private static IEnumerable <OutputGenerator> GetAllCodeGeneratorsForItems(IGraphConfiguration graphConfiguration,
DesignerGeneratorFactory[] graphItemGenerators, IDataRecord[] items, bool includeDisabled = false)
{
foreach (var graphItemGenerator in graphItemGenerators)
{
DesignerGeneratorFactory generator = graphItemGenerator;
// If its a generator for the entire diagram
foreach (var item in items)
{
if (generator.DiagramItemType.IsAssignableFrom(item.GetType()))
{
var codeGenerators = generator.GetGenerators(graphConfiguration, item);
foreach (var codeGenerator in codeGenerators)
{
if (!includeDisabled && !codeGenerator.IsValid())
{
continue;
}
// TODO Had to remove this?
//if (!codeGenerator.IsEnabled(prsteroject)) continue;
codeGenerator.AssetDirectory = graphConfiguration.CodeOutputPath;
//codeGenerator.Settings = settings;
if (codeGenerator.ObjectData == null)
{
codeGenerator.ObjectData = item;
}
codeGenerator.GeneratorFor = graphItemGenerator.DiagramItemType;
yield return(codeGenerator);
}
}
}
}
}
//public static IEnumerable<CodeFileGenerator> GetAllFileGenerators(GeneratorSettings settings)
//{
// return GetAllFileGenerators(settings, CurrentProject);
//}
/// <summary>
/// Get all of the merged generators for a project, this will merge any output generators with the same filename into a combined "CodeFileGenerator".
/// </summary>
/// <returns></returns>
public static IEnumerable <CodeFileGenerator> GetAllFileGenerators(IGraphConfiguration config,
IDataRecord[] items, bool includeDisabled = false)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (items == null)
{
throw new ArgumentNullException("items");
}
var codeGenerators = GetAllCodeGenerators(config, items, includeDisabled).ToArray();
var groups = codeGenerators.GroupBy(p => Path.Combine(config.CodeOutputPath, p.Filename)).Distinct();
foreach (var @group in groups)
{
var generator = new CodeFileGenerator(config.Namespace)
{
AssetPath = @group.Key.Replace("\\", "/"),
#if UNITY_EDITOR
//SystemPath = Path.Combine(config.CodeOutputSystemPath, @group.Key.Substring(7)).Replace("\\", "/"),
SystemPath = @group.Key,
#endif
Generators = @group.ToArray()
};
yield return(generator);
}
}
public void ChangeDatabase(IGraphConfiguration configuration)
{
var configRecord = configuration as IDataRecord;
if (configRecord != null)
{
CurrentDatabaseIdentifier = configRecord.Identifier;
}
InvertApplication.Container = null;
}
protected override bool InitializeModel(IGraphConfiguration configuration)
{
configuration.ConfigureCollection <IProfile>()
.AddEdge(t => t.Parents, "parent").Reverse <IProfile>(t => t.Children)
.AddQuery(t => t.AllSiblings, g => g.V("{id}").As("s").In("parent").Out("parent").Dedup())
.ConfigureCollection <ICompany>()
.ConfigureCollection <IEmployment>();
return(true);
}
public static MatterGraphModel GetMatters(IGraphConfiguration GraphConfiguration)
{
using (var tagHiveClient = CommunicationProcessingBusinessLogic.CreateGremlinClient(GraphConfiguration))
{
string query = GraphQueryBusinessLogic.GetMattersGraphQuery();
var results = CommunicationProcessingBusinessLogic.SubmitRequest(tagHiveClient, query).Result;
var jsonString = JsonConvert.SerializeObject(results);
return(JsonConvert.DeserializeObject <MatterGraphModel>(jsonString));
}
}
public static IEnumerable <OutputGenerator> GetAllCodeGenerators(IGraphConfiguration graphConfiguration,
IDataRecord[] items, bool includeDisabled = false)
{
var graphItemGenerators = Container.ResolveAll <DesignerGeneratorFactory>().ToArray();
foreach (var outputGenerator in GetAllCodeGeneratorsForItems(graphConfiguration, graphItemGenerators, items,
includeDisabled))
{
yield return(outputGenerator);
}
}
public static DocumentGraphModelList GetDocumentsForTag(IGraphConfiguration GraphConfiguration, string Tag)
{
using (var tagHiveClient = CommunicationProcessingBusinessLogic.CreateGremlinClient(GraphConfiguration))
{
string query = GraphQueryBusinessLogic.GetDocumentsForTagGraphQuery(Tag);
var results = CommunicationProcessingBusinessLogic.SubmitRequest(tagHiveClient, query).Result;
var jsonString = JsonConvert.SerializeObject(results);
return(JsonConvert.DeserializeObject <DocumentGraphModelList>(jsonString));
}
}
public override IEnumerable <OutputGenerator> CreateGenerators(IGraphConfiguration graphConfig, IDataRecord item)
{
foreach (var template in RegisteredTemplates)
{
if (template.Key.IsAssignableFrom(item.GetType()))
{
foreach (var templateType in template.Value)
{
foreach (var t in CreateTemplateGenerators(graphConfig, item, templateType))
{
yield return(t);
}
}
}
}
}
private IEnumerable <OutputGenerator> CreateTemplateGenerators(IGraphConfiguration config, IDataRecord graphItem, Type templateType)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (graphItem == null)
{
throw new ArgumentNullException("graphItem");
}
if (templateType == null)
{
throw new ArgumentNullException("templateType");
}
var templateClassType = templateType.GetGenericArguments()[1];
var templateAttribute = templateClassType.GetCustomAttributes(typeof(TemplateClass), true)
.OfType <TemplateClass>()
.FirstOrDefault();
if (templateAttribute == null)
{
InvertApplication.Log(string.Format("ClassTemplate attribute not found on {0} ", templateClassType.Name));
yield break;
}
if (templateAttribute.Location == TemplateLocation.DesignerFile || templateAttribute.Location == TemplateLocation.Both)
{
var template = Activator.CreateInstance(templateType) as CodeGenerator;
template.ObjectData = graphItem;
template.IsDesignerFile = true;
//template.AssetDirectory = graphItem.Graph.Project.SystemDirectory;
template.AssetDirectory = config.CodeOutputPath;
yield return(template);
}
if (templateAttribute.Location == TemplateLocation.EditableFile || templateAttribute.Location == TemplateLocation.Both)
{
var template = Activator.CreateInstance(templateType) as CodeGenerator;
template.ObjectData = graphItem;
template.IsDesignerFile = false;
template.AssetDirectory = config.CodeOutputPath;
yield return(template);
}
}
public static List <string> GetTopicSenders(string Topic, IGraphConfiguration GraphConfiguration)
{
List <string> tagSenders = new List <string>();
using (var tagHiveClient = CommunicationProcessingBusinessLogic.CreateGremlinClient(GraphConfiguration))
{
string query = GraphQueryBusinessLogic.GetTopicSendersGraphQuery(Topic);
var results = CommunicationProcessingBusinessLogic.SubmitRequest(tagHiveClient, query).Result;
if (results.Count > 0)
{
foreach (var item in results)
{
//TagSender tagSender = JsonConvert.DeserializeObject<TagSender>(JsonConvert.SerializeObject(item));
tagSenders.Add(item);
}
}
}
return(tagSenders);
}
public static List <TagRecipient> GetTopicRecipients(string Topic, IGraphConfiguration GraphConfiguration)
{
List <TagRecipient> tagRecipients = new List <TagRecipient>();
using (var tagHiveClient = CommunicationProcessingBusinessLogic.CreateGremlinClient(GraphConfiguration))
{
//TODO Update this query to find most common recipients of the topic
string query = string.Format("g.V(\"{0}\").outE(\"recipient\")", Topic);
var results = CommunicationProcessingBusinessLogic.SubmitRequest(tagHiveClient, query).Result;
if (results.Count > 0)
{
foreach (var item in results)
{
TagRecipient tagRecipient = JsonConvert.DeserializeObject <TagRecipient>(JsonConvert.SerializeObject(item));
tagRecipients.Add(tagRecipient);
}
}
}
return(tagRecipients);
}
/// <summary>
/// This method gets every method, property, or constructor generated for a node, pass in an item filter to filter only to specific items
/// that are set up as iterators on templates.
///
/// For Example:
/// You can get only the members of a class that have been added since last save and compile by comparing with with the change tracking data.
/// </summary>
/// <param name="node"></param>
/// <param name="itemFilter"></param>
/// <returns></returns>
public static IEnumerable <TemplateMemberResult> GetEditableOutputMembers(this IDiagramNodeItem node,
IGraphConfiguration config, Predicate <IDiagramNodeItem> itemFilter = null)
{
foreach (var item in GetAllEditableFilesForNode(node, config).OfType <ITemplateClassGenerator>())
{
var gen = new CodeFileGenerator()
{
Generators = new[] { item as OutputGenerator },
SystemPath = string.Empty
};
gen.Namespace = new CodeNamespace();
gen.Unit = new CodeCompileUnit();
gen.Unit.Namespaces.Add(gen.Namespace);
item.ItemFilter = itemFilter;
item.Initialize(gen);
foreach (var result in item.Results)
{
yield return(result);
}
}
}
public void PreCompile(IGraphConfiguration configuration, IDataRecord[] compilingRecords)
{
}
public void ChangeDatabase(IGraphConfiguration configuration)
{
RefreshToolbar();
}
public void ChangeDatabase(IGraphConfiguration configuration)
{
}
public void PostCompile(IGraphConfiguration configuration, IDataRecord[] compilingRecords)
{
Percentage = 0f;
}
public static IEnumerable <IClassTemplate> GetTemplates(this IDiagramNodeItem node, IGraphConfiguration config,
Predicate <IDiagramNodeItem> itemFilter = null)
{
foreach (var item in node.GetCodeGeneratorsForNode(config).OfType <ITemplateClassGenerator>())
{
yield return(item.Template);
}
}
/// <summary>
/// Get all of the output generators that are generated only the first time, AKA: Editable Files
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static IEnumerable <OutputGenerator> GetAllEditableFilesForNode(this IDataRecord node,
IGraphConfiguration config)
{
return(GetAllCodeGenerators(config, new[] { node }).Where(p => p.ObjectData == node && !p.AlwaysRegenerate));
}
public void PreCompile(IGraphConfiguration configuration, IDataRecord[] compilingRecords)
{
EditorApplication.LockReloadAssemblies();
}
public abstract IEnumerable<OutputGenerator> GetGenerators(IGraphConfiguration graphConfig, object node);
public static Dictionary <string, int> GetTopicSendersWithSentValues(string Topic, IGraphConfiguration GraphConfiguration)
{
Dictionary <string, int> tagSenders = new Dictionary <string, int>();
using (var tagHiveClient = CommunicationProcessingBusinessLogic.CreateGremlinClient(GraphConfiguration))
{
string query = GraphQueryBusinessLogic.GetTopicSendersGraphQueryWithSentValues(Topic);
var results = CommunicationProcessingBusinessLogic.SubmitRequest(tagHiveClient, query).Result;
if (results.Count > 0)
{
foreach (var resultsetItem in results)
{
foreach (var item in resultsetItem)
{
tagSenders.Add(((KeyValuePair <string, object>)item).Key, int.Parse(((KeyValuePair <string, object>)item).Value.ToString()));
}
}
}
}
return(tagSenders);
}
internal InReverse(IGraphConfiguration <TParent> c, string label)
{
_c = c;
_label = label;
}
public void ChangeDatabase(IGraphConfiguration configuration)
{
}
public static GremlinClient CreateGremlinClient(IGraphConfiguration graphConfiguration)
{
return(CreateGremlinClient(graphConfiguration.GetGraphDatabaseHostname(), graphConfiguration.GetGraphDatabasePort(), graphConfiguration.GetGraphDatabaseAccessKey(), graphConfiguration.GetGraphDatabaseName(), graphConfiguration.GetGraphDatabaseCollectionName()));
}
public void PostCompile(IGraphConfiguration configuration, IDataRecord[] compilingRecords)
{
EditorApplication.UnlockReloadAssemblies();
EditorUtility.ClearProgressBar();
}
public abstract IEnumerable <OutputGenerator> GetGenerators(IGraphConfiguration graphConfig, object node);
public void PostCompile(IGraphConfiguration configuration, IDataRecord[] compilingRecords)
{
Percentage = 0f;
}
public void PreCompile(IGraphConfiguration configuration, IDataRecord[] compilingRecords)
{
}
/// <summary>
/// Grab all of the output generators that are always regenerated on a node.
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static IEnumerable <OutputGenerator> GetAllDesignerFilesForNode(this IDiagramNodeItem node,
IGraphConfiguration config)
{
return(GetAllCodeGenerators(config, new IDataRecord[] { node })
.Where(p => p.ObjectData == node && p.AlwaysRegenerate));
}
protected override bool InitializeModel(IGraphConfiguration configuration)
{
configuration.AddCollection <IProfile>()
.AddCollection <ICompany>();
return(true);
}
/// <summary> /// Register all vertecies that should be used with this context. /// </summary> /// <param name="configuration"></param> /// <returns>true if overridden</returns> protected abstract bool InitializeModel(IGraphConfiguration configuration);
public void ChangeDatabase(IGraphConfiguration configuration)
{
RefreshToolbar();
}
