public void ChatSend(String input) { chatlist.AddNewTextLineDefault(20, 200, input); Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); end = new IPEndPoint(ip, 6114); MessageThread mt = new MessageThread(socket, end, input); Thread t = new Thread(new ThreadStart(mt.SendRecieve)); t.Start(); }
/// <summary> /// Open MidiIn. /// MidiIn��J���܂��B /// </summary> /// <param name="deviceId">index of GetDeviceNames(). GetDeviceNames()��index</param> public MidiIn(int deviceId) { messageProc = new MessageThread(false, ThreadPriority.Normal, "MidiInProcThread"); messageProc.MessageHandlers[Win32.MM_MIM_LONGDATA] = delegate(Message m) { Win32.MidiHeader header = Win32.MidiHeader.FromIntPtr(m.LParam); MidiBuffer buf = MidiBuffer.FromMidiHeader(header); int bytesRecorded = (int)header.dwBytesRecorded; if (OnLongMsg != null && bytesRecorded != 0) { byte[] data = buf.Data; if (bytesRecorded != buf.Data.Length) { data = new byte[bytesRecorded]; Array.Copy(buf.Data, data, bytesRecorded); } System.Diagnostics.Trace.WriteLine("Recieved message from DEVICE: " + BitConverter.ToString(data)); try { OnLongMsg(data); } catch { } } if (recording) { Win32.midiInAddBuffer(deviceHandle, m.LParam, Win32.MidiHeader.SizeOfMidiHeader); } else { Win32.midiInUnprepareHeader(deviceHandle, m.LParam, Win32.MidiHeader.SizeOfMidiHeader); buf.Dispose(); Interlocked.Decrement(ref enqueuedBufferCount); } }; messageProc.MessageHandlers[Win32.MM_MIM_DATA] = delegate(Message m) { if (OnShortMsg != null) OnShortMsg((uint)m.LParam); }; int mmret = Win32.midiInOpen(out deviceHandle, (uint)deviceId, new IntPtr(messageProc.Win32ThreadID), IntPtr.Zero, Win32.CALLBACK_THREAD); if (mmret != Win32.MMSYSERR_NOERROR) { messageProc.Dispose(); throw new IOException("�f�o�C�X���J���܂���ł����B(" + mmret + ")"); } }
/// <summary> /// Open MidiIn. /// MidiIn��J���܂��B /// </summary> /// <param name="deviceId">index of GetDeviceNames(). GetDeviceNames()��index</param> public MidiIn(uint deviceId) { messageProc = new MessageThread(); messageProc.MessageHandlers[Win32.MM_MIM_LONGDATA] = delegate(Message m) { Win32.MidiHeader header = Win32.MidiHeader.FromIntPtr(m.LParam); MidiBuffer buf = MidiBuffer.FromMidiHeader(header); int bytesRecorded = (int)header.dwBytesRecorded; if (OnLongMsg != null && bytesRecorded != 0) { byte[] data = buf.Data; if (bytesRecorded != buf.Data.Length) { data = new byte[bytesRecorded]; Array.Copy(buf.Data, data, bytesRecorded); } OnLongMsg(data); } if (recording) { Win32.midiInAddBuffer(deviceHandle, m.LParam, Win32.MidiHeader.SizeOfMidiHeader); } else { Win32.midiInUnprepareHeader(deviceHandle, m.LParam, Win32.MidiHeader.SizeOfMidiHeader); buf.Dispose(); Interlocked.Decrement(ref enqueuedBufferCount); } }; messageProc.MessageHandlers[Win32.MM_MIM_DATA] = delegate(Message m) { if (OnShortMsg != null) OnShortMsg((uint)m.LParam); }; int mmret = Win32.midiInOpen(out deviceHandle, deviceId, new IntPtr(messageProc.Win32ThreadID), IntPtr.Zero, Win32.CALLBACK_THREAD); if (mmret != Win32.MMSYSERR_NOERROR) { messageProc.Dispose(); throw new Exception("�f�o�C�X���J���܂���ł����B(" + mmret + ")"); } }
void WriteMessageThread(StringBuilder builder, IList <MessageSummary> messages, MessageThread thread, int depth) { builder.Append(new string (' ', depth * 3)); if (thread.UniqueId.HasValue) { var summary = messages[(int)thread.UniqueId.Value.Id - 1]; builder.Append(summary.Envelope.Subject); } else { builder.Append("dummy"); } builder.Append('\n'); foreach (var child in thread.Children) { WriteMessageThread(builder, messages, child, depth + 1); } }
/// <summary> /// Send Message /// </summary> /// <param name="userFrom"></param> /// <param name="userTo"></param> /// <param name="subject"></param> /// <param name="body"></param> /// <returns></returns> public static async Task SendMessage(MessageSendModel messageModel) { var unitOfWork = ContainerManager.GetConfiguredContainer().Resolve <IUnitOfWorkAsync>(); MessageThread messageThread; // Use message subject to find the message thread if no listing id is provided if (!messageModel.ListingID.HasValue) { var messageThreadQuery = await MessageThreadService .Query(x => x.Subject.Equals(messageModel.Subject, StringComparison.InvariantCultureIgnoreCase) && x.MessageParticipants.Any(y => y.UserID == messageModel.UserFrom) && x.MessageParticipants.Any(y => y.UserID == messageModel.UserTo)) .SelectAsync(); messageThread = messageThreadQuery.FirstOrDefault(); } else { // Otherwise, use listing ID var messageThreadQuery = await MessageThreadService .Query(x => x.ListingID == messageModel.ListingID) .SelectAsync(); messageThread = messageThreadQuery.FirstOrDefault(); } // Create message thread if there is not one yet. if (messageThread == null) { messageThread = new MessageThread() { Subject = messageModel.Subject, ListingID = messageModel.ListingID, Created = DateTime.Now, LastUpdated = DateTime.Now, ObjectState = Repository.Pattern.Infrastructure.ObjectState.Added }; MessageThreadService.Insert(messageThread); await UnitOfWorkAsync.SaveChangesAsync(); // Add message participants MessageParticipantService.Insert(new MessageParticipant() { UserID = messageModel.UserFrom, MessageThreadID = messageThread.ID, ObjectState = Repository.Pattern.Infrastructure.ObjectState.Added }); MessageParticipantService.Insert(new MessageParticipant() { UserID = messageModel.UserTo, MessageThreadID = messageThread.ID, ObjectState = Repository.Pattern.Infrastructure.ObjectState.Added }); } // Insert mail message to db var message = new Message() { UserFrom = messageModel.UserFrom, Body = messageModel.Body, MessageThreadID = messageThread.ID, Created = DateTime.Now, LastUpdated = DateTime.Now, ObjectState = Repository.Pattern.Infrastructure.ObjectState.Added }; MessageService.Insert(message); await UnitOfWorkAsync.SaveChangesAsync(); // Add read state of messages MessageReadStateService.Insert(new MessageReadState() { MessageID = message.ID, UserID = messageModel.UserFrom, ReadDate = DateTime.Now, ObjectState = Repository.Pattern.Infrastructure.ObjectState.Added }); MessageReadStateService.Insert(new MessageReadState() { MessageID = message.ID, UserID = messageModel.UserTo, ReadDate = null, ObjectState = Repository.Pattern.Infrastructure.ObjectState.Added }); await UnitOfWorkAsync.SaveChangesAsync(); }
public void Post([FromBody] MessageThreadDTO input) { // The reciever will always be the seller Message message; try { var messageThreadRetrieved = _context.MessageThread.Single(m => m.asset.assetID == input.AssetId && m.SenderId == input.SenderId); messageThreadRetrieved.LastUpdateDate = DateTime.Now; message = new Message(input.Subject, input.Body, false, false); message.messageThread = messageThreadRetrieved; _messageRepository.AddMessage(message); //if (User.Identity.Name == message.messageThread.RecieverEmail) if (!input.IsSender) { message.messageThread.SenderUnreadMessageCount += 1; message.SenderUnread = true; } else { message.messageThread.RecieverUnreadMessageCount += 1; message.RecieverUnread = true; } _messageRepository.Save(); } catch (InvalidOperationException) { message = new Message(input.Subject, input.Body, false, false); _messageRepository.AddMessage(message); MessageThread messageThread = new MessageThread(input.SenderId, input.RecieverId); messageThread.messages.Add(message); messageThread.LastUpdateDate = DateTime.Now; messageThread.SenderEmail = _context.User.Single(u => u.Id == input.SenderId).Email; messageThread.RecieverEmail = _context.User.Single(u => u.Id == input.RecieverId).Email; if (input.AssetId != 0) { messageThread.asset = _context.Asset.Single(a => a.assetID == input.AssetId); } _messageThreadRepository.AddMessageThread(messageThread); //if (User.Identity.Name == messageThread.RecieverEmail) if (!input.IsSender) { messageThread.SenderUnreadMessageCount += 1; message.SenderUnread = true; } else { messageThread.RecieverUnreadMessageCount += 1; message.RecieverUnread = true; } _messageThreadRepository.Save(); } var recieverUser = _context.User.Single(u => u.Id == input.RecieverId); // This notification redirect URL should put the user to the discussion string redirectURL = "/MessageThreads/Details/" + message.messageThread.id.ToString(); Notification notification = new Notification(message.Subject, message.Body, redirectURL); Clients.Group(recieverUser.UserName).UpdateOverallNotificationCount(); Clients.Group(recieverUser.UserName).AddNotificationToQueue(notification); }
private void AddMessage(MessageModel Model, AppDBContext context) { long Id = 0; try { Message message = new Message { Id = Model.Id, ThreadId = Model.ThreadId, MessageText = Model.MessageText, SenderId = Model.SenderId, RecieverId = Model.RecieverId, Status = (int)Constant.MessageStatus.Initial, QuotationId = Model.QuotationId, Time = DateTime.Now.ToUniversalTime() }; var userRepo = new UserRepository(context); var sender = userRepo.GetByUserId(message.SenderId); var recipient = userRepo.GetByUserId(message.RecieverId); if (message.ThreadId == 0) { long agentId = 0; long buyerId = 0; if (sender.UserType == Constant.UserType.BUYER) { buyerId = sender.Id; agentId = recipient.Id; } else { buyerId = recipient.Id; agentId = sender.Id; } var existingthread = new MessageThreadRepository(context).GetByAgentId(agentId).Where( t => t.RequestId == Model.RequestId && t.BuyerId == buyerId).FirstOrDefault(); if (existingthread == null) { MessageThread thread = new MessageThread(); thread.AgentId = agentId; thread.BuyerId = buyerId; thread.RequestId = Model.RequestId; thread.CreatedBy = Model.SenderId; thread.CreatedTime = DateTime.Now.ToUniversalTime(); var repo = new MessageThreadRepository(context); long tid = repo.Add(thread); message.ThreadId = tid; } else { message.ThreadId = existingthread.Id; } } Id = new MessageRepository(context).Add(message); } catch (Exception ex) { throw (ex); } }
public async void Returns_Status200OkAndThreadOut_when_ThreadExistsAndHasMessages() { IDatabaseContext databaseContext = DatabaseTestHelper.GetContext(); MapperConfiguration mapperConfiguration = new MapperConfiguration(conf => { conf.AddProfile(new MessageThread_to_ThreadOut()); conf.AddProfile(new MessageReadState_to_MessageReadStateOut()); conf.AddProfile(new Message_to_MessageOut()); conf.AddProfile(new MessageThreadParticipant_to_MessageThreadParticipantOut()); }); IMapper mapper = mapperConfiguration.CreateMapper(); IMessageService messageService = new MessageService(databaseContext, mapper); string adminId = (await databaseContext.Users .FirstOrDefaultAsync(_ => _.UserName == ADMIN_USERNAME))?.Id; await DatabaseTestHelper.AddNewUser(USER_USERNAME, databaseContext); string userId = (await databaseContext.Users .FirstOrDefaultAsync(_ => _.UserName == USER_USERNAME))?.Id; Message messageFirst = new Message { SendingUserID = adminId, SentDate = DateTime.Now, Content = "First message's content", MessageReadStates = new List <MessageReadState>() { new MessageReadState { ReadDate = DateTime.Now, UserID = adminId } } }; Message messageLast = new Message { SendingUserID = adminId, SentDate = DateTime.Now, Content = "Last message's content", MessageReadStates = new List <MessageReadState>() { new MessageReadState { ReadDate = DateTime.Now, UserID = userId } } }; MessageThread thread = new MessageThread { Messages = new List <Message>() { messageFirst, messageLast }, MessageThreadParticipants = new List <MessageThreadParticipant>() { new MessageThreadParticipant { UserID = adminId }, new MessageThreadParticipant { UserID = userId } } }; await databaseContext.MessageThreads .AddAsync(thread); await databaseContext.SaveChangesAsync(); int numberOfMessageToGetFromThread = 1; MessageFilter messageFilter = new MessageFilter { NumberOfLastMessage = numberOfMessageToGetFromThread }; StatusCode <ThreadOut> status = await messageService.GetMessagesByThreadAndFilterAndUser(thread.ID, messageFilter, ADMIN_USERNAME); Assert.NotNull(status); Assert.Equal(StatusCodes.Status200OK, status.Code); Assert.NotNull(status.Body); Assert.IsType <ThreadOut>(status.Body); Assert.NotNull(status.Body.Messages); Assert.Equal(numberOfMessageToGetFromThread, status.Body.Messages.Count); Assert.Equal(messageLast.Content, status.Body.Messages[0].Content); Assert.NotNull(status.Body.MessageThreadParticipants); Assert.Equal(2, status.Body.MessageThreadParticipants.Count); Assert.NotNull(status.Body.Messages[0].MessageReadStates); Assert.Contains(status.Body.Messages[0].MessageReadStates, _ => _.UserId == adminId); Assert.Contains(databaseContext.MessageReadStates, _ => _.UserID == adminId && _.MessageID == status.Body.Messages[0].ID); }
public async Task <StatusCode <ThreadOut> > GetMessagesByThreadAndFilterAndUser(Guid threadId, MessageFilter messageFilter, string username) { string userId = (await _databaseContext.Users .FirstOrDefaultAsync(_ => _.UserName == username))?.Id; MessageThread messageThread = await _databaseContext.MessageThreads .FirstOrDefaultAsync(_ => _.ID == threadId); if (messageThread == null) { return(new StatusCode <ThreadOut>(StatusCodes.Status404NotFound, $"Thread {threadId} not found")); } List <MessageThreadParticipant> messageThreadParticipants = await _databaseContext.MessageThreadParticipants .Include(_ => _.User) .Where(_ => _.ThreadID == threadId) .ToListAsync(); if (messageThreadParticipants == null) { return(new StatusCode <ThreadOut>(StatusCodes.Status404NotFound, $"Thread participants not found")); } if (!messageThreadParticipants.Any(_ => _.UserID == userId)) { return(new StatusCode <ThreadOut>(StatusCodes.Status404NotFound, $"Thread {threadId} not found")); } List <Message> messages = await _databaseContext.Messages .Include(_ => _.SendingUser) .Where(_ => _.ThreadID == threadId) .ToListAsync(); if (messages == null) { return(new StatusCode <ThreadOut>(StatusCodes.Status404NotFound, $"Thread messages not found")); } for (int i = 0; i < messages.Count; ++i) { messages[i].MessageReadStates = await _databaseContext.MessageReadStates .Where(_ => _.MessageID == messages[i].ID) .ToListAsync(); if (!messages[i].MessageReadStates.Any(_ => _.UserID == userId)) { MessageReadState messageReadState = new MessageReadState { MessageID = messages[i].ID, ReadDate = DateTime.Now, UserID = userId }; _databaseContext.MessageReadStates .Add(messageReadState); messages[i].MessageReadStates.Add(messageReadState); await _databaseContext.SaveChangesAsync(); } } /* * int numberOfUnreadMessages = messageThread.Messages * .Where(_ => !_.MessageReadStates.Any(_ => _.UserID == userId)) * .Count(); */ if (messageFilter.NumberOfLastMessage < 1) { messageFilter.NumberOfLastMessage = 1; } messageThread.Messages = messageThread.Messages .OrderBy(_ => _.SentDate) .TakeLast(messageFilter.NumberOfLastMessage) .ToList(); ThreadOut result = _mapper.Map <ThreadOut>(messageThread); return(new StatusCode <ThreadOut>(StatusCodes.Status200OK, result)); }
public async Task <StatusCode <MessageOut> > SendMessage(MessagePost messagePost, string senderUsername) { if (!await _databaseContext.Users.AnyAsync(_ => _.UserName == messagePost.ToUserUsername)) { return(new StatusCode <MessageOut>(StatusCodes.Status404NotFound, $"{messagePost.ToUserUsername} user not found")); } string receiverId = (await _databaseContext.Users .FirstOrDefaultAsync(_ => _.UserName == messagePost.ToUserUsername))? .Id; string senderId = (await _databaseContext.Users .FirstOrDefaultAsync(_ => _.UserName == senderUsername))? .Id; MessageThread messageThread = await _databaseContext.MessageThreads .Include(_ => _.Messages) .Include(_ => _.MessageThreadParticipants) .Where(_ => _.MessageThreadParticipants.Any(_ => _.UserID == senderId)) .FirstOrDefaultAsync(_ => _.MessageThreadParticipants.Any(_ => _.UserID == receiverId)); if (messageThread == null) { messageThread = new MessageThread { MessageThreadParticipants = new List <MessageThreadParticipant> { new MessageThreadParticipant { UserID = senderId }, new MessageThreadParticipant { UserID = receiverId } } }; await _databaseContext.MessageThreads .AddAsync(messageThread); } DateTime sentDate = DateTime.Now; Message message = new Message { Content = messagePost.Content, SendingUserID = senderId, ThreadID = messageThread.ID, SentDate = sentDate, MessageReadStates = new List <MessageReadState> { new MessageReadState { ReadDate = sentDate, UserID = senderId } } }; await _databaseContext.Messages.AddAsync(message); await _databaseContext.SaveChangesAsync(); MessageOut result = _mapper.Map <MessageOut>(message); return(new StatusCode <MessageOut>(StatusCodes.Status200OK, result)); }
public long Add(MessageThread MessageThread) { context.MessageThreads.Add(MessageThread); context.SaveChanges(); return(MessageThread.Id); }
public async Task <IActionResult> SendToAll([Bind("Subject, Body")] MessageThreadDTO messageThreadDTO) { var adminUser = _context.User.Single(u => u.Email == User.Identity.Name); messageThreadDTO.SenderId = adminUser.Id; messageThreadDTO.AssetId = 0; MessageRepository messageRepo = new MessageRepository(_context); MessageThreadRepository messageThreadRepo = new MessageThreadRepository(_context); var users = _context.User.Where(u => u.Email != User.Identity.Name); foreach (ApplicationUser user in users) { messageThreadDTO.RecieverId = user.Id; // The reciever will always be the seller Message message; Notification notification; message = new Message(messageThreadDTO.Subject, messageThreadDTO.Body, false, false); string messageThreadId; string recieverEmail; string redirectURL; try { var messageThreadRetrieved = _context.MessageThread.Single(m => m.SenderId == messageThreadDTO.SenderId && m.RecieverId == messageThreadDTO.RecieverId); message.messageThread = messageThreadRetrieved; message.messageThread.LastUpdateDate = DateTime.Now; messageRepo.AddMessage(message); messageThreadId = message.messageThread.id.ToString(); if (User.Identity.Name == message.messageThread.RecieverEmail) { recieverEmail = message.messageThread.SenderEmail; message.messageThread.SenderUnreadMessageCount += 1; message.SenderUnread = true; } else { recieverEmail = message.messageThread.RecieverEmail; message.messageThread.RecieverUnreadMessageCount += 1; message.RecieverUnread = true; } } catch (InvalidOperationException) { messageRepo.AddMessage(message); MessageThread messageThread = new MessageThread(messageThreadDTO.SenderId, messageThreadDTO.RecieverId); messageThread.SenderEmail = _context.User.Single(u => u.Id == messageThreadDTO.SenderId).Email; messageThread.RecieverEmail = _context.User.Single(u => u.Id == messageThreadDTO.RecieverId).Email; messageThreadId = messageThread.id.ToString(); messageThread.messages.Add(message); if (User.Identity.Name == messageThread.RecieverEmail) { recieverEmail = messageThread.SenderEmail; messageThread.SenderUnreadMessageCount += 1; message.SenderUnread = true; } else { recieverEmail = messageThread.RecieverEmail; messageThread.RecieverUnreadMessageCount += 1; message.RecieverUnread = true; } messageThread.LastUpdateDate = DateTime.Now; messageThreadRepo.AddMessageThread(messageThread); } // This notification redirect URL should put the user to the discussion redirectURL = "/MessageThreads/Details/" + message.messageThread.id.ToString(); notification = new Notification(message.Subject, message.Body, redirectURL); Clients.Group(recieverEmail).AddNotificationToQueue(notification); } _context.SaveChanges(); foreach (ApplicationUser user in users) { Clients.Group(user.Email).UpdateOverallNotificationCount(); } return(RedirectToAction(nameof(AdminController.Index))); }
public bool IsMemberOfThread(Entity entity, MessageThread thread) { return(thread.Recipients.Any(r => r.EntityID == entity.EntityID)); }
public void AddRecipient(Entity entity, MessageThread thread) { thread.Recipients.Add(entity); messageRepository.SaveChanges(); }
public IHttpActionResult AddMessage(MessageModel Model) { long Id = 0; try { Message message = new Message { Id = Model.Id, ThreadId = Model.ThreadId, MessageText = Model.MessageText, SenderId = Model.SenderId, RecieverId = Model.RecieverId, Status = (int)Constant.MessageStatus.Initial, Time = DateTime.Now.ToUniversalTime() }; using (AppDBContext context = new AppDBContext()) { var userRepo = new UserRepository(context); var sender = userRepo.GetByUserId(message.SenderId); var recipient = userRepo.GetByUserId(message.RecieverId); if (message.ThreadId == 0) { long agentId = 0; long buyerId = 0; if (sender.UserType == Constant.UserType.BUYER) { buyerId = sender.Id; agentId = recipient.Id; } else { buyerId = recipient.Id; agentId = sender.Id; new AgentServiceRequestRepository(context).UpdateResponseTime(Model.RequestId, agentId); } var existingthread = new MessageThreadRepository(context).GetByAgentId(agentId).Where( t => t.RequestId == Model.RequestId && t.BuyerId == buyerId).FirstOrDefault(); if (existingthread == null) { MessageThread thread = new MessageThread(); thread.AgentId = agentId; thread.BuyerId = buyerId; thread.RequestId = Model.RequestId; thread.CreatedBy = Model.SenderId; thread.CreatedTime = DateTime.Now.ToUniversalTime(); var repo = new MessageThreadRepository(context); long tid = repo.Add(thread); message.ThreadId = tid; } else { message.ThreadId = existingthread.Id; } } if (sender.UserType == Constant.UserType.BUYER) { new ServiceRequestRepository(context).UpdateBuyerResponded(Model.RequestId); } Id = new MessageRepository(context).Add(message); new NotificationRepository(context).Add( recipient.Id, (int)Constant.NotificationType.Message, message.ThreadId, ConfigurationHelper.NOTIFICATION_TITLE, Constant.Notification.NEW_MESSAGE_TEXT); } } catch (Exception ex) { Logger.Log(typeof(MessageController), ex.Message + ex.StackTrace, LogType.ERROR); InternalServerError(ex); } return(Ok(Id)); }
public void Add(MessageThread thread) { context.Set <MessageThread>().Add(thread); }
public async void Returns_Status404NotFound_when_ThreadNotBelongsToUser() { IDatabaseContext databaseContext = DatabaseTestHelper.GetContext(); MapperConfiguration mapperConfiguration = new MapperConfiguration(conf => { conf.AddProfile(new MessageThread_to_ThreadOut()); conf.AddProfile(new MessageReadState_to_MessageReadStateOut()); conf.AddProfile(new Message_to_MessageOut()); conf.AddProfile(new MessageThreadParticipant_to_MessageThreadParticipantOut()); }); IMapper mapper = mapperConfiguration.CreateMapper(); IMessageService messageService = new MessageService(databaseContext, mapper); string adminId = (await databaseContext.Users .FirstOrDefaultAsync(_ => _.UserName == ADMIN_USERNAME))?.Id; await DatabaseTestHelper.AddNewUser(USER_USERNAME, databaseContext); string userId = (await databaseContext.Users .FirstOrDefaultAsync(_ => _.UserName == USER_USERNAME))?.Id; MessageReadState messageReadState = new MessageReadState { ReadDate = DateTime.Now, UserID = adminId }; Message messageFirst = new Message { SendingUserID = adminId, SentDate = DateTime.Now, Content = "First message's content" }; Message messageLast = new Message { SendingUserID = adminId, SentDate = DateTime.Now, Content = "Last message's content", MessageReadStates = new List <MessageReadState>() { messageReadState } }; MessageThread thread = new MessageThread { Messages = new List <Message>() { messageFirst, messageLast }, MessageThreadParticipants = new List <MessageThreadParticipant>() { new MessageThreadParticipant { UserID = Guid.NewGuid().ToString() }, new MessageThreadParticipant { UserID = Guid.NewGuid().ToString() } } }; await databaseContext.MessageThreads .AddAsync(thread); await databaseContext.SaveChangesAsync(); int numberOfMessageToGetFromThread = 1; MessageFilter messageFilter = new MessageFilter { NumberOfLastMessage = numberOfMessageToGetFromThread }; StatusCode <ThreadOut> status = await messageService.GetMessagesByThreadAndFilterAndUser(thread.ID, messageFilter, USER_USERNAME); Assert.NotNull(status); Assert.Equal(StatusCodes.Status404NotFound, status.Code); }
public void Subscribe <T>(Action <T> messageHandler, MessageThread thread) { subscribeInternal(typeof(T), messageHandler, thread); }
/// <summary> /// Open MidiOut. MidiOut��J�� /// </summary> /// <param name="deviceId">MidiOut.MidiMapper or index of GetDeviceNames(). MidiOut.MidiMapper���AGetDeviceNames()��index</param> public MidiOut(int deviceId) { eventHandler = new MessageThread(); eventHandler.MessageHandlers[Win32.MM_MOM_DONE] = delegate(Message m) { Win32.MidiHeader hdr = Win32.MidiHeader.FromIntPtr(m.LParam); MidiBuffer buf = MidiBuffer.FromMidiHeader(hdr); Win32.midiOutUnprepareHeader(deviceHandle, buf.pHeader, Win32.MidiHeader.SizeOfMidiHeader); buf.Dispose(); Interlocked.Add(ref enqueuedBufferSize, -buf.BufferLength); if (OnDone != null) OnDone(); }; int mmret = Win32.midiOutOpen(out deviceHandle, (uint)deviceId, new IntPtr(eventHandler.Win32ThreadID), IntPtr.Zero, Win32.CALLBACK_THREAD); if (mmret != Win32.MMSYSERR_NOERROR) { eventHandler.Dispose(); throw new Exception("�f�o�C�X���J���܂���ł����B(" + mmret + ")"); } }
public void SetAssociatedMessageThread(MessageThread newThread) { associatedThread = newThread; }
static MessageThread ParseThread (ImapEngine engine, uint uidValidity, CancellationToken cancellationToken) { var token = engine.ReadToken (cancellationToken); MessageThread thread, node, child; uint uid; if (token.Type != ImapTokenType.Atom || !uint.TryParse ((string) token.Value, out uid)) throw ImapEngine.UnexpectedToken (token, false); node = thread = new MessageThread (new UniqueId (uidValidity, uid)); do { token = engine.ReadToken (cancellationToken); if (token.Type == ImapTokenType.CloseParen) break; if (token.Type == ImapTokenType.OpenParen) { child = ParseThread (engine, uidValidity, cancellationToken); node.Children.Add (child); } else { if (token.Type != ImapTokenType.Atom || !uint.TryParse ((string) token.Value, out uid)) throw ImapEngine.UnexpectedToken (token, false); child = new MessageThread (new UniqueId (uidValidity, uid)); node.Children.Add (child); node = child; } } while (true); return thread; }
public void testGetInd() { string subject = "This is a test subject."; string body = "This is a test body"; var options = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(databaseName: "API_GetInd_Database") .Options; using (var context = new ApplicationDbContext(options)) { IMessageRepository messageRepo = new MessageRepository(context); IMessageThreadRepository messageThreadRepo = new MessageThreadRepository(context); var mockConnectionManager = new Mock <IConnectionManager>(); var controller = new MessagesAPIController(messageRepo, messageThreadRepo, mockConnectionManager.Object); OkObjectResult getResult = (OkObjectResult)controller.Get(); List <Message> messageList = (List <Message>)getResult.Value; Assert.True(messageList.Count == 0); } MessageThread messageThread = new MessageThread(); messageThread.id = Guid.NewGuid(); using (var context = new ApplicationDbContext(options)) { IMessageRepository messageRepo = new MessageRepository(context); IMessageThreadRepository messageThreadRepo = new MessageThreadRepository(context); context.MessageThread.Add(messageThread); context.SaveChanges(); var mockConnectionManager = new Mock <IConnectionManager>(); var controller = new MessagesAPIController(messageRepo, messageThreadRepo, mockConnectionManager.Object); MessageDTO messageDTO = new MessageDTO(subject, body, messageThread.id.ToString()); controller.Post(messageDTO); } using (var context = new ApplicationDbContext(options)) { IMessageRepository messageRepo = new MessageRepository(context); IMessageThreadRepository messageThreadRepo = new MessageThreadRepository(context); var mockConnectionManager = new Mock <IConnectionManager>(); var controller = new MessagesAPIController(messageRepo, messageThreadRepo, mockConnectionManager.Object); OkObjectResult getResult = (OkObjectResult)controller.Get(); List <Message> messageList = (List <Message>)getResult.Value; Assert.True(messageList.Count == 1); } using (var context = new ApplicationDbContext(options)) { IMessageRepository messageRepo = new MessageRepository(context); IMessageThreadRepository messageThreadRepo = new MessageThreadRepository(context); var mockConnectionManager = new Mock <IConnectionManager>(); var controller = new MessagesAPIController(messageRepo, messageThreadRepo, mockConnectionManager.Object); Guid messageIdGuid = context.Message.Single(m => m.Subject == subject).id; OkObjectResult messageRetrievedObject = (OkObjectResult)controller.Get(messageIdGuid.ToString()); Message messageRetrieved = (Message)messageRetrievedObject.Value; Assert.True(messageRetrieved.id == messageIdGuid); } }