public CourseSubscription UpdateCourseSubscription(CourseSubscription subscription)
{
unitOfWork.CourseSubscriptions.Update(subscription);
unitOfWork.Save();
return(subscription);
}
public SubscriptionStatus GetSubscriptionStatus(string username, int courseId)
{
User user = _users.All().FirstOrDefault(x => x.Username == username);
if (user == null)
{
throw new UserNotFoundException(username);
}
Course course = _courses.GetById(courseId);
if (course == null)
{
throw new CourseNotFoundException(courseId);
}
CourseSubscription subscription = _courseSubscriptions.All().FirstOrDefault(x => x.UserId == user.Id && x.CourseId == courseId);
if (subscription != null)
{
return(subscription.Status);
}
return(SubscriptionStatus.None);
}
public SubscriptionStatus JoinCourse(string username, int courseId)
{
User user = _usersService.GetByUsername(username);
Course course = _courses.GetById(courseId);
if (user == null)
{
throw new UserNotFoundException(username);
}
if (course == null)
{
throw new CourseNotFoundException(courseId);
}
CourseSubscription subscription = _courseSubscriptions.All().FirstOrDefault(x => x.UserId == user.Id && x.CourseId == courseId);
if (subscription == null)
{
bool isPaidCourse = _coursesService.IsPaidCourse(course);
subscription = new CourseSubscription
{
UserId = user.Id,
CourseId = courseId,
RequestedDate = DateTime.Now
};
if (isPaidCourse)
{
subscription.Status = SubscriptionStatus.AwaitingPayment;
subscription.SubscriptionType = SubscriptionType.Paid;
subscription.Order = _ordersService.Generate(course, user);
}
else
{
subscription.Status = SubscriptionStatus.Active;
subscription.SubscriptionType = SubscriptionType.Free;
subscription.ApprovedDate = DateTime.Now;
}
_courseSubscriptions.Add(subscription);
//TODO implement proper Unit of Work
_courseSubscriptions.SaveChanges();
string courseUrl = _routeProvider.GetCourseRoute(subscription.CourseId);
string coursePictureUrl = _routeProvider.GetCoursePictureRoute(subscription.CourseId);
if (isPaidCourse)
{
_messageService.SendPaidCourseSignUpMessage(user, course, subscription, courseUrl, coursePictureUrl);
}
else
{
_messageService.SendFreeCourseSignUpMessage(user, course, courseUrl, coursePictureUrl);
}
}
return(subscription.Status);
}
public async Task <ActionResult> DeleteConfirmed(int subscriptionId, int courseId)
{
CourseSubscription courseSubscription = await GetCourseSubscription(subscriptionId, courseId);
db.CourseSubscriptions.Remove(courseSubscription);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Create([Bind(Include = "CourseId,SubscriptionId")] CourseSubscription courseSubscription)
{
if (ModelState.IsValid)
{
db.CourseSubscriptions.Add(courseSubscription);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(courseSubscription));
}
public void SendPaidCourseSignUpMessage(User user, Course course, CourseSubscription subscription, string courseUrl, string coursePictureUrl)
{
MessageTemplate template = _templateProvider.GetPaidCourseSignUpTemplate();
template.Body = template.Body.Replace("{{firstName}}", user.FirstName);
template.Body = template.Body.Replace("{{courseName}}", course.Title);
template.Body = template.Body.Replace("{{courseShortDescription}}", course.Description);
template.Body = template.Body.Replace("{{coursePrice}}", course.Price?.ToString());
template.Body = template.Body.Replace("/{{courseUrl}}", courseUrl);
template.Body = template.Body.Replace("/{{courseImageUrl}}", coursePictureUrl);
template.Body = template.Body.Replace("{{subscriptionNumber}}", subscription.Id.ToString());
_emailService.SendMail(user.Username, template.Subject, template.Body);
}
public async Task <ActionResult> Edit([Bind(Include = "CourseId,SubscriptionId,OldCourseId,OldSubscriptionId")] CourseSubscription courseSubscription)
{
if (ModelState.IsValid)
{
var canChange = await courseSubscription.CanChange(db);
if (canChange)
{
await courseSubscription.Change(db);
}
return(RedirectToAction("Index"));
}
return(View(courseSubscription));
}
public static async Task <bool> CanChange(
this CourseSubscription courseSubscriptions,
ApplicationDbContext db)
{
var oldCS = await db.CourseSubscriptions.CountAsync(sp =>
sp.CourseId.Equals(courseSubscriptions.OldCourseId) &&
sp.SubscriptionId.Equals(courseSubscriptions.OldSubscriptionId));
var newCS = await db.CourseSubscriptions.CountAsync(sp =>
sp.CourseId.Equals(courseSubscriptions.CourseId) &&
sp.SubscriptionId.Equals(courseSubscriptions.SubscriptionId));
return(oldCS.Equals(1) && newCS.Equals(0));
}
// GET: Admin/CourseSubscription/Edit/5
public async Task <ActionResult> Edit(int?subscriptionId, int?courseId)
{
if (subscriptionId == null || courseId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CourseSubscription courseSubscription = await GetCourseSubscription(subscriptionId, courseId);
if (courseSubscription == null)
{
return(HttpNotFound());
}
return(View(await courseSubscription.Convert(db)));
}
public ActionResult AddPayment(int subscriptionId)
{
CourseSubscription subscription = _subscriptions.AllIncluding(x => x.Course).FirstOrDefault(x => x.Id == subscriptionId);
if (subscription == null)
{
return(HttpNotFound());
}
ViewBag.SubscriptionName = subscription.Course.Title;
return(View(new PaymentEditViewModel {
SubscriptionId = subscriptionId
}));
}
public CourseSubscriptionDTO ConvertToCourseSubscriptionDTO(CourseSubscription subscription)
{
if (subscription != null)
{
return(new CourseSubscriptionDTO
{
Id = subscription.Id,
Rating = subscription.Rating,
UserLogin = subscription.User?.UserName,
CourseId = subscription.CourseId
});
}
return(null);
}
public static async Task <CourseSubscriptionModel> Convert(
this CourseSubscription courseSubscription,
ApplicationDbContext db, bool addListData = true)
{
var model = new CourseSubscriptionModel
{
SubscriptionId = courseSubscription.SubscriptionId,
CourseId = courseSubscription.CourseId,
Subscriptions = addListData ? await db.Subscriptions.ToListAsync() : null,
courses = addListData ? await db.Courses.ToListAsync() : null,
SubscriptionTitle = (await db.Subscriptions.FirstOrDefaultAsync(s =>
s.Id.Equals(courseSubscription.SubscriptionId))).Title,
CourseTitle = (await db.Courses.FirstOrDefaultAsync(p =>
p.Id.Equals(courseSubscription.CourseId))).Title
};
return(model);
}
public ActionResult AwaitingPayment(string courseNiceUrl)
{
Course course = _coursesContent.GetCourseByNiceUrl(courseNiceUrl);
string username = User.Identity.Name;
CourseSubscription subscription = _subscriptions.GetSubscription(username, course.Id);
if (subscription.Status != SubscriptionStatus.AwaitingPayment)
{
return(Redirect("/"));
}
AwaitingPaymentViewModel viewModel = new AwaitingPaymentViewModel
{
CourseName = course.Title,
SubscriptionId = subscription.Id,
CoursePrice = course.Price
};
return(View(viewModel));
}
public CourseSubscription CreateCourseSubscription(string userLogin, int courseId)
{
var subscription = unitOfWork.CourseSubscriptions.GetAll()
.FirstOrDefault(x => x.User.UserName == userLogin &&
x.CourseId == courseId);
if (subscription == null)
{
var course = unitOfWork.Courses.Get(courseId);
subscription = new CourseSubscription
{
Rating = -1,
User = unitOfWork.Users.FindByName(userLogin),
Course = course
};
unitOfWork.CourseSubscriptions.Create(subscription);
unitOfWork.Save();
}
return(subscription);
}
public void AddPayment(Payment payment)
{
_payments.Add(payment);
//TODO UoW
_payments.SaveChanges();
CourseSubscription subscription = _courseSubscriptions.GetById(payment.SubscriptionId);
subscription.ApprovedDate = DateTime.Now;
subscription.Status = SubscriptionStatus.Active;
var order = subscription.Order;
order.Payment = payment;
order.Status = OrderStatusType.Completed;
_courseSubscriptions.Update(subscription);
//TODO implement proper UoW pattern
_courseSubscriptions.SaveChanges();
string courseUrl = _routeProvider.GetCourseRoute(subscription.CourseId);
string coursePictureUrl = _routeProvider.GetCoursePictureRoute(subscription.CourseId);
_messageService.SendPaymentApprovedMessage(subscription.User, subscription.Course, payment, courseUrl, coursePictureUrl);
}
public static async Task Change(
this CourseSubscription courseSubscriptions,
ApplicationDbContext db)
{
var oldCourseSubscription = await db.CourseSubscriptions.FirstOrDefaultAsync(
sp => sp.CourseId.Equals(courseSubscriptions.OldCourseId) &&
sp.SubscriptionId.Equals(courseSubscriptions.OldSubscriptionId));
var newCourseSubscription = await db.CourseSubscriptions.FirstOrDefaultAsync(
sp => sp.CourseId.Equals(courseSubscriptions.CourseId) &&
sp.SubscriptionId.Equals(courseSubscriptions.SubscriptionId));
if (oldCourseSubscription != null && newCourseSubscription == null)
{
newCourseSubscription = new CourseSubscription
{
SubscriptionId = courseSubscriptions.SubscriptionId,
CourseId = courseSubscriptions.CourseId
};
using (var transaction = new TransactionScope(
TransactionScopeAsyncFlowOption.Enabled))
{
try
{
db.CourseSubscriptions.Remove(oldCourseSubscription);
db.CourseSubscriptions.Add(newCourseSubscription);
await db.SaveChangesAsync();
transaction.Complete();
}
catch { transaction.Dispose(); }
}
}
}
public void SendPaidCourseSignUpMessage(User user, Course course, CourseSubscription subscription, string courseUrl, string coursePictureUrl)
{
_taskRunner.Run <IMessageService>(x => x.SendPaidCourseSignUpMessage(user, course, subscription, courseUrl, coursePictureUrl));
}
