public async Task UpdateForumThread(ForumThreadModel forumThread)
{
forumThread.UpdateTimestamps(false);
using (var ct = GetConnection(DatabaseType.Forum, false))
{
await ct.DbConnection.ExecuteAsync(ReadQuery("UpdateForumThread", ct.ProviderName), forumThread, transaction : ct.DbTransaction);
}
}
public async Task InsertForumThread(ForumThreadModel forumThread, bool importFlag = false)
{
forumThread.UpdateGuid();
forumThread.UpdateTimestamps(true, importFlag);
using (var ct = GetConnection(DatabaseType.Forum, false))
{
await ct.DbConnection.ExecuteAsync(ReadQuery("InsertForumThread", ct.ProviderName), forumThread, transaction : ct.DbTransaction);
}
}
public async Task <IActionResult> InsertForumThread([FromBody] ForumThreadModel forumThread)
{
var result = await _forumService.UpsertForumThread(forumThread, Guid.Parse(HttpContext.User.Identity.Name),
HttpContext.User.IsInRole("ForumAdmin"));
if (result.Successful)
{
return(this.Ok(forumThread));
}
else
{
return(this.StatusCode(400, result));
}
}
public async Task <IActionResult> AddThread([FromBody] ForumThreadModel thread)
{
await forumThreadRepository.CreateThreadAsync(thread.Title, thread.Author);
var threads = await forumThreadRepository.ThreadsOrderedByDateAsync();
return(Ok(threads.ToEnumerable()
.Select(x => new ForumThreadModel
{
Id = x.Id,
Author = x.Author,
CreationDate = x.CreationDate,
Title = x.Title
})));
}
public ActionResult ViewThread(long?id, int?page)
{
int pageSize = 25;
if (!id.HasValue)
{
return(View("NotAvailable"));
}
var t = this.Forums.GetThread(id.Value);
if (t == null || t.IsDeleted)
{
return(View("NotFound"));
}
Forum f = t.Forum;
ForumAccess a = this.Security.GetUserForumAccess(CurrentUser, f);
if (!a.CanRead)
{
return(View("NotAuthorized"));
}
lock (syncRoot)
{
t = this.Forums.GetThread(id.Value);
t.Views = t.Views + 1;
this.Db.SubmitChanges();
}
if (CurrentUser != null)
{
ThreadRead tr = (from thr in this.Db.ThreadReads
where thr.ThreadID == id && thr.UserID == CurrentUser.UserID
select thr).SingleOrDefault();
if (tr == null)
{
tr = new ThreadRead
{
ThreadID = t.ThreadID,
UserID = CurrentUser.UserID,
DateRead = DateTime.UtcNow,
};
this.Db.ThreadReads.InsertOnSubmit(tr);
}
else
{
tr.DateRead = DateTime.UtcNow;
}
this.Db.SubmitChanges();
}
var posts = this.GetPostsInformation(t);
int postCount = posts.Count();
int pages = Pager.PageCount(postCount, pageSize);
page = Pager.ClampPage(page, pages);
posts = posts.OrderBy(p => p.Post.CreateDate).Skip((page.Value - 1) * pageSize).Take(pageSize);
ForumThreadModel tm = new ForumThreadModel
{
Thread = t,
Posts = posts.ToList(),
UserAccess = a,
PageInfo = new PaginationInformation
{
Pager = this.Skins.GetDefaultThreadPager(),
CurrentPage = page,
Items = postCount,
ItemsPerPage = pageSize,
ControllerName = "Forums",
ActionName = "ViewThread",
PageAttribute = "page",
RouteValues = new System.Web.Routing.RouteValueDictionary(new { id = id })
}
};
return(View("ViewThread", tm));
}
public async Task <OpResult> UpsertForumThread(ForumThreadModel forumThread, Guid forumUserGuid, bool isForumAdmin, bool importFlag = false)
{
var retvalue = new OpResult();
ForumThreadModel existingForumThread = null;
if (forumThread == null)
{
retvalue.LogError(THREAD_ERROR_DATA_MUST_BE_PROVIDED);
return(retvalue);
}
if (!importFlag)
{
if (forumThread.Guid != Guid.Empty)
{
existingForumThread = await _forumDal.GetForumThreadById(forumThread.Guid, null);
if (existingForumThread == null)
{
retvalue.LogError(THREAD_ERROR_INVALID_RECORD);
}
else
{
forumThread.UniqueName = existingForumThread.UniqueName;
forumThread.CreatedUTC = existingForumThread.CreatedUTC;
forumThread.ModifiedUTC = existingForumThread.ModifiedUTC;
forumThread.ForumUserGuid = existingForumThread.ForumUserGuid;
if (!isForumAdmin)
{
forumThread.ForumGuid = existingForumThread.ForumGuid;
forumThread.LockFlag = existingForumThread.LockFlag;
forumThread.VisibleFlag = existingForumThread.VisibleFlag;
if (forumThread.ForumUserGuid != forumUserGuid || !forumThread.VisibleFlag || forumThread.LockFlag)
{
retvalue.LogError(THREAD_ERROR_NOT_AUTHORIZED);
}
if (forumThread.CreatedUTC.HasValue &&
(DateTime.UtcNow - forumThread.CreatedUTC.Value).TotalMinutes > _settingsProvider.Current.TimeLimitForumPostEdit)
{
retvalue.LogError(THREAD_ERROR_TOO_LATE_TO_UPDATE);
}
}
}
}
else
{
forumThread.ForumUserGuid = forumUserGuid;
}
}
if (string.IsNullOrWhiteSpace(forumThread.Name))
{
retvalue.LogError(THREAD_ERROR_TITLE_IS_REQUIRED);
}
if (forumThread.Guid == Guid.Empty)
{
if (forumThread.InitialPost == null)
{
retvalue.LogError(THREAD_ERROR_INITIAL_POST_IS_REQUIRED);
}
}
if (retvalue.Successful)
{
var existingForumThreadUniqueNames = (await _forumDal.ListForumThreads(forumThread.ForumGuid, null))
.ToDictionary(ft => ft.UniqueName, ft => true, StringComparer.OrdinalIgnoreCase);
forumThread.GenerateUniqueName(existingForumThreadUniqueNames);
_forumDal.OpenTransaction(DatabaseType.Forum, false);
try
{
if (importFlag || forumThread.Guid == Guid.Empty)
{
await _forumDal.InsertForumThread(forumThread, importFlag);
}
else
{
await _forumDal.UpdateForumThread(forumThread);
}
if (forumThread.InitialPost != null)
{
forumThread.InitialPost.ForumThreadGuid = forumThread.Guid;
retvalue.Inhale(await UpsertForumThreadPost(forumThread.InitialPost, forumUserGuid, isForumAdmin, importFlag));
}
_forumDal.CommitTransaction(DatabaseType.Forum);
}
catch (Exception ex)
{
_forumDal.RollBackTransaction(DatabaseType.Forum);
throw new Exception("Forum Thread Transaction Rolled Back Due to Previous Errors", ex);
}
}
return(retvalue);
}
public ForumServiceTests()
{
//Setup
forumData = new ForumModel();
forumThreadData = new ForumThreadModel();
forumThreadPostData = new ForumThreadPostModel();
forumUserData = new ForumUserModel();
settingsData = new SettingsData();
mockedSettingsProvider = new Mock <ISettingsProvider>();
mockedSettingsProvider.SetupGet <SettingsData>(sd => sd.Current).Returns(settingsData);
mockedForumDal = new Mock <IForumDal>();
mockedForumDal.Setup(fd => fd.InsertForum(forumData, false)).Returns(Task.Delay(0));
mockedForumDal.Setup(fd => fd.UpdateForum(forumData)).Returns(Task.Delay(0));
mockedForumDal.Setup(fd => fd.GetForumById(invalidGuid, null)).ReturnsAsync((ForumModel)null);
mockedForumDal.Setup(fd => fd.GetForumById(validGuid, null)).ReturnsAsync(new ForumModel());
mockedForumDal.Setup(ad => ad.GetForumById(visibleGuid, null)).ReturnsAsync(new ForumModel()
{
VisibleFlag = true
});
mockedForumDal.Setup(ad => ad.GetForumById(hiddenGuid, null)).ReturnsAsync(new ForumModel()
{
VisibleFlag = false
});
mockedForumDal.Setup(ad => ad.ListForums()).ReturnsAsync(new List <ForumModel> {
new ForumModel()
{
VisibleFlag = true
},
new ForumModel()
{
VisibleFlag = false
}
});
mockedForumDal.Setup(fd => fd.InsertForumThread(forumThreadData, false)).Returns(Task.Delay(0));
mockedForumDal.Setup(fd => fd.UpdateForumThread(forumThreadData)).Returns(Task.Delay(0));
mockedForumDal.Setup(fd => fd.GetForumThreadById(invalidGuid, null)).ReturnsAsync((ForumThreadModel)null);
mockedForumDal.Setup(fd => fd.GetForumThreadById(validGuid, null)).ReturnsAsync(new ForumThreadModel()
{
ForumUserGuid = validGuid, VisibleFlag = true, LockFlag = false, CreatedUTC = DateTime.UtcNow.AddMinutes(-1)
});
mockedForumDal.Setup(fd => fd.GetForumThreadById(semiValidGuid1, null)).ReturnsAsync(new ForumThreadModel()
{
ForumUserGuid = validGuid, VisibleFlag = false, LockFlag = false, CreatedUTC = DateTime.UtcNow.AddMinutes((-1 * settingsData.TimeLimitForumPostEdit) - 1)
});
mockedForumDal.Setup(fd => fd.GetForumThreadById(semiValidGuid2, null)).ReturnsAsync(new ForumThreadModel()
{
ForumUserGuid = validGuid, VisibleFlag = true, LockFlag = true, CreatedUTC = DateTime.UtcNow.AddMinutes((-1 * settingsData.TimeLimitForumPostEdit) - 1)
});
mockedForumDal.Setup(ad => ad.GetForumThreadById(visibleGuid, null)).ReturnsAsync(new ForumThreadModel()
{
VisibleFlag = true
});
mockedForumDal.Setup(ad => ad.GetForumThreadById(hiddenGuid, null)).ReturnsAsync(new ForumThreadModel()
{
VisibleFlag = false
});
mockedForumDal.Setup(ad => ad.ListForumThreads(null, null)).ReturnsAsync(new List <ForumThreadModel> {
new ForumThreadModel()
{
VisibleFlag = true
},
new ForumThreadModel()
{
VisibleFlag = false
}
});
mockedForumDal.Setup(fd => fd.InsertForumThreadPost(forumThreadPostData, false)).Returns(Task.Delay(0));
mockedForumDal.Setup(fd => fd.UpdateForumThreadPost(forumThreadPostData)).Returns(Task.Delay(0));
mockedForumDal.Setup(fd => fd.GetForumThreadPostById(invalidGuid)).ReturnsAsync((ForumThreadPostModel)null);
mockedForumDal.Setup(fd => fd.GetForumThreadPostById(validGuid)).ReturnsAsync(new ForumThreadPostModel()
{
ForumUserGuid = validGuid, VisibleFlag = true, LockFlag = false, CreatedUTC = DateTime.UtcNow.AddMinutes(-1)
});
mockedForumDal.Setup(fd => fd.GetForumThreadPostById(semiValidGuid1)).ReturnsAsync(new ForumThreadPostModel()
{
ForumUserGuid = validGuid, VisibleFlag = false, LockFlag = false, CreatedUTC = DateTime.UtcNow.AddMinutes((-1 * settingsData.TimeLimitForumPostEdit) - 1)
});
mockedForumDal.Setup(fd => fd.GetForumThreadPostById(semiValidGuid2)).ReturnsAsync(new ForumThreadPostModel()
{
ForumUserGuid = validGuid, VisibleFlag = true, LockFlag = true, CreatedUTC = DateTime.UtcNow.AddMinutes((-1 * settingsData.TimeLimitForumPostEdit) - 1)
});
mockedForumDal.Setup(ad => ad.GetForumThreadPostById(visibleGuid)).ReturnsAsync(new ForumThreadPostModel()
{
VisibleFlag = true
});
mockedForumDal.Setup(ad => ad.GetForumThreadPostById(hiddenGuid)).ReturnsAsync(new ForumThreadPostModel()
{
VisibleFlag = false
});
mockedForumDal.Setup(ad => ad.ListForumThreadPosts(null, null, null, null)).ReturnsAsync(new List <ForumThreadPostModel> {
new ForumThreadPostModel()
{
VisibleFlag = true
},
new ForumThreadPostModel()
{
VisibleFlag = false
}
});
mockedForumDal.Setup(fd => fd.InsertForumUser(forumUserData, false)).Returns(Task.Delay(0));
mockedForumDal.Setup(fd => fd.UpdateForumUser(forumUserData)).Returns(Task.Delay(0));
mockedForumDal.Setup(fd => fd.GetForumUserById(invalidGuid, null)).ReturnsAsync((ForumUserModel)null);
mockedForumDal.Setup(fd => fd.GetForumUserById(validGuid, null)).ReturnsAsync(new ForumUserModel());
forumService = new ForumService(mockedForumDal.Object, mockedSettingsProvider.Object);
}
public async Task <IActionResult> UpdateForumThread([FromBody] ForumThreadModel forumThread)
{
return(await InsertForumThread(forumThread));
}
