/// <summary>
/// Generates a random token
/// </summary>
/// <returns></returns>
public async Task <string> MakeOauthToken(DeltaConnection conn, ObjectId oauthApp, uint oauthScope)
{
//Generate a unique string
string token = Tools.SecureStringTool.GenerateSecureString(62);
while (await conn.AuthenticateUserToken(token) != null)
{
token = Tools.SecureStringTool.GenerateSecureString(62);
}
//Add some information. This is for future use
token = "A." + token;
//Now, create a token object
DbToken t = new DbToken
{
created_utc = DateTime.UtcNow,
token = token,
user_id = _id,
_id = MongoDB.Bson.ObjectId.GenerateNewId(),
oauth_application = oauthApp,
oauth_scope = oauthScope
};
//Insert
await conn.system_tokens.InsertOneAsync(t);
//Return string
return(token);
}
public DeltaWebServer(DeltaConnection conn, int port)
{
this.conn = conn;
this.port = port;
this.services = new List <DeltaWebServiceDefinition>();
this.start = DateTime.UtcNow;
}
/// <summary>
/// Uploads an image after resizing it and returns the URL to it
/// </summary>
/// <param name="data"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <returns></returns>
public static async Task <string> UploadUserContentResizeImage(DeltaConnection conn, Stream data, int width, int height)
{
//Read as image
string url;
using (MemoryStream ms = new MemoryStream())
using (MemoryStream inputData = new MemoryStream())
{
//Read
await data.CopyToAsync(inputData);
//Rewind and create image
inputData.Position = 0;
using (Image <Rgba32> img = Image.Load <Rgba32>(inputData))
{
//Resize
img.Mutate(x => x.Resize(width, height));
//Save
img.SaveAsPng(ms);
}
//Rewind and upload
ms.Position = 0;
url = await UploadUserContent(conn, ms);
}
return(url);
}
static void Main(string[] args)
{
//Decode config file
config = JsonConvert.DeserializeObject <ConfigFile>(File.ReadAllText(args[0]));
//Create Delta connection
connection = new DeltaConnection(config.delta_config_path, config.server_id, 0, 1, new ManagerCoreNet());
connection.Connect().GetAwaiter().GetResult();
//Fetch server list
server_instances = connection.system_delta_servers.Find(Builders <DbSystemServer> .Filter.Eq("enviornment", connection.config.env)).ToList();
//Create all server types
server_types = new Dictionary <CoreNetworkServerType, ManagerServer>();
foreach (var s in config.servers)
{
server_types.Add(s.type, new ManagerServer(s));
}
//Start all
foreach (var t in server_types)
{
t.Value.StartAll();
}
Console.WriteLine("Ready.");
Task.Delay(-1).GetAwaiter().GetResult();
}
/// <summary>
/// Gets a user by their ID.
/// </summary>
/// <returns></returns>
public static async Task <DbUser> GetUserByID(DeltaConnection conn, ObjectId id)
{
//Get user. If a user account isn't created yet, make one.
DbUser user = await conn.GetUserByIdAsync(id.ToString());
return(user);
}
public async Task UpdatePrefs(DeltaConnection conn, DbServer server, SavedDinoTribePrefs prefs)
{
//TODO
//Set here
this.prefs = prefs;
}
/// <summary>
/// Gets all clusters owned by a user
/// </summary>
/// <param name="conn"></param>
/// <param name="user"></param>
/// <returns></returns>
public static async Task <List <DbCluster> > GetClustersForUser(DeltaConnection conn, ObjectId user)
{
var filterBuilder = Builders <DbCluster> .Filter;
var filter = filterBuilder.Eq("owner", user);
var results = await conn.system_clusters.FindAsync(filter);
return(await results.ToListAsync());
}
public async Task <List <DbPlayerProfile> > GetPlayerProfilesByTribeAsync(DeltaConnection conn, int tribeId)
{
var filterBuilder = Builders <DbPlayerProfile> .Filter;
var filter = filterBuilder.Eq("server_id", id) & filterBuilder.Eq("tribe_id", tribeId);
var results = await conn.content_player_profiles.FindAsync(filter);
return(await results.ToListAsync());
}
public int _request_id; //Random request ID for logging
public DeltaWebService(DeltaConnection conn, HttpContext e)
{
this.e = e;
this.conn = conn;
this.method = e.Request.Method.ToUpper();
_request_id = new Random().Next();
start = DateTime.UtcNow;
}
public async Task UpdateAsync(DeltaConnection conn)
{
var filterBuilder = Builders <DbAuthenticationSession> .Filter;
var updateBuilder = Builders <DbAuthenticationSession> .Update;
var filter = filterBuilder.Eq("_id", this._id);
var update = updateBuilder.Set("state", state).Set("custom_data", custom_data);
await conn.system_auth_sessions.UpdateOneAsync(filter, update);
}
/// <summary>
/// Renames a canvas by changing it's name and color
/// </summary>
/// <returns></returns>
public async Task UpdateUsers(DeltaConnection conn)
{
var updateBuilder = Builders <DbCanvas> .Update;
var update = updateBuilder.Set("users", users);
var filterBuilder = Builders <DbCanvas> .Filter;
var filter = filterBuilder.Eq("_id", _id);
await conn.system_canvases.UpdateOneAsync(filter, update);
}
/// <summary>
/// Finds a canvas by it's ID and returns it
/// </summary>
/// <param name="conn"></param>
/// <param name="id"></param>
/// <returns></returns>
public static async Task <DbCanvas> GetCanvasById(DeltaConnection conn, ObjectId id)
{
var filterBuilder = Builders <DbCanvas> .Filter;
var filter = filterBuilder.Eq("_id", id);
var result = await conn.system_canvases.FindAsync(filter);
return(await result.FirstOrDefaultAsync());
}
public async Task <DbPlayerProfile> GetUserPlayerProfile(DeltaConnection conn, DbUser user)
{
var filterBuilder = Builders <DbPlayerProfile> .Filter;
var filter = filterBuilder.Eq("server_id", _id) & filterBuilder.Eq("steam_id", user.steam_id);
var results = await conn.content_player_profiles.FindAsync(filter);
return(await results.FirstOrDefaultAsync());
}
public async Task <DbPlayerProfile> GetPlayerProfileBySteamIDAsync(DeltaConnection conn, int?tribeId, string steamId)
{
var filterBuilder = Builders <DbPlayerProfile> .Filter;
var filter = filterBuilder.Eq("steam_id", steamId) & Tools.FilterBuilderToolDb.CreateTribeFilter <DbPlayerProfile>(this, tribeId);
var results = await conn.content_player_profiles.FindAsync(filter);
return(await results.FirstOrDefaultAsync());
}
public async Task ActivateOauthToken(DeltaConnection conn)
{
var filterBuilder = Builders <DbToken> .Filter;
var filter = filterBuilder.Eq("_id", _id);
var updateBuilder = Builders <DbToken> .Update;
var update = updateBuilder.Set <string>("oauth_preflight", null);
await conn.system_tokens.UpdateOneAsync(filter, update);
}
public static async Task <NetGuildUser> GetNetGuild(DeltaConnection conn, DbServer server, DbUser user, DbPlayerProfile profile)
{
NetGuildUser g = new NetGuildUser();
g.SetServerData(server);
await g.SetServerGuildData(conn, server, user, profile);
return(g);
}
public async Task SetServerGuildData(DeltaConnection conn, DbServer server, DbUser user, DbPlayerProfile profile)
{
//Get tribe info
target_tribe = await conn.GetTribeByTribeIdAsync(server._id, profile.tribe_id);
//Set other
is_admin = server.CheckIsUserAdmin(user);
user_prefs = await server.GetUserPrefs(conn, user.id);
}
static void Main(string[] args)
{
//Connect to database
conn = DeltaConnection.InitDeltaManagedApp(args, DeltaCoreNetServerType.API_RPC, APP_VERSION_MAJOR, APP_VERSION_MINOR);
conn.net.BindReceiveEvent(RouterConnection.OPCODE_SYS_RPC, OnIncomingRPCCommand);
//Launch server
MainAsync().GetAwaiter().GetResult();
}
/// <summary>
/// Finds and devalidates all tokens belonging to this user.
/// </summary>
/// <returns></returns>
public async Task <long> DevalidateAllTokens(DeltaConnection conn)
{
//Search for all
var filterBuilder = Builders <DbToken> .Filter;
var filter = filterBuilder.Eq("user_id", id);
var results = await conn.system_tokens.DeleteManyAsync(filter);
return(results.DeletedCount);
}
/// <summary>
/// Generates the server creation token
/// </summary>
/// <returns></returns>
public async Task <string> GetServerCreationToken(DeltaConnection conn)
{
if (server_creation_token == null)
{
server_creation_token = Tools.SecureStringTool.GenerateSecureString(44);
await UpdateAsync(conn);
}
return(server_creation_token);
}
public async Task <List <DbServer> > GetAdminedServersAsync(DeltaConnection conn)
{
//Search for servers
var filterBuilder = Builders <DbServer> .Filter;
var filter = filterBuilder.Eq("owner_uid", this._id) | filterBuilder.In("admins", new ObjectId[] { this._id });
var result = await conn.system_servers.FindAsync(filter);
return(await result.ToListAsync());
}
public static async Task RequestConsoleLog(DeltaConnection conn, ObjectId server_id, ObjectId sender_id, string text)
{
//Create payload
JObject payload = new JObject();
payload["text"] = text;
//Send
await _SendCommand(conn, -1, false, server_id, sender_id, payload);
}
/// <summary>
/// Gets a structure by it's ID from a server
/// </summary>
/// <param name="token"></param>
/// <param name="server"></param>
/// <returns></returns>
public static async Task <DbStructure> GetStructureByID(DeltaConnection conn, int token, DbServer server)
{
var filterBuilder = Builders <DbStructure> .Filter;
var filter = filterBuilder.Eq("structure_id", token);
var response = await conn.content_structures.FindAsync(filter);
var structure = await response.FirstOrDefaultAsync();
return(structure);
}
/// <summary>
/// Fetches items belonging to this structure
/// </summary>
/// <param name="dino"></param>
/// <param name="server"></param>
/// <param name="tribeId"></param>
/// <returns></returns>
public async Task <List <DbItem> > GetItems(DeltaConnection conn, DbServer server)
{
var filterBuilder = Builders <DbItem> .Filter;
var filter = filterBuilder.Eq("server_id", server.id) & filterBuilder.Eq("tribe_id", tribe_id) & filterBuilder.Eq("parent_id", structure_id.ToString()) & filterBuilder.Eq("parent_type", DbInventoryParentType.Structure);
var response = await conn.content_items.FindAsync(filter);
var items = await response.ToListAsync();
return(items);
}
public async Task <List <DbTribe> > GetAllTribesAsync(DeltaConnection conn)
{
var filterBuilder = Builders <DbTribe> .Filter;
var filter = filterBuilder.Eq("server_id", this._id);
var results = await conn.content_tribes.FindAsync(filter);
var r = await results.ToListAsync();
return(r);
}
/// <summary>
/// Gets a DbSyncSavedState object.
/// </summary>
/// <param name="conn"></param>
/// <param name="token"></param>
/// <returns></returns>
public static async Task <DbSyncSavedState> GetStateByTokenAsync(DeltaConnection conn, string token)
{
var filterBuilder = Builders <DbSyncSavedState> .Filter;
var filter = filterBuilder.Eq("token", token);
var results = await conn.system_sync_states.FindAsync(filter);
var r = await results.FirstOrDefaultAsync();
return(r);
}
public static void SystemNotifyUserGroupReset(DeltaConnection conn, ObjectId user)
{
//Get buffer
byte[] buffer = _CreateResetGroupsTemplate(FILTERCODE_USER, 12, out int filterOffset);
//Write filter
BinaryTool.WriteMongoID(buffer, filterOffset, user);
//Send
conn.net.SendRPCCommand(buffer);
}
/// <summary>
/// Renames a canvas by changing it's name and color
/// </summary>
/// <returns></returns>
public async Task RenameCanvas(DeltaConnection conn, string name, string color)
{
var updateBuilder = Builders <DbCanvas> .Update;
var update = updateBuilder.Set("name", name).Set("color", color);
var filterBuilder = Builders <DbCanvas> .Filter;
var filter = filterBuilder.Eq("_id", _id);
this.name = name;
this.color = color;
await conn.system_canvases.UpdateOneAsync(filter, update);
}
public async Task <List <DbPlayerProfile> > GetPlayerProfiles(DeltaConnection conn, int offset = 0, int limit = int.MaxValue)
{
var filterBuilder = Builders <DbPlayerProfile> .Filter;
var filter = filterBuilder.Eq("server_id", _id);
var results = await conn.content_player_profiles.FindAsync(filter, new FindOptions <DbPlayerProfile, DbPlayerProfile>
{
Skip = offset,
Limit = limit
});
return(await results.ToListAsync());
}
private static async Task <StorageClient> GetClient(DeltaConnection conn)
{
if (client == null)
{
//Open client
string credsFile = await conn.GetUserConfigString(DeltaConnection.CONFIGNAME_FIREBASE, "");
creds = GoogleCredential.FromJson(credsFile);
client = StorageClient.Create(creds);
}
return(client);
}
