public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceId, Guid employeeID, Guid conceptPaymentID) where T : BaseEntity { var fonacotMovements = new List <FonacotMovement>(); fonacotMovements.Add(new FonacotMovement() { ID = Guid.NewGuid(), Active = true, company = identityWorkId, Timestamp = DateTime.UtcNow, InstanceID = instanceId, Description = "Departamento de nominas", CreationDate = DateTime.Now, Name = "Nominas", StatusID = 1, ConceptPaymentID = conceptPaymentID, CreditNumber = "AA010101", DeleteDate = null, EmployeeID = employeeID, FonacotMovementStatus = FonacotMovementStatus.Active, Month = 1, Year = 2020, Observations = "Observations", RetentionType = RetentionType.FixedAmount, user = Guid.Empty, }); var middlewareManager = new MiddlewareManager <FonacotMovement>(new BaseRecordManager <FonacotMovement>(), new FonacotMovementValidator()); await middlewareManager.CreateAsync(fonacotMovements, identityWorkId); return(fonacotMovements as List <T>); }
public async Task Should_Fall_Inhability_Duplicated_Folio() { var txOptions = new System.Transactions.TransactionOptions(); txOptions.IsolationLevel = System.Transactions.IsolationLevel.ReadUncommitted; using var scope = new TransactionScope(TransactionScopeOption.Required, txOptions, TransactionScopeAsyncFlowOption.Enabled); //Act Guid identityWorkId = Guid.NewGuid();//Guid.Parse("7535C4E6-4712-4DD6-955D-FCA86E054D49"); var middlewareManager = new MiddlewareManager <Inhability>(new BaseRecordManager <Inhability>(), new InhabilityValidator()); Guid id = Guid.Empty; try { Guid instanceId = Guid.NewGuid(); //Guid.Parse("33D7CA50-39E9-4B14-B482-5FCBEC07E8DB"); var inhabilities = await new InhabilityManagerUT().CreateDefaultAsync <Inhability>(identityWorkId, instanceId); id = inhabilities.FirstOrDefault().ID; inhabilities.FirstOrDefault().ID = Guid.NewGuid(); await middlewareManager.CreateAsync(inhabilities, identityWorkId); Assert.False(true); } catch (Exception ex) { Assert.Contains("Existe 1 o más registros que ya existen en la base de datos con el campo: Folio", ex.Message); } }
public async Task Should_Create_Fonacot_CreditNumber_Duplicated_ToValidate_Finally_do_Delete() { using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled); try { //Arrange var identityWorkId = Guid.NewGuid(); var instanceId = Guid.NewGuid(); var middlewareManager = new MiddlewareManager <FonacotMovement>(new BaseRecordManager <FonacotMovement>(), new FonacotMovementValidator()); var fonacotMovements = await new FonacotMovementManagerUT().CreateDefaultAsync <FonacotMovement>(identityWorkId, instanceId); fonacotMovements.FirstOrDefault().ID = Guid.NewGuid(); //Act await middlewareManager.CreateAsync(fonacotMovements, identityWorkId); //Assert Assert.False(true, "La validación de duplicado falló"); } catch (CotorraException ex) { Assert.Equal(15001, ex.ErrorCode); } catch { Assert.True(true); } }
public async Task Client_Should_Call_Dummy_Async() { using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled); var iMSSFare = new List <IMSSFare>(); var companyId = Guid.NewGuid(); var instanceId = Guid.NewGuid(); var userId = Guid.NewGuid(); iMSSFare = new MemoryStorageContext().GetDefaultIMSSFare(companyId, instanceId, userId); var middlewareManager = new MiddlewareManager <IMSSFare>(new BaseRecordManager <IMSSFare>(), new IMSSFareValidator()); //Act await middlewareManager.CreateAsync(iMSSFare, companyId); //Asserts //Get var result = await middlewareManager .GetByIdsAsync(iMSSFare.Select(p => p.ID).ToList(), companyId); Assert.True(result.Any()); //Delete await middlewareManager.DeleteAsync(iMSSFare.Select(p => p.ID).ToList(), companyId); //Get it again to verify if the registry it was deleted var result2 = await middlewareManager .GetByIdsAsync(iMSSFare.Select(p => p.ID).ToList(), companyId); Assert.True(!result2.Any()); }
public async Task <List <IncidentType> > CreateDefaultIncidentTypeAsync(Guid identityWorkId, Guid instanceID) { var middlewareManager = new MiddlewareManager <IncidentType>(new BaseRecordManager <IncidentType>(), new IncidentTypeValidator()); List <IncidentType> incidentTypes = new List <IncidentType>() { new IncidentType() { ID = Guid.NewGuid(), Active = true, company = identityWorkId, Timestamp = DateTime.UtcNow, InstanceID = instanceID, Description = "Incident", CreationDate = DateTime.Now, Name = "Incident", StatusID = 1, Code = "2", DecreasesSeventhDay = false, ItConsiders = ItConsiders.Absence, Percentage = 10, SalaryRight = true, TypeOfIncident = TypeOfIncident.Days, UnitValue = 10, } }; await middlewareManager.CreateAsync(incidentTypes, identityWorkId); return(incidentTypes); }
public async Task <List <ConceptPayment> > CreateDefaultSalaryPaymentConceptsAsync(Guid identityWorkId, Guid instanceID) { var memoryStorageContext = new MemoryStorageContext(); var middlewareAccumulates = new MiddlewareManager <AccumulatedType>(new BaseRecordManager <AccumulatedType>(), new AccumulatedTypeValidator()); var accumulatesTypes = await middlewareAccumulates.GetAllAsync(identityWorkId, instanceID); if (!accumulatesTypes.Any()) { accumulatesTypes = memoryStorageContext.GetDefaultAccumulatedType(identityWorkId, instanceID, Guid.NewGuid()); await middlewareAccumulates.CreateAsync(accumulatesTypes, identityWorkId); } var resultTuple = memoryStorageContext.GetDefaultConcept <ConceptPayment>(identityWorkId, instanceID, Guid.NewGuid(), accumulatesTypes); var concepts = resultTuple.Item1 .Cast <ConceptPayment>().ToList(); var middlewareManagerConceptPaymentRelationship = new MiddlewareManager <ConceptPaymentRelationship>(new BaseRecordManager <ConceptPaymentRelationship>(), new ConceptPaymentRelationshipValidator()); var middlewareConcept = new MiddlewareManager <ConceptPayment>(new BaseRecordManager <ConceptPayment>(), new ConceptPaymentValidator()); await middlewareConcept.CreateAsync(concepts, identityWorkId); var relationships = resultTuple.Item2.Cast <ConceptPaymentRelationship>().ToList(); await middlewareManagerConceptPaymentRelationship.CreateAsync(relationships, identityWorkId); return(concepts); }
public async Task Should_Fail_When_LowerLimit_is_less_than_zero() { using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled); //Arrange var identityWorkId = Guid.NewGuid(); var instanceId = Guid.NewGuid(); //create one uma var uMAs = await new UMAManagerUT().CreateDefaultAsync <UMA>(identityWorkId, instanceId); //Act var middlewareManager = new MiddlewareManager <UMA>(new BaseRecordManager <UMA>(), new UMAValidator()); //Asserts //Get var result = (await middlewareManager .GetByIdsAsync(uMAs.Select(p => p.ID).ToList(), identityWorkId)).First(); try { await middlewareManager.CreateAsync(new List <UMA>() { result }, identityWorkId); Assert.True(false, "Debe de mandar una excepción por registro duplicado"); } catch (CotorraException ex) { Assert.Equal(9006, ex.ErrorCode); } catch { Assert.True(true); } }
public async Task Should_Delete() { using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled); //Arrange var periodTypes = new List <PeriodType>(); var identityWorkId = Guid.NewGuid(); var id = Guid.NewGuid(); var periodType = PeriodTypeBuilder.Build(id, identityWorkId, "Quincenal"); periodTypes.Add(periodType); //Act var middlewareManager = new MiddlewareManager <PeriodType>(new BaseRecordManager <PeriodType>(), new PeriodTypeValidator()); await middlewareManager.CreateAsync(periodTypes, identityWorkId); //Assert var found = await middlewareManager.GetByIdsAsync(new List <Guid>() { id }, identityWorkId); Assert.True(found.Any()); var register = found.FirstOrDefault(x => x.ID == id); Assert.NotNull(register); await middlewareManager.DeleteAsync(new List <Guid>() { id }, identityWorkId); found = await middlewareManager.GetByIdsAsync(new List <Guid>() { id }, identityWorkId); register = found.FirstOrDefault(x => x.ID == id); Assert.Null(register); }
public async Task <List <T> > CreateDefaultAsyncWithPeriodDetailID <T>(Guid identityWorkId, Guid instanceID, Guid employeeID, Guid periodDetailID, bool salaryRight, DateTime date) where T : BaseEntity { //Act Dependencies var incidentType = await new IncidentTypeManagerUT().CreateDefaultAsync <IncidentType>(identityWorkId, instanceID); List <Incident> IncidentTypePeriodEmployeeRelationships = new List <Incident>() { new Incident() { ID = Guid.NewGuid(), Active = true, company = identityWorkId, Timestamp = DateTime.UtcNow, InstanceID = instanceID, Description = "2R", CreationDate = DateTime.Now, Name = "Dos horas retardo", StatusID = 1, IncidentTypeID = incidentType.FirstOrDefault(p => p.SalaryRight == salaryRight).ID, PeriodDetailID = periodDetailID, DeleteDate = null, Date = date, Value = 2, EmployeeID = employeeID } }; //Act var middlewareManager = new MiddlewareManager <Incident>(new BaseRecordManager <Incident>(), new IncidentValidator()); await middlewareManager.CreateAsync(IncidentTypePeriodEmployeeRelationships, identityWorkId); return(IncidentTypePeriodEmployeeRelationships as List <T>); }
public async Task Should_Fail_When_Period_Total_Days_Is_TooBig() { using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled); //Arrange var periodTypes = new List <PeriodType>(); var identityWorkId = Guid.NewGuid(); var periodType = PeriodTypeBuilder.Build(Guid.NewGuid(), identityWorkId, "name"); periodType.PeriodTotalDays = 366; periodTypes.Add(periodType); //Act var middlewareManager = new MiddlewareManager <PeriodType>(new BaseRecordManager <PeriodType>(), new PeriodTypeValidator()); try { await middlewareManager.CreateAsync(periodTypes, identityWorkId); } catch (CotorraException ex) { //Assert var res = ex.ValidationInfo; Assert.NotEmpty(res); Assert.Equal(9002, ex.ErrorCode); } }
public async Task Should_NotCreate_Employee_Duplicate_Name() { using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled); try { //Act Guid identityWorkId = Guid.NewGuid(); Guid instanceId = Guid.NewGuid(); var employees = await new EmployeeManagerUT().CreateDefaultAsync <Employee>(identityWorkId, instanceId, name: "Jimmy"); //Modify ToDuplicate employees.FirstOrDefault().ID = Guid.NewGuid(); employees.FirstOrDefault().Code = "2"; employees.FirstOrDefault().CURP = "asdasdas"; employees.FirstOrDefault().RFC = "AAA010102AAB"; var middlewareManager = new MiddlewareManager <Employee>(new BaseRecordManager <Employee>(), new EmployeeValidator()); await middlewareManager.CreateAsync(employees, identityWorkId); Assert.False(true, "No se permite Nombre duplicado"); } catch (Exception ex) { Assert.True(ex is CotorraException); Assert.True((ex as CotorraException).ErrorCode.Equals(4003)); } }
public async Task Should_Not_Create_Duplicate_DB_JobPosition_And_Get_ToValidate_Finally_do_Delete() { using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled); var middlewareManager = new MiddlewareManager <JobPosition>(new BaseRecordManager <JobPosition>(), new JobPositionValidator()); List <Guid> lstIds = new List <Guid>(); var identityWorkId = Guid.NewGuid(); try { //Arrange var JobPositions = new List <JobPosition>(); JobPositions.Add(new JobPosition() { ID = Guid.NewGuid(), Active = true, company = identityWorkId, Timestamp = DateTime.UtcNow, InstanceID = identityWorkId, Description = "Supervisor de ventas general", CreationDate = DateTime.Now, Name = "Supervisor de Ventas", StatusID = 1, }); lstIds.Add(JobPositions.FirstOrDefault().ID); //Act await middlewareManager.CreateAsync(JobPositions, identityWorkId); //Asserts //Get var result = await middlewareManager .GetByIdsAsync(JobPositions.Select(p => p.ID).ToList(), identityWorkId); Assert.True(result.Any()); //Act await middlewareManager.CreateAsync(JobPositions, identityWorkId); Assert.True(false, "No debió de pasar"); } catch (Exception ex) { Assert.True(ex is CotorraException); Assert.True((ex as CotorraException).ErrorCode.Equals(1002)); } }
public async Task SalaryAdjustment_Fail_PeriodClosed() { using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled); Guid identityWorkId = Guid.NewGuid(); Guid instanceID = Guid.NewGuid(); try { var employee = await new EmployeeManagerUT().CreateDefaultAsync <Employee>( identityWorkId, instanceID); var middlewareManagerPeriodDetail = new MiddlewareManager <PeriodDetail>(new BaseRecordManager <PeriodDetail>(), new PeriodDetailValidator()); var periodDetails = await middlewareManagerPeriodDetail.FindByExpressionAsync(p => p.InstanceID == instanceID, identityWorkId); var CotorriaPeriodDetail = periodDetails.FirstOrDefault(); CotorriaPeriodDetail.PeriodStatus = PeriodStatus.Authorized; await middlewareManagerPeriodDetail.UpdateAsync(new List <PeriodDetail> { CotorriaPeriodDetail }, identityWorkId); Guid sbcID = Guid.NewGuid(); var creationDate = DateTime.Now; EmployeeSBCAdjustment sbc = BuildEmployeeSBCAdjustment(sbcID, Guid.NewGuid(), identityWorkId, instanceID, creationDate, employee.FirstOrDefault().ID, 123.23M, 123.23M, 123.23M); EmployeeSalaryIncrease employeeSalaryIncrease = new EmployeeSalaryIncrease() { Active = true, company = identityWorkId, CreationDate = creationDate, DailySalary = 145.65M, DeleteDate = null, Description = "", EmployeeID = employee.FirstOrDefault().ID, ID = Guid.NewGuid(), user = Guid.NewGuid(), InstanceID = instanceID, ModificationDate = periodDetails.OrderBy(p => p.InitialDate).FirstOrDefault().InitialDate.AddDays(2), Name = "", StatusID = 1, Timestamp = DateTime.Now, EmployeeSBCAdjustment = sbc, EmployeeSBCAdjustmentID = sbc.ID }; var middlewareManager = new MiddlewareManager <EmployeeSalaryIncrease>(new BaseRecordManager <EmployeeSalaryIncrease>()); await middlewareManager.CreateAsync(new List <EmployeeSalaryIncrease>() { employeeSalaryIncrease }, identityWorkId); Assert.True(true, "No debió de pasar"); } catch (CotorraException ex) { Assert.True(ex.Code == "4005"); } catch { Assert.True(true, "No debió de pasar"); } }
public async Task <List <MinimunSalary> > CreateAsync(Guid identityWorkId, Guid instanceID) { var middlewareManager = new MiddlewareManager <MinimunSalary>(new BaseRecordManager <MinimunSalary>(), new MinimunSalaryValidator()); var lstMinimunSalary = new MemoryStorageContext().GetDefaultMinimunSalaries(identityWorkId, instanceID, Guid.NewGuid()); await middlewareManager.CreateAsync(lstMinimunSalary, identityWorkId); return(lstMinimunSalary); }
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceId) where T : BaseEntity { var MonthlyIncomeTaxs = new MemoryStorageContext().GetDefaultMonthlyEmploymentSubsidy(identityWorkId, instanceId, Guid.Empty); var middlewareManager = new MiddlewareManager <MonthlyEmploymentSubsidy>(new BaseRecordManager <MonthlyEmploymentSubsidy>(), new MonthlyEmploymentSubsidyValidator()); await middlewareManager.CreateAsync(MonthlyIncomeTaxs, identityWorkId); return(MonthlyIncomeTaxs as List <T>); }
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceId) where T : BaseEntity { var Areas = Build <T>(identityWorkId, instanceId) as List <Area>; var middlewareManager = new MiddlewareManager <Area>(new BaseRecordManager <Area>(), new AreaValidator()); await middlewareManager.CreateAsync(Areas, identityWorkId); return(Areas as List <T>); }
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceID, PaymentPeriodicity paymentPeriodicity) where T : BaseEntity { var periodTypes = new List <PeriodType>(); var namePeriodicity = Enum.GetName(typeof(PaymentPeriodicity), paymentPeriodicity); var periodTotalDays = 0; var paymentDays = 0; var paymentDayPosition = 0; bool monthCalendarFixed = true; if (paymentPeriodicity == PaymentPeriodicity.Biweekly) { periodTotalDays = 15; paymentDays = 15; paymentDayPosition = 15; monthCalendarFixed = true; } else if (paymentPeriodicity == PaymentPeriodicity.Monthly) { periodTotalDays = 30; paymentDays = 30; paymentDayPosition = 30; monthCalendarFixed = true; } else if (paymentPeriodicity == PaymentPeriodicity.Weekly) { periodTotalDays = 7; paymentDays = 7; paymentDayPosition = 7; monthCalendarFixed = false; } periodTypes.Add(new PeriodType() { ID = Guid.NewGuid(), Active = true, company = identityWorkId, Timestamp = DateTime.UtcNow, InstanceID = instanceID, Description = $"Periodo de pago {namePeriodicity}", CreationDate = DateTime.Now, Name = namePeriodicity, StatusID = 1, PaymentPeriodicity = paymentPeriodicity, PeriodTotalDays = periodTotalDays, PaymentDays = paymentDays, ExtraordinaryPeriod = false, MonthCalendarFixed = monthCalendarFixed, FortnightPaymentDays = AdjustmentPay_16Days_Febrary.PayCalendarDays, PaymentDayPosition = paymentDayPosition }); //Act var middlewareManager = new MiddlewareManager <PeriodType>(new BaseRecordManager <PeriodType>(), new PeriodTypeValidator()); await middlewareManager.CreateAsync(periodTypes, identityWorkId); return(periodTypes as List <T>); }
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceId) where T : BaseEntity { var umas = new MemoryStorageContext().GetdDefaultUMA(identityWorkId, instanceId, Guid.Empty); var middlewareManager = new MiddlewareManager <UMA>(new BaseRecordManager <UMA>(), new UMAValidator()); await middlewareManager.CreateAsync(umas, identityWorkId); return(umas as List <T>); }
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceId) where T : BaseEntity { var AnualIncomeTaxs = new MemoryStorageContext().GetDefaultAnualIncomeTax(identityWorkId, instanceId, Guid.Empty); var middlewareManager = new MiddlewareManager <AnualIncomeTax>(new BaseRecordManager <AnualIncomeTax>(), new AnualIncomeTaxValidator()); await middlewareManager.CreateAsync(AnualIncomeTaxs, identityWorkId); return(AnualIncomeTaxs as List <T>); }
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceID) { var IMSSWorkRiskTableLst = new List <IMSSWorkRisk>(); IMSSWorkRiskTableLst.AddRange(new MemoryStorageContext().GetDefaultIMSSWorkRisk(identityWorkId, instanceID, Guid.Empty)); var middlewareManager = new MiddlewareManager <IMSSWorkRisk>(new BaseRecordManager <IMSSWorkRisk>(), new IMSSWorkRiskValidator()); await middlewareManager.CreateAsync(IMSSWorkRiskTableLst, identityWorkId); return(IMSSWorkRiskTableLst as List <T>); }
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceID) { var SGDFLimitsLst = new List <SGDFLimits>(); SGDFLimitsLst.AddRange(new MemoryStorageContext().GetDefaultSGDFLimits(identityWorkId, instanceID, Guid.Empty)); var middlewareManager = new MiddlewareManager <SGDFLimits>(new BaseRecordManager <SGDFLimits>(), new SGDFLimitsValidator()); await middlewareManager.CreateAsync(SGDFLimitsLst, identityWorkId); return(SGDFLimitsLst as List <T>); }
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceID) { var settlementList = new List <SettlementCatalog>(); settlementList.AddRange(new MemoryStorageContext().GetDefaultSettlementCatalogTable(identityWorkId, instanceID, Guid.Empty)); var middlewareManager = new MiddlewareManager <SettlementCatalog>(new BaseRecordManager <SettlementCatalog>(), new SettlementCatalogValidator()); await middlewareManager.CreateAsync(settlementList, identityWorkId); return(settlementList as List <T>); }
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceId) where T : BaseEntity { var WorkCenters = new List <WorkCenter>(); WorkCenters.Add(BuildT <WorkCenter>(identityWorkId, instanceId)); var middlewareManager = new MiddlewareManager <WorkCenter>(new BaseRecordManager <WorkCenter>(), new WorkCenterValidator()); await middlewareManager.CreateAsync(WorkCenters, identityWorkId); return(WorkCenters as List <T>); }
public async Task <AreaDTO> Post(Guid instanceID, Guid userID, Guid identityWorkID, AreaValidator validator, IMapper mapper, AreaDTO AreaDTO) { Area dep = new Area(); mapper.Map(AreaDTO, dep); dep.InstanceID = instanceID; dep.CompanyID = identityWorkID; var mgr = new MiddlewareManager <Area>(new BaseRecordManager <Area>(), validator); await mgr.CreateAsync(new List <Area>() { dep }, identityWorkID); return(AreaDTO); }
public async Task <DepartmentDTO> Post(Guid instanceID, Guid userID, Guid identityWorkID, DepartmentValidator validator, IMapper mapper, DepartmentDTO departmentDTO) { Department dep = new Department(); mapper.Map(departmentDTO, dep); dep.InstanceID = instanceID; dep.CompanyID = identityWorkID; var mgr = new MiddlewareManager <Department>(new BaseRecordManager <Department>(), validator); await mgr.CreateAsync(new List <Department>() { dep }, identityWorkID); return(departmentDTO); }
public async Task ShouldFailWhen2ValuesAreBadSending2Objects() { using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled); //Arrange var Workshifts = new List <Workshift>(); var identityWorkId = Guid.NewGuid(); Workshifts.Add(new Workshift() { ID = Guid.NewGuid(), Active = true, company = identityWorkId, Timestamp = DateTime.UtcNow, InstanceID = Guid.NewGuid(), Description = "Turno mixto", CreationDate = DateTime.Now, Name = "", StatusID = 1, Hours = 49 }); Workshifts.Add(new Workshift() { ID = Guid.NewGuid(), Active = true, company = identityWorkId, Timestamp = DateTime.UtcNow, InstanceID = Guid.NewGuid(), Description = "Turno mixto", CreationDate = DateTime.Now, Name = "", StatusID = 1, Hours = 49 }); //Act var middlewareManager = new MiddlewareManager <Workshift>(new BaseRecordManager <Workshift>(), new WorkshiftValidator()); try { await middlewareManager.CreateAsync(Workshifts, identityWorkId); } catch (CotorraException ex) { var res = ex.ValidationInfo; Assert.NotEmpty(res); Assert.Equal(8001, ex.ErrorCode); } }
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceID) where T : BaseEntity { var permanentMovements = new List <PermanentMovement>(); List <ConceptPayment> conceptPayments = null; var employees = await(new EmployeeManagerUT().CreateDefaultAsync <Employee>(identityWorkId: identityWorkId, instanceID: instanceID, randomValues: true)); var middlewareConceptPaymentManager = new MiddlewareManager <ConceptPayment>(new BaseRecordManager <ConceptPayment>(), new ConceptPaymentValidator()); conceptPayments = await middlewareConceptPaymentManager.FindByExpressionAsync(p => p.InstanceID == instanceID, identityWorkId); if (!conceptPayments.Any()) { conceptPayments = await(new ConceptManagerUT().CreateDefaultSalaryPaymentConceptsAsync(identityWorkId, instanceID)); } permanentMovements.Add(new PermanentMovement() { AccumulatedAmount = 0, Active = true, Amount = 500, company = identityWorkId, ConceptPaymentID = conceptPayments.FirstOrDefault(p => p.ConceptType == ConceptType.SalaryPayment && p.Name == "Sueldo").ID, EmployeeID = employees.FirstOrDefault().ID, ControlNumber = 0, CreationDate = DateTime.UtcNow, DeleteDate = null, Description = "", ID = Guid.NewGuid(), InitialApplicationDate = DateTime.UtcNow, LimitAmount = 0, Name = "Movimiento permamente sueldito", PermanentMovementStatus = PermanentMovementStatus.Active, PermanentMovementType = PermanentMovementType.Amount, RegistryDate = DateTime.UtcNow, StatusID = 1, TimesApplied = 0, TimesToApply = 5, user = Guid.NewGuid(), InstanceID = instanceID, Timestamp = DateTime.UtcNow }); var middlewareManager = new MiddlewareManager <PermanentMovement>(new BaseRecordManager <PermanentMovement>(), new PermanentMovementValidator()); await middlewareManager.CreateAsync(permanentMovements, identityWorkId); return(permanentMovements as List <T>); }
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceId) where T : BaseEntity { var middlewareEmployeeManager = new MiddlewareManager <Employee>(new BaseRecordManager <Employee>(), new EmployeeValidator()); var employees = (await middlewareEmployeeManager.FindByExpressionAsync(p => p.Active && p.InstanceID == instanceId, identityWorkId)); if (!employees.Any()) { employees = (await new EmployeeManagerUT().CreateDefaultAsync <Employee>(identityWorkId: identityWorkId, instanceID: instanceId)); } var middlewareConceptManager = new MiddlewareManager <ConceptPayment>(new BaseRecordManager <ConceptPayment>(), new ConceptPaymentValidator()); var concepts = (await middlewareConceptManager.FindByExpressionAsync(p => p.Active && p.InstanceID == instanceId, identityWorkId)); if (!concepts.Any()) { concepts = (await new ConceptManagerUT().CreateDefaultSalaryPaymentConceptsAsync(identityWorkId, instanceId)); } var fonacotMovements = new List <FonacotMovement>(); fonacotMovements.Add(new FonacotMovement() { ID = Guid.NewGuid(), Active = true, company = identityWorkId, Timestamp = DateTime.UtcNow, InstanceID = instanceId, Description = "Departamento de nominas", CreationDate = DateTime.Now, Name = "Nominas", StatusID = 1, ConceptPaymentID = concepts.FirstOrDefault().ID, CreditNumber = "AA010101", DeleteDate = null, EmployeeID = employees.FirstOrDefault().ID, FonacotMovementStatus = FonacotMovementStatus.Active, Month = 1, Year = 2020, Observations = "Observations", RetentionType = RetentionType.FixedAmount, user = Guid.Empty, }); var middlewareManager = new MiddlewareManager <FonacotMovement>(new BaseRecordManager <FonacotMovement>(), new FonacotMovementValidator()); await middlewareManager.CreateAsync(fonacotMovements, identityWorkId); return(fonacotMovements as List <T>); }
public async Task <NOMSurveyReplyResult> CreateAsync(NOMSurveyReplyParams nOMSurveyReplyParams) { BeforeCreate(nOMSurveyReplyParams); var result = new NOMSurveyReplyResult(); using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled); var NOMSurveyReply = CreateDefault( nOMSurveyReplyParams.IdentityWorkId, nOMSurveyReplyParams.InstanceId, nOMSurveyReplyParams.EmployeeId, nOMSurveyReplyParams.NOMEvaluationPeriodId, nOMSurveyReplyParams.NOMEvaluationSurveyId); await SetAnswers(NOMSurveyReply); //middleware instance var middlewareManager = new MiddlewareManager <NOMSurveyReply>(new BaseRecordManager <NOMSurveyReply>(), new NOMSurveyReplyValidator()); //Get var resultPrevious = await middlewareManager.FindByExpressionAsync(p => p.EmployeeID == nOMSurveyReplyParams.EmployeeId && p.EvaluationState != EvaluationStateType.Answered && p.NOMEvaluationPeriod.ID == nOMSurveyReplyParams.NOMEvaluationPeriodId, nOMSurveyReplyParams.IdentityWorkId); //verify if exists pending surverreply for employee if (!resultPrevious.Any()) { //Create var lstToCreate = new List <NOMSurveyReply>(); lstToCreate.Add(NOMSurveyReply); await middlewareManager.CreateAsync(lstToCreate, nOMSurveyReplyParams.IdentityWorkId); } //Encrypt and encode de token var encrypted = StringCipher.Encrypt(NOMSurveyReply.ID.ToString()); var encryptedEncoded = HttpUtility.UrlEncode(encrypted); result.NOMSurveyReply = NOMSurveyReply; result.Token = encryptedEncoded; scope.Complete(); return(result); }
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceID) where T : BaseEntity { //Act Dependencies var accumulatedTypes = new MemoryStorageContext().GetDefaultAccumulatedType(identityWorkId, instanceID, Guid.NewGuid()); List <IncidentType> incidentTypes = new MemoryStorageContext().GetDefaultIncidentType(identityWorkId, instanceID, Guid.NewGuid(), accumulatedTypes); //AcumulatedTypes var middlewareManagerAccumulatedType = new MiddlewareManager <AccumulatedType>(new BaseRecordManager <AccumulatedType>(), new AccumulatedTypeValidator()); await middlewareManagerAccumulatedType.CreateAsync(accumulatedTypes, identityWorkId); //IncidentTypes var middlewareManagerIncidentType = new MiddlewareManager <IncidentType>(new BaseRecordManager <IncidentType>(), new IncidentTypeValidator()); await middlewareManagerIncidentType.CreateAsync(incidentTypes, identityWorkId); return(incidentTypes as List <T>); }