public static async Task <bool> SignUp(Registration model, RemoteUser user)
{
if (model.Password != model.ConfirmPassword)
{
throw new PasswordConfirmException("Passwords do not match.");
}
if (model.Email != model.ConfirmEmail)
{
throw new PasswordConfirmException("Emails do not match.");
}
model.Browser = user.Browser;
model.IpAddress = user.IpAddress;
var registration = model.Adapt <DTO.Registration>();
registration.Password = PasswordManager.GetHashedPassword(model.Password);
string registrationId = Registrations.Register(registration).ToString();
if (string.IsNullOrWhiteSpace(registrationId))
{
return(false);
}
var email = new SignUpEmail(registration, registrationId);
await email.SendAsync();
return(true);
}
private bool IsContactNumberExist(Registrations registration)
{
try
{
DataTable dtList = GetAll();
var rows = dtList.AsEnumerable().Where(x => ((string)x["ContactNumber"]).ToString() == registration.ContactNumber);
DataTable dt = rows.Any() ? rows.CopyToDataTable() : dtList.Clone();
if (dt != null)
{
if (dt.Rows.Count > 0)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
catch (Exception)
{
throw;
}
}
private static void RegisterServicesAndPlugins(SqlVersion sqlVersion, bool initialQuotedIdentifiers)
{
var registrations = new Registrations();
registrations.RegisterServices(sqlVersion, initialQuotedIdentifiers);
Logger.Info("Plugins:");
var pluginLoader = IocContainer.Instance.Resolve <IPluginLoaderService>();
var pluginLoadResults = pluginLoader.LoadPlugins();
foreach (var pluginLoadResult in pluginLoadResults)
{
if (pluginLoadResult.SuccessfullyLoaded)
{
Logger.Info($" Assembly: {pluginLoadResult.AssemblyFullName}");
Logger.Info($" Name: {pluginLoadResult.PluginServices.Information.Name}, Description: {pluginLoadResult.PluginServices.Information.Description}");
var ruleTypes = pluginLoadResult.PluginServices.GetRuleTypes();
Logger.Info($" {ruleTypes.Count} Ruletypes: {string.Join(", ", ruleTypes)}");
registrations.RegisterRuleTypes(ruleTypes);
}
foreach (var loadMessage in pluginLoadResult.LoadMessages)
{
Logger.Info($" Message:{loadMessage.Severity} {loadMessage.Message}");
}
}
if (!pluginLoadResults.Any(x => x.SuccessfullyLoaded))
{
Logger.Warn("No rule plugins found in base directory.");
}
IocContainer.Instance.VerifyResolutions();
}
internal void DeleteRegistration()
{
if (Registration.Delete())
{
Registrations.Remove(Registration);
}
}
public async Task <LoginResult> AuthenticateAsync(FacebookAccount account, RemoteUser user)
{
var facebookUser = this.GetFacebookUserInfo(account.Token);
if (!this.Validate(facebookUser, account.FacebookUserId, account.Email))
{
return(new LoginResult
{
Status = false,
Message = Resources.AccessIsDenied
});
}
var result =
await
FacebookSignIn.SignInAsync(this.Tenant, account.FacebookUserId, account.Email, account.OfficeId, facebookUser.Name, account.Token, user.Browser, user.IpAddress, account.Culture)
.ConfigureAwait(false);
if (result.Status)
{
if (!await Registrations.HasAccountAsync(this.Tenant, account.Email).ConfigureAwait(false))
{
string template = "~/Tenants/{tenant}/Areas/Frapid.Account/EmailTemplates/welcome-email-other.html";
var welcomeEmail = new WelcomeEmail(facebookUser, template, this.ProviderName);
await welcomeEmail.SendAsync(this.Tenant).ConfigureAwait(false);
}
}
return(result);
}
private async void doRegistration()
{
registration = new Registrations();
registrationServices = new RegistrationServices();
registration.norm = Preferences.Get("noRM", "");
registration.tglreg = dtTglPeriksa.Date.ToShortDateString();
registration.kodedokter = App.KodeDokterRegis;
registration.kodeklinik = App.KodeKlinikRegis;
try
{
registrationResults = new RegistrationResults();
registrationResults = await registrationServices.postRegistration(registration);
}
catch (Exception ex)
{
await PopupNavigation.Instance.PushAsync(new DialogAlertCustom("Error", ex.Message));
}
if (registrationResults.response.ToString() == "gagal")
{
await PopupNavigation.Instance.PushAsync(new DialogAlertCustom("Warning", registrationResults.deskripsiresponse));
}
else
{
await PopupNavigation.Instance.PushAsync(new DialogAlertCustom("Sukses", registrationResults.deskripsiresponse));
}
}
public async Task <LoginResult> AuthenticateAsync(FacebookAccount account, RemoteUser user)
{
var facebookUser = GetFacebookUserInfo(account.Token);
if (!Validate(facebookUser, account.FacebookUserId, account.Email))
{
return(new LoginResult
{
Status = false,
Message = "Access is denied"
});
}
var result = FacebookSignIn.SignIn(account.FacebookUserId, account.Email, account.OfficeId, facebookUser.Name, account.Token, user.Browser,
user.IpAddress, account.Culture);
if (result.Status)
{
if (!Registrations.HasAccount(account.Email))
{
string template = "~/Catalogs/{catalog}/Areas/Frapid.Account/EmailTemplates/welcome-email-other.html";
var welcomeEmail = new WelcomeEmail(facebookUser, template, ProviderName);
await welcomeEmail.SendAsync();
}
}
return(result);
}
public Registrations GetByModel(string model)
{
Registrations devices = new Registrations();
try
{
var query = "SELECT * FROM DeviceModel d WHERE d.model='" + model + "'";
var deviceList = this._persist.SelectByQuery <Registration>(query);
if (deviceList != null)
{
foreach (var d in deviceList)
{
devices.list.Add(d);
}
}
else
{
throw new Exception(Errors.ERR_DEVICEM_PROFILE_NOT_FOUND);
}
}
catch (Exception err)
{
throw new Exception(Errors.ERR_DEVICEM_BADREQUEST, err);
}
return(devices);
}
public async Task <LoginResult> AuthenticateAsync(GoogleAccount account, RemoteUser user)
{
bool validationResult = Task.Run(() => this.ValidateAsync(account.Token)).GetAwaiter().GetResult();
if (!validationResult)
{
return(new LoginResult
{
Status = false,
Message = Resources.AccessIsDenied
});
}
var gUser = new GoogleUserInfo
{
Email = account.Email,
Name = account.Name
};
var result = await GoogleSignIn.SignInAsync(this.Tenant, account.Email, account.OfficeId, account.Name, account.Token, user.Browser, user.IpAddress, account.Culture).ConfigureAwait(false);
if (result.Status)
{
if (!await Registrations.HasAccountAsync(this.Tenant, account.Email).ConfigureAwait(false))
{
string template = "~/Tenants/{tenant}/Areas/Frapid.Account/EmailTemplates/welcome-email-other.html";
var welcomeEmail = new WelcomeEmail(gUser, template, ProviderName);
await welcomeEmail.SendAsync(this.Tenant).ConfigureAwait(false);
}
}
return(result);
}
private void SetRegistrationNumbers()
{
/*
* Ring
* Grupp
* Ras
* klass (yngst först)
* kön (hane först)
* namn (bokstavsordning)
*/
var regs = Registrations
.OrderBy(c => c.Ring)
.ThenBy(c => c.CompetitionGroup)
.ThenBy(c => c.Breed.ToLower())
.ThenBy(c => c.Grouping)
.ThenBy(c => c.Sex)
.ThenBy(c => c.Group)
.ThenBy(c => c.Name);
var nextNumber = 1;
foreach (var registration in regs)
{
registration.CompetitionNumber = nextNumber;
nextNumber++;
}
}
public bool Delete(Registrations registration)
{
QuaintDatabaseManager db = new QuaintDatabaseManager(true);
try
{
bool flag = false;
db.AddParameters("RegistrationId", registration.EventId);
int affectedRows = db.ExecuteNonQuery("Delete_Registration", true);
if (affectedRows > 0)
{
flag = true;
}
return(flag);
}
catch (Exception)
{
throw;
}
finally
{
db.Disconnect();
}
}
internal void UpdateRegistrations()
{
Registrations = Persistence.Load();
SetRegistrationNumbers();
SortedRegistrations = new List <Registration>(Registrations).OrderBy(r => r.CompetitionNumber);
Emails = Registrations.Any()
? Registrations.Select(x => x.OwnerEmail).Aggregate((y, z) => y + ";" + z)
: string.Empty;
SixMonthsCount = Registrations.Where(r => r.Group == CompetitionClass.Categories.SixMonths).Count();
NineMonthsCount = Registrations.Where(r => r.Group == CompetitionClass.Categories.NineMonths).Count();
NineToFifteenMonthsCount = Registrations.Where(r => r.Group == CompetitionClass.Categories.NineToFifteenMonths).Count();
FifteenToTwentyFourMonthsCount = Registrations.Where(r => r.Group == CompetitionClass.Categories.FifteenToTwentyFourMonths).Count();
FifteenMonthsCount = Registrations.Where(r => r.Group == CompetitionClass.Categories.FifteenMonths).Count();
EightYearsCount = Registrations.Where(r => r.Group == CompetitionClass.Categories.EightYears).Count();
TotalCount = Registrations.Count();
GroupUnknownCount = Registrations.Where(r => r.CompetitionGroup == CompetitionGroup.Groups.Unknown).Count();
GroupOneCount = Registrations.Where(r => r.CompetitionGroup == CompetitionGroup.Groups.One).Count();
GroupTwoCount = Registrations.Where(r => r.CompetitionGroup == CompetitionGroup.Groups.Two).Count();
GroupThreeCount = Registrations.Where(r => r.CompetitionGroup == CompetitionGroup.Groups.Three).Count();
GroupFourCount = Registrations.Where(r => r.CompetitionGroup == CompetitionGroup.Groups.Four).Count();
GroupFiveCount = Registrations.Where(r => r.CompetitionGroup == CompetitionGroup.Groups.Five).Count();
GroupSixCount = Registrations.Where(r => r.CompetitionGroup == CompetitionGroup.Groups.Six).Count();
GroupSevenCount = Registrations.Where(r => r.CompetitionGroup == CompetitionGroup.Groups.Seven).Count();
GroupEightCount = Registrations.Where(r => r.CompetitionGroup == CompetitionGroup.Groups.Eight).Count();
GroupNineCount = Registrations.Where(r => r.CompetitionGroup == CompetitionGroup.Groups.Nine).Count();
GroupTenCount = Registrations.Where(r => r.CompetitionGroup == CompetitionGroup.Groups.Ten).Count();
SetBestInCounts();
SetBreedCounts();
}
private void SetBestInCounts()
{
var pups = Registrations.Where(r =>
r.Group == CompetitionClass.Categories.SixMonths ||
r.Group == CompetitionClass.Categories.NineMonths);
var pupGroups = pups.GroupBy(p => p.Breed);
var adults = Registrations.Where(r =>
r.Group == CompetitionClass.Categories.NineToFifteenMonths ||
r.Group == CompetitionClass.Categories.FifteenToTwentyFourMonths ||
r.Group == CompetitionClass.Categories.FifteenMonths);
var adultGroups = adults.GroupBy(p => p.Breed);
var veterans = Registrations.Where(r =>
r.Group == CompetitionClass.Categories.EightYears);
var veteranGroups = veterans.GroupBy(p => p.Breed);
// BIR (Best In Race) valp(2 klasser?)/vuxen(3 klasser!)/veteran per ras
PupBestInRaceCount = GetBirCount(pups);
AdultBestInRaceCount = GetBirCount(adults);
VeteranBestInRaceCount = GetBirCount(veterans);
// BIM (Best I Motsatt kön) om, minst, en hane och en hona i samma ras och klasser
PupBestInMotsattKönCount = GetGroupBimCount(pupGroups);
AdultBestInMotsattKönCount = GetGroupBimCount(adultGroups);
VeteranBestInMotsattKönCount = GetGroupBimCount(veteranGroups);
}
public static IHttpContext registrationList(IHttpContext context)
{
try
{
if (!context.token().hasPermission("registrations.read"))
{
context.Response.StatusCode = HttpStatusCode.NotFound;
context.Response.SendResponse("");
return(context);
}
var data = context.Request.QueryString;
DateTime start = data["start_time"] != null?DateTime.Parse(data["start_time"]) : DateTime.Parse("1970-01-01 00:00:00");
int pageSize = data["pagesize"] != null?int.Parse(data["pagesize"]) : 50;
int skip = data["skip"] != null?int.Parse(data["skip"]) : 0;
uint userId = data["usergroup_id"] != null?uint.Parse(data["user_id"]) : 0;
var regs = Registrations.list(start, pageSize, skip, userId);
context.Response.SendResponse(JsonConvert.SerializeObject(regs));
}
catch (Exception ex)
{
context.Response.StatusCode = HttpStatusCode.InternalServerError;
context.Response.SendResponse(ex.Message);
}
return(context);
}
public void HandleLine(string csvLine)
{
var registration = new Registration(csvLine);
Registrations.Add(registration);
var club = Clubs.FirstOrDefault(c => c.Name == registration.Club) ?? new Club(registration.Club);
club.Registration.Add(registration);
Clubs.Add(club);
/*var registration = new Registration(csvLine);
* Registrations.Add(registration);
*
* Club clubSearchRestult = null;
*
* foreach (var club in Clubs)
* {
* if (club.Name == registration.Club)
* {
* clubSearchRestult = club.Name;
* break;
* }
* }*/
}
public bool AddRegistration(int studentID, int realisationID)
{
Random rand = new Random();
int id = rand.Next(899999) + 100000;
using (var db = new StorageContext())
{
Students s = db.Students.Find(studentID);
Realisations r = db.Realisations.Find(realisationID);
Registrations reg = new Registrations();
reg.RegistrationID = id;
reg.Students = s;
reg.Realisations = r;
db.Registrations.Add(reg);
try
{
db.SaveChanges();
}
catch (Exception)
{
return(false);
}
return(true);
}
}
protected override string GetComponentName(MethodInfo method, object[] arguments)
{
var groupType = arguments.FirstOrDefault() as string;
// If no name was given use the default type
if (groupType == null)
{
return(Registrations[DetailsConstants.DefaultType]);
}
// Directly return the default view if it is known
if (Registrations.ContainsKey(groupType))
{
return(Registrations[groupType]);
}
// Start from the current type going upwards the type tree looking for a custom ui
var typeModel = FindType(groupType, ServiceModel.TypeTree);
while (typeModel != null)
{
if (Registrations.ContainsKey(typeModel.Name))
{
return(Registrations[typeModel.Name]);
}
typeModel = FindType(typeModel.BaseType, ServiceModel.TypeTree);
}
// If all failed use the default
return(Registrations[DetailsConstants.DefaultType]);
}
public void Build(IWorkflowBuilder <GeostationaryWorkflowData> builder)
{
builder
.Initialise()
.CreateActivity()
.InitialiseProgressBar(data => data.Activity !.Registrations.Count + 1)
.If(data => data.Activity !.Registrations.Any())
.Do(branch => branch
.ForEach(data => data.Activity !.Registrations, _ => false)
.Do(registration => registration
.SetWorkflowRegistration()
.ShouldWriteSingle()
.Branch(true, builder.CreateBranch()
.LoadImageSingle()
.NormaliseImage()
.EqualiseOverlayHistogram()
.RenderOverlay()
.RenderUnderlay()
.ComposeOverlay()
.ColourCorrect()
.ApplyHaze()
.SaveImage()
)
)
)
.LogCompletion();
}
public static async Task <bool> SignUpAsync(HttpContextBase context, string tenant, Registration model, RemoteUser user)
{
if (model.Password != model.ConfirmPassword)
{
throw new PasswordConfirmException(I18N.PasswordsDoNotMatch);
}
if (model.Email != model.ConfirmEmail)
{
throw new PasswordConfirmException(I18N.EmailsDoNotMatch);
}
model.Browser = user.Browser;
model.IpAddress = user.IpAddress;
var registration = model.Adapt <DTO.Registration>();
registration.Password = PasswordManager.GetHashedPassword(model.Email, model.Password);
string registrationId =
(await Registrations.RegisterAsync(tenant, registration).ConfigureAwait(false)).ToString();
if (string.IsNullOrWhiteSpace(registrationId))
{
return(false);
}
var email = new SignUpEmail(context, registration, registrationId);
await email.SendAsync(tenant).ConfigureAwait(false);
return(true);
}
protected void btnDelete_Command(object sender, CommandEventArgs e)
{
try
{
string id = Convert.ToString(e.CommandArgument);
if (!string.IsNullOrEmpty(id))
{
RegistrationBLL registrationBLL = new RegistrationBLL();
Registrations registration = new Registrations();
registration.RegistrationId = Convert.ToInt32(QuaintSecurityManager.Decrypt(id));
if (registration.RegistrationId > 0)
{
if (registrationBLL.Delete(registration))
{
Alert(AlertType.Success, "Deleted successfully.");
LoadList();
}
else
{
Alert(AlertType.Error, "Failed to delete.");
}
}
}
}
catch (Exception)
{
Alert(AlertType.Error, "Failed to delete.");
}
}
public bool Update(Registrations registration)
{
QuaintDatabaseManager db = new QuaintDatabaseManager(true);
try
{
bool flag = false;
db.AddParameters("EventId", registration.EventId);
db.AddParameters("RegistrationId", registration.RegistrationId);
db.AddParameters("RegistrationCode", registration.RegistrationCode);
db.AddParameters("FullName", registration.FullName);
db.AddParameters("Email", registration.Email);
db.AddParameters("ContactNumber", registration.ContactNumber);
db.AddParameters("Address", registration.Address);
db.AddParameters("EventId", registration.EventId);
int affectedRows = db.ExecuteNonQuery("Update_Registration", true);
if (affectedRows > 0)
{
flag = true;
}
return(flag);
}
catch (Exception)
{
throw;
}
finally
{
db.Disconnect();
}
}
protected void btnActiveOrDeactive_Command(object sender, CommandEventArgs e)
{
try
{
string id = Convert.ToString(e.CommandArgument);
if (!string.IsNullOrEmpty(id))
{
RegistrationBLL registrationBLL = new RegistrationBLL();
DataTable dt = registrationBLL.GetById(Convert.ToInt32(QuaintSecurityManager.Decrypt(id)));
if (dt != null)
{
if (dt.Rows.Count > 0)
{
Registrations registration = new Registrations();
registration.RegistrationId = Convert.ToInt32(Convert.ToString(dt.Rows[0]["RegistrationId"]));
registration.RegistrationCode = Convert.ToString(dt.Rows[0]["RegistrationCode"]);
registration.FullName = Convert.ToString(dt.Rows[0]["FullName"]);
registration.Email = Convert.ToString(dt.Rows[0]["Email"]);
registration.ContactNumber = Convert.ToString(dt.Rows[0]["ContactNumber"]);
registration.Address = Convert.ToString(dt.Rows[0]["Address"]);
registration.EventId = Convert.ToInt32(dt.Rows[0]["EventId"]);
}
}
}
}
catch (Exception)
{
Alert(AlertType.Error, "Failed to process.");
}
}
public async Task <RegistrationResults> postRegistration(Registrations registration)
{
RegistrationResults registrationResults = new RegistrationResults();
var uri = new Uri($"{urlWebServices}/pendaftarantgl/");
try
{
var jsonObj = JsonConvert.SerializeObject(registration);
var content = new StringContent(jsonObj,
Encoding.UTF8, "application/json");
var response = await client.PostAsync(uri, content);
if (!response.IsSuccessStatusCode)
{
throw new Exception("Gagal Registrasi Online");
}
else
{
var result = await response.Content.ReadAsStringAsync();
registrationResults = JsonConvert.DeserializeObject <RegistrationResults>(result);
return(registrationResults);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
static void Main(string[] args)
{
// initialize the configM microservice client sdk
_configM = new ConfigM {
ApiUrl = ConfigurationManager.AppSettings["ConfigM"]
};
// lookup the manifest for the device microservice
var deviceManifest = _configM.GetByName("DeviceM");
// initialize the device registery microservice client SDK
_registryM = new DeviceM {
ApiUrl = deviceManifest.lineitems[LineitemsKey.AdminAPI]
};
// get a list of all devices from the registry
_devices = _registryM.GetAll();
// initialize the IoT Hub registration manager
_registryManager = RegistryManager.CreateFromConnectionString(ConfigurationManager.AppSettings["IoTHubConnStr"]);
// register each device with IoT Hub
foreach (var device in _devices.list)
{
AddDeviceAsync(device).Wait();
}
}
public void Register(EndUserId endUserId, string?name, RobotApplication?application)
{
void AddRegistration()
{
var registrationId = new RobotRegistrationId(Guid.NewGuid());
var e = RobotRegistered.Create(registrationId, endUserId, name, application);
Apply(e);
Append(registrationId.Value, RobotRegistered.EventType, e);
}
var latestRegistration = Registrations.LastOrDefault();
if (latestRegistration == null)
{
AddRegistration();
}
else
{
latestRegistration.Apply(
registration => throw new ValidationException("Robot is already registered"),
unregistration => AddRegistration()
);
}
}
private void button11_Click(object sender, EventArgs e)
{
if (dataGridView3.SelectedRows.Count > 0)
{
int index = dataGridView3.SelectedRows[0].Index;
int id = (int)dataGridView3[0, index].Value;
Registrations row = db.Registrations.Find(id);
fRegistration f = new fRegistration();
f.comboBox2.SelectedValue = row.Id_Client;
f.comboBox1.SelectedValue = row.Id_Number;
f.dateTimePicker1.Text = row.DateInsert.ToString();
f.dateTimePicker2.Text = row.DateOut.ToString();
f.textBox1.Text = row.Cost.ToString();
if (f.ShowDialog() == DialogResult.OK)
{
row.Id_Client = (int)f.comboBox2.SelectedValue;
row.Id_Number = (int)f.comboBox1.SelectedValue;
row.DateInsert = Convert.ToDateTime(f.dateTimePicker1.Text);
row.DateOut = Convert.ToDateTime(f.dateTimePicker2.Text);
row.Cost = Convert.ToInt16(f.textBox1.Text);
db.Entry(row).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
LoadDate();
}
}
}
public void Edit(EndUserId endUserId, string?name, RobotApplication?application)
{
var latestRegistration = Registrations.LastOrDefault();
if (latestRegistration == null)
{
throw new ValidationException("Robot is not registered");
}
latestRegistration.Apply(
registration =>
{
if (registration.EndUserId != endUserId)
{
throw new ValidationException("Robot is registered to somebody else");
}
var e = RobotEdited.Create(name, application);
Apply(e);
Append(Guid.NewGuid(), RobotEdited.EventType, e);
},
unregistration => throw new ValidationException("Robot is not registered")
);
}
public void Unregister(EndUserId endUserId)
{
var latestRegistration = Registrations.LastOrDefault();
if (latestRegistration == null)
{
throw new ValidationException("Robot is not registered");
}
latestRegistration.Apply(
registration =>
{
if (registration.EndUserId == endUserId)
{
var e = RobotUnregistered.Create();
Apply(e);
Append(Guid.NewGuid(), RobotUnregistered.EventType, e);
}
else
{
throw new ValidationException("Robot is registered to somebody else");
}
},
unregistration => throw new ValidationException("Robot is not registered")
);
}
private void RegisterServicesAndPlugins()
{
var registrations = new Registrations();
// (don't care about sql version for rule configuration)
registrations.RegisterServices(SqlVersion.Sql120, false);
var pluginLoader = IocContainer.Instance.Resolve <IPluginLoaderService>();
var pluginLoadResults = pluginLoader.LoadPlugins();
foreach (var pluginLoadResult in pluginLoadResults)
{
if (pluginLoadResult.SuccessfullyLoaded)
{
var ruleTypes = pluginLoadResult.PluginServices.GetRuleTypes();
registrations.RegisterRuleTypes(ruleTypes);
var configControlTypes = pluginLoadResult.PluginServices.GetConfigControlTypes();
registrations.RegisterConfigControlTypes(configControlTypes);
}
}
IocContainer.Instance.VerifyResolutions();
// Todo improve...
IocContainer.Instance.Register <IWinFormsRuleConfigurationControl, RuleConfigurationControl>(setup: Setup.With(allowDisposableTransient: true));
}
public async Task <LoginResult> AuthenticateAsync(GoogleAccount account, RemoteUser user)
{
bool validationResult = Task.Run(() => ValidateAsync(account.Token)).Result;
if (!validationResult)
{
return(new LoginResult
{
Status = false,
Message = "Access is denied"
});
}
var gUser = new GoogleUserInfo
{
Email = account.Email,
Name = account.Name
};
var result = GoogleSignIn.SignIn(account.Email, account.OfficeId, account.Name, account.Token, user.Browser, user.IpAddress, account.Culture);
if (result.Status)
{
if (!Registrations.HasAccount(account.Email))
{
string template = "~/Catalogs/{catalog}/Areas/Frapid.Account/EmailTemplates/welcome-email-other.html";
var welcomeEmail = new WelcomeEmail(gUser, template, ProviderName);
await welcomeEmail.SendAsync();
}
}
return(result);
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
//get the passcode
PasscodeGenerator pg = new PasscodeGenerator();
int passcode = pg.GetPasscode();
//initialize customer and vehicle
Customer c = new Customer();
Vehicle v = new Vehicle();
//initialize PasswordHash
PasswordHash ph = new PasswordHash();
//Assign the values from the textboxes
//to the classes
c.LastName = txtLastName.Text;
c.FirstName = txtFirstName.Text;
c.email = txtEmail.Text;
c.password = txtPassword.Text;
c.passcode = passcode;
//get the hashed password
c.PasswordHash = ph.Hashit(txtPassword.Text, passcode.ToString());
c.apartment = txtApt.Text;
c.state = txtState.Text;
c.street = txtStreet.Text;
c.zip = txtZip.Text;
c.city = txtCity.Text;
c.phone = txtPhone.Text;
// v.License = txtLicense.Text;
//v.Make = txtMake.Text;
// v.Year = txtYear.Text;
try
{
//try to write to the database
Registrations r = new Registrations(c);
lblResult.Text = "Thank you for registering";
LinkButton1.Visible = true;
}
catch (Exception ex)
{
//if it fails show the error
lblError.Text = ex.ToString();
}
}
/// <summary>
/// Constructor for the Application object.
/// </summary>
public App()
{
// Standard XAML initialization
InitializeComponent();
// Language display initialization
InitializeLanguage();
// Show graphics profiling information while debugging.
if (Debugger.IsAttached)
{
// Display the current frame rate counters
Application.Current.Host.Settings.EnableFrameRateCounter = true;
// Show the areas of the app that are being redrawn in each frame.
//Application.Current.Host.Settings.EnableRedrawRegions = true;
// Enable non-production analysis visualization mode,
// which shows areas of a page that are handed off to GPU with a colored overlay.
//Application.Current.Host.Settings.EnableCacheVisualization = true;
// Prevent the screen from turning off while under the debugger by disabling
// the application's idle detection.
// Caution:- Use this under debug mode only. Application that disables user idle detection will continue to run
// and consume battery power when the user is not using the phone.
PhoneApplicationService.Current.UserIdleDetectionMode = IdleDetectionMode.Disabled;
}
Locator.CurrentMutable.Register(() => new AppBootstrapper(), typeof(IApplicationRootState));
var registrator = new Registrations();
registrator.Register((o, t) => Locator.CurrentMutable.Register(o, t));
var host = Locator.Current.GetService<ISuspensionHost>();
host.SetupDefaultSuspendResume();
}
/// <summary>
/// Registers the specified manager.
/// </summary>
/// <param name="manager">The manager.</param>
/// <param name="registrations">The registrations.</param>
/// <param name="attrib">The attrib.</param>
public static void Register(IClientScriptManager manager, Registrations registrations, Nparams attrib)
{
if (manager == null)
throw new ArgumentNullException("manager");
if ((registrations & Registrations.SwfUpload) == Registrations.SwfUpload)
{
//string swfUploadVersion;
var version = SwfUploadVersion; // ((attrib != null) && attrib.TryGetValue("swfUploadVersion", out swfUploadVersion) ? swfUploadVersion : SwfUploadVersion);
if (string.IsNullOrEmpty(version))
throw new InvalidOperationException("version");
var versionFolder = "Contoso.Resource_.SwfUpload" + version.Replace(".", "_");
// STATE
HttpContext.Current.Set<ClientScriptRegistrarSwfUploadShape>(new ClientScriptRegistrarSwfUploadShape
{
SwfUploadFlashUrl = ClientScriptManagerEx.GetWebResourceUrl(_type, versionFolder + ".swfupload.swf"),
});
// INCLUDES
manager.EnsureItem<HtmlHead>("SwfUpload", () => new IncludeForResourceClientScriptItem(_type, "Contoso.Resource_.SwfUpload" + version + ".js"));
if ((registrations & Registrations.SwfUploadCookiePlugin) == Registrations.SwfUploadCookiePlugin)
manager.EnsureItem<HtmlHead>("CookiePlugin", () => new IncludeForResourceClientScriptItem(_type, versionFolder + ".cookies.js"));
if ((registrations & Registrations.SwfUploadQueuePlugin) == Registrations.SwfUploadQueuePlugin)
manager.EnsureItem<HtmlHead>("QueuePlugin", () => new IncludeForResourceClientScriptItem(_type, versionFolder + ".queue.js"));
if ((registrations & Registrations.SwfUploadSpeedPlugin) == Registrations.SwfUploadSpeedPlugin)
manager.EnsureItem<HtmlHead>("SpeedPlugin", () => new IncludeForResourceClientScriptItem(_type, versionFolder + ".speed.js"));
if ((registrations & Registrations.SwfUploadSwfObjectPlugin) == Registrations.SwfUploadSwfObjectPlugin)
manager.EnsureItem<HtmlHead>("SwfObjectPlugin", () => new IncludeForResourceClientScriptItem(_type, versionFolder + ".swfobject.js"));
}
}
