public async Task <IActionResult> PutPieceIdentite(Guid id, PieceIdentite pieceIdentite) { if (id != pieceIdentite.Id) { return(BadRequest()); } _context.Entry(pieceIdentite).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!PieceIdentiteExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
//brisanje slika iz baze - post public async Task <ActionResult> ObrišiSlikuConfirmed(string id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } slika slika = db.slika.Find(id); string putanjaSlike = Server.MapPath(slika.putanjaSlike); if (System.IO.File.Exists(putanjaSlike)) { System.IO.File.Delete(putanjaSlike); } db.slika.Remove(slika); await db.SaveChangesAsync(); var slike = await(from c in db.slika where c.idPoduzeća.Equals(id) select c).ToListAsync(); if (slike.Count == 0) { return(RedirectToAction("Profil")); } else { return(RedirectToAction("ObrišiSliku")); } }
public async Task <IActionResult> PutEventLog(Guid id, EventLog eventLog) { if (id != eventLog.Id) { return(BadRequest()); } _context.Entry(eventLog).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!EventLogExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutMenuCategory(int id, MenuCategory menuCategory) { if (id != menuCategory.Id) { return(BadRequest()); } _context.Entry(menuCategory).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!MenuCategoryExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutProduct(int id, Product product) { if (id != product.ProductId) { return(BadRequest()); } var local = _context.Products.FirstOrDefault(entry => entry.ProductId.Equals(product.ProductId)); _context.Entry(local).State = EntityState.Detached; _context.Entry(product).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ProductExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutActivityBooking(int id, ActivityBooking activityBooking) { if (id != activityBooking.Id) { return(BadRequest()); } _context.Entry(activityBooking).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ActivityBookingExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutWasteBalance(int id, CardWaste wasteBalance) { if (id != wasteBalance.CardWasteId) { return(BadRequest()); } var local = _context.CardWastes.Find(id); _context.Entry(local).State = EntityState.Detached; _context.Entry(wasteBalance).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!WasteBalanceExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutWithdrawal(int id, Withdrawal withdrawal) { if (id != withdrawal.Id) { return(BadRequest()); } _context.Entry(withdrawal).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!WithdrawalExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutRestaurantInfo(int id, RestaurantInfo restaurantInfo) { if (id != restaurantInfo.Id) { return(BadRequest()); } _context.Entry(restaurantInfo).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!RestaurantInfoExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutUser(int id, User user) { if (id != user.Id) { return(BadRequest()); } _context.Entry(user).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!UserExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutOperation(Guid id, Operation operation) { if (id != operation.Id) { return(BadRequest()); } _context.Entry(operation).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!OperationExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutBillProduct(int id, BillProduct billProduct) { if (id != billProduct.Id) { return(BadRequest()); } _context.Entry(billProduct).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!BillProductExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutAddress([FromRoute] int id, [FromBody] Address address) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != address.AddressId) { return(BadRequest()); } _context.Entry(address).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!AddressExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutQuote([FromBody] Quote quote) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _context.Entry(quote).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!_context.Quotes.Any(x => x.Id == quote.Id)) { return(NotFound()); } else { throw; } } quote.Category = _context.Categories.Where(c => c.Id == quote.CategoryId).Single(); return(Ok(quote)); }
public async Task <ActionResult> ChangePassword([Bind(Include = "ID,StaraLozinka,NovaLozinka,PotvrdiNovuLozinku")] PromijeniLozinku promijeniLozinku) { if (ModelState.IsValid) { var user = await db.aspnetusers.FindAsync(promijeniLozinku.ID); if (!string.IsNullOrWhiteSpace(promijeniLozinku.StaraLozinka) && !string.IsNullOrWhiteSpace(promijeniLozinku.NovaLozinka)) { if (UserManager.PasswordHasher.VerifyHashedPassword(user.PasswordHash, promijeniLozinku.StaraLozinka) == PasswordVerificationResult.Success) { if (UserManager.PasswordHasher.VerifyHashedPassword(user.PasswordHash, promijeniLozinku.NovaLozinka) == PasswordVerificationResult.Success) { ModelState.AddModelError(string.Empty, "Nova i stara lozinka moraju biti različite!"); PromijeniLozinku _promijeniLozinku = new PromijeniLozinku(); return(View("~/Views/Korisnik/ChangePassword.cshtml", _promijeniLozinku)); } } else { ModelState.AddModelError(string.Empty, "Stara lozinka nije ispravna!"); PromijeniLozinku _promijeniLozinku = new PromijeniLozinku(); return(View("~/Views/Korisnik/ChangePassword.cshtml", _promijeniLozinku)); } } else { ModelState.AddModelError(string.Empty, "Lozinka ne može sadržavati samo razmak u sebi ili biti prazna!"); PromijeniLozinku _promijeniLozinku = new PromijeniLozinku(); return(View("~/Views/Korisnik/ChangePassword.cshtml", _promijeniLozinku)); } try { user.PasswordHash = UserManager.PasswordHasher.HashPassword(promijeniLozinku.NovaLozinka); await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (db.aspnetusers.Any(e => e.Id == promijeniLozinku.ID)) { return(HttpNotFound()); } else { throw; } } return(RedirectToAction("Profil")); } PromijeniLozinku promijeniLozinku_ = new PromijeniLozinku(); return(View("~/Views/Korisnik/ChangePassword.cshtml", promijeniLozinku_)); }
public async Task <IActionResult> Create([Bind("PersonId,FirstName,MiddleName,LastName,Description,Telephone,AddressId")] Person person) { if (ModelState.IsValid) { _context.Add(person); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } ViewData["AddressId"] = new SelectList(_context.Addresses, "AddressId", "HouseNumber", person.AddressId); return(View(person)); }
public async Task DeleteNotificationById([FromBody] List <Notifications> list) { foreach (var element in list) { try { _context.Notifications.Remove(element); }catch (Exception ex) { var message = ex.Message; } } await _context.SaveChangesAsync(); }
public async Task <ActionResult> AddAsync(Guid testId) { var user = await GetUser(); var test = await ModelsContext.Tests .FirstOrDefaultAsync(t => t.Id == testId && t.State != EntityState.Deleted); if (test == null) { return(BadRequest("Test does not exist")); } if (test.Owner?.Id != user.Id) { return(Forbid()); } var question = new QuestionDbo { Test = test }; ModelsContext.Add(question); await ModelsContext.SaveChangesAsync(); return(Ok(question.Id)); }
public async Task <ActionResult> UpdateAsync([FromBody] QuestionDto questionDto) { var questionDbo = await ModelsContext.Questions .Include(q => q.Test) .FirstOrDefaultAsync(q => q.Id == questionDto.Id && q.State != EntityState.Deleted); if (questionDbo == null) { return(BadRequest("Question does not exist")); } var user = await GetUser(); if (questionDbo.Test.Owner?.Id != user.Id) { return(Forbid()); } questionDbo.Question = questionDto.Question; questionDbo.Answer = questionDto.Answer; ModelsContext.Update(questionDbo); await ModelsContext.SaveChangesAsync(); return(Ok()); }
public async Task GetTeamsUsersSortedByRegisteredDateAsync_WhenUsersElderThan10AndLatestRegistered_ThenFirstUserInUsers() { var team = await teamService.CreateTeam(A.Fake <TeamCreateDTO>()); var userId = 1; var userFake = new Faker <User>() .RuleFor(u => u.Id, f => userId++) .RuleFor(u => u.FirstName, f => f.Person.FirstName) .RuleFor(u => u.LastName, f => f.Person.LastName) .RuleFor(u => u.Email, f => f.Person.Email) .RuleFor(pi => pi.Birthday, f => f.Date.Between(new DateTime(1990, 1, 1), new DateTime(2010, 1, 1))) .RuleFor(pi => pi.RegisteredAt, f => DateTime.Now) .RuleFor(pi => pi.TeamId, f => f.PickRandom(team).Id); var users = userFake.Generate(5); context.Users.AddRange(users); await context.SaveChangesAsync(); var check = context.Users .Where(u => (DateTime.Now.Year - u.Birthday.Year) > 10) .OrderByDescending(u => u.RegisteredAt) .FirstOrDefault(); var result = (await teamService.GetTeamsUsersSortedByRegisteredDateAsync()).FirstOrDefault(); Assert.Equal(check.Id, result.Users.FirstOrDefault().Id); }
public async Task <ActionResult> KreirajRecenziju([Bind(Include = "tekstRecenzija,poduzećeRecenzijaID,vlasnikRecenzijaID,datumRecenzija")] recenzija recenzija) { if (User.Identity.IsAuthenticated == false) { TempData["status"] = "Morate biti registrirani korisnik da možete objavljivati recenzije."; return(RedirectToAction("ProfilGosti", new { id = recenzija.poduzećeRecenzijaID })); } else if (User.IsInRole("Korisnik") == false) { TempData["status"] = "Morate biti ulogirani kao običan korisnik da bi mogli kreirati recenzije na druga poduzeća."; return(RedirectToAction("ProfilGosti", new { id = recenzija.poduzećeRecenzijaID })); } var rezRecenzija = db.recenzija.OrderBy(x => x.idRecenzija).AsEnumerable().Select(x => x.idRecenzija); int rezIDInt; if (ModelState.IsValid) { if (rezRecenzija.Count() != 0) { var rezID = rezRecenzija.Last(); rezIDInt = rezID; rezIDInt++; } else { rezIDInt = 1; } recenzija _recenzija = new recenzija { datumRecenzija = DateTime.Now.ToShortDateString(), poduzećeRecenzijaID = recenzija.poduzećeRecenzijaID, tekstRecenzija = recenzija.tekstRecenzija, odobrenoRecenzija = false, vlasnikRecenzijaID = User.Identity.GetUserId(), idRecenzija = rezIDInt }; db.recenzija.Add(_recenzija); await db.SaveChangesAsync(); TempData["status"] = "Recenzija je uspješno poslana administratoru na odobrenje."; return(RedirectToAction("ProfilGosti", new { id = recenzija.poduzećeRecenzijaID })); } poduzeće poduzeće = db.poduzeće.Find(recenzija.poduzećeRecenzijaID); IEnumerable <slika> modelSlika = (from c in db.slika where c.idPoduzeća.Equals(poduzeće.idPoduzeće) select c).ToList(); IEnumerable <recenzija> recenzije = (from c in db.recenzija where c.poduzećeRecenzijaID.Equals(poduzeće.idPoduzeće) && c.odobrenoRecenzija == true select c).ToList(); recenzija __recenzija = new recenzija { poduzećeRecenzijaID = poduzeće.idPoduzeće, vlasnikRecenzijaID = User.Identity.GetUserId(), datumRecenzija = DateTime.Now.ToShortDateString() }; Tuple <IEnumerable <slika>, poduzeće, IEnumerable <recenzija>, recenzija> tuple = Tuple.Create(modelSlika, poduzeće, recenzije, __recenzija); return(View("~/Views/Poduzeće/ProfilGosti.cshtml", tuple)); }
public async Task <IActionResult> AddCompetition([FromBody] Competition comp) { if (ModelState.IsValid) { Competition dbCompetition = _context.Competitions.FirstOrDefault(c => c.Name == comp.Name); if (dbCompetition != null) { return(new BadRequestObjectResult(comp.Name + " already exists")); } _notificationMessages.CompetitionNotification(_context, comp); await _context.AddAsync(comp); await _context.SaveChangesAsync(); return(Ok("Competition Added!")); } else { return(new BadRequestObjectResult("competition cannot be null")); } }
public async Task <ActionResult> AddAsync() { var user = await GetUser(); var test = new TestDbo { Owner = user }; ModelsContext.Add(test); await ModelsContext.SaveChangesAsync(); return(Ok(test.Id)); }
public async Task <IActionResult> PutUserMember([FromBody] User user) { if (user.Username == null) { return(new BadRequestObjectResult("No empty fields allowed")); } User dbUser = _context.Users.Where(u => u.Username == user.Username) .FirstOrDefault <User>(); if (dbUser == null) { return(BadRequest("User is null")); } dbUser.MemberID = user.MemberID; dbUser.MemberStartDate = user.MemberExpiryDate; dbUser.MemberStartDate = dbUser.MemberStartDate.Value.AddYears(-1); dbUser.MemberExpiryDate = user.MemberExpiryDate; _context.Users.Update(dbUser); await _context.SaveChangesAsync(); _notificationMessage.ConfirmationNotification(_context, dbUser); return(Ok("User update successful")); }
public async Task CreateUser_WhenNewUserToTeam_ThenUsersInTeamPlusOne() { var team = new Team { Id = 1, Name = "new team", CreatedAt = DateTime.Now }; context.Teams.Add(team); await context.SaveChangesAsync(); var user = A.Fake <UserCreateDTO>(); user.TeamId = team.Id; await userService.CreateUser(user); Assert.Single((await teamService.GetAllTeams()).FirstOrDefault()?.Participants); }
public async Task <ActionResult> LoginAsync([FromBody] UserDto userDto) { var userDbo = ModelsContext.Users.FirstOrDefault(u => u.Login == userDto.Login && u.Password == userDto.Password); if (userDbo == null) { return(Forbid()); } userDbo.Token = Guid.NewGuid(); userDbo.LastLogIn = DateTime.Now; ModelsContext.Update(userDbo); await ModelsContext.SaveChangesAsync(); Response.Cookies.Append(AuthConstants.TokenCookie, userDbo.Token.ToString()); return(Ok(userDbo.Token)); }
public async Task <ActionResult> RegisterUserAsync([FromBody] UserDto userDto) { var userDbo = Mapper.Map <UserDbo>(userDto); var count = ModelsContext.Users.Count(u => u.Login == userDto.Login); if (count != 0) { return(BadRequest("User already exist")); } userDbo.Token = Guid.NewGuid(); userDbo.LastLogIn = DateTime.Now; ModelsContext.Add(userDbo); await ModelsContext.SaveChangesAsync(); Response.Cookies.Append(AuthConstants.TokenCookie, userDbo.Token.ToString()); return(Ok(userDbo.Token)); }
public async Task <UserEntity> Register(RegisterRequest user) { var checkedUser = await _modelsContext.Users.SingleOrDefaultAsync(x => x.Email == user.Email); if (checkedUser == null) { var newUser = new UserEntity(); newUser.Email = user.Email; newUser.Password = user.Password; newUser.FirstName = user.FirstName; newUser.LastName = user.LastName; await _modelsContext.Users.AddAsync(newUser); await _modelsContext.SaveChangesAsync(); return(newUser); } return(null); }
public async Task <ActionResult> RemoveAsync(Guid testId) { var user = await GetUser(); var test = await ModelsContext.Tests.FirstOrDefaultAsync(t => t.Id == testId && t.State != EntityState.Deleted); if (test == null) { return(BadRequest("Test does not exist")); } if (test.Owner?.Id != user.Id) { return(Forbid()); } test.State = EntityState.Deleted; ModelsContext.Update(test); await ModelsContext.SaveChangesAsync(); return(Ok()); }
public async Task <IActionResult> UpdateUser(int id, [FromBody] User user) { if (ModelState.IsValid) { //error handling, check if client provided valid data if (user == null) { return(new BadRequestObjectResult("user cannot be null")); } else { User dbUser = null; //assume user does not exist using (_context) { dbUser = _context.Users .Where(u => u.Username == user.Username && u.Id != user.Id) //check if a different user with the new username already exists .FirstOrDefault <User>(); if (dbUser != null) { return(BadRequest("Cannot update user, Username already exists")); } dbUser = _context.Users .Where(u => u.Id == user.Id) .FirstOrDefault <User>(); //now updating user details dbUser.Username = user.Username; _context.Users.Update(dbUser); await _context.SaveChangesAsync(); return(Ok("User update successful")); } } } else { return(new BadRequestObjectResult("user cannot be null")); } }