Exemplo n.º 1
0
        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));
        }
Exemplo n.º 2
0
        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));
        }
Exemplo n.º 3
0
        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));
        }
Exemplo n.º 4
0
        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));
        }
Exemplo n.º 5
0
        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));
        }
Exemplo n.º 6
0
        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);
        }
Exemplo n.º 7
0
        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);
        }
Exemplo n.º 11
0
        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);
        }
Exemplo n.º 12
0
        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
            });
        }
Exemplo n.º 13
0
        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);
            }
        }
Exemplo n.º 14
0
        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);
        }