public async Task <IActionResult> FAQ(int?page, int?id, int?searchtype, string query)
{
if (id.HasValue && id.Value > 0)
{
return(RedirectToAction("FAQView", new { id = id }));
}
if (!page.HasValue)
{
page = 1;
}
else
if (page.Value == 0)
{
page = 1;
}
FaqViewModel searchModel = new FaqViewModel();
searchModel.PageNumber = page.Value;
if (!string.IsNullOrWhiteSpace(query))
{
searchModel.FaqSearchCriteria.SearchType = (Faq.SearchType)searchtype.Value;
searchModel.FaqSearchCriteria.SearchString = query;
}
searchModel = await _faqViewModel.SearchFaqs(searchModel);
return(View(searchModel));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Answer,DivId,Publish,Question,SubmittedOn")] FaqViewModel faqViewModel)
{
if (id != faqViewModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(faqViewModel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FaqViewModelExists(faqViewModel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
return(View(faqViewModel));
}
public async Task Create_Should_Return_OkResult()
{
// Assign
var faq = new FaqViewModel
{
Question = "q",
Answer = "",
Category = new Category
{
Title = "t",
},
};
using (var context = DbContextFake.GetDbContext <IntranetApiContext>())
{
var faqController = ControllerFake.GetController <FaqsController>(context);
// Act
var response = await faqController.Create(faq);
// Assert
Assert.True(response.ValidateActionRedirect("Details"));
}
using (var context = DbContextFake.GetDbContext <IntranetApiContext>())
{
var savedFaq = context.Faqs.Include(f => f.Category).First();
Assert.Equal(savedFaq.Question, "q");
Assert.Equal(savedFaq.Url, "q");
Assert.Equal(savedFaq.Category.Title, "t");
Assert.Equal(savedFaq.Category.Url, "t");
}
}
public JsonFaq FaqClearance(int id)
{
JsonFaq jsonFaq = new JsonFaq();
List <FaqViewModel> FaqListObj = new List <FaqViewModel>();
try
{
var Clearance = _faq.FaqClearance();
foreach (var item in Clearance)
{
FaqViewModel faqOBJ = new FaqViewModel();
faqOBJ.FaqType = item.FaqType;
faqOBJ.Title = item.Title;
faqOBJ.Description = item.Description;
FaqListObj.Add(faqOBJ);
}
jsonFaq.Result = FaqListObj;
return(jsonFaq);
}
catch (Exception ex)
{
_ = ex.Message;
return(jsonFaq);
}
}
public ActionResult Delete(int id, FaqViewModel model)
{
try
{
// TODO: Add delete logic here
var faq = _repo.FindById(id);
if (faq == null)
{
return(NotFound());
}
var isSuccess = _repo.Delete(faq);
if (!isSuccess)
{
return(View(model));
}
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View(model));
}
}
public FaqViewModel PostFaq()
{
FaqViewModel faqViewModel = new FaqViewModel();
try
{
List <Faq> faqs = UnitOfWork.FaqRepository.Get().OrderBy(c => c.Order).ToList();
List <FaqItemViewModel> faqItems = new List <FaqItemViewModel>();
foreach (Faq faq in faqs)
{
faqItems.Add(new FaqItemViewModel()
{
Question = faq.Question,
Answer = faq.Answer
});
}
faqViewModel.Result = faqItems;
faqViewModel.Status = status.ReturnStatus(0, Resources.Messages.SuccessGet, true);
}
catch (Exception)
{
return(new FaqViewModel()
{
Result = null,
Status = status.ReturnStatus(100, Resources.Messages.CatchError, false)
});
}
return(faqViewModel);
}
public ActionResult Create(FaqViewModel model)
{
try
{
// TODO: Add insert logic here
if (!ModelState.IsValid)
{
return(View(model));
}
var faq = _mapper.Map <Faq>(model);
var isSuccess = _repo.Create(faq);
if (!isSuccess)
{
ModelState.AddModelError("", "Something Went Wrong!");
return(View(model));
}
return(RedirectToAction(nameof(Index)));
}
catch
{
ModelState.AddModelError("", "Something Went Wrong!");
return(View(model));
}
}
public IActionResult Create(FaqViewModel faq)
{
if (ModelState.IsValid)
{
Faq model = _mapper.Map <FaqViewModel, Faq>(faq);
_faqRepository.CreateFaq(model);
return(RedirectToAction("index"));
}
return(View(faq));
}
public async Task <IActionResult> Create([Bind("Id,Answer,DivId,Publish,Question,SubmittedOn")] FaqViewModel faqViewModel)
{
if (ModelState.IsValid)
{
_context.Add(faqViewModel);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(faqViewModel));
}
private List <Tag> GetAllTagEntitiesInternal(FaqViewModel faq, IEnumerable <string> tags)
{
if (tags.IsNull())
{
return(new List <Tag>());
}
return(_context.Tags?
.Include(k => k.FaqTags)
.ThenInclude(ft => ft.Faq)?
.Where(k => tags.Contains(k.Name, StringComparer.OrdinalIgnoreCase) || k.FaqTags.Any(nt => nt.FaqId.Equals(faq.Id)))
.ToList());
}
public async Task <IActionResult> FAQ(FaqViewModel model)
{
if (model.FaqSearchCriteria != null && !string.IsNullOrWhiteSpace(model.FaqSearchCriteria.SearchString))
{
model.PageNumber = 1;
return(RedirectToAction("FAQ", new { page = 1, searchtype = (int)model.FaqSearchCriteria.SearchType, query = model.FaqSearchCriteria.SearchString }));
}
else
{
model.Faqs.CurrentPage = 1;
return(RedirectToAction("FAQ", new { page = 1, searchtype = SearchType.Title, query = "" }));
}
}
public ActionResult Edit(int id, FaqViewModel model)
{
try
{
// TODO: Add update logic here
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public IActionResult Create(FaqViewModel model)
{
if (ModelState.IsValid)
{
Faq faq = _mapper.Map <FaqViewModel, Faq>(model);
model.AddedBy = _admin.Fullname;
_sectionRepository.CreateFaq(faq);
return(RedirectToAction("index"));
}
return(View(model));
}
public async Task Edit_Faq_Should_Return_Ok()
{
// Assign
var faq = new Faq
{
Id = 1,
Question = "old question",
Answer = "",
Url = "old-question",
Category = new Category
{
Title = "old category",
Url = "old-category",
},
};
var newFaq = new FaqViewModel
{
Id = 1,
Question = "q",
Answer = "",
Category = new Category
{
Title = "t",
},
};
DbContextFake.SeedDb <IntranetApiContext>(c => c.Add(faq));
using (var context = DbContextFake.GetDbContext <IntranetApiContext>())
{
var faqController = ControllerFake.GetController <FaqsController>(context);
// Act
var result = await faqController.Edit(1, newFaq);
// Assert
Assert.True(result.ValidateActionRedirect("Details"));
}
using (var context = DbContextFake.GetDbContext <IntranetApiContext>())
{
var updatedFaq = context.Faqs.Include(f => f.Category).First();
Assert.Equal(faq.Question, "old question");
Assert.Equal(updatedFaq.Question, "q");
Assert.Equal(faq.Category.Title, "old category");
Assert.Equal(updatedFaq.Category.Title, "t");
Assert.Equal(updatedFaq.Url, "old-question");
Assert.Equal(updatedFaq.Category.Url, "t");
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Category,Question,Answer,Url")] FaqViewModel faqVM)
{
if (id != faqVM?.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var entity = await _context.Faqs
.Include(f => f.Category)
.SingleOrDefaultAsync(c => c.Id == id);
if (entity.IsNull())
{
return(NotFound());
}
if (!entity.Category.Title.Equals(faqVM.Category.Title, StringComparison.OrdinalIgnoreCase))
{
var category = await _context.Categories.SingleOrDefaultAsync(c => c.Title.Equals(faqVM.Category.Title, StringComparison.OrdinalIgnoreCase));
if (category.IsNotNull())
{
entity.Category = category;
}
else
{
entity.Category = new Category
{
Title = faqVM.Category.Title,
Url = CustomUrlHelper.URLFriendly(faqVM.Category.Title),
};
}
}
entity.Answer = faqVM.Answer;
entity.Question = faqVM.Question;
var tags = TagHelpers.GetTagsFromString(faqVM.Tags);
var allTagEntities = GetAllTagEntitiesInternal(faqVM, tags);
TagHelpers.SetTags <Faq, FaqTag>(tags, entity, allTagEntities);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", new { Id = entity.Id }));
}
return(View(faqVM));
}
public IActionResult Edit(FaqViewModel faq)
{
if (ModelState.IsValid)
{
Faq model = _mapper.Map <FaqViewModel, Faq>(faq);
Faq fagToUpdate = _faqRepository.GetFaqById(faq.Id);
if (fagToUpdate == null)
{
return(NotFound());
}
_faqRepository.UpdateFaq(fagToUpdate, model);
return(RedirectToAction("index"));
}
return(View(faq));
}
public IActionResult Create([FromQuery] string category = null)
{
if (category.IsNull())
{
ViewData["Categories"] = new SelectList(_context.Categories, nameof(Category.Title), nameof(Category.Title));
}
else
{
ViewData["Categories"] = new SelectList(_context.Categories, nameof(Category.Title), nameof(Category.Title), category);
}
var vm = new FaqViewModel();
vm.Category = new Category();
return(View(vm));
}
public async Task <IActionResult> FAQ(FaqViewModel model)
{
if (model.FaqSearchCriteria != null && !string.IsNullOrWhiteSpace(model.FaqSearchCriteria.SearchString))
{
model.PageNumber = 1;
HttpContext.Session.SetObjectAsJson("FaqViewModel", model);
model = await _faqViewModel.SearchFaqs(model);
}
else
{
HttpContext.Session.Remove("FaqViewModel");
model.Faqs.CurrentPage = 1;
model = await _faqViewModel.GetAllFaqs(model.Faqs.CurrentPage);
}
return(View(model));
}
public ActionResult Save(FaqViewModel model)
{
if (ModelState.IsValid)
{
var response = GetCommand <SaveFaqCommand>().ExecuteCommand(model);
if (response != null)
{
if (model.Id.HasDefaultValue())
{
Messages.AddSuccess("Created successfully!");
}
return(WireJson(true, response));
}
}
return(WireJson(false));
}
public async Task <ActionResult> ModifyFaq(FaqViewModel faqViewModel)
{
ViewBag.LeftMenu = Global.Cs;
//Faq 조회
var scFaq = await _scFaqService.GetFaqAsync(faqViewModel.FaqSn);
scFaq.QstTxt = faqViewModel.QstTxt;
scFaq.AnsTxt = faqViewModel.AnsTxt;
scFaq.QclSn = faqViewModel.QclSn;
scFaq.UpdDt = DateTime.Now;
scFaq.UpdId = Session[Global.LoginID].ToString();
await _scFaqService.SaveDbContextAsync();
return(RedirectToAction("Faq", "Cs"));
}
public IActionResult Update(FaqViewModel faq)
{
if (ModelState.IsValid)
{
Faq model = _mapper.Map <FaqViewModel, Faq>(faq);
model.ModifiedBy = "System";
model.ModifiedDate = DateTime.Now;
Faq faqToUpdate = _faqRepository.GetFaqById(faq.Id);
if (faqToUpdate == null)
{
return(NotFound());
}
_faqRepository.UpdateFaq(faqToUpdate, model);
return(RedirectToAction("index"));
}
return(View(faq));
}
public ActionResult Add(FaqViewModel model)
{
try
{
// apply mapping
var faq = this.mapper.Map <Faq>(model);
this.repositoryWrapper.Faq.Create(faq);
this.repositoryWrapper.Save();
this.loggerManager.LogInfo($"(Dashboard - FAQ) add new faq to database.");
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
this.loggerManager.LogError($"(Dashboard - FAQ) Something went wrong when try to add new faq: {ex.Message}");
return(View());
}
}
public async Task <IActionResult> Update([FromForm] FaqViewModel faqViewModel)
{
if (faqViewModel.FaqId == null)
{
return(NotFound("Notfound"));
}
Faq faq = FaqViewModel.MapFaqViewModelToEntity(faqViewModel);
// var updatedResult = await _faqService.UpdateAsync(faq, faqViewModel, Constants.EntityKey.FAQ_ID);
// var updatedResult = await _faqService.UpdateAsync(faq, Constants.EntityKey.FAQ_ID, faq => faq.Question, faq => faq.Answer);
// var updatedResult = await _faqService.UpdateAsync(faq, Constants.EntityKey.FAQ_ID);
var updatedResult = await _faqService.UpdateAsync(faq);
if (updatedResult.Item2)
{
return(Ok(updatedResult.Item1));
}
return(BadRequest());
}
public async Task <IActionResult> Create([Bind("Category,Question,Answer,Tags")] FaqViewModel faqVM)
{
if (ModelState.IsValid)
{
var category = await _context
.Categories
.SingleOrDefaultAsync(c => c.Title.Equals(faqVM.Category.Title, StringComparison.OrdinalIgnoreCase));
if (category.IsNotNull())
{
faqVM.Category = category;
}
else
{
faqVM.Category = new Category
{
Title = faqVM.Category.Title,
Url = CustomUrlHelper.URLFriendly(faqVM.Category.Title),
};
}
var faq = new Faq
{
Answer = faqVM.Answer,
Category = faqVM.Category,
Question = faqVM.Question,
Url = CustomUrlHelper.URLFriendly(faqVM.Question),
};
var tags = TagHelpers.GetTagsFromString(faqVM.Tags);
var allTagEntities = GetAllTagEntitiesInternal(faqVM, tags);
TagHelpers.SetTags <Faq, FaqTag>(tags, faq, allTagEntities);
await _context.AddAsync(faq);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", new { Id = faq.Id }));
}
ViewData["Categories"] = new SelectList(_context.Categories, nameof(Category.Id), nameof(Category.Title));
return(View(faqVM));
}
public IActionResult Edit(FaqViewModel model)
{
if (ModelState.IsValid)
{
var faq = _mapper.Map <FaqViewModel, Faq>(model);
var faqToUpdate = _sectionRepository.GetFaqById(model.Id);
if (faqToUpdate == null)
{
return(NotFound());
}
faq.ModifiedBy = _admin.Fullname;
_sectionRepository.UpdateFaq(faqToUpdate, faq);
return(RedirectToAction("index"));
}
return(View(model));
}
public async Task <ActionResult <Faq> > Create([FromForm] FaqViewModel faqViewModel)
{
if (faqViewModel == null)
{
return(NoContent());
}
if (ModelState.IsValid)
{
// var faq = FaqViewModel.MapFaqViewModelToEntity(faqViewModel);
var faq = _createFaqFromViewwModel.CreateMapping(faqViewModel);
var createdResult = await _faqService.CreateAsync(faq);
if (createdResult.Item2)
{
return(Ok("Successfully created Faq!"));
}
return(BadRequest("Something went wrong when create Faq."));
}
return(BadRequest(ModelState));
}
internal static void SetCategoryToCategoryViewModel(CategoryViewModel viewModel, Category model)
{
viewModel.Name = model.Name;
viewModel.Subcategories = new ObservableCollection <SubcategoryViewModel>();
foreach (Subcategory subcategory in model.Subcategories)
{
SubcategoryViewModel subcategoryViewModel = new SubcategoryViewModel
{
SubName = subcategory.Name,
Faqs = new ObservableCollection <FaqViewModel>(),
};
foreach (Faq faq in subcategory.Faqs)
{
FaqViewModel faqViewModel = new FaqViewModel
{
AnswerText = faq.AnswerText,
Question = faq.Question
};
subcategoryViewModel.Faqs.Add(faqViewModel);
}
viewModel.Subcategories.Add(subcategoryViewModel);
}
}
public async Task <ActionResult> RegFaq(FaqViewModel faqViewModel)
{
ViewBag.LeftMenu = Global.Cs;
var scFaq =
Mapper.Map <ScFaq>(faqViewModel);
scFaq.Stat = "N";
scFaq.RegDt = DateTime.Now;
scFaq.RegId = Session[Global.LoginID].ToString();
//Faq 등록
int result = await _scFaqService.AddFaqAsync(scFaq);
if (result != -1)
{
return(RedirectToAction("Faq", "Cs"));
}
else
{
ModelState.AddModelError("", "FAQ 등록 실패.");
return(View(faqViewModel));
}
}
public FaqPage()
{
this.InitializeComponent();
this.ViewModel = new FaqViewModel();
this.nfcListener = new NfcListener();
}
public JsonResult Save(FaqViewModel model)
{
var currentUser = GetAuthenticatedUser();
try
{
if (string.IsNullOrEmpty(model.question))
{
return(Error("وارد کردن سوال اجباری است."));
}
if (string.IsNullOrEmpty(model.answer))
{
return(Error("وارد کردن پاسخ اجباری است."));
}
if (model.id != null && model.id > 0)
{
var entity = _context.Faq.Single(x => x.StatusId != FaqStatus.Deleted.Id && x.Id == model.id);
entity.FaqCategoryId = model.faqCategoryId;
entity.Order = model.order;
entity.Question = model.question.ToStandardPersian();
entity.Answer = model.answer.ToStandardPersian();
entity.StatusId = model.statusId;
entity.ModifyUserId = currentUser.id;
entity.ModifyDate = GetDatetime();
entity.ModifyIp = GetCurrentIp();
_context.SaveChanges();
// تایید تمام فایل های جدید ذخیره شده در نقد و بررسی
VerifyHtmlImageFile(model.answer);
return(Success("اطلاعات سوال با موفقیت ویرایش شد."));
}
else
{
var entity = new Faq()
{
FaqCategoryId = model.faqCategoryId,
Order = model.order,
Question = model.question.ToStandardPersian(),
Answer = model.answer.ToStandardPersian(),
StatusId = model.statusId,
CreateUserId = currentUser.id,
ModifyUserId = currentUser.id,
CreateDate = GetDatetime(),
ModifyDate = GetDatetime(),
CreateIp = GetCurrentIp(),
ModifyIp = GetCurrentIp()
};
_context.Faq.Add(entity);
_context.SaveChanges();
// تایید تمام فایل های جدید ذخیره شده در نقد و بررسی
VerifyHtmlImageFile(model.answer);
return(Success("سوال با موفقیت ایجاد شد."));
}
}
catch (Exception ex)
{
return(ServerError(ex));
}
}
