public void Dictionary_Parent_Child_Relationship()
{
var parent = CreateNew();
//create a child
var childId = Dictionary.DictionaryItem.addKey("Test" + Guid.NewGuid().ToString("N"), "", parent.key);
Assert.IsTrue(childId > 0);
var child = new Dictionary.DictionaryItem(childId);
Assert.IsTrue(TypeHelper.IsTypeAssignableFrom <Dictionary.DictionaryItem>(child));
//set the parent relationship
Assert.AreEqual(parent.id, child.Parent.id);
Assert.AreEqual(parent.key, child.Parent.key);
Assert.AreEqual(parent.UniqueId, child.Parent.UniqueId);
//test the child relationship
Assert.IsTrue(parent.hasChildren);
Assert.AreEqual(1, parent.Children.Length);
Assert.AreEqual(child.id, parent.Children.First().id);
Assert.AreEqual(child.key, parent.Children.First().key);
Assert.AreEqual(child.UniqueId, parent.Children.First().UniqueId);
DeleteItem(child);
DeleteItem(parent);
}
public override void Render(ref XmlTree tree)
{
Dictionary.DictionaryItem[] tmp;
if (this.id == this.StartNodeID)
{
tmp = Dictionary.getTopMostItems;
}
else
{
tmp = new Dictionary.DictionaryItem(this.id).Children;
}
foreach (Dictionary.DictionaryItem di in tmp)
{
XmlTreeNode xNode = XmlTreeNode.Create(this);
xNode.NodeID = di.id.ToString(); //dictionary_ + id..
xNode.Text = di.key;
xNode.Action = string.Format("javascript:openDictionaryItem({0});", di.id);
xNode.Icon = "settingDataType.gif";
xNode.OpenIcon = "settingDataType.gif";
xNode.NodeType = "DictionaryItem"; //this shouldn't be like this, it should be this.TreeAlias but the ui.config file points to this name.
xNode.Source = this.GetTreeServiceUrl(di.id);
xNode.HasChildren = di.hasChildren;
OnBeforeNodeRender(ref tree, ref xNode, EventArgs.Empty);
if (xNode != null)
{
tree.Add(xNode);
OnAfterNodeRender(ref tree, ref xNode, EventArgs.Empty);
}
}
}
private void DictionaryItem_Saving(Dictionary.DictionaryItem sender, EventArgs e)
{
foreach (var dict in _localisedDictionaries.Where(x => x.Value.Keys.Contains(sender.key)))
{
dict.Value.Invalidated = true;
}
}
public static void ReadFromDisk(string path)
{
if (Directory.Exists(path))
{
foreach (string file in Directory.GetFiles(path, "*.config"))
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(file);
XmlNode node = xmlDoc.SelectSingleNode("./DictionaryItem");
if (node != null)
{
LogHelper.Debug <SyncDictionary>("Node Import: {0} {1}",
() => node.Attributes["Key"].Value, () => node.InnerXml);
try
{
Dictionary.DictionaryItem item = Dictionary.DictionaryItem.Import(node);
if (item != null)
{
item.Save();
}
}
catch (Exception ex)
{
LogHelper.Debug <SyncDictionary>("DictionaryItem.Import Failed {0}: {1}",
() => path, () => ex.ToString());
}
}
}
}
}
private static Dictionary.DictionaryItem GetTop(Dictionary.DictionaryItem item)
{
if (!item.IsTopMostItem())
{
LogHelper.Debug <SyncDictionaryItems>("is Top Most [{0}]", () => item.IsTopMostItem());
try
{
if (item.Parent != null)
{
LogHelper.Debug <SyncDictionaryItems>("parent [{0}]", () => item.Parent.key);
return(GetTop(item.Parent));
}
}
catch (ApplicationException ex)
{
LogHelper.Debug <SyncDictionaryItems>("Exception (just like null)");
}
catch (ArgumentException ex)
{
LogHelper.Debug <SyncDictionaryItems>("Exception (just like null)");
}
}
return(item);
}
static void DictionaryItem_Saving(Dictionary.DictionaryItem sender, EventArgs e)
{
if (!uSync.EventsPaused)
{
SaveToDisk(GetTop(sender));
}
}
public void Dictionary_Attempt_Duplicate_Key()
{
var key = "Test" + Guid.NewGuid().ToString("N");
var d1Id = Dictionary.DictionaryItem.addKey(key, "");
Assert.IsTrue(d1Id > 0);
var d1 = new Dictionary.DictionaryItem(d1Id);
Assert.IsTrue(TypeHelper.IsTypeAssignableFrom <Dictionary.DictionaryItem>(d1));
var alreadyExists = false;
try
{
var d2Id = Dictionary.DictionaryItem.addKey(key, "");
Assert.IsTrue(d2Id > 0);
var d2 = new Dictionary.DictionaryItem(d2Id);
}
catch (ArgumentException)
{
alreadyExists = true;
}
Assert.IsTrue(alreadyExists);
DeleteItem(d1);
}
/// <summary>
/// 获取Umbraco中Dictionary中的值
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static Models.UmbDictionaryModel GetDictionaryByKey(string key)
{
Models.UmbDictionaryModel model = new Models.UmbDictionaryModel();
Dictionary.DictionaryItem item = Dictionary.getTopMostItems.Where(d => d.key.Equals(key)).FirstOrDefault();
model.EnValue = item.Value(1);
model.CnValue = item.Value(2);
model.DicKey = item.key;
return(model);
}
/// <summary>
/// Gets the dictionary item for a specified language. Otherwise returns the fallback string.
/// </summary>
/// <param name="key">The dictionary key.</param>
/// <param name="fallback">The fallback.</param>
/// <param name="languageId">The language id.</param>
/// <returns>
/// Returns the value of a dictionary item from a language id, or the fallback string.
/// </returns>
public static string GetDictionaryItem(string key, string fallback, int languageId)
{
if (Dictionary.DictionaryItem.hasKey(key))
{
var item = new Dictionary.DictionaryItem(key);
return(item.Value(languageId));
}
return(fallback);
}
/// <summary>
/// Gets a dictionary item if it exists. Otherwise returns the fallback string.
/// </summary>
/// <param name="key">The dictionary key.</param>
/// <param name="fallback">The fallback.</param>
/// <returns>
/// A dictionary string or the fallback string
/// </returns>
public static string GetDictionaryItem(string key, string fallback)
{
if (Dictionary.DictionaryItem.hasKey(key))
{
var item = new Dictionary.DictionaryItem(key);
return item.Value();
}
return fallback;
}
public static void SaveToDisk(Dictionary.DictionaryItem item)
{
if (item != null)
{
Umbraco.Core.Strings.DefaultShortStringHelper _sh = new Umbraco.Core.Strings.DefaultShortStringHelper();
XElement node = _engine.Dictionary.Export(item);
var nameKey = _sh.CleanString(item.key, Umbraco.Core.Strings.CleanStringType.Ascii);
uSyncIO.SaveXmlToDisk(node, "Dictionary", nameKey);
}
}
protected void Page_Load(object sender, EventArgs e)
{
int dictionaryItemId = int.TryParse(Request["nodeId"], out dictionaryItemId) ? dictionaryItemId : 0;
//There is an issue in v6 with LocalizationService methods throwing "Sequence contains no elements"
//var localizationService = UmbracoContext.Current.Application.Services.LocalizationService;
var dicItems = new List <Dictionary.DictionaryItem>();
if (dictionaryItemId > 0)
{
var dicItem = new Dictionary.DictionaryItem(dictionaryItemId);
if (dicItem == null)
{
return;
}
dicItems.Add(dicItem);
}
else
{
//export all dictionary items
foreach (var dicItem in Dictionary.getTopMostItems)
{
dicItems.Add(dicItem);
}
}
var fileName = dictionaryItemId == 0 ? "dictionaryitems" : dicItems.First().key;
Path.GetInvalidFileNameChars().ToList().ForEach(c => fileName = fileName.Replace(c, '_'));
Response.AddHeader("Content-Disposition", "attachment;filename=" + fileName + ".dic");
Response.ContentType = "application/octet-stream";
var doc = new XmlDocument();
var parent = doc.CreateElement("DictionaryItems");
foreach (var dicItem in dicItems)
{
parent.AppendChild(dicItem.ToXml(doc));
}
doc.AppendChild(parent);
var writerSettings = new XmlWriterSettings();
writerSettings.Indent = true;
var xmlWriter = XmlWriter.Create(Response.OutputStream, writerSettings);
doc.Save(xmlWriter);
}
private Dictionary.DictionaryItem CreateNew()
{
var id = Dictionary.DictionaryItem.addKey("Test" + Guid.NewGuid().ToString("N"), "");
Assert.IsTrue(id > 0);
var d = new Dictionary.DictionaryItem(id);
Assert.IsTrue(TypeHelper.IsTypeAssignableFrom <Dictionary.DictionaryItem>(d));
return(d);
}
/// <summary>
/// Add Dictionary Item to list
/// </summary>
/// <param name="item"></param>
/// <param name="list"></param>
private void AddToList(Dictionary.DictionaryItem item, ref List <Dictionary.DictionaryItem> list)
{
list.Add(item);
if (!item.hasChildren)
{
return;
}
foreach (Dictionary.DictionaryItem child in item.Children)
{
AddToList(child, ref list);
}
}
public void Dictionary_Contructor_Key()
{
var d = CreateNew();
var same = new Dictionary.DictionaryItem(d.key);
Assert.AreEqual(d.id, same.id);
Assert.AreEqual(d.key, same.key);
Assert.AreEqual(d.UniqueId, same.UniqueId);
DeleteItem(d);
}
private Dictionary.DictionaryItem CreateNew()
{
var id = Dictionary.DictionaryItem.addKey("Test" + Guid.NewGuid().ToString("N"), "");
Assert.IsTrue(id > 0);
var d = new Dictionary.DictionaryItem(id);
Assert.IsInstanceOfType(d, typeof(Dictionary.DictionaryItem));
return(d);
}
private static void AddToList(Dictionary.DictionaryItem parent, ref IList <Dictionary.DictionaryItem> list)
{
list.Add(parent);
if (!parent.hasChildren)
{
return;
}
foreach (var child in parent.Children)
{
AddToList(child, ref list);
}
}
public void Dictionary_Delete_Parent_With_Children()
{
var parent = CreateNew();
//create a child
var childId1 = Dictionary.DictionaryItem.addKey("Test" + Guid.NewGuid().ToString("N"), "", parent.key);
Assert.IsTrue(childId1 > 0);
var child1 = new Dictionary.DictionaryItem(childId1);
Assert.IsTrue(TypeHelper.IsTypeAssignableFrom <Dictionary.DictionaryItem>(child1));
//create a child
var childId2 = Dictionary.DictionaryItem.addKey("Test" + Guid.NewGuid().ToString("N"), "", parent.key);
Assert.IsTrue(childId2 > 0);
var child2 = new Dictionary.DictionaryItem(childId2);
Assert.IsTrue(TypeHelper.IsTypeAssignableFrom <Dictionary.DictionaryItem>(child2));
Assert.IsTrue(parent.hasChildren);
Assert.AreEqual(2, parent.Children.Length);
DeleteItem(parent);
//make sure kids are gone
var notFound = false;
try
{
var check = new Dictionary.DictionaryItem(childId1);
}
catch (ArgumentException)
{
notFound = true;
}
Assert.IsTrue(notFound);
notFound = false;
try
{
var check = new Dictionary.DictionaryItem(childId2);
}
catch (ArgumentException)
{
notFound = true;
}
Assert.IsTrue(notFound);
}
public static void SaveToDisk(Dictionary.DictionaryItem item)
{
if (item != null)
{
Umbraco.Core.Strings.DefaultShortStringHelper _sh = new Umbraco.Core.Strings.DefaultShortStringHelper();
XmlDocument xmlDoc = helpers.XmlDoc.CreateDoc();
xmlDoc.AppendChild(item.ToXml(xmlDoc));
xmlDoc.AddMD5Hash();
helpers.XmlDoc.SaveXmlDoc("Dictionary",
_sh.CleanString(item.key, Umbraco.Core.Strings.CleanStringType.Ascii),
xmlDoc);
}
}
static void DictionaryItem_Deleting(Dictionary.DictionaryItem sender, EventArgs e)
{
if (!uSync.EventsPaused)
{
lock (_deleteLock)
{
if (sender.hasChildren)
{
// we get the delets in a backwards order, so we add all the children of this
// node to the list we are not going to delete when we get asked to.
//
foreach (Dictionary.DictionaryItem child in sender.Children)
{
_dChildren.Add(child.id);
}
}
if (_dChildren.Contains(sender.id))
{
// this is a child of a parent we have already deleted.
_dChildren.Remove(sender.id);
LogHelper.Debug <SyncDictionary>("No Deleteing Dictionary item {0} because we deleted it's parent",
() => sender.key);
}
else
{
//actually delete
LogHelper.Debug <SyncDictionary>("Deleting Dictionary Item {0}", () => sender.key);
// when you delete a tree, the top gets called before the children.
//
if (!sender.IsTopMostItem())
{
// if it's not top most, we save it's parent (that will delete)
SaveToDisk(GetTop(sender));
}
else
{
// it's top we need to delete
helpers.XmlDoc.ArchiveFile("Dictionary", sender.key);
}
}
}
}
}
private string dictinaryItem(string alias)
{
if (alias.Substring(1, 0) == "#")
{
if (Dictionary.DictionaryItem.hasKey(alias.Substring(1)))
{
Dictionary.DictionaryItem di = new Dictionary.DictionaryItem(alias.Substring(1));
if (di != null && !string.IsNullOrEmpty(di.Value()))
{
return(di.Value());
}
}
}
return(alias + " " + alias.Substring(1));
}
public void Dictionary_IsTopMostItem()
{
var parent = CreateNew();
//create a child
var childId = Dictionary.DictionaryItem.addKey("Test" + Guid.NewGuid().ToString("N"), "", parent.key);
Assert.IsTrue(childId > 0);
var child = new Dictionary.DictionaryItem(childId);
Assert.IsInstanceOfType(child, typeof(Dictionary.DictionaryItem));
Assert.IsTrue(parent.IsTopMostItem());
Assert.IsFalse(child.IsTopMostItem());
DeleteItem(child);
DeleteItem(parent);
}
public void Dictionary_IsTopMostItem()
{
var parent = CreateNew();
//create a child
var childId = Dictionary.DictionaryItem.addKey("Test" + Guid.NewGuid().ToString("N"), "", parent.key);
Assert.IsTrue(childId > 0);
var child = new Dictionary.DictionaryItem(childId);
Assert.IsTrue(TypeHelper.IsTypeAssignableFrom <Dictionary.DictionaryItem>(child));
Assert.IsTrue(parent.IsTopMostItem());
Assert.IsFalse(child.IsTopMostItem());
DeleteItem(child);
DeleteItem(parent);
}
private void SetupDictionaryChildren(Dictionary.DictionaryItem item, int level)
{
Dictionary.DictionaryItem[] children = item.Children;
IOrderedEnumerable <Dictionary.DictionaryItem> orderedEnumerable = children.OrderBy(c => c.key);
if (children.Count() > 0)
{
foreach (Dictionary.DictionaryItem child in orderedEnumerable)
{
string name = child.key;
for (int i = 0; i < level; i++)
{
name = "-" + name;
}
items.Add(new ListItem(name, child.key));
SetupDictionaryChildren(child, level + 1);
}
}
}
static string DictionaryReplace(string text)
{
if (!text.StartsWith("#"))
{
return(text);
}
else
{
Language lang = Language.GetByCultureCode(System.Threading.Thread.CurrentThread.CurrentCulture.Name);
if (lang != null)
{
if (Dictionary.DictionaryItem.hasKey(text.Substring(1, text.Length - 1)))
{
Dictionary.DictionaryItem di = new Dictionary.DictionaryItem(text.Substring(1, text.Length - 1));
return(di.Value(lang.id));
}
}
return("[" + text + "]");
}
}
private void DeleteItem(Dictionary.DictionaryItem d)
{
var id = d.id;
d.delete();
var notFound = false;
try
{
var check = new Dictionary.DictionaryItem(id);
}
catch (ArgumentException)
{
notFound = true;
}
Assert.IsTrue(notFound, "The item with key " + d.key + " still exists!");
//check with sql that the language text is gone
var count = Application.SqlHelper.ExecuteScalar <int>("SELECT COUNT(*) FROM cmsLanguageText WHERE uniqueId=@uniqueId",
Application.SqlHelper.CreateParameter("@uniqueId", d.UniqueId));
Assert.AreEqual(0, count);
}
public void Dictionary_ToXml()
{
var d = CreateNew();
//create a child
var childId = Dictionary.DictionaryItem.addKey("Test" + Guid.NewGuid().ToString("N"), "", d.key);
Assert.IsTrue(childId > 0);
var child = new Dictionary.DictionaryItem(childId);
Assert.IsTrue(TypeHelper.IsTypeAssignableFrom <Dictionary.DictionaryItem>(child));
var xml = new XmlDocument();
var output = d.ToXml(xml);
Assert.AreEqual("DictionaryItem", output.Name);
Assert.IsTrue(output.HasChildNodes);
Assert.IsNotNull(output.Attributes["Key"].Value);
Assert.AreEqual(1, output.ChildNodes.OfType <XmlElement>().Where(x => x.Name == "DictionaryItem").Count());
DeleteItem(child);
DeleteItem(d);
}
static void DictionaryItem_Saving(Dictionary.DictionaryItem sender, EventArgs e)
{
LogHelper.Info <SyncDictionaryItems>("Dicitionary Item Saved");
SaveToDisk(GetTop(sender));
}
public void Publish() {
CreatedPackage package = this;
PackageInstance pack = package.Data;
try
{
PublishEventArgs e = new PublishEventArgs();
package.FireBeforePublish(e);
if (!e.Cancel)
{
int outInt = 0;
//Path checking...
string localPath = IOHelper.MapPath(SystemDirectories.Media + "/" + pack.Folder);
if (!System.IO.Directory.Exists(localPath))
System.IO.Directory.CreateDirectory(localPath);
//Init package file...
createPackageManifest();
//Info section..
appendElement(utill.PackageInfo(pack, _packageManifest));
//Documents...
int _contentNodeID = 0;
if (!String.IsNullOrEmpty(pack.ContentNodeId) && int.TryParse(pack.ContentNodeId, out _contentNodeID))
{
XmlNode documents = _packageManifest.CreateElement("Documents");
XmlNode documentSet = _packageManifest.CreateElement("DocumentSet");
XmlAttribute importMode = _packageManifest.CreateAttribute("importMode", "");
importMode.Value = "root";
documentSet.Attributes.Append(importMode);
documents.AppendChild(documentSet);
//load content from umbraco.
cms.businesslogic.web.Document umbDocument = new Document(_contentNodeID);
documentSet.AppendChild(umbDocument.ToXml(_packageManifest, pack.ContentLoadChildNodes));
appendElement(documents);
}
//Document types..
List<DocumentType> dtl = new List<DocumentType>();
XmlNode docTypes = _packageManifest.CreateElement("DocumentTypes");
foreach (string dtId in pack.Documenttypes)
{
if (int.TryParse(dtId, out outInt))
{
DocumentType docT = new DocumentType(outInt);
AddDocumentType(docT, ref dtl);
}
}
foreach (DocumentType d in dtl)
{
docTypes.AppendChild(d.ToXml(_packageManifest));
}
appendElement(docTypes);
//Templates
XmlNode templates = _packageManifest.CreateElement("Templates");
foreach (string templateId in pack.Templates)
{
if (int.TryParse(templateId, out outInt))
{
Template t = new Template(outInt);
templates.AppendChild(t.ToXml(_packageManifest));
}
}
appendElement(templates);
//Stylesheets
XmlNode stylesheets = _packageManifest.CreateElement("Stylesheets");
foreach (string ssId in pack.Stylesheets)
{
if (int.TryParse(ssId, out outInt))
{
StyleSheet s = new StyleSheet(outInt);
stylesheets.AppendChild(s.ToXml(_packageManifest));
}
}
appendElement(stylesheets);
//Macros
XmlNode macros = _packageManifest.CreateElement("Macros");
foreach (string macroId in pack.Macros)
{
if (int.TryParse(macroId, out outInt))
{
macros.AppendChild(utill.Macro(int.Parse(macroId), true, localPath, _packageManifest));
}
}
appendElement(macros);
//Dictionary Items
XmlNode dictionaryItems = _packageManifest.CreateElement("DictionaryItems");
foreach (string dictionaryId in pack.DictionaryItems)
{
if (int.TryParse(dictionaryId, out outInt))
{
Dictionary.DictionaryItem di = new Dictionary.DictionaryItem(outInt);
dictionaryItems.AppendChild(di.ToXml(_packageManifest));
}
}
appendElement(dictionaryItems);
//Languages
XmlNode languages = _packageManifest.CreateElement("Languages");
foreach (string langId in pack.Languages)
{
if (int.TryParse(langId, out outInt))
{
language.Language lang = new umbraco.cms.businesslogic.language.Language(outInt);
languages.AppendChild(lang.ToXml(_packageManifest));
}
}
appendElement(languages);
//Datatypes
XmlNode dataTypes = _packageManifest.CreateElement("DataTypes");
foreach (string dtId in pack.DataTypes)
{
if (int.TryParse(dtId, out outInt))
{
cms.businesslogic.datatype.DataTypeDefinition dtd = new umbraco.cms.businesslogic.datatype.DataTypeDefinition(outInt);
dataTypes.AppendChild(dtd.ToXml(_packageManifest));
}
}
appendElement(dataTypes);
//Files
foreach (string fileName in pack.Files)
{
utill.AppendFileToManifest(fileName, localPath, _packageManifest);
}
//Load control on install...
if (!string.IsNullOrEmpty(pack.LoadControl))
{
XmlNode control = _packageManifest.CreateElement("control");
control.InnerText = pack.LoadControl;
utill.AppendFileToManifest(pack.LoadControl, localPath, _packageManifest);
appendElement(control);
}
//Actions
if (!string.IsNullOrEmpty(pack.Actions))
{
try
{
XmlDocument xd_actions = new XmlDocument();
xd_actions.LoadXml("<Actions>" + pack.Actions + "</Actions>");
XmlNode actions = xd_actions.DocumentElement.SelectSingleNode(".");
if (actions != null)
{
actions = _packageManifest.ImportNode(actions, true).Clone();
appendElement(actions);
}
}
catch { }
}
string manifestFileName = localPath + "/package.xml";
if (System.IO.File.Exists(manifestFileName))
System.IO.File.Delete(manifestFileName);
_packageManifest.Save(manifestFileName);
_packageManifest = null;
//string packPath = Settings.PackagerRoot.Replace(System.IO.Path.DirectorySeparatorChar.ToString(), "/") + "/" + pack.Name.Replace(' ', '_') + "_" + pack.Version.Replace(' ', '_') + "." + Settings.PackageFileExtension;
// check if there's a packages directory below media
string packagesDirectory = SystemDirectories.Media + "/created-packages";
if (!System.IO.Directory.Exists(IOHelper.MapPath(packagesDirectory)))
System.IO.Directory.CreateDirectory(IOHelper.MapPath(packagesDirectory));
string packPath = packagesDirectory + "/" + (pack.Name + "_" + pack.Version).Replace(' ', '_') + "." + Settings.PackageFileExtension;
utill.ZipPackage(localPath, IOHelper.MapPath(packPath));
pack.PackagePath = packPath;
if (pack.PackageGuid.Trim() == "")
pack.PackageGuid = Guid.NewGuid().ToString();
package.Save();
//Clean up..
System.IO.File.Delete(localPath + "/package.xml");
System.IO.Directory.Delete(localPath, true);
package.FireAfterPublish(e);
}
}
catch (Exception ex)
{
LogHelper.Error<CreatedPackage>("An error occurred", ex);
}
}
public void Publish()
{
CreatedPackage package = this;
PackageInstance pack = package.Data;
try
{
PublishEventArgs e = new PublishEventArgs();
package.FireBeforePublish(e);
if (!e.Cancel)
{
int outInt = 0;
//Path checking...
string localPath = IOHelper.MapPath(SystemDirectories.Media + "/" + pack.Folder);
if (!System.IO.Directory.Exists(localPath))
{
System.IO.Directory.CreateDirectory(localPath);
}
//Init package file...
createPackageManifest();
//Info section..
appendElement(utill.PackageInfo(pack, _packageManifest));
//Documents...
int _contentNodeID = 0;
if (!String.IsNullOrEmpty(pack.ContentNodeId) && int.TryParse(pack.ContentNodeId, out _contentNodeID))
{
XmlNode documents = _packageManifest.CreateElement("Documents");
XmlNode documentSet = _packageManifest.CreateElement("DocumentSet");
XmlAttribute importMode = _packageManifest.CreateAttribute("importMode", "");
importMode.Value = "root";
documentSet.Attributes.Append(importMode);
documents.AppendChild(documentSet);
//load content from umbraco.
cms.businesslogic.web.Document umbDocument = new Document(_contentNodeID);
documentSet.AppendChild(umbDocument.ToXml(_packageManifest, pack.ContentLoadChildNodes));
appendElement(documents);
}
//Document types..
List <DocumentType> dtl = new List <DocumentType>();
XmlNode docTypes = _packageManifest.CreateElement("DocumentTypes");
foreach (string dtId in pack.Documenttypes)
{
if (int.TryParse(dtId, out outInt))
{
DocumentType docT = new DocumentType(outInt);
AddDocumentType(docT, ref dtl);
}
}
foreach (DocumentType d in dtl)
{
docTypes.AppendChild(d.ToXml(_packageManifest));
}
appendElement(docTypes);
//Templates
XmlNode templates = _packageManifest.CreateElement("Templates");
foreach (string templateId in pack.Templates)
{
if (int.TryParse(templateId, out outInt))
{
Template t = new Template(outInt);
templates.AppendChild(t.ToXml(_packageManifest));
}
}
appendElement(templates);
//Stylesheets
XmlNode stylesheets = _packageManifest.CreateElement("Stylesheets");
foreach (string ssId in pack.Stylesheets)
{
if (int.TryParse(ssId, out outInt))
{
StyleSheet s = new StyleSheet(outInt);
stylesheets.AppendChild(s.ToXml(_packageManifest));
}
}
appendElement(stylesheets);
//Macros
XmlNode macros = _packageManifest.CreateElement("Macros");
foreach (string macroId in pack.Macros)
{
if (int.TryParse(macroId, out outInt))
{
macros.AppendChild(utill.Macro(int.Parse(macroId), true, localPath, _packageManifest));
}
}
appendElement(macros);
//Dictionary Items
XmlNode dictionaryItems = _packageManifest.CreateElement("DictionaryItems");
foreach (string dictionaryId in pack.DictionaryItems)
{
if (int.TryParse(dictionaryId, out outInt))
{
Dictionary.DictionaryItem di = new Dictionary.DictionaryItem(outInt);
dictionaryItems.AppendChild(di.ToXml(_packageManifest));
}
}
appendElement(dictionaryItems);
//Languages
XmlNode languages = _packageManifest.CreateElement("Languages");
foreach (string langId in pack.Languages)
{
if (int.TryParse(langId, out outInt))
{
language.Language lang = new umbraco.cms.businesslogic.language.Language(outInt);
languages.AppendChild(lang.ToXml(_packageManifest));
}
}
appendElement(languages);
//Datatypes
XmlNode dataTypes = _packageManifest.CreateElement("DataTypes");
foreach (string dtId in pack.DataTypes)
{
if (int.TryParse(dtId, out outInt))
{
cms.businesslogic.datatype.DataTypeDefinition dtd = new umbraco.cms.businesslogic.datatype.DataTypeDefinition(outInt);
dataTypes.AppendChild(dtd.ToXml(_packageManifest));
}
}
appendElement(dataTypes);
//Files
foreach (string fileName in pack.Files)
{
utill.AppendFileToManifest(fileName, localPath, _packageManifest);
}
//Load control on install...
if (!string.IsNullOrEmpty(pack.LoadControl))
{
XmlNode control = _packageManifest.CreateElement("control");
control.InnerText = pack.LoadControl;
utill.AppendFileToManifest(pack.LoadControl, localPath, _packageManifest);
appendElement(control);
}
//Actions
if (!string.IsNullOrEmpty(pack.Actions))
{
try
{
XmlDocument xd_actions = new XmlDocument();
xd_actions.LoadXml("<Actions>" + pack.Actions + "</Actions>");
XmlNode actions = xd_actions.DocumentElement.SelectSingleNode(".");
if (actions != null)
{
actions = _packageManifest.ImportNode(actions, true).Clone();
appendElement(actions);
}
}
catch { }
}
string manifestFileName = localPath + "/package.xml";
if (System.IO.File.Exists(manifestFileName))
{
System.IO.File.Delete(manifestFileName);
}
_packageManifest.Save(manifestFileName);
_packageManifest = null;
//string packPath = Settings.PackagerRoot.Replace(System.IO.Path.DirectorySeparatorChar.ToString(), "/") + "/" + pack.Name.Replace(' ', '_') + "_" + pack.Version.Replace(' ', '_') + "." + Settings.PackageFileExtension;
// check if there's a packages directory below media
string packagesDirectory = SystemDirectories.Media + "/created-packages";
if (!System.IO.Directory.Exists(IOHelper.MapPath(packagesDirectory)))
{
System.IO.Directory.CreateDirectory(IOHelper.MapPath(packagesDirectory));
}
string packPath = packagesDirectory + "/" + (pack.Name + "_" + pack.Version).Replace(' ', '_') + "." + Settings.PackageFileExtension;
utill.ZipPackage(localPath, IOHelper.MapPath(packPath));
pack.PackagePath = packPath;
if (pack.PackageGuid.Trim() == "")
{
pack.PackageGuid = Guid.NewGuid().ToString();
}
package.Save();
//Clean up..
System.IO.File.Delete(localPath + "/package.xml");
System.IO.Directory.Delete(localPath, true);
package.FireAfterPublish(e);
}
}
catch (Exception ex)
{
LogHelper.Error <CreatedPackage>("An error occurred", ex);
}
}
public void Publish()
{
var package = this;
var pack = package.Data;
var e = new PublishEventArgs();
package.FireBeforePublish(e);
if (e.Cancel == false)
{
var outInt = 0;
//Path checking...
var localPath = IOHelper.MapPath(SystemDirectories.Media + "/" + pack.Folder);
if (Directory.Exists(localPath) == false)
{
Directory.CreateDirectory(localPath);
}
//Init package file...
CreatePackageManifest();
//Info section..
AppendElement(utill.PackageInfo(pack, _packageManifest));
//Documents and tags...
var contentNodeId = 0;
if (string.IsNullOrEmpty(pack.ContentNodeId) == false && int.TryParse(pack.ContentNodeId, out contentNodeId))
{
if (contentNodeId > 0)
{
//Create the Documents/DocumentSet node
XmlNode documents = _packageManifest.CreateElement("Documents");
XmlNode documentSet = _packageManifest.CreateElement("DocumentSet");
XmlAttribute importMode = _packageManifest.CreateAttribute("importMode", "");
importMode.Value = "root";
documentSet.Attributes.Append(importMode);
documents.AppendChild(documentSet);
//load content from umbraco.
var umbDocument = new Document(contentNodeId);
documentSet.AppendChild(umbDocument.ToXml(_packageManifest, pack.ContentLoadChildNodes));
AppendElement(documents);
////Create the TagProperties node - this is used to store a definition for all
//// document properties that are tags, this ensures that we can re-import tags properly
//XmlNode tagProps = _packageManifest.CreateElement("TagProperties");
////before we try to populate this, we'll do a quick lookup to see if any of the documents
//// being exported contain published tags.
//var allExportedIds = documents.SelectNodes("//@id").Cast<XmlNode>()
// .Select(x => x.Value.TryConvertTo<int>())
// .Where(x => x.Success)
// .Select(x => x.Result)
// .ToArray();
//var allContentTags = new List<ITag>();
//foreach (var exportedId in allExportedIds)
//{
// allContentTags.AddRange(
// ApplicationContext.Current.Services.TagService.GetTagsForEntity(exportedId));
//}
////This is pretty round-about but it works. Essentially we need to get the properties that are tagged
//// but to do that we need to lookup by a tag (string)
//var allTaggedEntities = new List<TaggedEntity>();
//foreach (var group in allContentTags.Select(x => x.Group).Distinct())
//{
// allTaggedEntities.AddRange(
// ApplicationContext.Current.Services.TagService.GetTaggedContentByTagGroup(group));
//}
////Now, we have all property Ids/Aliases and their referenced document Ids and tags
//var allExportedTaggedEntities = allTaggedEntities.Where(x => allExportedIds.Contains(x.EntityId))
// .DistinctBy(x => x.EntityId)
// .OrderBy(x => x.EntityId);
//foreach (var taggedEntity in allExportedTaggedEntities)
//{
// foreach (var taggedProperty in taggedEntity.TaggedProperties.Where(x => x.Tags.Any()))
// {
// XmlNode tagProp = _packageManifest.CreateElement("TagProperty");
// var docId = _packageManifest.CreateAttribute("docId", "");
// docId.Value = taggedEntity.EntityId.ToString(CultureInfo.InvariantCulture);
// tagProp.Attributes.Append(docId);
// var propertyAlias = _packageManifest.CreateAttribute("propertyAlias", "");
// propertyAlias.Value = taggedProperty.PropertyTypeAlias;
// tagProp.Attributes.Append(propertyAlias);
// var group = _packageManifest.CreateAttribute("group", "");
// group.Value = taggedProperty.Tags.First().Group;
// tagProp.Attributes.Append(group);
// tagProp.AppendChild(_packageManifest.CreateCDataSection(
// JsonConvert.SerializeObject(taggedProperty.Tags.Select(x => x.Text).ToArray())));
// tagProps.AppendChild(tagProp);
// }
//}
//AppendElement(tagProps);
}
}
//Document types..
var dtl = new List <DocumentType>();
var docTypes = _packageManifest.CreateElement("DocumentTypes");
foreach (var dtId in pack.Documenttypes)
{
if (int.TryParse(dtId, out outInt))
{
DocumentType docT = new DocumentType(outInt);
AddDocumentType(docT, ref dtl);
}
}
foreach (DocumentType d in dtl)
{
docTypes.AppendChild(d.ToXml(_packageManifest));
}
AppendElement(docTypes);
//Templates
var templates = _packageManifest.CreateElement("Templates");
foreach (var templateId in pack.Templates)
{
if (int.TryParse(templateId, out outInt))
{
var t = new Template(outInt);
templates.AppendChild(t.ToXml(_packageManifest));
}
}
AppendElement(templates);
//Stylesheets
var stylesheets = _packageManifest.CreateElement("Stylesheets");
foreach (var stylesheetName in pack.Stylesheets)
{
if (stylesheetName.IsNullOrWhiteSpace())
{
continue;
}
var stylesheetXmlNode = utill.Stylesheet(stylesheetName, true, _packageManifest);
if (stylesheetXmlNode != null)
{
stylesheets.AppendChild(stylesheetXmlNode);
}
}
AppendElement(stylesheets);
//Macros
var macros = _packageManifest.CreateElement("Macros");
foreach (var macroId in pack.Macros)
{
if (int.TryParse(macroId, out outInt))
{
macros.AppendChild(utill.Macro(int.Parse(macroId), true, localPath, _packageManifest));
}
}
AppendElement(macros);
//Dictionary Items
var dictionaryItems = _packageManifest.CreateElement("DictionaryItems");
foreach (var dictionaryId in pack.DictionaryItems)
{
if (int.TryParse(dictionaryId, out outInt))
{
var di = new Dictionary.DictionaryItem(outInt);
dictionaryItems.AppendChild(di.ToXml(_packageManifest));
}
}
AppendElement(dictionaryItems);
//Languages
var languages = _packageManifest.CreateElement("Languages");
foreach (var langId in pack.Languages)
{
if (int.TryParse(langId, out outInt))
{
var lang = new language.Language(outInt);
languages.AppendChild(lang.ToXml(_packageManifest));
}
}
AppendElement(languages);
//Datatypes
var dataTypes = _packageManifest.CreateElement("DataTypes");
foreach (var dtId in pack.DataTypes)
{
if (int.TryParse(dtId, out outInt))
{
datatype.DataTypeDefinition dtd = new datatype.DataTypeDefinition(outInt);
dataTypes.AppendChild(dtd.ToXml(_packageManifest));
}
}
AppendElement(dataTypes);
//Files
foreach (var fileName in pack.Files)
{
utill.AppendFileToManifest(fileName, localPath, _packageManifest);
}
//Load control on install...
if (string.IsNullOrEmpty(pack.LoadControl) == false)
{
XmlNode control = _packageManifest.CreateElement("control");
control.InnerText = pack.LoadControl;
utill.AppendFileToManifest(pack.LoadControl, localPath, _packageManifest);
AppendElement(control);
}
//Actions
if (string.IsNullOrEmpty(pack.Actions) == false)
{
try
{
var xdActions = new XmlDocument();
xdActions.LoadXml("<Actions>" + pack.Actions + "</Actions>");
var actions = xdActions.DocumentElement.SelectSingleNode(".");
if (actions != null)
{
actions = _packageManifest.ImportNode(actions, true).Clone();
AppendElement(actions);
}
}
catch { }
}
var manifestFileName = localPath + "/package.xml";
if (File.Exists(manifestFileName))
{
File.Delete(manifestFileName);
}
_packageManifest.Save(manifestFileName);
_packageManifest = null;
//string packPath = Settings.PackagerRoot.Replace(System.IO.Path.DirectorySeparatorChar.ToString(), "/") + "/" + pack.Name.Replace(' ', '_') + "_" + pack.Version.Replace(' ', '_') + "." + Settings.PackageFileExtension;
// check if there's a packages directory below media
var packagesDirectory = SystemDirectories.Media + "/created-packages";
if (Directory.Exists(IOHelper.MapPath(packagesDirectory)) == false)
{
Directory.CreateDirectory(IOHelper.MapPath(packagesDirectory));
}
var packPath = packagesDirectory + "/" + (pack.Name + "_" + pack.Version).Replace(' ', '_') + "." + Settings.PackageFileExtension;
utill.ZipPackage(localPath, IOHelper.MapPath(packPath));
pack.PackagePath = packPath;
if (pack.PackageGuid.Trim() == "")
{
pack.PackageGuid = Guid.NewGuid().ToString();
}
package.Save();
//Clean up..
File.Delete(localPath + "/package.xml");
Directory.Delete(localPath, true);
package.FireAfterPublish(e);
}
}
