public void Validate(CustomFieldModel viewModel)
{
if (CustomFieldRepository.Items.Any(f => f.Name == viewModel.FieldName && f.Id != viewModel.Id))
{
throw new ValidationException(new ValidationResult("Name already exists", new string[] { "FieldName" }), null, viewModel.FieldName);
}
}
public void Edit(CustomFieldModel viewModel, EducationSecurityPrincipal user)
{
if (viewModel == null)
{
throw new ArgumentNullException("viewModel");
}
if (user == null)
{
throw new ArgumentNullException("user");
}
var model = CustomFieldRepository.Items.Include(c => c.Categories).SingleOrDefault(c => c.Id == viewModel.Id);
if (model == null)
{
throw new EntityNotFoundException("The requested custom field could not be found");
}
if (CustomFieldValueRepository.Items.Any(v => v.CustomFieldId == viewModel.Id) && model.CustomFieldTypeId != viewModel.SelectedFieldTypeId)
{
throw new ValidationException(new ValidationResult("Cannot edit field type because data values have already been loaded", new[] { "SelectedFieldTypeId" }), null, viewModel);
}
viewModel.CopyTo(model);
model.LastModifyingUser = user.Identity.User;
model.LastModifyTime = DateTime.Now;
model.Categories = CustomFieldCategoryRepository.Items.Where(c => viewModel.SelectedCategories.Contains(c.Id)).ToList();
CustomFieldRepository.Update(model);
RepositoryContainer.Save();
}
public CustomFieldModel GenerateCreateViewModel()
{
CustomFieldModel viewModel = CreateFieldModel();
PopulateViewModel(viewModel);
return(viewModel);
}
private List <ProductVariantModel> GetVariants(Product product, ProductType productType, string culture)
{
var controls = FormControls.Controls().ToList();
var models = new List <ProductVariantModel>();
foreach (var variant in product.Variants)
{
var variantKey = new EntityKey(typeof(ProductVariant), variant.Id);
var translation = _translationStore.Find(CultureInfo.GetCultureInfo(culture), variantKey);
var model = new ProductVariantModel
{
Id = variant.Id,
Sku = variant.Sku,
Price = variant.Price
};
foreach (var fieldDefinition in productType.VariantFieldDefinitions)
{
// field might be null because admin can add new fields to product types when products already exist
var field = variant.VariantFields.FirstOrDefault(f => f.FieldName == fieldDefinition.Name);
var control = controls.Find(c => c.Name == fieldDefinition.ControlType);
var compared = new CustomFieldModel
{
FieldName = fieldDefinition.Name,
FieldText = control.GetFieldDisplayText(fieldDefinition, field == null ? null : field.FieldValue),
FieldValue = field == null ? null : field.FieldValue
};
var translated = new CustomFieldModel
{
FieldName = compared.FieldName,
FieldText = compared.FieldText,
FieldValue = compared.FieldValue
};
var diff = new CustomFieldModel
{
FieldName = compared.FieldName
};
// If the field value is entered in product editing page, then it's always the field value that get translated
if (translation != null && !control.IsSelectionList && !control.IsValuesPredefined)
{
translated.FieldText = translation.GetTranslatedText("VariantFields[" + fieldDefinition.Name + "]");
translated.FieldValue = translated.FieldText;
diff.FieldText = DiffHelper.GetDiffHtml(translation.GetOriginalText("VariantFields[" + fieldDefinition.Name + "]"), field == null ? null : field.FieldValue);
}
model.VariantFields.Add(new TranslationTuple <CustomFieldModel>(compared, diff, translated));
}
models.Add(model);
}
return(models);
}
public virtual void PopulateViewModel(CustomFieldModel viewModel)
{
if (viewModel == null)
{
throw new ArgumentNullException("viewModel");
}
viewModel.Categories = new MultiSelectList(CustomFieldCategoryRepository.Items, "Id", "Name", viewModel.SelectedCategories);
viewModel.FieldTypes = new SelectList(CustomFieldTypeRepository.Items, "Id", "Name", viewModel.SelectedFieldTypeId);
}
public override void PopulateViewModel(CustomFieldModel viewModel)
{
base.PopulateViewModel(viewModel);
PrivateHealthFieldModel validViewModel = viewModel as PrivateHealthFieldModel;
if (validViewModel == null)
{
throw new ArgumentException(string.Format("Specified {0} must be of type {1}.", typeof(CustomFieldModel).Name, typeof(PrivateHealthFieldModel).Name), "viewModel");
}
validViewModel.Providers = new SelectList(ProviderRepository.Items, "Id", "Name");
}
public override void PopulateViewModel(CustomFieldModel viewModel)
{
base.PopulateViewModel(viewModel);
PrivateHealthFieldModel validViewModel = viewModel as PrivateHealthFieldModel;
if (validViewModel == null)
{
throw new ArgumentException(string.Format("Specified {0} must be of type {1}.", typeof(CustomFieldModel).Name, typeof(PrivateHealthFieldModel).Name), "viewModel");
}
validViewModel.Providers = new SelectList(ProviderRepository.Items, "Id", "Name");
}
public void WhenGenerateEditViewModel_ThenAuditDataPopulated()
{
CustomField data = EducationContext.CustomFields.Single(f => f.Name == "Tardies");
CustomFieldModel actual = Target.GenerateEditViewModel(data.Id, User);
Assert.IsNotNull(actual.Audit.CreatedBy);
Assert.AreNotEqual(DateTime.MinValue, actual.Audit.CreateTime);
Assert.IsNotNull(actual.Audit.LastModifiedBy);
Assert.IsTrue(actual.Audit.LastModifyTime.HasValue);
}
public async Task <ActionResult <CustomField> > CreateCustomField(int portalId,
[FromBody] CustomFieldModel customField)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
CustomField newCustomField = await _customFieldRepository.CreateCustomField(portalId, customField);
return(Ok(newCustomField));
}
public CustomFieldModel GenerateDeleteViewModel(int id)
{
var model = CustomFieldRepository.Items.SingleOrDefault(c => c.Id == id);
if (model == null)
{
throw new EntityNotFoundException("Specified custom field does not exist");
}
CustomFieldModel viewModel = CreateFieldModel();
viewModel.CopyFrom(model);
return(viewModel);
}
public CustomFieldModel GenerateEditViewModel(int id, EducationSecurityPrincipal user)
{
var model = CustomFieldRepository.Items.
Include(c => c.Categories).
Include(c => c.LastModifyingUser).
Include(c => c.CreatingUser).
SingleOrDefault(c => c.Id == id);
if (model == null)
{
throw new EntityNotFoundException("The requested custom field could not be found");
}
CustomFieldModel viewModel = CreateFieldModel();
viewModel.CopyFrom(model);
PopulateViewModel(viewModel);
return(viewModel);
}
public void Create(CustomFieldModel viewModel, EducationSecurityPrincipal user)
{
if (viewModel == null)
{
throw new ArgumentNullException("viewModel");
}
if (user == null)
{
throw new ArgumentNullException("user");
}
CustomField item = CreateFieldEntity();
viewModel.CopyTo(item);
item.Categories = CustomFieldCategoryRepository.Items.Where(c => viewModel.SelectedCategories.Contains(c.Id)).ToList();
if (item.Categories.Count != viewModel.SelectedCategories.Count())
{
throw new EntityNotFoundException("At least one selected category could not be found.");
}
item.CreatingUserId = user.Identity.UserEntity.Id;
CustomFieldRepository.Add(item);
RepositoryContainer.Save();
}
public async Task <CustomField> CreateCustomField(int portalId, CustomFieldModel customField)
{
IEnumerable <CustomField> existingCustomFields = await GetCustomFieldsByName(portalId, customField.Name);
if (existingCustomFields.Any())
{
throw new Exception("This custom field already exists. Please use another name.");
}
int sortOrder = customField.SortOrder ?? 0;
if (!customField.SortOrder.HasValue)
{
IEnumerable <CustomField> customFields = await GetCustomFields(portalId);
sortOrder = customFields.Last().SortOrder + 10;
}
CustomField newCustomField = new CustomField
{
PortalId = portalId,
Name = customField.Name.Trim(),
FieldType = Enum.GetName(typeof(CustomFieldType), customField.Type),
Required = customField.Required,
SortOrder = sortOrder,
CreatedBy = customField.CreatedBy,
CreatedDate = DateTimeOffset.Now,
UpdatedDate = DateTimeOffset.Now,
IsActive = true,
IsDeleted = false
};
await Context.CustomFields.AddAsync(newCustomField);
await Context.SaveChangesAsync();
return(newCustomField);
}
public static bool InsertCustomFieldModel(CustomFieldModel entity)
{
return(CustomFieldDAL.dal.InsertCustomFieldModel(entity));
}
public static bool UpdateCustomFieldModel(CustomFieldModel entity)
{
return(CustomFieldDAL.dal.UpdateCustomFieldModel(entity));
}
public ActionResult Translate(int id, string culture)
{
var product = CurrentInstance.Database.Repository <Product>().Find(id);
var productType = product.ProductType;
var controls = FormControls.Controls().ToList();
var compared = Mapper.Map <Product, ProductModel>(product);
var translated = Mapper.Map <Product, ProductModel>(product);
var difference = new ProductModel();
var productKey = new EntityKey(typeof(Product), product.Id);
var translation = _translationStore.Find(CultureInfo.GetCultureInfo(culture), productKey);
if (translation != null)
{
translated.Name = translation.GetTranslatedText("Name");
difference.Name = DiffHelper.GetDiffHtml(translation.GetOriginalText("Name"), product.Name);
}
// Custom fields
// Product type definition might change, so we need to display fields base on product type definition
compared.CustomFields.Clear();
translated.CustomFields.Clear();
foreach (var definition in productType.CustomFieldDefinitions)
{
var control = controls.Find(c => c.Name == definition.ControlType);
var field = product.CustomFields.FirstOrDefault(f => f.FieldName == definition.Name) ?? new ProductCustomField(definition.Name, null);
var comparedField = MapOrDefault(definition, field);
comparedField.FieldText = control.GetFieldDisplayText(definition, field == null ? null : field.FieldValue);
compared.CustomFields.Add(comparedField);
var translatedField = MapOrDefault(definition, field);
translatedField.FieldText = comparedField.FieldText;
var diffField = new CustomFieldModel {
FieldName = definition.Name
};
// If the field value is defined in product editing page, then it's always the field value that get translated
if (translation != null && !control.IsSelectionList && !control.IsValuesPredefined)
{
translatedField.FieldText = translation.GetTranslatedText("CustomFields[" + field.FieldName + "]");
translatedField.FieldValue = translatedField.FieldText;
diffField.FieldText = DiffHelper.GetDiffHtml(translation.GetOriginalText("CustomFields[" + field.FieldName + "]"), comparedField.FieldText);
}
translated.CustomFields.Add(translatedField);
difference.CustomFields.Add(diffField);
}
// Variants
translated.Variants = GetVariants(product, productType, culture);
ViewBag.ProductType = productType;
ViewBag.Compared = compared;
ViewBag.Difference = difference;
return(View(translated));
}
public async Task <CustomField> UpdateCustomField(int portalId, int customFieldId, CustomFieldModel customField)
{
CustomField dbCustomField = await GetCustomFieldById(portalId, customFieldId);
if (!string.Equals(dbCustomField.Name, customField.Name.Trim(), StringComparison.CurrentCultureIgnoreCase))
{
IEnumerable <CustomField> existingCustomFields = await GetCustomFieldsByName(portalId, customField.Name);
if (existingCustomFields.Any())
{
throw new Exception("This custom field already exists. Please use another name.");
}
}
int sortOrder = customField.SortOrder ?? 0;
if (!customField.SortOrder.HasValue)
{
IEnumerable <CustomField> customFields = await GetCustomFields(portalId);
sortOrder = customFields.Last().SortOrder + 10;
}
dbCustomField.Name = customField.Name.Trim();
dbCustomField.FieldType = Enum.GetName(typeof(CustomFieldType), customField.Type);
dbCustomField.Required = customField.Required;
dbCustomField.SortOrder = sortOrder;
dbCustomField.IsActive = customField.IsActive;
dbCustomField.UpdatedDate = DateTimeOffset.Now;
await Context.SaveChangesAsync();
return(dbCustomField);
}
public void Validate(CustomFieldModel viewModel)
{
if (CustomFieldRepository.Items.Any(f => f.Name == viewModel.FieldName && f.Id != viewModel.Id))
{
throw new ValidationException(new ValidationResult("Name already exists", new string[] { "FieldName" }), null, viewModel.FieldName);
}
}
public virtual void PopulateViewModel(CustomFieldModel viewModel)
{
if (viewModel == null)
{
throw new ArgumentNullException("viewModel");
}
viewModel.Categories = new MultiSelectList(CustomFieldCategoryRepository.Items, "Id", "Name", viewModel.SelectedCategories);
viewModel.FieldTypes = new SelectList(CustomFieldTypeRepository.Items, "Id", "Name", viewModel.SelectedFieldTypeId);
}
public void Edit(CustomFieldModel viewModel, EducationSecurityPrincipal user)
{
if (viewModel == null)
{
throw new ArgumentNullException("viewModel");
}
if (user == null)
{
throw new ArgumentNullException("user");
}
var model = CustomFieldRepository.Items.Include(c => c.Categories).SingleOrDefault(c => c.Id == viewModel.Id);
if (model == null)
{
throw new EntityNotFoundException("The requested custom field could not be found");
}
if (CustomFieldValueRepository.Items.Any(v => v.CustomFieldId == viewModel.Id) && model.CustomFieldTypeId != viewModel.SelectedFieldTypeId)
{
throw new ValidationException(new ValidationResult("Cannot edit field type because data values have already been loaded", new[] { "SelectedFieldTypeId" }), null, viewModel);
}
viewModel.CopyTo(model);
model.LastModifyingUser = user.Identity.User;
model.LastModifyTime = DateTime.Now;
model.Categories = CustomFieldCategoryRepository.Items.Where(c => viewModel.SelectedCategories.Contains(c.Id)).ToList();
CustomFieldRepository.Update(model);
RepositoryContainer.Save();
}
public void Create(CustomFieldModel viewModel, EducationSecurityPrincipal user)
{
if (viewModel == null)
{
throw new ArgumentNullException("viewModel");
}
if (user == null)
{
throw new ArgumentNullException("user");
}
CustomField item = CreateFieldEntity();
viewModel.CopyTo(item);
item.Categories = CustomFieldCategoryRepository.Items.Where(c => viewModel.SelectedCategories.Contains(c.Id)).ToList();
if (item.Categories.Count != viewModel.SelectedCategories.Count())
{
throw new EntityNotFoundException("At least one selected category could not be found.");
}
item.CreatingUserId = user.Identity.UserEntity.Id;
CustomFieldRepository.Add(item);
RepositoryContainer.Save();
}
public JsonResult UpdateActive(VM_FormModel data)
{
var user = UserBussiness.GetUserModel(m => m.OpenID == data.access_token);
ActivesModel actives = new ActivesModel();
actives.ActiveAddress = data.address;
actives.ActiveBeginTime = LeoUtils.ConvertIntDateTime1(double.Parse(data.act_start));
actives.ActiveEndTime = LeoUtils.ConvertIntDateTime1(double.Parse(data.act_end));
actives.CreateUserID = user.ID;
actives.Content = data.content;
actives.Img = data.banner;
actives.ImgDetails = data.pics != null?string.Join(",", data.pics) : "";
actives.IsAllowCancel = data.can_quit;
actives.ListReportPermission = data.visibility;
actives.ListShowType = data.user_visible;
actives.ManyCount = data.on_behalf_limit;
actives.PromoterMobile = data.phone;
actives.PromoterName = data.sign_name;
actives.PromoterWechat = data.wx_no;
actives.SignIntMaxCount = data.limit.ToInt32();
actives.Title = data.title;
actives.can_quit = data.can_quit;
actives.group_qr = data.group_qr;
actives.is_public = data.is_public;
actives.latitude = data.latitude;
actives.longitude = data.longitude;
actives.on_behalf_limit = data.on_behalf_limit;
actives.queue = data.queue;
actives.role = data.role;
actives.user_visible = data.user_visible;
actives.verify = data.verify;
actives.version = data.version;
actives.visibility = data.visibility;
actives.ID = data.eid.ToInt32();
List <CustomFieldModel> customFieldValueModel = new List <CustomFieldModel>();
int i = 1;
foreach (var item in data.req_info)
{
CustomFieldModel customField = new CustomFieldModel();
customField.CreateUserID = user.ID;
customField.MaxTextCount = item.max_length.ToInt32();
customField.MinTextCount = item.min_length.ToInt32();
customField.Name = item.field_name;
customField.PlaceHolder = item.field_desc;
customField.Type = item.field_type;
customField.Status = item.status.ToInt32();
customField.require = item.require;
customField.Sort = i;
customField.Options = item.options != null?string.Join(",", item.options) : "";
i++;
customFieldValueModel.Add(customField);
}
bool flag = ActivesBussiness.UpdateActiveByTran(actives, customFieldValueModel);
if (flag)
{
return(Success(new { eid = actives.ID }));
}
else
{
return(Fail("编辑失败，请重试"));
}
}
public void WhenGenerateEditViewModel_ThenSelectedCategoriesPopulated()
{
CustomFieldModel actual = Target.GenerateEditViewModel(1, User);
Assert.AreNotEqual(0, actual.SelectedCategories.Count());
}
