public async Task <JsonDefaultResponse> Handle(DeleteFavored request, CancellationToken cancellationToken)
{
try
{
var favoredToDelete = await _context.Favored
.Where(f => f.Id == request.Id && f.Status == Status.Active)
.SingleOrDefaultAsync();
if (favoredToDelete == null)
{
return new JsonDefaultResponse
{
Success = false,
Message = "Favorecido não encontrado."
}
}
;
var hasAccount = await _context.FavoredHasAccount
.Where(f => f.FavoredId == favoredToDelete.Id)
.SingleOrDefaultAsync();
if (hasAccount != null)
{
var accountToDelete = await _context.Account
.Where(a => a.Id == hasAccount.AccountId && a.Status == Status.Active)
.SingleOrDefaultAsync();
accountToDelete.Status = Status.Inactive;
//accountToDelete.updated_date = DateTime.Now; TODO: Validar a data de cancelamento
_context.Account.Update(accountToDelete);
}
favoredToDelete.Status = Status.Inactive;
//favoredToDelete.UpdatedDate = DateTime.Now; TODO: Validar a data de cancelamento
_context.Favored.Update(favoredToDelete);
await _context.SaveChangesAsync(cancellationToken);
return(new JsonDefaultResponse
{
Success = true,
Message = "Favorecido excluído com sucesso."
});
}
catch (Exception ex)
{
return(new JsonDefaultResponse
{
Success = false,
Message = "Houve um erro ao excluir o favorecido: " + ex.Message
});
}
}
public async Task <Unit> Handle(CreateAccount request, CancellationToken cancellationToken)
{
var entity = new Account
{
};
_context.Account.Add(entity);
await _context.SaveChangesAsync(cancellationToken);
await _mediator.Publish(new EntityCreated { Id = entity.Id }, cancellationToken);
return(Unit.Value);
}
public async Task <JsonDefaultResponse> Handle(CreateIncoming request, CancellationToken cancellationToken)
{
try
{
var userHasPerson = await _context.UserHasPerson
.Where(uhp => uhp.UserId == request.UserId)
.SingleOrDefaultAsync();
if (userHasPerson == null)
{
return new JsonDefaultResponse
{
Success = false,
Message = "Seu usuário não foi encontrado"
}
}
;
var incoming = new Incoming
{
PersonId = userHasPerson.PersonId,
IncomeType = request.IncomeType,
Name = request.Name,
Description = request.Description,
Value = request.Value,
Status = Status.Active,
ReceiveAt = request.ReceiveAt,
Recurrent = request.Recurrent
};
_context.Incoming.Add(incoming);
await _context.SaveChangesAsync(cancellationToken);
return(new JsonDefaultResponse
{
Success = true,
Message = "Renda cadastrada com sucesso!"
});
}
catch
{
return(new JsonDefaultResponse
{
Success = false,
Message = "Algo deu errado no servidor. Por favor, tente novamente mais tarde"
});
}
}
public async Task <JsonDefaultResponse> Handle(CancelToken request, CancellationToken cancellationToken)
{
try
{
var jwt = _context.LoginJwt
.Where(j => j.Id == request.Token)
.Where(j => j.Status == Status.Active)
.SingleOrDefault();
if (jwt == null)
{
return new JsonDefaultResponse
{
Success = false,
Message = "O token informado não existe ou já foi cancelado."
}
}
;
jwt.Status = Status.Inactive;
jwt.ExpireDate = DateTime.Now;
_context.LoginJwt.Add(jwt);
await _context.SaveChangesAsync(cancellationToken);
await _mediator.Publish(new TokenCanceled { Id = jwt.Id }, cancellationToken);
return(new JsonDefaultResponse
{
Success = true,
Message = "Token cancelado com sucesso."
});
}
catch (Exception ex)
{
return(new JsonDefaultResponse
{
Success = false,
Message = "Houve um erro ao cancelar o token: " + ex.Message
});
}
}
public async Task <JsonDefaultResponse> Handle(CreateAccount request, CancellationToken cancellationToken)
{
try
{
var existentUser = await _context.User
.Where(u => u.Username == request.Username)
.SingleOrDefaultAsync();
if (existentUser != null)
{
return new JsonDefaultResponse
{
Success = false,
Message = "Já existe um usuário cadastrado com esse nome de usuário."
}
}
;
}
catch
{
return(new JsonDefaultResponse
{
Success = false,
Message = "Houve um problema ao consultar os usuários existentes."
});
}
var user = new User
{
Username = request.Username,
Password = _cryptoHelper.Encrypt(request.Password),
Status = Status.Active
};
var person = new Person
{
FirstName = request.FirstName,
LastName = request.LastName,
Age = request.Age,
TaxNumber = request.TaxNumber,
Gender = request.Gender
};
var userHasPerson = new UserHasPerson
{
UserId = user.Id,
PersonId = person.Id
};
var contact = new Contact
{
PhoneNumber = request.PhoneNumber,
Email = request.PhoneNumber
};
var personHasContact = new PersonHasContact
{
PersonId = person.Id,
ContactId = contact.Id
};
var userImage = new UserImage
{
UserId = user.Id,
Path = request.ImagePath
};
try
{
_context.User.Add(user);
_context.Person.Add(person);
_context.UserHasPerson.Add(userHasPerson);
_context.Contact.Add(contact);
_context.PersonHasContact.Add(personHasContact);
await _context.SaveChangesAsync(cancellationToken);
}
catch
{
return(new JsonDefaultResponse
{
Success = false,
Message = "Houve um erro no servidor ao criar a sua conta"
});
}
return(new JsonDefaultResponse
{
Success = true,
Message = "Conta criada com sucesso."
});
}
public async Task <JsonDefaultResponse> Handle(SignIn request, CancellationToken cancellationToken)
{
var login = await _context.User
.Where(u => u.Username == request.Username)
.SingleOrDefaultAsync();
if (login == null)
{
return new JsonDefaultResponse
{
Success = false,
Message = Resx.Strings.LoginAndOrPasswordIncorrect
}
}
;
if (!cryptoHelper.IsValid(request.Password, login.Password))
{
return new JsonDefaultResponse
{
Success = false,
Message = Resx.Strings.PasswordInformedIsIncorrect
}
}
;
if (login.Status != Status.Active)
{
return new JsonDefaultResponse
{
Success = false,
Message = Resx.Strings.UserDoesntHaveAccessPermission
}
}
;
var loginToken = new LoginJwt
{
UserId = login.Id,
Validation = Guid.NewGuid().ToString(),
ExpireDate = DateTime.Now.AddDays(1),
LoginBy = LoginMode.App
};
Common.Helpers.JwtManager jwtManager = new Common.Helpers.JwtManager(Configuration);
string tokenJWT = jwtManager.GenerateToken(loginToken);
#region Saving JWT in the Database
var oldJWT = await _context.LoginJwt
.Where(j => j.UserId == loginToken.UserId && j.Status == Status.Active && j.ExpireDate > DateTime.Now)
.SingleOrDefaultAsync();
if (oldJWT != null)
{
oldJWT.Status = Status.Inactive;
oldJWT.UpdatedDate = DateTime.Now;
_context.Entry(oldJWT).State = EntityState.Modified;
await _context.SaveChangesAsync(cancellationToken);
}
string[] tokenSplitted = tokenJWT.Split('.');
var jwt = new Domain.Entities.LoginJwt
{
UserId = loginToken.UserId,
Header = tokenSplitted[0],
Payload = tokenSplitted[1],
Signature = tokenSplitted[2],
Status = Status.Active,
ExpireDate = loginToken.ExpireDate
};
try
{
_context.LoginJwt.Add(jwt);
await _context.SaveChangesAsync(cancellationToken);
}
catch
{
return(new JsonDefaultResponse
{
Success = false,
Message = Resx.Strings.ErrorSaveAuthToken
});
}
#endregion
await _mediator.Publish(new UserAuthenticated { Id = loginToken.UserId }, cancellationToken);
var person = await _context.UserHasPerson
.Where(uhp => uhp.UserId == login.Id)
.Select(uhp => uhp.Person)
.SingleOrDefaultAsync();
var contact = await _context.PersonHasContact
.Where(phc => phc.PersonId == person.Id)
.Select(phc => phc.Contact)
.SingleOrDefaultAsync();
return(new JsonDefaultResponse
{
Success = true,
Message = Resx.Strings.LoginAuthorized,
Payload = new UserAuth
{
JwtToken = tokenJWT,
User = new UserData
{
Id = login.Id,
Username = login.Username,
Name = person.FirstName,
LastName = person.LastName,
PhoneNumber = contact.PhoneNumber,
Email = contact.Email
}
}
});
}
}
}
public async Task <JsonDefaultResponse> Handle(SignUp request, CancellationToken cancellationToken)
{
try
{
var existentUser = await _context.User
.Where(u => u.Username == request.Username)
.SingleOrDefaultAsync();
if (existentUser != null)
{
return new JsonDefaultResponse
{
Success = false,
Message = Resx.Strings.ErrorUserAlreadyExists
}
}
;
}
catch (Exception ex)
{
return(new JsonDefaultResponse
{
Success = false,
Message = string.Format($"{Resx.Strings.ErrorSearchingForUsers}: {ex.Message}.")
});
}
var user = new User
{
Username = request.Username,
Password = _cryptoHelper.Encrypt(request.Password),
Status = Status.Active
};
var person = new Person
{
FirstName = request.FirstName,
LastName = request.LastName,
BirthDate = request.BirthDate,
TaxNumber = request.TaxNumber,
Gender = request.Gender
};
var userHasPerson = new UserHasPerson
{
UserId = user.Id,
PersonId = person.Id
};
var contact = new Contact
{
PhoneNumber = request.PhoneNumber,
Email = request.Email
};
var personHasContact = new PersonHasContact
{
PersonId = person.Id,
ContactId = contact.Id
};
var userImage = new UserImage
{
UserId = user.Id,
Path = request.ImagePath
};
try
{
_context.User.Add(user);
_context.Person.Add(person);
_context.UserHasPerson.Add(userHasPerson);
_context.Contact.Add(contact);
_context.PersonHasContact.Add(personHasContact);
await _context.SaveChangesAsync(cancellationToken);
}
catch (Exception ex)
{
return(new JsonDefaultResponse
{
Success = false,
Message = string.Format($"{Resx.Strings.ErrorCreatingAccount}: {ex.Message}.")
});
}
return(new JsonDefaultResponse
{
Success = true,
Message = Resx.Strings.SuccessAccountCreation
});
}
public async Task <JsonDefaultResponse> Handle(CreateFavored request, CancellationToken cancellationToken)
{
bool registerAuthorized = false;
try
{
var favoredAlreadyRegistered = await _context.Favored
.Where(f => f.TaxNumber == request.TaxNumber &&
f.Status == Status.Active &&
f.BelongsToUserId == request.BelongToUserId)
.ToListAsync();
if (favoredAlreadyRegistered.Count == 0)
{
registerAuthorized = true;
}
else
{
if (request.Account != null)
{
foreach (var favored in favoredAlreadyRegistered)
{
var favoredAccounts = await _context.FavoredHasAccount
.Where(fha => fha.FavoredId == favored.Id)
.Select(fha => fha.Account)
.ToListAsync();
if (favoredAccounts.Count > 0)
{
var favoredAccount = favoredAccounts
.Where(a => a.BankAccount == request.Account.BankAccount)
.SingleOrDefault();
if (favoredAccount != null)
{
return new JsonDefaultResponse
{
Success = false,
Message = "Já existe um favorecido cadastrado com essa conta no sistema"
}
}
;
}
}
registerAuthorized = true;
}
else
{
foreach (var favored in favoredAlreadyRegistered)
{
var favoredAccounts = await _context.FavoredHasAccount
.Where(fha => fha.FavoredId == favored.Id)
.Select(fha => fha.Account)
.ToListAsync();
if (favoredAccounts.Count > 0)
{
var favoredAccount = favoredAccounts
.Where(a => a.BankAccount == request.Account.BankAccount)
.SingleOrDefault();
if (favoredAccount == null)
{
return new JsonDefaultResponse
{
Success = false,
Message = "Um favorecido igual a esse sem conta cadastrada já foi registrado no sistema"
}
}
;
}
}
registerAuthorized = true;
}
}
}
catch (Exception ex)
{
return(new JsonDefaultResponse
{
Success = false,
Message = "Houve um problema em validar o favorecido antes de cadastrá-lo."
});
}
if (registerAuthorized)
{
var favored = new Favored
{
BelongsToUserId = request.BelongToUserId,
Name = request.Name,
TaxNumber = request.TaxNumber,
Status = Status.Active
};
if (request.Account.BankAccount != null)
{
var account = new Account
{
Bank = request.Account.BankAccount.Value,
BankBranch = request.Account.BankBranch.Value,
BankAccount = request.Account.BankAccount.Value,
BankAccountDigit = request.Account.BankAccountDigit.Value,
Status = Status.Active
};
var favored_has_account = new FavoredHasAccount
{
FavoredId = favored.Id,
AccountId = account.Id
};
try
{
_context.Account.Add(account);
_context.FavoredHasAccount.Add(favored_has_account);
}
catch (Exception ex)
{
return(new JsonDefaultResponse
{
Success = false,
Message = "Algo deu errado no servidor. Por favor, tente novamente mais tarde"
});
}
}
try
{
_context.Favored.Add(favored);
await _context.SaveChangesAsync(cancellationToken);
await _mediator.Publish(new FavoredCreated { Id = favored.Id }, cancellationToken);
}
catch (Exception ex)
{
return(new JsonDefaultResponse
{
Success = false,
Message = "Algo deu errado no servidor. Por favor, tente novamente mais tarde"
});
}
return(new JsonDefaultResponse
{
Success = true,
Message = "Favorecido cadastrado com sucesso!"
});
}
return(new JsonDefaultResponse
{
Success = false,
Message = "Erro na criação do favorecido. Por favor, revise os dados enviados e tente novamente"
});
}