public async Task <PayrollStampingResult> PayrollIndividualStampingAsync(PayrollIndividualStampingParams payrollIndividualStampingParams)
        {
            var manager = new PayrollStampingManager();

            return(await manager.PayrollIndividualStampingAsync(payrollIndividualStampingParams));
        }
 public async Task <PayrollStampingResult> PayrollIndividualStampingAsync(PayrollIndividualStampingParams payrollIndividualStampingParams)
 {
     throw new NotImplementedException();
 }
Example #3
0
 public async Task <PayrollStampingResult> PayrollIndividualStampingAsync(PayrollIndividualStampingParams payrollIndividualStampingParams)
 {
     return(await _client.PayrollIndividualStampingAsync(payrollIndividualStampingParams));
 }
        public async Task <PayrollStampingResult> PayrollIndividualStampingAsync(PayrollIndividualStampingParams payrollIndividualStampingParams)
        {
            //Obtiene todos los historic overdrafts del periodo seleccionado
            var historicOverdraftManager = new MiddlewareManager <Overdraft>(new BaseRecordManager <Overdraft>(),
                                                                             new OverdraftValidator());
            var incidentsManager = new MiddlewareManager <Incident>(new BaseRecordManager <Incident>(),
                                                                    new IncidentValidator());
            var inhabilitiesManager = new MiddlewareManager <Inhability>(
                new BaseRecordManager <Inhability>(),
                new InhabilityValidator());

            var historicOverdraftsToStamp = await historicOverdraftManager.FindByExpressionAsync(p =>
                                                                                                 p.company == payrollIndividualStampingParams.IdentityWorkID &&
                                                                                                 p.InstanceID == payrollIndividualStampingParams.InstanceID &&
                                                                                                 p.PeriodDetailID == payrollIndividualStampingParams.PeriodDetailID &&
                                                                                                 p.ID == payrollIndividualStampingParams.OverdraftID &&
                                                                                                 p.OverdraftStatus == OverdraftStatus.Authorized &&
                                                                                                 p.Active,
                                                                                                 payrollIndividualStampingParams.IdentityWorkID, new string[] {
                "OverdraftPreviousCancelRelationship",
                "OverdraftDetails",
                "OverdraftDetails.ConceptPayment",
                "PeriodDetail",
                "PeriodDetail.Period",
                "HistoricEmployee",
                "HistoricEmployee.Employee",
                "HistoricEmployee.Employee.Workshift",
                "HistoricEmployee.Employee.EmployerRegistration"
            });

            var incidents = await incidentsManager.FindByExpressionAsync(p =>
                                                                         p.PeriodDetailID == payrollIndividualStampingParams.PeriodDetailID &&
                                                                         p.InstanceID == payrollIndividualStampingParams.InstanceID,
                                                                         payrollIndividualStampingParams.IdentityWorkID,
                                                                         new string[] { "IncidentType" });

            var initialDate = historicOverdraftsToStamp.FirstOrDefault().PeriodDetail.InitialDate;
            var finalDate   = historicOverdraftsToStamp.FirstOrDefault().PeriodDetail.FinalDate;

            //Incapacidades dentro del periodo
            var inhabilities = await inhabilitiesManager.FindByExpressionAsync(p =>
                                                                               p.InstanceID == payrollIndividualStampingParams.InstanceID &&
                                                                               (
                                                                                   (p.InitialDate >= initialDate && p.InitialDate.AddDays(p.AuthorizedDays - 1) <= finalDate) ||
                                                                                   (p.InitialDate >= initialDate && p.InitialDate.AddDays(p.AuthorizedDays - 1) > finalDate) ||
                                                                                   (p.InitialDate < initialDate && p.InitialDate.AddDays(p.AuthorizedDays - 1) <= finalDate) ||
                                                                                   (p.InitialDate <initialDate && p.InitialDate.AddDays(p.AuthorizedDays - 1)> finalDate)
                                                                               ),
                                                                               payrollIndividualStampingParams.IdentityWorkID);

            //Obtiene la información fiscal del patrón, certificados
            var employerFiscalInformationManager = new MiddlewareManager <EmployerFiscalInformation>(new BaseRecordManager <EmployerFiscalInformation>(),
                                                                                                     new EmployerFiscalInformationValidator());
            var employerFiscalInformations = await employerFiscalInformationManager.FindByExpressionAsync(p =>
                                                                                                          p.company == payrollIndividualStampingParams.IdentityWorkID &&
                                                                                                          p.InstanceID == payrollIndividualStampingParams.InstanceID,
                                                                                                          payrollIndividualStampingParams.IdentityWorkID);

            if (!employerFiscalInformations.Any())
            {
                throw new CotorraException(105, "105", "No se han configurado los certificados (CSD) de la empresa para poder timbrar. Ve al menú Catálogos -> Certificados -> Agregar nuevo", null);
            }

            //Obtiene la configuración general de la empresa
            var payrollCompanyConfigurationManager = new MiddlewareManager <PayrollCompanyConfiguration>(new BaseRecordManager <PayrollCompanyConfiguration>(),
                                                                                                         new PayrollCompanyConfigurationValidator());
            var payrollConfigurations = await payrollCompanyConfigurationManager.FindByExpressionAsync(p =>
                                                                                                       p.company == payrollIndividualStampingParams.IdentityWorkID &&
                                                                                                       p.InstanceID == payrollIndividualStampingParams.InstanceID, payrollIndividualStampingParams.IdentityWorkID,
                                                                                                       new string[] { "Address" });

            if (!historicOverdraftsToStamp.Any())
            {
                throw new CotorraException(101, "101", "No hay ningún sobrerecibo a timbrar en estatus autorizado, con los parámetros proporcionados.", null);
            }

            var payrollStampingParams = _mapper.Map <PayrollIndividualStampingParams, PayrollStampingParams>(payrollIndividualStampingParams);

            return(await payrollStampingCoreAsync(payrollStampingParams,
                                                  historicOverdraftsToStamp, incidents, inhabilities,
                                                  employerFiscalInformations, payrollConfigurations));
        }