public async Task Initialization()
{
var customerID = await _serviceCustomer.GetById <Data.Model.Customer>(APIService.CustomerId);
customer = customerID;
var request = new BookingSearchRequest
{
CustomerID = customer.CustomerId
};
BookingList.Clear();
var list = await _serviceBooking.Get <List <Data.Model.Booking> >(request);
foreach (var item in list)
{
if (item.CommentStatus == false && item.EndDate.Date <= DateTime.Now.Date)
{
BookingList.Add(item);
}
}
if (BookingList.Count == 0)
{
await Application.Current.MainPage.DisplayAlert("Warning", "The list is empty. You can leave a comment on the reserved vehicle after the reservation expires or you have not booked yet. Please, try again later.", "OK");
}
}
public async Task ProcessAsync(Customer customer)
{
var cust = _context.Customers.FirstOrDefault(c => c.Email == customer.Email);
if (cust == null)
{
cust = new Data.Model.Customer {
Email = customer.Email
};
_context.Customers.Add(cust);
}
var regNumbers = customer.Vehicles.Select(v => v.RegistrationNumber).Select(_helper.ToRegistrationNumber);
var internalVehicles = _context.Vehicles
.Where(v => regNumbers.Contains(v.RegNo))
.Select(Map).ToArray();
var internalRegNumbers = internalVehicles.Select(v => v.RegistrationNumber);
var externalVehicles = regNumbers.Where(r => !internalRegNumbers.Contains(r))
.Select(async r => await _vehicleService.GetDetailsByAsync(r))
.Select(v => v.Result).ToList();
foreach (var veh in externalVehicles)
{
var vehicle = _context.Vehicles.FirstOrDefault(v => v.RegNo == veh.RegistrationNumber);
if (vehicle == null)
{
vehicle = Map(veh);
vehicle.Customer = cust;
_context.Vehicles.Add(vehicle);
}
}
await _context.SaveChangesAsync();
customer.Vehicles = internalVehicles.Union(externalVehicles).ToList();
}
public ServiceResponse <Data.Model.Customer> CreateCustomer(Data.Model.Customer customer)
{
try
{
solarDb.Customers.Add(customer);
solarDb.SaveChanges();
return(new ServiceResponse <Data.Model.Customer>
{
isSuccess = true,
Message = "New customer added",
Time = DateTime.UtcNow,
Data = customer,
});
}
catch (System.Exception e)
{
return(new ServiceResponse <Data.Model.Customer>
{
isSuccess = false,
Message = e.StackTrace,
Time = DateTime.UtcNow,
Data = customer,
});
}
}
public bool AddCustomer(CustomerModel customer)
{
var customerData = new Data.Model.Customer
{
Name = customer.Name,
Email = customer.Email
};
return(_custRepository.AddCustomer(customerData));
}
public async Task Initialization()
{
var customerID = await _serviceCustomer.GetById <Data.Model.Customer>(APIService.CustomerId);
customer = customerID;
FirstName = customer.FirstName;
LastName = customer.LastName;
Email = customer.Email;
PhoneNumber = customer.Phone;
Username = customer.Username;
}
public async Task Initialization()
{
var customerID = await _serviceCustomer.GetById <Data.Model.Customer>(APIService.CustomerId);
customer = customerID;
FirstName = customerID.FirstName;
LastName = customer.LastName;
var vehicleID = await _serviceVehicle.GetById <Data.Model.Vehicle>(vehicle.VehicleId);
vehicle = vehicleID;
Manufacturer = vehicle.VehicleModel.Manufacturer.ManufacturerName;
ModelName = vehicle.VehicleModel.ModelName;
}
protected override async Task <AuthenticateResult> HandleAuthenticateAsync()
{
if (!Request.Headers.ContainsKey("Authorization"))
{
return(AuthenticateResult.Fail("Missing Authorization Header"));
}
Data.Model.Customer user = null;
try
{
var authHeader = AuthenticationHeaderValue.Parse(Request.Headers["Authorization"]);
var credentialBytes = Convert.FromBase64String(authHeader.Parameter);
var credentials = Encoding.UTF8.GetString(credentialBytes).Split(':');
var username = credentials[0];
var password = credentials[1];
user = _userService.Authenticate(new CustomerLoginRequest()
{
Username = username,
Password = password
});
}
catch
{
return(AuthenticateResult.Fail("Invalid Authorization Header"));
}
if (user == null)
{
return(AuthenticateResult.Fail("Invalid Username or Password"));
}
var claims = new List <Claim> {
new Claim(ClaimTypes.NameIdentifier, user.Username),
new Claim(ClaimTypes.Name, user.FirstName),
};
claims.Add(new Claim(ClaimTypes.Role, user.CustomerType.Type));
var identity = new ClaimsIdentity(claims, Scheme.Name);
var principal = new ClaimsPrincipal(identity);
var ticket = new AuthenticationTicket(principal, Scheme.Name);
return(AuthenticateResult.Success(ticket));
}
public async Task SetNewRating()
{
if (Mark <= 0 || Mark > 10)
{
await Application.Current.MainPage.DisplayAlert("Error", "You have to add mark in range 1 - 10!", "OK");
return;
}
try
{
var customerID = await _serviceCustomer.GetById <Data.Model.Customer>(APIService.CustomerId);
customer = customerID;
var car = await _serviceVehicle.GetById <Data.Model.Vehicle>(vehicle.VehicleId);
bool answer = await Application.Current.MainPage.DisplayAlert("Alert", "Would you like to add rating?", "Yes", "No");
if (answer)
{
var request = new RatingUpsert
{
CustomerId = APIService.CustomerId,
VehicleId = vehicle.VehicleId,
RatingValue = Mark,
RatingDate = DateTime.Now.Date
};
var listRatings = await _serviceRating.Get <List <Data.Model.Rating> >(new RatingSearchRequest
{
CustomerID = customer.CustomerId,
VehicleId = vehicle.VehicleId
});
foreach (var rat in listRatings)
{
rat.RatingDate = rat.RatingDate.AddHours(8);
if (RatingDate.Date == rat.RatingDate.Date)
{
await Application.Current.MainPage.DisplayAlert("Message", "Rating for this reservation already exist! You can add just 1 rating for reservation", "Try again");
return;
}
}
request.RatingDate = DateTime.Now.Date;
await _serviceRating.Insert <Data.Model.Rating>(request);
await Application.Current.MainPage.DisplayAlert("Message", "Successfully! You added your mark for rented car!", "OK");
var listBooking = await _serviceBooking.Get <List <Data.Model.Booking> >(new BookingSearchRequest
{
CustomerID = customer.CustomerId
});
foreach (var item in listBooking)
{
if (item.VehicleId == car.VehicleId && item.CustomerId == customer.CustomerId)
{
if (item.RatingStatus == false)
{
var req = new BookingUpsert
{
CustomerId = item.CustomerId,
VehicleId = item.VehicleId,
StartDate = item.StartDate,
EndDate = item.EndDate,
RatingStatus = true,
CommentStatus = item.CommentStatus
};
await _serviceBooking.Update <Data.Model.Booking>(item.BookingId, req);
return;
}
}
}
}
}
catch (Exception ex)
{
await Application.Current.MainPage.DisplayAlert("Error", "Somethning went wrong", "Try again");
}
}
public async Task SaveEditChanges()
{
try
{
if (string.IsNullOrWhiteSpace(FirstName) || string.IsNullOrWhiteSpace(LastName) || string.IsNullOrWhiteSpace(Email) ||
string.IsNullOrWhiteSpace(PhoneNumber) || string.IsNullOrWhiteSpace(Username))
{
await Application.Current.MainPage.DisplayAlert("Error", "All fields are requreid", "Try again");
return;
}
if (Username.Length < 4)
{
await Application.Current.MainPage.DisplayAlert("Error", "Username must have minimum 4 characters", "Try again");
return;
}
var userList = await _serviceCustomer.Get <List <Data.Model.Customer> >(null);
foreach (var item in userList)
{
if (item.Username.StartsWith(Username) && APIService.Username != item.Username)
{
await Application.Current.MainPage.DisplayAlert("Error", "Username already exist", "Try again");
return;
}
}
var customerID = await _serviceCustomer.GetById <Data.Model.Customer>(APIService.CustomerId);
customer = customerID;
// Password
var request = new CustomerUpsert
{
FirstName = FirstName,
LastName = LastName,
Phone = PhoneNumber,
CityId = customer.CityId,
Email = Email,
Username = Username,
CustomerTypeId = 2,
Password = APIService.Password,
PasswordConfirm = APIService.Password
};
APIService.Username = Username;
var userUpdate = await _serviceCustomer.Update <Data.Model.Customer>(APIService.CustomerId, request);
await Application.Current.MainPage.DisplayAlert("Succesfull", "Succesfully changed, please log in with new credentials.", "OK");
await Application.Current.MainPage.Navigation.PushModalAsync(new LoginPage());
}
catch (Exception ex)
{
await Application.Current.MainPage.DisplayAlert("Error", "Something went wrong.", "Try again");
}
}
public IActionResult Update(string id, [FromBody] Data.Model.Customer Customer)
{
return(Ok(_repository.Update(id, Customer)));
}
