private async System.Threading.Tasks.Task CreatePackage(StreamWriter deliveryFileStream, string name)
{
var contentTypes = GetEntityChanges(_contentTypeService.GetAllContentTypes(), EntityType.CONTENT_TYPE);
var dataTypes = GetEntityChanges(_dataTypeService.GetAllDataTypeDefinitions(), EntityType.DATA_TYPE);
var templates = GetFileChanges(_fileService.GetTemplates(), EntityType.TEMPLATE);
var styleSheets = GetFileChanges(_fileService.GetStylesheets(), EntityType.STYLESHEET);
var macros = GetChangedMacros();
var packageXml = new XDocument();
packageXml.Add(
new XElement(
"umbPackage",
new XElement(
"DocumentTypes",
contentTypes.Select(ct => _packagingService.Export(ct, false))
),
_packagingService.Export(dataTypes, false),
_packagingService.Export(templates, false),
_packagingService.Export(macros, false),
new XElement(
"Stylesheets",
styleSheets.Select(s =>
new XElement(
"Stylesheet",
new XElement("Name", s.Alias),
new XElement("FileName", s.Name),
new XElement("Content", new XCData(s.Content)),
new XElement(
"Properties",
s.Properties.Select(p =>
new XElement(
"Property",
new XElement("Name", p.Name),
new XElement("Alias", p.Alias),
new XElement("Value", p.Value)
)
)
)
)
)
)
)
);
_settings.TryGetChauffeurDirectory(out string dir);
_fileSystem.File.WriteAllText(_fileSystem.Path.Combine(dir, $"{name}.xml"), packageXml.ToString());
await deliveryFileStream.WriteLineAsync($"package {name}");
_database.TruncateTable("Chauffeur_Changes");
}
public static bool DataTypeChanged(XElement node)
{
string filehash = XmlDoc.GetPreCalculatedHash(node);
if (string.IsNullOrEmpty(filehash))
{
return(true);
}
var dataTypeDefinitionId = new Guid(node.Attribute("Definition").Value);
XAttribute defId = node.Attribute("Definition");
if (defId == null)
{
return(true);
}
/*
* //var _dataTypeService = ApplicationContext.Current.Services.DataTypeService;
* var item = _dataTypeService.GetDataTypeDefinitionById(new Guid(defId.Value));
*/
if (_dataTypes == null)
{
// speed test, calling data types seems slow,
// so we load all them at once, then refrence this when doing the compares.
// this is a little bit faster than calling each one as we go through...
_dataTypes = new Dictionary <Guid, IDataTypeDefinition>();
foreach (IDataTypeDefinition dtype in _dataTypeService.GetAllDataTypeDefinitions())
{
_dataTypes.Add(dtype.Key, dtype);
}
}
Guid defGuid = new Guid(defId.Value);
if (!_dataTypes.ContainsKey(defGuid))
{
return(true);
}
//var packagingService = ApplicationContext.Current.Services.PackagingService;
XElement export = _packagingService.Export(_dataTypes[defGuid], false);
string dbMD5 = XmlDoc.CalculateMD5Hash(export, true);
// LogHelper.Info<uSync>("XML File (we just got to hash from) {0}", () => export.ToString());
// LogHelper.Info<uSync>("File {0} : Guid {1}", () => filehash, () => dbMD5);
return(!filehash.Equals(dbMD5));
}
private async Task CreatePackage(StreamWriter deliveryFileStream, string name)
{
var contentTypes = contentTypeService.GetAllContentTypes();
var dataTypes = dataTypeService.GetAllDataTypeDefinitions();
var templates = fileService.GetTemplates();
var styleSheets = fileService.GetStylesheets();
var macros = macroService.GetAll();
var packageXml = new XDocument();
packageXml.Add(
new XElement(
"umbPackage",
new XElement(
"DocumentTypes",
contentTypes.Select(ct => packagingService.Export(ct, false))
),
packagingService.Export(dataTypes, false),
packagingService.Export(templates, false),
packagingService.Export(macros, false),
new XElement(
"Stylesheets",
styleSheets.Select(s =>
new XElement(
"Stylesheet",
new XElement("Name", s.Alias),
new XElement("FileName", s.Name),
new XElement("Content", new XCData(s.Content)),
new XElement(
"Properties",
s.Properties.Select(p =>
new XElement(
"Property",
new XElement("Name", p.Name),
new XElement("Alias", p.Alias),
new XElement("Value", p.Value)
)
)
)
)
)
)
)
);
settings.TryGetChauffeurDirectory(out string dir);
fileSystem.File.WriteAllText(fileSystem.Path.Combine(dir, $"{name}.xml"), packageXml.ToString());
await deliveryFileStream.WriteLineAsync($"package {name}");
}
internal override SyncAttempt <XElement> SerializeCore(IMacro item)
{
var node = _packaingService.Export(item);
return(SyncAttempt <XElement> .SucceedIf(
node != null, item.Name, node, typeof(IMacro), ChangeType.Export));
}
private async Task Pack(string name, string chauffeurFolder)
{
var fileLocation = fileSystem.Path.Combine(chauffeurFolder, name + ".xml");
if (fileSystem.File.Exists(fileLocation))
{
await Out.WriteLineAsync($"The package '{name}' already in the Chauffeur folder");
return;
}
await Out.WriteLineAsync($"Exporting content to {name}.xml");
var content = contentService.GetRootContent();
var xml = new XDocument();
xml.Add(new XElement("umbPackage",
new XElement("Documents",
new XElement("DocumentSet",
content.Select(c => packagingService.Export(c, true)), new XAttribute("importMode", "root")
)
)
));
settings.TryGetChauffeurDirectory(out string dir);
fileSystem.File.WriteAllText(fileSystem.Path.Combine(dir, $"{name}.xml"), xml.ToString());
await Out.WriteLineAsync($"Content have been exported to {name}");
}
private async Task Export(IEnumerable <string> dataTypes)
{
IEnumerable <IDataTypeDefinition> dataTypeDefinitions;
if (dataTypes.Any())
{
var ids = dataTypes.Select(int.Parse);
dataTypeDefinitions = dataTypeService.GetAllDataTypeDefinitions(ids.ToArray());
}
else
{
dataTypeDefinitions = dataTypeService.GetAllDataTypeDefinitions();
}
if (!settings.TryGetChauffeurDirectory(out string exportDirectory))
{
return;
}
var xml = new XDocument();
xml.Add(packagingService.Export(dataTypeDefinitions, false));
var fileName = DateTime.UtcNow.ToString("yyyyMMdd") + "-data-type-definitions.xml";
fileSystem.File.WriteAllText(fileSystem.Path.Combine(exportDirectory, fileName), xml.ToString());
await Out.WriteLineFormattedAsync("Data Type Definitions have been exported with file name '{0}'", fileName);
}
private async Task Export(string[] args)
{
var contentType = await Get(args, false);
if (contentType == null)
{
return;
}
string exportDirectory;
if (!settings.TryGetChauffeurDirectory(out exportDirectory))
{
return;
}
var xml = new XDocument();
xml.Add(packagingService.Export(contentType, false));
var fileName = DateTime.UtcNow.ToString("yyyyMMdd") + "-" + contentType.Alias + ".xml";
xml.Save(fileSystem.Path.Combine(exportDirectory, fileName));
await Out.WriteLineFormattedAsync("Content Type has been exported with file name '{0}'", fileName);
}
public static bool DataTypeChanged(XElement node)
{
string filehash = XmlDoc.GetPreCalculatedHash(node);
if (string.IsNullOrEmpty(filehash))
{
return(true);
}
var dataTypeDefinitionId = new Guid(node.Attribute("Definition").Value);
XAttribute defId = node.Attribute("Definition");
if (defId == null)
{
return(true);
}
//var _dataTypeService = ApplicationContext.Current.Services.DataTypeService;
var item = _dataTypeService.GetDataTypeDefinitionById(new Guid(defId.Value));
if (item == null)
{
return(true);
}
//var packagingService = ApplicationContext.Current.Services.PackagingService;
XElement export = _packagingService.Export(item, false);
string dbMD5 = XmlDoc.CalculateMD5Hash(export);
// LogHelper.Info<uSync>("File {0} : Guid {1}", () => filehash, () => dbMD5);
return(!filehash.Equals(dbMD5));
}
internal override SyncAttempt <XElement> SerializeCore(IDictionaryItem item)
{
var node = _packagingService.Export(item, true);
return(SyncAttempt <XElement> .SucceedIf(
node != null,
node != null?item.ItemKey : node.NameFromNode(),
node,
typeof(IDictionaryItem),
ChangeType.Export));
}
/// <summary>
/// Creates the full xml representation for the <see cref="IMedia"/> object and all of it's descendants
/// </summary>
/// <param name="media"><see cref="IMedia"/> to generate xml for</param>
/// <param name="packagingService"></param>
/// <returns>Xml representation of the passed in <see cref="IMedia"/></returns>
internal static XElement ToDeepXml(this IMedia media, IPackagingService packagingService)
{
return(packagingService.Export(media, true, raiseEvents: false));
}
/// <summary>
/// Creates the xml representation for the <see cref="IMedia"/> object
/// </summary>
/// <param name="media"><see cref="IContent"/> to generate xml for</param>
/// <param name="packagingService"></param>
/// <returns>Xml representation of the passed in <see cref="IContent"/></returns>
public static XElement ToXml(this IMedia media, IPackagingService packagingService)
{
return(packagingService.Export(media, raiseEvents: false));
}
/// <summary>
/// Creates the xml representation for the <see cref="IContent"/> object
/// </summary>
/// <param name="content"><see cref="IContent"/> to generate xml for</param>
/// <param name="packagingService"></param>
/// <returns>Xml representation of the passed in <see cref="IContent"/></returns>
public static XElement ToXml(this IContent content, IPackagingService packagingService)
{
return(packagingService.Export(content, raiseEvents: false));
}
/// <summary>
/// Creates the full xml representation for the <see cref="IContent"/> object and all of it's descendants
/// </summary>
/// <param name="content"><see cref="IContent"/> to generate xml for</param>
/// <param name="packagingService"></param>
/// <returns>Xml representation of the passed in <see cref="IContent"/></returns>
internal static XElement ToDeepXml(this IContent content, IPackagingService packagingService)
{
return(packagingService.Export(content, true, raiseEvents: false));
}
public static XElement ExportToXml(this IContentType item)
{
XElement element = _packageService.Export(item);
// some extra stuff (we want)
// element.Element("Info").Add(new XElement("key", item.Key));
// element.Element("Info").Add(new XElement("Id", item.Id));
// element.Element("Info").Add(new XElement("Updated", item.UpdateDate));
if (element.Element("Info").Element("Container") == null)
{
element.Element("Info").Add(new XElement("Container", item.IsContainer.ToString()));
}
// fix the current (v6.1/v7.0.1) api doesn't do
// structure export proper
var structure = element.Element("Structure");
// empty it out.
structure.RemoveNodes();
//
// order isn't always right, and we care because we get hash values
//
SortedList <int, ContentTypeSort> allowedTypes = new SortedList <int, ContentTypeSort>();
foreach (var t in item.AllowedContentTypes)
{
allowedTypes.Add(t.Id.Value, t);
}
foreach (var allowedType in allowedTypes)
{
var allowedItem = _contentTypeService.GetContentType(allowedType.Value.Id.Value);
structure.Add(new XElement("DocumentType", allowedItem.Alias));
allowedItem.DisposeIfDisposable();
}
// put the sort order on the tabs
var tabs = element.Element("Tabs");
foreach (var tab in item.PropertyGroups)
{
XElement tabNode = tabs.Elements().First(x => x.Element("Id").Value == tab.Id.ToString());
if (tabNode != null)
{
tabNode.Add(new XElement("SortOrder", tab.SortOrder));
}
}
// put the sort order on the proerties ?
var properties = element.Element("GenericProperties");
foreach (var prop in item.PropertyTypes)
{
XElement propNode = properties.Elements().First(x => x.Element("Alias").Value == prop.Alias);
if (propNode != null)
{
propNode.Add(new XElement("SortOrder", prop.SortOrder));
}
}
return(element);
}
public XElement Export(IMacro macro, bool raiseEvents = true)
{
return(realPackagingService.Export(macro, raiseEvents));
}