public async Task <CustomerDTO> CreateCustomerOrUpdateIfExistAsync(CreateCustomerDTO createCustomerDTO) { var customer = await _DBContext.Customers.FirstOrDefaultAsync(c => c.Email == createCustomerDTO.Email); if (customer != null) { if (customer.FirstName != createCustomerDTO.FirstName || customer.LastName != createCustomerDTO.LastName) { customer.FirstName = createCustomerDTO.FirstName; customer.LastName = createCustomerDTO.LastName; _DBContext.Customers.Update(customer); } } else { customer = new CustomerEntity { Email = createCustomerDTO.Email, FirstName = createCustomerDTO.FirstName, LastName = createCustomerDTO.LastName }; await _DBContext.AddAsync(customer); } await _DBContext.SaveChangesAsync(); var customerDTO = _mapper.Map <CustomerDTO>(customer); return(customerDTO); }
public ActionResult <Customer> CreateNewCustomer(CreateCustomerDTO createCustomerDTO) { LoginToken <Administrator> admin_token = DesirializeToken(); Customer customer = _mapper.Map <Customer>(createCustomerDTO); string uri = null; try { customer.Id = _loggedInAdministratorFacade.CreateNewCustomer(admin_token, customer); if (customer.Id == 0) { return(Conflict()); } uri = _linkGenerator.GetPathByAction(nameof(AdministratorFacadeController.GetCustomerById), "AdministratorFacade", new { id = customer.Id }); } catch (RecordAlreadyExistsException) { return(Conflict()); } return(Created(uri, customer)); }
public async Task Purchase_And_Get_List_Of_Flights() { CreateFlightDTO createFlightDTO = new CreateFlightDTO { OriginCountryId = 1, DestinationCountryId = 1, DepartureTime = DateTime.Now.AddHours(2), LandingTime = DateTime.Now.AddHours(6), RemainingTickets = 1 }; await TestHelpers.Create_Flight_For_Tests(_httpClient, createFlightDTO); CreateCustomerDTO createCustomerDTO = await TestHelpers.Customer_Login(_httpClient); long flight_id = 1; await _httpClient.PostAsync("api/tickets", new StringContent(JsonSerializer.Serialize(flight_id), Encoding.UTF8, MediaTypeNames.Application.Json)); flight_id = 2; await _httpClient.PostAsync("api/tickets", new StringContent(JsonSerializer.Serialize(flight_id), Encoding.UTF8, MediaTypeNames.Application.Json)); var response = await _httpClient.GetAsync("api/customer/flights"); var responseContent = await response.Content.ReadAsStringAsync(); List <Flight> flightsResult = JsonSerializer.Deserialize <List <Flight> >(responseContent, new JsonSerializerOptions { PropertyNameCaseInsensitive = true }); Assert.AreEqual(flightsResult.Count, 2); }
public BaseDTO Create(object data) { Response response = new Response(); var type = new CreateCustomerDTO(); if (data.GetType() == type.GetType()) { var token = AuthorizationService.Authorize(_authParameters.ClientId, _authParameters.ClientSecret, _authParameters.StoreName); var url = HelperFunctions.CreateUrlFromParts(_authParameters.StoreName, Constants.apiCustomer, string.Empty, token.access_token); var result = HelperFunctions.HttpPost(url, data).GetAwaiter().GetResult(); if (result != null) { return(result); } else { return(new BaseDTO() { code = (int)HttpStatusCode.BadRequest, }); } } else { throw new System.Exception("Not suppoerted type of parameter"); } }
public async Task <CreateCustomerDTO> Create(CreateCustomerDTO c) { var model = _mapper.Map <Customer>(c); await _customerContext.InsertOneAsync(model); return(c); }
public CustomerDTO Insert(CreateCustomerDTO createCustomer) { var customer = _mapper.Map <CreateCustomerDTO, Customer>(createCustomer); _repositoryCustomer.Save(customer); return(_mapper.Map <Customer, CustomerDTO>(customer)); }
public async Task Get_Empty_List_Of_My_Tickets_Should_Return_No_Content() { CreateCustomerDTO createCustomerDTO = await TestHelpers.Customer_Login(_httpClient); var response = await _httpClient.GetAsync("api/customer/tickets"); Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode); }
public void Create(CreateCustomerDTO dto) { CustomerDbEntity Customer = new CustomerDbEntity(); Customer.Name = dto.Name; Customer.Email = dto.Email; Customer.Phone = dto.Phone; _DB.Customers.Add(Customer); _DB.SaveChanges(); }
public async Task <ActionResult <Customer> > PostCustomer(CreateCustomerDTO customerDTO) { var customer = new Customer(customerDTO.FirstName, customerDTO.LastName, customerDTO.Email); Console.WriteLine(customer); _context.Customer.Add(customer); await _context.SaveChangesAsync(); return(CreatedAtAction("GetCustomer", new { id = customer.Id }, customer)); }
public async Task Get_All_Tickets_By_Flight() { await TestHelpers.Airline_Company_Login(_httpClient); CreateFlightDTO createFlightDTO = new CreateFlightDTO { OriginCountryId = 1, DestinationCountryId = 1, DepartureTime = DateTime.Now.AddHours(2), LandingTime = DateTime.Now.AddHours(6), RemainingTickets = 15 }; await _httpClient.PostAsync("api/flights", new StringContent(JsonSerializer.Serialize(createFlightDTO), Encoding.UTF8, MediaTypeNames.Application.Json)); await TestHelpers.Customer_Login(_httpClient); long flight_id = 1; await _httpClient.PostAsync("api/tickets", new StringContent(JsonSerializer.Serialize(flight_id), Encoding.UTF8, MediaTypeNames.Application.Json)); CreateCustomerDTO createCustomerDTO = new CreateCustomerDTO { FirstName = "Customer2", LastName = "Custom2", Address = null, PhoneNumber = "052-5555512", CreditCardNumber = null, User = new CreateUserDTO { UserName = "******", Password = "******", Email = "*****@*****.**", } }; await TestHelpers.Customer_Login(_httpClient, createCustomerDTO); await _httpClient.PostAsync("api/tickets", new StringContent(JsonSerializer.Serialize(flight_id), Encoding.UTF8, MediaTypeNames.Application.Json)); await TestHelpers.Airline_Company_Login(_httpClient, create_airline : false); var response = await _httpClient.GetAsync($"api/airline-company/flights/{flight_id}/tickets"); var responseContent = await response.Content.ReadAsStringAsync(); List <TicketDetailsDTO> ticketsResult = JsonSerializer.Deserialize <List <TicketDetailsDTO> >(responseContent, new JsonSerializerOptions { PropertyNameCaseInsensitive = true }); Assert.AreEqual(ticketsResult.Count, 2); }
public async Task ChangeMyPassword_With_Incorrect_Password_Should_Return_Bad_Request() { CreateCustomerDTO createCustomerDTO = await TestHelpers.Customer_Login(_httpClient); var response = await _httpClient.PutAsync("api/account/change-password", new StringContent(JsonSerializer.Serialize(new ChangePasswordRequest { OldPassword = "******", NewPassword = "******" }), Encoding.UTF8, MediaTypeNames.Application.Json)); Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode); }
public async Task <IActionResult> AddCustomer([FromBody] CreateCustomerDTO customer) { var customerEntity = Mapper.Map <Customer>(customer); await _customerRepository.AddAsync(customerEntity); if (_customerRepository.Save()) { //return Ok(Mapper.Map<CustomerDTO>(customerEntity)); return(CreatedAtRoute("GetSingleCustomer", new { customerEntity.Id }, Mapper.Map <CustomerDTO>(customerEntity))); } //return StatusCode(500, "Unable to Save Customer."); throw new Exception("Unable to Save Customer Data."); }
public async Task <ActualResult <string> > CreateMainCustomerAsync(CreateCustomerDTO dto) { try { var customer = _mapper.Map <DimCustomer>(dto); await _context.DimCustomer.AddAsync(customer); await _context.SaveChangesAsync(); var hashId = HashHelper.EncryptLong(customer.CustomerKey); return(new ActualResult <string> { Result = hashId }); } catch (Exception exception) { return(new ActualResult <string>(DescriptionExceptionHelper.GetDescriptionError(exception))); } }
public async Task <int> CreateCustomerAsync(CreateCustomerDTO createCustomerDTO) { using (IUnitOfWork uow = this.unitOfWorkFactory.CreateUnitOfWork()) { var customerRepository = uow.GetRepository <ICustomersRepository>(); var newCustomer = new Customer { Name = createCustomerDTO.Name, ContactName = createCustomerDTO.ContactName, ContactEmail = createCustomerDTO.ContactEmail, ContactPhone = createCustomerDTO.ContactPhone }; customerRepository.Add(newCustomer); await uow.SaveChangesAsync(); return(newCustomer.Id); } }
internal static async Task <CreateCustomerDTO> Customer_Login(HttpClient httpClient, CreateCustomerDTO createCustomerDTO = null) { if (createCustomerDTO == null) { createCustomerDTO = new CreateCustomerDTO { FirstName = "Customer", LastName = "Custom", Address = null, PhoneNumber = "052-1234567", CreditCardNumber = null, User = new CreateUserDTO { UserName = "******", Password = "******", Email = "*****@*****.**", } }; } await Main_Admin_Login(httpClient); await Create_Customer_For_Tests(httpClient, createCustomerDTO); var credentials = new LoginRequest//Demi credentials { UserName = createCustomerDTO.User.UserName, Password = createCustomerDTO.User.Password }; var loginResponse = await httpClient.PostAsync("api/account/login", new StringContent(JsonSerializer.Serialize(credentials), Encoding.UTF8, MediaTypeNames.Application.Json)); var loginResponseContent = await loginResponse.Content.ReadAsStringAsync(); //Get response content as json string var loginResult = JsonSerializer.Deserialize <LoginResult>(loginResponseContent); //Desirialize the json string back to LoginResult httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(JwtBearerDefaults.AuthenticationScheme, loginResult.AccessToken); //Set the Jwt access token in the request header return(createCustomerDTO); }
public async Task Get_Ticket_Of_Another_Customer_Should_Return_Forbidden() { CreateCustomerDTO createCustomerDTO = new CreateCustomerDTO { FirstName = "Customer2", LastName = "Custom2", Address = null, PhoneNumber = "052-5555512", CreditCardNumber = null, User = new CreateUserDTO { UserName = "******", Password = "******", Email = "*****@*****.**", } }; await TestHelpers.Customer_Login(_httpClient, createCustomerDTO); long flight_id = 1; var response = await _httpClient.PostAsync("api/tickets", new StringContent(JsonSerializer.Serialize(flight_id), Encoding.UTF8, MediaTypeNames.Application.Json)); var responseContent = await response.Content.ReadAsStringAsync(); TicketDetailsDTO ticketPostResult = JsonSerializer.Deserialize <TicketDetailsDTO>(responseContent, new JsonSerializerOptions { PropertyNameCaseInsensitive = true }); await TestHelpers.Customer_Login(_httpClient); var response2 = await _httpClient.GetAsync($"api/tickets/{ticketPostResult.Id}"); Assert.AreEqual(HttpStatusCode.Forbidden, response2.StatusCode); }
public async Task <IActionResult> CreateCustomer([FromBody] CreateCustomerDTO customerDTO) { if (!ModelState.IsValid) { _logger.LogError($"Invalid POST attempt in {nameof(CreateCustomer)}"); return(BadRequest(ModelState)); } try { var customer = _mapper.Map <Customer>(customerDTO); await _unitOfWork.Customer.Insert(customer); await _unitOfWork.Save(); //Created at route returns object to slient return(CreatedAtRoute("GetCustomer", new { id = customer.Id }, customer)); } catch (Exception ex) { _logger.LogError(ex, $"Something went wrong in the {nameof(CreateCustomer)}"); return(StatusCode(500, "Internal Server Error. Please try again later.")); } }
private static async Task Create_Customer_For_Tests(HttpClient httpClient, CreateCustomerDTO createCustomerDTO) { await httpClient.PostAsync("api/customers", new StringContent(JsonSerializer.Serialize(createCustomerDTO), Encoding.UTF8, MediaTypeNames.Application.Json)); }
public async Task <IActionResult> CreateCustomer([FromBody] CreateCustomerDTO createCustomerDTO) { int customerId = await this.customersService.CreateCustomerAsync(createCustomerDTO); return(Ok(new { Id = customerId })); }
public async Task <IActionResult> Create([FromBody] CreateCustomerDTO dto) { var result = await _customerService.Create(dto); return(Ok(result)); }
public IActionResult Create([FromBody] CreateCustomerDTO dto) { _CustomerService.Create(dto); return(Ok(GetResponse("Added"))); }