public async Task Push(string message, NotificationType type = NotificationType.Other)
{
var notification = Notification.Create(message, httpContextReader.CurrentUserId, type);
database.NotificationRepository.Add(notification);
if (await database.Complete())
{
await hubManager.Invoke(SignalrActions.ON_NOTIFICATION_SENT, httpContextReader.CurrentUserId,
mapper.Map <NotificationDto>(notification));
}
}
public async Task <AddReportSubscriberResponse> Handle(AddReportSubscriberRequest request,
CancellationToken cancellationToken)
{
var report =
await reportValidationHub.ValidateAndReturnReport(request.ReportId, ReportPermission.AddComment)
?? throw new NoPermissionsException(ErrorMessages.NotAllowedMessage);
var addedReportSubscriber = await reportSubscriberService.AddSubscriber(report, request.UserId) ??
throw new CrudException("Adding report subscriber failed");
if (ReportStatusTypeSmartEnum.FromValue(report.Status)
.ShouldBeOpened(report, httpContextReader.CurrentUserId))
{
await reportManager.ChangeStatus(ReportStatusType.Opened, report);
}
var notification = await notifier.Push(
$"You were added to subscribers in report: {report.Subject}",
request.UserId);
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, request.UserId,
mapper.Map <NotificationDto>(notification));
return((AddReportSubscriberResponse) new AddReportSubscriberResponse
{
ReportSubscriber = mapper.Map <ReportSubscriberDto>(addedReportSubscriber)
}.LogInformation(
$"Assignee #{httpContextReader.CurrentUserId} has added subscriber #{request.UserId} in report #{report.Id}"));
}
public async Task <MoveReportAssignmentResponse> Handle(MoveReportAssignmentRequest request,
CancellationToken cancellationToken)
{
var report =
await reportValidationHub.ValidateAndReturnReport(request.ReportId, ReportPermission.MoveAssignment)
?? throw new NoPermissionsException(ErrorMessages.NotAllowedMessage);
if (!(await reportManager.GetReportsAllowedAssignees((ReportCategoryType)report.CategoryType,
isPrivate: report.Private)).Any(a => a.Id == request.NewAssigneeId))
{
throw new NoPermissionsException(ErrorMessages.NotAllowedMessage);
}
if (await reportManager.MoveReportAssignment(report, request.NewAssigneeId))
{
var membersGroup = new List <int> {
report.CreatorId, request.NewAssigneeId
};
var notifications = await notifier.PushToGroup(
$"Report {report.Subject} assignment has been moved to another admin",
membersGroup);
foreach (var memberId in membersGroup)
{
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, memberId,
mapper.Map <IEnumerable <NotificationDto> >(notifications));
}
return((MoveReportAssignmentResponse) new MoveReportAssignmentResponse().LogInformation(
$"Assignee #{httpContextReader.CurrentUserId} move report #{report.Id} assignment to user #{request.NewAssigneeId}"));
}
throw new CrudException("Toggling private status of report failed");
}
public async Task <SetOrderApprovalStateResponse> Handle(SetOrderApprovalStateRequest request,
CancellationToken cancellationToken)
{
var hasOrderReviewed =
await orderService.SetOrderApprovalState(request.OrderId, request.ApprovalState, request.AdminNote);
if (!hasOrderReviewed.IsSucceeded)
{
throw new PremiumOperationException("Setting approval state of order failed");
}
var notification = await notifier.Push(
$"Approval state of order #{request.OrderId} has been change to {Enum.GetName(request.ApprovalState)}",
hasOrderReviewed.UserId);
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, hasOrderReviewed.UserId,
mapper.Map <NotificationDto>(notification));
//TODO: Call LUA
return((SetOrderApprovalStateResponse) new SetOrderApprovalStateResponse
{
CurrentApprovalState = request.ApprovalState
}
.LogInformation(
$"Admin #{httpContextReader.CurrentUserId} set order #{request.OrderId} approval state to: {(int) request.ApprovalState}"));
}
public async Task <ReceiveFriendResponse> Handle(ReceiveFriendRequest request,
CancellationToken cancellationToken)
{
var receiveResult =
await friendService.Receive(request.SenderId, request.RecipientId, accepted : request.Accepted);
var friendUpdated = receiveResult?.Friend != null?mapper.Map <FriendDto>(receiveResult.Friend) : null;
string currentUserId = httpContextReader.CurrentUserId;
if (receiveResult != null)
{
await hubManager.Invoke(SignalrActions.ON_FRIEND_RECEIVED,
currentUserId == request.SenderId?request.RecipientId : request.SenderId, request);
if (request.Accepted)
{
await notifier.Push(currentUserId == friendUpdated.SenderId
?NotificationMessages.FriendAcceptedNotification(friendUpdated.RecipientName)
: NotificationMessages.FriendAcceptedNotification(friendUpdated.SenderName),
currentUserId == friendUpdated.SenderId
?friendUpdated.RecipientId
: friendUpdated.SenderId,
NotificationType.FriendAccepted);
}
return(new ReceiveFriendResponse
{
FriendAccepted = receiveResult.FriendAccepted, Friend = friendUpdated
});
}
throw new CrudException("Friend invite has not been accepted");
}
public async Task <ArchiveReportResponse> Handle(ArchiveReportRequest request,
CancellationToken cancellationToken)
{
var report =
await reportValidationHub.ValidateAndReturnReport(request.ReportId, ReportPermission.ArchiveReport)
?? throw new NoPermissionsException(ErrorMessages.NotAllowedMessage);
if (await reportManager.ArchiveReport(report))
{
var membersGroup =
ReportManagerUtils.GenerateReportMembersGroup(report, httpContextReader.CurrentUserId);
var notifications = await notifier.PushToGroup(
$"Report {report.Subject} has been archived",
membersGroup);
foreach (var memberId in membersGroup)
{
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, memberId,
mapper.Map <IEnumerable <NotificationDto> >(notifications));
}
return((ArchiveReportResponse) new ArchiveReportResponse().LogInformation(
$"Report #{report.Id} has been archived"));
}
throw new CrudException("Archiving report failed");
}
public async Task <BlockAccountResponse> Handle(BlockAccountRequest request, CancellationToken cancellationToken)
{
bool isBlocked = await adminService.BlockAccount(request.UserId);
await hubManager.Invoke(SignalrActions.REFRESH_USER_DATA, request.UserId);
return(new BlockAccountResponse {
IsBlocked = isBlocked
});
}
public async Task <DeleteMessageResponse> Handle(DeleteMessageRequest request, CancellationToken cancellationToken)
{
if (await messenger.Delete(request.MessageId))
{
await hubManager.Invoke(SignalrActions.ON_MESSAGE_DELETED, request.RecipientId, request.MessageId);
return(new DeleteMessageResponse());
}
throw new CrudException("Message has not been deleted");
}
public async Task <DeleteFriendResponse> Handle(DeleteFriendRequest request, CancellationToken cancellationToken)
{
if (await friendService.DeleteFriend(request.FriendId))
{
await hubManager.Invoke(SignalrActions.ON_FRIEND_DELETED, request.FriendId,
httpContextReader.CurrentUserId);
return(new DeleteFriendResponse());
}
throw new CrudException("Friend has not been deleted");
}
public async Task <RevokeRoleResponse> Handle(RevokeRoleRequest request, CancellationToken cancellationToken)
{
if (await adminService.RevokeRole(request.UserId, request.Role))
{
await notifier.Push(NotificationMessages.AdminRevokedNotification, request.UserId, NotificationType.AdminRevoked);
await hubManager.Invoke(SignalrActions.REFRESH_USER_DATA, request.UserId);
return(new RevokeRoleResponse());
}
throw new AdminActionException("Role has not been revoked");
}
public async Task <PurchaseOrderResponse> Handle(PurchaseOrderRequest request, CancellationToken cancellationToken)
{
if (!await balanceValidationService.HasEnoughFunds(httpContextReader.CurrentUserId, request.TotalAmount))
{
throw new PaymentException("Insufficient funds to complete transaction");
}
var order = await orderService.PurchaseOrder(request);
var orderOfferItems = order.Items.Where(i => i.Type == OrderType.Offer);
var offersData = orderOfferItems.Select(i => new { OwnerId = i.OptionalData, Amount = (decimal)i.Amount / Constants.MoneyMultiplier });
foreach (var item in orderOfferItems)
{
var notification = await notifier.Push(NotificationMessages.OfferBoughtMessage(order.User.UserName, item.ProductName), item.OptionalData);
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, item.OptionalData, mapper.Map <NotificationDto>(notification));
}
var premiumOrder = order.Items.FirstOrDefault(i => i.Type == OrderType.Premium);
if (premiumOrder != null && !await rolesManager.AdmitRole(RoleName.Premium, order.User))
{
throw new PaymentException("Upgrading account to premium status failed");
}
if (order != null)
{
foreach (var offerData in offersData)
{
await balanceService.AddBalance(offerData.OwnerId, offerData.Amount);
await balanceService.AddBalance(order.UserId, -offerData.Amount);
}
string token = default(string);
if (premiumOrder != null)
{
await balanceService.AddBalance(order.UserId, -(decimal)premiumOrder.Amount / Constants.MoneyMultiplier);
token = await jwtAuthorizationTokenGenerator.GenerateToken(order.User);
}
return(new PurchaseOrderResponse {
Order = mapper.Map <OrderDto>(order), Token = token
});
}
throw new PaymentException("Purchasing order failed");
}
public async Task <SendMessageResponse> Handle(SendMessageRequest request, CancellationToken cancellationToken)
{
var messageSent = await messenger.SendMessage(request.Text, request.RecipientId);
if (messageSent != null)
{
await hubManager.Invoke(SignalrActions.MESSAGE_RECEIVED, request.RecipientId, mapper.Map <MessageDto>(messageSent));
return(new SendMessageResponse {
Message = mapper.Map <MessageDto>(messageSent)
});
}
throw new CrudException("Sending message failed");
}
public async Task <FollowUserResponse> Handle(FollowUserRequest request, CancellationToken cancellationToken)
{
var(isFollowed, follow) = await userService.FollowUser(request.UserId);
if (isFollowed)
{
var notification = await notifier.Push(NotificationMessages.UserFollowMessage(follow.Follower.UserName), request.UserId);
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, request.UserId, mapper.Map <NotificationDto>(notification));
}
return(new FollowUserResponse {
IsFollowed = isFollowed, Follow = mapper.Map <UserFollowDto>(follow)
});
}
public async Task <LikeOfferResponse> Handle(LikeOfferRequest request, CancellationToken cancellationToken)
{
var(isLiked, like) = await favoritesService.LikeOffer(request.OfferId);
if (isLiked)
{
var notification = await notifier.Push(NotificationMessages.OfferFollowMessage(like.User.UserName, request.OfferId), like.Offer.OwnerId);
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, like.Offer.OwnerId, mapper.Map <NotificationDto>(notification));
}
return(new LikeOfferResponse {
IsLiked = isLiked, Like = mapper.Map <OfferLikeDto>(like)
});
}
public async Task <CleanAccountResponse> Handle(CleanAccountRequest request, CancellationToken cancellationToken)
{
if (await userManager.CleanAccount(request.UserId))
{
var notification = await notifier.Push(
$"Admin has cleaned your account",
request.UserId);
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, request.UserId,
mapper.Map <NotificationDto>(notification));
return((CleanAccountResponse) new CleanAccountResponse().LogInformation(
$"Admin #{httpContextReader.CurrentUserId} cleaned account of user #{request.UserId}"));
}
throw new CrudException($"Cleaning account #{request.UserId} failed");
}
public async Task <InviteFriendResponse> Handle(InviteFriendRequest request, CancellationToken cancellationToken)
{
var friendCreated = await friendService.Invite(request.RecipientId);
if (friendCreated != null)
{
var friendToReturn = mapper.Map <FriendDto>(friendCreated);
await hubManager.Invoke(SignalrActions.ON_FRIEND_INVITED, request.RecipientId, friendToReturn);
return(new InviteFriendResponse {
Friend = friendToReturn
});
}
throw new CrudException("Friend invite has not been sent");
}
public async Task <CreateOfferAuctionResponse> Handle(CreateOfferAuctionRequest request, CancellationToken cancellationToken)
{
var offerAuction = await auctionManager.CreateAuction(request.NewPrice, request.OfferId);
if (offerAuction != null)
{
var notification = await notifier.Push(NotificationMessages.NewOfferPriceProposedMessage(request.NewPrice, request.OfferId), offerAuction.Offer.OwnerId);
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, offerAuction.Offer.OwnerId, mapper.Map <NotificationDto>(notification));
return(new CreateOfferAuctionResponse {
OfferAuction = mapper.Map <OfferAuctionDto>(offerAuction)
});
}
throw new CrudException("Creating offer auction failed");
}
public async Task <BlockAccountResponse> Handle(BlockAccountRequest request, CancellationToken cancellationToken)
{
if (await userManager.BlockAccount(request))
{
var notification = await notifier.Push(
$"Your account has been blocked",
request.AccountId);
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, request.AccountId,
mapper.Map <NotificationDto>(notification));
return((BlockAccountResponse) new BlockAccountResponse().LogInformation(
$"Admin #{httpContextReader} has blocked user #{request.AccountId}"));
}
throw new CrudException("Blocking user account failed");
}
public async Task <AddCreditsResponse> Handle(AddCreditsRequest request, CancellationToken cancellationToken)
{
var result = await userManager.AddCredits(request.Credits, request.UserId);
var notification = await notifier.Push(
$"Account credits amount {(request.Credits > 0 ? "increased by" : "decreased by")} {Math.Abs(request.Credits)}, current balance: {result.CurrentCreditsCount}",
request.UserId);
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, request.UserId,
mapper.Map <NotificationDto>(notification));
return((AddCreditsResponse) new AddCreditsResponse {
CreditsCount = result.CurrentCreditsCount
}
.LogInformation(
$"Admin #{httpContextReader.CurrentUserId} added {request.Credits} to user #{request.UserId}"));
}
public async Task <AddOpinionResponse> Handle(AddOpinionRequest request, CancellationToken cancellationToken)
{
var opinionAdded = await opinionService.AddOpinion(request.Text, request.Rating, request.UserId);
if (opinionAdded != null)
{
var notification = await notifier.Push(NotificationMessages.NewOpinionAdded(opinionAdded.Creator.UserName), opinionAdded.UserId);
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, opinionAdded.UserId, mapper.Map <NotificationDto>(notification));
return(new AddOpinionResponse {
Opinion = mapper.Map <OpinionDto>(opinionAdded), NewRating = RatingUtils.CalculateRating(opinionAdded.User)
});
}
throw new CrudException("Adding opinion failed");
}
public async Task <ReviewRPTestResponse> Handle(ReviewRPTestRequest request, CancellationToken cancellationToken)
{
var result = await rpTestManager.ReviewRPTest(request.ApplicationId, request.Note, request.StateType);
if (result.IsSucceeded)
{
var notification = await notifier.Push(
"Status of your RP test has been changed",
result.UserId);
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, result.UserId,
mapper.Map <NotificationDto>(notification));
return((ReviewRPTestResponse) new ReviewRPTestResponse().LogInformation(
$"Reviewer #{httpContextReader.CurrentUserId} review application test #{request.ApplicationId} and set state to: {(int) request.StateType}"));
}
throw new ServerException("Processing RP test failed");
}
public async Task <AddOfferResponse> Handle(AddOfferRequest request, CancellationToken cancellationToken)
{
var createdOffer = await offerService.AddOffer(request);
if (createdOffer != null)
{
var followersIds = FollowersUtils.GetFollowersIds(createdOffer.Owner);
foreach (var followerId in followersIds)
{
var notification = await notifier.Push(NotificationMessages.NewOfferByFollowedUserAddedMessage(createdOffer.Owner.UserName), followerId);
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, followerId, mapper.Map <NotificationDto>(notification));
}
return(new AddOfferResponse {
Offer = mapper.Map <OfferDto>(createdOffer)
});
}
throw new CrudException("Adding offer failed");
}
public async Task <DenyOfferAuctionResponse> Handle(DenyOfferAuctionRequest request, CancellationToken cancellationToken)
{
var offer = await offerService.GetOffer(request.OfferId) ?? throw new EntityNotFoundException("Offer not found");
var denied = await auctionManager.DenyAuction(request.AuctionId, request.OfferId);
if (denied)
{
var followersIds = FollowersUtils.GetFollowersIds(offer.Owner);
foreach (var followerId in followersIds)
{
var notification = await notifier.Push(NotificationMessages.OfferAuctionDenied(request.OfferId), followerId);
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, followerId, mapper.Map <NotificationDto>(notification));
}
return(new DenyOfferAuctionResponse());
}
throw new CrudException("Deny offer auction failed");
}
public async Task <RemoveReportSubscriberResponse> Handle(RemoveReportSubscriberRequest request,
CancellationToken cancellationToken)
{
var report =
await reportValidationHub.ValidateAndReturnReport(request.ReportId, ReportPermission.AddComment)
?? throw new NoPermissionsException(ErrorMessages.NotAllowedMessage);
if (await reportSubscriberService.RemoveSubscriber(report, request.UserId))
{
var notification = await notifier.Push(
$"You were removed from subscribers in report: {report.Subject}",
request.UserId);
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, request.UserId,
mapper.Map <NotificationDto>(notification));
return((RemoveReportSubscriberResponse) new RemoveReportSubscriberResponse().LogInformation(
$"Assignee #{httpContextReader.CurrentUserId} has removed subscriber #{request.UserId} in report #{report.Id}"));
}
throw new CrudException("Removing report subscriber failed");
}
public async Task <ToggleBlockCharacterResponse> Handle(ToggleBlockCharacterRequest request,
CancellationToken cancellationToken)
{
var blockCharacterResult = await characterManager.ToggleBlockCharacter(request.CharacterId);
if (blockCharacterResult.IsSucceeded)
{
var notification = await notifier.Push(
$"Character {blockCharacterResult.CharacterName} has been blocked",
blockCharacterResult.AccountId);
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, blockCharacterResult.AccountId,
mapper.Map <NotificationDto>(notification));
return((ToggleBlockCharacterResponse) new ToggleBlockCharacterResponse
{
IsBlocked = blockCharacterResult.IsBlocked
}.LogInformation(
$"Admin #{httpContextReader.CurrentUserId} blocked character #{request.CharacterId}"));
}
throw new CrudException("Toggling block character status failed");
}
public async Task <AddReportCommentResponse> Handle(AddReportCommentRequest request,
CancellationToken cancellationToken)
{
var report =
await reportValidationHub.ValidateAndReturnReport(request.ReportId, ReportPermission.AddComment)
?? throw new NoPermissionsException(ErrorMessages.NotAllowedMessage);
var addedReportComment = await reportCommentService.AddComment(request with {
IsPrivate = report.Private
})
?? throw new CrudException("Adding report comment failed");
if (ReportStatusTypeSmartEnum.FromValue(report.Status)
.ShouldBeOpened(report, addedReportComment.UserId))
{
await reportManager.ChangeStatus(ReportStatusType.Opened, report);
}
var membersGroup = ReportManagerUtils.GenerateReportMembersGroup(report, addedReportComment.UserId);
var notifications = await notifier.PushToGroup(
$"Someone responded to your report: {report.Subject}", membersGroup);
foreach (var memberId in membersGroup)
{
await hubManager.Invoke(SignalrActions.NOTIFICATION_RECEIVED, memberId,
mapper.Map <IEnumerable <NotificationDto> >(notifications));
}
return((AddReportCommentResponse) new AddReportCommentResponse
{
ReportComment = mapper.Map <ReportCommentDto>(addedReportComment)
}
.LogInformation(
$"Member #{addedReportComment.UserId} of report #{report.Id} added comment #{addedReportComment.Id}"));
}