C# Models.ContentTypeDefinition类代码示例

        private string GetLayout(ContentTypeDefinition contentTypeDefinition, ICollection<Section> data) {
            //check field valid
            if (contentTypeDefinition.Parts.Any()) {
                var part = contentTypeDefinition.Parts.First(x => x.PartDefinition.Name == contentTypeDefinition.Name);
                var partFields = part.PartDefinition.Fields.ToList();
                var fields = data.SelectMany(x => x.Rows)
                    .SelectMany(x => x.Columns)
                    .Where(x => x.Field != null)
                    .Select(x => x.Field).ToList();
                if (partFields.Any(f => f.Settings.ContainsKey(AlwaysInLayoutKey)
                                        && bool.Parse(f.Settings[AlwaysInLayoutKey])
                                        && !fields.Select(x => x.FieldName).Contains(f.Name))) {
                    return string.Empty;
                }
                foreach (var field in fields) {
                    if (partFields.Any(x => x.Name == field.FieldName)) {
                        field.IsValid = true;
                    }
                    else if (contentTypeDefinition.Parts.Any(x => x.PartDefinition.Name == field.FieldName)) {
                        field.IsValid = true;
                    }
                }
            }

            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData.Add("Layout", data);
            string layout = _templateViewService
                .RenderView("Coevery.FormDesigner", "FormTemplate", "FormDesignerLayout", viewData);
            return layout;
        }

 public EditTypeViewModel(ContentTypeDefinition contentTypeDefinition)
 {
     Name = contentTypeDefinition.Name;
     DisplayName = contentTypeDefinition.DisplayName;
     Settings = contentTypeDefinition.Settings;
     TypeDefinition = contentTypeDefinition;
 }

        private IEnumerable<EditPartFieldViewModel> GetTypeFields(ContentTypeDefinition contentTypeDefinition) {
            var implicitTypePart = contentTypeDefinition.Parts.SingleOrDefault(p => string.Equals(p.PartDefinition.Name, Name, StringComparison.OrdinalIgnoreCase));

            return implicitTypePart == null
                ? Enumerable.Empty<EditPartFieldViewModel>()
                : implicitTypePart.PartDefinition.Fields.Select((f, i) => new EditPartFieldViewModel(i, f) { Part = new EditPartViewModel(implicitTypePart.PartDefinition) });
        }

        public int Create()
        {
            try {

                SchemaBuilder.CreateTable("ProxyPartRecord", table => table
                    .ContentPartRecord()
                    .Column("ServiceUrl", DbType.String)
                );

                var proxy = new ContentTypeDefinition("Proxy", "Proxy");
                ContentDefinitionManager.StoreTypeDefinition(proxy);
                ContentDefinitionManager.AlterTypeDefinition("Proxy", cfg => cfg.Creatable()
                    .WithPart("ProxyPart")
                    .WithPart("CommonPart")
                    .WithPart("TitlePart")
                    .WithPart("IdentityPart")
                    .WithPart("ContentPermissionsPart", builder => builder
                        .WithSetting("ContentPermissionsPartSettings.View", "Administrator")
                        .WithSetting("ContentPermissionsPartSettings.Publish", "Administrator")
                        .WithSetting("ContentPermissionsPartSettings.Edit", "Administrator")
                        .WithSetting("ContentPermissionsPartSettings.Delete", "Administrator")
                        .WithSetting("ContentPermissionsPartSettings.DisplayedRoles", "Administrator,Authenticated")
                    )
                );

            } catch (Exception e) {
                var message = string.Format("Error creating Proxy module. {0}", e.Message);
                Logger.Warning(message);
                Notifier.Warning(T(message));
                return 0;
            }
            return 1;
        }

        public override IEnumerable<TemplateViewModel> TypeEditor(ContentTypeDefinition definition) {
            var settings = definition.Settings.GetModel<ContentPermissionsTypeSettings>();
            var model = new SecurableContentItemsSettingsViewModel {
                SecurableContentItems = settings.SecurableContentItems,
            };

            yield return DefinitionTemplate(model);
        }

 public EditTypeViewModel(ContentTypeDefinition contentTypeDefinition) {
     Name = contentTypeDefinition.Name;
     DisplayName = contentTypeDefinition.DisplayName;
     Settings = contentTypeDefinition.Settings;
     Fields = GetTypeFields(contentTypeDefinition).ToList();
     Parts = GetTypeParts(contentTypeDefinition).ToList();
     _Definition = contentTypeDefinition;
 }

 /// <summary>
 /// Generates a permission dynamically for a content type
 /// </summary>
 public static Permission CreateDynamicPermission(Permission template, ContentTypeDefinition typeDefinition) {
     return new Permission {
         Name = String.Format(template.Name, typeDefinition.Name),
         Description = String.Format(template.Description, typeDefinition.DisplayName),
         Category = typeDefinition.DisplayName,
         ImpliedBy = (template.ImpliedBy ?? new Permission[0]).Select(t => CreateDynamicPermission(t, typeDefinition))
     };
 }

 public override IDisplayResult Edit(ContentTypeDefinition contentTypeDefinition)
 {
     return Shape<ContentTypeViewModel>("ContentType_Edit", model =>
     {
         model.DisplayName = contentTypeDefinition.DisplayName;
         return Task.CompletedTask;
     }).Location("Content");
 }

 /// <summary>
 /// Generates a permission dynamically for a content type
 /// </summary>
 public static Permission CreateSubmitPermission(ContentTypeDefinition typeDefinition) {
     return new Permission {
         Name = String.Format(SubmitForm.Name, typeDefinition.Name),
         Description = String.Format(SubmitForm.Description, typeDefinition.DisplayName),
         Category = "Custom Forms",
         ImpliedBy = new [] { SubmitForm }
     };
 }

 public Task BuildTypeEditorAsync(ContentTypeDefinition model, BuildEditorContext context)
 {
     return _typeDisplayDrivers.InvokeAsync(async contentDisplay =>
     {
         var result = await contentDisplay.BuildEditorAsync(model, context);
         if (result != null)
             result.Apply(context);
     }, Logger);
 }

        public override IEnumerable<TemplateViewModel> TypeEditor(ContentTypeDefinition definition)
        {
            var settings = definition.Settings.GetModel<DynamicTypeSettings>();
            var model = new DynamicTypeSettingsViewModel
            {
                IsDeployed = settings.IsDeployed
            };

            yield return DefinitionTemplate(model);
        }

        public XElement Export(ContentTypeDefinition typeDefinition) {
            var typeElement = NewElement(typeDefinition.Name, typeDefinition.Settings);
            if (typeElement.Attribute("DisplayName") == null && typeDefinition.DisplayName != null) {
                typeElement.Add(new XAttribute("DisplayName", typeDefinition.DisplayName));
            }

            foreach(var typePart in typeDefinition.Parts) {
                typeElement.Add(NewElement(typePart.PartDefinition.Name, typePart.Settings));
            }
            return typeElement;
        }

 public ContentTypeDefinitionBuilder(ContentTypeDefinition existing) {
     if (existing == null) {
         _parts = new List<ContentTypePartDefinition>();
         _settings = new SettingsDictionary();
     }
     else {
         _name = existing.Name;
         _displayName = existing.DisplayName;
         _parts = existing.Parts.ToList();
         _settings = new SettingsDictionary(existing.Settings.ToDictionary(kv => kv.Key, kv => kv.Value));
     }
 }

        public void GivenIHaveAContainableContentType(string name) {
            var webApp = Binding<WebAppHosting>();
            webApp.Host.Execute(() => {
                using (var environment = MvcApplication.CreateStandaloneEnvironment("Default")) {
                    var cdm = environment.Resolve<IContentDefinitionManager>();

                    var contentTypeDefinition = new ContentTypeDefinition(name, name);
                    cdm.StoreTypeDefinition(contentTypeDefinition);
                    cdm.AlterTypeDefinition(name, cfg => cfg.WithPart("CommonPart").WithPart("BodyPart").WithPart("RoutePart").WithPart("ContainablePart").Creatable().Draftable());
                }
            });
        }

        public ContentTypeDefinitionModel(ContentTypeDefinition contentTypeDefinition) {
            Parts = new List<ContentPartDefinitionModel>();
            Settings = new Dictionary<string, string>(contentTypeDefinition.Settings);

            foreach (var partDefinitionModel in contentTypeDefinition.Parts.Select(partDefinition => new ContentPartDefinitionModel(partDefinition)))
            {
                Parts.Add(partDefinitionModel);
            }

            Name = contentTypeDefinition.Name;
            DisplayName = contentTypeDefinition.DisplayName;
        }