public async Task UpdateAsync(Guid?processId, ProcessRequestTO processRequestTO)
{
var processEntity = await _processRepository.GetByIdWithIncludesAsync(processId.Value);
processEntity.UnifiedProcessNumber = processRequestTO.UnifiedProcessNumber;
processEntity.ClientPhysicalFolder = processRequestTO.ClientPhysicalFolder;
processEntity.DistributionDate = processRequestTO.DistributionDate;
processEntity.LinkedProcessId = processRequestTO.LinkedProcessId;
processEntity.JusticeSecret = processRequestTO.JusticeSecret;
processEntity.Description = processRequestTO.Description;
processEntity.SituationId = processRequestTO.SituationId;
processEntity.ProcessResponsible = new List <ProcessResponsibleEntity>();
foreach (var responsibleId in processRequestTO.Responsibles)
{
processEntity.ProcessResponsible.Add(new ProcessResponsibleEntity
{
ResponsibleId = responsibleId
});
}
processEntity.UpdateUserName = processRequestTO.UpdateUserName;
processEntity.Version = processEntity.Version + 1;
processEntity.UpdateDate = DateTime.Now;
await _processRepository.UpdateAsync(processEntity);
}
private async Task <List <ErrorsTO> > ValidateSituationId(ProcessRequestTO processRequestTO)
{
var errors = new List <ErrorsTO>();
var situationEntity = await _situationRepository.GetByIdAsync(processRequestTO.SituationId.Value);
if (situationEntity == null)
{
errors.Add(new ErrorsTO
{
Field = "SituationId",
Validation = Messaging.InvalidSituationId
});
}
else if (situationEntity.Finished != null && situationEntity.Finished.Value)
{
errors.Add(new ErrorsTO
{
Field = "SituationId",
Validation = Messaging.RegistrationCannotBeEdited
});
}
return(errors);
}
private async Task <List <ErrorsTO> > ValidateLinkedProcessId(ProcessRequestTO processRequestTO)
{
var errors = new List <ErrorsTO>();
var processSpecification = new BaseSpecification <ProcessEntity>();
processSpecification.AddCriteria(process => process.Id == processRequestTO.LinkedProcessId);
var processFather = (await _processRepository.ListAsync(processSpecification)).FirstOrDefault();
var cont = 0;
while (processFather != null && processFather.LinkedProcessId != null)
{
cont++;
processSpecification = new BaseSpecification <ProcessEntity>();
processSpecification.AddCriteria(process => process.Id == processRequestTO.LinkedProcessId);
processFather = (await _processRepository.ListAsync(processSpecification)).FirstOrDefault();
}
if (cont > 4)
{
errors.Add(new ErrorsTO
{
Field = "LinkedProcessId",
Validation = Messaging.ExceededLimitOfHierarchyLinkedProcessId
});
}
return(errors);
}
public async Task <ProcessResponseTO> AddAsync(ProcessRequestTO processRequestTO)
{
var processEntity = processRequestTO.ToProcessEntity();
processEntity.Version = 1;
processEntity.UpdateDate = DateTime.Now;
processEntity = await _processRepository.AddAsync(processEntity);
return(processEntity.ToProcessResponseTO());
}
public async Task ValidateUpdateAsync(Guid?processId, ProcessRequestTO processRequestTO)
{
var errors = new List <ErrorsTO>();
errors.AddRange(await RequiredProcessId(processId));
if (errors.Count == 0)
{
errors.AddRange(RequiredFields(processRequestTO));
}
if (errors.Count == 0)
{
errors.AddRange(FixedSizeFields(processRequestTO));
}
if (errors.Count == 0)
{
errors.AddRange(MaximumSizeFields(processRequestTO));
}
if (errors.Count == 0)
{
errors.AddRange(await ValidateDoubleUnifiedProcessNumber(processId, processRequestTO));
}
if (errors.Count == 0)
{
errors.AddRange(ValidateDistributionDate(processRequestTO));
}
if (errors.Count == 0)
{
errors.AddRange(await ValidateResponsibles(processRequestTO));
}
if (errors.Count == 0)
{
errors.AddRange(await ValidateSituationId(processRequestTO));
}
if (errors.Count == 0)
{
errors.AddRange(await ValidateLinkedProcessId(processRequestTO));
}
if (errors.Count > 0)
{
throw new ErrorsException(errors);
}
}
private List <ErrorsTO> FixedSizeFields(ProcessRequestTO processRequestTO)
{
var errors = new List <ErrorsTO>();
if (processRequestTO.UnifiedProcessNumber.Replace("-", string.Empty).Replace(".", string.Empty).Trim().Length != 20)
{
errors.Add(new ErrorsTO
{
Field = "UnifiedProcessNumber",
Validation = Messaging.FixedSizeUnifiedProcessNumber
});
}
return(errors);
}
private List <ErrorsTO> ValidateDistributionDate(ProcessRequestTO processRequestTO)
{
var errors = new List <ErrorsTO>();
if (processRequestTO.DistributionDate != null && processRequestTO.DistributionDate.Value.Date > DateTime.Now.Date)
{
errors.Add(new ErrorsTO
{
Field = "DistributionDate",
Validation = Messaging.DistributionDateGreaterThanTheCurrentDate
});
}
return(errors);
}
private async Task <List <ErrorsTO> > ExistsSituationId(ProcessRequestTO processRequestTO)
{
var errors = new List <ErrorsTO>();
var situationEntity = await _situationRepository.GetByIdAsync(processRequestTO.SituationId.Value);
if (situationEntity == null)
{
errors.Add(new ErrorsTO
{
Field = "SituationId",
Validation = Messaging.InvalidSituationId
});
}
return(errors);
}
private async Task <ProcessRequestTO> CreateProcess()
{
Guid?situationId = null;
if (!string.IsNullOrEmpty(Variable.SituationId))
{
var situationRepository = Repository.CatalogContext.Set <SituationEntity>();
situationId = ((await situationRepository.ToListAsync()).First(situation => situation.Name.Trim().ToUpper() == Variable.SituationId.Trim().ToUpper())).Id;
}
var responsibleRepository = Repository.CatalogContext.Set <ResponsibleEntity>();
ResponsibleEntity responsibleEntity = null;
if (!string.IsNullOrEmpty(Variable.ResponsiblesCpf) && !string.IsNullOrEmpty(Variable.ResponsiblesName) && !string.IsNullOrEmpty(Variable.ResponsiblesEMail) && !string.IsNullOrEmpty(Variable.Image))
{
responsibleEntity = (await responsibleRepository.AddAsync(new ResponsibleEntity
{
Cpf = Convert.ToInt64(Variable.ResponsiblesCpf.Replace(".", "").Replace("-", "")),
Name = Variable.ResponsiblesName,
Mail = Variable.ResponsiblesEMail,
Photograph = Variable.Image,
})).Entity;
}
var processRequestTO = new ProcessRequestTO
{
Description = Variable.Description,
UpdateUserName = "******",
DistributionDate = !string.IsNullOrEmpty(Variable.DistributionDate) ? (DateTime?)DateTime.ParseExact(Variable.DistributionDate, "yyyy-MM-dd", CultureInfo.CreateSpecificCulture("pt-BR")) : null,
JusticeSecret = !string.IsNullOrEmpty(Variable.JusticeSecret) ? (bool?)(Variable.JusticeSecret == "S" ? true : false) : null,
SituationId = situationId,
UnifiedProcessNumber = Variable.UnifiedProcessNumber,
ClientPhysicalFolder = Variable.ClientPhysicalFolder,
Responsibles = responsibleEntity != null ? new List <Guid?>
{
responsibleEntity.Id
} : null
};
await Repository.CatalogContext.SaveChangesAsync();
return(processRequestTO);
}
private List <ErrorsTO> RequiredFields(ProcessRequestTO processRequestTO)
{
var errors = new List <ErrorsTO>();
if (string.IsNullOrEmpty(processRequestTO.UnifiedProcessNumber))
{
errors.Add(new ErrorsTO
{
Field = "UnifiedProcessNumber",
Validation = Messaging.RequiredUnifiedProcessNumber
});
}
if (processRequestTO.JusticeSecret == null)
{
errors.Add(new ErrorsTO
{
Field = "JusticeSecret",
Validation = Messaging.RequiredJusticeSecret
});
}
if (processRequestTO.SituationId == null)
{
errors.Add(new ErrorsTO
{
Field = "SituationId",
Validation = Messaging.RequiredSituationId
});
}
if (processRequestTO.Responsibles == null || !processRequestTO.Responsibles.Any())
{
errors.Add(new ErrorsTO
{
Field = "Responsibles",
Validation = Messaging.RequiredResponsibles
});
}
return(errors);
}
public static ProcessEntity ToProcessEntity(this ProcessRequestTO processRequestTO)
{
if (processRequestTO == null)
{
return(null);
}
return(new ProcessEntity()
{
Description = processRequestTO.Description,
SituationId = processRequestTO.SituationId,
JusticeSecret = processRequestTO.JusticeSecret,
UpdateUserName = processRequestTO.UpdateUserName,
LinkedProcessId = processRequestTO.LinkedProcessId,
DistributionDate = processRequestTO.DistributionDate,
ClientPhysicalFolder = processRequestTO.ClientPhysicalFolder,
UnifiedProcessNumber = processRequestTO.UnifiedProcessNumber,
ProcessResponsible = ToProcessResponsibleEntity(processRequestTO.Responsibles)
});
}
public async Task <IActionResult> AddAsync([FromBody][Required] ProcessRequestTO processRequestTO)
{
ProcessResponseTO responseTO = null;
try
{
responseTO = await _processFacade.AddAsync(processRequestTO);
}
catch (ErrorsException ex)
{
return(BadRequest(ex.ErrorResponse));
}
catch (Exception ex)
{
_logger.LogError(ex, "AddAsync", new object[] { processRequestTO });
return(StatusCode((int)HttpStatusCode.InternalServerError, ErrorHelper.GenericError(ex)));
}
return(Created(nameof(AddAsync), responseTO));
}
private List <ErrorsTO> MaximumSizeFields(ProcessRequestTO processRequestTO)
{
var errors = new List <ErrorsTO>();
if (!string.IsNullOrEmpty(processRequestTO.ClientPhysicalFolder) && processRequestTO.ClientPhysicalFolder.Trim().Length > 50)
{
errors.Add(new ErrorsTO
{
Field = "ClientPhysicalFolder",
Validation = Messaging.MaximumSizeClientPhysicalFolder
});
}
if (!string.IsNullOrEmpty(processRequestTO.Description) && processRequestTO.Description.Trim().Length > 1000)
{
errors.Add(new ErrorsTO
{
Field = "Description",
Validation = Messaging.MaximumSizeDescription
});
}
return(errors);
}
private async Task <List <ErrorsTO> > ValidateResponsibles(ProcessRequestTO processRequestTO)
{
var errors = new List <ErrorsTO>();
foreach (var responsibleId in processRequestTO.Responsibles)
{
if ((await _responsibleRepository.GetByIdAsync(responsibleId.Value)) == null)
{
errors.Add(new ErrorsTO
{
Field = "Responsibles",
Validation = Messaging.InvalidResponsible
});
}
}
if (processRequestTO.Responsibles.Count > 3)
{
errors.Add(new ErrorsTO
{
Field = "Responsibles",
Validation = Messaging.ExceededLimitOfResponsible
});
}
if (processRequestTO.Responsibles.GroupBy(responsibleId => responsibleId).ToList().Count != processRequestTO.Responsibles.Count)
{
errors.Add(new ErrorsTO
{
Field = "Responsibles",
Validation = Messaging.DuplicateResponsible
});
}
return(errors);
}
public async Task <ProcessResponseTO> AddAsync(ProcessRequestTO processRequestTO)
{
await _processService.ValidateAddAsync(processRequestTO);
return(await _processService.AddAsync(processRequestTO));
}
public async Task UpdateAsync(Guid?processId, ProcessRequestTO processRequestTO)
{
await _processService.ValidateUpdateAsync(processId, processRequestTO);
await _processService.UpdateAsync(processId, processRequestTO);
}
private async Task <List <ErrorsTO> > ValidateDoubleUnifiedProcessNumber(Guid?processId, ProcessRequestTO processRequestTO)
{
var errors = new List <ErrorsTO>();
var processSpecification = new BaseSpecification <ProcessEntity>();
processSpecification.AddCriteria(processId, process => process.Id != processId);
processSpecification.AddCriteria(process => process.UnifiedProcessNumber.Replace("-", string.Empty).Replace(".", string.Empty) == processRequestTO.UnifiedProcessNumber.Replace("-", string.Empty).Replace(".", string.Empty));
var listProcess = await _processRepository.ListAsync(processSpecification);
if (listProcess.Any())
{
errors.Add(new ErrorsTO
{
Field = "UnifiedProcessNumber",
Validation = Messaging.DoubleUnifiedProcessNumber
});
}
return(errors);
}
public async Task <IActionResult> UpdateAsync([FromRoute(Name = "id")][Required] Guid?id, [FromBody][Required] ProcessRequestTO processRequestTO)
{
try
{
await _processFacade.UpdateAsync(id, processRequestTO);
}
catch (ErrorsException ex)
{
return(BadRequest(ex.ErrorResponse));
}
catch (Exception ex)
{
_logger.LogError(ex, "UpdateAsync", new object[] { id, processRequestTO });
return(StatusCode((int)HttpStatusCode.InternalServerError, ErrorHelper.GenericError(ex)));
}
return(Ok());
}
