/// <summary> Removes the sync logic for member _postedByUser</summary>
/// <param name="signalRelatedEntity">If set to true, it will call the related entity's UnsetRelatedEntity method</param>
/// <param name="resetFKFields">if set to true it will also reset the FK fields pointing to the related entity</param>
private void DesetupSyncPostedByUser(bool signalRelatedEntity, bool resetFKFields)
{
this.PerformDesetupSyncRelatedEntity( _postedByUser, new PropertyChangedEventHandler( OnPostedByUserPropertyChanged ), "PostedByUser", SD.HnD.DAL.RelationClasses.StaticMessageRelations.UserEntityUsingPostedByUserIDStatic, true, signalRelatedEntity, "PostedMessages", resetFKFields, new int[] { (int)MessageFieldIndex.PostedByUserID } );
_postedByUser = null;
}
/// <summary> setups the sync logic for member _placedInQueueByUser</summary>
/// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
private void SetupSyncPlacedInQueueByUser(IEntityCore relatedEntity)
{
if(_placedInQueueByUser!=relatedEntity)
{
DesetupSyncPlacedInQueueByUser(true, true);
_placedInQueueByUser = (UserEntity)relatedEntity;
this.PerformSetupSyncRelatedEntity( _placedInQueueByUser, new PropertyChangedEventHandler( OnPlacedInQueueByUserPropertyChanged ), "PlacedInQueueByUser", SD.HnD.DAL.RelationClasses.StaticSupportQueueThreadRelations.UserEntityUsingPlacedInQueueByUserIDStatic, true, ref _alreadyFetchedPlacedInQueueByUser, new string[] { } );
}
}
/// <summary>
/// Checks if the user with the given UserID exists in the database.
/// </summary>
/// <param name="userID">The UserID of the user to check if he/she exists in the database</param>
/// <returns>true if user exists, false otherwise. </returns>
public static bool DoesUserExist(int userID)
{
UserEntity user = new UserEntity(userID);
// return true if the user entity was fetched succesfully, i.e.: the entity isn't new anymore.
return (!user.IsNew);
}
/// <summary> setups the sync logic for member _setByUser</summary>
/// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
private void SetupSyncSetByUser(IEntityCore relatedEntity)
{
if(_setByUser!=relatedEntity)
{
DesetupSyncSetByUser(true, true);
_setByUser = (UserEntity)relatedEntity;
this.PerformSetupSyncRelatedEntity( _setByUser, new PropertyChangedEventHandler( OnSetByUserPropertyChanged ), "SetByUser", SD.HnD.DAL.RelationClasses.StaticIPBanRelations.UserEntityUsingIPBanSetByUserIDStatic, true, ref _alreadyFetchedSetByUser, new string[] { "SetByUserNickName" } );
}
}
/// <summary>Private CTor for deserialization</summary>
/// <param name="info"></param>
/// <param name="context"></param>
protected SupportQueueThreadEntityBase(SerializationInfo info, StreamingContext context)
: base(info, context)
{
_supportQueue = (SupportQueueEntity)info.GetValue("_supportQueue", typeof(SupportQueueEntity));
if(_supportQueue!=null)
{
_supportQueue.AfterSave+=new EventHandler(OnEntityAfterSave);
}
_supportQueueReturnsNewIfNotFound = info.GetBoolean("_supportQueueReturnsNewIfNotFound");
_alwaysFetchSupportQueue = info.GetBoolean("_alwaysFetchSupportQueue");
_alreadyFetchedSupportQueue = info.GetBoolean("_alreadyFetchedSupportQueue");
_claimedByUser = (UserEntity)info.GetValue("_claimedByUser", typeof(UserEntity));
if(_claimedByUser!=null)
{
_claimedByUser.AfterSave+=new EventHandler(OnEntityAfterSave);
}
_claimedByUserReturnsNewIfNotFound = info.GetBoolean("_claimedByUserReturnsNewIfNotFound");
_alwaysFetchClaimedByUser = info.GetBoolean("_alwaysFetchClaimedByUser");
_alreadyFetchedClaimedByUser = info.GetBoolean("_alreadyFetchedClaimedByUser");
_placedInQueueByUser = (UserEntity)info.GetValue("_placedInQueueByUser", typeof(UserEntity));
if(_placedInQueueByUser!=null)
{
_placedInQueueByUser.AfterSave+=new EventHandler(OnEntityAfterSave);
}
_placedInQueueByUserReturnsNewIfNotFound = info.GetBoolean("_placedInQueueByUserReturnsNewIfNotFound");
_alwaysFetchPlacedInQueueByUser = info.GetBoolean("_alwaysFetchPlacedInQueueByUser");
_alreadyFetchedPlacedInQueueByUser = info.GetBoolean("_alreadyFetchedPlacedInQueueByUser");
_thread = (ThreadEntity)info.GetValue("_thread", typeof(ThreadEntity));
if(_thread!=null)
{
_thread.AfterSave+=new EventHandler(OnEntityAfterSave);
}
_threadReturnsNewIfNotFound = info.GetBoolean("_threadReturnsNewIfNotFound");
_alwaysFetchThread = info.GetBoolean("_alwaysFetchThread");
_alreadyFetchedThread = info.GetBoolean("_alreadyFetchedThread");
this.FixupDeserialization(FieldInfoProviderSingleton.GetInstance(), PersistenceInfoProviderSingleton.GetInstance());
// __LLBLGENPRO_USER_CODE_REGION_START DeserializationConstructor
// __LLBLGENPRO_USER_CODE_REGION_END
}
/// <summary>
/// Registers a new user, using the properties of this class.
/// </summary>
/// <param name="nickName">Name of the nick.</param>
/// <param name="dateOfBirth">The date of birth.</param>
/// <param name="emailAddress">The email address.</param>
/// <param name="emailAddressIsPublic">flag to signal if the emailaddress is visible for everyone or not</param>
/// <param name="iconURL">The icon URL.</param>
/// <param name="ipNumber">The ip number.</param>
/// <param name="location">The location.</param>
/// <param name="occupation">The occupation.</param>
/// <param name="signature">The signature.</param>
/// <param name="website">The website.</param>
/// <param name="emailTemplatePath">The email template path.</param>
/// <param name="emailData">The email data.</param>
/// <param name="autoSubscribeThreads">Default value when user creates new threads.</param>
/// <param name="defaultMessagesPerPage">Messages per page to display</param>
/// <returns>
/// UserID of new user or 0 if registration failed.
/// </returns>
public static int RegisterNewUser(string nickName, DateTime? dateOfBirth, string emailAddress, bool emailAddressIsPublic, string iconURL,
string ipNumber, string location, string occupation, string signature, string website, string emailTemplatePath, Dictionary<string, string> emailData, ParserData parserData,
bool autoSubscribeThreads, short defaultMessagesPerPage)
{
UserEntity newUser = new UserEntity();
// initialize objects
newUser.AmountOfPostings = 0;
newUser.DateOfBirth = dateOfBirth;
newUser.EmailAddress = emailAddress;
newUser.EmailAddressIsPublic = emailAddressIsPublic;
newUser.IPNumber = ipNumber;
newUser.IconURL = iconURL;
newUser.IsBanned = false;
newUser.JoinDate = DateTime.Now;
newUser.Location = location;
newUser.NickName = nickName;
newUser.Occupation = occupation;
newUser.Signature = signature;
newUser.Website = website;
string password = HnDGeneralUtils.GenerateRandomPassword();
newUser.Password = HnDGeneralUtils.CreateMD5HashedBase64String(password);
//Preferences
newUser.AutoSubscribeToThread = autoSubscribeThreads;
newUser.DefaultNumberOfMessagesPerPage = defaultMessagesPerPage;
if(!string.IsNullOrEmpty(signature))
{
newUser.SignatureAsHTML = TextParser.TransformSignatureUBBStringToHTML(signature, parserData);
}
else
{
newUser.SignatureAsHTML = "";
}
//Fetch the SystemDataEntity to use the "DefaultUserTitleNewUser" as the user title & the "DefaultRoleNewUser"
// as the roleID of the newly created RoleUserEntity.
SystemDataEntity systemData = SystemGuiHelper.GetSystemSettings();
newUser.UserTitleID = systemData.DefaultUserTitleNewUser;
RoleUserEntity roleUser = new RoleUserEntity();
roleUser.RoleID = systemData.DefaultRoleNewUser;
roleUser.User = newUser;
// first encode fields which could lead to cross-site-scripting attacks
EncodeUserTextFields(newUser);
// now save the new user entity and the new RoleUser entity recursively in one go. This will create a transaction for us
// under the hood so we don't have to do that ourselves.
if (newUser.Save(true))
{
// all ok, Email the password
bool result = HnDGeneralUtils.EmailPassword(password, emailAddress, emailTemplatePath, emailData);
}
return newUser.UserID;
}
/// <summary>
/// Encodes some of the user text fields in the passed in entity. Encoding is done here so the data is HtmlEncoded when it's saved into the database.
/// This routine is used in code to store data. It's stored encoded so viewing logic isn't relying on the encoding code inside the page, which might be
/// absent and which then would create a potential cross-site scripting error.
/// </summary>
/// <param name="toEncode">To encode.</param>
/// <remarks>Fields which are filled in by the user are encoded using HtmlEncoding. The signature is parsed by the UBB parser and therefore already
/// is free from potential scripting code as tag markers are already converted to html encoded characters. </remarks>
private static void EncodeUserTextFields(UserEntity toEncode)
{
toEncode.EmailAddress = HttpUtility.HtmlEncode(toEncode.EmailAddress);
toEncode.Occupation = HttpUtility.HtmlEncode(toEncode.Occupation);
toEncode.Location = HttpUtility.HtmlEncode(toEncode.Location);
toEncode.Website = HttpUtility.HtmlEncode(toEncode.Website);
toEncode.IconURL = HttpUtility.HtmlEncode(toEncode.IconURL);
}
/// <summary> setups the sync logic for member _userAudited</summary>
/// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
private void SetupSyncUserAudited(IEntityCore relatedEntity)
{
if(_userAudited!=relatedEntity)
{
DesetupSyncUserAudited(true, true);
_userAudited = (UserEntity)relatedEntity;
this.PerformSetupSyncRelatedEntity( _userAudited, new PropertyChangedEventHandler( OnUserAuditedPropertyChanged ), "UserAudited", SD.HnD.DAL.RelationClasses.StaticAuditDataCoreRelations.UserEntityUsingUserIDStatic, true, ref _alreadyFetchedUserAudited, new string[] { } );
}
}
/// <summary> setups the sync logic for member _user</summary>
/// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
private void SetupSyncUser(IEntityCore relatedEntity)
{
if(_user!=relatedEntity)
{
DesetupSyncUser(true, true);
_user = (UserEntity)relatedEntity;
this.PerformSetupSyncRelatedEntity( _user, new PropertyChangedEventHandler( OnUserPropertyChanged ), "User", SD.HnD.DAL.RelationClasses.StaticThreadSubscriptionRelations.UserEntityUsingUserIDStatic, true, ref _alreadyFetchedUser, new string[] { } );
}
}
/// <summary>Private CTor for deserialization</summary>
/// <param name="info"></param>
/// <param name="context"></param>
protected AuditDataCoreEntityBase(SerializationInfo info, StreamingContext context)
: base(info, context)
{
_auditAction = (AuditActionEntity)info.GetValue("_auditAction", typeof(AuditActionEntity));
if(_auditAction!=null)
{
_auditAction.AfterSave+=new EventHandler(OnEntityAfterSave);
}
_auditActionReturnsNewIfNotFound = info.GetBoolean("_auditActionReturnsNewIfNotFound");
_alwaysFetchAuditAction = info.GetBoolean("_alwaysFetchAuditAction");
_alreadyFetchedAuditAction = info.GetBoolean("_alreadyFetchedAuditAction");
_userAudited = (UserEntity)info.GetValue("_userAudited", typeof(UserEntity));
if(_userAudited!=null)
{
_userAudited.AfterSave+=new EventHandler(OnEntityAfterSave);
}
_userAuditedReturnsNewIfNotFound = info.GetBoolean("_userAuditedReturnsNewIfNotFound");
_alwaysFetchUserAudited = info.GetBoolean("_alwaysFetchUserAudited");
_alreadyFetchedUserAudited = info.GetBoolean("_alreadyFetchedUserAudited");
this.FixupDeserialization(FieldInfoProviderSingleton.GetInstance(), PersistenceInfoProviderSingleton.GetInstance());
// __LLBLGENPRO_USER_CODE_REGION_START DeserializationConstructor
// __LLBLGENPRO_USER_CODE_REGION_END
}
/// <summary> Removes the sync logic for member _userAudited</summary>
/// <param name="signalRelatedEntity">If set to true, it will call the related entity's UnsetRelatedEntity method</param>
/// <param name="resetFKFields">if set to true it will also reset the FK fields pointing to the related entity</param>
private void DesetupSyncUserAudited(bool signalRelatedEntity, bool resetFKFields)
{
this.PerformDesetupSyncRelatedEntity( _userAudited, new PropertyChangedEventHandler( OnUserAuditedPropertyChanged ), "UserAudited", SD.HnD.DAL.RelationClasses.StaticAuditDataCoreRelations.UserEntityUsingUserIDStatic, true, signalRelatedEntity, "LoggedAudits", resetFKFields, new int[] { (int)AuditDataCoreFieldIndex.UserID } );
_userAudited = null;
}
/// <summary> Removes the sync logic for member _userWhoStartedThread</summary>
/// <param name="signalRelatedEntity">If set to true, it will call the related entity's UnsetRelatedEntity method</param>
/// <param name="resetFKFields">if set to true it will also reset the FK fields pointing to the related entity</param>
private void DesetupSyncUserWhoStartedThread(bool signalRelatedEntity, bool resetFKFields)
{
this.PerformDesetupSyncRelatedEntity( _userWhoStartedThread, new PropertyChangedEventHandler( OnUserWhoStartedThreadPropertyChanged ), "UserWhoStartedThread", SD.HnD.DAL.RelationClasses.StaticThreadRelations.UserEntityUsingStartedByUserIDStatic, true, signalRelatedEntity, "StartedThreads", resetFKFields, new int[] { (int)ThreadFieldIndex.StartedByUserID } );
_userWhoStartedThread = null;
}
/// <summary>Private CTor for deserialization</summary>
/// <param name="info"></param>
/// <param name="context"></param>
protected ThreadEntityBase(SerializationInfo info, StreamingContext context)
: base(info, context)
{
_auditDataThreadRelated = (SD.HnD.DAL.CollectionClasses.AuditDataThreadRelatedCollection)info.GetValue("_auditDataThreadRelated", typeof(SD.HnD.DAL.CollectionClasses.AuditDataThreadRelatedCollection));
_alwaysFetchAuditDataThreadRelated = info.GetBoolean("_alwaysFetchAuditDataThreadRelated");
_alreadyFetchedAuditDataThreadRelated = info.GetBoolean("_alreadyFetchedAuditDataThreadRelated");
_presentInBookmarks = (SD.HnD.DAL.CollectionClasses.BookmarkCollection)info.GetValue("_presentInBookmarks", typeof(SD.HnD.DAL.CollectionClasses.BookmarkCollection));
_alwaysFetchPresentInBookmarks = info.GetBoolean("_alwaysFetchPresentInBookmarks");
_alreadyFetchedPresentInBookmarks = info.GetBoolean("_alreadyFetchedPresentInBookmarks");
_messages = (SD.HnD.DAL.CollectionClasses.MessageCollection)info.GetValue("_messages", typeof(SD.HnD.DAL.CollectionClasses.MessageCollection));
_alwaysFetchMessages = info.GetBoolean("_alwaysFetchMessages");
_alreadyFetchedMessages = info.GetBoolean("_alreadyFetchedMessages");
_threadSubscription = (SD.HnD.DAL.CollectionClasses.ThreadSubscriptionCollection)info.GetValue("_threadSubscription", typeof(SD.HnD.DAL.CollectionClasses.ThreadSubscriptionCollection));
_alwaysFetchThreadSubscription = info.GetBoolean("_alwaysFetchThreadSubscription");
_alreadyFetchedThreadSubscription = info.GetBoolean("_alreadyFetchedThreadSubscription");
_usersWhoBookmarkedThread = (SD.HnD.DAL.CollectionClasses.UserCollection)info.GetValue("_usersWhoBookmarkedThread", typeof(SD.HnD.DAL.CollectionClasses.UserCollection));
_alwaysFetchUsersWhoBookmarkedThread = info.GetBoolean("_alwaysFetchUsersWhoBookmarkedThread");
_alreadyFetchedUsersWhoBookmarkedThread = info.GetBoolean("_alreadyFetchedUsersWhoBookmarkedThread");
_usersWhoPostedInThread = (SD.HnD.DAL.CollectionClasses.UserCollection)info.GetValue("_usersWhoPostedInThread", typeof(SD.HnD.DAL.CollectionClasses.UserCollection));
_alwaysFetchUsersWhoPostedInThread = info.GetBoolean("_alwaysFetchUsersWhoPostedInThread");
_alreadyFetchedUsersWhoPostedInThread = info.GetBoolean("_alreadyFetchedUsersWhoPostedInThread");
_usersWhoSubscribedThread = (SD.HnD.DAL.CollectionClasses.UserCollection)info.GetValue("_usersWhoSubscribedThread", typeof(SD.HnD.DAL.CollectionClasses.UserCollection));
_alwaysFetchUsersWhoSubscribedThread = info.GetBoolean("_alwaysFetchUsersWhoSubscribedThread");
_alreadyFetchedUsersWhoSubscribedThread = info.GetBoolean("_alreadyFetchedUsersWhoSubscribedThread");
_forum = (ForumEntity)info.GetValue("_forum", typeof(ForumEntity));
if(_forum!=null)
{
_forum.AfterSave+=new EventHandler(OnEntityAfterSave);
}
_forumReturnsNewIfNotFound = info.GetBoolean("_forumReturnsNewIfNotFound");
_alwaysFetchForum = info.GetBoolean("_alwaysFetchForum");
_alreadyFetchedForum = info.GetBoolean("_alreadyFetchedForum");
_userWhoStartedThread = (UserEntity)info.GetValue("_userWhoStartedThread", typeof(UserEntity));
if(_userWhoStartedThread!=null)
{
_userWhoStartedThread.AfterSave+=new EventHandler(OnEntityAfterSave);
}
_userWhoStartedThreadReturnsNewIfNotFound = info.GetBoolean("_userWhoStartedThreadReturnsNewIfNotFound");
_alwaysFetchUserWhoStartedThread = info.GetBoolean("_alwaysFetchUserWhoStartedThread");
_alreadyFetchedUserWhoStartedThread = info.GetBoolean("_alreadyFetchedUserWhoStartedThread");
_supportQueueThread = (SupportQueueThreadEntity)info.GetValue("_supportQueueThread", typeof(SupportQueueThreadEntity));
if(_supportQueueThread!=null)
{
_supportQueueThread.AfterSave+=new EventHandler(OnEntityAfterSave);
}
_supportQueueThreadReturnsNewIfNotFound = info.GetBoolean("_supportQueueThreadReturnsNewIfNotFound");
_alwaysFetchSupportQueueThread = info.GetBoolean("_alwaysFetchSupportQueueThread");
_alreadyFetchedSupportQueueThread = info.GetBoolean("_alreadyFetchedSupportQueueThread");
this.FixupDeserialization(FieldInfoProviderSingleton.GetInstance(), PersistenceInfoProviderSingleton.GetInstance());
// __LLBLGENPRO_USER_CODE_REGION_START DeserializationConstructor
// __LLBLGENPRO_USER_CODE_REGION_END
}
/// <summary>
/// Checks if the user with the given NickName exists in the database. This is necessary to check if a user which gets authenticated through
/// forms authentication is still available in the database.
/// </summary>
/// <param name="nickName">The nickname of the user to check if he/she exists in the database</param>
/// <param name="user">The user object is returned</param>
/// <returns>true if user exists, false otherwise.</returns>
public static bool DoesUserExist(string nickName, out UserEntity user)
{
user = new UserEntity();
// fetch the user using the unique constraint functionality.
return user.FetchUsingUCNickName(nickName);
}
/// <summary>Private CTor for deserialization</summary>
/// <param name="info"></param>
/// <param name="context"></param>
protected MessageEntityBase(SerializationInfo info, StreamingContext context)
: base(info, context)
{
_attachments = (SD.HnD.DAL.CollectionClasses.AttachmentCollection)info.GetValue("_attachments", typeof(SD.HnD.DAL.CollectionClasses.AttachmentCollection));
_alwaysFetchAttachments = info.GetBoolean("_alwaysFetchAttachments");
_alreadyFetchedAttachments = info.GetBoolean("_alreadyFetchedAttachments");
_auditDataMessageRelated = (SD.HnD.DAL.CollectionClasses.AuditDataMessageRelatedCollection)info.GetValue("_auditDataMessageRelated", typeof(SD.HnD.DAL.CollectionClasses.AuditDataMessageRelatedCollection));
_alwaysFetchAuditDataMessageRelated = info.GetBoolean("_alwaysFetchAuditDataMessageRelated");
_alreadyFetchedAuditDataMessageRelated = info.GetBoolean("_alreadyFetchedAuditDataMessageRelated");
_thread = (ThreadEntity)info.GetValue("_thread", typeof(ThreadEntity));
if(_thread!=null)
{
_thread.AfterSave+=new EventHandler(OnEntityAfterSave);
}
_threadReturnsNewIfNotFound = info.GetBoolean("_threadReturnsNewIfNotFound");
_alwaysFetchThread = info.GetBoolean("_alwaysFetchThread");
_alreadyFetchedThread = info.GetBoolean("_alreadyFetchedThread");
_postedByUser = (UserEntity)info.GetValue("_postedByUser", typeof(UserEntity));
if(_postedByUser!=null)
{
_postedByUser.AfterSave+=new EventHandler(OnEntityAfterSave);
}
_postedByUserReturnsNewIfNotFound = info.GetBoolean("_postedByUserReturnsNewIfNotFound");
_alwaysFetchPostedByUser = info.GetBoolean("_alwaysFetchPostedByUser");
_alreadyFetchedPostedByUser = info.GetBoolean("_alreadyFetchedPostedByUser");
this.FixupDeserialization(FieldInfoProviderSingleton.GetInstance(), PersistenceInfoProviderSingleton.GetInstance());
// __LLBLGENPRO_USER_CODE_REGION_START DeserializationConstructor
// __LLBLGENPRO_USER_CODE_REGION_END
}
/// <summary>Creates a new, empty UserEntity object.</summary>
/// <returns>A new, empty UserEntity object.</returns>
public override IEntity Create()
{
IEntity toReturn = new UserEntity();
// __LLBLGENPRO_USER_CODE_REGION_START CreateNewUser
// __LLBLGENPRO_USER_CODE_REGION_END
return toReturn;
}
/// <summary> setups the sync logic for member _postedByUser</summary>
/// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
private void SetupSyncPostedByUser(IEntityCore relatedEntity)
{
if(_postedByUser!=relatedEntity)
{
DesetupSyncPostedByUser(true, true);
_postedByUser = (UserEntity)relatedEntity;
this.PerformSetupSyncRelatedEntity( _postedByUser, new PropertyChangedEventHandler( OnPostedByUserPropertyChanged ), "PostedByUser", SD.HnD.DAL.RelationClasses.StaticMessageRelations.UserEntityUsingPostedByUserIDStatic, true, ref _alreadyFetchedPostedByUser, new string[] { } );
}
}
/// <summary> Removes the sync logic for member _user</summary>
/// <param name="signalRelatedEntity">If set to true, it will call the related entity's UnsetRelatedEntity method</param>
/// <param name="resetFKFields">if set to true it will also reset the FK fields pointing to the related entity</param>
private void DesetupSyncUser(bool signalRelatedEntity, bool resetFKFields)
{
this.PerformDesetupSyncRelatedEntity( _user, new PropertyChangedEventHandler( OnUserPropertyChanged ), "User", SD.HnD.DAL.RelationClasses.StaticRoleUserRelations.UserEntityUsingUserIDStatic, true, signalRelatedEntity, "RoleUser", resetFKFields, new int[] { (int)RoleUserFieldIndex.UserID } );
_user = null;
}
/// <summary>
/// Resets the user's Password by generating a new random password which is mailed to
/// the emailaddress specified. Will fail if the nickname doesn't exist or the emailaddress
/// doesn't match with the specified emailaddress of the nickname in the database.
/// </summary>
/// <param name="nickName">Nickname of user which password should be reset</param>
/// <param name="emailAddress">Emailaddress of user</param>
/// <param name="emailTemplate">The email template.</param>
/// <param name="emailData">The email data.</param>
/// <returns>true if succeed, false otherwise</returns>
/// <exception cref="NickNameNotFoundException">Throws NickNameNotFoundException when the nickname isn't found.</exception>
/// <exception cref="EmailAddressDoesntMatchException">Throws EmailAddressDoesntMatchException when the emailaddress of the nickname isn't matching
/// with the emailaddress specified.</exception>
public static bool ResetPassword(string nickName, string emailAddress, string emailTemplate, Dictionary<string, string> emailData)
{
UserEntity user = new UserEntity();
// fetch the user using the unique constraint fetch logic on nickname
bool fetchResult = user.FetchUsingUCNickName(nickName);
if(!fetchResult)
{
// not found
throw new NickNameNotFoundException("Nickname: '" + nickName + "' not found");
}
// check emailaddress
if(user.EmailAddress.ToLowerInvariant() != emailAddress.ToLowerInvariant())
{
// no match
throw new EmailAddressDoesntMatchException("Emailaddress '" + emailAddress + "' doesn't match.");
}
// does match, reset the password
string newPassword = HnDGeneralUtils.GenerateRandomPassword();
// hash the password with an MD5 hash and store that hashed value into the database.
user.Password = HnDGeneralUtils.CreateMD5HashedBase64String(newPassword);
// store it
bool result = user.Save();
if(result)
{
// mail it
result = HnDGeneralUtils.EmailPassword(newPassword, emailAddress, emailTemplate, emailData);
}
//done
return result;
}
/// <summary>
/// Updates the user/forum/thread statistics after a message insert. Also makes sure if the thread isn't in a queue and the forum has a default support
/// queue that the thread is added to that queue
/// </summary>
/// <param name="threadID">The thread ID.</param>
/// <param name="userID">The user ID.</param>
/// <param name="transactionToUse">The transaction to use.</param>
/// <param name="postingDate">The posting date.</param>
/// <param name="addToQueueIfRequired">if set to true, the thread will be added to the default queue of the forum the thread is in, if the forum
/// has a default support queue and the thread isn't already in a queue.</param>
/// <remarks>Leaves the passed in transaction open, so it doesn't commit/rollback, it just performs a set of actions inside the
/// passed in transaction.</remarks>
internal static void UpdateStatisticsAfterMessageInsert(int threadID, int userID, Transaction transactionToUse, DateTime postingDate, bool addToQueueIfRequired, bool subscribeToThread)
{
// user statistics
UserEntity userUpdater = new UserEntity();
// set the amountofpostings field to an expression so it will be increased with 1.
userUpdater.Fields[(int)UserFieldIndex.AmountOfPostings].ExpressionToApply = (UserFields.AmountOfPostings + 1);
UserCollection users = new UserCollection();
transactionToUse.Add(users);
users.UpdateMulti(userUpdater, (UserFields.UserID == userID)); // update directly on the DB.
// thread statistics
ThreadEntity threadUpdater = new ThreadEntity();
threadUpdater.ThreadLastPostingDate = postingDate;
threadUpdater.MarkedAsDone = false;
ThreadCollection threads = new ThreadCollection();
transactionToUse.Add(threads);
threads.UpdateMulti(threadUpdater, (ThreadFields.ThreadID == threadID));
// forum statistics. Load the forum from the DB, as we need it later on. Use a fieldcompareset predicate to fetch the forum as we don't know the
// forumID as we haven't fetched the thread
ForumCollection forums = new ForumCollection();
transactionToUse.Add(forums);
// use a fieldcompare set predicate to select the forumid based on the thread. This filter is equal to
// WHERE ForumID == (SELECT ForumID FROM Thread WHERE ThreadID=@ThreadID)
var forumFilter = new FieldCompareSetPredicate(
ForumFields.ForumID, ThreadFields.ForumID, SetOperator.Equal, (ThreadFields.ThreadID == threadID));
forums.GetMulti(forumFilter);
ForumEntity containingForum = null;
if(forums.Count>0)
{
// forum found. There's just one.
containingForum = forums[0];
containingForum.ForumLastPostingDate = postingDate;
// save the forum. Just save the collection
forums.SaveMulti();
}
if(addToQueueIfRequired)
{
// If the thread involved isn't in a queue, place it in the default queue of the forum (if applicable)
SupportQueueEntity containingQueue = SupportQueueGuiHelper.GetQueueOfThread(threadID, transactionToUse);
if((containingQueue == null) && (containingForum != null) && (containingForum.DefaultSupportQueueID.HasValue))
{
// not in a queue, and the forum has a default queue. Add the thread to the queue of the forum
SupportQueueManager.AddThreadToQueue(threadID, containingForum.DefaultSupportQueueID.Value, userID, transactionToUse);
}
}
//subscribe to thread if indicated
if(subscribeToThread)
{
UserManager.AddThreadToSubscriptions(threadID, userID, transactionToUse);
}
}
/// <summary> Removes the sync logic for member _setByUser</summary>
/// <param name="signalRelatedEntity">If set to true, it will call the related entity's UnsetRelatedEntity method</param>
/// <param name="resetFKFields">if set to true it will also reset the FK fields pointing to the related entity</param>
private void DesetupSyncSetByUser(bool signalRelatedEntity, bool resetFKFields)
{
this.PerformDesetupSyncRelatedEntity( _setByUser, new PropertyChangedEventHandler( OnSetByUserPropertyChanged ), "SetByUser", SD.HnD.DAL.RelationClasses.StaticIPBanRelations.UserEntityUsingIPBanSetByUserIDStatic, true, signalRelatedEntity, "IPBansSet", resetFKFields, new int[] { (int)IPBanFieldIndex.IPBanSetByUserID } );
_setByUser = null;
}
/// <summary>
/// Returns the user entity of the user with ID userID
/// </summary>
/// <param name="userID">The user ID.</param>
/// <returns>entity with data requested or null if not found.</returns>
public static UserEntity GetUser(int userID)
{
UserEntity user = new UserEntity(userID);
if(user.IsNew)
{
// not found
return null;
}
return user;
}
/// <summary>Private CTor for deserialization</summary>
/// <param name="info"></param>
/// <param name="context"></param>
protected IPBanEntityBase(SerializationInfo info, StreamingContext context)
: base(info, context)
{
_setByUser = (UserEntity)info.GetValue("_setByUser", typeof(UserEntity));
if(_setByUser!=null)
{
_setByUser.AfterSave+=new EventHandler(OnEntityAfterSave);
}
_setByUserReturnsNewIfNotFound = info.GetBoolean("_setByUserReturnsNewIfNotFound");
_alwaysFetchSetByUser = info.GetBoolean("_alwaysFetchSetByUser");
_alreadyFetchedSetByUser = info.GetBoolean("_alreadyFetchedSetByUser");
this.FixupDeserialization(FieldInfoProviderSingleton.GetInstance(), PersistenceInfoProviderSingleton.GetInstance());
// __LLBLGENPRO_USER_CODE_REGION_START DeserializationConstructor
// __LLBLGENPRO_USER_CODE_REGION_END
}
/// <summary>
/// Returns the user entity of the user with ID userID, With A UserEntityTitle prefetched.
/// </summary>
/// <param name="userID">The user ID.</param>
/// <returns>entity with data requested</returns>
public static UserEntity GetUserWithTitleDescription(int userID)
{
PrefetchPath prefetchPath = new PrefetchPath((int)EntityType.UserEntity);
prefetchPath.Add(UserEntity.PrefetchPathUserTitle);
UserEntity user = new UserEntity(userID, prefetchPath);
if(user.IsNew)
{
// not found
return null;
}
return user;
}
/// <summary> Removes the sync logic for member _placedInQueueByUser</summary>
/// <param name="signalRelatedEntity">If set to true, it will call the related entity's UnsetRelatedEntity method</param>
/// <param name="resetFKFields">if set to true it will also reset the FK fields pointing to the related entity</param>
private void DesetupSyncPlacedInQueueByUser(bool signalRelatedEntity, bool resetFKFields)
{
this.PerformDesetupSyncRelatedEntity( _placedInQueueByUser, new PropertyChangedEventHandler( OnPlacedInQueueByUserPropertyChanged ), "PlacedInQueueByUser", SD.HnD.DAL.RelationClasses.StaticSupportQueueThreadRelations.UserEntityUsingPlacedInQueueByUserIDStatic, true, signalRelatedEntity, "SupportQueueThreadsPlaced", resetFKFields, new int[] { (int)SupportQueueThreadFieldIndex.PlacedInQueueByUserID } );
_placedInQueueByUser = null;
}
/// <summary>
/// Checks if the given nickname is already taken. If so, true is returned, otherwise false.
/// </summary>
/// <param name="sNickName">NickName to check</param>
/// <returns>true if nickname already exists in the database, false otherwise</returns>
public static bool CheckIfNickNameExists(string nickName)
{
UserEntity user = new UserEntity();
user.FetchUsingUCNickName(nickName);
return !user.IsNew;
}
/// <summary> Retrieves the related entity of type 'UserEntity', using a relation of type 'n:1'</summary>
/// <param name="forceFetch">if true, it will discard any changes currently in the currently loaded related entity and will refetch the entity from the persistent storage</param>
/// <returns>A fetched entity of type 'UserEntity' which is related to this entity.</returns>
public virtual UserEntity GetSinglePlacedInQueueByUser(bool forceFetch)
{
if( ( !_alreadyFetchedPlacedInQueueByUser || forceFetch || _alwaysFetchPlacedInQueueByUser) && !this.IsSerializing && !this.IsDeserializing && !this.InDesignMode)
{
bool performLazyLoading = this.CheckIfLazyLoadingShouldOccur(Relations.UserEntityUsingPlacedInQueueByUserID);
UserEntity newEntity = new UserEntity();
bool fetchResult = false;
if(performLazyLoading)
{
AddToTransactionIfNecessary(newEntity);
fetchResult = newEntity.FetchUsingPK(this.PlacedInQueueByUserID);
}
if(fetchResult)
{
newEntity = (UserEntity)GetFromActiveContext(newEntity);
}
else
{
if(!_placedInQueueByUserReturnsNewIfNotFound)
{
RemoveFromTransactionIfNecessary(newEntity);
newEntity = null;
}
}
this.PlacedInQueueByUser = newEntity;
_alreadyFetchedPlacedInQueueByUser = fetchResult;
}
return _placedInQueueByUser;
}
/// <summary>
/// Authenticates the user with the given Nickname and the given Password.
/// </summary>
/// <param name="nickName">Nickname of the user</param>
/// <param name="password">Password of the user</param>
/// <returns>AuthenticateResult.AllOk if the user could be authenticated,
/// AuthenticateResult.WrongUsernamePassword if user couldn't be authenticated given the current credentials,
/// AuthenticateResult.IsBanned if the user is banned. </returns>
public static AuthenticateResult AuthenticateUser(string nickName, string password, out UserEntity user)
{
// fetch the Roles related to the user when fetching the user, using a prefetchPath object.
PrefetchPath prefetchPath = new PrefetchPath((int)EntityType.UserEntity);
prefetchPath.Add(UserEntity.PrefetchPathRoles);
// fetch the user data using the nickname which has a unique constraint
user = new UserEntity();
bool fetchResult = user.FetchUsingUCNickName(nickName, prefetchPath);
if(!fetchResult)
{
// not found. Simply return that the user has specified a wrong username/password combination.
return AuthenticateResult.WrongUsernamePassword;
}
// user was found, check if the user can be authenticated and has specified the correct password.
if(user.IsBanned)
{
// user is banned. We'll report that to the caller
return AuthenticateResult.IsBanned;
}
else
{
// check password and UserID. We disallow the user with id 0 to login as that's the anonymous coward ID for a user not logged in.
string md5HashedPassword = HnDGeneralUtils.CreateMD5HashedBase64String(password);
if((md5HashedPassword == user.Password)&&(user.UserID != Globals.UserIDToDenyLogin))
{
// correct username/password combination
return AuthenticateResult.AllOk;
}
else
{
// something was wrong, report wrong authentication combination
return AuthenticateResult.WrongUsernamePassword;
}
}
}