public JsonResult GetCustomFieldMeta(Guid Id)
        {
            var client = SvcBldr.CustomFieldV2();
            var result = client.GetCustomField(Id);

            return(Result(result.Result, result.Error, JsonRequestBehavior.AllowGet));
        }
        public JsonResult GetAllCustomFieldMetas()
        {
            var client = SvcBldr.CustomFieldV2();
            var result = client.GetCustomFieldsWithNew();

            return(Result(result.Result, result.Error, JsonRequestBehavior.AllowGet));
        }
Esempio n. 3
0
        public JsonResult GetAllData()
        {
            var clientV2 = SvcBldr.AdministrationV2();
            var freezes  = clientV2.GetAllFreezes();

            if (freezes != null && freezes.Error != null)
            {
                return(Result(null, freezes.Error, JsonRequestBehavior.AllowGet));
            }

            var fList = freezes.Result.ToList();

            fList.Insert(0, new Freeze()
            {
                Id = Guid.Empty, Name = Constants.i18n("newTitle"), Active = true
            });
            var srRecCats = clientV2.GetAllRecordCategories();

            if (srRecCats.Error != null)
            {
                return(Result(null, srRecCats.Error, JsonRequestBehavior.AllowGet));
            }

            var rcats = srRecCats.Result.ToList();

            rcats.Insert(0, new RecordCategory()
            {
                Id = Guid.Empty, Name = Constants.i18n("newTitle")
            });

            var scRC = SvcBldr.SecurityV2().GetSecurityClassSlims();

            if (scRC.Error != null)
            {
                return(Result(null, scRC.Error, JsonRequestBehavior.AllowGet));
            }

            var customFields = SvcBldr.CustomFieldV2().GetCustomFields();

            if (customFields.Error != null)
            {
                return(Result(null, customFields.Error, JsonRequestBehavior.AllowGet));
            }

            var dateFields = customFields.Result.Where(c => c.Type == CFTypeCode.DateTime)
                             .Select(f => new SlimEntity(f.Id, f.Name, PermissionType.NotSet)).ToList();

            dateFields.Insert(0, new SlimEntity(DateFieldConstants.Created, Constants.i18n("createdOn"), PermissionType.NotSet));
            dateFields.Insert(1, new SlimEntity(DateFieldConstants.Modified, Constants.i18n("modifiedOn"), PermissionType.NotSet));
            dateFields.Insert(2, new SlimEntity(DateFieldConstants.Accessed, Constants.i18n("accessedOn"), PermissionType.NotSet));

            return(Result(new { f = fList.Where(f => f.Active), rcs = rcats, sc = scRC.Result, cf = dateFields }, null, JsonRequestBehavior.AllowGet));
        }
        public JsonResult GetAllData()
        {
            var cfClient = SvcBldr.CustomFieldV2();
            var adClient = SvcBldr.AdministrationV2();
            var client   = SvcBldr.SearchV2();

            var result = cfClient.GetCustomFields();

            if (result.Error != null)
            {
                return(Result(null, result.Error, JsonRequestBehavior.AllowGet));
            }
            var lists = adClient.GetCustomListsSlim();

            if (lists.Error != null)
            {
                return(Result(null, lists.Error, JsonRequestBehavior.AllowGet));
            }
            var sr = client.GetFieldNames();

            if (sr.Error != null)
            {
                return(Result(null, sr.Error, JsonRequestBehavior.AllowGet));
            }
            var srGroups = cfClient.GetGroups();

            if (srGroups.Error != null)
            {
                return(Result(null, srGroups.Error, JsonRequestBehavior.AllowGet));
            }
            var fieldsnames = sr.Result.Where(r => result.Result == null || result.Result.ToList().All(l => l.Name != r)).ToList();

            fieldsnames.AddRange(new List <string>
            {
                "id",
                Constants.CN_ENTITY_ID,
                Constants.DOCTYPE,
                Constants.DOCID,
                Constants.WFDOCID,
                Constants.APPID,
                Constants.SF_TYPE
            });
            return(Result(new { cfs = result.Result, cls = lists.Result, cfg = srGroups.Result, spnms = fieldsnames }, null, JsonRequestBehavior.AllowGet));
        }
        /// <summary>
        /// Retrieves all data required by the designer
        /// </summary>
        public JsonResult GetData()
        {
            var wfSvc      = SvcBldr.WorkflowV2();
            var secSvc     = SvcBldr.SecurityV2();
            var ibxSvc     = SvcBldr.InboxV2();
            var companySvc = SvcBldr.Company();
            var adminSvc   = SvcBldr.AdministrationV2();
            var userSvc    = SvcBldr.UserV2();
            var dlSvc      = SvcBldr.DataLinkV2();
            var ctSvc      = SvcBldr.ContentTypeV2();
            var cfSvc      = SvcBldr.CustomFieldV2();
            var licSvc     = SvcBldr.LicenseV2();
            var docSVC     = SvcBldr.DocumentV2();
            var searchSvc  = SvcBldr.SearchV2();
            var tokens     = licSvc.GetLicenseTokens();

            if (tokens.Error != null)
            {
                return(Result(null, tokens.Error));
            }

            var dbFieldsSR = searchSvc.GetFields();

            if (dbFieldsSR.Error != null)
            {
                return(Result(null, dbFieldsSR.Error));
            }
            var dbFields   = dbFieldsSR.Result;
            var advancedWF = false;

            if (tokens.Result != null)
            {
                advancedWF = tokens.Result.HasTokenKey(TokenKey.AdvancedWorkflow);
            }
            var customLists = adminSvc.GetCustomListsSlim();

            if (customLists.Error != null)
            {
                return(Result(null, customLists.Error));
            }

            var userPrefsSR = userSvc.GetPreferences();

            if (userPrefsSR.Error != null)
            {
                return(Result(null, userPrefsSR.Error));
            }

            var userPrefsKVP = new Dictionary <String, String>();
            var upLen        = userPrefsSR.Result.Length;

            for (int i = 0; i < upLen; i++)
            {
                if (userPrefsKVP.ContainsKey(userPrefsSR.Result[i].Key))
                {
                    continue;
                }
                userPrefsKVP.Add(userPrefsSR.Result[i].Key, userPrefsSR.Result[i].Value);
            }

            var allTasks    = TaskDesignProperties.GetAll();
            var uiTasks     = allTasks.Where(r => r.NeedsUserInput);
            var clientTasks = allTasks.Where(r => r.NeedsClientService);
            var autoTasks   = allTasks.Where(r => !r.NeedsClientService && !r.NeedsUserInput).ToList();


            var actionLibrary = wfSvc.GetActionLibrarySlim();

            if (actionLibrary.Error != null)
            {
                return(Result(null, actionLibrary.Error));
            }

            actionLibrary.Result.Append(new SlimActionLibraryItem()
            {
                Id = Guid.Empty,
                EffectivePermissions = (int)PermissionType.Full,
                Name = Constants.i18n("newTitle"),
                Type = (int)WFActionType.LibraryItem
            });

            var wfNames = wfSvc.GetSlim();

            if (wfNames.Error != null)
            {
                return(Result(null, wfNames.Error));
            }
            var wfNamesWithNew = wfNames.Result.Prepend(new SlimEntity(Guid.Empty, Constants.i18n("newTitle"), PermissionType.Full));

            var inboxes = ibxSvc.GetSlim();

            if (inboxes.Error != null)
            {
                return(Result(null, inboxes.Error));
            }

            var inboxNVP     = inboxes.Result.ToDictionary(k => k.Id.ToString(), v => v.Name);
            var contentTypes = ctSvc.GetContentTypesSlim();

            if (contentTypes.Error != null)
            {
                return(Result(null, contentTypes.Error));
            }

            var ctNVP = contentTypes.Result.ToDictionary(k => k.Id.ToString(), v => v.Name);


            var securityClasses = secSvc.GetAllSecurityClassesSlim();

            if (securityClasses.Error != null)
            {
                return(Result(null, securityClasses.Error));
            }

            var scNVP = securityClasses.Result.ToDictionary(k => k.Id.ToString(), v => v.Name);

            var users = userSvc.GetAll();

            if (users.Error != null)
            {
                return(Result(null, users.Error));
            }
            var slimUsers = users.Result.Select(r => new { Id = r.Id, Username = r.Username, Flags = r.Flags, SiteUser = r.SiteUser }).ToList();

            var roles = secSvc.GetAllRolesSlim();

            if (roles.Error != null)
            {
                return(Result(null, roles.Error));
            }

            var rolesNVP     = roles.Result.ToDictionary(k => k.Id.ToString(), v => v.Name);
            var customFields = cfSvc.GetCustomFields();

            if (customFields.Error != null)
            {
                return(Result(null, customFields.Error));
            }

            var customFieldsNVP = customFields.Result.ToDictionary(k => k.Id.ToString(), v => v.Name);

            var cfGroupsSR = cfSvc.GetGroups();

            if (cfGroupsSR.Error != null)
            {
                return(Result(null, cfGroupsSR.Error));
            }

            var docProps = WFDocMeta.GetProperties();
            var args     = new Dictionary <string, WFMetaPropertyInfo>
            {
                {
                    Constants.i18n("argSysCurrUser"),
                    new WFMetaPropertyInfo()
                    {
                        Name                = Argument.SystemProperty(SystemArguments.CurrentUser),
                        ReadOnly            = true,
                        PropertyType        = CFTypeCode.Object,
                        SupportedActionType = WFActionType.SyncVerifyAction | WFActionType.AutoRun
                    }
                },
                {
                    Constants.i18n("argSysNow"),
                    new WFMetaPropertyInfo()
                    {
                        Name                = Argument.SystemProperty(SystemArguments.Now),
                        ReadOnly            = true,
                        PropertyType        = CFTypeCode.DateTime,
                        SupportedActionType = WFActionType.SyncVerifyAction | WFActionType.AutoRun
                    }
                },
                {
                    Constants.i18n("argSysToday"),
                    new WFMetaPropertyInfo()
                    {
                        Name                = Argument.SystemProperty(SystemArguments.Today),
                        ReadOnly            = true,
                        PropertyType        = CFTypeCode.DateTime,
                        SupportedActionType = WFActionType.SyncVerifyAction | WFActionType.AutoRun
                    }
                },
                {
                    Constants.i18n("argSysTomorrow"),
                    new WFMetaPropertyInfo()
                    {
                        Name                = Argument.SystemProperty(SystemArguments.Tomorrow),
                        ReadOnly            = true,
                        PropertyType        = CFTypeCode.DateTime,
                        SupportedActionType = WFActionType.SyncVerifyAction | WFActionType.AutoRun
                    }
                },
                {
                    Constants.i18n("argDocFolder"),
                    new WFMetaPropertyInfo()
                    {
                        Name                = Argument.DocProperty(Argument.FOLDERS),
                        ReadOnly            = true,
                        PropertyType        = CFTypeCode.Object,
                        SupportedActionType = WFActionType.SyncAutoRunAction
                    }
                },
                {
                    Constants.i18n("argDocText"),
                    new WFMetaPropertyInfo()
                    {
                        Name                = Argument.DocProperty(Argument.TEXT),
                        ReadOnly            = false,
                        PropertyType        = CFTypeCode.String,
                        Indexable           = true,
                        SupportedActionType = WFActionType.SyncVerifyAction | WFActionType.AutoRun
                    }
                }
            };

            foreach (var docProp in docProps)
            {
                args.Add(Constants.i18n("argDoc" + docProp.Name), new WFMetaPropertyInfo()
                {
                    Name = Argument.DocProperty(docProp.Name), ReadOnly = docProp.ReadOnly, PropertyType = docProp.PropertyType, SupportedActionType = docProp.SupportedActionType
                });
            }
            foreach (var cf in customFields.Result)
            {
                args.Add(String.Format(Constants.i18n("argDocCustomField"), cf.Name), new WFMetaPropertyInfo()
                {
                    Name = Argument.DocCustomField(cf.Name), ReadOnly = false, PropertyType = cf.Type, SupportedActionType = WFActionType.SyncVerifyAction | WFActionType.AutoRun
                });
            }
            var orderedArgs = args.OrderBy(r => r.Key).ToDictionary(k => k.Key, v => v.Value);
            var datalinks   = new SR <DataLinkQueryPackage[]>();

            if (!(tokens.Result != null && tokens.Result.HasTokenKey(TokenKey.DataLink)))
            {
                autoTasks.Remove(autoTasks.First(r => r.TaskClassName == "DatalinkTask"));
            }
            else
            {
                datalinks = dlSvc.GetDataLinkQueries();
                if (datalinks.Error != null)
                {
                    return(Result(null, datalinks.Error));
                }
            }
            var recognitionOptions = docSVC.GetRecognitionOptions();

            if (recognitionOptions.Error != null)
            {
                return(Result(null, recognitionOptions.Error));
            }

            var xml    = this.GetHelpXML("en"); // TRANSLATE THIS FRIGGIN KEY ;)
            var retObj = new
            {
                HelpXMLString      = xml,
                BuiltInArgs        = orderedArgs,
                ActionLibrary      = actionLibrary.Result,
                UITasks            = uiTasks,
                ClientTasks        = clientTasks,
                AutoTasks          = autoTasks,
                Workflows          = wfNamesWithNew,
                Inboxes            = inboxNVP,
                ContentTypes       = ctNVP,
                CustomFields       = customFieldsNVP,
                SecurityClasses    = scNVP,
                Users              = slimUsers,
                Roles              = rolesNVP,
                AdvancedWF         = advancedWF,
                CustomLists        = customLists.Result,
                Datalinks          = datalinks.Result,
                UserPreferences    = userPrefsKVP,
                CustomFieldGroups  = cfGroupsSR.Result,
                RecognitionOptions = recognitionOptions.Result,
                DatabaseFields     = dbFields
            };

            return(Result(retObj, null));
        }