public RegCommand(ChatRepository chatRepository, UserRepository userRepository)
: base()
{
_userRepository = userRepository;
_chatRepository = chatRepository;
_chatService = new ChatService(_chatRepository);
}
public bool SendMessageToLogistician(string authKey, string message)
{
try {
using (var uow = UnitOfWorkFactory.CreateWithoutRoot($"[CS]Отправка сообщения логисту"))
{
var driver = EmployeeRepository.GetDriverByAuthKey(uow, authKey);
if (driver == null)
{
return(false);
}
var chat = ChatRepository.GetChatForDriver(uow, driver);
if (chat == null)
{
chat = new ChatClass();
chat.ChatType = ChatType.DriverAndLogists;
chat.Driver = driver;
}
ChatMessage chatMessage = new ChatMessage();
chatMessage.Chat = chat;
chatMessage.DateTime = DateTime.Now;
chatMessage.Message = message;
chatMessage.Sender = driver;
chat.Messages.Add(chatMessage);
uow.Save(chat);
uow.Commit();
return(true);
}
} catch (Exception e) {
logger.Error(e);
return(false);
}
}
public bool SendMessageToDriver(int senderId, int recipientId, string message)
{
try
{
using (var senderUoW = UnitOfWorkFactory.CreateForRoot <Employee>(senderId, $"[CS]Отправка сообщения водителю {recipientId}"))
{
var recipient = senderUoW.GetById <Employee>(recipientId);
var chat = ChatRepository.GetChatForDriver(senderUoW, recipient);
if (chat == null)
{
chat = new ChatClass();
chat.ChatType = ChatType.DriverAndLogists;
chat.Driver = recipient;
}
ChatMessage chatMessage = new ChatMessage();
chatMessage.Chat = chat;
chatMessage.DateTime = DateTime.Now;
chatMessage.Message = message;
chatMessage.Sender = senderUoW.Root;
chat.Messages.Add(chatMessage);
senderUoW.Save(chat);
senderUoW.Commit();
FCMHelper.SendMessage(recipient.AndroidToken, senderUoW.Root.ShortName, message);
return(true);
}
} catch (Exception e) {
logger.Error(e);
return(false);
}
}
public ViewController()
{
groupChatRepository = new GroupChatRepository(dataContext);
chatRepository = new ChatRepository(dataContext);
viewRepository = new ViewRepository(dataContext);
userRepository = new UserRepository(dataContext);
}
public JsonResult HaalChatOp(int userId1, int userId2)
{
var sql = new ChatSqlContext();
var chatRepo = new ChatRepository(sql);
return(Json(chatRepo.GetChatByUsers(userId1, userId2)));
}
public DashboardController(ILogger <DashboardController> logger)
{
_logger = logger;
userrepo = new UserRepository();
chatrepo = new ChatRepository();
chatuserrepo = new ChatUserRepository();
}
public ChatController(ILogger <ChatController> logger)
{
_logger = logger;
chatrepo = new ChatRepository();
messageRepository = new MessageRepository();
userRepository = new UserRepository();
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
MessageRepository = new MessageRepository(context);
GroupRepository = new GroupRepository(context);
ChatRepository = new ChatRepository(context);
}
public IEnumerable <MessageDTO> GetMessages(ChatDTO chatDTO)
{
IEnumerable <Message> messages;
List <MessageDTO> messageDTOs = new List <MessageDTO>();
IMainMap mainMap = new Map();
using (ChatRepository repository = new ChatRepository())
{
messages = repository.GetMessages(mainMap.ChatDTOToChat(chatDTO));
}
using (UserRepository repository = new UserRepository())
{
foreach (Message message in messages)
{
MessageDTO messageDTO = new MessageDTO();
messageDTO = mainMap.MessageToMessageDTO(message);
User user = repository.GetItem(messageDTO.UserId);
messageDTO.Author = user.UserLogin;
messageDTO.Img = user.UserImg;
messageDTOs.Add(messageDTO);
}
}
return(messageDTOs);
}
public List <ChatModel> unread_messages(ChatModel model)
{
using (chatRepository = new ChatRepository())
{
return(chatRepository.unread_messages(model));
}
}
//Delete
public async Task <TranStatus> deleteMsg(int ID, ChatModel model)
{
using (chatRepository = new ChatRepository())
{
return(await chatRepository.deleteMsg(ID, model));
}
}
public List <ChatModel> getchats(ChatModel model)
{
using (chatRepository = new ChatRepository())
{
return(chatRepository.getchats(model));
}
}
public Task <TranStatus> sendmessage(ChatModel model)
{
using (chatRepository = new ChatRepository())
{
return(chatRepository.sendmessage(model));
}
}
private void Tick(object sender, EventArgs e)
{
//clear list view
chatListbox.Items.Clear();
if (CheckAuth())
{
ChatSQLContext csc = new ChatSQLContext();
ChatRepository cr = new ChatRepository(csc);
List <ChatBericht> chatBerichten = cr.RetrieveAllChatBerichtenByOpdracht(_hulpOpdracht.Id);
chatBerichten.Sort();
GebruikerSQLContext gsc = new GebruikerSQLContext();
GebruikerRepository gr = new GebruikerRepository(gsc);
foreach (ChatBericht chat in chatBerichten)
{
Gebruiker g = gr.RetrieveGebruiker(chat.GebruikerId);
chatListbox.Items.Add("[" + chat.Tijd + " | " + g.Naam + "] : " + chat.Bericht);
}
}
else
{
chatListbox.Items.Add("U heeft geen rechten voor deze chat");
btnSendChat.IsEnabled = false;
}
}
public async Task OnChatUpdateAsync(Chat chat)
{
if (chat == null)
{
throw new ArgumentNullException(nameof(chat));
}
var clientIds = chat.Users.Select(x => x.Id).ToList();
var existingChat = await ChatRepository.GetByIdAsync(chat.Id);
clientIds.AddRange(existingChat.Users.Select(x => x.Id).ToList());
await ChatRepository.UpdateAsync(chat);
existingChat = await ChatRepository.GetByIdAsync(chat.Id);
var existingUsers = existingChat.Users.Select(x => x.Id).ToList();
foreach (var clientId in clientIds)
{
if (existingUsers.Contains(clientId))
{
NotifyClient(clientId.ToString(), client => client.onChatUpdateAsync(existingChat));
}
else
{
NotifyClient(clientId.ToString(), client => client.onChatDeleteAsync(existingChat.Id));
}
}
}
public ChatService(ChatRepository chatRepository, IChatTL chatTL, IUserService userService, UserChatRepository userChatRepository)
{
_chatRepository = chatRepository;
_chatTL = chatTL;
_userService = userService;
_userChatRepository = userChatRepository;
}
public ChattingService(ChatRoomsService chatRoomService, ChatRepository chatRepository, ILogger <ChattingService> logger)
{
_chatRoomService = chatRoomService;
_chatRepository = chatRepository;
_logger = logger;
handler = OnMessageReceived;
}
public void Chat(object value)
{
string json = JsonConvert.SerializeObject(value);
var values = JsonConvert.DeserializeObject <Dictionary <string, object> >(json);
int chatId = int.Parse(values["id"].ToString());
int senderId = int.Parse(values["userId"].ToString());
var convo = ((JArray)values["dialog"]).Select(x => new Messages {
ChatId = chatId,
UserId = (int)x["who"],
Message = (string)x["message"],
Time = DateTime.Parse(x["time"].ToString())
}).ToList();
var repository = new ChatRepository(context);
var chat = repository.UpdateChat(chatId, senderId, convo);
//notify the users substribed to the chat
var groups = new List <string>()
{
chat.StarterUserId.ToString(), chat.OtherUserId.ToString()
};
hub.Clients.Groups(groups).SendAsync("send", chat.StarterUserId, chat.OtherUserId);
// hub.Clients.All.SendAsync("send",chat.StarterUserId ,chat.OtherUserId );
}
public ChatController()
{
viewRepository = new ViewRepository(dataContext);
chatRepository = new ChatRepository(dataContext);
userRepository = new UserRepository(dataContext);
privateMessageRepository = new PrivateMessageRepository(dataContext);
}
public ActionResult <IEnumerable <object> > Chats(int id)
{
var repository = new ChatRepository(context);
var result = repository.GetChatsForUser(id);
return(result);
}
protected void OnButtonOkClicked(object sender, EventArgs e)
{
var currentEmployee = EmployeeRepository.GetEmployeeForCurrentUser(UoW);
var service = new ChannelFactory <IChatService>(
new BasicHttpBinding(),
ChatMain.ChatServiceUrl).CreateChannel();
var accessToLogisticChat = ServicesConfig.CommonServices.CurrentPermissionService.ValidatePresetPermission("logistican");
var unreadedMessages = ChatMessageRepository.GetUnreadedChatMessages(UoW, currentEmployee, accessToLogisticChat);
bool needCommit = false;
foreach (var recipient in Recipients)
{
service.SendMessageToDriver(
currentEmployee.Id,
recipient.Id,
textviewMessage.Buffer.Text
);
var unreaded = unreadedMessages.FirstOrDefault(x => x.EmployeeId == recipient.Id);
if (unreaded == null)
{
var chat = ChatRepository.GetChatForDriver(UoW, recipient);
if (chat != null)
{
chat.UpdateLastReadedTime(currentEmployee);
UoW.Save(chat);
needCommit = true;
}
}
if (needCommit)
{
UoW.Commit();
}
}
}
public ActionResult <object> Chat(int id)
{
string jsonTime = Request.Query["time"].FirstOrDefault();
int userId = int.Parse(Request.Query["userId"].FirstOrDefault());
var repository = new ChatRepository(context);
object result;
//get chat
if (jsonTime == "null")
{
result = repository.GetMessagesForChat(id);
}
else
{
DateTime time = JsonConvert.DeserializeObject <DateTime>(jsonTime);
result = repository.GetMessagesForChat(id, userId, time);
}
//notify the client apps that the chat has been opened
var fromPanel = Request.Query["panel"].FirstOrDefault();
if (fromPanel != null && bool.Parse(fromPanel))
{
hub.Clients.Groups(userId.ToString()).SendAsync("open", id, 0);
}
return(result);
}
//GET : Chat/{AnderegebruikerId}
public ActionResult ChatScherm(string id)
{
if (!AuthRepository.CheckIfUserCanAcces(GebruikerType.All, (Gebruiker)Session["LoggedInUser"]))
{
return(View("~/Views/Error/AuthError.cshtml"));
}
try
{
GebruikerSqlContext gsc = new GebruikerSqlContext();
GebruikerRepository gr = new GebruikerRepository(gsc);
var sql = new ChatSqlContext();
var chatRepo = new ChatRepository(sql);
Gebruiker loggedInUser = (Gebruiker)Session["LoggedInUser"];
// Gebruiker loggedInUser = gr.GetById(1);
ViewBag.LoggedInUser = loggedInUser;
ViewBag.Gebruikers = gr.GetAll();
ViewBag.EnableChat = "true";
return(View("~/Views/Chat/Index.cshtml"));
}
catch (Exception e)
{
return(RedirectToAction("Index", "Error"));
}
}
public ApplicationDataService(IDatabase database)
{
Attachments = new AttachmentRepository(database);
Chats = new ChatRepository(database);
Messages = new MessageRepository(database);
Users = new UserRepository(database);
}
public IHttpActionResult Get(int sid, int rid)
{
ChatRepository chatrepo = new ChatRepository();
var chatFromSender = chatrepo.GetChatBySenderReceiver(sid, rid);
if (chatFromSender != null)
{
MessageRepository msgrepo = new MessageRepository();
var msgList = msgrepo.GetMessageByChatId(chatFromSender.ID);
if (msgList.Count() > 0)
{
return(Ok(msgList));
}
else
{
return(Created("", chatFromSender));
}
}
else
{
Chat chat = new Chat();
chat.SenderID = sid;
chat.ReceiverID = rid;
chatrepo.Insert(chat);
//Get(sid, rid);
return(Created("", chat));
}
}
public ChatHub(ChatRepository chatRepository, MessageRepository messageRepository, UserRepository userRepository, RoomUserRepository roomUserRepository)
{
_chatRepository = chatRepository;
_messageRepository = messageRepository;
_userRepository = userRepository;
_roomUserRepository = roomUserRepository;
}
/// <summary>
/// Sends the server notification to driver.
/// ВНИМАНИЕ!!! Делает коммит UoW.
/// </summary>
public static bool SendServerNotificationToDriver(IUnitOfWork uow, Employee driver, string message, string androidNotification)
{
try {
if (driver == null)
{
return(false);
}
var chat = ChatRepository.GetChatForDriver(uow, driver);
if (chat == null)
{
chat = new ChatClass();
chat.ChatType = ChatType.DriverAndLogists;
chat.Driver = driver;
}
ChatMessage chatMessage = new ChatMessage();
chatMessage.Chat = chat;
chatMessage.DateTime = DateTime.Now;
chatMessage.Message = message;
chatMessage.IsServerNotification = true;
chatMessage.IsAutoCeated = true;
chat.Messages.Add(chatMessage);
uow.Save(chat);
uow.Commit();
FCMHelper.SendOrderStatusChangeMessage(driver.AndroidToken, UserNameOfServer, androidNotification);
return(true);
} catch (Exception e) {
logger.Error(e);
return(false);
}
}
public ChatAddRemoveAllCommand(IChatService chatService, IUserService userService, ChatRepository chatRepository, bool isAdd)
{
_isAdd = isAdd;
_chatService = chatService;
_userService = userService;
_chatRepository = chatRepository;
}
public List <MessageDTO> AndroidGetChatMessages(string authKey, int days)
{
try {
using (var uow = UnitOfWorkFactory.CreateWithoutRoot($"[CS]Получение сообщений чата"))
{
var driver = EmployeeRepository.GetDriverByAuthKey(uow, authKey);
if (driver == null)
{
return(null);
}
var chat = ChatRepository.GetChatForDriver(uow, driver);
if (chat == null)
{
return(null);
}
var messages = new List <MessageDTO>();
var chatMessages = ChatMessageRepository.GetChatMessagesForPeriod(uow, chat, days);
foreach (var m in chatMessages)
{
messages.Add(new MessageDTO(m, driver));
}
return(messages);
}
} catch (Exception e) {
logger.Error(e);
return(null);
}
}
public RoomsController(RoomRepository roomRepository, ChatRepository chatRepository, RoomUserRepository roomUserRepository, UserRepository userRepository)
{
_roomRepository = roomRepository;
_chatRepository = chatRepository;
_roomUserRepository = roomUserRepository;
_userRepository = userRepository;
}
