/// <summary>
/// Calls the db and updates the term and action for a given modclassid
/// </summary>
/// <param name="readerCreator"></param>
/// <param name="modClassId"></param>
/// <param name="historyId"></param>
public bool UpdateTermForModClassId(IDnaDataReaderCreator readerCreator, int modClassId, int historyId)
{
if (string.IsNullOrEmpty(Value))
{//if empty then throw exception
throw new Exception("Term value cannot be empty.");
}
if (historyId == 0)
{//if empty then throw exception
throw new Exception("HistoryId cannot be 0.");
}
if (modClassId == 0)
{//if empty then throw exception
throw new Exception("ModClassId cannot be 0.");
}
bool termUpdated = true;
using (IDnaDataReader reader = readerCreator.CreateDnaDataReader("addtermsfilterterm"))
{
reader.AddParameter("term", Value);
reader.AddParameter("actionId", (byte)Action);
reader.AddParameter("modClassId", modClassId);
reader.AddParameter("historyId", historyId);
reader.Execute();
if (reader.HasRows && reader.Read())
{
termUpdated = reader.GetBoolean("termupdated");
}
}
return termUpdated;
}
static public ReviewForum CreateFromDatabase(IDnaDataReaderCreator readerCreator, int id, bool isReviewForumID)
{
ReviewForum forum = new ReviewForum()
{
Id = id
};
using (IDnaDataReader reader = readerCreator.CreateDnaDataReader("fetchreviewforumdetails"))
{
if (isReviewForumID)
{
reader.AddParameter("reviewforumid", id);
}
else
{
reader.AddParameter("h2g2id", id);
}
reader.Execute();
// Check to see if we found anything
if (reader.HasRows && reader.Read())
{
forum.Id = reader.GetInt32NullAsZero("ReviewForumID");
forum.ForumName = reader.GetStringNullAsEmpty("forumname");
forum.UrlFriendlyName = reader.GetStringNullAsEmpty("urlfriendlyname");
forum.H2g2Id = reader.GetInt32NullAsZero("h2g2id");
forum.SiteId = reader.GetInt32NullAsZero("siteid");
forum.IncubateTime = reader.GetInt32NullAsZero("IncubateTime");
forum.Recommendable= reader.GetByteNullAsZero("recommend");
}
}
return forum;
}
static public ArticleInfoRelatedMembers GetRelatedMembers(int h2g2Id, IDnaDataReaderCreator readerCreator)
{
ArticleInfoRelatedMembers members = new ArticleInfoRelatedMembers();
members.RelatedArticles = RelatedArticle.GetRelatedArticles(h2g2Id, readerCreator);
members.RelatedClubs = RelatedClubs.GetRelatedClubs(h2g2Id, readerCreator);
return members;
}
static public ArticleInfoSubmittable CreateSubmittable(IDnaDataReaderCreator readerCreator, int h2g2Id, bool isSubmittable)
{
ArticleInfoSubmittable submittable = new ArticleInfoSubmittable();
using (IDnaDataReader reader = readerCreator.CreateDnaDataReader("fetchreviewforummemberdetails"))
{
reader.AddParameter("h2g2id", h2g2Id);
reader.Execute();
if (reader.HasRows && reader.Read())
{
submittable.Forum = new SubmittableForum(){Id=reader.GetInt32("ForumID")};
submittable.Thread = new SubmittableThread() { Id = reader.GetInt32("ThreadID") };
submittable.Post = new SubmittablePost() { Id = reader.GetInt32("PostID") };
submittable.Type = "IN";
submittable.ReviewForum = ReviewForum.CreateFromDatabase(readerCreator, reader.GetInt32("ReviewForumID"), true);
}
else if (isSubmittable)
{
submittable.Type = "YES";
}
else
{
submittable.Type = "NO";
}
}
return submittable;
}
/// <summary>
/// Load list of smileys which need to be replaced by Smiley XML.
/// Generate XML replacements.
/// Generate RegEx to match smiley shortcode.
/// </summary>
/// <returns></returns>
public static void LoadSmileys(IDnaDataReaderCreator creator)
{
Replacements.Clear();
TagReplacements.Clear();
IsInitialised = false;
String regex = String.Empty;
using (IDnaDataReader dataReader = creator.CreateDnaDataReader("getsmileylist"))
{
dataReader.Execute();
while (dataReader.Read())
{
String name = dataReader.GetStringNullAsEmpty("name");
String shorthand = dataReader.GetStringNullAsEmpty("tag");
String replace = "<SMILEY TYPE='***' H2G2='Smiley#***'/>";
shorthand = StringUtils.EscapeAllXml(shorthand);
if (shorthand.IndexOf("<") == 0)
{
TagReplacements.Add(shorthand, replace.Replace("***", name));
}
else
{
Replacements.Add(shorthand, replace.Replace("***", name));
}
}
}
IsInitialised = true;
}
/// <summary>
/// Debug constructor
/// </summary>
/// <param name="signInSystem">The sign in system to use</param>
/// <param name="dnaDataReaderCreator">A DnaDataReaderCreator object for creating the procedure this class needs.
/// If NULL, it uses the connection stringsfrom the configuration manager</param>
/// <param name="dnaDiagnostics">A DnaDiagnostics object for logging purposes</param>
/// <param name="caching">The caching object that the class can use for caching</param>
/// <param name="debugUserID">A userid for debugging/testing purposes</param>
/// <param name="siteList">A SiteList object for getting siteoption values</param>
public CallingUser(SignInSystem signInSystem, IDnaDataReaderCreator dnaDataReaderCreator, IDnaDiagnostics dnaDiagnostics, ICacheManager caching, string debugUserID, ISiteList siteList)
: base(dnaDataReaderCreator, dnaDiagnostics, caching)
{
_signInSystem = signInSystem;
_debugUserID = debugUserID;
_siteList = siteList;
}
/// <summary>
/// Constructs objects
/// </summary>
public User()
{
_dnaDataReaderCreator = null;
_dnaDiagnostics = null;
_cacheManager = null;
Groups = new List<Group>();
}
static public SiteEvent CreateComplaintArticleEventActivity(IDnaDataReader dataReader, IDnaDataReaderCreator creator)
{
SiteEvent siteEvent = null;
try
{
siteEvent = new SiteEvent();
siteEvent.SiteId = dataReader.GetInt32NullAsZero("siteid");
siteEvent.Date = new Date(dataReader.GetDateTime("DateCreated"));
siteEvent.Type = SiteActivityType.ComplaintArticle;
var complainantUserName = dataReader.GetStringNullAsEmpty("complainantUserName");
if (String.IsNullOrEmpty(complainantUserName))
{
complainantUserName = "******";
}
siteEvent.ActivityData = XElement.Parse(
string.Format(DataFormat,
dataReader.GetInt32NullAsZero("complaintantID_userid"), complainantUserName,
dataReader.GetInt32NullAsZero("h2g2id"), dataReader.GetStringNullAsEmpty("subject"),
dataReader.GetStringNullAsEmpty("complainttext"))
);
siteEvent.UserId = 0;
siteEvent.SaveEvent(creator);
}
catch(Exception e)
{
siteEvent = null;
SiteEventsProcessor.SiteEventLogger.LogException(e);
}
return siteEvent;
}
/// <summary>
/// Constructs objects
/// </summary>
public User(IDnaDataReaderCreator dnaDataReaderCreator, IDnaDiagnostics dnaDiagnostics, ICacheManager cacheManager)
{
_dnaDataReaderCreator = dnaDataReaderCreator;
_dnaDiagnostics = dnaDiagnostics;
_cacheManager = cacheManager;
Groups = new List<Group>();
}
static public ArticleInfoPageAuthor CreateListForArticle(int h2g2Id, int editorId, IDnaDataReaderCreator readerCreator)
{
ArticleInfoPageAuthor author = new ArticleInfoPageAuthor();
// Create the datareader to get the authors
using (IDnaDataReader reader = readerCreator.CreateDnaDataReader("getauthorsfromh2g2id"))
{
reader.AddParameter("h2g2ID", h2g2Id);
reader.Execute();
// Now go through all the results in turn
int lastUserID = 0;
while (reader.Read())
{
// Get the current researcher
int researcherID = reader.GetInt32("UserID");
if (researcherID != lastUserID)
{
// Check to see if we've just got the editors results
User researcher = User.CreateUserFromReader(reader);
author.Researchers.Add(researcher);
if (researcherID == editorId)
{
author.Editor = new UserElement() { user = researcher };
}
lastUserID = researcherID;
}
}
}
return author;
}
/// <summary>
/// Registers complaint against post
/// </summary>
/// <param name="creator"></param>
/// <param name="userId"></param>
/// <param name="complaintText"></param>
/// <param name="email"></param>
/// <param name="postId"></param>
/// <param name="verificationUid"></param>
/// <param name="modId"></param>
public static void RegisterComplaint(IDnaDataReaderCreator creator, int userId, String complaintText,
String email, int postId, string ipAddress, Guid bbcUid, out Guid verificationUid, out int modId)
{
verificationUid = Guid.Empty;
modId = 0;
using (IDnaDataReader dataReader = creator.CreateDnaDataReader("registerpostingcomplaint"))
{
dataReader.AddParameter("complainantid", userId);
dataReader.AddParameter("correspondenceemail", email);
dataReader.AddParameter("postid", postId);
dataReader.AddParameter("complainttext", complaintText);
dataReader.AddParameter("ipaddress", ipAddress);
dataReader.AddParameter("bbcuid", bbcUid);
//HashValue
Guid hash = DnaHasher.GenerateHash(Convert.ToString(userId) + ":" + email + ":" + Convert.ToString(postId) + ":" + complaintText);
dataReader.AddParameter("hash", hash);
dataReader.Execute();
// Send Email
if (dataReader.Read())
{
if (dataReader.DoesFieldExist("modId"))
{
modId = dataReader.GetInt32NullAsZero("modId");
}
if (dataReader.DoesFieldExist("verificationUid"))
{
verificationUid = dataReader.GetGuid("verificationUid");
}
}
}
}
/// <summary>
/// Checks if an item has a group alert
/// </summary>
/// <param name="reader"></param>
/// <param name="groupId"></param>
/// <param name="userId"></param>
/// <param name="siteId"></param>
/// <param name="itemType"></param>
/// <param name="itemId"></param>
static public void HasGroupAlertOnItem(IDnaDataReaderCreator readerCreator, ref int groupId, int userId, int siteId, EventItemTypes itemType, int itemId)
{
groupId =0;
IDnaDataReader reader = null;
switch (itemType)
{
case EventItemTypes.IT_FORUM: reader = readerCreator.CreateDnaDataReader("getforumgroupalertid"); reader.AddParameter("itemid", itemId); break;
case EventItemTypes.IT_H2G2: reader = readerCreator.CreateDnaDataReader("getarticlegroupalertid"); reader.AddParameter("itemid", itemId); break;
case EventItemTypes.IT_NODE: reader = readerCreator.CreateDnaDataReader("getnodegroupalertid"); reader.AddParameter("nodeid", itemId); break;
case EventItemTypes.IT_THREAD: reader = readerCreator.CreateDnaDataReader("getthreadgroupalertid"); reader.AddParameter("threadid", itemId); break;
case EventItemTypes.IT_CLUB: reader = readerCreator.CreateDnaDataReader("getclubgroupalertid"); reader.AddParameter("itemid", itemId); break;
default: throw new NotImplementedException();
}
using (reader)
{
reader.AddParameter("userid", userId);
reader.AddParameter("siteid", siteId);
reader.Execute();
if (reader.Read())
{
groupId = reader.GetInt32NullAsZero("GroupID");
}
}
}
/// <summary>
/// Creates a mocked datareader and loads it with row data ready to replay
/// </summary>
/// <param name="mocks">The mock repository object that all the tests are running with</param>
/// <param name="procedureName">The name of the procedure you want to call</param>
/// <param name="creator">The new DataReaderCreator object</param>
/// <param name="reader">The new DataReader object</param>
/// <param name="testRowData">A list of test row data to load the reader with</param>
static public void CreateMockedDataBaseObjects(MockRepository mocks, string procedureName, out IDnaDataReaderCreator creator, out IDnaDataReader reader, List<TestDatabaseRow> testRowData)
{
reader = CreateMockedIDnaDataReader(mocks, testRowData);
creator = mocks.DynamicMock<IDnaDataReaderCreator>();
creator.Stub(x => x.CreateDnaDataReader(procedureName)).Return(reader);
mocks.ReplayAll();
}
/// <summary>
/// Creates the forum specific term admin object
/// </summary>
/// <param name="readerCreator"></param>
/// <param name="cacheManager"></param>
/// <param name="forumId"></param>
/// <returns></returns>
public static TermsFilterAdmin CreateForumTermAdmin(IDnaDataReaderCreator readerCreator, ICacheManager cacheManager,
int forumId)
{
var termAdmin = new TermsFilterAdmin(forumId, true);
termAdmin.TermsList = TermsList.GetTermsListByForumId(readerCreator, cacheManager, forumId, true);
return termAdmin;
}
public static List<ArticleSummary> GetChildArticles(IDnaDataReaderCreator readerCreator, int nodeID, int siteID)
{
List<ArticleSummary> childArticles = new List<ArticleSummary>();
using (IDnaDataReader reader = readerCreator.CreateDnaDataReader("getarticlesinhierarchynode"))
{
reader.AddParameter("nodeID", nodeID);
reader.AddParameter("currentsiteid", siteID);
reader.Execute();
if (reader.HasRows)
{
while (reader.Read())
{
ArticleSummary childArticle = new ArticleSummary();
childArticle.H2G2ID = reader.GetInt32NullAsZero("h2g2id");
childArticle.Name = reader.GetStringNullAsEmpty("subject");
childArticle.StrippedName = StringUtils.StrippedName(reader.GetStringNullAsEmpty("subject"));
childArticle.Type = Article.GetArticleTypeFromInt(reader.GetInt32NullAsZero("Type"));
childArticle.Editor = new UserElement() { user = User.CreateUserFromReader(reader, "editor")} ;
childArticle.DateCreated = new DateElement(reader.GetDateTime("datecreated"));
childArticle.LastUpdated = new DateElement(reader.GetDateTime("lastupdated")); ;
//childArticle.SortOrder = null;
childArticle.Status = ArticleStatus.GetStatus(reader.GetInt32NullAsZero("status"));
childArticles.Add(childArticle);
}
}
}
return childArticles;
}
static public SiteEvent CreateNewUserEventActivity(IDnaDataReader dataReader, IDnaDataReaderCreator creator)
{
SiteEvent siteEvent = null;
try
{
siteEvent = new SiteEvent();
siteEvent.SiteId = dataReader.GetInt32NullAsZero("siteid");
siteEvent.Date = new Date(dataReader.GetDateTime("DateCreated"));
siteEvent.Type = SiteActivityType.NewUserToSite;
siteEvent.ActivityData = XElement.Parse(
string.Format(DataFormat,
dataReader.GetInt32NullAsZero("user_userid"), dataReader.GetStringNullAsEmpty("user_username"),
dataReader.GetInt32NullAsZero("siteid"))
);
siteEvent.UserId = dataReader.GetInt32NullAsZero("user_userid");
siteEvent.SaveEvent(creator);
}
catch(Exception e)
{
siteEvent = null;
SiteEventsProcessor.SiteEventLogger.LogException(e);
}
return siteEvent;
}
public Context(IDnaDiagnostics dnaDiagnostics, IDnaDataReaderCreator dataReaderCreator, ICacheManager cacheManager, ISiteList siteList)
{
DnaDiagnostics = dnaDiagnostics;
DnaDataReaderCreator = dataReaderCreator;
CacheManager = cacheManager;
SiteList = siteList;
}
/// <summary>
/// Gets Recommendations from cache or db if not found in cache
/// </summary>
/// <param name="cache"></param>
/// <param name="readerCreator"></param>
/// <param name="ignoreCache"></param>
/// <returns></returns>
public static Recommendations CreateRecommendations(ICacheManager cache, IDnaDataReaderCreator readerCreator, bool ignoreCache)
{
var recommendations = new Recommendations();
//string key = recommendations.GetCacheKey();
//check for item in the cache first
/*
if (!ignoreCache)
{
//not ignoring cache
recommendations = (Recommendations)cache.GetData(key);
if (recommendations != null)
{
//check if still valid with db...
if (recommendations.IsUpToDate(readerCreator))
{
return recommendations;
}
}
}
*/
//create from db
recommendations = CreateRecommendationsFromDatabase(readerCreator);
//add to cache
//cache.Add(key, recommendations);
return recommendations;
}
public ExModerationProcessor(IDnaDataReaderCreator dataReaderCreator,
IDnaLogger logger,
IDnaHttpClientCreator httpClientCreator)
{
DataReaderCreator = dataReaderCreator;
HttpClientCreator = httpClientCreator;
ExModLogger = logger;
}
/// <summary>
/// Creates the term admin object
/// </summary>
/// <param name="readerCreator"></param>
/// <param name="cacheManager"></param>
/// <param name="modClassId"></param>
/// <returns></returns>
public static TermsFilterAdmin CreateTermAdmin(IDnaDataReaderCreator readerCreator, ICacheManager cacheManager,
int modClassId)
{
var termAdmin = new TermsFilterAdmin() ;
termAdmin.ModerationClasses = ModerationClassListCache.GetObject();
termAdmin.TermsList = TermsList.GetTermsListByModClassId(readerCreator, cacheManager, modClassId, true);
return termAdmin;
}
public static string GetDatabaseVersion(IDnaDataReaderCreator readerCreator)
{
using (var dataReader = readerCreator.CreateDnaDataReader("dna.DatabaseVersion"))
{
dataReader.Execute();
dataReader.Read();
var databaseVersion = dataReader.GetString("DatabaseVersion");
return databaseVersion;
}
}
public SnesActivityProcessor(IDnaDataReaderCreator dataReaderCreator,
IDnaLogger logger,
IDnaHttpClientCreator httpClientCreator,
int batchSize)
{
DataReaderCreator = dataReaderCreator;
HttpClientCreator = httpClientCreator;
BatchSize = batchSize;
SnesActivityLogger = logger;
}
/// <summary>
/// Helper function to set up parameters for CreateCategory call
/// </summary>
/// <param name="mocks"></param>
/// <param name="cache"></param>
/// <param name="article"></param>
/// <param name="article_h2g2id"></param>
/// <param name="readerCreator"></param>
/// <param name="viewingUser"></param>
public void CreateCategory_SetupDefaultMocks(out MockRepository mocks, out ICacheManager cache, out Article article, int article_h2g2id, out IDnaDataReaderCreator readerCreator, out User viewingUser, out ISite site)
{
mocks = new MockRepository();
cache = mocks.DynamicMock<ICacheManager>();
article = ArticleTest.CreateArticle();
article.H2g2Id = article_h2g2id;
article.EntryId = article_h2g2id / 10;
readerCreator = mocks.DynamicMock<IDnaDataReaderCreator>();
viewingUser = UserTest.CreateTestUser();
site = mocks.DynamicMock<ISite>();
}
public static SiteStatistics CreateSiteStatistics(IDnaDataReaderCreator readerCreator, int siteId)
{
var stats = new SiteStatistics();
stats.TotalUneditedEntries = GetUneditedArticleCount(readerCreator, siteId);
stats.TotalEditedEntries = GetTotalEditedEntries(readerCreator, siteId);
stats.MostRecentGuideEntries = CreateRecentArticles(readerCreator, siteId, 0, 20);
stats.MostRecentConversations = CreateRecentConversations(readerCreator, siteId, 0, 20);
return stats;
}
static public void ProcessArticleModerationDecisionActivity(IDnaDataReaderCreator DataReaderCreator)
{
//Get Article Moderation Events
using (IDnaDataReader reader = DataReaderCreator.CreateDnaDataReader("getsiteevents_articlemoderationdecision"))
{
reader.Execute();
while (reader.Read())
{
ArticleModerationDecision.CreateArticleModerationDecisionActivity(reader, DataReaderCreator);
}
}
}
static public void ProcessUserModatedEventActivity(IDnaDataReaderCreator DataReaderCreator)
{
using (IDnaDataReader reader = DataReaderCreator.CreateDnaDataReader("getsiteevents_usermoderation"))
{
reader.Execute();
while (reader.Read())
{
CreateUserModatedEventActivity(reader, DataReaderCreator);
}
}
}
static public void ProcessComplaintArticleEventActivity(IDnaDataReaderCreator DataReaderCreator)
{
using (IDnaDataReader reader = DataReaderCreator.CreateDnaDataReader("getsiteevents_complaintarticle"))
{
reader.Execute();
while (reader.Read())
{
CreateComplaintArticleEventActivity(reader, DataReaderCreator);
}
}
}
static public void ProcessNewUserEventActivity(IDnaDataReaderCreator DataReaderCreator)
{
using (IDnaDataReader reader = DataReaderCreator.CreateDnaDataReader("getsiteevents_newuser"))
{
reader.Execute();
while (reader.Read())
{
CreateNewUserEventActivity(reader, DataReaderCreator);
}
}
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="connectionString">Connection details for accessing the database</param>
/// <param name="caching">The caching object that the class can use for caching</param>
public UserGroups(IDnaDataReaderCreator dnaDataReaderCreator, IDnaDiagnostics dnaDiagnostics, ICacheManager caching)
{
_dnaDataReaderCreator = dnaDataReaderCreator;
_dnaDiagnostics = dnaDiagnostics;
_cachedGroups = caching;
if (_cachedGroups == null)
{
_cachedGroups = new StaticCacheManager();
}
}
public void TestsSetup()
{
//SnapshotInitialisation.ForceRestore();
using (FullInputContext _context = new FullInputContext(""))
{
dnaDiagnostics = _context.dnaDiagnostics;
readerCreator = new DnaDataReaderCreator(_context.DnaConfig.ConnectionString, dnaDiagnostics);
}
var bannedEmails = new BannedEmails(readerCreator, dnaDiagnostics, _emailCache, null, null);
bannedEmails.Clear();
}
