private async Task <IActionResult> UserPutAsync(string userId, GuestUser guestUser)
{
if (guestUser.Email != userId)
{
throw new GuestUserNotValidError();
}
try
{
await _guests.GetById(userId);
await _guests.Edit(guestUser.Email, guestUser);
return(new JsonResult(guestUser));
}
catch (UserNotFoundError)
{
await _guests.Add(guestUser.Email, guestUser);
return(new JsonResult(guestUser)
{
StatusCode = 201
});
}
}
public async Task <GuestUser> createGuest()
{
string rv = await generateRandomUname();
var ex = await _gU.Find(x => x.UserName == rv).ToListAsync();
if (ex.Count != 0)
{
while (ex.Count != 0)
{
rv = await generateRandomUname();
ex = await _gU.Find(x => x.UserName == rv).ToListAsync();
}
}
GuestUser newguest = new GuestUser()
{
UserName = rv,
};
newguest.Roles.Add("guest");
await _gU.InsertOneAsync(newguest);
return(newguest);
}
// Reset code from guestuser
public Task ResetLoginCode(GuestUser guest)
{
var newCode = "";
// newCode = GenerateNewGuestLoginCode();
guest.LoginCode = newCode;
throw new NotImplementedException();
}
public string CheckGuestUser(GuestUser user)
{
if (db.Users.Any(u => u.Email == user.Email))
{
return("Exists");
}
else
{
return("Not");
}
}
public static void UpdateUser(this Order order, GuestUser user)
{
order.Email = user.Email;
order.FirstName = user.FirstName;
order.LastName = user.LastName;
order.Address = user.Address;
order.City = user.City;
order.State = user.State;
order.Zip = user.PostalCode;
order.Phone = user.PhoneNumber;
}
public GuestUser Add(GuestUser guestUser)
{
if (Get(guestUser.Id) == null)
{
List <GuestUser> guestUsers = GetAll();
guestUsers.Add(guestUser);
WriteAll(guestUsers);
return(guestUser);
}
return(null);
}
public async Task <ActionResult> WarningDisplay([Bind(Include = "GuestUserId, GuestUserEmail, GuestUserFirstName, GuestUserLastName, GuestUserCity, State, GuestUserZipCode")] GuestUser guestUser)
{
if (ModelState.IsValid)
{
db.GuestUsers.Add(guestUser);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(guestUser));
}
/// <summary>
/// Get users from the specified OU ready to add to the list box.
/// </summary>
/// <param name="sender"></param>
/// <param name="doWorkEventArgs"></param>
private void FetchUsersWorkerOnDoWork(object sender, DoWorkEventArgs doWorkEventArgs)
{
try
{
users =
GuestUser.LoadGuestUsers(Properties.Settings.Default["LDAPSearchBase"].ToString());
}
catch (Exception e)
{
Logger.Warn($"Failed to load guest users from {Properties.Settings.Default["LDAPSearchBase"]} -- {e}");
}
}
public GuestUser Remove(int id)
{
List <GuestUser> guestUsers = GetAll();
GuestUser guestUserToRemove = guestUsers.SingleOrDefault(r => r.Id == id);
if (guestUserToRemove != null)
{
guestUsers.Remove(guestUserToRemove);
WriteAll(guestUsers);
}
return(guestUserToRemove);
}
protected void Application_BeginRequest(object sender, EventArgs e)
{
//Set a auth cookie and redirect if the login is successful
if (Request.Path.Contains("login"))
{
var username = Request.Form["username"];
if (!string.IsNullOrEmpty(username))
{
var user = new GuestUser(username);
user.TryLogOn();
FormsAuthentication.SetAuthCookie(username, false);
Response.Redirect("multy-game.html");
}
}
}
private int AddBooking(BookingDetails bookingDetails, List <BookingTransactions> transactions, List <BookingPassengers> passengers, GuestUser guestUser = null)
{
GuestUser guest = new GuestUser();
Booking booking = ConvertToBooking(bookingDetails);
if (bookingDetails.UserRegistered != 1)
{
if (db.GuestUsers.Any(gu => gu.Email == guestUser.Email && gu.Contact == guestUser.Contact))
{
guest = db.GuestUsers.Where(gu => gu.Email == guestUser.Email && gu.Contact == guestUser.Contact).First();
}
else
{
guest = guestUser;
db.GuestUsers.Add(guest);
db.SaveChanges();
}
booking.GuestId = guest.Id;
}
db.Bookings.Add(booking);
db.SaveChanges();
foreach (BookingPassengers bookingPassenger in passengers)
{
PassengerDetail passenger = ConvertPassenger(bookingPassenger);
passenger.BookingID = booking.BookingID;
db.PassengerDetails.Add(passenger);
db.SaveChanges();
}
foreach (BookingTransactions bookingTransaction in transactions)
{
Transaction transaction = ConvertToTransaction(bookingTransaction);
transaction.BookingID = booking.BookingID;
db.Transactions.Add(transaction);
if (transaction.Mode == "Wallet")
{
User user = db.Users.Where(u => u.Id == booking.UserId).First();
user.Wallet -= (int)transaction.amount;
db.Entry(user).State = System.Data.Entity.EntityState.Modified;
}
db.SaveChanges();
}
return(booking.BookingID);
}
public GuestUser Update(GuestUser guestUser)
{
List <GuestUser> guestUsers = GetAll();
for (int i = 0; i < guestUsers.Count; i++)
{
if (guestUsers[i].Id == guestUser.Id)
{
guestUsers[i] = guestUser;
break;
}
}
WriteAll(guestUsers);
return(guestUser);
}
public CheckoutRequest(GuestUser user, CartViewModel cart)
{
Cart = cart;
if (user == null)
{
return;
}
FirstName = user.FirstName;
LastName = user.LastName;
Email = user.Email;
Phone = user.PhoneNumber;
Address = user.Address;
City = user.City;
State = user.State;
PostalCode = user.PostalCode;
}
public virtual void TestInit()
{
DesignTimeHelper.Reset();
mockMessageService = GetMockMessageService();
messageService = mockMessageService.Object;
viewLocator = new ViewLocator();
mockRoomService = GetMockRoomService();
roomService = mockRoomService.Object;
viewModelFactory = new ViewModelFactory(roomService, messageService, viewLocator);
user = DesignTimeHelper.GetRegisteredUser();
room = DesignTimeHelper.GetRoom();
guestUser = DesignTimeHelper.GetGuestUser();
// Wait to kick off any of the actual tests until the basic test initialization has completed.
EnqueueConditional(() => TestGlobals.Initialized);
EnqueueTestComplete();
}
public IUser GetUserObject(UserIdentifier userIdentifier)
{
if (userIdentifier.IsGuest)
{
var res = new GuestUser(userIdentifier.Guid, _unirOfWork, _shopDomain);
if (!DomainData.GuestsCollection.ContainsKey(res.Guid))
{
DomainData.GuestsCollection.Add(res.Guid, res.Guid);
}
return(res);
}
var baseUser = _unirOfWork.BaseUserRepository.FindByIdOrNull(userIdentifier.Guid);
if (baseUser.IsAdmin)
{
return(new AdminUser(baseUser, _unirOfWork, _shopDomain));
}
return(new RegisteredUser(baseUser, _unirOfWork, _shopDomain));
}
/// <summary>
/// When the user changes the selected item in the list box.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void chooseAccountBox_SelectedIndexChanged(object sender, EventArgs e)
{
if (users == null)
{
Logger.Info("No users to select -- users is null");
return;
}
if (!users.Any())
{
Logger.Info("No users to select");
return;
}
// match user
try
{
user = users.Single((theUser =>
(theUser.ADUser.SamAccountName == (sender as ComboBox).SelectedItem.ToString())));
disableButton.Enabled = true;
generatePassword.Enabled = true;
UpdateStatusLabel();
}
catch (Exception ex)
{
Logger.Warn($"Failed to match the user selected to a GuestUser object -- {ex}");
}
passwordRevealBox.Text = "";
adUsername.Text = user.ADUser.SamAccountName;
revealButton.Enabled = false;
printButton.Enabled = false;
passwordRevealBox.Enabled = true;
passwordRevealBox.ReadOnly = true;
adUsername.Enabled = true;
adUsername.ReadOnly = true;
}
public List <int> CreateNewBooking(CompleteBookingDetails cBD)
{
List <BookingDetails> bookingDetails = cBD.Bookings;
List <BookingTransactions> bookingTransactions = cBD.Transactions;
List <BookingPassengers> bookingPassengers = cBD.Passengers;
GuestUser guestUser = cBD.GuestUser;
List <int> Ids = new List <int>();
Boolean IsReturn = cBD.Bookings.Count > 1 ? true : false;
Booking onwardBooking = ConvertToBooking(cBD.Bookings.First());
List <BookingTransactions> onwardTransactions = cBD.Transactions.Where(t => t.BookingDirection == "onward").ToList();
if (cBD.Bookings[0].UserRegistered == 1)
{
Ids.Add(AddBooking(cBD.Bookings[0], onwardTransactions, cBD.Passengers.ToList()));
}
else
{
Ids.Add(AddBooking(cBD.Bookings[0], onwardTransactions, cBD.Passengers.ToList(), cBD.GuestUser));
}
if (IsReturn)
{
List <BookingTransactions> returnTransactions = cBD.Transactions.Where(t => t.BookingDirection == "return").ToList();
if (cBD.Bookings[1].UserRegistered == 1)
{
Ids.Add(AddBooking(cBD.Bookings[1], returnTransactions, cBD.Passengers));
}
else
{
Ids.Add(AddBooking(cBD.Bookings[1], returnTransactions, cBD.Passengers, guestUser));
}
}
return(Ids);
}
public string AddUser(User user)
{
if (db.Users.Any(u => u.Email.ToLower() == user.Email.ToLower()))
{
return("Exists");
}
else
{
if (user.FirstName != "" && user.FirstName != null &&
user.LastName != "" && user.LastName != null &&
user.Email != "" && user.Email != null &&
user.Contact != "" && user.Contact != null && user.Contact.Length == 10 &&
user.Password != "" && user.Password != null)
{
db.Users.Add(user);
db.SaveChanges();
if (db.GuestUsers.Any(gu => gu.Email.ToLower() == user.Email.ToLower() && gu.Contact == user.Contact))
{
GuestUser guestUser = db.GuestUsers.Where(gu => gu.Email.ToLower() == user.Email.ToLower() && gu.Contact == user.Contact).First();
if (db.Bookings.Any(b => b.GuestId == guestUser.Id))
{
foreach (Booking booking in db.Bookings.Where(b => b.GuestId == guestUser.Id))
{
booking.UserRegistered = 1;
booking.UserId = user.Id;
booking.GuestId = null;
db.Entry(booking).State = System.Data.Entity.EntityState.Modified;
}
}
db.Entry(guestUser).State = System.Data.Entity.EntityState.Deleted;
db.SaveChanges();
}
return("Added");
}
else
{
return("Invalid");
}
}
}
public async Task <(AnyCompleteUser, int)> UserPutAsync(string userId, GuestUser payload)
{
if (payload.Email != userId)
{
throw new GuestUserNotValidError();
}
try
{
await _guests.GetById(userId);
await _guests.Edit(payload.Email, payload);
return(payload, 200);
}
catch (UserNotFoundError)
{
await _guests.Add(payload.Email, payload);
return(payload, 201);
}
}
public void CreateGuestUserTest()
{
// Arrange
var controller = new TracerController();
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
var gusr = new GuestUser();
gusr.lstNewUserEmails = "*****@*****.**";
gusr.siteID = 4;
gusr.updateByID = 50331;
// Act
var response = controller.CreateGuestUserByEmailIds(gusr);
// Assert
Assert.IsTrue(response.StatusCode == HttpStatusCode.OK);
}
private async Task <HttpResponseMessage> UserPutAsync(string userId, GuestUser guestUser)
{
if (guestUser.Email != userId)
{
throw new GuestUserNotValidError();
}
try
{
await _guests.GetById(userId);
await _guests.Edit(guestUser.Email, guestUser);
return(JsonResult(guestUser));
}
catch (UserNotFoundError)
{
await _guests.Add(guestUser.Email, guestUser);
return(JsonResult(guestUser, HttpStatusCode.Created));
}
}
/// <summary>
/// Generate and set the password across AD and SQL. Runs in BackgroundWorker
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void GenerateAndSetPassword(object sender, DoWorkEventArgs e)
{
generatePasswordWorker.DoWork -= GenerateAndSetPassword;
if (user == null)
{
NotifyUserIsNull();
passwordSetSucceeded = false;
return;
}
try
{
int passwordLength = Int32.Parse(Properties.Settings.Default["PasswordLength"].ToString());
newPassword = GuestUser.GenerateRandomPassword(passwordLength);
}
catch (Exception ex)
{
Invoke(new ShowExceptionDialogWithDetails(ShowExceptionDialog), "Unable to generate the password.", ex);
passwordSetSucceeded = false;
return;
}
try
{
user.SetPassword(newPassword);
}
catch (Exception ex)
{
Invoke(new ShowExceptionDialogWithDetails(ShowExceptionDialog),
$"There was a problem setting the user's password. Check that your user account has been delegated permission to change the user's password.",
ex);
passwordSetSucceeded = false;
return;
}
passwordSetSucceeded = true;
}
public async Task Create(GuestUser user)
{
var entity = _mapper.Map <Entity.GuestUser>(user);
await _guestUserRepository.Create(entity);
}
public Task CreateGuestUser(GuestUser model) => _guestUserService.Create(model);
public IActionResult AddOrderGuest([FromBody] OrderGuestUserViewModel model)
{
if (ModelState.IsValid)
{
GuestUser guestUser = new GuestUser
{
UserGuid = Guid.NewGuid(),
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber
};
ShippingAddress userAddress = new ShippingAddress
{
PostalCode = model.PostalCode,
StreetNumber = model.StreetNumber,
StreetName = model.StreetName,
CityName = model.CityName,
Country = model.Country,
AssociatedUser = guestUser.UserGuid
};
guestUser.ShippingAddress = userAddress;
decimal totalPriceOrder = CalculateOrderPrice(model.Products);
List <ProductOrder> productOrders = GetOrderProducts(model.Products);
decimal finalPrice = totalPriceOrder;
decimal discount = 0;
if (model.Coupon != null)
{
var discountValidation = ValidateCouponCode(model.Coupon, totalPriceOrder);
if (discountValidation != null)
{
model.Coupon = discountValidation.Item1;
discount = discountValidation.Item2;
finalPrice = discountValidation.Item3;
}
}
Order newOrder = new Order
{
Guid = Guid.NewGuid(),
Paid = false,
Shipped = false,
OrderCreated = DateTime.Now,
TotalPrice = totalPriceOrder,
Discount = discount,
FinalPrice = finalPrice,
CouponCode = model.Coupon,
OrderedProducts = productOrders,
AssociatedUserGuid = guestUser.UserGuid,
OrderedFromGuestAccount = true,
EmailConfirmationSent = false
};
OrderRepository.AddOrder(newOrder, guestUser);
return(Ok(newOrder.Guid));
}
return(BadRequest());
}
public async Task CreateGuestUser(GuestUser model) => await _guestUsers.Create(model);
private async Task <AuthenticationResult> GenerateAuthenticationResultForGuestAsync(GuestUser user)
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_jwtSettings.Secret);
var userR = _gU.Find <GuestUser>(x => x.UserName == user.UserName).FirstOrDefault();
var userrole = userR.Roles;
var claimlist = new List <Claim> {
new Claim(JwtRegisteredClaimNames.Sub, user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim("id", userR.Id),
new Claim("name", userR.UserName),
new Claim("role", userrole.FirstOrDefault())
};
var claims = new List <IdentityUserClaim>();
for (int i = 0; i < claimlist.Count; i++)
{
claims.Add(new IdentityUserClaim(claimlist[i]));
}
foreach (var userRole in userrole)
{
Claim claim = new Claim(ClaimTypes.Role, userRole);
claims.Add(new IdentityUserClaim(claim));
}
var filter = Builders <GuestUser> .Filter.Eq("Id", userR.Id);
var userClaims = _gU.Find <GuestUser>(filter).FirstOrDefault();
var CurrentClaims = userClaims.Claims;
CurrentClaims.AddRange(claims);
var update = Builders <GuestUser> .Update.Set("Claims", CurrentClaims);
await _gU.UpdateOneAsync(filter, update);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claimlist),
Expires = DateTime.Now.Add(_jwtSettings.TokenLifetime),
SigningCredentials =
new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
return(new AuthenticationResult
{
Username = user.UserName,
Success = true,
Token = tokenHandler.WriteToken(token),
RefreshToken = "",
});
}
public async Task <AuthenticationResult> AuthenticateGuest(GuestUser ar)
{
AuthenticationResult response = new AuthenticationResult();
return(await GenerateAuthenticationResultForGuestAsync(ar));
}
public GuestUser Add(GuestUser guestUser)
{
return(_guestUserRepository.Add(guestUser));
}
public List <int> GetGuestBookings(GuestUser user)
{
return(db.Bookings.Where(b => b.GuestUser.Email == user.Email && b.GuestUser.Contact == user.Contact).Select(bd => bd.BookingID).ToList());
}
/// <summary>
/// Load the users from the OU
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void LoadUsersDoWork(object sender, DoWorkEventArgs e)
{
IEnumerable <GuestUser> users = GuestUser.LoadGuestUsers(adPicker.ADsPath);
foundUsersLabel.Invoke((MethodInvoker)(() => foundUsersLabel.Text = $"Found {users.Count()} users in {adPicker.ADsPath}"));
}
