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