Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Tworzę aplikację, której część frontendowa napisana jest w Vue.js, a częśc backendowa w…

  1. User

    Tworzę aplikację, której część frontendowa napisana jest w Vue.js, a częśc backendowa w .NET 6. Dopisz funkcjonalność polegającą na możliwości odroczenia bonusa. Ma być ona możliwa do wprowadzenia w edycji konfiguracji bonusa dla wybranej roli, gdzie można wybrać ilość miesięcy, o które bonusa odraczamy. W przypadku ustawienia tej funkcjonalności bonus nie powinien być naliczany przez ustawiony okres od rozpoczęcia zatrudnienia.

    /// FRONTEND

    /// manage-bonuses.vue

    <edit-user-bonuses :readonly="false" :selected-user-id="selectedUserId" />
    

    @Component({ components: { EditUserBonuses } }) export default class ManageBonuses extends AbpBasePage { users: Array<{ id: number; name: string }> = []; selectedUserId = 0;

    async mounted() { super.baseOnMounted(); const response = await axios.get("/api/services/app/Bonuses/GetSubordinates"); this.users = response.data.result.map(dtoItem => ({ id: dtoItem.key, name: dtoItem.value })); }

    @Watch("query", { deep: true }) onQueryChanged(newValue: any, oldValue: any) { super.baseOnQueryChanged(newValue, oldValue); }

    @Watch("search") onSearchChanged(newValue: string, oldValue: string) { super.baseOnSearchChanged(newValue, oldValue); } }

    /// edit-user-bonuses-config.vue

    /// add-edit-role.vue

      <v-form ref="form" v-model="valid" lazy-validation>
        <v-tabs class="ma-2">
          <v-tab>Ogólne</v-tab>
          <v-tab>Uprawnienia</v-tab>
          <v-tab>Przypisani użytkownicy</v-tab>
          <v-tab>Konfiguracja bonusów</v-tab>
    
          <v-tab-item>
            <v-container fluid grid-list-lg>
              <v-row>
                <v-col cols="12" md="6">
                  <v-row>
                    <v-col>
                      <v-switch
                        v-model="roleUpdated.isActive"
                        :readonly="readonly"
                        :filled="readonly"
                        label="Aktywny" />
                    </v-col>
                  </v-row>
                  <v-row>
                    <v-col>
                      <v2-text-field
                        v-model="roleUpdated.displayName"
                        :readonly="readonly"
                        :rules="nameRules"
                        label="Nazwa" />
                    </v-col>
                  </v-row>
                  <v-row>
                    <v-col>
                      <v2-text-field
                        v-model="roleUpdated.description"
                        :readonly="readonly"
                        label="Opis" />
                    </v-col>
                  </v-row>
                  <v-row>
                    <v-col><v-switch
                      v-model="roleUpdated.isPatientRegistrationEnabled"
                      :readonly="readonly"
                      :filled="readonly"
                      label="Rejestracja pacjentów aktywna" /></v-col>
                  </v-row>
                  <v-row>
                    <v-col><v-switch
                      v-model="roleUpdated.isStaffAccountingEnabled"
                      :readonly="readonly"
                      label="Rozliczania jako personel medyczny" /></v-col>
                  </v-row>
                  <v-row>
                    <v-col><v-switch
                      v-model="roleUpdated.excludeGroupRequiredActionsPenalties"
                      :readonly="readonly"
                      label="Wyklucz członków z grupowych kar" /></v-col>
                  </v-row>
                </v-col>
                <v-col cols="12" md="6" />
              </v-row>
    
              <v-row>
                <v-col cols="12" md="6" />
              </v-row>
            </v-container>
          </v-tab-item>
    
          <v-tab-item class="ma-2">
            <v-layout v-if="!readonly">
              <v-spacer />
              <v2-btn class="mx-2" color="primary" text @click="copyFromDialog = true">
                Skopiuj z innej roli
              </v2-btn>
            </v-layout>
    
            <v-layout row>
              <v-flex lg5 md6 xs12>
                <div v-for="(group, key, index) in permissionsGrouped" :key="index">
                  <span class="primary--text title">{{ L(key) }}</span>
    
                  <div v-for="permission in group" :key="permission.name">
                    <v-list-item @click.stop>
                      <v-list-item-content class="ma-2">
                        <v-list-item-title>{{ permission.displayName }}</v-list-item-title>
                      </v-list-item-content>
                      <v-list-item-action>
                        <v-switch
                          v-model="permission.allow"
                          :readonly="readonly"
                          :filled="readonly"
                          @change="onUpdated" />
                      </v-list-item-action>
                    </v-list-item>
                    <v-divider />
                  </div>
                </div>
              </v-flex>
            </v-layout>
          </v-tab-item>
    
          <v-tab-item>
            <v-list>
              <v-list-item v-for="user in roleUpdated.users" :key="user.id" @click.stop>
                <v-list-item-avatar tile>
                  <img :src="getUserPhoto(user.id)">
                </v-list-item-avatar>
                <v-list-item-content class="ma-2">
                  <v-list-item-title>{{ user.fullName }}</v-list-item-title>
                  <v-list-item-subtitle>{{ user.userName }}</v-list-item-subtitle>
                </v-list-item-content>
              </v-list-item>
            </v-list>
          </v-tab-item>
    
          <v-tab-item>
            <edit-role-bonus-config
              ref="bonusConfigTab"
              :readonly="readonly"
              :role="role" />
          </v-tab-item>
        </v-tabs>
      </v-form>
    
      <v-dialog v-model="copyFromDialog" max-width="600px" scrollable>
        <v-card>
          <v-card-title>Wybierz rolę do skopiowania</v-card-title>
          <v-divider />
          <v-card-text style="height: 300px">
            <v-list>
              <v-list-item v-for="role in roles" :key="role.id" @click="copyFromRole(role)">
                <v-list-item-content>
                  <v-list-item-title>{{ role.name }}</v-list-item-title>
                  <v-list-item-subtitle>{{ L(role.displayName) }}</v-list-item-subtitle>
                </v-list-item-content>
              </v-list-item>
            </v-list>
          </v-card-text>
          <v-divider />
          <v-card-actions>
            <v-btn block text @click.native="copyFromDialog = false">
              Anuluj
            </v-btn>
          </v-card-actions>
        </v-card>
      </v-dialog>
    </v-card>
    

    /// BACKEND

    /// RolesAppService.cs

    using System; using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; using Abp.Application.Services.Dto; using Abp.Auditing; using Abp.Authorization; using Abp.Collections.Extensions; using Abp.Configuration; using Abp.Domain.Repositories; using Abp.Domain.Uow; using Abp.ObjectMapping; using Abp.Runtime.Session; using Medica.Authentication.Users; using Medica.Authorization; using Medica.Authorization.Roles; using Medica.Configuration; using Medica.HumanResources.Bonuses; using Medica.HumanResources.Bonuses.Dto; using Medica.Users.Dto; using Microsoft.EntityFrameworkCore;

    namespace Medica.Users;

    [AbpAuthorize] public class RolesAppService : MedicaAppServiceWithLocalizationBase { private readonly IRepository _roles; private readonly IRepository<BonusRoleConfig, long> _bonusRoleConfigs; private readonly IPermissionManager _permissionManager; private readonly ISettingManager _settingManager; private readonly IObjectMapper _objectMapper; private readonly ICurrentUnitOfWorkProvider _currentUnitOfWorkProvider; private readonly RoleManager _roleManager; private readonly UserManager _userManager;

    public RolesAppService(
        IRepository<Role> roles,
        RoleManager roleManager,
        UserManager userManager,
        IRepository<BonusRoleConfig, long> bonusRoleConfigs,
        IPermissionManager permissionManager,
        ISettingManager settingManager,
        IObjectMapper objectMapper,
        ICurrentUnitOfWorkProvider currentUnitOfWorkProvider)
    {
        _roles = roles;
        _roleManager = roleManager;
        _userManager = userManager;
        _bonusRoleConfigs = bonusRoleConfigs;
        _permissionManager = permissionManager;
        _settingManager = settingManager;
        _objectMapper = objectMapper;
        _currentUnitOfWorkProvider = currentUnitOfWorkProvider;
        LocalizationSourceName = MedicaConsts.LocalizationSourceName;
    }
    
    [AbpAuthorize(PermissionNames.Admin_CustomRoles)]
    public async Task<RoleDto> Create(RoleDto input)
    {
        if (input.Permissions.IsNullOrEmpty())
            throw new UserFriendlyException("Musisz przydzielić przynajmniej jedno uprawnienie");
    
        var role = new Role()
        {
            IsStatic = false,
        };
    
        UpdateEntity(role, input);
        CheckErrors(await _roleManager.CreateAsync(role));
    
        await SetPermissionsAsync(role, input);
        await UpsertBonusRoleConfig(input);
        await _currentUnitOfWorkProvider.Current.SaveChangesAsync();
    
        return await MapToEntityDtoAsync(role);
    }
    
    [AbpAuthorize(PermissionNames.Admin_CustomRoles)]
    public async Task<RoleDto> Update(RoleDto input)
    {
        if (input.Permissions.IsNullOrEmpty())
            throw new UserFriendlyException("Musisz przydzielić przynajmniej jedno uprawnienie");
    
        var role = await _roleManager.GetRoleByIdAsync(input.Id);
        UpdateEntity(role, input);
        CheckErrors(await _roleManager.UpdateAsync(role));
    
        await SetPermissionsAsync(role, input);
        await UpsertBonusRoleConfig(input);
        await _currentUnitOfWorkProvider.Current.SaveChangesAsync();
    
        return await MapToEntityDtoAsync(role);
    }
    
    [AbpAuthorize(PermissionNames.Admin_CustomRoles)]
    public async Task Delete(EntityDto<int> input)
    {
        var role = await _roleManager.GetRoleByIdAsync(input.Id);
    
        if (role.IsStatic)
            throw new UserFriendlyException("Nie można usuwać predefiniowanych ról");
    
        var users = await _userManager.GetUsersInRoleAsync(role.NormalizedName);
    
        foreach (var user in users)
        {
            CheckErrors(await _userManager.RemoveFromRoleAsync(user, role.NormalizedName));
        }
    
        await _bonusRoleConfigs.DeleteAsync(config => config.RoleId == role.Id);
        CheckErrors(await _roleManager.DeleteAsync(role));
    }
    
    [AbpAuthorize(
        PermissionNames.Admin_CustomRoles,
        PermissionNames.Users_View,
        PermissionNames.Users_RolesView)]
    public Task<ListResultDto<PermissionDto>> GetAllPermissions()
    {
        var permissions = _permissionManager.GetAllPermissions();
        var result = _objectMapper.Map<List<PermissionDto>>(permissions);
        foreach (var item in result)
        {
            item.DisplayName = L(item.DisplayName);
        }
    
        return Task.FromResult(new ListResultDto<PermissionDto>(
            result
        ));
    }
    
    [AbpAuthorize(
        PermissionNames.Admin_CustomRoles,
        PermissionNames.Users_View,
        PermissionNames.Users_RolesView)]
    public async Task<PagedResultDto<RoleDto>> GetAll(PagedSortedFilteredResultRequest request)
    {
        var query = _roles
            .GetAll()
            .AsNoTracking()
            .Where(v => !v.Name.StartsWith("_") && v.Id > 1)
            .Include(v => v.Permissions);
    
        return await GetPagedResultDto(query, request, v => new ValueTask<RoleDto>(MapToEntityDtoAsync(v)));
    }
    
    [DisableAuditing]
    [AbpAuthorize(
        PermissionNames.Admin_CustomRoles,
        PermissionNames.Users_View,
        PermissionNames.Users_RolesView)]
    public async Task<List<SimpleRoleDto>> GetSimpleList()
    {
        var query = _roles.GetAll().AsNoTracking().Where(v => !v.Name.StartsWith("_"));
        return await query.Select(role => RoleConfigConverters.ToSimpleRole(role)).ToListAsync();
    }
    
    [AbpAuthorize(
        PermissionNames.Admin_CustomRoles,
        PermissionNames.Users_View,
        PermissionNames.Users_RolesView)]
    public async Task<GetRoleForEditOutput> GetRoleForEdit(EntityDto input)
    {
        var permissions = _permissionManager.GetAllPermissions();
        var role = await _roleManager.GetRoleByIdAsync(input.Id);
        var grantedPermissions = (await _roleManager.GetGrantedPermissionsAsync(role)).ToArray();
        var roleEditDto = _objectMapper.Map<RoleEditDto>(role);
    
        return new GetRoleForEditOutput
        {
            Role = roleEditDto,
            Permissions = _objectMapper.Map<List<FlatPermissionDto>>(permissions).OrderBy(p => p.DisplayName).ToList(),
            GrantedPermissionNames = grantedPermissions.Select(p => p.Name).ToList(),
            BonusRoleConfig = await ResolveBonusRoleConfig(role)
        };
    }
    
    private void UpdateEntity(Role entity, RoleDto dto)
    {
        entity.DisplayName = dto.DisplayName;
        entity.Description = dto.Description;
        entity.IsActive = dto.IsActive;
        entity.IsPatientRegistrationEnabled = dto.IsPatientRegistrationEnabled;
        entity.IsStaffAccountingEnabled = dto.IsStaffAccountingEnabled;
        entity.ExcludeGroupRequiredActionsPenalties = dto.ExcludeGroupRequiredActionsPenalties;
        entity.SetNormalizedName();
    
        if (string.IsNullOrEmpty(entity.Name))
            entity.Name = Guid.NewGuid().ToString("N").ToUpper();
    }
    
    private async Task SetPermissionsAsync(Role entity, RoleDto dto)
    {
        var grantedPermissions = _permissionManager
            .GetAllPermissions()
            .Where(p => dto.Permissions.Contains(p.Name));
    
        await _roleManager.SetGrantedPermissionsAsync(entity, grantedPermissions);
    }
    
    private async Task<RoleDto> MapToEntityDtoAsync(Role entity)
    {
        var dto = _objectMapper.Map<RoleDto>(entity);
    
        var grantedPermissions = (await _roleManager.GetGrantedPermissionsAsync(entity.Name)).ToArray();
        dto.Permissions = grantedPermissions?
            .Select(v => v.Name)
            .ToList();
    
        var users = await _userManager.GetUsersInRoleAsync(entity.NormalizedName);
        dto.Users = users
            .Where(v => v.IsActive && !v.IsDeleted)
            .Select(v => new UserInfoDto() { Id = v.Id, UserName = v.UserName, FullName = v.FullName })
            .ToList();
    
        dto.BonusRoleConfig = await ResolveBonusRoleConfig(entity);
    
        return dto;
    }
    
    private async Task<BonusRoleConfigDto> ResolveBonusRoleConfig(Role entity)
    {
        var bonusRoleConfig = await _bonusRoleConfigs
                                  .GetAll()
                                  .Where(config => config.RoleId == entity.Id)
                                  .FirstOrDefaultAsync()
                              ?? await DefaultBonusRoleConfig();
    
        return MapToBonusRoleConfigDto(bonusRoleConfig);
    }
    
    private static BonusRoleConfigDto MapToBonusRoleConfigDto(BonusRoleConfig bonusConfig)
    {
        return new BonusRoleConfigDto
        {
            IsActive = bonusConfig.IsActive,
            MaxValue = bonusConfig.MaxValue,
            MinValue = bonusConfig.MinValue,
            MaxExtraBonusValue = bonusConfig.MaxExtraBonusValue,
            YearlyIncreaseValue = bonusConfig.YearlyIncreaseValue,
            SickLeaveDecrement = bonusConfig.SickLeaveDecrement,
            ChildCareDecrement = bonusConfig.ChildCareDecrement,
        };
    }
    
    private async Task<BonusRoleConfig> DefaultBonusRoleConfig()
    {
        int tenantId = MedicaSession.GetTenantId();
        return new BonusRoleConfig()
        {
            IsActive = false,
            MinValue = await _settingManager.GetSettingValueForTenantAsync<decimal>(AppSettingsNames.BonusesDefaults.MinValue, tenantId),
            MaxValue = await _settingManager.GetSettingValueForTenantAsync<decimal>(AppSettingsNames.BonusesDefaults.MaxValue, tenantId),
            YearlyIncreaseValue = await _settingManager.GetSettingValueForTenantAsync<decimal>(AppSettingsNames.BonusesDefaults.YearlyIncreaseValue, tenantId),
            MaxExtraBonusValue = await _settingManager.GetSettingValueForTenantAsync<decimal>(AppSettingsNames.BonusesDefaults.MaxExtraBonusValue, tenantId),
            SickLeaveDecrement = await _settingManager.GetSettingValueForTenantAsync<decimal>(AppSettingsNames.BonusesDefaults.SickLeaveDecrement, tenantId),
            ChildCareDecrement = await _settingManager.GetSettingValueForTenantAsync<decimal>(AppSettingsNames.BonusesDefaults.ChildCareDecrement, tenantId),
        };
    }
    
    private async Task UpsertBonusRoleConfig(RoleDto input)
    {
        var tenantId = MedicaSession.GetTenantId();
        var config = await _bonusRoleConfigs
                         .GetAll()
                         .Where(c => c.RoleId == input.Id)
                         .FirstOrDefaultAsync()
                     ?? await DefaultBonusRoleConfig();
    
        if (input.BonusRoleConfig is { } dtoConfig)
        {
            config.IsActive = dtoConfig.IsActive;
            config.MaxValue = dtoConfig.MaxValue;
            config.MinValue = dtoConfig.MinValue;
            config.MaxExtraBonusValue = dtoConfig.MaxExtraBonusValue;
            config.YearlyIncreaseValue = dtoConfig.YearlyIncreaseValue;
            config.SickLeaveDecrement = dtoConfig.SickLeaveDecrement;
            config.ChildCareDecrement = dtoConfig.ChildCareDecrement;
        }
    
        config.RoleId = input.Id;
        config.TenantId = tenantId;
    
        await _bonusRoleConfigs.InsertOrUpdateAsync(config);
    }
    

    }

    /// RoleDto.cs

    using System.Collections.Generic; using System.ComponentModel.DataAnnotations; using Abp.Application.Services.Dto; using Abp.Authorization.Roles; using Abp.AutoMapper; using AutoMapper; using Medica.Authorization.Roles; using Medica.HumanResources.Bonuses.Dto;

    namespace Medica.Users.Dto;

    [AutoMapFrom(typeof(Role))] [AutoMapTo(typeof(RoleDto))] public class RoleDto : EntityDto { public string Name { get; set; } public string NormalizedName { get; set; }

    [Required]
    [StringLength(AbpRoleBase.MaxDisplayNameLength)]
    public string DisplayName { get; set; }
    
    [StringLength(Role.MaxDescriptionLength)]
    public string Description { get; set; }
    
    public bool IsStatic { get; set; }
    public bool IsActive { get; set; }
    public bool IsPatientRegistrationEnabled { get; set; }
    public bool IsStaffAccountingEnabled { get; set; }
    public bool ExcludeGroupRequiredActionsPenalties { get; set; }
    
    public List<string> Permissions { get; set; }
    
    [IgnoreMap]
    public BonusRoleConfigDto BonusRoleConfig { get; set; }
    
    [IgnoreMap]
    public List<UserInfoDto> Users { get; set; }
    

    }

    /// BonusRoleConfigDto.cs

    using System.Collections.Generic; using System.ComponentModel.DataAnnotations;

    namespace Medica.HumanResources.Bonuses.Dto;

    public class BonusRoleConfigDto : IValidatableObject { public bool IsActive { get; set; } public decimal MinValue { get; set; } public decimal MaxValue { get; set; } public decimal YearlyIncreaseValue { get; set; } public decimal MaxExtraBonusValue { get; set; } public decimal SickLeaveDecrement { get; set; } public decimal ChildCareDecrement { get; set; } public IEnumerable Validate(ValidationContext validationContext) { if (MinValue < 0 || MinValue > 10000) yield return new ValidationResult("Must be valid non-negative value from range [0..10000]", new List { "MinValue" }); if (MaxValue < 0 || MaxValue > 10000) yield return new ValidationResult("Must be valid non-negative value from range [0..10000]", new List { "MaxValue" }); if (YearlyIncreaseValue < 0 || YearlyIncreaseValue > 10000) yield return new ValidationResult("Must be valid non-negative value from range [0..10000]", new List { "YearlyIncreaseValue" }); if (MaxExtraBonusValue < 0 || MaxExtraBonusValue > 50000) yield return new ValidationResult("Must be valid non-negative value from range [0..50000]", new List { "MaxExtraBonusValue" }); if (SickLeaveDecrement < 0 || SickLeaveDecrement > 10000) yield return new ValidationResult("Must be valid non-negative value from range [0..10000]", new List { "SickLeaveDecrement" }); if (ChildCareDecrement < 0 || ChildCareDecrement > 10000) yield return new ValidationResult("Must be valid non-negative value from range [0..10000]", new List { "ChildCareDecrement" }); if (MinValue > MaxValue) yield return new ValidationResult("Minimal value cannot be larger than maximum one", new List { "MinValue", "MaxValue" }); } }

    /// BonusRoleConfig.cs

    using Abp.Domain.Entities; using Abp.Domain.Entities.Auditing; using Medica.Authentication.Users; using Medica.RequiredActions;

    namespace Medica.HumanResources.Bonuses;

    public class BonusRoleConfig : FullAuditedEntity, IMustHaveTenant { public long RoleId { get; set; }

    public bool IsActive { get; set; }
    public decimal MinValue { get; set; }
    public decimal MaxValue { get; set; }
    public decimal YearlyIncreaseValue { get; set; }
    public decimal MaxExtraBonusValue { get; set; }
    public decimal SickLeaveDecrement { get; set; }
    public decimal ChildCareDecrement { get; set; }
    public int TenantId { get; set; }
    

    }

    /// BonusService.cs

    #nullable enable using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using Medica.Authentication.Users; using Medica.Helpers; using Medica.OrgStructure; using Medica.Schedule;

    namespace Medica.HumanResources.Bonuses;

    public class BonusService : IBonusService { private static readonly DateTime _featureEnabledTimeStamp = new DateTime(2020, 07, 01); private const int _maxAlterationAmount = 10000; private readonly IBonusDbAdapter _dbAdapter; private readonly IBonusRoleConfigResolver _roleConfigResolver; private readonly Func _currentTimeProvider; private readonly ISchedulerService _emailService; private readonly IOrgStructureService _orgStructureService;

    public BonusService(IBonusDbAdapter dbAdapter, IBonusRoleConfigResolver roleConfigResolver, ISchedulerService emailService, IOrgStructureService orgStructureService) : this(dbAdapter, roleConfigResolver, emailService, orgStructureService, () => DateTime.Now)
    {
    }
    
    public BonusService(IBonusDbAdapter dbAdapter, IBonusRoleConfigResolver roleConfigResolver, ISchedulerService emailService, IOrgStructureService orgStructureService, Func<DateTime> currentTimeProvider)
    {
        _dbAdapter = dbAdapter;
        _roleConfigResolver = roleConfigResolver;
        _emailService = emailService;
        _currentTimeProvider = currentTimeProvider;
        _orgStructureService = orgStructureService;
    }
    
    public async Task<Either<BonusAlteration>> AddBonusAlterationAsync(BonusAlteration bonusAlteration)
    {
        return await AddUpdateBonusAlterationAsync(bonusAlteration, alteration => _dbAdapter.AddBonusAlterationAsync(alteration))
            .FlatMapAsync(SendAddAlterationEmail);
    }
    
    public async Task<Either<BonusAlteration>> UpdateBonusAlterationAsync(BonusAlteration bonusAlteration, long? validOwnerId = null)
    {
        return await AddUpdateBonusAlterationAsync(bonusAlteration, alteration => _dbAdapter.UpdateBonusAlterationAsync(alteration))
            .FlatMapAsync(alteration => VerifyRequester(alteration, validOwnerId))
            .FlatMapAsync(SendUpdateAlterationEmail);
    }
    
    private async Task<Either<BonusAlteration>> AddUpdateBonusAlterationAsync(BonusAlteration bonusAlteration,
        Func<BonusAlteration, Task<Either<BonusAlteration>>> methodAsync)
    {
        var userId = bonusAlteration.UserId;
        var resolvedRole = await _roleConfigResolver.Resolve(userId);
        return await resolvedRole.FlatMapAsync(
            async config =>
            {
                var validationError = await ValidateAlterationAsync(bonusAlteration, config);
                if (validationError is { } error) return Either<BonusAlteration>.Error(error);
                return await methodAsync(bonusAlteration);
            });
    }
    
    public async Task<Either> DeleteAlterationAsync(long id, long? validOwnerId = null)
    {
        return await _dbAdapter.GetAlterationAsync(id)
            .FlatMapAsync(alteration => VerifyRequester(alteration, validOwnerId))
            .FlatMapAsync(DeleteAlterationAsync)
            .FlatMapAsync(SendDeleteAlterationEmail)
            .IgnoreValue();
    }
    
    private async Task<Either<BonusAlteration>> DeleteAlterationAsync(BonusAlteration alteration)
    {
        if (alteration.OptimaId != null || alteration.RequiredActionId != null)
        {
            alteration.Amount = Decimal.Zero;
            return await _dbAdapter.UpdateBonusAlterationAsync(alteration);
        }
    
        var thisQuarter = Quarter.FromDate(_currentTimeProvider());
        if (alteration.CreationTime < thisQuarter.StartDate)
            return Either<BonusAlteration>.UserFriendlyError(
                "Cannot delete bonus alteration from non-active quarter",
                "Nie można usunąć wpisu z poprzedniego kwartału");
        return await _dbAdapter.DeleteAlterationAsync(alteration.Id).FlatMapAsync(alteration.AsSuccess);
    }
    
    public async Task<Either<IList<BonusAlteration>>> GetAlterations(long userId, Quarter quarter)
    {
        return await _dbAdapter.GetBonusAlterationsAsync(userId, quarter.StartDate, quarter.EndDate);
    }
    
    public async Task<Either<IList<BonusQuarterSummary>>> GetSummaries(User user, DateTime targetDate)
    {
    
        var resolvedRoleConfig = await _roleConfigResolver.Resolve(user.Id);
        return await resolvedRoleConfig.Match(
            async config => await GetSummariesForRole(user, targetDate, config),
            error => Task.FromResult(Either<IList<BonusQuarterSummary>>.Error(error)));
    }
    
    public async Task<Either<IList<User>>> GetSubordinatesWithBonusFeatureAsync(long supervisorId)
    {
        return await _orgStructureService.GetSubordinatesAsync(supervisorId).FlatMapAsync(FilterSubordinates);
    }
    
    private async Task<Either<IList<User>>> FilterSubordinates(IList<User> inputList)
    {
        var list = new List<User>();
        foreach (var user in inputList)
        {
            var resolveResult = await _roleConfigResolver.TryResolve(user.Id, true);
            if (resolveResult.IsFailure) return Either<IList<User>>.Error(resolveResult);
            resolveResult.MatchSome(roleConfig =>
            {
                if (roleConfig?.IsActive == true) list.Add(user);
            });
        }
    
        return list.AsSuccess();
    }
    
    public async Task<Either<BonusQuarterSummary>> GetCurrentQuarterSummary(User user, DateTime targetDate)
    {
        var resolvedRoleConfig = await _roleConfigResolver.Resolve(user.Id);
        return await resolvedRoleConfig.Match(
            async config => await GetCurrentQuarterSummary(user, targetDate, config),
            error => Task.FromResult(Either<BonusQuarterSummary>.Error(error)));
    }
    
    private async Task<Either<IList<BonusQuarterSummary>>> GetSummariesForRole(User user, DateTime targetDate, BonusRoleConfig config)
    {
        var pastSummariesResult = await _dbAdapter.GetAllSummariesAsync(user.Id);
        return await pastSummariesResult.Match(async pastSummaries =>
            {
                var currentQuarterSummaryResult = await ComputeQuarterSummary(user, targetDate, config, pastSummaries);
                return currentQuarterSummaryResult.Match(
                    currentQuarterSummary =>
                    {
                        var summaryStartTime = user.WorkStartTimestamp is { } workStartTimestamp
                            ? new DateTime(Math.Max(_featureEnabledTimeStamp.Ticks, workStartTimestamp.Ticks))
                            : _featureEnabledTimeStamp;
                        var summaries = CombineQuarterSummaries(targetDate, summaryStartTime, pastSummaries, currentQuarterSummary);
                        return summaries.AsSuccess();
                    },
                    Either<IList<BonusQuarterSummary>>.Error);
            },
            error => Task.FromResult(Either<IList<BonusQuarterSummary>>.Error(error)));
    }
    
    private static List<BonusQuarterSummary> CombineQuarterSummaries(DateTime targetDate, DateTime summaryStartTime, IList<BonusQuarterSummary> list, BonusQuarterSummary currentQuarterSummary)
    {
        var pastSummariesDict = list.ToDictionary(
            v => new Quarter(v.Year, v.Quarter),
            v => new BonusQuarterSummaryData(v.PaidAmount, v.Balance));
        var pastQuarters = Quarter.PastQuartersRange(summaryStartTime, targetDate);
    
        var summaries = pastQuarters.Select(quarter =>
        {
            var isDataAvailable = pastSummariesDict.TryGetValue(quarter, out var data);
            return new BonusQuarterSummary
            {
                Balance = isDataAvailable ? data!.Balance : decimal.Zero,
                PaidAmount = isDataAvailable ? data!.PaidAmount : decimal.Zero,
                Quarter = quarter.QuarterIdx,
                Year = quarter.Year
            };
        }).ToList();
    
        summaries.Insert(0, currentQuarterSummary);
        return summaries;
    }
    
    public async Task<Either<BonusQuarterSummary>> GetCurrentQuarterSummary(User user, DateTime targetDate, BonusRoleConfig config)
    {
        var pastSummaries = await _dbAdapter.GetAllSummariesAsync(user.Id);
        return await pastSummaries.Match(async list => await ComputeQuarterSummary(user, targetDate, config, list),
            error => Task.FromResult(Either<BonusQuarterSummary>.Error(error)));
    }
    
    private async Task<Either<BonusQuarterSummary>> ComputeQuarterSummary(User user, DateTime targetDate, BonusRoleConfig config, IList<BonusQuarterSummary> list)
    {
        var targetQuarter = Quarter.FromDate(targetDate);
        var currentBalanceResult = await GetCurrentQuarterInputBalance(user.Id, targetQuarter, list);
        return currentBalanceResult.Match(
            currentBalance =>
            {
                var activeQuarter = ActiveQuarter.Create(targetDate, currentBalance, user, config);
                var summary = new BonusQuarterSummary()
                {
                    Balance = activeQuarter.FinalBalance,
                    PaidAmount = activeQuarter.CurrentPaidAmount,
                    Quarter = targetQuarter.QuarterIdx,
                    Year = targetQuarter.Year,
                    UserId = user.Id
                };
                return summary.AsSuccess();
            },
    
            Either<BonusQuarterSummary>.Error);
    }
    
    private async Task<Either<decimal>> GetCurrentQuarterInputBalance(long userId, Quarter targetQuarter, IList<BonusQuarterSummary> previousSummaries)
    {
        return await GetPreviousQuartersBalance(targetQuarter, previousSummaries).Match(async previousBalance =>
            {
                var bonusAlterationsResult = await _dbAdapter.GetBonusAlterationsAsync(userId, targetQuarter.StartDate, targetQuarter.EndDate);
                return bonusAlterationsResult.Match(
                    list => Either.Success(previousBalance + list.Select(item => item.Amount).Sum()),
                    Either<decimal>.Error);
    
            },
            error => Task.FromResult(Either<decimal>.Error(error)));
    }
    
    private Either<decimal> GetPreviousQuartersBalance(Quarter targetQuarter, IList<BonusQuarterSummary> bonusQuarterSummaries)
    {
        if (bonusQuarterSummaries.Count == 0)
        {
            return Either.Success(decimal.Zero);
        }
    
        var lastSummary = bonusQuarterSummaries[0];
        var lastQuarter = new Quarter(lastSummary.Year, lastSummary.Quarter);
        return lastQuarter.IsBefore(targetQuarter)
            ? Either.Success(lastSummary.Balance - lastSummary.PaidAmount)
            : Either<decimal>.InternalError("Quarter requested as current already has locked summary");
    }
    
    private async Task<AppServiceError?> ValidateAlterationAsync(BonusAlteration bonusAlteration, BonusRoleConfig roleConfig)
    {
        var now = _currentTimeProvider();
        var userId = bonusAlteration.UserId;
        var currentQuarter = Quarter.FromDate(now);
        if (bonusAlteration.Amount == Decimal.Zero)
        {
            return AppServiceError.UserFriendly("Bonus alteration amount cannot be zero", "Kwota musi być różna od zera");
        }
    
        if (bonusAlteration.CreationTime > now)
        {
            return AppServiceError.UserFriendly("Bonus alteration cannot be set into the future", "Data wpisu z przyszłości");
        }
    
        if (bonusAlteration.CreationTime < currentQuarter.StartDate)
        {
            return AppServiceError.UserFriendly("Bonus alteration can be added only to current quarter", "Data wpisu nie jest w bieżącym kwartale");
        }
    
        if (bonusAlteration.Amount < 0)
        {
            return Math.Abs(bonusAlteration.Amount) > _maxAlterationAmount
                ? AppServiceError.UserFriendly("Bonus alteration amount out of range", "Niepoprawna kwota")
                : null;
        }
    
        var currentQuarterAlterations = await _dbAdapter.GetBonusAlterationsAsync(userId, currentQuarter.StartDate, currentQuarter.EndDate);
        return currentQuarterAlterations.Match(
            list =>
            {
                var currentRewardsSum = list
                    .Where(item => item.Amount > 0)
                    .Select(item => item.Amount)
                    .Sum();
                return currentRewardsSum + bonusAlteration.Amount > roleConfig.MaxExtraBonusValue
                    ? AppServiceError.UserFriendly(
                        $"Bonus alteration [{bonusAlteration.Amount}] together with existing rewards [{currentRewardsSum}] exceeds configured limit [{roleConfig.MaxExtraBonusValue}]",
                        "Limit bonusów dodatkowych dla danego stanowiska / roli został przekroczony")
                    : null;
            }, error => error);
    
    }
    
    private Either<BonusAlteration> SendAddAlterationEmail(BonusAlteration alteration)
    {
        var operationDescription = alteration.Amount > 0 ? "Została nadana nagroda uznaniowa" : "Zostało nadane pomniejszenie bonusa";
        var operationSummary = "";
        return SendEmail(alteration, operationSummary, operationDescription);
    }
    
    private Either<BonusAlteration> SendUpdateAlterationEmail(BonusAlteration alteration)
    {
        var operationDescription = alteration.Amount > 0 ? "Nagroda uznaniowa została zaktualizowana" : "Nadane pomniejszenie bonusa zostało zaktualizowane";
        var subjectSuffix = alteration.Amount > 0 ? " - Zmieniona" : " - Zmienione";
    
        return SendEmail(alteration, subjectSuffix, operationDescription);
    }
    
    private Either<BonusAlteration> VerifyRequester(BonusAlteration alteration, long? validRequesterId)
    {
        if (validRequesterId is { } id && alteration.CreatorUserId != id)
        {
            return Either<BonusAlteration>.UserFriendlyError(
                $"Creator user id is of invalid value. Expected: {validRequesterId}. Actual: {alteration.CreatorUserId}",
                "Brak uprawnień do wykonania żądanej operacji");
        }
    
        return alteration.AsSuccess();
    }
    
    private Either<BonusAlteration> SendDeleteAlterationEmail(BonusAlteration alteration)
    {
        var operationDescription = alteration.Amount > 0 ? "Nagroda uznaniowa została anulowana" : "Nadane pomniejszenie bonusa zostało anulowane";
        var subjectSuffix = alteration.Amount > 0 ? " - Anulowana" : " - Anulowane";
        return SendEmail(alteration, subjectSuffix, operationDescription);
    }
    
    private Either<BonusAlteration> SendEmail(BonusAlteration alteration, string subjectSuffix, string operationDescription)
    {
        var alterationType = alteration.Amount > 0 ? "Nagroda uznaniowa" : "Pomniejszenie bonusa";
        var amountFormatted = $"{Math.Abs(alteration.Amount):0.00} zł";
        var subject = $"{alterationType} - {alteration.Title} ({amountFormatted}){subjectSuffix}";
        var bodyBuilder = new StringBuilder();
        bodyBuilder.Append($"<h2>{alterationType}</h2>");
    
        bodyBuilder.Append($"<p>{operationDescription}. Wyskość: {amountFormatted},  Powód</p>");
        bodyBuilder.Append($"<h3>{alteration.Title}</h3>");
        if (!string.IsNullOrWhiteSpace(alteration.Description))
        {
            bodyBuilder.Append($"<p>{alteration.Description}</p>");
        }
        bodyBuilder.Append($"<p>Identyfikator wpisu: {alteration.Id}</p>");
        var body = bodyBuilder.ToString();
        var emailsOpt = alteration.User.GetAllEmailAddresses();
    
        if (emailsOpt is { } emails && emails.Length > 0)
        {
            try
            {
                foreach (var email in emails)
                {
                    if (EmailHelper.IsValidEmail(email)) _emailService.ScheduleEmail(email.ToLower(), subject, body);
                }
            }
            catch (Exception ex)
            {
                return Either<BonusAlteration>.InternalError(ex);
            }
        }
    
        return alteration.AsSuccess();
    }
    

    }

    /// IBonusService.cs

    using System; using System.Collections.Generic; using System.Threading.Tasks; using Abp.Dependency; using Medica.Authentication.Users;

    namespace Medica.HumanResources.Bonuses;

    public interface IBonusService : ITransientDependency { Task<Either> AddBonusAlterationAsync(BonusAlteration bonusAlteration); Task<Either> UpdateBonusAlterationAsync(BonusAlteration bonusAlteration, long? validOwnerId = null); Task DeleteAlterationAsync(long id, long? validOwnerId = null); Task<Either<IList>> GetAlterations(long userId, Quarter quarter); Task<Either> GetCurrentQuarterSummary(User user, DateTime targetDate); Task<Either> GetCurrentQuarterSummary(User user, DateTime targetDate, BonusRoleConfig bonusRoleConfig); Task<Either<IList>> GetSummaries(User user, DateTime targetDate); Task<Either<IList>> GetSubordinatesWithBonusFeatureAsync(long supervisorId); }

    /// ActiveQuarter.cs

    using System; using Medica.Authentication.Users;

    namespace Medica.HumanResources.Bonuses;

    public class ActiveQuarter { public decimal CurrentBalance { get; } public decimal FinalBalance { get; } public decimal CurrentPaidAmount { get; } public decimal FinalPaidAmount { get; } public decimal Remnant { get; }

    private ActiveQuarter(decimal currentBalance, decimal finalBalance, decimal currentPaidAmount, decimal finalPaidAmount, decimal remnant)
    {
        CurrentBalance = currentBalance;
        FinalBalance = finalBalance;
        CurrentPaidAmount = currentPaidAmount;
        FinalPaidAmount = finalPaidAmount;
        Remnant = remnant;
    }
    
    public static ActiveQuarter Create(DateTime thisDate, decimal alterationsBalance, User user, BonusRoleConfig roleConfig)
    {
        var quarter = Quarter.FromDate(thisDate);
    
        var userBonusStatus = UserBonusStatus.Create(user, roleConfig);
    
        decimal bonusLimit = decimal.Zero;
        var firstMonthLimit = userBonusStatus.PartTimeBonusLimit(quarter.StartDate);
        var secondMonthLimit = userBonusStatus.PartTimeBonusLimit(quarter.SecondMonth.StartDate);
        var thirdMonthLimit = userBonusStatus.PartTimeBonusLimit(quarter.ThirdMonth.StartDate);
    
        if (thisDate >= quarter.SecondMonth.StartDate) bonusLimit += firstMonthLimit;
        if (thisDate >= quarter.ThirdMonth.StartDate) bonusLimit += secondMonthLimit;
        if (thisDate >= quarter.EndDate) bonusLimit += thirdMonthLimit;
    
        var currentBalance = bonusLimit + alterationsBalance;
        var finalBalance = alterationsBalance + firstMonthLimit + secondMonthLimit + thirdMonthLimit;
    
        var currentPaidAmount = Math.Max(0, currentBalance);
        var finalPaidAmount = Math.Max(0, finalBalance);
    
        var remnant = finalBalance > 0 ? 0 : finalBalance;
    
        return new ActiveQuarter(currentBalance, finalBalance, currentPaidAmount, finalPaidAmount, remnant);
    }
    

    }

    /// Quarter.cs

    using System; using System.Collections.Generic; using System.Linq;

    namespace Medica.HumanResources.Bonuses;

    public class Quarter { public int Year { get; } public int QuarterIdx { get; }

    public QuarterMonth FirstMonth { get; }
    public QuarterMonth SecondMonth { get; }
    public QuarterMonth ThirdMonth { get; }
    public DateTime StartDate => FirstMonth.StartDate;
    public DateTime EndDate => ThirdMonth.EndDate;
    public Quarter Previous => new Quarter(QuarterIdx > 0 ? Year : Year - 1, QuarterIdx > 0 ? QuarterIdx - 1 : 3);
    
    protected bool Equals(Quarter other)
    {
        return Year == other.Year && QuarterIdx == other.QuarterIdx;
    }
    
    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj)) return false;
        if (ReferenceEquals(this, obj)) return true;
        if (obj.GetType() != this.GetType()) return false;
        return Equals((Quarter)obj);
    }
    
    public override int GetHashCode()
    {
        return HashCode.Combine(Year, QuarterIdx);
    }
    
    public Quarter(int year, int quarterIdx)
    {
        Year = year;
        QuarterIdx = quarterIdx;
        FirstMonth = QuarterMonth.Create(quarterIdx, year, 1);
        SecondMonth = QuarterMonth.Create(quarterIdx, year, 2);
        ThirdMonth = QuarterMonth.Create(quarterIdx, year, 3);
    }
    
    public static Quarter FromDate(DateTime dateTime)
    {
        return new Quarter(dateTime.Year, (dateTime.Month - 1) / 3);
    }
    
    public bool IsBefore(Quarter other)
    {
        return (Year < other.Year) || (Year == other.Year && QuarterIdx < other.QuarterIdx);
    }
    
    
    public static IEnumerable<Quarter> PastQuartersRange(DateTime startDate, DateTime thisDate)
    {
        var thisQuarter = (thisDate.Month - 1) / 3;
        var startDateQuarter = (startDate.Month - 1) / 3;
        var lastPastQuarterYear = thisQuarter > 0 ? thisDate.Year : thisDate.Year - 1;
        var lastPastQuarter = thisQuarter > 0 ? thisQuarter - 1 : 3;
    
        if (lastPastQuarterYear < startDate.Year || lastPastQuarterYear == startDate.Year && lastPastQuarter < startDateQuarter)
        {
            return new List<Quarter>();
        }
    
        return Enumerable.Range(startDate.Year, lastPastQuarterYear - startDate.Year + 1).SelectMany(revertedYear =>
        {
            var year = startDate.Year + lastPastQuarterYear - revertedYear;
            var startQuarter = year == startDate.Year ? startDateQuarter : 0;
            var endQuarter = year == lastPastQuarterYear ? lastPastQuarter : 3;
            return Enumerable.Range(startQuarter, endQuarter - startQuarter + 1)
                .Select(quarter => new Quarter(year, startQuarter + endQuarter - quarter));
        });
    }
    
    public class QuarterMonth
    {
        public int Index { get; }
        public DateTime StartDate { get; }
        public DateTime EndDate { get; }
    
        private QuarterMonth(int index, DateTime startDate, DateTime endDate)
        {
            Index = index;
            StartDate = startDate;
            EndDate = endDate;
        }
    
        public static QuarterMonth Create(int quarterIndex, int year, int monthIndex)
        {
            var index = quarterIndex * 3 + monthIndex;
            var startTime = new DateTime(year, index, 1);
            var oneDayAfterEndTimeYear = quarterIndex < 3 ? year : year + 1;
            var oneDayAfterEndTimeMonth = index < 12 ? index + 1 : 1;
            var endTime = new DateTime(oneDayAfterEndTimeYear, oneDayAfterEndTimeMonth, 1, 23, 59, 59, 999).Subtract(TimeSpan.FromDays(1));
            return new QuarterMonth(index, startTime, endTime);
        }
    }
    

    }

    /// UserBonusStatus.cs

    using System; using Medica.Authentication.Users;

    namespace Medica.HumanResources.Bonuses;

    public class UserBonusStatus { private readonly DateTime? _adjustedInServiceStartDate; private readonly decimal _currentBonusLimit; private readonly BonusRoleConfig _bonusRoleConfig; private readonly int _yearsInServiceTillLastUpdate; private readonly decimal _partTimeRatio;

    private UserBonusStatus(DateTime? adjustedInServiceStartDate, decimal currentBonusLimit, int yearsInServiceTillLastUpdate, BonusRoleConfig bonusRoleConfig, decimal partTimeRatio)
    {
        _adjustedInServiceStartDate = adjustedInServiceStartDate;
        _currentBonusLimit = currentBonusLimit;
        _yearsInServiceTillLastUpdate = yearsInServiceTillLastUpdate;
        _bonusRoleConfig = bonusRoleConfig;
        _partTimeRatio = partTimeRatio;
    }
    
    public static UserBonusStatus Create(User user, BonusRoleConfig bonusRoleConfig)
    {
        var currentBonusLimit = Math.Max(user.CurrentBonusLimit, bonusRoleConfig.MinValue);
        var adjustedInServiceStartDate = user.WorkStartTimestamp is { } workStartTimestamp
            ? (DateTime?)AdjustUserInServiceStartDate(workStartTimestamp)
            : null;
    
        var yearsInServiceTillLastUpdate = user.LastBonusUpdateTimestamp is { } lastBonusUpdateTimestamp && adjustedInServiceStartDate is { } adjustedInServiceStartDateVal
            ? YearsInService(lastBonusUpdateTimestamp, adjustedInServiceStartDateVal)
            : 0;
        return new UserBonusStatus(adjustedInServiceStartDate, currentBonusLimit, yearsInServiceTillLastUpdate, bonusRoleConfig, user.SalaryRatio());
    }
    
    public decimal BonusLimit(DateTime targetDate)
    {
        if (_adjustedInServiceStartDate is { } startDate && startDate > targetDate) return Decimal.Zero;
    
        var yearsInServiceTillNow = YearsInService(targetDate);
        var gapYears = Math.Max(0, yearsInServiceTillNow - _yearsInServiceTillLastUpdate);
        return Math.Min(_bonusRoleConfig.MaxValue, _currentBonusLimit + gapYears * _bonusRoleConfig.YearlyIncreaseValue);
    }
    
    public decimal PartTimeBonusLimit(DateTime targetDate)
    {
        return BonusLimit(targetDate) * _partTimeRatio;
    }
    
    private static int YearsInService(DateTime targetDate, DateTime adjustedInServiceStartTime)
    {
        if (adjustedInServiceStartTime > targetDate) return 0;
        var diff = targetDate.Year - adjustedInServiceStartTime.Year;
        return adjustedInServiceStartTime.Month > targetDate.Month || (adjustedInServiceStartTime.Month == targetDate.Month && adjustedInServiceStartTime.Day > targetDate.Day) ? diff - 1 : diff;
    }
    
    
    private int YearsInService(DateTime targetDate)
    {
        return _adjustedInServiceStartDate is { } adjustedInServiceStartDate
            ? YearsInService(targetDate, adjustedInServiceStartDate)
            : 0;
    }
    
    
    private static DateTime AdjustUserInServiceStartDate(DateTime rawTime)
    {
        if (rawTime.Day <= 3)
        {
            return new DateTime(rawTime.Year, rawTime.Month, 1);
        }
    
        var month = rawTime.Month < 12 ? rawTime.Month + 1 : 1;
        var year = rawTime.Month < 12 ? rawTime.Year : rawTime.Year + 1;
        return new DateTime(year, month, 1);
    }
    

    }

  2. Assistant

    Aby dodać funkcjonalność odroczenia bonusa w Twojej aplikacji, musisz wprowadzić zmiany zarówno w części frontendowej (Vue.js), jak i backendowej (.NET 6). Poniżej przedstawiam szczegółowy przewodnik krok po kroku, wraz z odpowiednimi fragmentami kodu, które pomogą Ci zaimplementować tę funkcjonalność.

    1. Frontend - Vue.js

    a. Aktualizacja Modelu BonusConfig

    Najpierw musisz zaktualizować model BonusConfig, aby uwzględniał nowe pola związane z odroczeniem bonusa.

    BonusConfig.ts (Przykładowy plik modelu)

    // src/store/entities/bonus-config.ts
    
    export default class BonusConfig {
      isActive: boolean = false;
      minValue: number = 0;
      maxValue: number = 0;
      yearlyIncreaseValue: number = 0;
      maxExtraBonusValue: number = 0;
      sickLeaveDecrement: number = 0;
      childCareDecrement: number = 0;
      
      // Nowe pola dla odroczenia bonusa
      isBonusDeferred: boolean = false;
      deferredMonths: number = 0;
      
      constructor(init?: Partial<BonusConfig>) {
        Object.assign(this, init);
      }
    }
    

    b. Aktualizacja Komponentu edit-role-bonus-config.vue

    Dodaj nowe pola do formularza konfiguracyjnego bonusów, umożliwiające ustawienie odroczenia bonusa.

    edit-role-bonus-config.vue

    <template>
      <v-container style="margin: 0; max-width: 400px" fixed>
        <v-form v-model="isFormValid" lazy-validation>
          <div style="max-width: 400px">
            <!-- Istniejące pola konfiguracyjne -->
            <!-- ... -->
    
            <!-- Nowe pola dla odroczenia bonusa -->
            <v-row>
              <v-col cols="7">
                <v-subheader>Odroczenie Bonusa</v-subheader>
              </v-col>
              <v-col cols="5">
                <v-switch
                  v-model="bonusConfig.isBonusDeferred"
                  :readonly="readonly"
                  @change="isModified = true"
                  label="Włącz odroczenie" />
              </v-col>
            </v-row>
            <v-row v-if="bonusConfig.isBonusDeferred">
              <v-col cols="7">
                <v-subheader>Ilość miesięcy do odroczenia</v-subheader>
              </v-col>
              <v-col cols="5">
                <v-text-field
                  v-model.number="bonusConfig.deferredMonths"
                  label="Miesiące"
                  :rules="[v => v >= 0 || 'Liczba miesięcy musi być nieujemna']"
                  :readonly="readonly"
                  type="number"
                  min="0"
                  @input="isModified = true" />
              </v-col>
            </v-row>
          </div>
        </v-form>
      </v-container>
    </template>
    
    <script lang="ts">
    import { Component, Prop, Watch } from "vue-property-decorator";
    import AbpBaseComponent from "@/lib/abp-base-component";
    import BonusConfig from "@/store/entities/bonus-config";
    import Util from "@/lib/util";
    
    @Component({
      components: {}
    })
    export default class EditRoleBonusConfig extends AbpBaseComponent {
      isFormValid: boolean = false;
      isModified: boolean = false;
    
      bonusConfig: BonusConfig = new BonusConfig();
    
      @Prop() readonly!: boolean;
      @Prop() role!: any | null; // Zaktualizuj typ, jeśli masz zdefiniowany typ Role
    
      @Watch("role", {
        immediate: true
      })
      async onRoleChanged(newRole: any) { // Zaktualizuj typ, jeśli masz zdefiniowany typ Role
        this.bonusConfig = Util.deepCloneObject(newRole.bonusRoleConfig);
      }
    
      // Istniejące reguły walidacji
      // ...
    
      getDataIfValid(): BonusConfig | null {
        if (!this.isFormValid) {
          abp.message.error("Nie wszystkie pola konfiguracji bonusów są wypełnione poprawnie");
          return null;
        }
        const consistencyError = this.getConsistencyError(this.bonusConfig);
        if (consistencyError) {
          abp.message.error(consistencyError);
          return null;
        }
        this.isModified = false;
        return this.bonusConfig;
      }
    }
    </script>
    

    c. Aktualizacja Komponentu add-edit-role.vue

    Upewnij się, że nowa konfiguracja bonusów jest przesyłana do backendu podczas zapisywania roli.

    add-edit-role.vue

    <!-- Dodaj nowe pola do formularza lub upewnij się, że komponent edit-role-bonus-config przesyła nowe dane -->
    
    <v-tab-item>
      <edit-role-bonus-config
        ref="bonusConfigTab"
        :readonly="readonly"
        :role="role"
      />
    </v-tab-item>
    

    Aktualizacja Metody save

    Upewnij się, że podczas zapisywania roli, nowe pola są uwzględnione.

    async save() {
      if (!(this.$refs.form as any).validate()) return;
    
      let bonusConfig;
      if (this.$refs.bonusConfigTab) {
        bonusConfig = (this.$refs.bonusConfigTab as any).getDataIfValid();
        if (!bonusConfig) return;
      }
    
      abp.message.confirm("Czy chcesz zapisać zmiany?", async result => {
        if (!result) return;
        this.loading = true;
        try {
          if (this.roleUpdated) {
            if (bonusConfig) {
              this.roleUpdated.bonusRoleConfig = Util.deepCloneObject(bonusConfig);
            }
    
            const response = !this.role!.id
              ? await axios.post("/api/services/app/Roles/Create", this.roleUpdated)
              : await axios.put("/api/services/app/Roles/Update", this.roleUpdated);
            const result = response.data.result;
    
            Object.assign(this.role!, result);
            this.notifier.successToast("Ustawienia roli zostały zapisane");
          }
          this.close(true);
        } finally {
          this.loading = false;
        }
      });
    }
    

    d. Aktualizacja manage-bonuses.vue (Opcjonalne)

    Jeżeli chcesz wyświetlić status odroczenia bonusa użytkownika, możesz zaktualizować ten komponent, aby uwzględniał nowe informacje.

    2. Backend - .NET 6

    a. Aktualizacja BonusRoleConfig Enity

    Dodaj nowe właściwości do encji BonusRoleConfig, które będą przechowywać informacje o odroczeniu bonusa.

    BonusRoleConfig.cs

    namespace Medica.HumanResources.Bonuses
    {
        public class BonusRoleConfig : FullAuditedEntity<long>, IMustHaveTenant
        {
            public long RoleId { get; set; }
    
            public bool IsActive { get; set; }
            public decimal MinValue { get; set; }
            public decimal MaxValue { get; set; }
            public decimal YearlyIncreaseValue { get; set; }
            public decimal MaxExtraBonusValue { get; set; }
            public decimal SickLeaveDecrement { get; set; }
            public decimal ChildCareDecrement { get; set; }
    
            // Nowe właściwości dla odroczenia bonusa
            public bool IsBonusDeferred { get; set; }
            public int DeferredMonths { get; set; }
    
            public int TenantId { get; set; }
        }
    }
    

    Aktualizacja Migracji

    Jeżeli używasz Entity Framework Core, musisz zaktualizować migracje, aby uwzględnić nowe kolumny.

    # W terminalu
    dotnet ef migrations add AddBonusDeferredFields
    dotnet ef database update
    

    Nowa Migracja (AddBonusDeferredFields.cs)

    public partial class AddBonusDeferredFields : Migration
    {
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.AddColumn<bool>(
                name: "IsBonusDeferred",
                table: "BonusRoleConfig",
                nullable: false,
                defaultValue: false);
    
            migrationBuilder.AddColumn<int>(
                name: "DeferredMonths",
                table: "BonusRoleConfig",
                nullable: false,
                defaultValue: 0);
        }
    
        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropColumn(
                name: "IsBonusDeferred",
                table: "BonusRoleConfig");
    
            migrationBuilder.DropColumn(
                name: "DeferredMonths",
                table: "BonusRoleConfig");
        }
    }
    

    b. Aktualizacja BonusRoleConfigDto

    Zaktualizuj DTO, aby uwzględniał nowe pola dla odroczenia bonusa.

    BonusRoleConfigDto.cs

    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations;
    
    namespace Medica.HumanResources.Bonuses.Dto
    {
        public class BonusRoleConfigDto : IValidatableObject
        {
            public bool IsActive { get; set; }
            public decimal MinValue { get; set; }
            public decimal MaxValue { get; set; }
            public decimal YearlyIncreaseValue { get; set; }
            public decimal MaxExtraBonusValue { get; set; }
            public decimal SickLeaveDecrement { get; set; }
            public decimal ChildCareDecrement { get; set; }
    
            // Nowe właściwości
            public bool IsBonusDeferred { get; set; }
            public int DeferredMonths { get; set; }
    
            public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
            {
                if (MinValue < 0 || MinValue > 10000) yield return new ValidationResult("Must be valid non-negative value from range [0..10000]", new List<string> { "MinValue" });
                if (MaxValue < 0 || MaxValue > 10000) yield return new ValidationResult("Must be valid non-negative value from range [0..10000]", new List<string> { "MaxValue" });
                if (YearlyIncreaseValue < 0 || YearlyIncreaseValue > 10000) yield return new ValidationResult("Must be valid non-negative value from range [0..10000]", new List<string> { "YearlyIncreaseValue" });
                if (MaxExtraBonusValue < 0 || MaxExtraBonusValue > 50000) yield return new ValidationResult("Must be valid non-negative value from range [0..50000]", new List<string> { "MaxExtraBonusValue" });
                if (SickLeaveDecrement < 0 || SickLeaveDecrement > 10000) yield return new ValidationResult("Must be valid non-negative value from range [0..10000]", new List<string> { "SickLeaveDecrement" });
                if (ChildCareDecrement < 0 || ChildCareDecrement > 10000) yield return new ValidationResult("Must be valid non-negative value from range [0..10000]", new List<string> { "ChildCareDecrement" });
    
                // Walidacja nowych pól
                if (IsBonusDeferred && DeferredMonths <= 0)
                {
                    yield return new ValidationResult("Ilość miesięcy do odroczenia musi być większa niż zero, jeśli odroczenie jest włączone.", new List<string> { "DeferredMonths" });
                }
    
                if (MinValue > MaxValue)
                {
                    yield return new ValidationResult("Minimalna wartość bonusa musi być mniejsza niż maksymalna", new List<string> { "MinValue", "MaxValue" });
                }
            }
        }
    }
    

    c. Aktualizacja RoleDto

    Upewnij się, że RoleDto mapuje nowe pola z BonusRoleConfig.

    RoleDto.cs

    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations;
    using Abp.Application.Services.Dto;
    using Abp.Authorization.Roles;
    using Abp.AutoMapper;
    using AutoMapper;
    using Medica.Authorization.Roles;
    using Medica.HumanResources.Bonuses.Dto;
    
    namespace Medica.Users.Dto
    {
        [AutoMapFrom(typeof(Role))]
        [AutoMapTo(typeof(RoleDto))]
        public class RoleDto : EntityDto<int>
        {
            public string Name { get; set; }
            public string NormalizedName { get; set; }
    
            [Required]
            [StringLength(AbpRoleBase.MaxDisplayNameLength)]
            public string DisplayName { get; set; }
    
            [StringLength(Role.MaxDescriptionLength)]
            public string Description { get; set; }
    
            public bool IsStatic { get; set; }
            public bool IsActive { get; set; }
            public bool IsPatientRegistrationEnabled { get; set; }
            public bool IsStaffAccountingEnabled { get; set; }
            public bool ExcludeGroupRequiredActionsPenalties { get; set; }
    
            public List<string> Permissions { get; set; }
    
            [IgnoreMap]
            public BonusRoleConfigDto BonusRoleConfig { get; set; }
    
            [IgnoreMap]
            public List<UserInfoDto> Users { get; set; }
    
            // Jeśli konieczne, dodaj nowe mapowanie
        }
    }
    

    d. Aktualizacja RolesAppService

    Zaktualizuj serwis RolesAppService, aby obsługiwał nowe pola odroczenia bonusa podczas tworzenia i aktualizacji roli.

    RolesAppService.cs

    // Importy pozostają bez zmian
    
    namespace Medica.Users
    {
        [AbpAuthorize]
        public class RolesAppService : MedicaAppServiceWithLocalizationBase
        {
            // Istniejące pola i konstruktor
            // ...
    
            public override async Task<RoleDto> Create(RoleDto input)
            {
                if (input.Permissions.IsNullOrEmpty())
                    throw new UserFriendlyException("Musisz przydzielić przynajmniej jedno uprawnienie");
    
                var role = new Role()
                {
                    IsStatic = false,
                };
    
                UpdateEntity(role, input);
                CheckErrors(await _roleManager.CreateAsync(role));
    
                await SetPermissionsAsync(role, input);
                await UpsertBonusRoleConfig(input);
                await _currentUnitOfWorkProvider.Current.SaveChangesAsync();
    
                return await MapToEntityDtoAsync(role);
            }
    
            public override async Task<RoleDto> Update(RoleDto input)
            {
                if (input.Permissions.IsNullOrEmpty())
                    throw new UserFriendlyException("Musisz przydzielić przynajmniej jedno uprawnienie");
    
                var role = await _roleManager.GetRoleByIdAsync(input.Id);
                UpdateEntity(role, input);
                CheckErrors(await _roleManager.UpdateAsync(role));
    
                await SetPermissionsAsync(role, input);
                await UpsertBonusRoleConfig(input);
                await _currentUnitOfWorkProvider.Current.SaveChangesAsync();
    
                return await MapToEntityDtoAsync(role);
            }
    
            public override async Task<GetRoleForEditOutput> GetRoleForEdit(EntityDto input)
            {
                var permissions = _permissionManager.GetAllPermissions();
                var role = await _roleManager.GetRoleByIdAsync(input.Id);
                var grantedPermissions = (await _roleManager.GetGrantedPermissionsAsync(role)).ToArray();
                var roleEditDto = _objectMapper.Map<RoleEditDto>(role);
    
                return new GetRoleForEditOutput
                {
                    Role = roleEditDto,
                    Permissions = _objectMapper.Map<List<FlatPermissionDto>>(permissions).OrderBy(p => p.DisplayName).ToList(),
                    GrantedPermissionNames = grantedPermissions.Select(p => p.Name).ToList(),
                    BonusRoleConfig = await ResolveBonusRoleConfig(role)
                };
            }
    
            private async Task UpsertBonusRoleConfig(RoleDto input)
            {
                var tenantId = MedicaSession.GetTenantId();
                var config = await _bonusRoleConfigs
                                 .GetAll()
                                 .Where(c => c.RoleId == input.Id)
                                 .FirstOrDefaultAsync()
                             ?? await DefaultBonusRoleConfig();
    
                if (input.BonusRoleConfig is { } dtoConfig)
                {
                    config.IsActive = dtoConfig.IsActive;
                    config.MaxValue = dtoConfig.MaxValue;
                    config.MinValue = dtoConfig.MinValue;
                    config.MaxExtraBonusValue = dtoConfig.MaxExtraBonusValue;
                    config.YearlyIncreaseValue = dtoConfig.YearlyIncreaseValue;
                    config.SickLeaveDecrement = dtoConfig.SickLeaveDecrement;
                    config.ChildCareDecrement = dtoConfig.ChildCareDecrement;
    
                    // Aktualizacja nowych pól
                    config.IsBonusDeferred = dtoConfig.IsBonusDeferred;
                    config.DeferredMonths = dtoConfig.DeferredMonths;
                }
    
                config.RoleId = input.Id;
                config.TenantId = tenantId;
    
                await _bonusRoleConfigs.InsertOrUpdateAsync(config);
            }
    
            // Istniejące metody pozostają bez zmian
            // ...
        }
    }
    

    e. Aktualizacja BonusService

    Zaktualizuj serwis BonusService, aby uwzględniał odroczenie bonusa przy obliczaniu bonusów użytkowników.

    BonusService.cs

    namespace Medica.HumanResources.Bonuses
    {
        public class BonusService : IBonusService
        {
            // Istniejące pola i konstruktor
            // ...
    
            public async Task<Either<IList<BonusQuarterSummary>>> GetSummaries(User user, DateTime targetDate)
            {
                var resolvedRoleConfig = await _roleConfigResolver.Resolve(user.Id);
                return await resolvedRoleConfig.Match(
                    async config => await GetSummariesForRole(user, targetDate, config),
                    error => Task.FromResult(Either<IList<BonusQuarterSummary>>.Error(error)));
            }
    
            private async Task<Either<IList<BonusQuarterSummary>>> GetSummariesForRole(User user, DateTime targetDate, BonusRoleConfig config)
            {
                // Sprawdź odroczenie bonusa
                if (config.IsBonusDeferred)
                {
                    // Oblicz datę zakończenia odroczenia
                    var employmentStart = user.WorkStartTimestamp ?? DateTime.MinValue;
                    var defermentEndDate = employmentStart.AddMonths(config.DeferredMonths);
                    if (targetDate < defermentEndDate)
                    {
                        // Bonus jest odroczony, nie naliczaj bonusa
                        return new List<BonusQuarterSummary>().AsSuccess();
                    }
                }
    
                // Kontynuuj istniejącą logikę obliczania bonusów
                return await base.GetSummaries(user, targetDate);
            }
    
            // Opcjonalnie, możesz zaktualizować inne metody, które obliczają bonusy,
            // aby uwzględniały odroczenie bonusa
        }
    }
    

    Wyjaśnienie:

    • Sprawdzenie odroczenia bonusa: Przed obliczeniem bonusów, sprawdzamy, czy dla danej roli jest włączone odroczenie bonusa (IsBonusDeferred). Jeśli tak, obliczamy datę zakończenia odroczenia na podstawie daty rozpoczęcia pracy użytkownika i liczby miesięcy do odroczenia (DeferredMonths).

    • Warunek odroczenia: Jeśli data docelowa (targetDate) jest przed datą zakończenia odroczenia (defermentEndDate), zwracamy pustą listę podsumowań bonusa, co oznacza, że bonus nie jest naliczany w tym okresie.

    • Kontynuacja obliczeń: Jeśli odroczenie nie jest aktywne lub okres odroczenia już minął, kontynuujemy istniejącą logikę obliczania bonusów.

    f. Aktualizacja Mapowania Automatycznego (Opcjonalne)

    Jeżeli używasz automappera dla mapowania DTO do encji, upewnij się, że nowe pola są poprawnie mapowane.

    // W pliku AutoMapperConfiguration.cs lub odpowiednim miejscu konfiguracji AutoMappera
    
    CreateMap<BonusRoleConfigDto, BonusRoleConfig>()
        .ForMember(dest => dest.IsBonusDeferred, opt => opt.MapFrom(src => src.IsBonusDeferred))
        .ForMember(dest => dest.DeferredMonths, opt => opt.MapFrom(src => src.DeferredMonths))
        // Mapowanie innych pól
        .ReverseMap();
    

    3. Testowanie Funkcjonalności

    Po wprowadzeniu powyższych zmian, przeprowadź dokładne testy, aby upewnić się, że:

    1. Konfiguracja Rol:

      • Administrator może włączyć/wyłączyć odroczenie bonusa dla danej roli.
      • Administrator może ustawić poprawną liczbę miesięcy do odroczenia.
    2. Obliczanie Bonusów:

      • Bonusy nie są naliczane przez ustawiony okres od rozpoczęcia zatrudnienia, gdy odroczenie jest aktywne.
      • Bonusy są prawidłowo naliczane po zakończeniu okresu odroczenia.
      • Odroczenie nie wpływa negatywnie na inne funkcjonalności związane z bonusami.
    3. Walidacja:

      • System poprawnie waliduje dane wejściowe, np. liczba miesięcy do odroczenia musi być dodatnia, gdy odroczenie jest włączone.
    4. Obsługa Błędów:

      • System poprawnie obsługuje przypadki brzegowe, np. brak daty rozpoczęcia pracy użytkownika.

    4. Uwagi i Dodatki

    • Bezpieczeństwo: Upewnij się, że tylko uprawnieni użytkownicy (np. administratorzy) mogą edytować konfiguracje bonusa i ustawiać odroczenie.

    • Użyteczność: Możesz dodać dodatkowe powiadomienia lub wskaźniki w interfejsie użytkownika informujące o statusie odroczenia bonusa dla danej roli.

    • Dokumentacja: Zaktualizuj dokumentację aplikacji, aby uwzględniała nowe funkcjonalności związane z odroczeniem bonusa.

    • Migracje Danych: Jeśli w istniejącej bazie danych są już rekordy BonusRoleConfig, pomyśl o tym, jakie wartości domyślne powinny zostać przypisane dla nowych pól IsBonusDeferred i DeferredMonths.

    5. Podsumowanie

    Dodanie funkcjonalności odroczenia bonusa wymaga zarówno aktualizacji modeli danych, jak i interfejsu użytkownika oraz logiki biznesowej. Starannie przetestuj wszystkie zmiany, aby zapewnić, że bonusy są naliczane zgodnie z nowymi ustawieniami, a użytkownicy mają przejrzysty i intuicyjny dostęp do nowych opcji konfiguracyjnych.

    Jeżeli napotkasz na jakiekolwiek problemy podczas implementacji, nie wahaj się pytać o szczegóły lub dodatkowe wyjaśnienia!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.