private async Task <bool> SendNotificationUsers(PushNotification pushNotification, int?anousmentId)
        {
            List <User> allUsers = await _repository.GetAll <User>().Include(s => s.PersonSettings).ToListAsync();

            foreach (var user in allUsers)
            {
                var userLanguage = await _repository.FilterAsNoTracking <PersonOtherSetting>(x =>
                                                                                             x.UserId == user.Id).ToListAsync();

                if (user.PersonSettings.Select(x => x.SubscriptionsType).Contains(SubscriptionsType.NewMessagesNotifications))
                {
                    _repository.Create(new PersonNotification
                    {
                        UserId             = user.Id,
                        PushNotificationId = pushNotification.Id,
                        Announcement       = null,
                    });
                    var lang = userLanguage.Select(l => l.Language).FirstOrDefault();
                    await _firebaseRepository.SendIndividualNotification(new FirebaseIndividualNotificationModel
                    {
                        Description = lang == Language.English ? pushNotification.Description :
                                      pushNotification.PushNotificationTranslates.Select(n => n.Description).FirstOrDefault(),
                        Title = lang == Language.English ? pushNotification.Title :
                                pushNotification.PushNotificationTranslates.Select(n => n.Title).FirstOrDefault(),
                        NotificationType           = NotificationType.PushNotification,
                        PushNotificationActionType = pushNotification.PushNotificationActionType,
                        FromAdmin  = true,
                        SenderId   = null,
                        ReceiverId = user.Id,
                        GenericId  = anousmentId.HasValue ? anousmentId.Value : 0
                    }, false);
                }
            }
            await _repository.SaveChangesAsync();

            return(true);
        }
示例#2
0
        public async Task <MessageListModel> Send(SendMessageModel model, int userId, Language language, string deviceId)
        {
            string sentMessage;
            var    caller = await _repository.Filter <User>(u => u.Id == userId).FirstOrDefaultAsync();

            if (caller == null)
            {
                throw new Exception("caller not found");
            }
            var conversation = await _repository.Filter <Conversation>(x => x.Id == model.ConversationId)
                               .FirstOrDefaultAsync();

            if (conversation.AnnouncementCreatorId != caller.Id && conversation.QuestionerId != caller.Id)
            {
                throw new Exception(_optionsBinder.Error().NotParticipating);
            }
            if (conversation.AnnouncementCreatorConversationIsDeleted || conversation.QuestionerConversationIsDeleted)
            {
                conversation.QuestionerConversationIsDeleted          = false;
                conversation.AnnouncementCreatorConversationIsDeleted = false;
                _repository.Update(conversation);
            }

            var  body            = model.MessageText;
            var  messageBodyType = MessageBodyType.Text;
            long length          = 0;

            if (model.File != null)
            {
                messageBodyType = MessageBodyType.Image;
                body            = await _accessor.Upload(model.File, UploadType.MessageFiles, conversation.Id);

                var extension = Path.GetExtension(body);
                if (extension != ".jpg" && extension != ".jpeg" && extension != ".png")
                {
                    messageBodyType = MessageBodyType.File;
                }
                length = await _accessor.GetLength(body, UploadType.MessageFiles, conversation.Id);
            }
            int?replayValue = null;
            var receiverId  = conversation.AnnouncementCreatorId == caller.Id
              ? conversation.QuestionerId
              : conversation.AnnouncementCreatorId;
            var message = _repository.Create(new Message
            {
                ConversationId  = conversation.Id,
                MessageBodyType = messageBodyType,
                MessageText     = body,
                SenderId        = caller.Id,
                FileLength      = length,
                ReciverId       = receiverId,
                ReplayMessageId = model.ReplayMessageId.HasValue ? model.ReplayMessageId.Value : replayValue
            });
            await _repository.SaveChangesAsync();

            int unreadConversationCount = _repository.Filter <Message>(m => m.ReciverId == receiverId && !m.IsSeen).GroupBy(m => m.ConversationId).Count();
            var success = _repository.FilterAsNoTracking <PersonSetting>(x => x.UserId == receiverId).Where(x =>
                                                                                                            x.SubscriptionsType == SubscriptionsType.EnableMessageNotification).Count();
            var notify = (new MessageListModel
            {
                SenderId = caller.Id,
                FullName = message.User != null ? message.User.FullName : "User",
                Photo = message.User != null ? new ImageOptimizer
                {
                    Photo = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                                     UploadType.ProfilePhoto, message.User.ProfilePhoto, ConstValues.Width, ConstValues.Height, false, 0),
                    PhotoBlur = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                                         UploadType.ProfilePhoto, message.User.ProfilePhoto, 100, 100, true, 0)
                } : new ImageOptimizer(),
                CreatedDate = new DateTime(message.CreatedDt.Ticks),
                IsSentFromMe = false,
                MessageId = message.Id,
                MessageBodyType = messageBodyType,
                MessageText = message.MessageBodyType == MessageBodyType.Image
                    ? Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                               UploadType.MessageFiles, message.MessageText, 200, 200, false, conversation.Id) : message.MessageText,
                FileSize = length,
                FileUrl = messageBodyType == MessageBodyType.File
                    ? Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaDownload,
                                               UploadType.MessageFiles, message.MessageText, false, conversation.Id) : null,
                ReplayMessage = message.ReplayMessageId != null ? await _repository.Filter <Message>(s => s.Id == message.ReplayMessageId)
                                .Select(s => new MessageListModel
                {
                    MessageBodyType = s.MessageBodyType,
                    Photo = s.User != null ? new ImageOptimizer
                    {
                        Photo = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                                         UploadType.ProfilePhoto, s.User.ProfilePhoto, ConstValues.Width, ConstValues.Height, false, 0),
                        PhotoBlur = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                                             UploadType.ProfilePhoto, s.User.ProfilePhoto, 100, 100, true, 0)
                    } : new ImageOptimizer(),
                    SenderId = s.SenderId,
                    FullName = s.User != null ? s.User.FullName : "User",
                    MessageId = s.Id,
                    MessageText = s.MessageBodyType == MessageBodyType.Image ?
                                  Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                                           UploadType.MessageFiles, s.MessageText, 1000, 1000, false, conversation.Id) : s.MessageText,
                    CreatedDate = s.CreatedDt,
                    IsSentFromMe = s.SenderId == caller.Id,
                    FileUrl = s.MessageBodyType == MessageBodyType.File ?
                              Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaDownload,
                                                       UploadType.MessageFiles, s.MessageText, false, conversation.Id) : null,
                    FileSize = s.FileLength
                }).FirstOrDefaultAsync() : null
            });

            var ann = _repository.Filter <Announcement>(a => a.Id == model.AnnouncementId).FirstOrDefault();

            if (ann != null)
            {
                await _activityService.AddOrUpdate(ann, caller.Id, false, ActivityType.Contacted);
            }
            var notifyToString = Utilities.SerializeObject(notify);
            var isSent         = await ChatMessageHandler.SendMessageAsync(conversation.Id, caller.Id, notifyToString, deviceId);

            if (isSent)
            {
                message.IsSeen = true;
                await _repository.SaveChangesAsync();
            }
            if (!isSent)
            {
                var receiverLanguage = await _repository.Filter <PersonOtherSetting>(x => x.UserId == receiverId)
                                       .Select(x => x.Language).FirstOrDefaultAsync();

                if (receiverLanguage == Language.English)
                {
                    sentMessage = "sent you a message";
                }
                else
                {
                    sentMessage = "ارسلت لك رساله";
                }
                await BaseMessageHandler.SendMessageAsync(conversation.Id, receiverId);

                if (success > 0)
                {
                    await _firebaseRepository.SendIndividualNotification(new NewMessageNotificationModel
                    {
                        SenderId    = caller.Id,
                        Description = messageBodyType == MessageBodyType.Image ? "Image" :
                                      messageBodyType == MessageBodyType.File ? "Photo" : model.MessageText,
                        GenericId               = conversation.Id,
                        NotificationType        = NotificationType.NewMessage,
                        ReceiverId              = receiverId,
                        Title                   = $"{caller.FullName} {sentMessage}",
                        UnreadConversationCount = unreadConversationCount
                    }, false);
                }
                await _firebaseRepository.SendIndividualNotification(new NewMessageNotificationModel
                {
                    SenderId    = caller.Id,
                    Description = messageBodyType == MessageBodyType.Image ? "Image" :
                                  messageBodyType == MessageBodyType.File ? "Photo" : model.MessageText,
                    GenericId               = conversation.Id,
                    NotificationType        = NotificationType.NewMessageGeneralInformation,
                    ReceiverId              = receiverId,
                    Title                   = $"{caller.FullName} {sentMessage}",
                    UnreadConversationCount = unreadConversationCount
                }, false);
            }
            return(notify);
        }
示例#3
0
        public async Task <SupportMessageListModel> Send(SendSupportMessageModel model, int userId, Language language, string deviceId)
        {
            //User caller = null;
            Guest guest  = null;
            var   caller = await _repository.FilterAsNoTracking <User>(u => u.Id == userId).FirstOrDefaultAsync();

            if (caller == null)
            {
                guest = await _repository.FilterAsNoTracking <Guest>(g => g.DeviceId == deviceId).FirstOrDefaultAsync();

                if (guest == null)
                {
                    throw new Exception(_optionsBinder.Error().UserNotFound);
                }
            }

            var conversation = await _repository.Filter <SupportConversation>(x => x.Id == model.ConversationId)
                               .FirstOrDefaultAsync();

            if (conversation == null)
            {
                throw new Exception("connversation not found");
            }
            var  body            = model.MessageText;
            var  messageBodyType = model.SupportMessageBodyType;
            long length          = 0;

            if (model.File != null)
            {
                messageBodyType = SupportMessageBodyType.Image;
                body            = await _accessor.Upload(model.File, UploadType.SupportConversationFiles, conversation.Id);

                var extension = Path.GetExtension(body);
                if (extension != ".jpg" && extension != ".jpeg" && extension != ".png")
                {
                    messageBodyType = SupportMessageBodyType.Photo;
                }
                length = await _accessor.GetLength(body, UploadType.SupportConversationFiles, conversation.Id);
            }
            int?replayValue    = null;
            var supportMessage = new SupportMessage
            {
                SupportConversationId  = conversation.Id,
                SupportMessageBodyType = messageBodyType,
                MessageText            = body,
                FileLength             = length,
                ReplayMessageId        = model.ReplayMessageId.HasValue ? model.ReplayMessageId.Value : replayValue
            };

            if (caller != null)
            {
                supportMessage.UserSenderId  = caller.Id;
                supportMessage.GuestSenderId = null;
            }
            else
            {
                supportMessage.GuestSenderId = guest.Id;
                supportMessage.UserSenderId  = null;
            }
            _repository.Create(supportMessage);
            await _repository.SaveChangesAsync();

            int receiverId;

            if (caller != null)
            {
                receiverId = conversation.AdminId == caller.Id
                    ? conversation.GuestId ?? conversation.UserId ?? 0
                    : conversation.AdminId;
            }
            else
            {
                receiverId = conversation.AdminId;
            }
            var isGuest  = conversation.GuestId != null;
            var callerId = caller?.Id ?? guest.Id;
            AnnouncementListViewModel announcement = null;

            if (messageBodyType == SupportMessageBodyType.Announcement)
            {
                int.TryParse(model.MessageText, out var id);
                announcement = await _repository.Filter <Announcement>(x => !x.IsDraft && x.Id == id).Select(x =>
                                                                                                             new AnnouncementListViewModel
                {
                    Id            = x.Id,
                    BathroomCount = x.BathroomCount,
                    AnnouncementResidentialType = x.AnnouncementResidentialType,
                    AnnouncementRentType        = x.AnnouncementRentType,
                    IsFavourite            = false,
                    Address                = x.AddressEn.Trim(),
                    AnnouncementEstateType = x.AnnouncementEstateType,
                    AnnouncementType       = x.AnnouncementType,
                    Area         = Convert.ToInt64(x.Area),
                    BedroomCount = x.BedroomCount,
                    Price        = Convert.ToInt64(x.Price),
                    Title        = x.Title,
                    CreateDate   = x.CreatedDt,
                    Photo        = new ImageOptimizer
                    {
                        Photo = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                                         UploadType.AnnouncementBasePhoto, x.BasePhoto, 300, 300, false, 0),
                        PhotoBlur = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                                             UploadType.AnnouncementBasePhoto, x.BasePhoto, 100, 100, true, 0)
                    }
                }).FirstOrDefaultAsync();
            }
            var notify = (new SupportMessageListModel
            {
                ConversationId = conversation.Id,
                MessageId = supportMessage.Id,
                MessageText = supportMessage.SupportMessageBodyType == SupportMessageBodyType.Image ?
                              Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                                       UploadType.SupportConversationFiles, supportMessage.MessageText, 1000, 1000, false, conversation.Id) : supportMessage.MessageText,
                MessageBodyType = messageBodyType,
                SenderId = caller?.Id ?? guest.Id,
                FullName = caller != null ? supportMessage.UserSender.FullName : guest.Id.ToString(),
                Photo = caller != null ? new ImageOptimizer
                {
                    Photo = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                                     UploadType.ProfilePhoto, supportMessage.UserSender.ProfilePhoto, ConstValues.Width, ConstValues.Height, false, 0),
                    PhotoBlur = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                                         UploadType.ProfilePhoto, supportMessage.UserSender.ProfilePhoto, 100, 100, true, 0)
                } : new ImageOptimizer(),
                CreatedDate = supportMessage.CreatedDt,
                IsSentFromMe = false,
                Announcement = announcement,
                FileSize = length,
                FileUrl = messageBodyType == SupportMessageBodyType.Photo
                    ? Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaDownload,
                                               UploadType.SupportConversationFiles, supportMessage.MessageText, false, conversation.Id) : null,
                ReplayMessage = supportMessage.ReplayMessageId != null ? await _repository.Filter <SupportMessage>(s => s.Id == supportMessage.ReplayMessageId)
                                .Select(s => new SupportMessageListModel
                {
                    MessageBodyType = s.SupportMessageBodyType,
                    MessageId = s.Id,
                    MessageText = s.SupportMessageBodyType == SupportMessageBodyType.Image ?
                                  Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                                           UploadType.SupportConversationFiles, s.MessageText, 1000, 1000, false, conversation.Id) : s.MessageText,
                    CreatedDate = s.CreatedDt,
                    IsSentFromMe = (s.UserSenderId ?? s.GuestSenderId ?? 0) == callerId,
                    Photo = s.UserSender != null ? new ImageOptimizer
                    {
                        Photo = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                                         UploadType.ProfilePhoto, s.UserSender.ProfilePhoto, ConstValues.Width, ConstValues.Height, false, 0),
                        PhotoBlur = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                                             UploadType.ProfilePhoto, s.UserSender.ProfilePhoto, 100, 100, true, 0)
                    } : new ImageOptimizer(),
                    SenderId = s.UserSenderId ?? s.GuestSenderId.GetValueOrDefault(),
                    FullName = s.UserSenderId != null ? s.UserSender.FullName : "User",
                    FileUrl = s.SupportMessageBodyType == SupportMessageBodyType.Photo ?
                              Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaDownload,
                                                       UploadType.SupportConversationFiles, s.MessageText, false, conversation.Id) : null,
                    FileSize = s.FileLength
                }).FirstOrDefaultAsync() : null
            });

            if (notify.ReplayMessage != null && notify.ReplayMessage.MessageBodyType == SupportMessageBodyType.Announcement)
            {
                int.TryParse(notify.ReplayMessage.MessageText, out var replayMessage);
                notify.ReplayMessage.Announcement = _repository.Filter <Announcement>(x => !x.IsDraft && x.Id == replayMessage)
                                                    .Select(x => new AnnouncementListViewModel
                {
                    Id            = x.Id,
                    BathroomCount = x.BathroomCount,
                    AnnouncementResidentialType = x.AnnouncementResidentialType,
                    AnnouncementRentType        = x.AnnouncementRentType,
                    IsFavourite            = false,
                    Address                = x.AddressEn.Trim(),
                    AnnouncementEstateType = x.AnnouncementEstateType,
                    AnnouncementType       = x.AnnouncementType,
                    Area         = Convert.ToInt64(x.Area),
                    BedroomCount = x.BedroomCount,
                    Price        = Convert.ToInt64(x.Price),
                    Title        = x.Title,
                    Photo        = new ImageOptimizer
                    {
                        Photo = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                                         UploadType.AnnouncementBasePhoto, x.BasePhoto, 300, 300, false, 0),
                        PhotoBlur = Utilities.ReturnFilePath(ConstValues.MediaBaseUrl, ConstValues.MediaResize,
                                                             UploadType.AnnouncementBasePhoto, x.BasePhoto, 100, 100, true, 0)
                    }
                }).FirstOrDefault();
            }
            var notifyToString = Utilities.SerializeObject(notify);
            var isSent         = await SupportChatMessageHandler.SendMessageAsync(conversation.Id, receiverId,
                                                                                  notifyToString, receiverId == conversation.GuestId);

            bool enableNotification = true;

            notify.IsSentFromMe = true;
            if (receiverId == conversation.AdminId && !isSent)
            {
                await SupportBaseMessageHandler.SendMessageAsync(conversation.Id, conversation.AdminId);

                return(notify);
            }
            if (!isSent && receiverId != conversation.AdminId)
            {
                if (isGuest && receiverId != conversation.AdminId)
                {
                    enableNotification = _repository.FilterAsNoTracking <PersonSetting>(s => s.GuestId == receiverId)
                                         .Select(s => s.SubscriptionsType).Contains(SubscriptionsType.EnableMessageNotification);
                }
                else if (!isGuest && caller != null && receiverId != conversation.AdminId)
                {
                    enableNotification = _repository.FilterAsNoTracking <PersonSetting>(s => s.UserId == receiverId)
                                         .Select(s => s.SubscriptionsType).Contains(SubscriptionsType.EnableMessageNotification);
                }

                if (enableNotification)
                {
                    await _firebaseRepository.SendIndividualNotification(new NewMessageNotificationModel
                    {
                        SenderId    = caller?.Id ?? guest.Id,
                        Description = messageBodyType == SupportMessageBodyType.Image ? "Image" :
                                      messageBodyType == SupportMessageBodyType.Photo ? "Photo" :
                                      messageBodyType == SupportMessageBodyType.Announcement ? "Announcement" : model.MessageText,
                        GenericId        = conversation.Id,
                        NotificationType = NotificationType.SupportMessage,
                        ReceiverId       = receiverId,
                        Title            = caller != null
                            ? $"{caller.FullName} sent you a message"
                            : $"Guest N {guest.Id} sent you a message"
                    }, isGuest);
                }
            }
            return(notify);
        }