protected void Validate(string name, string email, string password, Department department, UserAccess userAccess)
{
DomainValidation.When(string.IsNullOrEmpty(name), "Nome é obrigatório.");
DomainValidation.When(string.IsNullOrEmpty(email), "E-mail é obrigatório.");
DomainValidation.When(string.IsNullOrEmpty(password), "Deve criar uma senha.");
DomainValidation.When(department is null, "Selecione um departamento.");
}
/// <summary>
/// Safe Loading
/// Check Beneficiary before load Depositor
/// </summary>
/// <returns>Transfer</returns>
private async Task <Domain.Models.Transfer> LoadAsync(TransferCommand cmd, DomainValidation vld)
{
var transfer = new Domain.Models.Transfer()
{
Amount = cmd.Amount,
};
var beneficiary = await _accountRepo.GetAsync(
agency : cmd.Beneficiary.Agency,
accountNumber : cmd.Beneficiary.AccountNumber);
vld = beneficiary.IsValidForReceiveAmount(cmd.Amount);
if (!vld.IsSuccess)
{
return(null);
}
transfer.SetBeneficiary(beneficiary);
var depositor = await _accountRepo.GetAsync(
agency : cmd.Depositor.Agency,
accountNumber : cmd.Depositor.AccountNumber);
vld = depositor.IsValidForMakeDeposit(cmd.Amount);
if (!vld.IsSuccess)
{
return(null);
}
transfer.SetDepositor(depositor);
return(transfer);
}
public void Validate(int userId, int tabulationId, string ip, string formJson)
{
DomainValidation.When(userId == 0, "Usuário deve estar logado para prosseguir");
DomainValidation.When(tabulationId == 0, "Identificador da tabulação é obrigatório");
DomainValidation.When(string.IsNullOrEmpty(ip), "Não foi possível rastrear seu endereço virtual, contato o suporte");
DomainValidation.When(string.IsNullOrEmpty(formJson), "Formulário deve ser preenchido, se o problema persistir contate o suporte");
}
public static void Add(DomainValidation newDomainValidation)
{
if (HttpContext.Current.Items["DomainValidation"] == null)
{
HttpContext.Current.Items["DomainValidation"] = new List <DomainValidation>();
}
(HttpContext.Current.Items as List <DomainValidation>).Add(newDomainValidation);
}
public Tarefa(double progresso, double horasDeEsforco)
{
DomainValidation.Validar(() => progresso > 100, "progresso excedente 100%");
DomainValidation.Validar(() => progresso < 0, "Seu progresso tem que ser positivo");
DomainValidation.Validar(() => horasDeEsforco < 0, "Suas horas de esforço não devem ser menores que 0");
Progresso = progresso;
HorasDeEsforco = horasDeEsforco;
}
public static void Add(DomainValidation newDomainValidation)
{
if (HttpContext.Current.Items["DomainValidation"] == null)
{
HttpContext.Current.Items["DomainValidation"] = new List<DomainValidation>();
}
(HttpContext.Current.Items as List<DomainValidation>).Add(newDomainValidation);
}
private void ValidationDomain(string name, DateTime birthDate, string cpf)
{
DomainValidation.When(string.IsNullOrEmpty(name),
"Nome é necessario.");
DomainValidation.When(string.IsNullOrEmpty(cpf),
"CPF é necessario.");
Name = name;
BirthDate = birthDate;
Cpf = cpf;
}
public void Progredir(
double progresso,
double horasDeEsforco)
{
DomainValidation.Validar(() => Progresso == 100, "Tarefa ja foi concluida");
DomainValidation.Validar(() => progresso + Progresso > 100, "progresso excedente 100%");
DomainValidation.Validar(() => progresso < 0, "Seu progresso tem que ser positivo");
DomainValidation.Validar(() => horasDeEsforco < 0, "Suas horas de esforço não devem ser menores que 0");
Progresso += progresso;
HorasDeEsforco += horasDeEsforco;
}
private void ValidateDomain(string name, string crm, string crmUf)
{
DomainValidation.When(string.IsNullOrEmpty(name),
"Nome é necessario.");
DomainValidation.When(string.IsNullOrEmpty(crm),
"CRM é necessario.");
DomainValidation.When(string.IsNullOrEmpty(crmUf),
"CRMUF é necessario.");
Name = name;
Crm = crm;
CrmUf = crmUf;
}
public IActionResult Delete(int id)
{
try
{
var user = userRepo.GetById(id);
DomainValidation.When(user == null, "User not found.");
return(View((UserLightModel)user));
}
catch (Exception e)
{
SetMessage(e.Message, MsgType.Error); return(RedirectToAction("Index"));
}
}
public IActionResult Delete(UserLightModel form)
{
try
{
var user = userRepo.GetById(form.Id);
DomainValidation.When(user == null, "User not found.");
SetMessage(Messenger.SoftExclude(userRepo.SoftExclude(user)), MsgType.Success);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
SetMessage(e.Message, MsgType.Error); return(RedirectToAction("Index"));
}
}
public IActionResult Delete(DepartmentModel form)
{
try
{
var dept = deptRepo.GetById(form.Id);
DomainValidation.When(dept == null, "Dept not found.");
deptRepo.SoftExclude(dept);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
ViewData["Error"] = e.Message;
return(RedirectToAction("Index"));
}
}
public IActionResult Edit(int id)
{
try
{
var user = userRepo.GetQueriable().Include(x => x.Department)
.Where(x => x.Id == id).SingleOrDefault();
DomainValidation.When(user == null, "User not found.");
ViewBag.Departments = GetDropDown(deptRepo.List()
.Where(x => x.Name != "Root").ToList(), "Name", "Id");
return(View((UserModel)user));
}
catch (Exception e)
{
SetMessage(e.Message, MsgType.Error); return(RedirectToAction("Index"));
}
}
public IActionResult Delete(int id)
{
try
{
var dept = deptRepo.GetById(id);
DomainValidation.When(dept == null, "Dept not found.");
return(View(new DepartmentModel
{
Id = dept.Id,
Name = dept.Name,
Description = dept.Description,
}));
}
catch (Exception e)
{
ViewData["Error"] = e.Message;
return(RedirectToAction("Index"));
}
}
public async Task <TrasnferCompletedResponse> Handle(TransferCommand cmd, CancellationToken cancelToken)
{
var response = new TrasnferCompletedResponse()
{
Status = false
};
ValidationResult validation = Validate(cmd);
if (!validation.IsValid)
{
response.Error(validation.Errors.First().ErrorMessage);
return(response);
}
DomainValidation dValidation = DomainValidation.Success;
var transfer = await LoadAsync(cmd, dValidation);
if (!dValidation.IsSuccess)
{
response.Error(dValidation.Message);
return(response);
}
if (transfer != null)
{
transfer.Apply();
SetUnitOfWork(transfer);
await _unitOfWork.SaveChangesAsync();
SetResponse(response, transfer);
return(response);
}
return(response);
}
/// <summary>
/// Adiciona um erro de validação de domínio.
/// </summary>
/// <param name="validation">Dados da validação de domínio.</param>
public void AddValidationError(DomainValidation validation)
{
_validations.Add(validation);
}
private static MonthBudgetResponse MapUserBudgetToResponse(UserBudget currentMonth, bool defaultTemplate, DomainValidation validation = null)
{
return(new MonthBudgetResponse
{
IsProposedBudget = defaultTemplate,
Budget = new Responses.BudgetDto
{
UserId = currentMonth.UserId,
Amount = currentMonth.Amount,
Currency = currentMonth.CurrencySign,
Year = currentMonth.EndDate.Year,
Name = currentMonth.StartDate.MonthName(),
StartDate = currentMonth.StartDate,
EndDate = currentMonth.EndDate,
BudgetCategory = MapBudgetCategories(currentMonth)
},
ValidationMessage = validation?.ValidationErrorMessage
});
}
private void Validate(string name)
{
DomainValidation.When(string.IsNullOrEmpty(name), "Defina um nome ao novo departamento");
}
public void FinalizarDia()
{
hoje.FimDoDia(date: DateTime.Now);
DomainValidation.Validar(() => hoje.HorasTrabalhadas <= 0, "Algo deu errado no seu apontamento");
historico.Add(hoje);
}
public void NovoDiaDeTrabalho()
{
DomainValidation.Validar(() => PossuiPendencia(), "Você não pode começar um novo dia até ajustar suas dependências");
hoje = new DiaDeTrabalho(date: DateTime.Now);
}
private void Validate(string name, string code)
{
DomainValidation.When(string.IsNullOrEmpty(name), "Nome é obrigatório");
DomainValidation.When(string.IsNullOrEmpty(code), "Identificador é obrigatório");
}
private void Validate(int tabulationId, int formId)
{
DomainValidation.When(tabulationId == 0, "Selecione uma tabulação para criar o formulário");
DomainValidation.When(formId == 0, "Selecione o atributo que deseja adicionar no formulário");
}
private void Validate(Form form, string name, string title)
{
DomainValidation.When(string.IsNullOrEmpty(name), "Defina um nome para seu atributo");
DomainValidation.When(string.IsNullOrEmpty(title), "Titulo de exibição é obrigatorio");
DomainValidation.When(form is null, "É necessário vincular um formulário");
}
private void Validate(string name)
{
DomainValidation.When(string.IsNullOrEmpty(name), "Defina um nome ao tabulação");
}
private void Validate(int departmentId, int tabulationId)
{
DomainValidation.When(departmentId == 0, "Selecione um departamento");
DomainValidation.When(tabulationId == 0, "Selecione uma tabulação");
}
