protected virtual List <BoxMetadataTemplate> ReadMetadataTemplateCsvFile(string filePathTemplate, string filePathFields)
        {
            var templates = new List <BoxMetadataTemplate>();
            var fields    = new List <BoxMetadataTemplateFieldForCsv>();

            using (var fs = File.OpenText(filePathTemplate))
                using (var csv = new CsvReader(fs))
                {
                    csv.Configuration.RegisterClassMap(typeof(BoxMetadataTemplateMap));
                    templates = csv.GetRecords <BoxMetadataTemplate>().ToList();
                }
            using (var fs = File.OpenText(filePathFields))
                using (var csv = new CsvReader(fs))
                {
                    csv.Configuration.RegisterClassMap(typeof(BoxMetadataTemplateFieldMap));
                    fields = csv.GetRecords <BoxMetadataTemplateFieldForCsv>().ToList();
                }
            var templateCollection = new List <BoxMetadataTemplate>();

            foreach (var template in templates)
            {
                var matches = fields.FindAll(f => f.TemplateKey == template.TemplateKey);
                if (matches.Count > 0)
                {
                    template.Fields = new List <BoxMetadataTemplateField>();
                    foreach (var match in matches)
                    {
                        var field = new BoxMetadataTemplateField();
                        field.DisplayName = match.DisplayName;
                        field.Hidden      = match.Hidden;
                        field.Key         = match.Key;
                        field.Type        = match.Type;
                        if (match.OptionsFromCsv != null && match.OptionsFromCsv.Count > 0)
                        {
                            field.Options = new List <BoxMetadataTemplateFieldOption>();
                            foreach (var option in match.OptionsFromCsv)
                            {
                                field.Options.Add(new BoxMetadataTemplateFieldOption()
                                {
                                    Key = option
                                });
                            }
                        }
                        template.Fields.Add(field);
                    }
                }
                templateCollection.Add(template);
            }
            return(templateCollection);
        }
Example #2
0
        private async Task <BoxMetadataTemplate> createTestTemplate(string templateKey)
        {
            var field1 = new BoxMetadataTemplateField()
            {
                Key = "attr1", DisplayName = "a string", Type = "string", Hidden = true
            };
            var field2 = new BoxMetadataTemplateField()
            {
                Key = "attr2", DisplayName = "a float", Type = "float"
            };
            var field3 = new BoxMetadataTemplateField()
            {
                Key = "attr3", DisplayName = "a date", Type = "date"
            };
            var options = new List <BoxMetadataTemplateFieldOption>()
            {
                new BoxMetadataTemplateFieldOption()
                {
                    Key = "value1"
                }, new BoxMetadataTemplateFieldOption()
                {
                    Key = "value2"
                }
            };
            var field4 = new BoxMetadataTemplateField()
            {
                Key = "attr4", DisplayName = "a enum", Type = "enum", Options = options
            };
            var fields = new List <BoxMetadataTemplateField>()
            {
                field1, field2, field3, field4
            };
            var templateToCreate = new BoxMetadataTemplate()
            {
                TemplateKey = templateKey, DisplayName = templateKey, Fields = fields, Hidden = true, Scope = SCOPE
            };
            var createdTemplate = await _client.MetadataManager.CreateMetadataTemplate(templateToCreate);

            return(createdTemplate);
        }
Example #3
0
        // [TestCategory("CI-APP-USER")]
        public async Task Metadata_UpdateTemplate_LiveSession()
        {
            /*
             * if (!IsUnderCI())
             * {
             *  return;
             * }
             */

            // var templateKey = "template-" + Guid.NewGuid().ToString().Replace("-", "").Substring(0, 8);
            // var createdTemplate = await createTestTemplate(templateKey);

            var templateKey = "template-fbc81a44";

            //addField operation
            var newField = new BoxMetadataTemplateField()
            {
                Key = "attr5", DisplayName = "a string", Type = "string"
            };
            var update = new BoxMetadataTemplateUpdate()
            {
                Op = MetadataTemplateUpdateOp.addField, Data = newField
            };
            var updates = new List <BoxMetadataTemplateUpdate>()
            {
                update
            };
            var updatedTemplate = await _client.MetadataManager.UpdateMetadataTemplate(updates, "enterprise", templateKey);

            Assert.IsTrue(updatedTemplate.Fields.Any(f => f.Key == "attr5"), "addField operation failed on metadata update");

            //editField operation
            var fieldUpdate = new BoxMetadataTemplateField()
            {
                DisplayName = "a string edited"
            };

            update = new BoxMetadataTemplateUpdate()
            {
                Op = MetadataTemplateUpdateOp.editField, FieldKey = "attr1", Data = fieldUpdate
            };
            updates = new List <BoxMetadataTemplateUpdate>()
            {
                update
            };
            updatedTemplate = await _client.MetadataManager.UpdateMetadataTemplate(updates, "enterprise", templateKey);

            Assert.IsTrue(updatedTemplate.Fields.Single(f => f.Key == "attr1").DisplayName == "a string edited", "editField operation failed on metadata update");

            //editTemplate operation
            var templateUpdate = new BoxMetadataTemplate()
            {
                DisplayName = "new display name"
            };

            update = new BoxMetadataTemplateUpdate()
            {
                Op = MetadataTemplateUpdateOp.editTemplate, Data = templateUpdate
            };
            updates = new List <BoxMetadataTemplateUpdate>()
            {
                update
            };
            updatedTemplate = await _client.MetadataManager.UpdateMetadataTemplate(updates, "enterprise", templateKey);

            Assert.IsTrue(updatedTemplate.DisplayName == "new display name", "editTemplate operation failed on metadata update");

            //addEnumOption operation
            var newValue = new BoxMetadataTemplateFieldOption()
            {
                Key = "value3"
            };

            update = new BoxMetadataTemplateUpdate()
            {
                Op = MetadataTemplateUpdateOp.addEnumOption, FieldKey = "attr4", Data = newValue
            };
            updates = new List <BoxMetadataTemplateUpdate>()
            {
                update
            };
            updatedTemplate = await _client.MetadataManager.UpdateMetadataTemplate(updates, "enterprise", templateKey);

            Assert.IsTrue(updatedTemplate.Fields.Single(f => f.Key == "attr4").Options.Count == 3, "addEnumOption operation failed on metadata update");

            //reorderEnumOptions operation
            var newValueOrder = new List <string>()
            {
                "value2", "value1", "value3"
            };

            update = new BoxMetadataTemplateUpdate()
            {
                Op = MetadataTemplateUpdateOp.reorderEnumOptions, FieldKey = "attr4", EnumOptionKeys = newValueOrder
            };
            updates = new List <BoxMetadataTemplateUpdate>()
            {
                update
            };
            updatedTemplate = await _client.MetadataManager.UpdateMetadataTemplate(updates, "enterprise", templateKey);

            Assert.IsTrue(updatedTemplate.Fields.Single(f => f.Key == "attr4").Options[0].Key == "value2", "reorderEnumOptions operation failed on metadata update");

            //editEnumOption operation
            newValue = new BoxMetadataTemplateFieldOption()
            {
                Key = "value31"
            };
            update = new BoxMetadataTemplateUpdate()
            {
                Op = MetadataTemplateUpdateOp.editEnumOption, FieldKey = "attr4", EnumOptionKey = "value3", Data = newValue
            };
            updates = new List <BoxMetadataTemplateUpdate>()
            {
                update
            };
            updatedTemplate = await _client.MetadataManager.UpdateMetadataTemplate(updates, "enterprise", templateKey);

            Assert.IsTrue(updatedTemplate.Fields.Single(f => f.Key == "attr4").Options.Count == 3, "editEnumOption operation failed on metadata update");

            //removeEnumOption operation
            update = new BoxMetadataTemplateUpdate()
            {
                Op = MetadataTemplateUpdateOp.removeEnumOption, FieldKey = "attr4", EnumOptionKey = "value31"
            };
            updates = new List <BoxMetadataTemplateUpdate>()
            {
                update
            };
            updatedTemplate = await _client.MetadataManager.UpdateMetadataTemplate(updates, "enterprise", templateKey);

            Assert.IsTrue(updatedTemplate.Fields.Single(f => f.Key == "attr4").Options.Count == 2, "removeEnumOption operation failed on metadata update");

            //reorderFields operation
            var newFieldOrder = new List <string>()
            {
                "attr5", "attr4", "attr3", "attr2", "attr1"
            };

            update = new BoxMetadataTemplateUpdate()
            {
                Op = MetadataTemplateUpdateOp.reorderFields, FieldKeys = newFieldOrder
            };
            updates = new List <BoxMetadataTemplateUpdate>()
            {
                update
            };
            updatedTemplate = await _client.MetadataManager.UpdateMetadataTemplate(updates, "enterprise", templateKey);

            Assert.IsTrue(updatedTemplate.Fields[0].Key == "attr5", "reorderFields operation failed on metadata update");

            //removeField operation
            update = new BoxMetadataTemplateUpdate()
            {
                Op = MetadataTemplateUpdateOp.removeField, FieldKey = "attr5"
            };
            updates = new List <BoxMetadataTemplateUpdate>()
            {
                update
            };
            updatedTemplate = await _client.MetadataManager.UpdateMetadataTemplate(updates, "enterprise", templateKey);

            Assert.IsFalse(updatedTemplate.Fields.Any(f => f.Key == "attr5"), "removeField operation failed on metadata update");
        }
        protected virtual List <BoxMetadataTemplateField> BuildTemplateFromConsole()
        {
            var yN      = "n";
            var display = "";
            var type    = "";
            var mdt     = new List <BoxMetadataTemplateField>();

            do
            {
                var mdtField = new BoxMetadataTemplateField();
                if (mdt.Count > 0)
                {
                    Reporter.WriteInformation("Current metadata template fields:");
                    foreach (var m in mdt)
                    {
                        Reporter.WriteInformation($"{m.DisplayName}");
                    }
                }
                Reporter.WriteInformation("Enter the metadata template field display name:");
                display = Console.ReadLine();
                mdtField.DisplayName = display;
                var yNKey = "y";
                Reporter.WriteInformation($"Use {display} as metadata template field key? (Y/n)");
                yNKey = Console.ReadLine().ToLower();
                if (string.IsNullOrEmpty(yNKey) || yNKey == "y")
                {
                    mdtField.Key = display;
                }
                else
                {
                    Reporter.WriteInformation("Enter the key for this metadata template field:");
                    mdtField.Key = Console.ReadLine();
                }

                Reporter.WriteInformation("Enter a number to select a metadata template field type:");
                Reporter.WriteInformation("1. string");
                Reporter.WriteInformation("2. enum");
                Reporter.WriteInformation("3. float");
                Reporter.WriteInformation("4. date");
                type = Console.ReadLine();
                switch (type)
                {
                case "1":
                    type = "string";
                    break;

                case "2":
                    type = "enum";
                    break;

                case "3":
                    type = "float";
                    break;

                case "4":
                    type = "date";
                    break;

                default:
                    type = "";
                    break;
                }
                if (string.IsNullOrEmpty(type))
                {
                    Reporter.WriteWarning("Not a valid selection");
                    continue;
                }
                mdtField.Type = type;
                if (type == "enum")
                {
                    var yNOpts = "n";
                    var opts   = new List <BoxMetadataTemplateFieldOption>();
                    do
                    {
                        var opt = new BoxMetadataTemplateFieldOption();
                        Reporter.WriteInformation("Enter an enum option key: ");
                        opt.Key = Console.ReadLine();
                        opts.Add(opt);
                        Reporter.WriteInformation("Enter another option? (y/N)");
                        yNOpts = Console.ReadLine().ToLower();
                        if (string.IsNullOrEmpty(yNOpts))
                        {
                            break;
                        }
                    }while (yNOpts == "y");
                    mdtField.Options = opts;
                }
                mdt.Add(mdtField);
                Reporter.WriteInformation("Enter another metadata template field? (y/N)");
                yN = Console.ReadLine().ToLower();
                if (string.IsNullOrEmpty(yN))
                {
                    break;
                }
            }while (yN != "n");
            Reporter.WriteSuccess("Finished building metadata template fields.");
            return(mdt);
        }