public async Task<ActionResult> Payment(int id, string stripeToken, string stripeEmail)
{
var selectQuery = await _orderService.Query(x => x.ID == id).Include(x => x.Listing).SelectAsync();
// Check if order exists
var order = selectQuery.FirstOrDefault();
if (order == null)
return new HttpNotFoundResult();
var stripeConnectQuery = await _stripConnectService.Query(x => x.UserID == order.UserProvider).SelectAsync();
var stripeConnect = stripeConnectQuery.FirstOrDefault();
if (stripeConnect == null)
return new HttpNotFoundResult();
//https://stripe.com/docs/checkout
var charge = new StripeChargeCreateOptions();
// always set these properties
charge.Amount = order.PriceInCents;
charge.Currency = CacheHelper.Settings.Currency;
charge.Source = new StripeSourceOptions()
{
TokenId = stripeToken
};
// set booking fee
var bookingFee = (int)Math.Round(CacheHelper.Settings.TransactionFeePercent * order.PriceInCents);
if (bookingFee < CacheHelper.Settings.TransactionMinimumFee * 100)
bookingFee = (int)(CacheHelper.Settings.TransactionMinimumFee * 100);
charge.ApplicationFee = bookingFee;
charge.Capture = false;
charge.Description = order.Description;
charge.Destination = stripeConnect.stripe_user_id;
var chargeService = new StripeChargeService(CacheHelper.GetSettingDictionary("StripeApiKey").Value);
StripeCharge stripeCharge = chargeService.Create(charge);
// Update order status
order.Status = (int)Enum_OrderStatus.Pending;
order.PaymentPlugin = StripePlugin.PluginName;
_orderService.Update(order);
// Save transaction
var transaction = new StripeTransaction()
{
OrderID = id,
ChargeID = stripeCharge.Id,
StripeEmail = stripeEmail,
StripeToken = stripeToken,
Created = DateTime.Now,
LastUpdated = DateTime.Now,
FailureCode = stripeCharge.FailureCode,
FailureMessage = stripeCharge.FailureMessage,
ObjectState = Repository.Pattern.Infrastructure.ObjectState.Added
};
_transactionService.Insert(transaction);
await _unitOfWorkAsync.SaveChangesAsync();
await _unitOfWorkAsyncStripe.SaveChangesAsync();
ClearCache();
// Payment succeeded
if (string.IsNullOrEmpty(stripeCharge.FailureCode))
{
// Send message to the user
var message = new MessageSendModel()
{
UserFrom = order.UserReceiver,
UserTo = order.UserProvider,
Subject = order.Listing.Title,
ListingID = order.ListingID,
Body = HttpContext.ParseAndTranslate(string.Format(
"[[[Order Requested - %0 - Total Price %1 %2|||{0}|||{1}|||{2}]]]",
order.Description,
order.Price,
order.Currency))
};
await MessageHelper.SendMessage(message);
TempData[TempDataKeys.UserMessage] = "[[[Thanks for your order! You payment will not be charged until the provider accepted your request.]]]";
return RedirectToAction("Orders", "Payment");
}
else
{
TempData[TempDataKeys.UserMessageAlertState] = "bg-danger";
TempData[TempDataKeys.UserMessage] = stripeCharge.FailureMessage;
return RedirectToAction("Payment");
}
}
public async Task<IdentityResult> RegisterAccount(RegisterViewModel model)
{
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
RegisterDate = DateTime.Now,
RegisterIP = System.Web.HttpContext.Current.Request.GetVisitorIP(),
LastAccessDate = DateTime.Now,
LastAccessIP = System.Web.HttpContext.Current.Request.GetVisitorIP()
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
// Send Message
var roleAdministrator = await RoleManager.FindByNameAsync(BeYourMarket.Model.Enum.Enum_UserType.Administrator.ToString());
var administrator = roleAdministrator.Users.FirstOrDefault();
var message = new MessageSendModel()
{
UserFrom = administrator.UserId,
UserTo = user.Id,
Subject = HttpContext.ParseAndTranslate(string.Format("[[[Welcome to {0}!]]]", CacheHelper.Settings.Name)),
Body = HttpContext.ParseAndTranslate(string.Format("[[[Hi, Welcome to {0}! I am happy to assist you if you has any questions.]]]", CacheHelper.Settings.Name))
};
await MessageHelper.SendMessage(message);
// Send an email with this link
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var urlHelper = new UrlHelper(System.Web.HttpContext.Current.Request.RequestContext);
var callbackUrl = urlHelper.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: System.Web.HttpContext.Current.Request.Url.Scheme);
var emailTemplateQuery = await _emailTemplateService.Query(x => x.Slug.ToLower() == "signup").SelectAsync();
var emailTemplate = emailTemplateQuery.FirstOrDefault();
if (emailTemplate != null)
{
dynamic email = new Postal.Email("Email");
email.To = CacheHelper.Settings.EmailContact;
email.From = CacheHelper.Settings.EmailContact;
email.Subject = emailTemplate.Subject;
email.Body = emailTemplate.Body;
email.CallbackUrl = callbackUrl;
EmailHelper.SendEmail(email);
}
}
return result;
}
public async Task<ActionResult> OrderAction(int id, int status)
{
var orderQuery = await _orderService.Query(x => x.ID == id).Include(x => x.Listing).SelectAsync();
var order = orderQuery.FirstOrDefault();
if (order == null)
return new HttpNotFoundResult();
var currentUserId = User.Identity.GetUserId();
// Unauthorized access
if (order.UserProvider != currentUserId && order.UserReceiver != currentUserId)
return new HttpUnauthorizedResult();
var descriptor = _pluginFinder.GetPluginDescriptorBySystemName<IHookPlugin>(order.PaymentPlugin);
if (descriptor == null)
return new HttpNotFoundResult("Not found");
var controllerType = descriptor.Instance<IHookPlugin>().GetControllerType();
var controller = ContainerManager.GetConfiguredContainer().Resolve(controllerType) as IPaymentController;
string message = string.Empty;
var orderResult = controller.OrderAction(id, status, out message);
var orderStatus = (Enum_OrderStatus)status;
var orderStatusText = string.Empty;
switch (orderStatus)
{
case Enum_OrderStatus.Created:
case Enum_OrderStatus.Pending:
orderStatusText = "[[[Pending]]]";
break;
case Enum_OrderStatus.Confirmed:
orderStatusText = "[[[Confirmed]]]";
break;
case Enum_OrderStatus.Cancelled:
orderStatusText = "[[[Cancelled]]]";
break;
default:
orderStatusText = orderStatus.ToString();
break;
}
var result = new
{
Success = orderResult,
Message = message
};
if (orderResult)
{
// Send message to the user
var messageSend = new MessageSendModel()
{
UserFrom = currentUserId,
UserTo = order.UserProvider == currentUserId ? order.UserReceiver : order.UserProvider,
ListingID = order.ListingID,
Subject = order.Listing.Title,
Body = HttpContext.ParseAndTranslate(string.Format(
"[[[Order %0 - %1 - Total Price %2 %3. <a href=\"%4\">See Details</a>|||{0}|||{1}|||{2}|||{3}|||{4}]]]",
HttpContext.ParseAndTranslate(orderStatusText),
HttpContext.ParseAndTranslate(order.Description),
order.Price,
order.Currency,
Url.Action("Orders")))
};
await MessageHelper.SendMessage(messageSend);
}
TempData[TempDataKeys.UserMessage] = string.Format("[[[The order is %0.|||{0}]]]", orderStatus);
return Json(result, JsonRequestBehavior.AllowGet);
}
public async Task<ActionResult> ReviewListing(ListingReview listingReview)
{
var currentUserId = User.Identity.GetUserId();
// Check if listing review is enabled
if (!CacheHelper.Settings.ListingReviewEnabled)
{
TempData[TempDataKeys.UserMessageAlertState] = "bg-danger";
TempData[TempDataKeys.UserMessage] = "[[[Listing review is not allowed!]]]";
return RedirectToAction("Listing", "Listing", new { id = listingReview.ID });
}
// Check if users reach max review limit
var today = DateTime.Today.Date;
var reviewQuery = await _listingReviewService.Query(x => x.UserFrom == currentUserId
&& System.Data.Entity.DbFunctions.TruncateTime(x.Created) == today).SelectAsync();
var reviewCount = reviewQuery.Count();
if (reviewCount >= CacheHelper.Settings.ListingReviewMaxPerDay)
{
TempData[TempDataKeys.UserMessageAlertState] = "bg-danger";
TempData[TempDataKeys.UserMessage] = "[[[You have reach the review limits today!]]]";
return RedirectToAction("Listing", "Listing", new { id = listingReview.ID });
}
var listingQuery = await _listingService.Query(x => x.ID == listingReview.ID)
.Include(x => x.AspNetUser)
.SelectAsync();
var listing = listingQuery.FirstOrDefault();
// User cannot comment himself
if (currentUserId == listing.UserID)
{
TempData[TempDataKeys.UserMessageAlertState] = "bg-danger";
TempData[TempDataKeys.UserMessage] = "[[[You cannot review yourself!]]]";
return RedirectToAction("Listing", "Listing", new { id = listingReview.ID });
}
// update review id on the order
var review = new ListingReview()
{
UserFrom = currentUserId,
UserTo = listing.UserID,
Description = listingReview.Description,
Rating = listingReview.Rating,
Spam = false,
Active = true,
Enabled = true,
ObjectState = Repository.Pattern.Infrastructure.ObjectState.Added,
Created = DateTime.Now
};
review.ListingID = listingReview.ID;
_listingReviewService.Insert(review);
await _unitOfWorkAsync.SaveChangesAsync();
// update rating on the user
var listingReviewQuery = await _listingReviewService.Query(x => x.UserTo == listing.UserID).SelectAsync();
var rating = listingReviewQuery.Average(x => x.Rating);
var user = await UserManager.FindByIdAsync(listing.UserID);
user.Rating = rating;
await UserManager.UpdateAsync(user);
// Notify the user with the rating and comment
var message = new MessageSendModel()
{
UserFrom = review.UserFrom,
UserTo = review.UserTo,
Subject = review.Title,
Body = string.Format("{0} <span class=\"score s{1} text-xs\"></span>", review.Description, review.RatingClass),
ListingID = listingReview.ID
};
await MessageHelper.SendMessage(message);
TempData[TempDataKeys.UserMessage] = "[[[Thanks for your feedback!]]]";
return RedirectToAction("Listing", "Listing", new { id = listingReview.ID });
}
public async Task<ActionResult> Review(ListingReview listingReview)
{
var currentUserId = User.Identity.GetUserId();
var orderQuery = await _orderService.Query(x => x.ID == listingReview.OrderID)
.Include(x => x.Listing)
.SelectAsync();
var order = orderQuery.FirstOrDefault();
var userTo = order.UserProvider == currentUserId ? order.UserReceiver : order.UserProvider;
// User cannot comment himself
if (currentUserId == userTo)
{
TempData[TempDataKeys.UserMessageAlertState] = "bg-danger";
TempData[TempDataKeys.UserMessage] = "[[[You cannot review yourself!]]]";
return RedirectToAction("Orders", "Payment");
}
// check if user has right to review the order
if (order == null || (order.UserProvider != currentUserId && order.UserReceiver != currentUserId))
{
TempData[TempDataKeys.UserMessageAlertState] = "bg-danger";
TempData[TempDataKeys.UserMessage] = "[[[You cannot review the order!]]]";
return RedirectToAction("Orders", "Payment");
}
// update review id on the order
var review = new ListingReview()
{
UserFrom = currentUserId,
UserTo = userTo,
OrderID = listingReview.OrderID,
Description = listingReview.Description,
Rating = listingReview.Rating,
Spam = false,
Active = true,
Enabled = true,
ObjectState = Repository.Pattern.Infrastructure.ObjectState.Added,
Created = DateTime.Now
};
// Set listing id if it's service receiver
if (order.UserReceiver == currentUserId)
review.ListingID = order.ListingID;
_listingReviewService.Insert(review);
await _unitOfWorkAsync.SaveChangesAsync();
// update rating on the user
var listingReviewQuery = await _listingReviewService.Query(x => x.UserTo == userTo).SelectAsync();
var rating = listingReviewQuery.Average(x => x.Rating);
var user = await UserManager.FindByIdAsync(userTo);
user.Rating = rating;
await UserManager.UpdateAsync(user);
// Notify the user with the rating and comment
var message = new MessageSendModel()
{
UserFrom = review.UserFrom,
UserTo = review.UserTo,
Subject = review.Title,
Body = string.Format("{0} <span class=\"score s{1} text-xs\"></span>", review.Description, review.RatingClass),
ListingID = order.ListingID
};
await MessageHelper.SendMessage(message);
TempData[TempDataKeys.UserMessage] = "[[[Thanks for your feedback!]]]";
return RedirectToAction("Orders", "Payment");
}
public async Task<ActionResult> ContactUser(ContactUserModel model)
{
var listing = await _listingService.FindAsync(model.ListingID);
var userIdCurrent = User.Identity.GetUserId();
var user = userIdCurrent.User();
// Check if user send message to itself, which is not allowed
if (listing.UserID == userIdCurrent)
{
TempData[TempDataKeys.UserMessageAlertState] = "bg-danger";
TempData[TempDataKeys.UserMessage] = "[[[You cannot send message to yourself!]]]";
return RedirectToAction("Listing", "Listing", new { id = model.ListingID });
}
// Send message to user
var message = new MessageSendModel()
{
UserFrom = userIdCurrent,
UserTo = listing.UserID,
Subject = listing.Title,
Body = model.Message,
ListingID = listing.ID
};
await MessageHelper.SendMessage(message);
// Send email with notification
var emailTemplateQuery = await _emailTemplateService.Query(x => x.Slug.ToLower() == "privatemessage").SelectAsync();
var emailTemplate = emailTemplateQuery.Single();
dynamic email = new Postal.Email("Email");
email.To = user.Email;
email.From = CacheHelper.Settings.EmailAddress;
email.Subject = emailTemplate.Subject;
email.Body = emailTemplate.Body;
email.Message = model.Message;
EmailHelper.SendEmail(email);
TempData[TempDataKeys.UserMessage] = "[[[Message sent succesfully!]]]";
return RedirectToAction("Listing", "Listing", new { id = model.ListingID });
}
/// <summary>
/// Send Message
/// </summary>
/// <param name="userFrom"></param>
/// <param name="userTo"></param>
/// <param name="subject"></param>
/// <param name="body"></param>
/// <returns></returns>
public static async Task SendMessage(MessageSendModel messageModel)
{
var unitOfWork = ContainerManager.GetConfiguredContainer().Resolve<IUnitOfWorkAsync>();
MessageThread messageThread;
// Use message subject to find the message thread if no listing id is provided
if (!messageModel.ListingID.HasValue)
{
var messageThreadQuery = await MessageThreadService
.Query(x =>
x.Subject.Equals(messageModel.Subject, StringComparison.InvariantCultureIgnoreCase) &&
x.MessageParticipants.Any(y => y.UserID == messageModel.UserFrom) &&
x.MessageParticipants.Any(y => y.UserID == messageModel.UserTo))
.SelectAsync();
messageThread = messageThreadQuery.FirstOrDefault();
}
else
{
// Otherwise, use listing ID
var messageThreadQuery = await MessageThreadService
.Query(x => x.ListingID == messageModel.ListingID)
.SelectAsync();
messageThread = messageThreadQuery.FirstOrDefault();
}
// Create message thread if there is not one yet.
if (messageThread == null)
{
messageThread = new MessageThread()
{
Subject = messageModel.Subject,
ListingID = messageModel.ListingID,
Created = DateTime.Now,
LastUpdated = DateTime.Now,
ObjectState = Repository.Pattern.Infrastructure.ObjectState.Added
};
MessageThreadService.Insert(messageThread);
await UnitOfWorkAsync.SaveChangesAsync();
// Add message participants
MessageParticipantService.Insert(new MessageParticipant()
{
UserID = messageModel.UserFrom,
MessageThreadID = messageThread.ID,
ObjectState = Repository.Pattern.Infrastructure.ObjectState.Added
});
MessageParticipantService.Insert(new MessageParticipant()
{
UserID = messageModel.UserTo,
MessageThreadID = messageThread.ID,
ObjectState = Repository.Pattern.Infrastructure.ObjectState.Added
});
}
// Insert mail message to db
var message = new Message()
{
UserFrom = messageModel.UserFrom,
Body = messageModel.Body,
MessageThreadID = messageThread.ID,
Created = DateTime.Now,
LastUpdated = DateTime.Now,
ObjectState = Repository.Pattern.Infrastructure.ObjectState.Added
};
MessageService.Insert(message);
await UnitOfWorkAsync.SaveChangesAsync();
// Add read state of messages
MessageReadStateService.Insert(new MessageReadState()
{
MessageID = message.ID,
UserID = messageModel.UserFrom,
ReadDate = DateTime.Now,
ObjectState = Repository.Pattern.Infrastructure.ObjectState.Added
});
MessageReadStateService.Insert(new MessageReadState()
{
MessageID = message.ID,
UserID = messageModel.UserTo,
ReadDate = null,
ObjectState = Repository.Pattern.Infrastructure.ObjectState.Added
});
await UnitOfWorkAsync.SaveChangesAsync();
}
