public AddUserVM(IChatHub chat, IFile file, IAbstractFactory <ChatVM> abstractFactory)
{
_chat = chat;
_file = file;
baseContent = abstractFactory.GetInstance();
baseContent.NewChatCreated += RemoveFindedUser;
}
public IResponseDTO PostChat(ChatVM message)
{
var depart = _ChatServices.PostChat(message);
// _ChatHubContext.Clients.User(message.OrderId.ToString()).SendAsync("ReceiveMessage", message);
return(depart);
}
private async Task <Chat> CreatePrivateChat(ChatVM model)
{
if (IsNotValidForCreatingPrivateChat(model))
{
return(null);
}
Chat chat;
if ((chat = await IsDuplicatePVChat(model)) != null)
{
return(chat);
}
chat = new Chat()
{
AppId = model.AppId,
ChatType = model.ChatType,
ChatMembers = new List <ChatMember> ()
{
new ChatMember()
{
UserId = model.UserId
},
new ChatMember()
{
UserId = model.PrivateChatDetail.OtherMember
}
},
ChatConversations = new List <ChatConversation> ()
};
return(await _chatRepository.CreateAsync(chat));
}
public IActionResult Chat(int id)
{
ApplicationUser user = _userManager.GetUserAsync(User).Result;
var chat = _context.Chats
.Include(x => x.Mesaje)
.Include(x => x.Users)
.ThenInclude(x => x.ApplicationUser)
.FirstOrDefault(x => x.ChatId == id);
IList <Chat> utilizatoriPrivati = _chatManager.Private(user.Id);
var grupuri = _context.Chats
.Include(x => x.Users)
.ThenInclude(x => x.ApplicationUser)
.Where(x => x.Users.Any(y => y.ApplicationUserId == user.Id) && x.Tip.Equals(TipChat.Grup))
.ToList();
var chatVM = new ChatVM
{
Chat = chat,
Private = utilizatoriPrivati,
Grupuri = grupuri
};
return(View(chatVM));
}
public IResponseDTO EditChat(ChatVM model)
{
try
{
var DbChat = _mapper.Map <Chat>(model);
var entityEntry = _ChatRepositroy.Update(DbChat);
int save = _unitOfWork.Commit();
if (save == 200)
{
_response.Data = model;
_response.IsPassed = true;
_response.Message = "Ok";
}
else
{
_response.Data = null;
_response.IsPassed = false;
_response.Message = "Not saved";
}
}
catch (Exception ex)
{
_response.Data = null;
_response.IsPassed = false;
_response.Message = "Error " + string.Format("{0} - {1} ", ex.Message, ex.InnerException != null ? ex.InnerException.FullMessage() : "");
}
return(_response);
}
public ChatScreen(string sender, string reciever)
{
InitializeComponent();
_chatVM = new ChatVM(sender, reciever);
Task.Run(new Action(() => _chatVM.StartChat()));
_chatVM.PropertyChanged += _chatVM_PropertyChanged;
}
public async Task <ApiResponse> Chat_Sent(ChatVM _vm)
{
ApiResponse apiResponse = new ApiResponse();
ChatRepo _obj = new ChatRepo();
try
{
_vm._flag = 0;
var result = await _obj.ChatMessageSend(_vm);
if (result > 0)
{
return new ApiResponse {
IsValidUser = true, Message = "success", MessageType = result, DataList = result
}
}
;
else
{
return new ApiResponse {
IsValidUser = true, Message = "someting went wrong..!!", MessageType = result, DataList = result
}
};
}
catch (Exception ex)
{
apiResponse = TaskUTL.GenerateExceptionResponse(ex, "hub", true);
return(apiResponse);
}
}
public ActionResult Index([FromRoute] int connectionId)
{
//logger.LogInformation("Cinnection id" + connectionId);
ChatVM chatVM = GetChatVM(connectionId);
return(View(chatVM));
}
protected void GetChatItem(string sTTGUID)
{
ChatVM VM = new ChatVM(m);
ChatList = VM.GetChatList(sTTGUID);
PutMessagesInView(VM.ErrorMessage, VM.InfoMessage, VM.SecretErrorDetails);
}
public async Task <ApiResponse> ChatSignOut(ChatVM _vm)
{
ApiResponse apiResponse = new ApiResponse();
ChatRepo _obj = new ChatRepo();
try
{
_vm._flag = 0;
var result = await _obj.ChatSignOut(_vm);
if (result > 0)
{
return new ApiResponse {
IsValidUser = true, Message = "success", MessageType = result, DataList = null
}
}
;
else
{
return new ApiResponse {
IsValidUser = true, Message = "Already Chat Off", MessageType = result, DataList = null
}
};
}
catch (Exception ex)
{
apiResponse = TaskUTL.GenerateExceptionResponse(ex, _pageName, true);
return(apiResponse);
}
}
public async Task <RespRepoVM> ChatReceivedByTime(ChatVM _vm)
{
try
{
DataCommand dataCmd = new DataCommand();
dataCmd.Command = "ChatReceivedByTime";
dataCmd.Type = CommandType.StoredProcedure;
SqlParameter _Flag = new SqlParameter("@flag", _vm._flag);
_Flag.Direction = ParameterDirection.InputOutput;
dataCmd.Parameters.Add(_Flag);
dataCmd.Parameters.Add(new SqlParameter("@OperatorId", _vm._operatorId));
dataCmd.Parameters.Add(new SqlParameter("@UserId", _vm._userId));
dataCmd.Parameters.Add(new SqlParameter("@ChatSessionId", _vm._chatSessionId));
dataCmd.Parameters.Add(new SqlParameter("@lastChatReadTime", _vm._lastChatReadTime));
dataCmd.Parameters.Add(new SqlParameter("@Token", _vm._token));
return(new RespRepoVM {
_dataList = objCommonDB.GetDataTable(dataCmd), _flag = Convert.ToInt32(_Flag.Value)
});
}
catch (Exception)
{
throw;
}
}
public async Task <ChatReceiveResponse> ChatReceivedByTime(ChatVM _vm)
{
ChatReceiveResponse apiResponse = new ChatReceiveResponse();
ChatRepo _obj = new ChatRepo();
try
{
_vm._flag = 0;
var result = await _obj.ChatReceivedByTime(_vm);
if (result._flag > 0)
{
return new ChatReceiveResponse {
ChatStatus = 1, DataList = result._dataList
}
}
;
else
{
return new ChatReceiveResponse {
ChatStatus = 0, DataList = result._dataList
}
};
}
catch (Exception ex)
{
apiResponse = new ChatReceiveResponse {
error = ex.Message.ToString()
}; //TaskUTL.GenerateExceptionResponse(ex, _pageName, true);
return(apiResponse);
}
}
private async Task <Chat> CreateGroupChat(ChatVM model)
{
if (IsNotValidForCreatingGroupChat(model))
{
return(null);
}
var chatMembers = model.GroupChatDetail.OtherMembers
.Where(member => member != model.UserId)
.Select(member => new ChatMember()
{
UserId = member
}).ToList();
chatMembers.Add(new ChatMember()
{
UserId = model.UserId
});
var chat = new Chat()
{
AppId = model.AppId,
Name = model.GroupChatDetail.ChatName,
ChatType = model.ChatType,
ChatMembers = chatMembers,
ChatConversations = new List <ChatConversation> ()
};
return(await _chatRepository.CreateAsync(chat));
}
public IResponseDTO SignupMarket([FromForm] ChatVM Message)
{
ResponseDTO res;
try
{
if (Message.DataFile != null)
{
var logoUrl = BackEnd.API.Hlper.UploadHelper.SaveFile(Message.DataFile, "File");
Message.DataUrl = logoUrl;
Message.DataFile = null;
}
return(_ChatServices.PostChat(Message));
}
catch (Exception ex)
{
res = new ResponseDTO()
{
IsPassed = false,
Message = "Error in Upload File " + ex.Message,
Data = null,
};
}
return(res);
}
public IActionResult Chat(int?id)
{
var user = _context.ApplicationUsers
.Include(x => x.Chats)
.ThenInclude(x => x.Chat)
.FirstOrDefault(x => x.UserName == User.Identity.Name);
int chatId = 0;
if (_context.ChatUsers.FirstOrDefault(x => x.ApplicationUserId == user.Id) == null)
{
var admin = _context.ApplicationUsers.FirstOrDefault(x => x.UserName.Contains("dana_moisi")).Id;
chatId = _chatManager.CreatePrivateRoom(user.Id, admin).Result;
}
else
{
chatId = _context.ChatUsers.FirstOrDefault(x => x.ApplicationUserId == user.Id).ChatId;
}
var chat = new Chat();
if (id == null)
{
chat = _context.Chats
.Include(x => x.Mesaje)
.Include(x => x.Users)
.ThenInclude(x => x.ApplicationUser)
.FirstOrDefault(x => x.ChatId == chatId);
}
else
{
chat = _context.Chats
.Include(x => x.Mesaje)
.Include(x => x.Users)
.ThenInclude(x => x.ApplicationUser)
.FirstOrDefault(x => x.ChatId == id);
}
var grupuri = _context.Chats
.Include(x => x.Users)
.ThenInclude(x => x.ApplicationUser)
.Where(x => x.Users.Any(y => y.ApplicationUserId == user.Id) && x.Tip.Equals(TipChat.Grup))
.ToList();
var privat = _context.Chats
.Include(x => x.Users)
.ThenInclude(x => x.ApplicationUser)
.Where(x => x.Users.Any(y => y.ApplicationUserId == user.Id) && x.Tip.Equals(TipChat.Privat))
.ToList();
ChatVM chatVM = new ChatVM
{
Chat = chat,
Private = privat,
Grupuri = grupuri
};
return(View(chatVM));
}
/// <summary>
/// Load all data in this ViewModel from local storage such as database
/// </summary>
public void Load()
{
LocalUserVM.Load();
ChatVM.Load();
ContactVM.Load();
GroupVM.Load();
SystemVM.Load();
}
public void SetUp()
{
dispatcher = new Mock <IDispatcher>();
hubproxy = new Mock <IClientHubProxy>();
chatVM = new ChatVM(hubproxy.Object, dispatcher.Object);
dispatcher.Setup(mock => mock.Invoke(It.IsAny <Action>())).Callback <Action>(action => action());
}
public MainWindow()
{
AbstractDispatcher abstractDispatcher = new AbstractDispatcher(this.Dispatcher);
chatVM = new ChatVM(new ClientHubProxy("http://localhost:8080", "chat"), abstractDispatcher);
this.DataContext = chatVM;
InitializeComponent();
}
public async Task <Chat> CreateChat(string appId, string userId, ChatVM model)
{
model.AppId = appId;
model.UserId = userId;
var chat = await CreateChatRecord(model);
return(chat);
}
public IActionResult Index()
{
var user = this.User;
var model = new ChatVM();
model.Name = user.FindFirst(ClaimTypes.Name).Value;
model.Email = user.FindFirst(ClaimTypes.Email).Value;
return(View(model));
}
// GET: Chat
public ActionResult Index()
{
//var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);//Get ID
//ChatVM chatVM = new ChatVM();
//chatVM.Connections = dataBaseRepository.GetAllConnections(userId);
ChatVM chatVM = GetChatVM();
return(View(chatVM));
}
private async Task <Chat> IsDuplicatePVChat(ChatVM model)
{
var userChats = await _userService.GetUserChats(model.AppId, model.UserId);
var duplicateUserChat = userChats.Find(chat => chat.Chat.ChatType == ChatType.Private &&
chat.Chat.ChatMembers.Any(m => m.UserId == model.UserId) &&
chat.Chat.ChatMembers.Any(m => m.UserId == model.PrivateChatDetail.OtherMember));
return(duplicateUserChat != null?duplicateUserChat.Chat : null);
}
public async Task BroadCastMessage(ChatVM _chatmsg)
{
var id = Context.ConnectionId;
string[] Exceptional = new string[0];
Clients.Group(_chatmsg._token, Exceptional).receiveMessage(_chatmsg._userName, _chatmsg._message, _chatmsg._token, DateTime.Now.ToString());
var _result = await Chat_Sent(_chatmsg);
Clients.Group(_chatmsg._token, Exceptional).dbAlert(_result);
}
public Chat(MainWindowVM mainWindow, UserRestClient userRestClient)
{
InitializeComponent();
chatVM = new ChatVM(userRestClient.CurrentUser, mainWindow);
this.DataContext = chatVM;
restClient = userRestClient;
chatVM.CurrentContacts = userRestClient.GetAllContacts(userRestClient.CurrentUser.Id);
chatVM.CurrentView = new ChatList(userRestClient.CurrentUser, chatVM);
this.mainWindowVM = mainWindow;
}
private bool IsNotValidForCreatingGroupChat(ChatVM model)
{
if (model.GroupChatDetail == null ||
string.IsNullOrWhiteSpace(model.GroupChatDetail.ChatName) ||
model.GroupChatDetail.OtherMembers == null)
{
return(true);
}
return(false);
}
public ActionResult Inbox()
{
ChatVM model = new ChatVM()
{
AppUsers = appUserService.GetActive(),
Chats = chatService.GetActive(),
user = appUserService.GetByDefault(x => x.UserName == User.Identity.Name)
};
return(View(model));
}
private bool IsNotValidForCreatingPrivateChat(ChatVM model)
{
if (model.PrivateChatDetail == null)
{
return(true);
}
if (model.UserId == model.PrivateChatDetail.OtherMember)
{
return(true);
}
return(false);
}
protected void SaveDialogDeleteChat()
{
ChatVM VM = new ChatVM(m);
dialogDeleteChatisOpen = false;
VM.DeleteChatItem(chatItem.ChatGUID);
if (m.IsEmpty(VM.ErrorMessage))
{
GetListOfTT();
}
PutMessagesInView(VM.ErrorMessage, VM.InfoMessage, VM.SecretErrorDetails);
}
public ChatList(User user, ChatVM chatVM)
{
InitializeComponent();
ChatListVM chatListVM = new ChatListVM();
this.chatVM = chatVM;
this.DataContext = chatListVM;
chatListVM.CurrentChats = chatRestClient.GetAllChatsforUser(user.Id);
foreach (Models.Chat chat in chatListVM.CurrentChats)
{
chat.Members = chatRestClient.GetAllMembersToChat(chat.Id);
}
}
public ActionResult Delete(int id, FormCollection collection)
{
try
{
ChatVM.GetMeuteDeChats().Remove(ChatVM.GetMeuteDeChats().Where(c => c.Id == id).First());
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
