public Dictionary<EntityToken, IEnumerable<EntityToken>> GetParents(IEnumerable<EntityToken> entityTokens)
        {
            Dictionary<EntityToken, IEnumerable<EntityToken>> result = new Dictionary<EntityToken, IEnumerable<EntityToken>>();

            foreach (EntityToken entityToken in entityTokens)
            {
                string functionName = entityToken.Id;

                int index = functionName.LastIndexOf('.');

                string folderName = functionName.Remove(index);
                string id = BaseFunctionProviderElementProvider.BaseFunctionProviderElementProvider.CreateId(folderName, _providerName);

                EntityToken resultEntityToken = new BaseFunctionFolderElementEntityToken(id);

                IEnumerable<EntityToken> resultEntityTokens;
                if (!result.TryGetValue(entityToken, out resultEntityTokens))
                {
                    resultEntityTokens = new List<EntityToken>();
                    result.Add(entityToken, resultEntityTokens);
                }

                (resultEntityTokens as List<EntityToken>).Add(resultEntityToken);
            }

            return result;
        }
        public IEnumerable <EntityToken> GetParents(EntityToken entityToken)
        {
            BaseFunctionFolderElementEntityToken token = (BaseFunctionFolderElementEntityToken)entityToken;

            int index = token.Id.LastIndexOf('.');

            if (index != -1)
            {
                return(new EntityToken[] { new BaseFunctionFolderElementEntityToken(token.Id.Remove(index)) });
            }
            else
            {
                return(new EntityToken[] { });
            }
        }
Example #3
0
        /// <exclude />
        public Dictionary <EntityToken, IEnumerable <EntityToken> > GetParents(IEnumerable <EntityToken> entityTokens)
        {
            Dictionary <EntityToken, IEnumerable <EntityToken> > result = new Dictionary <EntityToken, IEnumerable <EntityToken> >();

            foreach (EntityToken entityToken in entityTokens)
            {
                IFunctionTreeBuilderLeafInfo functionTreeBuilderLeafInfo = OnIsEntityOwner(entityToken);
                if (functionTreeBuilderLeafInfo == null)
                {
                    continue;
                }

                BaseFunctionFolderElementEntityToken parentEntityToken = new BaseFunctionFolderElementEntityToken(CreateId(functionTreeBuilderLeafInfo.Namespace, _context.ProviderName));

                result.Add(entityToken, new EntityToken[] { parentEntityToken });
            }

            return(result);
        }
Example #4
0
        /// <exclude />
        public IEnumerable <Element> GetChildren(EntityToken entityToken, SearchToken searchToken)
        {
            BaseFunctionFolderElementEntityToken castedEntityToken = (BaseFunctionFolderElementEntityToken)entityToken;

            string id = castedEntityToken.Id;

            int index = castedEntityToken.Id.IndexOf('.');

            if (index != -1)
            {
                id = id.Remove(0, index + 1);
            }

            NamespaceTreeBuilder builder = new NamespaceTreeBuilder(OnGetFunctionInfos(searchToken).Cast <INamespaceTreeBuilderLeafInfo>());

            NamespaceTreeBuilderFolder folderNode;

            if (castedEntityToken.Id == CreateId("", _context.ProviderName))
            {
                folderNode = builder.RootFolder;
            }
            else
            {
                folderNode = builder.GetFolder(id);
            }

            List <Element> result = new List <Element>();

            if (searchToken == null)
            {
                if (folderNode != null)
                {
                    foreach (NamespaceTreeBuilderFolder node in folderNode.SubFolders.OrderBy(f => f.Name))
                    {
                        Element element = CreateFolderElement(node);
                        result.Add(element);
                    }

                    foreach (IFunctionTreeBuilderLeafInfo function in folderNode.Leafs)
                    {
                        Element element = CreateFunctionElement(function);

                        element.PropertyBag.Add("ElementType", "application/x-composite-function");
                        element.PropertyBag.Add("ElementId", IMetaFunctionExtensionMethods.CompositeName(function.Namespace, function.Name));

                        result.Add(element);
                    }
                }
            }
            else
            {
                if (folderNode != null)
                {
                    foreach (NamespaceTreeBuilderFolder node in folderNode.SubFolders.OrderBy(f => f.Name))
                    {
                        if (SubTreeContainsToken(node, searchToken))
                        {
                            Element element = CreateFolderElement(node);
                            result.Add(element);
                        }
                    }

                    foreach (IFunctionTreeBuilderLeafInfo function in folderNode.Leafs)
                    {
                        if (searchToken.Keyword == null || function.Name.Contains(searchToken.Keyword))
                        {
                            Element element = CreateFunctionElement(function);

                            element.PropertyBag.Add("ElementType", "application/x-composite-function");
                            element.PropertyBag.Add("ElementId", IMetaFunctionExtensionMethods.CompositeName(function.Namespace, function.Name));

                            result.Add(element);
                        }
                    }
                }
            }

            return(result);
        }
        /// <exclude />
        public Dictionary<EntityToken, IEnumerable<EntityToken>> GetParents(IEnumerable<EntityToken> entityTokens)
        {
            Dictionary<EntityToken, IEnumerable<EntityToken>> result = new Dictionary<EntityToken, IEnumerable<EntityToken>>();

            foreach (EntityToken entityToken in entityTokens)
            {
                IFunctionTreeBuilderLeafInfo functionTreeBuilderLeafInfo = OnIsEntityOwner(entityToken);
                if (functionTreeBuilderLeafInfo == null) continue;

                BaseFunctionFolderElementEntityToken parentEntityToken = new BaseFunctionFolderElementEntityToken(CreateId(functionTreeBuilderLeafInfo.Namespace, _context.ProviderName));

                result.Add(entityToken, new EntityToken[] { parentEntityToken });
            }

            return result;
        }
        private void saveCodeActivity_ExecuteCode(object sender, EventArgs e)
        {
            try
            {
                IXsltFunction xslt = this.GetBinding<IXsltFunction>("CurrentXslt");
                IXsltFunction previousXslt = DataFacade.GetData<IXsltFunction>(f => f.Id == xslt.Id).SingleOrDefault();

                IFile persistemTemplateFile = IFileServices.TryGetFile<IXsltFile>(xslt.XslFilePath);
                if (persistemTemplateFile != null)
                {
                    string persistemTemplate = (persistemTemplateFile != null ? persistemTemplateFile.ReadAllText() : "");

                    if (this.GetBinding<int>("XslTemplateLastSaveHash") != persistemTemplate.GetHashCode())
                    {
                        this.Bindings["XslTemplate"] = persistemTemplate;
                        this.RerenderView();
                        ConsoleMessageQueueFacade.Enqueue(new LogEntryMessageQueueItem { Level = LogLevel.Fine, Message = "XSLT file on file system has been changed by another process. In-browser editor updated to reflect file on file system.", Sender = this.GetType() }, this.GetCurrentConsoleId());
                    }
                }

                string xslTemplate = this.GetBinding<string>("XslTemplate");

                var parameters = this.GetBinding<IEnumerable<ManagedParameterDefinition>>("Parameters");

                IEnumerable<NamedFunctionCall> FunctionCalls = this.GetBinding<IEnumerable<NamedFunctionCall>>("FunctionCalls");
                
                if (FunctionCalls.Select(f => f.Name).Distinct().Count() != FunctionCalls.Count())
                {                    
                    ShowMessage(DialogType.Error,
                        GetString("EditXsltFunctionWorkflow.SameLocalFunctionNameClashTitle"),
                        GetString("EditXsltFunctionWorkflow.SameLocalFunctionNameClashMessage"));
                    return;
                }


                using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
                {
                    // Renaming related file if necessary
                    string oldRelativePath = previousXslt.XslFilePath.Replace('\\', '/'); // This replace takes care of old paths having \ in them
                    string newRelativePath = xslt.CreateXslFilePath();

                    if (string.Compare(oldRelativePath, newRelativePath, true) != 0)
                    {
                        var xlsFile = IFileServices.GetFile<IXsltFile>(previousXslt.XslFilePath);
                        string systemPath = (xlsFile as FileSystemFileBase).SystemPath;
                        // Implement it in another way?
                        string xsltFilesRoot = systemPath.Substring(0, systemPath.Length - previousXslt.XslFilePath.Length);

                        string newSystemPath = (xsltFilesRoot + newRelativePath).Replace('\\', '/');

                        if ((string.Compare(systemPath, newSystemPath, true) != 0) && C1File.Exists(newSystemPath))
                        {
                            FlowControllerServicesContainer serviceContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
                            var consoleMessageService = serviceContainer.GetService<IManagementConsoleMessageService>();
                            consoleMessageService.ShowMessage(
                                DialogType.Error,
                                GetString("EditXsltFunctionWorkflow.InvalidName"),
                                GetString("EditXsltFunctionWorkflow.CannotRenameFileExists").FormatWith(newSystemPath));
                            return;
                        }

                        string directoryPath = Path.GetDirectoryName(newSystemPath);
                        if (!C1Directory.Exists(directoryPath))
                        {
                            C1Directory.CreateDirectory(directoryPath);
                        }

                        C1File.Move(systemPath, newSystemPath);

                        xslt.XslFilePath = newRelativePath;

                        // TODO: Implement removing empty Xslt directories
                    }


                    IFile file = IFileServices.GetFile<IXsltFile>(xslt.XslFilePath);
                    file.SetNewContent(xslTemplate);

                    ManagedParameterManager.Save(xslt.Id, parameters);

                    DataFacade.Update(xslt);
                    DataFacade.Update(file);

                    this.Bindings["XslTemplateLastSaveHash"] = xslTemplate.GetHashCode();


                    DataFacade.Delete<INamedFunctionCall>(f => f.XsltFunctionId == xslt.Id);
                    DataFacade.AddNew<INamedFunctionCall>(ConvertFunctionCalls(FunctionCalls, xslt.Id));

                    transactionScope.Complete();
                }

                if (previousXslt.Namespace != xslt.Namespace || previousXslt.Name != xslt.Name || previousXslt.Description != xslt.Description)
                {
                    // This is a some what nasty hack. Due to the nature of the BaseFunctionProviderElementProvider, this hack is needed
                    BaseFunctionFolderElementEntityToken entityToken = new BaseFunctionFolderElementEntityToken("ROOT:XsltBasedFunctionProviderElementProvider");
                    RefreshEntityToken(entityToken);
                }

                SetSaveStatus(true);

            }
            catch (Exception ex)
            {
                LoggingService.LogCritical("XSLT Save", ex);

                FlowControllerServicesContainer serviceContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
                var consoleMsgService = serviceContainer.GetService<IManagementConsoleMessageService>();
                consoleMsgService.ShowMessage(DialogType.Error, "Error", ex.Message);

                SetSaveStatus(false);
            }
        }