private async Task SendReportEmail(ProjectImport projectImport, List <string> outputLines)
        {
            var    locale  = projectImport.Owner.LocaleOrDefault();
            string subject = await translator.TranslateAsync(locale, "importProject", "importProject.subject", null);

            string title = await translator.TranslateAsync(locale, "importProject", "importProject.title", null);

            string propertiesHeader = await translator.TranslateAsync(locale, "importProject", "importProject.propertiesHeader", null);

            string outputHeader = await translator.TranslateAsync(locale, "importProject", "importProject.outputHeader", null);

            var propertyLines = new List <string>();

            await TranslateProperty(propertyLines, locale, "Owner", projectImport.Owner.Name);
            await TranslateProperty(propertyLines, locale, "Group", projectImport.Group.Name);
            await TranslateProperty(propertyLines, locale, "Organization", projectImport.Organization.Name);
            await TranslateProperty(propertyLines, locale, "Application Type", projectImport.Type.Description);

            var email = new Email
            {
                To              = projectImport.Owner.Email,
                Subject         = subject,
                ContentTemplate = "ProjectImport.txt",
                ContentModel    = new
                {
                    Title            = title,
                    PropertiesHeader = propertiesHeader,
                    Properties       = propertyLines,
                    OutputHeader     = outputHeader,
                    Output           = outputLines
                }
            };
            await emailRepository.CreateAsync(email);
        }
Пример #2
0
 /// <summary>
 /// Importe un projet.
 /// </summary>
 /// <param name="import">Les données à importer.</param>
 /// <param name="mergeReferentials"><c>true</c> pour fusionner les référentiels.</param>
 /// <param name="videosDirectory">Le dossier qui contient les vidéos.</param>
 public virtual async Task <Project> ImportProject(ProjectImport import, bool mergeReferentials, string videosDirectory) =>
 await Task.Run(async() =>
 {
     using (var context = ContextFactory.GetNewContext())
     {
         return(await ImportProject(context, import, mergeReferentials, videosDirectory));
     }
 });
Пример #3
0
 /// <summary>
 /// Importe un projet.
 /// </summary>
 /// <param name="import">Les données à importer.</param>
 /// <param name="mergeReferentials"><c>true</c> pour fusionner les référentiels.</param>
 /// <param name="videosDirectory">Le dossier qui contient les vidéos.</param>
 public virtual async Task <Project> ImportProject(ProjectImport import, bool mergeReferentials, string videosDirectory) =>
 await Task.Run(async() =>
 {
     dynamic param           = new ExpandoObject();
     param.import            = import;
     param.mergeReferentials = mergeReferentials;
     param.videosDirectory   = videosDirectory;
     return(await _apiHttpClient.ServiceAsync <Project>(KL2_Server.API, nameof(ImportExportService), nameof(ImportProject), param));
 });
Пример #4
0
        public async Task <IHttpActionResult> ImportProject([DynamicBody] dynamic param)
        {
            try
            {
                ProjectImport import            = param.allScenarios.ToObject <ProjectImport>();
                bool          mergeReferentials = param.allScenarios.ToObject <bool>();
                string        videosDirectory   = param.allScenarios.ToObject <string>();

                await _importExportService.ImportProject(import, mergeReferentials, videosDirectory);

                return(Ok());
            }
            catch (Exception ex)
            {
                _traceManager.TraceError(ex, ex.Message);
                return(InternalServerError(ex));
            }
        }
Пример #5
0
        private void DrawAssetSelection()
        {
            CurrentPackage = (ProjectImport)EditorGUILayout.ObjectField(CurrentPackage, typeof(ProjectImport), true);
            if (CurrentPackage != null)
            {
                var explorer = CurrentPackage.Explorer;

                foreach (var resource in explorer.Resources)
                {
                    if (!resource.Name.EndsWith(".bhvr"))
                    {
                        continue;
                    }

                    if (GUILayout.Button(resource.ToString()))
                    {
                        CurrentResource = resource;
                        JObject editorTarget;
                        using (var editorTargetData = CurrentResource.LoadStream())
                            using (var sr = new StreamReader(editorTargetData))
                                using (var reader = new JsonTextReader(sr))
                                {
                                    editorTarget = JObject.Load(reader);
                                }

                        var nodes = NodeManifest.Construct(new Type[] { typeof(AddNode), typeof(RollNode), typeof(OutputValueNode) });
                        var types = TypeManifest.ConstructBaseTypes();

                        var manifest = new BehaviourManifest()
                        {
                            Nodes = nodes,
                            Types = types,
                        };
                        Debug.Log(editorTarget);
                        var graphEditor = new EditorSession(manifest, editorTarget, "SerializedGraph", Serializer);

                        View.BeginSession(graphEditor);
                    }
                }
            }
        }
Пример #6
0
        public override void OnGUI()
        {
            if (resourceTreeViewState == null)
            {
                resourceTreeViewState = new TreeViewState();
            }
            if (resourceTreeView == null)
            {
                resourceTreeView = new ResourceTreeView(resourceTreeViewState);
            }

            CurrentPackage = (ProjectImport)EditorGUILayout.ObjectField(CurrentPackage, typeof(ProjectImport), true,
                                                                        GUILayout.Width(180));
            if (CurrentPackage == null)
            {
                return;
            }

            if (resourceTreeView != null)
            {
                resourceTreeView.SetTarget(CurrentPackage.Explorer);

                var treeViewRect = new Rect(
                    0,
                    EditorGUIUtility.singleLineHeight + 6,
                    180,
                    Position.height - EditorGUIUtility.singleLineHeight - 6);

                var remainingRect = new Rect(
                    184,
                    0,
                    Position.width - 184,
                    Position.height);

                resourceTreeView.OnGUI(treeViewRect);

                GUILayout.BeginArea(remainingRect);

                foreach (int selected in resourceTreeView.GetSelection())
                {
                    if (resourceTreeView.resourceMapping.TryGetValue(selected, out var resource))
                    {
                        if (CurrentResource != resource)
                        {
                            CurrentResource = resource;

                            CurrentResourceTabs.Clear();

                            try
                            {
                                CurrentResourceTabs.Add(new FrameTab()
                                {
                                    Title = new GUIContent("Editor"),
                                    Frame = new EditorSessionFrame(CurrentResource)
                                });
                            }
                            catch
                            {
                            }

                            CurrentResourceTabs.Add(new FrameTab()
                            {
                                Title = new GUIContent("Information"),
                                Frame = new ResourceInformationFrame(CurrentResource)
                            });
                        }
                    }

                    EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
                    for (int i = 0; i < CurrentResourceTabs.Count; i++)
                    {
                        var tab = CurrentResourceTabs[i];
                        if (GUILayout.Button(tab.Title, EditorStyles.toolbarButton))
                        {
                            CurrentResourceTabIndex = i;
                        }
                    }
                    EditorGUILayout.EndHorizontal();

                    if (CurrentResourceTabIndex >= 0 && CurrentResourceTabIndex < CurrentResourceTabs.Count)
                    {
                        var currentTab = CurrentResourceTabs[CurrentResourceTabIndex];
                        currentTab.Frame.OnGUI();
                    }
                }

                GUILayout.EndArea();
            }
        }
Пример #7
0
        public async Task <bool> IsValid(ProjectImport projectImport)
        {
            // Project and ProjectImport have the same base properties for Organization,
            // Owner, and Group.  So we can reuse those checks.

            // If these fields aren't filled in, then let the foreign key failure
            // be reported
            if ((projectImport.OrganizationId != VALUE_NOT_SET) &&
                (projectImport.OwnerId != VALUE_NOT_SET) &&
                (projectImport.GroupId != VALUE_NOT_SET))
            {
                Organization = await OrganizationRepository.Get()
                               .Where(o => o.Id == projectImport.OrganizationId)
                               .Include(o => o.OrganizationProductDefinitions)
                               .Include(o => o.OrganizationStores)
                               .FirstOrDefaultAsync();

                Group = await GroupRepository.Get()
                        .Where(g => g.Id == projectImport.GroupId)
                        .Include(g => g.Owner).FirstOrDefaultAsync();

                ProjectOwner = await UserRepository.Get()
                               .Where(u => u.Id == projectImport.OwnerId)
                               .Include(u => u.OrganizationMemberships)
                               .ThenInclude(om => om.Organization)
                               .FirstOrDefaultAsync();

                CurrentUserOrgIds = CurrentUser.OrganizationIds.OrEmpty();
                base.ValidateProject();
            }

            if (base.IsValid())
            {
                // Verify the Products
                var importData = JsonConvert.DeserializeObject <ImportData>(projectImport.ImportData);
                foreach (var importProduct in importData.Products)
                {
                    var productDefinition = await ProductDefinitionRepository.Get()
                                            .Where(pd => pd.Name == importProduct.Name)
                                            .Include(pd => pd.Workflow)
                                            .FirstOrDefaultAsync();

                    if (productDefinition == null)
                    {
                        var message = $"The product.Name={importProduct.Name} was not found";
                        AddError(message);
                    }
                    else if (!Organization.ProductDefinitionIds.Contains(productDefinition.Id))
                    {
                        var message = $"The product.Name={importProduct.Name} is not allowed for organization.Name={Organization.Name}";
                        AddError(message);
                    }

                    var store = await StoreRepository.Get()
                                .Where(s => s.Name == importProduct.Store)
                                .Include(s => s.StoreType)
                                .ThenInclude(st => st.Languages)
                                .FirstOrDefaultAsync();

                    if (store == null)
                    {
                        var message = $"The product.Store={importProduct.Store} was not found";
                        AddError(message);
                    }
                    else
                    {
                        if (!Organization.StoreIds.Contains(store.Id))
                        {
                            var message = $"The product.Store={importProduct.Store} is not allowed for organization.Name={Organization.Name}";
                            AddError(message);
                        }

                        if (store.StoreTypeId != productDefinition.Workflow.StoreTypeId)
                        {
                            var message = "The store type values do not match for this product";
                            AddError(message);
                        }

                        // Not validating Product.StoreLanguageId since it will be coming
                        // from the project's default-language and should be validated in SAB??
                    }
                }
            }

            return(base.IsValid());
        }
Пример #8
0
        /// <summary>
        /// Importe le projet spécifié.
        /// </summary>
        /// <param name="context">Le contexte.</param>
        /// <param name="import">Le projet exporté.</param>
        /// <param name="mergeReferentials"><c>true</c> pour fusionner les référentiels.</param>
        /// <param name="videosDirectory">Le dossier où se situent les vidéos.</param>
        /// <returns>Le projet créé.</returns>
        private async Task <Project> ImportProject(KsmedEntities context, ProjectImport import, bool mergeReferentials, string videosDirectory)
        {
            // Projet
            var p = import.ExportedProject.Project;

            p.ProjectId = default(int);
            MarkAsAdded(p);

            // Ajouter l'utilisateur courant en tant qu'analyste créateur
            var owner = await context.Users.FirstAsync(u => !u.IsDeleted && u.Username == _securityContext.CurrentUser.Username);

            p.Process.Owner = owner;
            p.Process.UserRoleProcesses.Add(new UserRoleProcess()
            {
                User     = owner,
                RoleCode = KnownRoles.Analyst,
            });

            // Videos
            foreach (var video in p.Process.Videos)
            {
                if (video.DefaultResourceId.HasValue && video.DefaultResource == null)
                {
                    // Bug présent dans certains exports de la version 2.5.0.0. Supprimer le lien vers la ressource par défaut.
                    video.DefaultResourceId = null;
                }

                video.VideoId = default(int);
                MarkAsAdded(video);
                video.FilePath = IOHelper.ChangeDirectory(video.FilePath, videosDirectory);
            }

            var referentialsToRemap = new Dictionary <IActionReferential, IActionReferential>();

            if (!mergeReferentials)
            {
                // Référentiels process
                foreach (var refe in import.ExportedProject.ReferentialsProject)
                {
                    MarkAsAdded(refe);
                }

                // Référentiels standard
                foreach (var refe in import.ExportedProject.ReferentialsStandard)
                {
                    var refProject = ReferentialsFactory.CopyToNewProject(refe);

                    // Associer au process
                    refProject.Process = p.Process;

                    referentialsToRemap[refe] = refProject;
                }
            }
            else
            {
                // Référentiels process
                foreach (var refe in import.ExportedProject.ReferentialsProject)
                {
                    // Ajouter au tableau de remap s'il y a une correspondance.
                    if (import.ProjectReferentialsMergeCandidates.ContainsKey(refe))
                    {
                        referentialsToRemap[refe] = import.ProjectReferentialsMergeCandidates[refe];
                    }
                    else
                    {
                        MarkAsAdded(refe);
                    }
                }

                // Référentiels standard
                foreach (var refe in import.ExportedProject.ReferentialsStandard)
                {
                    if (import.StandardReferentialsMergeCandidates.ContainsKey(refe))
                    {
                        referentialsToRemap[refe] = import.StandardReferentialsMergeCandidates[refe];
                    }
                    else
                    {
                        var refProject = ReferentialsFactory.CopyToNewProject(refe);

                        // Associer au process
                        refProject.Process = p.Process;

                        referentialsToRemap[refe] = refProject;
                    }
                }
            }


            // Scénarios
            foreach (var scenario in p.Scenarios.Where(s => s.OriginalScenarioId.HasValue))
            {
                // Remapper l'original
                scenario.Original = p.Scenarios.Single(s => s.ScenarioId == scenario.OriginalScenarioId);
            }

            foreach (var scenario in p.Scenarios)
            {
                foreach (var action in scenario.Actions.Where(a => a.OriginalActionId.HasValue))
                {
                    // Remapper l'original
                    action.Original = p.Scenarios.SelectMany(s => s.Actions).Single(a => a.ActionId == action.OriginalActionId);
                }
            }

            foreach (var scenario in p.Scenarios)
            {
                scenario.ScenarioId = default(int);
                MarkAsAdded(scenario);

                // Supprimer le WebPublicationGuid
                scenario.WebPublicationGuid = null;

                // Actions
                foreach (var action in scenario.Actions)
                {
                    action.ActionId = default(int);
                    MarkAsAdded(action);

                    // Actions réduites
                    if (action.IsReduced)
                    {
                        MarkAsAdded(action.Reduced);
                    }
                }
            }

            // Remapper les référentiels du projet, des actions et des vidéos
            foreach (var oldReferential in referentialsToRemap.Keys)
            {
                ReferentialsHelper.UpdateReferentialReferences(p, oldReferential, referentialsToRemap[oldReferential]);
            }

            foreach (var scenario in p.Scenarios)
            {
                if (scenario.Original != null)
                {
                    context.Scenarios.ApplyChanges(scenario);
                    ObjectContextExt.SetRelationShipReferenceValue(context, scenario, scenario.Original, s => s.OriginalScenarioId);

                    foreach (var action in scenario.Actions)
                    {
                        if (action.Original != null)
                        {
                            context.KActions.ApplyChanges(action);
                            ObjectContextExt.SetRelationShipReferenceValue(context, action, action.Original, a => a.OriginalActionId);
                        }
                    }
                }
            }

            var resources = p.Scenarios.SelectMany(s => s.Actions).Select(a => a.Resource).Distinct().ToArray();

            context.Projects.ApplyChanges(p);

            if (mergeReferentials)
            {
                ServicesDiagnosticsDebug.CheckNotInContext(context, referentialsToRemap.Keys);
                ServicesDiagnosticsDebug.CheckObjectStateManagerState(context, EntityState.Unchanged, referentialsToRemap.Values);
            }

            ServicesDiagnosticsDebug.CheckReferentialsState();

            await context.SaveChangesAsync();

            return(p);
        }
Пример #9
0
        private void DrawAssetSelection()
        {
            CurrentPackage = (ProjectImport)EditorGUILayout.ObjectField(CurrentPackage, typeof(ProjectImport), true,
                                                                        GUILayout.Width(180));
            if (CurrentPackage == null)
            {
                return;
            }

            var explorer = CurrentPackage.Explorer;

            foreach (var resource in explorer.Resources)
            {
                if (!resource.Name.EndsWith(".bhvr"))
                {
                    continue;
                }

                if (GUILayout.Button(resource.ToString()))
                {
                    CurrentResource = resource;
                    JObject editorTarget;
                    using (var editorTargetData = CurrentResource.LoadStream())
                        using (var sr = new StreamReader(editorTargetData))
                            using (var reader = new JsonTextReader(sr))
                            {
                                editorTarget = JObject.Load(reader);
                            }

                    var nodes = NodeManifest.Construct(new Type[] {
                        typeof(AddNode),
                        typeof(RollNode),
                        typeof(OutputValueNode),
                        typeof(ItemInputNode),
                        typeof(ActivatableItemNode),
                        typeof(IterateNode),
                        typeof(GetStatNode),
                    });
                    var types = TypeManifest.Construct(
                        new Type[]
                    {
                        typeof(bool),
                        typeof(string),
                        typeof(int),
                        typeof(byte),
                        typeof(long),
                        typeof(short),
                        typeof(uint),
                        typeof(ulong),
                        typeof(ushort),
                        typeof(sbyte),
                        typeof(char),
                        typeof(float),
                        typeof(double),
                        typeof(decimal),
                        typeof(InputSocket),
                        typeof(LocalId),
                    },
                        new Type[]
                    {
                        typeof(SerializedGraph),
                        typeof(SerializedNode),
                        typeof(PackageNodeEditor),
                        typeof(PackageNodePosition),
                        typeof(ExtraData)
                    }
                        );

                    var manifest = new BehaviourManifest()
                    {
                        Nodes = nodes,
                        Types = types,
                    };
                    Debug.Log(editorTarget);
                    var graphEditor = new EditorSession(manifest, editorTarget, "SerializedGraph", Serializer);

                    View.BeginSession(graphEditor, graphEditor.Root);
                }
            }
        }
Пример #10
0
        public void OnGUI()
        {
            screenRect = new Rect(0, EditorGUIUtility.singleLineHeight + 1,
                                  position.width, position.height - (EditorGUIUtility.singleLineHeight + 1));

            currentEvent = Event.current;

            // HandleDragAndDrop (screenRect);


            DrawBackground(screenRect, dragging_Position);
            DrawTopBar();


            CurrentPackage = (ProjectImport)EditorGUILayout.ObjectField(CurrentPackage, typeof(ProjectImport), true);

            var explorer = CurrentPackage.Explorer;

            foreach (var resource in explorer.Resources)
            {
                if (!resource.Name.EndsWith(".bhvr"))
                {
                    continue;
                }

                if (GUILayout.Button(resource.ToString()))
                {
                    CurrentResource    = resource;
                    HasCurrentResource = true;
                    HasEditor          = false;
                }
            }

            if (HasCurrentResource && CurrentResource != null)
            {
                if (HasEditor == false)
                {
                    Debug.Log(CurrentResource);

                    var editorTargetData = CurrentResource.LoadStream();

                    using (var sr = new StreamReader(editorTargetData))
                        using (var reader = new JsonTextReader(sr))
                        {
                            editorTarget = JObject.Load(reader);
                            // editorTarget = serializer.Deserialize(reader);
                        }

                    var nodes = NodeManifest.Construct(new Type[] { typeof(AddNode), typeof(RollNode) });
                    var types = TypeManifest.ConstructBaseTypes();

                    var manifest = new BehaviourManifest()
                    {
                        Nodes = nodes,
                        Types = types,
                    };
                    Debug.Log(editorTarget);
                    graphEditor = new EditorSession(manifest, editorTarget, "SerializedGraph");
                    HasEditor   = true;
                }

                if (GUILayout.Button("Save"))
                {
                    using (var file = CurrentResource.WriteStream())
                    {
                        serializer.Serialize(new JsonTextWriter(file)
                        {
                            Formatting = Formatting.Indented
                        }, editorTarget);
                    }
                }

                foreach (var node in graphEditor.Root["Nodes"])
                {
                    var nodeEditor         = node["Editor"];
                    var nodeEditorPosition = nodeEditor["Position"];

                    var nodeRect = new Rect(
                        dragging_Position.x + nodeEditorPosition["x"].GetValue <int>(),
                        dragging_Position.y + nodeEditorPosition["y"].GetValue <int>(),
                        200,
                        160
                        );

                    bool startDrag = false;
                    if (Event.current.type == EventType.Repaint)
                    {
                        BehaviourGraphResources.Instance.NodeStyle.Draw(nodeRect,
                                                                        false, node.Name == selectedNode, false, false);
                    }

                    GUILayout.BeginArea(nodeRect);

                    var nodeData = node.Json["Data"];
                    var nodeType = node["Type"];

                    object fieldObject;
                    if (!node.ViewBag.TryGetValue("Generic", out fieldObject))
                    {
                        var fieldInformation = new FieldInformation();
                        fieldInformation.Type = nodeType.Json.ToObject <string>();

                        fieldObject = new EditorField(graphEditor, nodeData, node.Name,
                                                      fieldInformation);

                        node.ViewBag["Generic"] = fieldObject;
                    }
                    var field = (EditorField)fieldObject;


                    foreach (var childField in field)
                    {
                        DrawField(childField);
                    }

                    GUILayout.EndArea();

                    if (Event.current.type == EventType.MouseDown)
                    {
                        if (nodeRect.Contains(Event.current.mousePosition))
                        {
                            selectedNode          = node.Name;
                            dragging_IsDragging   = true;
                            dragging_NodeDragging = true;

                            GUI.UnfocusWindow();
                            GUI.FocusControl("");

                            Event.current.Use();
                        }
                    }
                }

                foreach (var node in graphEditor.Root["Nodes"])
                {
                    var nodeEditor         = node["Editor"];
                    var nodeEditorPosition = nodeEditor["Position"];

                    var nodePositionX = nodeEditorPosition["x"].GetValue <int>() + dragging_Position.x;
                    var nodePositionY = nodeEditorPosition["y"].GetValue <int>() + dragging_Position.y;

                    var nodeData = node.Json["Data"];
                    var nodeType = node["Type"];

                    object fieldObject;
                    if (!node.ViewBag.TryGetValue("Generic", out fieldObject))
                    {
                        var fieldInformation = new FieldInformation();
                        fieldInformation.Type = nodeType.Json.ToObject <string>();

                        fieldObject = new EditorField(graphEditor, nodeData, node.Name,
                                                      fieldInformation);

                        node.ViewBag["Generic"] = fieldObject;
                    }
                    var field = (EditorField)fieldObject;


                    foreach (var childField in field)
                    {
                        if (childField.Field.Type == "InputSocket")
                        {
                            object renderPosObject;
                            var    renderPos = new Rect();;
                            if (childField.ViewBag.TryGetValue("Position", out renderPosObject))
                            {
                                renderPos = (Rect)renderPosObject;
                            }
                            else
                            {
                                Debug.LogError(childField.Name + " has no position");
                            }

                            renderPos.x += nodePositionX;
                            renderPos.y += nodePositionY;

                            // EditorGUI.DrawRect(renderPos, Color.red);

                            Vector3 start    = new Vector3(renderPos.x, renderPos.y);
                            Vector3 end      = new Vector3(renderPos.x - 100, renderPos.y - 100);
                            Vector3 startDir = new Vector3(-1, 0);
                            Vector3 endDir   = new Vector3(1, 0);

                            DrawConnection(start, end, startDir, endDir);
                        }
                    }
                }
            }

            HandleInput();
        }