public static Submission GetSticky(string subverse)
{
//Heads up: Right now the cache is set to ignore nulls, so we create an empty list to use if a sub has no stickies
//will refactor this in the future when we modify the cachehandler to support null caching per call
List <Submission> stickies = CacheHandler.Instance.Register(CachingKey.StickySubmission(subverse), new Func <List <Submission> >(() =>
{
using (var db = new voatEntities())
{
var x = db.StickiedSubmissions.FirstOrDefault(s => s.Subverse == subverse);
if (x != null)
{
return(new List <Submission>()
{
DataCache.Submission.Retrieve(x.SubmissionID)
});
}
return(new List <Submission>());
}
}), TimeSpan.FromSeconds(600));
if (stickies != null && stickies.Any())
{
return(stickies.First());
}
else
{
return(null);
}
}
public override void ClassInitialize()
{
using (var db = new VoatDataContext())
{
//1
db.Filter.Add(new Filter()
{
Pattern = ".",
IsActive = false,
Name = "Match Anything",
CreationDate = DateTime.UtcNow.AddDays(-10)
});
//2
db.Filter.Add(new Filter()
{
Pattern = @"evildomain\.evil",
IsActive = true,
Name = "Evil Domain is Banned",
CreationDate = DateTime.UtcNow.AddDays(-10)
});
//3
db.Filter.Add(new Filter()
{
Pattern = @"google\.com/url",
IsActive = true,
Name = "Google redirect ban",
CreationDate = DateTime.UtcNow.AddDays(-10)
});
db.SaveChanges();
}
//Remove Filters that may be in cache
CacheHandler.Instance.Remove(CachingKey.Filters());
}
private void ClearUserCache(string userName = null)
{
userName = String.IsNullOrEmpty(userName) ? User.Identity.Name : userName;
CacheHandler.Instance.Remove(CachingKey.UserPreferences(userName));
CacheHandler.Instance.Remove(CachingKey.UserInformation(userName));
}
protected override void UpdateCache(CommandResponse <Vote> result)
{
if (result.Success)
{
CacheHandler.Instance.Remove(CachingKey.Vote(result.Response.ID));
}
}
public async Task <IActionResult> ApproveOrReject(int replyId, [FromBody] dynamic model)
{
var operation = (string)model.Operation;
if (string.IsNullOrEmpty(operation))
{
throw new ServiceException(HttpStatusCode.BadRequest, Reason.InvalidArgument, "回复审批操作方式未指定，请指定Approve或者Reject操作。");
}
if (operation.ToUpper() != "APPROVE" &&
operation.ToUpper() != "REJECT")
{
throw new ServiceException(HttpStatusCode.MethodNotAllowed, Reason.InvalidArgument, "指定的审批操作方式不可用，请指定Approve或者Reject操作。");
}
var blogPostId = -1;
var affectedRows = await this.storage.ExecuteAsync(async (connection, transaction, cancellationToken) =>
{
var reply = (await this.replyStore.SelectAsync(connection,
r => r.Id == replyId,
transaction: transaction,
cancellationToken: cancellationToken)).FirstOrDefault();
if (reply == null)
{
throw new ServiceException(HttpStatusCode.NotFound, Reason.EntityNotFound, $"ID为{replyId}的用户回复内容不存在。");
}
blogPostId = reply.BlogPostId;
var updateFields = new List <Expression <Func <Reply, object> > >();
switch (operation.ToUpper())
{
case "APPROVE":
reply.Status = ReplyStatus.Approved;
break;
case "REJECT":
reply.Status = ReplyStatus.Rejected;
break;
}
return(await this.replyStore.UpdateAsync(reply,
connection,
r => r.Id == replyId,
new Expression <Func <Reply, object> >[] { r => r.Status },
transaction,
cancellationToken));
});
if (affectedRows > 0)
{
if (blogPostId >= 0)
{
var key = new CachingKey(CachingKeys.BLOGPOSTS_POST_KEY, blogPostId);
this.cachingService.Delete(key);
}
return(Ok(affectedRows));
}
throw new ServiceException(Reason.UpdateFailed, "用户回复审批失败。");
}
protected override void UpdateCache(CommandResponse result)
{
if (result.Success)
{
CacheHandler.Instance.Remove(CachingKey.UserSubscriptions(UserName));
}
}
protected override void UpdateCache(ApiClient result)
{
if (result != null)
{
CacheHandler.Instance.Remove(CachingKey.ApiClient(result.PublicKey));
}
}
public async Task <ActionResult> ResignAsModeratorPost(string subverse)
{
// get moderator name for selected subverse
var subModerator = _db.SubverseModerator.FirstOrDefault(s => s.Subverse == subverse && s.UserName == User.Identity.Name);
if (subModerator == null)
{
return(HybridError(ErrorViewModel.GetErrorViewModel(ErrorType.NotFound)));
//return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
var subverseObject = DataCache.Subverse.Retrieve(subModerator.Subverse);
if (subverseObject == null)
{
return(HybridError(ErrorViewModel.GetErrorViewModel(ErrorType.SubverseNotFound)));
//return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
// execute removal
_db.SubverseModerator.Remove(subModerator);
await _db.SaveChangesAsync();
//clear mod cache
CacheHandler.Instance.Remove(CachingKey.SubverseModerators(subverseObject.Name));
return(RedirectToRoute(Models.ROUTE_NAMES.SUBVERSE_INDEX, new { subverse = subverse }));
}
protected override async Task <CommandResponse <VoteTracker> > ExecuteStage(CommandStage stage, CommandResponse <VoteTracker> previous)
{
switch (stage)
{
case CommandStage.OnExecuting:
var q = new QueryVote(_voteID);
var vote = await q.ExecuteAsync();
var notPassed = vote.Restrictions.FirstOrDefault(x => {
var e = x.Evaluate(User);
return(!e.Success);
});
_restrictionsPassed = notPassed == null;
break;
case CommandStage.OnExecuted:
if (previous.Success)
{
CacheHandler.Instance.Remove(CachingKey.VoteStatistics(_voteID));
}
break;
}
return(await base.ExecuteStage(stage, previous));
}
public async Task <ActionResult> RemoveLinkFlair(int id)
{
// get link flair for selected subverse
var linkFlairToRemove = await _db.SubverseFlair.FindAsync(id);
if (linkFlairToRemove == null)
{
return(HybridError(ErrorViewModel.GetErrorViewModel(ErrorType.NotFound)));
//return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
var subverse = DataCache.Subverse.Retrieve(linkFlairToRemove.Subverse);
if (subverse == null)
{
return(HybridError(ErrorViewModel.GetErrorViewModel(ErrorType.SubverseNotFound)));
//return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
// check if caller has clearance to remove a link flair
if (!ModeratorPermission.HasPermission(User, subverse.Name, Domain.Models.ModeratorAction.ModifyFlair))
{
return(RedirectToAction("Index", "Home"));
}
// execute removal
var subverseFlairSetting = await _db.SubverseFlair.FindAsync(id);
_db.SubverseFlair.Remove(subverseFlairSetting);
await _db.SaveChangesAsync();
//clear cache
CacheHandler.Instance.Remove(CachingKey.SubverseFlair(subverse.Name));
return(RedirectToAction("SubverseFlairSettings"));
}
protected override void UpdateCache(CommandResponse <RemoveModeratorResponse> result)
{
if (result.Success)
{
CacheHandler.Instance.Remove(CachingKey.SubverseModerators(result.Response.Subverse));
}
}
protected override void UpdateCache(Data.Models.Submission result)
{
CacheHandler.Instance.Remove(CachingKey.Submission(result.ID));
//Legacy item removal
CacheHandler.Instance.Remove(DataCache.Keys.Submission(result.ID));
}
public async Task <ActionResult> SubverseStylesheetEditor(SubverseStylesheetViewModel model)
{
try
{
if (!ModelState.IsValid)
{
SetNavigationViewModel(model.Name);
return(View("~/Views/Subverses/Admin/SubverseStylesheetEditor.cshtml"));
}
var existingSubverse = _db.Subverse.FirstOrDefault(x => x.Name.ToUpper() == model.Name.ToUpper());
// check if subverse exists before attempting to edit it
if (existingSubverse != null)
{
SetNavigationViewModel(model.Name);
// check if user requesting edit is authorized to do so for current subverse
// check that the user requesting to edit subverse settings is subverse owner!
if (!ModeratorPermission.HasPermission(User, existingSubverse.Name, Domain.Models.ModeratorAction.ModifyCSS))
{
return(new EmptyResult());
}
if (!String.IsNullOrEmpty(model.Stylesheet))
{
if (model.Stylesheet.Length < 50001)
{
existingSubverse.Stylesheet = model.Stylesheet;
}
else
{
ModelState.AddModelError(string.Empty, "Sorry, custom CSS limit is set to 50000 characters.");
return(View("~/Views/Subverses/Admin/SubverseStylesheetEditor.cshtml"));
}
}
else
{
existingSubverse.Stylesheet = model.Stylesheet;
}
await _db.SaveChangesAsync();
//purge new minified CSS
CacheHandler.Instance.Remove(CachingKey.SubverseStylesheet(existingSubverse.Name));
CacheHandler.Instance.Remove(CachingKey.Subverse(existingSubverse.Name));
// go back to this subverse
return(RedirectToRoute(Models.ROUTE_NAMES.SUBVERSE_INDEX, new { subverse = model.Name }));
}
ModelState.AddModelError(string.Empty, "Sorry, The subverse you are trying to edit does not exist.");
return(View("~/Views/Subverses/Admin/SubverseStylesheetEditor.cshtml", model));
}
catch (Exception ex)
{
EventLogger.Instance.Log(ex);
ModelState.AddModelError(string.Empty, "Something bad happened.");
return(View("~/Views/Subverses/Admin/SubverseStylesheetEditor.cshtml", model));
}
}
protected override void UpdateCache(CommandResponse <bool?> result)
{
if (result.Success)
{
//purge subscriptions from cache because they just changed
CacheHandler.Instance.Remove(CachingKey.UserSubscriptions(UserName));
}
}
protected override void UpdateCache(CommandResponse <Domain.Models.Set> result)
{
if (result.Success)
{
CacheHandler.Instance.Remove(CachingKey.UserSubscriptions(UserName));
CacheHandler.Instance.Remove(CachingKey.Set(this._set.Name, this._set.UserName));
}
}
public async Task <ActionResult> Index(int?page, string domainname, string sortingmode)
{
const int pageSize = 25;
int pageNumber = (page ?? 0);
if (pageNumber < 0 || String.IsNullOrWhiteSpace(domainname) || pageNumber > 9)
{
return(NotFoundErrorView());
}
if (domainname.Length < 4)
{
return(RedirectToAction("UnAuthorized", "Error"));
}
sortingmode = (sortingmode == "new" ? "new" : "hot");
ViewBag.SelectedSubverse = "domains";
ViewBag.SelectedDomain = domainname;
domainname = domainname.Trim().ToLower();
//TODO: This needs to moved to Query/Repository
var results = CacheHandler.Instance.Register(CachingKey.DomainSearch(domainname, pageNumber, sortingmode), () => {
using (var db = new voatEntities())
{
db.EnableCacheableOutput();
//restrict disabled subs from result list
IQueryable <Submission> q = (from m in db.Submissions
join s in db.Subverses on m.Subverse equals s.Name
where
!s.IsAdminDisabled.Value &&
!m.IsDeleted &&
m.Type == 2 &&
m.Url.ToLower().Contains(domainname)
select m);
if (sortingmode == "new")
{
ViewBag.SortingMode = sortingmode;
q = q.OrderByDescending(x => x.CreationDate);
}
else
{
ViewBag.SortingMode = "hot";
q = q.OrderByDescending(x => x.Rank).ThenByDescending(x => x.CreationDate);
}
var result = q.Skip(pageNumber * pageSize).Take(pageSize).ToList();
return(result);
}
}, TimeSpan.FromMinutes(60));
var paginatedSubmissions = new PaginatedList <Submission>(results, page ?? 0, pageSize);
ViewBag.Title = "Showing all submissions which link to " + domainname;
return(View("Index", paginatedSubmissions));
}
public async Task <IActionResult> Update(int id, [FromBody] dynamic model)
{
var title = (string)model.Title;
var content = (string)model.Content;
var datePublished = (DateTime?)model.DatePublished;
var visits = (int?)model.Visits;
var result = await this.storage.ExecuteAsync(async (connection, transaction, cancellationToken) =>
{
var blogPost = (await this.blogPostStore.SelectAsync(connection,
bp => bp.Id == id,
transaction: transaction,
cancellationToken: cancellationToken)).FirstOrDefault();
if (blogPost == null)
{
throw new ServiceException(HttpStatusCode.NotFound, Reason.EntityNotFound, $"Id为{id}的博客日志不存在。");
}
var listUpdateFields = new List <Expression <Func <BlogPost, object> > >();
if (!string.IsNullOrEmpty(title))
{
blogPost.Title = title;
listUpdateFields.Add(x => x.Title);
}
if (!string.IsNullOrEmpty(content))
{
blogPost.Content = content;
listUpdateFields.Add(x => x.Content);
}
if (datePublished != null && datePublished.HasValue && datePublished != DateTime.MinValue)
{
blogPost.DatePublished = datePublished.Value;
listUpdateFields.Add(x => x.DatePublished);
}
if (visits != null && visits.HasValue && visits != int.MinValue)
{
blogPost.Visits = visits.Value;
listUpdateFields.Add(x => x.Visits);
}
return(await this.blogPostStore.UpdateAsync(blogPost, connection,
x => x.Id == id,
listUpdateFields, transaction, cancellationToken));
});
if (result > 0)
{
// Removes the specific post from the cache
var cachingKey = new CachingKey(CachingKeys.BLOGPOSTS_POST_KEY, id);
this.cachingService.Delete(cachingKey);
return(Ok());
}
throw new ServiceException(Reason.UpdateFailed, "更新博客日志失败。");
}
protected override void UpdateCache(CommandResponse <Data.Models.Submission> result)
{
if (result.Success)
{
CacheHandler.Instance.Remove(CachingKey.Submission(result.Response.ID));
}
//Legacy item removal
//CacheHandler.Instance.Remove(DataCache.Keys.Submission(result.ID));
}
public object Get(CachingKey key)
{
object ret = null;
if (cache.TryGetValue(key, out ret))
{
return(ret);
}
return(null);
}
public static double?GetSubverseHighestRanking(string subverse)
{
var highestRank = CacheHandler.Instance.Register(CachingKey.SubverseHighestRank(subverse), new Func <double?>(() =>
{
using (var repo = new Repository())
{
return(repo.HighestRankInSubverse(subverse));
}
}), TimeSpan.FromMinutes(30));
return(highestRank);
}
public static void UpdateSubverseHighestRanking(string subverse, double newRank)
{
var highestRankCacheEntry = GetSubverseHighestRanking(subverse);
if (highestRankCacheEntry != null)
{
if (highestRankCacheEntry < newRank)
{
CacheHandler.Instance.Replace <double?>(CachingKey.SubverseHighestRank(subverse), highestRankCacheEntry, TimeSpan.FromMinutes(30));
}
}
}
public static int CommentCount(int submissionID)
{
string cacheKey = CachingKey.CommentCount(submissionID);
var data = CacheHandler.Instance.Register(cacheKey, new Func <int?>(() =>
{
using (var repo = new Repository())
{
return(repo.GetCommentCount(submissionID));
}
}), _cacheTime, 3);
return(data.Value);
}
protected override void UpdateCache(CommandResponse <bool?> result)
{
if (result.Success)
{
if (_setRef.Name.IsEqual(SetType.Front.ToString()))
{
CacheHandler.Instance.Remove(CachingKey.UserSubscriptions(UserName));
}
else if (_setRef.Name.IsEqual(SetType.Blocked.ToString()))
{
CacheHandler.Instance.Remove(CachingKey.UserBlocks(UserName));
}
}
}
protected override async Task <IEnumerable <Vote> > GetData()
{
using (var repo = new Repository(User))
{
var result = await repo.GetVotes(_subverse, _options);
//Add to cache
if (result != null && result.Any())
{
result.ForEach(x => CacheHandler.Replace(CachingKey.Vote(x.ID), x, TimeSpan.FromMinutes(30)));
}
return(result);
}
}
public ICsvRowActivatorFactory <T> Create(IConverterProvider converterProvider, IColumnNameMapper columnNameMapper)
{
CachingKey key = new CachingKey(converterProvider, columnNameMapper);
if (!cache.Keys.Contains(key))
{
var newFactory = factoryFactory.Create(converterProvider, columnNameMapper);
cache.Add(key, newFactory);
return(newFactory);
}
else
{
return(cache[key]);
}
}
public string Get()
{
var cachingKey = new CachingKey(CachingKeys.VERSION_NUMBER_KEY);
var version = cachingService.Get(cachingKey);
if (version != null)
{
return(version.ToString());
}
var result = System.IO.File.ReadAllText(Path.Combine(this.hostingEnvironment.WebRootPath, "version.txt"));
cachingService.Put(cachingKey, result);
return(result);
}
protected override void UpdateCache(CommandResponse result)
{
if (result.Success)
{
//Cleare user cache
CacheHandler.Instance.Remove(CachingKey.UserBlocks(_options.UserName));
CacheHandler.Instance.Remove(CachingKey.UserInformation(_options.UserName));
CacheHandler.Instance.Remove(CachingKey.UserOverview(_options.UserName));
CacheHandler.Instance.Remove(CachingKey.UserPreferences(_options.UserName));
CacheHandler.Instance.Remove(CachingKey.UserSubscriptions(_options.UserName));
CacheHandler.Instance.Remove(CachingKey.UserData(_options.UserName));
CacheHandler.Instance.Remove(CachingKey.UserBlocks(_options.UserName));
CacheHandler.Instance.Remove(CachingKey.UserRecord(_options.UserName));
//CacheHandler.Instance.Remove(CachingKey.UserSavedItems(_options.UserName));
}
}
protected override void UpdateCache(CommandResponse result)
{
if (result.Success)
{
var hasDomain = _banList.Any(x => x.Type == BanType.Domain);
var hasUser = _banList.Any(x => x.Type == BanType.User);
if (hasDomain)
{
CacheHandler.Instance.Remove(CachingKey.BannedDomains());
}
if (hasUser)
{
CacheHandler.Instance.Remove(CachingKey.BannedUsers());
}
}
}
public ActionResult AddLinkFlair(SubverseFlairInput subverseFlairSetting)
{
if (!ModelState.IsValid)
{
return(View("~/Views/Subverses/Admin/Flair/AddLinkFlair.cshtml", subverseFlairSetting));
}
//check perms
if (!ModeratorPermission.HasPermission(User, subverseFlairSetting.Subverse, Domain.Models.ModeratorAction.ModifyFlair))
{
return(RedirectToAction("Index", "Home"));
}
// get model for selected subverse
var subverse = DataCache.Subverse.Retrieve(subverseFlairSetting.Subverse);
if (subverse == null)
{
return(HybridError(ErrorViewModel.GetErrorViewModel(ErrorType.SubverseNotFound)));
}
var count = _db.SubverseFlair.Count(x => x.Subverse == subverseFlairSetting.Subverse);
if (count >= 20)
{
ViewBag.SubverseModel = subverse;
ViewBag.SubverseName = subverse.Name;
ViewBag.SelectedSubverse = string.Empty;
SetNavigationViewModel(subverse.Name);
ModelState.AddModelError("", "Subverses are limited to 20 flairs");
return(View("~/Views/Subverses/Admin/Flair/AddLinkFlair.cshtml", subverseFlairSetting));
}
subverseFlairSetting.Subverse = subverse.Name;
_db.SubverseFlair.Add(new SubverseFlair()
{
Label = subverseFlairSetting.Label,
CssClass = subverseFlairSetting.CssClass,
Subverse = subverseFlairSetting.Subverse
});
_db.SaveChanges();
//clear cache
CacheHandler.Instance.Remove(CachingKey.SubverseFlair(subverse.Name));
return(RedirectToAction("SubverseFlairSettings"));
}
protected override void UpdateCache(CommandResponse <bool?> result)
{
if (result.Success)
{
string key = CachingKey.UserSavedItems(_type, UserName);
if (result.Response.HasValue && CacheHandler.Instance.Exists(key))
{
if (result.Response.Value)
{
CacheHandler.Instance.SetAdd(key, _id);
}
else
{
CacheHandler.Instance.SetRemove(key, _id);
}
}
}
}
