예제 #1
0
        public PostLayer getActualLayer(Board board, PostLayer desiredLayer)
        {
            Dictionary <int, DateTime> restrictionData = Restriction.GetRestrictionData(this, board);

            if (restrictionData.ContainsKey(desiredLayer.id) && (restrictionData[desiredLayer.id].CompareTo(DateTime.Now) >= 0))
            {
                throw new FLocalException("You're restricted from posting in this layer until " + restrictionData[desiredLayer.id].ToString());
            }
            return(desiredLayer);
        }
예제 #2
0
            public void refreshSqlObject(int id)
            {
                Refresh(id);
                var restriction = Restriction.LoadById(id);

                byUser_Recalculate(restriction.userId);
                byBoard_Recalculate(restriction.boardId);
                lock (restrictionId_cache) {
                    if (!restrictionId_cache.ContainsKey(restriction.userId))
                    {
                        restrictionId_cache[restriction.userId] = new Dictionary <int, int?>();
                    }
                    restrictionId_cache[restriction.userId][restriction.boardId] = restriction.id;
                }
            }
예제 #3
0
        public XElement exportLayersInfoForUser(UserContext context)
        {
            Dictionary <int, DateTime> restrictionData = new Dictionary <int, DateTime>();

            if (context.account != null)
            {
                restrictionData = Restriction.GetRestrictionData(context.account.user, this);
            }
            return(new XElement("layers",
                                from layer in PostLayer.allLayers
                                select layer.exportToXml(
                                    context,
                                    new XElement("isRestricted",
                                                 (restrictionData.ContainsKey(layer.id) && restrictionData[layer.id].CompareTo(DateTime.Now) >= 0).ToPlainString()
                                                 ),
                                    new XElement("restrictionExpires",
                                                 restrictionData.ContainsKey(layer.id) ? restrictionData[layer.id].ToXml() : null
                                                 )
                                    )
                                ));
        }
예제 #4
0
        public void Punish(Account account, PunishmentType type, string comment, PunishmentTransfer.NewTransferInfo?transferInfo, PunishmentLayerChange.NewLayerChangeInfo?layerChangeInfo)
        {
            if (string.IsNullOrEmpty(comment))
            {
                throw new FLocalException("Comment is empty");
            }

            if (!Moderator.isModerator(account, this.thread))
            {
                throw new FLocalException(account.id + " is not a moderator in board " + this.thread.board.id);
            }

            if (!Moderator.isTrueModerator(account, this.thread.board))
            {
                if (type.weight != 0)
                {
                    throw new FLocalException("You cannot set punishments with weight != 0");
                }
                if (transferInfo.HasValue && !transferInfo.Value.newBoard.isTransferTarget)
                {
                    throw new FLocalException("You cannot transfer in '" + transferInfo.Value.newBoard.name + "'");
                }
            }

            lock (this.Punish_Locker) {
                lock (this.thread.locker) {
                    IEnumerable <AbstractChange> changes = (
                        from punishment in this.punishments
                        select(AbstractChange) new UpdateChange(
                            Punishment.TableSpec.instance,
                            new Dictionary <string, AbstractFieldValue> {
                        { Punishment.TableSpec.FIELD_ISWITHDRAWED, new ScalarFieldValue("1") },
                    },
                            punishment.id
                            )
                        );

                    InsertChange layerChangeInsert = null;
                    if (layerChangeInfo.HasValue)
                    {
                        var _layerChangeInfo = layerChangeInfo.Value;

                        if (_layerChangeInfo.newLayer.name == PostLayer.NAME_HIDDEN)
                        {
                            throw new FLocalException("You cannot hide posts");
                        }

                        layerChangeInsert = new InsertChange(
                            PunishmentLayerChange.TableSpec.instance,
                            new Dictionary <string, AbstractFieldValue> {
                            { PunishmentLayerChange.TableSpec.FIELD_OLDLAYERID, new ScalarFieldValue(this.layerId.ToString()) },
                            { PunishmentLayerChange.TableSpec.FIELD_NEWLAYERID, new ScalarFieldValue(_layerChangeInfo.newLayerId.ToString()) },
                            { PunishmentLayerChange.TableSpec.FIELD_ISSUBTHREADCHANGE, new ScalarFieldValue(_layerChangeInfo.isSubthreadChange.ToDBString()) },
                        }
                            );
                        changes.Union(layerChangeInsert);

                        List <Post> postsAffected;
                        if (_layerChangeInfo.isSubthreadChange)
                        {
                            postsAffected = this.ToSequence(post => post.subPosts).OrderBy(post => post.id).ToList();
                        }
                        else
                        {
                            postsAffected = new List <Post>();
                            postsAffected.Add(this);
                        }

                        changes = changes.Union(
                            from post in postsAffected
                            select(AbstractChange) new UpdateChange(
                                Post.TableSpec.instance,
                                new Dictionary <string, AbstractFieldValue> {
                            { Post.TableSpec.FIELD_LAYERID, new ScalarFieldValue(_layerChangeInfo.newLayerId.ToString()) },
                        },
                                post.id
                                )
                            );
                    }

                    InsertChange transferInsert = null;
                    if (transferInfo.HasValue)
                    {
                        var _transferInfo = transferInfo.Value;

                        transferInsert = new InsertChange(
                            PunishmentTransfer.TableSpec.instance,
                            new Dictionary <string, AbstractFieldValue> {
                            { PunishmentTransfer.TableSpec.FIELD_OLDBOARDID, new ScalarFieldValue(this.thread.boardId.ToString()) },
                            { PunishmentTransfer.TableSpec.FIELD_NEWBOARDID, new ScalarFieldValue(_transferInfo.newBoardId.ToString()) },
                            { PunishmentTransfer.TableSpec.FIELD_ISSUBTHREADTRANSFER, new ScalarFieldValue(_transferInfo.isSubthreadTransfer.ToDBString()) },
                            { PunishmentTransfer.TableSpec.FIELD_OLDPARENTPOSTID, new ScalarFieldValue(this.parentPostId.HasValue ? this.parentPostId.ToString() : null) },
                        }
                            );
                        changes = changes.Union(transferInsert);

                        Post lastAffectedPost;
                        int  totalAffectedPosts;

                        if (!this.parentPostId.HasValue)
                        {
                            if (!_transferInfo.isSubthreadTransfer)
                            {
                                throw new FLocalException("You cannot move the first post in thread");
                            }
                            else
                            {
                                lastAffectedPost   = this.thread.lastPost;
                                totalAffectedPosts = this.thread.totalPosts;
                                changes            = changes.Union(
                                    new UpdateChange(
                                        Thread.TableSpec.instance,
                                        new Dictionary <string, AbstractFieldValue> {
                                    { Thread.TableSpec.FIELD_BOARDID, new ScalarFieldValue(_transferInfo.newBoardId.ToString()) },
                                },
                                        this.thread.id
                                        )
                                    );
                            }
                        }
                        else
                        {
                            List <Post> postsAffected;
                            if (_transferInfo.isSubthreadTransfer)
                            {
                                postsAffected = this.ToSequence(post => post.subPosts).OrderBy(post => post.id).ToList();
                            }
                            else
                            {
                                postsAffected = new List <Post>();
                                postsAffected.Add(this);
                            }

                            lastAffectedPost   = postsAffected.Last();
                            totalAffectedPosts = postsAffected.Count;

                            InsertChange threadCreate = new InsertChange(
                                Thread.TableSpec.instance,
                                new Dictionary <string, AbstractFieldValue> {
                                { Thread.TableSpec.FIELD_BOARDID, new ScalarFieldValue(_transferInfo.newBoardId.ToString()) },
                                { Thread.TableSpec.FIELD_FIRSTPOSTID, new ScalarFieldValue(this.id.ToString()) },
                                { Thread.TableSpec.FIELD_ISANNOUNCEMENT, new ScalarFieldValue("0") },
                                { Thread.TableSpec.FIELD_ISLOCKED, new ScalarFieldValue("0") },
                                { Thread.TableSpec.FIELD_LASTPOSTDATE, new ScalarFieldValue(lastAffectedPost.postDate.ToUTCString()) },
                                { Thread.TableSpec.FIELD_LASTPOSTID, new ScalarFieldValue(lastAffectedPost.id.ToString()) },
                                { Thread.TableSpec.FIELD_TITLE, new ScalarFieldValue(this.title) },
                                { Thread.TableSpec.FIELD_TOPICSTARTERID, new ScalarFieldValue(this.posterId.ToString()) },
                                { Thread.TableSpec.FIELD_TOTALPOSTS, new ScalarFieldValue(totalAffectedPosts.ToString()) },
                                { Thread.TableSpec.FIELD_TOTALVIEWS, new ScalarFieldValue("0") },
                            }
                                );
                            changes = changes.Union(threadCreate);

                            changes = changes.Union(
                                from post in postsAffected
                                select(AbstractChange) new UpdateChange(
                                    TableSpec.instance,
                                    new Dictionary <string, AbstractFieldValue> {
                                { TableSpec.FIELD_THREADID, new ReferenceFieldValue(threadCreate) },
                            },
                                    post.id
                                    )
                                );

                            if (!_transferInfo.isSubthreadTransfer)
                            {
                                changes = changes.Union(
                                    from post in this.subPosts
                                    select(AbstractChange) new UpdateChange(
                                        TableSpec.instance,
                                        new Dictionary <string, AbstractFieldValue> {
                                    { TableSpec.FIELD_PARENTPOSTID, new ScalarFieldValue(this.parentPostId.ToString()) },
                                },
                                        post.id
                                        )
                                    );
                            }
                        }

                        changes = changes.Union(
                            from board in this.thread.board.boardAndParents
                            select(AbstractChange) new UpdateChange(
                                Board.TableSpec.instance,
                                new Dictionary <string, AbstractFieldValue> {
                            { Board.TableSpec.FIELD_TOTALPOSTS, new IncrementFieldValue(IncrementFieldValue.DECREMENTOR_CUSTOM(totalAffectedPosts)) },
                            { Board.TableSpec.FIELD_TOTALTHREADS, new IncrementFieldValue(IncrementFieldValue.DECREMENTOR_CUSTOM(this.parentPostId.HasValue ? 0 : 1)) },
                        },
                                board.id
                                )
                            );

                        changes = changes.Union(
                            from board in _transferInfo.newBoard.boardAndParents
                            select(AbstractChange) new UpdateChange(
                                Board.TableSpec.instance,
                                new Dictionary <string, AbstractFieldValue> {
                            { Board.TableSpec.FIELD_TOTALPOSTS, new IncrementFieldValue(IncrementFieldValue.INCREMENTOR_CUSTOM(totalAffectedPosts)) },
                            { Board.TableSpec.FIELD_TOTALTHREADS, new IncrementFieldValue() },
                            { Board.TableSpec.FIELD_LASTPOSTID, new IncrementFieldValue(IncrementFieldValue.GREATEST(lastAffectedPost.id)) },
                        },
                                board.id
                                )
                            );

                        changes = changes.Union(
                            new UpdateChange(
                                TableSpec.instance,
                                new Dictionary <string, AbstractFieldValue> {
                            { TableSpec.FIELD_PARENTPOSTID, new ScalarFieldValue(null) },
                        },
                                this.id
                                )
                            );

                        if (this.parentPostId.HasValue)
                        {
                            changes = changes.Union(
                                new UpdateChange(
                                    Thread.TableSpec.instance,
                                    new Dictionary <string, AbstractFieldValue> {
                                { Thread.TableSpec.FIELD_TOTALPOSTS, new IncrementFieldValue(IncrementFieldValue.DECREMENTOR_CUSTOM(totalAffectedPosts)) },
                            },
                                    this.threadId
                                    )
                                );
                        }
                    }

                    changes = changes.Union(
                        new UpdateChange(
                            TableSpec.instance,
                            new Dictionary <string, AbstractFieldValue> {
                        { TableSpec.FIELD_TOTALPUNISHMENTS, new IncrementFieldValue() },
                    },
                            this.id
                            ),
                        new InsertChange(
                            Punishment.TableSpec.instance,
                            new Dictionary <string, AbstractFieldValue> {
                        { Punishment.TableSpec.FIELD_POSTID, new ScalarFieldValue(this.id.ToString()) },
                        { Punishment.TableSpec.FIELD_OWNERID, new ScalarFieldValue(this.poster.id.ToString()) },
                        { Punishment.TableSpec.FIELD_ORIGINALBOARDID, new ScalarFieldValue(this.thread.board.id.ToString()) },
                        { Punishment.TableSpec.FIELD_MODERATORID, new ScalarFieldValue(account.id.ToString()) },
                        { Punishment.TableSpec.FIELD_PUNISHMENTDATE, new ScalarFieldValue(DateTime.Now.ToUTCString()) },
                        { Punishment.TableSpec.FIELD_PUNISHMENTTYPE, new ScalarFieldValue(type.id.ToString()) },
                        { Punishment.TableSpec.FIELD_ISWITHDRAWED, new ScalarFieldValue("0") },
                        { Punishment.TableSpec.FIELD_COMMENT, new ScalarFieldValue(comment) },
                        { Punishment.TableSpec.FIELD_EXPIRES, new ScalarFieldValue(DateTime.Now.Add(type.timeSpan).ToUTCString()) },
                        { Punishment.TableSpec.FIELD_TRANSFERID, (transferInsert != null) ? (AbstractFieldValue) new ReferenceFieldValue(transferInsert) : (AbstractFieldValue) new ScalarFieldValue(null) },
                        { Punishment.TableSpec.FIELD_LAYERCHANGEID, (layerChangeInsert != null) ? (AbstractFieldValue) new ReferenceFieldValue(layerChangeInsert) : (AbstractFieldValue) new ScalarFieldValue(null) },
                    }
                            )
                        );

                    ChangeSetUtil.ApplyChanges(changes.ToArray());

                    this.punishments_Reset();

                    Account posterAccount = null;
                    try {
                        posterAccount = Account.LoadByUser(this.poster);
                    } catch (NotFoundInDBException) {
                    }

                    if ((posterAccount != null) && (posterAccount.id != account.id) && !posterAccount.needsMigration)
                    {
                        PMMessage newMessage = PMConversation.SendPMMessage(
                            account,
                            posterAccount,
                            this.title,
                            String.Format("{0}{3}[post]{2}[/post]{3}{1}", type.description, comment, this.id, Util.EOL)
                            );
                        newMessage.conversation.markAsRead(account, newMessage, newMessage);
                    }

                    HashSet <int> punishmentsBoards = new HashSet <int>(from punishment in this.punishments select punishment.originalBoardId);
                    foreach (int boardId in punishmentsBoards)
                    {
                        Restriction.RecalculateRestrictions(Board.LoadById(boardId), this.poster);
                    }
                }
            }
        }