public static bool PublishPost(Core core, Job job)
        {
            core.LoadUserProfile(job.UserId);
            User owner = core.PrimitiveCache[job.UserId];
            ItemKey sharedItemKey = new ItemKey(job.ItemId, job.ItemTypeId);
            IActionableItem sharedItem = null;

            core.ItemCache.RequestItem(sharedItemKey);
            try
            {
                sharedItem = (IActionableItem)core.ItemCache[sharedItemKey];
            }
            catch
            {
                try
                {
                    sharedItem = (IActionableItem)NumberedItem.Reflect(core, sharedItemKey);
                    HttpContext.Current.Response.Write("<br />Fallback, had to reflect: " + sharedItemKey.ToString());
                }
                catch
                {
                    return true; // Item is probably deleted, report success to delete from queue
                }
            }

            UpdateQuery uQuery = new UpdateQuery(typeof(ItemInfo));
            uQuery.AddCondition("info_item_id", sharedItemKey.Id);
            uQuery.AddCondition("info_item_type_id", sharedItemKey.TypeId);

            try
            {
                if (owner.UserInfo.FacebookAuthenticated) // are we still authenticated
                {
                    string postDescription = job.Body;

                    Facebook fb = new Facebook(core.Settings.FacebookApiAppid, core.Settings.FacebookApiSecret);

                    FacebookAccessToken token = fb.OAuthAppAccessToken(core, owner.UserInfo.FacebookUserId);
                    FacebookPost post = fb.StatusesUpdate(token, postDescription, sharedItem.Info.ShareUri, owner.UserInfo.FacebookSharePermissions);

                    if (post != null)
                    {
                        uQuery.AddField("info_facebook_post_id", post.PostId);
                    }

                    core.Db.Query(uQuery);
                }
            }
            catch (System.Net.WebException ex)
            {
                HttpWebResponse response = (HttpWebResponse)ex.Response;
                if (response.StatusCode == HttpStatusCode.Forbidden)
                {
                    return true; // This request cannot succeed, so remove it from the queue
                }
                return false; // Failed for other reasons, retry
            }

            return true; // success
        }

        public static void Show(Core core)
        {
            string path = core.Http.Query["path"];
            long ownerId = core.Functions.RequestLong("owner_id", 0);
            long ownerTypeId = core.Functions.RequestLong("owner_type_id", 0);
            ItemKey ownerKey = new ItemKey(ownerId, ownerTypeId);

            try
            {
                core.PrimitiveCache.LoadPrimitiveProfile(ownerKey);
                Primitive owner = core.PrimitiveCache[ownerKey];

                Page thePage = new Page(core, owner, path);

                JsonSerializer js;
                StringWriter jstw;
                JsonTextWriter jtw;

                js = new JsonSerializer();
                jstw = new StringWriter();
                jtw = new JsonTextWriter(jstw);

                js.NullValueHandling = NullValueHandling.Ignore;

                core.Http.WriteJson(js, thePage);
            }
            catch (PageNotFoundException)
            {

            }
            catch
            {
            }
        }

 public AjaxPermissionGroupDictionaryItem(ItemKey ik, string value, string tile)
 {
     this.Id = ik.Id;
     this.TypeId = ik.TypeId;
     this.Value = value;
     this.Tile = tile;
 }

        public static bool PublishPost(Core core, Job job)
        {
            core.LoadUserProfile(job.UserId);
            User owner = core.PrimitiveCache[job.UserId];
            ItemKey sharedItemKey = new ItemKey(job.ItemId, job.ItemTypeId);
            IActionableItem sharedItem = null;

            core.ItemCache.RequestItem(sharedItemKey);
            try
            {
                sharedItem = (IActionableItem)core.ItemCache[sharedItemKey];
            }
            catch
            {
                try
                {
                    sharedItem = (IActionableItem)NumberedItem.Reflect(core, sharedItemKey);
                    HttpContext.Current.Response.Write("<br />Fallback, had to reflect: " + sharedItemKey.ToString());
                }
                catch
                {
                    job.Cancel = true;
                    return true; // Item is probably deleted, report success to delete from queue
                }
            }

            UpdateQuery uQuery = new UpdateQuery(typeof(ItemInfo));
            uQuery.AddCondition("info_item_id", sharedItemKey.Id);
            uQuery.AddCondition("info_item_type_id", sharedItemKey.TypeId);

            try
            {
                if (owner.UserInfo.TumblrAuthenticated) // are we still authenticated
                {
                    string postDescription = job.Body;

                    Tumblr t = new Tumblr(core.Settings.TumblrApiKey, core.Settings.TumblrApiSecret);
                    TumblrPost post = t.StatusesUpdate(new TumblrAccessToken(owner.UserInfo.TumblrToken, owner.UserInfo.TumblrTokenSecret), owner.UserInfo.TumblrHostname, sharedItem.PostType, string.Empty, postDescription, sharedItem.Info.ShareUri, sharedItem.Data, sharedItem.DataContentType);

                    if (post != null)
                    {
                        uQuery.AddField("info_tumblr_post_id", post.Id);
                    }

                    core.Db.Query(uQuery);
                }
            }
            catch (System.Net.WebException ex)
            {
                HttpWebResponse response = (HttpWebResponse)ex.Response;
                if (response.StatusCode == HttpStatusCode.Forbidden)
                {
                    return true; // This request cannot succeed, so remove it from the queue
                }
                job.Error = ex.ToString();
                return false; // Failed for other reasons, retry
            }

            return true; // success
        }

 public Primitive this[ItemKey key]
 {
     get
     {
         return (Primitive)core.ItemCache[key];
     }
 }

 public UnsavedAccessControlGrant(Core core, ItemKey primitiveKey, ItemKey itemKey, long permissionId, AccessControlGrants grantAllow)
 {
     this.core = core;
     this.itemKey = itemKey;
     this.primitiveKey = primitiveKey;
     this.permissionId = permissionId;
     this.grantAllow = (sbyte)grantAllow;
 }

        internal Access(Core core, ItemKey key, Primitive leafOwner)
        {
            if (core == null)
            {
                throw new NullCoreException();
            }

            this.core = core;
            this.item = null;
            this.owner = leafOwner;
            this.itemKey = key;
            this.viewer = core.Session.LoggedInMember;
        }

        public PermissionGroupSelectBox(Core core, string name, ItemKey permissibleItem, List<PrimitivePermissionGroup> itemKeys)
        {
            this.core = core;
            this.name = name;
            this.permissibleItem = permissibleItem;
            this.itemKeys = itemKeys;

            disabled = false;
            visible = true;

            width = new StyleLength(100F, LengthUnits.Percentage);
            script = new ScriptProperty();
        }

        public bool IsNetworkMember(ItemKey key)
        {
            if (key != null)
            {
                if (networkMemberCache.ContainsKey(key))
                {
                    return networkMemberCache[key];
                }
                else
                {
                    DataTable memberTable = db.Query(string.Format("SELECT user_id FROM network_members WHERE network_id = {0} AND user_id = {1} AND member_active = 1",
                        networkId, key.Id));

                    if (memberTable.Rows.Count > 0)
                    {
                        networkMemberCache.Add(key, true);
                        return true;
                    }
                    else
                    {
                        networkMemberCache.Add(key, false);
                        return false;
                    }
                }
            }

            return false;
        }

 public void LoadPrimitiveProfile(ItemKey key)
 {
     core.ItemCache.RequestItem(key);
 }

        public override void ExecuteCall(string callName)
        {
            switch (callName)
            {
                case "list_galleries":
                    {
                        long ownerId = core.Functions.RequestLong("owner_id", core.Session.LoggedInMember.Id);
                        long ownerTypeId = core.Functions.RequestLong("owner_type_id", core.Session.LoggedInMember.ItemKey.TypeId);
                        long galleryId = core.Functions.RequestLong("gallery_id", 0);
                        ItemKey ownerKey = new ItemKey(ownerId, ownerTypeId);

                        Gallery gallery = null;
                        if (galleryId > 0)
                        {
                            gallery = new Gallery(core, galleryId);
                        }
                        else
                        {
                            core.PrimitiveCache.LoadPrimitiveProfile(ownerKey);
                            Primitive owner = core.PrimitiveCache[ownerKey];

                            gallery = new Gallery(core, owner);
                        }

                        if (gallery != null)
                        {
                            if (gallery.Access.Can("VIEW"))
                            {
                                List<Gallery> galleries = gallery.GetGalleries();
                                List<Gallery> responseGalleries = new List<Gallery>();

                                foreach (Gallery g in galleries)
                                {
                                    if (gallery.Access.Can("VIEW"))
                                    {
                                        responseGalleries.Add(g);
                                    }
                                }

                                core.Response.WriteObject(responseGalleries);
                            }
                            else
                            {

                            }
                        }
                    }
                    break;
                case "list_gallery_items":
                    {
                        long galleryId = core.Functions.RequestLong("gallery_id", 0);
                        long offsetId = core.Functions.RequestLong("offset_id", 0);

                        Gallery gallery = null;
                        if (galleryId > 0)
                        {
                            gallery = new Gallery(core, galleryId);
                        }

                        if (gallery != null)
                        {
                            if (gallery.Access.Can("VIEW_ITEMS"))
                            {
                                List<GalleryItem> galleryItems = gallery.GetItems(core, 1, 12, offsetId);

                                core.Response.WriteObject(galleryItems);
                            }
                        }
                    }
                    break;
                case "gallery_item":
                    GalleryItem.Show(core);
                    break;
                case "upload":
                    Gallery.Upload(core);
                    break;
            }
        }

 public ItemSubscribedEventArgs(User rater, ItemKey itemKey)
 {
     this.rater = rater;
     this.itemKey = itemKey;
 }

        public void ParseACL(Template template, Primitive owner, string variable)
        {
            Template aclTemplate = new Template("std.acl.html");
            aclTemplate.Medium = core.Template.Medium;
            aclTemplate.SetProse(core.Prose);

            if (itemPermissions == null)
            {
                itemPermissions = GetPermissions(core, item);
            }
            if (itemGrants == null)
            {
                itemGrants = AccessControlGrant.GetGrants(core, item);
            }
            if (unsavedGrants == null)
            {
                unsavedGrants = new List<UnsavedAccessControlGrant>();
            }

            if (itemGrants != null)
            {
                foreach (AccessControlGrant itemGrant in itemGrants)
                {
                    core.PrimitiveCache.LoadPrimitiveProfile(itemGrant.PrimitiveKey);
                }
            }

            bool simple = item.IsSimplePermissions;

            string mode = core.Http["aclmode"];
            switch (mode)
            {
                case "simple":
                    simple = true;
                    break;
                case "detailed":
                    simple = false;
                    break;
            }

            bool first = true;
            PermissionTypes lastType = PermissionTypes.View;
            VariableCollection permissionTypeVariableCollection = null;

            PermissionGroupSelectBox typeGroupSelectBox = null;
            List<PrimitivePermissionGroup> ownerGroups = null;

            if (itemPermissions != null)
            {
                foreach (AccessControlPermission itemPermission in itemPermissions)
                {
                    if (first || itemPermission.PermissionType != lastType)
                    {
                        if (typeGroupSelectBox != null)
                        {
                            permissionTypeVariableCollection.Parse("S_SIMPLE_SELECT", typeGroupSelectBox);
                        }

                        permissionTypeVariableCollection = aclTemplate.CreateChild("permision_types");
                        typeGroupSelectBox = new PermissionGroupSelectBox(core, "group-select-" + itemPermission.PermissionType.ToString(), item.ItemKey);

                        permissionTypeVariableCollection.Parse("TITLE", AccessControlLists.PermissionTypeToString(itemPermission.PermissionType));

                        first = false;
                        lastType = itemPermission.PermissionType;
                    }

                    if (simple)
                    {
                        if (ownerGroups == null)
                        {
                            ownerGroups = new List<PrimitivePermissionGroup>();
                            int itemGroups = 0;

                            Type type = item.GetType();
                            if (type.GetMethod(type.Name + "_GetItemGroups", new Type[] { typeof(Core) }) != null)
                            {
                                ownerGroups.AddRange((List<PrimitivePermissionGroup>)type.InvokeMember(type.Name + "_GetItemGroups", BindingFlags.Public | BindingFlags.Static | BindingFlags.InvokeMethod, null, null, new object[] { core }));
                                itemGroups = ownerGroups.Count;
                            }

                            ownerGroups.AddRange(core.GetPrimitivePermissionGroups(owner));
                        }

                        VariableCollection permissionVariableCollection = permissionTypeVariableCollection.CreateChild("permission_desc");
                        permissionVariableCollection.Parse("ID", itemPermission.Id.ToString());
                        permissionVariableCollection.Parse("TITLE", itemPermission.Name);
                        permissionVariableCollection.Parse("DESCRIPTION", itemPermission.Description);

                        if (itemGrants != null)
                        {
                            foreach (AccessControlGrant itemGrant in itemGrants)
                            {
                                if (itemGrant.PermissionId == itemPermission.Id)
                                {
                                    switch (itemGrant.Allow)
                                    {
                                        case AccessControlGrants.Allow:
                                            PrimitivePermissionGroup ppg = null;

//.........这里部分代码省略.........

        public override SearchResult DoSearch(string input, int pageNumber, Primitive filterByOwner, Type filterByType)
        {
            Initialise();

            int perPage = 10;
            int start = (pageNumber - 1) * perPage;

            List<ISearchableItem> results = new List<ISearchableItem>();
            List<ItemKey> itemKeys = new List<ItemKey>();
            List<long> applicationIds = new List<long>();

            IndexSearcher searcher = new IndexSearcher(directory);

            QueryParser parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, "item_string", analyzer);

            BooleanQuery query = new BooleanQuery();
            Query bodyQuery = parser.Parse(input);

            query.Add(bodyQuery, Occur.MUST);

            BooleanQuery accessQuery = new BooleanQuery();
            TermQuery accessPublicQuery = new TermQuery(new Term("item_public", "1"));
            accessQuery.Add(accessPublicQuery, Occur.SHOULD);

            if (core.Session.IsLoggedIn)
            {
                List<long> friends = core.Session.LoggedInMember.GetFriendsWithMeIds();

                BooleanQuery accessFriendQuery = new BooleanQuery();
                TermQuery friendQuery = new TermQuery(new Term("item_public", "2"));
                accessFriendQuery.Add(friendQuery, Occur.MUST);

                string userTypeId =  ItemType.GetTypeId(core, typeof(User)).ToString();
                foreach (long friendId in friends)
                {
                    BooleanQuery ownerQuery = new BooleanQuery();
                    TermQuery ownerIdQuery = new TermQuery(new Term("owner_id", friendId.ToString()));
                    TermQuery ownerTypeQuery = new TermQuery(new Term("owner_type_id", userTypeId));

                    ownerQuery.Add(ownerIdQuery, Occur.MUST);
                    ownerQuery.Add(ownerTypeQuery, Occur.MUST);

                    accessFriendQuery.Add(ownerQuery, Occur.SHOULD);
                }

                accessQuery.Add(accessFriendQuery, Occur.SHOULD);
            }

            query.Add(accessQuery, Occur.MUST);

            if (filterByType != null)
            {
                TermQuery typeQuery = new TermQuery(new Term("item_type_id", ItemType.GetTypeId(core, filterByType).ToString()));

                query.Add(typeQuery, Occur.MUST);
            }

            if (filterByOwner != null)
            {
                TermQuery ownerIdQuery = new TermQuery(new Term("owner_id", filterByOwner.Id.ToString()));
                TermQuery ownerTypeIdQuery = new TermQuery(new Term("owner_type_id", filterByOwner.TypeId.ToString()));

                query.Add(ownerIdQuery, Occur.MUST);
                query.Add(ownerTypeIdQuery, Occur.MUST);
            }

            TopScoreDocCollector collector = TopScoreDocCollector.Create(start + perPage, true);

            searcher.Search(query, collector);

            ScoreDoc[] hits = collector.TopDocs().ScoreDocs;

            int totalResults = collector.TotalHits;
            int returnResults = hits.Length;

            int end = Math.Min(hits.Length, start + perPage);

            for (int i = start; i < end; i++)
            {
                Document doc = searcher.Doc(hits[i].Doc);

                long itemId = 0;
                long itemTypeId = 0;
                long applicationId = 0;

                long.TryParse(doc.GetField("item_id").StringValue, out itemId);
                long.TryParse(doc.GetField("item_type_id").StringValue, out itemTypeId);
                long.TryParse(doc.GetField("application_id").StringValue, out applicationId);

                ItemKey key = new ItemKey(itemId, itemTypeId);

                if (!applicationIds.Contains(applicationId))
                {
                    applicationIds.Add(applicationId);
                }

                itemKeys.Add(key);
            }

            // Force each application with results to load
//.........这里部分代码省略.........

 public bool GetDefaultCan(string permission, ItemKey viewer)
 {
     return false;
 }

        public static List<User> GetUserSubscribers(Core core, ItemKey itemKey, int page, int perPage)
        {
            List<User> subscribers = new List<User>();

            SelectQuery query = Subscription.GetSelectQueryStub(core, typeof(Subscription));
            query.AddCondition("subscription_item_id", itemKey.Id);
            query.AddCondition("subscription_item_type_id", itemKey.TypeId);
            query.AddFields(User.GetFieldsPrefixed(core, typeof(User)));
            query.AddFields(UserInfo.GetFieldsPrefixed(core, typeof(UserInfo)));
            query.AddFields(UserProfile.GetFieldsPrefixed(core, typeof(UserProfile)));
            query.AddField(new DataField("gallery_items", "gallery_item_uri"));
            query.AddField(new DataField("gallery_items", "gallery_item_parent_path"));
            query.AddJoin(JoinTypes.Inner, User.GetTable(typeof(User)), "user_id", "user_id");
            query.AddJoin(JoinTypes.Inner, UserInfo.GetTable(typeof(UserInfo)), "user_id", "user_id");
            query.AddJoin(JoinTypes.Inner, UserProfile.GetTable(typeof(UserProfile)), "user_id", "user_id");
            query.AddJoin(JoinTypes.Left, new DataField("user_profile", "profile_country"), new DataField("countries", "country_iso"));
            query.AddJoin(JoinTypes.Left, new DataField("user_profile", "profile_religion"), new DataField("religions", "religion_id"));
            query.AddJoin(JoinTypes.Left, new DataField("user_info", "user_icon"), new DataField("gallery_items", "gallery_item_id"));
            query.AddSort(SortOrder.Ascending, "subscription_time_ut");
            query.LimitStart = (page - 1) * perPage;
            query.LimitCount = perPage;

            DataTable subscribersDataTable = core.Db.Query(query);

            foreach (DataRow dr in subscribersDataTable.Rows)
            {
                subscribers.Add(new User(core, dr, UserLoadOptions.All));
            }

            return subscribers;
        }

        public static Notification Create(Core core, ApplicationEntry application, User actionBy, User receiver, ItemKey itemOwnerKey, ItemKey itemKey, string verb, string url, string action)
        {
            if (core == null)
            {
                throw new NullCoreException();
            }

            int applicationId = 0;

            if (application != null)
            {
                // TODO: ensure only internals can call a null application
                applicationId = (int)application.Id;
            }

            RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
            byte[] randomNumber = new byte[16];
            rng.GetBytes(randomNumber);

            string rand = SessionState.HexRNG(randomNumber);
            string verificationString = SessionState.SessionMd5(rand + "bsseed" + DateTime.Now.Ticks.ToString() + core.Session.IPAddress.ToString()).ToLower();

            InsertQuery iQuery = new InsertQuery("notifications");
            iQuery.AddField("notification_primitive_id", receiver.Id);
            iQuery.AddField("notification_primitive_type_id", ItemKey.GetTypeId(core, typeof(User)));
            if (itemKey != null)
            {
                iQuery.AddField("notification_item_id", itemKey.Id);
                iQuery.AddField("notification_item_type_id", itemKey.TypeId);
            }
            if (itemOwnerKey != null)
            {
                iQuery.AddField("notification_item_owner_id", itemOwnerKey.Id);
                iQuery.AddField("notification_item_owner_type_id", itemOwnerKey.TypeId);
            }
            iQuery.AddField("notification_user_id", actionBy.Id);
            iQuery.AddField("notification_user_count", 1);
            iQuery.AddField("notification_verb", verb);
            iQuery.AddField("notification_action", action);
            iQuery.AddField("notification_url", url);
            iQuery.AddField("notification_time_ut", UnixTime.UnixTimeStamp());
            iQuery.AddField("notification_read", false);
            iQuery.AddField("notification_seen", false);
            iQuery.AddField("notification_application", applicationId);
            iQuery.AddField("notification_verification_string", verificationString);

            long notificationId = core.Db.Query(iQuery);

            core.Db.BeginTransaction();
            UpdateQuery query = new UpdateQuery(typeof(UserInfo));
            query.AddField("user_unread_notifications", new QueryOperation("user_unread_notifications", QueryOperations.Addition, 1));
            query.AddCondition("user_id", receiver.Id);

            core.Db.Query(query);

            Notification notification = new Notification(core, receiver, notificationId, string.Empty, string.Empty, UnixTime.UnixTimeStamp(), applicationId);
            // this is not elegant
            // TODO: write appropriate constructor
            notification.userId = actionBy.Id;
            notification.verb = verb;
            notification.action = action;
            notification.url = url;
            notification.itemKey = itemKey;
            notification.itemOwnerKey = itemOwnerKey;
            notification.verificationString = verificationString;

            return notification;
        }

        private Notification(Core core, Primitive owner, long notificationId, string subject, string body, long timeRaw, int applicationId)
            : base(core)
        {
            this.db = db;
            this.recipient = owner;

            this.notificationId = notificationId;
            this.applicationId = applicationId;
            this.title = subject;
            this.body = body;
            this.ownerKey = new ItemKey(owner.Id, owner.TypeId);
            this.timeRaw = timeRaw;
        }

        public void SavePermissions()
        {
            if (itemPermissions == null)
            {
                itemPermissions = GetPermissions(core, item);
            }
            if (itemGrants == null)
            {
                itemGrants = AccessControlGrant.GetGrants(core, item);
            }
            if (unsavedGrants == null)
            {
                unsavedGrants = new List<UnsavedAccessControlGrant>();
            }

            bool simple = item.IsSimplePermissions;

            string mode = core.Http.Form["aclmode"];
            switch (mode)
            {
                case "simple":
                    simple = true;
                    break;
                case "detailed":
                    simple = false;
                    break;
            }

            if (itemPermissions != null)
            {
                if (simple)
                {
                    //
                    // Simple
                    //

                    //HttpContext.Current.Response.Write("Simple<br />");
                    bool first = true;
                    PermissionTypes lastType = PermissionTypes.View;
                    List<PrimitivePermissionGroup> groups = null;

                    foreach (AccessControlPermission itemPermission in itemPermissions)
                    {
                        if (first || itemPermission.PermissionType != lastType)
                        {
                            groups = PermissionGroupSelectBox.FormPermissionGroups(core, "group-select-" + itemPermission.PermissionType.ToString());
                            //HttpContext.Current.Response.Write("Groups: " + groups.Count.ToString() + "<br />");

                            first = false;
                            lastType = itemPermission.PermissionType;
                        }

                        List<ItemKey> keysGranted = new List<ItemKey>();
                        foreach (AccessControlGrant grant in itemGrants)
                        {
                            if (grant.PermissionId == itemPermission.Id)
                            {
                                if (grant.Allow == AccessControlGrants.Allow)
                                {
                                    keysGranted.Add(grant.PrimitiveKey);
                                }
                            }
                        }

                        List<ItemKey> keysPosted = new List<ItemKey>();
                        foreach (PrimitivePermissionGroup ppg in groups)
                        {
                            // Only create if not exists
                            if (!keysGranted.Contains(ppg.ItemKey))
                            {
                                AccessControlGrant newACG = AccessControlGrant.Create(core, ppg.ItemKey, item.ItemKey, itemPermission.Id, AccessControlGrants.Allow);
                                itemGrants.Add(newACG);
                                //HttpContext.Current.Response.Write("Created<br />");
                            }
                            keysPosted.Add(ppg.ItemKey);
                        }

                        List<AccessControlGrant> grantsGrandfathered = new List<AccessControlGrant>();
                        foreach (AccessControlGrant grant in itemGrants)
                        {
                            if (grant.PermissionId == itemPermission.Id)
                            {
                                if (!keysPosted.Contains(grant.PrimitiveKey))
                                {
                                    grantsGrandfathered.Add(grant);
                                }
                            }
                        }

                        foreach (AccessControlGrant grant in grantsGrandfathered)
                        {
                            itemGrants.Remove(grant);
                            grant.Delete();
                            //HttpContext.Current.Response.Write("Deleted<br />");
                        }
                    }

                    item.IsSimplePermissions = true;
                    item.Update();
                }
//.........这里部分代码省略.........

 public override bool GetDefaultCan(string permission, ItemKey viewer)
 {
     switch (permission)
     {
         case "COMMENT":
             return IsNetworkMember(viewer);
         case "DELETE_COMMENTS":
             return false;
     }
     return false;
 }