public async Task <IResponseEnvelope <UserToken> > SearchByTokenAsync(string token)
{
//Recover user by token
var userToken = await userTokenRepository.SearchByTokenAsync(token);
// Verify if the token is valid
if (userToken == null || !userToken.IsValid)
{
return(ResponseEnvelope.CreateErrorResponseEnvelope <UserToken>(ValidationMessageHelper.CreateErrorMessage(ValidationMessages.UNAUTHORIZED_USER)));
}
// Get all tokens from the current user
var userTokens = await userTokenRepository.SearchTokensByLoginAsync(userToken.Email);
// Get the last token from the current user
var lastUserToken = userTokens.OrderByDescending(e => e.CreateDate).FirstOrDefault();
if (lastUserToken == null ||
lastUserToken.Token != token)
{
return(ResponseEnvelope.CreateErrorResponseEnvelope <UserToken>(ValidationMessageHelper.CreateErrorMessage(ValidationMessages.UNAUTHORIZED_USER)));
}
if (DateTime.Now.Subtract(lastUserToken.ModifyDate).TotalMinutes > 3)
{
return(ResponseEnvelope.CreateErrorResponseEnvelope <UserToken>(ValidationMessageHelper.CreateErrorMessage(ValidationMessages.INVALID_TOKEN)));
}
lastUserToken.ModifyDate = DateTime.Now;
await userTokenRepository.UpdateTokenAsync(lastUserToken);
return(ResponseEnvelope.CreateResponseEnvelope(userToken));
}
public async Task <IResponse> InsertAsync(UserSimpleQuery query)
{
// 1 - Valida se campos estão preenchidos
if (string.IsNullOrWhiteSpace(query.Name) && query.QueryType == 1)
{
return(Response
.CreateErrorResponse(ValidationMessageHelper
.Create(ValidationMessages.REQUIRED_FIELD_NAME)));
}
// 2 - Pesquisa a existência de pesquisa com o mesmo nome
var pesquisas = await queryRepository.SearchByUserAsync(query.UserId);
if (pesquisas.Where(e => e.Name == query.Name).Count() > 0)
{
return(Response
.CreateErrorResponse(ValidationMessageHelper
.Create(ValidationMessages.DUPLICATE_NAME_SEARCH)));
}
// 3 - Caso pesquisa seja automática, enfileira a indexação da pesquisa
//if (query.QueryType == 2) return Response.CreateResponse(await queryQueueRepository.InserirAsync(query));
// 4 - Salva as informações da pesquisa
var response = await queryRepository.InsertAsync(query);
return(Response.CreateResponse(response));
}
public async Task <IResponseEnvelope <UserToken> > AuthenticateAsync(string login, string senha)
{
if (login == null || senha == null)
{
return(ResponseEnvelope.CreateErrorResponseEnvelope <UserToken>(ValidationMessageHelper.CreateErrorMessage(ValidationMessages.MISSING_FIELDS)));
}
var userCredentials = await userTokenRepository.SearchAsync(login);
if (userCredentials == null || userCredentials.Password != securityHelper.SHA256(senha))
{
return(ResponseEnvelope.CreateErrorResponseEnvelope <UserToken>(ValidationMessageHelper.CreateErrorMessage(ValidationMessages.INVALID_LOGIN)));
}
var userToken = new UserToken
{
CreateDate = DateTime.Now,
ModifyDate = DateTime.Now,
IsValid = true,
UserId = userCredentials.Id,
Token = securityHelper.GenerateUniqueToken(),
Email = userCredentials.Email
};
await userTokenRepository.DeleteByEmailAsync(login);
await userTokenRepository.InsertToken(userToken);
return(ResponseEnvelope.CreateResponseEnvelope(userToken));
}
public ContactFormRequestModelValidator()
{
RuleFor(x => x.FirstName)
.NotEmpty().WithMessage(ValidationMessageHelper.ForNotEmpty(nameof(ContactFormRequestModel.FirstName)))
.MinimumLength(2).WithMessage("'{PropertyName}' must have a minimum of 2 charaters")
.MaximumLength(20).WithMessage("'{PropertyName}' must have a maximum of 20 charaters")
.Matches(_alphaNumericPattern).WithMessage("'{PropertyName}' must only contain alphanumeric charaters (a-z, A-Z, 0-9)");
RuleFor(x => x.LastName)
.NotEmpty().WithMessage(ValidationMessageHelper.ForNotEmpty(nameof(ContactFormRequestModel.LastName)))
.MinimumLength(2).WithMessage("'{PropertyName}' must have a minimum of 2 charaters")
.MaximumLength(20).WithMessage("'{PropertyName}' must have a maximum of 20 charaters")
.Matches(_alphaNumericPattern).WithMessage("'{PropertyName}' must only contain alphanumeric charaters (a-z, A-Z, 0-9)");
RuleFor(x => x.Email)
.NotEmpty().WithMessage(ValidationMessageHelper.ForNotEmpty(nameof(ContactFormRequestModel.Email)))
.MaximumLength(320).WithMessage("'{PropertyName}' must have a maximum of 320 charaters")
.Matches(_emailPattern).WithMessage("'{PropertyName}' must only contain a valid email pattern");
RuleFor(x => x.Subject)
.NotEmpty().WithMessage(ValidationMessageHelper.ForNotEmpty(nameof(ContactFormRequestModel.Subject)))
.MinimumLength(2).WithMessage("'{PropertyName}' must have a minimum of 2 charaters")
.MaximumLength(100).WithMessage("'{PropertyName}' must have a maximum of 100 charaters")
.Matches(_alphaNumericWithSpecialCharPattern).WithMessage("'{PropertyName}' must only contain alphanumeric charaters and a limited set of special charaters");
RuleFor(x => x.Message)
.NotEmpty().WithMessage(ValidationMessageHelper.ForNotEmpty(nameof(ContactFormRequestModel.Message)))
.MinimumLength(10).WithMessage("'{PropertyName}' must have a minimum of 2 charaters")
.MaximumLength(1000).WithMessage("'{PropertyName}' must have a maximum of 20 charaters")
.Matches(_alphaNumericWithSpecialCharPattern).WithMessage("'{PropertyName}' must only contain alphanumeric charaters and a limited set of special charaters");
}
public override void OnException(HttpActionExecutedContext actionExecutedContext)
{
var exception = actionExecutedContext.Exception;
var message = string.Format(ValidationMessages.GENERIC_ERROR, exception.ToString());
var response = ResponseEnvelope
.CreateErrorResponseEnvelope(ValidationMessageHelper
.Create(message));
actionExecutedContext.Response = actionExecutedContext.Request.CreateResponse(System.Net.HttpStatusCode.InternalServerError, response);
}
public async Task <IResponse> DeleteAsync(UserSimpleQuery query)
{
var userQuery = await queryRepository.SearchByUserAsync(query.UserId);
if (!userQuery.Any(e => e.QueryId == query.QueryId))
{
return(Response.CreateErrorResponse(ValidationMessageHelper.Create(ValidationMessages.QUERY_NOT_FOUND)));
}
await queryRepository.DeleteAsync(query.QueryId);
return(Response.CreateResponse());
}
public async Task <IResponseEnvelope> InvalidateToken(string token)
{
var userToken = await userTokenRepository.SearchByTokenAsync(token);
if (userToken == null || !userToken.IsValid)
{
return(ResponseEnvelope.CreateErrorResponseEnvelope <UserToken>(ValidationMessageHelper.CreateErrorMessage(ValidationMessages.INVALID_TOKEN)));
}
userToken.IsValid = false;
userToken.ModifyDate = DateTime.Now;
await userTokenRepository.UpdateTokenAsync(userToken);
return(ResponseEnvelope.CreateResponseEnvelope());
}
public async Task <IResponseEnvelope> InsertAsync(User user)
{
//Verify if already exists
var u = await userRepository.SearchByEmailAsync(user.Email);
if (u != null)
{
return(ResponseEnvelope.CreateErrorResponseEnvelope(ValidationMessageHelper.Create(ValidationMessages.EMAIL_EXISTS)));
}
if (!IsUserFieldsValid(user))
{
return(ResponseEnvelope.CreateErrorResponseEnvelope(ValidationMessageHelper.Create(ValidationMessages.INVALID_FIELDS)));
}
;
if (!IsUserFieldsFilled(user))
{
return(ResponseEnvelope.CreateErrorResponseEnvelope(ValidationMessageHelper.Create(ValidationMessages.MISSING_FIELDS)));
}
user.Password = securityHelper.SHA256(user.Password);
await userRepository.InsertAsync(user);
return(ResponseEnvelope.CreateResponseEnvelope());
}
public LocationDetailsRequestModelValidator()
{
RuleFor(x => x.Lat)
.NotNull().WithMessage(ValidationMessageHelper.ForNotNull(nameof(LocationDetailsRequestModel.Lat)));
RuleFor(x => x.Lng)
.NotNull().WithMessage(ValidationMessageHelper.ForNotNull(nameof(LocationDetailsRequestModel.Lng)));
RuleFor(x => x.Address)
.NotNull().WithMessage(ValidationMessageHelper.ForNotNull(nameof(LocationDetailsRequestModel.Address)));
RuleFor(x => x.Address.LineOne)
.NotEmpty().WithMessage(ValidationMessageHelper.ForNotEmpty(nameof(LocationDetailsRequestModel.Address.LineOne)))
.MinimumLength(2).WithMessage("'{PropertyName}' must have a minimum of 2 charaters")
.MaximumLength(100).WithMessage("'{PropertyName}' must have a maximum of 100 charaters")
.Matches("[a-zA-Z0-9_.+-]").WithMessage("'{ PropertyName}' must only contain alphanumeric charaters (a-z, A-Z, 0-9)");
RuleFor(x => x.Address.Country)
.NotEmpty().WithMessage(ValidationMessageHelper.ForNotEmpty(nameof(LocationDetailsRequestModel.Address.Country)));
RuleFor(x => x.AssignedGamesList)
.NotNull().WithMessage(ValidationMessageHelper.ForNotNull(nameof(LocationDetailsRequestModel.AssignedGamesList)));
}
