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