public async Task <string> Handle(CreateRoleCommand request, CancellationToken cancellationToken)
{
ApplicationRole role = new ApplicationRole()
{
Name = request.Name
};
var result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
foreach (var item in request.Claims)
{
await _database.RoleClaims.AddAsync(new RoleClaims()
{
RoleId = role.Id,
ClaimType = item.ClaimType,
ClaimValue = item.ClaimValue
});
}
await _database.SaveAsync();
return(role.Id);
}
throw new Exception(result.Errors.ToString());
}
public async Task <Unit> Handle(UpdateRoleCommand request, CancellationToken cancellationToken)
{
var role = await _roleManager.Roles
.FirstOrDefaultAsync(r => r.Id == request.Id);
if (role == null)
{
throw new NotFoundException("Role", request.Id);
}
role.Name = request.Name;
var claims = _database.RoleClaims.Where(r => r.RoleId == role.Id).ToList();
_database.RoleClaims.RemoveRange(claims);
foreach (var item in request.Claims)
{
_database.RoleClaims.Add(new RoleClaims()
{
RoleId = role.Id,
ClaimType = item.ClaimType,
ClaimValue = item.ClaimValue
});
}
await _roleManager.UpdateAsync(role);
await _database.SaveAsync();
return(Unit.Value);
}
public async Task <string> Handle(CreateUserCommand request, CancellationToken cancellationToken)
{
var userModel = new ApplicationUser()
{
UserName = request.UserName,
Email = request.Email,
PhoneNumber = request.PhoneNumber,
PasswordHash = "000000",
};
var role = await _database.Roles.FindAsync(request.RoleId);
if (role == null)
{
throw new NotFoundException("Role", request.RoleId);
}
var result = await _userManager.CreateAsync(userModel, "000000");
_database.UserRoles.Add(new UserRoles()
{
UserId = userModel.Id,
RoleId = role.Id
});
await _database.SaveAsync();
return(userModel.Id);
}
public async Task <Unit> Handle(AddCustomerPaymentCommand request, CancellationToken cancellationToken)
{
var customer = await _database.Customer.FindAsync(request.CustomerId);
if (customer == null)
{
throw new NotFoundException("Customer", request.CustomerId);
}
RentPayment payment = new RentPayment()
{
CustomerId = request.CustomerId,
Date = request.Date
};
foreach (var item in request.Rents)
{
payment.RentPaymentDetail.Add(new RentPaymentDetail()
{
RentId = item.RentId,
PaymentAmount = item.Amount
});
}
await _database.RentPayment.AddRangeAsync(payment);
await _database.SaveAsync();
return(Unit.Value);
}
public async Task <Unit> Handle(UpdateSystemLookupCommand request, CancellationToken cancellationToken)
{
var lookups = _Mapper.Map <IEnumerable <NewSystemLookupModel>, IEnumerable <SystemLookup> > (request.Lookups);
_database.SystemLookup.UpdateRange(lookups);
await _database.SaveAsync();
return(Unit.Value);
}
public async Task <uint> Handle(CreateCustomerCommand request, CancellationToken cancellationToken)
{
Customer customer = _Mapper.Map <CreateCustomerCommand, Customer> (request);
customer.DateAdded = DateTime.Now;
_database.Customer.Add(customer);
await _database.SaveAsync();
return(customer.CustomerId);
}
public async Task <uint> Handle(CreatePartnerCommand request, CancellationToken cancellationToken)
{
VehicleOwner owner = _Mapper.Map <CreatePartnerCommand, VehicleOwner> (request);
owner.DateAdded = DateTime.Now;
owner.DateUpdated = DateTime.Now;
_database.VehicleOwner.Add(owner);
await _database.SaveAsync();
return(owner.OwnerId);
}
public async Task <Unit> Handle(DeleteVehicleCommand request, CancellationToken cancellationToken)
{
var vehicle = await _database.Vehicle.FindAsync(request.Id);
if (vehicle == null)
{
throw new NotFoundException($"Vehicle with id: {request.Id} Not found");
}
_database.Vehicle.Remove(vehicle);
await _database.SaveAsync();
return(Unit.Value);
}
public async Task <Unit> Handle(DeleteRentCommand request, CancellationToken cancellationToken)
{
var rent = await _database.Rent.FindAsync(request.Id);
if (rent == null)
{
throw new NotFoundException($"Rent with id {request.Id} not found");
}
_database.Rent.Remove(rent);
await _database.SaveAsync();
return(Unit.Value);
}
public async Task <Unit> Handle(DeleteCustomerCommand request, CancellationToken cancellationToken)
{
var customer = await _database.Customer.FindAsync(request.Id);
if (customer == null)
{
throw new NotFoundException($"Customer with Id: {request.Id} Not found");
}
_database.Customer.Remove(customer);
await _database.SaveAsync();
return(Unit.Value);
}
public async Task <Unit> Handle(DeletePartnerPaymentCommand request, CancellationToken cancellationToken)
{
var payment = await _database.RentPayment.FindAsync(request.Id);
if (payment == null)
{
throw new NotFoundException("Payment", request.Id);
}
_database.RentPayment.Remove(payment);
await _database.SaveAsync();
return(Unit.Value);
}
public async Task <uint> Handle(CreateRentCommand request, CancellationToken cancellationToken)
{
Rent rent = new Rent()
{
DateAdded = DateTime.Now,
DateUpdated = DateTime.Now,
CustomerId = request.CustomerId,
VehicleId = request.VehicleId,
RentedPrice = request.RentedPrice,
StartDate = request.StartDate,
ReturnDate = request.ReturnDate,
OwnerRentingPrice = request.OwnerRentingPrice,
ColateralDeposit = request.ColateralDeposit,
RentCondition = new List <RentCondition> ()
{
new RentCondition()
{
WindowController = request.VehicleCondition.WindowController,
SeatBelt = request.VehicleCondition.SeatBelt,
SpareTire = request.VehicleCondition.SpareTire,
Wiper = request.VehicleCondition.Wiper,
CrickWrench = request.VehicleCondition.CrickWrench,
DashboardClose = request.VehicleCondition.DashboardClose,
MudeProtecter = request.VehicleCondition.MudeProtecter,
SpokioOuter = request.VehicleCondition.SpokioInner,
SpokioInner = request.VehicleCondition.SpokioOuter,
SunVisor = request.VehicleCondition.SunVisor,
MatInner = request.VehicleCondition.MatInner,
WindProtecter = request.VehicleCondition.WindProtecter,
Blinker = request.VehicleCondition.Blinker,
Radio = request.VehicleCondition.Radio,
FuielLevel = request.VehicleCondition.FuielLevel,
CigaretLighter = request.VehicleCondition.CigaretLighter,
FuielLid = request.VehicleCondition.FuielLid,
RadiatorLid = request.VehicleCondition.RadiatorLid,
Crick = request.VehicleCondition.Crick,
Comment = request.VehicleCondition.Comment,
TotalKilometer = request.VehicleCondition.TotalKilometer
}
}
};
_database.Rent.Add(rent);
await _database.SaveAsync();
return(await Task.FromResult <uint> (rent.RentId));
}
public async Task <Unit> Handle(UpdatePartnerCommand request, CancellationToken cancellationToken)
{
var owner = await _database.VehicleOwner.FindAsync(request.Id);
if (owner == null)
{
throw new NotFoundException($" Partner with id : {request.Id} Not found");
}
_Mapper.Map(request, owner);
owner.DateUpdated = DateTime.Now;
_database.VehicleOwner.Update(owner);
await _database.SaveAsync();
return(Unit.Value);
}
public async Task <Unit> Handle(UpdateCustomerPaymentCommand request, CancellationToken cancellationToken)
{
var payment = await _database.RentPayment
.Include(p => p.RentPaymentDetail)
.FirstOrDefaultAsync(p => p.Id == request.Id);
if (payment == null)
{
throw new NotFoundException("Payment", request.Id);
}
payment.Date = request.Date;
payment.CustomerId = request.CustomerId;
foreach (var item in request.Rents)
{
if (item.Id != 0)
{
var o = payment.RentPaymentDetail.FirstOrDefault(i => i.Id == item.Id);
o.PaymentAmount = item.Amount;
o.RentId = item.RentId;
}
else
{
payment.RentPaymentDetail.Add(new RentPaymentDetail()
{
RentId = item.RentId,
PaymentAmount = item.Amount
});
}
}
foreach (var id in request.DeletedIds)
{
var o = payment.RentPaymentDetail.FirstOrDefault(i => i.Id == id);
_database.RentPaymentDetail.Remove(o);
}
await _database.SaveAsync();
return(Unit.Value);
}
public async Task <uint> Handle(CreateVehicleCommand request, CancellationToken cancellationToken)
{
if (request.OwnerId != null)
{
var owner = await _database.VehicleOwner.FindAsync(request.OwnerId);
if (owner == null)
{
throw new NotFoundException($"Partner with id: {request.OwnerId} not foun");
}
}
Vehicle vehicle = _Mapper.Map <CreateVehicleCommand, Vehicle> (request);
vehicle.DateUpdated = DateTime.Now;
_database.Vehicle.Add(vehicle);
await _database.SaveAsync();
return(vehicle.VehicleId);
}
public async Task <Unit> Handle(AddPartnerPaymentCommand request, CancellationToken cancellationToken)
{
RentPayment payments = new RentPayment()
{
PartnerId = request.PartnerId,
Date = request.Date
};
foreach (var item in request.Rents)
{
payments.RentPaymentDetail.Add(new RentPaymentDetail()
{
PaymentAmount = item.Amount,
RentId = item.RentId
});
}
await _database.RentPayment.AddRangeAsync(payments);
await _database.SaveAsync();
return(Unit.Value);
}
public async Task <Unit> Handle(UpdateRentCommand request, CancellationToken cancellationToken)
{
var rent = await _database.Rent.Include(r => r.RentCondition).FirstOrDefaultAsync(i => i.RentId == request.Id);
if (rent == null)
{
throw new NotFoundException($"rent with id {request.Id} not found");
}
rent.DateUpdated = DateTime.Now;
rent.CustomerId = request.CustomerId;
rent.VehicleId = request.VehicleId;
rent.RentedBy = request.RentedBy;
rent.RentedPrice = request.RentedPrice;
rent.StartDate = request.StartDate;
rent.ReturnDate = request.ReturnDate;
rent.OwnerRentingPrice = request.OwnerRentingPrice;
rent.ColateralDeposit = request.ColateralDeposit;
_database.Rent.Update(rent);
await _database.SaveAsync();
return(Unit.Value);
}