public ActionResult AttributeEditorDialog()
{
MetadataModel metadata = TempData["Metadata"] as MetadataModel;
AttributeViewModel attributeModel = metadata.DialogStack.Pop() as AttributeViewModel;
TempData["Metadata"] = metadata;
return(PartialView("AttributeEditorDialog", attributeModel));
}
public void UpdateQuestionGeneric(FormViewModel _formViewModel, List <QuestionCreateViewModel> _listQuestionCreateViewModel)
{
FormViewModel formViewModel = _formViewModel;
List <QuestionCreateViewModel> listQuestionCreateViewModel = _listQuestionCreateViewModel;
foreach (var questionCreateViewModel in listQuestionCreateViewModel)
{
ElementViewModel elementViewModel = new ElementViewModel
{
Name = questionCreateViewModel.ElementViewModel.Name,
Description = questionCreateViewModel.ElementViewModel.Description
};
// elementBL.Create(elementViewModel); // ???
QuestionViewModel questionViewModel = new QuestionViewModel
{
Name = questionCreateViewModel.QuestionViewModel.Name,
FormId = formBL.GetId(formViewModel),
ElementId = elementBL.GetId(elementViewModel)
};
questionBL.Update(questionViewModel);
int questionId = questionBL.GetId(questionViewModel);
foreach (var answerViewModel in questionCreateViewModel.AnswerViewModel)
{
AnswerViewModel answerVM = new AnswerViewModel
{
Name = answerViewModel.Name,
QuestionId = questionId
};
answerBL.Update(answerVM);
}
foreach (var attributeViewModel in questionCreateViewModel.AttributeViewModel)
{
attributeVM = new AttributeViewModel
{
Name = attributeViewModel.Name,
DisplayName = attributeViewModel.DisplayName,
QuestionId = questionId
};
attributeBL.Update(attributeVM);
}
foreach (var attributeResultViewModel in questionCreateViewModel.AttributeResultViewModel)
{
AttributeResultViewModel attributeResult = new AttributeResultViewModel
{
Value = attributeResultViewModel.Value,
AttributeId = attributeBL.GetId(attributeVM)
};
attributeResultBL.Update(attributeResult);
}
}
}
public ActionResult AttributeEdit()
{
AttributeViewModel attributeViewModel = new AttributeViewModel();
using (ShopDbDataContext db = new ShopDbDataContext())
{
attributeViewModel.Attributes = db.Attributes.ToList();
attributeViewModel.Categories = db.Categories.ToList();
}
return(View(attributeViewModel));
}
public IActionResult Edit(AttributeViewModel vm)
{
try
{
return(RedirectToAction("Index", "Attribute"));
}
catch
{
return(View());
}
}
public MainServiceController(ComputerAccessoriesV2Context db, UserManager <MyUsers> userManager, RoleManager <IdentityRole <int> > roleManager)
{
_db = db;
CategoryVM = new CategoryViewModel
{
listParent = _db.Category.ToList()
};
AttributeVM = new AttributeViewModel();
_userManager = userManager;
_roleManager = roleManager;
//AccountVM.Roles = _db.AspNetRoles.ToList();
}
public static string GetDescription(this AttributeViewModel attribute)
{
if (attribute == null)
{
throw new ArgumentNullException("attribute");
}
Template template = GetAttributeTemplate();
template.Add("attr", attribute);
return(template.Render().Replace("\\", "\\\\").Replace("\r", "\\r").Replace("\n", "\\n").Replace("\0", "\\0"));
}
public JsonResult UpdateAttributeStatus(AttributeViewModel attributeViewModel)
{
var attributeModel = new AttributeModel();
Mapper.Map(attributeViewModel, attributeModel);
var att = _productService.UpdateAttributeStatus(attributeModel);
Mapper.Map(att, attributeViewModel);
return(Json(attributeViewModel, JsonRequestBehavior.AllowGet));
}
public IActionResult Edit(AttributeViewModel vm)
{
try
{
var model = _mapper.Map <Attribute>(vm);
_unityOfWork.Attribute.Update(model);
_unityOfWork.Save();
return(RedirectToAction("Index", "Attribute"));
}
catch
{
return(View());
}
}
public async Task <IActionResult> AddEditAttribute(long?id, AttributeViewModel attributeViewModel)
{
try
{
if (attributeViewModel == null)
{
_logger.LogInformation(LogMessageConstant.ItemNotFound, attributeViewModel);
return(NotFound());
}
if (ModelState.IsValid)
{
bool isNew = !id.HasValue;
if (isNew)
{
var attribute = _mapper.Map <Domain.Attribute>(attributeViewModel);
await _uow.Attributes.AddAsync(attribute);
_logger.LogInformation(LogMessageConstant.Added, attribute.Name);
}
else
{
var attribute = _mapper.Map <Domain.Attribute>(attributeViewModel);
await _uow.Attributes.UpdateAsync(id.Value, attribute);
_logger.LogInformation(LogMessageConstant.Updated, attribute.Name);
}
}
}
catch (DbUpdateConcurrencyException ce)
{
var isExist = await _uow.Attributes.GetAsync(id.Value);
if (isExist == null)
{
_logger.LogWarning(LogMessageConstant.IdNotFound, id);
return(NotFound());
}
else
{
_logger.LogError(ce.Message, id);
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex.StackTrace);
}
return(RedirectToAction(nameof(Index)));
}
public static AttributeViewModel AttributeToViewModel(DAL.Models.Attribute attribute, string attributeGroupName)
{
string valueType = EnumHelper.EnumValueTypeToString(attribute.Value);
var attributeViewModel = new AttributeViewModel()
{
AttributeId = attribute.Id,
AttributeName = attribute.Name,
CreationDate = attribute.CreationDate,
LastModifiedDate = attribute.LastModifiedDate,
ValueType = valueType,
AttributeGroupName = attributeGroupName
};
return(attributeViewModel);
}
// GET: Attribute
public ActionResult Index()
{
var attributeList = new AttributeViewModel();
{
attributeList.Attribute = db.Attributes.ToList();
attributeList.AttributeGroup = db.AttributeGroups.ToList();
}
if (attributeList == null)
{
return(HttpNotFound());
}
return(View(attributeList));
}
public JsonResult GetAttributeById(string eAttributeId)
{
int attributeId = eAttributeId != "" ? Common.Utility.Helper.Decrypt(eAttributeId) : 0;
var attributeViewModel = new AttributeViewModel();
if (attributeId > 0)
{
var attribute = _productService.GetAttributeById(attributeId);
Mapper.Map(attribute, attributeViewModel);
Mapper.Map(attribute.AttributeCategoryModel, attributeViewModel.AttributeCategories);
}
return(Json(new { Attribute = attributeViewModel, Success = true, Message = "Success" }, JsonRequestBehavior.AllowGet));
}
public JsonResult GetProductAttribute(int Id)
{
var product = _unityOfWork.Product.GetByIdWithAttributes(Id);
List <AttributeViewModel> attributes = new List <AttributeViewModel>();
foreach (var attribute in product.ProductAttributes)
{
AttributeViewModel model = new AttributeViewModel()
{
ID = attribute.AttributeID,
Name = _unityOfWork.Attribute.GetById(attribute.AttributeID).Name, //attribute.Attribute.Name,
Value = attribute.Value
};
attributes.Add(model);
}
return(Json(attributes));
}
/*==========================================================================================================================
| METHOD: INVOKE
\-------------------------------------------------------------------------------------------------------------------------*/
/// <summary>
/// Assembles the view model for the <see cref="TopicReferenceViewComponent"/>.
/// </summary>
public IViewComponentResult Invoke(
EditingTopicViewModel currentTopic,
TopicReferenceAttributeDescriptorViewModel attribute,
string htmlFieldPrefix
) {
/*------------------------------------------------------------------------------------------------------------------------
| Validate parameters
\-----------------------------------------------------------------------------------------------------------------------*/
Contract.Requires(currentTopic, nameof(currentTopic));
Contract.Requires(attribute, nameof(attribute));
/*------------------------------------------------------------------------------------------------------------------------
| Set HTML prefix
\-----------------------------------------------------------------------------------------------------------------------*/
ViewData.TemplateInfo.HtmlFieldPrefix = htmlFieldPrefix;
/*------------------------------------------------------------------------------------------------------------------------
| Set configuration values
\-----------------------------------------------------------------------------------------------------------------------*/
//### TODO 6.0.0: Remove hard-coded reference to BaseTopic; this is only needed for backward compatibility with 5.0.0.
var isBaseTopic = attribute.Key.Equals("BaseTopic", StringComparison.OrdinalIgnoreCase);
if (attribute.UseCurrentContentType || isBaseTopic) {
attribute = attribute with {
AttributeKey = "ContentType",
AttributeValue = currentTopic.ContentType,
AutoPostBack = isBaseTopic? true : attribute.AutoPostBack
};
}
/*------------------------------------------------------------------------------------------------------------------------
| Establish view model
\-----------------------------------------------------------------------------------------------------------------------*/
var viewModel = new AttributeViewModel<TopicReferenceAttributeDescriptorViewModel>(currentTopic, attribute);
/*------------------------------------------------------------------------------------------------------------------------
| Return view with view model
\-----------------------------------------------------------------------------------------------------------------------*/
return View(viewModel);
}
} // Class
public async Task <IActionResult> AddEditAttribute(long?id)
{
AttributeViewModel attributeViewModel = new AttributeViewModel();
if (id.HasValue)
{
var attribute = await _uow.Attributes.GetAsync(id.Value);
if (attribute == null)
{
_logger.LogInformation(LogMessageConstant.ItemNotFound, attributeViewModel);
return(NotFound());
}
attributeViewModel = _mapper.Map <AttributeViewModel>(attribute);
}
return(PartialView("~/Areas/Admin/Views/Attribute/_AddEditAttribute.cshtml", attributeViewModel));
}
public JsonResult AddEditAttribute(AttributeViewModel attributeViewModel)
{
var message = attributeViewModel.AttributeId != null ? "Updated" : "Saved";
var attributeModel = new AttributeModel();
Mapper.Map(attributeViewModel, attributeModel);
Mapper.Map(attributeViewModel.AttributeCategories, attributeModel.AttributeCategoryModel);
var attribute = _productService.AddEditAttribute(attributeModel);
Mapper.Map(attribute, attributeViewModel);
Mapper.Map(attribute.AttributeCategoryModel, attributeViewModel.AttributeCategories);
return(Json(new { Attribute = attributeViewModel, Success = true, Message = message }, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> CreateNewAttribute(AttributeViewModel model)
{
if (!ModelState.IsValid)
{
return(NotFound());
}
Models.TblAttribute att = new Models.TblAttribute
{
AttributeName = model.AttributeName,
CategoryId = model.CategoryId,
CreatedDate = DateTime.Now
};
_db.TblAttribute.Add(att);
await _db.SaveChangesAsync();
return(RedirectToAction(nameof(Attributes)));
}
public async Task Update(int id, string culture, AttributeViewModel attribute)
{
using (var conn = new SqlConnection(_connectionString))
{
if (conn.State == System.Data.ConnectionState.Closed)
{
conn.Open();
}
var paramaters = new DynamicParameters();
paramaters.Add("@id", id);
paramaters.Add("@name", attribute.Name);
paramaters.Add("@sortOrder", attribute.SortOrder);
paramaters.Add("@backendType", attribute.BackendType);
paramaters.Add("@isActive", attribute.IsActive);
paramaters.Add("@hasOption", attribute.HasOption);
paramaters.Add("@values", attribute.Values);
await conn.ExecuteAsync("Update_Attribute", paramaters, null, null, System.Data.CommandType.StoredProcedure);
}
}
/*==========================================================================================================================
| METHOD: INVOKE
\-------------------------------------------------------------------------------------------------------------------------*/
/// <summary>
/// Assembles the view model for the <see cref="NumberViewComponent"/>.
/// </summary>
public IViewComponentResult Invoke(
EditingTopicViewModel currentTopic,
NumberAttributeDescriptorViewModel attribute,
string htmlFieldPrefix
) {
/*------------------------------------------------------------------------------------------------------------------------
| Set HTML prefix
\-----------------------------------------------------------------------------------------------------------------------*/
ViewData.TemplateInfo.HtmlFieldPrefix = htmlFieldPrefix;
/*------------------------------------------------------------------------------------------------------------------------
| Establish view model
\-----------------------------------------------------------------------------------------------------------------------*/
var viewModel = new AttributeViewModel<NumberAttributeDescriptorViewModel>(currentTopic, attribute);
/*------------------------------------------------------------------------------------------------------------------------
| Return view with view model
\-----------------------------------------------------------------------------------------------------------------------*/
return View(viewModel);
}
/*==========================================================================================================================
| METHOD: INVOKE
\-------------------------------------------------------------------------------------------------------------------------*/
/// <summary>
/// Assembles the view model for the <see cref="HtmlViewComponent"/>.
/// </summary>
public IViewComponentResult Invoke(
EditingTopicViewModel currentTopic,
HtmlAttributeDescriptorViewModel attribute,
string htmlFieldPrefix
) {
/*------------------------------------------------------------------------------------------------------------------------
| Validate parameters
\-----------------------------------------------------------------------------------------------------------------------*/
Contract.Requires(currentTopic, nameof(currentTopic));
Contract.Requires(attribute, nameof(attribute));
/*------------------------------------------------------------------------------------------------------------------------
| Set HTML prefix
\-----------------------------------------------------------------------------------------------------------------------*/
ViewData.TemplateInfo.HtmlFieldPrefix = htmlFieldPrefix;
/*------------------------------------------------------------------------------------------------------------------------
| Set configuration values
\-----------------------------------------------------------------------------------------------------------------------*/
if (attribute.Height is null || attribute.Height is 0 && attribute.Rows is not null) {
attribute = attribute with {
Height = attribute.Rows * 20
};
}
/*------------------------------------------------------------------------------------------------------------------------
| Establish view model
\-----------------------------------------------------------------------------------------------------------------------*/
var viewModel = new AttributeViewModel<HtmlAttributeDescriptorViewModel>(currentTopic, attribute);
/*------------------------------------------------------------------------------------------------------------------------
| Return view with view model
\-----------------------------------------------------------------------------------------------------------------------*/
return View(viewModel);
}
} // Class
public async Task Update(int id, [FromBody] AttributeViewModel attribute)
{
await _attributeRepository.Update(id, CultureInfo.CurrentCulture.Name, attribute);
}
public ActionResult AddNewAttributes(AttributeViewModel model)
{
return(View("../Product/Attributes"));
}
public async Task <IActionResult> Add(AttributeViewModel model)
{
await _attributeService.AddAsync(model);
return(RedirectToAction("Index"));
}
/*==========================================================================================================================
| METHOD: INVOKE
\-------------------------------------------------------------------------------------------------------------------------*/
/// <summary>
/// Assembles the view model for the <see cref="ReflexiveViewComponent"/>.
/// </summary>
public async Task<IViewComponentResult> InvokeAsync(
EditingTopicViewModel currentTopic,
ReflexiveAttributeDescriptorViewModel attribute,
string htmlFieldPrefix
) {
/*------------------------------------------------------------------------------------------------------------------------
| Validate parameters
\-----------------------------------------------------------------------------------------------------------------------*/
Contract.Requires(currentTopic, nameof(currentTopic));
Contract.Requires(attribute, nameof(attribute));
/*------------------------------------------------------------------------------------------------------------------------
| Set HTML prefix
\-----------------------------------------------------------------------------------------------------------------------*/
ViewData.TemplateInfo.HtmlFieldPrefix = htmlFieldPrefix;
/*------------------------------------------------------------------------------------------------------------------------
| Establish snapshot of previously saved attribute descriptor
\-----------------------------------------------------------------------------------------------------------------------*/
var topic = _topicRepository.Load(currentTopic.UniqueKey);
var reflexiveViewModel = (AttributeDescriptorViewModel?)null;
if (topic?.ContentType.EndsWith("AttributeDescriptor", StringComparison.OrdinalIgnoreCase)?? false) {
reflexiveViewModel = (AttributeDescriptorViewModel?)await _topicMappingService.MapAsync(topic).ConfigureAwait(false);
}
if (reflexiveViewModel is null) {
reflexiveViewModel = new();
}
/*------------------------------------------------------------------------------------------------------------------------
| Establish hybrid view model
>-------------------------------------------------------------------------------------------------------------------------
| The ParentAttributeDescriptor will be of the target type expected for the view component that will be executed. But it
| should use the core AttributeDescriptor attributes of the current attribute, so it shows up in the same location with
| the same title and description as defined for the ReflexiveAttributeDescriptorViewModel.
\-----------------------------------------------------------------------------------------------------------------------*/
reflexiveViewModel = reflexiveViewModel with {
Key = attribute.Key,
Description = attribute.Description,
DisplayGroup = attribute.DisplayGroup,
DefaultValue = attribute.DefaultValue,
IsRequired = attribute.IsRequired,
SortOrder = attribute.SortOrder,
Title = attribute.Title
};
/*------------------------------------------------------------------------------------------------------------------------
| Establish view model
\-----------------------------------------------------------------------------------------------------------------------*/
var viewModel = new AttributeViewModel<AttributeDescriptorViewModel>(currentTopic, reflexiveViewModel);
/*------------------------------------------------------------------------------------------------------------------------
| Return view with view model
\-----------------------------------------------------------------------------------------------------------------------*/
return View(viewModel);
}
} // Class
public ActionResult ViewAttributes()
{
AttributeViewModel model = new AttributeViewModel();
return(View("../Product/Attributes", model));
}
public AttributeView()
{
InitializeComponent();
DataContext = new AttributeViewModel();
}
public JsonResult AddEditAttribute(AttributeViewModel attributeViewModel)
{
var message = attributeViewModel.AttributeId != null ? "Updated" : "Saved";
var attributeModel = new AttributeModel();
Mapper.Map(attributeViewModel, attributeModel);
Mapper.Map(attributeViewModel.AttributeCategories, attributeModel.AttributeCategoryModel);
var attribute = _productService.AddEditAttribute(attributeModel);
Mapper.Map(attribute, attributeViewModel);
Mapper.Map(attribute.AttributeCategoryModel, attributeViewModel.AttributeCategories);
return Json(new { Attribute = attributeViewModel, Success = true, Message = message }, JsonRequestBehavior.AllowGet);
}
/// <summary>
/// Applies the additional properties and security to view model.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="viewModel">The view model.</param>
/// <param name="currentPerson">The current person.</param>
/// <param name="loadAttributes">if set to <c>true</c> [load attributes].</param>
public override void ApplyAdditionalPropertiesAndSecurityToViewModel(Attribute model, AttributeViewModel viewModel, Person currentPerson = null, bool loadAttributes = true)
{
var attributeCache = AttributeCache.Get(model.Id);
viewModel.FieldTypeGuid = FieldTypeCache.Get(attributeCache.FieldTypeId).Guid;
viewModel.CategoryGuids = attributeCache.Categories.Select(c => c.Guid).ToArray();
viewModel.QualifierValues = attributeCache.QualifierValues.ToDictionary(kvp => kvp.Key, kvp => new ViewModel.NonEntities.AttributeConfigurationValue
{
Name = kvp.Value.Name,
Value = kvp.Value.Value,
Description = kvp.Value.Description
});
}
public JsonResult UpdateAttributeStatus(AttributeViewModel attributeViewModel)
{
var attributeModel = new AttributeModel();
Mapper.Map(attributeViewModel, attributeModel);
var att = _productService.UpdateAttributeStatus(attributeModel);
Mapper.Map(att, attributeViewModel);
return Json(attributeViewModel, JsonRequestBehavior.AllowGet);
}
public JsonResult GetAttributeById(string eAttributeId)
{
int attributeId = eAttributeId != "" ? Common.Utility.Helper.Decrypt(eAttributeId) : 0;
var attributeViewModel = new AttributeViewModel();
if (attributeId > 0)
{
var attribute = _productService.GetAttributeById(attributeId);
Mapper.Map(attribute, attributeViewModel);
Mapper.Map(attribute.AttributeCategoryModel, attributeViewModel.AttributeCategories);
}
return Json(new { Attribute = attributeViewModel, Success = true, Message = "Success" }, JsonRequestBehavior.AllowGet);
}
public ActionResult Edit(int Id)
{
AttributeViewModel attributeViewModel = Mapper.Map <App.Domain.Entities.Attribute.Attribute, AttributeViewModel>(this._attributeService.GetById(Id));
return(base.View(attributeViewModel));
}
public async Task AddAttribute([FromBody] AttributeViewModel attribute)
{
await _attributeRepository.Add(CultureInfo.CurrentCulture.Name, attribute);
}
