internal ResultBase SendMessage(string userKey, string message, string communityId)
{
IMongoCollection <DBEntry.Community> communitiesCollection = Program.Database.GetCollection <DBEntry.Community>("communities");
IMongoCollection <DBEntry.Message> messageCollection = Program.Database.GetCollection <DBEntry.Message>("messages");
(UserGatewayController.CheckUserResult userResult, DBEntry.User user) = UserGatewayController.CheckUser(userKey);
if (!userResult.success)
{
return(userResult);
}
List <DBEntry.Community> communities = communitiesCollection.Find(x => x.UniqueName == communityId).ToList();
if (communities.Count != 1)
{
return(new Api.Result()
{
type = "no community", authorized = true, success = false, message = "community does not exists"
});
}
DBEntry.Community community = communities[0];
if (!community.Users.Contains(user.Username))
{
return(new Api.Result()
{
type = "unauthorized for community", authorized = true, success = false, message = "you are not part of that community"
});
}
MongoDB.Bson.ObjectId objectId = MongoDB.Bson.ObjectId.GenerateNewId();
messageCollection.InsertOneAsync(new DBEntry.Message()
{
Author = user.Username, CommunityId = communityId, Content = message, Ip = Request.HttpContext.Connection.RemoteIpAddress.ToString(), TimeOfSending = DateTime.Now, _id = objectId
});
if (RESTMessageDictionary.ContainsKey(community.UniqueName))
{
GetMessageResult.Message RESTMessage = new GetMessageResult.Message()
{
author = user.Username,
content = message,
timeOfSending = ((DateTimeOffset)DateTime.Now).ToUnixTimeSeconds(),
objectId = objectId.ToString()
};
while (RESTMessageDictionary[community.UniqueName].Count != 0)
{
if (!RESTMessageDictionary[community.UniqueName][0].Task.Task.IsCompleted)
{
RESTMessageDictionary[community.UniqueName][0].Task.SetResult(RESTMessage);
}
try {
RESTMessageDictionary[community.UniqueName].RemoveAt(0);
}
catch (Exception) { };
}
}
return(new Api.Result()
{
type = "successful", authorized = true, success = true, message = "all good"
});
}
internal GetCommunityResult GetCommunity(string userKey, string uniqueName)
{
IMongoCollection <DBEntry.Community> communitiesCollection = Program.Database.GetCollection <DBEntry.Community>("communities");
IMongoCollection <DBEntry.User> usersCollection = Program.Database.GetCollection <DBEntry.User>("users");
(UserGatewayController.CheckUserResult userResult, DBEntry.User user) = UserGatewayController.CheckUser(userKey);
if (!userResult.success)
{
return(new GetCommunityResult()
{
authorized = userResult.authorized,
community = null,
message = userResult.message,
success = userResult.success,
type = userResult.type
});
}
List <DBEntry.Community> communities = communitiesCollection.Find(x => x.UniqueName == uniqueName).ToList();
if (communities.Count != 1)
{
return(new GetCommunityResult()
{
type = "unsuccessful", authorized = true, success = false, message = "community doesnt exist", community = null
});
}
DBEntry.Community dbCommunity = communities[0];
if (!dbCommunity.Users.Contains(user.Username))
{
return(new GetCommunityResult()
{
type = "unsuccessful",
authorized = true,
success = false,
message = "you are not a part of that community",
community = null
});
}
return(new GetCommunityResult()
{
type = "successful",
authorized = true,
success = true,
message = "all good",
community = new GetCommunityResult.Community()
{
admins = dbCommunity.Admins,
description = dbCommunity.Description,
name = dbCommunity.Name,
owner = dbCommunity.Owner,
uniqueName = dbCommunity.UniqueName,
users = dbCommunity.Users,
boxKey = dbCommunity.Boxes.Select(x => x.Key).ToArray(),
boxLocation = dbCommunity.Boxes.Select(x => x.Location).ToArray(),
boxName = dbCommunity.Boxes.Select(x => x.Name).ToArray(),
}
});
}
internal UsersResult Users(string userKey, string query, int skip, int limit)
{
IMongoCollection <DBEntry.Community> communitiesCollection = Program.Database.GetCollection <DBEntry.Community>("communities");
IMongoCollection <DBEntry.User> usersCollection = Program.Database.GetCollection <DBEntry.User>("users");
List <DBEntry.User> dbUsers = usersCollection.Find(x => x.Cookie == userKey).ToList();
(UserGatewayController.CheckUserResult userResult, DBEntry.User user) = UserGatewayController.CheckUser(userKey);
if (!userResult.success)
{
return(new UsersResult()
{
queryReturn = null,
authorized = userResult.authorized,
message = userResult.message,
success = userResult.success,
type = userResult.type,
});
}
List <DBEntry.Community> communities = communitiesCollection.Find(x => x.Users.Contains(user.Username)).ToList();
List <DBEntry.User> commonUsers = usersCollection.
Find(x => x.Username.Contains(query) && x.Username != user.Username &&
communities.Any(y => y.Users.Contains(x.Username))).Limit(limit + skip).ToList();
List <DBEntry.User> uncommonUsers = usersCollection.
Find(x => x.Username.Contains(query) && x.Username != user.Username &&
commonUsers.Any(y => y.Username == x.Username)).Limit(commonUsers.Count - (limit + skip)).ToList();
List <UsersResult.QueryReturn> queryReturn = new List <UsersResult.QueryReturn>();
commonUsers.ForEach(x => {
List <string> commonCommunities = new List <string>();
communities.ForEach(y => {
if (y.Users.Contains(x.Username))
{
commonCommunities.Add(y.UniqueName);
}
});
queryReturn.Add(new UsersResult.QueryReturn()
{
username = x.Username,
commonCommunities = commonCommunities.ToArray()
});
});
uncommonUsers.ForEach(x => {
queryReturn.Add(new UsersResult.QueryReturn()
{
username = x.Username,
commonCommunities = null
});
});
return(new UsersResult()
{
type = "successful",
authorized = true,
success = true,
message = "all good",
queryReturn = queryReturn.ToArray()
});
}
internal ResultBase RenameBox(string userKey, string boxKey, string newName)
{
(UserGatewayController.CheckUserResult userResult, DBEntry.User user) = UserGatewayController.CheckUser(userKey);
if (!userResult.success)
{
return(userResult);
}
IMongoCollection <DBEntry.User> usersCollection = Program.Database.GetCollection <DBEntry.User>("users");
IMongoCollection <DBEntry.Community> communitiesCollection = Program.Database.GetCollection <DBEntry.Community>("communities");
List <DBEntry.User> boxesUser = usersCollection.Find(x => x.Boxes.Any(y => y.Key == boxKey)).ToList();
List <DBEntry.Community> boxesCommunity = communitiesCollection.Find(x => x.Boxes.Any(y => y.Key == boxKey)).ToList();
if (boxesCommunity.Count + boxesUser.Count != 1)
{
return(new Result()
{
authorized = true,
success = true,
type = "unsuccessful",
message = "nfc id does not exist"
});
}
DBEntry.Box box = boxesCommunity.Select(x => x.Boxes.First(y => y.Key == boxKey)).Concat(boxesUser.Select(x => x.Boxes.First(y => y.Key == boxKey))).ElementAt(0);
box.Name = newName;
if (boxesUser.Select(x => x.Boxes.First(y => y.Key == box.Key)).Count() == 1)
{
DBEntry.User replaceUser = boxesUser.ElementAt(0);
for (int i = 0; i < replaceUser.Boxes.Length; i++)
{
if (replaceUser.Boxes[i].Key == box.Key)
{
replaceUser.Boxes[i] = box;
}
}
usersCollection.ReplaceOne(x => x.Username == replaceUser.Username, replaceUser);
}
else
{
DBEntry.Community replaceCommunity = boxesCommunity.ElementAt(0);
for (int i = 0; i < replaceCommunity.Boxes.Length; i++)
{
if (replaceCommunity.Boxes[i].Key == box.Key)
{
replaceCommunity.Boxes[i] = box;
}
}
communitiesCollection.ReplaceOne(x => x.UniqueName == replaceCommunity.UniqueName, replaceCommunity);
}
return(new Result()
{
authorized = true,
message = "all good",
success = true,
type = "successful"
});
}
internal GetMessageResult GetMessage(string userKey, string communityId, int skip, int limit)
{
IMongoCollection <DBEntry.Community> communitiesCollection = Program.Database.GetCollection <DBEntry.Community>("communities");
IMongoCollection <DBEntry.Message> messageCollection = Program.Database.GetCollection <DBEntry.Message>("messages");
(UserGatewayController.CheckUserResult userResult, DBEntry.User user) = UserGatewayController.CheckUser(userKey);
if (!userResult.success)
{
return(new GetMessageResult()
{
authorized = userResult.authorized,
message = userResult.message,
messages = null,
success = userResult.success,
type = userResult.type,
});
}
List <DBEntry.Community> communities = communitiesCollection.Find(x => x.UniqueName == communityId).ToList();
if (communities.Count != 1)
{
return(new GetMessageResult()
{
type = "no community", authorized = true, success = false, message = "community does not exists", messages = new GetMessageResult.Message[0]
});
}
DBEntry.Community community = communities[0];
if (!community.Users.Contains(user.Username))
{
return(new GetMessageResult()
{
type = "unauthorized for community", authorized = true, success = false, message = "you are not part of that community", messages = new GetMessageResult.Message[0]
});
}
List <DBEntry.Message> dbMessages = messageCollection.Find(x => x.CommunityId == communityId).SortByDescending(x => x.TimeOfSending).Skip(skip).Limit(limit).ToList();
List <GetMessageResult.Message> messages = new List <GetMessageResult.Message>();
foreach (DBEntry.Message message in dbMessages)
{
messages.Add(new GetMessageResult.Message()
{
author = message.Author,
content = message.Content,
timeOfSending = ((DateTimeOffset)message.TimeOfSending).ToUnixTimeSeconds(),
objectId = message._id.ToString()
});
}
return(new GetMessageResult()
{
type = "successful", authorized = true, success = true, message = "all good", messages = messages.ToArray()
});
}
internal GetMyResult GetMy(string userKey)
{
IMongoCollection <DBEntry.Community> communitiesCollection = Program.Database.GetCollection <DBEntry.Community>("communities");
IMongoCollection <DBEntry.User> usersCollection = Program.Database.GetCollection <DBEntry.User>("users");
(UserGatewayController.CheckUserResult userResult, DBEntry.User user) = UserGatewayController.CheckUser(userKey);
if (!userResult.success)
{
return(new GetMyResult()
{
type = userResult.type,
authorized = userResult.authorized,
communities = null,
message = userResult.message,
success = userResult.success
});
}
List <DBEntry.Community> dbCommunities = communitiesCollection.Find(x => x.Users.Contains(user.Username)).ToList();
List <GetMyResult.Community> communities = new List <GetMyResult.Community>();
foreach (DBEntry.Community community in dbCommunities)
{
communities.Add(new GetMyResult.Community()
{
name = community.Name,
admins = community.Admins,
description = community.Description,
owner = community.Owner,
uniqueName = community.UniqueName,
users = community.Users
});
}
return(new GetMyResult()
{
type = "successful", authorized = true, success = true, message = "all good", communities = communities.ToArray()
});
}
internal async Task <RESTMessageResult> RESTMessage(string userKey, string communityId)
{
IMongoCollection <DBEntry.Community> communitiesCollection = Program.Database.GetCollection <DBEntry.Community>("communities");
IMongoCollection <DBEntry.Message> messageCollection = Program.Database.GetCollection <DBEntry.Message>("messages");
(UserGatewayController.CheckUserResult userResult, DBEntry.User user) = UserGatewayController.CheckUser(userKey);
if (!userResult.success)
{
return(new RESTMessageResult()
{
authorized = userResult.authorized,
message = userResult.message,
restMessage = null,
success = userResult.success,
type = userResult.type
});
}
List <DBEntry.Community> communities = communitiesCollection.Find(x => x.UniqueName == communityId).ToList();
if (communities.Count != 1)
{
return(new RESTMessageResult()
{
type = "no community", authorized = true, success = false, message = "community does not exists"
});
}
DBEntry.Community community = communities[0];
if (!community.Users.Contains(user.Username))
{
return(new RESTMessageResult()
{
type = "unauthorized for community", authorized = true, success = false, message = "you are not part of that community"
});
}
TaskCompletionSource <GetMessageResult.Message> tcs = new TaskCompletionSource <GetMessageResult.Message>();
if (RESTMessageDictionary.ContainsKey(communityId))
{
RESTMessageDictionary[communityId].Add(new Resting()
{
Ip = Request.HttpContext.Connection.RemoteIpAddress.ToString(),
Task = tcs,
User = user.Username
});
}
else
{
RESTMessageDictionary.Add(communityId, new List <Resting>()
{
new Resting()
{
Ip = Request.HttpContext.Connection.RemoteIpAddress.ToString(),
Task = tcs
}
});
}
GetMessageResult.Message awaitedMessage = await tcs.Task;
return(new RESTMessageResult()
{
type = "successful",
authorized = true,
success = true,
message = "all good",
restMessage = awaitedMessage
});
}
internal ResultBase MoveBox(string userKey, string boxKey, string to, string toType)
{
if (!(toType == "community" || toType == "user"))
{
return(new Result()
{
authorized = false, success = false, type = "unsuccessful", message = "fromType or toType is not valid"
});
}
(UserGatewayController.CheckUserResult userCheck, DBEntry.User dbUser) = UserGatewayController.CheckUser(userKey);
if (!userCheck.authorized)
{
return(userCheck);
}
IMongoCollection <DBEntry.User> usersCollection = Program.Database.GetCollection <DBEntry.User>("users");
IMongoCollection <DBEntry.Community> communitiesCollection = Program.Database.GetCollection <DBEntry.Community>("communities");
List <DBEntry.User> boxesUser = usersCollection.Find(x => x.Boxes.Any(y => y.Key == boxKey)).ToList();
List <DBEntry.Community> boxesCommunity = communitiesCollection.Find(x => x.Boxes.Any(y => y.Key == boxKey)).ToList();
if (boxesCommunity.Count + boxesUser.Count != 1)
{
return(new Result()
{
authorized = true,
success = true,
type = "unsuccessful",
message = "box does not exist"
});
}
DBEntry.Box box = boxesCommunity.Select(x => x.Boxes.First(y => y.Key == boxKey)).Concat(boxesUser.Select(x => x.Boxes.First(y => y.Key == boxKey))).ElementAt(0);
if (boxesCommunity.Count == 1)
{
DBEntry.Community community = boxesCommunity[0];
List <DBEntry.Box> boxes = community.Boxes.ToList();
boxes.Remove(box);
community.Boxes = boxes.ToArray();
communitiesCollection.ReplaceOne(x => x.UniqueName == community.UniqueName, community);
}
else
{
DBEntry.User user = boxesUser[0];
List <DBEntry.Box> boxes = user.Boxes.ToList();
boxes.Remove(box);
user.Boxes = boxes.ToArray();
usersCollection.ReplaceOne(x => x.Username == user.Username, user);
}
if (toType == "community")
{
List <DBEntry.Community> communities = communitiesCollection.Find(x => x.UniqueName == to).ToList();
if (communities.Count != 1)
{
return(new Result()
{
authorized = true,
success = false,
type = "unsuccessful",
message = "to does not exist"
});
}
DBEntry.Community community = communities[0];
List <DBEntry.Box> boxes = community.Boxes.ToList();
boxes.Add(box);
community.Boxes = boxes.ToArray();
communitiesCollection.ReplaceOne(x => x.UniqueName == community.UniqueName, community);
}
else
{
List <DBEntry.User> users = usersCollection.Find(x => x.Username == to).ToList();
if (users.Count != 1)
{
return(new Result()
{
authorized = true,
success = false,
type = "unsuccessful",
message = "to does not exist"
});
}
DBEntry.User user = users[0];
List <DBEntry.Box> boxes = user.Boxes.ToList();
boxes.Add(box);
user.Boxes = boxes.ToArray();
usersCollection.ReplaceOne(x => x.Username == user.Username, user);
}
return(new Result()
{
authorized = true,
success = true,
type = "successful",
message = "all good",
});
}
