public ChatMessageService(IChatMessageRepository chatMessageRepository, IUserRepository userRepository, IDriverRepository driverRepository, IUnitOfWork unitOfWork) { this._chatMessageRepository = chatMessageRepository; this._userRepository = userRepository; this._driverRepository = driverRepository; this._unitOfWork = unitOfWork; }
public CreateChatMessageCommandHandler( IChatMessageRepository chatMessageRepository, ILogger logger, IValidator <CreateChatMessageCommand> validator) { _chatMessageRepository = chatMessageRepository; _logger = logger; _validator = validator; }
public V1GamesController(IUserRepository userRepository, IGameRepository gameRepository, IChatMessageRepository chatMessageRepository, IGameWordRepository gameWordRepository, IMapper mapper) { this.userRepository = userRepository; this.gameRepository = gameRepository; this.chatMessageRepository = chatMessageRepository; this.gameWordRepository = gameWordRepository; this.mapper = mapper; }
public ChatMessageService( IChatMessageRepository chatMessageRepository, IUnitOfWork unitOfWork, IUserService userService) { _chatMessageRepository = chatMessageRepository; _unitOfWork = unitOfWork; _userService = userService; }
public ChatGroupUserService( IChatMessageRepository chatMessageRepository, IUserRepository userRepository, IChatGroupRepository chatGroupRepository, IChatGroupUserRepository chatGroupUserRepository, IUnitOfWork unitOfWork //IMapper mapper, ) : base(chatMessageRepository, userRepository, chatGroupRepository, chatGroupUserRepository, unitOfWork) { }
private ChatCallbackObservable(int employeeId, IChatMessageRepository chatMessageRepository) { _chatMessageRepository = chatMessageRepository ?? throw new ArgumentNullException(nameof(chatMessageRepository)); observers = new List <IChatCallbackObserver>(); employeeUoW = UnitOfWorkFactory.CreateForRoot <Employee>(employeeId, $"[CS]Слежение за чатами"); unreadedMessages = _chatMessageRepository.GetLastChatMessages(employeeUoW); //Initiates new message check every 30 seconds. timerId = GLib.Timeout.Add(refreshInterval, new GLib.TimeoutHandler(refresh)); }
public ChatMessageService( IConfigurationManager configManager, IChatMessageRepository chatMessageRepository, IConnection connection ) : base(configManager) { _connection = connection; _channel = _connection.CreateModel(); _chatMessageRepository = chatMessageRepository; }
public CreateChatMessageCommandHandler( IRoomRepository roomRepository, IChatMessageRepository chatMessageRepository, IMapper mapper, ILogger <CreateChatMessageCommandHandler> logger) { _roomRepository = roomRepository ?? throw new ArgumentNullException(nameof(roomRepository)); _chatMessageRepository = chatMessageRepository ?? throw new ArgumentNullException(nameof(chatMessageRepository)); _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public MessagePersistor( IConfigurationManager configManager, IConnection connection, IChatMessageRepository chatMessageRepository ) : base(configManager, connection) { _chatMessageRepository = chatMessageRepository; var exchangeName = RabbitConst.MessageExchange; var persistorQueueName = _channel.QueueDeclare(queue: RabbitConst.MessagePersistorQueue, durable: true, exclusive: false, autoDelete: false, arguments: null) .QueueName; _channel.ExchangeDeclare(exchange: exchangeName, type: ExchangeType.Topic, durable: true, autoDelete: false, arguments: null); _channel.QueueBind(exchange: exchangeName, queue: persistorQueueName, routingKey: "msg.*.to.*", arguments: null); var consumer = new EventingBasicConsumer(_channel); consumer.Received += (sndr, ea) => { var headers = ea.BasicProperties.Headers; var message = new ChatMessage { Id = Decode(headers[RabbitConst.IdHeader]), RoomId = Decode(headers[RabbitConst.RoomIdHeader]), From = Decode(headers[RabbitConst.FromHeader]), To = Decode(headers[RabbitConst.ToHeader]), Timestamp = ToDateTime(Decode(headers[RabbitConst.TimestampHeader])), Body = Decode(ea.Body), Status = ChatMessageStatus.Sent }; Task.Run(() => _chatMessageRepository.InsertAsync(message)).Wait(); _channel.BasicAck(ea.DeliveryTag, false); }; _channel.BasicConsume(queue: persistorQueueName, autoAck: false, consumer: consumer); }
public ChatRoomReadCommand( IChatMessageRepository chatMessageRepository, IChatRoomListRepository chatRoomListRepository, IUserRepository userRepository, IChatMessageFileRepository chatMessageFileRepository) { _chatMessageRepository = chatMessageRepository; _chatRoomListRepository = chatRoomListRepository; _userRepository = userRepository; _chatMessageFileRepository = chatMessageFileRepository; }
public ChatMessageFileWriteCommand( IChatMessageRepository chatMessageRepository, IChatMessageFileRepository chatMessageFileRepository, IUserRepository userRepository, DomainContext domainContext ) { _chatMessageRepository = chatMessageRepository; _chatMessageFileRepository = chatMessageFileRepository; _domainContext = domainContext; _userRepository = userRepository; }
public WebRTCController( IWebRTCRoomRepository roomRepository, IUserRepository userRepository, IWebRTCSDPMessageRepository sdpMessageRepository, IWebRTCCandidatesTableRepository candidateRepository, IChatMessageRepository chatMessageRepsitory) { _roomRepository = roomRepository; _userRepository = userRepository; _sdpMessageRepository = sdpMessageRepository; _candidateRepository = candidateRepository; _chatMessageRepsitory = chatMessageRepsitory; }
public ChatMessageService( IChatMessageRepository chatMessageRepository, IChatRepository chatRepository, IUserRepository userRepository, IChatPermissionService chatPermissionService, IMapper mapper) { this.chatMessageRepository = chatMessageRepository; this.chatRepository = chatRepository; this.userRepository = userRepository; this.chatPermissionService = chatPermissionService; this.mapper = mapper; }
//private readonly IMapper _mapper; public ServiceBase( IChatMessageRepository chatMessageRepository, IUserRepository userRepository, IChatGroupRepository chatGroupRepository, IChatGroupUserRepository chatGroupUserRepository, IUnitOfWork unitOfWork //IMapper mapper, ) { _chatMessageRepository = chatMessageRepository; _userRepository = userRepository; _chatGroupRepository = chatGroupRepository; _chatGroupUserRepository = chatGroupUserRepository; _unitOfWork = unitOfWork; //_mapper = mapper; }
public StatusUpdatePersistor( IConfigurationManager configManager, IConnection connection, IChatMessageRepository chatMessageRepository ) : base(configManager, connection) { _chatMessageRepository = chatMessageRepository; var exchangeName = RabbitConst.StatuUpdateExchange; var persistorQueueName = _channel.QueueDeclare(queue: RabbitConst.StatusPersistorQueue, durable: true, exclusive: false, autoDelete: false, arguments: null) .QueueName; _channel.ExchangeDeclare(exchange: exchangeName, type: ExchangeType.Topic, durable: true, autoDelete: false, arguments: null); _channel.QueueBind(exchange: exchangeName, queue: persistorQueueName, routingKey: "update.*.to.*", arguments: null); var consumer = new EventingBasicConsumer(_channel); consumer.Received += (sndr, ea) => { var headers = ea.BasicProperties.Headers; Func <object, string> Decode = value => Encoding.UTF8.GetString((byte[])value); var msgId = Decode(headers[RabbitConst.IdHeader]); var msgStatus = (ChatMessageStatus)int.Parse(Decode(headers[RabbitConst.StatusHeader])); Task.Run(() => _chatMessageRepository.SetMessageStatusAsync(msgId, msgStatus).Wait()); _channel.BasicAck(ea.DeliveryTag, false); }; _channel.BasicConsume(queue: persistorQueueName, autoAck: false, consumer: consumer); }
public ChatService( IChatChannelRepository chatChannelRepository, IChatMessageRepository chatMessageRepository, IChatChannelMemberRepository chatChannelMemberRepository, IMapper mapper, IUserService userService, INotificationService notificationService, IPushService pushService) { _chatChannelRepository = chatChannelRepository.ThrowIfNull(nameof(chatChannelRepository)); _chatMessageRepository = chatMessageRepository.ThrowIfNull(nameof(chatMessageRepository)); _mapper = mapper.ThrowIfNull(nameof(mapper)); _userService = userService.ThrowIfNull(nameof(userService)); _chatChannelMemberRepository = chatChannelMemberRepository.ThrowIfNull(nameof(chatChannelMemberRepository)); _notificationService = notificationService.ThrowIfNull(nameof(notificationService)); _pushService = pushService.ThrowIfNull(nameof(pushService)); }
public UnitOfWork( ApplicationDbContext context , UserManager <ApplicationUser> userManager //, RoleManager<ApplicationRole> roleManager , IFriendRepository friendRepository , IChatMessageRepository chatMessageRepository , IChatRoomRepository chatRoomRepository , IChatRoomUserRepository chatRoomUsersRepository , IPrivateMessageRepository privateMessageRepository , IPrivateMessageStatusesRepository privateMessageStatuses , IChatMessageStatusesRepository chatMessageStatuses) { Context = context; UserManager = userManager; //RoleManager = roleManager; Friends = friendRepository; ChatMessages = chatMessageRepository; ChatRooms = chatRoomRepository; ChatRoomUsers = chatRoomUsersRepository; PrivateMessages = privateMessageRepository; PrivateMessageStatuses = privateMessageStatuses; ChatMessageStatuses = chatMessageStatuses; }
public ChatHub(IGameRepository gameRepository, IUserRepository userRepository, IChatMessageRepository chatMessageRepository, IMapper mapper) { this.gameRepository = gameRepository; this.userRepository = userRepository; this.chatMessageRepository = chatMessageRepository; this.mapper = mapper; }
public ChatMessagesController(IChatMessageRepository chatRepository) { _chatRepository = chatRepository; }
public ChatMessageController(IChatService chatService, IProducerService producerService, IChatMessageRepository chatHttpClient) { _chatService = chatService; _producer = producerService; _chatHttpClient = chatHttpClient; }
public ChatMessageService(IMapper mapper, IChatMessageRepository chatMessageRepository) { this.mapper = mapper; this.chatMessageRepository = chatMessageRepository; }
public ChatMessageService(IChatMessageRepository chatMessageRepository, IMapper mapper) { _chatMessageRepository = chatMessageRepository; _mapper = mapper; }
public ChatService(IChatMessageRepository repository) { _repository = repository; }
public AppRunner(IChatMessageRepository chatMessageRepository, IDatabaseRepository databaseRepository) { _chatMessageRepository = chatMessageRepository; _databaseRepository = databaseRepository; }
public ChatService(IChatMessageRepository chatMessageRepository) { this.ChatMessageRepository = chatMessageRepository; }
public ChatMessagesLogic(IChatMessageRepository chatMessageRepository, IUserRepository userRepository) { _chatMessageRepository = chatMessageRepository; _userRepository = userRepository; }
public ChatMessagesController(IChatMessageRepository repository) { this.repository = repository; }
public ChatService(IChatMessageRepository chatRepository) { _chatRepository = chatRepository; }
public ChatHub(IChatMessageRepository messagerepo, IMasterListRepository listrepo, UserManager <ApplicationUser> userManager) { _messagerepo = messagerepo; _listrepo = listrepo; _userManager = userManager; }
public HubController(IChatMessageRepository chatRepo, IHubContext <ChatHub> hub) { _hub = hub; _chatRepo = chatRepo; }
public static void CreateInstance(int employeeId, IChatMessageRepository chatMessageRepository) { instance = new ChatCallbackObservable(employeeId, chatMessageRepository); }
public GameAdminServiceServer(IAccountRepository accountRepository, IChatMessageRepository chatMessageRepository) { _accountRepository = accountRepository; _chatMessageRepository = chatMessageRepository; }
public ChatService(IChatMessageRepository entityRepository) : base(entityRepository) { }