public async void Save()
{
try
{
await _context.SaveChangesAsync();
}
catch (Exception)
{
throw;
}
}
public async Task <Publication> CreateOneAsync(Publication item)
{
item.Reservation = null;
await _context.Publications.AddAsync(item);
await _context.SaveChangesAsync();
_context.Entry(item).State = EntityState.Detached;
return(item);
}
public async Task <ActionResult> Create([Bind(Include = "TypeEventId, Name")] TypeEvent typeEvent)
{
if (ModelState.IsValid)
{
db.TypeEvents.Add(typeEvent);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(typeEvent));
}
public async Task <ActionResult> Edit(QuestionAnswerDhamma questionanswerdhamma)
{
if (ModelState.IsValid)
{
QuestionAnswerDhamma qa = questionanswerdhamma;
if (qa != null)
{
TempData["message"] = string.Format("Question & Answer Dhamma Information has been saved");
db.Entry(qa).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
else
{
return(RedirectToAction("Index"));
}
}
return(View(questionanswerdhamma));
}
public async Task <IActionResult> PutTable([FromRoute] int id, [FromBody] Table table)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != table.Id)
{
return(BadRequest(new { status = "error", message = "Table id is not equal to id from route" }));
}
var tableExists = _context.Tables.FirstOrDefault(t => t.Name == table.Name && t.Id != table.Id);
if (tableExists != null)
{
return(BadRequest(new { status = "error", message = "Стол с таким названием уже существует" }));
}
_context.Entry(table).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TableExists(id))
{
return(NotFound(new { status = "error", message = "Table was not found" }));
}
else
{
throw;
}
}
return(Ok(new { status = "success", message = "Changes was add" }));
}
public async Task <IActionResult> EndMeal([FromBody] MealReadyModel model)
{
var mealOrder = _context.MealOrders
.Include(mo => mo.Order)
.Include(mo => mo.Meal)
.Include(mo => mo.Meal.Category)
.FirstOrDefault(mo => mo.OrderId == model.OrderId && mo.MealId == model.MealId);
if (mealOrder == null)
{
return(NotFound(new { status = "error", message = "Заказ или блюдо не было найдено" }));
}
if (mealOrder.Meal.Category.Department != Department.Bar)
{
return(BadRequest(new { status = "error", message = "Вы можете завершать блюда только своего департамента" }));
}
int finishedQuantity = mealOrder.FinishedQuantity + model.FinishedQuantity;
if (mealOrder.OrderedQuantity < finishedQuantity)
{
return(BadRequest(new { status = "error", message = "Количество законченных порций не может быть выше чем количество заказанных" }));
}
else if (mealOrder.OrderedQuantity > finishedQuantity)
{
mealOrder.FinishedQuantity = finishedQuantity;
}
else
{
mealOrder.FinishedQuantity = finishedQuantity;
mealOrder.MealOrderStatus = MealOrderStatus.Ready;
}
await _context.SaveChangesAsync();
//string message = $"Стол: {mealOrder.Order.Table.Name} блюдо {mealOrder.Meal.Name} готово";
//await _hubContext.Clients.User(mealOrder.Order.UserId.ToString()).SendAsync($"Notify", message);
return(Ok(new { status = "success", message = "Блюда успешно были завершены" }));
}
public async Task <IActionResult> PutCategory([FromRoute] int id, [FromBody] Category category)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != category.Id)
{
return(BadRequest(new { status = "error", message = "Category id is not equal to id from route" }));
}
var categoryExist = _context.Categories.FirstOrDefault(c => c.Name == category.Name && c.Id != category.Id);
if (categoryExist != null)
{
return(BadRequest(new { status = "error", message = "Категория с таким названием уже существует" }));
}
_context.Entry(category).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CategoryExists(id))
{
return(NotFound(new { status = "error", message = "Category was not found" }));
}
else
{
throw;
}
}
return(Ok(new { status = "success", message = "Changes was add" }));
}
public async Task <IActionResult> OnPostDelete(int id)
{
var group = await _db.Groups.FindAsync(id);
if (group == null)
{
return(NotFound());
}
_db.Groups.Remove(group);
await _db.SaveChangesAsync();
return(RedirectToPage("Index"));
}
public async Task <IActionResult> PutMeal([FromRoute] int id, [FromBody] Meal meal)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != meal.Id)
{
return(BadRequest(new { status = "error", message = "Meal id is not equal to id from route" }));
}
var mealExists = _context.Meals.FirstOrDefault(m => m.Name == meal.Name && m.Weight == meal.Weight && m.Id != meal.Id);
if (mealExists != null)
{
return(BadRequest(new { status = "error", message = "Блюдо с таким названием и описанем уже существует" }));
}
_context.Entry(meal).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MealExists(id))
{
return(NotFound(new { status = "error", message = "Meal was not found" }));
}
else
{
throw;
}
}
return(Ok(new { status = "success", message = "Changes was add" }));
}
public async Task <IActionResult> PutUser([FromRoute] int id, [FromBody] User user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != user.Id)
{
return(BadRequest(new { status = "error", message = "User id is not equal to id from route" }));
}
var loginExist = _context.Users.FirstOrDefault(u => u.Login == user.Login && u.Id != user.Id);
if (loginExist != null)
{
return(BadRequest(new { status = "error", message = "Пользователь с таким логином уже существует" }));
}
_context.Entry(user).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(id))
{
return(NotFound(new { status = "error", message = "User was not found" }));
}
else
{
throw;
}
}
return(Ok(new { status = "success", message = "Changes was add" }));
}
public async Task <IActionResult> OnPost()
{
if (ModelState.IsValid)
{
var GroupFromDb = await _db.Groups.FindAsync(Group.Id);
GroupFromDb.Name = Group.Name;
GroupFromDb.Year = Group.Year;
await _db.SaveChangesAsync();
return(RedirectToPage("Index"));
}
return(RedirectToPage());
}
public async Task <IActionResult> OnPost()
{
if (ModelState.IsValid)
{
await _db.Groups.AddAsync(Group);
await _db.SaveChangesAsync();
return(RedirectToPage("Index"));
}
else
{
return(Page());
}
}
public async Task <IActionResult> NewFile(ImageViewModel imageVM)
{
if (ModelState.IsValid)
{
string uniqueFileName = UploadedFile(imageVM);
Image image = new Image
{
Title = imageVM.Title,
ImageDescription = imageVM.ImageDescription,
};
_context.Add(image);
await _context.SaveChangesAsync();
return(RedirectToAction("NewFileHelper"));
}
return(View());
}
public async Task <IActionResult> CreateOrder([FromBody] CreateOrderModel model)
{
if (model.MealOrders.Count == 0)
{
return(BadRequest(new { status = "error", message = "Список блюд не может быть пустым" }));
}
if (model.MealOrders.FirstOrDefault(mo => mo.OrderedQuantity == 0) != null)
{
return(BadRequest(new { status = "error", message = "Количество порций не может быть равным нулю" }));
}
if (TableIsNull(model.TableId))
{
return(NotFound(new { status = "error", message = "Table is not exists in DB" }));
}
var order = new Order()
{
UserId = GetUserId(),
TableId = model.TableId,
DateTimeOrdered = DateTime.Now,
Comment = model.Comment,
MealOrders = model.MealOrders
};
using (var transaction = _context.Database.BeginTransaction())
{
order.DateTimeOrdered = DateTime.Now;
order.OrderStatus = OrderStatus.Active;
_context.Orders.Add(order);
await _context.SaveChangesAsync();
var ord = _context.Orders.Include(o => o.Table).FirstOrDefault(o => o.Id == order.Id);
foreach (var item in ord.MealOrders)
{
item.FinishedQuantity = 0;
}
if (ord.Table.Status == TableStatus.Busy || ord.Table.Status == TableStatus.Booked)
{
return(BadRequest(new { status = "error", message = "Стол занят или забронирован" }));
}
ord.Table.Status = TableStatus.Busy;
await _context.SaveChangesAsync();
transaction.Commit();
}
return(Ok(new { status = "success", message = "Заказ был создан" }));
}
public async Task Execute(IJobExecutionContext context)
{
try
{
using (EFDbContext _context = new EFDbContext())
{
var books = _context.Books.Include(b => b.Table);
foreach (var book in books)
{
TimeSpan ts = book.BookDate - DateTime.Now;
if (ts.TotalMinutes <= 30)
{
book.Table.Status = TableStatus.Booked;
}
}
await _context.SaveChangesAsync();
}
}
catch (Exception)
{
throw new Exception("Возникло исключение");
}
}
public async Task <ActionResult> Edit(TProduct prod, HttpPostedFileBase image = null)
{
if (ModelState.IsValid)
{
if (image != null)
{
prod.ImageMimeType = image.ContentType;
prod.ImageData = new byte[image.ContentLength];
image.InputStream.Read(prod.ImageData, 0, image.ContentLength);
}
db.Entry(prod).State = EntityState.Modified;
await db.SaveChangesAsync();
//repository.SaveProduct(prod);
TempData["message"] = string.Format("Изменения в товаре \"{0}\" были сохранены", prod.Name_Product);
return(RedirectToAction("Index"));
}
else
{
// Что-то не так со значениями данных
return(View(prod));
}
}
public async Task <ActionResult> Register(UserViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (!IsValidEmail(model.Email))
{
ModelState.AddModelError("Email", "Błędny adres email.");
return(View(model));
}
User userLogin = _context.Users.FirstOrDefault(x => x.Login == model.Login);
if (userLogin != null)
{
ModelState.AddModelError("Login", "Istnieje użytkownik o takim loginie.");
return(View(model));
}
User userEmail = _context.Users.FirstOrDefault(x => x.Email == model.Email);
if (userEmail != null)
{
ModelState.AddModelError("Email", "Istnieje użytkownik o takim adresie email.");
return(View(model));
}
if (!model.Password.Any(char.IsDigit))
{
ModelState.AddModelError("Password", "Hasło musi zawierać liczbę.");
return(View(model));
}
if (!model.Password.Any(char.IsUpper))
{
ModelState.AddModelError("Password", "Brak wielkich liter.");
return(View(model));
}
if (!model.Password.Any(char.IsLower))
{
ModelState.AddModelError("Password", "Brak małych liter.");
return(View(model));
}
if (!model.Password.Any(ch => !char.IsLetterOrDigit(ch)))
{
ModelState.AddModelError("Password", "Brak specjalnych znaków.");
return(View(model));
}
var entropy = model.Password.Length * Math.Log2(94);
if (entropy < 25)
{
ModelState.AddModelError("Password", "Twoje hasło jest zdecydowanie za słabe..");
return(View(model));
}
if (entropy < 50)
{
ModelState.AddModelError("Password", "Twoje hasło jest za słabe.");
return(View(model));
}
if (!model.Password.Equals(model.RepeatPassword))
{
ModelState.AddModelError("RepeatPassword", "Hasła muszą się zgadzać.");
return(View(model));
}
byte[] salt;
new RNGCryptoServiceProvider().GetBytes(salt = new byte[16]);
var pbkdf2 = new Rfc2898DeriveBytes(model.Password, salt, 10000);
byte[] hash = pbkdf2.GetBytes(20);
byte[] hashBytes = new byte[36];
Array.Copy(salt, 0, hashBytes, 0, 16);
Array.Copy(hash, 0, hashBytes, 16, 20);
string savedPasswordHash = Convert.ToBase64String(hashBytes);
User newUser = new User
{
Email = model.Email,
Login = model.Login,
Password = savedPasswordHash,
Notes = new List <Note>(),
LogTries = 0,
IsLocked = false
};
_context.Users.Add(newUser);
await _context.SaveChangesAsync();
var claims = new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, model.Email),
new Claim(ClaimTypes.Name, model.Login),
new Claim(ClaimTypes.Email, model.Email)
};
var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
var principal = new ClaimsPrincipal(identity);
await HttpContext.SignInAsync(principal);
return(RedirectToAction("Index"));
}
public async Task AddDailyReportAsync(DailyReport dailyReport)
{
_context.DailyReports.Add(dailyReport);
await _context.SaveChangesAsync();
}
public Task SaveChangesAsync()
{
return(dbContext.SaveChangesAsync());
}
public async Task <GetCubicleDto> CreateOneAsync(CreateCubicleDto createCubicle)
{
// Validando que el cubiculo no exista en la base de datos
var found = await _cubicleRepository.FindOneByCodeAsync(createCubicle.Code);
if (found != null)
{
throw new BadRequestException($"Cubicle with code {createCubicle.Code} already exists");
}
var resources = new List <Resource>();
foreach (var resourceId in createCubicle.ResourcesIds)
{
// Validando la existencia de cada recurso
var resource = await _resourceRepository.FindOneByIdAsync(resourceId);
if (resource == null)
{
throw new BadRequestException($"Resource with id {resourceId} was not found");
}
// Validando que el recurso no le pertenezca a otro cubículo
if (resource.CubicleId.HasValue)
{
throw new BadRequestException($"The resource with id {resource.Id} already has a Cubicle");
}
resources.Add(resource);
}
// Se valida la existencia del campus
var campus = await _campusRepository.GetOneByIdAsync(createCubicle.CampusId);
if (campus == null)
{
throw new BadRequestException($"CampusId with id {createCubicle.CampusId} was not found");
}
var cubicle = new Cubicle
{
Code = createCubicle.Code,
Description = createCubicle.Description,
CampusId = campus.Id,
Pavilion = createCubicle.PavilionId,
IsActive = createCubicle.IsActive,
CreatedAt = new DateTime(),
UpdatedAt = new DateTime(),
TotalSeats = createCubicle.TotalSeats,
};
await _cubicleRepository.CreateOneAsync(cubicle);
foreach (var resource in resources)
{
resource.CubicleId = cubicle.Id;
await _resourceRepository.UpdateOneByIdAsync(resource.Id, resource);
}
await _context.SaveChangesAsync();
return(GetCubicleDto.FromCubicle(cubicle));
}
public async Task AddReportAsync(Report report)
{
_context.Reports.Add(report);
await _context.SaveChangesAsync();
}
public async Task SaveAsync()
{
await db.SaveChangesAsync();
}
public async Task <int> Complete()
{
return(await _context.SaveChangesAsync());
}
