public void AddOrUpdateOwner(OwnerDTO owner, int[] seleceedCars)
{
var carsEntity = _carOwnerContext.Cars;
var ownerEntity = new OwnerEntity();
if (owner.IdOwner != 0)
{
ownerEntity = _carOwnerContext.Owners.Find(owner.IdOwner);
}
ownerEntity.Name = owner.Name;
ownerEntity.Surname = owner.Surname;
ownerEntity.BirthDate = owner.BirthDate;
ownerEntity.DrivingExperience = owner.DrivingExperience;
ownerEntity.CarEntities.Clear();
if (seleceedCars != null)
{
foreach (var car in carsEntity.Where(c => seleceedCars.Contains(c.IdCar)))
{
ownerEntity.CarEntities.Add(car);
}
}
_carOwnerContext.Owners.AddOrUpdate(ownerEntity);
}
private BaseResponse <OwnerAuthenticatedDTO> Authentication(OwnerDTO owner)
{
var response = new BaseResponse <OwnerAuthenticatedDTO>();
var identity = new ClaimsIdentity(new GenericIdentity(owner.id.ToString(), "id"), new[] { new Claim(JwtRegisteredClaimNames.NameId, owner.id.ToString()) });
identity.AddClaim(new Claim("id", owner.id.ToString()));
var expires = DateTime.Now.AddYears(10);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = DateTime.Now,
Expires = expires
});
var token = handler.WriteToken(securityToken);
response.Dto.Token = new TokenDTO()
{
Hash = token,
Type = "Bearer",
};
response.Dto.Name = owner.FirstName.Value;
response.Success = true;
return(response);
}
public async Task <IEnumerable <SettlementSheetDTO> > GetAll(OwnerDTO OwnerDTO)
{
var flats = await buildingService.GetFlats(OwnerDTO.OwnerId);
var periods = await periodService.GetPeriods();
using (MUEContext db = new MUEContext())
{
var ss = await db.SettlementSheets.ToListAsync();
ss = ss.Where(sse => flats.Select(f => f.FlatId).ToList().Contains(sse.FlatId)).ToList();
return(ss.Select(ssd => new SettlementSheetDTO
{
AmmountToBePaid = ssd.AmmountToBePaid,
Description = ssd.Description,
FlatId = ssd.FlatId,
PeriodId = ssd.PeriodId,
SettlementSheetId = ssd.SettlementSheetId,
Status = ssd.Status,
Flat = flats.Where(f => ssd.FlatId == f.FlatId).Select(f => f.Address).FirstOrDefault(),
Period = periods.Where(p => ssd.PeriodId == p.PeriodId).Select(p => p.Name).FirstOrDefault()
}).ToList());
}
}
public void Save(OwnerDTO ownerDTO)
{
if (ownerDTO.id.Equals(0))
{
ownerDTO.Guid = new PropertyDtoGuid(true);
ownerDTO.Created = DateTime.Now;
ownerDTO.Confirmated = DateTime.Now;
}
var result =
dapper
.ResetParameter()
.AddParameter("@Guid", ownerDTO.Guid)
.AddParameter("@FirstName", ownerDTO.FirstName)
.AddParameter("@LastName", ownerDTO.LastName)
.AddParameter("@Email", ownerDTO.Email)
.AddParameter("@Cpf", ownerDTO.Cpf.Value.OnlyNumber())
.AddParameter("@Phone", ownerDTO.Phone.Value.OnlyNumber())
.AddParameter("@CellPhone", ownerDTO.CellPhone.Value.OnlyNumber())
.AddParameter("@Password", ownerDTO.Password.Hash)
.AddParameter("@Created", ownerDTO.Created)
.AddParameter("@Confirmated", ownerDTO.Confirmated)
.AddParameter("@idStatus", (int)ownerDTO.Status)
.AddParameter("@emailAccept", ownerDTO.EmailAccept)
.ExecuteWithOneResult <OwnerResult>("owner_register");
var parser = new OwnerDTOParser();
parser.Parse(result, ownerDTO);
}
public BaseResponse <OwnerAuthenticatedDTO> Login(OwnerDTO owner)
{
var response = new BaseResponse <OwnerAuthenticatedDTO>();
var code = ERROR_CODE.NONE;
if (owner == null)
{
code = ERROR_CODE.INVALID;
}
else if (!owner.id.Equals(0))
{
response.Dto.Name = owner.FirstName.Value;
if (owner.Status.Equals(OWNER_STATUS.WAITING_ACTIVATION))
{
code = ERROR_CODE.INACTIVE;
}
else
{
response = Authentication(owner);
}
}
response.Error = new ErrorEnvelope {
Code = code
};
return(response);
}
private void btnAdd_Click(object sender, EventArgs e)
{
if (!txtId.ReadOnly)
{
if (KiemTraDuLieu())
{
string id = txtId.Text;
string name = txtName.Text;
string phone = txtPhone.Text;
DateTime dob = dtpDateOfBirth.Value;
string cmnd = txtCMND.Text;
string address = txtAddress.Text;
try
{
bll.InsertOwner(id, name, phone, dob, cmnd, address);
main_owner_dto = new OwnerDTO()
{
Id = id, Name = name, Phone = phone, DateOfBirth = dob, CMND = cmnd, Address = address
};
LoadData();
txtId.ReadOnly = true;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
else
{
MessageBox.Show("Please click new to add Owner");
}
}
private void btnUpdate_Click(object sender, EventArgs e)
{
if (txtId.ReadOnly)
{
if (KiemTraDuLieu())
{
string id = txtId.Text;
string name = txtName.Text;
string phone = txtPhone.Text;
DateTime dob = DateTime.Parse(dtpDateOfBirth.Value.ToShortDateString());
string cmnd = txtCMND.Text;
string address = txtAddress.Text;
try
{
bll.UpdateOwner(id, name, phone, dob, cmnd, address);
main_owner_dto = new OwnerDTO()
{
Id = id, Name = name, Phone = phone, DateOfBirth = dob, CMND = cmnd, Address = address
};
LoadData();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
else
{
MessageBox.Show("Please chosse to update Owner");
}
}
private void btnAdd_Click(object sender, EventArgs e)
{
if (!txtId.ReadOnly)
{
if (KiemTraDuLieu())
{
try
{
OwnerDTO od = (OwnerDTO)cbbOwner.SelectedItem;
bll.InsertBus(txtId.Text, txtBSX.Text, txtBrand.Text, dtpDateRegistration.Value, od.Id, cbbRouteID.Text);
LoadData();
UpdateMainBusDto();
txtId.ReadOnly = true;
cbbOwner.Enabled = false;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
else
{
MessageBox.Show("Please click new before add");
}
}
public OwnerDTO GetOwner(int id)
{
var ownerEntity = _carOwnerContext.Owners.Find(id);
var ownerDto = new OwnerDTO()
{
IdOwner = ownerEntity.IdOwner,
Name = ownerEntity.Name,
Surname = ownerEntity.Surname,
BirthDate = ownerEntity.BirthDate,
DrivingExperience = ownerEntity.DrivingExperience,
};
var carsOwner = ownerEntity.CarEntities;
foreach (var car in carsOwner)
{
ownerDto.CarList.Add(new CarDTO()
{
IdCar = car.IdCar,
Model = car.Model,
СarMake = car.СarMake,
});
}
return(ownerDto);
}
public void CreateOwner(OwnerDTO ownerDTO)
{
Owner updatedOwner = Mapper.Map <OwnerDTO, Owner>(ownerDTO);
Database.Owners.Create(updatedOwner);
Database.Save();
}
public BaseResponse <OwnerAuthenticatedDTO> Login(OwnerDTO dto)
{
var response = new BaseResponse <OwnerAuthenticatedDTO>();
response = loginService.Login(dto);
return(response);
}
public static Owner ToOwner(this OwnerDTO ownerDto)
{
Owner owner = new Owner(ownerDto.PassportNumber, ownerDto.FirstName, ownerDto.LastName, ownerDto.PassportNumber);
owner.Id = ownerDto.Id;
return(owner);
}
public OwnerDetailOfBus(OwnerDTO dto)
{
InitializeComponent();
bll = new OwnerBLL();
txtId.ReadOnly = true;
this.dto = dto;
LoadData();
}
public void Add(OwnerDTO owner)
{
if (ReferenceEquals(owner, null))
{
throw new ArgumentNullException($"The {nameof(owner)} can not be null.");
}
owners.Add(owner);
}
public Owner Post(OwnerDTO value)
{
Owner model = new Owner()
{
firstName = value.firstName,
lastName = value.lastName
};
return(IOwnerRepository.Create(model));
}
public void Update(OwnerDTO owner)
{
//TODO if null
AccountOwner ownerForUpdate = dbContext.Set <AccountOwner>().Find(owner.Id);
ownerForUpdate.FirstName = owner.FirstName;
ownerForUpdate.LastName = owner.LastName;
ownerForUpdate.PassportNumber = owner.PassportNumber;
ownerForUpdate.Email = owner.Email;
}
public void Confirmation(OwnerDTO ownerDTO)
{
var procedure =
dapper
.ResetParameter()
.AddParameter("@Guid", ownerDTO.Guid)
.AddParameter("@idStatus", (int)ownerDTO.Status)
.AddParameter("@Confirmated", ownerDTO.Confirmated)
.Execute("owner_confirmation");
}
public List <OwnerDTO> Save(OwnerDTO OwnerDTO)
{
var entity = mapper.Map <Owner>(OwnerDTO);
if (ownerRepository.Save(entity) > 0)
{
var data = ownerRepository.GetAll().ToList();
return(mapper.Map <List <OwnerDTO> >(data));
}
return(null);
}
public static AccountOwner ToOwnerORM(this OwnerDTO ownerDto)
{
return(new AccountOwner()
{
Id = ownerDto.Id,
FirstName = ownerDto.FirstName,
LastName = ownerDto.LastName,
PassportNumber = ownerDto.PassportNumber,
Email = ownerDto.Email
});
}
public static OwnerEntity ToOwnerEntity(this OwnerDTO ownerDto)
{
return(new OwnerEntity()
{
Id = ownerDto.Id,
FirstName = ownerDto.FirstName,
LastName = ownerDto.LastName,
PassportNumber = ownerDto.PassportNumber,
Email = ownerDto.Email
});
}
public ActionResult EditOwner(OwnerViewModel ownerModel, int[] selectedCar)
{
OwnerDTO owner = ownerModel.Owner;
if (ModelState.IsValid)
{
_ownerService.AddOrUpdateOwnerDto(owner, selectedCar);
return(RedirectToAction(MethodName.OwnersList));
}
ViewBag.ListCar = _carService.GetCarsDtoList();
return(View(MethodName.AddOrUpdateOwner, ownerModel));
}
// GET: Owner/Delete/5
public ActionResult Delete(int id)
{
OwnerDTO ownerDTO = dbService.Delete(id); //db.Owners.Find(id);
if (ownerDTO == null)
{
return(HttpNotFound());
}
var model = mapperService.Map <OwnerDTO, OwnerViewModel>(ownerDTO);
return(View(model));
}
/// <summary>
/// Validates the type of Owner
/// </summary>
/// <param name="ownerDTO"></param>
/// <returns></returns>
public bool ValidateOwnerType(OwnerDTO ownerDTO)
{
bool isValid = true;
if ((string.Equals(ownerDTO.OwnerType, Dealer, System.StringComparison.InvariantCultureIgnoreCase) && string.IsNullOrWhiteSpace(ownerDTO.DealerABN)) ||
(string.Equals(ownerDTO.OwnerType, PrivateOwner, System.StringComparison.InvariantCultureIgnoreCase) && (string.IsNullOrWhiteSpace(ownerDTO.Name) || string.IsNullOrWhiteSpace(ownerDTO.PhoneNumber)))
)
{
isValid = false;
}
return(isValid);
}
public void Update(OwnerDTO owner)
{
if (ReferenceEquals(owner, null))
{
throw new ArgumentNullException($"The {nameof(owner)} can not be null.");
}
OwnerDTO ownerForUpdate = owners.FirstOrDefault(x => x.PassportNumber == owner.PassportNumber);
ownerForUpdate.FirstName = owner.FirstName;
ownerForUpdate.LastName = owner.LastName;
ownerForUpdate.Email = owner.Email;
}
public IActionResult Create([Bind(include: new string[] { "FirstName", "LastName", "Birthdate", "DrivingExperience" })] OwnerViewModel ownerViewModel)
{
if (ModelState.IsValid)
{
OwnerDTO carDTO = Mapper.Map <OwnerViewModel, OwnerDTO>(ownerViewModel);
ownerService.CreateOwner(carDTO);
return(RedirectToAction("Index"));
}
else
{
return(View());
}
}
public async Task Update(OwnerDTO dto)
{
var owner = await GetEntity(dto.OwnerId);
using (MUEContext db = new MUEContext())
{
owner.FirstName = dto.FirstName;
owner.LastName = dto.LastName;
owner.MiddlleName = dto.MiddlleName;
owner.Status = dto.Status;
db.Entry(owner).State = EntityState.Modified;
await db.SaveChangesAsync();
}
}
public ActionResult DeleteConfirmed(int id)
{
//Owner owner = db.Owners.Find(id);
OwnerDTO ownerDTO = dbService.Get(id);
if (ownerDTO == null)
{
return(HttpNotFound());
}
dbService.Remove(ownerDTO.Id);
//db.Owners.Remove(owner);
//db.SaveChanges();
return(RedirectToAction("Index"));
}
public void ownerType_required()
{
// Arrange
var model = new OwnerDTO();
var context = new ValidationContext(model, null, null);
var result = new List <ValidationResult>();
// Act
var valid = Validator.TryValidateObject(model, context, result, true);
Assert.IsFalse(valid);
Assert.AreEqual(result[0].ErrorMessage, "Please Enter the owner type");
Assert.IsTrue(result[0].MemberNames.Contains("OwnerType"));
}
public void UpdateOwner(string id, string name, string phone, DateTime dob, string CMND, string address)
{
try
{
OwnerDTO dto = new OwnerDTO {
Id = id, Name = name, Phone = phone, DateOfBirth = dob, CMND = CMND, Address = address
};
dao.Update(dto);
}
catch (Exception ex)
{
throw ex;
}
}
public IActionResult Edit(OwnerViewModel ownerViewModel)
{
if (ModelState.IsValid)
{
OwnerDTO ownerDTO = Mapper.Map <OwnerViewModel, OwnerDTO>(ownerViewModel);
ownerService.UpdateOwnerInfo(ownerDTO);
return(RedirectToAction("Index"));
}
else
{
return(View());
}
}
