public iS3Territory(iS3TerritoryHandle handle) : base(handle)
{
TerritoryHandle = handle;
Domains = new List <iS3Domain>();
Projects = new List <iS3Project>();
}
public async Task <IHttpActionResult> AddTerritory(iS3TerritoryHandle handle)
{
if (handle == null)
{
return(BadRequest("Argument Null"));
}
iS3TerritoryHandle newHandle = await MiniServer.AddTerritory(handle);
return(Ok(newHandle));
}
public async Task <IHttpActionResult> GetTerritoryHandle(string nameOrID)
{
if (nameOrID == null)
{
return(BadRequest("Argument Null"));
}
iS3TerritoryHandle result = null;
result = await MiniServer.getTerritoryHandle(nameOrID);
return(Ok(result));
}
// Add territory using the corresponding information in handle
// Returns the newly added territory handle (not the input one).
//
public static async Task <iS3TerritoryHandle> AddTerritory(
iS3TerritoryHandle territoryHandle)
{
iS3TerritoryHandle newHandle =
await MiniServer.AddTerritoryHandle(territoryHandle.Name,
territoryHandle.Type, territoryHandle.DbName);
Type t = MiniServer.GetType(newHandle.Type);
iS3Territory territory = (iS3Territory)
Activator.CreateInstance(t, newHandle);
MiniServer.AddTerritory(territory);
return(newHandle);
}
// Add a new domain handle:
// name, type, parentNameOrID should be filled
// if dbName is not given, i.e., null, default database name will be used.
//
public static async Task <iS3DomainHandle> AddDomainHandle(string name,
string type, string parentNameOrID, string dbName = null)
{
iS3TerritoryHandle territoryHandle = null;
using (var ctx = new iS3MainDbContext())
{
territoryHandle = await getTerritoryHandle(parentNameOrID, ctx);
if (territoryHandle == null)
{
throw new Exception("Territory null and no default");
}
bool exist = territoryHandle.DomainHandles.Any(c => c.Name == name);
if (exist)
{
throw new Exception("Already exists");
}
iS3DomainHandle domainHandle = new iS3DomainHandle();
domainHandle.ID = int.Parse(Guid.NewGuid().ToString());
domainHandle.Name = name;
domainHandle.Type = type;
domainHandle.ParentID = territoryHandle.ID.ToString();
if (domainHandle.DbName == null)
{
if (territoryHandle.DbName != null)
{
domainHandle.DbName = territoryHandle.DbName;
}
else
{
domainHandle.DbName = MiniServer.DefaultDatabase;
}
}
territoryHandle.DomainHandles.Add(domainHandle);
await ctx.SaveChangesAsync();
return(domainHandle);
}
}
// Add a new territory handle:
// name, should be filled
// if type is not give, i.e., null, default is iS3SimpleTerritory
// if dbName is not given, i.e., null, default database name will be used.
//
public static async Task <iS3TerritoryHandle> AddTerritoryHandle(string name,
string type = null, string dbName = null)
{
if (name == null)
{
throw new Exception("Argument Null");
}
if (type == null)
{
type = typeof(iS3SimpleTerritory).ToString();
}
using (var ctx = new iS3MainDbContext())
{
bool exists = await ctx.TerritoryHandles.AnyAsync(c => c.Name == name);
if (exists)
{
throw new Exception("Already exists");
}
iS3TerritoryHandle newTerritoryHandle = new iS3TerritoryHandle();
newTerritoryHandle.ID = int.Parse(Guid.NewGuid().ToString());
newTerritoryHandle.Name = name;
newTerritoryHandle.Type = type;
if (dbName == null)
{
newTerritoryHandle.DbName = MiniServer.DefaultDatabase;
}
else
{
newTerritoryHandle.DbName = dbName;
}
var result = ctx.TerritoryHandles.Add(newTerritoryHandle);
await ctx.SaveChangesAsync();
return(newTerritoryHandle);
}
}
// Get territory handle.
// Note:
// 1. If not found, it will try to return the territory which is the default,
// i.e., iS3TerritoryHandle.Default==true
// 2. if ctx is null, default context, i.e., the default database will be used.
//
public static async Task <iS3TerritoryHandle> getTerritoryHandle(string nameOrID,
iS3MainDbContext ctx = null)
{
iS3TerritoryHandle tHandle = null;
if (ctx == null)
{
using (var ctx_new = new iS3MainDbContext())
{
tHandle = await getTerritoryHandleInternal(nameOrID, ctx_new);
// explicit load domain handles
//
var entry = ctx_new.Entry(tHandle).Collection(t => t.DomainHandles);
var isLoaded = entry.IsLoaded;
await entry.LoadAsync();
isLoaded = entry.IsLoaded;
return(tHandle);
}
}
else
{
tHandle = await getTerritoryHandleInternal(nameOrID, ctx);
// explicit load domain handles
//
var entry = ctx.Entry(tHandle).Collection(t => t.DomainHandles);
var isLoaded = entry.IsLoaded;
await entry.LoadAsync();
isLoaded = entry.IsLoaded;
return(tHandle);
}
}
public iS3SimpleTerritory(iS3TerritoryHandle handle) : base(handle)
{
}