public void Temp()
{
var productService = ObjectFactoryBase.Resolve <IProductService>();
var article = productService.GetProductById(2166354);
XamlConfigurationParser.Save(article);
}
public static T GetXaml <T>(string path)
{
using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(path))
{
return((T)XamlConfigurationParser.LoadFrom(stream));
}
}
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 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 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 string Serialize(Content product)
{
using (var stream = new MemoryStream())
{
XamlConfigurationParser.SaveTo(stream, product);
return(new StreamReader(stream).ReadToEnd());
}
}
private static UIElement Read(string path)
{
using (var stream = File.OpenRead(path))
{
Throws.IfNot(stream != null, "The requested file is not exist.");
// создаем экземпляр
return((UIElement)XamlConfigurationParser.LoadFrom(stream));
}
}
protected virtual T GetOrAdd <T>(string key, Func <T> func)
{
var paths = new List <string>()
{
Path.Combine(DataDirectory, key)
};
if (ArchiveFiles)
{
paths.Insert(0, Path.Combine(DataDirectory, $"{key}.zip"));
}
foreach (var path in paths)
{
if (File.Exists(path))
{
if (path.EndsWith("zip"))
{
using (var archive = ZipFile.OpenRead(path))
{
var entry = archive.Entries.FirstOrDefault();
using (var stream = entry.Open())
{
return((T)XamlConfigurationParser.LoadFrom(stream));
}
}
}
else
{
return((T)XamlConfigurationParser.LoadFrom(path));
}
}
}
var data = func();
if (data != null)
{
var path = paths[0];
if (path.EndsWith("zip"))
{
using (var memoryStream = File.Create(path))
{
using (var archive = new ZipArchive(memoryStream, ZipArchiveMode.Create))
{
var entry = archive.CreateEntry(key);
using (var stream = entry.Open())
{
XamlConfigurationParser.SaveTo(stream, data);
}
}
}
}
}
return(data);
}
protected T GetXaml <T>(string path)
{
using (var stream = Assembly.GetExecutingAssembly()
.GetManifestResourceStream(path))
{
Throws.IfNot(stream != null, "The requested file is not found in embedded resource.");
// создаем экземпляр
return((T)XamlConfigurationParser.LoadFrom(stream));
}
}
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 UIElement GetControlForProduct(Article product)
{
var text = GetString(product);
if (!string.IsNullOrEmpty(text))
{
return((UIElement)XamlConfigurationParser.CreateFrom(text));
}
return(null);
}
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 ActionResult GetInitialNodeUrl(int?contentId)
{
var xml = XamlConfigurationParser.Save(new Content {
ContentId = contentId.Value
});
return(new ContentResult()
{
ContentType = "application/json", Content = JsonConvert.SerializeObject(xml)
});
}
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 Index([Bind("content_item_id")] int?contentItemId, int?contentId)
{
_cacheItemWatcher.TrackChanges();
var definitionXml = contentItemId.HasValue
? _contentDefinitionService.GetDefinitionXml(contentItemId.Value)
: contentId.HasValue
? XamlConfigurationParser.Save(new Content {
ContentId = contentId.Value
})
: string.Empty;
return(View(new DefinitionEditor {
ContentItemId = contentItemId, Xml = definitionXml
}));
}
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 string Serialize(Article product)
{
return(XamlConfigurationParser.Save(product));
}
public Task Write(Stream stream, Article product)
{
return(Task.Run(() => XamlConfigurationParser.SaveTo(stream, product)));
}
public Task <Article> Read(Stream stream)
{
return(Task.Run <Article>(() => (Article)XamlConfigurationParser.LoadFrom(stream)));
}
public Task <Content> Read(Stream stream)
{
return(Task.Run <Content>(() => (Content)XamlConfigurationParser.LoadFrom(stream)));
}
/// <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 static void SaveXaml(string path, object data)
{
XamlConfigurationParser.Save(data);
}
