From f36a88384d9f9f1e8bfab1fc789fc637830afc47 Mon Sep 17 00:00:00 2001 From: Shannon Deminick Date: Thu, 23 Aug 2012 22:28:22 +0600 Subject: [PATCH] Migrated UmbracoSettings, GlobalSettings, XmlHelper, IOHelper and supporting classes to Umbraco.Core. This fixes the need for Umbraco.Core to reference business logic since business logic needs to reference Umbraco.Core (Umbraco.Core should never reference any other project except for interfaces, it is the 'Core' of the new codebase. --- .../Configuration/GlobalSettings.cs | 837 +++++++++++ .../Configuration/UmbracoSettings.cs | 1303 +++++++++++++++++ src/Umbraco.Core/IO/FileSecurityException.cs | 20 + src/Umbraco.Core/IO/IOHelper.cs | 206 +++ ...nsions.cs => MediaFileSystemExtensions.cs} | 4 +- src/Umbraco.Core/IO/SystemDirectories.cs | 181 +++ src/Umbraco.Core/IO/SystemFiles.cs | 122 ++ .../RazorDataTypeModelStaticMappingItem.cs | 31 + src/Umbraco.Core/SystemUtilities.cs | 40 + src/Umbraco.Core/Umbraco.Core.csproj | 17 +- src/Umbraco.Core/XmlHelper.cs | 168 +++ .../Exceptions/FileSecurityException.cs | 7 +- src/umbraco.businesslogic/GlobalSettings.cs | 473 +----- src/umbraco.businesslogic/IO/IOHelper.cs | 131 +- .../IO/SystemDirectories.cs | 106 +- src/umbraco.businesslogic/IO/SystemFiles.cs | 151 +- .../RazorDataTypeModelStaticMappingItem.cs | 51 +- src/umbraco.businesslogic/UmbracoSettings.cs | 797 ++-------- .../umbraco.businesslogic.csproj | 4 + src/umbraco.businesslogic/xmlHelper.cs | 76 +- src/umbraco.cms/businesslogic/Content.cs | 2 +- .../tinyMCE3/webcontrol/TinyMCEWebControl.cs | 10 +- .../tinymce/tinyMCEImageHelper.cs | 2 +- src/umbraco.webservices/media/mediaService.cs | 6 +- 24 files changed, 3205 insertions(+), 1540 deletions(-) create mode 100644 src/Umbraco.Core/Configuration/GlobalSettings.cs create mode 100644 src/Umbraco.Core/Configuration/UmbracoSettings.cs create mode 100644 src/Umbraco.Core/IO/FileSecurityException.cs create mode 100644 src/Umbraco.Core/IO/IOHelper.cs rename src/Umbraco.Core/IO/{IMediaFileSystemExtensions.cs => MediaFileSystemExtensions.cs} (90%) create mode 100644 src/Umbraco.Core/IO/SystemDirectories.cs create mode 100644 src/Umbraco.Core/IO/SystemFiles.cs create mode 100644 src/Umbraco.Core/RazorDataTypeModelStaticMappingItem.cs create mode 100644 src/Umbraco.Core/SystemUtilities.cs create mode 100644 src/Umbraco.Core/XmlHelper.cs diff --git a/src/Umbraco.Core/Configuration/GlobalSettings.cs b/src/Umbraco.Core/Configuration/GlobalSettings.cs new file mode 100644 index 0000000000..4eb22fae1f --- /dev/null +++ b/src/Umbraco.Core/Configuration/GlobalSettings.cs @@ -0,0 +1,837 @@ +using System; +using System.Collections.Generic; +using System.Configuration; +using System.Diagnostics; +using System.Web; +using System.Web.Configuration; +using System.Xml; +using Umbraco.Core.IO; + +namespace Umbraco.Core.Configuration +{ + //NOTE: Do not expose this class ever until we cleanup all configuration including removal of static classes, etc... + // we have this two tasks logged: + // http://issues.umbraco.org/issue/U4-58 + // http://issues.umbraco.org/issue/U4-115 + + //TODO: Re-enable Logging!!!! + + //TODO: Remove checks for if HttpContext is null, why are we doing this? we should be checking if the config setting + // can be read and if not then return the default. + + /// + /// The GlobalSettings Class contains general settings information for the entire Umbraco instance based on information from web.config appsettings + /// + internal class GlobalSettings + { + + private static HttpContextBase _customHttpContext; + + /// + /// Gets/sets the HttpContext object, this is generally used for unit testing. By default this will + /// use the HttpContext.Current + /// + internal static HttpContextBase HttpContext + { + get + { + if (_customHttpContext == null && System.Web.HttpContext.Current != null) + { + //return the current HttpContxt, do NOT store this in the _customHttpContext field + //as it will persist across reqeusts! + return new HttpContextWrapper(System.Web.HttpContext.Current); + } + + if (_customHttpContext == null && System.Web.HttpContext.Current == null) + { + //throw new NullReferenceException("The HttpContext property has not been set or the object execution is not running inside of an HttpContext"); + //NOTE: We should throw an exception here but the legacy code checks for null so we need to stick witht he legacy code for now. + return null; + } + return _customHttpContext; + } + set { _customHttpContext = value; } + } + + #region Private static fields + + // CURRENT UMBRACO VERSION ID + private const string CurrentUmbracoVersion = "4.9.0"; + + private static string _reservedUrlsCache; + private static string _reservedPathsCache; + private static StartsWithContainer _reservedList = new StartsWithContainer(); + + #endregion + + /// + /// Gets the reserved urls from web.config. + /// + /// The reserved urls. + public static string ReservedUrls + { + get + { + if (HttpContext != null) + return ConfigurationManager.AppSettings["umbracoReservedUrls"]; + return String.Empty; + } + } + + /// + /// Gets the reserved paths from web.config + /// + /// The reserved paths. + public static string ReservedPaths + { + get + { + if (HttpContext != null) + return ConfigurationManager.AppSettings["umbracoReservedPaths"]; + return String.Empty; + } + } + + /// + /// Gets the name of the content XML file. + /// + /// The content XML. + public static string ContentXml + { + get + { + try + { + return ConfigurationManager.AppSettings["umbracoContentXML"]; + } + catch + { + return String.Empty; + } + } + } + + /// + /// Gets the path to the storage directory (/data by default). + /// + /// The storage directory. + public static string StorageDirectory + { + get + { + try + { + return ConfigurationManager.AppSettings["umbracoStorageDirectory"]; + } + catch + { + return String.Empty; + } + } + } + + /// + /// Gets the path to umbraco's root directory (/umbraco by default). + /// + /// The path. + public static string Path + { + get + { + + try + { + return IOHelper.ResolveUrl(ConfigurationManager.AppSettings["umbracoPath"]); + } + catch + { + return String.Empty; + } + } + } + + /// + /// Gets the path to umbraco's client directory (/umbraco_client by default). + /// This is a relative path to the Umbraco Path as it always must exist beside the 'umbraco' + /// folder since the CSS paths to images depend on it. + /// + /// The path. + public static string ClientPath + { + get + { + return Path + "/../umbraco_client"; + } + } + + /// + /// Gets the database connection string + /// + /// The database connection string. + public static string DbDsn + { + get + { + try + { + return ConfigurationManager.AppSettings["umbracoDbDSN"]; + } + catch + { + return String.Empty; + } + } + set + { + if (DbDsn != value) + { + SaveSetting("umbracoDbDSN", value); + } + } + } + + /// + /// Gets or sets the configuration status. This will return the version number of the currently installed umbraco instance. + /// + /// The configuration status. + public static string ConfigurationStatus + { + get + { + try + { + return ConfigurationManager.AppSettings["umbracoConfigurationStatus"]; + } + catch + { + return String.Empty; + } + } + set + { + SaveSetting("umbracoConfigurationStatus", value); + } + } + + + /// + /// Forces umbraco to be medium trust compatible + /// + /// If true, umbraco will be medium-trust compatible, no matter what Permission level the server is on. + public static bool UseMediumTrust + { + get + { + try + { + var trustLevel = SystemUtilities.GetCurrentTrustLevel(); + if (trustLevel == AspNetHostingPermissionLevel.High || trustLevel == AspNetHostingPermissionLevel.Unrestricted) + return false; + else + return bool.Parse(ConfigurationManager.AppSettings["umbracoUseMediumTrust"]); + } + catch + { + return false; + } + } + } + + /// + /// Saves a setting into the configuration file. + /// + /// Key of the setting to be saved. + /// Value of the setting to be saved. + internal static void SaveSetting(string key, string value) + { + var webConfig = new WebConfigurationFileMap(); + var vDirs = webConfig.VirtualDirectories; + var vDir = FullpathToRoot; + foreach (VirtualDirectoryMapping v in webConfig.VirtualDirectories) + { + if (v.IsAppRoot) + { + vDir = v.PhysicalDirectory; + } + } + + var doc = new XmlDocument(); + doc.Load(String.Concat(vDir, "web.config")); + var root = doc.DocumentElement; + var setting = doc.SelectSingleNode(String.Concat("//appSettings/add[@key='", key, "']")); + setting.Attributes["value"].InnerText = value; + doc.Save(String.Concat(vDir, "web.config")); + ConfigurationManager.RefreshSection("appSettings"); + } + + /// + /// Gets the full path to root. + /// + /// The fullpath to root. + public static string FullpathToRoot + { + get { return HttpRuntime.AppDomainAppPath; } + } + + /// + /// Gets a value indicating whether umbraco is running in [debug mode]. + /// + /// true if [debug mode]; otherwise, false. + public static bool DebugMode + { + get + { + try + { + return bool.Parse(ConfigurationManager.AppSettings["umbracoDebugMode"]); + } + catch + { + return false; + } + } + } + + /// + /// Gets a value indicating whether the current version of umbraco is configured. + /// + /// true if configured; otherwise, false. + public static bool Configured + { + get + { + try + { + string configStatus = ConfigurationStatus; + string currentVersion = CurrentVersion; + + + if (currentVersion != configStatus) + { + //Log.Add(LogTypes.Debug, User.GetUser(0), -1, + // "CurrentVersion different from configStatus: '" + currentVersion + "','" + configStatus + + // "'"); + } + + + return (configStatus == currentVersion); + } + catch + { + return false; + } + } + } + + /// + /// Gets the time out in minutes. + /// + /// The time out in minutes. + public static int TimeOutInMinutes + { + get + { + try + { + return int.Parse(ConfigurationManager.AppSettings["umbracoTimeOutInMinutes"]); + } + catch + { + return 20; + } + } + } + + /// + /// Gets a value indicating whether umbraco uses directory urls. + /// + /// true if umbraco uses directory urls; otherwise, false. + public static bool UseDirectoryUrls + { + get + { + try + { + return bool.Parse(ConfigurationManager.AppSettings["umbracoUseDirectoryUrls"]); + } + catch + { + return false; + } + } + } + + /// + /// Returns a string value to determine if umbraco should skip version-checking. + /// + /// The version check period in days (0 = never). + public static int VersionCheckPeriod + { + get + { + int versionCheckPeriod = 7; + if (HttpContext != null) + { + if (int.TryParse(ConfigurationManager.AppSettings["umbracoVersionCheckPeriod"], out versionCheckPeriod)) + return versionCheckPeriod; + + } + return versionCheckPeriod; + } + } + + /// + /// Gets the URL forbitten characters. + /// + /// The URL forbitten characters. + public static string UrlForbittenCharacters + { + get + { + if (HttpContext != null) + return ConfigurationManager.AppSettings["umbracoUrlForbittenCharacters"]; + return ""; + } + } + + /// + /// Gets the URL space character. + /// + /// The URL space character. + public static string UrlSpaceCharacter + { + get + { + if (HttpContext != null) + return ConfigurationManager.AppSettings["umbracoUrlSpaceCharacter"]; + return ""; + } + } + + /// + /// Gets the SMTP server IP-address or hostname. + /// + /// The SMTP server. + public static string SmtpServer + { + get + { + try + { + var mailSettings = ConfigurationManager.GetSection("system.net/mailSettings") as System.Net.Configuration.MailSettingsSectionGroup; + + if (mailSettings != null) + return mailSettings.Smtp.Network.Host; + else + return ConfigurationManager.AppSettings["umbracoSmtpServer"]; + } + catch + { + return ""; + } + } + } + + /// + /// Returns a string value to determine if umbraco should disbable xslt extensions + /// + /// "true" if version xslt extensions are disabled, otherwise, "false" + public static string DisableXsltExtensions + { + get + { + if (HttpContext != null) + return ConfigurationManager.AppSettings["umbracoDisableXsltExtensions"]; + return ""; + } + } + + /// + /// Returns a string value to determine if umbraco should use Xhtml editing mode in the wysiwyg editor + /// + /// "true" if Xhtml mode is enable, otherwise, "false" + public static string EditXhtmlMode + { + get + { + if (HttpContext != null) + return ConfigurationManager.AppSettings["umbracoEditXhtmlMode"]; + return ""; + } + } + + /// + /// Gets the default UI language. + /// + /// The default UI language. + public static string DefaultUILanguage + { + get + { + if (HttpContext != null) + return ConfigurationManager.AppSettings["umbracoDefaultUILanguage"]; + return ""; + } + } + + /// + /// Gets the profile URL. + /// + /// The profile URL. + public static string ProfileUrl + { + get + { + if (HttpContext != null) + return ConfigurationManager.AppSettings["umbracoProfileUrl"]; + return ""; + } + } + + /// + /// Gets a value indicating whether umbraco should hide top level nodes from generated urls. + /// + /// + /// true if umbraco hides top level nodes from urls; otherwise, false. + /// + public static bool HideTopLevelNodeFromPath + { + get + { + if (HttpContext != null) + return bool.Parse(ConfigurationManager.AppSettings["umbracoHideTopLevelNodeFromPath"]); + return false; + } + } + + /// + /// Gets the current version. + /// + /// The current version. + public static string CurrentVersion + { + get + { + // change this to be hardcoded in the binary + return CurrentUmbracoVersion; + } + } + + /// + /// Gets the major version number. + /// + /// The major version number. + public static int VersionMajor + { + get + { + string[] version = CurrentVersion.Split(".".ToCharArray()); + return int.Parse(version[0]); + } + } + + /// + /// Gets the minor version number. + /// + /// The minor version number. + public static int VersionMinor + { + get + { + string[] version = CurrentVersion.Split(".".ToCharArray()); + return int.Parse(version[1]); + } + } + + /// + /// Gets the patch version number. + /// + /// The patch version number. + public static int VersionPatch + { + get + { + string[] version = CurrentVersion.Split(".".ToCharArray()); + return int.Parse(version[2]); + } + } + + /// + /// Gets the version comment (like beta or RC). + /// + /// The version comment. + public static string VersionComment + { + get + { + string[] version = CurrentVersion.Split(".".ToCharArray()); + if (version.Length > 3) + return version[3]; + else + return ""; + } + } + + + /// + /// Requests the is in umbraco application directory structure. + /// + /// The context. + /// + public static bool RequestIsInUmbracoApplication(HttpContext context) + { + return context.Request.Path.ToLower().IndexOf(IOHelper.ResolveUrl(SystemDirectories.Umbraco).ToLower()) > -1; + } + + public static bool RequestIsLiveEditRedirector(HttpContext context) + { + return context.Request.Path.ToLower().IndexOf(SystemDirectories.Umbraco.ToLower() + "/liveediting.aspx") > -1; + } + + /// + /// Gets a value indicating whether umbraco should force a secure (https) connection to the backoffice. + /// + /// true if [use SSL]; otherwise, false. + public static bool UseSSL + { + get + { + try + { + return bool.Parse(ConfigurationManager.AppSettings["umbracoUseSSL"]); + } + catch + { + return false; + } + } + } + + /// + /// Gets the umbraco license. + /// + /// The license. + public static string License + { + get + { + string license = + "the open source license MIT. The umbraco UI is freeware licensed under the umbraco license."; + if (HttpContext != null) + { + var versionDoc = new XmlDocument(); + var versionReader = new XmlTextReader(IOHelper.MapPath(SystemDirectories.Umbraco + "/version.xml")); + versionDoc.Load(versionReader); + versionReader.Close(); + + // check for license + try + { + string licenseUrl = + versionDoc.SelectSingleNode("/version/licensing/licenseUrl").FirstChild.Value; + string licenseValidation = + versionDoc.SelectSingleNode("/version/licensing/licenseValidation").FirstChild.Value; + string licensedTo = + versionDoc.SelectSingleNode("/version/licensing/licensedTo").FirstChild.Value; + + if (licensedTo != "" && licenseUrl != "") + { + license = "umbraco Commercial License
Registered to:
" + + licensedTo.Replace("\n", "
") + "
For use with domain:
" + + licenseUrl; + } + } + catch + { + } + } + return license; + } + } + + + /// + /// Developer method to test if configuration settings are loaded properly. + /// + /// true if succesfull; otherwise, false. + internal static bool Test + { + get + { + if (HttpContext != null) + { + HttpContext.Response.Write("ContentXML :" + ContentXml + "\n"); + HttpContext.Response.Write("DbDSN :" + DbDsn + "\n"); + HttpContext.Response.Write("DebugMode :" + DebugMode + "\n"); + HttpContext.Response.Write("DefaultUILanguage :" + DefaultUILanguage + "\n"); + HttpContext.Response.Write("VersionCheckPeriod :" + VersionCheckPeriod + "\n"); + HttpContext.Response.Write("DisableXsltExtensions :" + DisableXsltExtensions + "\n"); + HttpContext.Response.Write("EditXhtmlMode :" + EditXhtmlMode + "\n"); + HttpContext.Response.Write("HideTopLevelNodeFromPath :" + HideTopLevelNodeFromPath + "\n"); + HttpContext.Response.Write("Path :" + Path + "\n"); + HttpContext.Response.Write("ProfileUrl :" + ProfileUrl + "\n"); + HttpContext.Response.Write("ReservedPaths :" + ReservedPaths + "\n"); + HttpContext.Response.Write("ReservedUrls :" + ReservedUrls + "\n"); + HttpContext.Response.Write("StorageDirectory :" + StorageDirectory + "\n"); + HttpContext.Response.Write("TimeOutInMinutes :" + TimeOutInMinutes + "\n"); + HttpContext.Response.Write("UrlForbittenCharacters :" + UrlForbittenCharacters + "\n"); + HttpContext.Response.Write("UrlSpaceCharacter :" + UrlSpaceCharacter + "\n"); + HttpContext.Response.Write("UseDirectoryUrls :" + UseDirectoryUrls + "\n"); + return true; + } + return false; + } + } + + + /// + /// Determines whether the specified URL is reserved or is inside a reserved path. + /// + /// The URL to check. + /// + /// true if the specified URL is reserved; otherwise, false. + /// + public static bool IsReservedPathOrUrl(string url) + { + // check if GlobalSettings.ReservedPaths and GlobalSettings.ReservedUrls are unchanged + if (!object.ReferenceEquals(_reservedPathsCache, GlobalSettings.ReservedPaths) + || !object.ReferenceEquals(_reservedUrlsCache, GlobalSettings.ReservedUrls)) + { + // store references to strings to determine changes + _reservedPathsCache = GlobalSettings.ReservedPaths; + _reservedUrlsCache = GlobalSettings.ReservedUrls; + + string _root = SystemDirectories.Root.Trim().ToLower(); + + // add URLs and paths to a new list + StartsWithContainer _newReservedList = new StartsWithContainer(); + foreach (string reservedUrl in _reservedUrlsCache.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries)) + { + //resolves the url to support tilde chars + string reservedUrlTrimmed = IOHelper.ResolveUrl(reservedUrl).Trim().ToLower(); + if (reservedUrlTrimmed.Length > 0) + _newReservedList.Add(reservedUrlTrimmed); + } + + foreach (string reservedPath in _reservedPathsCache.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries)) + { + bool trimEnd = !reservedPath.EndsWith("/"); + //resolves the url to support tilde chars + string reservedPathTrimmed = IOHelper.ResolveUrl(reservedPath).Trim().ToLower(); + + if (reservedPathTrimmed.Length > 0) + _newReservedList.Add(reservedPathTrimmed + (reservedPathTrimmed.EndsWith("/") ? "" : "/")); + } + + // use the new list from now on + _reservedList = _newReservedList; + } + + string res = ""; + foreach (string st in _reservedList._list.Keys) + res += st + ","; + + Debug.Write("reserverd urls: '" + res + "'"); + + // return true if url starts with an element of the reserved list + return _reservedList.StartsWith(url.ToLower()); + } + + /// + /// Structure that checks in logarithmic time + /// if a given string starts with one of the added keys. + /// + private class StartsWithContainer + { + /// Internal sorted list of keys. + public SortedList _list + = new SortedList(StartsWithComparator.Instance); + + /// + /// Adds the specified new key. + /// + /// The new key. + public void Add(string newKey) + { + // if the list already contains an element that begins with newKey, return + if (String.IsNullOrEmpty(newKey) || StartsWith(newKey)) + return; + + // create a new collection, so the old one can still be accessed + SortedList newList + = new SortedList(_list.Count + 1, StartsWithComparator.Instance); + + // add only keys that don't already start with newKey, others are unnecessary + foreach (string key in _list.Keys) + if (!key.StartsWith(newKey)) + newList.Add(key, null); + // add the new key + newList.Add(newKey, null); + + // update the list (thread safe, _list was never in incomplete state) + _list = newList; + } + + /// + /// Checks if the given string starts with any of the added keys. + /// + /// The target. + /// true if a key is found that matches the start of target + /// + /// Runs in O(s*log(n)), with n the number of keys and s the length of target. + /// + public bool StartsWith(string target) + { + return _list.ContainsKey(target); + } + + /// Comparator that tests if a string starts with another. + /// Not a real comparator, since it is not reflexive. (x==y does not imply y==x) + private sealed class StartsWithComparator : IComparer + { + /// Default string comparer. + private readonly static Comparer _stringComparer = Comparer.Default; + + /// Gets an instance of the StartsWithComparator. + public static readonly StartsWithComparator Instance = new StartsWithComparator(); + + /// + /// Tests if whole begins with all characters of part. + /// + /// The part. + /// The whole. + /// + /// Returns 0 if whole starts with part, otherwise performs standard string comparison. + /// + public int Compare(string part, string whole) + { + // let the default string comparer deal with null or when part is not smaller then whole + if (part == null || whole == null) + return _stringComparer.Compare(part, whole); + + //trim the end '/' of each + part = part.TrimEnd('/'); + whole = whole.TrimEnd('/'); + if (part.Length >= whole.Length) + return _stringComparer.Compare(part, whole); + + // loop through all characters that part and whole have in common + int pos = 0; + bool match; + do + { + match = (part[pos] == whole[pos]); + } while (match && ++pos < part.Length); + + // return result of last comparison + return match ? 0 : (part[pos] < whole[pos] ? -1 : 1); + } + } + } + + } + + + + +} diff --git a/src/Umbraco.Core/Configuration/UmbracoSettings.cs b/src/Umbraco.Core/Configuration/UmbracoSettings.cs new file mode 100644 index 0000000000..268b289e30 --- /dev/null +++ b/src/Umbraco.Core/Configuration/UmbracoSettings.cs @@ -0,0 +1,1303 @@ +using System; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Web; +using System.Web.Caching; +using System.Xml; + +using System.Collections.Generic; + + +namespace Umbraco.Core.Configuration +{ + //NOTE: Do not expose this class ever until we cleanup all configuration including removal of static classes, etc... + // we have this two tasks logged: + // http://issues.umbraco.org/issue/U4-58 + // http://issues.umbraco.org/issue/U4-115 + + //TODO: Re-enable logging !!!! + + /// + /// The UmbracoSettings Class contains general settings information for the entire Umbraco instance based on information from the /config/umbracoSettings.config file + /// + internal class UmbracoSettings + { + internal const string TempFriendlyXmlChildContainerNodename = ""; // "children"; + + /// + /// Gets the umbraco settings document. + /// + /// The _umbraco settings. + internal static XmlDocument UmbracoSettingsXmlDoc + { + get + { + var us = (XmlDocument)HttpRuntime.Cache["umbracoSettingsFile"] ?? EnsureSettingsDocument(); + return us; + } + } + + private static string _path; + + /// + /// Gets/sets the settings file path, the setter can be used in unit tests + /// + internal static string SettingsFilePath + { + get { return _path ?? (_path = GlobalSettings.FullpathToRoot + Path.DirectorySeparatorChar + "config" + Path.DirectorySeparatorChar); } + set { _path = value; } + } + + internal const string Filename = "umbracoSettings.config"; + + internal static XmlDocument EnsureSettingsDocument() + { + var settingsFile = HttpRuntime.Cache["umbracoSettingsFile"]; + + // Check for language file in cache + if (settingsFile == null) + { + var temp = new XmlDocument(); + var settingsReader = new XmlTextReader(SettingsFilePath + Filename); + try + { + temp.Load(settingsReader); + HttpRuntime.Cache.Insert("umbracoSettingsFile", temp, + new CacheDependency(SettingsFilePath + Filename)); + } + catch (XmlException e) + { + throw new XmlException("Your umbracoSettings.config file fails to pass as valid XML. Refer to the InnerException for more information", e); + } + catch (Exception e) + { + Trace.TraceError("Error reading umbracoSettings file: " + e.ToString() + ". ERROR: " + e.Message); + } + settingsReader.Close(); + return temp; + } + else + return (XmlDocument)settingsFile; + } + + internal static void Save() + { + UmbracoSettingsXmlDoc.Save(SettingsFilePath + Filename); + } + + + /// + /// Selects a xml node in the umbraco settings config file. + /// + /// The xpath query to the specific node. + /// If found, it returns the specific configuration xml node. + public static XmlNode GetKeyAsNode(string key) + { + if (key == null) + throw new ArgumentException("Key cannot be null"); + EnsureSettingsDocument(); + if (UmbracoSettingsXmlDoc == null || UmbracoSettingsXmlDoc.DocumentElement == null) + return null; + return UmbracoSettingsXmlDoc.DocumentElement.SelectSingleNode(key); + } + + /// + /// Gets the value of configuration xml node with the specified key. + /// + /// The key. + /// + public static string GetKey(string key) + { + EnsureSettingsDocument(); + + var node = UmbracoSettingsXmlDoc.DocumentElement.SelectSingleNode(key); + if (node == null || node.FirstChild == null || node.FirstChild.Value == null) + return string.Empty; + return node.FirstChild.Value; + } + + /// + /// Gets a value indicating whether the media library will create new directories in the /media directory. + /// + /// + /// true if new directories are allowed otherwise, false. + /// + public static bool UploadAllowDirectories + { + get { return bool.Parse(GetKey("/settings/content/UploadAllowDirectories")); } + } + + /// + /// THIS IS TEMPORARY until we fix up settings all together, this setting is actually not 'settable' but is + /// here for future purposes since we check for thsi settings in the module. + /// + internal static bool EnableBaseRestHandler + { + get { return true; } + } + + /// + /// THIS IS TEMPORARY until we fix up settings all together, this setting is actually not 'settable' but is + /// here for future purposes since we check for thsi settings in the module. + /// + internal static string BootSplashPage + { + get { return "~/default.aspx"; } + } + + /// + /// Gets a value indicating whether logging is enabled in umbracoSettings.config (/settings/logging/enableLogging). + /// + /// true if logging is enabled; otherwise, false. + public static bool EnableLogging + { + get + { + // We return true if no enable logging element is present in + // umbracoSettings (to enable default behaviour when upgrading) + var enableLogging = GetKey("/settings/logging/enableLogging"); + return String.IsNullOrEmpty(enableLogging) || bool.Parse(enableLogging); + } + } + + /// + /// Gets a value indicating whether logging happens async. + /// + /// true if async logging is enabled; otherwise, false. + public static bool EnableAsyncLogging + { + get + { + string value = GetKey("/settings/logging/enableAsyncLogging"); + bool result; + if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out result)) + return result; + return false; + } + } + + /// + /// Gets the assembly of an external logger that can be used to store log items in 3rd party systems + /// + public static string ExternalLoggerAssembly + { + get + { + var value = GetKeyAsNode("/settings/logging/externalLogger"); + return value != null ? value.Attributes["assembly"].Value : ""; + } + } + /// + /// Gets the type of an external logger that can be used to store log items in 3rd party systems + /// + public static string ExternalLoggerType + { + get + { + var value = GetKeyAsNode("/settings/logging/externalLogger"); + return value != null ? value.Attributes["type"].Value : ""; + } + } + + /// + /// Long Audit Trail to external log too + /// + public static bool ExternalLoggerLogAuditTrail + { + get + { + var value = GetKeyAsNode("/settings/logging/externalLogger"); + if (value != null) + { + var logAuditTrail = value.Attributes["logAuditTrail"].Value; + bool result; + if (!string.IsNullOrEmpty(logAuditTrail) && bool.TryParse(logAuditTrail, out result)) + return result; + } + return false; + } + } + + /// + /// Keep user alive as long as they have their browser open? Default is true + /// + public static bool KeepUserLoggedIn + { + get + { + var value = GetKey("/settings/security/keepUserLoggedIn"); + bool result; + if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out result)) + return result; + return true; + } + } + + /// + /// Show disabled users in the tree in the Users section in the backoffice + /// + public static bool HideDisabledUsersInBackoffice + { + get + { + string value = GetKey("/settings/security/hideDisabledUsersInBackoffice"); + bool result; + if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out result)) + return result; + return false; + } + } + + /// + /// Gets a value indicating whether the logs will be auto cleaned + /// + /// true if logs are to be automatically cleaned; otherwise, false + public static bool AutoCleanLogs + { + get + { + string value = GetKey("/settings/logging/autoCleanLogs"); + bool result; + if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out result)) + return result; + return false; + } + } + + /// + /// Gets the value indicating the log cleaning frequency (in miliseconds) + /// + public static int CleaningMiliseconds + { + get + { + string value = GetKey("/settings/logging/cleaningMiliseconds"); + int result; + if (!string.IsNullOrEmpty(value) && int.TryParse(value, out result)) + return result; + return -1; + } + } + + public static int MaxLogAge + { + get + { + string value = GetKey("/settings/logging/maxLogAge"); + int result; + if (!string.IsNullOrEmpty(value) && int.TryParse(value, out result)) + return result; + return -1; + } + } + + /// + /// Gets the disabled log types. + /// + /// The disabled log types. + public static XmlNode DisabledLogTypes + { + get { return GetKeyAsNode("/settings/logging/disabledLogTypes"); } + } + + /// + /// Gets the package server url. + /// + /// The package server url. + public static string PackageServer + { + get { return "packages.umbraco.org"; } + } + + /// + /// Gets a value indicating whether umbraco will use domain prefixes. + /// + /// true if umbraco will use domain prefixes; otherwise, false. + public static bool UseDomainPrefixes + { + get + { + try + { + bool result; + if (bool.TryParse(GetKey("/settings/requestHandler/useDomainPrefixes"), out result)) + return result; + return false; + } + catch + { + return false; + } + } + } + + /// + /// This will add a trailing slash (/) to urls when in directory url mode + /// NOTICE: This will always return false if Directory Urls in not active + /// + public static bool AddTrailingSlash + { + get + { + try + { + if (GlobalSettings.UseDirectoryUrls) + { + bool result; + if (bool.TryParse(GetKey("/settings/requestHandler/addTrailingSlash"), out result)) + return result; + return false; + } + else + { + return false; + } + } + catch + { + return false; + } + } + } + + /// + /// Gets a value indicating whether umbraco will use ASP.NET MasterPages for rendering instead of its propriatary templating system. + /// + /// true if umbraco will use ASP.NET MasterPages; otherwise, false. + public static bool UseAspNetMasterPages + { + get + { + try + { + bool result; + if (bool.TryParse(GetKey("/settings/templates/useAspNetMasterPages"), out result)) + return result; + return false; + } + catch + { + return false; + } + } + } + + + /// + /// Gets a value indicating whether umbraco will attempt to load any skins to override default template files + /// + /// true if umbraco will override templates with skins if present and configured false. + public static bool EnableTemplateFolders + { + get + { + try + { + bool result; + if (bool.TryParse(GetKey("/settings/templates/enableTemplateFolders"), out result)) + return result; + return false; + } + catch + { + return false; + } + } + } + + //TODO: I"m not sure why we need this, need to ask Gareth what the deal is, pretty sure we can remove it or change it, seems like + // massive overkill. + + /// + /// razor DynamicNode typecasting detects XML and returns DynamicXml - Root elements that won't convert to DynamicXml + /// + public static IEnumerable NotDynamicXmlDocumentElements + { + get + { + try + { + List items = new List(); + XmlNode root = GetKeyAsNode("/settings/scripting/razor/notDynamicXmlDocumentElements"); + foreach (XmlNode element in root.SelectNodes(".//element")) + { + items.Add(element.InnerText); + } + return items; + } + catch + { + return new List() { "p", "div" }; + } + } + } + + public static IEnumerable RazorDataTypeModelStaticMapping + { + get + { + if (HttpContext.Current != null && HttpContext.Current.Cache != null && HttpContext.Current.Cache["settings.scripting.razor.dataTypeModelStaticMappings"] != null) + { + return HttpContext.Current.Cache["settings.scripting.razor.dataTypeModelStaticMappings"] as List; + } + /* + + DigibizAdvancedMediaPicker.RazorModel.ModelBinder + DigibizAdvancedMediaPicker.RazorModel.ModelBinder + + */ + List items = new List(); + XmlNode root = GetKeyAsNode("/settings/scripting/razor/dataTypeModelStaticMappings"); + if (root != null) + { + foreach (XmlNode element in root.SelectNodes(".//mapping")) + { + string propertyTypeAlias = null, nodeTypeAlias = null; + Guid? dataTypeGuid = null; + if (!string.IsNullOrEmpty(element.InnerText)) + { + if (element.Attributes["dataTypeGuid"] != null) + { + dataTypeGuid = (Guid?)new Guid(element.Attributes["dataTypeGuid"].Value); + } + if (element.Attributes["propertyTypeAlias"] != null && !string.IsNullOrEmpty(element.Attributes["propertyTypeAlias"].Value)) + { + propertyTypeAlias = element.Attributes["propertyTypeAlias"].Value; + } + if (element.Attributes["nodeTypeAlias"] != null && !string.IsNullOrEmpty(element.Attributes["nodeTypeAlias"].Value)) + { + nodeTypeAlias = element.Attributes["nodeTypeAlias"].Value; + } + items.Add(new RazorDataTypeModelStaticMappingItem() + { + DataTypeGuid = dataTypeGuid, + PropertyTypeAlias = propertyTypeAlias, + NodeTypeAlias = nodeTypeAlias, + TypeName = element.InnerText, + Raw = element.OuterXml + }); + } + } + } + if (HttpContext.Current != null && HttpContext.Current.Cache != null) + { + HttpContext.Current.Cache.Add("settings.scripting.razor.dataTypeModelStaticMappings", items, null, Cache.NoAbsoluteExpiration, new TimeSpan(0, 20, 0), CacheItemPriority.AboveNormal, null); + } + return items; + + } + } + + /// + /// Gets a value indicating whether umbraco will clone XML cache on publish. + /// + /// + /// true if umbraco will clone XML cache on publish; otherwise, false. + /// + public static bool CloneXmlCacheOnPublish + { + get + { + try + { + bool result; + if (bool.TryParse(GetKey("/settings/content/cloneXmlContent"), out result)) + return result; + return false; + } + catch + { + return false; + } + } + } + + /// + /// Gets a value indicating whether rich text editor content should be parsed by tidy. + /// + /// true if content is parsed; otherwise, false. + public static bool TidyEditorContent + { + get { return bool.Parse(GetKey("/settings/content/TidyEditorContent")); } + } + + /// + /// Gets the encoding type for the tidyied content. + /// + /// The encoding type as string. + public static string TidyCharEncoding + { + get + { + string encoding = GetKey("/settings/content/TidyCharEncoding"); + if (String.IsNullOrEmpty(encoding)) + { + encoding = "UTF8"; + } + return encoding; + } + } + + /// + /// Gets the property context help option, this can either be 'text', 'icon' or 'none' + /// + /// The property context help option. + public static string PropertyContextHelpOption + { + get { return GetKey("/settings/content/PropertyContextHelpOption").ToLower(); } + } + + public static string DefaultBackofficeProvider + { + get + { + string defaultProvider = GetKey("/settings/providers/users/DefaultBackofficeProvider"); + if (String.IsNullOrEmpty(defaultProvider)) + defaultProvider = "UsersMembershipProvider"; + + return defaultProvider; + } + } + + /// + /// Whether to force safe aliases (no spaces, no special characters) at businesslogic level on contenttypes and propertytypes + /// + public static bool ForceSafeAliases + { + get + { + string forceSafeAlias = GetKey("/settings/content/ForceSafeAliases"); + if (String.IsNullOrEmpty(forceSafeAlias)) + return true; + else + { + try + { + return bool.Parse(forceSafeAlias); + } + catch + { + return true; + } + } + + } + } + + + /// + /// Gets the allowed image file types. + /// + /// The allowed image file types. + public static string ImageFileTypes + { + get { return GetKey("/settings/content/imaging/imageFileTypes").ToLowerInvariant(); } + } + + /// + /// Gets the allowed script file types. + /// + /// The allowed script file types. + public static string ScriptFileTypes + { + get { return GetKey("/settings/content/scripteditor/scriptFileTypes"); } + } + + /// + /// Gets the duration in seconds to cache queries to umbraco library member and media methods + /// Default is 1800 seconds (30 minutes) + /// + public static int UmbracoLibraryCacheDuration + { + get + { + string libraryCacheDuration = GetKey("/settings/content/UmbracoLibraryCacheDuration"); + if (String.IsNullOrEmpty(libraryCacheDuration)) + return 1800; + else + { + try + { + return int.Parse(libraryCacheDuration); + } + catch + { + return 1800; + } + } + + } + } + + /// + /// Gets the path to the scripts folder used by the script editor. + /// + /// The script folder path. + public static string ScriptFolderPath + { + get { return GetKey("/settings/content/scripteditor/scriptFolderPath"); } + } + + /// + /// Enabled or disable the script/code editor + /// + public static bool ScriptDisableEditor + { + get + { + string _tempValue = GetKey("/settings/content/scripteditor/scriptDisableEditor"); + if (_tempValue != String.Empty) + return bool.Parse(_tempValue); + else + return false; + } + } + + /// + /// Gets the graphic headline format - png or gif + /// + /// The graphic headline format. + public static string GraphicHeadlineFormat + { + get { return GetKey("/settings/content/graphicHeadlineFormat"); } + } + + /// + /// Gets a value indicating whether umbraco will ensure unique node naming. + /// This will ensure that nodes cannot have the same url, but will add extra characters to a url. + /// ex: existingnodename.aspx would become existingnodename(1).aspx if a node with the same name is found + /// + /// true if umbraco ensures unique node naming; otherwise, false. + public static bool EnsureUniqueNaming + { + get + { + try + { + return bool.Parse(GetKey("/settings/content/ensureUniqueNaming")); + } + catch + { + return false; + } + } + } + + /// + /// Gets the notification email sender. + /// + /// The notification email sender. + public static string NotificationEmailSender + { + get { return GetKey("/settings/content/notifications/email"); } + } + + /// + /// Gets a value indicating whether notification-emails are HTML. + /// + /// + /// true if html notification-emails are disabled; otherwise, false. + /// + public static bool NotificationDisableHtmlEmail + { + get + { + var tempValue = GetKey("/settings/content/notifications/disableHtmlEmail"); + return tempValue != String.Empty && bool.Parse(tempValue); + } + } + + /// + /// Gets the allowed attributes on images. + /// + /// The allowed attributes on images. + public static string ImageAllowedAttributes + { + get { return GetKey("/settings/content/imaging/allowedAttributes"); } + } + + public static XmlNode ImageAutoFillImageProperties + { + get { return GetKeyAsNode("/settings/content/imaging/autoFillImageProperties"); } + } + + /// + /// Gets the scheduled tasks as XML + /// + /// The scheduled tasks. + public static XmlNode ScheduledTasks + { + get { return GetKeyAsNode("/settings/scheduledTasks"); } + } + + /// + /// Gets a list of characters that will be replaced when generating urls + /// + /// The URL replacement characters. + public static XmlNode UrlReplaceCharacters + { + get { return GetKeyAsNode("/settings/requestHandler/urlReplacing"); } + } + + /// + /// Whether to replace double dashes from url (ie my--story----from--dash.aspx caused by multiple url replacement chars + /// + public static bool RemoveDoubleDashesFromUrlReplacing + { + get + { + try + { + return bool.Parse(UrlReplaceCharacters.Attributes.GetNamedItem("removeDoubleDashes").Value); + } + catch + { + return false; + } + } + } + + /// + /// Gets a value indicating whether umbraco will use distributed calls. + /// This enables umbraco to share cache and content across multiple servers. + /// Used for load-balancing high-traffic sites. + /// + /// true if umbraco uses distributed calls; otherwise, false. + public static bool UseDistributedCalls + { + get + { + try + { + return bool.Parse(GetKeyAsNode("/settings/distributedCall").Attributes.GetNamedItem("enable").Value); + } + catch + { + return false; + } + } + } + + + /// + /// Gets the ID of the user with access rights to perform the distributed calls. + /// + /// The distributed call user. + public static int DistributedCallUser + { + get + { + try + { + return int.Parse(GetKey("/settings/distributedCall/user")); + } + catch + { + return -1; + } + } + } + + /// + /// Gets the html injected into a (x)html page if Umbraco is running in preview mode + /// + public static string PreviewBadge + { + get + { + try + { + return GetKey("/settings/content/PreviewBadge"); + } + catch + { + return "In Preview Mode - click to end"; + } + } + } + + /// + /// Gets IP or hostnames of the distribution servers. + /// These servers will receive a call everytime content is created/deleted/removed + /// and update their content cache accordingly, ensuring a consistent cache on all servers + /// + /// The distribution servers. + public static XmlNode DistributionServers + { + get + { + try + { + return GetKeyAsNode("/settings/distributedCall/servers"); + } + catch + { + return null; + } + } + } + + /// + /// Gets HelpPage configurations. + /// A help page configuration specify language, user type, application, application url and + /// the target help page url. + /// + public static XmlNode HelpPages + { + get + { + try + { + return GetKeyAsNode("/settings/help"); + } + catch + { + return null; + } + } + } + + /// + /// Gets all repositories registered, and returns them as XmlNodes, containing name, alias and webservice url. + /// These repositories are used by the build-in package installer and uninstaller to install new packages and check for updates. + /// All repositories should have a unique alias. + /// All packages installed from a repository gets the repository alias included in the install information + /// + /// The repository servers. + public static XmlNode Repositories + { + get + { + try + { + return GetKeyAsNode("/settings/repositories"); + } + catch + { + return null; + } + } + } + + /// + /// Gets a value indicating whether umbraco will use the viewstate mover module. + /// The viewstate mover will move all asp.net viewstate information to the bottom of the aspx page + /// to ensure that search engines will index text instead of javascript viewstate information. + /// + /// + /// true if umbraco will use the viewstate mover module; otherwise, false. + /// + public static bool UseViewstateMoverModule + { + get + { + try + { + return + bool.Parse( + GetKeyAsNode("/settings/viewstateMoverModule").Attributes.GetNamedItem("enable").Value); + } + catch + { + return false; + } + } + } + + + /// + /// Tells us whether the Xml Content cache is disabled or not + /// Default is enabled + /// + public static bool IsXmlContentCacheDisabled + { + get + { + try + { + bool xmlCacheEnabled; + string value = GetKey("/settings/content/XmlCacheEnabled"); + if (bool.TryParse(value, out xmlCacheEnabled)) + return !xmlCacheEnabled; + // Return default + return false; + } + catch + { + return false; + } + } + } + + /// + /// Check if there's changes to the umbraco.config xml file cache on disk on each request + /// Makes it possible to updates environments by syncing the umbraco.config file across instances + /// Relates to http://umbraco.codeplex.com/workitem/30722 + /// + public static bool XmlContentCheckForDiskChanges + { + get + { + try + { + bool checkForDiskChanges; + string value = GetKey("/settings/content/XmlContentCheckForDiskChanges"); + if (bool.TryParse(value, out checkForDiskChanges)) + return checkForDiskChanges; + // Return default + return false; + } + catch + { + return false; + } + } + } + + /// + /// If this is enabled, all Umbraco objects will generate data in the preview table (cmsPreviewXml). + /// If disabled, only documents will generate data. + /// This feature is useful if anyone would like to see how data looked at a given time + /// + public static bool EnableGlobalPreviewStorage + { + get + { + try + { + bool globalPreviewEnabled = false; + string value = GetKey("/settings/content/GlobalPreviewStorageEnabled"); + if (bool.TryParse(value, out globalPreviewEnabled)) + return !globalPreviewEnabled; + // Return default + return false; + } + catch + { + return false; + } + } + } + + /// + /// Whether to use the new 4.1 schema or the old legacy schema + /// + /// + /// true if yes, use the old node/data model; otherwise, false. + /// + public static bool UseLegacyXmlSchema + { + get + { + try + { + string value = GetKey("/settings/content/UseLegacyXmlSchema"); + bool result; + if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out result)) + return result; + return true; + } + catch (Exception) + { + //default. TODO: When we change this to a real config section we won't have to worry about parse errors + // and should handle defaults with unit tests properly. + return false; + } + } + } + + [Obsolete("This setting is not used anymore, the only file extensions that are supported are .cs and .vb files")] + public static IEnumerable AppCodeFileExtensionsList + { + get + { + return (from XmlNode x in AppCodeFileExtensions + where !String.IsNullOrEmpty(x.InnerText) + select x.InnerText).ToList(); + } + } + + [Obsolete("This setting is not used anymore, the only file extensions that are supported are .cs and .vb files")] + public static XmlNode AppCodeFileExtensions + { + get + { + XmlNode value = GetKeyAsNode("/settings/developer/appCodeFileExtensions"); + if (value != null) + { + return value; + } + + // default is .cs and .vb + value = UmbracoSettingsXmlDoc.CreateElement("appCodeFileExtensions"); + value.AppendChild(XmlHelper.AddTextNode(UmbracoSettingsXmlDoc, "ext", "cs")); + value.AppendChild(XmlHelper.AddTextNode(UmbracoSettingsXmlDoc, "ext", "vb")); + return value; + } + } + + /// + /// Tells us whether the Xml to always update disk cache, when changes are made to content + /// Default is enabled + /// + public static bool ContinouslyUpdateXmlDiskCache + { + get + { + try + { + bool updateDiskCache; + string value = GetKey("/settings/content/ContinouslyUpdateXmlDiskCache"); + if (bool.TryParse(value, out updateDiskCache)) + return updateDiskCache; + // Return default + return false; + } + catch + { + return true; + } + } + } + + /// + /// Tells us whether to use a splash page while umbraco is initializing content. + /// If not, requests are queued while umbraco loads content. For very large sites (+10k nodes) it might be usefull to + /// have a splash page + /// Default is disabled + /// + public static bool EnableSplashWhileLoading + { + get + { + try + { + bool updateDiskCache; + string value = GetKey("/settings/content/EnableSplashWhileLoading"); + if (bool.TryParse(value, out updateDiskCache)) + return updateDiskCache; + // Return default + return false; + } + catch + { + return false; + } + } + } + + private static bool? _resolveUrlsFromTextString; + public static bool ResolveUrlsFromTextString + { + get + { + if (_resolveUrlsFromTextString == null) + { + try + { + bool enableDictionaryFallBack; + var value = GetKey("/settings/content/ResolveUrlsFromTextString"); + if (value != null) + if (bool.TryParse(value, out enableDictionaryFallBack)) + _resolveUrlsFromTextString = enableDictionaryFallBack; + } + catch (Exception ex) + { + Trace.WriteLine("Could not load /settings/content/ResolveUrlsFromTextString from umbracosettings.config:\r\n {0}", + ex.Message); + + // set url resolving to true (default (legacy) behavior) to ensure we don't keep writing to trace + _resolveUrlsFromTextString = true; + } + } + return _resolveUrlsFromTextString == true; + } + } + + /// + /// Configuration regarding webservices + /// + /// Put in seperate class for more logik/seperation + internal class WebServices + { + /// + /// Gets a value indicating whether this is enabled. + /// + /// true if enabled; otherwise, false. + public static bool Enabled + { + get + { + try + { + return + bool.Parse(GetKeyAsNode("/settings/webservices").Attributes.GetNamedItem("enabled").Value); + } + catch + { + return false; + } + } + } + + #region "Webservice configuration" + + /// + /// Gets the document service users who have access to use the document web service + /// + /// The document service users. + public static string[] DocumentServiceUsers + { + get + { + try + { + return GetKey("/settings/webservices/documentServiceUsers").Split(','); + } + catch + { + return new string[0]; + } + } + } + + /// + /// Gets the file service users who have access to use the file web service + /// + /// The file service users. + public static string[] FileServiceUsers + { + get + { + try + { + return GetKey("/settings/webservices/fileServiceUsers").Split(','); + } + catch + { + return new string[0]; + } + } + } + + + /// + /// Gets the folders used by the file web service + /// + /// The file service folders. + public static string[] FileServiceFolders + { + get + { + try + { + return GetKey("/settings/webservices/fileServiceFolders").Split(','); + } + catch + { + return new string[0]; + } + } + } + + /// + /// Gets the member service users who have access to use the member web service + /// + /// The member service users. + public static string[] MemberServiceUsers + { + get + { + try + { + return GetKey("/settings/webservices/memberServiceUsers").Split(','); + } + catch + { + return new string[0]; + } + } + } + + /// + /// Gets the stylesheet service users who have access to use the stylesheet web service + /// + /// The stylesheet service users. + public static string[] StylesheetServiceUsers + { + get + { + try + { + return GetKey("/settings/webservices/stylesheetServiceUsers").Split(','); + } + catch + { + return new string[0]; + } + } + } + + /// + /// Gets the template service users who have access to use the template web service + /// + /// The template service users. + public static string[] TemplateServiceUsers + { + get + { + try + { + return GetKey("/settings/webservices/templateServiceUsers").Split(','); + } + catch + { + return new string[0]; + } + } + } + + /// + /// Gets the media service users who have access to use the media web service + /// + /// The media service users. + public static string[] MediaServiceUsers + { + get + { + try + { + return GetKey("/settings/webservices/mediaServiceUsers").Split(','); + } + catch + { + return new string[0]; + } + } + } + + + /// + /// Gets the maintenance service users who have access to use the maintance web service + /// + /// The maintenance service users. + public static string[] MaintenanceServiceUsers + { + get + { + try + { + return GetKey("/settings/webservices/maintenanceServiceUsers").Split(','); + } + catch + { + return new string[0]; + } + } + } + + #endregion + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/IO/FileSecurityException.cs b/src/Umbraco.Core/IO/FileSecurityException.cs new file mode 100644 index 0000000000..8358b5efd2 --- /dev/null +++ b/src/Umbraco.Core/IO/FileSecurityException.cs @@ -0,0 +1,20 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Umbraco.Core.IO +{ + public class FileSecurityException : Exception + { + public FileSecurityException() + { + + } + + public FileSecurityException(string message) : base(message) + { + + } + } +} diff --git a/src/Umbraco.Core/IO/IOHelper.cs b/src/Umbraco.Core/IO/IOHelper.cs new file mode 100644 index 0000000000..c0734898d6 --- /dev/null +++ b/src/Umbraco.Core/IO/IOHelper.cs @@ -0,0 +1,206 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Reflection; +using System.Text; +using System.IO; +using System.Configuration; +using System.Web; +using System.Text.RegularExpressions; +using Umbraco.Core.Configuration; + +namespace Umbraco.Core.IO +{ + internal static class IOHelper + { + private static string _rootDir = ""; + // static compiled regex for faster performance + private readonly static Regex ResolveUrlPattern = new Regex("(=[\"\']?)(\\W?\\~(?:.(?![\"\']?\\s+(?:\\S+)=|[>\"\']))+.)[\"\']?", RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace); + + public static char DirSepChar + { + get + { + return Path.DirectorySeparatorChar; + } + } + + //helper to try and match the old path to a new virtual one + public static string FindFile(string virtualPath) + { + string retval = virtualPath; + + if (virtualPath.StartsWith("~")) + retval = virtualPath.Replace("~", SystemDirectories.Root); + + if (virtualPath.StartsWith("/") && !virtualPath.StartsWith(SystemDirectories.Root)) + retval = SystemDirectories.Root + "/" + virtualPath.TrimStart('/'); + + return retval; + } + + //Replaces tildes with the root dir + public static string ResolveUrl(string virtualPath) + { + if (virtualPath.StartsWith("~")) + return virtualPath.Replace("~", SystemDirectories.Root).Replace("//", "/"); + else + return VirtualPathUtility.ToAbsolute(virtualPath, SystemDirectories.Root); + } + + + public static string ResolveUrlsFromTextString(string text) + { + if (UmbracoSettings.ResolveUrlsFromTextString) + { + var sw = new Stopwatch(); + sw.Start(); + Debug.WriteLine("Start: " + sw.ElapsedMilliseconds); + + // find all relative urls (ie. urls that contain ~) + var tags = + ResolveUrlPattern.Matches(text); + Debug.WriteLine("After regex: " + sw.ElapsedMilliseconds); + foreach (Match tag in tags) + { + Debug.WriteLine("-- inside regex: " + sw.ElapsedMilliseconds); + string url = ""; + if (tag.Groups[1].Success) + url = tag.Groups[1].Value; + + // The richtext editor inserts a slash in front of the url. That's why we need this little fix + // if (url.StartsWith("/")) + // text = text.Replace(url, ResolveUrl(url.Substring(1))); + // else + if (!String.IsNullOrEmpty(url)) + { + Debug.WriteLine("---- before resolve: " + sw.ElapsedMilliseconds); + string resolvedUrl = (url.Substring(0, 1) == "/") ? ResolveUrl(url.Substring(1)) : ResolveUrl(url); + Debug.WriteLine("---- after resolve: " + sw.ElapsedMilliseconds); + Debug.WriteLine("---- before replace: " + sw.ElapsedMilliseconds); + text = text.Replace(url, resolvedUrl); + Debug.WriteLine("---- after replace: " + sw.ElapsedMilliseconds); + } + + } + + Debug.WriteLine("total: " + sw.ElapsedMilliseconds); + sw.Stop(); + Debug.WriteLine("Resolve Urls", sw.ElapsedMilliseconds.ToString()); + + } + return text; + } + + public static string MapPath(string path, bool useHttpContext) + { + // Check if the path is already mapped + if (path.Length >= 2 && path[1] == Path.VolumeSeparatorChar) + return path; + + // Check that we even have an HttpContext! otherwise things will fail anyways + // http://umbraco.codeplex.com/workitem/30946 + + if (useHttpContext && HttpContext.Current != null) + { + //string retval; + if (!string.IsNullOrEmpty(path) && (path.StartsWith("~") || path.StartsWith(SystemDirectories.Root))) + return System.Web.Hosting.HostingEnvironment.MapPath(path); + else + return System.Web.Hosting.HostingEnvironment.MapPath("~/" + path.TrimStart('/')); + } + + //var root = (!string.IsNullOrEmpty(System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath)) + // ? System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath.TrimEnd(IOHelper.DirSepChar) + // : getRootDirectorySafe(); + + var root = GetRootDirectorySafe(); + var newPath = path.TrimStart('~', '/').Replace('/', IOHelper.DirSepChar); + var retval = root + IOHelper.DirSepChar.ToString() + newPath; + + return retval; + } + + public static string MapPath(string path) + { + return MapPath(path, true); + } + + //use a tilde character instead of the complete path + public static string ReturnPath(string settingsKey, string standardPath, bool useTilde) + { + string retval = ConfigurationManager.AppSettings[settingsKey]; + + if (string.IsNullOrEmpty(retval)) + retval = standardPath; + + return retval.TrimEnd('/'); + } + + + public static string ReturnPath(string settingsKey, string standardPath) + { + return ReturnPath(settingsKey, standardPath, false); + + } + + + /// + /// Validates if the current filepath matches a directory where the user is allowed to edit a file + /// + /// filepath + /// + /// true if valid, throws a FileSecurityException if not + public static bool ValidateEditPath(string filePath, string validDir) + { + if (!filePath.StartsWith(MapPath(SystemDirectories.Root))) + filePath = MapPath(filePath); + if (!validDir.StartsWith(MapPath(SystemDirectories.Root))) + validDir = MapPath(validDir); + + if (!filePath.StartsWith(validDir)) + throw new FileSecurityException(String.Format("The filepath '{0}' is not within an allowed directory for this type of files", filePath.Replace(MapPath(SystemDirectories.Root), ""))); + + return true; + } + + public static bool ValidateFileExtension(string filePath, List validFileExtensions) + { + if (!filePath.StartsWith(MapPath(SystemDirectories.Root))) + filePath = MapPath(filePath); + var f = new FileInfo(filePath); + + + if (!validFileExtensions.Contains(f.Extension.Substring(1))) + throw new FileSecurityException(String.Format("The extension for the current file '{0}' is not of an allowed type for this editor. This is typically controlled from either the installed MacroEngines or based on configuration in /config/umbracoSettings.config", filePath.Replace(MapPath(SystemDirectories.Root), ""))); + + return true; + } + + + /// + /// Returns the path to the root of the application, by getting the path to where the assembly where this + /// method is included is present, then traversing until it's past the /bin directory. Ie. this makes it work + /// even if the assembly is in a /bin/debug or /bin/release folder + /// + /// + internal static string GetRootDirectorySafe() + { + if (!String.IsNullOrEmpty(_rootDir)) + { + return _rootDir; + } + + var codeBase = Assembly.GetExecutingAssembly().CodeBase; + var uri = new Uri(codeBase); + var path = uri.LocalPath; + var baseDirectory = Path.GetDirectoryName(path); + _rootDir = baseDirectory.Substring(0, baseDirectory.LastIndexOf("bin") - 1); + + return _rootDir; + + } + + } +} diff --git a/src/Umbraco.Core/IO/IMediaFileSystemExtensions.cs b/src/Umbraco.Core/IO/MediaFileSystemExtensions.cs similarity index 90% rename from src/Umbraco.Core/IO/IMediaFileSystemExtensions.cs rename to src/Umbraco.Core/IO/MediaFileSystemExtensions.cs index 5201923dbf..02c031608d 100644 --- a/src/Umbraco.Core/IO/IMediaFileSystemExtensions.cs +++ b/src/Umbraco.Core/IO/MediaFileSystemExtensions.cs @@ -3,11 +3,11 @@ using System.Collections.Generic; using System.IO; using System.Linq; using System.Text; -using umbraco; +using Umbraco.Core.Configuration; namespace Umbraco.Core.IO { - public static class IMediaFileSystemExtensions + public static class MediaFileSystemExtensions { internal static string GetRelativePath(this IMediaFileSystem fs, int propertyId, string fileName) { diff --git a/src/Umbraco.Core/IO/SystemDirectories.cs b/src/Umbraco.Core/IO/SystemDirectories.cs new file mode 100644 index 0000000000..3ee99750d2 --- /dev/null +++ b/src/Umbraco.Core/IO/SystemDirectories.cs @@ -0,0 +1,181 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Configuration; + +using System.Web; +using System.IO; + +namespace Umbraco.Core.IO +{ + //all paths has a starting but no trailing / + internal class SystemDirectories + { + public static string Bin + { + get + { + return IOHelper.ReturnPath("umbracoBinDirectory", "~/bin"); + } + } + + public static string Base + { + get + { + return IOHelper.ReturnPath("umbracoBaseDirectory", "~/base"); + } + } + + public static string Config + { + get + { + return IOHelper.ReturnPath("umbracoConfigDirectory", "~/config"); + } + } + + public static string Css + { + get + { + return IOHelper.ReturnPath("umbracoCssDirectory", "~/css"); + } + } + + public static string Data + { + get + { + return IOHelper.ReturnPath("umbracoStorageDirectory", "~/App_Data"); + } + } + + public static string Install + { + get + { + return IOHelper.ReturnPath("umbracoInstallPath", "~/install"); + } + } + + public static string Masterpages + { + get + { + return IOHelper.ReturnPath("umbracoMasterPagesPath", "~/masterpages"); + } + } + + + public static string Media + { + get + { + return IOHelper.ReturnPath("umbracoMediaPath", "~/media"); + } + } + + [Obsolete("Please use MacroScripts instead!", true)] + public static string Python + { + get + { + return MacroScripts; + } + } + + public static string MacroScripts + { + get + { + // for legacy we test for the python path first, but else we use the new default location + string tempPath = IOHelper.ReturnPath("umbracoPythonPath", "") == String.Empty + ? IOHelper.ReturnPath("umbracoMacroScriptPath", "~/macroScripts") + : IOHelper.ReturnPath("umbracoPythonPath", "~/python"); + return tempPath; + } + } + + public static string Scripts + { + get + { + return IOHelper.ReturnPath("umbracoScriptsPath", "~/scripts"); + } + } + + public static string Umbraco + { + get + { + return IOHelper.ReturnPath("umbracoPath", "~/umbraco"); + } + } + + public static string UmbracoClient + { + get + { + return IOHelper.ReturnPath("umbracoClientPath", "~/umbraco_client"); + } + } + + public static string UserControls + { + get + { + return IOHelper.ReturnPath("umbracoUsercontrolsPath", "~/usercontrols"); + } + } + + public static string WebServices + { + get + { + return IOHelper.ReturnPath("umbracoWebservicesPath", "~/umbraco/webservices"); + } + } + + public static string Xslt + { + get { + return IOHelper.ReturnPath("umbracoXsltPath", "~/xslt"); + } + } + + public static string Packages + { + get + { + //by default the packages folder should exist in the data folder + return IOHelper.ReturnPath("umbracoPackagesPath", Data + IOHelper.DirSepChar + "packages"); + } + } + + public static string Preview + { + get + { + //by default the packages folder should exist in the data folder + return IOHelper.ReturnPath("umbracoPreviewPath", Data + IOHelper.DirSepChar + "preview"); + } + } + + public static string Root + { + get + { + string appPath = HttpRuntime.AppDomainAppVirtualPath ?? string.Empty; + if (appPath == "/") + appPath = string.Empty; + + return appPath; + } + } + } + + + +} diff --git a/src/Umbraco.Core/IO/SystemFiles.cs b/src/Umbraco.Core/IO/SystemFiles.cs new file mode 100644 index 0000000000..59b2debf0a --- /dev/null +++ b/src/Umbraco.Core/IO/SystemFiles.cs @@ -0,0 +1,122 @@ +using System; +using System.Collections.Generic; +using System.Configuration; +using System.IO; +using System.Linq; +using System.Text; +using System.Web; + +namespace Umbraco.Core.IO +{ + internal class SystemFiles + { + + public static string AccessXml + { + get + { + return SystemDirectories.Data + "/access.config"; + } + } + + public static string CreateUiXml + { + get + { + return SystemDirectories.Umbraco + "/config/create/UI.xml"; + } + } + + public static string TinyMceConfig + { + get + { + return SystemDirectories.Config + "/tinyMceConfig.config"; + } + } + + public static string MetablogConfig + { + get + { + return SystemDirectories.Config + "/metablogConfig.config"; + } + } + + public static string DashboardConfig + { + get + { + return SystemDirectories.Config + "/dashboard.config"; + } + } + + public static string XsltextensionsConfig + { + get + { + return SystemDirectories.Config + "/xsltextensions.config"; + } + } + + public static string RestextensionsConfig + { + get + { + return SystemDirectories.Config + "/restextensions.config"; + } + } + + + public static string SkinningXml + { + get + { + return SystemDirectories.Data + "/skinning.config"; + } + } + + public static string NotFoundhandlersConfig + { + get + { + return SystemDirectories.Config + "/404handlers.config"; + } + } + + public static string FeedProxyConfig + { + get + { + return string.Concat(SystemDirectories.Config, "/feedProxy.config"); + } + } + + public static string ContentCacheXml + { + get + { + if (ContentCacheXmlIsEphemeral) + { + return Path.Combine(HttpRuntime.CodegenDir, @"UmbracoData\umbraco.config"); + } + return IOHelper.ReturnPath("umbracoContentXML", "~/App_Data/umbraco.config"); + } + } + + public static bool ContentCacheXmlIsEphemeral + { + get + { + bool returnValue = false; + string configSetting = ConfigurationManager.AppSettings["umbracoContentXMLUseLocalTemp"]; + + if (!string.IsNullOrEmpty(configSetting)) + if(bool.TryParse(configSetting, out returnValue)) + return returnValue; + + return false; + } + } + } +} diff --git a/src/Umbraco.Core/RazorDataTypeModelStaticMappingItem.cs b/src/Umbraco.Core/RazorDataTypeModelStaticMappingItem.cs new file mode 100644 index 0000000000..7cc24bc5b3 --- /dev/null +++ b/src/Umbraco.Core/RazorDataTypeModelStaticMappingItem.cs @@ -0,0 +1,31 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Umbraco.Core +{ + //NOTE: I'm not sure what this does or what it is used for, have emailed Gareth about it as the name really means nothing to me + // and don't know where this class actually belongs. + + internal class RazorDataTypeModelStaticMappingItem + { + public string Raw { get; set; } + //if all of the set (non null) properties match the property data currently being evaluated + public string PropertyTypeAlias { get; set; } + public string NodeTypeAlias { get; set; } + public Guid? DataTypeGuid { get; set; } + public string TypeName { get; set; } + + public bool Applies(Guid dataTypeGuid, string nodeTypeAlias, string propertyTypeAlias) + { + return + ( + (this.NodeTypeAlias != null || this.PropertyTypeAlias != null || this.DataTypeGuid != null) && + ((this.DataTypeGuid != null && this.DataTypeGuid == dataTypeGuid) || this.DataTypeGuid == null) && + ((this.PropertyTypeAlias != null && this.PropertyTypeAlias == propertyTypeAlias) || this.PropertyTypeAlias == null) && + ((this.NodeTypeAlias != null && this.NodeTypeAlias == nodeTypeAlias) || this.NodeTypeAlias == null) + ); + } + } +} diff --git a/src/Umbraco.Core/SystemUtilities.cs b/src/Umbraco.Core/SystemUtilities.cs new file mode 100644 index 0000000000..5146aade59 --- /dev/null +++ b/src/Umbraco.Core/SystemUtilities.cs @@ -0,0 +1,40 @@ +using System.Security; +using System.Web; + +namespace Umbraco.Core +{ + /// + /// Static helper methods for returning information about the current System + /// + public static class SystemUtilities + { + + /// + /// Get the current trust level of the hosted application + /// + /// + public static AspNetHostingPermissionLevel GetCurrentTrustLevel() + { + foreach (var trustLevel in new[] { + AspNetHostingPermissionLevel.Unrestricted, + AspNetHostingPermissionLevel.High, + AspNetHostingPermissionLevel.Medium, + AspNetHostingPermissionLevel.Low, + AspNetHostingPermissionLevel.Minimal }) + { + try + { + new AspNetHostingPermission(trustLevel).Demand(); + } + catch (SecurityException) + { + continue; + } + + return trustLevel; + } + + return AspNetHostingPermissionLevel.None; + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj index a523522d6e..4107c7258a 100644 --- a/src/Umbraco.Core/Umbraco.Core.csproj +++ b/src/Umbraco.Core/Umbraco.Core.csproj @@ -48,31 +48,34 @@ + + + - + + + + + + - - - - {E469A9CE-1BEC-423F-AC44-713CD72457EA} - umbraco.businesslogic - + ", "", "]]>"); + } + + /// + /// Determines whether the specified string appears to be XML. + /// + /// The XML string. + /// + /// true if the specified string appears to be XML; otherwise, false. + /// + public static bool CouldItBeXml(string xml) + { + if (!string.IsNullOrEmpty(xml)) + { + xml = xml.Trim(); + + if (xml.StartsWith("<") && xml.EndsWith(">")) + { + return true; + } + } + + return false; + } + + /// + /// Splits the specified delimited string into an XML document. + /// + /// The data. + /// The separator. + /// Name of the root. + /// Name of the element. + /// Returns an System.Xml.XmlDocument representation of the delimited string data. + public static XmlDocument Split(string data, string[] separator, string rootName, string elementName) + { + return Split(new XmlDocument(), data, separator, rootName, elementName); + } + + /// + /// Splits the specified delimited string into an XML document. + /// + /// The XML document. + /// The delimited string data. + /// The separator. + /// Name of the root node. + /// Name of the element node. + /// Returns an System.Xml.XmlDocument representation of the delimited string data. + public static XmlDocument Split(XmlDocument xml, string data, string[] separator, string rootName, string elementName) + { + // load new XML document. + xml.LoadXml(string.Concat("<", rootName, "/>")); + + // get the data-value, check it isn't empty. + if (!string.IsNullOrEmpty(data)) + { + // explode the values into an array + var values = data.Split(separator, StringSplitOptions.None); + + // loop through the array items. + foreach (string value in values) + { + // add each value to the XML document. + var xn = XmlHelper.AddTextNode(xml, elementName, value); + xml.DocumentElement.AppendChild(xn); + } + } + + // return the XML node. + return xml; + } + } +} diff --git a/src/umbraco.businesslogic/Exceptions/FileSecurityException.cs b/src/umbraco.businesslogic/Exceptions/FileSecurityException.cs index 407c117d5d..1b9f084003 100644 --- a/src/umbraco.businesslogic/Exceptions/FileSecurityException.cs +++ b/src/umbraco.businesslogic/Exceptions/FileSecurityException.cs @@ -5,14 +5,17 @@ using System.Text; namespace umbraco.businesslogic.Exceptions { - public class FileSecurityException : Exception + [Obsolete("This class has been superceded by Umbraco.Core.UI.FileSecurityException")] + public class FileSecurityException : Umbraco.Core.IO.FileSecurityException { public FileSecurityException() + : base() { } - public FileSecurityException(string message) : base(message) + public FileSecurityException(string message) + : base(message) { } diff --git a/src/umbraco.businesslogic/GlobalSettings.cs b/src/umbraco.businesslogic/GlobalSettings.cs index 9c67f39976..00e312ea08 100644 --- a/src/umbraco.businesslogic/GlobalSettings.cs +++ b/src/umbraco.businesslogic/GlobalSettings.cs @@ -16,34 +16,14 @@ namespace umbraco /// public class GlobalSettings { - #region Private static fields - // CURRENT UMBRACO VERSION ID - private static string _currentVersion = "4.9.0"; - - private static string _reservedUrlsCache; - private static string _reservedPathsCache; - private static StartsWithContainer _reservedList = new StartsWithContainer(); - #endregion - - /// - /// Initializes a new instance of the class. - /// - public GlobalSettings() - { - } - - /// + + /// /// Gets the reserved urls from web.config. /// /// The reserved urls. public static string ReservedUrls { - get - { - if (HttpContext.Current != null) - return ConfigurationManager.AppSettings["umbracoReservedUrls"]; - return String.Empty; - } + get { return Umbraco.Core.Configuration.GlobalSettings.ReservedUrls; } } /// @@ -52,12 +32,7 @@ namespace umbraco /// The reserved paths. public static string ReservedPaths { - get - { - if (HttpContext.Current != null) - return ConfigurationManager.AppSettings["umbracoReservedPaths"]; - return String.Empty; - } + get { return Umbraco.Core.Configuration.GlobalSettings.ReservedPaths; } } /// @@ -66,17 +41,7 @@ namespace umbraco /// The content XML. public static string ContentXML { - get - { - try - { - return ConfigurationManager.AppSettings["umbracoContentXML"]; - } - catch - { - return String.Empty; - } - } + get { return Umbraco.Core.Configuration.GlobalSettings.ContentXml; } } /// @@ -85,17 +50,7 @@ namespace umbraco /// The storage directory. public static string StorageDirectory { - get - { - try - { - return ConfigurationManager.AppSettings["umbracoStorageDirectory"]; - } - catch - { - return String.Empty; - } - } + get { return Umbraco.Core.Configuration.GlobalSettings.StorageDirectory; } } /// @@ -104,18 +59,7 @@ namespace umbraco /// The path. public static string Path { - get - { - - try - { - return IOHelper.ResolveUrl(ConfigurationManager.AppSettings["umbracoPath"]); - } - catch - { - return String.Empty; - } - } + get { return Umbraco.Core.Configuration.GlobalSettings.Path; } } /// @@ -126,10 +70,7 @@ namespace umbraco /// The path. public static string ClientPath { - get - { - return Path + "/../umbraco_client"; - } + get { return Umbraco.Core.Configuration.GlobalSettings.ClientPath; } } /// @@ -138,24 +79,8 @@ namespace umbraco /// The database connection string. public static string DbDSN { - get - { - try - { - return ConfigurationManager.AppSettings["umbracoDbDSN"]; - } - catch - { - return String.Empty; - } - } - set - { - if (DbDSN != value) - { - SaveSetting("umbracoDbDSN", value); - } - } + get { return Umbraco.Core.Configuration.GlobalSettings.DbDsn; } + set { Umbraco.Core.Configuration.GlobalSettings.DbDsn = value; } } /// @@ -164,57 +89,13 @@ namespace umbraco /// The configuration status. public static string ConfigurationStatus { - get - { - try - { - return ConfigurationManager.AppSettings["umbracoConfigurationStatus"]; - } - catch - { - return String.Empty; - } - } - set - { - SaveSetting("umbracoConfigurationStatus", value); - } + get { return Umbraco.Core.Configuration.GlobalSettings.ConfigurationStatus; } + set { Umbraco.Core.Configuration.GlobalSettings.ConfigurationStatus = value; } } - private static AspNetHostingPermissionLevel? m_ApplicationTrustLevel = null; public static AspNetHostingPermissionLevel ApplicationTrustLevel { - get - { - if (!m_ApplicationTrustLevel.HasValue) - { - //set minimum - m_ApplicationTrustLevel = AspNetHostingPermissionLevel.None; - - //determine maximum - foreach (AspNetHostingPermissionLevel trustLevel in - new AspNetHostingPermissionLevel[] { - AspNetHostingPermissionLevel.Unrestricted, - AspNetHostingPermissionLevel.High, - AspNetHostingPermissionLevel.Medium, - AspNetHostingPermissionLevel.Low, - AspNetHostingPermissionLevel.Minimal - }) - { - try - { - new AspNetHostingPermission(trustLevel).Demand(); - m_ApplicationTrustLevel = trustLevel; - break; //we've set the highest permission we can - } - catch (System.Security.SecurityException) - { - continue; - } - } - } - return m_ApplicationTrustLevel.Value; - } + get { return Umbraco.Core.SystemUtilities.GetCurrentTrustLevel(); } } @@ -224,20 +105,7 @@ namespace umbraco /// If true, umbraco will be medium-trust compatible, no matter what Permission level the server is on. public static bool UseMediumTrust { - get - { - try - { - if (ApplicationTrustLevel == AspNetHostingPermissionLevel.High || ApplicationTrustLevel == AspNetHostingPermissionLevel.Unrestricted) - return false; - else - return bool.Parse(ConfigurationManager.AppSettings["umbracoUseMediumTrust"]); - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.GlobalSettings.UseMediumTrust; } } /// @@ -247,24 +115,7 @@ namespace umbraco /// Value of the setting to be saved. protected static void SaveSetting(string key, string value) { - WebConfigurationFileMap webConfig = new WebConfigurationFileMap(); - var vDirs = webConfig.VirtualDirectories; - var vDir = FullpathToRoot; - foreach (VirtualDirectoryMapping v in webConfig.VirtualDirectories) - { - if (v.IsAppRoot) - { - vDir = v.PhysicalDirectory; - } - } - - XmlDocument doc = new XmlDocument(); - doc.Load(String.Concat(vDir, "web.config")); - XmlNode root = doc.DocumentElement; - XmlNode setting = doc.SelectSingleNode(String.Concat("//appSettings/add[@key='", key, "']")); - setting.Attributes["value"].InnerText = value; - doc.Save(String.Concat(vDir, "web.config")); - ConfigurationManager.RefreshSection("appSettings"); + Umbraco.Core.Configuration.GlobalSettings.SaveSetting(key, value); } /// @@ -273,7 +124,7 @@ namespace umbraco /// The fullpath to root. public static string FullpathToRoot { - get { return HttpRuntime.AppDomainAppPath; } + get { return Umbraco.Core.Configuration.GlobalSettings.FullpathToRoot; } } /// @@ -282,17 +133,7 @@ namespace umbraco /// true if [debug mode]; otherwise, false. public static bool DebugMode { - get - { - try - { - return bool.Parse(ConfigurationManager.AppSettings["umbracoDebugMode"]); - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.GlobalSettings.DebugMode; } } /// @@ -301,26 +142,7 @@ namespace umbraco /// true if configured; otherwise, false. public static bool Configured { - get - { - try - { - string configStatus = ConfigurationStatus; - string currentVersion = CurrentVersion; - - - if (currentVersion != configStatus) - Log.Add(LogTypes.Debug, User.GetUser(0), -1, - "CurrentVersion different from configStatus: '" + currentVersion + "','" + configStatus + - "'"); - - return (configStatus == currentVersion); - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.GlobalSettings.Configured; } } /// @@ -329,17 +151,7 @@ namespace umbraco /// The time out in minutes. public static int TimeOutInMinutes { - get - { - try - { - return int.Parse(ConfigurationManager.AppSettings["umbracoTimeOutInMinutes"]); - } - catch - { - return 20; - } - } + get { return Umbraco.Core.Configuration.GlobalSettings.TimeOutInMinutes; } } /// @@ -348,17 +160,7 @@ namespace umbraco /// true if umbraco uses directory urls; otherwise, false. public static bool UseDirectoryUrls { - get - { - try - { - return bool.Parse(ConfigurationManager.AppSettings["umbracoUseDirectoryUrls"]); - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.GlobalSettings.UseDirectoryUrls; } } /// @@ -367,17 +169,7 @@ namespace umbraco /// The version check period in days (0 = never). public static int VersionCheckPeriod { - get - { - int versionCheckPeriod = 7; - if (HttpContext.Current != null) - { - if (int.TryParse(ConfigurationManager.AppSettings["umbracoVersionCheckPeriod"], out versionCheckPeriod)) - return versionCheckPeriod; - - } - return versionCheckPeriod; - } + get { return Umbraco.Core.Configuration.GlobalSettings.VersionCheckPeriod; } } /// @@ -386,12 +178,7 @@ namespace umbraco /// The URL forbitten characters. public static string UrlForbittenCharacters { - get - { - if (HttpContext.Current != null) - return ConfigurationManager.AppSettings["umbracoUrlForbittenCharacters"]; - return ""; - } + get { return Umbraco.Core.Configuration.GlobalSettings.UrlForbittenCharacters; } } /// @@ -400,12 +187,7 @@ namespace umbraco /// The URL space character. public static string UrlSpaceCharacter { - get - { - if (HttpContext.Current != null) - return ConfigurationManager.AppSettings["umbracoUrlSpaceCharacter"]; - return ""; - } + get { return Umbraco.Core.Configuration.GlobalSettings.UrlSpaceCharacter; } } /// @@ -414,22 +196,7 @@ namespace umbraco /// The SMTP server. public static string SmtpServer { - get - { - try - { - System.Net.Configuration.MailSettingsSectionGroup mailSettings = ConfigurationManager.GetSection("system.net/mailSettings") as System.Net.Configuration.MailSettingsSectionGroup; - - if (mailSettings != null) - return mailSettings.Smtp.Network.Host; - else - return ConfigurationManager.AppSettings["umbracoSmtpServer"]; - } - catch - { - return ""; - } - } + get { return Umbraco.Core.Configuration.GlobalSettings.SmtpServer; } } /// @@ -438,12 +205,7 @@ namespace umbraco /// "true" if version xslt extensions are disabled, otherwise, "false" public static string DisableXsltExtensions { - get - { - if (HttpContext.Current != null) - return ConfigurationManager.AppSettings["umbracoDisableXsltExtensions"]; - return ""; - } + get { return Umbraco.Core.Configuration.GlobalSettings.DisableXsltExtensions; } } /// @@ -452,12 +214,7 @@ namespace umbraco /// "true" if Xhtml mode is enable, otherwise, "false" public static string EditXhtmlMode { - get - { - if (HttpContext.Current != null) - return ConfigurationManager.AppSettings["umbracoEditXhtmlMode"]; - return ""; - } + get { return Umbraco.Core.Configuration.GlobalSettings.EditXhtmlMode; } } /// @@ -466,12 +223,7 @@ namespace umbraco /// The default UI language. public static string DefaultUILanguage { - get - { - if (HttpContext.Current != null) - return ConfigurationManager.AppSettings["umbracoDefaultUILanguage"]; - return ""; - } + get { return Umbraco.Core.Configuration.GlobalSettings.DefaultUILanguage; } } /// @@ -480,12 +232,7 @@ namespace umbraco /// The profile URL. public static string ProfileUrl { - get - { - if (HttpContext.Current != null) - return ConfigurationManager.AppSettings["umbracoProfileUrl"]; - return ""; - } + get { return Umbraco.Core.Configuration.GlobalSettings.ProfileUrl; } } /// @@ -496,12 +243,7 @@ namespace umbraco /// public static bool HideTopLevelNodeFromPath { - get - { - if (HttpContext.Current != null) - return bool.Parse(ConfigurationManager.AppSettings["umbracoHideTopLevelNodeFromPath"]); - return false; - } + get { return Umbraco.Core.Configuration.GlobalSettings.HideTopLevelNodeFromPath; } } /// @@ -510,11 +252,7 @@ namespace umbraco /// The current version. public static string CurrentVersion { - get - { - // change this to be hardcoded in the binary - return _currentVersion; - } + get { return Umbraco.Core.Configuration.GlobalSettings.CurrentVersion; } } /// @@ -523,11 +261,7 @@ namespace umbraco /// The major version number. public static int VersionMajor { - get - { - string[] version = CurrentVersion.Split(".".ToCharArray()); - return int.Parse(version[0]); - } + get { return Umbraco.Core.Configuration.GlobalSettings.VersionMajor; } } /// @@ -536,11 +270,7 @@ namespace umbraco /// The minor version number. public static int VersionMinor { - get - { - string[] version = CurrentVersion.Split(".".ToCharArray()); - return int.Parse(version[1]); - } + get { return Umbraco.Core.Configuration.GlobalSettings.VersionMinor; } } /// @@ -549,11 +279,7 @@ namespace umbraco /// The patch version number. public static int VersionPatch { - get - { - string[] version = CurrentVersion.Split(".".ToCharArray()); - return int.Parse(version[2]); - } + get { return Umbraco.Core.Configuration.GlobalSettings.VersionPatch; } } /// @@ -562,14 +288,7 @@ namespace umbraco /// The version comment. public static string VersionComment { - get - { - string[] version = CurrentVersion.Split(".".ToCharArray()); - if (version.Length > 3) - return version[3]; - else - return ""; - } + get { return Umbraco.Core.Configuration.GlobalSettings.VersionComment; } } @@ -580,12 +299,12 @@ namespace umbraco /// public static bool RequestIsInUmbracoApplication(HttpContext context) { - return context.Request.Path.ToLower().IndexOf(IOHelper.ResolveUrl(SystemDirectories.Umbraco).ToLower()) > -1; + return Umbraco.Core.Configuration.GlobalSettings.RequestIsInUmbracoApplication(context); } public static bool RequestIsLiveEditRedirector(HttpContext context) { - return context.Request.Path.ToLower().IndexOf(SystemDirectories.Umbraco.ToLower() + "/liveediting.aspx") > -1; + return Umbraco.Core.Configuration.GlobalSettings.RequestIsLiveEditRedirector(context); } /// @@ -594,17 +313,7 @@ namespace umbraco /// true if [use SSL]; otherwise, false. public static bool UseSSL { - get - { - try - { - return bool.Parse(ConfigurationManager.AppSettings["umbracoUseSSL"]); - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.GlobalSettings.UseSSL; } } /// @@ -613,40 +322,7 @@ namespace umbraco /// The license. public static string License { - get - { - string license = - "the open source license MIT. The umbraco UI is freeware licensed under the umbraco license."; - if (HttpContext.Current != null) - { - XmlDocument versionDoc = new XmlDocument(); - XmlTextReader versionReader = new XmlTextReader(IOHelper.MapPath(SystemDirectories.Umbraco + "/version.xml")); - versionDoc.Load(versionReader); - versionReader.Close(); - - // check for license - try - { - string licenseUrl = - versionDoc.SelectSingleNode("/version/licensing/licenseUrl").FirstChild.Value; - string licenseValidation = - versionDoc.SelectSingleNode("/version/licensing/licenseValidation").FirstChild.Value; - string licensedTo = - versionDoc.SelectSingleNode("/version/licensing/licensedTo").FirstChild.Value; - - if (licensedTo != "" && licenseUrl != "") - { - license = "umbraco Commercial License
Registered to:
" + - licensedTo.Replace("\n", "
") + "
For use with domain:
" + - licenseUrl; - } - } - catch - { - } - } - return license; - } + get { return Umbraco.Core.Configuration.GlobalSettings.License; } } @@ -656,34 +332,7 @@ namespace umbraco /// true if succesfull; otherwise, false. public static bool test { - get - { - try - { - HttpContext.Current.Response.Write("ContentXML :" + ContentXML + "\n"); - HttpContext.Current.Response.Write("DbDSN :" + DbDSN + "\n"); - HttpContext.Current.Response.Write("DebugMode :" + DebugMode + "\n"); - HttpContext.Current.Response.Write("DefaultUILanguage :" + DefaultUILanguage + "\n"); - HttpContext.Current.Response.Write("VersionCheckPeriod :" + VersionCheckPeriod + "\n"); - HttpContext.Current.Response.Write("DisableXsltExtensions :" + DisableXsltExtensions + "\n"); - HttpContext.Current.Response.Write("EditXhtmlMode :" + EditXhtmlMode + "\n"); - HttpContext.Current.Response.Write("HideTopLevelNodeFromPath :" + HideTopLevelNodeFromPath + "\n"); - HttpContext.Current.Response.Write("Path :" + Path + "\n"); - HttpContext.Current.Response.Write("ProfileUrl :" + ProfileUrl + "\n"); - HttpContext.Current.Response.Write("ReservedPaths :" + ReservedPaths + "\n"); - HttpContext.Current.Response.Write("ReservedUrls :" + ReservedUrls + "\n"); - HttpContext.Current.Response.Write("StorageDirectory :" + StorageDirectory + "\n"); - HttpContext.Current.Response.Write("TimeOutInMinutes :" + TimeOutInMinutes + "\n"); - HttpContext.Current.Response.Write("UrlForbittenCharacters :" + UrlForbittenCharacters + "\n"); - HttpContext.Current.Response.Write("UrlSpaceCharacter :" + UrlSpaceCharacter + "\n"); - HttpContext.Current.Response.Write("UseDirectoryUrls :" + UseDirectoryUrls + "\n"); - return true; - } - catch - { - } - return false; - } + get { return Umbraco.Core.Configuration.GlobalSettings.Test; } } @@ -696,48 +345,7 @@ namespace umbraco /// public static bool IsReservedPathOrUrl(string url) { - // check if GlobalSettings.ReservedPaths and GlobalSettings.ReservedUrls are unchanged - if (!object.ReferenceEquals(_reservedPathsCache, GlobalSettings.ReservedPaths) - || !object.ReferenceEquals(_reservedUrlsCache, GlobalSettings.ReservedUrls)) - { - // store references to strings to determine changes - _reservedPathsCache = GlobalSettings.ReservedPaths; - _reservedUrlsCache = GlobalSettings.ReservedUrls; - - string _root = SystemDirectories.Root.Trim().ToLower(); - - // add URLs and paths to a new list - StartsWithContainer _newReservedList = new StartsWithContainer(); - foreach (string reservedUrl in _reservedUrlsCache.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries)) - { - //resolves the url to support tilde chars - string reservedUrlTrimmed = IOHelper.ResolveUrl(reservedUrl).Trim().ToLower(); - if (reservedUrlTrimmed.Length > 0) - _newReservedList.Add(reservedUrlTrimmed); - } - - foreach (string reservedPath in _reservedPathsCache.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries)) - { - bool trimEnd = !reservedPath.EndsWith("/"); - //resolves the url to support tilde chars - string reservedPathTrimmed = IOHelper.ResolveUrl(reservedPath).Trim().ToLower(); - - if (reservedPathTrimmed.Length > 0) - _newReservedList.Add(reservedPathTrimmed + (reservedPathTrimmed.EndsWith("/") ? "" : "/")); - } - - // use the new list from now on - _reservedList = _newReservedList; - } - - string res = ""; - foreach (string st in _reservedList._list.Keys) - res += st + ","; - - HttpContext.Current.Trace.Write("umbracoGlobalsettings", "reserverd urls: '" + res + "'"); - - // return true if url starts with an element of the reserved list - return _reservedList.StartsWith(url.ToLower()); + return Umbraco.Core.Configuration.GlobalSettings.IsReservedPathOrUrl(url); } } @@ -747,6 +355,7 @@ namespace umbraco /// Structure that checks in logarithmic time /// if a given string starts with one of the added keys. /// + [Obsolete("Use Umbraco.Core.Configuration.GlobalSettings.StartsWithContainer container instead")] public class StartsWithContainer { /// Internal sorted list of keys. diff --git a/src/umbraco.businesslogic/IO/IOHelper.cs b/src/umbraco.businesslogic/IO/IOHelper.cs index 1ff13ee642..8bd27eab9c 100644 --- a/src/umbraco.businesslogic/IO/IOHelper.cs +++ b/src/umbraco.businesslogic/IO/IOHelper.cs @@ -2,6 +2,7 @@ using System.Collections.Generic; using System.Diagnostics; using System.Linq; +using System.Reflection; using System.Text; using System.IO; using System.Configuration; @@ -12,133 +13,55 @@ using umbraco.businesslogic.Exceptions; namespace umbraco.IO { + [Obsolete("Use Umbraco.Core.IO.IOHelper instead")] public static class IOHelper - { - private static string m_rootDir = ""; - // static compiled regex for faster performance - private readonly static Regex _resolveUrlPattern = new Regex("(=[\"\']?)(\\W?\\~(?:.(?![\"\']?\\s+(?:\\S+)=|[>\"\']))+.)[\"\']?", RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace); - + { public static char DirSepChar { get { - return Path.DirectorySeparatorChar; + return Umbraco.Core.IO.IOHelper.DirSepChar; } } //helper to try and match the old path to a new virtual one public static string FindFile(string virtualPath) { - string retval = virtualPath; - - if (virtualPath.StartsWith("~")) - retval = virtualPath.Replace("~", SystemDirectories.Root); - - if (virtualPath.StartsWith("/") && !virtualPath.StartsWith(SystemDirectories.Root)) - retval = SystemDirectories.Root + "/" + virtualPath.TrimStart('/'); - - return retval; + return Umbraco.Core.IO.IOHelper.FindFile(virtualPath); } //Replaces tildes with the root dir public static string ResolveUrl(string virtualPath) { - if (virtualPath.StartsWith("~")) - return virtualPath.Replace("~", SystemDirectories.Root).Replace("//", "/"); - else - return VirtualPathUtility.ToAbsolute(virtualPath, SystemDirectories.Root); + return Umbraco.Core.IO.IOHelper.ResolveUrl(virtualPath); } public static string ResolveUrlsFromTextString(string text) { - if (UmbracoSettings.ResolveUrlsFromTextString) - { - Stopwatch sw = new Stopwatch(); - sw.Start(); - Debug.WriteLine("Start: " + sw.ElapsedMilliseconds); - - // find all relative urls (ie. urls that contain ~) - MatchCollection tags = - _resolveUrlPattern.Matches(text); - Debug.WriteLine("After regex: " + sw.ElapsedMilliseconds); - foreach (Match tag in tags) - { - Debug.WriteLine("-- inside regex: " + sw.ElapsedMilliseconds); - string url = ""; - if (tag.Groups[1].Success) - url = tag.Groups[1].Value; - - // The richtext editor inserts a slash in front of the url. That's why we need this little fix - // if (url.StartsWith("/")) - // text = text.Replace(url, ResolveUrl(url.Substring(1))); - // else - if (!String.IsNullOrEmpty(url)) - { - Debug.WriteLine("---- before resolve: " + sw.ElapsedMilliseconds); - string resolvedUrl = (url.Substring(0, 1) == "/") ? ResolveUrl(url.Substring(1)) : ResolveUrl(url); - Debug.WriteLine("---- after resolve: " + sw.ElapsedMilliseconds); - Debug.WriteLine("---- before replace: " + sw.ElapsedMilliseconds); - text = text.Replace(url, resolvedUrl); - Debug.WriteLine("---- after replace: " + sw.ElapsedMilliseconds); - } - - } - - Debug.WriteLine("total: " + sw.ElapsedMilliseconds); - sw.Stop(); - System.Web.HttpContext.Current.Trace.Write("Resolve Urls", sw.ElapsedMilliseconds.ToString()); - - } - return text; + return Umbraco.Core.IO.IOHelper.ResolveUrlsFromTextString(text); } public static string MapPath(string path, bool useHttpContext) { - // Check if the path is already mapped - if (path.Length >= 2 && path[1] == Path.VolumeSeparatorChar) - return path; - - if (useHttpContext) - { - //string retval; - if (!string.IsNullOrEmpty(path) && (path.StartsWith("~") || path.StartsWith(SystemDirectories.Root))) - return System.Web.Hosting.HostingEnvironment.MapPath(path); - else - return System.Web.Hosting.HostingEnvironment.MapPath("~/" + path.TrimStart('/')); - } - else - { - string _root = (!String.IsNullOrEmpty(System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath)) ? System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath.TrimEnd(IOHelper.DirSepChar) : getRootDirectorySafe(); - - string _path = path.TrimStart('~', '/').Replace('/', IOHelper.DirSepChar); - - string retval = _root + IOHelper.DirSepChar.ToString() + _path; - - return retval; - } + return Umbraco.Core.IO.IOHelper.MapPath(path, useHttpContext); } public static string MapPath(string path) { - return MapPath(path, true); + return Umbraco.Core.IO.IOHelper.MapPath(path); } //use a tilde character instead of the complete path public static string returnPath(string settingsKey, string standardPath, bool useTilde) { - string retval = ConfigurationManager.AppSettings[settingsKey]; - - if (string.IsNullOrEmpty(retval)) - retval = standardPath; - - return retval.TrimEnd('/'); + return Umbraco.Core.IO.IOHelper.ReturnPath(settingsKey, standardPath, useTilde); } public static string returnPath(string settingsKey, string standardPath) { - return returnPath(settingsKey, standardPath, false); + return Umbraco.Core.IO.IOHelper.ReturnPath(settingsKey, standardPath); } @@ -151,28 +74,12 @@ namespace umbraco.IO /// true if valid, throws a FileSecurityException if not public static bool ValidateEditPath(string filePath, string validDir) { - if (!filePath.StartsWith(MapPath(SystemDirectories.Root))) - filePath = MapPath(filePath); - if (!validDir.StartsWith(MapPath(SystemDirectories.Root))) - validDir = MapPath(validDir); - - if (!filePath.StartsWith(validDir)) - throw new FileSecurityException(String.Format("The filepath '{0}' is not within an allowed directory for this type of files", filePath.Replace(MapPath(SystemDirectories.Root), ""))); - - return true; + return Umbraco.Core.IO.IOHelper.ValidateEditPath(filePath, validDir); } public static bool ValidateFileExtension(string filePath, List validFileExtensions) { - if (!filePath.StartsWith(MapPath(SystemDirectories.Root))) - filePath = MapPath(filePath); - FileInfo f = new FileInfo(filePath); - - - if (!validFileExtensions.Contains(f.Extension.Substring(1))) - throw new FileSecurityException(String.Format("The extension for the current file '{0}' is not of an allowed type for this editor. This is typically controlled from either the installed MacroEngines or based on configuration in /config/umbracoSettings.config", filePath.Replace(MapPath(SystemDirectories.Root), ""))); - - return true; + return Umbraco.Core.IO.IOHelper.ValidateFileExtension(filePath, validFileExtensions); } @@ -184,17 +91,7 @@ namespace umbraco.IO /// private static string getRootDirectorySafe() { - if (!String.IsNullOrEmpty(m_rootDir)) - { - return m_rootDir; - } - - string baseDirectory = - System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().CodeBase.Substring(8)); - m_rootDir = baseDirectory.Substring(0, baseDirectory.LastIndexOf("bin") - 1); - - return m_rootDir; - + return Umbraco.Core.IO.IOHelper.GetRootDirectorySafe(); } } diff --git a/src/umbraco.businesslogic/IO/SystemDirectories.cs b/src/umbraco.businesslogic/IO/SystemDirectories.cs index 0c0ce810e0..b98f59b808 100644 --- a/src/umbraco.businesslogic/IO/SystemDirectories.cs +++ b/src/umbraco.businesslogic/IO/SystemDirectories.cs @@ -9,170 +9,104 @@ using System.IO; namespace umbraco.IO { - //all paths has a starting but no trailing / + [Obsolete("Use Umbraco.Core.UI.SystemDirectories instead")] public class SystemDirectories { public static string Bin { - get - { - return IOHelper.returnPath("umbracoBinDirectory", "~/bin"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.Bin; } } public static string Base { - get - { - return IOHelper.returnPath("umbracoBaseDirectory", "~/base"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.Base; } } public static string Config { - get - { - return IOHelper.returnPath("umbracoConfigDirectory", "~/config"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.Config; } } public static string Css { - get - { - return IOHelper.returnPath("umbracoCssDirectory", "~/css"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.Css; } } public static string Data { - get - { - return IOHelper.returnPath("umbracoStorageDirectory", "~/App_Data"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.Data; } } public static string Install { - get - { - return IOHelper.returnPath("umbracoInstallPath", "~/install"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.Install; } } public static string Masterpages { - get - { - return IOHelper.returnPath("umbracoMasterPagesPath", "~/masterpages"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.Masterpages; } } public static string Media { - get - { - return IOHelper.returnPath("umbracoMediaPath", "~/media"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.Media; } } [Obsolete("Please use MacroScripts instead!", true)] public static string Python { - get - { - return MacroScripts; - } + get { return global::Umbraco.Core.IO.SystemDirectories.MacroScripts; } } public static string MacroScripts { - get - { - // for legacy we test for the python path first, but else we use the new default location - string tempPath = IOHelper.returnPath("umbracoPythonPath", "") == String.Empty - ? IOHelper.returnPath("umbracoMacroScriptPath", "~/macroScripts") - : IOHelper.returnPath("umbracoPythonPath", "~/python"); - return tempPath; - } + get { return global::Umbraco.Core.IO.SystemDirectories.MacroScripts; } } public static string Scripts { - get - { - return IOHelper.returnPath("umbracoScriptsPath", "~/scripts"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.Scripts; } } public static string Umbraco { - get - { - return IOHelper.returnPath("umbracoPath", "~/umbraco"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.Umbraco; } } public static string Umbraco_client { - get - { - return IOHelper.returnPath("umbracoClientPath", "~/umbraco_client"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.UmbracoClient; } } public static string Usercontrols { - get - { - return IOHelper.returnPath("umbracoUsercontrolsPath", "~/usercontrols"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.UserControls; } } public static string Webservices { - get - { - return IOHelper.returnPath("umbracoWebservicesPath", "~/umbraco/webservices"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.WebServices; } } public static string Xslt { - get { - return IOHelper.returnPath("umbracoXsltPath", "~/xslt"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.Xslt; } } public static string Packages { - get - { - //by default the packages folder should exist in the data folder - return IOHelper.returnPath("umbracoPackagesPath", Data + IOHelper.DirSepChar + "packages"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.Packages; } } public static string Preview { - get - { - //by default the packages folder should exist in the data folder - return IOHelper.returnPath("umbracoPreviewPath", Data + IOHelper.DirSepChar + "preview"); - } + get { return global::Umbraco.Core.IO.SystemDirectories.Preview; } } public static string Root { - get - { - string appPath = HttpRuntime.AppDomainAppVirtualPath ?? string.Empty; - if (appPath == "/") - appPath = string.Empty; - - return appPath; - } + get { return global::Umbraco.Core.IO.SystemDirectories.Root; } } } diff --git a/src/umbraco.businesslogic/IO/SystemFiles.cs b/src/umbraco.businesslogic/IO/SystemFiles.cs index b840511e4c..f2915d11a3 100644 --- a/src/umbraco.businesslogic/IO/SystemFiles.cs +++ b/src/umbraco.businesslogic/IO/SystemFiles.cs @@ -8,115 +8,70 @@ using System.Web; namespace umbraco.IO { - public class SystemFiles - { - public static string AccessXml - { - get - { - return SystemDirectories.Data + "/access.config"; - } - } + [Obsolete("Use Umbraco.Core.UI.SystemFiles instead")] + public class SystemFiles + { - public static string CreateUiXml - { - get - { - return SystemDirectories.Umbraco + "/config/create/UI.xml"; - } - } + public static string AccessXml + { + get { return Umbraco.Core.IO.SystemFiles.AccessXml; } + } - public static string TinyMceConfig - { - get - { - return SystemDirectories.Config + "/tinyMceConfig.config"; - } - } + public static string CreateUiXml + { + get { return Umbraco.Core.IO.SystemFiles.CreateUiXml; } + } - public static string MetablogConfig - { - get - { - return SystemDirectories.Config + "/metablogConfig.config"; - } - } + public static string TinyMceConfig + { + get { return Umbraco.Core.IO.SystemFiles.TinyMceConfig; } + } - public static string DashboardConfig - { - get - { - return SystemDirectories.Config + "/dashboard.config"; - } - } + public static string MetablogConfig + { + get { return Umbraco.Core.IO.SystemFiles.MetablogConfig; } + } - public static string XsltextensionsConfig - { - get - { - return SystemDirectories.Config + "/xsltextensions.config"; - } - } + public static string DashboardConfig + { + get { return Umbraco.Core.IO.SystemFiles.DashboardConfig; } + } - public static string RestextensionsConfig - { - get - { - return SystemDirectories.Config + "/restextensions.config"; - } - } + public static string XsltextensionsConfig + { + get { return Umbraco.Core.IO.SystemFiles.XsltextensionsConfig; } + } + + public static string RestextensionsConfig + { + get { return Umbraco.Core.IO.SystemFiles.RestextensionsConfig; } + } - public static string SkinningXml - { - get - { - return SystemDirectories.Data + "/skinning.config"; - } - } + public static string SkinningXml + { + get { return Umbraco.Core.IO.SystemFiles.SkinningXml; } + } - public static string NotFoundhandlersConfig - { - get - { - return SystemDirectories.Config + "/404handlers.config"; - } - } + public static string NotFoundhandlersConfig + { + get { return Umbraco.Core.IO.SystemFiles.NotFoundhandlersConfig; } + } - public static string FeedProxyConfig - { - get - { - return string.Concat(SystemDirectories.Config, "/feedProxy.config"); - } - } + public static string FeedProxyConfig + { + get { return Umbraco.Core.IO.SystemFiles.FeedProxyConfig; } + } - public static string ContentCacheXml - { - get - { - if (ContentCacheXmlIsEphemeral) - { - return Path.Combine(HttpRuntime.CodegenDir, @"UmbracoData\umbraco.config"); - } - return IOHelper.returnPath("umbracoContentXML", "~/App_Data/umbraco.config"); - } - } + public static string ContentCacheXml + { + get { return Umbraco.Core.IO.SystemFiles.ContentCacheXml; } + } - public static bool ContentCacheXmlIsEphemeral - { - get - { - bool returnValue = false; - string configSetting = ConfigurationManager.AppSettings["umbracoContentXMLUseLocalTemp"]; - - if (!string.IsNullOrEmpty(configSetting)) - if(bool.TryParse(configSetting, out returnValue)) - return returnValue; - - return false; - } - } - } + public static bool ContentCacheXmlIsEphemeral + { + get { return Umbraco.Core.IO.SystemFiles.ContentCacheXmlIsEphemeral; } + } + } } diff --git a/src/umbraco.businesslogic/Razor/RazorDataTypeModelStaticMappingItem.cs b/src/umbraco.businesslogic/Razor/RazorDataTypeModelStaticMappingItem.cs index 2bd9cce16b..fab1d4d291 100644 --- a/src/umbraco.businesslogic/Razor/RazorDataTypeModelStaticMappingItem.cs +++ b/src/umbraco.businesslogic/Razor/RazorDataTypeModelStaticMappingItem.cs @@ -5,28 +5,45 @@ using System.Text; namespace umbraco.MacroEngines { + [Obsolete("use Umbraco.Core.RazorDataTypeModelStaticMappingItem instead")] public class RazorDataTypeModelStaticMappingItem - { - public string Raw; + { + private readonly Umbraco.Core.RazorDataTypeModelStaticMappingItem _realMappingItem = new Umbraco.Core.RazorDataTypeModelStaticMappingItem(); + + public string Raw + { + get { return _realMappingItem.Raw; } + set { _realMappingItem.Raw = value; } + } //if all of the set (non null) properties match the property data currently being evaluated - public string PropertyTypeAlias; - public string NodeTypeAlias; - public Guid? DataTypeGuid; + public string PropertyTypeAlias + { + get { return _realMappingItem.PropertyTypeAlias; } + set { _realMappingItem.PropertyTypeAlias = value; } + } - public string TypeName; + public string NodeTypeAlias + { + get { return _realMappingItem.NodeTypeAlias; } + set { _realMappingItem.NodeTypeAlias = value; } + } - public RazorDataTypeModelStaticMappingItem() { } + public Guid? DataTypeGuid + { + get { return _realMappingItem.DataTypeGuid; } + set { _realMappingItem.DataTypeGuid = value; } + } - public bool Applies(Guid dataTypeGuid, string nodeTypeAlias, string propertyTypeAlias) - { - return - ( - (this.NodeTypeAlias != null || this.PropertyTypeAlias != null || this.DataTypeGuid != null) && - ((this.DataTypeGuid != null && this.DataTypeGuid == dataTypeGuid) || this.DataTypeGuid == null) && - ((this.PropertyTypeAlias != null && this.PropertyTypeAlias == propertyTypeAlias) || this.PropertyTypeAlias == null) && - ((this.NodeTypeAlias != null && this.NodeTypeAlias == nodeTypeAlias) || this.NodeTypeAlias == null) - ); - } + public string TypeName + { + get { return _realMappingItem.TypeName; } + set { _realMappingItem.TypeName = value; } + } + + public bool Applies(Guid dataTypeGuid, string nodeTypeAlias, string propertyTypeAlias) + { + return _realMappingItem.Applies(dataTypeGuid, nodeTypeAlias, propertyTypeAlias); + } } } diff --git a/src/umbraco.businesslogic/UmbracoSettings.cs b/src/umbraco.businesslogic/UmbracoSettings.cs index 7a38b42823..855028adfb 100644 --- a/src/umbraco.businesslogic/UmbracoSettings.cs +++ b/src/umbraco.businesslogic/UmbracoSettings.cs @@ -1,6 +1,7 @@ using System; using System.Diagnostics; using System.IO; +using System.Linq; using System.Web; using System.Web.Caching; using System.Xml; @@ -23,55 +24,17 @@ namespace umbraco /// The _umbraco settings. public static XmlDocument _umbracoSettings { - get - { - XmlDocument us = (XmlDocument)HttpRuntime.Cache["umbracoSettingsFile"]; - if (us == null) - us = ensureSettingsDocument(); - return us; - } - } - - private static string _path = GlobalSettings.FullpathToRoot + Path.DirectorySeparatorChar + "config" + - Path.DirectorySeparatorChar; - - private static string _filename = "umbracoSettings.config"; - - private static XmlDocument ensureSettingsDocument() - { - object settingsFile = HttpRuntime.Cache["umbracoSettingsFile"]; - - // Check for language file in cache - if (settingsFile == null) - { - XmlDocument temp = new XmlDocument(); - XmlTextReader settingsReader = new XmlTextReader(_path + _filename); - try - { - temp.Load(settingsReader); - HttpRuntime.Cache.Insert("umbracoSettingsFile", temp, - new CacheDependency(_path + _filename)); - } - catch (XmlException e) - { - throw new XmlException("Your umbracoSettings.config file fails to pass as valid XML. Refer to the InnerException for more information", e); - } - catch (Exception e) - { - Log.Add(LogTypes.Error, new User(0), -1, "Error reading umbracoSettings file: " + e.ToString()); - } - settingsReader.Close(); - return temp; - } - else - return (XmlDocument)settingsFile; - } - - private static void save() - { - _umbracoSettings.Save(_path + _filename); + get { return Umbraco.Core.Configuration.UmbracoSettings.UmbracoSettingsXmlDoc; } } + /// + /// Gets/sets the settings file path, the setter can be used in unit tests + /// + internal static string SettingsFilePath + { + get { return Umbraco.Core.Configuration.UmbracoSettings.SettingsFilePath; } + set { Umbraco.Core.Configuration.UmbracoSettings.SettingsFilePath = value; } + } /// /// Selects a xml node in the umbraco settings config file. @@ -80,12 +43,7 @@ namespace umbraco /// If found, it returns the specific configuration xml node. public static XmlNode GetKeyAsNode(string Key) { - if (Key == null) - throw new ArgumentException("Key cannot be null"); - ensureSettingsDocument(); - if (_umbracoSettings == null || _umbracoSettings.DocumentElement == null) - return null; - return _umbracoSettings.DocumentElement.SelectSingleNode(Key); + return Umbraco.Core.Configuration.UmbracoSettings.GetKeyAsNode(Key); } /// @@ -95,12 +53,7 @@ namespace umbraco /// public static string GetKey(string Key) { - ensureSettingsDocument(); - - XmlNode node = _umbracoSettings.DocumentElement.SelectSingleNode(Key); - if (node == null || node.FirstChild == null || node.FirstChild.Value == null) - return string.Empty; - return node.FirstChild.Value; + return Umbraco.Core.Configuration.UmbracoSettings.GetKey(Key); } /// @@ -111,7 +64,7 @@ namespace umbraco /// public static bool UploadAllowDirectories { - get { return bool.Parse(GetKey("/settings/content/UploadAllowDirectories")); } + get { return Umbraco.Core.Configuration.UmbracoSettings.UploadAllowDirectories; } } /// @@ -120,16 +73,7 @@ namespace umbraco /// true if logging is enabled; otherwise, false. public static bool EnableLogging { - get - { - // We return true if no enable logging element is present in - // umbracoSettings (to enable default behaviour when upgrading) - string m_EnableLogging = GetKey("/settings/logging/enableLogging"); - if (String.IsNullOrEmpty(m_EnableLogging)) - return true; - else - return bool.Parse(m_EnableLogging); - } + get { return Umbraco.Core.Configuration.UmbracoSettings.EnableLogging; } } /// @@ -138,14 +82,7 @@ namespace umbraco /// true if async logging is enabled; otherwise, false. public static bool EnableAsyncLogging { - get - { - string value = GetKey("/settings/logging/enableAsyncLogging"); - bool result; - if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out result)) - return result; - return false; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.EnableAsyncLogging; } } /// @@ -153,30 +90,14 @@ namespace umbraco /// public static string ExternalLoggerAssembly { - get - { - XmlNode value = GetKeyAsNode("/settings/logging/externalLogger"); - if (value != null) - { - return value.Attributes["assembly"].Value; - } - return ""; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.ExternalLoggerAssembly; } } /// /// Gets the type of an external logger that can be used to store log items in 3rd party systems /// public static string ExternalLoggerType { - get - { - XmlNode value = GetKeyAsNode("/settings/logging/externalLogger"); - if (value != null) - { - return value.Attributes["type"].Value; - } - return ""; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.ExternalLoggerType; } } /// @@ -184,18 +105,7 @@ namespace umbraco /// public static bool ExternalLoggerLogAuditTrail { - get - { - XmlNode value = GetKeyAsNode("/settings/logging/externalLogger"); - if (value != null) - { - string logAuditTrail = value.Attributes["logAuditTrail"].Value; - bool result; - if (!string.IsNullOrEmpty(logAuditTrail) && bool.TryParse(logAuditTrail, out result)) - return result; - } - return false; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.ExternalLoggerLogAuditTrail; } } /// @@ -203,14 +113,7 @@ namespace umbraco /// public static bool KeepUserLoggedIn { - get - { - string value = GetKey("/settings/security/keepUserLoggedIn"); - bool result; - if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out result)) - return result; - return true; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.KeepUserLoggedIn; } } /// @@ -218,14 +121,7 @@ namespace umbraco /// public static bool HideDisabledUsersInBackoffice { - get - { - string value = GetKey("/settings/security/hideDisabledUsersInBackoffice"); - bool result; - if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out result)) - return result; - return false; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.HideDisabledUsersInBackoffice; } } /// @@ -234,14 +130,7 @@ namespace umbraco /// true if logs are to be automatically cleaned; otherwise, false public static bool AutoCleanLogs { - get - { - string value = GetKey("/settings/logging/autoCleanLogs"); - bool result; - if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out result)) - return result; - return false; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.AutoCleanLogs; } } /// @@ -249,26 +138,12 @@ namespace umbraco /// public static int CleaningMiliseconds { - get - { - string value = GetKey("/settings/logging/cleaningMiliseconds"); - int result; - if (!string.IsNullOrEmpty(value) && int.TryParse(value, out result)) - return result; - return -1; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.CleaningMiliseconds; } } public static int MaxLogAge { - get - { - string value = GetKey("/settings/logging/maxLogAge"); - int result; - if (!string.IsNullOrEmpty(value) && int.TryParse(value, out result)) - return result; - return -1; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.MaxLogAge; } } /// @@ -277,7 +152,7 @@ namespace umbraco /// The disabled log types. public static XmlNode DisabledLogTypes { - get { return GetKeyAsNode("/settings/logging/disabledLogTypes"); } + get { return Umbraco.Core.Configuration.UmbracoSettings.DisabledLogTypes; } } /// @@ -286,7 +161,7 @@ namespace umbraco /// The package server url. public static string PackageServer { - get { return "packages.umbraco.org"; } + get { return Umbraco.Core.Configuration.UmbracoSettings.PackageServer; } } /// @@ -295,20 +170,7 @@ namespace umbraco /// true if umbraco will use domain prefixes; otherwise, false. public static bool UseDomainPrefixes { - get - { - try - { - bool result; - if (bool.TryParse(GetKey("/settings/requestHandler/useDomainPrefixes"), out result)) - return result; - return false; - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.UseDomainPrefixes; } } /// @@ -317,27 +179,7 @@ namespace umbraco /// public static bool AddTrailingSlash { - get - { - try - { - if (GlobalSettings.UseDirectoryUrls) - { - bool result; - if (bool.TryParse(GetKey("/settings/requestHandler/addTrailingSlash"), out result)) - return result; - return false; - } - else - { - return false; - } - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.AddTrailingSlash; } } /// @@ -346,20 +188,7 @@ namespace umbraco /// true if umbraco will use ASP.NET MasterPages; otherwise, false. public static bool UseAspNetMasterPages { - get - { - try - { - bool result; - if (bool.TryParse(GetKey("/settings/templates/useAspNetMasterPages"), out result)) - return result; - return false; - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.UseAspNetMasterPages; } } @@ -369,20 +198,7 @@ namespace umbraco /// true if umbraco will override templates with skins if present and configured false. public static bool EnableTemplateFolders { - get - { - try - { - bool result; - if (bool.TryParse(GetKey("/settings/templates/enableTemplateFolders"), out result)) - return result; - return false; - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.EnableTemplateFolders; } } /// @@ -390,79 +206,25 @@ namespace umbraco /// public static List NotDynamicXmlDocumentElements { - get - { - try - { - List items = new List(); - XmlNode root = GetKeyAsNode("/settings/scripting/razor/notDynamicXmlDocumentElements"); - foreach (XmlNode element in root.SelectNodes(".//element")) - { - items.Add(element.InnerText); - } - return items; - } - catch - { - return new List() { "p", "div" }; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.NotDynamicXmlDocumentElements.ToList(); } } public static List RazorDataTypeModelStaticMapping { - get - { - if (HttpContext.Current != null && HttpContext.Current.Cache != null && HttpContext.Current.Cache["settings.scripting.razor.dataTypeModelStaticMappings"] != null) - { - return HttpContext.Current.Cache["settings.scripting.razor.dataTypeModelStaticMappings"] as List; - } - /* - - DigibizAdvancedMediaPicker.RazorModel.ModelBinder - DigibizAdvancedMediaPicker.RazorModel.ModelBinder - - */ - List items = new List(); - XmlNode root = GetKeyAsNode("/settings/scripting/razor/dataTypeModelStaticMappings"); - if (root != null) - { - foreach (XmlNode element in root.SelectNodes(".//mapping")) - { - string propertyTypeAlias = null, nodeTypeAlias = null; - Guid? dataTypeGuid = null; - if (!string.IsNullOrEmpty(element.InnerText)) - { - if (element.Attributes["dataTypeGuid"] != null) - { - dataTypeGuid = (Guid?)new Guid(element.Attributes["dataTypeGuid"].Value); - } - if (element.Attributes["propertyTypeAlias"] != null && !string.IsNullOrEmpty(element.Attributes["propertyTypeAlias"].Value)) - { - propertyTypeAlias = element.Attributes["propertyTypeAlias"].Value; - } - if (element.Attributes["nodeTypeAlias"] != null && !string.IsNullOrEmpty(element.Attributes["nodeTypeAlias"].Value)) - { - nodeTypeAlias = element.Attributes["nodeTypeAlias"].Value; - } - items.Add(new RazorDataTypeModelStaticMappingItem() - { - DataTypeGuid = dataTypeGuid, - PropertyTypeAlias = propertyTypeAlias, - NodeTypeAlias = nodeTypeAlias, - TypeName = element.InnerText, - Raw = element.OuterXml - }); - } - } - } - if (HttpContext.Current != null && HttpContext.Current.Cache != null) - { - HttpContext.Current.Cache.Add("settings.scripting.razor.dataTypeModelStaticMappings", items, null, Cache.NoAbsoluteExpiration, new TimeSpan(0, 20, 0), CacheItemPriority.AboveNormal, null); - } - return items; - - } + get + { + var mapping = Umbraco.Core.Configuration.UmbracoSettings.RazorDataTypeModelStaticMapping; + + //now we need to map to the old object until we can clean all this nonsense up + return mapping.Select(x => new RazorDataTypeModelStaticMappingItem() + { + DataTypeGuid = x.DataTypeGuid, + NodeTypeAlias = x.NodeTypeAlias, + PropertyTypeAlias = x.PropertyTypeAlias, + Raw = x.Raw, + TypeName = x.TypeName + }).ToList(); + } } /// @@ -473,20 +235,7 @@ namespace umbraco /// public static bool CloneXmlCacheOnPublish { - get - { - try - { - bool result; - if (bool.TryParse(GetKey("/settings/content/cloneXmlContent"), out result)) - return result; - return false; - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.CloneXmlCacheOnPublish; } } /// @@ -495,7 +244,7 @@ namespace umbraco /// true if content is parsed; otherwise, false. public static bool TidyEditorContent { - get { return bool.Parse(GetKey("/settings/content/TidyEditorContent")); } + get { return Umbraco.Core.Configuration.UmbracoSettings.TidyEditorContent; } } /// @@ -504,15 +253,7 @@ namespace umbraco /// The encoding type as string. public static string TidyCharEncoding { - get - { - string encoding = GetKey("/settings/content/TidyCharEncoding"); - if (String.IsNullOrEmpty(encoding)) - { - encoding = "UTF8"; - } - return encoding; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.TidyCharEncoding; } } /// @@ -521,19 +262,12 @@ namespace umbraco /// The property context help option. public static string PropertyContextHelpOption { - get { return GetKey("/settings/content/PropertyContextHelpOption").ToLower(); } + get { return Umbraco.Core.Configuration.UmbracoSettings.PropertyContextHelpOption; } } public static string DefaultBackofficeProvider { - get - { - string defaultProvider = GetKey("/settings/providers/users/DefaultBackofficeProvider"); - if (String.IsNullOrEmpty(defaultProvider)) - defaultProvider = "UsersMembershipProvider"; - - return defaultProvider; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.DefaultBackofficeProvider; } } /// @@ -541,24 +275,7 @@ namespace umbraco /// public static bool ForceSafeAliases { - get - { - string forceSafeAlias = GetKey("/settings/content/ForceSafeAliases"); - if (String.IsNullOrEmpty(forceSafeAlias)) - return true; - else - { - try - { - return bool.Parse(forceSafeAlias); - } - catch - { - return true; - } - } - - } + get { return Umbraco.Core.Configuration.UmbracoSettings.ForceSafeAliases; } } @@ -568,7 +285,7 @@ namespace umbraco /// The allowed image file types. public static string ImageFileTypes { - get { return GetKey("/settings/content/imaging/imageFileTypes").ToLowerInvariant(); } + get { return Umbraco.Core.Configuration.UmbracoSettings.ImageFileTypes; } } /// @@ -577,7 +294,7 @@ namespace umbraco /// The allowed script file types. public static string ScriptFileTypes { - get { return GetKey("/settings/content/scripteditor/scriptFileTypes"); } + get { return Umbraco.Core.Configuration.UmbracoSettings.ScriptFileTypes; } } /// @@ -586,24 +303,7 @@ namespace umbraco /// public static int UmbracoLibraryCacheDuration { - get - { - string libraryCacheDuration = GetKey("/settings/content/UmbracoLibraryCacheDuration"); - if (String.IsNullOrEmpty(libraryCacheDuration)) - return 1800; - else - { - try - { - return int.Parse(libraryCacheDuration); - } - catch - { - return 1800; - } - } - - } + get { return Umbraco.Core.Configuration.UmbracoSettings.UmbracoLibraryCacheDuration; } } /// @@ -612,7 +312,7 @@ namespace umbraco /// The script folder path. public static string ScriptFolderPath { - get { return GetKey("/settings/content/scripteditor/scriptFolderPath"); } + get { return Umbraco.Core.Configuration.UmbracoSettings.ScriptFolderPath; } } /// @@ -620,14 +320,7 @@ namespace umbraco /// public static bool ScriptDisableEditor { - get - { - string _tempValue = GetKey("/settings/content/scripteditor/scriptDisableEditor"); - if (_tempValue != String.Empty) - return bool.Parse(_tempValue); - else - return false; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.ScriptDisableEditor; } } /// @@ -636,7 +329,7 @@ namespace umbraco /// The graphic headline format. public static string GraphicHeadlineFormat { - get { return GetKey("/settings/content/graphicHeadlineFormat"); } + get { return Umbraco.Core.Configuration.UmbracoSettings.GraphicHeadlineFormat; } } /// @@ -647,17 +340,7 @@ namespace umbraco /// true if umbraco ensures unique node naming; otherwise, false. public static bool EnsureUniqueNaming { - get - { - try - { - return bool.Parse(GetKey("/settings/content/ensureUniqueNaming")); - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.EnsureUniqueNaming; } } /// @@ -666,7 +349,7 @@ namespace umbraco /// The notification email sender. public static string NotificationEmailSender { - get { return GetKey("/settings/content/notifications/email"); } + get { return Umbraco.Core.Configuration.UmbracoSettings.NotificationEmailSender; } } /// @@ -677,14 +360,7 @@ namespace umbraco /// public static bool NotificationDisableHtmlEmail { - get - { - string _tempValue = GetKey("/settings/content/notifications/disableHtmlEmail"); - if (_tempValue != String.Empty) - return bool.Parse(_tempValue); - else - return false; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.NotificationDisableHtmlEmail; } } /// @@ -693,12 +369,12 @@ namespace umbraco /// The allowed attributes on images. public static string ImageAllowedAttributes { - get { return GetKey("/settings/content/imaging/allowedAttributes"); } + get { return Umbraco.Core.Configuration.UmbracoSettings.ImageAllowedAttributes; } } public static XmlNode ImageAutoFillImageProperties { - get { return GetKeyAsNode("/settings/content/imaging/autoFillImageProperties"); } + get { return Umbraco.Core.Configuration.UmbracoSettings.ImageAutoFillImageProperties; } } /// @@ -707,7 +383,7 @@ namespace umbraco /// The scheduled tasks. public static XmlNode ScheduledTasks { - get { return GetKeyAsNode("/settings/scheduledTasks"); } + get { return Umbraco.Core.Configuration.UmbracoSettings.ScheduledTasks; } } /// @@ -716,7 +392,7 @@ namespace umbraco /// The URL replacement characters. public static XmlNode UrlReplaceCharacters { - get { return GetKeyAsNode("/settings/requestHandler/urlReplacing"); } + get { return Umbraco.Core.Configuration.UmbracoSettings.UrlReplaceCharacters; } } /// @@ -724,17 +400,7 @@ namespace umbraco /// public static bool RemoveDoubleDashesFromUrlReplacing { - get - { - try - { - return bool.Parse(UrlReplaceCharacters.Attributes.GetNamedItem("removeDoubleDashes").Value); - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.RemoveDoubleDashesFromUrlReplacing; } } /// @@ -745,17 +411,7 @@ namespace umbraco /// true if umbraco uses distributed calls; otherwise, false. public static bool UseDistributedCalls { - get - { - try - { - return bool.Parse(GetKeyAsNode("/settings/distributedCall").Attributes.GetNamedItem("enable").Value); - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.UseDistributedCalls; } } @@ -765,17 +421,7 @@ namespace umbraco /// The distributed call user. public static int DistributedCallUser { - get - { - try - { - return int.Parse(GetKey("/settings/distributedCall/user")); - } - catch - { - return -1; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.DistributedCallUser; } } /// @@ -783,17 +429,7 @@ namespace umbraco /// public static string PreviewBadge { - get - { - try - { - return GetKey("/settings/content/PreviewBadge"); - } - catch - { - return "In Preview Mode - click to end"; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.PreviewBadge; } } /// @@ -804,17 +440,7 @@ namespace umbraco /// The distribution servers. public static XmlNode DistributionServers { - get - { - try - { - return GetKeyAsNode("/settings/distributedCall/servers"); - } - catch - { - return null; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.DistributionServers; } } /// @@ -824,17 +450,7 @@ namespace umbraco /// public static XmlNode HelpPages { - get - { - try - { - return GetKeyAsNode("/settings/help"); - } - catch - { - return null; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.HelpPages; } } /// @@ -846,17 +462,7 @@ namespace umbraco /// The repository servers. public static XmlNode Repositories { - get - { - try - { - return GetKeyAsNode("/settings/repositories"); - } - catch - { - return null; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.Repositories; } } /// @@ -869,19 +475,7 @@ namespace umbraco /// public static bool UseViewstateMoverModule { - get - { - try - { - return - bool.Parse( - GetKeyAsNode("/settings/viewstateMoverModule").Attributes.GetNamedItem("enable").Value); - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.UseViewstateMoverModule; } } @@ -891,22 +485,7 @@ namespace umbraco /// public static bool isXmlContentCacheDisabled { - get - { - try - { - bool xmlCacheEnabled; - string value = GetKey("/settings/content/XmlCacheEnabled"); - if (bool.TryParse(value, out xmlCacheEnabled)) - return !xmlCacheEnabled; - // Return default - return false; - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.IsXmlContentCacheDisabled; } } /// @@ -916,22 +495,7 @@ namespace umbraco /// public static bool XmlContentCheckForDiskChanges { - get - { - try - { - bool checkForDiskChanges; - string value = GetKey("/settings/content/XmlContentCheckForDiskChanges"); - if (bool.TryParse(value, out checkForDiskChanges)) - return checkForDiskChanges; - // Return default - return false; - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.XmlContentCheckForDiskChanges; } } /// @@ -941,22 +505,7 @@ namespace umbraco /// public static bool EnableGlobalPreviewStorage { - get - { - try - { - bool globalPreviewEnabled = false; - string value = GetKey("/settings/content/GlobalPreviewStorageEnabled"); - if (bool.TryParse(value, out globalPreviewEnabled)) - return !globalPreviewEnabled; - // Return default - return false; - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.EnableGlobalPreviewStorage; } } /// @@ -967,32 +516,18 @@ namespace umbraco /// public static bool UseLegacyXmlSchema { - get - { - string value = GetKey("/settings/content/UseLegacyXmlSchema"); - bool result; - if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out result)) - return result; - return true; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.UseLegacyXmlSchema; } } + public static IEnumerable AppCodeFileExtensionsList + { + get { return Umbraco.Core.Configuration.UmbracoSettings.AppCodeFileExtensionsList; } + } + + [Obsolete("Use AppCodeFileExtensionsList instead")] public static XmlNode AppCodeFileExtensions { - get - { - XmlNode value = GetKeyAsNode("/settings/developer/appCodeFileExtensions"); - if (value != null) - { - return value; - } - - // default is .cs and .vb - value = _umbracoSettings.CreateElement("appCodeFileExtensions"); - value.AppendChild(xmlHelper.addTextNode(_umbracoSettings, "ext", "cs")); - value.AppendChild(xmlHelper.addTextNode(_umbracoSettings, "ext", "vb")); - return value; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.AppCodeFileExtensions; } } /// @@ -1001,22 +536,7 @@ namespace umbraco /// public static bool continouslyUpdateXmlDiskCache { - get - { - try - { - bool updateDiskCache; - string value = GetKey("/settings/content/ContinouslyUpdateXmlDiskCache"); - if (bool.TryParse(value, out updateDiskCache)) - return updateDiskCache; - // Return default - return false; - } - catch - { - return true; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.ContinouslyUpdateXmlDiskCache; } } /// @@ -1027,50 +547,12 @@ namespace umbraco /// public static bool EnableSplashWhileLoading { - get - { - try - { - bool updateDiskCache; - string value = GetKey("/settings/content/EnableSplashWhileLoading"); - if (bool.TryParse(value, out updateDiskCache)) - return updateDiskCache; - // Return default - return false; - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.EnableSplashWhileLoading; } } - private static bool? _resolveUrlsFromTextString; public static bool ResolveUrlsFromTextString { - get - { - if (_resolveUrlsFromTextString == null) - { - try - { - bool enableDictionaryFallBack; - var value = GetKey("/settings/content/ResolveUrlsFromTextString"); - if (value != null) - if (bool.TryParse(value, out enableDictionaryFallBack)) - _resolveUrlsFromTextString = enableDictionaryFallBack; - } - catch (Exception ex) - { - Trace.WriteLine("Could not load /settings/content/ResolveUrlsFromTextString from umbracosettings.config:\r\n {0}", - ex.Message); - - // set url resolving to true (default (legacy) behavior) to ensure we don't keep writing to trace - _resolveUrlsFromTextString = true; - } - } - return _resolveUrlsFromTextString == true; - } + get { return Umbraco.Core.Configuration.UmbracoSettings.ResolveUrlsFromTextString; } } /// @@ -1085,18 +567,7 @@ namespace umbraco /// true if enabled; otherwise, false. public static bool Enabled { - get - { - try - { - return - bool.Parse(GetKeyAsNode("/settings/webservices").Attributes.GetNamedItem("enabled").Value); - } - catch - { - return false; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.WebServices.Enabled; } } #region "Webservice configuration" @@ -1107,17 +578,7 @@ namespace umbraco /// The document service users. public static string[] documentServiceUsers { - get - { - try - { - return GetKey("/settings/webservices/documentServiceUsers").Split(','); - } - catch - { - return new string[0]; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.WebServices.DocumentServiceUsers; } } /// @@ -1126,17 +587,7 @@ namespace umbraco /// The file service users. public static string[] fileServiceUsers { - get - { - try - { - return GetKey("/settings/webservices/fileServiceUsers").Split(','); - } - catch - { - return new string[0]; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.WebServices.FileServiceUsers; } } @@ -1146,17 +597,7 @@ namespace umbraco /// The file service folders. public static string[] fileServiceFolders { - get - { - try - { - return GetKey("/settings/webservices/fileServiceFolders").Split(','); - } - catch - { - return new string[0]; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.WebServices.FileServiceFolders; } } /// @@ -1165,17 +606,7 @@ namespace umbraco /// The member service users. public static string[] memberServiceUsers { - get - { - try - { - return GetKey("/settings/webservices/memberServiceUsers").Split(','); - } - catch - { - return new string[0]; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.WebServices.MemberServiceUsers; } } /// @@ -1184,17 +615,7 @@ namespace umbraco /// The stylesheet service users. public static string[] stylesheetServiceUsers { - get - { - try - { - return GetKey("/settings/webservices/stylesheetServiceUsers").Split(','); - } - catch - { - return new string[0]; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.WebServices.StylesheetServiceUsers; } } /// @@ -1203,17 +624,7 @@ namespace umbraco /// The template service users. public static string[] templateServiceUsers { - get - { - try - { - return GetKey("/settings/webservices/templateServiceUsers").Split(','); - } - catch - { - return new string[0]; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.WebServices.TemplateServiceUsers; } } /// @@ -1222,17 +633,7 @@ namespace umbraco /// The media service users. public static string[] mediaServiceUsers { - get - { - try - { - return GetKey("/settings/webservices/mediaServiceUsers").Split(','); - } - catch - { - return new string[0]; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.WebServices.MediaServiceUsers; } } @@ -1242,17 +643,7 @@ namespace umbraco /// The maintenance service users. public static string[] maintenanceServiceUsers { - get - { - try - { - return GetKey("/settings/webservices/maintenanceServiceUsers").Split(','); - } - catch - { - return new string[0]; - } - } + get { return Umbraco.Core.Configuration.UmbracoSettings.WebServices.MaintenanceServiceUsers; } } #endregion diff --git a/src/umbraco.businesslogic/umbraco.businesslogic.csproj b/src/umbraco.businesslogic/umbraco.businesslogic.csproj index b4bfe1530c..7950351e24 100644 --- a/src/umbraco.businesslogic/umbraco.businesslogic.csproj +++ b/src/umbraco.businesslogic/umbraco.businesslogic.csproj @@ -119,6 +119,10 @@ System.XML + + {31785BC3-256C-4613-B2F5-A1B0BDDED8C1} + Umbraco.Core + {C7CB79F0-1C97-4B33-BFA7-00731B579AE2} umbraco.datalayer diff --git a/src/umbraco.businesslogic/xmlHelper.cs b/src/umbraco.businesslogic/xmlHelper.cs index 3fafbbaf65..5eb07b5309 100644 --- a/src/umbraco.businesslogic/xmlHelper.cs +++ b/src/umbraco.businesslogic/xmlHelper.cs @@ -7,6 +7,7 @@ namespace umbraco /// /// The xmlHelper class contains general helper methods for working with xml in umbraco. /// + [Obsolete("Use Umbraco.Core.XmlHelper instead")] public class xmlHelper { /// @@ -17,8 +18,7 @@ namespace umbraco /// public static XmlNode ImportXmlNodeFromText(string text, ref XmlDocument xmlDoc) { - xmlDoc.LoadXml(text); - return xmlDoc.FirstChild; + return Umbraco.Core.XmlHelper.ImportXmlNodeFromText(text, ref xmlDoc); } /// @@ -28,17 +28,7 @@ namespace umbraco /// Returns a XmlDocument class public static XmlDocument OpenAsXmlDocument(string filePath) { - - XmlTextReader reader = new XmlTextReader(IOHelper.MapPath(filePath)); - - reader.WhitespaceHandling = WhitespaceHandling.All; - XmlDocument xmlDoc = new XmlDocument(); - //Load the file into the XmlDocument - xmlDoc.Load(reader); - //Close off the connection to the file. - reader.Close(); - - return xmlDoc; + return Umbraco.Core.XmlHelper.OpenAsXmlDocument(filePath); } /// @@ -50,9 +40,7 @@ namespace umbraco /// a XmlAttribute public static XmlAttribute addAttribute(XmlDocument Xd, string Name, string Value) { - XmlAttribute temp = Xd.CreateAttribute(Name); - temp.Value = Value; - return temp; + return Umbraco.Core.XmlHelper.AddAttribute(Xd, Name, Value); } /// @@ -64,9 +52,7 @@ namespace umbraco /// a XmlNode public static XmlNode addTextNode(XmlDocument Xd, string Name, string Value) { - XmlNode temp = Xd.CreateNode(XmlNodeType.Element, Name, ""); - temp.AppendChild(Xd.CreateTextNode(Value)); - return temp; + return Umbraco.Core.XmlHelper.AddTextNode(Xd, Name, Value); } /// @@ -78,9 +64,7 @@ namespace umbraco /// A XmlNode public static XmlNode addCDataNode(XmlDocument Xd, string Name, string Value) { - XmlNode temp = Xd.CreateNode(XmlNodeType.Element, Name, ""); - temp.AppendChild(Xd.CreateCDataSection(Value)); - return temp; + return Umbraco.Core.XmlHelper.AddCDataNode(Xd, Name, Value); } /// @@ -90,18 +74,7 @@ namespace umbraco /// the value as a string public static string GetNodeValue(XmlNode n) { - string value = string.Empty; - if (n == null || n.FirstChild == null) - return value; - if (n.FirstChild.Value != null) - { - value = n.FirstChild.Value; - } - else - { - value = n.InnerXml; - } - return value.Replace("", "", "]]>"); + return Umbraco.Core.XmlHelper.GetNodeValue(n); } /// @@ -113,17 +86,7 @@ namespace umbraco /// public static bool CouldItBeXml(string xml) { - if (!string.IsNullOrEmpty(xml)) - { - xml = xml.Trim(); - - if (xml.StartsWith("<") && xml.EndsWith(">")) - { - return true; - } - } - - return false; + return Umbraco.Core.XmlHelper.CouldItBeXml(xml); } /// @@ -136,7 +99,7 @@ namespace umbraco /// Returns an System.Xml.XmlDocument representation of the delimited string data. public static XmlDocument Split(string data, string[] separator, string rootName, string elementName) { - return Split(new XmlDocument(), data, separator, rootName, elementName); + return Umbraco.Core.XmlHelper.Split(data, separator, rootName, elementName); } /// @@ -150,26 +113,7 @@ namespace umbraco /// Returns an System.Xml.XmlDocument representation of the delimited string data. public static XmlDocument Split(XmlDocument xml, string data, string[] separator, string rootName, string elementName) { - // load new XML document. - xml.LoadXml(string.Concat("<", rootName, "/>")); - - // get the data-value, check it isn't empty. - if (!string.IsNullOrEmpty(data)) - { - // explode the values into an array - var values = data.Split(separator, StringSplitOptions.None); - - // loop through the array items. - foreach (string value in values) - { - // add each value to the XML document. - var xn = xmlHelper.addTextNode(xml, elementName, value); - xml.DocumentElement.AppendChild(xn); - } - } - - // return the XML node. - return xml; + return Umbraco.Core.XmlHelper.Split(xml, data, separator, rootName, elementName); } } } diff --git a/src/umbraco.cms/businesslogic/Content.cs b/src/umbraco.cms/businesslogic/Content.cs index f404a06772..9bb9204dd7 100644 --- a/src/umbraco.cms/businesslogic/Content.cs +++ b/src/umbraco.cms/businesslogic/Content.cs @@ -581,7 +581,7 @@ namespace umbraco.cms.businesslogic { if (p.PropertyType.DataTypeDefinition.DataType.Id == uploadField.Id && p.Value.ToString() != "" - && File.Exists(IOHelper.MapPath(p.Value.ToString()))) + && File.Exists(Umbraco.Core.IO.IOHelper.MapPath(p.Value.ToString()))) { isUploadField = true; } diff --git a/src/umbraco.editorControls/tinyMCE3/webcontrol/TinyMCEWebControl.cs b/src/umbraco.editorControls/tinyMCE3/webcontrol/TinyMCEWebControl.cs index 94b076c208..fb77c1b85f 100644 --- a/src/umbraco.editorControls/tinyMCE3/webcontrol/TinyMCEWebControl.cs +++ b/src/umbraco.editorControls/tinyMCE3/webcontrol/TinyMCEWebControl.cs @@ -73,7 +73,7 @@ namespace umbraco.editorControls.tinyMCE3.webcontrol base.Attributes.Add("style", "visibility: hidden"); config.Add("mode", "exact"); config.Add("theme", "umbraco"); - config.Add("umbraco_path", IOHelper.ResolveUrl(SystemDirectories.Umbraco)); + config.Add("umbraco_path", Umbraco.Core.IO.IOHelper.ResolveUrl(Umbraco.Core.IO.SystemDirectories.Umbraco)); CssClass = "tinymceContainer"; plugin.ConfigSection configSection = (plugin.ConfigSection)System.Web.HttpContext.Current.GetSection("TinyMCE"); @@ -218,8 +218,8 @@ namespace umbraco.editorControls.tinyMCE3.webcontrol suffix = "_" + this.mode; outURI = this.InstallPath + "/tiny_mce_src" + suffix + ".js"; - if (!File.Exists(IOHelper.MapPath(outURI))) - throw new Exception("Could not locate TinyMCE by URI:" + outURI + ", Physical path:" + IOHelper.MapPath(outURI) + ". Make sure that you configured the installPath to a valid location in your web.config. This path should be an relative or site absolute URI to where TinyMCE is located."); + if (!File.Exists(Umbraco.Core.IO.IOHelper.MapPath(outURI))) + throw new Exception("Could not locate TinyMCE by URI:" + outURI + ", Physical path:" + Umbraco.Core.IO.IOHelper.MapPath(outURI) + ". Make sure that you configured the installPath to a valid location in your web.config. This path should be an relative or site absolute URI to where TinyMCE is located."); // Collect themes, languages and plugins and build gzip URI // TODO: Make sure gzip is re-enabled @@ -332,7 +332,7 @@ namespace umbraco.editorControls.tinyMCE3.webcontrol // Find the original filename, by removing the might added width and height // NH, 4.8.1 - above replaced by loading the right media file from the db later! orgSrc = - IOHelper.ResolveUrl(orgSrc.Replace("%20", " ")); + Umbraco.Core.IO.IOHelper.ResolveUrl(orgSrc.Replace("%20", " ")); // Check for either id or guid from media string mediaId = getIdFromSource(orgSrc, rootMediaUrl); @@ -364,7 +364,7 @@ namespace umbraco.editorControls.tinyMCE3.webcontrol // Format the tag tempTag = tempTag + " rel=\"" + imageMedia.getProperty("umbracoWidth").Value.ToString() + "," + - imageMedia.getProperty("umbracoHeight").Value.ToString() + "\" src=\"" + IOHelper.ResolveUrl(imageMedia.getProperty("umbracoFile").Value.ToString()) + + imageMedia.getProperty("umbracoHeight").Value.ToString() + "\" src=\"" + Umbraco.Core.IO.IOHelper.ResolveUrl(imageMedia.getProperty("umbracoFile").Value.ToString()) + "\""; tempTag += "/>"; diff --git a/src/umbraco.editorControls/tinymce/tinyMCEImageHelper.cs b/src/umbraco.editorControls/tinymce/tinyMCEImageHelper.cs index f4e31e55bd..79219c0f10 100644 --- a/src/umbraco.editorControls/tinymce/tinyMCEImageHelper.cs +++ b/src/umbraco.editorControls/tinymce/tinyMCEImageHelper.cs @@ -122,7 +122,7 @@ namespace umbraco.editorControls.tinymce { string src = helper.FindAttribute(ht, "src"); //get the media folder, minus the starting '~' - string mediaRoot = SystemDirectories.Media.Replace("~", string.Empty); + string mediaRoot = Umbraco.Core.IO.SystemDirectories.Media.Replace("~", string.Empty); // update orgSrc to remove umbraco reference int mediaRootIndex = src.IndexOf(mediaRoot); diff --git a/src/umbraco.webservices/media/mediaService.cs b/src/umbraco.webservices/media/mediaService.cs index d9fc7df114..fcd4df1399 100644 --- a/src/umbraco.webservices/media/mediaService.cs +++ b/src/umbraco.webservices/media/mediaService.cs @@ -122,9 +122,9 @@ namespace umbraco.webservices.media { Authenticate(username, password); - filename = filename.Replace("/", IOHelper.DirSepChar.ToString()); - filename = filename.Replace(@"\", IOHelper.DirSepChar.ToString()); - filename = filename.Substring(filename.LastIndexOf(IOHelper.DirSepChar) + 1, filename.Length - filename.LastIndexOf(IOHelper.DirSepChar) - 1).ToLower(); + filename = filename.Replace("/", Umbraco.Core.IO.IOHelper.DirSepChar.ToString()); + filename = filename.Replace(@"\", Umbraco.Core.IO.IOHelper.DirSepChar.ToString()); + filename = filename.Substring(filename.LastIndexOf(Umbraco.Core.IO.IOHelper.DirSepChar) + 1, filename.Length - filename.LastIndexOf(Umbraco.Core.IO.IOHelper.DirSepChar) - 1).ToLower(); Media m = new Media(id);