public bool SendEmail(string to, string body)
{
try
{
MailAddress mailFrom = new MailAddress("*****@*****.**", "202MobileService");
MailAddress mailTo = new MailAddress(to, to);
SmtpClient client = new SmtpClient();
client.Host = "smtp.gmail.com";
client.Port = 587;
client.EnableSsl = true;
client.DeliveryMethod = SmtpDeliveryMethod.Network;
client.UseDefaultCredentials = false;
client.Credentials = new NetworkCredential(mailFrom.Address, "hide");
MailMessage message = new MailMessage(mailFrom, mailTo);
message.Subject = "Message from Abundant Life!";
message.Body = body;
message.IsBodyHtml = true;
client.Send(message);
return(true);
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
return(false);
}
}
public static void UpdatePassword(UpdateAccount model, out string errorMessage, bool isTest = false)
{
try
{
IMembershipTools membershipTools = AppTools.InitMembershipTools(isTest);
errorMessage = string.Empty;
if (model.NewPassword.Length < 9)
{
errorMessage = "Password must be at least 9 characters and have a special character";
}
else if (model.CurrentPassword == model.NewPassword)
{
errorMessage = "New password must be different from the current password.";
}
else if (model.NewPassword != model.RepeatPassword)
{
errorMessage = "New password and repeated password does not match.";
}
else if (membershipTools.UpdatePassword(model.UserName, model.NewPassword) == false)
{
errorMessage = "Error updating account.";
}
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
errorMessage = ex.Message;
}
}
private static string ValidateUser(UserInfo user)
{
try
{
string errorMessage = string.Empty;
if (string.IsNullOrEmpty(user.Email))
{
errorMessage += "Email is required. <br />";
}
else
{
string emailRegEx = @"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z";
if (Regex.IsMatch(user.Email, emailRegEx, RegexOptions.IgnoreCase) == false)
{
errorMessage += "Please provide valid email.<br />";
}
}
if (user.GroupUsers.Count <= 0)
{
errorMessage += "Error loading user groups. <br />";
}
return(errorMessage);
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
return("Error validating user.");
}
}
public static List <AppRequest> AppRequestsGetAll(bool isUnitTest = false)
{
List <AppRequest> appRequests = new List <AppRequest>();
try
{
ISprocCalls sprocCalls = AppTools.InitSprocCalls(isUnitTest);
DataTable requestTable = sprocCalls.AppRequestsGetAll();
AppRequest request;
foreach (DataRow row in requestTable.Rows)
{
request = new AppRequest();
request.Active = Convert.ToBoolean(row["Active"]);
request.AppBusiness = sprocCalls.GetBusinessByID(Convert.ToInt32(row["BusinessID"]));
request.AppRequestID = Convert.ToInt32(row["AppRequestID"]);
request.DateRequested = Convert.ToDateTime(row["DateRequested"]);
request.DevStatus = (row["DevStatus"] != DBNull.Value) ? row["DevStatus"].ToString() : "";
appRequests.Add(request);
}
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
}
return(appRequests);
}
public static void RecoverPassword(RecoverModel model, out string errorMessage, bool isTest = false)
{
try
{
IMembershipTools membershipTools = AppTools.InitMembershipTools(isTest);
IEmailTools emailTools = AppTools.InitEmailTools(isTest);
errorMessage = string.Empty;
if (model.Email == membershipTools.GetUserEmail(model.UserName))
{
string tempPassword = Membership.GeneratePassword(9, 1);
if (membershipTools.SetTempPassword(model.UserName, tempPassword) == false)
{
errorMessage = "Error updating account";
}
string emailBody = BuildRecoverBody(model.UserName, tempPassword);
if (emailTools.SendEmail(emailBody, model.Email) == false)
{
errorMessage = "Error sending recover email.";
}
}
else
{
errorMessage = "Email and username is not valid.";
}
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
errorMessage = ex.Message;
}
}
public static int FeatureInsert(Features feature, out string errorMessage, bool isUnitTest = false)
{
int id = -1;
try
{
ISprocCalls sprocCalls = AppTools.InitSprocCalls(isUnitTest);
IEmailTools emailTools = AppTools.InitEmailTools(isUnitTest);
errorMessage = ValidateFeature(feature);
if (string.IsNullOrEmpty(errorMessage))
{
id = sprocCalls.FeaturesInsert(feature);
if (id <= 0)
{
errorMessage = "Error inserting new feature " + feature.FeatureName + ".";
}
//else
// emailTools.SendToAll("New Feature created : " + feature.FeatureName + "<br />Description : " + feature.FeatureDescription);
}
}
catch (Exception ex)
{
errorMessage = ex.Message;
DBCommands.RecordError(ex);
}
return(id);
}
public static List <FeatureRequested> RequestedFeaturesByBusiness(int businessID, bool isUnitTest = false)
{
List <FeatureRequested> features = new List <FeatureRequested>();
try
{
ISprocCalls sprocCalls = AppTools.InitSprocCalls(isUnitTest);
DataTable featureTable = sprocCalls.BusinessRequestedFeature(businessID);
FeatureRequested requestFeature;
foreach (DataRow row in featureTable.Rows)
{
requestFeature = new FeatureRequested();
requestFeature.Active = Convert.ToBoolean(row["Active"]);
requestFeature.AppRequestID = Convert.ToInt32(row["AppRequestID"]);
requestFeature.AssignedTo = (row["AssignedTo"] != DBNull.Value) ? UserManager.GetUserByName(row["AssignedTo"].ToString()) : null;
requestFeature.DateRequested = (row["DateRequested"] != DBNull.Value) ? Convert.ToDateTime(row["DateRequested"]) : (DateTime?)null;
requestFeature.DevStatus = (row["DevStatus"] != DBNull.Value) ? row["DevStatus"].ToString() : "";
requestFeature.FeatureRequestedID = Convert.ToInt32(row["FeatureRequestedID"]);
requestFeature.RequestedFeature = FeatureGetByID(Convert.ToInt32(row["FeatureID"]));
features.Add(requestFeature);
}
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
}
return(features);
}
public static List <UserInfo> GetAllUsers(bool isTest = false)
{
List <UserInfo> allUsers = new List <UserInfo>();
try
{
ISprocCalls sprocCalls = AppTools.InitSprocCalls(isTest);
DataTable userTable = sprocCalls.UserInfoGetAll();
UserInfo user;
foreach (DataRow row in userTable.Rows)
{
user = new UserInfo();
user.UserInfoID = Convert.ToInt32(row["UserInfoID"]);
user.UserName = row["UserName"].ToString();
user.Email = row["Email"].ToString();
user.ProfileImage = row["ProfileImage"].ToString();
user.GroupUsers = GetGroupsByUserName(user.UserName, sprocCalls);
allUsers.Add(user);
}
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
}
return(allUsers);
}
public static List <Features> GetAllFeatures(bool allActive, bool isUnitTest = false)
{
List <Features> allFeatures = new List <Features>();
try
{
ISprocCalls sprocCalls = AppTools.InitSprocCalls(isUnitTest);
DataTable featureTable = sprocCalls.FeaturesGetAll();
foreach (DataRow row in featureTable.Rows)
{
Features feature = new Features();
feature.Active = allActive;
feature.FeatureDescription = (row["FeatureDescription"] != DBNull.Value) ? row["FeatureDescription"].ToString() : "";
feature.FeatureID = Convert.ToInt32(row["FeatureID"]);
feature.FeatureName = row["FeatureName"].ToString();
feature.MainFeature = Convert.ToBoolean(row["MainFeature"]);
allFeatures.Add(feature);
}
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
}
return(allFeatures);
}
public static List <UserGroups> GroupsGetAll(bool isTest = false)
{
List <UserGroups> groupList = new List <UserGroups>();
try
{
ISprocCalls sprocCalls = AppTools.InitSprocCalls(isTest);
DataTable groupTable = sprocCalls.UserGroupsGetActive();
UserGroups group;
foreach (DataRow row in groupTable.Rows)
{
group = new UserGroups();
group.Active = false;
group.GroupLevel = Convert.ToInt32(row["GroupLevel"]);
group.GroupName = row["GroupName"].ToString();
group.UserGroupID = Convert.ToInt32(row["UserGroupID"]);
groupList.Add(group);
}
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
}
return(groupList);
}
public static void UpdateUser(UserInfo user, out string errorMessage, bool isTest = false)
{
try
{
errorMessage = ValidateUser(user);
if (string.IsNullOrEmpty(errorMessage))
{
IMembershipTools membershipTools = AppTools.InitMembershipTools(isTest);
ISprocCalls sprocCalls = AppTools.InitSprocCalls(isTest);
if (membershipTools.UpdateUserEmail(user.UserName, user.Email) == false)
{
errorMessage = "Error updating email.";
}
if (sprocCalls.UserInfoUpdate(user) == false)
{
errorMessage = "Error saving user information";
}
}
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
errorMessage = ex.Message;
}
}
public bool CreateUser(string userName, string email)
{
try
{
Membership.CreateUser(userName, "p@ssword1", email);
return(true);
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
return(false);
}
}
public static bool DeleteUser(string userName, bool isTest = false)
{
try
{
IMembershipTools membershipTools = AppTools.InitMembershipTools(isTest);
return(membershipTools.DeleteUser(userName));
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
return(false);
}
}
public static void SendAlertToWorkers(bool isTest = false)
{
try
{
IEmailTools emailTools = AppTools.InitEmailTools(isTest);
emailTools.SendToGroup(2, "A new request has been sent.");
emailTools.SendToGroup(3, "A new request has been sent.");
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
}
}
public bool CreateUser(string userName, string email, string password = null)
{
try
{
password = (string.IsNullOrEmpty(password)) ? "p@ssword1" : password;
Membership.CreateUser(userName, password, email);
return(true);
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
return(false);
}
}
public static Features FeatureGetByID(int featureID, bool IsUnitTest = false)
{
Features feature = null;
try
{
ISprocCalls sprocCalls = AppTools.InitSprocCalls(IsUnitTest);
feature = sprocCalls.FeatureGetByID(featureID);
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
}
return(feature);
}
public Provider()
{
try
{
SqlMembershipProvider sqlMembershipProvider = new SqlMembershipProvider();
NameValueCollection config = new NameValueCollection();
config.Add("connectionStringName", "myConnection");
config.Add("enablePasswordRetrieval", "false");
config.Add("enablePasswordReset", "true");
config.Add("requiresQuestionAndAnswer", "false");
config.Add("applicationName", "MyApp");
config.Add("requiresUniqueEmail", "true");
config.Add("maxInvalidPasswordAttempts", "3");
config.Add("passwordAttemptWindow", "5");
config.Add("commandTimeout", "30");
config.Add("name", "AspNetSqlMembershipProvider");
config.Add("minRequiredPasswordLength", "9");
config.Add("minRequiredNonalphanumericCharacters", "1");
sqlMembershipProvider.Initialize(config["name"], config);
MembershipProviderCollection membershipProviders = new MembershipProviderCollection();
membershipProviders.Add(sqlMembershipProvider);
membershipProviders.SetReadOnly();
BindingFlags bindingFlags = BindingFlags.NonPublic | BindingFlags.Static;
Type membershipType = typeof(Membership);
membershipType.GetField("s_Initialized", bindingFlags).SetValue(null, true);
membershipType.GetField("s_InitializeException", bindingFlags).SetValue(null, null);
membershipType.GetField("s_HashAlgorithmType", bindingFlags).SetValue(null, "SHA-512");
membershipType.GetField("s_HashAlgorithmFromConfig", bindingFlags).SetValue(null, false);
membershipType.GetField("s_UserIsOnlineTimeWindow", bindingFlags).SetValue(null, 15);
membershipType.GetField("s_Provider", bindingFlags).SetValue(null, sqlMembershipProvider);
membershipType.GetField("s_Providers", bindingFlags).SetValue(null, membershipProviders);
var connectionString = Membership.Provider.GetType().GetField("_sqlConnectionString", BindingFlags.Instance | BindingFlags.NonPublic);
if (connectionString != null)
{
connectionString.SetValue(Membership.Provider, DBCommands._Connection);
}
NewPasswordNeeded();
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
}
}
public static Business BusinessGetByUser(string userName, bool isTest = false)
{
Business business = new Business();
try
{
ISprocCalls sprocCalls = AppTools.InitSprocCalls(isTest);
business = sprocCalls.GetBusinessByUser(userName);
business.user = UserManager.GetUserByName(userName);
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
}
return(business);
}
public static void InsertUser(UserInfo user, out string errorMessage, bool isTest = false)
{
try
{
errorMessage = ValidateUser(user);
if (string.IsNullOrEmpty(errorMessage))
{
errorMessage = InsertUser(user, isTest);
}
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
errorMessage = ex.Message;
}
}
public static void FeatureDelete(int featureID, out string errorMessage, bool isUnitTest = false)
{
try
{
errorMessage = string.Empty;
ISprocCalls sprocCalls = AppTools.InitSprocCalls(isUnitTest);
if (sprocCalls.FeatureDelete(featureID) == false)
{
errorMessage = "Error deleting feature.";
}
}
catch (Exception ex)
{
errorMessage = ex.Message;
DBCommands.RecordError(ex);
}
}
public static void InsertClient(UserInfo user, out string errorMessage, bool isTest = false)
{
try
{
user.GroupUsers = UserManager.GroupsGetAll();
user.GroupUsers.Where(g => g.GroupLevel == 0).FirstOrDefault().Active = true;
errorMessage = ValidateClient(user);
if (string.IsNullOrEmpty(errorMessage))
{
errorMessage = InsertUser(user, isTest);
}
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
errorMessage = ex.Message;
}
}
public bool UpdatePassword(string userName, string password)
{
try
{
MembershipUser user = Membership.GetUser(userName);
if (user.ChangePassword(user.ResetPassword(), password) == false)
{
throw new Exception("Error changing password.");
}
return(true);
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
return(false);
}
}
public bool UpdateUserEmail(string userName, string email)
{
try
{
string currentEmail = GetUserEmail(userName);
if (email != currentEmail)
{
MembershipUser user = Membership.GetUser(userName);
user.Email = email;
Membership.UpdateUser(user);
}
return(true);
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
return(false);
}
}
public static void AppRequestUpdate(AppRequest request, out string errorMessage, bool isUnitTest = false)
{
try
{
errorMessage = ValidateRequest(request);
if (string.IsNullOrEmpty(errorMessage))
{
ISprocCalls sprocCalls = AppTools.InitSprocCalls(isUnitTest);
if (sprocCalls.AppRequestUpdate(request) == false)
{
errorMessage = "Error updating request.";
}
}
}
catch (Exception ex)
{
errorMessage = ex.Message;
DBCommands.RecordError(ex);
}
}
public static void RequestFeatureUpdate(List <FeatureRequested> features, out string errorMessage, bool isUnitTest = false)
{
try
{
errorMessage = string.Empty;
ISprocCalls sprocCalls = AppTools.InitSprocCalls(isUnitTest);
foreach (FeatureRequested request in features)
{
if (sprocCalls.RequestedFeatureUpdate(request) == false)
{
errorMessage = "Error gathering all features";
}
}
}
catch (Exception ex)
{
errorMessage = ex.Message;
DBCommands.RecordError(ex);
}
}
public static void FeatureUpdate(Features feature, out string errorMessage, bool isUnitTest = false)
{
try
{
ISprocCalls sprocCalls = AppTools.InitSprocCalls(isUnitTest);
errorMessage = ValidateFeature(feature);
if (string.IsNullOrEmpty(errorMessage))
{
if (sprocCalls.FeaturesUpdate(feature) == false)
{
errorMessage = "Error updating feature " + feature.FeatureName + ".";
}
}
}
catch (Exception ex)
{
errorMessage = ex.Message;
DBCommands.RecordError(ex);
}
}
public static void BusinessUpdate(Business business, out string errorMessage, bool isTest = false)
{
try
{
errorMessage = ValidateBusiness(business);
if (string.IsNullOrEmpty(errorMessage))
{
ISprocCalls sprocCalls = AppTools.InitSprocCalls(isTest);
if (sprocCalls.BusinessUpdate(business) == false)
{
errorMessage = "Error updating business.";
}
}
}
catch (Exception ex)
{
errorMessage = ex.Message;
DBCommands.RecordError(ex);
}
}
public bool SetTempPassword(string userName, string tempPassword)
{
try
{
MembershipUser user = Membership.GetUser(userName);
if (user.ChangePassword(user.ResetPassword(), tempPassword) == false)
{
throw new Exception("Error changing password.");
}
user.LastActivityDate = DateTime.Now.AddMonths(-1);
Membership.UpdateUser(user);
return(true);
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
return(false);
}
}
public static List <Business> BusinessGetAll(bool isTest = false)
{
List <Business> businesses = new List <Business>();
try
{
ISprocCalls sprocCalls = AppTools.InitSprocCalls(isTest);
DataTable table = sprocCalls.BusinessGetAll();
Business business;
foreach (DataRow row in table.Rows)
{
business = new Business();
business.AppLink = (row["AppLink"] != DBNull.Value) ? row["AppLink"].ToString() : "";
business.AppStatus = (row["AppStatus"] != DBNull.Value) ? row["AppStatus"].ToString() : "";
business.BusinessAddress = (row["BusinessAddress"] != DBNull.Value) ? row["BusinessAddress"].ToString() : "";
business.BusinessEmail = (row["BusinessEmail"] != DBNull.Value) ? row["BusinessEmail"].ToString() : "";
business.BusinessHoursEnd = (row["BusinessHoursEnd"] != DBNull.Value) ? row["BusinessHoursEnd"].ToString() : "";
business.BusinessHoursStart = (row["BusinessHoursStart"] != DBNull.Value) ? row["BusinessHoursStart"].ToString() : "";
business.BusinessID = Convert.ToInt32(row["BusinessID"]);
business.BusinessName = (row["BusinessName"] != DBNull.Value) ? row["BusinessName"].ToString() : "";
business.BusinessPhone = (row["BusinessPhone"] != DBNull.Value) ? row["BusinessPhone"].ToString() : "";
business.FacebookUrl = (row["FacebookUrl"] != DBNull.Value) ? row["FacebokUrl"].ToString() : "";
business.ImageGalleryUrl = (row["ImageGalleryUrl"] != DBNull.Value) ? row["ImageGalleryUrl"].ToString() : "";
business.IsPublic = Convert.ToBoolean(row["IsPublic"] != DBNull.Value) ? Convert.ToBoolean(row["IsPublic"]) : false;
business.Other = (row["Other"] != DBNull.Value) ? row["Other"].ToString() : "";
business.TypeOfBusiness = (row["TypeOfBusiness"] != DBNull.Value) ? row["TypeOfBusiness"].ToString() : "";
business.user = UserManager.GetUserByName(row["UserName"].ToString());
business.WebsiteUrl = (row["WebsiteUrl"] != DBNull.Value) ? row["WebsiteUrl"].ToString() : "";
businesses.Add(business);
}
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
}
return(businesses);
}
public static UserInfo GetUserByCode(CompleteRec model, string code, bool isTest = false)
{
UserInfo user = null;
try
{
ISprocCalls sprocCalls = AppTools.InitSprocCalls(isTest);
IMembershipTools membershipTools = AppTools.InitMembershipTools(isTest);
user = sprocCalls.UserInfoGetByCode(code);
if (user.Email == model.Email)
{
if (membershipTools.UpdatePassword(model.UserName, model.Password))
{
string errorMessage = string.Empty;
user.GroupUsers = GetGroupsByUserName(user.UserName, sprocCalls);
user.RecoverCode = null;
UpdateUser(user, out errorMessage, isTest);
if (string.IsNullOrEmpty(errorMessage) == false)
{
throw new Exception(errorMessage);
}
}
}
else
{
throw new Exception("User recovered email does not match.");
}
return(user);
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
}
return(user);
}
