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);
}
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;
}
}
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
)
)
));
}
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);
}
}
}
}