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(); }