internal bool ValidateUser(UserModel userModel)
{
string password = userModel.Password + userModel.UserName;
HashAlgorithm mhash = new SHA1CryptoServiceProvider();
byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(password);
byte[] bytHash = mhash.ComputeHash(bytValue);
mhash.Clear();
userModel.Password = Convert.ToBase64String(bytHash);
bool validUser = false;
List <DataParameter> parameters = new List <DataParameter>();
parameters.Add(new DataParameter("UserName", userModel.UserName, "AND"));
parameters.Add(new DataParameter("Password", userModel.Password, ""));
DataSet data = DataAccess.GetSingleByMultipleParameter(new UserModel().DataProvider, "users", parameters);
if (data.Tables["users"].Rows.Count != 0)
{
UserModel loadedUser = FillUser(data.Tables["users"].Rows[0]);
validUser = true;
ForumUserController controller = new ForumUserController();
ForumUserModel forumUserModel = controller.GetForumUserByName(loadedUser.UserName);
SetStateUser(loadedUser, forumUserModel);
}
return(validUser);
}
public void SetStateUser(UserModel loadedUser, ForumUserModel forumUserModel)
{
State state = new State();
//null out password, because we don't want that to go through the session state
loadedUser.Password = "";
state.Cache().SetUser(loadedUser, forumUserModel);
}
public async Task UpdateForumUser(ForumUserModel forumUser)
{
forumUser.UpdateTimestamps(false);
using (var ct = GetConnection(DatabaseType.Forum, false))
{
await ct.DbConnection.ExecuteAsync(ReadQuery("UpdateForumUser", ct.ProviderName), param : forumUser, transaction : ct.DbTransaction);
}
}
public async Task InsertForumUser(ForumUserModel forumUser, bool importFlag = false)
{
forumUser.UpdateGuid();
forumUser.UpdateTimestamps(true, importFlag);
using (var ct = GetConnection(DatabaseType.Forum, false))
{
await ct.DbConnection.ExecuteAsync(ReadQuery("InsertForumUser", ct.ProviderName), param : forumUser, transaction : ct.DbTransaction);
}
}
private ForumUserModel FillForumUser(DataRow row)
{
ForumUserModel model = new ForumUserModel();
model.Id = (int)row["UserId"];
model.UserName = (string)row["UserName"];
model.Password = (string)row["Password"];
model.Email = (string)row["Email"];
return(model);
}
public bool CreateForumUser(ForumUserModel forumUser)
{
Dictionary <string, DataAccessType> forumUsersDictionary = new Dictionary <string, DataAccessType>();
forumUsersDictionary.Add("UserId", new DataAccessType(forumUser.Id.ToString(), typeof(int)));
forumUsersDictionary.Add("UserName", new DataAccessType(forumUser.UserName, typeof(string)));
forumUsersDictionary.Add("Password", new DataAccessType(forumUser.Password, typeof(string)));
forumUsersDictionary.Add("Email", new DataAccessType(forumUser.Email, typeof(string)));
DataAccess.Save(new ForumUserModel().DataProvider, new ForumUserModel().KeyField, "ForumUsers", forumUsersDictionary);
return(true);
}
public void SetUser(UserModel user, ForumUserModel forumUserModel)
{
if (Session["User"] == null)
{
Session["User"] = user;
}
if (forumUserModel != null)
{
Session["aspnetforumUserID"] = forumUserModel.Id;
Session["aspnetforumUserName"] = forumUserModel.UserName;
}
}
public async Task <IActionResult> InsertForumUser([FromBody] ForumUserModel forumUser)
{
var result = await _forumService.UpsertForumUser(forumUser, Guid.Parse(HttpContext.User.Identity.Name), HttpContext.User.IsInRole("ForumAdmin"));
if (result.Successful)
{
return(this.Ok(forumUser));
}
else
{
return(this.StatusCode(400, result));
}
}
protected void SubmitButtonClick(object sender, EventArgs e)
{
recaptcha.Validate();
if (Page.IsValid)
{
UserModel user = new UserModel();
ForumUserModel forumUser = new ForumUserModel();
user.CreateOrReset = true;
user.UserName = UserNameTextBox.Text;
user.Email = EmailTextBox.Text;
user.Password = PasswordReenterTextBox.Text;
//default, we make users not administrators but they are customers.
user.Administrator = false;
user.IsCustomer = true;
forumUser.UserName = UserNameTextBox.Text;
forumUser.Email = EmailTextBox.Text;
forumUser.Password = "";
UserController controller = new UserController();
if (!controller.IsExistingUser(user))
{
controller.SaveUser(user);
ForumUserController forumUserController = new ForumUserController();
forumUserController.CreateForumUser(forumUser);
MailUserCreationToUser(user, PasswordReenterTextBox.Text);
MailUserCreationToSupportMessage(user);
SendToThankYou(user.UserName, user.Email);
}
else
{
UserNameNotAvailableLabel.Visible = true;
}
}
}
public bool IsExistingUser(UserModel user)
{
State state = new State();
bool exitingUser = false;
DataSet data = DataAccess.GetSingleByParameter(new UserModel().DataProvider, "users", new KeyValuePair <string, string>("UserName", user.UserName));
if (data.Tables["users"].Rows.Count != 0)
{
UserModel loadedUser = FillUser(data.Tables["users"].Rows[0]);
exitingUser = true;
loadedUser.Password = "";
ForumUserController forumUserController = new ForumUserController();
ForumUserModel forumUserModel = forumUserController.GetForumUserByName(loadedUser.UserName);
state.Cache().SetUser(loadedUser, forumUserModel);
}
return(exitingUser);
}
public async Task <OpResult> UpsertForumUser(ForumUserModel forumUser, Guid forumUserGuid, bool isForumAdmin, bool importFlag = false)
{
var retvalue = new OpResult();
ForumUserModel existingForumUser = null;
if (forumUser == null)
{
retvalue.LogError(USER_ERROR_DATA_MUST_BE_PROVIDED);
return(retvalue);
}
if (!importFlag && forumUser.Guid != Guid.Empty)
{
existingForumUser = await _forumDal.GetForumUserById(forumUser.Guid, null);
if (existingForumUser == null)
{
retvalue.LogError(USER_ERROR_INVALID_RECORD);
}
else
{
forumUser.CreatedUTC = existingForumUser.CreatedUTC;
forumUser.ModifiedUTC = existingForumUser.ModifiedUTC;
forumUser.LastIPAddress = existingForumUser.LastIPAddress;
forumUser.LastLogon = existingForumUser.LastLogon;
if (!isForumAdmin)
{
forumUser.AdminFlag = existingForumUser.AdminFlag;
forumUser.BanFlag = existingForumUser.BanFlag;
forumUser.UserId = existingForumUser.UserId;
if (forumUser.Guid != forumUserGuid)
{
retvalue.LogError(USER_ERROR_NOT_AUTHORIZED);
}
}
}
}
if (string.IsNullOrWhiteSpace(forumUser.UserId))
{
retvalue.LogError(USER_ERROR_USER_ID_IS_REQUIRED);
}
if (string.IsNullOrWhiteSpace(forumUser.Email))
{
retvalue.LogError(USER_ERROR_EMAIL_IS_REQUIRED);
}
if (forumUser.Guid == Guid.Empty && string.IsNullOrWhiteSpace(forumUser.NewPassword.Value))
{
retvalue.LogError(USER_ERROR_PASSWORD_IS_REQUIRED_FOR_NEW_USERS);
}
if (string.IsNullOrEmpty(forumUser.Comment))
{
retvalue.LogError(USER_ERROR_COMMENT_IS_REQUIRED);
}
if (retvalue.Successful)
{
if (importFlag || forumUser.Guid == Guid.Empty)
{
if (!importFlag)
{
forumUser.Password = Security.Encrypt(forumUser.NewPassword.Value);
}
await _forumDal.InsertForumUser(forumUser, importFlag);
}
else
{
if (forumUser.NewPassword.Reset)
{
forumUser.Password = Security.Encrypt(string.Empty);
}
else if (!string.IsNullOrEmpty(forumUser.NewPassword.Value))
{
forumUser.Password = Security.Encrypt(forumUser.NewPassword.Value);
}
else
{
forumUser.Password = existingForumUser?.Password ?? string.Empty;
}
await _forumDal.UpdateForumUser(forumUser);
}
}
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> UpdateForumUser([FromBody] ForumUserModel forumUser)
{
return(await InsertForumUser(forumUser));
}
