public FormFieldViewModel(FormField formField, int abstractFormId)
{
Name = formField.MultilingualName.ToList();
Description = formField.MultilingualDescription.ToList();
IsRequired = formField.IsRequired;
FieldType = formField.GetType().AssemblyQualifiedName;
Guid = formField.Guid;
Rank = formField.Rank;
Page = formField.Page;
IsPageBreak = formField.IsPageBreak();
Files = formField.Files.Select(m => new FileViewModel(m, abstractFormId)).ToList();
//FieldFileGuids = src.FieldFileGuidsArray;
//Files = src.Files;
CFTypeLabelAttribute att = Attribute.GetCustomAttribute(formField.GetType(), typeof(CFTypeLabelAttribute)) as CFTypeLabelAttribute;
TypeLabel = att == null?formField.GetType().ToString() : att.Name;
IsOptionField = typeof(OptionsField).IsAssignableFrom(formField.GetType());
if (IsOptionField)
{
MultilingualOptionSet = new List <TextValue>();
//making sure we have an option-list editor for each language defined in the configuration settings.
foreach (var lang in ConfigHelper.Languages)
{
MultilingualOptionSet.Add(new TextValue(lang.TwoLetterISOLanguageName, lang.NativeName, ""));
}
IReadOnlyList <Option> options = (formField as OptionsField).Options;
foreach (Option op in options)
{
foreach (TextValue txt in op.Value)
{
TextValue editorData = MultilingualOptionSet.Where(x => x.LanguageCode == txt.LanguageCode).FirstOrDefault();
//Accommodating odd situations where data has a language that is not specified in the configuration
if (editorData == null)
{
MultilingualOptionSet.Add(editorData = new TextValue(txt.LanguageCode, txt.LanguageLabel, ""));
}
if (string.IsNullOrEmpty(editorData.Value))
{
editorData.Value = txt.Value;
}
else
{
editorData.Value = editorData.Value + "\n" + txt.Value;
}
}
}
}
}
protected string SortField(int sortAttributeMappingId)
{
string sortField = null;
CFEntityTypeAttributeMapping attrMap = Db.EntityTypeAttributeMappings.Where(m => m.Id == sortAttributeMappingId).FirstOrDefault();
if (attrMap != null)
{
string resultType = "en_ss";
FormField field = attrMap.Field;
if (typeof(NumberField).IsAssignableFrom(field.GetType()))
{
resultType = "is";
sortField = string.Format("field(value_{0}_{1}_{2}, min)", attrMap.MetadataSet.Guid.Replace('-', '_'), field.Guid.Replace('-', '_'), resultType);
}
else
{
sortField = string.Format("value_{0}_{1}_{2}", attrMap.MetadataSet.Guid.Replace('-', '_'), field.Guid.Replace('-', '_'), resultType);
}
//return Db.Items.FromSolr(query, out total, entityTypeFilter, start, itemsPerPage,
// sortField, sortAsc);
}
return(sortField);
}
public string[] GetAttributeMappingOptionValues(string name, string lang = null)
{
var mapping = EntityType.AttributeMappings.Where(m => m.Name == name).FirstOrDefault();
if (mapping != null)
{
string msGuid = mapping.MetadataSet.Guid;
string fieldName = mapping.FieldName;
FormField field = GetMetadataSetField(msGuid, fieldName);
if (field == null || !typeof(OptionsField).IsAssignableFrom(field.GetType()))
{
return(new string[] { string.Format("ERROR: INCORRECT {0} OPTIONS MAPPING FOUND FOR THIS ENTITY TYPE", mapping) });
}
OptionsField optionField = (OptionsField)field;
IEnumerable <List <TextValue> > values = optionField.Options.Where(o => o.Selected).Select(o => o.Value);
if (lang != null)
{
return(values.SelectMany(v => v).Where(v => v.LanguageCode == lang).Select(v => v.Value).ToArray());
}
return(values.Select(v => MultilingualHelper.Join(v, " / ", false)).ToArray());
}
return(new string[] { });
}
public string GetAttributeMappingValue(string name, string lang = null)
{
if (EntityType == null)
{
return(null);
}
var mapping = EntityType.AttributeMappings.Where(m => m.Name == name).FirstOrDefault();
if (mapping != null)
{
string msGuid = mapping.MetadataSet.Guid;
string fieldName = mapping.FieldName;
FormField field = GetMetadataSetField(msGuid, fieldName);
if (field == null)
{
return(string.Format("ERROR: INCORRECT {0} MAPPING FOUND FOR THIS ENTITY TYPE", mapping));
}
if (typeof(OptionsField).IsAssignableFrom(field.GetType()))
{
return(string.Join(", ", GetAttributeMappingOptionValues(name, lang)));
}
return(MultilingualHelper.Join(field.GetValues(true, lang), " / ", false));
}
return(null);
}
public FormFieldViewModel(FormField field, string[] languageCodes) : this()
{
var names = field.GetNames(true);
var values = field.GetValues(false);
IEnumerable <Option> options = typeof(OptionsField).IsAssignableFrom(field.GetType()) ? ((OptionsField)field).Options : new List <Option>();
foreach (var name in names)
{
if (languageCodes.Contains(name.LanguageCode))
{
Names.Add(name.LanguageCode, name.Value);
}
}
foreach (var value in values)
{
if (languageCodes.Contains(value.LanguageCode))
{
if (Values.ContainsKey(value.LanguageCode))
{
Values = new Dictionary <string, string>();
ValuesList.Add(Values);
Values.Add(value.LanguageCode, value.Value);
}
else
{
Values.Add(value.LanguageCode, value.Value);
}
}
}
foreach (string code in languageCodes)
{
SelectedOptions.Add(code, new List <string>());
}
foreach (var option in options)
{
if (option.Selected)
{
foreach (var optionVal in option.Value)
{
if (languageCodes.Contains(optionVal.LanguageCode))
{
SelectedOptions[optionVal.LanguageCode].Add(optionVal.Value);
}
}
}
}
}
private void GetDynamicValues(
ref Dictionary <string, object> result,
string keyFields,
FormField field)
{
Regex numberRegex = new Regex(@"^(?=.)([+-]?([0-9]*)(\.([0-9]+))?)$");
// add field Options Values
if (typeof(OptionsField).IsAssignableFrom(field.GetType()))
{
AddOptions(ref result, keyFields, field as OptionsField);
}
else
{
// add field Values
foreach (TextValue textValue in field.Values)
{
// language
AddTextValue(ref result, keyFields, textValue);
// numbers
// if value can be interpreted as number add decimal and
// integer values to solr
if (numberRegex.Matches(textValue.Value).Count > 0)
{
string integerKey = $@"value_{keyFields}_is";
string decimalKey = $@"value_{keyFields}_ds";
Decimal decimalValue = Decimal.Parse(textValue.Value);
if (!result.ContainsKey(decimalKey))
{
result[decimalKey] = new List <decimal>();
}
if (!result.ContainsKey(integerKey))
{
result[integerKey] = new List <int>();
}
((List <decimal>)result[decimalKey]).Add(decimalValue);
((List <int>)result[integerKey]).Add((int)Decimal.Round(decimalValue));
}
}
}
}
private string GetGraphFieldString(string metadataSetGuid, string fieldGuid, string languageCode = "en", bool wrapInFunction = false)
{
string baseSearch = wrapInFunction ? "\"unique(value_{0}_{1}_{2}_ss)\"" : "value_{0}_{1}_{2}_ss";
CFMetadataSet metadataSet = MetadataSrv.GetMetadataSet(metadataSetGuid);
FormField field = metadataSet.Fields.Where(f => f.Guid.Equals(fieldGuid)).FirstOrDefault();
if (field != null)
{
if (typeof(NumberField).IsAssignableFrom(field.GetType()))
{
baseSearch = wrapInFunction ? "\"sum(field(value_{0}_{1}_is, max))\"" : "value_{0}_{1}_is";
}
}
return(string.Format(baseSearch, metadataSetGuid.Replace('-', '_'), fieldGuid.Replace('-', '_'), languageCode));
}
public FormFieldViewModel(FormField formField, int abstractFormId)
{
Name = formField.MultilingualName.ToList();
Description = formField.MultilingualDescription.ToList();
IsRequired = formField.IsRequired;
FieldType = formField.GetType().AssemblyQualifiedName;
Guid = formField.Guid;
Rank = formField.Rank;
Page = formField.Page;
IsPageBreak = formField.IsPageBreak();
Files = formField.Files.Select( m => new FileViewModel(m, abstractFormId)).ToList();
//FieldFileGuids = src.FieldFileGuidsArray;
//Files = src.Files;
CFTypeLabelAttribute att = Attribute.GetCustomAttribute(formField.GetType(), typeof(CFTypeLabelAttribute)) as CFTypeLabelAttribute;
TypeLabel = att == null ? formField.GetType().ToString() : att.Name;
IsSliderField = typeof(SliderField).IsAssignableFrom(formField.GetType());
if (IsSliderField)
{
Min = ((SliderField)formField).Min;
Max = ((SliderField)formField).Max;
Step = ((SliderField)formField).Step;
MinLabel = ((SliderField)formField).MinLabel;
MaxLabel = ((SliderField)formField).MaxLabel;
}
IsExternalMediaField = typeof(ExternalMediaField).IsAssignableFrom(formField.GetType());
MediaProperties = new List<KeyValuePair<string, ViewModelTuple<IEnumerable<string>, bool>>>();
if (IsExternalMediaField)
{
Source = ((ExternalMediaField)formField).Source;
MimeType = Enum.GetName(typeof(CFDataFile.MimeType), ((ExternalMediaField)formField).MediaType);
var mediaTypeProperties = formField.GetType().GetProperties().Where(p => Attribute.IsDefined(p, typeof(MediaTypeAttribute)));
foreach (var p in mediaTypeProperties)
{
MediaProperties.Add(new KeyValuePair<string, ViewModelTuple<IEnumerable<string>, bool>>(p.Name, new ViewModelTuple<IEnumerable<string>, bool>(p.GetCustomAttribute<MediaTypeAttribute>(true)
.MimeTypes.Select(m => Enum.GetName(typeof(CFDataFile.MimeType), m)),
(bool)p.GetValue(formField))));
}
}
IsOptionField = typeof(OptionsField).IsAssignableFrom(formField.GetType());
if (IsOptionField)
{
MultilingualOptionSet = new List<TextValue>();
//making sure we have an option-list editor for each language defined in the configuration settings.
foreach (var lang in ConfigHelper.Languages)
MultilingualOptionSet.Add(new TextValue(lang.TwoLetterISOLanguageName, lang.NativeName, ""));
IReadOnlyList<Option> options = (formField as OptionsField).Options;
foreach (Option op in options)
{
foreach (TextValue txt in op.Value)
{
TextValue editorData = MultilingualOptionSet.Where(x => x.LanguageCode == txt.LanguageCode).FirstOrDefault();
//Accommodating odd situations where data has a language that is not specified in the configuration
if (editorData == null)
MultilingualOptionSet.Add(editorData = new TextValue(txt.LanguageCode, txt.LanguageLabel, ""));
if (string.IsNullOrEmpty(editorData.Value))
editorData.Value = txt.Value;
else
editorData.Value = editorData.Value + "\n" + txt.Value;
}
}
}
IsTextArea = typeof(TextArea).IsAssignableFrom(formField.GetType());
if(IsTextArea){
IsRichText = ((TextArea)formField).IsRichText;
}
IsTextField = typeof(TextField).IsAssignableFrom(formField.GetType());
if (IsTextField)
IsMultiple = ((TextField)formField).IsMultiple; //Nov 19 2016
}
public FormField InstantiateDataModel()
{
Type type = Type.GetType(FieldType, true);
if (!typeof(FormField).IsAssignableFrom(type))
throw new InvalidOperationException("Bad Type");
FormField field = Activator.CreateInstance(type) as FormField;
field.MultilingualName = Name;
field.MultilingualDescription = Description;
field.IsRequired = IsRequired;
field.Guid = Guid;
field.Rank = Rank;
field.Page = Page;
field.Files = Files != null ? Files.Select(m => m.ToFileDescription()).ToList() :
new List<CFFileDescription>();
UpdateFileList(field);
if (IsSliderField)
{
((SliderField)field).Min = Min;
((SliderField)field).Max = Max;
((SliderField)field).Step = Step;
((SliderField)field).MinLabel = MinLabel;
((SliderField)field).MaxLabel = MaxLabel;
}
if (IsExternalMediaField)
{
((ExternalMediaField)field).Source = Source;
((ExternalMediaField)field).MediaType = (CFDataFile.MimeType)Enum.Parse(typeof(CFDataFile.MimeType), MimeType);
var mediaTypeProperties = field.GetType().GetProperties().Where(p => Attribute.IsDefined(p, typeof(MediaTypeAttribute)));
foreach(var entry in MediaProperties)
{
mediaTypeProperties.Where(p => p.Name == entry.Key).First().SetValue(field, entry.Value.Item2);
}
}
if (typeof(OptionsField).IsAssignableFrom(type))
{
//Creating option list separately and assigning it to the Options propery of the Options field
//to make sure that the overridden setter method is invoked to save data in XML
List<Option> optList = new List<Option>();
//In the this FormFieldViewModel, each TextValue element in the "MultilingualOptionSet" array
//contains a text string of which each line represents an "option" in the data model.
foreach (TextValue optionValueSet in MultilingualOptionSet)
{
string[] optionTextValues = optionValueSet.Value
.Split(new char[] { '\r', '\n' }, StringSplitOptions.None)
.Select(v => v.Trim())
.Where(v => !string.IsNullOrEmpty(v))
.ToArray();
for (int i = 0; i < optionTextValues.Length; ++i)
{
if (optList.Count <= i)
optList.Add(new Option());
optList[i].Value.Add(new TextValue(optionValueSet.LanguageCode, optionValueSet.LanguageLabel, optionTextValues[i]));
}
}
(field as OptionsField).Options = optList;
}
if (IsTextArea)
{
((TextArea)field).IsRichText = IsRichText;
}
if (IsTextField)
{
((TextField)field).IsMultiple = IsMultiple;
}
return field;
}
public Dictionary <string, List <string> > ExportValues(FormField field)
{
Dictionary <string, List <string> > values = new Dictionary <string, List <string> >();
if (field is HtmlField || field is ExternalMediaField)
{
return(values); //These fields do not take user inputs.
}
if (field is CompositeFormField)
{
//exporting values from the header
foreach (var child in (field as CompositeFormField).Header)
{
Dictionary <string, List <string> > childValues = ExportValues(child);
foreach (var obj in childValues)
{
if (values.ContainsKey(obj.Key))
{
values[obj.Key].AddRange(obj.Value);
}
else
{
values.Add(obj.Key, obj.Value);
}
}
}
//exporting values from the child fields
foreach (var child in (field as CompositeFormField).Fields)
{
Dictionary <string, List <string> > childValues = ExportValues(child);
foreach (var obj in childValues)
{
if (values.ContainsKey(obj.Key))
{
values[obj.Key].AddRange(obj.Value);
}
else
{
values.Add(obj.Key, obj.Value);
}
}
}
//exporting values from the footer fields
foreach (var child in (field as CompositeFormField).Footer)
{
Dictionary <string, List <string> > childValues = ExportValues(child);
foreach (var obj in childValues)
{
if (values.ContainsKey(obj.Key))
{
values[obj.Key].AddRange(obj.Value);
}
else
{
values.Add(obj.Key, obj.Value);
}
}
}
}
else
{
var vals = field.GetValues();
//Melania
if (typeof(OptionsField).IsAssignableFrom(field.GetType()))
{
vals = field.GetOptionValues();
}
if (vals.Count() > 0)
{
foreach (var val in vals)
{
if (values.ContainsKey(field.ReferenceLabel))
{
values[field.ReferenceLabel].Add(val.Value);
}
else
{
values.Add(field.ReferenceLabel, new List <string>()
{
val.Value
});
}
}
}
else
{
values.Add(field.ReferenceLabel, new List <string>());
}
}
return(values);
}
