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;
}
