public async Task <ActionResult <IEnumerable <Category> > > GetCategory()
{
var parentCategories = await _bll.CategoryService.GetAllParentCategoriesAsync();
var result = parentCategories.Select(c => _categoryMapper.Map(c));
return(Ok(result));
}
public override void Execute(object parameter)
{
List <Category> categories = DB.CategoryRepository.Get();
List <CategoryModel> categoryModels = new List <CategoryModel>();
CategoryMapper categoryMapper = new CategoryMapper();
for (int i = 0; i < categories.Count; i++)
{
Category category = categories[i];
CategoryModel categoryModel = categoryMapper.Map(category);
categoryModel.No = i + 1;
categoryModels.Add(categoryModel);
}
Enumeration.Enumerate(categoryModels);
CategoryViewModel categoryViewModel = new CategoryViewModel();
categoryViewModel.AllCategories = categoryModels;
categoryViewModel.Categories = new ObservableCollection <CategoryModel>(categoryModels);
CategoriesControl categoriesControl = new CategoriesControl();
categoriesControl.DataContext = categoryViewModel;
MainWindow mainWindow = (MainWindow)mainViewModel.Window;
mainWindow.GrdCenter.Children.Clear();
mainWindow.GrdCenter.Children.Add(categoriesControl);
}
public async Task <IActionResult> PutCategory(Guid id, V1DTO.Category category)
{
if (id != category.Id)
{
return(BadRequest(new V1DTO.MessageDTO("Id and Category.Id do not match")));
}
if (!await _bll.Addresses.ExistsAsync(category.Id))
{
return(NotFound(new V1DTO.MessageDTO($"Current user does not have session with this id {id}")));
}
await _bll.Categories.UpdateAsync(_mapper.Map(category));
await _bll.SaveChangesAsync();
return(NoContent());
}
public IActionResult SaveCategory(CategoryModel categoryModel)
{
if (ModelState.IsValid == false)
{
return(Content("Model is invalid"));
}
CategoryMapper mapper = new CategoryMapper();
Category category = mapper.Map(categoryModel);
//ERROR: category.Creator = CurrentUser;
if (category.Id != 0)
{
DB.CategoryRepository.Update(category);
}
else
{
DB.CategoryRepository.Add(category);
}
TempData["Message"] = "Saved successfully";
return(RedirectToAction("Index"));
}
public async Task <CategoryDto> AddAsync(int userId, CategoryDto dto)
{
var model = CategoryMapper.Map(dto);
var newModel = await _categoryRepository.AddAsync(userId, model);
var result = CategoryDtoMapper.Map(newModel);
return(result);
}
public CategoryDTO GetById(int?id)
{
if (id == null)
{
throw new ArgumentNullException();
}
else
{
var category = UnitOfWork.CategoryRepository.GetById(id);
return(CategoryMapper.Map(category));
}
}
public IEnumerable <BLLCategory> Find(string stringKey)
{
var categories = uow.Categories.GetAll();
if (!ReferenceEquals(stringKey, null))
{
categories = categories.Where(c => c.Name.Contains(stringKey));
}
return(CategoryMapper.Map(categories));
}
public void MapCategoryToCategoryViewModel()
{
var category = new Category
{
Id = 2,
Description = "Category Description"
};
var mapper = new CategoryMapper();
var viewModel = mapper.Map(category);
Assert.Equal(category.Id, viewModel.Id);
Assert.Equal(category.Description, viewModel.Description);
}
public void MapCategoryViewModelToCategory()
{
var viewModel = new CategoryViewModel
{
Id = 2,
Description = "Category Description"
};
var mapper = new CategoryMapper();
var category = mapper.Map(viewModel);
Assert.Equal(viewModel.Id, category.Id);
Assert.Equal(viewModel.Description, category.Description);
}
public List <DALCategory> GetUserSpheres(int userId)
{
var sphereInCategories = CategoryMapper.Map(context.Set <Category>().Select(c => c).Include(c => c.Sphere));
foreach (var item in sphereInCategories)
{
foreach (var sphere in item.Sphere)
{
var userSphere = context.Set <Programmer_Sphere>().FirstOrDefault(us => us.IdProgrammer == userId && us.IdSphere == sphere.Id);
sphere.Level = ReferenceEquals(context.Set <Programmer_Sphere>(), null) ? 0 : (int)userSphere.Level;
}
}
return(sphereInCategories.ToList());
}
public ActionResult Index()
{
var id = Convert.ToInt16(User.Identity.GetUserId());
var userSpheres = CategoryMapper.Map(programmers.GetUserSpheres(id));
if (Request.IsAjaxRequest())
{
return(PartialView("_Spheres"));
}
else
{
return(View());
}
}
public async Task <ActionResult <IEnumerable <ItemDisplayView> > > IndexView(Guid?brandId)
{
var items = (await _bll.ItemService.AllAsync("", null,
(brandId == null) ? null : new List <Guid> {
(Guid)brandId
}));
var itemsView = new ItemDisplayView()
{
Items = items.Select(i => _itemMapper.MapToItemDisplay(i)),
Categories = _bll.CategoryService.GetAllSubCategoriesAsync().Result.Select(c => _categoryMapper.Map(c)),
Brands = _bll.BrandService.AllAsync().Result.Select(b => _brandMapper.Map(b))
};
return(Ok(itemsView));
}
public async Task <CategoryResponse> GetById(Guid categoryId)
{
Category category = await _categoryRepository.FindById(categoryId);
if (category == null)
{
string errorMessage = "Category not found.";
Log.Error(errorMessage);
return(new CategoryResponse(errorMessage));
}
return(new CategoryResponse(CategoryMapper.Map(category)));
}
public async Task <CategoryDto> UpdateAsync(int userId, CategoryDto dto)
{
var model = await _categoryRepository.GetAsync(userId, dto.Id);
if (model == null)
{
return(null);
}
CategoryMapper.Map(dto, model);
await _categoryRepository.SaveChangesAsync(userId);
// Return a fresh copy of the saved object.
return(await GetAsync(userId, model.Id));
}
public IEnumerable <CategoryDTO> GetCategoriesWithFilter(IEnumerable <PropertyFilterDTO> propertyFilters)
{
if (propertyFilters == null)
{
throw new ArgumentNullException();
}
else
{
Filter <Category> filter = new Filter <Category>();
foreach (PropertyFilterDTO propertyFilter in propertyFilters)
{
if (propertyFilter.PropertyId == null)
{
throw new ArgumentNullException();
}
else if (propertyFilter.PropertyId.CompareTo("Id") != 0 && propertyFilter.PropertyId.CompareTo("Name") != 0)
{
throw new ArgumentException();
}
else
{
var type = (new Category()).GetType().GetProperty(propertyFilter.PropertyId).PropertyType;
if (propertyFilter.Value != null && propertyFilter.Value2 != null)
{
var value1 = Convert.ChangeType(propertyFilter.Value, type);
var value2 = Convert.ChangeType(propertyFilter.Value2, type);
filter.By(propertyFilter.PropertyId, propertyFilter.Operation, value1,
value2, propertyFilter.Connector);
}
else if (propertyFilter.Value != null)
{
var value1 = Convert.ChangeType(propertyFilter.Value, type);
filter.By(propertyFilter.PropertyId, propertyFilter.Operation, value1, null, propertyFilter.Connector);
}
else
{
filter.By(propertyFilter.PropertyId, propertyFilter.Operation, propertyFilter.Connector);
}
}
}
var categories = UnitOfWork.CategoryRepository.Get(filter);
return(CategoryMapper.Map(categories));
}
}
public IActionResult GetCategory(int id)
{
if (id != 0)
{
Category category = DB.CategoryRepository.Get(id);
if (category == null)
{
return(Content("Filial tapılmadı"));
}
CategoryMapper mapper = new CategoryMapper();
CategoryModel model = mapper.Map(category);
return(View(model));
}
return(View(new CategoryModel()));
}
public CategoryDTO Create(CategoryDTO dto)
{
if (dto == null)
{
throw new ArgumentNullException();
}
else if (UnitOfWork.CategoryRepository.Get((c => c.Name == dto.Name)).FirstOrDefault() != null)
{
throw new ArgumentException("Entity already exist");
}
else
{
var entity = CategoryMapper.Map(dto);
UnitOfWork.CategoryRepository.Insert(entity);
UnitOfWork.Save();
var created = UnitOfWork.CategoryRepository.Get((c => c.Name == dto.Name)).FirstOrDefault();
return(CategoryMapper.Map(created));
}
}
private List <MvcCategory> FindSpheres(string sphere, string category)
{
var mvcCategories = CategoryMapper.Map(categories.GetAll());
if (!ReferenceEquals(category, null) && category != "")
{
mvcCategories = mvcCategories.Where(s => s.Name == category).ToList();
}
if (!ReferenceEquals(sphere, null) && sphere != "")
{
foreach (var item in mvcCategories)
{
item.Sphere = item.Sphere.Where(s => s.Name.Contains(sphere)).ToList();
}
}
return(mvcCategories.Where(c => c.Sphere.Count > 0).ToList());
}
public IActionResult Index()
{
ViewBag.Message = TempData["Message"];
List <Category> categories = DB.CategoryRepository.Get();
ViewModel <CategoryModel> viewModel = new ViewModel <CategoryModel>();
CategoryMapper categoryMapper = new CategoryMapper();
foreach (var category in categories)
{
var categoryModel = categoryMapper.Map(category);
viewModel.Models.Add(categoryModel);
}
Enumeration <CategoryModel> .Enumerate(viewModel.Models);
return(View(viewModel));
}
public override void Execute(object parameter)
{
// TODO: Step1. Validate Model-xeta mesajlarini cixar
CategoryMapper categoryMapper = new CategoryMapper();
Category category = categoryMapper.Map(categoryAddViewModel.CurrentCategory);
category.Creator = Kernel.CurrentUser;
if (category.Id != 0)
{
DB.CategoryRepository.Update(category);
}
else
{
DB.CategoryRepository.Add(category);
}
MessageBox.Show(UIMessages.OperationSuccessMessage, "Information", MessageBoxButton.OK, MessageBoxImage.Information);
categoryAddViewModel.CurrentWindow.Close();
}
public async Task <CategoryResponse> Create(CreateCategoryRequest createCategoryRequest)
{
Category category = CategoryMapper.Map(createCategoryRequest);
try
{
Category createdCategory = _categoryRepository.Create(category);
await _context.SaveChangesAsync();
return(new CategoryResponse(CategoryMapper.Map(createdCategory)));
}
catch (Exception ex)
{
string errorMessage = $"An error occurred when creating the category: {ex.Message}";
Log.Error <string>(ex, $"An error occurred when creating the category: {category}", JsonSerializer.Serialize(category));
return(new CategoryResponse(errorMessage));
}
}
public override void Execute(object parameter)
{
SureDialogViewModel sureViewModel = new SureDialogViewModel();
sureViewModel.DialogText = UIMessages.DeleteSureMessage;
SureDialog dialog = new SureDialog();
dialog.DataContext = sureViewModel;
dialog.ShowDialog();
if (dialog.DialogResult == true)
{
CategoryMapper mapper = new CategoryMapper();
Category category = mapper.Map(categoryViewModel.CurrentCategory);
category.IsDeleted = true;
category.Creator = Kernel.CurrentUser;
DB.CategoryRepository.Update(category);
int no = categoryViewModel.SelectedCategory.No;
categoryViewModel.Categories.Remove(categoryViewModel.SelectedCategory);
List <CategoryModel> modelList = categoryViewModel.Categories.ToList();
Enumeration.Enumerate(modelList, no - 1);
categoryViewModel.AllCategories = modelList;
categoryViewModel.UpdateDataFiltered();
categoryViewModel.SelectedCategory = null;
categoryViewModel.CurrentCategory = new CategoryModel();
MessageBox.Show(UIMessages.OperationSuccessMessage, "Information", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
public override void Execute(object parameter)
{
CategoryAddWindow categoryAddWindow = new CategoryAddWindow();
CategoryAddViewModel categoryAddViewModel = new CategoryAddViewModel
{
CurrentCategory = categoryViewModel.CurrentCategory,
CurrentWindow = categoryAddWindow
};
categoryAddWindow.DataContext = categoryAddViewModel;
categoryAddWindow.WindowStyle = System.Windows.WindowStyle.None;
categoryAddWindow.AllowsTransparency = true;
categoryAddWindow.WindowStartupLocation = System.Windows.WindowStartupLocation.CenterScreen;
categoryAddWindow.ShowDialog();
List <Category> categories = DB.CategoryRepository.Get();
List <CategoryModel> categoryModels = new List <CategoryModel>();
CategoryMapper categoryMapper = new CategoryMapper();
for (int i = 0; i < categories.Count; i++)
{
Category category = categories[i];
CategoryModel categoryModel = categoryMapper.Map(category);
categoryModels.Add(categoryModel);
}
Enumeration.Enumerate(categoryModels);
categoryViewModel.AllCategories = categoryModels;
categoryViewModel.Categories = new ObservableCollection <CategoryModel>(categoryModels);
categoryViewModel.CurrentCategory = new CategoryModel();
}
public IEnumerable <BLLCategory> GetUserSpheres(int userId)
{
return(CategoryMapper.Map(uow.Spheres.GetUserSpheres(userId)));
}
public IEnumerable <BLLCategory> GetAll()
{
return(CategoryMapper.Map(uow.Categories.GetAll()));
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
CategoryMapper.Map(modelBuilder);
AuthorMapper.Map(modelBuilder);
BookMapper.Map(modelBuilder);
}
public override void Execute(object parameter)
{
//OrderAddViewModel addViewModel = new OrderAddViewModel();
//OrderAddWindow addWindow = new OrderAddWindow();
//addViewModel.DetailPanel = addWindow.DetailPanel;
//addViewModel.DetailPanel.Children.Add(new SingleOrderDetailControl());
//addWindow.DataContext = addViewModel;
//addWindow.ShowDialog();
//return;
ProductAddWindow productAddWindow = new ProductAddWindow();
ProductAddViewModel productAddViewModel = new ProductAddViewModel
{
CurrentProduct = productViewModel.CurrentProduct,
CurrentWindow = productAddWindow
};
#region Category-for Combobox
List <Category> categories = DB.CategoryRepository.Get();
List <CategoryModel> categoryModels = new List <CategoryModel>();
CategoryMapper categoryMapper = new CategoryMapper();
for (int i = 0; i < categories.Count; i++)
{
Category category = categories[i];
CategoryModel categoryModel = categoryMapper.Map(category);
categoryModels.Add(categoryModel);
}
productAddViewModel.Categories = categoryModels;
#endregion
productAddWindow.DataContext = productAddViewModel;
productAddWindow.WindowStyle = System.Windows.WindowStyle.None;
productAddWindow.AllowsTransparency = true;
productAddWindow.WindowStartupLocation = System.Windows.WindowStartupLocation.CenterScreen;
productAddWindow.ShowDialog();
// Refresh products list
List <Product> products = DB.ProductRepository.Get();
List <ProductModel> productModels = new List <ProductModel>();
ProductMapper productMapper = new ProductMapper();
for (int i = 0; i < products.Count; i++)
{
Product product = products[i];
ProductModel productModel = productMapper.Map(product);
productModels.Add(productModel);
}
Enumeration.Enumerate(productModels);
productViewModel.AllProducts = productModels;
productViewModel.Products = new ObservableCollection <ProductModel>(productModels);
productViewModel.CurrentProduct = new ProductModel();
}
public async Task <CategoryDto> Get(int id)
{
var category = await this.unitOfWork.CategoryRepository.Get(id);
return(CategoryMapper.Map(category));
}
public void UpdateCategory(CategoryDto category)
{
_repository.Update(CategoryMapper.Map(category));
_unitOfWork.SaveChanges();
}
public async Task <ActionResult <IEnumerable <ItemDisplayView> > > IndexView(string?search = "")
{
var items = (await _bll.ItemService.AllAsync(search));
var itemsView = new ItemDisplayView()
{
Items = items.Select(i => _itemMapper.MapToItemDisplay(i)),
Categories = _bll.CategoryService.GetAllSubCategoriesAsync().Result.Select(c => _categoryMapper.Map(c)),
Brands = _bll.BrandService.AllAsync().Result.Select(b => _brandMapper.Map(b))
};
return(Ok(itemsView));
}
