public async Task EditOwnerTenantAsync(OwnerTenantDto ownerTenant)
{
var prevOwnerTenants = await _buildingManager.GetAllCurrrentOwnerOfApartment(ownerTenant.ApartmentId);
if (ownerTenant.IsOwner)
{
var owner = prevOwnerTenants.FirstOrDefault(t => t.IsOwner);
if (owner != null && ownerTenant.PersonId == owner.PersonId)
{
owner.To = ownerTenant.From;
await EditOwnerTenantAsync(owner);
}
await _personRepository.AddOwnerTenantAsync(ownerTenant);
}
else
{
var tenant = prevOwnerTenants.FirstOrDefault(t => !t.IsOwner);
if (tenant != null && (tenant.PersonId != ownerTenant.PersonId || tenant.OccupantCount != ownerTenant.OccupantCount))
{
tenant.To = DateTime.Now;
await EditOwnerTenantAsync(tenant);
}
await _personRepository.AddOwnerTenantAsync(ownerTenant);
}
}
public async Task AddOwnerTenantAsync(OwnerTenantDto owner)
{
var entry = owner.ToEntry();
await _baseInfoContext.OwnerTenants.AddAsync(entry);
await _baseInfoContext.SaveChangesAsync();
owner.OwnerTenantId = entry.OwnerTenantId;
}
public static OwnerTenantRespone ToModel(this OwnerTenantDto owner)
{
return(new OwnerTenantRespone
{
OccupantCount = owner.OccupantCount,
IsOwner = owner.IsOwner,
From = owner.From,
To = owner.To,
OwnerTenantId = owner.OwnerTenantId
});
}
public static OwnerTenant ToEntry(this OwnerTenantDto ownertenantDto)
{
return(new OwnerTenant
{
OwnerTenantId = ownertenantDto.OwnerTenantId,
OccupantCount = ownertenantDto.OccupantCount,
IsOwner = ownertenantDto.IsOwner,
From = ownertenantDto.From,
To = ownertenantDto.To,
PersonId = ownertenantDto.PersonId,
ApartmentId = ownertenantDto.ApartmentId,
});
}
public void OwnertenatDto_Map_To_Entry()
{
DateTime now = DateTime.Now;
OwnerTenantDto otdto = new OwnerTenantDto {
PersonId = 1, From = now, IsOwner = false, OccupantCount = 4
, OwnerTenantId = 7, ApartmentId = 4
};
OwnerTenant ow = otdto.ToEntry();
bool check = false;
if (ow.IsOwner == otdto.IsOwner && ow.From == otdto.From && ow.ApartmentId == otdto.ApartmentId &&
ow.OccupantCount == otdto.OccupantCount && ow.PersonId == otdto.PersonId)
{
check = true;
}
Assert.IsTrue(check);
}
public async Task EditOwnerTenantAsync(OwnerTenantDto owner)
{
var ownertenant = await _baseInfoContext.OwnerTenants.AsNoTracking().FirstOrDefaultAsync(b => b.OwnerTenantId == owner.OwnerTenantId);
if (ownertenant == null)
{
throw new NullReferenceException($"Cannot Find OwnerTenant with {owner.OwnerTenantId} id");
}
var entry = owner.ToEntry();
entry.PersonId = ownertenant.PersonId;
entry.ApartmentId = ownertenant.ApartmentId;
_baseInfoContext.OwnerTenants.Update(entry);
try
{
await _baseInfoContext.SaveChangesAsync();
}
catch (Exception e)
{
}
}
private async Task ValidateOwnerTenantAsync(OwnerTenantDto ownertenant)
{
if (ownertenant.To < ownertenant.From)
{
throw new ValidationException(ErrorCodes.Invalid_Entrence_Time, $"Date entrance should not be greater than Exit Time ");
}
var allCurrentOwners = await _buildingManager.GetAllCurrrentOwnerOfApartment(ownertenant.ApartmentId);
foreach (var ot in allCurrentOwners)
{
if (ot.IsOwner == ownertenant.IsOwner && ot.From < ownertenant.To && ot.To >= ownertenant.From)
{
throw new ValidationException(ErrorCodes.Apartment_Is_Taken, $"This apartment Is occupied");
}
}
if (!ownertenant.IsOwner && ownertenant.OccupantCount < 1)
{
throw new ValidationException(ErrorCodes.OccupantCount_Error, $"The counts of the occupant should not be smaller than 1");
}
}
public Task EditOwnerTenantAsync(OwnerTenantDto owner)
{
throw new NotImplementedException();
}
public async Task AddOwnerTenant(OwnerTenantDto owner)
{
owner.OwnerTenantId = _ownertenants.Max(a => a.OwnerTenantId) + 1;
_ownertenants.Add(owner);
}
public async Task AddOwnerTenantAsync(OwnerTenantDto ownerTenant)
{
await ValidateOwnerTenantAsync(ownerTenant);
await _personRepository.AddOwnerTenantAsync(ownerTenant);
}
public async Task EditOwnerTenantAsync(OwnerTenantDto ownerTenant)
{
await _personManager.EditOwnerTenantAsync(ownerTenant);
await _chargeCalculationApplicationService.ReCalculateChargeAsync(ownerTenant.ApartmentId, ownerTenant.From, ownerTenant.To);
}
