Exemple #1
0
        public ActionResult Edit(Role role, string MemberListSelect)
        {
            if (ModelState.IsValid)
            {
                //取得資料庫裏面原來的值
                var roleItem = db.Roles.Single(r => r.Id == role.Id);

                //套用新的值
                db.Entry(roleItem).CurrentValues.SetValues(role);


                //放入新的值
                roleItem.Members.Clear();
                string[] strArray    = MemberListSelect.Split(',');
                var      memberLists = db.Members.ToList().Where(c => strArray.Contains(c.Id.ToString()));
                foreach (var m in memberLists)
                {
                    roleItem.Members.Add(m);
                }

                db.Entry(roleItem).State = EntityState.Modified;
                db.SaveChanges();

                return(RedirectToAction("Index"));
            }
            return(RedirectToAction("Edit"));
        }
Exemple #2
0
        public async Task <IActionResult> PutClazz([FromRoute] string id, [FromBody] Clazz clazz)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != clazz.Id)
            {
                return(BadRequest());
            }

            _context.Entry(clazz).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ClazzExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Exemple #3
0
        public async Task <IActionResult> PutAccount([FromRoute] string id, [FromBody] Account account)
        {
            _context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != account.Id)
            {
                return(BadRequest("ID is not correct"));
            }

            if (await _context.Account.SingleOrDefaultAsync(a => a.Id == account.Id) != null) // Kiem tra account update co ton tai khong
            {
                var currentAccount = await _context.Account.SingleOrDefaultAsync(a => a.Id == account.Id);

                string tokenHeader = Request.Headers["Authorization"];
                var    token       = tokenHeader.Replace("Basic ", "");
                var    tokenUser   = await _context.Credential.SingleOrDefaultAsync(c => c.AccessToken == token);

                if (tokenUser.OwnerId == currentAccount.Id
                    ||
                    (await _context.AccountRoles.SingleOrDefaultAsync(ar => ar.AccountId == tokenUser.OwnerId)).RoleId < (await _context.AccountRoles.SingleOrDefaultAsync(ar => ar.AccountId == currentAccount.Id)).RoleId ||
                    tokenUser.OwnerId == "ADMIN"
                    )
                {
                    if (account.Password == null)
                    {
                        account.Password = currentAccount.Password;
                        account.Salt     = currentAccount.Salt;
                    }
                    else
                    {
                        if (PasswordHandle.GetInstance().EncryptPassword(account.Password, currentAccount.Salt) == currentAccount.Password) //Kiểm tra mật  khẩu có trùng với mật khẩu cũ không, nếu trùng thì trả về lỗi
                        {
                            return(BadRequest(new ResponseError("New password do not same old password", 400)));
                        }
                        account.Salt     = PasswordHandle.GetInstance().GenerateSalt();
                        account.Password = PasswordHandle.GetInstance().EncryptPassword(account.Password, account.Salt);
                    }


                    account.UpdatedAt             = DateTime.Now;
                    _context.Entry(account).State = EntityState.Modified;
                    _context.Entry(account.GeneralInformation).State = EntityState.Modified;
                    await _context.SaveChangesAsync();

                    return(Ok(_context.Account.Include(a => a.GeneralInformation).SingleOrDefault(a => a.Id == account.Id)));
                }
            }
            return(BadRequest(account.Id));
        }
Exemple #4
0
        public void UpdateDepartures2(Variant variant, List <Departure> departuresToRemove, List <Explanation> explanationsToRemove)
        {
            using (BackendContext db = new BackendContext())
            {
                var variantEntry = db.Variants.Single(v => v.Id == variant.Id);
                if (variant.Departures != null)
                {
                    foreach (var singleDeparture in variant.Departures)
                    {
                        foreach (var singleExplanation in singleDeparture.Explanations)
                        {
                            if (singleExplanation.Id < 1)
                            {
                                db.Entry(singleExplanation).State = System.Data.Entity.EntityState.Added;
                            }
                        }

                        if (singleDeparture.Id < 1 && false)
                        {
                            singleDeparture.Variant         = variantEntry;
                            db.Entry(singleDeparture).State = System.Data.Entity.EntityState.Added;
                        }
                    }
                }

                if (explanationsToRemove != null)
                {
                    foreach (var singleExplanation in explanationsToRemove)
                    {
                        if (singleExplanation.Id > 0)
                        {
                            db.Entry(singleExplanation).State = System.Data.Entity.EntityState.Deleted;
                        }
                    }
                }

                if (departuresToRemove != null)
                {
                    foreach (var singleDeparture in departuresToRemove)
                    {
                        if (singleDeparture.Id > 0)
                        {
                            db.Entry(singleDeparture).State = System.Data.Entity.EntityState.Deleted;
                        }
                    }
                }

                db.SaveChanges();
            }
        }
        public async Task <IActionResult> PutHaandvaerker(int id, Haandvaerker haandvaerker)
        {
            if (id != haandvaerker.HaandvaerkerId)
            {
                return(BadRequest());
            }

            _context.Entry(haandvaerker).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!HaandvaerkerExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task <IActionResult> PutInvoiceItem([FromRoute] int id, [FromBody] InvoiceItem invoiceItem)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != invoiceItem.ID)
            {
                return(BadRequest());
            }

            _context.Entry(invoiceItem).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!InvoiceItemExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Exemple #7
0
        public async Task <IActionResult> PutAccountRole([FromRoute] int id, [FromBody] AccountRole accountRole)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != accountRole.RoleId)
            {
                return(BadRequest());
            }

            _context.Entry(accountRole).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!AccountRoleExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task <IActionResult> PutLegalCase(long id, LegalCase legalCase)
        {
            if (id != legalCase.Id)
            {
                return(BadRequest());
            }

            _context.Entry(legalCase).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!LegalCaseExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Exemple #9
0
        public async Task <IHttpActionResult> PutSongs(int id, Songs songs)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != songs.SongId)
            {
                return(BadRequest());
            }

            db.Entry(songs).State = EntityState.Modified;

            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!SongsExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
Exemple #10
0
        public async Task <IActionResult> PutVaerktoejskasse(int id, Vaerktoejskasse vaerktoejskasse)
        {
            if (id != vaerktoejskasse.VTKId)
            {
                return(BadRequest());
            }

            _context.Entry(vaerktoejskasse).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!VaerktoejskasseExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task <IActionResult> PutFolder(long id, Folder folder)
        {
            if (id != folder.Id)
            {
                return(BadRequest());
            }

            _context.Entry(folder).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!FolderExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public Product Update(Product updateProduct)
        {
            var pro = GetProductByID(updateProduct.ID);

            if (pro != null)
            {
                pro.Name = updateProduct.Name;
                // pro.Price = updateProduct.Price;
                pro.Color = updateProduct.Color;
                pro.Type  = updateProduct.Type;
                //pro.CreatedDate = pro.CreatedDate;
            }
            _btx.Entry(pro).State = EntityState.Modified;
            _btx.SaveChanges();
            return(pro);
        }
        public async Task <IActionResult> PutGeneralInformation([FromRoute] string id, [FromBody] GeneralInformation generalInformation)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != generalInformation.AccountId)
            {
                return(BadRequest());
            }

            _context.Entry(generalInformation).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!GeneralInformationExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Exemple #14
0
        public void UpdateLineWithVariants(Line line, List <Variant> variants, List <Variant> variantsToRemove)
        {
            using (BackendContext db = new BackendContext())
            {
                if (line.Id > 0)
                {
                    // entity exists
                    db.Entry(line).State = System.Data.Entity.EntityState.Modified;

                    foreach (var singleVariant in variants)
                    {
                        if (singleVariant.Id > 0)
                        {
                            db.Entry(line.Variants.Single(v => v.Id == singleVariant.Id)).State = System.Data.Entity.EntityState.Modified;
                        }
                        else
                        {
                            singleVariant.Line            = db.Lines.Single(l => l.Id == line.Id);
                            db.Entry(singleVariant).State = System.Data.Entity.EntityState.Added;
                        }
                    }
                }
                else
                {
                    // this creates the Variants as well
                    db.Entry(line).State = System.Data.Entity.EntityState.Added;
                }
                db.SaveChanges();

                if (variantsToRemove != null)
                {
                    foreach (var singleVariant in variantsToRemove)
                    {
                        if (singleVariant.Id > 0)
                        {
                            db.Departures.RemoveRange(db.Departures.Where(d => d.Variant.Id == singleVariant.Id));
                            db.VariantStops.RemoveRange(db.VariantStops.Where(vs => vs.Variant.Id == singleVariant.Id));
                            db.Variants.Remove(db.Variants.Single(v => v.Id == singleVariant.Id));
                        }
                    }
                    db.SaveChanges();
                }
            }
        }
Exemple #15
0
        public ActionResult ChangePassword(string newPassword)
        {
            Member member = db.Members.SingleOrDefault(o => o.Account == User.Identity.Name);

            if (member != null)
            {
                member.Password        = Utility.GenerateHashWithSalt(newPassword, member.PasswordSalt);
                db.Entry(member).State = EntityState.Modified;
                db.SaveChanges();
                ViewBag.message = "修改成功";
                return(View());
            }
            ViewBag.message = "修改失敗!請重新登入試試!!";
            return(View());
        }
Exemple #16
0
        public async Task <ActionResult <Customer> > Update(long id, Customer customer)
        {
            if (id != customer.Id)
            {
                return(BadRequest());
            }

            _context.Entry(customer).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                return(BadRequest());
            }

            return(NoContent());
        }
        public async Task <IActionResult> PutDrone([FromRoute] int id, [FromBody] Drone drone)
        {
            dbContext.Entry(drone).State = EntityState.Modified;

            try
            {
                await dbContext.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!DroneExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public void UpdateVariantStops(int variantId, List <Stop> stops, List <VariantStop> variantStops, List <VariantStop> variantStopsToRemove)
        {
            using (BackendContext db = new BackendContext())
            {
                if (variantStopsToRemove != null)
                {
                    foreach (var singleVariantStop in variantStopsToRemove)
                    {
                        if (singleVariantStop.Id > 0)
                        {
                            db.Entry(singleVariantStop).State = System.Data.Entity.EntityState.Deleted;
                        }
                    }
                    db.SaveChanges();
                }

                Variant variant = db.Variants.Include("VariantStops").Single(v => v.Id == variantId);
                if (variantStops != null)
                {
                    foreach (var singleVariantStop in variantStops)
                    {
                        // vs is new
                        if (singleVariantStop.Id < 1)
                        {
                            Stop stop;
                            // stop already exists
                            if (singleVariantStop.Stop.Id > 0)
                            {
                                stop = db.Stops.Single(s => s.Id == singleVariantStop.Stop.Id);
                            }
                            // stop is new
                            else
                            {
                                stop = db.Stops.Add(singleVariantStop.Stop);
                                db.SaveChanges();
                            }

                            singleVariantStop.Stop    = stop;
                            singleVariantStop.Variant = variant;

                            db.Entry(singleVariantStop).State = System.Data.Entity.EntityState.Added;
                        }
                    }
                    db.SaveChanges();

                    var orderedVariantStops = db.VariantStops.Include("Stop").Where(vs => vs.Variant.Id == variantId).OrderBy(vs => vs.TimeOffset).ToList();
                    if (orderedVariantStops.Count > 0)
                    {
                        int firstStopId = orderedVariantStops.First().Stop.Id;
                        int lastStopId  = orderedVariantStops.Last().Stop.Id;
                        variant.FirstLineStop = db.Stops.Single(s => s.Id == firstStopId);
                        variant.LastLineStop  = db.Stops.Single(s => s.Id == lastStopId);
                    }
                    else
                    {
                        variant.FirstLineStop = null;
                        variant.LastLineStop  = null;
                    }
                    db.SaveChanges();
                }
            }
        }
Exemple #19
0
        public void UpdateDepartures(Variant variant, List <Departure> departuresToRemove, List <Explanation> explanationsToRemove)
        {
            using (BackendContext db = new BackendContext())
            {
                if (departuresToRemove != null)
                {
                    foreach (var singleDeparture in departuresToRemove)
                    {
                        if (singleDeparture.Id > 0)
                        {
                            db.Entry(singleDeparture).State = EntityState.Deleted;
                        }
                    }
                    db.SaveChanges();
                }

                var dbVariant = db.Variants.Single(v => v.Id == variant.Id);
                List <Departure> departures = variant.Departures;

                if (departures != null)
                {
                    foreach (var singleDeparture in departures)
                    {
                        //dep is new
                        if (singleDeparture.Id < 1)
                        {
                            Explanation        explanation;
                            List <Explanation> singleDepartureExplanationCopy = singleDeparture.Explanations.ToList();
                            foreach (var singleExplanation in singleDepartureExplanationCopy)
                            {
                                //explanation already exists
                                if (singleExplanation.Id > 0)
                                {
                                    explanation = db.Explanations.Single(e => e.Id == singleExplanation.Id);
                                }
                                //explanation is new
                                else
                                {
                                    explanation = db.Explanations.Add(singleExplanation);
                                    db.SaveChanges();
                                }

                                singleDeparture.Explanations.Remove(singleDeparture.Explanations.Single(e => e.Id == singleExplanation.Id));
                                singleDeparture.Explanations.Add(explanation);
                            }

                            singleDeparture.VariantId = dbVariant.Id;

                            db.Entry(singleDeparture).State = EntityState.Added;
                        }
                    }
                    db.SaveChanges();
                }

                if (explanationsToRemove != null)
                {
                    foreach (var singleExplanation in explanationsToRemove)
                    {
                        if (singleExplanation.Id > 0)
                        {
                            db.Explanations.Remove(db.Explanations.Single(e => e.Id == singleExplanation.Id));
                        }
                    }
                }
            }
        }
Exemple #20
0
 public void Atualizar(TEntity entity)
 {
     _dbContext.Entry(entity).State = EntityState.Modified;
     _dbContext.SaveChanges();
 }
Exemple #21
0
 public void Edit(User updateUser)
 {
     _btx.Entry(updateUser).State = EntityState.Modified;
     _btx.SaveChanges();
 }