public void refreshSqlObject(int id)
{
Refresh(id);
var moderator = Moderator.LoadById(id);
byAccount_Recalculate(moderator.accountId);
byBoard_Recalculate(moderator.boardId);
lock (isModerator_cache) {
if (!isModerator_cache.ContainsKey(moderator.accountId))
{
isModerator_cache[moderator.accountId] = new Dictionary <int, bool>();
}
isModerator_cache[moderator.accountId][moderator.boardId] = moderator.isActive;
}
}
public XElement exportToXml(UserContext context, Board.SubboardsOptions subboardsOptions, params XElement[] additional)
{
XElement result = new XElement("board",
new XElement("id", this.id),
new XElement("sortOrder", this.sortOrder),
new XElement("categoryId", this.categoryId),
new XElement("totalPosts", this.totalPosts),
new XElement("totalThreads", this.totalThreads),
new XElement("name", this.name),
new XElement("description", this.description),
new XElement("lastPostInfo", this.exportLastPostInfo(context)),
new XElement("moderators", from moderator in Moderator.GetModerators(this) select moderator.user.exportToXmlForViewing(context)),
new XElement("isTopicstarterModeration", this.isTopicstarterModeration.ToPlainString()),
new XElement("isTransferTarget", this.isTransferTarget.ToPlainString()),
new XElement("administrator", this.administrator.user.exportToXmlForViewing(context, new XElement("isAdministrator", "true")))
);
if (context.account != null)
{
result.Add(new XElement("hasNewPosts", this.hasNewPosts(context.account).ToPlainString()));
}
if ((subboardsOptions & SubboardsOptions.FirstLevel) == SubboardsOptions.FirstLevel)
{
result.Add(new XElement("subBoards",
from board in this.subBoards select board.exportToXml(context, (subboardsOptions == SubboardsOptions.AllLevels) ? SubboardsOptions.AllLevels : SubboardsOptions.None)
));
}
if (additional.Length > 0)
{
result.Add(additional);
}
return(result);
}
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);
}
}
}
}
public XElement exportToXml(UserContext context, params XElement[] additional)
{
XElement result = null;
switch (context.isPostVisible(this))
{
case PostVisibilityEnum.UNVISIBLE:
return(null);
case PostVisibilityEnum.HIDDEN:
result = new XElement("post",
new XElement("hidden"),
new XElement("id", this.id),
new XElement("postDate", this.postDate.ToXml())
);
break;
case PostVisibilityEnum.VISIBLE:
result = new XElement("post",
new XElement("id", this.id),
new XElement("poster",
this.poster.exportToXmlForViewing(
context,
new XElement("isModerator", Moderator.isModerator(this.poster, this.thread).ToPlainString()),
new XElement("isAdministrator", (this.thread.board.administrator.userId == this.poster.id).ToPlainString())
)
),
new XElement("postDate", this.postDate.ToXml()),
new XElement("layerId", this.layerId),
new XElement("layerName", this.layer.name),
new XElement("title", this.title),
new XElement("body", context.outputParams.preprocessBodyIntermediate(this.body)),
//this.XMLBody(context),
new XElement("bodyShort", this.bodyShort),
new XElement("threadId", this.threadId),
new XElement("isPunishmentEnabled", ((context.account != null) && Moderator.isModerator(context.account, this.thread)).ToPlainString()),
new XElement("isOwner", ((context.account != null) && (this.poster.id == context.account.user.id)).ToPlainString()),
new XElement(
"specific",
new XElement(
"changeInfo",
new XElement("lastChangeDate", this.lastChangeDate.ToXml()),
new XElement("revision", this.revision.ToString())
)
)
);
if (this.totalPunishments > 0)
{
result.Add(from punishment in punishments select new XElement("specific", punishment.exportToXml(context)));
}
if (this.parentPostId.HasValue)
{
result.Add(new XElement("parentPost", this.parentPost.exportToXmlBase(context)));
}
break;
}
if (additional.Length > 0)
{
result.Add(additional);
}
return(result);
}
