public ActionResult MembershipOptionConfirmation()
{
//DeSerialize
Club club = (Club)Session["Club Object"];
ClubMembership clubMembership = (ClubMembership)Session["ClubMembership Object"];
MembershipOption membershipOption = (MembershipOption)Session["MembershipOption Object"];
if (club == null || clubMembership == null || membershipOption == null)
{
return(HttpNotFound());
}
ViewBag.ClubId = club.Id;
ViewBag.ClubName = club.name;
ViewBag.ClubNickName = club.nickname;
ViewBag.Price = membershipOption.Price;
ViewBag.Duration = membershipOption.Duration;
ViewBag.MembershipOptionId = membershipOption.Id;
ViewBag.JoinDate = clubMembership.JoinDate.ToString("D");
ViewBag.TermDate = clubMembership.TermDate.ToString("D");
ViewBag.Description = membershipOption.Description;
//Store description: membershipOption.Description for membershipOption == clubMembership.MembershipOption and ClubID == club.ClubID
//ViewBag.Description = db.MembershipOptions.Where(n => n.Id == clubMembership.MembershipOptionId).ToList().First().Description;
//below is a test to see what gets stored
//string tempMessage = club.name + " " + membershipOption.Duration + " (" + clubMembership.JoinDate + "~" + clubMembership.TermDate + ")" + " USD: " + membershipOption.Price;
//return Content(tempMessage);
return(View(clubMembership));
}
public void ClubMembership_Create_IsCreated()
{
ClubMembership clubMembership = ClubMembership.Create();
clubMembership.ShouldNotBeNull();
clubMembership.Status.ShouldBe(ClubMembership.MembershipStatus.Pending);
}
public ActionResult DeleteConfirmed(int id)
{
ClubMembership clubMembership = db.ClubMemberships.Find(id);
db.ClubMemberships.Remove(clubMembership);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private async Task AcceptInvitationAsync(ClubInvitation invitation, Guid userId)
{
var membership = new ClubMembership {
UserId = userId, ClubId = invitation.ClubId
};
await _context.AddAsync(membership);
_context.Remove(invitation);
await _context.SaveChangesAsync();
}
public ActionResult Edit([Bind(Include = "Id,UserId,ClubId,TermDate,JoinDate,Description,HasAccessToFinance")] ClubMembership clubMembership)
{
if (ModelState.IsValid)
{
db.Entry(clubMembership).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ClubId = new SelectList(db.Clubs, "Id", "name", clubMembership.ClubId);
return(View(clubMembership));
}
public void ClubMembership_Reject_MembershipRejected()
{
ClubMembership clubMembership = ClubMembership.Create();
clubMembership.Reject(PlayerTestData.GolfClubId, PlayerTestData.MembershipId, PlayerTestData.RejectionReason, PlayerTestData.MembershipRejectedDateTime);
clubMembership.MembershipId.ShouldBe(PlayerTestData.MembershipId);
clubMembership.MembershipNumber.ShouldBeNullOrEmpty();
clubMembership.AcceptedDateTime.ShouldBe(DateTime.MinValue);
clubMembership.RejectionReason.ShouldBe(PlayerTestData.RejectionReason);
clubMembership.RejectedDateTime.ShouldBe(PlayerTestData.MembershipRejectedDateTime);
clubMembership.Status.ShouldBe(ClubMembership.MembershipStatus.Rejected);
}
public ActionResult Edit([Bind(Include = "Id,UserId,ClubId,MembershipOptionId,RoleId,TermDate,JoinDate,Description,HasAccessToFinance,CanEditClubData,Violation")] ClubMembership clubMembership)
{
if (ModelState.IsValid)
{
db.Entry(clubMembership).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.UserId = new SelectList(db.AspNetUsers, "Id", "Email", clubMembership.UserId);
ViewBag.ClubId = new SelectList(db.Clubs, "Id", "name", clubMembership.ClubId);
ViewBag.MembershipOptionId = new SelectList(db.MembershipOptions, "Id", "Description", clubMembership.MembershipOptionId);
ViewBag.RoleId = new SelectList(db.TypesOfRoles, "Id", "Description", clubMembership.RoleId);
return(View(clubMembership));
}
// GET: ClubMemberList/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ClubMembership clubMembership = db.ClubMemberships.Find(id);
if (clubMembership == null)
{
return(HttpNotFound());
}
return(View(clubMembership));
}
// GET: ClubMemberships/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ClubMembership clubMembership = db.ClubMemberships.Find(id);
if (clubMembership == null)
{
return(HttpNotFound());
}
ViewBag.ClubId = new SelectList(db.Clubs, "Id", "name", clubMembership.ClubId);
return(View(clubMembership));
}
// Payment success. Show success message such as 'welcome to the club'
public ActionResult Success(int?clubId, int?clubMembershipId)
{
// retrieve the database result and show the congratulation message
Club club = db.Clubs.Find(clubId);
ClubMembership clubMembership = db.ClubMemberships.Find(clubMembershipId);
ViewBag.ClubId = club.Id;
ViewBag.ClubName = club.name;
ViewBag.ClubNickName = club.nickname;
ViewBag.WebSite = club.website;
ViewBag.JoinDate = clubMembership.JoinDate.ToString("d");
ViewBag.TermDate = clubMembership.TermDate.ToString("d");
return(View());
}
public ActionResult SelectMembershipOptions([Bind(Include = "Id,UserId,ClubId,MembershipOptionId,RoleId,TermDate,JoinDate,Description,HasAccessToFinance,CanEditClubData,Violation")] ClubMembership clubMembership)
{
if (ModelState.IsValid)
{
// duplicate check
List <ClubMembership> list = db.ClubMemberships.Where(c => c.UserId == clubMembership.UserId && c.ClubId == clubMembership.ClubId).ToList();
if (list.Count > 0)
{
foreach (ClubMembership item in list)
{
if (item.MembershipOptionId == clubMembership.MembershipOptionId)
{
// duplicate membership exist
return(RedirectToAction("DuplicateMembership", new {
duplicateClubId = clubMembership.ClubId,
duplicateMembershipOptionId = clubMembership.MembershipOptionId,
}));
}
}
}
// proceed with new membership
MembershipOption membershipOption = db.MembershipOptions.Where(n => n.Id == clubMembership.MembershipOptionId).ToList().First();
if (membershipOption == null)
{
return(HttpNotFound());
}
clubMembership.JoinDate = DateTime.Now;
//clubMembership.TermDate = clubMembership.JoinDate.AddYears(membershipOption.Duration);
clubMembership.TermDate = membershipOption.ExpDate;
clubMembership.Description = membershipOption.Description;
// Serialize
Session["ClubMembership Object"] = clubMembership;
Session["MembershipOption Object"] = membershipOption;
return(RedirectToAction("MembershipOptionConfirmation"));
}
ViewBag.UserId = new SelectList(db.AspNetUsers, "Id", "Email", clubMembership.UserId);
ViewBag.ClubId = new SelectList(db.Clubs, "Id", "name", clubMembership.ClubId);
return(View(clubMembership));
}
// GET: Events/Details/5
public ActionResult Details(int?id, int?clubId)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Event @event = db.Events.Find(id);
if (@event.Capacity != null)
{
int rsvpGoing = @event.EventsRSVPs.Where(r => r.Status == "going").ToList().Count();
@event.SpotsLeft = @event.Capacity.Value - rsvpGoing;
}
if (@event == null)
{
return(HttpNotFound());
}
//This code is to help determine if user can RSVP to event
//Passes whether or not user is a club member to Details view (if True, then they can RSVP)
ClubMembership membership = new ClubMembership();
var userid = User.Identity.GetUserId();
membership = db.ClubMemberships.Where(c => c.UserId == userid).Where(c => c.ClubId == @event.PrimaryClubID).FirstOrDefault();
if (membership == null)
{
ViewBag.isClubMember = false;
}
else
{
ViewBag.isClubMember = true;
}
//This code is to help determine if user can perform officer actions (Show RSVPs, Edit, and Delete for event)
//Passes whether or not user is a club officer to Details view (if True, then they can perform officer functions...Show RSVP, Edit/Delete Event)
//Currently just directly uses CanEditClubData to determine if officer. Might want to call CanEditAndCreateEvents() instead? But need to sort out int? vs int
if (membership != null && membership.CanEditClubData)
{
ViewBag.isClubOfficer = true;
}
else
{
ViewBag.isClubOfficer = false;
}
return(View(@event));
}
// GET: ClubMemberList/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ClubMembership clubMembership = db.ClubMemberships.Find(id);
if (clubMembership == null)
{
return(HttpNotFound());
}
ViewBag.UserId = new SelectList(db.AspNetUsers, "Id", "Email", clubMembership.UserId);
ViewBag.ClubId = new SelectList(db.Clubs, "Id", "name", clubMembership.ClubId);
ViewBag.MembershipOptionId = new SelectList(db.MembershipOptions, "Id", "Description", clubMembership.MembershipOptionId);
ViewBag.RoleId = new SelectList(db.TypesOfRoles, "Id", "Description", clubMembership.RoleId);
return(View(clubMembership));
}
public ActionResult DuplicateMembership(int?duplicateClubId, int?duplicateMembershipOptionId)
{
string userId = User.Identity.GetUserId();
MembershipOption membershipOption = db.MembershipOptions.Where(n => n.Id == duplicateMembershipOptionId).ToList().First();
ClubMembership clubMembership = db.ClubMemberships.Where(n => n.ClubId == duplicateClubId && n.UserId == userId && n.MembershipOptionId == duplicateMembershipOptionId).ToList().First();
Club club = db.Clubs.Find(duplicateClubId);
ViewBag.DuplicateClubId = duplicateClubId;
ViewBag.ClubName = club.name;
ViewBag.ClubNickName = club.nickname;
ViewBag.Duration = membershipOption.Duration;
ViewBag.JoinDate = clubMembership.JoinDate.Day + "/" + clubMembership.JoinDate.Month + "/" + clubMembership.JoinDate.Year;
ViewBag.TermDate = clubMembership.TermDate.Day + "/" + clubMembership.TermDate.Month + "/" + clubMembership.TermDate.Year;
ViewBag.Description = membershipOption.Description;
return(View());
}
public async Task <Club> Add(string clubName)
{
var membership = new ClubMembership {
User = await _userService.GetLoggedInUserAsync(),
IsAdmin = true
};
var club = new Club {
ClubName = clubName,
Memberships = new List <ClubMembership>
{
membership
}
};
var entity = await _context.AddAsync(club);
await _context.SaveChangesAsync();
return(entity.Entity);
}
/// <summary>
/// Checks whether the current user has edit access for events for a certain club
/// </summary>
/// <param name="clubID">The club to check against for edit access</param>
/// <returns>True is user has access, false if not</returns>
private bool CanCreateAndEditEvents(int clubID)
{
ClubMembership membership = new ClubMembership();
var userid = User.Identity.GetUserId();
membership = db.ClubMemberships.Where(c => c.UserId == userid).Where(c => c.ClubId == clubID).FirstOrDefault();
if (membership == null)
{
return(false);
}
if (membership.CanEditClubData)
{
return(true);
}
else
{
return(false);
}
}
public ActionResult Create([Bind(Include = "Id,UserId,ClubId,MembershipOptionId,RoleId,TermDate,JoinDate,Description,HasAccessToFinance,CanEditClubData,Violation")] ClubMembership clubMembership)
{
if (ModelState.IsValid)
{
db.ClubMemberships.Add(clubMembership);
db.SaveChanges();
return(RedirectToAction("Success", "PayPal", new { clubId = clubMembership.ClubId, clubMembershipId = clubMembership.Id }));
}
else
{
// Need to repopulate the SelectList (for free payment on MembershipOptionConfirmation.cshtml file)
// http://stackoverflow.com/questions/3393521/the-viewdata-item-that-has-the-key-my-key-is-of-type-system-string-but-must
// For UserIds
IEnumerable <SelectListItem> userIds = db.ClubMemberships.Select(
x => new SelectListItem {
Value = x.UserId, Text = x.UserId
});
ViewBag.ClubId = new SelectList(db.Clubs, "Id", "name", clubMembership.ClubId);
ViewData["UserId"] = userIds;
// For MembershipOptionIds
IEnumerable <SelectListItem> membershipOptionIds = db.ClubMemberships.Select(
x => new SelectListItem {
Value = x.MembershipOptionId.ToString(), Text = x.MembershipOptionId.ToString()
});
ViewData["MembershipOptionId"] = membershipOptionIds;
// For ClubId
IEnumerable <SelectListItem> clubIds = db.ClubMemberships.Select(
x => new SelectListItem {
Value = x.ClubId.ToString(), Text = x.ClubId.ToString()
});
ViewData["ClubId"] = clubIds;
ViewBag.ClubId = new SelectList(db.Clubs, "Id", "name", clubMembership.ClubId);
return(RedirectToAction("Success", "PayPal", new { clubId = clubMembership.ClubId, clubMembershipId = clubMembership.Id }));
//return View(clubMembership);
}
}
public async Task <Club> AddMember(Guid clubId, ApiUser user)
{
var membership = new ClubMembership {
User = user
};
var club = await _context.Clubs.FindAsync(clubId);
var currentUser = await _userService.GetLoggedInUserAsync();
var currentMembership = await _context.ClubMemberships.Where(x =>
x.UserId == currentUser.UserId && x.ClubId == clubId
).SingleOrDefaultAsync();
if (await isMember(currentUser.UserId, clubId) && currentMembership.IsAdmin)
{
club.Memberships.Add(membership);
await _context.SaveChangesAsync();
}
else
{
throw new UnauthorizedException($"Unauthorized to add to club with id, {clubId}");
}
return(club);
}
// start of the payment trasaction
public ActionResult PaymentWithPaypal([Bind(Include = "name,currency,price,quantity")] Item item)
{
var clubMembership = Session["ClubMembership Object"] as ClubMembership;
var membershipOption = Session["MembershipOption Object"] as MembershipOption;
//getting the apiContext as earlier
APIContext apiContext = Configuration.GetAPIContext(clubMembership.ClubId);
//APIContext apiContext = Configuration.GetAPIContext();
try
{
string payerId = Request.Params["PayerID"];
if (string.IsNullOrEmpty(payerId))
{
//this section will be executed first because PayerID doesn't exist
//it is returned by the create function call of the payment class
// Creating a payment
// baseURL is the url on which paypal sendsback the data.
// So we have provided URL of this controller only
string baseURI = Request.Url.Scheme + "://" + Request.Url.Authority + "/PayPal/PaymentWithPayPal?";
string cancelUrl = Request.Url.Scheme + "://" + Request.Url.Authority + "/ClubMemberships/MembershipOptionConfirmation";
//guid we are generating for storing the paymentID received in session
//after calling the create function and it is used in the payment execution
var guid = Convert.ToString((new Random()).Next(100000));
//CreatePayment function gives us the payment approval url
//on which payer is redirected for paypal acccount payment
var createdPayment = this.CreatePayment(apiContext, baseURI + "guid=" + guid, cancelUrl, item);
//var createdPayment = this.CreatePayment(apiContext, testredirect, item);
//get links returned from paypal in response to Create function call
var links = createdPayment.links.GetEnumerator();
string paypalRedirectUrl = null;
while (links.MoveNext())
{
Links lnk = links.Current;
if (lnk.rel.ToLower().Trim().Equals("approval_url"))
{
//saving the payapalredirect URL to which user will be redirected for payment
paypalRedirectUrl = lnk.href;
}
}
// saving the paymentID in the key guid
Session.Add(guid, createdPayment.id);
return(Redirect(paypalRedirectUrl));
}
else
{
// This section is executed when we have received all the payments parameters
// from the previous call to the function Create
// Executing a payment
var guid = Request.Params["guid"];
var executedPayment = ExecutePayment(apiContext, payerId, Session[guid] as string);
if (executedPayment.state.ToLower() != "approved")
{
return(View("Failure"));
}
}
}
catch (Exception ex)
{
Logger.Log("Error" + ex.Message);
return(View("Failure"));
}
var payment = new payment
{
TransactionId = TransactionId,
AspNetUser = clubMembership.AspNetUser,
clubID = clubMembership.ClubId,
userID = clubMembership.UserId,
amount = membershipOption.Price,
payment_type = "membership",
payment_time = System.DateTime.Now
};
// after payment success, add this member to the club as a new memebr
ClubMembership CM = db.ClubMemberships.Add(clubMembership);
db.payments.Add(payment);
db.SaveChanges();
return(RedirectToAction("Success", new { clubId = CM.ClubId, clubMembershipId = CM.Id }));
}