public ViewResult AddCategory()
{
CategoryDetailViewModel model = new CategoryDetailViewModel();
model.Id = Guid.NewGuid();
return(View(model));
}
public async Task <ActionResultResponse <CategoryDetailViewModel> > GetDetail(string tenantId, int id)
{
var categoryInfo = await _categoryRepository.GetInfo(tenantId, id, true);
if (categoryInfo == null)
{
return(new ActionResultResponse <CategoryDetailViewModel>(-1, _resourceService.GetString("Category does not exists.")));
}
var categoryDetail = new CategoryDetailViewModel
{
Id = categoryInfo.Id,
ParentId = categoryInfo.ParentId,
ConcurrencyStamp = categoryInfo.ConcurrencyStamp,
IsActive = categoryInfo.IsActive,
Order = categoryInfo.Order,
BannerImage = categoryInfo.BannerImage,
IsHomePage = categoryInfo.IsHomePage,
CategoryTranslations = await _categoryTranslationRepository.GetByCategoryId(id)
};
return(new ActionResultResponse <CategoryDetailViewModel>
{
Data = categoryDetail
});
}
public async Task <ActionResult> SaveModify(CategoryDetailViewModel model)
{
using (CategoryDetailServiceClient client = new CategoryDetailServiceClient())
{
MethodReturnResult <CategoryDetail> result = await client.GetAsync(new CategoryDetailKey()
{
CategoryName = model.CategoryName,
ParameterName = model.ParameterName
});
if (result.Code == 0)
{
result.Data.ItemNo = model.ItemNo;
result.Data.Editor = User.Identity.Name;
result.Data.EditTime = DateTime.Now;
MethodReturnResult rst = await client.ModifyAsync(result.Data);
if (rst.Code == 0)
{
rst.Message = string.Format(EDCResources.StringResource.CategoryDetail_SaveModify_Success
, result.Data.Key);
}
return(Json(rst));
}
return(Json(result));
}
}
//
// GET: /EDC/CategoryDetail/Detail
public async Task <ActionResult> Detail(string categoryName, string parameterName)
{
using (CategoryDetailServiceClient client = new CategoryDetailServiceClient())
{
MethodReturnResult <CategoryDetail> result = await client.GetAsync(new CategoryDetailKey()
{
CategoryName = categoryName,
ParameterName = parameterName
});
if (result.Code == 0)
{
CategoryDetailViewModel viewModel = new CategoryDetailViewModel()
{
CategoryName = result.Data.Key.CategoryName,
ParameterName = result.Data.Key.ParameterName,
ItemNo = result.Data.ItemNo,
Editor = result.Data.Editor,
EditTime = result.Data.EditTime,
CreateTime = result.Data.CreateTime,
Creator = result.Data.Creator
};
return(PartialView("_InfoPartial", viewModel));
}
else
{
ModelState.AddModelError("", result.Message);
}
}
return(PartialView("_InfoPartial"));
}
public void Process(CategoryDetailViewModel category)
{
if (!IsValidImage(category.Picture))
{
category.Picture = category.Picture.Skip(BrokenBytesAmount).ToArray();
}
}
public async Task <ActionResult> Save(CategoryDetailViewModel model)
{
using (CategoryDetailServiceClient client = new CategoryDetailServiceClient())
{
CategoryDetail obj = new CategoryDetail()
{
Key = new CategoryDetailKey()
{
CategoryName = model.CategoryName.ToUpper(),
ParameterName = model.ParameterName.ToUpper()
},
ItemNo = model.ItemNo,
Editor = User.Identity.Name,
EditTime = DateTime.Now,
CreateTime = DateTime.Now,
Creator = User.Identity.Name
};
MethodReturnResult rst = await client.AddAsync(obj);
if (rst.Code == 0)
{
rst.Message = string.Format(EDCResources.StringResource.CategoryDetail_Save_Success
, obj.Key);
}
return(Json(rst));
}
}
public ServiceResult Add(CategoryDetailViewModel item)
{
var v_item = _mapper.Map <Category>(item);
m_Context.Categories.Add(v_item);
return(SaveChanges());
}
public async Task <ResultDataList <CategoryDetailViewModel> > SearchAsync(string filterExpression, int?pageIndex, int pageSize = 20, string culture = "fr")
{
if (string.IsNullOrEmpty(filterExpression))
{
return(new ResultDataList <CategoryDetailViewModel>(false));
}
var lambda = System.Linq.Dynamic.DynamicExpression.ParseLambda <Category, bool>(filterExpression);
var func = lambda.Compile();
var data = await _repository.SearchAsync(func, pageIndex, pageSize);
var translations = await _repositoryTranslation.AllAsync();
if (data.Any())
{
var result = data.Select((c) =>
{
var detail = new CategoryDetailViewModel(c);
detail.SetTranslation(translations.FirstOrDefault(x => x.Name == c.Name && x.Language == culture));
return(detail);
}).ToList();
return(PagineData(result, pageIndex, pageSize));
}
return(new ResultDataList <CategoryDetailViewModel>(false));
}
public CategoryDetailPage(Category category)
{
this.category = category;
InitializeComponent();
BindingContext = viewModel = new CategoryDetailViewModel(this.category);
}
public ActionResult Details(int ID)
{
CategoryDetailViewModel model = new CategoryDetailViewModel();
model.Category = categoriesService.GetCategoryByID(ID);
model.PageTitle = "Category Details:";
model.PageDescription = model.Category.Description.Substring(0, 10);
return(View(model));
}
public CategoryDetailPage(CategoryViewModel viewModel)
{
InitializeComponent();
var categoryStore = new CategoryStore();
var pageService = new PageService();
Title = (viewModel.Description == null) ? "New Category" : "Edit Category";
BindingContext = new CategoryDetailViewModel(viewModel ?? new CategoryViewModel(), categoryStore, pageService);
}
public async Task <IActionResult> Create()
{
int projectId = HttpContext.Request.Cookies.GetProjectId().Value;
var model = new CategoryDetailViewModel()
{
ProjectId = projectId,
Categories = await Mediator.Send(new GetCategoriesListQuery { ProjectId = projectId })
};
return(View(model));
}
public static CategoryDetailViewModel ConvertCategoryToCategoryDetailViewModel(Category category)
{
CategoryDetailViewModel categoryDetailViewModel = new CategoryDetailViewModel();
categoryDetailViewModel.Id = category.Id;
categoryDetailViewModel.Name = category.Name;
categoryDetailViewModel.SlugUrl = category.SlugUrl;
return(categoryDetailViewModel);
}
public IActionResult Detail(int id)
{
var singleCategoryWithVarietalList = categoryBusiness.GetCategoryWithVarietalListById(id);
var viewModel = new CategoryDetailViewModel
{
AllCategoriesWithVarietalsList = baseViewModel.AllCategoriesWithVarietalsList,
SingleCategoryWithVarietalList = singleCategoryWithVarietalList,
};
return(View(viewModel));
}
public ServiceResult Delete(CategoryDetailViewModel item)
{
var v_item = m_Context.Categories.SingleOrDefault(emp => emp.ID == item.ID);
if (v_item != null)
{
m_Context.Categories.Remove(v_item);
return(SaveChanges());
}
return(new ServiceResult(false, ""));
}
public async Task <IActionResult> Get([FromRoute] int id)
{
CategoryDetailViewModel category = await _mediator.Send(new GetCategoryQuery { Id = id });
return(Ok(new ResponseModel
{
Message = "category fetched successfully.",
Data = category,
BlogStatusCode = (int)HttpStatusCode.OK
}));
}
public static List <CategoryDetailViewModel> ConvertListCategorysToListCategoryDetailViewModel(List <Category> categorys)
{
List <CategoryDetailViewModel> categoryViewModel = new List <CategoryDetailViewModel>();
foreach (var category in categorys)
{
CategoryDetailViewModel categoryDetailViewModel = ConvertCategoryToCategoryDetailViewModel(category);
categoryViewModel.Add(categoryDetailViewModel);
}
return(categoryViewModel);
}
public ActionResult Edit(CategoryDetailViewModel category)
{
if (ModelState.IsValid)
{
Category categoryEntity = category.TransformToCategory();
Data.Categories.Update(categoryEntity);
Data.SaveChanges();
return(RedirectToAction("Index", new { page = category.Page })
.WithSuccess(string.Format(_successMsg, category.NameEn, "edited")));
}
return(View(category));
}
public CategoryDetailPage()
{
InitializeComponent();
var category = new Category
{
Name = "Category 1",
Questions = null
};
viewModel = new CategoryDetailViewModel(category);
BindingContext = viewModel;
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
if (e.Parameter is CategoryDetailViewModel)
{
ViewModel = e.Parameter as CategoryDetailViewModel;
}
else
{
throw new NotSupportedException("Parameter not supported");
}
UpdateUI();
}
public async Task <IActionResult> EditCategory(CategoryDetailViewModel model)
{
if (ModelState.IsValid)
{
var category = await _newsService.EditCategoryAsync(model.Category);
ShowAlertSuccess($"Updated Category \"{category.Name}\"!");
return(RedirectToAction(nameof(Categories)));
}
model.Action = nameof(EditCategory);
return(View("CategoryDetail", model));
}
public ActionResult Delete(CategoryDetailViewModel model)
{
ServiceResult result = _categoryService.Delete(model);
if (result.Status)
{
AddSuccessDeletedToastMessage();
return(RedirectToAction("Index"));
}
else
{
AddServiceErrorToastMessage(result);
return(RedirectToAction("Delete", new { model.ID }));
}
}
public IActionResult Details(int id)
{
Category cat = _categoryService.GetById(id);
IEnumerable <Inventory> inventoriesList = _inventoryService.Query(p => p.CategoryId == id);
var inventories = inventoriesList.ToList();
CategoryDetailViewModel vm = new CategoryDetailViewModel
{
Total = inventories.Count(),
CategoryName = cat.CategoryName,
Inventories = inventories.ToList(),
CategoryId = cat.CategoryId,
Active = cat.Active
};
return(View(vm));
}
public ActionResult Details(int?id, int?page)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Category category = Data.Categories.GetById((int)id);
if (category == null)
{
return(HttpNotFound());
}
CategoryDetailViewModel categoryModel = CategoryDetailViewModel.TransformToViewModel(category);
return(View(categoryModel));
}
// GET: Categories/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Category category = await db.Categories.FindAsync(id);
if (category == null)
{
return(HttpNotFound());
}
CategoryDetailViewModel categoryDetailViewModel = ClassCategoryConverter.ConvertCategoryToCategoryDetailViewModel(category);
return(View(categoryDetailViewModel));
}
public ActionResult Details(int id)
{
try
{
if (id > 0)
{
CategoryDTO category = _bl.Categories.GetItemById(id);
CategoryDetailViewModel model = new CategoryDetailViewModel()
{
Id = category.Id,
Name = category.Name,
};
model.Notes = new List <CategoryNoteViewModel>();
IEnumerable <NoteDTO> notes = _bl.Notes.GetNotesByCategoryId(category.Id).OrderBy(note => note.Title);
int counter = 0;
IEnumerable <UserDTO> users = _bl.Users.GetList();
foreach (NoteDTO note in notes)
{
CategoryNoteViewModel noteModel = new CategoryNoteViewModel()
{
Id = note.Id,
Title = note.Title,
ActualTill = note.ActualTill,
OwnerId = note.OwnerId
};
UserDTO user = users.First(u => u.Id == note.OwnerId);
noteModel.Owner = (user != null) ? (user.NameOrLogin) : "не найден";
model.Notes.Add(noteModel);
if (++counter > 9)
{
break;
}
}
return(PartialView(model));
}
else
{
return(PartialView());
}
}
catch (NoteCustomException e)
{
return(new HttpNotFoundResult(e.Message));
}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
if (e.NavigationMode == NavigationMode.Back)
{
return;
}
if (!(e.Parameter is IEditorPageParameter))
{
throw new NotSupportedException("Parameter is not supported");
}
if (e.Parameter is NewCategoryParameter)
{
var parameter = (e.Parameter as NewCategoryParameter);
DeleteButton.Visibility = Visibility.Collapsed;
if (parameter.Category is GeneralCategory)
{
DatePicker.Date = (parameter.Category as GeneralCategory).Date;
}
ViewModel = new CategoryDetailViewModel(parameter.Category);
}
else
{
var parameter = (e.Parameter as EditCategoryParameter);
DeleteButton.Visibility = Visibility.Visible;
if (parameter.CategoryType == typeof(GeneralCategory))
{
var category = DBContext.GeneralCategories
.Include(c => c.CategoryContacts)
.ThenInclude(cc => cc.Contact)
.Single(s => s.ID == parameter.ID);
DatePicker.Date = category.Date.Date;
ViewModel = new CategoryDetailViewModel(category);
}
else
{
var category = DBContext.BirthdayCategories
.Include(c => c.CategoryContacts)
.ThenInclude(cc => cc.Contact)
.Single(s => s.ID == parameter.ID);
ViewModel = new CategoryDetailViewModel(category);
}
}
MessageFrame.Navigate(typeof(MessageEditorPage), ViewModel);
}
public async Task<ResultDataList<CategoryDetailViewModel>> ListAsync(int? pageIndex, int pageSize = 20, string culture = "fr")
{
var categories = await _repository.ListAsync(pageIndex, pageSize);
var translations = await _repositoryTranslation.AllAsync();
if (categories.Any())
{
var result = categories.Select((c) =>
{
var detail = new CategoryDetailViewModel(c);
detail.SetTranslation(translations.FirstOrDefault(x => x.Name == c.Name && x.Language == culture));
return detail;
}).ToList();
return PagineData(result, pageIndex, pageSize);
}
return new ResultDataList<CategoryDetailViewModel>(false, "NO CATEGORY FOUND");
}
public async Task <IActionResult> CreateCategory(CategoryDetailViewModel model)
{
if (model == null)
{
ShowAlertDanger("Could not create empty category.");
return(RedirectToAction(nameof(Index)));
}
if (ModelState.IsValid)
{
var category = await _newsService.CreateCategoryAsync(model.Category);
ShowAlertSuccess($"Added Category \"{category.Name}\"!");
return(RedirectToAction(nameof(Categories)));
}
model.Action = nameof(CreateCategory);
return(View("CategoryDetail", model));
}
public async Task<RequestResultWithData<CategoryDetailViewModel>> GetByIdAsync([FromRoute]Guid id, string culture = "fr")
{
if (id == Guid.Empty)
return new RequestResultWithData<CategoryDetailViewModel>(false, "ID EMPTY");
var category = await _repository.GetByIdAsync(id);
var translations = await _repositoryTranslation.SearchAsync(x => x.Name == category.Name && x.Language == culture, 0, 20);
var categoryDetail = new CategoryDetailViewModel(category);
if (!translations.Any())
{
return new RequestResultWithData<CategoryDetailViewModel>(false, "NO TRANSLATION");
}
categoryDetail.SetTranslation(translations.FirstOrDefault());
return new RequestResultWithData<CategoryDetailViewModel>(true, categoryDetail);
}
