public static ValidationResponseType IsValidLastName(string lastName)
{
ValidationResponseType response = new ValidationResponseType();
if (lastName == null || lastName == "")
{
response.isValid = false;
response.validationMessage = "Last name cannot be blank.";
return(response);
}
if (lastName.Length < Settings.Accounts.Registration.UserLastNameMinimumLength || lastName.Length > Settings.Accounts.Registration.UserLastNameNameMaximunLength)
{
response.isValid = false;
response.validationMessage = "Last name must be between " + Settings.Accounts.Registration.UserLastNameMinimumLength + "-" + Settings.Accounts.Registration.UserLastNameNameMaximunLength + " characters in length.";
return(response);
}
else if (lastName.Contains(" ")) //|| Disallow special characters: (Regex.IsMatch(lastName, "^[a-zA-Z0-9 ]*$")) == false)
{
response.isValid = false;
response.validationMessage = "Last name cannot contain spaces."; // or special charcters.";
return(response);
}
else
{
response.isValid = true;
}
return(response);
}
public static ValidationResponseType IsValidPaymentPlanName(string PlanName)
{
ValidationResponseType response = new ValidationResponseType();
//Check if name is null
if (PlanName == null || PlanName == String.Empty)
{
response.isValid = false;
response.validationMessage = "Plan name is blank.";
return(response);
}
//Check if name has any spaces
if (PlanName.Contains(" "))
{
response.isValid = false;
response.validationMessage = "Plan name cannot contain any double empty spaces";
return(response);
}
//Check if the character length conforsms to policy
if (PlanName.Length < 2 || PlanName.Length > 25)
{
response.isValid = false;
response.validationMessage = "Plan name must be between " + 2 + "-" + 35 + " characters long.";
return(response);
}
//We allow for spaces, dashes, ampersands and apostrophes, so we remove them before doing a regex for other special characters
else if ((Regex.IsMatch(PlanName.Replace("(", "").Replace(")", "").Replace(" ", ""), @"^[a-zA-Z0-9]+$")) == false)
{
response.isValid = false;
response.validationMessage = "Plan name cannot contain special characters";
return(response);
}
else
{
//Check if PlanName Exists ====================
SqlBoolStatements sqlBoolStatements = new SqlBoolStatements();
bool accountExists = sqlBoolStatements.PlanNameExists(PlanName);
if (accountExists)
{
response.isValid = false;
response.validationMessage = "Plan with that name already exists.";
return(response);
}
else
{
response.isValid = true;
}
}
return(response);
}
public static ValidationResponseType IsValidImageFormatName(string imageFormatName)
{
ValidationResponseType response = new ValidationResponseType();
//Check if name is null
if (imageFormatName == null || imageFormatName == String.Empty)
{
response.isValid = false;
response.validationMessage = "Name cannot be blank.";
return(response);
}
//Check if Objcect Name is a system reserved name:
foreach (string reservedName in Settings.Objects.Names.ReservedImageFormatNames)
{
if (Sahara.Core.Common.Methods.ObjectNames.ConvertToObjectNameKey(imageFormatName) == reservedName)
{
response.isValid = false;
response.validationMessage = imageFormatName + " is a reserved name.";
return(response);
}
}
//Check if name has ANY whitespace(s)
if (imageFormatName.Contains(" "))
{
response.isValid = false;
response.validationMessage = "Name cannot contain any spaces.";
return(response);
}
//Check if the character length conforsms to policy
if (imageFormatName.Length < Settings.Objects.Names.ObjectNameMinimumLength || imageFormatName.Length > Settings.Objects.Names.ObjectNameMaximunLength)
{
response.isValid = false;
response.validationMessage = "Name must be between " + Settings.Objects.Names.ObjectNameMinimumLength + "-" + Settings.Objects.Names.ObjectNameMaximunLength + " characters long.";
return(response);
}
//We ONLY allow for letters
else if ((Regex.IsMatch(imageFormatName, @"^[a-zA-Z0-9]+$")) == false)
{
response.isValid = false;
response.validationMessage = "Name can only contain letters and numbers. No special characters allowed.";
return(response);
}
else
{
response.isValid = true;
}
return(response);
}
/// <summary>
/// Constructor to init message, name, originalValue and type
/// </summary>
/// <param name="message">The message</param>
/// <param name="name">The name of the validation</param>
/// <param name="originalValue">The original value that was validated</param>
/// <param name="type">The response type</param>
public ValidationResponse(
string message,
string name,
object originalValue,
ValidationResponseType type)
{
Message = message;
Name = name;
OriginalValue = originalValue;
Type = type;
}
/// <summary>
/// method for determining that provided email address is valid
/// </summary>
/// <param name="email">email address to validate</param>
/// <returns>true is valid, false if not valid</returns>
public static ValidationResponseType IsValidEmail(string email)
{
ValidationResponseType response = new ValidationResponseType();
//regular expression pattern for valid email
//addresses, allows for the following domains:
//com,edu,info,gov,int,mil,net,org,biz,name,museum,coop,aero,pro,tv
string pattern = @"^[-a-zA-Z0-9][-.a-zA-Z0-9]*@[-.a-zA-Z0-9]+(\.[-.a-zA-Z0-9]+)*\.(com|edu|info|gov|int|mil|net|org|biz|name|museum|coop|aero|pro|tv|[a-zA-Z]{2}|[a-zA-Z]{3}|[a-zA-Z]{4})$";
//Regular expression object
Regex check = new Regex(pattern, RegexOptions.IgnorePatternWhitespace);
//boolean variable to return to calling method
response.isValid = false;
//make sure an email address was provided
if (string.IsNullOrEmpty(email))
{
response.isValid = false;
}
else
{
//use IsMatch to validate the address
response.isValid = check.IsMatch(email);
}
//return the value to the calling method
//Check if additional invalid characters exist
/*
* if(email.Contains(")") || email.Contains("(") || email.Contains(""))
* {
*
* }*/
if (!response.isValid)
{
response.validationMessage = "You must use a valid email address.";
return(response);
}
else
{
response.isValid = true;
response.validationMessage = "Email is valid!";
return(response);
}
}
public static DataAccessResponseType CreateTag(Account account, string tagName)
{
#region Convert multiple spaces with single
tagName = Regex.Replace(tagName, @"\s+", " ");
#endregion
#region Validate Tag Name:
ValidationResponseType ojectNameValidationResponse = ValidationManager.IsValidTagName(tagName);
if (!ojectNameValidationResponse.isValid)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = ojectNameValidationResponse.validationMessage
});
}
#endregion
#region validate tag does not exist
var tags = GetTags(account.AccountNameKey);
foreach (string tag in tags)
{
if (tag.ToLower() == tagName.ToLower())
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "A tag with that name already exists."
});
}
}
#endregion
var tagEntity = new TagTableEntity(account.AccountID.ToString(), account.StoragePartition, tagName);
var response = Internal.StoreTag(tagEntity, account.StoragePartition);
if (response.isSuccess)
{
Caching.InvalidateTagsCache(account.AccountNameKey);
}
return(response);
}
public static ValidationResponseType IsValidPhoneNumber(string phoneNumber)
{
ValidationResponseType response = new ValidationResponseType();
//string pattern = @"(\([2-9]\d\d\)|[2-9]\d\d) ?[-.,]? ?[2-9]\d\d ?[-.,]? ?\d{4}";
//Regex check = new Regex(pattern);
if (phoneNumber == null)
{
response.isValid = false;
response.validationMessage = "Phone number cannot be blank.";
return(response);
}
if (phoneNumber.Replace("-", "").Replace("(", "").Replace(")", "").Replace(" ", "").Length < 10)
{
response.isValid = false;
response.validationMessage = "Please include area code or country code.";
return(response);
}
if (phoneNumber.Length > 28)
{
response.isValid = false;
response.validationMessage = "Phone number is too long.";
return(response);
}
//if (!check.IsMatch(phoneNumber.Replace(" ", "").Replace("-", "").Replace(".", "")))
//{
//response.isValid = false;
//response.validationMessage = "Phone number is not valid. Please make sure you include area code and/or country codes.";
//return response;
//}
else
{
response.isValid = true;
}
return(response);
}
public static ValidationResponseType IsValidPlatformUserPassword(string Password)
{
ValidationResponseType response = new ValidationResponseType();
if (Password.Length < Settings.Platform.Users.Authentication.PasswordMinimumLength)
{
response.isValid = false;
response.validationMessage = "Password must be at least " + Settings.Platform.Users.Authentication.PasswordMinimumLength + " characters in length.";
return(response);
}
else
{
response.isValid = true;
}
return(response);
}
public static ValidationResponseType IsValidPropertyName(string propertyName)
{
ValidationResponseType response = new ValidationResponseType();
//Check if name is null
if (propertyName == null || propertyName == String.Empty)
{
response.isValid = false;
response.validationMessage = "Property cannot be blank.";
return(response);
}
//Check if Property Name is a system reserved name:
foreach (string reservedName in Settings.Objects.Names.ReservedPropertyNames)
{
if (Sahara.Core.Common.Methods.PropertyNames.ConvertToPropertyNameKey(propertyName) == reservedName)
{
response.isValid = false;
response.validationMessage = propertyName + " is a reserved name.";
return(response);
}
}
if (propertyName.ToLower().Contains("locationmetadata"))
{
response.isValid = false;
response.validationMessage = "Property cannot contain the term 'locationmetadata'.";
return(response);
}
//Check if name has trailing whitespace(s)
if (Regex.IsMatch(propertyName, @"\s+$"))
{
response.isValid = false;
response.validationMessage = "Property cannot contain empty spaces at the end.";
return(response);
}
//Check if name has whitespace(s) at front
if (propertyName[0].ToString() == " ")
{
response.isValid = false;
response.validationMessage = "Property cannot contain an empty space as the first character.";
return(response);
}
//Check if the character length conforsms to policy
if (propertyName.Length < Settings.Objects.Names.TagNameMinimumLength || propertyName.Length > Settings.Objects.Names.TagNameMaximunLength)
{
response.isValid = false;
response.validationMessage = "Property must be between " + Settings.Objects.Names.PropertyNameMinimumLength + "-" + Settings.Objects.Names.PropertyNameMaximunLength + " characters long.";
return(response);
}
//We allow for spaces, dashes, ampersands and apostrophes, so we remove them before doing a regex for other special characters
else if ((Regex.IsMatch(propertyName, "^[a-zA-Z0-9\\-\\s]*$")) == false)
{
response.isValid = false;
response.validationMessage = "Property cannot contain special characters";
return(response);
}
else
{
response.isValid = true;
}
if (propertyName.Contains(","))
{
response.isValid = false;
response.validationMessage = "Property cannot contain commas";
return(response);
}
return(response);
}
public static ValidationResponseType IsValidAccountName(string AccountName)
{
AccountName = AccountName.Trim(); //<---We trim here, since registration will also trim
ValidationResponseType response = new ValidationResponseType();
//Check if name is null
if (AccountName == null || AccountName == String.Empty)
{
response.isValid = false;
response.validationMessage = "Account name is blank.";
return(response);
}
//Check if Accounts Name is a system reserved name:
foreach (string reservedName in Settings.Accounts.Registration.ReservedAccountNames)
{
if (Sahara.Core.Common.Methods.AccountNames.ConvertToAccountNameKey(AccountName) == reservedName)
{
response.isValid = false;
response.validationMessage = AccountName + " is a reserved name.";
return(response);
}
}
//Check if name has trailing whitespace(s)
if (Regex.IsMatch(AccountName, @"\s+$"))
{
response.isValid = false;
response.validationMessage = "Name cannot contain empty spaces at the end.";
return(response);
}
//Check if name has whitespace(s) at front
if (AccountName[0].ToString() == " ")
{
response.isValid = false;
response.validationMessage = "Name cannot contain an empty space as the first character.";
return(response);
}
//Check if the character length conforsms to policy
if (AccountName.Length < Settings.Accounts.Registration.AccountNameMinimumLength || AccountName.Length > Settings.Accounts.Registration.AccountNameMaximunLength)
{
response.isValid = false;
response.validationMessage = "Name must be between " + Settings.Accounts.Registration.AccountNameMinimumLength + "-" + Settings.Accounts.Registration.AccountNameMaximunLength + " characters long.";
return(response);
}
//We allow for spaces, dashes, ampersands and apostrophes, so we remove them before doing a regex for other special characters
else if ((Regex.IsMatch(Sahara.Core.Common.Methods.AccountNames.ConvertToAccountNameKey(AccountName), "^[a-zA-Z0-9\\-]*$")) == false)
{
response.isValid = false;
response.validationMessage = "Name cannot contain special characters";
return(response);
}
else
{
//Check if AccountName Exists ====================
SqlBoolStatements sqlBoolStatements = new SqlBoolStatements();
bool accountExists = sqlBoolStatements.AccountNameExists(AccountName);
if (accountExists)
{
response.isValid = false;
response.validationMessage = "Account with that name already exists.";
return(response);
}
else
{
response.isValid = true;
}
}
//check if subdomain will be less than minimum character length after shortening (to avoid names like "--T--" being able to create subdomains like "t")
if (Sahara.Core.Common.Methods.AccountNames.ConvertToAccountNameKey(AccountName).Length < Settings.Accounts.Registration.AccountNameMinimumLength)
{
response.isValid = false;
response.validationMessage = "Name must have at least " + Settings.Accounts.Registration.AccountNameMinimumLength + " alphanumeric characters.";
return(response);
}
return(response);
}
public static DataAccessResponseType RegisterNewAccount(RegisterNewAccountModel model)
{
//trim the name of whitespaces (start & end):
model.AccountName = model.AccountName.Trim();
#region Refactoring notes
/*
*
* With some refactoring you can start them directly with a chosen payment plan by passing a planid parameter to the Registration site (and ultimatly into this method) along with C.C. info
*
* This method will then check for a MonthlyRate > 0 and attempt to process the C.C.
* note: You would only add a Credit Card capture form to the Registration site if a plan with a MonthlyRate above 0 is selected -->
*
*
*
* -- Adding a new "AllowRegistration" bool to the PaymentPlan object will allow for validation of selected plans coming in from users on this method for scenarios where users can choose a plan while signing up to avoid passing in ID's for plans such as "Unlimited" which must be approved by a Platform Admin
*
*/
#endregion
var response = new DataAccessResponseType {
isSuccess = true
};
try
{
#region Validate Account Info
//Validate Registration Data:
#region Refactoring notes
/*
*
*
* -- Adding a new "AllowRegistration" bool to the PaymentPlan object will allow for validation of selected plans coming in from users on AccountRegistrationManager for scenarios where users can choose a plan while signing up to avoid passing in ID's for plans such as "Unlimited" which must be approved by a Platform Admin
*
* > response.ErrorMessages.Add("Not a valid payment plan for public registration");
*
*/
#endregion
#region Validate Password(s) Match
if (model.Password != model.ConfirmPassword)
{
response.isSuccess = false;
response.ErrorMessages.Add("Password and password confirmation do not match");
}
#endregion
#region Validate Account Name:
ValidationResponseType accountNameValidationResponse = ValidationManager.IsValidAccountName(model.AccountName);
if (!accountNameValidationResponse.isValid)
{
response.isSuccess = false;
response.ErrorMessages.Add(accountNameValidationResponse.validationMessage);
//return response;
}
#endregion
#region Validate User Name
ValidationResponseType firstNameValidationResponse = ValidationManager.IsValidFirstName(model.FirstName);
if (!firstNameValidationResponse.isValid)
{
response.isSuccess = false;
response.ErrorMessages.Add(firstNameValidationResponse.validationMessage);
//return response;
}
ValidationResponseType lastNameValidationResponse = ValidationManager.IsValidLastName(model.LastName);
if (!lastNameValidationResponse.isValid)
{
response.isSuccess = false;
response.ErrorMessages.Add(lastNameValidationResponse.validationMessage);
//return response;
}
#endregion
#region Validate Email Unique (Optional)
/*
* var userValidation = AccountUserManager.GetUserIdentity(model.Email);
* if (userValidation != null)
* {
* response.isSuccess = false;
* response.ErrorMessages.Add("Another account is associated with that email address, please provide another");
* }
*/
#endregion
//If validation(s) fails, return the response:
if (response.isSuccess == false)
{
//Log Platform Activity
string errors = string.Empty;
foreach (string error in response.ErrorMessages)
{
errors += error + "|";
}
PlatformLogManager.LogActivity(CategoryType.Registration,
ActivityType.Registration_Failed,
String.Format("Registration failed for: '{0}' by: {1} from: {2}", model.AccountName, model.Email, model.Origin),
String.Format("Errors:{0}", errors
));
//Return the response
response.ErrorMessage = "Could not register this account";
return(response);
}
#endregion
// Generate AccountID ====================================
Guid accountId = Guid.NewGuid();
#region Register Initial AccountUser (AKA: AccountOwner)
#region Validate & Create Account Owner User
// Further validations and account owner creation:
var registerUserResponse = AccountUserManager.RegisterAccountOwner(
model.FirstName,
model.LastName,
accountId.ToString(),
model.AccountName,
model.Email,
model.Password
);
#endregion
if (!registerUserResponse.isSuccess)
{
//Log Platform Activity
string errors = string.Empty;
foreach (string error in registerUserResponse.ErrorMessages)
{
errors += error + "|";
}
PlatformLogManager.LogActivity(CategoryType.Registration,
ActivityType.Registration_Failed,
String.Format("Registration failed for: '{0}' by: {1} from: {2}", model.AccountName, model.Email, model.Origin),
String.Format("Errors:{0}", errors
));
//Return the response
response.isSuccess = false;
response.ErrorMessage = registerUserResponse.ErrorMessage;
response.ErrorMessages = registerUserResponse.ErrorMessages;
return(response);
}
//Get user back from result
var user = (AccountUserIdentity)registerUserResponse.ResponseObject;
#endregion
#region Create Account
try
{
// Create Accounts =============================================================
InsertStatements insertStatements = new InsertStatements();
var insertResult = insertStatements.InsertNewAccount(model, accountId);
if (insertResult.isSuccess)
{
// (Optional) for certain scenrios
//Add user to account, make them the owner, and assign them as SuperAdmin role:
//AccountManager.AddUserToAccount(user.Id, AccountID.ToString(), true); // <-- Only for certain scenarios
response.isSuccess = true;
response.SuccessMessage = Sahara.Core.Settings.Copy.PlatformMessages.AccountRegistration.SuccessMessage;
var origin = "";
if (model.Origin != null)
{
origin = "<br/><br/><b>Origin:</b> " + model.Origin;
}
var name = "<br/><br/><b>Name:</b> " + model.FirstName + " " + model.LastName;
var email = "<br/><br/><b>Email:</b> " + model.Email;
var phone = "";
if (model.PhoneNumber != null)
{
phone = "<br/><br/><b>Phone:</b> " + model.PhoneNumber;
}
try
{
//Send an alert to the platform admin(s):
EmailManager.Send(
Settings.Endpoints.Emails.PlatformEmailAddresses,
Settings.Endpoints.Emails.FromRegistration,
"Registration",
"New Registrant",
"A new account named <b>'" + model.AccountName + "'</b> has just been registered." + name + email + phone + origin,
true
);
}
catch
{
}
//Log The Activity ------------ :
//PlatformLogManager.LogActivity(CategoryType.Registration,
//ActivityType.Registration_Succeeded,
//String.Format("Registration completed for: '{0}' by: {1} from: {2}", model.AccountName, model.Email, model.Origin),
//String.Format("Name:'{0}', Email:'{1}', Origin:{2}", model.AccountName, model.Email, model.Origin));
PlatformLogManager.LogActivity(CategoryType.Account,
ActivityType.Account_Registered,
String.Format("Registration completed for: '{0}' by: {1} from: {2}", model.AccountName, model.Email, model.Origin),
String.Format("Name:'{0}', Email:'{1}', Origin:{2}", model.AccountName, model.Email, model.Origin),
accountId.ToString(),
model.AccountName,
null,
null,
null,
null,
model.Origin);
return(response);
}
else
{
#region Error Handling
string error = insertResult.ErrorMessage;
AccountUser outUser = null;
//rollback user creation:
AccountUserManager.DeleteUser(user.Id, false, out outUser);
//Log The Activity ------------ :
PlatformLogManager.LogActivity(CategoryType.Registration,
ActivityType.Registration_Failed,
String.Format("Registration failed for: '{0}' by: {1} from: {2}", model.AccountName, model.Email, model.Origin),
String.Format("Error:{0}", error));
//PlatformLogManager.LogActivity(ErrorLogActivity.PlatformError,
//String.Format("Registration failed for: '{0}' by: {1} from: {2}", model.AccountName, model.Email, model.Origin),
//String.Format("Error:{0}", error));
response.isSuccess = false;
response.ErrorMessage = error;
response.ErrorMessages.Add(error);
return(response);
#endregion
}
}
catch (Exception e)
{
#region Error Handling
string error = String.Empty;
AccountUser outUser = null;
//rollback user creation:
AccountUserManager.DeleteUser(user.Id, false, out outUser);
try
{
error = e.Message;
}
catch
{
error = "An error occured";
}
//rollback user:
//To Do: AccountUserManager.DeleteUser(model.Email);
string errorDetails = String.Format("Registration failed for: '{0}' by: {1} from: {2}", model.AccountName, model.Email, model.Origin);
//Log The Error(s) ------------ :
PlatformLogManager.LogActivity(CategoryType.Registration,
ActivityType.Registration_Error,
errorDetails,
String.Format("Error:{0}", error));
PlatformExceptionsHelper.LogExceptionAndAlertAdmins(
e,
"registering a new account for " + model.AccountName + " / " + model.Email + " / " + model.FirstName + " " + model.LastName + " from: " + model.Origin,
System.Reflection.MethodBase.GetCurrentMethod());
response.isSuccess = false;
response.ErrorMessage = error;
response.ErrorMessages.Add(error);
return(response);
#endregion
}
#endregion
}
catch (Exception e)
{
//Log The Error(s) ------------ :
PlatformLogManager.LogActivity(CategoryType.Registration,
ActivityType.Registration_Error,
String.Format("Registration failed for: '{0}' by: {1} from: {2}", model.AccountName, model.Email, model.Origin),
String.Format("Error:{0}", e.Message));
PlatformExceptionsHelper.LogExceptionAndAlertAdmins(
e,
"registering a new account for " + model.AccountName + " / " + model.Email + " / " + model.FirstName + " " + model.LastName + " from: " + model.Origin,
System.Reflection.MethodBase.GetCurrentMethod());
response.isSuccess = false;
response.ErrorMessage = "An error occured when creating the account";
response.ErrorMessages.Add(e.Message);
try
{
response.ErrorMessages.Add(e.InnerException.InnerException.Message);
}
catch
{
}
return(response);
}
}
public static DataAccessResponseType CreateImageFormat(Account account, string imageGroupTypeNameKey, string imageGroupNameKey, string imageFormatName, int width, int height, bool listing, bool gallery)
{
var response = new DataAccessResponseType();
#region Validate Plan Restrictions
if (GetCustomImageFormatCount(account.AccountNameKey) >= account.PaymentPlan.MaxImageFormats)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "You have reached your account restriction of " + account.PaymentPlan.MaxImageFormats + " custom image formats"
});
}
if (gallery && GetCustomImageGalleryCount(account.AccountNameKey) >= account.PaymentPlan.MaxImageGalleries)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "You have reached your account restriction of " + account.PaymentPlan.MaxImageGalleries + " custom image galleries"
});
}
#endregion
#region Validate Platform Restrictions
if (listing)
{
if (GetCustomImageFormatsAsListingCount(account.AccountNameKey) >= Settings.Objects.Limitations.MaximumImageFormatsAsListings)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "You have reached the platform restriction of " + Settings.Objects.Limitations.MaximumImageFormatsAsListings + " listing images per inventory"
});
}
}
#endregion
#region Validate Input
if (String.IsNullOrEmpty(imageGroupTypeNameKey))
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "imageGroupTypeNameKey cannot be empty"
});
}
if (String.IsNullOrEmpty(imageGroupNameKey))
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "imageGroupNameKey cannot be empty"
});
}
if (String.IsNullOrEmpty(imageFormatName))
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "imageFormatName cannot be empty"
});
}
if (listing && gallery)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "Image format cannot be both a Listing and a Gallery"
});
}
if (height < 1)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "Image height must be taller than 1px"
});
}
if (width < 0)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "Image width must be a positive number"
});
}
//if (width < 1) //<-- 0 now means that this is a VARIABLE WIDTH image
//{
//return new DataAccessResponseType { isSuccess = false, ErrorMessage = "Image width must be wider than 1px" };
//}
if (height > 4000)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "Image height cannot be taller than 4,000px"
});
}
if (width > 4000)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "Image width cannot be wider than 4,000px"
});
}
#endregion
#region Validate Image Format Name:
ValidationResponseType ojectNameValidationResponse = ValidationManager.IsValidImageFormatName(imageFormatName);
if (!ojectNameValidationResponse.isValid)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = ojectNameValidationResponse.validationMessage
});
}
#endregion
//CREATE NAME KEY
var imageFormatNameKey = Sahara.Core.Common.Methods.ObjectNames.ConvertToObjectNameKey(imageFormatName);
#region Validate GroupType Exists
var imageGroupTypes = GetImageFormatGroupTypes();
bool typeExists = false;
foreach (ImageFormatGroupTypeModel type in imageGroupTypes)
{
if (type.ImageFormatGroupTypeNameKey == imageGroupTypeNameKey)
{
typeExists = true;
}
}
if (!typeExists)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "Format group type '" + imageGroupTypeNameKey + "' does not exists!"
});
}
#endregion
var imageFormats = GetImageFormats(account.AccountNameKey, imageGroupTypeNameKey);
#region Validate Group Exists in this Type
bool groupExistsInType = false;
foreach (ImageFormatGroupModel group in imageFormats)
{
if (group.ImageFormatGroupTypeNameKey == imageGroupTypeNameKey && group.ImageFormatGroupNameKey == imageGroupNameKey)
{
groupExistsInType = true;
}
}
if (!groupExistsInType)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "Format group '" + imageGroupNameKey + "' does not exists!"
});
}
#endregion
#region Validate Format name is unique to this group/type combo
bool nameUniqueInGroup = true;
foreach (ImageFormatGroupModel group in imageFormats)
{
if (group.ImageFormatGroupTypeNameKey == imageGroupTypeNameKey && group.ImageFormatGroupNameKey == imageGroupNameKey)
{
foreach (ImageFormatModel format in group.ImageFormats)
{
if (format.ImageFormatName == imageFormatName || format.ImageFormatNameKey == imageFormatNameKey)
{
nameUniqueInGroup = false;
}
}
}
}
if (!nameUniqueInGroup)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "Format name '" + imageFormatNameKey + "' is not unique to the '" + imageGroupNameKey + "' group!"
});
}
#endregion
#region Create Model & ID
var imageFormat = new ImageFormatModel
{
ImageFormatGroupTypeNameKey = imageGroupTypeNameKey,
ImageFormatGroupNameKey = imageGroupNameKey,
ImageFormatID = Guid.NewGuid(),
ImageFormatName = imageFormatName,
ImageFormatNameKey = imageFormatNameKey,
Height = height,
Width = width,
Listing = listing,
Gallery = gallery
};
#endregion
//INSERT
response = Sql.Statements.InsertStatements.InsertImageFormat(account.SqlPartition, account.SchemaName, imageFormat); //, account.PaymentPlan.MaxImageFormats);
//CLear Cache
if (response.isSuccess)
{
Caching.InvalidateImageFormatCaches(account.AccountNameKey);
}
return(response);
}
public static DataAccessResponseType CreateImageGroup(Account account, string imageGroupTypeNameKey, string imageGroupName)
{
var response = new DataAccessResponseType();
#region Validate Input
#region Validate Image Group Name:
ValidationResponseType ojectNameValidationResponse = ValidationManager.IsValidImageGroupName(imageGroupName);
if (!ojectNameValidationResponse.isValid)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = ojectNameValidationResponse.validationMessage
});
}
#endregion
if (String.IsNullOrEmpty(imageGroupTypeNameKey))
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "imageGroupTypeNameKey cannot be empty"
});
}
if (String.IsNullOrEmpty(imageGroupName))
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "imageGroupName cannot be empty"
});
}
#endregion
#region Validate Plan Restrictions
if (GetCustomImageGroupCount(account.AccountNameKey) >= account.PaymentPlan.MaxImageGroups)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "You have reached your account restriction of " + account.PaymentPlan.MaxImageGroups + " custom image groups"
});
}
#endregion
//CREATE NAME KEY
var imageGroupNameKey = Sahara.Core.Common.Methods.ObjectNames.ConvertToObjectNameKey(imageGroupName);
#region Validate GroupType Exists
var imageGroupTypes = GetImageFormatGroupTypes();
bool typeExists = false;
foreach (ImageFormatGroupTypeModel type in imageGroupTypes)
{
if (type.ImageFormatGroupTypeNameKey == imageGroupTypeNameKey)
{
typeExists = true;
}
}
if (!typeExists)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "Format group type '" + imageGroupTypeNameKey + "' does not exists!"
});
}
#endregion
#region Validate GroupName is unique to this type
var imageFormats = GetImageFormats(account.AccountNameKey, imageGroupTypeNameKey);
bool nameUniqueInType = true;
foreach (ImageFormatGroupModel group in imageFormats)
{
if (group.ImageFormatGroupTypeNameKey == imageGroupTypeNameKey && group.ImageFormatGroupNameKey == imageGroupNameKey)
{
nameUniqueInType = false;
}
}
if (!nameUniqueInType)
{
return(new DataAccessResponseType {
isSuccess = false, ErrorMessage = "Group name '" + imageGroupNameKey + "' is not unique to the '" + imageGroupTypeNameKey + "' type!"
});
}
#endregion
#region Create Model & ID
var imageGroup = new ImageFormatGroupModel
{
ImageFormatGroupTypeNameKey = imageGroupTypeNameKey,
ImageFormatGroupID = Guid.NewGuid(),
ImageFormatGroupName = imageGroupName,
ImageFormatGroupNameKey = imageGroupNameKey
};
imageGroup.ImageFormatGroupID = Guid.NewGuid();
#endregion
//INSERT
response = Sql.Statements.InsertStatements.InsertImageGroup(account.SqlPartition, account.SchemaName, imageGroup); //, account.PaymentPlan.MaxImageGroups);
//CLear Cache
if (response.isSuccess)
{
Caching.InvalidateImageFormatCaches(account.AccountNameKey);
}
return(response);
}
public static DataAccessResponseType CreateProperty(Account account, string propertyTypeNameKey, string propertyName)
{
//TO DO: Always clear/update caches AND update counts!
var response = new DataAccessResponseType();
#region Validate Property Name:
ValidationResponseType propertyNameValidationResponse = ValidationManager.IsValidPropertyName(propertyName);
if (!propertyNameValidationResponse.isValid)
{
response.isSuccess = false;
response.ErrorMessage = propertyNameValidationResponse.validationMessage;
response.ErrorMessages.Add(propertyNameValidationResponse.validationMessage);
return(response);
}
#endregion
var property = new PropertyModel
{
PropertyTypeNameKey = propertyTypeNameKey,
PropertyID = Guid.NewGuid(),
PropertyName = propertyName,
PropertyNameKey = Sahara.Core.Common.Methods.PropertyNames.ConvertToPropertyNameKey(propertyName),
SearchFieldName = Sahara.Core.Common.Methods.PropertyNames.ConvertToPropertyNameKey(propertyName, true),
Facetable = false,
Sortable = false,
Listing = false,
Details = true
};
#region Check if this name already exists
var propertyExists = GetProperty(account, property.PropertyNameKey);
if (propertyExists != null)
{
response.isSuccess = false;
response.ErrorMessage = "A property with that name already exists.";
return(response);
}
#endregion
response = Sql.Statements.InsertStatements.InsertProperty(account.SqlPartition, account.SchemaName, property);
var searchUpdateResponse = new DataAccessResponseType();
if (response.isSuccess)
{
//Clear Category Caches:
Caching.InvalidateAllPropertyCachesForAccount(account.AccountNameKey);
//Update Search Index Fields
searchUpdateResponse = ProductSearchManager.AddProductPropertyToSearchIndexFields(account.SearchPartition, account.ProductSearchIndex, property.SearchFieldName, propertyTypeNameKey);
}
if (!searchUpdateResponse.isSuccess)
{
#region Rollback and send Error
//Delete the property
Sql.Statements.DeleteStatements.DeleteProperty(account.SqlPartition, account.SchemaName, property.PropertyID.ToString());
//Return the error
return(searchUpdateResponse);
#endregion
}
//Clear Caches & Send Response:
Caching.InvalidateAllPropertyCachesForAccount(account.AccountNameKey);
response.SuccessMessage = property.PropertyID.ToString(); //<--Returned for logging purposes
return(response);
}
