public async Task <IActionResult> Edit(int id, [Bind("CustomerId,FirstName,LastName,Address,City,State,Country,UserId")] Customer customer)
{
if (id != customer.CustomerId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(customer);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomerExists(customer.CustomerId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(customer));
}
public async Task <IActionResult> Edit(int id, [Bind("OrderId,OrderDate,ShippingAddress,City,State,Country,OrderStatus")] Order order)
{
if (id != order.OrderId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(order);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderExists(order.OrderId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(order));
}
public async Task <IActionResult> Edit(int id, [Bind("CategoryId,Description")] Category category)
{
if (id != category.CategoryId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(category);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CategoryExists(category.CategoryId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(category));
}
public async Task <IActionResult> Shipping(Customer model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (model.CustomerId == 0)
{
_contextModel.Add(model);
await _contextModel.SaveChangesAsync();
}
else
{
_contextModel.Update(model);
await _contextModel.SaveChangesAsync();
}
Customer customer = _contextModel.Customers.SingleOrDefault <Customer>(m => m.UserId == model.UserId);
if (customer == null)
{
throw new ApplicationException($"Unable to load customer.");
}
_logger.LogInformation("Shipping information changed successfully.");
StatusMessage = "Your shipping has been changed.";
ViewBag.StatusMessage = StatusMessage;
return(View(customer));
}
public async Task <IActionResult> Edit(int id, [Bind("ProductId,Name,Discription,Price,CategoryId,Active")] Product product)
{
if (id != product.ProductId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(product);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductExists(product.ProductId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(product));
}
private async Task SoftUpdateMpanFields(ModelDbContext dbContext, Site newSite, Mpan existing, MpanDto updatedDto)
{
SetPropertyIfNotNull(existing, e => e.IsEnergized, updatedDto.IsEnergized);
SetPropertyIfNotNull(existing, e => e.IsNewConnection, updatedDto.IsNewConnection);
SetPropertyIfNotNull(existing, e => e.EAC, updatedDto.EAC);
SetPropertyIfNotNull(existing, e => e.REC, updatedDto.REC);
SetPropertyIfNotNull(existing, e => e.Capacity, updatedDto.Capacity);
SetPropertyIfNotNull(existing, e => e.CCLEligible, updatedDto.CCLEligible);
SetPropertyIfNotNull(existing, e => e.VATPercentage, updatedDto.VATPercentage);
SetPropertyIfNotNull(existing, e => e.IsAMR, updatedDto.IsAMR);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.MeterType, updatedDto.MeterType);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.MeterTimeSwitchCode, updatedDto.MeterTimeSwitchCode);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.LLF, updatedDto.LLF);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.ProfileClass, updatedDto.ProfileClass);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.RetrievalMethod, updatedDto.RetrievalMethod);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.GSPGroup, updatedDto.GSPGroup);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.MeasurementClass, updatedDto.MeasurementClass);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.MOAgent, updatedDto.MOAgent);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.DAAgent, updatedDto.DAAgent);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.DCAgent, updatedDto.DCAgent);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.SerialNumber, updatedDto.SerialNumber);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.Voltage, updatedDto.Voltage);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.Postcode, updatedDto.Postcode);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.Connection, updatedDto.Connection);
existing.TariffId = updatedDto.TariffId;
existing.Site = newSite;
await dbContext.Update(existing);
}
public async Task Put(Guid id, [FromBody] MpanDto mpanDto)
{
var mpan = Mapper.Map <Mpan>(mpanDto);
mpan.Id = id;
await _dbContext.Update(mpan);
}
public async Task Put(Guid id, [FromBody] SiteDto siteDto)
{
var site = Mapper.Map <Site>(siteDto);
site.Id = id;
await _dbContext.Update(site);
}
public async Task Put(Guid id, [FromBody] TenancyPeriodDto tenancyPeriodDto)
{
var tenancyPeriod = Mapper.Map <TenancyPeriod>(tenancyPeriodDto);
tenancyPeriod.Id = id;
await _dbContext.Update(tenancyPeriod);
}
public async Task Put(Guid id, [FromBody] AccountContactDto contactDto)
{
var contact = Mapper.Map <AccountContact>(contactDto);
contact.Id = id;
await _reportingService.ReportAccountChanged(contactDto.AccountId.ToString());
await _dbContext.Update(contact);
}
private async Task SoftUpdateSiteFields(ModelDbContext dbContext, Site existing, SiteDto updatedDto)
{
SetStringPropertyIfNotNullOrEmpty(existing, e => e.Name, updatedDto.Name);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.Contact, updatedDto.Contact);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.Address1, updatedDto.Address1);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.Address2, updatedDto.Address2);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.Town, updatedDto.Town);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.CoT, updatedDto.CoT);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.BillingAddress, updatedDto.BillingAddress);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.Postcode, updatedDto.Postcode);
await dbContext.Update(existing);
}
private async Task <BulkUploadSitesResponseDto> ProcessSite(ModelDbContext dbContext, Guid accountId,
QualifiedSiteDto siteDto)
{
var existingSite = await dbContext.RetrieveSiteByCode(siteDto.SiteCode);
var siteExists = existingSite != null;
var siteId = existingSite?.Id ?? Guid.NewGuid();
string siteState;
if (siteExists)
{
await SoftUpdateSiteFields(dbContext, existingSite, siteDto);
await dbContext.Update(existingSite);
siteState = BulkUploadResponseStates.Updated;
}
else
{
var mappedSite = Mapper.Map <Site>(siteDto);
mappedSite.Id = siteId;
await dbContext.Add(mappedSite);
var tenancyPeriod = new TenancyPeriod
{
Id = Guid.NewGuid(),
AccountId = accountId,
SiteId = siteId,
Site = mappedSite,
EffectiveFrom = DateTime.MinValue,
EffectiveTo = DateTime.MaxValue
};
await dbContext.Add(tenancyPeriod);
siteState = BulkUploadResponseStates.Created;
}
return(new BulkUploadSitesResponseDto
{
Id = siteId,
SiteCode = siteDto.SiteCode,
State = siteState
});
}
private async Task <List <MeterBulkUploadResponseDto> > ProcessRequestMprns(ModelDbContext dbContext,
Site associatedSite, MprnDto[] mprns)
{
var mprnResults = new List <MeterBulkUploadResponseDto>();
{
foreach (var mprnDto in mprns)
{
var existing = await dbContext.RetrieveMprnByCore(mprnDto.MprnCore);
var mprnId = existing?.Id ?? Guid.NewGuid();
string mprnState;
if (existing != null)
{
await SoftUpdateMprnFields(dbContext, associatedSite, existing, mprnDto);
await dbContext.Update(existing);
mprnState = BulkUploadResponseStates.Updated;
}
else
{
var mprn = Mapper.Map <Mprn>(mprnDto);
mprn.Id = mprnId;
mprn.Site = associatedSite;
await dbContext.Add(mprn);
mprnState = BulkUploadResponseStates.Created;
}
mprnResults.Add(new MeterBulkUploadResponseDto
{
Core = mprnDto.MprnCore,
Id = mprnId,
State = mprnState
});
}
return(mprnResults);
}
}
private async Task SoftUpdateMprnFields(ModelDbContext dbContext, Site newSite, Mprn existing, MprnDto updatedDto)
{
SetPropertyIfNotNull(existing, e => e.ChangeOfUse, updatedDto.ChangeOfUse);
SetPropertyIfNotNull(existing, e => e.AQ, updatedDto.AQ);
SetPropertyIfNotNull(existing, e => e.IsImperial, updatedDto.IsImperial);
SetPropertyIfNotNull(existing, e => e.Size, updatedDto.Size);
SetPropertyIfNotNull(existing, e => e.CCLEligible, updatedDto.CCLEligible);
SetPropertyIfNotNull(existing, e => e.VATPercentage, updatedDto.VATPercentage);
SetPropertyIfNotNull(existing, e => e.IsAMR, updatedDto.IsAMR);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.SerialNumber, updatedDto.SerialNumber);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.Make, updatedDto.Make);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.Model, updatedDto.Model);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.EmergencyContactAddress, updatedDto.EmergencyContactAddress);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.EmergencyContactName, updatedDto.EmergencyContactName);
SetStringPropertyIfNotNullOrEmpty(existing, e => e.EmergencyContactTelephone, updatedDto.EmergencyContactTelephone);
existing.TariffId = updatedDto.TariffId;
existing.Site = newSite;
await dbContext.Update(existing);
}
