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"));
}
}