public ActionResult Register([Bind(Include = "insurerId,userId,password,confirmPassword")] RegisteredUser user)
{
user.password = Encrypt(user.password);
user.confirmPassword = Encrypt(user.confirmPassword);
var check = db.registeredUsers.Find(user.userId);
var idcheck = db.Insurers.Where(i => i.insurerId.Equals(user.insurerId)).FirstOrDefault();
if (idcheck != null)
{
if (check == null)
{
db.Configuration.ValidateOnSaveEnabled = false;
db.registeredUsers.Add(user);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "User already Exists");
return(View());
}
}
else
{
ModelState.AddModelError("", "Please Check Your Insurer ID");
return(View());
}
}
private RegisteredUser GetOutfitsInfo()
{
RegisteredUser user = GetUser();
IList <FashionFlavor> flavors = new List <FashionFlavor>();
foreach (UserFlavor flavor in user.UserFlavors)
{
flavors.Add(flavor.Flavor);
}
ViewData["FashionFlavors"] = flavors;
List <SelectListItem> lst = new List <SelectListItem>();
SelectListItem sl = new SelectListItem();
sl.Text = "Editor Rating";
sl.Value = 1.ToString();
lst.Add(sl);
sl = new SelectListItem();
sl.Text = "My Rating";
sl.Value = 2.ToString();
lst.Add(sl);
sl = new SelectListItem();
sl.Text = "Friend Rating";
sl.Value = 3.ToString();
lst.Add(sl);
sl = new SelectListItem();
sl.Text = "Last Worn Date";
sl.Value = 4.ToString();
lst.Add(sl);
ViewData["SortBy"] = lst;
return(user);
}
public HttpResponseMessage PostLogin(string email, string password)
{
FRSEntities db = new FRSEntities();
bool Exists = false;
RegisteredUser ru = new RegisteredUser();
List <RegisteredUser> users = db.RegisteredUsers.ToList();
foreach (var item in users)
{
if (item.Email == email)
{
Exists = true;
ru = item;
break;
}
}
if (Exists)
{
if (ru.Password == password)
{
return(Request.CreateResponse(HttpStatusCode.OK, "Success"));
}
else
{
return(Request.CreateResponse(HttpStatusCode.OK, "Wrong Password"));
}
}
else
{
return(Request.CreateResponse(HttpStatusCode.OK, "Invalid User"));
}
}
private static RegisteredUser Parse(string userInformationAsJson)
{
if (String.IsNullOrEmpty(userInformationAsJson))
{
return(null);
}
var jsSerializer = new JavaScriptSerializer();
var userInformation = jsSerializer.Deserialize <Dictionary <string, object> >(userInformationAsJson);
RegisteredUser information = new RegisteredUser()
{
FacebookId = userInformation["id"].ToString(),
Name = userInformation["name"].ToString(),
Email = userInformation["email"].ToString(),
Bio = userInformation.ContainsKey("bio") ? userInformation["bio"].ToString() : string.Empty,
};
if (userInformation.ContainsKey("location"))
{
var location = userInformation["location"] as Dictionary <string, object>;
if (null != location)
{
information.City = location["name"].ToString();
}
}
return(information);
}
public object createcontact(Registration Lvm)
{
try
{
FRSEntities db = new FRSEntities();
RegisteredUser Ru = new RegisteredUser();
if (Ru.Email == null)
{
Ru.FirstName = Lvm.FirstName;
Ru.LastName = Lvm.LastName;
Ru.Email = Lvm.Email;
Ru.Password = Lvm.Password;
Ru.DOB = Lvm.DOB;
Ru.ContactNo = Lvm.ContactNo;
Ru.Title = Lvm.Title;
db.RegisteredUsers.Add(Ru);
db.SaveChanges();
return(new Response
{
Status = "Success", Message = "SuccessFully Saved."
});
}
}
catch (Exception)
{
throw;
}
return(new Response
{
Status = "Error", Message = "Invalid Data."
});
}
public void RegisterUser(string userName, string referrerName)
{
RegisteredUser user = CreateUser(userName);
RegisterUser(user);
SetReferrer(user, referrerName);
}
public async Task <RegisteredUser> Create(string email, string password, string timezoneId)
{
if (string.IsNullOrEmpty(password))
{
throw new ApplicationException("Password is required");
}
if (_context.RegisteredUsers.Any(u => u.Email.Equals(email.ToLowerInvariant())))
{
throw new ApplicationException($"The email {email} is already registered");
}
(byte[] hash, byte[] salt) = HashPassword(password);
var user = new RegisteredUser
{
Email = email.ToLowerInvariant(),
PasswordHash = hash,
PasswordSalt = salt,
TimezoneId = timezoneId
};
await _context.RegisteredUsers.AddAsync(user);
await _context.SaveChangesAsync();
_logger.LogInformation("User registered");
return(user);
}
public async Task <IHttpActionResult> PutRegisteredUser(int id, RegisteredUser registeredUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != registeredUser.Id)
{
return(BadRequest());
}
db.Entry(registeredUser).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RegisteredUserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
/// <summary>
/// Get user for authorization by name and key hash.
/// </summary>
/// <param name="name">User name string.</param>
/// <param name="keyHash">Key hash string.</param>
/// <returns>Registered user object or null.</returns>
public RegisteredUser GetUser(string name, string keyHash)
{
RegisteredUser foundUser = _db.RegisteredUsers
.FirstOrDefault(x => x.Name == name && x.KeyHash == keyHash);
return(foundUser);
}
public AuthenticationResponse LogOn(string token)
{
AuthenticationResponse response = null;
// ONLY TO USE IN DEMOS WITHOUT INTERNET!
if (Convert.ToBoolean(WebConfigurationManager.AppSettings["OfflineMode"]))
{
return(GetFakeAuthorization());
}
if (String.IsNullOrEmpty(token))
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
RegisteredUser registeredUser = _facebookService.GetUserInformation(token);
if (registeredUser != null && !String.IsNullOrEmpty(registeredUser.FacebookId))
{
int registeredUserId = _registeredUserRepository.Add(registeredUser);
if (registeredUserId > 0)
{
response = new AuthenticationResponse();
response.RegisteredUserId = registeredUserId;
response.UserName = registeredUser.Name;
response.Token = MyEventsToken.CreateToken(registeredUserId);
response.ExpirationTime = TimeSpan.FromHours(1).TotalMilliseconds;
response.FacebookUserId = registeredUser.FacebookId;
}
}
return(response);
}
public RegisteredUser Edit(RegisteredUser obj)
{
//var users = _stream.ReadAll().ToList();
//users[users.FindIndex(apt => apt.Id == obj.Id)] = obj;
//_stream.SaveAll(users);
return(obj);
}
public ActionResult KeyCheck(RegisteredUser registeredUser)
{
try
{
var locateuser = db.RegisteredUsers.Where(x => x.InviteKey == registeredUser.InviteKey).FirstOrDefault();
var locateusercount = db.RegisteredUsers.Where(x => x.InviteKey == registeredUser.InviteKey).Count();
if (registeredUser.InviteKey == null)
{
registeredUser.LoginErrorMsg = "Please enter invitation key or a valid invitation key";
return(View("KeyCheck", registeredUser));
}
if (registeredUser.InviteKey.Length < 6)
{
registeredUser.LoginErrorMsg = "Invitation key must be at least 6 characters long.";
return(View("KeyCheck", registeredUser));
}
if (locateusercount == 0)
{
registeredUser.LoginErrorMsg = "Please enter invitation key or a valid invitation key";
return(View("KeyCheck", registeredUser));
}
if (registeredUser.InviteKey == locateuser.InviteKey)
{
return(RedirectToAction("InitialSettings", "Access", new { id = locateuser.RegisteredUserId }));
}
}
catch (Exception e)
{
Console.WriteLine(e);
return(View(registeredUser));
}
return(View());
}
public async Task <ActionResult> SetPassword(SetPasswordViewModel model)
{
if (ModelState.IsValid)
{
var result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
// spremi promjene također i u bazu podataka
context = new Guess_WhereEntities1();
RegisteredUser u = context.RegisteredUser.First(x => x.email == user.Email);
u.password = model.NewPassword.GetHashCode().ToString();
context.SaveChanges();
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.SetPasswordSuccess }));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
// PUT: api/RegisteredUsers/5
public async Task <string> Put(int id, object user)
{
RegisteredUser registeredUser = (RegisteredUser)user;
if (id != registeredUser.Id)
{
return("fail");
}
_context.Entry(registeredUser).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Exists(id))
{
return("fail");
}
else
{
throw;
}
}
return("success");
}
public string RegisterUser(RegisteredUser registeredUserModel)
{
string success = "";
try
{
using (OggleBoobleMySqContext db = new OggleBoobleMySqContext())
{
RegisteredUser dbRegisteredUser = db.RegisteredUsers.Where(u => u.UserName == registeredUserModel.UserName).FirstOrDefault();
if (dbRegisteredUser != null)
{
success = "user name already exists";
}
else
{
registeredUserModel.Pswrd = HashSHA256(registeredUserModel.Pswrd);
registeredUserModel.Created = DateTime.Now;
//registeredUserModel.IpAddress = Helpers.GetIPAddress();
db.RegisteredUsers.Add(registeredUserModel);
db.SaveChanges();
success = "ok";
}
}
}
catch (Exception ex)
{
success = Helpers.ErrorDetails(ex);
}
return(success);
}
public ActionResult Register(RegisterViewModel model)
{
if (!this.User.Identity.IsAuthenticated)
{
if (ModelState.IsValid)
{
// Attempt to register the user
if (!NHibernateSession.Query <RegisteredUser>().Any(p => p.Username == model.UserName || p.Email == model.Email))
{
var anonymousUser = NHibernateSession.Get <AnonymousUser>(TypedSession.UserId);
MvcMusicStore.Models.Enums.Roles role = model.UserName == "Admin" ? MvcMusicStore.Models.Enums.Roles.Admin : MvcMusicStore.Models.Enums.Roles.User;
var newRegisteredUser = new RegisteredUser {
Username = model.UserName, Password = model.Password, Role = role, Email = model.Email, LatestAddress = anonymousUser.LatestAddress
};
NHibernateSession.Save(newRegisteredUser);
NHibernateSession.Delete(anonymousUser);
SetCredentialsFromTo(anonymousUser, newRegisteredUser);
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "This username or email already exists");
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
else
{
return(new ViewResult {
ViewName = "AlreadyLoggedIn"
});
}
}
public string VerifyLogin(string userName, string passWord)
{
string success = "";
using (OggleBoobleMySqContext db = new OggleBoobleMySqContext())
{
string encryptedPassword = HashSHA256(passWord);
RegisteredUser dbRegisteredUser = db.RegisteredUsers.Where(u => u.UserName == userName && u.Pswrd == encryptedPassword).FirstOrDefault();
if (dbRegisteredUser != null)
{
//--record Login
success = "ok";
}
else
{
dbRegisteredUser = db.RegisteredUsers.Where(u => u.UserName == userName).FirstOrDefault();
if (dbRegisteredUser == null)
{
success = "user name not found";
}
else
{
success = "password fail";
}
}
}
return(success);
}
public IList <Friend> Search(RegisteredUser user, string friend, FriendStatus status, int limit)
{
ICriteria crit = NHibernateSession.Current.CreateCriteria(typeof(Friend));
crit.SetFetchMode("User", FetchMode.Join);
crit.Add(Restrictions.Eq("BasicUser.Id", user.Id));
crit.Add(Expression.Not(Expression.Eq("Status", FriendStatus.Denied)));
if (status != FriendStatus.All)
{
crit.Add(Expression.Eq("Status", status));
}
Disjunction d = new Disjunction();
if (!string.IsNullOrEmpty(friend))
{
ICriteria critUser = crit.CreateCriteria("User");
d.Add(Expression.Like("FirstName", friend, MatchMode.Anywhere));
d.Add(Expression.Like("LastName", friend, MatchMode.Anywhere));
d.Add(Expression.Like("EmailAddress", friend, MatchMode.Anywhere));
critUser.Add(d);
}
if (limit > 0)
{
crit.SetMaxResults(limit);
}
return(crit.List <Friend>());
}
public bool RegisterUser(string username, string realname, string password)
{
try
{
if (ValidPassword(password))
{
RegisteredUser newUser = new RegisteredUser(username, realname, password);
_usersRegistered.Add(username, newUser);
SaveData();
Console.WriteLine("[Server]: User {0} registered with success", username);
return(true);
}
return(false);
}
catch (ArgumentNullException e)
{
Console.WriteLine(@"[Server]: Username can not be null");
return(false);
}
catch (ArgumentException e)
{
Console.WriteLine("[Server]: User {0} is already registered", username);
return(false);
}
}
public async Task <dynamic> Register(RegisteredUser user)
{
return(await ExecuteInMonitoring(async() =>
{
return await this.service.Register(user);
}));
}
private static void AddOrganizer(MyEventsContext context)
{
var facebookId = GetFacebookId();
if (!context.RegisteredUsers.Any())
{
facebookId = _fakeUserFacebookId;
}
var existsOrganizer = context.RegisteredUsers.Any(ru => ru.FacebookId == facebookId);
if (existsOrganizer)
return;
var organizer = new RegisteredUser();
if (facebookId == _fakeUserFacebookId)
organizer.Name = _fakeUserName;
else
organizer.Name = GetOrganizerName();
organizer.FacebookId = facebookId;
organizer.Email = "*****@*****.**";
organizer.City = GetCity()[0];
organizer.Bio = SpeakerBio;
context.RegisteredUsers.Add(organizer);
context.SaveChanges();
}
public IActionResult MoveToEdit(int id)
{
RegisteredUser user = new RegisteredUser();
tempid = id;
return(View("EditView", user));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the user
if (!await _session.Query <RegisteredUser>().AnyAsync(p => p.Username == model.UserName || p.Email == model.Email))
{
Roles role = model.UserName == "Admin" ? Roles.Admin : Roles.User;
var newRegisteredUser = new RegisteredUser {
Username = model.UserName, Password = model.Password, Role = role, Email = model.Email, LatestAddress = HttpContext.Connection.RemoteIpAddress.ToString()
};
await _session.SaveAsync(newRegisteredUser);
await _userService.CopyCartItemsFromAnonymousUserAsync(newRegisteredUser);
await SetCredentialsAsync(newRegisteredUser);
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "This username or email already exists");
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public void Setup()
{
inMemoryConnection = Effort.DbConnectionFactory.CreateTransient();
using var context = new MarketDbContext(inMemoryConnection);
context.Init();
RegisteredUser first_owner = new RegisteredUser("FIRST_OWNER", new byte[] { });
context.Users.Add(first_owner);
TEST_FIRST_OWNER = first_owner.ID;
RegisteredUser owner = new RegisteredUser("OWNER", new byte[] { });
context.Users.Add(owner);
TEST_OWNER = owner.ID;
RegisteredUser manager = new RegisteredUser("MANAGER", new byte[] { });
context.Users.Add(manager);
TEST_MANAGER = manager.ID;
RegisteredUser new_user = new RegisteredUser("NEW_USER", new byte[] { });
context.Users.Add(new_user);
TEST_NEW_USER = new_user.ID;
storeName = DataForTests.CreateTestContactDetails().Name;
storeHandler = new StoreHandler();
orderManager = new OrderManager(storeHandler, inMemoryConnection);
storeManagement = new StoreManagementFacade(storeHandler, orderManager);
storeHandler.OpenStore(DataForTests.CreateTestContactDetails(), TEST_FIRST_OWNER, context);
Store store = storeHandler.GetStoreByName(storeName, context);
store.AddOwner(TEST_OWNER, TEST_FIRST_OWNER, STUB_USER_NAME, storeHandler, context);
store.AddManager(TEST_MANAGER, TEST_OWNER, context);
item = store.AddItem("existing", 2, categories1, 3.55, context);
itemID = item.Id;
storeID = store.Id;
}
void OnRegisteredUser(RegisteredUser registeredUserResponse)
{
if (UserRegistered != null)
{
UserRegistered(registeredUserResponse);
}
}
public async Task <Unit> Handle(CreateNewUser request, CancellationToken cancellationToken)
{
ValidateRequest();
var ipAddress = _httpContextAccessor.HttpContext.Connection.RemoteIpAddress.ToString();
var user = RegisteredUser.CreateAccount(request.Username, request.Password, request.Email, ipAddress,
request.UserType);
await _context.Users.AddAsync(user, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
return(Unit.Value);
void ValidateRequest()
{
if (string.IsNullOrEmpty(request.Username))
{
throw new ApplicationException("Username cannot be null");
}
if (string.IsNullOrEmpty(request.Password))
{
throw new ApplicationException("Password cannot be null");
}
if (string.IsNullOrEmpty(request.Email))
{
throw new ApplicationException("Email cannot be null");
}
}
}
public async Task <IActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
RegisteredUser user = new RegisteredUser(0, model.Email, model.Email, model.Password, 0);
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
return(View(model));
}
/// <summary>
/// Add new user to database.
/// </summary>
/// <param name="registeredUser">Registered user object.</param>
/// <returns>Result: true or false.</returns>
public bool AddNewUser(RegisteredUser registeredUser)
{
try
{
KeyHash keyHash = new KeyHash();
DateTime currentDate = DateTime.Now;
registeredUser.RegistrationDate = currentDate;
registeredUser.KeyHash = keyHash.Decrypt(JsonConvert.SerializeObject(new UserJson
{
Name = registeredUser.Name,
MacAdress = registeredUser.MacAdress,
LicenseFinishDate = registeredUser.LicenseFinishDate,
RegistrationDate = currentDate
}), "AssisTant321", "AlphaPeriod");
_db.RegisteredUsers.Add(registeredUser);
_db.SaveChanges();
return(true);
}
catch
{
return(false);
}
}
public ActionResult Register(RegisteredUser newUser)
{
var userStore = new UserStore <IdentityUser>();
UserManager <IdentityUser> manager = new UserManager <IdentityUser>(userStore)
{
UserLockoutEnabledByDefault = true,
DefaultAccountLockoutTimeSpan = new TimeSpan(0, 10, 0),
MaxFailedAccessAttemptsBeforeLockout = 3
};
var identityUser = new IdentityUser()
{
UserName = newUser.UserName,
Email = newUser.Email
};
IdentityResult result = manager.Create(identityUser, newUser.Password);
if (result.Succeeded)
{
var authenticationManager
= HttpContext.Request.GetOwinContext().Authentication;
var userIdentity = manager.CreateIdentity(identityUser,
DefaultAuthenticationTypes.ApplicationCookie);
authenticationManager.SignIn(new AuthenticationProperties()
{
},
userIdentity);
string testVariable = newUser.UserRole;
AddUserToRole(newUser.UserName, newUser.UserRole);
}
return(View());
}
/// <summary>
/// Update license date and time by user id.
/// </summary>
/// <param name="id">User id value.</param>
/// <param name="newLicenseDate">New license date and time.</param>
public void UpdateLicense(int id, DateTime newLicenseDate)
{
RegisteredUser updatingUser = _db.RegisteredUsers
.FirstOrDefault(x => x.Id == id);
if (updatingUser == null)
{
// TODO: Add logging
return;
}
KeyHash keyHash = new KeyHash();
DateTime currentDate = DateTime.Now;
updatingUser.RegistrationDate = currentDate;
updatingUser.LicenseFinishDate = newLicenseDate;
updatingUser.KeyHash = keyHash.Decrypt(JsonConvert.SerializeObject(new UserJson
{
Name = updatingUser.Name,
MacAdress = updatingUser.MacAdress,
LicenseFinishDate = newLicenseDate,
RegistrationDate = currentDate
}), "AssisTant321", "AlphaPeriod");
_db.SaveChanges();
}
/// <summary>
/// Geocodes the specified address.
/// </summary>
/// <param name="address">The address.</param>
/// <param name="result">The result.</param>
/// <returns>
/// True/False value of whether the address was standardized was succesfully
/// </returns>
public override bool Geocode( Rock.CRM.Address address, out string result )
{
if ( address != null )
{
var registeredUser = new RegisteredUser();
registeredUser.UserID = AttributeValue("UserID");
registeredUser.Password = AttributeValue("Password");
var licenseInfo = new LicenseInfo();
licenseInfo.RegisteredUser = registeredUser;
var client = new USAddressVerificationSoapClient();
SIWsOutputOfUSAddress verifyResult;
SubscriptionInfo info = client.VerifyAddressUSA(
licenseInfo,
address.Street1,
address.Street2,
string.Format("{0} {1} {2}",
address.City,
address.State,
address.Zip),
string.Empty,
string.Empty,
CasingEnum.PROPER,
out verifyResult );
if (verifyResult != null)
{
result = verifyResult.ServiceStatus.StatusNbr.ToString();
if ( verifyResult.ServiceStatus.StatusNbr == 200 )
{
USAddress usAddress = verifyResult.ServiceResult;
if ( usAddress != null && usAddress.GeoCode != null )
{
address.Latitude = usAddress.GeoCode.Latitude;
address.Longitude = usAddress.GeoCode.Longitude;
return true;
}
}
}
else
result = "Null Result";
}
else
result = "Null Address";
return false;
}
public ActionResult Register(RegisteredUser newUser)
{
var userStore = new UserStore<IdentityUser>();
var manager = new UserManager<IdentityUser>(userStore);
var identityUser = new IdentityUser()
{
UserName = newUser.UserName,
Email = newUser.Email
};
IdentityResult result = manager.Create(identityUser, newUser.Password);
if (result.Succeeded)
{
var authenticationManager
= HttpContext.Request.GetOwinContext().Authentication;
var userIdentity = manager.CreateIdentity(identityUser,
DefaultAuthenticationTypes.ApplicationCookie);
authenticationManager.SignIn(new AuthenticationProperties() { },
userIdentity);
}
return View();
}
void OnRegisteredUser(RegisteredUser registeredUserResponse)
{
if(UserRegistered != null)
UserRegistered(registeredUserResponse);
}
/* [Randy] Edit a specific registration entry */
public bool updateRegistration(RegisteredUser registeredUser)
{
try
{
using (conferenceadminContext context = new conferenceadminContext())
{
var registration = context.registrations.Where(reg => reg.registrationID == registeredUser.registrationID).FirstOrDefault();
var temp = registration.userID;
var user = context.users.Where(u => u.userID == registration.userID).FirstOrDefault();
user.firstName = registeredUser.firstname;
user.lastName = registeredUser.lastname;
user.userTypeID = Convert.ToInt32(registeredUser.usertypeid);
user.affiliationName = registeredUser.affiliationName;
registration.user = user;
registration.date1 = registeredUser.date1;
registration.date2 = registeredUser.date2;
registration.date3 = registeredUser.date3;
registration.note = registeredUser.notes;
context.SaveChanges();
return true;
}
}
catch (Exception ex)
{
Console.Write("AdminManager.updateRegistration error " + ex);
return false;
}
}
/// <summary>
/// Standardizes the specified address.
/// </summary>
/// <remarks>
/// The StrikeIron address verification will also attempt to geocode the address. If this
/// geocode is succesful, the Geocode information of the address will be updated also.
/// </remarks>
/// <param name="location">The location.</param>
/// <param name="result">The result.</param>
/// <returns>
/// True/False value of whether the address was standardized was succesfully
/// </returns>
public override bool Standardize( Rock.Model.Location location, out string result )
{
if ( location != null )
{
var registeredUser = new RegisteredUser();
registeredUser.UserID = GetAttributeValue("UserID");
registeredUser.Password = GetAttributeValue("Password");
var licenseInfo = new LicenseInfo();
licenseInfo.RegisteredUser = registeredUser;
var client = new USAddressVerificationSoapClient();
SIWsOutputOfUSAddress verifyResult;
SubscriptionInfo info = client.VerifyAddressUSA(
licenseInfo,
location.Street1,
location.Street2,
string.Format("{0} {1} {2}",
location.City,
location.State,
location.Zip),
string.Empty,
string.Empty,
CasingEnum.PROPER,
out verifyResult );
if (verifyResult != null)
{
result = verifyResult.ServiceStatus.StatusNbr.ToString();
if ( verifyResult.ServiceStatus.StatusNbr == 200 )
{
USAddress usAddress = verifyResult.ServiceResult;
if ( usAddress != null && usAddress.GeoCode != null )
{
location.Street1 = usAddress.AddressLine1;
location.Street2 = usAddress.AddressLine2;
location.City = usAddress.City;
location.State = usAddress.State;
location.Zip = usAddress.ZIPPlus4;
if ( usAddress.GeoCode != null )
{
location.GeocodeAttemptedServiceType = "StrikeIron";
location.GeocodeAttemptedResult = "200";
location.GeocodedDateTime = DateTime.Now;
location.SetLocationPointFromLatLong( usAddress.GeoCode.Latitude, usAddress.GeoCode.Longitude );
}
return true;
}
}
}
else
result = "Null Result";
}
else
result = "Null Address";
return false;
}
public void CreateUser(InvolvedModel model)
{
dbContext = new RockstarDBModelDataContext();
RegisteredUser userTbl = new RegisteredUser();
UserFile fileTbl = new UserFile();
userTbl.FirstName = model.FirstName;
userTbl.LastName = model.LastName;
userTbl.EmailAddress = model.EmailAddress;
userTbl.PhoneNumber = model.PhoneNumber;
userTbl.Facebook = model.Facebook;
userTbl.Twitter = model.Twitter;
userTbl.LinkedIn = model.LinkedIn;
userTbl.Instagram = model.Instagram;
userTbl.Skype = model.Skype;
userTbl.CompanyProjName = model.CompanyProjName;
userTbl.CompanyProjDescription = model.CompanyProjDescription;
userTbl.QuantifiableMetrics = model.QuantifiableMetrics;
userTbl.ImpactQuestion = model.ImpactQuestion;
userTbl.ExampleQuestion = model.ExampleQuestion;
userTbl.LearnQuestion = model.LearnQuestion;
userTbl.AdditionalInfo = model.AdditionalInfo;
userTbl.CreatedOn = DateTime.Now;
dbContext.RegisteredUsers.InsertOnSubmit(userTbl);
dbContext.SubmitChanges();
if (model.FirstFile != null)
{
byte[] firstUploadFile = new byte[model.FirstFile.InputStream.Length];
model.FirstFile.InputStream.Read(firstUploadFile, 0, firstUploadFile.Length);
fileTbl.FileName = model.FirstFile.FileName;
fileTbl.FileData = firstUploadFile;
fileTbl.UserID = userTbl.Id;
dbContext.UserFiles.InsertOnSubmit(fileTbl);
dbContext.SubmitChanges(); ;
}
if (model.SecondFile != null)
{
byte[] secondUploadFile = new byte[model.SecondFile.InputStream.Length];
model.SecondFile.InputStream.Read(secondUploadFile, 0, secondUploadFile.Length);
fileTbl.FileName = model.FirstFile.FileName;
fileTbl.UserID = userTbl.Id;
fileTbl.FileData = secondUploadFile;
}
if (model.ThirdFile != null)
{
byte[] secondUploadFile = new byte[model.SecondFile.InputStream.Length];
model.SecondFile.InputStream.Read(secondUploadFile, 0, secondUploadFile.Length);
fileTbl.FileName = model.FirstFile.FileName;
fileTbl.UserID = userTbl.Id;
fileTbl.FileData = secondUploadFile;
}
}
void UnityUICloudGoodsLogin_UserRegistered(RegisteredUser obj)
{
StatusPanel.SetActive(true);
StatusText.text = "User has successfully been registered. Check your email to authorize your user for login.";
}
