public static void SaveToDisk(StyleSheet item)
 {
     if (item != null)
     {
         try
         {
             XmlDocument xmlDoc = helpers.XmlDoc.CreateDoc();
             xmlDoc.AppendChild(item.ToXml(xmlDoc));
             helpers.XmlDoc.SaveXmlDoc(item.GetType().ToString(), item.Text, xmlDoc);
         }
         catch (Exception ex)
         {
             Log.Add(LogTypes.Error, 0, String.Format("uSync: Error Reading Stylesheet {0} - {1}", item.Text, ex.ToString()));
             throw new SystemException(string.Format("error saving stylesheet {0}", item.Text), ex); 
         }
     }
 }
Example #2
0
        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);
			}
        }