private void ImportBaseElementTemplates([NotNull] ThreatModel source, [NotNull] IThreatModel target)
        {
            var elements = source.ElementTypes?
                           .Where(x => x.IsGeneric)
                           .ToArray();

            if (elements?.Any() ?? false)
            {
                IPropertySchema schema       = null;
                var             baseEISchema = new BaseExternalInteractorPropertySchemaManager(target).GetSchema();
                var             basePSchema  = new BaseProcessPropertySchemaManager(target).GetSchema();
                var             baseDSSchema = new BaseDataStorePropertySchemaManager(target).GetSchema();
                var             baseTBSchema = new BaseTrustBoundaryPropertySchemaManager(target).GetSchema();

                foreach (var element in elements)
                {
                    switch (element.ElementType)
                    {
                    case ElementType.StencilRectangle:
                        schema = baseEISchema;
                        break;

                    case ElementType.StencilEllipse:
                        schema = basePSchema;
                        break;

                    case ElementType.StencilParallelLines:
                        schema = baseDSSchema;
                        break;

                    case ElementType.BorderBoundary:
                    case ElementType.LineBoundary:
                        schema = baseTBSchema;
                        break;
                    }

                    if (schema != null)
                    {
                        var properties = element.Properties?.ToArray();

                        var outOfScope = schema.GetPropertyType("Out of Scope") ??
                                         schema.AddPropertyType("Out of Scope", PropertyValueType.Boolean);
                        var reason = schema.GetPropertyType("Reason For Out Of Scope") ??
                                     schema.AddPropertyType("Reason For Out Of Scope", PropertyValueType.String);

                        AddProperties(schema, null, properties);
                    }
                }
            }
        }
        private void ImportElements([NotNull] ThreatModel source, [NotNull] IThreatModel target, float dpiFactor,
                                    out int diagrams, out int externalInteractors, out int processes, out int dataStores, out int trustBoundaries)
        {
            diagrams            = 0;
            externalInteractors = 0;
            processes           = 0;
            dataStores          = 0;
            trustBoundaries     = 0;

            var elements = source.Elements?
                           .OrderBy(x => (int)x.Value.ElementType)
                           .ToArray();

            if (elements?.Any() ?? false)
            {
                var schemaManager = new ObjectPropertySchemaManager(target);

                IEntity                entity;
                ITrustBoundary         boundary;
                IEntityTemplate        entityTemplate;
                ITrustBoundaryTemplate trustBoundaryTemplate;
                IPropertySchema        schema;
                IPropertySchema        secondarySchema;
                var baseEISchema = new BaseExternalInteractorPropertySchemaManager(target).GetSchema();
                var basePSchema  = new BaseProcessPropertySchemaManager(target).GetSchema();
                var baseDSSchema = new BaseDataStorePropertySchemaManager(target).GetSchema();
                var baseTBSchema = new BaseTrustBoundaryPropertySchemaManager(target).GetSchema();

                foreach (var element in elements)
                {
                    switch (element.Value.ElementType)
                    {
                    case ElementType.StencilRectangle:
                        entityTemplate = target.EntityTemplates?.FirstOrDefault(x =>
                                                                                string.CompareOrdinal(schemaManager.GetObjectId(x), element.Value.TypeId) == 0);
                        entity = entityTemplate != null?entityTemplate.CreateEntity(element.Value.Name) :
                                     target.AddEntity <IExternalInteractor>(element.Value.Name);

                        boundary        = null;
                        schema          = baseEISchema;
                        secondarySchema = entityTemplate != null?
                                          target.GetSchema(entityTemplate.Name, Resources.DefaultNamespace) : null;

                        externalInteractors++;
                        break;

                    case ElementType.StencilEllipse:
                        entityTemplate = target.EntityTemplates?.FirstOrDefault(x =>
                                                                                string.CompareOrdinal(schemaManager.GetObjectId(x), element.Value.TypeId) == 0);
                        entity = entityTemplate != null?entityTemplate.CreateEntity(element.Value.Name) :
                                     target.AddEntity <IProcess>(element.Value.Name);

                        boundary        = null;
                        schema          = basePSchema;
                        secondarySchema = entityTemplate != null?
                                          target.GetSchema(entityTemplate.Name, Resources.DefaultNamespace) : null;

                        processes++;
                        break;

                    case ElementType.StencilParallelLines:
                        entityTemplate = target.EntityTemplates?.FirstOrDefault(x =>
                                                                                string.CompareOrdinal(schemaManager.GetObjectId(x), element.Value.TypeId) == 0);
                        entity = entityTemplate != null?entityTemplate.CreateEntity(element.Value.Name) :
                                     target.AddEntity <IDataStore>(element.Value.Name);

                        boundary        = null;
                        schema          = baseDSSchema;
                        secondarySchema = entityTemplate != null?
                                          target.GetSchema(entityTemplate.Name, Resources.DefaultNamespace) : null;

                        dataStores++;
                        break;

                    case ElementType.BorderBoundary:
                    case ElementType.LineBoundary:
                        trustBoundaryTemplate = target.TrustBoundaryTemplates?.FirstOrDefault(x =>
                                                                                              string.CompareOrdinal(schemaManager.GetObjectId(x), element.Value.TypeId) == 0);
                        entity   = null;
                        boundary = trustBoundaryTemplate != null?trustBoundaryTemplate.CreateTrustBoundary(element.Value.Name) :
                                       target.AddGroup <ITrustBoundary>(element.Value.Name);

                        schema          = baseTBSchema;
                        secondarySchema = trustBoundaryTemplate != null?
                                          target.GetSchema(trustBoundaryTemplate.Name, Resources.DefaultNamespace) : null;

                        trustBoundaries++;
                        break;

                    default:
                        entity          = null;
                        boundary        = null;
                        schema          = null;
                        secondarySchema = null;
                        break;
                    }

                    if (entity != null)
                    {
                        schemaManager.SetObjectId(entity, element.Value.TypeId);
                        schemaManager.SetInstanceId(entity, element.Key.ToString());
                        var properties = element.Value.Properties?.ToArray();
                        AddProperties(target, schema, secondarySchema, entity, properties);

                        var diagram = target.Diagrams?.FirstOrDefault(x =>
                                                                      string.CompareOrdinal(x.Name, element.Value.Page) == 0);
                        if (diagram == null)
                        {
                            diagram = target.AddDiagram(element.Value.Page);
                            diagrams++;
                        }

                        diagram.AddEntityShape(entity.Id,
                                               new PointF((element.Value.Position.X + element.Value.Size.Width / 2f) * dpiFactor, (element.Value.Position.Y + element.Value.Size.Height / 2f) * dpiFactor));
                    }
                    else if (boundary != null)
                    {
                        schemaManager.SetObjectId(boundary, element.Value.TypeId);
                        schemaManager.SetInstanceId(boundary, element.Key.ToString());
                        var properties = element.Value.Properties?.ToArray();
                        AddProperties(target, schema, secondarySchema, entity, properties);

                        if (element.Value.ElementType == ElementType.BorderBoundary)
                        {
                            var diagram = target.Diagrams?.FirstOrDefault(x =>
                                                                          string.CompareOrdinal(x.Name, element.Value.Page) == 0);
                            if (diagram == null)
                            {
                                diagram = target.AddDiagram(element.Value.Page);
                                diagrams++;
                            }

                            diagram.AddGroupShape(boundary.Id,
                                                  new PointF((element.Value.Position.X + element.Value.Size.Width / 2f) * dpiFactor, (element.Value.Position.Y + element.Value.Size.Height / 2f) * dpiFactor),
                                                  new SizeF(element.Value.Size.Width * dpiFactor, element.Value.Size.Height * dpiFactor));
                        }
                    }
                }
            }
        }
        private int ImportEntityTemplates([NotNull] ThreatModel source, [NotNull] IThreatModel target)
        {
            int result   = 0;
            var elements = source.ElementTypes?
                           .Where(x => !x.IsGeneric)
                           .ToArray();

            if (elements?.Any() ?? false)
            {
                var schemaManager = new ObjectPropertySchemaManager(target);

                IEntityTemplate        entityTemplate;
                ITrustBoundaryTemplate trustBoundaryTemplate;
                Interfaces.Scope       scope;
                IPropertySchema        baseSchema;
                var baseEISchema = new BaseExternalInteractorPropertySchemaManager(target).GetSchema();
                var basePSchema  = new BaseProcessPropertySchemaManager(target).GetSchema();
                var baseDSSchema = new BaseDataStorePropertySchemaManager(target).GetSchema();
                var baseTBSchema = new BaseTrustBoundaryPropertySchemaManager(target).GetSchema();

                foreach (var element in elements)
                {
                    switch (element.ElementType)
                    {
                    case ElementType.StencilRectangle:
                        entityTemplate = target.AddEntityTemplate(element.Name, element.Description,
                                                                  element.Image, element.Image, element.Image,
                                                                  EntityType.ExternalInteractor);
                        trustBoundaryTemplate = null;
                        scope      = Scope.ExternalInteractor;
                        baseSchema = baseEISchema;
                        result++;
                        break;

                    case ElementType.StencilEllipse:
                        entityTemplate = target.AddEntityTemplate(element.Name, element.Description,
                                                                  element.Image, element.Image, element.Image,
                                                                  EntityType.Process);
                        trustBoundaryTemplate = null;
                        scope      = Scope.Process;
                        baseSchema = basePSchema;
                        result++;
                        break;

                    case ElementType.StencilParallelLines:
                        entityTemplate = target.AddEntityTemplate(element.Name, element.Description,
                                                                  element.Image, element.Image, element.Image,
                                                                  EntityType.DataStore);
                        trustBoundaryTemplate = null;
                        scope      = Scope.DataStore;
                        baseSchema = baseDSSchema;
                        result++;
                        break;

                    case ElementType.LineBoundary:
                    case ElementType.BorderBoundary:
                        entityTemplate        = null;
                        trustBoundaryTemplate = target.AddTrustBoundaryTemplate(element.Name, element.Description);
                        scope      = Scope.TrustBoundary;
                        baseSchema = baseTBSchema;
                        result++;
                        break;

                    default:
                        entityTemplate        = null;
                        trustBoundaryTemplate = null;
                        scope      = Scope.Undefined;
                        baseSchema = null;
                        break;
                    }

                    if (entityTemplate != null)
                    {
                        InitializeBaseSchema(entityTemplate, baseSchema);
                        schemaManager.SetObjectId(entityTemplate, element.TypeId);
                        var properties = element.Properties?.ToArray();

                        AddProperties(target, element.Name, scope, baseSchema, entityTemplate, properties);
                    }
                    else if (trustBoundaryTemplate != null)
                    {
                        InitializeBaseSchema(trustBoundaryTemplate, baseSchema);
                        schemaManager.SetObjectId(trustBoundaryTemplate, element.TypeId);
                        var properties = element.Properties?.ToArray();

                        AddProperties(target, element.Name, scope, baseSchema, trustBoundaryTemplate, properties);
                    }
                }
            }

            return(result);
        }