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));