public static int Create(RegistrationDataModel data, RequestProfile requestProfile)
{
var sql = Save(data, "Create", requestProfile);
var newId = DBDML.RunScalarSQL("Registration.Insert", sql, DataStoreKey);
return(Convert.ToInt32(newId));
}
private void btnGenerate_Click(object sender, EventArgs e)
{
if (txtSalt.Text.Length == 0)
{
MessageBox.Show(this, "Salt can not be empty, please generate a new value", "Missing salt", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
if (registrationDataModel == null)
{
registrationDataModel = new RegistrationDataModel();
}
registrationDataModel.Company = txtCompany.Text;
registrationDataModel.FirstName = txtFirstName.Text;
registrationDataModel.LastName = txtLastName.Text;
registrationDataModel.Salt = txtSalt.Text;
registrationDataModel.ValidTo = dateTimePicker.Value;
registrationDataModel.VersionName = comboVersion.SelectedText;
serialNumberGenerator.LicenseData.RegistrationData = registrationDataModel;
serialNumberGenerator.GenerateLicenseData(rsaPrivateKeyIdentity);
txtSerial.Text = serialNumberGenerator.LicenseData.RegistrationKey;
ComputeAndSetSaltValue();
string path = destinationFolder + "\\" + serialNumberGenerator.LicenseData.RegistrationKey;
CreateFolder(path);
serialNumberGenerator.CreateLicenseFile(path + "\\license.txt");
}
public static string Save(RegistrationDataModel data, string action, RequestProfile requestProfile)
{
var sql = "EXEC ";
switch (action)
{
case "Create":
sql += "dbo.RegistrationInsert " +
" " + ToSQLParameter(BaseDataModel.BaseDataColumns.AuditId, requestProfile.AuditId) +
", " + ToSQLParameter(BaseDataModel.BaseDataColumns.ApplicationId, requestProfile.ApplicationId);
break;
case "Update":
sql += "dbo.RegistrationUpdate " +
" " + ToSQLParameter(BaseDataModel.BaseDataColumns.AuditId, requestProfile.AuditId);
break;
default:
break;
}
sql = sql + ", " + ToSQLParameter(data, RegistrationDataModel.DataColumns.RegistrationId);
sql = sql + ", " + ToSQLParameter(data, RegistrationDataModel.DataColumns.CourseId);
sql = sql + ", " + ToSQLParameter(data, RegistrationDataModel.DataColumns.StudentId);
sql = sql + ", " + ToSQLParameter(data, RegistrationDataModel.DataColumns.EnrollmentDate);
return(sql);
}
public static List <RegistrationDataModel> GetEntityDetails(RegistrationDataModel dataQuery, RequestProfile requestProfile, int returnAuditInfo = BaseDataManager.ReturnAuditInfoOnDetails)
{
const string sql = @"dbo.RegistrationSearch ";
var parameters =
new
{
AuditId = requestProfile.AuditId
, ApplicationId = requestProfile.ApplicationId
, ReturnAuditInfo = returnAuditInfo
, RegistrationId = dataQuery.RegistrationId
, CourseId = dataQuery.CourseId
, StudentId = dataQuery.StudentId
, FromSearchEnrollmentDate = dataQuery.FromSearchEnrollmentDate
, ToSearchEnrollmentDate = dataQuery.ToSearchEnrollmentDate
};
List <RegistrationDataModel> result;
using (var dataAccess = new DataAccessBase(DataStoreKey))
{
result = dataAccess.Connection.Query <RegistrationDataModel>(sql, parameters, commandType: CommandType.StoredProcedure).ToList();
}
return(result);
}
public async Task <IActionResult> Register([FromBody] RegistrationDataModel registrationDataModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ApplicationUser applicationUser = new ApplicationUser()
{
UserName = registrationDataModel.Email, Email = registrationDataModel.Email
};
var result = await _userManager.CreateAsync(applicationUser, registrationDataModel.Password);
if (result.Succeeded)
{
var code = await _userManager.GenerateEmailConfirmationTokenAsync(applicationUser);
var callbackUrl = Url.EmailConfirmationLink(applicationUser.Id, code, Request.Scheme);
await _emailSender.SendEmailConfirmationAsync(registrationDataModel.Email, callbackUrl);
await _signInManager.SignInAsync(applicationUser, isPersistent : false);
return(new OkResult());
}
return(new BadRequestObjectResult(result.Errors));
}
private void btnLoad_Click(object sender, EventArgs e)
{
openFileDialog1.Filter = "License files|*.txt";
openFileDialog1.FileName = "";
if (openFileDialog1.ShowDialog(this) == DialogResult.OK)
{
string fileName = openFileDialog1.FileName;
try
{
RegistrationDataModel registrationData = serialNumberGenerator.ReadRegistrationDataFromFile(fileName);
registrationDataModel = registrationData;
if (registrationDataModel != null)
{
txtCompany.Text = registrationDataModel.Company;
txtFirstName.Text = registrationDataModel.FirstName;
txtLastName.Text = registrationDataModel.LastName;
txtComputerId.Text = registrationData.ComputerId.ComputerId;
ComputeAndSetSaltValue();
}
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
// GET: UserAccountDetails/Details/5
public async Task <ActionResult> Details()
{
RegistrationDataModel dataModel = new RegistrationDataModel();
int id = Convert.ToInt32(Session["UserId"]);
if (id.Equals(null))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
dataModel.User = await db.TblUsers.FindAsync(id);
var address = from data in db.TblAddresses where (data.UserId.Equals(id)) select data;
dataModel.Address = address.FirstOrDefault();
var contact = from data in db.TblContacts where (data.UserId.Equals(id)) select data;
dataModel.Contact = contact.FirstOrDefault();
if (dataModel == null)
{
return(HttpNotFound());
}
return(View(dataModel));
}
public void Delete(string value)
{
var dataQuery = new RegistrationDataModel();
dataQuery.RegistrationId = int.Parse(value);
RegistrationDataManager.Delete(dataQuery, SessionVariables.RequestProfile);
}
public async Task <ActionResult> Edit(RegistrationDataModel dataModel)
{
if (ModelState.IsValid)
{
int id = Convert.ToInt32(Session["UserId"]);
TblAddress address = (from x in db.TblAddresses
where x.UserId == id
select x).FirstOrDefault();
address.Line1 = dataModel.Address.Line1;
address.Area = dataModel.Address.Area;
address.Province = dataModel.Address.Province;
address.PostalCode = dataModel.Address.PostalCode;
await db.SaveChangesAsync();
TblContact contact = (from x in db.TblContacts
where x.UserId == id
select x).FirstOrDefault();
contact.Number = dataModel.Contact.Number;
await db.SaveChangesAsync();
TblUser user = (from x in db.TblUsers
where x.UserId == id
select x).FirstOrDefault();
user.Name = dataModel.User.Name;
await db.SaveChangesAsync();
return(RedirectToAction("Details"));
}
return(View(dataModel));
}
private void btnGenerate_Click(object sender, EventArgs e)
{
if (txtFirstName.Text.Length < 2)
{
lblInfo.Text = "Missing firstname";
}
if (txtLastName.Text.Length < 2)
{
lblInfo.Text = "Missing lastname";
}
if (txtCompany.Text.Length < 2)
{
lblInfo.Text = "Missing company";
}
_registrationData = new RegistrationDataModel
{
FirstName = this.txtFirstName.Text,
LastName = this.txtLastName.Text,
Company = this.txtCompany.Text,
ComputerId = SysInfoManager.GetComputerId()
};
_registrationDataManager = RegistrationDataManager.Create(_registrationData);
txtLicenseRequest.Text = _registrationDataManager.SerializeToString();
}
public RegistrationDataModel GetById(string value)
{
var dataQuery = new RegistrationDataModel();
dataQuery.RegistrationId = int.Parse(value);
var result = RegistrationDataManager.GetEntityDetails(dataQuery, SessionVariables.RequestProfile, 1);
return(result[0]);
}
private string GetRegistrationDetails(RegistrationDataModel registrationData)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(registrationData.FirstName + " " + registrationData.LastName);
sb.AppendLine("Company: " + registrationData.Company);
sb.AppendLine("Valid to: " + registrationData.ValidTo.ToString("Y"));
return(sb.ToString());
}
// Non relevant
//[TestMethod]
public void TestValidateGeneratedRequest()
{
Assert.IsTrue(File.Exists(LicenseReqFilename), "No license request file was found. Please run 'TestGenerateLicenseRequest' first");
RegistrationDataModel registrationData = null;
FileStream fs = null;
try
{
fs = File.OpenRead(LicenseReqFilename);
StreamReader reader = new StreamReader(fs);
string regRequestContext = reader.ReadToEnd();
registrationData = ObjectSerializer.DeserializeRegistrationDataFromString(regRequestContext);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
finally
{
fs?.Close();
}
Assert.IsNotNull(registrationData, "registrationData could not be reconstructed");
//licenseService.LicenseData.RegistrationData = registrationData;
var serialNumberManager = licenseService.GetSerialNumberManager();
string registrationKey = serialNumberManager.GenerateRegistrationKey(registrationData);
Console.WriteLine(registrationKey);
Assert.IsNotNull(registrationKey, "registrationKey can not be null");
fs = null;
try
{
fs = File.Create(LicenseKeyFilename);
StreamWriter sw = new StreamWriter(fs);
sw.Write(registrationKey);
sw.Flush();
fs.Flush(true);
}
catch (Exception exception)
{
Assert.Fail(exception.Message);
}
finally
{
fs?.Close();
}
licenseService.LoadLicenseFromFile(LicenseKeyFilename);
licenseService.ValidateLicense();
Assert.IsTrue(licenseService.ValidLicense, "Valid license check failed");
}
public static bool DoesExist(RegistrationDataModel data, RequestProfile requestProfile)
{
var doesExistRequest = new RegistrationDataModel();
doesExistRequest.ApplicationId = data.ApplicationId;
doesExistRequest.CourseId = data.CourseId;
doesExistRequest.StudentId = data.StudentId;
var list = GetEntityDetails(doesExistRequest, requestProfile, 0);
return(list.Count > 0);
}
public RegistrationResultDataModel Registration(RegistrationDataModel obj)
{
using (var chatDb = new ChatDbEntities())
{
return(new RegistrationResultDataModel
{
Result = (RegistrationResultData)chatDb
.Registration(obj.Login, obj.Hash, obj.Email, obj.Color32, obj.RoleId)
.FirstOrDefault()
});
}
}
public async Task <ActionResult> Create(RegistrationDataModel registrationDataModel)
{
if (ModelState.IsValid)
{
var emails = from data in db.TblUsers select data.Email;
foreach (string email in emails)
{
if (email.Equals(registrationDataModel.Email))
{
return(Content("<script language='javascript' type='text/javascript'>alert('Email is already in use! User other Email');$.ajax({url: '/Home/Index',success: function(data) {alert(data);}});</script >"));
}
}
TblUser tblUser = new TblUser();
tblUser.Name = registrationDataModel.Name;
tblUser.Email = registrationDataModel.Email;
tblUser.UserType = registrationDataModel.UserType.ToString();
tblUser.Password = registrationDataModel.Password;
tblUser.ValidateEmail = false;
List <string> encryptedPasswordAndSalt = Password.Ecrypt(tblUser.Password);
tblUser.Salt = encryptedPasswordAndSalt[0];
tblUser.Hash = encryptedPasswordAndSalt[1];
db.TblUsers.Add(tblUser);
await db.SaveChangesAsync();
int lastGeneratedId = tblUser.UserId;
TblAddress tblAddress = new TblAddress();
tblAddress.Line1 = registrationDataModel.Line1;
tblAddress.Area = registrationDataModel.Area;
tblAddress.Province = registrationDataModel.Province;
tblAddress.PostalCode = registrationDataModel.PostalCode;
tblAddress.UserId = lastGeneratedId;
tblAddress.Country = "Canada";
db.TblAddresses.Add(tblAddress);
await db.SaveChangesAsync();
TblContact tblContact = new TblContact();
tblContact.Number = registrationDataModel.Number;
tblContact.UserId = lastGeneratedId;
db.TblContacts.Add(tblContact);
await db.SaveChangesAsync();
var sysData = from data in db.TblSysCredentials select data;
//Send Confirmation EMail
Email.Email.BuildEmailTemplate(tblUser.UserId, tblUser.Email, sysData.FirstOrDefault().Email, sysData.FirstOrDefault().Password);
//BuildEmailTemplate(tblUser.UserId);
return(RedirectToAction("Index", "Home"));
}
return(View());
}
private void InitControlState()
{
btnCreateRequest.Enabled = !ValidLicence;
btnEnterLicence.Enabled = !ValidLicence;
if (_licenceData?.RegistrationData == null)
{
return;
}
RegistrationDataModel registrationData = _licenceData.RegistrationData;
this.txtLicenceInfo.Text = this.ValidLicence ? this.GetRegistrationDetails(registrationData) : this.NotRegisteredInfoText;
txtComputerId.Text = registrationData.ComputerId.ComputerId;
}
public static void Delete(RegistrationDataModel data, RequestProfile requestProfile)
{
const string sql = @"dbo.RegistrationDelete ";
var parameters =
new
{
AuditId = requestProfile.AuditId
, RegistrationId = data.RegistrationId
};
using (var dataAccess = new DataAccessBase(DataStoreKey))
{
dataAccess.Connection.Execute(sql, parameters, commandType: CommandType.StoredProcedure);
}
}
private SerialNumberGenerator CreateSerialNumberGenerator()
{
var rsaPublicKeyIdentity = new RsaKeySetIdentity(null, RSAKeys.PublicKeys.GetKeyString());
RsaAsymetricEncryption rsaAsymmetricEncryption = new RsaAsymetricEncryption();
RSAParameters pubKeyParams = rsaAsymmetricEncryption.ParseRsaPublicKeyOnlyInfo(rsaPublicKeyIdentity);
SerialNumberGenerator serialNumberGenerator = new SerialNumberGenerator(pubKeyParams, SerialNumbersSettings.ProtectedApp.SecureMemo);
RegistrationDataModel registrationData = new RegistrationDataModel
{
Company = "Doe",
Salt = GeneralConverters.GetRandomHexValue(256),
ValidTo = DateTime.Now.AddYears(1),
VersionName = LicenseGeneratorStaticData.SecureMemo.Versions.First()
};
serialNumberGenerator.LicenseData.RegistrationData = registrationData;
return(serialNumberGenerator);
}
public void OnSignUpPressed()
{
if (string.IsNullOrEmpty(model.registrationEmail.value) || string.IsNullOrEmpty(model.registrationPassword.value) || string.IsNullOrEmpty(model.registrationConfirmPassword.value))
{
ModalPopupOK.Spawn("Please ensure all fields are filled out.");
}
else if (model.registrationPassword.value != model.registrationConfirmPassword.value)
{
ModalPopupOK.Spawn("Passwords do not match.");
}
else if (!model.registrationAcceptTerms.value)
{
ModalPopupOK.Spawn("You must accept the terms and conditions to register a new account.");
}
else
{
tempRegistrationData = new RegistrationDataModel();
tempRegistrationData.email = model.registrationEmail.value;
int atIndex = model.registrationEmail.value.IndexOf('@');
if (0 > atIndex)
{
ModalPopupOK.Spawn("The email address has been entered incorrectly.");
return;
}
tempRegistrationData.username = model.registrationEmail.value;
tempRegistrationData.password = model.registrationPassword.value;
tempRegistrationData.legal_accept = (model.registrationAcceptTerms.value ? "1" : "0");
// TODO: actual call
_registering = true;
DetermineSignUpButtonStatus();
ITTGoogleAnalytics.Instance.googleAnalytics.LogEvent(new EventHitBuilder()
.SetEventCategory("Registration - Registration Screen")
.SetEventAction("Click - Sign Up Button")
.SetEventLabel("User has clicked the sign up button. Username: "******" Legal: " + tempRegistrationData.legal_accept.ToString()));
ITTDataCache.Instance.RegisterUser(tempRegistrationData, OnRegistrationSuccess, OnRegistrationFailure);
}
}
//[TestMethod]
public void TestGenerateLicenseRequest()
{
var registrationData = new RegistrationDataModel
{
FirstName = Resources.RegFirstName,
LastName = Resources.RegLastName,
Company = Resources.RegCompany,
ComputerId = SysInfoManager.GetComputerId(),
ValidTo = DateTime.Today.AddYears(2),
VersionName = "Secure memo",
};
var registrationDataManager = RegistrationDataManager.Create(registrationData);
string licenseRequestString = registrationDataManager.SerializeToString();
// SaveDatabase to file
FileStream fs = null;
try
{
fs = File.Create(LicenseReqFilename);
StreamWriter sw = new StreamWriter(fs);
sw.Write(licenseRequestString);
sw.Flush();
fs.Flush(true);
}
catch (Exception exception)
{
Assert.Fail(exception.Message);
}
finally
{
fs?.Close();
}
Assert.IsTrue(File.Exists(LicenseReqFilename), "License request file was not generated");
//System.Diagnostics.Process.Start(LicenseReqFilename);
}
public void OnRegistrationFailure(string error)
{
_registering = false;
DetermineSignUpButtonStatus();
tempRegistrationData = null;
Debug.LogError("Registration error: " + error);
ITTGoogleAnalytics.Instance.googleAnalytics.LogEvent(new EventHitBuilder()
.SetEventCategory("Registration - Registration Screen")
.SetEventAction("Registration Failure - Registration Screen")
.SetEventLabel("User had a registration error: " + error));
if (error.Contains("406"))
{
// Get the 406 message
string[] parts = error.Split(':');
string msg = parts[parts.Length - 1];
ModalPopupOK.Spawn(msg);
}
else if (error.Contains("409") || error.ToLower().Contains("already taken"))
{
// Technically this error means the user name is in use, but since we don't have a username field... :/
ModalPopupOK.Spawn("This email address is already in use.");
}
else if (error.Contains(HelperMethods.Instance.Error_NetworkRadioOff) || error.Contains(HelperMethods.Instance.Error_NetworkTimeOut))
{
ModalPopupOK.Spawn("Experiencing connection issues with the server. Please check your connection.", () => {
StartCoroutine(OnHide());
});
}
else if (!error.Contains("200"))
{
ModalPopupOK.Spawn("An error occurred. Error: " + error);
}
else
{
ModalPopupOK.Spawn("An error occurred. Please try again later.");
}
}
// GET: UserAccountDetails/Edit/5
public async Task <ActionResult> Edit(int?id)
{
RegistrationDataModel dataModel = new RegistrationDataModel();
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
dataModel.User = await db.TblUsers.FindAsync(id);
var address = from data in db.TblAddresses where (data.UserId == id) select data;
dataModel.Address = address.FirstOrDefault();
var contact = from data in db.TblContacts where (data.UserId == id) select data;
dataModel.Contact = contact.FirstOrDefault();
if (dataModel == null)
{
return(HttpNotFound());
}
return(View(dataModel));
}
public string GenerateRegistrationKey(RegistrationDataModel registrationData)
{
byte[] licenseDataBytes = ObjectSerializer.SerializeDataContract(registrationData);
return(CreateRegistrationKey(licenseDataBytes));
}
public void Update([FromBody] RegistrationDataModel data)
{
RegistrationDataManager.Update(data, SessionVariables.RequestProfile);
}
private RegistrationDataManager(RegistrationDataModel registrationData)
{
_registrationData = registrationData;
}
public static RegistrationDataManager Create(RegistrationDataModel registrationData)
{
return(new RegistrationDataManager(registrationData));
}
public static DataTable Search(RegistrationDataModel data, RequestProfile requestProfile)
{
var list = GetEntityDetails(data, requestProfile, 0);
return(list.ToDataTable());
}
public static void Update(RegistrationDataModel data, RequestProfile requestProfile)
{
var sql = Save(data, "Update", requestProfile);
DBDML.RunSQL("Registration.Update", sql, DataStoreKey);
}
public static string ToSQLParameter(RegistrationDataModel data, string dataColumnName)
{
var returnValue = "NULL";
switch (dataColumnName)
{
case RegistrationDataModel.DataColumns.RegistrationId:
if (data.RegistrationId != null)
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NUMBER, RegistrationDataModel.DataColumns.RegistrationId, data.RegistrationId);
}
else
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NULL, RegistrationDataModel.DataColumns.RegistrationId);
}
break;
case RegistrationDataModel.DataColumns.CourseId:
if (data.CourseId != null)
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NUMBER, RegistrationDataModel.DataColumns.CourseId, data.CourseId);
}
else
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NULL, RegistrationDataModel.DataColumns.CourseId);
}
break;
case RegistrationDataModel.DataColumns.Course:
if (!string.IsNullOrEmpty(data.Course))
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_STRING_OR_DATE, RegistrationDataModel.DataColumns.Course, data.Course);
}
else
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NULL, RegistrationDataModel.DataColumns.Course);
}
break;
case RegistrationDataModel.DataColumns.StudentId:
if (data.StudentId != null)
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NUMBER, RegistrationDataModel.DataColumns.StudentId, data.StudentId);
}
else
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NULL, RegistrationDataModel.DataColumns.StudentId);
}
break;
case RegistrationDataModel.DataColumns.Student:
if (!string.IsNullOrEmpty(data.Student))
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_STRING_OR_DATE, RegistrationDataModel.DataColumns.Student, data.Student);
}
else
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NULL, RegistrationDataModel.DataColumns.Student);
}
break;
case RegistrationDataModel.DataColumns.EnrollmentDate:
if (data.EnrollmentDate != null)
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_STRING_OR_DATE, RegistrationDataModel.DataColumns.EnrollmentDate, data.EnrollmentDate);
}
else
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NULL, RegistrationDataModel.DataColumns.EnrollmentDate);
}
break;
case RegistrationDataModel.DataColumns.FromSearchEnrollmentDate:
if (data.FromSearchEnrollmentDate != null)
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_STRING_OR_DATE, RegistrationDataModel.DataColumns.FromSearchEnrollmentDate, data.FromSearchEnrollmentDate);
}
else
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NULL, RegistrationDataModel.DataColumns.FromSearchEnrollmentDate);
}
break;
case RegistrationDataModel.DataColumns.ToSearchEnrollmentDate:
if (data.ToSearchEnrollmentDate != null)
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_STRING_OR_DATE, RegistrationDataModel.DataColumns.ToSearchEnrollmentDate, data.ToSearchEnrollmentDate);
}
else
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NULL, RegistrationDataModel.DataColumns.ToSearchEnrollmentDate);
}
break;
default:
returnValue = BaseDataManager.ToSQLParameter(data, dataColumnName);
break;
}
return(returnValue);
}
