public async Task <IActionResult> EditServer([FromForm] RustShopViewModel model)
{
if (!ModelState.IsValid)
{
var errors = ModelState.Values.SelectMany(x => x.Errors.Select(xx => xx.ErrorMessage)).ToList();
errors.ForEach(x => ModelState.AddModelError("", x));
model.RustServerEditViewModel.Status = RustEditServerResult.Failed;
model.RustServerEditViewModel.MapsDict = _rustServerService.GetAllMaps();
model.RustServerEditViewModel.IsNewServer = true;
return(View(model));
}
var resultPair = await _rustServerService.UpdateAsync(model);
var status = resultPair.Item1;
var serverId = resultPair.Item2;
model.RustServerEditViewModel.MapsDict = _rustServerService.GetAllMaps();
if (status == RustEditServerResult.Updated)
{
return(RedirectToAction("EditServer",
new { shopId = model.Id, serverId = serverId, status = RustEditServerResult.Updated }));
}
else if (status == RustEditServerResult.Created)
{
return(RedirectToAction("EditServer",
new { shopId = model.Id, serverId = serverId, status = RustEditServerResult.Created }));
}
return(RedirectToAction("SomethingWentWrong", "ControlPanel"));
}
public async Task <IActionResult> EditCategory([FromForm] RustShopViewModel model)
{
if (!ModelState.IsValid)
{
var errors = ModelState.Values.SelectMany(x => x.Errors.Select(xx => xx.ErrorMessage)).ToList();
errors.ForEach(x => ModelState.AddModelError("", x));
model.RustCategoryEditViewModel.Status = RustEditCategoryResult.Failed;
return(View(model));
}
var result = await _rustShopService.UpdateCategoryAsync(model);
model.RustCategoryEditViewModel.Status = result.Item2;
switch (result.Item2)
{
case RustEditCategoryResult.Success:
return(View(model));
case RustEditCategoryResult.Created:
return(RedirectToAction("EditCategory", "RustShop", new { shopId = model.Id, categoryId = result.Item1.Id, created = true }));
case RustEditCategoryResult.Failed:
return(View(model));
default: return(RedirectToAction("SomethingWentWrong", "ControlPanel"));
}
}
public async Task <IActionResult> EditMainSettings([FromForm] RustShopViewModel model)
{
if (!ModelState.IsValid)
{
var errors = ModelState.Values.SelectMany(x => x.Errors.Select(xx => xx.ErrorMessage)).ToList();
errors.ForEach(x => ModelState.AddModelError("", x));
var shop = _shopService.GetShopById(Guid.Parse(model.Id));
model.RustShopEditMainSettingsViewModel.Secret = shop.Secret;
model.RustShopEditMainSettingsViewModel.Status = RustEditMainSettingsResult.Failed;
return(View(model));
}
var result = await _rustShopService.UpdateShopAsync(model.RustShopEditMainSettingsViewModel);
if (result is null)
{
return(RedirectToAction("SomethingWentWrong", "ControlPanel"));
}
model = result.CreateRustShopViewModel();
model.RustShopEditMainSettingsViewModel.Status = RustEditMainSettingsResult.Updated;
return(View(model));
}
private static RustShopViewModel CopyToRustShopViewModel(this Shop shop)
{
var model = new RustShopViewModel
{
Id = shop.Id.ToString(),
ShopName = shop.ShopName,
ShopTitle = shop.ShopTitle,
RustShopEditMainSettingsViewModel = shop.CreateMainSettingsViewModel(),
RustCategoryEditViewModel = new RustCategoryEditViewModel(),
RustShopStatsViewModel = new RustShopStatsViewModel()
};
return(model);
}
public async Task <IActionResult> EditProduct(RustShopViewModel model)
{
var userCategories = _rustShopService.GetAllAssignedCategoriesToShopByShopId(Guid.Parse(model.Id));
var product = await _rustShopService.GetProductById(Guid.Parse(model.RustProductEditViewModel.Id));
if (!ModelState.IsValid)
{
var errors = ModelState.Values.SelectMany(x => x.Errors.Select(xx => xx.ErrorMessage)).ToList();
errors.ForEach(x => ModelState.AddModelError("", x));
bool showInShopValue = model.RustProductEditViewModel.ShowInShop;
model.RustProductEditViewModel = product.CreateRustEditProductViewModel(userCategories);
model.RustProductEditViewModel.Status = RustEditProductResult.Failed;
model.RustProductEditViewModel.ShowInShop = showInShopValue;
return(View(model));
}
var result = await _rustShopService.UpdateRustProductAsync(model);
var updatedProduct = await _rustShopService.GetProductById(Guid.Parse(model.RustProductEditViewModel.Id));
model.RustProductEditViewModel = updatedProduct.CreateRustEditProductViewModel(userCategories);
if (result == RustEditProductResult.Success)
{
model.RustProductEditViewModel.Status = RustEditProductResult.Success;
return(View(model));
}
else if (result == RustEditProductResult.DateHaveToBeBiggerThanCurrentMoment)
{
model.RustProductEditViewModel.Status = RustEditProductResult.DateHaveToBeBiggerThanCurrentMoment;
return(View(model));
}
else if (result == RustEditProductResult.NotFound)
{
return(RedirectToAction("NotFoundPage", "Home"));
}
return(RedirectToAction("SomethingWentWrong", "ControlPanel"));
}
public async Task <RustEditProductResult> UpdateRustProductAsync(RustShopViewModel model)
{
var shop = GetShopById(Guid.Parse(model.Id));
var product =
_easyShopContext.RustUserItems.FirstOrDefault(x => x.Id == Guid.Parse(model.RustProductEditViewModel.Id));
var userForLog = await _userManager.FindByEmailAsync(_httpContextAccessor.HttpContext.User.Identity.Name);
if (shop is null || product is null)
{
return(RustEditProductResult.NotFound);
}
if (!model.RustProductEditViewModel.ShowInShop)
{
product.ShowInShop = false;
_easyShopContext.RustUserItems.Update(product);
await _easyShopContext.SaveChangesAsync();
_logger.LogInformation("UserName: {0} | UserId: {1} | Request: {2} | Message: {3}",
userForLog.UserName,
userForLog.Id,
_httpContextAccessor.HttpContext.Request.GetRawTarget(),
$"Rust product was successfully updated. ItemId: {product.Id}");
return(RustEditProductResult.Success);
}
product.ShowInShop = true;
product.Name = model.RustProductEditViewModel.Name;
product.Description = model.RustProductEditViewModel.Description;
product.Price = model.RustProductEditViewModel.Price;
product.Discount = model.RustProductEditViewModel.Discount;
product.ItemsPerStack = model.RustProductEditViewModel.Amount;
product.Index = model.RustProductEditViewModel.Index;
if (model.RustProductEditViewModel.BlockedTill != null)
{
var dateFromModel = model.RustProductEditViewModel.BlockedTill.Split('/');
var blockedTillDate = new DateTime(int.Parse(dateFromModel[2]), int.Parse(dateFromModel[0]), int.Parse(dateFromModel[1]));
long blockedTillTicks = blockedTillDate.Ticks;
long currentMoment = DateTime.Now.Ticks;
if (blockedTillTicks - currentMoment < 1)
{
return(RustEditProductResult.DateHaveToBeBiggerThanCurrentMoment);
}
product.BlockedTill = blockedTillDate;
}
if (model.RustProductEditViewModel.NewCategoryId != null)
{
product.RustCategory = GetCategoryById(Guid.Parse(model.RustProductEditViewModel.NewCategoryId));
}
_easyShopContext.RustUserItems.Update(product);
await _easyShopContext.SaveChangesAsync();
_logger.LogInformation("UserName: {0} | UserId: {1} | Request: {2} | Message: {3}",
userForLog.UserName,
userForLog.Id,
_httpContextAccessor.HttpContext.Request.GetRawTarget(),
$"Rust product was successfully updated. ItemId: {product.Id}");
return(RustEditProductResult.Success);
}
public async Task <(RustCategory, RustEditCategoryResult)> UpdateCategoryAsync(RustShopViewModel model)
{
var userForLog = await _userManager.FindByEmailAsync(_httpContextAccessor.HttpContext.User.Identity.Name);
if (model.RustCategoryEditViewModel.Category.Id is null)
{
var shop = GetShopById(Guid.Parse(model.Id));
if (shop is null)
{
return(null, RustEditCategoryResult.Failed);
}
RustCategory newCategory = new RustCategory
{
Id = Guid.NewGuid(),
Index = 1,
Name = model.RustCategoryEditViewModel.Category.Name,
AppUser = await _userManager.FindByEmailAsync(_httpContextAccessor.HttpContext.User.Identity.Name),
Shop = shop
};
_easyShopContext.RustCategories.Add(newCategory);
await _easyShopContext.SaveChangesAsync();
_logger.LogInformation("UserName: {0} | UserId: {1} | Request: {2} | Message: {3}",
userForLog.UserName,
userForLog.Id,
_httpContextAccessor.HttpContext.Request.GetRawTarget(),
$"Description was successfully created. CategoryId: {newCategory.Id}");
return(newCategory, RustEditCategoryResult.Created);
}
var category = GetCategoryById(Guid.Parse(model.RustCategoryEditViewModel.Category.Id));
if (category is null)
{
return(null, RustEditCategoryResult.Failed);
}
category.Index = model.RustCategoryEditViewModel.Category.Index;
category.Name = model.RustCategoryEditViewModel.Category.Name;
_easyShopContext.RustCategories.Update(category);
await _easyShopContext.SaveChangesAsync();
_logger.LogInformation("UserName: {0} | UserId: {1} | Request: {2} | Message: {3}",
userForLog.UserName,
userForLog.Id,
_httpContextAccessor.HttpContext.Request.GetRawTarget(),
$"Description was successfully updated. CategoryId: {category.Id}");
return(category, RustEditCategoryResult.Success);
}
public async Task <(RustEditServerResult, string)> UpdateAsync(RustShopViewModel model)
{
var shop = _context.Shops.FirstOrDefault(x => x.Id == Guid.Parse(model.Id));
var userForLog = await _userManager.FindByEmailAsync(_httpContextAccessor.HttpContext.User.Identity.Name);
if (shop is null)
{
return(RustEditServerResult.NotFound, string.Empty);
}
if (model.RustServerEditViewModel.Id is null)
{
var newServerId = Guid.NewGuid();
var newServer = new RustServer
{
Id = newServerId,
Name = model.RustServerEditViewModel.Name,
NameInShop = model.RustServerEditViewModel.NameInShop,
Index = model.RustServerEditViewModel.Index,
IpAddress = model.RustServerEditViewModel.IpAddress,
Port = model.RustServerEditViewModel.Port,
ShowInShop = model.RustServerEditViewModel.ShowInShop,
Shop = shop,
ServerMap = _context.RustServerMaps.First(x =>
x.Id == Guid.Parse(model.RustServerEditViewModel.MapId))
};
_context.RustServers.Add(newServer);
await _context.SaveChangesAsync();
_logger.LogInformation("UserName: {0} | UserId: {1} | Request: {2} | PostMessage: {3}",
userForLog.UserName,
userForLog.Id,
_httpContextAccessor.HttpContext.Request.GetRawTarget(),
$"Server was successfully created. ServerId: {newServer.Id}");
return(RustEditServerResult.Created, newServerId.ToString());
}
var server = _context.RustServers.FirstOrDefault(x => x.Id == Guid.Parse(model.RustServerEditViewModel.Id));
if (server is null)
{
return(RustEditServerResult.NotFound, String.Empty);
}
server.Name = model.RustServerEditViewModel.Name;
server.NameInShop = model.RustServerEditViewModel.NameInShop;
server.Index = model.RustServerEditViewModel.Index;
server.IpAddress = model.RustServerEditViewModel.IpAddress;
server.Port = model.RustServerEditViewModel.Port;
server.ShowInShop = model.RustServerEditViewModel.ShowInShop;
server.Shop = shop;
if (model.RustServerEditViewModel.MapId != null)
{
var map = _context.RustServerMaps.FirstOrDefault(x =>
x.Id == Guid.Parse(model.RustServerEditViewModel.MapId));
server.ServerMap = map;
}
_context.RustServers.Update(server);
await _context.SaveChangesAsync();
_logger.LogInformation("UserName: {0} | UserId: {1} | Request: {2} | PostMessage: {3}",
userForLog.UserName,
userForLog.Id,
_httpContextAccessor.HttpContext.Request.GetRawTarget(),
$"Server was successfully updated. ServerId: {server.Id}");
return(RustEditServerResult.Updated, server.Id.ToString());
}
