public async Task ExecuteAsync(CreateStudyRoomCommand message, CancellationToken token)
{
var userTutor = await _userRepository.LoadAsync(message.TutorId, token);
if (userTutor.Tutor?.State != ItemState.Ok)
{
throw new InvalidOperationException("user is not a tutor");
}
var student = await _userRepository.LoadAsync(message.StudentId, token);
var chatRoomIdentifier = ChatRoom.BuildChatRoomIdentifier(new[] { userTutor.Id, student.Id });
var chatRoom = await _chatRoomRepository.GetChatRoomAsync(chatRoomIdentifier, token);
if (chatRoom.Messages.Count == 0)
{
throw new InvalidOperationException("no active conversation");
}
var url = await _googleDocument.CreateOnlineDocAsync(chatRoomIdentifier, token);
userTutor.AddFollower(student);
var studyRoom = new StudyRoom(userTutor.Tutor, student, url);
await _studyRoomRepository.AddAsync(studyRoom, token);
}
public async Task ExecuteAsync(SendChatTextMessageCommand message, CancellationToken token)
{
//var users = message.ToUsersId.ToList();
//users.Add(message.UserSendingId);
var users = new[] { message.ToUsersId, message.UserSendingId };
var chatRoom = await _chatRoomRepository.GetChatRoomAsync(users, token);
if (chatRoom == null)
{
var userSending = await _userRepository.LoadAsync(message.UserSendingId, token);
var userReceiving = await _userRepository.LoadAsync(message.ToUsersId, token);
if (userReceiving.Tutor == null)
{
throw new ArgumentException("sending a message not to tutor");
}
chatRoom = new ChatRoom(new List <User>()
{
userSending, userReceiving
});
await _chatRoomRepository.AddAsync(chatRoom, token);
}
var user = _userRepository.Load(message.UserSendingId);
var chatMessage = new ChatTextMessage(user, message.Message, chatRoom);
chatRoom.AddMessage(chatMessage);
await _chatRoomRepository.UpdateAsync(chatRoom, token);
await _chatMessageRepository.AddAsync(chatMessage, token); // need this in order to get id from nhibernate
}
public async Task ExecuteAsync(UpdateUserImageCommand message, CancellationToken token)
{
var user = await _userRepository.LoadAsync(message.UserId, token);
user.UpdateUserImage(message.ImagePath, message.FileName);
await _userRepository.UpdateAsync(user, token);
}
public async Task ExecuteAsync(SuspendUserCommand message, CancellationToken token)
{
var user = await _userRepository.LoadAsync(message.Id, token);
user.SuspendUser(message.LockoutEnd, message.Reason);
await _userRepository.UpdateAsync(user, token);
}
public async Task ExecuteAsync(RequestTutorCommand message, CancellationToken token)
{
Tutor?tutor = null;
if (message.TutorId.HasValue)
{
if (message.UserId == message.TutorId.Value)
{
throw new ArgumentException("You cannot request tutor to yourself");
}
tutor = await _tutorRepository.LoadAsync(message.TutorId.Value, token);
}
var user = await _userRepository.LoadAsync(message.UserId, token);
var lead = new Lead(message.Course, message.LeadText,
message.Referer, user,
tutor, message.UtmSource);
await _leadRepository.AddAsync(lead, token);
var tutorsIds = new List <long>();
if (message.MoreTutors)
{
var needToSendToMoreTutors = await _leadRepository.NeedToSendMoreTutorsAsync(message.UserId, token);
if (needToSendToMoreTutors)
{
var t = await _tutorRepository.GetTutorsByCourseAsync(message.Course, message.UserId, user.Country,
token);
tutorsIds.AddRange(t);
}
}
if (tutor != null)
{
tutorsIds.Add(tutor.Id);
}
foreach (var userId in tutorsIds.Distinct())
{
var users = new[] { userId, message.UserId };
var chatRoom = await _chatRoomRepository.GetOrAddChatRoomAsync(users, token);
if (chatRoom.Extra == null)
{
chatRoom.Extra = new ChatRoomAdmin(chatRoom);
}
chatRoom.Extra.Lead = lead;
await _chatRoomRepository.UpdateAsync(chatRoom, token);
var chatMessage = new ChatTextMessage(user, message.ChatText, chatRoom);
chatRoom.AddMessage(chatMessage);
await _chatRoomRepository.UpdateAsync(chatRoom, token);
await _chatMessageRepository.AddAsync(chatMessage, token);
}
}
public async Task ExecuteAsync(PaymentCommand message, CancellationToken token)
{
var session = await _studyRoomSessionRepository.LoadAsync(message.StudyRoomSessionId, token);
var tutor = await _tutorRepository.LoadAsync(message.TutorId, token);
var user = await _userRepository.LoadAsync(message.UserId, token);
var receipt = $"Payed in {DateTime.UtcNow}";
if (message.StudentPay != 0)
{
var response = await _payment.TransferPaymentAsync(tutor.SellerKey,
user.BuyerPayment.PaymentKey, message.StudentPay, token);
receipt = response.PaymeSaleId;
}
if (message.SpitballPay != 0)
{
await _payment.TransferPaymentAsync(tutor.SellerKey,
message.SpitballBuyerKey, message.SpitballPay, token);
}
//session.SetReceipt(receipt);
//var payme = new Payme(message.StudentPay, message.SpitballPay);
//session.SetPyment(payme);
session.SetReceiptAndAdminDate(receipt, message.AdminDuration);
user.UseCoupon(tutor);
//SessionTransaction.MakerTransaction(user, tutor, session);
await _studyRoomSessionRepository.UpdateAsync(session, token);
}
public async Task ExecuteAsync(ChangeOnlineStatusCommand message, CancellationToken token)
{
var user = await _userRepository.LoadAsync(message.UserId, token);
user.ChangeOnlineStatus(message.Status);
await _userRepository.UpdateAsync(user, token);
}
public async Task ExecuteAsync(ChangeCountryCommand message, CancellationToken token)
{
var user = await _userRepository.LoadAsync(message.Id, token);
user.ChangeCountryAdmin(message.Country.ToUpperInvariant());
await _userRepository.UpdateAsync(user, token);
}
public async Task ExecuteAsync(TransferMoneyToPointsCommand message, CancellationToken token)
{
var user = await _userRepository.LoadAsync(message.UserId, token);
var t = new BuyPointsTransaction(message.Amount, message.PayPalTransactionId);
user.MakeTransaction(t);
await _userRepository.UpdateAsync(user, token);
}
public async Task ExecuteAsync(UserRemoveCourseCommand message, CancellationToken token)
{
var user = await _userRepository.LoadAsync(message.UserId, token);
var course = await _courseRepository.LoadAsync(message.Name, token);
user.RemoveCourse(course);
await _userRepository.UpdateAsync(user, token);
}
public async Task ExecuteAsync(BecomeTutorCommand message, CancellationToken token)
{
var user = await _userRepository.LoadAsync(message.UserId, token);
if (user.Tutor != null)
{
throw new ArgumentException("user is already a tutor");
}
user.BecomeTutor(message.Bio, message.Price, message.Description, message.FirstName, message.LastName);
await _tutorRepository.AddAsync(user.Tutor, token);
await _userRepository.UpdateAsync(user, token);
}
public async Task ExecuteAsync(CashOutCommand message, CancellationToken token)
{
var balance = await _userRepository.UserBalanceAsync(message.UserId, token);
if (balance < 1000)
{
throw new InvalidOperationException("user doesn't have enough money");
}
var user = await _userRepository.LoadAsync(message.UserId, token);
user.CashOutMoney(/*message.Amount*/);
await _userRepository.UpdateAsync(user, token);
}
public async Task ExecuteAsync(UpdateUserBalanceCommand message, CancellationToken token)
{
foreach (var id in message.UsersIds)
{
//TODO: we can do it better
var user = await _userRepository.LoadAsync(id, token);
var balance = await _transactionRepository.GetBalanceAsync(id, token);
var score = (int)(await _transactionRepository.GetUserScoreAsync(id, token));
user.UpdateUserBalance(balance, score);
await _userRepository.UpdateAsync(user, token);
}
}
public async Task ExecuteAsync(AddTutorReviewCommand message, CancellationToken token)
{
var studyRoom = await _studyRoomRepository.LoadAsync(message.RoomId, token);
var tutor = studyRoom.Tutor;
if (studyRoom.Users.Any(a => a.User.Id == message.UserId))
{
var user = await _regularUserRepository.LoadAsync(message.UserId, token);
tutor.AddReview(message.Review, message.Rate, user);
}
else
{
throw new InvalidOperationException();
}
}
public async Task ExecuteAsync(AddTutorCalendarEventCommand message, CancellationToken token)
{
//TODO : need to check universal time in all the process in here
//TODO : need to check only one hour is booked
//TODO : need to check if user have payment detail
var tutor = await _tutorRepository.LoadAsync(message.TutorId, token);
if (!tutor.TutorHours.Any(a => a.AvailabilitySlot.Day == message.From.DayOfWeek &&
a.AvailabilitySlot.From <= message.From.TimeOfDay &&
message.To.TimeOfDay <= a.AvailabilitySlot.To))
{
throw new ArgumentException("Slot is booked");
}
// Tutor hours
var appointments = await _calendarService.ReadCalendarEventsAsync(tutor.Id, tutor.Calendars.Select(s => s.Calendar.GoogleId), message.From.AddHours(-1), message.To.AddHours(1), token);
if (appointments.Any(a =>
{
if (IsBetween(message.From, a.From, a.To))
{
return(true);
}
if (IsBetween(message.To, a.From, a.To))
{
return(true);
}
return(false);
}))
{
throw new ArgumentException("Google Slot is booked");
}
var user = await _userRepository.LoadAsync(message.UserId, token);
var googleTokens = await _googleTokenRepository.GetAsync(message.TutorId.ToString(), token);
await _calendarService.BookCalendarEventAsync(tutor.User, user, googleTokens,
message.From, message.To, token);
}
public async Task ExecuteAsync(CreateQuestionCommand message, CancellationToken token)
{
var user = await _userRepository.LoadAsync(message.UserId, token);
if (await _questionRepository.GetSimilarQuestionAsync(message.Text, token))
{
throw new DuplicateRowException();
}
var course = await _courseRepository.LoadAsync(message.Course, token);
await _courseRepository.UpdateAsync(course, token);
var question = new Question(
message.Text,
user, course, user.University);
//await _userRepository.UpdateAsync(user, token);
await _questionRepository.AddAsync(question, token);
}
public async Task ExecuteAsync(ApplyCouponCommand message, CancellationToken token)
{
var coupon = await _couponRepository.GetCouponAsync(message.Coupon, token);
var tutor = await _tutorRepository.LoadAsync(message.TutorId, token);
if (coupon is null)
{
throw new ArgumentException("invalid coupon");
}
if (coupon.Tutor != null && coupon.Tutor.Id != message.TutorId)
{
throw new ArgumentException("invalid coupon");
}
var user = await _userRepository.LoadAsync(message.UserId, token);
user.ApplyCoupon(coupon, tutor);
var tutorPrice = tutor.Price.Price;
message.NewPrice = Coupon.CalculatePrice(coupon.CouponType, tutorPrice, coupon.Value);
}
public async Task ExecuteAsync(ConfirmPaymentCommand message, CancellationToken token)
{
var user = await _userRepository.LoadAsync(message.UserId, token);
user.CreditCardReceived();
}
public async Task ExecuteAsync(AddBuyerTokenCommand message, CancellationToken token)
{
var user = await _userRepository.LoadAsync(message.UserId, token);
user.AddPayment(message.Token, message.Expiration, message.BuyerCardMask);
}
public async Task ExecuteAsync(DeleteUserPaymentCommand command, CancellationToken token)
{
var user = await _userRepository.LoadAsync(command.UserId, token);
user.DeleteUserPayment();
}
