public override IEnumerable <object[]> GetData(MethodInfo testMethod)
{
if (testMethod == null)
{
throw new ArgumentNullException(nameof(testMethod));
}
var result = new List <object> {
XamlConfigurationParser.CreateFrom(File.ReadAllText(GetFullFilename(_fileName)))
};
if (!string.IsNullOrWhiteSpace(_expression))
{
result.Insert(0, _expression);
}
if (_expectedCount.HasValue)
{
result.Add(_expectedCount);
}
return(new[]
{
result.ToArray()
});
}
public void TestEvaluatorExtensionField()
{
var xaml = File.ReadAllText("TestData\\ReferenceDto.xaml");
var productDto = (Article)XamlConfigurationParser.CreateFrom(xaml);
var res = DPathProcessor.Process("MarketingProduct[ProductType='289']", productDto);
Assert.IsTrue(res.Length > 0);
}
public void TestEvaluatorRootFilter()
{
var xaml = File.ReadAllText("TestData\\ReferenceDto.xaml");
var productDto = (Article)XamlConfigurationParser.CreateFrom(xaml);
var res = DPathProcessor.Process("[Type='305']", productDto);
Assert.IsTrue(res.Length > 0);
}
public ActionResult GetDefinitionLevel(DefinitionPathInfo defInfo)
{
var content = (Content)XamlConfigurationParser.CreateFrom(defInfo.Xml);
var objects = DefinitionTreeNode.GetObjectsFromPath(content, defInfo.Path, _fieldService,
_definitionEditorService, _contentService);
return(new ContentResult()
{
ContentType = "application/json", Content = JsonConvert.SerializeObject(objects)
});
}
public UIElement GetControlForProduct(Article product)
{
var text = GetString(product);
if (!string.IsNullOrEmpty(text))
{
return((UIElement)XamlConfigurationParser.CreateFrom(text));
}
return(null);
}
public void TextJsonDeserialization()
{
var jsonProductService = ObjectFactoryBase.Resolve <IJsonProductService>();
var defStr = File.ReadAllText("TestData\\ProductDefinition.xaml");
var json = File.ReadAllText("TestData\\ProductJson.js");
var resultArticle = jsonProductService.DeserializeProduct(json, (Content)XamlConfigurationParser.CreateFrom(defStr));
var resultXaml = XamlConfigurationParser.Save(resultArticle);
var referenceXaml = File.ReadAllText("TestData\\ReferenceDto.xaml");
Assert.AreEqual(resultXaml, referenceXaml);
}
public ActionResult Edit(DefinitionPathInfo defInfo)
{
var rootContent = (Content)XamlConfigurationParser.CreateFrom(defInfo.Xml);
var objectToEdit = _definitionEditorService.GetObjectFromPath(rootContent, defInfo.Path, out var notFoundInDef);
if (objectToEdit is Field edit)
{
return new ContentResult()
{
ContentType = "application/json", Content = JsonConvert.SerializeObject(new DefinitionFieldInfo(edit)
{
InDefinition = !notFoundInDef,
Path = defInfo.Path,
Xml = defInfo.Xml
}
)
}
}
;
var isFromDictionaries = false;
if (!Equals(rootContent, objectToEdit))
{
isFromDictionaries = _definitionEditorService.GetParentObjectFromPath(rootContent, defInfo.Path) is Dictionaries;
}
var contentToEdit = (Content)objectToEdit;
return(new ContentResult()
{
ContentType = "application/json", Content = JsonConvert.SerializeObject(new DefinitionContentInfo
{
ContentName = contentToEdit.ContentName,
IsReadOnly = contentToEdit.IsReadOnly,
PublishingMode = contentToEdit.PublishingMode,
ContentId = contentToEdit.ContentId,
LoadAllPlainFields = contentToEdit.LoadAllPlainFields,
CacheEnabled = contentToEdit.CachePeriod.HasValue,
CachePeriod = contentToEdit.CachePeriod ?? new TimeSpan(1, 45, 0),
Path = defInfo.Path,
Xml = defInfo.Xml,
InDefinition = !notFoundInDef,
IsFromDictionaries = isFromDictionaries,
})
});
}
public void TestXmlDeserialization()
{
var xmlProductService = ObjectFactoryBase.Resolve <IXmlProductService>();
var xDoc = XDocument.Load("TestData\\Product.xml");
var defStr = File.ReadAllText("TestData\\ProductDefinition.xaml");
var resultArticle = xmlProductService.DeserializeProductXml(xDoc, (Content)XamlConfigurationParser.CreateFrom(defStr));
var st = new Stopwatch();
st.Start();
xmlProductService.DeserializeProductXml(xDoc, (Content)XamlConfigurationParser.CreateFrom(defStr));
st.Stop();
Debug.WriteLine(st.Elapsed);
XamlConfigurationParser.Save(resultArticle);
File.ReadAllText("TestData\\ReferenceDto.xaml");
}
public ActionResult GetSingleNode(DefinitionPathInfo defInfo)
{
var content = (Content)XamlConfigurationParser.CreateFrom(defInfo.Xml);
var objFromDef = _definitionEditorService.GetObjectFromPath(content, defInfo.Path, out var notFoundInDef);
if (objFromDef == null)
{
return(Json(new { MissingFieldToDeleteId = defInfo.Path }));
}
DefinitionTreeNode resultObj = null;
switch (objFromDef)
{
case Content def:
{
var isFromDictionaries = _definitionEditorService.GetParentObjectFromPath(content, defInfo.Path) is Dictionaries;
resultObj = new DefinitionTreeNode(def, null, defInfo.Path, isFromDictionaries, notFoundInDef, _contentService);
break;
}
case Field field:
{
var existsInQp = true;
if (!(field is BaseVirtualField))
{
existsInQp = _fieldService.Read(field.FieldId) != null;
}
resultObj = new DefinitionTreeNode(field, null, defInfo.Path, !existsInQp, notFoundInDef);
break;
}
}
return(new ContentResult()
{
ContentType = "application/json", Content = JsonConvert.SerializeObject(resultObj)
});
}
public Content[] GetDefinitions(bool isLive = false)
{
int prodDefContentId = int.Parse(_settingsService.GetSetting(SettingsTitles.PRODUCT_DEFINITIONS_CONTENT_ID));
using (_articleService.CreateQpConnectionScope())
{
_articleService.IsLive = isLive;
var definitions = _articleService.List(prodDefContentId, null).Where(x => !x.Archived && x.Visible);
return(definitions
.Select(x => x.FieldValues
.Where(a => a.Field.Name == FIELD_NAME_XML_DEF)
.Select(a => a.Value)
.FirstOrDefault())
.Where(x => !string.IsNullOrEmpty(x))
.Select(x => (Content)XamlConfigurationParser.CreateFrom(x))
.ToArray());
}
}
public EditorDefinition GetEditorDefinition(int productTypeId, int contentId, bool isLive = false)
{
int xamlContentId = int.Parse(_settingsService.GetSetting(SettingsTitles.PRODUCT_DEFINITIONS_CONTENT_ID));
var fieldsByName = GetDefinitionFields(xamlContentId, contentId, productTypeId, isLive, forEditor: true);
if (fieldsByName != null &&
fieldsByName.TryGetValue(FIELD_NAME_XML_DEF, out string xmlDefinition) &&
fieldsByName.TryGetValue(nameof(Article.Id), out string productDefinitionId) &&
fieldsByName.TryGetValue(FIELD_NAME_EDITOR_VIEW_PATH, out string editorViewPath))
{
return(new EditorDefinition
{
Content = (Content)XamlConfigurationParser.CreateFrom(xmlDefinition),
ProductDefinitionId = Int32.Parse(productDefinitionId),
EditorViewPath = editorViewPath
});
}
return(null);
}
public ActionResult SaveField(DefinitionFieldInfo defInfo)
{
var rootContent = (Content)XamlConfigurationParser.CreateFrom(defInfo.Xml);
var savedField = _definitionEditorService.UpdateOrDeleteField(rootContent, defInfo.GetField(), defInfo.Path, !defInfo.InDefinition);
string resultXml = XamlConfigurationParser.Save(rootContent);
ModelState.Clear();
Field fieldForEditView = savedField ?? (Field)_definitionEditorService.GetObjectFromPath(rootContent, defInfo.Path, out _);
return(new ContentResult()
{
ContentType = "application/json",
Content = JsonConvert.SerializeObject(new DefinitionFieldInfo(fieldForEditView)
{
InDefinition = defInfo.InDefinition,
Path = defInfo.Path,
Xml = resultXml
})
});
}
public static Content GetContent(string text)
{
return((Content)XamlConfigurationParser.CreateFrom(text));
}
/// <returns><see cref="Content"/> or null</returns>
public Content TryGetDefinitionForContent(int productTypeId, int contentId, bool isLive = false)
{
string xml = GetDefinitionXml(productTypeId, contentId, isLive);
return(xml != null ? (Content)XamlConfigurationParser.CreateFrom(xml) : null);
}
public Content GetDefinitionForContent(int productTypeId, int contentId, bool isLive = false)
{
return((Content)XamlConfigurationParser.CreateFrom(GetDefinitionXml(productTypeId, contentId, isLive)));
}
public Content GetDefinitionById(int productDefinitionId, bool isLive = false)
{
return((Content)XamlConfigurationParser.CreateFrom(GetDefinitionXml(productDefinitionId, isLive)));
}
public ServiceDefinition GetServiceDefinition(string slug, string version, bool clearExtensions)
{
int productServicesContentId = int.Parse(_settingsService.GetSetting(SettingsTitles.PRODUCT_SERVICES_CONTENT_ID));
int prodDefContentId = int.Parse(_settingsService.GetSetting(SettingsTitles.PRODUCT_DEFINITIONS_CONTENT_ID));
string cacheKey = $"KEY_GET_DEFINITION_BY_SLUG:{slug.ToLower()}_{version.ToLower()}";
return(_cacheProvider.GetOrAdd(
cacheKey,
new[] { productServicesContentId.ToString(), prodDefContentId.ToString() },
_cachePeriod, () =>
{
using (_articleService.CreateQpConnectionScope())
{
var dbConnector = new DBConnector(_customer.ConnectionString, _customer.DatabaseType);
string wherePart =
$@"(lower({FIELD_NAME_SLUG})='{slug.Replace("'", "").ToLower()}'
AND lower({FIELD_NAME_VERSION})='{version.Replace("'", "").ToLower()}')" ;
var dtdefinitionArticles = dbConnector.GetContentData(new ContentDataQueryObject(
dbConnector,
productServicesContentId,
FIELD_NAME_DEFINITION + "," + FIELD_NAME_TYPE + "," + FIELD_NAME_FILTER,
wherePart, null, 0, 1));
if (dtdefinitionArticles.Rows.Count == 0)
{
throw new Exception($"Slug '{slug}' with version '{version}' not found");
}
int definitionArticleId = (int)(decimal)dtdefinitionArticles.Rows[0][FIELD_NAME_DEFINITION];
object productTypeArticleId = dtdefinitionArticles.Rows[0][FIELD_NAME_TYPE];
int[] exstensionContentIds = new int[0];
var content = (Content)XamlConfigurationParser.CreateFrom(
_articleService.GetFieldValues(new[] { definitionArticleId }, prodDefContentId, FIELD_NAME_XML_DEF)[0]);
if (productTypeArticleId is decimal)
{
var productTypeArticle = _articleService.Read((int)(decimal)productTypeArticleId);
exstensionContentIds = productTypeArticle.FieldValues
.Where(fv => fv.Field.Name.EndsWith("content", StringComparison.CurrentCultureIgnoreCase) &&
fv.RelatedItems.Any())
.SelectMany(fv => fv.RelatedItems)
.Distinct()
.ToArray();
}
if (clearExtensions)
{
ClearExstensions(content, exstensionContentIds, null);
}
return new ServiceDefinition
{
Content = content,
Filter = dtdefinitionArticles.Rows[0][FIELD_NAME_FILTER].ToString(),
ExstensionContentIds = exstensionContentIds
};
}
}));
}
public RemoteValidationResult Validate(RemoteValidationContext context, RemoteValidationResult result)
{
var xmlDefinition = context.Definitions.FirstOrDefault(x => x.Alias == FieldXmlDefinition);
if (xmlDefinition == null)
{
var message = new ActionTaskResultMessage()
{
ResourceClass = ValidationHelper.ResourceClass,
ResourceName = nameof(RemoteValidationMessages.FieldNotFound),
Parameters = new object[] { FieldXmlDefinition }
};
result.Messages.Add(ValidationHelper.ToString(context, message));
}
var xaml = context.ProvideValueExact <string>(xmlDefinition);
if (!string.IsNullOrWhiteSpace(xaml))
{
Content definition;
try
{
definition = (Content)XamlConfigurationParser.CreateFrom(xaml);
}
catch (Exception ex)
{
var message = new ActionTaskResultMessage()
{
ResourceClass = ValidationHelper.ResourceClass,
ResourceName = nameof(RemoteValidationMessages.NotValidXamlDefinition),
Parameters = new object[] { ex.Message }
};
result.Messages.Add(ValidationHelper.ToString(context, message));
return(result);
}
var jsonDefinition = context.Definitions.FirstOrDefault(x => x.Alias == FieldJsonDefinition);
if (jsonDefinition != null)
{
using (var stream = new MemoryStream())
{
using (var reader = new StreamReader(stream))
{
try
{
_formatter.Write(stream, definition);
stream.Position = 0;
context.SetValue(result, jsonDefinition, reader.ReadToEnd());
}
catch (Exception ex)
{
var message = new ActionTaskResultMessage()
{
ResourceClass = ValidationHelper.ResourceClass,
ResourceName = nameof(RemoteValidationMessages.JsonDefinitionError),
Parameters = new object[] { ex.Message }
};
result.Messages.Add(ValidationHelper.ToString(context, message));
return(result);
}
}
}
}
}
return(result);
}
public ActionResult SaveContent(DefinitionContentInfo defInfo)
{
var rootContent = (Content)XamlConfigurationParser.CreateFrom(defInfo.Xml);
var contentToSave = (Content)_definitionEditorService.GetObjectFromPath(rootContent, defInfo.Path, out var notFoundInDef);
contentToSave.ContentName = defInfo.ContentName;
contentToSave.CachePeriod = defInfo.CacheEnabled ? defInfo.CachePeriod : (TimeSpan?)null;
if (defInfo.IsFromDictionaries)
{
var dictionaries = (Dictionaries)_definitionEditorService.GetParentObjectFromPath(rootContent, defInfo.Path);
if (contentToSave.CachePeriod != null && notFoundInDef)
{
dictionaries.ContentDictionaries[contentToSave.ContentId] = contentToSave;
}
else if (contentToSave.CachePeriod == null && !notFoundInDef)
{
dictionaries.ContentDictionaries.Remove(contentToSave.ContentId);
}
}
else
{
contentToSave.IsReadOnly = defInfo.IsReadOnly;
contentToSave.LoadAllPlainFields = defInfo.LoadAllPlainFields;
contentToSave.PublishingMode = defInfo.PublishingMode;
if (notFoundInDef)
{
var parentExtension = (ExtensionField)_definitionEditorService.GetParentObjectFromPath(rootContent, defInfo.Path);
parentExtension.ContentMapping[contentToSave.ContentId] = contentToSave;
}
}
string resultXml = XamlConfigurationParser.Save(rootContent);
var objectToEdit = _definitionEditorService.GetObjectFromPath(rootContent, defInfo.Path, out _);
var isFromDictionaries = false;
if (!Equals(rootContent, objectToEdit))
{
isFromDictionaries = _definitionEditorService.GetParentObjectFromPath(rootContent, defInfo.Path) is Dictionaries;
}
var contentToEdit = (Content)objectToEdit;
ModelState.Clear();
return(new ContentResult()
{
ContentType = "application/json",
Content = JsonConvert.SerializeObject(new DefinitionContentInfo
{
ContentName = contentToEdit.ContentName,
IsReadOnly = contentToEdit.IsReadOnly,
PublishingMode = contentToEdit.PublishingMode,
ContentId = contentToEdit.ContentId,
LoadAllPlainFields = contentToEdit.LoadAllPlainFields,
CacheEnabled = contentToEdit.CachePeriod.HasValue,
CachePeriod = contentToEdit.CachePeriod ?? new TimeSpan(1, 45, 0),
Path = defInfo.Path,
Xml = resultXml,
InDefinition = !notFoundInDef,
IsFromDictionaries = isFromDictionaries,
})
});
}