Exemple #1
0
        private void btnUpdate_Click(object sender, EventArgs e)
        {
            UpdateChange update = new UpdateChange();

            update.ShowDialog();
            update.success += Update_success;
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="UpdateUIEventArgs" /> class.
 /// </summary>
 /// <param name="change">A bitwise combination of <see cref="UpdateChange" /> values specifying the reason to update the UI.</param>
 public UpdateUIEventArgs(UpdateChange change)
 {
     Change = change;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="UpdateUIEventArgs" /> class.
 /// </summary>
 /// <param name="change">A bitwise combination of <see cref="UpdateChange" /> values specifying the reason to update the UI.</param>
 public UpdateUIEventArgs(UpdateChange change)
 {
     Change = change;
 }
Exemple #4
0
        public static PMMessage SendPMMessage(Account sender, Account receiver, string title, string bodyUBB)
        {
            string         bodyIntermediate = UBBParser.UBBToIntermediate(bodyUBB);
            AbstractChange insertPmReceiver = new InsertChange(
                PMMessage.TableSpec.instance,
                new Dictionary <string, AbstractFieldValue> {
                { PMMessage.TableSpec.FIELD_OWNERID, new ScalarFieldValue(receiver.id.ToString()) },
                { PMMessage.TableSpec.FIELD_INTERLOCUTORID, new ScalarFieldValue(sender.id.ToString()) },
                { PMMessage.TableSpec.FIELD_DIRECTION, new ScalarFieldValue(PMMessage.ENUM_DIRECTION_INCOMING) },
                { PMMessage.TableSpec.FIELD_POSTDATE, new ScalarFieldValue(DateTime.Now.ToUTCString()) },
                { PMMessage.TableSpec.FIELD_TITLE, new ScalarFieldValue(title) },
                { PMMessage.TableSpec.FIELD_BODY, new ScalarFieldValue(bodyIntermediate) },
                { PMMessage.TableSpec.FIELD_BODYUBB, new ScalarFieldValue(bodyUBB) },
                { PMMessage.TableSpec.FIELD_INCOMINGPMID, new ScalarFieldValue(null) },
                { PMMessage.TableSpec.FIELD_ISREAD, new ScalarFieldValue("0") },
            }
                );
            AbstractChange insertPmSender = new InsertChange(
                PMMessage.TableSpec.instance,
                new Dictionary <string, AbstractFieldValue> {
                { PMMessage.TableSpec.FIELD_OWNERID, new ScalarFieldValue(sender.id.ToString()) },
                { PMMessage.TableSpec.FIELD_INTERLOCUTORID, new ScalarFieldValue(receiver.id.ToString()) },
                { PMMessage.TableSpec.FIELD_DIRECTION, new ScalarFieldValue(PMMessage.ENUM_DIRECTION_OUTGOING) },
                { PMMessage.TableSpec.FIELD_POSTDATE, new ScalarFieldValue(DateTime.Now.ToUTCString()) },
                { PMMessage.TableSpec.FIELD_TITLE, new ScalarFieldValue(title) },
                { PMMessage.TableSpec.FIELD_BODY, new ScalarFieldValue(bodyIntermediate) },
                { PMMessage.TableSpec.FIELD_BODYUBB, new ScalarFieldValue(bodyUBB) },
                { PMMessage.TableSpec.FIELD_INCOMINGPMID, new ReferenceFieldValue(insertPmReceiver) },
                { PMMessage.TableSpec.FIELD_ISREAD, new ScalarFieldValue("1") },
            }
                );
            AbstractChange updateConversationSender = new InsertOrUpdateChange(
                TableSpec.instance,
                new Dictionary <string, AbstractFieldValue> {
                { TableSpec.FIELD_OWNERID, new ScalarFieldValue(sender.id.ToString()) },
                { TableSpec.FIELD_INTERLOCUTORID, new ScalarFieldValue(receiver.id.ToString()) },
                { TableSpec.FIELD_TOTALMESSAGES, new ScalarFieldValue("1") },
                { TableSpec.FIELD_LASTMESSAGEID, new ReferenceFieldValue(insertPmSender) },
                { TableSpec.FIELD_LASTMESSAGEDATE, new ScalarFieldValue(DateTime.Now.ToUTCString()) },
                { TableSpec.FIELD_LASTREADMESSAGEID, new ReferenceFieldValue(insertPmSender) },
            },
                new Dictionary <string, AbstractFieldValue> {
                { TableSpec.FIELD_TOTALMESSAGES, new IncrementFieldValue() },
                { TableSpec.FIELD_LASTMESSAGEID, new TwoWayReferenceFieldValue(insertPmSender, TwoWayReferenceFieldValue.GREATEST) },
                { TableSpec.FIELD_LASTMESSAGEDATE, new ScalarFieldValue(DateTime.Now.ToUTCString()) },
            },
                new ComplexCondition(
                    ConditionsJoinType.AND,
                    new ComparisonCondition(
                        TableSpec.instance.getColumnSpec(TableSpec.FIELD_OWNERID),
                        ComparisonType.EQUAL,
                        sender.id.ToString()
                        ),
                    new ComparisonCondition(
                        TableSpec.instance.getColumnSpec(TableSpec.FIELD_INTERLOCUTORID),
                        ComparisonType.EQUAL,
                        receiver.id.ToString()
                        )
                    )
                );
            AbstractChange updateConversationReceiver = new InsertOrUpdateChange(
                TableSpec.instance,
                new Dictionary <string, AbstractFieldValue> {
                { TableSpec.FIELD_OWNERID, new ScalarFieldValue(receiver.id.ToString()) },
                { TableSpec.FIELD_INTERLOCUTORID, new ScalarFieldValue(sender.id.ToString()) },
                { TableSpec.FIELD_TOTALMESSAGES, new ScalarFieldValue("1") },
                { TableSpec.FIELD_LASTMESSAGEID, new ReferenceFieldValue(insertPmReceiver) },
                { TableSpec.FIELD_LASTMESSAGEDATE, new ScalarFieldValue(DateTime.Now.ToUTCString()) },
                { TableSpec.FIELD_LASTREADMESSAGEID, new ScalarFieldValue(null) },
            },
                new Dictionary <string, AbstractFieldValue> {
                { TableSpec.FIELD_TOTALMESSAGES, new IncrementFieldValue() },
                { TableSpec.FIELD_LASTMESSAGEID, new TwoWayReferenceFieldValue(insertPmReceiver, TwoWayReferenceFieldValue.GREATEST) },
                { TableSpec.FIELD_LASTMESSAGEDATE, new ScalarFieldValue(DateTime.Now.ToUTCString()) },
            },
                new ComplexCondition(
                    ConditionsJoinType.AND,
                    new ComparisonCondition(
                        TableSpec.instance.getColumnSpec(TableSpec.FIELD_OWNERID),
                        ComparisonType.EQUAL,
                        receiver.id.ToString()
                        ),
                    new ComparisonCondition(
                        TableSpec.instance.getColumnSpec(TableSpec.FIELD_INTERLOCUTORID),
                        ComparisonType.EQUAL,
                        sender.id.ToString()
                        )
                    )
                );
            AbstractChange updateIndicatorReceiver = new UpdateChange(
                AccountIndicator.TableSpec.instance,
                new Dictionary <string, AbstractFieldValue> {
                { AccountIndicator.TableSpec.FIELD_PRIVATEMESSAGES, new IncrementFieldValue() },
                { AccountIndicator.TableSpec.FIELD_UNREADPRIVATEMESSAGES, new IncrementFieldValue() },
            },
                AccountIndicator.LoadByAccount(receiver).id
                );

            ChangeSetUtil.ApplyChanges(
                insertPmReceiver,
                insertPmSender,
                updateConversationReceiver,
                updateConversationSender,
                updateIndicatorReceiver
                );
            return(PMMessage.LoadById(insertPmSender.getId().Value));
        }
 private void OnUpdateChanage(KeyValuePair <CbCardInfo, int> dic)
 {
     UpdateChange?.Invoke(dic);
 }
Exemple #6
0
        internal static KeyValuePair <AbstractChange, IEnumerable <AbstractChange> > getNewPostChanges(Board board, int threadId, Post parentPost, User poster, PostLayer layer, string title, string body, DateTime date, int?forcedPostId)
        {
            string parentPostId = null;

            if (parentPost != null)
            {
                parentPostId = parentPost.id.ToString();
            }
            bool          isNewThread       = (parentPost == null);
            HashSet <int> mentionedUsersIds = new HashSet <int>();

            if (parentPost != null && parentPost.poster.id != poster.id)
            {
                mentionedUsersIds.Add(parentPost.poster.id);
            }
            string bodyIntermediate;

            if (forcedPostId.HasValue)
            {
                //dirty hack
                bodyIntermediate = body;
            }
            else
            {
                bodyIntermediate = UBBParser.UBBToIntermediate(
                    new DelegatePostParsingContext(mentionedUser => mentionedUsersIds.Add(mentionedUser.id)),
                    body
                    );
            }
            var postInsertData = new Dictionary <string, AbstractFieldValue> {
                { Post.TableSpec.FIELD_THREADID, new ScalarFieldValue(threadId.ToString()) },
                { Post.TableSpec.FIELD_PARENTPOSTID, new ScalarFieldValue(parentPostId) },
                { Post.TableSpec.FIELD_POSTERID, new ScalarFieldValue(poster.id.ToString()) },
                { Post.TableSpec.FIELD_POSTDATE, new ScalarFieldValue(date.ToUTCString()) },
                //{ Post.TableSpec.FIELD_REVISION, new ScalarFieldValue("0") },
                { Post.TableSpec.FIELD_LASTCHANGEDATE, new ScalarFieldValue(date.ToUTCString()) },
                { Post.TableSpec.FIELD_LAYERID, new ScalarFieldValue(layer.id.ToString()) },
                { Post.TableSpec.FIELD_TITLE, new ScalarFieldValue(title) },
                { Post.TableSpec.FIELD_BODY, new ScalarFieldValue(bodyIntermediate) },
                { Post.TableSpec.FIELD_TOTALPUNISHMENTS, new ScalarFieldValue("0") },
            };

            if (!forcedPostId.HasValue)
            {
                postInsertData[Post.TableSpec.FIELD_REVISION] = new ScalarFieldValue("0");
            }
            else
            {
                postInsertData[Post.TableSpec.FIELD_ID] = new ScalarFieldValue(forcedPostId.Value.ToString());
            }
            AbstractChange postInsert = new InsertChange(
                Post.TableSpec.instance,
                postInsertData
                );
            AbstractFieldValue postReference      = new ReferenceFieldValue(postInsert);
            AbstractFieldValue postIndexReference = new TwoWayReferenceFieldValue(postInsert, TwoWayReferenceFieldValue.GREATEST);
            AbstractChange     revisionInsert     = new InsertChange(
                Revision.TableSpec.instance,
                new Dictionary <string, AbstractFieldValue> {
                { Revision.TableSpec.FIELD_POSTID, postReference },
                { Revision.TableSpec.FIELD_NUMBER, new ScalarFieldValue("0") },
                { Revision.TableSpec.FIELD_CHANGEDATE, new ScalarFieldValue(date.ToUTCString()) },
                { Revision.TableSpec.FIELD_TITLE, new ScalarFieldValue(title) },
                { Revision.TableSpec.FIELD_BODY, new ScalarFieldValue(body) },
            }
                );
            Dictionary <string, AbstractFieldValue> threadData = new Dictionary <string, AbstractFieldValue> {
                { Thread.TableSpec.FIELD_LASTPOSTDATE, new ScalarFieldValue(date.ToUTCString()) },
                { Thread.TableSpec.FIELD_TOTALPOSTS, new IncrementFieldValue() },
                {
                    Thread.TableSpec.FIELD_LASTPOSTID,
                    postIndexReference
                }
            };

            if (isNewThread)
            {
                threadData[Thread.TableSpec.FIELD_FIRSTPOSTID] = postReference;
            }
            AbstractChange threadUpdate = new UpdateChange(
                Thread.TableSpec.instance,
                threadData,
                threadId
                );
            AbstractChange userUpdate = new UpdateChange(
                User.TableSpec.instance,
                new Dictionary <string, AbstractFieldValue> {
                { User.TableSpec.FIELD_TOTALPOSTS, new IncrementFieldValue() },
            },
                poster.id
                );

            List <AbstractChange> changes = new List <AbstractChange>();

            changes.Add(postInsert);
            if (!forcedPostId.HasValue)
            {
                //dirty hack
                changes.Add(revisionInsert);
            }
            changes.Add(threadUpdate);
            changes.Add(userUpdate);

            foreach (var mentionedUserId in mentionedUsersIds)
            {
                changes.Add(
                    new InsertChange(
                        Mention.TableSpec.instance,
                        new Dictionary <string, AbstractFieldValue> {
                    { Mention.TableSpec.FIELD_MENTIONEDUSERID, new ScalarFieldValue(mentionedUserId.ToString()) },
                    { Mention.TableSpec.FIELD_POSTID, new ReferenceFieldValue(postInsert) },
                    { Mention.TableSpec.FIELD_DATE, new ScalarFieldValue(date.ToUTCString()) },
                }
                        )
                    );
            }

            Dictionary <string, AbstractFieldValue> boardData = new Dictionary <string, AbstractFieldValue> {
                { Board.TableSpec.FIELD_TOTALPOSTS, new IncrementFieldValue() },
                {
                    Board.TableSpec.FIELD_LASTPOSTID,
                    postIndexReference
                }
            };

            if (isNewThread)
            {
                boardData[Board.TableSpec.FIELD_TOTALTHREADS] = new IncrementFieldValue();
            }
            int?boardId = board.id;

            do
            {
                Board _board = Board.LoadById(boardId.Value);
                changes.Add(
                    new UpdateChange(
                        Board.TableSpec.instance,
                        boardData,
                        _board.id
                        )
                    );
                boardId = _board.parentBoardId;
            } while(boardId.HasValue);

            return(new KeyValuePair <AbstractChange, IEnumerable <AbstractChange> >(postInsert, changes));
        }