private void ProcessModelItemEvent(ModelItemEventBase modelItemEvent)
{
switch (modelItemEvent)
{
case ModelNodeUpdatedEvent modelNodeUpdated:
var updatedNode = modelNodeUpdated.NewNode;
DiagramService.UpdateModelNode(updatedNode);
break;
case ModelNodeRemovedEvent modelNodeRemovedEvent:
var removedNode = modelNodeRemovedEvent.RemovedNode;
DiagramService.RemoveNode(removedNode.Id);
break;
case ModelRelationshipAddedEvent modelRelationshipAddedEvent:
var addedRelationship = modelRelationshipAddedEvent.AddedRelationship;
ShowModelRelationshipIfBothEndsAreVisible(addedRelationship, DiagramService.LatestDiagram);
break;
case ModelRelationshipRemovedEvent modelRelationshipRemovedEvent:
var modelRelationship = modelRelationshipRemovedEvent.RemovedRelationship;
DiagramService.RemoveConnector(modelRelationship.Id);
break;
}
}
public static object FindDiagramsByStory(IDictionary <string, object> story)
{
DiagramService service = (DiagramService) new ServiceLocator <Attachment>().locate();
var diagrams = service.FindByStoryID(int.Parse(story["Id"].ToString()));
return(Utils.SerializeObject(diagrams));
}
private void OnModelChanged(ModelEventBase modelEvent)
{
DiagramService.UpdateModel(modelEvent.NewModel);
switch (modelEvent)
{
case ModelNodeUpdatedEvent modelNodeUpdatedEvent:
DiagramService.UpdateModelNode(modelNodeUpdatedEvent.NewNode);
break;
case ModelNodeRemovedEvent modelNodeRemovedEvent:
var removedNode = modelNodeRemovedEvent.RemovedNode;
DiagramService.RemoveNode(removedNode.Id);
break;
case ModelRelationshipAddedEvent modelRelationshipAddedEvent:
var addedRelationship = modelRelationshipAddedEvent.AddedRelationship;
ShowModelRelationshipIfBothEndsAreVisible(addedRelationship, DiagramService.LatestDiagram);
break;
case ModelRelationshipRemovedEvent modelRelationshipRemovedEvent:
var modelRelationship = modelRelationshipRemovedEvent.RemovedRelationship;
DiagramService.RemoveConnector(modelRelationship.Id);
break;
case ModelClearedEvent _:
DiagramService.ClearDiagram();
break;
}
}
private void OnDiagramChanged(DiagramEvent diagramEvent)
{
var diagram = diagramEvent.NewDiagram;
var diagramLayoutInfo = _layoutAlgorithm.Calculate(diagram);
DiagramService.ApplyLayout(diagramLayoutInfo);
}
private void MoveViewport()
{
if (_followedNodeIds == null)
{
return;
}
var rect = DiagramService.GetRect(_followedNodeIds).ToWpf();
if (rect.IsUndefined())
{
return;
}
switch (Mode)
{
case ViewportAutoMoveMode.Center:
ZoomToRect(rect, _followNodesTransitionSpeed);
break;
case ViewportAutoMoveMode.Contain:
ContainRect(rect, _followNodesTransitionSpeed);
break;
}
}
public void ConfigureServices(IServiceCollection services)
{
services.AddSignalR(options =>
{
options.MaximumReceiveMessageSize = Int64.MaxValue;
});
var dbContextInitializer = new DBContextInitializer();
_dbContext = dbContextInitializer.MakeDBContext(Configuration);
services.AddSingleton <IDBContext>(_dbContext);
var diagramService = new DiagramService(_dbContext);
services.AddSingleton <IDiagramService>(diagramService);
var actionService = new ActionService();
services.AddSingleton <IActionService>(actionService);
var mainNotifier = new MainNotifier();
mainNotifier.Start();
services.AddSingleton <IMainNotifier>(mainNotifier);
services.AddControllers();
}
public void ItGetValidPngImageUrlForSource()
{
var imageUrl = DiagramService.GetImageUrlForSource(SamplePlantUml, "png");
_imageOnDisk = ImageService.SaveImagefromUrlToDisk(imageUrl, Core.ImageRequestFormat.Png, Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()));
AssertIsAPng(_imageOnDisk);
}
private void ApplyChanges(IDictionary <ModelNodeId, Rect2D> changedRects, IDiagram diagram)
{
foreach (var rect in changedRects)
{
var diagramNode = diagram.GetNode(rect.Key);
DiagramService.UpdateDiagramNodeCenter(diagramNode, rect.Value.Center);
}
}
private void BindDiagram()
{
DiagramService diagramService = (DiagramService) new ServiceLocator <Attachment>().locate();
List <UserStoryAttachment> attachments = diagramService.ListAll();
Diagrams.DataSource = attachments;
Diagrams.DataBind();
}
public void DiagramService_Initialization_Test()
{
// Create new DiagramService
IDiagramService diagramservice = new DiagramService();
// Check the DiagramService object
Assert.IsNotNull(diagramservice.Diagram);
Assert.IsInstanceOfType(diagramservice, typeof(DiagramService));
}
private void OnModelChanged(ModelEvent modelEvent)
{
DiagramService.UpdateModel(modelEvent.NewModel);
foreach (var itemChange in modelEvent.ItemEvents)
{
ProcessModelItemEvent(itemChange);
}
}
protected void AddDiagramConnectorIfNotExists(IModelRelationship modelRelationship, IDiagram diagram)
{
if (diagram.ConnectorExists(modelRelationship.Id))
{
return;
}
DiagramService.AddConnector(modelRelationship.Id);
}
private async Task ShowEntitiesAsync(
[NotNull] IReadOnlyCollection <ModelNodeId> modelEntities,
CancellationToken cancellationToken,
IIncrementalProgress progress)
{
await Task.Run(
() => DiagramService.AddNodes(modelEntities, cancellationToken, progress),
cancellationToken);
}
private void ShowContainment([NotNull] IModelRelationship addedRelationship)
{
var diagram = DiagramService.LatestDiagram;
if (diagram.NodeExists(addedRelationship.Source) && diagram.NodeExists(addedRelationship.Target))
{
DiagramService.UpdateParent(addedRelationship.Target, addedRelationship.Source);
}
}
private void ShowAsParentNode([NotNull] IModelNode addedModelNode, [NotNull] IModel model)
{
var diagram = DiagramService.LatestDiagram;
var childNodes = model.GetRelatedNodes(addedModelNode.Id, CommonDirectedModelRelationshipTypes.Contained);
if (childNodes.Any(i => diagram.NodeExists(i.Id)))
{
DiagramService.AddNode(addedModelNode.Id);
}
}
private void HideRedundantConnectors([NotNull] IDiagram diagram)
{
foreach (var connector in diagram.Connectors.Where(i => _modelRelationshipFeatureProvider.IsTransitive(i.ModelRelationship.Stereotype)))
{
if (diagram.IsConnectorRedundant(connector.Id, connector.ModelRelationship.Stereotype))
{
DiagramService.RemoveConnector(connector.Id);
}
}
}
protected void gvResult_RowCommand(object sender, GridViewCommandEventArgs e)
{
string Id = gvResult.DataKeys[Convert.ToInt32(e.CommandArgument)].Values[0].ToString();
DiagramService dService = (DiagramService) new ServiceLocator <Engineer.EMF.Attachment>().locate();
var diagrams = dService.FindByStoryID(int.Parse(Id));
Diagrams.DataSource = diagrams != null ? diagrams : new List <Engineer.EMF.UserStoryAttachment>();
Diagrams.DataBind();
Diagrams.Visible = true;
}
private void HideRedundantConnectors(IDiagram diagram)
{
foreach (var connector in diagram.Connectors)
{
if (diagram.IsConnectorRedundant(connector.Id))
{
DiagramService.RemoveConnector(connector.Id);
}
}
}
private void OnDiagramChanged(DiagramEvent diagramEvent)
{
if (diagramEvent.ShapeEvents.All(i => !IsLayoutTriggeringChange(i)))
{
return;
}
var diagram = diagramEvent.NewDiagram;
var diagramLayoutInfo = _layoutAlgorithm.Calculate(diagram);
DiagramService.ApplyLayout(diagramLayoutInfo);
}
private void OnDiagramChanged([NotNull] DiagramEventBase diagramEvent)
{
switch (diagramEvent)
{
case DiagramNodeRectChangedEvent _:
case DiagramConnectorRouteChangedEvent _:
return;
}
var diagram = diagramEvent.NewDiagram;
var diagramLayoutInfo = _layoutAlgorithm.Calculate(diagram);
DiagramService.ApplyLayout(diagramLayoutInfo);
}
protected async Task <Maybe <IModelNode> > TryAddCurrentSymbolToDiagramAsync()
{
var maybeSymbol = await RoslynWorkspaceProvider.TryGetCurrentSymbolAsync();
if (!maybeSymbol.HasValue)
{
return(Maybe <IModelNode> .Nothing);
}
var modelNode = RoslynBasedModelService.GetOrAddNode(maybeSymbol.Value);
DiagramService.AddNode(modelNode.Id);
return(Maybe.Create(modelNode));
}
public void DiagramService_SetChartData_Test()
{
// Create new DiagramService and Test-Data
DiagramService diagramservice = new DiagramService();
var testdata = new List <KeyValuePair <int, string> >()
{
new KeyValuePair <int, string>(1, "test")
};
// Execute SetChartData Function
diagramservice.SetChartData <int, string>(testdata, DiagramType.LINE);
// Check if a new Diagram was created and a DataSeries was added
Assert.IsNotNull(diagramservice.Diagram);
Assert.IsNotNull(diagramservice.Diagram.Series);
}
private IEnumerable <ModelNodeId> ShowModelNodeWithHierarchy(
ModelNodeId nodeId,
CancellationToken cancellationToken,
IIncrementalProgress progress)
{
var model = RoslynBasedModelService.LatestModel;
var baseTypeIds = model.GetRelatedNodes(nodeId, DirectedModelRelationshipTypes.BaseType, recursive: true).Select(i => i.Id);
var subtypeIds = model.GetRelatedNodes(nodeId, DirectedModelRelationshipTypes.Subtype, recursive: true).Select(i => i.Id);
var nodeIds = new[] { nodeId }.Union(baseTypeIds).Union(subtypeIds).ToList();
DiagramService.AddNodes(nodeIds, cancellationToken, progress);
return(nodeIds);
}
private void ShowParentNode([NotNull] IDiagramNode diagramNode)
{
var modelNode = diagramNode.ModelNode;
if (!modelNode.Stereotype.In(TypeMemberModelNodeStereotypes))
{
return;
}
var parentModelNode = _modelService.LatestModel.GetRelatedNodes(modelNode.Id, CommonDirectedModelRelationshipTypes.Container).SingleOrDefault();
if (parentModelNode != null)
{
DiagramService.AddNode(parentModelNode.Id);
}
}
/// <summary>
/// Converts to interface.
/// </summary>
/// <param name="type">The type.</param>
/// <returns></returns>
private static Models.Interface ConvertToInterface(Type type)
{
var @interface = new Models.Interface
{
Name = Regex.Replace(type.Name, TypingSetter, ""),
Properties = GetProperties(type),
Functions = GetFunctions(type),
Voids = GetVoids(type)
};
@interface.Diagram = string.Format(Templates.PsuedoCode, AssemblyDiagrammer.WriteClassDiagram(@interface));
@interface.DiagramUrl = DiagramService.GetImageUrlForSource(@interface.Diagram, "svg");
@interface.Documentation = DocumentService.GetInterfaceDocumentation(type.Namespace, @interface);
@interface.Relationships = AssemblyDiagrammer.GetRelationships(@interface);
return(@interface);
}
/// <summary>
/// Lists the namespaces.
/// </summary>
/// <param name="assembly">The assembly.</param>
/// <returns></returns>
private static List <Models.Namespace> ListNamespaces(Assembly assembly)
{
var names = assembly.GetTypes().Select((t) => t.Namespace).Distinct().ToList();
names.Where((x) => (x != null) && (!string.IsNullOrEmpty(x)) && (!x.Contains("My.")) && (!x.Contains(".My"))).ToList().ForEach((n) => Namespaces.Add(new Models.Namespace {
Name = n
}));
Namespaces.ForEach((n) =>
{
Console.WriteLine(n.Name);
GetTypes(assembly, n);
n.Topography = AssemblyDiagrammer.MapTopography(n);
n.TopographyUrl = DiagramService.GetImageUrlForSource(n.Topography, "svg");
n.Documentation = DocumentService.GetNamespaceDocumentation(n);
});
return(Namespaces);
}
private void AddNode(IDiagramNode diagramNode)
{
var diagramNodeUi = (DiagramNodeViewModelBase)_diagramShapeUiFactory.CreateDiagramNodeUi(DiagramService, diagramNode, MiniButtonPanelViewModel);
diagramNodeUi.SizeChanged += OnDiagramNodeSizeChanged;
diagramNodeUi.ShowRelatedNodesRequested += OnShowRelatedNodesRequested;
diagramNodeUi.RelatedNodeSelectorRequested += OnEntitySelectorRequested;
diagramNodeUi.RemoveRequested += OnRemoveDiagramNodeRequested;
_diagramNodeToViewModelMap.Set(diagramNode, diagramNodeUi);
if (DiagramService.TryGetContainerNode(diagramNode, out var containerNode) &&
IsNodeVisibleOnDiagram(containerNode, out var containerNodeUi))
{
((IContainerDiagramNodeUi)containerNodeUi).AddChildNode(diagramNodeUi);
}
else
{
DiagramNodeViewModels.Add(diagramNodeUi);
}
}
private void OnModelChanged(ModelEventBase modelEvent)
{
var diagram = DiagramService.Diagram;
switch (modelEvent)
{
case ModelNodeUpdatedEvent modelNodeUpdatedEvent:
var newModelNode = modelNodeUpdatedEvent.NewNode;
if (diagram.TryGetNode(newModelNode.Id, out var diagramNodeToUpdate))
{
DiagramService.UpdateDiagramNodeModelNode(diagramNodeToUpdate, newModelNode);
}
break;
case ModelNodeRemovedEvent modelNodeRemovedEvent:
var removedModelNode = modelNodeRemovedEvent.RemovedNode;
if (diagram.TryGetNode(removedModelNode.Id, out var diagramNodeToRemove))
{
DiagramService.RemoveNode(diagramNodeToRemove.Id);
}
break;
case ModelRelationshipAddedEvent modelRelationshipAddedEvent:
var addedRelationship = modelRelationshipAddedEvent.AddedRelationship;
ShowModelRelationshipIfBothEndsAreVisible(addedRelationship, diagram);
break;
case ModelRelationshipRemovedEvent modelRelationshipRemovedEvent:
var modelRelationship = modelRelationshipRemovedEvent.RemovedRelationship;
if (diagram.TryGetConnector(modelRelationship.Id, out var diagramConnector))
{
DiagramService.RemoveConnector(diagramConnector.Id);
}
break;
case ModelClearedEvent _:
DiagramService.ClearDiagram();
break;
}
}
public static object Share(IDictionary <string, string> diagram)
{
DiagramService service = (DiagramService) new ServiceLocator <Attachment>().locate();
var stories = new List <UserStoryAttachment>();
IEnumerable <string> storiesStr = !string.IsNullOrEmpty(diagram["userStories"]) ? diagram["userStories"].Split(',') : Enumerable.Empty <string>();
storiesStr.ToList().ForEach(f =>
{
stories.Add(new UserStoryAttachment()
{
userStoryId = int.Parse(f), attachId = int.Parse(diagram["attachId"])
});
});
var diagramObject = new Attachment()
{
Id = int.Parse(diagram["attachId"]),
UserStoryAttachments = stories
};
service.Share(diagramObject, int.Parse(diagram["userStoryId"]), new List().GetUserId());
return(Utils.SerializeObject(stories));
}
/// <summary>
/// Converts to class.
/// </summary>
/// <param name="type">The type.</param>
/// <returns></returns>
public static Models.Class ConvertToClass(Type type)
{
var @class = new Models.Class
{
Name = Regex.Replace(type.Name, TypingSetter, ""),
Properties = GetProperties(type),
Functions = GetFunctions(type),
Voids = GetVoids(type),
Abstract = type.IsAbstract,
Static = IsStaticType(type),
Module = IsModule(type),
Implements = type.GetInterfaces().FirstOrDefault(),
Inherits = (type.BaseType ?? null)
};
@class.Diagram = string.Format(Templates.PsuedoCode, AssemblyDiagrammer.WriteClassDiagram(@class));
@class.DiagramUrl = DiagramService.GetImageUrlForSource(@class.Diagram, "svg");
@class.Documentation = DocumentService.GetClassDocumentation(type.Namespace, @class);
@class.Relationships = AssemblyDiagrammer.GetRelationships(@class);
return(@class);
}
