private void SynchronizeMacroProperties(Type typeUserControl, Macro macro) { // first delete all macro properties macro.Properties.ToList().ForEach(mp => mp.Delete()); List<MacroPropertyType> allPropertyTypes = MacroPropertyType.GetAll; // foreach property marked with MacroParameter create an macro parameter foreach (PropertyInfo propInfo in typeUserControl.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)) { MacroParameterAttribute macroParamAttr = Util.GetAttribute<MacroParameterAttribute>(propInfo); if (macroParamAttr == null) { // if property is not given attribute MacroParameterAttribute try to create default one based on property type macroParamAttr = this.GetDefaultMacroParameterAttribute(propInfo); if (macroParamAttr == null) { // if default attribute cannot be created (e.g. if property type is DateTime) // skip creating this macro parameter continue; } } string macroParamName = string.IsNullOrEmpty(macroParamAttr.Name) ? propInfo.Name : macroParamAttr.Name; string macroParamAlias = propInfo.Name; MacroProperty.MakeNew(macro, macroParamAttr.Show, macroParamAlias, macroParamName, allPropertyTypes.First(mpt => mpt.Alias.ToLower() == macroParamAttr.Type.ToString().ToLower())); } }
private void CommunityHome() { var migrationName = MethodBase.GetCurrentMethod().Name; try { var path = HostingEnvironment.MapPath(MigrationMarkersPath + migrationName + ".txt"); if (File.Exists(path)) return; var macroService = UmbracoContext.Current.Application.Services.MacroService; var macroAlias = "CommunityHome"; if (macroService.GetByAlias(macroAlias) == null) { // Run migration var macro = new Macro { Name = "[Community] Home", Alias = macroAlias, ScriptingFile = "~/Views/MacroPartials/Community/Home.cshtml", UseInEditor = true }; macro.Save(); } string[] lines = { "" }; File.WriteAllLines(path, lines); } catch (Exception ex) { LogHelper.Error<MigrationsHandler>(string.Format("Migration: '{0}' failed", migrationName), ex); } }
public void Macro_Make_New_Add_Property() { var m = Macro.MakeNew(Guid.NewGuid().ToString("N")); Assert.IsTrue(m.Id > 0); Assert.IsInstanceOfType(m, typeof(Macro)); //now, add a property... //get the first macro property type we can find var mpt = MacroPropertyType.GetAll.First(); var mp = MacroProperty.MakeNew(m, false, Guid.NewGuid().ToString("N"), Guid.NewGuid().ToString("N"), mpt); Assert.IsTrue(mp.Id > 0); Assert.IsInstanceOfType(mp, typeof(MacroProperty)); m.Delete(); //make sure the property is gone var props = MacroProperty.GetProperties(m.Id); Assert.IsFalse(props.Select(x => x.Id).Contains(mp.Id)); var isfound = false; try { var asdf = new Macro(m.Id); isfound = true; } catch (ArgumentException) { isfound = false; } Assert.IsFalse(isfound); }
/// <summary> /// This changes the macro type to a PartialViewMacro if the SelectedPartialView txt box has a value. /// This then also updates the file path saved for the partial view to be the full virtual path, not just the file name. /// </summary> /// <param name="macro"> </param> /// <param name="macroCachePeriod"></param> /// <param name="macroAssemblyValue"></param> /// <param name="macroTypeValue"></param> protected override void SetMacroValuesFromPostBack(Macro macro, int macroCachePeriod, string macroAssemblyValue, string macroTypeValue) { base.SetMacroValuesFromPostBack(macro, macroCachePeriod, macroAssemblyValue, macroTypeValue); if (!SelectedPartialView.Text.IsNullOrWhiteSpace()) { macro.ScriptingFile = SelectedPartialView.Text; } }
protected void Button1_Click(object sender, System.EventArgs e) { string result = ""; // Get the macro object umbraco.cms.businesslogic.macro.Macro macroObject = new umbraco.cms.businesslogic.macro.Macro(Convert.ToInt32(Request.QueryString["macroID"])); // Load all macroPropertyTypes Hashtable macroPropertyTypes = new Hashtable(); Hashtable macroPropertyIds = new Hashtable(); // SqlDataReader dr = SqlHelper.ExecuteReader(_ConnString, CommandType.Text, "select id, macroPropertyTypeBaseType, macroPropertyTypeAlias from cmsMacroPropertyType"); List <MacroPropertyType> macroPropTypes = MacroPropertyType.GetAll; foreach (MacroPropertyType mpt in macroPropTypes) { macroPropertyIds.Add(mpt.Alias, mpt.Id.ToString()); macroPropertyTypes.Add(mpt.Alias, mpt.BaseType); } // dr.Close(); foreach (ListItem li in MacroProperties.Items) { if (li.Selected && !macrohasProperty(macroObject, li.Text.Substring(0, li.Text.IndexOf(" ")).ToLower())) { result += "<li>Added: " + spaceCamelCasing(li.Text) + "</li>"; string _macroPropertyTypeAlias = findMacroType(macroPropertyTypes, li.Value); if (_macroPropertyTypeAlias == "") { _macroPropertyTypeAlias = "text"; } object propertyId = macroPropertyIds[_macroPropertyTypeAlias]; if (propertyId != null) { int macroPropertyTypeId = 0; if (int.TryParse(string.Format("{0}", propertyId), out macroPropertyTypeId)) { MacroProperty.MakeNew(macroObject, true, li.Text.Substring(0, li.Text.IndexOf(" ")), spaceCamelCasing(li.Text), macroPropTypes.Find(delegate(MacroPropertyType mpt) { return(mpt.Id == macroPropertyTypeId); })); } } } else if (li.Selected) { result += "<li>Skipped: " + spaceCamelCasing(li.Text) + " (already exists as a parameter)</li>"; } } ChooseProperties.Visible = false; ConfigProperties.Visible = true; resultLiteral.Text = result; }
public bool Save() { string template = _alias.Substring(0, _alias.IndexOf("|||")).Trim(); string fileName = _alias.Substring(_alias.IndexOf("|||") + 3, _alias.Length - _alias.IndexOf("|||") - 3).Replace(" ", ""); if (!fileName.Contains(".")) { fileName = _alias + ".py"; } string scriptContent = ""; if (!string.IsNullOrEmpty(template)) { System.IO.StreamReader templateFile = System.IO.File.OpenText(IOHelper.MapPath(SystemDirectories.Umbraco + "/scripting/templates/" + template)); scriptContent = templateFile.ReadToEnd(); templateFile.Close(); } string abFileName = IOHelper.MapPath(SystemDirectories.MacroScripts + "/" + fileName); if (!System.IO.File.Exists(abFileName)) { if (fileName.Contains("/")) //if there's a / create the folder structure for it { string[] folders = fileName.Split("/".ToCharArray()); string basePath = IOHelper.MapPath(SystemDirectories.MacroScripts); for (int i = 0; i < folders.Length - 1; i++) { basePath = System.IO.Path.Combine(basePath, folders[i]); System.IO.Directory.CreateDirectory(basePath); } } System.IO.StreamWriter scriptWriter = System.IO.File.CreateText(abFileName); scriptWriter.Write(scriptContent); scriptWriter.Flush(); scriptWriter.Close(); if (ParentID == 1) { var name = fileName .Substring(0, (fileName.LastIndexOf('.') + 1)).Trim('.') .SplitPascalCasing().ToFirstUpperInvariant(); cms.businesslogic.macro.Macro m = cms.businesslogic.macro.Macro.MakeNew(name); m.ScriptingFile = fileName; } } m_returnUrl = string.Format(SystemDirectories.Umbraco + "/developer/python/editPython.aspx?file={0}", fileName); return(true); }
/// <summary> /// This ensures that the SelectedPartialView txt box value is set correctly when the m_macro object's /// ScriptingFile property contains a full virtual path beginning with the MacroPartials path /// </summary> /// <param name="macro"> </param> /// <param name="macroAssemblyValue"></param> /// <param name="macroTypeValue"></param> protected override void PopulateFieldsOnLoad(Macro macro, string macroAssemblyValue, string macroTypeValue) { base.PopulateFieldsOnLoad(macro, macroAssemblyValue, macroTypeValue); //check if the ScriptingFile property contains the MacroPartials path if (macro.ScriptingFile.IsNullOrWhiteSpace() == false && (macro.ScriptingFile.StartsWith(SystemDirectories.MvcViews + "/MacroPartials/") || (Regex.IsMatch(macro.ScriptingFile, "~/App_Plugins/.+?/Views/MacroPartials", RegexOptions.Compiled)))) { macroPython.Text = ""; SelectedPartialView.Text = macro.ScriptingFile; } }
private bool macrohasProperty(umbraco.cms.businesslogic.macro.Macro macroObject, string propertyAlias) { foreach (cms.businesslogic.macro.MacroProperty mp in macroObject.Properties) { if (mp.Alias.ToLower() == propertyAlias) { return(true); } } return(false); }
public bool Save() { string template = _alias.Substring(0, _alias.IndexOf("|||")); string fileName = _alias.Substring(_alias.IndexOf("|||") + 3, _alias.Length - _alias.IndexOf("|||") - 3).Replace(" ", ""); string xsltTemplateSource = IOHelper.MapPath(SystemDirectories.Umbraco + "/xslt/templates/" + template); string xsltNewFilename = IOHelper.MapPath(SystemDirectories.Xslt + "/" + fileName + ".xslt"); if (!System.IO.File.Exists(xsltNewFilename)) { if (fileName.Contains("/")) //if there's a / create the folder structure for it { string[] folders = fileName.Split("/".ToCharArray()); string xsltBasePath = IOHelper.MapPath(SystemDirectories.Xslt); for (int i = 0; i < folders.Length - 1; i++) { xsltBasePath = System.IO.Path.Combine(xsltBasePath, folders[i]); System.IO.Directory.CreateDirectory(xsltBasePath); } } // System.IO.File.Copy(xsltTemplateSource, xsltNewFilename, false); // update with xslt references string xslt = ""; System.IO.StreamReader xsltFile = System.IO.File.OpenText(xsltTemplateSource); xslt = xsltFile.ReadToEnd(); xsltFile.Close(); // prepare support for XSLT extensions xslt = macro.AddXsltExtensionsToHeader(xslt); System.IO.StreamWriter xsltWriter = System.IO.File.CreateText(xsltNewFilename); xsltWriter.Write(xslt); xsltWriter.Flush(); xsltWriter.Close(); // Create macro? if (ParentID == 1) { var name = _alias.Substring(_alias.IndexOf("|||") + 3, _alias.Length - _alias.IndexOf("|||") - 3) .SplitPascalCasing().ToFirstUpperInvariant(); cms.businesslogic.macro.Macro m = cms.businesslogic.macro.Macro.MakeNew(name); m.Xslt = fileName + ".xslt"; } } _returnUrl = string.Format(SystemDirectories.Umbraco + "/developer/xslt/editXslt.aspx?file={0}.xslt", fileName); return(true); }
public static void SaveToDisk(Macro item) { if (item != null) { try { XmlDocument xmlDoc = helpers.XmlDoc.CreateDoc(); xmlDoc.AppendChild(item.ToXml(xmlDoc)); helpers.XmlDoc.SaveXmlDoc(item.GetType().ToString(), item.Alias, xmlDoc); } catch (Exception ex) { Log.Add(LogTypes.Error, 0, String.Format("uSync: Error Saving Macro {0} - {1}", item.Name, ex.ToString())); } } }
public static void SaveToDisk(Macro item) { if (item != null) { try { XmlDocument xmlDoc = helpers.XmlDoc.CreateDoc(); xmlDoc.AppendChild(item.ToXml(xmlDoc)); helpers.XmlDoc.SaveXmlDoc(item.GetType().ToString(), item.Alias, xmlDoc); } catch (Exception ex) { LogHelper.Error<SyncMacro>("uSync: Error Saving Macro", ex); } } }
public override void Execute(Core.ItemIdentifier itemId, Core.SerializableDictionary<string, string> Parameters) { try { if (umbraco.UmbracoSettings.UseDistributedCalls) { Macro m = new Macro(itemId.Id); if (m != null) { umbraco.presentation.cache.dispatcher.Refresh( new Guid("7B1E683C-5F34-43dd-803D-9699EA1E98CA"), m.Id); } } } catch (Exception ex) { Umbraco.Courier.Core.Helpers.Logging._Debug(ex.ToString()); } }
public void Macro_Make_New() { var m = Macro.MakeNew(Guid.NewGuid().ToString("N")); Assert.IsTrue(m.Id > 0); Assert.IsInstanceOfType(m, typeof(Macro)); m.Delete(); var isfound = false; try { var asdf = new Macro(m.Id); isfound = true; } catch (ArgumentException) { isfound = false; } Assert.IsFalse(isfound); }
private string GetCacheIdentifier(MacroModel model) { var id = new StringBuilder(); var alias = string.IsNullOrEmpty(model.ScriptCode) ? model.Alias : Macro.GenerateCacheKeyFromCode(model.ScriptCode); id.AppendFormat("{0}-", alias); if (CacheByPersonalization) { var currentMember = Member.GetCurrentMember(); id.AppendFormat("m{0}-", currentMember == null ? 0 : currentMember.Id); } foreach (var prop in model.Properties) { var propValue = prop.Value; id.AppendFormat("{0}-", propValue.Length <= 255 ? propValue : propValue.Substring(0, 255)); } return(id.ToString()); }
public MacroModel(Macro m) { Properties = new List<MacroPropertyModel>(); if (m != null) { Id = m.Id; Name = m.Name; Alias = m.Alias; TypeAssembly = m.Assembly; TypeName = m.Type; Xslt = m.Xslt; ScriptName = m.ScriptingFile; CacheDuration = m.RefreshRate; CacheByPage = m.CacheByPage; CacheByMember = m.CachePersonalized; RenderInEditor = m.RenderContent; foreach (MacroProperty mp in m.Properties) { Properties.Add( new MacroPropertyModel(mp.Alias, string.Empty, mp.Type.Alias, mp.Type.BaseType)); } MacroType = Macro.FindMacroType(Xslt, ScriptName, TypeName, TypeAssembly); } }
private void loadMacro() { if (m_macro == null && MacroAlias != "") { m_macro = Macro.GetByAlias(MacroAlias); if (m_macro == null) { throw new ArgumentException(String.Format("No macro with alias '{0}' found", MacroAlias)); } } }
private static Control LoadMacro(Match match) { if (match == null) return null; var parameters = new Dictionary<string, string>(); for (var i = 0; i < match.Groups["property"].Captures.Count; i++) parameters.Add(match.Groups["name"].Captures[i].Value.ToLower(), match.Groups["value"].Captures[i].Value); var macroAlias = parameters["macroalias"]; parameters.Remove("macroalias"); var macro = new Macro(macroAlias); var page = (System.Web.UI.Page) HttpContext.Current.Handler; Control control; if (!string.IsNullOrEmpty(macro.Assembly)) { try { var ctrlType = Type.GetType(macro.Type + "," + macro.Assembly); control = (Control)Activator.CreateInstance(ctrlType); } catch(Exception) { return new LiteralControl("Unable to create macro: " + macro.Type + "," + macro.Assembly); } } else { var filepath = "~/" + macro.Type; control = page.LoadControl(filepath); } var type = control.GetType(); var controlProperties = type.GetProperties().ToDictionary(p => p.Name.ToLower()); foreach (var key in parameters.Keys) { if (!controlProperties.ContainsKey(key.ToLower())) continue; var propertyInfo = controlProperties[key.ToLower()]; if (propertyInfo == null || !propertyInfo.CanWrite) continue; var converter = TypeDescriptor.GetConverter(propertyInfo.PropertyType); var value = converter.ConvertFrom(parameters[key]); propertyInfo.SetValue(control, value, null); } return control; }
public static MacroProperty MakeNew(Macro M, bool show, string alias, string name, MacroPropertyType propertyType) { int macroPropertyId = 0; // The method is synchronized SqlHelper.ExecuteNonQuery("INSERT INTO cmsMacroProperty (macro, macroPropertyHidden, macropropertyAlias, macroPropertyName, macroPropertyType) VALUES (@macro, @show, @alias, @name, @type)", SqlHelper.CreateParameter("@macro", M.Id), SqlHelper.CreateParameter("@show", show), SqlHelper.CreateParameter("@alias", alias), SqlHelper.CreateParameter("@name", name), SqlHelper.CreateParameter("@type", propertyType.Id)); macroPropertyId = SqlHelper.ExecuteScalar<int>("SELECT MAX(id) FROM cmsMacroProperty"); return new MacroProperty(macroPropertyId); }
static void Macro_AfterSave(Macro sender, SaveEventArgs e) { SaveToDisk(sender); }
static void Macro_AfterDelete(Macro sender, DeleteEventArgs e) { helpers.XmlDoc.ArchiveFile(sender.GetType().ToString(), sender.Alias); e.Cancel = false; }
public static MacroProperty MakeNew(Macro macro, string alias, string name, string editorAlias) { //try to get the new mapped parameter editor var mapped = LegacyParameterEditorAliasConverter.GetNewAliasFromLegacyAlias(editorAlias, false); if (mapped.IsNullOrWhiteSpace() == false) { editorAlias = mapped; } int macroPropertyId = 0; // The method is synchronized SqlHelper.ExecuteNonQuery("INSERT INTO cmsMacroProperty (macro, macropropertyAlias, macroPropertyName, editorAlias) VALUES (@macro, @alias, @name, @editorAlias)", SqlHelper.CreateParameter("@macro", macro.Id), SqlHelper.CreateParameter("@alias", alias), SqlHelper.CreateParameter("@name", name), SqlHelper.CreateParameter("@editorAlias", editorAlias)); macroPropertyId = SqlHelper.ExecuteScalar<int>("SELECT MAX(id) FROM cmsMacroProperty"); return new MacroProperty(macroPropertyId); }
public void Macro_Not_Found_Constructor() { Macro target = new Macro(-1111); }
public void AddMacro(Macro MacroToAdd) { _macros.Add(MacroToAdd); }
public override bool PerformSave() { IOHelper.EnsurePathExists(SystemDirectories.Xslt); IOHelper.EnsureFileExists(Path.Combine(IOHelper.MapPath(SystemDirectories.Xslt), "web.config"), Files.BlockingWebConfig); var template = Alias.Substring(0, Alias.IndexOf("|||")); var fileName = Alias.Substring(Alias.IndexOf("|||") + 3, Alias.Length - Alias.IndexOf("|||") - 3).Replace(" ", ""); if (fileName.ToLowerInvariant().EndsWith(".xslt") == false) { fileName += ".xslt"; } var xsltTemplateSource = IOHelper.MapPath(SystemDirectories.Umbraco + "/xslt/templates/" + template); var xsltNewFilename = IOHelper.MapPath(SystemDirectories.Xslt + "/" + fileName); if (File.Exists(xsltNewFilename) == false) { if (fileName.Contains("/")) //if there's a / create the folder structure for it { var folders = fileName.Split("/".ToCharArray()); var xsltBasePath = IOHelper.MapPath(SystemDirectories.Xslt); for (var i = 0; i < folders.Length - 1; i++) { xsltBasePath = System.IO.Path.Combine(xsltBasePath, folders[i]); System.IO.Directory.CreateDirectory(xsltBasePath); } } // update with xslt references var xslt = ""; using (var xsltFile = System.IO.File.OpenText(xsltTemplateSource)) { xslt = xsltFile.ReadToEnd(); xsltFile.Close(); } // prepare support for XSLT extensions xslt = macro.AddXsltExtensionsToHeader(xslt); var xsltWriter = System.IO.File.CreateText(xsltNewFilename); xsltWriter.Write(xslt); xsltWriter.Flush(); xsltWriter.Close(); // Create macro? if (ParentID == 1) { var name = Alias.Substring(Alias.IndexOf("|||") + 3, Alias.Length - Alias.IndexOf("|||") - 3); if (name.ToLowerInvariant().EndsWith(".xslt")) { name = name.Substring(0, name.Length - 5); } name = name.SplitPascalCasing().ToFirstUpperInvariant(); cms.businesslogic.macro.Macro m = cms.businesslogic.macro.Macro.MakeNew(name); m.Xslt = fileName; m.Save(); } } _returnUrl = string.Format(SystemDirectories.Umbraco + "/developer/xslt/editXslt.aspx?file={0}", fileName); return(true); }
/// <summary> /// Creates a macro object /// </summary> /// <param name="id">Specify the macro-id which should be loaded (from table macro)</param> public uWebshopMacro(int id) { var m = Macro.GetById(id); Model = new MacroModel(m); }
protected void Button1_Click(object sender, EventArgs e) { var result = ""; // Get the macro object var macroObject = new Macro(Convert.ToInt32(Request.QueryString["macroID"])); // Load all macroPropertyTypes var macroPropertyTypes = new Hashtable(); var macroPropertyIds = new Hashtable(); var macroPropTypes = MacroPropertyType.GetAll; foreach (var mpt in macroPropTypes) { macroPropertyIds.Add(mpt.Alias, mpt.Id.ToString()); macroPropertyTypes.Add(mpt.Alias, mpt.BaseType); } foreach (ListItem li in MacroProperties.Items) { if (li.Selected && !MacroHasProperty(macroObject, li.Text.Substring(0, li.Text.IndexOf(" ")).ToLower())) { result += "<li>Added: " + SpaceCamelCasing(li.Text) + "</li>"; var macroPropertyTypeAlias = FindMacroType(macroPropertyTypes, li.Value); if (macroPropertyTypeAlias == "") macroPropertyTypeAlias = "text"; var propertyId = macroPropertyIds[macroPropertyTypeAlias]; if (propertyId != null) { var macroPropertyTypeId = 0; if(int.TryParse(string.Format("{0}", propertyId), out macroPropertyTypeId)) { MacroProperty.MakeNew(macroObject, true, li.Text.Substring(0, li.Text.IndexOf(" ")), SpaceCamelCasing(li.Text), macroPropTypes.Find(mpt => mpt.Id == macroPropertyTypeId)); } } } else if (li.Selected) result += "<li>Skipped: " + SpaceCamelCasing(li.Text) + " (already exists as a parameter)</li>"; } ChooseProperties.Visible = false; ConfigProperties.Visible = true; resultLiteral.Text = result; }
/// <summary> /// Sets the values on the Macro object from the values posted back before saving the macro /// </summary> protected virtual void SetMacroValuesFromPostBack(Macro macro, int macroCachePeriod, string macroAssemblyValue, string macroTypeValue) { macro.UseInEditor = macroEditor.Checked; macro.RenderContent = macroRenderContent.Checked; macro.CacheByPage = cacheByPage.Checked; macro.CachePersonalized = cachePersonalized.Checked; macro.RefreshRate = macroCachePeriod; macro.Alias = macroAlias.Text; macro.Name = macroName.Text; macro.Assembly = macroAssemblyValue; macro.Type = macroTypeValue; macro.Xslt = macroXslt.Text; macro.ScriptingFile = macroPython.Text; }
public uWebshopMacro(string alias) { var m = Macro.GetByAlias(alias); Model = new MacroModel(m); }
public static Macro Import(XmlNode n) { Macro m = null; string alias = xmlHelper.GetNodeValue(n.SelectSingleNode("alias")); try { //check to see if the macro alreay exists in the system //it's better if it does and we keep using it, alias *should* be unique remember m = new Macro(alias); Macro.GetByAlias(alias); } catch (IndexOutOfRangeException) { m = MakeNew(xmlHelper.GetNodeValue(n.SelectSingleNode("name"))); } try { m.Alias = alias; m.Assembly = xmlHelper.GetNodeValue(n.SelectSingleNode("scriptAssembly")); m.Type = xmlHelper.GetNodeValue(n.SelectSingleNode("scriptType")); m.Xslt = xmlHelper.GetNodeValue(n.SelectSingleNode("xslt")); m.RefreshRate = int.Parse(xmlHelper.GetNodeValue(n.SelectSingleNode("refreshRate"))); // we need to validate if the usercontrol is missing the tilde prefix requirement introduced in v6 if (String.IsNullOrEmpty(m.Assembly) && !String.IsNullOrEmpty(m.Type) && !m.Type.StartsWith("~")) { m.Type = "~/" + m.Type; } if (n.SelectSingleNode("scriptingFile") != null) { m.ScriptingFile = xmlHelper.GetNodeValue(n.SelectSingleNode("scriptingFile")); } try { m.UseInEditor = bool.Parse(xmlHelper.GetNodeValue(n.SelectSingleNode("useInEditor"))); } catch (Exception macroExp) { LogHelper.Error <Macro>("Error creating macro property", macroExp); } // macro properties foreach (XmlNode mp in n.SelectNodes("properties/property")) { try { string propertyAlias = mp.Attributes.GetNamedItem("alias").Value; var property = m.Properties.SingleOrDefault(p => p.Alias == propertyAlias); if (property != null) { property.Public = bool.Parse(mp.Attributes.GetNamedItem("show").Value); property.Name = mp.Attributes.GetNamedItem("name").Value; property.Type = new MacroPropertyType(mp.Attributes.GetNamedItem("propertyType").Value); property.Save(); } else { MacroProperty.MakeNew( m, bool.Parse(mp.Attributes.GetNamedItem("show").Value), propertyAlias, mp.Attributes.GetNamedItem("name").Value, new MacroPropertyType(mp.Attributes.GetNamedItem("propertyType").Value) ); } } catch (Exception macroPropertyExp) { LogHelper.Error <Macro>("Error creating macro property", macroPropertyExp); } } m.Save(); } catch { return(null); } return(m); }
public static Macro Import(XmlNode n) { Macro m = null; string alias = xmlHelper.GetNodeValue(n.SelectSingleNode("alias")); try { //check to see if the macro alreay exists in the system //it's better if it does and we keep using it, alias *should* be unique remember m = new Macro(alias); Macro.GetByAlias(alias); } catch (IndexOutOfRangeException) { m = MakeNew(xmlHelper.GetNodeValue(n.SelectSingleNode("name"))); } try { m.Alias = alias; m.Assembly = xmlHelper.GetNodeValue(n.SelectSingleNode("scriptAssembly")); m.Type = xmlHelper.GetNodeValue(n.SelectSingleNode("scriptType")); m.Xslt = xmlHelper.GetNodeValue(n.SelectSingleNode("xslt")); m.RefreshRate = int.Parse(xmlHelper.GetNodeValue(n.SelectSingleNode("refreshRate"))); if (n.SelectSingleNode("scriptingFile") != null) { m.ScriptingFile = xmlHelper.GetNodeValue(n.SelectSingleNode("scriptingFile")); } try { m.UseInEditor = bool.Parse(xmlHelper.GetNodeValue(n.SelectSingleNode("useInEditor"))); } catch (Exception macroExp) { BusinessLogic.Log.Add(BusinessLogic.LogTypes.Error, BusinessLogic.User.GetUser(0), -1, "Error creating macro property: " + macroExp.ToString()); } // macro properties foreach (XmlNode mp in n.SelectNodes("properties/property")) { try { string propertyAlias = mp.Attributes.GetNamedItem("alias").Value; var property = m.Properties.SingleOrDefault(p => p.Alias == propertyAlias); if (property != null) { property.Public = bool.Parse(mp.Attributes.GetNamedItem("show").Value); property.Name = mp.Attributes.GetNamedItem("name").Value; property.Type = new MacroPropertyType(mp.Attributes.GetNamedItem("propertyType").Value); property.Save(); } else { MacroProperty.MakeNew( m, bool.Parse(mp.Attributes.GetNamedItem("show").Value), propertyAlias, mp.Attributes.GetNamedItem("name").Value, new MacroPropertyType(mp.Attributes.GetNamedItem("propertyType").Value) ); } } catch (Exception macroPropertyExp) { BusinessLogic.Log.Add(BusinessLogic.LogTypes.Error, BusinessLogic.User.GetUser(0), -1, "Error creating macro property: " + macroPropertyExp.ToString()); } } m.Save(); } catch { return(null); } return(m); }
/// <summary> /// Reads the configuration of the package from the configuration xmldocument /// </summary> /// <param name="tempDir">The folder to which the contents of the package is extracted</param> public void LoadConfig(string tempDir) { _packageConfig = new XmlDocument(); _packageConfig.Load(tempDir + Path.DirectorySeparatorChar + "package.xml"); _name = _packageConfig.DocumentElement.SelectSingleNode("/umbPackage/info/package/name").FirstChild.Value; _version = _packageConfig.DocumentElement.SelectSingleNode("/umbPackage/info/package/version").FirstChild.Value; _url = _packageConfig.DocumentElement.SelectSingleNode("/umbPackage/info/package/url").FirstChild.Value; _license = _packageConfig.DocumentElement.SelectSingleNode("/umbPackage/info/package/license").FirstChild.Value; _licenseUrl = _packageConfig.DocumentElement.SelectSingleNode("/umbPackage/info/package/license").Attributes.GetNamedItem("url").Value; _reqMajor = int.Parse(_packageConfig.DocumentElement.SelectSingleNode("/umbPackage/info/package/requirements/major").FirstChild.Value); _reqMinor = int.Parse(_packageConfig.DocumentElement.SelectSingleNode("/umbPackage/info/package/requirements/major").FirstChild.Value); _reqPatch = int.Parse(_packageConfig.DocumentElement.SelectSingleNode("/umbPackage/info/package/requirements/patch").FirstChild.Value); _authorName = _packageConfig.DocumentElement.SelectSingleNode("/umbPackage/info/author/name").FirstChild.Value; _authorUrl = _packageConfig.DocumentElement.SelectSingleNode("/umbPackage/info/author/website").FirstChild.Value; string basePath = System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath; foreach (XmlNode n in _packageConfig.DocumentElement.SelectNodes("//file")) { bool badFile = false; string destPath = GetFileName(basePath, xmlHelper.GetNodeValue(n.SelectSingleNode("orgPath"))); string destFile = GetFileName(destPath, xmlHelper.GetNodeValue(n.SelectSingleNode("orgName"))); if (destPath.ToLower().Contains(IOHelper.DirSepChar + "app_code")) badFile = true; if (destPath.ToLower().Contains(IOHelper.DirSepChar + "bin")) badFile = true; if (destFile.ToLower().EndsWith(".dll")) badFile = true; if (badFile) { _containUnsecureFiles = true; _unsecureFiles.Add(xmlHelper.GetNodeValue(n.SelectSingleNode("orgName"))); } } //this will check for existing macros with the same alias //since we will not overwrite on import it's a good idea to inform the user what will be overwritten foreach (XmlNode n in _packageConfig.DocumentElement.SelectNodes("//macro")) { var alias = n.SelectSingleNode("alias").InnerText; if (!string.IsNullOrEmpty(alias)) { try { var m = new Macro(alias); this._containsMacroConflict = true; this._conflictingMacroAliases.Add(m.Name, alias); } catch (IndexOutOfRangeException) { } //thrown when the alias doesn't exist in the DB, ie - macro not there } } foreach (XmlNode n in _packageConfig.DocumentElement.SelectNodes("Templates/Template")) { var alias = n.SelectSingleNode("Alias").InnerText; if (!string.IsNullOrEmpty(alias)) { var t = Template.GetByAlias(alias); if (t != null) { this._containsTemplateConflict = true; this._conflictingTemplateAliases.Add(t.Text, alias); } } } foreach (XmlNode n in _packageConfig.DocumentElement.SelectNodes("Stylesheets/Stylesheet")) { var alias = n.SelectSingleNode("Name").InnerText; if (!string.IsNullOrEmpty(alias)) { var s = StyleSheet.GetByName(alias); if (s != null) { this._containsStyleSheetConflict = true; this._conflictingStyleSheetNames.Add(s.Text, alias); } } } try { _readme = xmlHelper.GetNodeValue(_packageConfig.DocumentElement.SelectSingleNode("/umbPackage/info/readme")); } catch { } try { _control = xmlHelper.GetNodeValue(_packageConfig.DocumentElement.SelectSingleNode("/umbPackage/control")); } catch { } }
public static Macro Import(XmlNode n) { Macro m = null; string alias = xmlHelper.GetNodeValue(n.SelectSingleNode("alias")); try { //check to see if the macro alreay exists in the system //it's better if it does and we keep using it, alias *should* be unique remember m = new Macro(alias); Macro.GetByAlias(alias); } catch (IndexOutOfRangeException) { m = MakeNew(xmlHelper.GetNodeValue(n.SelectSingleNode("name"))); } try { m.Alias = alias; m.Assembly = xmlHelper.GetNodeValue(n.SelectSingleNode("scriptAssembly")); m.Type = xmlHelper.GetNodeValue(n.SelectSingleNode("scriptType")); m.Xslt = xmlHelper.GetNodeValue(n.SelectSingleNode("xslt")); m.RefreshRate = int.Parse(xmlHelper.GetNodeValue(n.SelectSingleNode("refreshRate"))); if (n.SelectSingleNode("scriptingFile") != null) m.ScriptingFile = xmlHelper.GetNodeValue(n.SelectSingleNode("scriptingFile")); try { m.UseInEditor = bool.Parse(xmlHelper.GetNodeValue(n.SelectSingleNode("useInEditor"))); } catch (Exception macroExp) { BusinessLogic.Log.Add(BusinessLogic.LogTypes.Error, BusinessLogic.User.GetUser(0), -1, "Error creating macro property: " + macroExp.ToString()); } // macro properties foreach (XmlNode mp in n.SelectNodes("properties/property")) { try { string propertyAlias = mp.Attributes.GetNamedItem("alias").Value; var property = m.Properties.SingleOrDefault(p => p.Alias == propertyAlias); if (property != null) { property.Public = bool.Parse(mp.Attributes.GetNamedItem("show").Value); property.Name = mp.Attributes.GetNamedItem("name").Value; property.Type = new MacroPropertyType(mp.Attributes.GetNamedItem("propertyType").Value); property.Save(); } else { MacroProperty.MakeNew( m, bool.Parse(mp.Attributes.GetNamedItem("show").Value), propertyAlias, mp.Attributes.GetNamedItem("name").Value, new MacroPropertyType(mp.Attributes.GetNamedItem("propertyType").Value) ); } } catch (Exception macroPropertyExp) { BusinessLogic.Log.Add(BusinessLogic.LogTypes.Error, BusinessLogic.User.GetUser(0), -1, "Error creating macro property: " + macroPropertyExp.ToString()); } } m.Save(); } catch { return null; } return m; }
public static MacroProperty MakeNew(Macro macro, bool show, string alias, string name, MacroPropertyType propertyType) { return MakeNew(macro, alias, name, propertyType.Alias); }
/// <summary> /// Populates the control (textbox) values on page load /// </summary> /// <param name="macro"></param> /// <param name="macroAssemblyValue"></param> /// <param name="macroTypeValue"></param> protected virtual void PopulateFieldsOnLoad(Macro macro, string macroAssemblyValue, string macroTypeValue) { macroName.Text = macro.Name; macroAlias.Text = macro.Alias; macroXslt.Text = macro.Xslt; macroPython.Text = macro.ScriptingFile; cachePeriod.Text = macro.RefreshRate.ToString(); macroRenderContent.Checked = macro.RenderContent; macroEditor.Checked = macro.UseInEditor; cacheByPage.Checked = macro.CacheByPage; cachePersonalized.Checked = macro.CachePersonalized; // Populate either user control or custom control if (macroTypeValue != string.Empty && macroAssemblyValue != string.Empty) { macroAssembly.Text = macroAssemblyValue; macroType.Text = macroTypeValue; } else { macroUserControl.Text = macroTypeValue; } }
public static MacroProperty MakeNew(Macro macro, bool show, string alias, string name, MacroPropertyType propertyType) { return(MakeNew(macro, alias, name, propertyType.Alias)); }
protected void Page_Load(object sender, EventArgs e) { m_macro = new Macro(Convert.ToInt32(Request.QueryString["macroID"])); if (!IsPostBack) { ClientTools .SetActiveTreeType(TreeDefinitionCollection.Instance.FindTree<loadMacros>().Tree.Alias) .SyncTree("-1,init," + m_macro.Id.ToString(), false); string tempMacroAssembly = m_macro.Assembly ?? ""; string tempMacroType = m_macro.Type ?? ""; PopulateFieldsOnLoad(m_macro, tempMacroAssembly, tempMacroType); // Check for assemblyBrowser if (tempMacroType.IndexOf(".ascx") > 0) assemblyBrowserUserControl.Controls.Add( new LiteralControl("<br/><button onClick=\"UmbClientMgr.openModalWindow('" + IOHelper.ResolveUrl(SystemDirectories.Umbraco) + "/developer/macros/assemblyBrowser.aspx?fileName=" + macroUserControl.Text + "¯oID=" + m_macro.Id.ToString() + "', 'Browse Properties', true, 475,500); return false;\" class=\"guiInputButton\"><img src=\"../../images/editor/propertiesNew.gif\" align=\"absmiddle\" style=\"width: 18px; height: 17px; padding-right: 5px;\"/> Browse properties</button>")); else if (tempMacroType != string.Empty && tempMacroAssembly != string.Empty) assemblyBrowser.Controls.Add( new LiteralControl("<br/><button onClick=\"UmbClientMgr.openModalWindow('" + IOHelper.ResolveUrl(SystemDirectories.Umbraco) + "/developer/macros/assemblyBrowser.aspx?fileName=" + macroAssembly.Text + "¯oID=" + m_macro.Id.ToString() + "&type=" + macroType.Text + "', 'Browse Properties', true, 475,500); return false\" class=\"guiInputButton\"><img src=\"../../images/editor/propertiesNew.gif\" align=\"absmiddle\" style=\"width: 18px; height: 17px; padding-right: 5px;\"/> Browse properties</button>")); // Load elements from macro macroPropertyBind(); // Load xslt files from default dir PopulateXsltFiles(); // Load python files from default dir PopulatePythonFiles(); // Load usercontrols PopulateUserControls(IOHelper.MapPath(SystemDirectories.UserControls)); userControlList.Items.Insert(0, new ListItem("Browse usercontrols on server...", string.Empty)); } else { int macroID = Convert.ToInt32(Request.QueryString["macroID"]); string tempMacroAssembly = macroAssembly.Text; string tempMacroType = macroType.Text; string tempCachePeriod = cachePeriod.Text; if (tempCachePeriod == string.Empty) tempCachePeriod = "0"; if (tempMacroAssembly == string.Empty && macroUserControl.Text != string.Empty) tempMacroType = macroUserControl.Text; SetMacroValuesFromPostBack(m_macro, Convert.ToInt32(tempCachePeriod), tempMacroAssembly, tempMacroType); m_macro.Save(); // Save elements foreach (RepeaterItem item in macroProperties.Items) { HtmlInputHidden macroPropertyID = (HtmlInputHidden)item.FindControl("macroPropertyID"); TextBox macroElementName = (TextBox)item.FindControl("macroPropertyName"); TextBox macroElementAlias = (TextBox)item.FindControl("macroPropertyAlias"); CheckBox macroElementShow = (CheckBox)item.FindControl("macroPropertyHidden"); DropDownList macroElementType = (DropDownList)item.FindControl("macroPropertyType"); MacroProperty mp = new MacroProperty(int.Parse(macroPropertyID.Value)); mp.Type = new MacroPropertyType(int.Parse(macroElementType.SelectedValue)); mp.Alias = macroElementAlias.Text; mp.Name = macroElementName.Text; mp.Save(); } // Flush macro from cache! if (UmbracoSettings.UseDistributedCalls) dispatcher.Refresh( new Guid("7B1E683C-5F34-43dd-803D-9699EA1E98CA"), macroID); else macro.GetMacro(macroID).removeFromCache(); ClientTools.ShowSpeechBubble(speechBubbleIcon.save, "Macro saved", ""); // Check for assemblyBrowser if (tempMacroType.IndexOf(".ascx") > 0) assemblyBrowserUserControl.Controls.Add( new LiteralControl("<br/><button onClick=\"UmbClientMgr.openModalWindow('developer/macros/assemblyBrowser.aspx?fileName=" + macroUserControl.Text + "¯oID=" + Request.QueryString["macroID"] + "', 'Browse Properties', true, 500, 475); return false\" class=\"guiInputButton\"><img src=\"../../images/editor/propertiesNew.gif\" align=\"absmiddle\" style=\"width: 18px; height: 17px; padding-right: 5px;\"/> Browse properties</button>")); else if (tempMacroType != string.Empty && tempMacroAssembly != string.Empty) assemblyBrowser.Controls.Add( new LiteralControl("<br/><button onClick=\"UmbClientMgr.openModalWindow('developer/macros/assemblyBrowser.aspx?fileName=" + macroAssembly.Text + "¯oID=" + Request.QueryString["macroID"] + "&type=" + macroType.Text + "', 'Browse Properties', true, 500, 475); return false\" class=\"guiInputButton\"><img src=\"../../images/editor/propertiesNew.gif\" align=\"absmiddle\" style=\"width: 18px; height: 17px; padding-right: 5px;\"/> Browse properties</button>")); } }
protected void Button1_Click(object sender, System.EventArgs e) { string result = ""; // Get the macro object umbraco.cms.businesslogic.macro.Macro macroObject = new umbraco.cms.businesslogic.macro.Macro(Convert.ToInt32(Request.QueryString["macroID"])); // Load all macroPropertyTypes Hashtable macroPropertyTypes = new Hashtable(); Hashtable macroPropertyIds = new Hashtable(); // SqlDataReader dr = SqlHelper.ExecuteReader(_ConnString, CommandType.Text, "select id, macroPropertyTypeBaseType, macroPropertyTypeAlias from cmsMacroPropertyType"); List<MacroPropertyType> macroPropTypes = MacroPropertyType.GetAll; foreach (MacroPropertyType mpt in macroPropTypes) { macroPropertyIds.Add(mpt.Alias, mpt.Id.ToString()); macroPropertyTypes.Add(mpt.Alias, mpt.BaseType); } // dr.Close(); foreach (ListItem li in MacroProperties.Items) { if (li.Selected && !macrohasProperty(macroObject, li.Text.Substring(0, li.Text.IndexOf(" ")).ToLower())) { result += "<li>Added: " + spaceCamelCasing(li.Text) + "</li>"; string _macroPropertyTypeAlias = findMacroType(macroPropertyTypes, li.Value); if (_macroPropertyTypeAlias == "") _macroPropertyTypeAlias = "text"; object propertyId = macroPropertyIds[_macroPropertyTypeAlias]; if (propertyId != null) { int macroPropertyTypeId = 0; if(int.TryParse(string.Format("{0}", propertyId), out macroPropertyTypeId)) { MacroProperty.MakeNew(macroObject, true, li.Text.Substring(0, li.Text.IndexOf(" ")), spaceCamelCasing(li.Text), macroPropTypes.Find(delegate(MacroPropertyType mpt) { return mpt.Id == macroPropertyTypeId; })); } } } else if (li.Selected) result += "<li>Skipped: " + spaceCamelCasing(li.Text) + " (already exists as a parameter)</li>"; } ChooseProperties.Visible = false; ConfigProperties.Visible = true; resultLiteral.Text = result; }
private static bool MacroHasProperty(Macro macroObject, string propertyAlias) { return macroObject.Properties.Any(mp => mp.Alias.ToLower() == propertyAlias); }
protected void Page_Load(object sender, EventArgs e) { ClientLoader.DataBind(); _scriptOnLoad = ""; string reqMacroID = UmbracoContext.Current.Request["umb_macroID"]; string reqMacroAlias = UmbracoContext.Current.Request["umb_macroAlias"]; bool ignoreForm = string.IsNullOrEmpty(UmbracoContext.Current.Request["class"]); pane_insert.Text = ui.Text("insertMacro"); Page.Title = ui.Text("insertMacro"); if (!String.IsNullOrEmpty(reqMacroID) || !String.IsNullOrEmpty(reqMacroAlias)) { pane_edit.Visible = true; pane_insert.Visible = false; edit_buttons.Visible = true; insert_buttons.Visible = false; // Put user code to initialize the page here if (!string.IsNullOrEmpty(reqMacroID)) { m = new Macro(int.Parse(reqMacroID)); } else { m = new Macro(reqMacroAlias); } pane_edit.Text = ui.Text("edit") + " " + m.Name; Page.Title = ui.Text("edit") + " " + m.Name; String macroAssembly = ""; String macroType = ""; if (m.Properties.Length == 0) { if (ignoreForm) { renderMacro_Click(null, EventArgs.Empty); } else { Literal fb = new Literal(); fb.Text = "<p>" + ui.Text("macroDoesNotHaveProperties") + "</p><p><a href='#' onClick='tinyMCEPopup.close();'>" + ui.Text("closeThisWindow") + "</a>"; macroProperties.Controls.Add(fb); edit_buttons.Visible = false; } } else { foreach (MacroProperty mp in m.Properties) { macroAssembly = mp.Type.Assembly; macroType = mp.Type.Type; try { Assembly assembly = Assembly.LoadFrom( IOHelper.MapPath(SystemDirectories.Bin + "/" + macroAssembly + ".dll")); Type type = assembly.GetType(macroAssembly + "." + macroType); IMacroGuiRendering typeInstance = Activator.CreateInstance(type) as IMacroGuiRendering; if (typeInstance != null) { Control control = Activator.CreateInstance(type) as Control; control.ID = mp.Alias; if (!IsPostBack) { string propertyValue = Request["umb_" + mp.Alias]; if (propertyValue != null) { // replace linebreaks and quotes propertyValue = propertyValue.Replace("\\r", "\r").Replace("\\n", "\n").Replace("\\\"", "\""); // check encoding propertyValue = HttpUtility.UrlDecode(propertyValue); if (propertyValue != "") { type.GetProperty("Value").SetValue(control, Convert.ChangeType( propertyValue, type.GetProperty("Value").PropertyType), null); } } } uicontrols.PropertyPanel pp = new global::umbraco.uicontrols.PropertyPanel(); pp.Text = mp.Name; pp.Controls.Add(control); _scriptOnLoad += "\t\tregisterAlias('" + control.ID + "');\n"; // pp.Controls.Add(new LiteralControl("<script type=\"text/javascript\"></script>\n")); macroProperties.Controls.Add(pp); _dataFields.Add(control); //macroProperties.Controls.Add(new LiteralControl("</td></tr>")); } else { Trace.Warn("umbEditContent", "Type doesn't exist or is not umbraco.interfaces.DataFieldI ('" + macroAssembly + "." + macroType + "')"); } } catch (Exception fieldException) { Trace.Warn("umbEditContent", "Error creating type '" + macroAssembly + "." + macroType + "'", fieldException); } } } } else { IRecordsReader macroRenderings; if (UmbracoContext.Current.Request["editor"] != "") macroRenderings = SqlHelper.ExecuteReader("select macroAlias, macroName from cmsMacro where macroUseInEditor = 1 order by macroName"); else macroRenderings = SqlHelper.ExecuteReader("select macroAlias, macroName from cmsMacro order by macroName"); umb_macroAlias.DataSource = macroRenderings; umb_macroAlias.DataValueField = "macroAlias"; umb_macroAlias.DataTextField = "macroName"; umb_macroAlias.DataBind(); macroRenderings.Close(); } }
public static Macro MakeNew(string Name) { int macroId = 0; // The method is synchronized SqlHelper.ExecuteNonQuery("INSERT INTO cmsMacro (macroAlias, macroName) values (@macroAlias, @macroName)", SqlHelper.CreateParameter("@macroAlias", Name.Replace(" ", String.Empty)), SqlHelper.CreateParameter("@macroName", Name)); macroId = SqlHelper.ExecuteScalar<int>("SELECT MAX(id) FROM cmsMacro"); Macro newMacro = new Macro(macroId); //fire new event NewEventArgs e = new NewEventArgs(); newMacro.OnNew(e); return newMacro; }
public static Macro Import(XmlNode n) { Macro m = null; string alias = xmlHelper.GetNodeValue(n.SelectSingleNode("alias")); try { //check to see if the macro alreay exists in the system //it's better if it does and we keep using it, alias *should* be unique remember m = new Macro(alias); Macro.GetByAlias(alias); } catch (IndexOutOfRangeException) { m = MakeNew(xmlHelper.GetNodeValue(n.SelectSingleNode("name"))); } try { m.Alias = alias; m.Assembly = xmlHelper.GetNodeValue(n.SelectSingleNode("scriptAssembly")); m.Type = xmlHelper.GetNodeValue(n.SelectSingleNode("scriptType")); m.Xslt = xmlHelper.GetNodeValue(n.SelectSingleNode("xslt")); m.RefreshRate = int.Parse(xmlHelper.GetNodeValue(n.SelectSingleNode("refreshRate"))); // we need to validate if the usercontrol is missing the tilde prefix requirement introduced in v6 if (String.IsNullOrEmpty(m.Assembly) && !String.IsNullOrEmpty(m.Type) && !m.Type.StartsWith("~")) m.Type = "~/" + m.Type; if (n.SelectSingleNode("scriptingFile") != null) m.ScriptingFile = xmlHelper.GetNodeValue(n.SelectSingleNode("scriptingFile")); try { m.UseInEditor = bool.Parse(xmlHelper.GetNodeValue(n.SelectSingleNode("useInEditor"))); } catch (Exception macroExp) { LogHelper.Error<Macro>("Error creating macro property", macroExp); } // macro properties foreach (XmlNode mp in n.SelectNodes("properties/property")) { try { string propertyAlias = mp.Attributes.GetNamedItem("alias").Value; var property = m.Properties.SingleOrDefault(p => p.Alias == propertyAlias); if (property != null) { property.Public = bool.Parse(mp.Attributes.GetNamedItem("show").Value); property.Name = mp.Attributes.GetNamedItem("name").Value; property.Type = new MacroPropertyType(mp.Attributes.GetNamedItem("propertyType").Value); property.Save(); } else { MacroProperty.MakeNew( m, bool.Parse(mp.Attributes.GetNamedItem("show").Value), propertyAlias, mp.Attributes.GetNamedItem("name").Value, new MacroPropertyType(mp.Attributes.GetNamedItem("propertyType").Value) ); } } catch (Exception macroPropertyExp) { LogHelper.Error<Macro>("Error creating macro property", macroPropertyExp); } } m.Save(); } catch { return null; } return m; }