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)
{
}
