Skip to content
The Chat Archive
o1-mini-2024-09-12· OpenAI 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 backendzie (.NET 6), jak i w frontendzie (Vue.js). Poniżej przedstawiam szczegółowy plan wraz z odpowiednimi fragmentami kodu, które umożliwią realizację tego zadania.

    1. Backend (.NET 6)

    a. Modyfikacja Klasy BonusRoleConfig

    Dodaj nową właściwość DeferralMonths do klasy BonusRoleConfig, która będzie przechowywać liczbę miesięcy, o które bonus jest odroczony.

    // BonusRoleConfig.cs
    
    public class BonusRoleConfig : FullAuditedEntity<long>, IMustHaveTenant
    {
        // Istniejące właściwości...
        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; }
    
        // Nowa właściwość
        public int DeferralMonths { get; set; } = 0; // Domyślnie brak odroczenia
    
        public int TenantId { get; set; }
    }
    

    b. Aktualizacja DTO: BonusRoleConfigDto

    Dodaj pole DeferralMonths do klasy BonusRoleConfigDto oraz odpowiednie reguły walidacji.

    // BonusRoleConfigDto.cs
    
    public class BonusRoleConfigDto : IValidatableObject
    {
        // Istniejące właściwości...
        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; }
    
        // Nowa właściwość
        public int DeferralMonths { get; set; } = 0; // Domyślnie brak odroczenia
    
        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
        {
            // Istniejąca walidacja...
    
            // Nowa walidacja dla DeferralMonths
            if (DeferralMonths < 0 || DeferralMonths > 60)
            {
                yield return new ValidationResult("DeferralMonths musi być wartością nieujemną i nie większą niż 60 miesięcy.", new List<string> { "DeferralMonths" });
            }
    
            // Przykład istniejącej walidacji...
            if (MinValue > MaxValue)
            {
                yield return new ValidationResult("Minimalna wartość bonusa nie może być większa niż maksymalna.", new List<string> { "MinValue", "MaxValue" });
            }
    
            // ...inne reguły walidacji
        }
    }
    

    c. Aktualizacja RoleDto

    Dodaj pole DeferralMonths do klasy RoleDto poprzez BonusRoleConfigDto.

    // RoleDto.cs
    
    public class RoleDto : EntityDto<int>
    {
        // Istniejące właściwości...
        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; }
    }
    

    d. Modyfikacja RolesAppService

    Zaktualizuj serwis RolesAppService aby uwzględniał nową właściwość DeferralMonths podczas tworzenia i aktualizacji konfiguracji bonusa.

    // RolesAppService.cs
    
    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,
            DeferralMonths = bonusConfig.DeferralMonths // Dodaj tę linię
        };
    }
    
    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),
            DeferralMonths = 0 // Inicjalizacja domyślną wartością
        };
    }
    
    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.DeferralMonths = dtoConfig.DeferralMonths; // Dodaj tę linię
        }
    
        config.RoleId = input.Id;
        config.TenantId = tenantId;
    
        await _bonusRoleConfigs.InsertOrUpdateAsync(config);
    }
    

    e. Aktualizacja Logiki BonusService

    Zaktualizuj BonusService, aby uwzględniał okres odroczenia bonusa przy kalkulacji bonusów.

    // BonusService.cs
    
    public class BonusService : IBonusService
    {
        // Istniejące zależności i konstruktor...
    
        public async Task<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 => throw new Exception(error.Message)); // Możesz obsłużyć błąd w inny sposób
        }
    
        private async Task<IList<BonusQuarterSummary>> GetSummariesForRole(User user, DateTime targetDate, BonusRoleConfig config)
        {
            // Uwzględnij DeferralMonths
            DateTime employmentStartDate = user.WorkStartTimestamp ?? targetDate;
            DateTime bonusStartDate = employmentStartDate.AddMonths(config.DeferralMonths);
    
            if (targetDate < bonusStartDate)
            {
                // Bonus jest odroczony, nie naliczaj bonusa
                return new List<BonusQuarterSummary>();
            }
    
            // Kontynuuj istniejącą logikę kalkulacji bonusów
            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 => Either<IList<BonusQuarterSummary>>.Error(error));
        }
    
        private async Task<BonusQuarterSummary> ComputeQuarterSummary(User user, DateTime targetDate, BonusRoleConfig config, IList<BonusQuarterSummary> list)
        {
            // Przearanżowana logika z uwzględnieniem DeferralMonths
            DateTime employmentStartDate = user.WorkStartTimestamp ?? targetDate;
            DateTime bonusStartDate = employmentStartDate.AddMonths(config.DeferralMonths);
    
            if (targetDate < bonusStartDate)
            {
                // Bonus jest odroczony
                return new BonusQuarterSummary()
                {
                    Balance = 0,
                    PaidAmount = 0,
                    Quarter = Quarter.FromDate(targetDate).QuarterIdx,
                    Year = Quarter.FromDate(targetDate).Year,
                    UserId = user.Id
                };
            }
    
            // Kontynuuj istniejącą logikę kalkulacji
            // ...
        }
    
        // Inne metody...
    }
    

    Uwagi:

    • Walidacja i Domyślne Wartości: Upewnij się, że nowe pole DeferralMonths ma sensowne domyślne wartości i odpowiednią walidację zarówno po stronie backendu, jak i frontend.

    • Obsługa Przypadków Krawędziowych: Rozważ scenariusze, w których DeferralMonths przekracza określone limity, lub gdy użytkownik zmienia datę rozpoczęcia zatrudnienia.

    • Testowanie: Przeprowadź dokładne testy, aby upewnić się, że odroczenie bonusa działa zgodnie z oczekiwaniami w różnych scenariuszach.

    2. Frontend (Vue.js)

    a. Aktualizacja Komponentu edit-user-bonuses-config.vue

    Dodaj pole do edycji liczby miesięcy odroczenia bonusa w interfejsie użytkownika.

    <!-- edit-user-bonuses-config.vue -->
    
    <template class="lg12">
      <v-container style="margin: 0; max-width: 400px" fixed>
        <v-form v-model="isFormValid" lazy-validation>
          <div style="max-width: 400px">
            <!-- Istniejące pola... -->
    
            <v-row>
              <v-col cols="7">
                <v-subheader>Odroczenie Bonusu</v-subheader>
              </v-col>
              <v-col cols="5">
                <v-switch
                  v-model="bonusConfig.isDeferred"
                  :readonly="readonly"
                  @change="isModified = true"
                  label="Odroczyć bonus" />
              </v-col>
            </v-row>
            <v-row v-if="bonusConfig.isDeferred">
              <v-col cols="7">
                <v-subheader>Liczba Miesięcy Odroczenia</v-subheader>
              </v-col>
              <v-col cols="5">
                <v-text-field
                  v-model.number="bonusConfig.deferralMonths"
                  label="Miesiące"
                  :rules="deferralRules"
                  :readonly="readonly || !bonusConfig.isDeferred"
                  type="number"
                  min="0"
                  max="60"
                  @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 type Role from "@/store/entities/role";
    import BonusConfig from "@/store/entities/bonus-config";
    import Util from "@/lib/util";
    import ValidatePolish from "@/lib/validate-polish";
    
    @Component({
      components: {}
    })
    export default class EditRoleBonusConfig extends AbpBaseComponent {
      isFormValid: boolean;
      isModified = false;
    
      bonusConfig: BonusConfig = new BonusConfig();
    
      @Prop() readonly!: boolean;
      @Prop() role!: Role | null;
    
      @Watch("role", {
        immediate: true
      })
      async onRoleChanged(newRole: Role) {
        this.bonusConfig = Util.deepCloneObject(newRole.bonusRoleConfig);
      }
    
      nameRules = [
        v => !!v || "Pole jest wymagane",
        v => (!!v && v.length >= 3) || "Pole musi mieć przynajmniej 3 znaki"
      ];
    
      amountRules = [
        v => v !== "" || "Pole jest wymagane",
        v => (ValidatePolish.amount(v) && Number(v) >= 0 && Number(v) < 100000) || "Niepoprawna wartość"
      ];
    
      // Nowe reguły walidacji dla DeferralMonths
      deferralRules = [
        v => v !== "" || "Pole jest wymagane",
        v => Number.isInteger(v) || "Miesiące muszą być liczbą całkowitą",
        v => v >= 0 || "Miesiące nie mogą być ujemne",
        v => v <= 60 || "Maksymalnie 60 miesięcy odroczenia"
      ];
    
      deferralMonthsRules = [
        v => v >= 0 || "Liczba miesięcy odroczenia nie może być ujemna",
        v => v <= 60 || "Maksymalnie 60 miesięcy odroczenia"
      ];
    
      public getConsistencyError(bonusConfig: BonusConfig): string | null {
        if (bonusConfig.minValue > bonusConfig.maxValue) {
          return "Maksymalna wartość bonusa musi być większa od minimalnej";
        }
        if (bonusConfig.yearlyIncreaseValue > bonusConfig.maxValue - bonusConfig.minValue) {
          return "Roczna podwyżka bonusa nie może być większa niż różnica między wartością minimalną a maksymalną";
        }
        return null;
      }
    
      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>
    

    Uwagi:

    • Dodano przełącznik isDeferred do aktywacji/dezaktywacji odroczenia bonusa.
    • Dodano pole deferralMonths widoczne tylko wtedy, gdy isDeferred jest włączony.
    • Dodano reguły walidacji dla deferralMonths.

    b. Aktualizacja Modelu BonusConfig

    Upewnij się, że model BonusConfig zawiera nowe pole deferralMonths aby przechowywać dane z formularza.

    // bonus-config.ts (Przykładowa lokalizacja w sklepie Vuex lub podobnym)
    
    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;
    
      // Nowa właściwość
      isDeferred: boolean = false;
      deferralMonths: number = 0;
    }
    

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

    Zaktualizuj komponent edit-role-bonus-config.vue, aby obsługiwał nowe pole deferralMonths. Upewnij się, że dane są poprawnie przesyłane i odbierane.

    <!-- edit-role-bonus-config.vue -->
    
    <template class="lg12">
      <v-container style="margin: 0; max-width: 400px" fixed>
        <v-form v-model="isFormValid" lazy-validation>
          <div style="max-width: 400px">
            <!-- Istniejące pola... -->
    
            <!-- Dodane pola dla Odroczenia Bonusu -->
            <v-row>
              <v-col cols="7">
                <v-subheader>Odroczenie Bonusu</v-subheader>
              </v-col>
              <v-col cols="5">
                <v-switch
                  v-model="bonusConfig.isDeferred"
                  :readonly="readonly"
                  @change="handleDeferralChange"
                  label="Odroczyć bonus" />
              </v-col>
            </v-row>
            <v-row v-if="bonusConfig.isDeferred">
              <v-col cols="7">
                <v-subheader>Liczba Miesięcy Odroczenia</v-subheader>
              </v-col>
              <v-col cols="5">
                <v-text-field
                  v-model.number="bonusConfig.deferralMonths"
                  label="Miesiące"
                  :rules="deferralRules"
                  :readonly="readonly || !bonusConfig.isDeferred"
                  type="number"
                  min="0"
                  max="60"
                  @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 type Role from "@/store/entities/role";
    import BonusConfig from "@/store/entities/bonus-config";
    import Util from "@/lib/util";
    import ValidatePolish from "@/lib/validate-polish";
    
    @Component({
      components: {}
    })
    export default class EditRoleBonusConfig extends AbpBaseComponent {
      isFormValid: boolean;
      isModified = false;
    
      bonusConfig: BonusConfig = new BonusConfig();
    
      @Prop() readonly!: boolean;
      @Prop() role!: Role | null;
    
      @Watch("role", {
        immediate: true
      })
      async onRoleChanged(newRole: Role) {
        this.bonusConfig = Util.deepCloneObject(newRole.bonusRoleConfig);
      }
    
      nameRules = [
        v => !!v || "Pole jest wymagane",
        v => (!!v && v.length >= 3) || "Pole musi mieć przynajmniej 3 znaki"
      ];
    
      amountRules = [
        v => v !== "" || "Pole jest wymagane",
        v => (ValidatePolish.amount(v) && Number(v) >= 0 && Number(v) < 100000) || "Niepoprawna wartość"
      ];
    
      deferralRules = [
        v => v !== "" || "Pole jest wymagane",
        v => Number.isInteger(v) || "Miesiące muszą być liczbą całkowitą",
        v => v >= 0 || "Miesiące nie mogą być ujemne",
        v => v <= 60 || "Maksymalnie 60 miesięcy odroczenia"
      ];
    
      public getConsistencyError(bonusConfig: BonusConfig): string | null {
        if (bonusConfig.minValue > bonusConfig.maxValue) {
          return "Maksymalna wartość bonusa musi być większa od minimalnej";
        }
        if (bonusConfig.yearlyIncreaseValue > bonusConfig.maxValue - bonusConfig.minValue) {
          return "Roczna podwyżka bonusa nie może być większa niż różnica między wartością minimalną a maksymalną";
        }
        return null;
      }
    
      handleDeferralChange() {
        if (!this.bonusConfig.isDeferred) {
          this.bonusConfig.deferralMonths = 0;
        }
        this.isModified = true;
      }
    
      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>
    

    Uwagi:

    • Dodano przełącznik isDeferred oraz pole deferralMonths.
    • Funkcja handleDeferralChange resetuje deferralMonths do 0, gdy odroczenie jest wyłączone.

    d. Aktualizacja Komponentu add-edit-role.vue

    Upewnij się, że komponent add-edit-role.vue prawidłowo przekazuje i odbiera nowe pole deferralMonths.

    <!-- add-edit-role.vue -->
    
    <template>
      <v-dialog v-model="value" fullscreen hide-overlay transition="dialog-bottom-transition">
        <v-card v-if="!!roleUpdated">
          <!-- Istniejący kod... -->
    
          <v-form ref="form" v-model="valid" lazy-validation>
            <v-tabs class="ma-2">
              <!-- Istniejące zakładki... -->
    
              <v-tab-item>
                <edit-role-bonus-config
                  ref="bonusConfigTab"
                  :readonly="readonly"
                  :role="role" />
              </v-tab-item>
            </v-tabs>
          </v-form>
    
          <!-- Istniejący dialog kopiowania... -->
        </v-card>
      </v-dialog>
    </template>
    
    <script lang="ts">
    import { Component, Inject, Prop, Watch } from "vue-property-decorator";
    import groupBy from "lodash/groupBy";
    import Util from "@/lib/util";
    import type Role from "@/store/entities/role";
    import type { Permission } from "@/store/entities/permission";
    import AbpBaseDialog from "@/lib/abp-base-dialog";
    import EditRoleBonusConfig from "@/views/admin/roles/edit-role-bonus-config.vue";
    import Notifier from "@/views/main-wrap/notifier";
    import V2Btn from "@/compatibility-layer/components/v2-btn.vue";
    import V2TextField from "@/compatibility-layer/components/v2-text-field.vue";
    import axios from "@/lib/axios";
    
    @Component({
      components: {
        V2TextField,
        V2Btn,
        EditRoleBonusConfig
      }
    })
    export default class AddEditRole extends AbpBaseDialog {
      copyFromDialog = false;
      activeTab = 0;
      loading = false;
      nameRules = [
        v => !!v || "Pole jest wymagane",
        v => (!!v && v.length >= 3) || "Pole musi mieć przynajmniej 3 znaki"
      ];
      roleUpdated: Role | null = null;
      permissions: Permission[] = new Array<Permission>();
      primaryRoleName: string;
      isFormValid: boolean;
    
      @Prop() readonly!: boolean;
      @Prop() value!: boolean;
      @Prop() role!: Role | null;
      @Prop() roles!: Role[];
    
      @Inject(Notifier.Key) notifier: Notifier;
    
      get permissionsGrouped() {
        return groupBy(this.permissions, v => v.name.split(".")[0]);
      }
    
      @Watch("role", {
        immediate: true
      })
      async onRoleChanged(nv: Role) {
        this.roleUpdated = Util.deepCloneObject(nv);
    
        const response = await axios.get("/api/services/app/Roles/getAllPermissions");
        const permissions = response.data.result.items;
    
        permissions.forEach(perm => {
          if (!!nv && !!nv.permissions && nv.permissions.includes(perm.name)) {
            perm.allow = true;
          } else {
            perm.allow = false;
          }
        });
    
        this.permissions = permissions;
      }
    
      onUpdated() {
        if (!this.role) return;
    
        this.roleUpdated!.permissions = this.permissions.filter(v => v.allow === true).map(v => v.name);
      }
    
      copyFromRole(role: Role) {
        this.permissions.forEach(p => {
          const found = role.permissions.includes(p.name);
          p.allow = found;
        });
    
        this.onUpdated();
        this.copyFromDialog = false;
      }
    
      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;
          }
        });
      }
    }
    </script>
    

    Uwagi:

    • Komponent add-edit-role.vue działań pozostaje taki, jaki jest, ponieważ główne zmiany zostały wprowadzone w komponencie edit-role-bonus-config.vue.

    e. Aktualizacja Modelu Danych Wysyłanych/Przyjmowanych

    Upewnij się, że API jest w stanie przyjmować i zwracać nowe pole deferralMonths. Jeśli korzystasz z mapowania Automappera, powinno to się odbywać automatycznie dzięki AutoMap* atrybutom, ale warto to potwierdzić.

    3. Migracja Bazy Danych

    Musisz utworzyć migrację bazodanową, aby dodać nową kolumnę DeferralMonths do tabeli BonusRoleConfig.

    // Utwórz migrację
    
    public partial class AddDeferralMonthsToBonusRoleConfig : Migration
    {
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.AddColumn<int>(
                name: "DeferralMonths",
                table: "BonusRoleConfig",
                type: "int",
                nullable: false,
                defaultValue: 0);
        }
    
        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropColumn(
                name: "DeferralMonths",
                table: "BonusRoleConfig");
        }
    }
    

    Instrukcje:

    1. Dodaj powyższy kod do folderu migracji w projekcie .NET.

    2. Uruchom komendę migracji:

      dotnet ef migrations add AddDeferralMonthsToBonusRoleConfig
      dotnet ef database update
      

    4. Testowanie

    Po wprowadzeniu wszystkich zmian, wykonaj następujące kroki, aby upewnić się, że funkcjonalność działa poprawnie:

    1. Tworzenie/Rozbudowywanie Ról:

      • Przejdź do panelu administracyjnego i edytuj konfigurację bonusów dla roli.
      • Włącz opcję odroczenia bonusa i ustaw liczbę miesięcy.
      • Zapisz zmiany i upewnij się, że nowe ustawienia są poprawnie zapisane w bazie danych.
    2. Przydzielanie Ról Użytkownikom:

      • Przydziel rolę z ustawionym odroczeniem bonusu użytkownikowi.
      • Zweryfikuj, że bonus nie jest naliczany przez określony okres od rozpoczęcia zatrudnienia.
    3. Kalkulacja Bonusów:

      • Przetestuj logikę kalkulacji bonusów, aby upewnić się, że odroczenie jest uwzględniane.
    4. Użyteczność UI:

      • Sprawdź, czy nowe pola są intuicyjne i czy walidacja działa poprawnie.

    5. Podsumowanie

    Dodanie funkcjonalności odroczenia bonusa wymaga aktualizacji zarówno backendu, jak i frontend'u aplikacji. Przez dodanie nowej właściwości DeferralMonths oraz odpowiednią zmianę logiki kalkulacji, uda Ci się wprowadzić tę funkcjonalność zgodnie z wymaganiami. Upewnij się, że przetestujesz zmiany w różnych scenariuszach, aby zapewnić ich poprawne działanie w Twojej aplikacji.

    Jeśli napotkasz jakiekolwiek problemy lub potrzebujesz dalszej pomocy, nie wahaj się zapytać!

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