Esempio n. 1
0
        /// <summary>
        /// Method for creating a new version of the data associated to the Content.
        ///
        /// </summary>
        /// <returns>The new version Id</returns>
        protected Guid createNewVersion()
        {
            ClearLoadedProperties();

            Guid newVersion     = Guid.NewGuid();
            bool tempHasVersion = hasVersion();

            foreach (propertytype.PropertyType pt in this.ContentType.PropertyTypes)
            {
                object oldValue = "";
                if (tempHasVersion)
                {
                    try
                    {
                        oldValue = this.getProperty(pt.Alias).Value;
                    }
                    catch { }
                }
                property.Property p = this.addProperty(pt, newVersion);
                if (oldValue != null && oldValue.ToString() != "")
                {
                    p.Value = oldValue;
                }
            }
            SqlHelper.ExecuteNonQuery("Insert into cmsContentVersion (ContentId,versionId) values (" + this.Id + ",'" + newVersion + "')");
            this.Version = newVersion;
            return(newVersion);
        }
Esempio n. 2
0
    /// <summary>
    /// Return a value of a PreValue by Property
    /// </summary>
    /// <param name="parameter">UmbracoType</param>
    /// <param name="value">value as a Property</param>
    /// <returns>Returns the value of the Property if exists, if not returns an empty string</returns>
    public static string PropertyValue(UmbracoType parameter, Property value)
    {
        string result = string.Empty;

        if (value.Value.ToString() != "")
        {
            int id = Convert.ToInt32(GetParameterValue(parameter));
            IEnumerable <PreValue> data = DataTypeValue(id);
            PreValue preValue           = data.SingleOrDefault(dt => dt.Id == Convert.ToInt32(value.Value));
            result = (preValue != null) ? preValue.Value : string.Empty;
        }
        return(result);
    }
Esempio n. 3
0
    /// <summary>
    /// Get the Content of a UComponenet Grid
    /// </summary>
    /// <param name="property">Property</param>
    /// <returns>List of dymamic objects</returns>
    public static IEnumerable <dynamic> GetDataTypeGrid(Property property)
    {
        List <dynamic> result = new List <dynamic>();

        if (property != null)
        {
            foreach (XElement element in XDocument.Parse(property.Value.ToString()).Descendants("item"))
            {
                dynamic data = new ExpandoObject();
                ((IDictionary <string, object>)data).Add("id", element.Attribute("id").Value);
                ((IDictionary <string, object>)data).Add("sortorder", element.Attribute("sortOrder").Value);
                foreach (XElement item in element.Descendants())
                {
                    ((IDictionary <string, object>)data).Add(item.Name.LocalName, item.Value);
                }
                result.Add(data);
            }
        }
        return(result);
    }
Esempio n. 4
0
        /// <summary>
        /// Method for creating a new version of the data associated to the Content.
        ///
        /// </summary>
        /// <returns>The new version Id</returns>
        protected Guid createNewVersion(DateTime versionDate = default(DateTime))
        {
            if (versionDate == default(DateTime))
            {
                versionDate = DateTime.Now;
            }

            ClearLoadedProperties();

            Guid newVersion     = Guid.NewGuid();
            bool tempHasVersion = hasVersion();

            // we need to ensure that a version in the db exist before we add related data
            SqlHelper.ExecuteNonQuery("Insert into cmsContentVersion (ContentId,versionId,versionDate) values (" + this.Id + ",'" + newVersion + "', @updateDate)",
                                      SqlHelper.CreateParameter("@updateDate", versionDate));

            List <PropertyType> pts = ContentType.PropertyTypes;

            foreach (propertytype.PropertyType pt in pts)
            {
                object oldValue = "";
                if (tempHasVersion)
                {
                    try
                    {
                        oldValue = this.getProperty(pt.Alias).Value;
                    }
                    catch { }
                }
                property.Property p = this.addProperty(pt, newVersion);
                if (oldValue != null && oldValue.ToString() != "")
                {
                    p.Value = oldValue;
                }
            }
            this.Version = newVersion;
            return(newVersion);
        }
Esempio n. 5
0
        /// <summary>
        /// Loads all properties from database into objects. If this method is re-called, it will re-query the database.
        /// </summary>
        /// <remarks>
        /// This optimizes sql calls. This will first check if all of the properties have been loaded. If not,
        /// then it will query for all property types for the current version from the db. It will then iterate over each
        /// cmdPropertyData row and store the id and propertyTypeId in a list for lookup later. Once the records have been
        /// read, we iterate over the cached property types for this ContentType and create a new property based on
        /// our stored list of proeprtyTypeIds. We then have a cached list of Property objects which will get returned
        /// on all subsequent calls and is also used to return a property with calls to getProperty.
        /// </remarks>
        private void InitializeProperties()
        {
            _loadedProperties = new Properties();

            if (ContentBase != null)
            {
                //NOTE: we will not load any properties where HasIdentity = false - this is because if properties are
                // added to the property collection that aren't persisted we'll get ysods
                _loadedProperties.AddRange(ContentBase.Properties.Where(x => x.HasIdentity).Select(x => new Property(x)));
                return;
            }

            if (this.ContentType == null)
            {
                return;
            }

            //Create anonymous typed list with 2 props, Id and PropertyTypeId of type Int.
            //This will still be an empty list since the props list is empty.
            var propData = _loadedProperties.Select(x => new { Id = 0, PropertyTypeId = 0 }).ToList();

            string sql = @"select id, propertyTypeId from cmsPropertyData where versionId=@versionId";

            using (var sqlHelper = Application.SqlHelper)
                using (IRecordsReader dr = sqlHelper.ExecuteReader(sql,
                                                                   sqlHelper.CreateParameter("@versionId", Version)))
                {
                    while (dr.Read())
                    {
                        //add the item to our list
                        propData.Add(new { Id = dr.Get <int>("id"), PropertyTypeId = dr.Get <int>("propertyTypeId") });
                    }
                }

            foreach (PropertyType pt in this.ContentType.PropertyTypes)
            {
                if (pt == null)
                {
                    continue;
                }

                //get the propertyId
                var property = propData.LastOrDefault(x => x.PropertyTypeId == pt.Id);
                if (property == null)
                {
                    continue;
                    //var prop = Property.MakeNew(pt, this, Version);
                    //property = new {Id = prop.Id, PropertyTypeId = pt.Id};
                }
                var propertyId = property.Id;

                Property p = null;
                try
                {
                    p = new Property(propertyId, pt);
                }
                catch
                {
                    continue; //this remains from old code... not sure why we would do this?
                }

                _loadedProperties.Add(p);
            }
        }
Esempio n. 6
0
        public static void SetDefaultValuesOnNew(Document newDocument, umbraco.cms.businesslogic.NewEventArgs e)
        {
            log.Info("SetDefaultValuesOnNew Startet");
            log.InfoFormat("Document id: {1} - Document Type Alias: {0}", newDocument.ContentType.Alias, newDocument.Id);
            // We wrap it in a try since this part should not break for the user in umbraco
            try
            {
                string path = newDocument.Path;
                if (string.IsNullOrEmpty(path))
                {
                    StopWithError("Path on new document not found!");
                    return;
                }

                string[] strings      = StringUtil.Split(path, ",", true);
                string   strHomeDocId = strings[1];

                // Now we have the doc home id, lets see if the default value document based on document type alias exists
                string cacheKeyDefaultValueDocumentTypeAlias = string.Format("SetDefaultValuesOnNew#homeDoc:{0}#DefaultValueDocumentTypeAlias:{1}", strHomeDocId, newDocument.ContentType.Alias);
                int    defaultValueDocId = -1;
                if (CacheUtil.Exist(cacheKeyDefaultValueDocumentTypeAlias))
                {
                    defaultValueDocId = CacheUtil.Get <int>(cacheKeyDefaultValueDocumentTypeAlias);
                }
                else
                {
                    // Does not exist in the cache, lets try to look it up
                    int defaultValuesFolderDocId = GetDefaultValuesFolderId(strHomeDocId);
                    if (defaultValuesFolderDocId == -1)
                    {
                        StopWithError("Could not load default values folder id!");
                        return;
                    }

                    // For speed we use the published node factory
                    Node node = UmbracoUtil.GetNode(defaultValuesFolderDocId);
                    if (node == null)
                    {
                        StopWithError(string.Format("Could not load published node for default values folder id: {0}!", defaultValuesFolderDocId));
                        return;
                    }

                    Node defaultValueNode = node.GetDescendantViaDocumentTypePath(newDocument.ContentType.Alias);
                    if (defaultValueNode != null)
                    {
                        defaultValueDocId = defaultValueNode.Id;
                        CacheUtil.Insert(cacheKeyDefaultValueDocumentTypeAlias, defaultValueDocId, 10, false);
                    }
                    else
                    {
                        log.DebugFormat("No default node for document type alias: {0}", newDocument.ContentType.Alias);
                    }
                }

                if (defaultValueDocId > -1)
                {
                    Document defaultValueDocument = new Document(true, defaultValueDocId);

                    log.DebugFormat("ContentType {0} match. Let's start copying", newDocument.ContentType.Alias);

                    umbraco.cms.businesslogic.property.Properties newDocumentProperties  = newDocument.GenericProperties;
                    umbraco.cms.businesslogic.property.Properties defaultValueProperties = defaultValueDocument.GenericProperties;

                    for (int i = 0; i < newDocumentProperties.Count; i++)
                    {
                        umbraco.cms.businesslogic.property.Property newDocumentProperty     = newDocumentProperties[i];
                        umbraco.cms.businesslogic.property.Property defaultDocumentProperty = defaultValueProperties[i];

                        if (newDocumentProperty.Value != defaultDocumentProperty.Value)
                        {
                            log.DebugFormat("Set value on property alias {0}", newDocumentProperty.PropertyType.Alias);
                            newDocumentProperty.Value = defaultDocumentProperty.Value;
                        }
                    }
                }
                log.Info("SetDefaultValuesOnNew Ended");
            }
            catch (Exception ex)
            {
                log.Error("Could not complete SetDefaultValuesOnNew - stopped with exception", ex);
            }
        }
Esempio n. 7
0
        /// <summary>
        /// Loads all properties from database into objects. If this method is re-called, it will re-query the database.
        /// </summary>
        /// <remarks>
        /// This optimizes sql calls. This will first check if all of the properties have been loaded. If not, 
        /// then it will query for all property types for the current version from the db. It will then iterate over each
        /// cmdPropertyData row and store the id and propertyTypeId in a list for lookup later. Once the records have been 
        /// read, we iterate over the cached property types for this ContentType and create a new property based on
        /// our stored list of proeprtyTypeIds. We then have a cached list of Property objects which will get returned
        /// on all subsequent calls and is also used to return a property with calls to getProperty.
        /// </remarks>
        private void InitializeProperties()
        {
            m_LoadedProperties = new Properties();

            if (ContentBase != null)
            {
                m_LoadedProperties.AddRange(ContentBase.Properties.Select(x => new Property(x)));
                return;
            }

            if (this.ContentType == null)
                return;

            //Create anonymous typed list with 2 props, Id and PropertyTypeId of type Int.
            //This will still be an empty list since the props list is empty.
            var propData = m_LoadedProperties.Select(x => new { Id = 0, PropertyTypeId = 0 }).ToList();

            string sql = @"select id, propertyTypeId from cmsPropertyData where versionId=@versionId";

            using (IRecordsReader dr = SqlHelper.ExecuteReader(sql,
                SqlHelper.CreateParameter("@versionId", Version)))
            {
                while (dr.Read())
                {
                    //add the item to our list
                    propData.Add(new { Id = dr.Get<int>("id"), PropertyTypeId = dr.Get<int>("propertyTypeId") });
                }
            }

            foreach (PropertyType pt in this.ContentType.PropertyTypes)
            {
                if (pt == null)
                    continue;

                //get the propertyId
                var property = propData.LastOrDefault(x => x.PropertyTypeId == pt.Id);
                if (property == null)
                {
                    continue;
                    //var prop = Property.MakeNew(pt, this, Version);
                    //property = new {Id = prop.Id, PropertyTypeId = pt.Id};
                }
                var propertyId = property.Id;

                Property p = null;
                try
                {
                    p = new Property(propertyId, pt);
                }
                catch
                {
                    continue; //this remains from old code... not sure why we would do this?
                }

                m_LoadedProperties.Add(p);
            }
        }
Esempio n. 8
0
        public static void ReadProperties(Type contentType, Content content, object output)
        {
            foreach (PropertyInfo propInfo in contentType.GetProperties(BindingFlags.Public | BindingFlags.Instance))
            {
                DocumentTypePropertyAttribute propAttr = Util.GetAttribute <DocumentTypePropertyAttribute>(propInfo);
                if (propAttr == null)
                {
                    continue;     // skip this property - not part of a Document Type
                }

                string propertyName;
                string propertyAlias;
                DocumentTypeManager.ReadPropertyNameAndAlias(propInfo, propAttr, out propertyName, out propertyAlias);

                umbraco.cms.businesslogic.property.Property property = content.getProperty(propertyAlias);

                object value = null;
                try
                {
                    if (property == null)
                    {
                        value = null;
                    }
                    else if (propInfo.PropertyType.Equals(typeof(System.Boolean)))
                    {
                        if (String.IsNullOrEmpty(Convert.ToString(property.Value)) || Convert.ToString(property.Value) == "0")
                        {
                            value = false;
                        }
                        else
                        {
                            value = true;
                        }
                    }
                    else if (PropertyConvertors.ContainsKey(propInfo.PropertyType))
                    {
                        value = ContentUtil.GetInnerXml(content.Id.ToString(), propertyAlias);
                    }
                    else if (String.IsNullOrEmpty(Convert.ToString(property.Value)))
                    {
                        // if property type is string or if it's some custom type, try to get the inner xml of this property within a node.
                        if (propInfo.PropertyType == typeof(string) ||
                            PropertyConvertors.ContainsKey(propInfo.PropertyType))
                        {
                            value = ContentUtil.GetInnerXml(content.Id.ToString(), propertyAlias);
                            if (value == null && propInfo.PropertyType == typeof(string))
                            {
                                value = string.Empty;
                            }
                        }
                        else
                        {
                            value = null;
                        }
                    }
                    else if (propInfo.PropertyType.IsGenericType &&
                             propInfo.PropertyType.GetGenericTypeDefinition() == typeof(Nullable <>))
                    {
                        value = Convert.ChangeType(property.Value, Nullable.GetUnderlyingType(propInfo.PropertyType));

                        // TODO: If data type is DateTime and is nullable and is less than 1.1.1000 than set it to NULL
                    }
                    else
                    {
                        value = Convert.ChangeType(property.Value, propInfo.PropertyType);
                    }

                    if (PropertyConvertors.ContainsKey(propInfo.PropertyType))
                    {
                        value = PropertyConvertors[propInfo.PropertyType].ConvertValueWhenRead(value);
                    }

                    propInfo.SetValue(output, value, null);
                }
                catch (Exception exc)
                {
                    throw new Exception(string.Format("Cannot set the value of a document type property {0}.{1} (document type: {2}) to value: '{3}' (value type: {4}). Error: {5}",
                                                      contentType.Name, propInfo.Name, propInfo.PropertyType.FullName,
                                                      value, value != null ? value.GetType().FullName : "", exc.Message));
                }
            }
        }
Esempio n. 9
0
 /// <summary>
 /// Return a value of a PreValue by Property
 /// </summary>
 /// <param name="parameter">UmbracoType</param>
 /// <param name="value">value as a Property</param>
 /// <returns>Returns the value of the Property if exists, if not returns an empty string</returns>
 public static string PropertyValue(UmbracoType parameter, Property value)
 {
     string result = string.Empty;
     if (value.Value.ToString() != "")
     {
         int id = Convert.ToInt32(GetParameterValue(parameter));
         IEnumerable<PreValue> data = DataTypeValue(id);
         PreValue preValue = data.SingleOrDefault(dt => dt.Id == Convert.ToInt32(value.Value));
         result = (preValue != null) ? preValue.Value : string.Empty;
     }
     return result;
 }
Esempio n. 10
0
 /// <summary>
 /// Get the Content of a UComponenet Grid
 /// </summary>
 /// <param name="property">Property</param>
 /// <returns>List of dymamic objects</returns>
 public static IEnumerable<dynamic> GetDataTypeGrid(Property property)
 {
     List<dynamic> result = new List<dynamic>();
     if (property != null)
     {
         foreach (XElement element in XDocument.Parse(property.Value.ToString()).Descendants("item"))
         {
             dynamic data = new ExpandoObject();
             ((IDictionary<string, object>)data).Add("id", element.Attribute("id").Value);
             ((IDictionary<string, object>)data).Add("sortorder", element.Attribute("sortOrder").Value);
             foreach (XElement item in element.Descendants())
             {
                 ((IDictionary<string, object>)data).Add(item.Name.LocalName, item.Value);
             }
             result.Add(data);
         }
     }
     return result;
 }