public async Task NewMemberAccountAsync(MemberAccount entity)
{
using (var conn = CreateConnection())
{
await conn.InsertAsync <MemberAccount>(entity).ConfigureAwait(false);
}
}
public async Task <bool> UpdateMemberAccountAsync(MemberAccount entity)
{
using (var conn = CreateConnection())
{
return((await conn.UpdateAsync(entity).ConfigureAwait(false)) > 0);
}
}
public async Task <ActionResult> OnGet()
{
var code = Request.Query["code"];
var UserAccessTokenResult = await wxService.GetMPAccessToken(code);
HttpContext.Session.SetString("AccessToken", JsonConvert.SerializeObject(UserAccessTokenResult));
var userInfo = await wxService.GetUserInfo(UserAccessTokenResult.AccessToken, UserAccessTokenResult.OpenId);
var hasUser = await userManager.FindByLoginAsync("wxMP", UserAccessTokenResult.OpenId);
if (hasUser == null)
{
var user = new MemberAccount
{
UserName = "******" + Guid.NewGuid().ToString(),
NormalizedUserName = userInfo.NickName
};
await userManager.CreateAsync(user, "WechatPassword123#");
await userManager.AddLoginAsync(user, new UserLoginInfo("wxMP", UserAccessTokenResult.OpenId, "Wechat"));
await userManager.AddClaimAsync(user, new System.Security.Claims.Claim("wxopenid", UserAccessTokenResult.OpenId));
await signInManager.SignInAsync(user, true);
}
else
{
await signInManager.SignInAsync(hasUser, true);
}
return(Redirect("/"));
}
public ActionResult Register(Member mbr, MemberAccount memberAccount)
{
var a = ModelState.IsValid;
string GetMemberID = db.Database.SqlQuery <string>("Select dbo.GetMemberID()").FirstOrDefault();
mbr.mbrID = GetMemberID;
memberAccount.mbrID = GetMemberID;
mbr.nickName = mbr.mbrName;
mbr.Points = 0;
mbr.mbrAut = false;
mbr.signupDate = DateTime.Now;
mbr.mbrImage = "0.jpg";
mbr.mbrBlock = false;
mbr.MemberAccount = memberAccount;
if (ModelState.IsValid)
{
//db.Entry(mbr).State = EntityState.Modified;
//db.Entry(mbr).State = EntityState.Detached;
db.Member.Add(mbr);
db.SaveChanges();
//db.MemberAccount.Add(memberAccount);
//db.SaveChanges();
return(RedirectToAction("Registercheck", "login"));
}
ViewBag.RegisterErr = true;
return(View("Login"));
}
public void CannotConvertRubToUse()
{
var sourceAccount = new MemberAccount
{
Balance = 10,
};
var targetAccount = new MemberAccount
{
Balance = 10,
};
var unitOfWork = new Mock <IUnitOfWork>();
var memberAccountRepo = new Mock <IMemberAccountReposotory>();
var rateRepo = new Mock <ICurrencyRateRepoository>();
rateRepo.Setup(a => a.GetBy(It.IsAny <string>())).Returns <string>((x) =>
{
return(new CurrencyRate
{
Rate = x == "rub" ? 80 : 0.9m,
});
});
memberAccountRepo.Setup(a => a.GetByUser(It.IsAny <int>(), It.IsAny <string>())).Returns <int, string>((x, y) =>
{
return(y == "rub" ? sourceAccount : targetAccount);
});
unitOfWork.SetupGet(x => x.MemberAccounts).Returns(memberAccountRepo.Object);
unitOfWork.SetupGet(x => x.CurrencyRates).Returns(rateRepo.Object);
_target = new CurrencyConverterService(unitOfWork.Object);
Assert.Catch <InvalidOperationException>(() => _target.Convert(new CurrencyConverClaim {
From = "rub", To = "Usd", Amount = 100, UserId = 1
}));
}
private Member TryJoin(PersonalDetailsMemberModel memberModel, IHavePasswords passwordsModel, Guid?friendInvitationId)
{
var account = new MemberAccount
{
FirstName = memberModel.FirstName,
LastName = memberModel.LastName,
EmailAddress = memberModel.EmailAddress
};
var credentials = new AccountLoginCredentials
{
LoginId = memberModel.EmailAddress,
Password = passwordsModel.Password,
ConfirmPassword = passwordsModel.ConfirmPassword,
};
// If the user is responding to an invitation then don't need to activate, unless they have changed their email.
var friendInvitation = GetFriendInvitation(friendInvitationId);
var acceptingFriendInvitation = friendInvitation != null && string.Equals(account.EmailAddress, friendInvitation.InviteeEmailAddress, StringComparison.OrdinalIgnoreCase);
var requiresActivation = !acceptingFriendInvitation;
// Join.
var member = _accountsManager.Join(HttpContext, account, credentials, requiresActivation);
// Deal with the invitations.
if (acceptingFriendInvitation)
{
AcceptFriendInvitation(member.Id, friendInvitation);
}
return(member);
}
public MemberAccount GetAccountDetail(string email, DateTime dateTime1, DateTime dateTime2)
{
MemberAccount requestedAccount = new MemberAccount(email, connectionString);
requestedAccount.GetAccountDetails(dateTime1, dateTime2);
return(requestedAccount);
}
/* Get specific User Account
* Input = Id_student
* return account that has Id_student equal input*/
public MemberAccount GetUserAccount(string id_account)
{
try
{
//find user account
var user = _dbContext.accounts.SingleOrDefault(x => x.Id_account == id_account);
//if there is no account
if (user == null)
{
return(null);
}
//if there is account in database
MemberAccount newby = new MemberAccount()
{
Id_account = user.Id_account,
Name = user.Name,
Point = user.Point
};
return(newby);
}
catch (Exception)
{
//error
return(null);
}
}
public async Task <IActionResult> UserAuthenticate([FromBody] Token token)
{
TimeZoneInfo zone = TimeZoneInfo.FindSystemTimeZoneById("SE Asia Standard Time");
DateTime dateTime = TimeZoneInfo.ConvertTime(DateTime.Now, zone);
try
{
var user = await _userService.AuthenticateAsync(token._Token);
//if there is no user in database
if (user == null)
{
Log.Information("Access Denied. {DateTime}", dateTime);
return(BadRequest(new { message = "Access Denied." }));
}
// there is user in database
Log.Information("user access {name}. {DateTime}.", user.Name, dateTime);
MemberAccount member = new MemberAccount()
{
Id_account = user.Id_account,
Name = user.Name,
Point = user.Point,
Token = user.Token
};
return(Ok(member));
}
catch
{
//error
Log.Information("Error User Authentication", dateTime);
return(NotFound("Error User Authentication"));
}
}
public ActionResult DeleteConfirmed(int id)
{
MemberAccount memberAccount = db.memberAccounts.Find(id);
db.memberAccounts.Remove(memberAccount);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static MemberAccountViewModel Create(MemberAccount account)
{
return(new MemberAccountViewModel
{
Balance = account.Balance,
Currency = account.CurrencyCode,
});
}
/// <summary>
/// save the member account
/// </summary>
protected void btnSave_click(object sender, EventArgs e)
{
MemberAccount Account = MemberAccount.GetMemberAccountByMemberID(member.MemberID);
Account.Username = txtTwitterUserName.Text;
Account.Password = txtTwitterPassword.Text;
Account.Save();
}
public ActionResult Edit([Bind(Include = "MemberID,UserName,Email,DateOfBirth,FirstName,LastName,MobilePhone")] MemberAccount memberAccount)
{
if (ModelState.IsValid)
{
db.Entry(memberAccount).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(memberAccount));
}
public void FilteredAccountDetails_ContainsOnlyFilterCriteria()
{
membershipApplication.CreateMemberAccount(out string _);
CBS requestDirector = new CBS(connectionString);
MemberAccount foundAccount = requestDirector.GetAccountDetail(membershipApplication.ProspectiveMemberContactInfo.Email, DateTime.Today.AddDays(-29), DateTime.Today.AddDays(1));
foundAccount.FilterAccountDetails("membership");
Assert.All(foundAccount.Transactions, (Transaction tran) => tran.Description.Contains("membership"));
}
public MemberAccount FindMemberAccount(string memberID)
{
SqlConnection ClubBaistConnection = new SqlConnection();
ClubBaistConnection.ConnectionString = @"Data Source= (LocalDB)\MSSQLLocalDB;
Initial Catalog = aspnet-ClubBaistGolfManagement-53bc9b9d-9d6a-45d4-8429-2a2761773502;
Integrated Security = True; MultipleActiveResultSets=True";
SqlCommand thecommand = new SqlCommand();
thecommand.CommandType = CommandType.StoredProcedure;
thecommand.Connection = ClubBaistConnection;
thecommand.CommandText = "GetMemberAccount";
SqlParameter memberid = new SqlParameter();
memberid.ParameterName = "@memberid";
memberid.SqlDbType = SqlDbType.VarChar;
memberid.Value = memberID;
memberid.Direction = ParameterDirection.Input;
thecommand.Parameters.Add(memberid);
ClubBaistConnection.Open();
SqlDataReader theDataReader;
theDataReader = thecommand.ExecuteReader();
MemberAccount chosenMemberAccount = new MemberAccount();
List <AccountEntry> accountEntriesforMember = new List <AccountEntry>();
if (theDataReader.HasRows)
{
while (theDataReader.Read())
{
AccountEntry accountEntry = new AccountEntry();
chosenMemberAccount.MemberId = theDataReader["MemberID"].ToString();
chosenMemberAccount.Balance = Decimal.Parse(theDataReader["Balance"].ToString());
accountEntry.WhenCharged = DateTime.Parse(theDataReader["WhenCharged"].ToString());
accountEntry.WhenMade = DateTime.Parse(theDataReader["WhenMade"].ToString());
accountEntry.Amount = Decimal.Parse(theDataReader["Amount"].ToString());
accountEntry.PaymentDescription = theDataReader["PaymentDescription"].ToString();
accountEntriesforMember.Add(accountEntry);
}
}
ClubBaistConnection.Close();
chosenMemberAccount.AccountEntries = accountEntriesforMember;
return(chosenMemberAccount);
}
public ActionResult Create([Bind(Include = "MemberID,UserName,Email,DateOfBirth,FirstName,LastName,MobilePhone")] MemberAccount memberAccount)
{
if (ModelState.IsValid)
{
db.memberAccounts.Add(memberAccount);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(memberAccount));
}
public void SHOULD_THROW_ERROR_WHEN_REDEEMED_FROM_ACCOUNT_BALANCE_NOT_ENOUGH()
{
//Arrange
var name = "Lufthansa";
var status = "ACTIVE";
var balance = 100;
//Act
var fakeMemberAccount = new MemberAccount(balance, status, name);
//Assert
Assert.Throws <MemberDomainException>(() => fakeMemberAccount.RedeemPointFromAccount(200));
}
private void NotifyPhotoUploaded(Member member, PhotoCollection photoCollection)
{
System.Diagnostics.Debug.Assert(member != null, "member != null");
var memberAccount = MemberAccount.GetMemberAccountByMemberID(member.MemberID);
if (MemberAccount.IsTwitterReady(memberAccount))
{
if (TwitterService.CanPost(MemberAccountActivity.GetLastActivity(member.MemberID, 1 /* Twitter */, 2 /* PhotoGallery */)))
{
TwitterService.NotifyPhotoUploaded(memberAccount.Username, memberAccount.Password, member.WebMemberID, photoCollection.WebPhotoCollectionID);
MemberAccountActivity.SetLastActivity(member.MemberID, 1 /* Twitter */, 2 /* PhotoGallery */);
}
}
}
// GET: MemberAccounts/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MemberAccount memberAccount = db.memberAccounts.Find(id);
if (memberAccount == null)
{
return(HttpNotFound());
}
return(View(memberAccount));
}
public void GetAccountDetails_NotEmpty(MembershipType membershipType)
{
membershipApplication = CreateAndRecordMembershipApplication(membershipType);
membershipApplication.CreateMemberAccount(out string _);
CBS requestDirector = new CBS(connectionString);
MemberAccount foundAccount = requestDirector.GetAccountDetail(membershipApplication.ProspectiveMemberContactInfo.Email, DateTime.Today.AddDays(-29), DateTime.Today.AddDays(1));
Assert.NotEmpty(foundAccount.Transactions);
Assert.False(string.IsNullOrWhiteSpace(foundAccount.Name));
Assert.False(string.IsNullOrWhiteSpace(foundAccount.MembershipLevel));
Assert.NotNull(foundAccount.MembershipType);
RemoveMemberAccount();
RemoveMembershipApplication();
}
protected ActionResult TryJoin(MemberJoin join, CheckBoxValue acceptTerms, Func <IErrorHandler> createErrorHandler)
{
try
{
join = join ?? new MemberJoin();
// Process the post to check validations.
if (acceptTerms == null || !acceptTerms.IsChecked)
{
ModelState.AddModelError(new[] { new TermsValidationError("AcceptTerms") }, createErrorHandler());
}
// Try to join.
if (acceptTerms != null && acceptTerms.IsChecked)
{
var account = new MemberAccount
{
FirstName = join.FirstName,
LastName = join.LastName,
EmailAddress = join.EmailAddress,
};
var credentials = new AccountLoginCredentials
{
LoginId = join.EmailAddress,
Password = join.JoinPassword,
ConfirmPassword = join.JoinConfirmPassword,
};
_accountsManager.Join(HttpContext, account, credentials, true);
return(RedirectToUrl(JoinUrl));
}
// Not accepting terms so cannot proceed but also check whether any other fields fail validation.
join.Prepare();
join.Validate();
}
catch (UserException ex)
{
ModelState.AddModelError(ex, createErrorHandler());
}
return(null);
}
public ActionResult Join(MemberJoin joinModel, bool acceptTerms)
{
try
{
joinModel = joinModel ?? new MemberJoin();
// Process the post to check validations.
if (acceptTerms)
{
// Try to join.
var account = new MemberAccount
{
FirstName = joinModel.FirstName,
LastName = joinModel.LastName,
EmailAddress = joinModel.EmailAddress,
};
var credentials = new AccountLoginCredentials
{
LoginId = joinModel.EmailAddress,
Password = joinModel.JoinPassword,
ConfirmPassword = joinModel.JoinConfirmPassword,
};
_accountsManager.Join(HttpContext, account, credentials, true);
}
else
{
ModelState.AddModelError(new[] { new TermsValidationError("AcceptTerms") }, new StandardErrorHandler());
// Not accepting terms so cannot proceed but also check whether any other fields fail validation.
joinModel.Prepare();
joinModel.Validate();
}
}
catch (UserException ex)
{
ModelState.AddModelError(ex, new StandardErrorHandler());
}
return(Json(new JsonResponseModel()));
}
public bool CloseAccount(MemberAccount memberAccount)
{
try
{
var amountTransaction = memberAccount.AmountTransaction;
amountTransaction.Id = Common.UniqueTransactionId();
amountTransaction.TransactionType = (int)TransactionType.Debit;
amountTransaction.StatusId = (int)AmountTransactionStatus.Pending;
amountTransaction.TransactionPurposeId = SavingAccountModel.GetForcefullyTransactionPurposeIdByName(TransactionPurposeType.Closing.ToString());
memberAccount.AmountTransactions.Add(amountTransaction);
Repository.Instance.Update(memberAccount);
return(true);
}
catch (Exception ex)
{
return(false);
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
MemberAccount Account = MemberAccount.GetMemberAccountByMemberID(member.MemberID);
if (Account == null)
{
Account = new MemberAccount();
Account.MemberID = member.MemberID;
Account.Save();
}
txtTwitterUserName.Text = Account.Username;
txtTwitterPassword.Text = Account.Password;
}
txtTwitterUserName.Attributes.Add("value", txtTwitterUserName.Text);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
MemberAccount Account = MemberAccount.GetMemberAccountByMemberID(member.MemberID);
if (Account == null)
{
Account = new MemberAccount();
Account.MemberID = member.MemberID;
Account.Save();
}
txtTwitterUserName.Text = Account.Username;
txtTwitterPassword.Text = Account.Password;
}
txtTwitterUserName.Attributes.Add("value", txtTwitterUserName.Text);
}
public JsonResult GetUserAccount(string id_account)
{
TimeZoneInfo zone = TimeZoneInfo.FindSystemTimeZoneById("SE Asia Standard Time");
DateTime dateTime = TimeZoneInfo.ConvertTime(DateTime.Now, zone);
MemberAccount account = _accountRepo.GetUserAccount(id_account);
//if there is user account return to this function
if (account != null)
{
Log.Information("Get user account from mobile {name}. {DateTime).", account.Name, dateTime);
return(Json(account));
}
//if there is no user account return to this function
else
{
Log.Information("Get user account from mobile {name}, {DateTime}.", id_account, dateTime);
return(Json(null));
}
}
/*For checking token APIs, Finding id account and return some information*/
public MemberAccount User_Information(string token)
{
//find account
var user = _dbContext.accounts.SingleOrDefault(x => x.Token.Contains(token));
//if there is no user
if (user == null)
{
return(null);
}
//if there is user, create user form in order to return to user
MemberAccount _user = new MemberAccount()
{
Id_account = user.Id_account,
Name = user.Name,
Point = user.Point
};
return(_user);
}
public void CanConvertRubToUse()
{
var sourceAccount = new MemberAccount
{
Balance = 1000,
};
var targetAccount = new MemberAccount
{
Balance = 10,
};
var unitOfWork = new Mock <IUnitOfWork>();
var memberAccountRepo = new Mock <IMemberAccountReposotory>();
var rateRepo = new Mock <ICurrencyRateRepoository>();
rateRepo.Setup(a => a.GetBy(It.IsAny <string>())).Returns <string>((x) =>
{
return(new CurrencyRate
{
Rate = x == "rub" ? 80 : 0.9m,
});
});
memberAccountRepo.Setup(a => a.GetByUser(It.IsAny <int>(), It.IsAny <string>())).Returns <int, string>((x, y) =>
{
return(y == "rub" ? sourceAccount : targetAccount);
});
unitOfWork.SetupGet(x => x.MemberAccounts).Returns(memberAccountRepo.Object);
unitOfWork.SetupGet(x => x.CurrencyRates).Returns(rateRepo.Object);
_target = new CurrencyConverterService(unitOfWork.Object);
_target.Convert(new CurrencyConverClaim {
From = "rub", To = "Usd", Amount = 100, UserId = 1
});
var calculeted = _target.CalculateConvert("rub", "use", 100);
Assert.AreEqual(sourceAccount.Balance, 900);
Assert.AreEqual(targetAccount.Balance, 11.125);
Assert.AreEqual(calculeted, 1.125);
}
public ActionResult AddSavingAccount(MemberAccount account)
{
if (ModelState.IsValid)
{
if (account.Id == 0)
{
account.AccountTypeId = (int)AccountType.SavingAccount;
var accountTransaction = account.AmountTransaction;
accountTransaction.Id = Common.UniqueTransactionId();
accountTransaction.TransactionType = (int)TransactionType.Credit;
accountTransaction.Amount = account.MinAmount;
account.AmountTransactions.Add(accountTransaction);
var newRecord = Repository.Instance.Insert(account, true);
}
else
{
Repository.Instance.Update(account);
Repository.Instance.Commit();
}
}
return(View(new MemberAccount()));
}
public MemberAccount FindMemberAccount(string memberId)
{
var retrievedMemberAccountEntries = new List <MemberAccountEntry>();
var requestedMemberAccount = new MemberAccount();
using var connection = new SqlConnection(ConnectionString);
using var command = new SqlCommand("GetMemberAccount", connection);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.Add("@memberId", SqlDbType.NVarChar).Value = memberId;
//Open the connection and execute the reader
connection.Open();
var reader = command.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read()) // Mapping the program Object to Database
{
requestedMemberAccount.MemberId = memberId;
requestedMemberAccount.TotalBalance = (decimal)reader[4];
var retrievedMemberAccountEntry = new MemberAccountEntry()
{
WhenCharged = (DateTime)reader[0],
WhenMade = (DateTime)reader[1],
Amount = (decimal)reader[2],
EntryDecription = (string)reader[3]
};
retrievedMemberAccountEntries.Add(retrievedMemberAccountEntry);
}
}
reader.Close();
requestedMemberAccount.AccountEntries = retrievedMemberAccountEntries;
return(requestedMemberAccount);
}
public static IApplicationBuilder UseMPAuth(this IApplicationBuilder app)
{
app.MapWhen((ctx) =>
{
var accessTokenJson = ctx.Session.GetString("AccessToken");
var accessToken = JsonConvert.DeserializeObject <UserAccessTokenResult>(accessTokenJson ?? "");
var wxService = ctx.RequestServices.GetService <WxService>();
return(ctx.Request.Headers["User-Agent"].Any(x => x.ToLower().Contains("micromessenger")) &&
!ctx.Request.Path.Value.Contains("/UrlWxMPLogin") &&
!(ctx.User.Identity.IsAuthenticated || !string.IsNullOrEmpty(accessToken?.OpenId)));
}, appbuilder =>
{
appbuilder.Run(async ctx =>
{
var wxService = ctx.RequestServices.GetService <WxService>();
var callbackUrl = ctx.Request.Scheme + "://" + ctx.Request.Host + "/UrlWxMPLogin";
var redirectUrl = wxService.GetRedirectUrl(HttpUtility.UrlEncode(callbackUrl));
ctx.Response.Redirect(redirectUrl);
await Task.CompletedTask;
});
});
app.Map("/UrlWxMPLogin", appBuilder =>
{
appBuilder.Run(async ctx =>
{
var wxService = appBuilder.ApplicationServices.GetService <WxService>();
var signInManager = ctx.RequestServices.GetService <SignInManager <MemberAccount> >();
var userManager = ctx.RequestServices.GetService <UserManager <MemberAccount> >();
var logger = ctx.RequestServices.GetService <ILogger <WxService> >();
try
{
var code = ctx.Request.Query["code"];
var UserAccessTokenResult = await wxService.GetMPAccessToken(code);
ctx.Session.SetString("AccessToken", JsonConvert.SerializeObject(UserAccessTokenResult));
var userInfo = await wxService.GetUserInfo(UserAccessTokenResult.AccessToken, UserAccessTokenResult.OpenId);
var hasUser = await userManager.FindByLoginAsync("wxMP", UserAccessTokenResult.OpenId);
logger.LogInformation("Has user");
if (hasUser == null)
{
var user = new MemberAccount
{
UserName = "******" + Guid.NewGuid().ToString(),
NormalizedUserName = userInfo.NickName,
NickName = userInfo.NickName,
MemberBind = new MemberBind
{
WxNickName = userInfo.NickName,
WxOpenId = userInfo.OpenId
}
};
await userManager.CreateAsync(user, "WechatPassword123#");
//await userManager.AddLoginAsync(user, new UserLoginInfo("wxMP", UserAccessTokenResult.OpenId, "Wechat"));
await userManager.AddClaimAsync(user, new Claim("wxopenid", UserAccessTokenResult.OpenId));
await userManager.AddClaimAsync(user, new Claim("nickName", userInfo.NickName));
await signInManager.SignInAsync(user, true);
}
else
{
logger.LogInformation("SignIn user");
var claims = await userManager.GetClaimsAsync(hasUser);
if (!claims.Any(x => x.Type == "wxopenid"))
{
await userManager.AddClaimAsync(hasUser, new Claim("wxopenid", UserAccessTokenResult.OpenId));
}
if (!claims.Any(x => x.Type == "nickName"))
{
await userManager.AddClaimAsync(hasUser, new Claim("nickName", userInfo.NickName));
}
await signInManager.SignInAsync(hasUser, true);
}
ctx.Response.Redirect("/");
}
catch (Exception exc)
{
logger.LogError(exc, exc.Message);
}
});
});
return(app);
}
