internal ServiceResult AddBidderAccount(BAccountCreateViewModel vm, Guid auctionGuid)
{
ABUserModel abuserModel = new ABUserModel();
abuserModel.Alias = vm.Alias;
abuserModel.Email = vm.EmailAddress;
abuserModel.Password = vm.Password;
abuserModel.ABUserGUID = Guid.NewGuid();
abuserModel.ABUser_AuctionGUID = auctionGuid;
abuserModel.Money = vm.Money;
ABUser addBidderSuccess = SaveBidderAccount(abuserModel);
bool commitSuccess = UpdateUser(addBidderSuccess);
if (commitSuccess)
{
return(new ServiceResult()
{
Success = true,
Params = addBidderSuccess.ToString()
});
}
return(new ServiceResult()
{
ErrorMessage = "Error message",
Success = false
});
}
public static async Task SeedDefaultUserAsync(UserManager <ABUser> userManager)
{
//ADMIN
var defaultAdmin = new ABUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Bill",
LastName = "Admin",
EmailConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(defaultAdmin.Email);
if (user == null)
{
await userManager.CreateAsync(defaultAdmin, "Abc&123!");
await userManager.AddToRoleAsync(defaultAdmin, Roles.Admin.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("**error**");
Debug.WriteLine("error Seeding Default Admin User.");
Debug.WriteLine(ex.Message);
Debug.WriteLine("****************");
}
//AddressBookUser
var defaultAddressBookUser = new ABUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Tom",
LastName = "User",
EmailConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(defaultAddressBookUser.Email);
if (user == null)
{
await userManager.CreateAsync(defaultAddressBookUser, "Abc&123!");
await userManager.AddToRoleAsync(defaultAddressBookUser, Roles.AddressBookUser.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("**error**");
Debug.WriteLine("error Seeding Default User User.");
Debug.WriteLine(ex.Message);
Debug.WriteLine("****************");
}
}
internal void DeleteAuctionData(string email)
{
ABUser user = _abUserRepository.FindBy(x => x.Email == email).FirstOrDefault();
Auction auction = user.Auction;
if (auction != null)
{
if (auction.CurrentBid.Bidder.Email == email)
{
auction.Auction_BidGUID = null;
var bidList = _bidRepository.FindBy(x => x.Bid_AuctionGUID == auction.AuctionGUID).ToList();
if (bidList != null && bidList.Count > 0)
{
foreach (var item in bidList)
{
_bidRepository.Delete(item);
}
}
_unitOfWork.Commit();
var userList = _abUserRepository.FindBy(x => x.ABUser_AuctionGUID == auction.AuctionGUID).ToList();
if (userList != null && userList.Count > 0)
{
foreach (var item in userList)
{
_abUserRepository.Delete(item);
}
}
_unitOfWork.Commit();
_auctionRepository.Delete(auction);
_unitOfWork.Commit();
}
}
}
internal ServiceResult UpdateAccountWithMoney(DepositMoneyViewModel vm)
{
UserInfoModel sessionVar = (UserInfoModel)HttpContext.Current.Session["User"];
var currEmail = sessionVar.Email;
ABUser currentUser = GetUserByUserName(currEmail);
var currentUserMoneyBalance = currentUser.Money;
currentUser.Money = currentUserMoneyBalance + vm.Money;
_userRepository.Update(currentUser);
bool commitSuccess = UpdateUser(currentUser);
if (commitSuccess)
{
return(new ServiceResult()
{
Success = true,
Params = currentUser.ToString()
});
}
return(new ServiceResult()
{
ErrorMessage = "Error message",
Success = false
});
}
public ActionResult RegisterSeller(string returnUrl)
{
var sellerGuid = Request.QueryString["sellerGuid"];
var code = Request.QueryString["code"];
ABUser currentUser = AccountService.GetUserByGUID(sellerGuid);
var currentUserEmail = currentUser.Email;
ViewBag.UserEmail = currentUserEmail;
AccountCreateViewModel model = new AccountCreateViewModel();
model.userGUID = new Guid(sellerGuid);
model.userToken = code;
HttpCookie cookie = Request.Cookies["AnonymousBidder"];
if (cookie != null)
{
try
{
return(DoRegister(model, model.userGUID, model.userToken, returnUrl));
}
catch (Exception)
{
}
}
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}
internal ServiceResult SendEmail(ABUser user)
{
if (user != null &&
user.Role != null &&
user.Role.UserRoleName == "BIDDER" &&
user.ABUser_AuctionGUID != null)
{
using (MemoryStream ms = new MemoryStream())
{
string body = @"<p>Dear User,</p>
<br/>
<p>You have been outbidded!</p>
<p>Do login to submit a new bid for the auction</p>
<br/>
<p>Thank you,</p>
<p>AnonymousBidder Team</p>
<p>AnonymousBidder Pte. Ltd.</p>
<br/>
<p><i>This is a system auto-generated email. Please do not reply to this email.</i></p>";
EmailHelper.SendMail("*****@*****.**", user.Email, "Your auction has been listed", body, "", "smtp_anonymousbidder");
}
return(new ServiceResult()
{
Success = true
});
}
return(new ServiceResult()
{
ErrorMessage = "Could not find user",
Success = false
});
}
private ActionResult DoRegister(AccountCreateViewModel model, Guid sellerGuid, string token, string returnUrl)
{
bool isRegisterValidEmail = isValidEmail(model.EmailAddress);
bool isRegisterValidPassword = isValidPassword(model.Password);
if (isRegisterValidEmail && isRegisterValidPassword)
{
ABUser currentUser = AccountService.GetUserByUserName(model.EmailAddress);
var currentUserGuid = currentUser.ABUserGUID;
var currentUserToken = currentUser.Token;
Guid tempCurrentUserGuid = sellerGuid;
if (tempCurrentUserGuid == currentUserGuid && currentUserToken == token && isRegisterValidEmail)
{
var hashedPassword = Utilities.CreatePasswordHash(model.Password, model.EmailAddress);
AccountCreateViewModel vm = new AccountCreateViewModel();
vm.Password = hashedPassword;
vm.EmailAddress = model.EmailAddress;
vm.ConfirmPassword = hashedPassword;
vm.Alias = model.Alias;
ServiceResult result = new ServiceResult();
result = AccountService.AddAccount(vm);
if (result.Success)
{
return(RedirectToAction("RegisterSuccess", result));
}
return(RedirectToAction("RegisterFail", result));
}
}
return(null);
}
/*
* This function is for updatig user or equal to add a new seller into system
*/
internal ServiceResult AddAccount(AccountCreateViewModel vm)
{
ABUserModel abuserModel = new ABUserModel();
abuserModel.Alias = vm.Alias;
abuserModel.Email = vm.EmailAddress;
abuserModel.Password = vm.Password;
abuserModel.Token = null;
ABUser currentUser = GetUserByUserName(vm.EmailAddress);
currentUser.Alias = vm.Alias;
currentUser.Password = vm.Password;
currentUser.Token = null;
_userRepository.Update(currentUser);
bool commitSuccess = UpdateUser(currentUser);
if (commitSuccess)
{
return(new ServiceResult()
{
Success = true,
Params = currentUser.ToString()
});
}
return(new ServiceResult()
{
ErrorMessage = "Error message",
Success = false
});
}
public ActionResult DoChangePassword(ChangePasswordViewModel model)
{
UserInfoModel user = HttpSession.GetFromSession <UserInfoModel>();
if (user == null)
{
return(RedirectToAction("Login"));
}
if (!ModelState.IsValid)
{
return(View("ChangePassword", model));
}
string hashedPassword = Utilities.CreatePasswordHash(model.OldPassword, user.Email);
var isValidOldPassword = AccountService.DoLogin(user.Email, hashedPassword);
if (isValidOldPassword)
{
ABUser ca_user = AccountService.GetUserByUserNameAndPassword(user.Email, hashedPassword);
hashedPassword = Utilities.CreatePasswordHash(model.Password, user.Email);
ca_user.Password = hashedPassword;
var result = AccountService.UpdateUser(ca_user);
if (result)
{
return(RedirectToAction("Login"));
}
}
else
{
ModelState.AddModelError("OldPassword", "The Old Password is not correct.");
}
return(View("ChangePassword", model));
}
internal ServiceResult SendEmail(string registrationPath, Guid sellerGuid, string bidderRegistrationPath)
{
ABUser seller = _abUserRepository.FindBy(x => x.ABUserGUID == sellerGuid).FirstOrDefault();
ABUser bidderQr = _abUserRepository.FindBy(x => x.ABUser_AuctionGUID == seller.ABUser_AuctionGUID).FirstOrDefault();
if (seller != null &&
seller.Role != null &&
seller.Role.UserRoleName == "SELLER")
{
var url = string.Format("http://chart.apis.google.com/chart?cht=qr&chs={1}x{2}&chl={0}", bidderRegistrationPath, "250", "250");
WebResponse response = default(WebResponse);
Stream remoteStream = default(Stream);
StreamReader readStream = default(StreamReader);
WebRequest request = WebRequest.Create(url);
response = request.GetResponse();
remoteStream = response.GetResponseStream();
readStream = new StreamReader(remoteStream);
System.Drawing.Image img = System.Drawing.Image.FromStream(remoteStream);
//img.Save("D:/QRCode/" + txtCode.Text + "facebook.png");
response.Close();
remoteStream.Close();
readStream.Close();
using (MemoryStream ms = new MemoryStream())
{
img.Save(ms, img.RawFormat);
byte[] imageBytes = ms.ToArray();
string attachment = Convert.ToBase64String(imageBytes);
string body = @"<p>Your auction has been listed.</p>
<p>Please kindly click <a href=" + registrationPath + @">here</a> to register and view the auction.</p>
<p>Thank you,</p>
<p>AnonymousBidder Team</p>
<p>AnonymousBidder Pte. Ltd.</p>
<p><i>This is a system auto-generated email. Please do not reply to this email. </i></p>";
EmailHelper.SendMail("*****@*****.**", seller.Email, "Your auction has been listed", body, "", "smtp_anonymousbidder", attachment);
}
return(new ServiceResult()
{
Success = true
});
}
return(new ServiceResult()
{
ErrorMessage = "Could not find user",
Success = false
});
}
public JsonResult EmailExists(string emailAddress)
{
bool isUserExisted = false;
ABUser user = AccountService.GetUserByUserName(emailAddress);
isUserExisted = user != null;
return(Json(isUserExisted, JsonRequestBehavior.AllowGet));
}
private Bid createNewBid(ABUser user, Auction data, decimal bid)
{
Bid b = new Bid();
b.Bid_AuctionGUID = data.AuctionGUID;
b.Bid_ABUserGUID = user.ABUserGUID;
b.BidGUID = Guid.NewGuid();
b.BidPlaced = bid;
return(b);
}
internal Guid StoreCodetoGuid2(Guid sellerGuid)
{
ABUser seller = _abUserRepository.FindBy(x => x.ABUserGUID == sellerGuid).FirstOrDefault();
Guid auctionGuid = seller.Auction.AuctionGUID;
return(auctionGuid);
if (seller != null)
{
Commit();
}
}
public bool UpdateUser(ABUser user)
{
try
{
_unitOfWork.Commit();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
internal ServiceResult updateAuctionBid(string email, decimal bid)
{
ABUser user = _abUserRepository.FindBy(x => x.Email.ToString() == email).FirstOrDefault();
if (user != null && user.Role.UserRoleName.ToString() == "BIDDER")
{
Auction auctionResult = _auctionRepository.FindBy(x => x.AuctionGUID == user.ABUser_AuctionGUID).FirstOrDefault();
if (auctionResult.Auction_BidGUID == null)
{
if (bid > auctionResult.StartingBid &&
bid < user.Money)
{
Bid b = createNewBid(user, auctionResult, bid);
_bidRepository.Add(b);
auctionResult.Auction_BidGUID = b.BidGUID;
_unitOfWork.Commit();
return(new ServiceResult()
{
Success = true
});
}
}
else
{
if (bid > auctionResult.CurrentBid.BidPlaced &&
bid < user.Money)
{
Bid pBid = _bidRepository.FindBy(x => x.Bid_AuctionGUID == auctionResult.AuctionGUID).FirstOrDefault();
ABUser pBidder = _abUserRepository.FindBy(x => x.ABUserGUID == pBid.Bid_ABUserGUID).FirstOrDefault();
Bid b = createNewBid(user, auctionResult, bid);
_bidRepository.Add(b);
auctionResult.Auction_BidGUID = b.BidGUID;
_unitOfWork.Commit();
SendEmail(pBidder);
return(new ServiceResult()
{
Success = true
});
}
}
}
return(new ServiceResult()
{
ErrorMessage = "New bid could not be submitted.",
Success = false
});
}
private ABUser SaveAccount(ABUserModel abuserModel)
{
var role = getGUID();
ABUser abuser = new ABUser()
{
ABUserGUID = Guid.NewGuid(),
Alias = abuserModel.Alias,
Email = abuserModel.Email,
Password = abuserModel.Password,
Role = role
};
_userRepository.Add(abuser);
return(abuser);
}
private ABUser SaveBidderAccount(ABUserModel abuserModel)
{
var role = getBidderRoleGUID();
ABUser abuser = new ABUser()
{
ABUserGUID = Guid.NewGuid(),
Alias = abuserModel.Alias,
Email = abuserModel.Email,
Password = abuserModel.Password,
Role = role,
Money = abuserModel.Money,
ABUser_AuctionGUID = abuserModel.ABUser_AuctionGUID
};
_userRepository.Add(abuser);
return(abuser);
}
private BidPostViewModel GetBidPostByEmail(string email)
{
ABUser user = _abUserRepository.FindBy(x => x.Email == email).FirstOrDefault();
if (user != null && user.Role.UserRoleName == "BIDDER" &&
user.ABUser_AuctionGUID != null)
{
BidPostViewModel result = new BidPostViewModel();
var auction = user.Auction;
result.AuctionModel = new AuctionModel()
{
ItemName = auction.ItemName,
EndDate = auction.EndDate,
StartingBid = auction.StartingBid,
AuctionOver = auction.AuctionOver
};
Auction auctionBid = _auctionRepository.FindBy(x => x.AuctionGUID == user.ABUser_AuctionGUID).FirstOrDefault();
if (auctionBid.Auction_BidGUID == null)
{
result.BidModel = new BidModel()
{
BidPlaced = auctionBid.StartingBid
};
}
else
{
result.BidModel = new BidModel()
{
BidPlaced = auctionBid.CurrentBid.BidPlaced
};
}
if (auction == null || auctionBid == null)
{
return(null);
}
return(result);
}
else
{
return(null);
}
}
private Guid SaveSeller(ABUserModel ABUserModel, Guid auctionGUID)
{
Guid sellerRoleGuid = _userRoleRepository.FindBy(x => x.UserRoleName == "SELLER").FirstOrDefault().UserRoleGUID;
if (sellerRoleGuid != null && sellerRoleGuid != Guid.Empty)
{
ABUser abUser = new ABUser()
{
ABUserGUID = Guid.NewGuid(),
ABUser_AuctionGUID = auctionGUID,
ABUser_UserRoleGUID = sellerRoleGuid,
Email = ABUserModel.Email,
};
_abUserRepository.Add(abUser);
return(abUser.ABUserGUID);
}
return(Guid.Empty);
}
public ActionResult SaveSellerItemStatus(AuctionItemViewModel itemViewModel, FormCollection form)
{
string valueOf = form["auctionItem.SellerSent"].ToString();
ABUser seller = _auctionService.ViewSellerAuctionIdViaEmail(UserInfoModel.Email);
if (valueOf.Equals("1"))
{
itemViewModel.auctionItem.SellerSent = true;
}
else if (valueOf.Equals("0"))
{
itemViewModel.auctionItem.SellerSent = false;
}
else
{
}
Auction queryObj;
try
{
queryObj = _auctionService.ViewAuctionByGUID(seller.ABUser_AuctionGUID.Value);
queryObj.SellerSent = itemViewModel.auctionItem.SellerSent;
}
catch
{
return(null);
}
ServiceResult result = _auctionService.SaveSellerShippingStatus(queryObj);
if (result.Success)
{
return(RedirectToAction("Item", result));
}
return(null);
}
private void SendToSeller(Auction auction)
{
ABUser seller = auction.AllUsers.Where(x => x.Role != null && x.Role.UserRoleName == "SELLER").FirstOrDefault();
if (seller != null)
{
// Find all buyers that isnt a winner
string body = @"<p>The auction you have listed has ended.</p>
<p>Please ship the item to the highest bidder to receive the payment</p>
<p>Thank you,</p>
<p>AnonymousBidder Team</p>
<p>AnonymousBidder Pte. Ltd.</p>
<p><i>This is a system auto-generated email. Please do not reply to this email. </i></p>";
EmailHelper.SendMail("*****@*****.**", seller.Email, "The auction you have listed has ended", body, "", "smtp_anonymousbidder");
}
}
protected override void Seed(AnonymousBidder.Data.AnonymousBidderDataContext context)
{
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data. E.g.
//
//---------- ROLES --------------
UserRole admin = new UserRole
{
UserRoleGUID = Guid.NewGuid(),
UserRoleName = "ADMIN",
};
UserRole seller = new UserRole
{
UserRoleGUID = Guid.NewGuid(),
UserRoleName = "SELLER",
};
UserRole bidder = new UserRole
{
UserRoleGUID = Guid.NewGuid(),
UserRoleName = "BIDDER",
};
context.Role.AddOrUpdate(
admin, bidder, seller
);
//----------- AUCTION ---------------
Auction auction = new Auction
{
AuctionGUID = Guid.NewGuid(),
EndDate = DateTime.Now.AddDays(1),
StartDate = DateTime.Now,
ItemName = "Rare Pepe",
StartingBid = (decimal)10000.00,
BuyerReceived = false,
SellerSent = false
};
context.Auction.AddOrUpdate(
auction
);
//----------- FILE PATH ------------
string fileLocation = AppDomain.CurrentDomain.BaseDirectory + "/App_Data/Auction_Images/TestAuction.jpg";
FilePath filePath = new FilePath
{
FilePathGUID = Guid.NewGuid(),
FilePathName = fileLocation,
FilePath_AuctionGUID = auction.AuctionGUID
};
context.FilePath.AddOrUpdate(
filePath
);
//------------ USERS -------------
ABUser bidUser = new ABUser
{
Alias = "NotShadyGuy",
Email = "*****@*****.**",
Password = Utilities.CreatePasswordHash("notshadypassword", "*****@*****.**"),
ABUser_UserRoleGUID = bidder.UserRoleGUID,
ABUserGUID = Guid.NewGuid(),
ABUser_AuctionGUID = auction.AuctionGUID
};
ABUser sellerUser = new ABUser
{
Alias = "NotShadyGuy",
Email = "*****@*****.**",
Password = Utilities.CreatePasswordHash("notshadypassword", "*****@*****.**"),
ABUser_UserRoleGUID = seller.UserRoleGUID,
ABUserGUID = Guid.NewGuid(),
ABUser_AuctionGUID = auction.AuctionGUID
};
ABUser adminUser = new ABUser
{
Alias = "NotShadyAdmin",
Email = "*****@*****.**",
Password = Utilities.CreatePasswordHash("notshadyadminpassword", "*****@*****.**"),
ABUser_UserRoleGUID = admin.UserRoleGUID,
ABUserGUID = Guid.NewGuid()
};
context.User.AddOrUpdate(
adminUser, sellerUser, bidUser);
//----------- BID --------------
Bid bid = new Bid
{
BidGUID = Guid.NewGuid(),
BidPlaced = (decimal)10000.00,
Bid_AuctionGUID = auction.AuctionGUID,
Bid_ABUserGUID = bidUser.ABUserGUID
};
context.Bid.AddOrUpdate(
bid
);
context.Commit();
//
}
/// <summary>
/// Score a conversion for this test for the specified user
/// </summary>
/// <param name="user"></param>
public void Score(ABUser user)
{
GetUserAlternative(user.ID).ScoreConversion();
}
private ActionResult DoLogin(LoginViewModel model, string returnUrl)
{
if (isValidEmail(model.EmailAddress))
{
if (string.IsNullOrEmpty(model.HashedPassword))
{
model.HashedPassword = Utilities.CreatePasswordHash(model.Password, model.EmailAddress);
}
ABUser user = AccountService.GetUserByUserNameAndPassword(model.EmailAddress, model.HashedPassword);
if (user != null)
{
UserInfoModel userInfo = new UserInfoModel
{
Email = user.Email,
Role = user.Role.UserRoleName
};
Session["User"] = userInfo;
HttpSession.SetInSession(userInfo);
FormsAuthentication.SetAuthCookie(model.EmailAddress, model.RememberMe);
#region Remember Me
if (model.RememberMe)
{
var userData = model.HashedPassword;
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
model.EmailAddress,
DateTime.Now,
DateTime.Now.AddDays(7), //Remember for 7 days
model.RememberMe,
userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie cookie = new HttpCookie("AnonymousBidder", encTicket);
cookie.Expires = authTicket.Expiration; //must do it for cookie expiration
Response.Cookies.Add(cookie);
}
#endregion Remember Me
if (Url.IsLocalUrl(returnUrl) &&
returnUrl.Length > 1 && returnUrl.StartsWith("/") &&
!returnUrl.StartsWith("//") &&
!returnUrl.StartsWith("/\\"))
{
return(Redirect(returnUrl));
}
if (userInfo.Role == "ADMIN")
{
return(RedirectToAction("Create", "Auction"));
}
else if (userInfo.Role == "SELLER")
{
return(RedirectToAction("Item", "Auction"));
}
else if (userInfo.Role == "BIDDER")
{
return(RedirectToAction("BidPost", "BidPost"));
}
}
}
return(View());
}
internal ABUser ViewSellerAuctionIdViaEmail(string sellerEmail)
{
ABUser queryResultObj = _abUserRepository.FindBy(x => x.Email == sellerEmail).FirstOrDefault();
return(queryResultObj);
}
