public static IProjectManager Create(ILoggerFactory loggerFactory,
IMetaManager metaManager, string projectRootDir)
{
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
if (metaManager == null)
{
throw new ArgumentNullException(nameof(metaManager));
}
if (string.IsNullOrWhiteSpace(projectRootDir))
{
throw new ArgumentException(
"Project Directory not specified.", nameof(projectRootDir));
}
var logger = loggerFactory.CreateLogger <ProjectManager>();
logger.LogInformation("Searching {directory} for projects.", projectRootDir);
return(new ProjectManager {
Logger = logger,
ProjectRootDir = projectRootDir,
ProjectFiles = GetProjectFilePaths(projectRootDir),
MetaManager = metaManager
});
}
/// <summary>
/// Executes the given request
/// </summary>
public override void Execute(IMetaManager myMetaManager)
{
RequestUpdate update;
_alteredEdgeType =
myMetaManager
.EdgeTypeManager
.ExecuteManager
.AlterType(_request,
Int64,
SecurityToken,
out update);
#region update vertices
//if (update.GetVerticesRequest == null)
//{
// var getVerticesRequest = CreateGetVerticesRequest(myMetaManager, update);
// if (getVerticesRequest != null)
// {
// update.SetGetVerticesRequest(getVerticesRequest);
// myMetaManager
// .VertexManager
// .ExecuteManager
// .UpdateVertices(update,
// Int64,
// SecurityToken);
// }
//}
#endregion
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
this.metaManager = new MetaManager();
if (!this.Page.IsPostBack)
{
if (String.IsNullOrEmpty(Request.QueryString["CustomerID"]))
{
this.InitControls();
}
else if ((!String.IsNullOrEmpty(Request.QueryString["CustomerID"])) && (!String.IsNullOrEmpty(Request.QueryString["ConfigID"])) && (!String.IsNullOrEmpty(Request.QueryString["ConfigIndex"])))
{
this.restoreControlStateFromSession(Request.QueryString["CustomerID"], Request.QueryString["ConfigID"], Request.QueryString["ConfigIndex"]);
}
}
}
catch (Exception ex)
{
//TracingUtility.Trace(new object[] { ex.ToString() }, TracingUtility.DefaultTraceSourceName);
Provider.Tracer().Trace(new object[] { ex.ToString() }, null);
throw;
}
}
void IManager.Initialize(IMetaManager myMetaManager)
{
_vertexTypeManager = myMetaManager.VertexTypeManager;
_edgeTypeManager = myMetaManager.EdgeTypeManager;
_vertexStore = myMetaManager.VertexStore;
_indexManager = myMetaManager.IndexManager;
}
public override void Validate(IMetaManager myMetaManager)
{
if (_request == null)
{
throw new NotImplementedException();
}
}
public override void Validate(IMetaManager myMetaManager)
{
myMetaManager
.EdgeTypeManager
.CheckManager
.GetAllTypes(Int64,
SecurityToken);
}
public override void Execute(IMetaManager myMetaManager)
{
_fetchedEdgeTypes = myMetaManager
.EdgeTypeManager
.ExecuteManager
.GetAllTypes(Int64,
SecurityToken);
}
public override void Validate(IMetaManager myMetaManager)
{
myMetaManager
.EdgeTypeManager
.CheckManager
.AddTypes(_request.TypePredefinitions,
Int64,
SecurityToken);
}
private void FreeMetaManager()
{
if (mMetaManager != null)
{
mMetaManager.Dispose();
mMetaManager = null;
IsLoad = false;
}
}
public override void Execute(IMetaManager myMetaManager)
{
_createdEdgeTypes = myMetaManager
.EdgeTypeManager
.ExecuteManager
.AddTypes(_request.TypePredefinitions,
Int64,
SecurityToken);
}
public override void Execute(IMetaManager myMetaManager)
{
IndexDef = myMetaManager.IndexManager.CreateIndex(_request.IndexDefinition, SecurityToken, Int64);
if (IndexDef == null)
{
throw new IndexCreationException(_request.IndexDefinition, "");
}
}
public IMetaManager GetMetaManager()
{
if (!IsLoad)
{
mMetaManager = CreateMetaManager();
IsLoad = (mMetaManager != null);
}
return(mMetaManager);
}
public override void Validate(IMetaManager myMetaManager)
{
if (_request.VertexTypeName != null)
{
myMetaManager.VertexTypeManager.CheckManager.GetType(_request.VertexTypeName, Int64, SecurityToken);
}
else
{
myMetaManager.VertexTypeManager.CheckManager.GetType(_request.VertexTypeID, Int64, SecurityToken);
}
}
private void getData()
{
if (this.metaManager == null)
{
this.metaManager = new MetaManager();
}
this.customers = new List <Customer>(this.metaManager.ListCustomers());
this.Page.Cache["CurrentCustomer"] = this.customers;
}
public override void Execute(IMetaManager myMetaManager)
{
if (_request.VertexTypeName == null)
{
_fetchedVertexType = myMetaManager.VertexTypeManager.ExecuteManager.GetType(_request.VertexTypeID, Int64, SecurityToken);
}
else
{
_fetchedVertexType = myMetaManager.VertexTypeManager.ExecuteManager.GetType(_request.VertexTypeName, Int64, SecurityToken);
}
}
/// <summary>
/// Validates if the given request can be executed
/// </summary>
public override void Validate(IMetaManager myMetaManager)
{
RequestUpdate update;
myMetaManager
.VertexTypeManager
.CheckManager
.AlterType(_request,
Int64,
SecurityToken,
out update);
}
public override void Execute(IMetaManager myMetaManager)
{
_createdEdgeType =
myMetaManager
.EdgeTypeManager
.ExecuteManager
.AddTypes(new List <ATypePredefinition> {
_request.EdgeTypePredefinition
},
Int64,
SecurityToken).FirstOrDefault();
}
public override void Validate(IMetaManager myMetaManager)
{
if (string.IsNullOrWhiteSpace(_request.IndexDefinition.VertexTypeName))
{
throw new InvalidIndexAttributeException(_request.IndexDefinition.VertexTypeName, "");
}
else if (string.IsNullOrWhiteSpace(_request.IndexDefinition.Name))
{
throw new InvalidIndexAttributeException(_request.IndexDefinition.Name, "");
}
//else if (string.IsNullOrWhiteSpace(_request.IndexDefinition.TypeName))
//{
// throw new InvalidIndexAttributeException(_request.IndexDefinition.TypeName, "");
//}
}
public override void Execute(IMetaManager myMetaManager)
{
IEnumerable <long> vertexTypeID;
if (_request.VertexTypeName != null)
{
vertexTypeID = myMetaManager.VertexTypeManager.ExecuteManager.GetType(_request.VertexTypeName, Int64, SecurityToken).GetDescendantVertexTypesAndSelf().Select(_ => _.ID);
}
else
{
vertexTypeID = myMetaManager.VertexTypeManager.ExecuteManager.GetType(_request.VertexTypeID, Int64, SecurityToken).GetDescendantVertexTypesAndSelf().Select(_ => _.ID);
}
foreach (var aCount in vertexTypeID.Select(_ => myMetaManager.VertexManager.ExecuteManager.VertexStore.GetVertexCount(SecurityToken, Int64, _)))
{
_vertexCount += aCount;
}
}
public override void Execute(IMetaManager myMetaManager)
{
IVertexType graphDBType = myMetaManager
.VertexTypeManager
.ExecuteManager
.GetType(_request.TypeName,
Int64,
SecurityToken);
if (graphDBType == null)
{
throw new TypeDoesNotExistException <IVertexType>(_request.TypeName);
}
_deletedTypeIDs = myMetaManager.VertexTypeManager.ExecuteManager.RemoveTypes(new List <IVertexType> {
graphDBType
}, Int64, SecurityToken);
}
internal RequestGetVertices CreateGetVerticesRequest(IMetaManager myMetaManager,
RequestUpdate myRequestUpdate)
{
var outEdges = myRequestUpdate.UpdateOutgoingEdgesProperties;
if (outEdges != null)
{
var userdefTypes = myMetaManager
.VertexTypeManager
.ExecuteManager
.GetAllTypes(Int64,
SecurityToken)
.Where(_ => _
.IsUserDefined);
if (userdefTypes != null && userdefTypes.Count() > 0)
{
var types =
userdefTypes
.Where(_ => _
.GetOutgoingEdgeDefinitions(false)
.Any(x => x.EdgeType
.ID
.Equals(outEdges.First().EdgeTypeID) ||
x
.InnerEdgeType
.ID
.Equals(outEdges.First().EdgeTypeID)));
if (types != null && types.Count() > 0)
{
return(new RequestGetVertices(types.FirstOrDefault().ID));
}
}
}
else
{
throw new TypeDoesNotExistException <IVertexType>(
"Empty",
"There is no type found to update after alter type.");
}
return(null);
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
string customerID = Request.QueryString["CustomerID"];
string configurationID = Request.QueryString["ConfigID"];
if ((!String.IsNullOrEmpty(customerID)) && (!String.IsNullOrEmpty(configurationID)))
{
if (this.metaManager == null)
{
this.metaManager = new MetaManager();
}
Customer customer = this.metaManager.GetCustomer(customerID);
if (customer != null)
{
Configuration configuration = customer.Configurations.First((o) => (o.ID.ToLower() == configurationID.ToLower()));
if (configuration != null)
{
string serverName, databaseName, userName, password;
DatabaseManager.ParseConnectionString(configuration.DbConnectionString, out serverName, out databaseName, out userName, out password);
string connectionString = DatabaseManager.BuildConnectionString(serverName, "master", userName, password);
this.DBBackupDetail.BindData(customer.Name, databaseName, connectionString, this.Page.IsPostBack);
}
}
}
}
catch (Exception ex)
{
//TracingUtility.Trace(new object[] { ex.ToString() }, TracingUtility.DefaultTraceSourceName);
Provider.Tracer().Trace(new object[] { ex.ToString() }, null);
throw;
}
}
public override void Validate(IMetaManager myMetaManager)
{
myMetaManager
.VertexTypeManager
.CheckManager
.GetType(_request.TypeName,
Int64,
SecurityToken);
myMetaManager
.VertexTypeManager
.CheckManager
.RemoveTypes(new List <IVertexType> {
myMetaManager
.VertexTypeManager
.ExecuteManager
.GetType(_request.TypeName,
Int64,
SecurityToken)
},
Int64,
SecurityToken);
}
public override void Validate(IMetaManager myMetaManager)
{
if (_request.VertexTypeName == null)
{
//1. Vertex type by ID
myMetaManager.VertexManager.CheckManager.GetVertex(
_request.VertexTypeID,
_request.VertexID,
_request.Edition,
_request.Timespan,
Int64, SecurityToken);
}
else
{
//2. Vertex type by Name
myMetaManager.VertexManager.CheckManager.GetVertex(
_request.VertexTypeName,
_request.VertexID,
_request.Edition,
_request.Timespan,
Int64, SecurityToken);
}
}
public override void Execute(IMetaManager myMetaManager)
{
if (_request.VertexTypeName == null)
{
//1. Vertex type by ID
_fetchedVertex = myMetaManager.VertexManager.ExecuteManager.GetVertex(
_request.VertexTypeID,
_request.VertexID,
_request.Edition,
_request.Timespan,
Int64, SecurityToken);
}
else
{
//2. Vertex type by Name
_fetchedVertex = myMetaManager.VertexManager.ExecuteManager.GetVertex(
_request.VertexTypeName,
_request.VertexID,
_request.Edition,
_request.Timespan,
Int64, SecurityToken);
}
}
protected IConfigType[] LoadConfigTypes()
{
IConfigType[] types = null;
if (mMetaManagerEnter != null)
{
if (mMetaManager == null)
{
mMetaManager = mMetaManagerEnter.GetMetaManager();
}
if (mMetaManager != null)
{
types = mMetaManager.GetTypes();
if (types != null && types.Length > 0)
{
foreach (IConfigType type in types)
{
if (type != null)
{
if (type.FileName != null && type.FileName.Equals("."))
{
type.FileName = "";
}
else if (type.FileName == null || type.FileName.Equals(""))
{
type.FileName = FileName;
}
}
}
}
}
}
return(types);
}
/// <summary>
/// Executes the given request
/// </summary>
public override void Execute(IMetaManager myMetaManager)
{
RequestUpdate update;
_alteredVertexType =
myMetaManager
.VertexTypeManager
.ExecuteManager
.AlterType(_request,
Int64,
SecurityToken,
out update);
#region update vertices
//myMetaManager
// .VertexManager
// .ExecuteManager
// .UpdateVertices(update,
// Int64,
// SecurityToken);
#endregion
}
public abstract void Initialize(IMetaManager myMetaManager);
public SafeMetaManager(IMetaManager manager)
{
_manager = manager;
}
public override void Initialize(IMetaManager myMetaManager)
{
_vertexTypeManager = myMetaManager.VertexTypeManager.ExecuteManager;
}
/// <summary>
/// Validates the given request.
/// </summary>
public override void Validate(IMetaManager myMetaManager)
{
myMetaManager.VertexManager.CheckManager.UpdateVertices(_request, Int64, SecurityToken);
}
/// <summary>
/// Executes the given request.
/// </summary>
public override void Execute(IMetaManager myMetaManager)
{
updatedVertices = myMetaManager.VertexManager.ExecuteManager.UpdateVertices(_request, Int64, SecurityToken);
}
void IManager.Initialize(IMetaManager myMetaManager)
{
_vertexTypeManager = myMetaManager.VertexTypeManager;
_edgeTypeManager = myMetaManager.EdgeTypeManager;
_vertexStore = myMetaManager.VertexStore;
_indexManager = myMetaManager.IndexManager;
}
/// <summary>
/// Creates a new request manager
/// </summary>
/// <param name="myMetaManager">The meta mananger of the graphdb</param>
public SimpleRequestManager(IMetaManager myMetaManager)
{
_metaManager = myMetaManager;
}
public override void Initialize(IMetaManager myMetaManager)
{
base.Initialize(myMetaManager);
_indexManager = myMetaManager.IndexManager;
_vertexStore = myMetaManager.VertexStore;
_queryPlanManager = myMetaManager.QueryPlanManager;
}
public SchemaCache(IMetaManager metaManager)
{
this.metaManager = metaManager;
}
public void Initialize(IMetaManager myMetaManager)
{
_vertexManager = myMetaManager.VertexManager;
}
public void Initialize(IMetaManager myMetaManager)
{
_metaManager = myMetaManager;
}
public virtual void Initialize(IMetaManager myMetaManager)
{
_vertexTypeManager = myMetaManager.VertexTypeManager;
_queryPlanManager = myMetaManager.QueryPlanManager;
}
/// <summary> /// Validation of the request /// </summary> /// <param name="myMetaManager">A manager that contains every other manager</param> public abstract void Validate(IMetaManager myMetaManager);
/// <summary> /// Execute the request /// </summary> /// <param name="myMetaManager">A manager that contains every other manager</param> public abstract void Execute(IMetaManager myMetaManager);
public override void Initialize(IMetaManager myMetaManager)
{
_edgeManager = myMetaManager.EdgeTypeManager;
_indexManager = myMetaManager.IndexManager;
_vertexManager = myMetaManager.VertexManager;
}
void IManager.Initialize(IMetaManager myMetaManager)
{
}
public void Initialize(IMetaManager myMetaManager)
{
_vertexTypeManager = myMetaManager.VertexTypeManager;
_vertexStore = myMetaManager.VertexStore;
_baseStorageManager = myMetaManager.BaseGraphStorageManager;
}
public void Initialize(IMetaManager myMetaManager)
{
_vertexTypeManager = myMetaManager.VertexTypeManager;
_vertexStore = myMetaManager.VertexStore;
}
