public async Task <IActionResult> OnPostAsync()
        {
            if (!ModelState.IsValid)
            {
                return(Page());
            }

            //Override values for created by and date
            Address.CreatedDate = DateTime.Now;
            Address.CreatedBy   = Identity.GetUserId(User, _context);

            _context.Address.Add(Address);
            await _context.SaveChangesAsync();

            await Audit.AddAuditRecord(_context, 'C', "Address", "AddressID", Address.AddressID, Identity.GetUserId(User, _context), "Address Created");

            //return RedirectToPage("./Index");
            JObject jsonItem = JObject.FromObject(Address);

            //objectID added for form.js
            jsonItem.Add("objectID", Address.AddressID);

            return(Content(jsonItem.ToString(), "application/json"));
            //return new JsonResult(Address);
        }
        public async Task <IActionResult> OnPostAsync()
        {
            if (!ModelState.IsValid)
            {
                return(Page());
            }

            _context.Attach(AuditTrail).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!AuditTrailExists(AuditTrail.AuditTrailID))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(RedirectToPage("./Index"));
        }
        public async Task <IActionResult> OnPostAsync()
        {
            if (!ModelState.IsValid)
            {
                return(Page());
            }

            //Original details
            var originalAddress = await _context.Address
                                  .AsNoTracking()
                                  .FirstOrDefaultAsync(a => a.AddressID == Address.AddressID);

            _context.Attach(Address).State = EntityState.Modified;

            //Override values for updated by and date
            Address.CreatedBy   = originalAddress.CreatedBy;
            Address.CreatedDate = originalAddress.CreatedDate;
            Address.UpdatedDate = DateTime.Now;
            Address.UpdatedBy   = Shared.Identity.GetUserId(User, _context);

            var customerToUpdate = await _context.Customer
                                   .Include(c => c.Address)
                                   .FirstOrDefaultAsync(c => c.CustomerID == Address.CustomerID);

            try
            {
                UpdateCustomerPrimaryAddress(_context, Address, customerToUpdate);
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!AddressExists(Address.AddressID))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            object originalObj = new object();

            originalObj = originalAddress;

            object newObj = new object();

            newObj = Address;

            string changes = Shared.Audit.WhatChanged(originalObj, newObj, "");

            await Shared.Audit.AddAuditRecord(_context, 'E', "Address", "AddressID", Address.AddressID, Shared.Identity.GetUserId(User, _context), changes);

            //return RedirectToPage("./Index");
            return(new JsonResult(Address));
        }
        public async Task <IActionResult> OnPostAsync()
        {
            if (!ModelState.IsValid)
            {
                return(Page());
            }

            _context.AuditTrail.Add(AuditTrail);
            await _context.SaveChangesAsync();

            return(RedirectToPage("./Index"));
        }
        public async Task <IActionResult> OnPostAsync(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            AuditTrail = await _context.AuditTrail.FindAsync(id);

            if (AuditTrail != null)
            {
                _context.AuditTrail.Remove(AuditTrail);
                await _context.SaveChangesAsync();
            }

            return(RedirectToPage("./Index"));
        }
        public async Task <IActionResult> OnPostAsync(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            Note = await _context.Note.FindAsync(id);

            if (Note != null)
            {
                _context.Note.Remove(Note);
                await _context.SaveChangesAsync();

                await Shared.Audit.AddAuditRecord(_context, 'D', "Note", "NoteID", Note.NoteID, Shared.Identity.GetUserId(User, _context), "Note Deleted: Note: " + Note.NoteText);
            }

            //return RedirectToPage("./Index");
            return(new JsonResult(Note));
        }
예제 #7
0
        public async Task <IActionResult> OnPostAsync(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            Customer = await _context.Customer.FindAsync(id);

            if (Customer != null)
            {
                _context.Customer.Remove(Customer);
                await _context.SaveChangesAsync();

                await Shared.Audit.AddAuditRecord(_context, 'D', "Customer", "CustomerID", Customer.CustomerID, Shared.Identity.GetUserId(User, _context), "Customer Deleted: Forename: " + Customer.Forename + ", Surname: " + Customer.Surname);
            }

            //return RedirectToPage("./Index");
            return(new JsonResult(Customer));
        }
        public async Task <IActionResult> OnPostAsync(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            Address = await _context.Address.FindAsync(id);

            if (Address != null)
            {
                _context.Address.Remove(Address);
                await _context.SaveChangesAsync();

                await Shared.Audit.AddAuditRecord(_context, 'D', "Address", "AddressID", Address.AddressID, Shared.Identity.GetUserId(User, _context), "Address Deleted: Address1: " + Address.Address1 + ", Post Code: " + Address.PostcodeOut + " " + Address.PostcodeIn);
            }

            //return RedirectToPage("./Index");
            return(new JsonResult(Address));
        }
        public async Task <IActionResult> OnPostAsync(string[] selectedAreas)
        {
            if (!ModelState.IsValid)
            {
                return(Page());
            }

            //Override values for created by and date
            Customer.CreatedDate = DateTime.Now;
            Customer.CreatedBy   = Identity.GetUserId(User, _context);

            if (selectedAreas != null)
            {
                Customer.CustomerArea = new List <CustomerArea>();
                foreach (var area in selectedAreas)
                {
                    var areaToAdd = new CustomerArea
                    {
                        AreaID = int.Parse(area)
                    };
                    Customer.CustomerArea.Add(areaToAdd);
                }
            }

            _context.Customer.Add(Customer);
            await _context.SaveChangesAsync();

            await Audit.AddAuditRecord(_context, 'C', "Customer", "CustomerID", Customer.CustomerID, Identity.GetUserId(User, _context), "Customer Created");

            //return RedirectToPage("./Index");
            JObject jsonItem = JObject.FromObject(Customer);

            //objectID added for form.js
            jsonItem.Add("objectID", Customer.CustomerID);

            return(Content(jsonItem.ToString(), "application/json"));
            //return new JsonResult(Customer);
        }
예제 #10
0
        public async Task <IActionResult> OnPostAsync(int?id, string[] selectedAreas)
        {
            if (!ModelState.IsValid)
            {
                return(Page());
            }

            //Original details
            var originalCustomer = await _context.Customer
                                   .Include(c => c.CustomerArea)
                                   .ThenInclude(c => c.Area)
                                   .AsNoTracking()
                                   .FirstOrDefaultAsync(c => c.CustomerID == id);

            _context.Attach(Customer).State = EntityState.Modified;

            //Override values for updated by and date
            Customer.CreatedBy   = originalCustomer.CreatedBy;
            Customer.CreatedDate = originalCustomer.CreatedDate;
            Customer.UpdatedDate = DateTime.Now;
            Customer.UpdatedBy   = Identity.GetUserId(User, _context);

            var customerToUpdate = await _context.Customer
                                   .Include(c => c.CustomerArea)
                                   .ThenInclude(c => c.Area)
                                   .FirstOrDefaultAsync(c => c.CustomerID == id);

            try
            {
                UpdateCustomerAreas(_context, selectedAreas, customerToUpdate);
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!CustomerExists(customerToUpdate.CustomerID))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            object originalCustomerObj = new object();

            originalCustomerObj = originalCustomer;

            object newCustomerObj = new object();

            newCustomerObj = customerToUpdate;

            object originalCustomerAreasObj = new object();

            originalCustomerAreasObj = originalCustomer.CustomerArea;

            object newCustomerAreasObj = new object();

            newCustomerAreasObj = customerToUpdate.CustomerArea;

            string changes = "";

            changes = Audit.WhatChanged(originalCustomerObj, newCustomerObj, changes);

            changes = Audit.ElementsChanged(originalCustomerAreasObj, newCustomerAreasObj, "AreaID", changes);

            await Audit.AddAuditRecord(_context, 'E', "Customer", "CustomerID", Customer.CustomerID, Identity.GetUserId(User, _context), changes);

            //return RedirectToPage("./Index");
            return(new JsonResult(Customer));
        }