public ViewModels.CategoryViewModel Execute(ViewModels.CategoryViewModel request)
{
//ValidateCategory(request);
UnitOfWork.BeginTransaction();
Models.ProductCategory category;
if (!request.Id.HasDefaultValue())
{
category = Repository
.AsQueryable <Models.ProductCategory>()
.Where(c => c.Id == request.Id)
.ToList()
.FirstOne();
}
else
{
category = new Models.ProductCategory();
}
category.Version = request.Version;
category.Name = request.Name;
category.Name_en = request.Name_en;
category.ParentId = request.ParentId;
category.SortOrder = request.SortOrder;
Repository.Save(category);
UnitOfWork.Commit();
return(new ViewModels.CategoryViewModel
{
Id = category.Id,
Name = category.Name,
Name_en = category.Name_en,
Version = category.Version,
ParentId = category.ParentId,
SortOrder = category.SortOrder
});
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
ProductCategory = await _context.ProductCategory.FirstOrDefaultAsync(m => m.ProductCategoryId == id);
if (ProductCategory == null)
{
return(NotFound());
}
return(Page());
}
public ActionResult Create(ECommerce.ViewModels.ProductCategoryCreateViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
using (var db = new ECommerceDB())
{
var category = new Models.ProductCategory
{
Name = model.Name,
};
db.ProductCategories.Add(category);
db.SaveChanges();
}
return(RedirectToAction("Index", "Home", new { area = "" }));
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
ProductCategory = await _context.ProductCategory.FindAsync(id);
if (ProductCategory != null)
{
_context.ProductCategory.Remove(ProductCategory);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public ActionResult CreateCategory(ViewModels.CategoryCreateViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
using (var db = new Models.DBModel())
{
var category = new Models.ProductCategory
{
id = model.id,
name = model.name
};
db.ProductCategories.Add(category);
db.SaveChanges();
}
return(RedirectToAction("Index"));
}
private void SaveButton_Click(object sender, EventArgs e)
{
string code = codeTextBox.Text.Trim();
string name = nameTextBox.Text.Trim();
if (!CheckValidation(code, name))
{
MessageBox.Show("Invalid Inputs");
}
Models.ProductCategory productCategory = new Models.ProductCategory();
productCategory.Code = code;
productCategory.CategoryName = name;
BLL.ProductCategory _productCategory = new BLL.ProductCategory();
if (!_productCategory.AddProductCategory(productCategory))
{
return;
}
DisplayProductCategories();
}
public async Task <bool> Update(ShopAggregate shop)
{
if (shop == null)
{
throw new ArgumentNullException(nameof(shop));
}
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
var record = await _context.Shops
.Include(s => s.Comments)
.Include(s => s.ProductCategories)
.Include(s => s.ShopTags)
.Include(c => c.ShopGameEntities).ThenInclude(s => s.GameEntity)
.Include(s => s.Filters).ThenInclude(f => f.Values)
.FirstOrDefaultAsync(s => s.Id == shop.Id).ConfigureAwait(false);
if (record == null)
{
transaction.Rollback();
return(false);
}
record.BannerImage = shop.BannerImage;
record.CategoryId = shop.CategoryId;
record.Country = shop.Country;
record.Description = shop.Description;
record.GooglePlaceId = shop.GooglePlaceId;
record.Latitude = shop.Latitude;
record.Locality = shop.Locality;
record.Longitude = shop.Longitude;
record.Name = shop.Name;
record.PostalCode = shop.PostalCode;
record.ProfileImage = shop.ProfileImage;
record.StreetAddress = shop.StreetAddress;
record.Subject = shop.Subject;
record.TotalScore = shop.TotalScore;
record.AverageScore = shop.AverageScore;
record.UpdateDateTime = shop.UpdateDateTime;
var tags = new List <Models.ShopTag>(); // Update tags.
var shopTags = shop.TagNames == null ? new List <string>() : shop.TagNames;
var tagNames = shop.TagNames;
var connectedTags = _context.Tags.Where(t => tagNames.Any(tn => t.Name == tn));
foreach (var connectedTag in connectedTags)
{
tags.Add(new Models.ShopTag
{
Id = Guid.NewGuid().ToString(),
TagName = connectedTag.Name,
ShopId = shop.Id
});
}
var connectedTagNames = (await connectedTags.Select(t => t.Name).ToListAsync().ConfigureAwait(false));
foreach (var notExistingTagName in tagNames.Where(tn => !connectedTagNames.Contains(tn)))
{
var newTag = new Models.Tag
{
Name = notExistingTagName,
Description = notExistingTagName
};
_context.Tags.Add(newTag);
tags.Add(new Models.ShopTag
{
Id = Guid.NewGuid().ToString(),
TagName = notExistingTagName,
ShopId = shop.Id,
Tag = newTag
});
}
record.ShopTags = tags;
var productCategories = shop.ProductCategories == null ? new List <ShopProductCategory>() : shop.ProductCategories;
var productCategoryIds = productCategories.Select(p => p.Id);
var productCategoriesToUpdate = record.ProductCategories.Where(c => productCategoryIds.Contains(c.Id));
var productCategoriesToRemove = record.ProductCategories.Where(c => !productCategoryIds.Contains(c.Id));
var existingCategoryIds = record.ProductCategories.Select(c => c.Id);
var productCategoriesToAdd = productCategories.Where(c => !existingCategoryIds.Contains(c.Id));
foreach (var productCategoryToUpdate in productCategoriesToUpdate)
{
var productCategory = productCategories.First(p => p.Id == productCategoryToUpdate.Id);
productCategoryToUpdate.Name = productCategory.Name;
productCategoryToUpdate.UpdateDateTime = productCategory.UpdateDateTime;
productCategoryToUpdate.Description = productCategory.Description;
}
foreach (var productCategoryToRemove in productCategoriesToRemove)
{
_context.ProductCategories.Remove(productCategoryToRemove);
}
foreach (var productCategoryToAdd in productCategoriesToAdd)
{
var rec = new Models.ProductCategory
{
Id = productCategoryToAdd.Id,
Description = productCategoryToAdd.Description,
Name = productCategoryToAdd.Name,
CreateDateTime = productCategoryToAdd.CreateDateTime,
UpdateDateTime = productCategoryToAdd.UpdateDateTime,
ShopId = shop.Id
};
_context.ProductCategories.Add(rec);
}
var filters = shop.ShopFilters == null ? new List <ShopFilter>() : shop.ShopFilters; // Update filters.
var filterIds = filters.Select(c => c.Id);
var filtersToUpdate = record.Filters.Where(c => filterIds.Contains(c.Id));
var filtersToRemove = record.Filters.Where(c => !filterIds.Contains(c.Id));
var existingFilterIds = record.Filters.Select(c => c.Id);
var filtersToAdd = filters.Where(c => !existingFilterIds.Contains(c.Id));
foreach (var filterToUpdate in filtersToUpdate)
{
var filter = filters.First(c => c.Id == filterToUpdate.Id);
filterToUpdate.Name = filter.Name;
var filterValues = filter.Values == null ? new List <ShopFilterValue>() : filter.Values;
var filterValueIds = filterValues.Select(f => f.Id);
var filterValuesToUpdate = filterToUpdate.Values.Where(v => filterValueIds.Contains(v.Id)); // Update filter values.
var filterValuesToRemove = filterToUpdate.Values.Where(v => !filterValueIds.Contains(v.Id));
var existingFilterValueIds = filterToUpdate.Values.Select(v => v.Id);
var filterValuesToAdd = filter.Values.Where(v => !existingFilterValueIds.Contains(v.Id));
foreach (var filterValueToUpdate in filterValuesToUpdate)
{
var filterValue = filterToUpdate.Values.First(v => v.Id == filterValueToUpdate.Id);
filterValue.UpdateDateTime = filterValueToUpdate.UpdateDateTime;
filterValue.Content = filterValueToUpdate.Content;
}
foreach (var filterValueToRemove in filterValuesToRemove)
{
_context.FilterValues.Remove(filterValueToRemove);
}
foreach (var filterValueToAdd in filterValuesToAdd)
{
var rec = new Models.FilterValue
{
Id = filterValueToAdd.Id,
Content = filterValueToAdd.Content,
CreateDateTime = filterValueToAdd.CreateDateTime,
UpdateDateTime = filterValueToAdd.UpdateDateTime,
FilterId = filter.Id
};
_context.FilterValues.Add(rec);
}
}
foreach (var filterToRemove in filtersToRemove)
{
_context.Filters.Remove(filterToRemove);
}
foreach (var filterToAdd in filtersToAdd)
{
var rec = new Models.Filter
{
Id = filterToAdd.Id,
Name = filterToAdd.Name,
ShopId = shop.Id,
Values = filterToAdd.Values == null ? new List <Models.FilterValue>() : filterToAdd.Values.Select(v => new Models.FilterValue
{
Id = v.Id,
Content = v.Content,
CreateDateTime = v.CreateDateTime,
UpdateDateTime = v.UpdateDateTime,
FilterId = filterToAdd.Id
}).ToList()
};
_context.Filters.Add(rec);
}
var comments = shop.Comments == null ? new List <ShopComment>() : shop.Comments; // Update comments
var commentIds = comments.Select(c => c.Id);
var commentsToUpdate = record.Comments.Where(c => commentIds.Contains(c.Id));
var commentsToRemove = record.Comments.Where(c => !commentIds.Contains(c.Id));
var existingCommentIds = record.Comments.Select(c => c.Id);
var commentsToAdd = comments.Where(c => !existingCommentIds.Contains(c.Id));
foreach (var commentToUpdate in commentsToUpdate)
{
var comment = comments.First(c => c.Id == commentToUpdate.Id);
commentToUpdate.Score = comment.Score;
commentToUpdate.Subject = comment.Subject;
commentToUpdate.UpdateDateTime = comment.UpdateDateTime;
commentToUpdate.Content = comment.Content;
}
foreach (var commentToRemove in commentsToRemove)
{
_context.Comments.Remove(commentToRemove);
}
foreach (var commentToAdd in commentsToAdd)
{
var rec = new Models.Comment
{
Id = commentToAdd.Id,
Content = commentToAdd.Content,
Score = commentToAdd.Score,
CreateDateTime = commentToAdd.CreateDateTime,
ShopId = shop.Id,
UpdateDateTime = commentToAdd.UpdateDateTime,
Subject = commentToAdd.Subject
};
_context.Comments.Add(rec);
}
var gameEntities = shop.ShopGameEntities == null ? new List <ShopAggregateGameEntity>() : shop.ShopGameEntities; // Update game entities.
var gameEntitiesId = gameEntities.Select(c => c.Id);
var gameEntitiesToUpdate = record.ShopGameEntities.Where(c => gameEntitiesId.Contains(c.Id));
var gameEntitiesToRemove = record.ShopGameEntities.Where(c => !gameEntitiesId.Contains(c.Id));
var existingGameEntitiesId = record.ShopGameEntities.Select(c => c.Id);
var gameEntitiesToAdd = gameEntities.Where(c => !existingGameEntitiesId.Contains(c.Id));
foreach (var gameEntityToUpdate in gameEntitiesToUpdate)
{
var gameEntity = gameEntities.First(c => c.Id == gameEntityToUpdate.Id);
gameEntityToUpdate.Col = gameEntity.Col;
gameEntityToUpdate.Row = gameEntity.Row;
gameEntityToUpdate.GameEntityId = gameEntity.Name;
gameEntityToUpdate.ProductCategoryId = gameEntity.ProductCategoryId;
gameEntityToUpdate.IsFlipped = gameEntity.IsFlipped;
}
foreach (var gameEntityToRemove in gameEntitiesToRemove)
{
_context.ShopGameEntities.Remove(gameEntityToRemove);
}
foreach (var gameEntityToAdd in gameEntitiesToAdd)
{
var rec = new Models.ShopGameEntity
{
Id = gameEntityToAdd.Id,
Col = gameEntityToAdd.Col,
Row = gameEntityToAdd.Row,
GameEntityId = gameEntityToAdd.Name,
ProductCategoryId = gameEntityToAdd.ProductCategoryId,
ShopId = shop.Id,
IsFlipped = gameEntityToAdd.IsFlipped
};
_context.ShopGameEntities.Add(rec);
}
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
return(true);
}
catch (Exception ex)
{
transaction.Rollback();
return(false);
}
}
}
private static IEnumerable <Models.Product> GenerateProductModel(IEnumerable <Product> products)
{
List <Models.Product> productsModel = new List <Models.Product>();
foreach (Product p in products)
{
Models.Product productModel = new Models.Product();
#region Get Basic Information
productModel.ProductID = p.ProductID;
productModel.Name = p.Name;
productModel.ProductNumber = p.ProductNumber;
productModel.Color = p.Color;
productModel.ListPrice = p.ListPrice;
#endregion
#region Get Photos
/* If executed without "includes" it generates a new connection per product item querying "ProductProductPhoto" table. */
/* If executed without "includes" it generates a new connection per product item querying "ProductPhoto" table, if each item has a different photo!
* Otherwise, use EF cache capabilities to retrieve previously returned photos avoiding hitting database. */
/* Overload: 1 * N + X (N => number of products, X => number of distinct photos over all products ) */
foreach (ProductProductPhoto x in p.ProductProductPhoto)
{
Models.ProductPhoto productPhoto = new Models.ProductPhoto();
productPhoto.ProductPhotoID = x.ProductPhoto.ProductPhotoID;
productPhoto.LargePhoto = x.ProductPhoto.LargePhoto;
productModel.ProductPhoto.Add(productPhoto);
}
#endregion
#region Get Reviews
/* If executed without "includes" it generates a new connection per product item querying "ProductReview" table. */
/* Overload: N (N => number of products) */
foreach (ProductReview x in p.ProductReview)
{
Models.ProductReview productReview = new Models.ProductReview();
productReview.ProductReviewID = x.ProductReviewID;
productReview.Comments = x.Comments;
productReview.Rating = x.Rating;
productModel.ProductReview.Add(productReview);
}
#endregion
#region Get Category
/* Without "includes" it generates a new connection for ProductCategory: Category => Bikes (1) */
/* Without "includes" it generates three new connections for ProductSubCategory: SubcategoryId => Mountain Bikes (1), Road Bikes (2) and Touring Bikes (3) */
/* After getting all the required categories and subcategories, EF uses cache capabilities to avoid hitting DB again if previous entities were retrieved */
/* Overload: 4 */
Models.ProductCategory category = new Models.ProductCategory();
if (p.ProductSubcategory != null)
{
category.ProductCategoryId = p.ProductSubcategory.ProductCategoryID;
category.CategoryName = p.ProductSubcategory.ProductCategory.Name;
category.ProductSubcategoryId = p.ProductSubcategory.ProductSubcategoryID;
category.SubcategoryName = p.ProductSubcategory.Name;
}
productModel.ProductCategory = category;
#endregion
productsModel.Add(productModel);
}
return(productsModel);
}
public bool AddProductCategory(Models.ProductCategory productCategory)
{
string commandString = @"INSERT INTO ProductCategories (Code, CategoryName) Values ('" + productCategory.Code + "','" + productCategory.CategoryName + "')";
return(ExecuteSQLNonQueryCommand(commandString));
}
private async Task <ApiResult <long> > Add(Model.CategoryPost.Submit.Input input)
{
var output = new ApiResult <long>();
if (string.IsNullOrEmpty(input.Name))
{
output.Msgs.Add(new MsgResult("name", "common.name_empty"));
}
else
{
var category = await _repository.CategoryGetQuery(new Model.Repository.CategoryGetQuery.Input {
Name = input.Name
}).Select(x => new Model.CategoryPost.Submit.Input
{
Name = x.Name
}).FirstOrDefaultAsync();
if (category != null)
{
output.Msgs.Add(new MsgResult("name", "common.name_duplicate"));
}
}
if (input.ParentId.HasValue == false)
{
output.Msgs.Add(new MsgResult("parent", "common.parent_empty"));
}
if (input.OrderNumber.HasValue == false)
{
output.Msgs.Add(new MsgResult("orderNumber", "common.order_empty"));
}
if (output.Msgs.Any())
{
return(output);
}
using (var transaction = await _unitOfWork.BeginTransactionAsync())
{
try
{
var treeData = await _tree.Insert <Models.ProductCategory>(new Common.Model.Tree.Insert.Input
{
ParentId = input.ParentId.Value,
OrderNumber = input.OrderNumber.Value
});
var item = new Models.ProductCategory
{
ParentId = input.ParentId,
OrderNumber = input.OrderNumber.Value,
Level = treeData.Level,
Name = input.Name,
Left = treeData.Left,
Right = treeData.Right,
PopularOrderNumber = input.PopularOrderNumber,
Icon = input.Icon,
};
await _unitOfWork._dbContext.ProductCategory.AddAsync(item);
await _unitOfWork.SaveChanges();
input.Id = item.Id;
if (input.FileList != null)
{
await _fileManage.Update(new File.Model.Manage.UpdateModel.Input
{
CategoryId = (long)Const.FileCategory.Category,
ItemId = input.Id.ToString(),
IsTemp = false,
FileList = input.FileList.Select((m, index) => new File.Model.Manage.UploadModel.File {
Id = m.Id, OrderNumber = index
}).ToList(),
});
}
transaction.Commit();
output.Code = Const.ApiCodeEnum.Success;
output.Data = item.Id;
}
catch (Exception ex)
{
transaction.Rollback();
_logger.Error(ex, ex.Message);
}
}
return(output);
}
public bool AddProductCategory(Models.ProductCategory productCategory)
{
Repository.ProductCatalog productCatalog = new Repository.ProductCatalog();
return(productCatalog.AddProductCategory(productCategory));
}
