public IActionResult Post([FromBody] Message message)
{
var messages = _context.Messages.Add(message);
_context.SaveChanges();
return(Ok());
}
public T Insert(T entity)
{
T result = m_DbContext.Set <T>().Add(entity).Entity;
m_DbContext.SaveChanges();
return(result);
}
public int Create(UserFriend userFriend)
{
Context.UserFriends.Add(userFriend);
Context.SaveChanges();
return(userFriend.FriendId);
}
public void Insert(T entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
entities.Add(entity);
context.SaveChanges();
}
public IActionResult DeleteById(int id, [FromHeader] int UserID, [FromHeader] string UserRole)
{
var chat = _context.Chats.Find(id);
if (chat == null)
{
return(StatusCode(StatusCodes.Status404NotFound));
}
if (_user.GetUserById(UserID) == null)
{
return(StatusCode(StatusCodes.Status400BadRequest));
}
if (chat.CreatedBy != UserID && UserRole != "Admin")
{
return(StatusCode(StatusCodes.Status403Forbidden));
}
_context.Chats.Remove(chat);
var success = _context.SaveChanges();
if (success < 1)
{
return(StatusCode(StatusCodes.Status400BadRequest));
}
this._loggerCommunication.logAction("Deleted a chat with id:" + id);
return(StatusCode(StatusCodes.Status202Accepted, new JsonResult(chat)));
}
public static void CleanupTestTrack()
{
int deleteResult = -1;
MessagingContext context = null;
#region Clean database of records added during test
try
{
using (context = new MessagingContext(connectionStringName))
{
MessagePing recordToDelete = context.FindOne(new object[] { recordId });
bool recordIsNotAvailable = null != recordToDelete;
if (recordIsNotAvailable)
{
context.Remove(recordToDelete);
deleteResult = context.SaveChanges();
}
}
}
catch { }
finally
{
if (null != context)
{
context.Dispose();
}
}
#endregion
}
public JsonResult MessagesViewed()
{
string user = User.Identity.GetUserName();
using (var db = new MessagingContext())
{
var updateQuery = db.Messages.Where(f => f.ToUserID == user).ToList();
updateQuery.ForEach(a => a.Seen = true);
var ImageDeleteQuery = db.Messages.Where(f => f.ToUserID == user && f.Image != null).ToList();
foreach (var item in ImageDeleteQuery)
{
string fullPath = Request.MapPath("~/ContentUser/" + Encoding.ASCII.GetString(item.Image));
if (System.IO.File.Exists(fullPath))
{
System.IO.File.Delete(fullPath);
}
}
//db.Messages.RemoveRange(db.Messages.Where(f => f.ToUserID == user && f.Image != null));
db.SaveChanges();
return(Json(new { result = "ok" }));
}
}
public int Create(User user)
{
Context.Users.Add(user);
Context.SaveChanges();
return(user.UserId);
}
/* This thread ensures that messages aggregated from various partners are added to the queue in the correct order */
public void HandleQueueBuffer()
{
/* Iterate over all the queues and look for messages that expired their indexing period and should enter the queue */
using (var ctx = new MessagingContext())
{
foreach (var q in ctx.MsgQueues)
{
var messages = ctx.QueueBuffer.Where(m => (m.QueueId == q.Id));
var messageList = new List <QueueBuffer>();
foreach (var m in messages)
{
if (DateTime.UtcNow.Ticks + Config <long> .GetInstance()["TIMEZONE_CORRECTION"] > m.Timestamp + Config <int> .GetInstance()["QUEUE_GRACE_PERIOD"])
{
/* Add this message to the queue. We assume that by now all slaves have synced */
messageList.Add(m);
}
}
/* Sort by time of arrival */
messageList.Sort((a, b) => ((int)(a.Timestamp - b.Timestamp)));
foreach (var m in messageList)
{
WriteQueue(ctx, m.UserId, m.NodeId, m.QueueId, m.Data, m.Timestamp);
ctx.QueueBuffer.Remove(m);
/* Important to save here for consistancy */
ctx.SaveChanges();
}
}
}
}
public void CommitQueue(int userId, int nodeId, int readerId, int readerNodeId, string queueName)
{
using (var ctx = new MessagingContext())
{
//var r = ctx.Readers.FirstOrDefault(reader => reader.UserId == userId && reader.NodeId == nodeId);
var r = ctx.Readers.FirstOrDefault(reader => reader.UserId == readerId && reader.NodeId == readerNodeId);
/* For now, remember messages only until the last user read them */
var q = ctx.MsgQueues.FirstOrDefault(queue => queue.Name == queueName && queue.UserId == userId && queue.NodeId == nodeId);
int highestIndex = ctx.Readers.FirstOrDefault(reader => reader.UserId == readerId && reader.NodeId == readerNodeId).Position;
foreach (Message m in q.Messages.FindAll(m => (m.MsgIdx > highestIndex)))
{
if (m.MsgIdx > highestIndex)
{
highestIndex = m.MsgIdx;
}
}
r.Position = highestIndex;
q.Messages.RemoveAll(m => (m.MsgIdx <= q.Readers.Min(rUser => (rUser.Position))));
ctx.SaveChanges();
}
}
static void Main(string[] args)
{
string url = "http://localhost:45000";
using (WebApp.Start(url))
{
Console.WriteLine("Server running on {0}", url);
while (Console.ReadKey().Key != ConsoleKey.Q)
{
Console.WriteLine("Create new random message");
using (var db = new MessagingContext())
{
var message = new Message
{
Id = Guid.NewGuid().ToString(),
ClientId = "SystemID",
DateTime = DateTimeOffset.Now,
Text = "Random generated value: " + new Random().Next(1000)
};
db.Messages.Add(message);
db.SaveChanges();
Console.WriteLine(
$"Client '{message.ClientId}' created message '{message.Text}' at {message.DateTime}");
}
}
}
}
public void CreateQueue(int userId, int nodeId, string queueName, List <List <int> > readers)
{
using (var ctx = new MessagingContext())
{
var u = ctx.Users.Include(user => user.Queues).First(user => user.Id == userId && user.IssueNodeId == nodeId);
if (u == null)
{
throw new Exception("Invalid userId");
}
if (u.Queues == null)
{
u.Queues = new List <MsgQueue>();
}
if (u.Queues.Find(queue => (queue.Name == queueName)) != null)
{
throw new Exception("Invalid queue name: Already exists");
}
if (u.Queues.Count >= Config <int> .GetInstance()["USER_MAX_QUEUES"])
{
throw new Exception("User has too many queues.");
}
/* Create a dictionary with mapping for everyone */
var newQueue = new MsgQueue()
{
Name = queueName, TopMsgIdx = 0, Readers = new List <Reader>()
};
foreach (var uid in readers)
{
var reader = ctx.Users.Find(uid[0], uid[1]);
/* Invalid reader Id */
if (reader == null)
{
continue;
}
var r = new Reader {
User = reader, Position = newQueue.TopMsgIdx - 1, NodeId = nodeId, UserId = userId, Queue = newQueue
};
ctx.Readers.Add(r);
newQueue.Readers.Add(r);
}
u.Queues.Add(newQueue);
ctx.SaveChanges();
}
}
private void CleanOldMessageQueues(MessagingContext ctx, MsgQueue q)
{
/* Clean old messages */
foreach (var m in q.Messages.FindAll(m => ((m.Timestamp + Config <int> .GetInstance()["QUEUE_MESSAGE_MAX_AGE"]) / 100 < DateTime.UtcNow.Ticks / 100)))
{
q.Messages.Remove(m);
ctx.Messages.Remove(m);
}
ctx.SaveChanges();
}
public void AddUpdateDeleteUser()
{
user = new User {
Id = 1, Login = "******"
};
context.Users.Add(user);
context.SaveChanges();
var userFromDb = context.Users.Find(1);
Assert.IsNotNull(userFromDb);
Assert.AreEqual(userFromDb.Id, 1);
Assert.AreEqual(userFromDb.Login, "NK");
user.Login = "******";
context.Users.Update(user);
context.SaveChanges();
userFromDb = context.Users.Find(1);
Assert.IsNotNull(userFromDb);
Assert.AreEqual(userFromDb.Id, 1);
Assert.AreEqual(userFromDb.Login, "neNK");
context.Users.Remove(user);
context.SaveChanges();
userFromDb = context.Users.Find(1);
Assert.IsNull(userFromDb);
}
public static int RegisterUser(int NodeId, int UserId, byte[] key)
{
var u = new User {
Id = UserId, IssueNodeId = NodeId, Key = ComputeHash(key), Queues = new List <MsgQueue>()
};
using (var ctx = new MessagingContext())
{
ctx.Users.Add(u);
ctx.SaveChanges();
}
return(u.Id);
}
public ActionResult SendMessage(SendMessageViewModel model)
{
Message msg = CreateNewMessage();
msg.MessageText = model.MessageText;
using (var db = new MessagingContext())
{
db.Messages.Add(msg);
db.SaveChanges();
}
ModelState.Clear();
return(View("Index"));
}
public void Create(MessageDto dto)
{
var messageToSave = new Message
{
Description = dto.Description,
Title = dto.Title,
CreatedDate = DateTime.UtcNow,
User = dto.User
};
_context.Messages.Add(messageToSave);
_context.SaveChanges();
dto.CreatedDate = messageToSave.CreatedDate;
}
public static string generateSessionKey(int id, int nodeId)
{
var sess = _generateSessionKey();
using (var ctx = new MessagingContext())
{
while (ctx.Users.FirstOrDefault(user => (user.SessionKey == sess)) != null)
{
sess = _generateSessionKey();
}
var u = ctx.Users.Find(id, nodeId);
u.SessionKey = sess;
ctx.SaveChanges();
}
return(sess);
}
public async Task SendMessage(string message, string sentTo)
{
string userName;
try
{
userName = Context.User.Identity.Name;
_context.Message.Add(new Message()
{
MessageText = message, SentFrom = userName, SentTo = sentTo
});
_context.SaveChanges();
}
catch (System.NullReferenceException)
{
//Username unavailable
userName = "******";
}
await Clients.All.SendAsync("ReceiveMessage", userName, message);
}
public bool WriteBufferedQueue(int userId, int nodeId, string queueName, string Data, DateTime Timestamp)
{
using (var ctx = new MessagingContext())
{
var u = ctx.Users.Include(user => user.Queues).FirstOrDefault(user => user.Id == userId && user.IssueNodeId == nodeId);
if (u == null)
{
throw new Exception("Invalid userId");
}
var q = u.Queues.Find(queue => (queue.Name == queueName));
if (q == null)
{
throw new Exception("Invalid queue");
}
/* Clean old messages */
CleanOldMessageQueues(ctx, q);
var queuedMessagesSize = ctx.QueueBuffer.Where(qb => qb.QueueId == q.Id).Select(qb => qb.Data).ToList().Sum(d => d.Length);
var queueContentLength = q.Messages.Select(m => m.Content).ToList().Sum(m => m.Length);
if (!IsEnoughQueueSpace(queuedMessagesSize, queueContentLength, Data))
{
return(false);
}
ctx.QueueBuffer.Add(new QueueBuffer {
User = u, Queue = q, Timestamp = Timestamp.Ticks, Data = Data
});
ctx.SaveChanges();
}
return(true);
}
private void WriteQueue(MessagingContext ctx, int userId, int nodeId, int queueId, string Data, long Timestamp)
{
var u = ctx.Users.Include(user => user.Queues).FirstOrDefault(user => user.Id == userId && user.IssueNodeId == nodeId);
if (u == null)
{
throw new Exception("Invalid userId");
}
var q = ctx.MsgQueues.Include(queue => queue.Messages).FirstOrDefault(queue => (queue.Id == queueId));
if (q == null)
{
throw new Exception("Invalid queue");
}
q.Messages.Add(new Message {
Content = Data, MsgIdx = q.TopMsgIdx++, Timestamp = Timestamp, QueueId = queueId, Queue = q
});
ctx.SaveChanges();
}
public ActionResult FileUpload(HttpPostedFileBase file)
{
if (file != null)
{
var fileName = Guid.NewGuid().ToString() +
System.IO.Path.GetExtension(file.FileName);
string contentFolder = Server.MapPath("~/ContentUser");
string fullFileName = Path.Combine(contentFolder, fileName);
file.SaveAs(Path.Combine(contentFolder, fileName));
//string pic = System.IO.Path.GetFileName(file.FileName);
/* byte[] array = null;
* using (MemoryStream ms = new MemoryStream())
* {
* file.InputStream.CopyTo(ms);
* array = ms.GetBuffer();
* }*/
Message msg = CreateNewMessage();
msg.Image = Encoding.ASCII.GetBytes(fileName);
using (var db = new MessagingContext())
{
db.Messages.Add(msg);
db.SaveChanges();
}
ModelState.Clear();
return(View("Index"));
}
// after successfully uploading redirect the user
return(RedirectToAction("actionname", "controller name"));
}
public static int RegisterUser(int NodeId, byte[] key)
{
var u = new User {
IssueNodeId = NodeId, Key = ComputeHash(key), Queues = new List <MsgQueue>()
};
using (var ctx = new MessagingContext())
{
/* Generate an incrementing Id as SQLite apparently drops the autoincrement when there are multiple fields for PK */
try
{
u.Id = ctx.Users.Max(user => user.Id) + 1;
}
catch (InvalidOperationException e)
{
u.Id = 0;
}
ctx.Users.Add(u);
ctx.SaveChanges();
}
return(u.Id);
}
public List <string> ReadQueue(int requestingUser, int userId, int nodeId, string queueName, bool commit)
{
var messages = new List <string>();
using (var ctx = new MessagingContext())
{
var u = ctx.Users.Include(user => user.Queues).FirstOrDefault(user => user.Id == userId && user.IssueNodeId == nodeId);
if (u == null)
{
throw new Exception("Invalid userId");
}
var reader = ctx.Users.Find(requestingUser, nodeId);
if (reader == null)
{
throw new Exception("Invalid readerId");
}
var q = u.Queues.Find(queue => (queue.Name == queueName));
if (q == null)
{
throw new Exception("Invalid queue");
}
/* Clean old messages */
CleanOldMessageQueues(ctx, q);
var r = q.Readers.Find(uReader => (uReader.UserId == requestingUser && uReader.NodeId == nodeId));
if (r == null)
{
throw new Exception("Permission denied: Invalid reader");
}
int highestIndex = r.Position;
//q = ctx.MsgQueues.Include(queue => queue.Messages).FirstOrDefault(queue => queue.Id == q.Id);
Console.WriteLine("Queue " + q.Id + " Count: " + q.Messages.Count);
foreach (Message m in q.Messages.FindAll(m => (m.MsgIdx > highestIndex)))
{
messages.Add(m.Content);
if (m.MsgIdx > highestIndex)
{
highestIndex = m.MsgIdx;
}
}
if (commit)
{
/* Update user commit message */
r.Position = highestIndex;
/* For now, remember messages only until the last user read them */
foreach (var m in q.Messages.FindAll(m => (m.MsgIdx <= q.Readers.Min(rUser => (rUser.Position)))))
{
q.Messages.Remove(m);
ctx.Messages.Remove(m);
}
}
ctx.SaveChanges();
}
return(messages);
}
public void UpdateRecordToDatabase()
{
#region Test Setup
MessagePing testSubject;
#endregion
#region Test
using (var context = new MessagingContext(connectionStringName))
{
try
{
testSubject = AssertRecordExistence(recordId, context);
}
catch (AssertFailedException)
{
AddRecordsToDatabase();
testSubject = AssertRecordExistence(recordId, context);
}
testSubject.Message = updatedMessage;
context.SaveChanges();
}
testSubject = null;
using (var context = new MessagingContext(connectionStringName))
{
testSubject = context.FindOne(new object[] { recordId });
Assert.IsNotNull(testSubject, "Record not found in database");
Assert.IsTrue(updatedMessage == testSubject.Message, "Record was not updated");
}
#endregion
}
