C# IContentService.GetById方法代码示例

        public DomainManagerDomain(umbraco.cms.businesslogic.web.Domain domain, IContentService contentService)
        {
            if (domain == null || contentService == null)
                return;

            Id = domain.Id;
            Culture = domain.Language.CultureAlias;
            Name = domain.Name.Equals("*" + domain.RootNodeId) ? "-" : domain.Name;
            RootNodeId = domain.RootNodeId;

            var rootNode = contentService.GetById(RootNodeId);
            if (rootNode != null)
            {
                RootNodeName = rootNode.Name;
            }
        }

        /// <summary>
        /// Resolves the item.
        /// </summary>
        /// <param name="target">The target.</param>
        /// <param name="contentService">The content service.</param>
        /// <returns></returns>
        /// <exception cref="System.NotSupportedException">
        /// You can not save a class that does not contain a property that represents the item ID. Ensure that at least one property has the UmbracoIdAttribute
        /// or
        /// Can not get ID for item
        /// </exception>
        public IContent ResolveItem(object target, IContentService contentService)
        {
            Guid versionNumber = default(Guid);

            if (IdConfig == null)
                throw new NotSupportedException(
                    "You can not save a class that does not contain a property that represents the item ID. Ensure that at least one property has the UmbracoIdAttribute");

            if (IdConfig.PropertyInfo.PropertyType == typeof(int))
            {
                var id = (int)IdConfig.PropertyInfo.GetValue(target, null);
                return contentService.GetById(id);
            }
            
            if (IdConfig.PropertyInfo.PropertyType == typeof(Guid))
            {
                var id = (Guid)IdConfig.PropertyInfo.GetValue(target, null);
                return contentService.GetById(id);
            }

            if (VersionConfig != null)
            {
                versionNumber = (Guid)VersionConfig.PropertyInfo.GetValue(target, null);
            }

            if (versionNumber != default(Guid))
            {
                return contentService.GetByVersion(versionNumber);
            }

            throw new NotSupportedException("Can not get ID for item");
        }

        /// <summary>
        /// Performs a permissions check for the user to check if it has access to the node based on 
        /// start node and/or permissions for the node
        /// </summary>
        /// <param name="storage">The storage to add the content item to so it can be reused</param>
        /// <param name="user"></param>
        /// <param name="userService"></param>
        /// <param name="contentService"></param>
        /// <param name="nodeId">The content to lookup, if the contentItem is not specified</param>
        /// <param name="permissionsToCheck"></param>
        /// <param name="contentItem">Specifies the already resolved content item to check against</param>
        /// <returns></returns>
        internal static bool CheckPermissions(
            IDictionary<string, object> storage,
            IUser user,
            IUserService userService,
            IContentService contentService,
            int nodeId,
            char[] permissionsToCheck = null,
            IContent contentItem = null)
        {
           
            if (contentItem == null && nodeId != Constants.System.Root && nodeId != Constants.System.RecycleBinContent)
            {
                contentItem = contentService.GetById(nodeId);
                //put the content item into storage so it can be retreived 
                // in the controller (saves a lookup)
                storage[typeof(IContent).ToString()] = contentItem;
            }

            if (contentItem == null && nodeId != Constants.System.Root && nodeId != Constants.System.RecycleBinContent)
            {
                throw new HttpResponseException(HttpStatusCode.NotFound);
            }

            var hasPathAccess = (nodeId == Constants.System.Root)
                                    ? UserExtensions.HasPathAccess(
                                        Constants.System.Root.ToInvariantString(),
                                        user.StartContentId,
                                        Constants.System.RecycleBinContent)
                                    : (nodeId == Constants.System.RecycleBinContent)
                                          ? UserExtensions.HasPathAccess(
                                              Constants.System.RecycleBinContent.ToInvariantString(),
                                              user.StartContentId,
                                              Constants.System.RecycleBinContent)
                                          : user.HasPathAccess(contentItem);

            if (hasPathAccess == false)
            {
                return false;
            }

            if (permissionsToCheck == null || permissionsToCheck.Any() == false)
            {
                return true;
            }

            var permission = userService.GetPermissions(user, nodeId).FirstOrDefault();

            var allowed = true;
            foreach (var p in permissionsToCheck)
            {
                if (permission == null || permission.AssignedPermissions.Contains(p.ToString(CultureInfo.InvariantCulture)) == false)
                {
                    allowed = false;
                }
            }
            return allowed;
        }