public async Task <ActionResult <Response> > CreateCategory(CategoryModel model)
{
var category = model.ToEntity();
if (category.Invalid)
{
return(BadRequest(ResponseHelper.CreateResponse("Informações inválidas para criar uma categoria", category.Notifications)));
}
if (await _repository.CategoryExist(category))
{
return(UnprocessableEntity(
ResponseHelper
.CreateResponse("Categoria já cadastrada", model)));
}
_repository.Add(category);
model = (CategoryModel)category;
return(CreatedAtAction(
nameof(GetCategoryById),
new { id = category.Id },
ResponseHelper.CreateResponse("Categoria cadastrada com sucesso", model)));
}
public async Task <ActionResult <Response> > CreateState(StateModel model)
{
var country = await _countryRepository.GetCountryById(model.CountryId, include : false);
if (country == null)
{
return(NotFound(ResponseHelper.CreateResponse("Pais não encontrado")));
}
var state = model.ToEntity(country);
if (state.Invalid)
{
return(BadRequest(ResponseHelper.CreateResponse("Informações inválidas para cadastrar um estado", model)));
}
if (await _stateRepository.StateExist(state))
{
return(BadRequest(ResponseHelper.CreateResponse("Esse estado já foi cadastrado", model)));
}
_stateRepository.Add(state);
return(Ok(ResponseHelper.CreateResponse("Estado cadastrado com sucesso!", (StateModel)state)));
}
public async Task <ActionResult <Response> > CreateAuthor(AuthorModel model)
{
var author = model.ToEntity();
if (author.Invalid)
{
return(BadRequest(
ResponseHelper
.CreateResponse("Informações inválidas para criar um autor", author.Notifications)
));
}
if (await _repository.AuthorExist(author))
{
return(UnprocessableEntity(
ResponseHelper
.CreateResponse("Email já cadastrado", model)));
}
await _repository.Add(author);
return(CreatedAtAction(
nameof(GetAuthorById),
new { id = author.Id },
ResponseHelper.CreateResponse("Autor cadastrado com sucesso", AuthorModel.ToModel(author))));
}
public ActionResult <Response <Juros> > GetTaxaJuros()
{
try
{
_loggingService.LogInfo($"Retornando taxa de juros valor { new { taxaJuros = _taxaJuros } }.");
var conteudo = new Juros
{
Taxa = _taxaJuros
};
var response = ResponseHelper.CreateResponse("Taxa de Juros recuperada com sucesso.", HttpStatusCode.OK, new List <Error>(), conteudo);
return(Ok(response));
}
catch (Exception ex)
{
_loggingService.LogError($"Exceção ocorreu. {ex.Message}", ex);
var response = ResponseHelper.CreateResponse("Algo inesperado ocorreu. Por favor cheque a lista de erros.", HttpStatusCode.InternalServerError, new List <Error> {
new Error {
Mensagem = ex.Message
}
});
return(StatusCode(500, response));
}
}
public async Task <ActionResult <Response> > CreateBook(BookModel model)
{
var(category, author) = await _repository.GetCategoryAndAuthor(model.AuthorId, model.CategoryId);
if (category == null || author == null)
{
return(NotFound(
ResponseHelper
.CreateResponse("Author ou categoria não foram encontrados", model)
));
}
var book = model.ToEntity(category, author);
if (book.Invalid)
{
return(BadRequest(
ResponseHelper
.CreateResponse("Informações inválidas para criar um livro", book.Notifications)
));
}
if (await _repository.BookExist(book))
{
return(BadRequest(
ResponseHelper
.CreateResponse("O livro já existe", book.Notifications)
));
}
_repository.Add(book);
return(Ok(ResponseHelper.CreateResponse("Livro cadastrado com sucesso", (BookModel)book)));
}
public async Task <ActionResult <Response> > GetAll()
{
var books = await _repository.GetAll();
var booksReturn = books?.Select(b => (BookModel)b).ToList();
return(Ok(ResponseHelper.CreateResponse("Todos os livros encontrados", booksReturn)));
}
public async Task <ActionResult <Response> > GetAuthorById(Guid id)
{
var author = await _repository.GetById(id);
if (author == null)
{
return(NotFound(new { message = "Author não encontrado" }));
}
return(Ok(ResponseHelper.CreateResponse("Usuário encontrado", AuthorModel.ToModel(author))));
}
public async Task <IActionResult> AlertRead(int idAlert)
{
AlertRead.AlertReadRequest request = new AlertRead.AlertReadRequest()
{
IdAlert = idAlert,
IdEmployee = userInfoAccesor.IdUser
};
return(ResponseHelper.CreateResponse(await Mediator.Send(request).ConfigureAwait(false)));
}
public async Task <ActionResult <Response> > Checkout(CheckoutModel model)
{
var output = await _handler.Handle(model);
if (!output.Sucess)
{
return(BadRequest(ResponseHelper.CreateResponse(output.Message, output.Notifications)));
}
return(CreatedAtAction(nameof(GetOrderById), new { id = ((Order)output.Data).Id }, "Pedido realizado com sucesso"));
}
public async Task <ActionResult <Response> > GetBookById(Guid id)
{
var book = await _repository.GetBookById(id);
if (book == null)
{
return(NotFound(ResponseHelper.CreateResponse("Livro não encontrado")));
}
return(Ok(ResponseHelper.CreateResponse("Livro encontrado", (BookModel)book)));
}
public async Task <ActionResult <Response> > GetCountryById(Guid id, bool includestates)
{
var country = await _countryRepository.GetCountryById(id, include : includestates);
if (country == null)
{
return(NotFound(ResponseHelper.CreateResponse("Pais não encontrado")));
}
return(Ok(ResponseHelper.CreateResponse("Pais encontrado com sucesso", (CountryModel)country)));
}
public ApiResponse <List <User> > GetUsers()
{
var users = _unitOfWork.UserRepository.GetAll().ToList();
if (users != null)
{
return(ResponseHelper.CreateResponse(users, language.Success, 1, false));
}
else
{
return(ResponseHelper.CreateResponse <List <User> >(null, language.WrongInput, 2, true));
}
}
public HttpResponseMessage UpdateGeoTargets(string campaignId, UpdateGeoTargetsRequest updateGeoTargetsRequest)
{
try
{
CampaignControllerPut put = new CampaignControllerPut();
UpdateGeoTargetsResponse updatedTargets = put.UpdateCampaignGeoTargets(campaignId, updateGeoTargetsRequest);
return(ResponseHelper.CreateResponse(Request, HttpStatusCode.OK, updatedTargets, PublicApiCommonErrorCode.SUCCESS));
}
catch (Exception e)
{
return(ResponseHelper.CreateResponse(Request, HttpStatusCode.NotFound, e.Message + " " + e.InnerException + " " + e.StackTrace, PublicApiCommonErrorCode.NOT_FOUND));
}
}
public HttpResponseMessage GetAdwordsCampaigns()
{
try
{
CampaignControllerGet get = new CampaignControllerGet();
List <AdwordsCampaign> retrievedCampaigns = get.GetCampaigns();
return(ResponseHelper.CreateResponse(Request, HttpStatusCode.OK, retrievedCampaigns, PublicApiCommonErrorCode.SUCCESS));
}
catch (Exception e)
{
return(ResponseHelper.CreateResponse(Request, HttpStatusCode.NotFound, e.Message, PublicApiCommonErrorCode.NOT_FOUND));
}
}
public HttpResponseMessage GetCampaignGeoTargets(string campaignId)
{
try
{
CampaignControllerGet get = new CampaignControllerGet();
List <GeoTarget> retrievedLocations = get.GetCampaignGeoTargets(campaignId);
return(ResponseHelper.CreateResponse(Request, HttpStatusCode.OK, retrievedLocations, PublicApiCommonErrorCode.SUCCESS));
}
catch (Exception e)
{
return(ResponseHelper.CreateResponse(Request, HttpStatusCode.NotFound, e.Message + " " + e.InnerException + " " + e.StackTrace, PublicApiCommonErrorCode.NOT_FOUND));
}
}
public HttpResponseMessage GetStationCounts(string city, string state)
{
try
{
ChargingStationsGet get = new ChargingStationsGet();
StationCounts retrievedCounts = get.GetStationCounts(city, state);
return(ResponseHelper.CreateResponse(Request, HttpStatusCode.OK, retrievedCounts, PublicApiCommonErrorCode.SUCCESS));
}
catch (Exception e)
{
return(ResponseHelper.CreateResponse(Request, HttpStatusCode.NotFound, e.Message, PublicApiCommonErrorCode.NOT_FOUND));
}
}
public async Task <ActionResult <Response> > Get()
{
var countries = await _countryRepository.Get(include : true);
if (countries == null)
{
return(NotFound(ResponseHelper.CreateResponse("Nenhum país encontrado")));
}
var countriesResult = countries.Select(c => (CountryModel)c).ToList();
return(Ok(ResponseHelper.CreateResponse("Paises encontrados", countriesResult)));
}
public ApiResponse <User> GetUser(string id)
{
if (id.Equals("") || id == null)
{
return(ResponseHelper.CreateResponse <User>(null, language.SetArguments("ID").WrongInput, 2, true));
}
var user = _unitOfWork.UserRepository.Get(id);
if (user != null)
{
return(ResponseHelper.CreateResponse(user, language.Success, 1, false));
}
else
{
return(ResponseHelper.CreateResponse <User>(null, language.Failled, 2, true));
}
}
public async Task <ActionResult <Response <Juros> > > CalculaJuros([FromQuery] decimal valorInicial, [FromQuery] int meses)
{
try
{
if (valorInicial == default && meses == default)
{
var erros = new List <Error>
{
new Error {
Mensagem = $"Valor inicial não pode ser zero. { new { valorInicial } }"
},
new Error {
Mensagem = $"Quantidade de meses não pode ser zero. { new { meses } }"
}
};
_loggingService.LogInfo($"Parâmetros inválidos { new { valorInicial, meses } }.");
return(BadRequest(ResponseHelper.CreateResponse("Parâmetros inválidos.", HttpStatusCode.BadRequest, erros)));
}
_loggingService.LogInfo($"Calculando juros para { new { valorInicial, meses } }");
var conteudo = new Investimento
{
ValorInicial = valorInicial,
ValorFinal = await _jurosService.CalculaJurosAsync(valorInicial, meses)
};
var response = ResponseHelper.CreateResponse("Cálculo de Juros realizado com sucesso.", HttpStatusCode.OK, new List <Error>(), conteudo);
return(Ok(response));
}
catch (Exception ex)
{
_loggingService.LogError($"Exceção ocorreu. {ex.Message}", ex);
var response = ResponseHelper.CreateResponse("Algo inesperado ocorreu. Por favor cheque a lista de erros.", HttpStatusCode.InternalServerError, new List <Error> {
new Error {
Mensagem = ex.Message
}
});
return(StatusCode(500, response));
}
}
public async Task <ActionResult <Response> > CreateCountry(CountryModel model)
{
var country = model.ToEntity();
if (country.Invalid)
{
return(BadRequest(ResponseHelper.CreateResponse("Informações inválidas para cadastrar um país", model)));
}
if (await _countryRepository.CountryExist(country))
{
return(BadRequest(ResponseHelper.CreateResponse("Esse país já foi cadastrado", model)));
}
_countryRepository.Add(country);
return(Ok(ResponseHelper.CreateResponse("País cadastrado com sucesso!", (CountryModel)country)));
}
public ActionResult <Response> CreateCoupon(CouponModel model)
{
var newCoupon = (Coupon)model;
if (newCoupon.Invalid)
{
return(BadRequest(ResponseHelper.CreateResponse("Cupom inválido", newCoupon.Notifications)));
}
if (_couponRepository.Exist(newCoupon))
{
return(BadRequest(ResponseHelper.CreateResponse("Este cupom ja está cadastrado", newCoupon.Code)));
}
_couponRepository.Add(newCoupon);
return(Ok(ResponseHelper.CreateResponse("Cupon criado com sucesso", newCoupon.Id)));
}
public async Task <ActionResult <Response> > GetOrderById(Guid id)
{
var order = await _orderRepository.GetById(id);
if (order == null)
{
return(BadRequest(ResponseHelper.CreateResponse("Pedido não encontrado", id)));
}
return(Ok(ResponseHelper.CreateResponse("Aqui esta seu pedido",
new
{
Id = order.Id,
FirstName = order.Customer.FirstName,
Email = order.Customer.Email.Address,
SubTotal = order.SubTotal,
Total = order.Total,
Items = order.Items.Select(item => new { Name = item.Book.Title, Quantity = item.Quantity })
})));
}
public ApiResponse <User> Insert([FromBody] User user)
{
var isValidUser = UserHelper.IsUserValid(user, language);
if (isValidUser == false)
{
return(ResponseHelper.CreateResponse <User>(null, language.WrongInput, 2, true));
}
var result = _unitOfWork.UserRepository.Insert(user);
var commitResult = _unitOfWork.Commit();
language.SetArguments("User Inserted");
if (result != null && commitResult)
{
return(ResponseHelper.CreateResponse(result, language.Success, 1, false));
}
else
{
return(ResponseHelper.CreateResponse <User>(null, language.Failled, 2, true));
}
}
public ActionResult <Response> EditCupon(Guid id, CouponModel model)
{
var couponToEdit = _couponRepository.GetById(id);
if (couponToEdit == null)
{
return(BadRequest(ResponseHelper.CreateResponse("Cupom não encontrado", model.Code)));
}
if (!couponToEdit.ChangeInfo(model.Code, model.Percentage, model.ExpiryDate))
{
return(BadRequest(ResponseHelper.CreateResponse("Não foi possível alterar o cupom", couponToEdit.Notifications)));
}
if (_couponRepository.Exist(couponToEdit))
{
return(BadRequest(ResponseHelper.CreateResponse("Este cupom já se encontra cadastrado", couponToEdit.Id)));
}
_couponRepository.Edit(couponToEdit);
return(Ok(ResponseHelper.CreateResponse("Cupom alterado com sucesso")));
}
public async Task <IActionResult> BulkLocations(IFormFile locationsCSV) => ResponseHelper.CreateResponse(await Mediator.Send(new BulkLocations.BulkLocationsRequest()
{
LocationsFile = locationsCSV
}).ConfigureAwait(false));
public async Task <IActionResult> BulkWorks(IFormFile workCSV) => ResponseHelper.CreateResponse(await Mediator.Send(new BulkWorks.BulkWorksRequest()
{
WorksFile = workCSV
}).ConfigureAwait(false));
public async Task <IActionResult> BulkEmployeesExternal(IFormFile employeesCSV, string origen) => ResponseHelper.CreateResponse(await Mediator.Send(new BulkEmployeesExternal.BulkEmployeesExternalRequest()
{
EmployeesFile = employeesCSV, Origen = origen
}).ConfigureAwait(false));
public async Task <IActionResult> BulkEmployees(IFormFile employeesCSV) => ResponseHelper.CreateResponse(await Mediator.Send(new BulkEmployees.BulkEmployeesRequest()
{
EmployeesFile = employeesCSV
}).ConfigureAwait(false));
public async Task <IActionResult> BulkDepartments(IFormFile departmentsCSV) => ResponseHelper.CreateResponse(await Mediator.Send(new BulkDepartments.BulkDepartmentsRequest()
{
DepartmentsFile = departmentsCSV
}).ConfigureAwait(false));
public async Task <IActionResult> GetAreas() => ResponseHelper.CreateResponse(await Mediator.Send(new GetAreas.GetAreasRequest()).ConfigureAwait(false));