public Task <dynamic> UpdateTypeEditorAsync(ContentTypeDefinition contentTypeDefinition, IUpdateModel updater, string groupId)
        {
            if (contentTypeDefinition == null)
            {
                throw new ArgumentNullException(nameof(contentTypeDefinition));
            }

            dynamic contentTypeDefinitionShape = CreateContentShape("ContentTypeDefinition_Edit");

            contentTypeDefinitionShape.ContentTypeDefinition = contentTypeDefinition;

            _contentDefinitionManager.AlterTypeDefinition(contentTypeDefinition.Name, typeBuilder =>
            {
                var typeContext = new UpdateTypeEditorContext(
                    typeBuilder,
                    contentTypeDefinitionShape,
                    groupId,
                    _shapeFactory,
                    _layoutAccessor.GetLayout(),
                    updater
                    );

                BindPlacementAsync(typeContext).Wait();

                _handlers.InvokeAsync(handler => handler.UpdateTypeEditorAsync(contentTypeDefinition, typeContext), Logger).Wait();
            });

            return(Task.FromResult <dynamic>(contentTypeDefinitionShape));
        }
Beispiel #2
0
        public async Task <dynamic> UpdateTypeEditorAsync(ContentTypeDefinition contentTypeDefinition, IUpdateModel updater, string groupId)
        {
            if (contentTypeDefinition == null)
            {
                throw new ArgumentNullException(nameof(contentTypeDefinition));
            }

            dynamic contentTypeDefinitionShape = await CreateContentShapeAsync("ContentTypeDefinition_Edit");

            contentTypeDefinitionShape.ContentTypeDefinition = contentTypeDefinition;

            var layout = await _layoutAccessor.GetLayoutAsync();

            _contentDefinitionManager.AlterTypeDefinition(contentTypeDefinition.Name, typeBuilder =>
            {
                var typeContext = new UpdateTypeEditorContext(
                    typeBuilder,
                    contentTypeDefinitionShape,
                    groupId,
                    false,
                    _shapeFactory,
                    layout,
                    updater
                    );

                BindPlacementAsync(typeContext).GetAwaiter().GetResult();

                _handlers.InvokeAsync((handler, contentTypeDefinition, typeContext) => handler.UpdateTypeEditorAsync(contentTypeDefinition, typeContext), contentTypeDefinition, typeContext, Logger).GetAwaiter().GetResult();
            });

            return(contentTypeDefinitionShape);
        }
 public Task UpdateTypeEditorAsync(ContentTypeDefinition model, UpdateTypeEditorContext context)
 {
     return(_typeDisplayDrivers.InvokeAsync(async contentDisplay =>
     {
         var result = await contentDisplay.UpdateEditorAsync(model, context);
         if (result != null)
         {
             await result.ApplyAsync(context);
         }
     }, Logger));
 }
        public override async Task <IDisplayResult> UpdateAsync(ContentTypeDefinition contentTypeDefinition, UpdateTypeEditorContext context)
        {
            var model = new ContentTypeSettingsViewModel();

            if (await context.Updater.TryUpdateModelAsync(model, Prefix))
            {
                context.Builder.Creatable(model.Creatable);
                context.Builder.Listable(model.Listable);
                context.Builder.Draftable(model.Draftable);
                context.Builder.Securable(model.Securable);
                context.Builder.Stereotype(model.Stereotype);
            }

            return(Edit(contentTypeDefinition, context.Updater));
        }
        public override async Task <IDisplayResult> UpdateAsync(ContentTypeDefinition contentTypeDefinition, UpdateTypeEditorContext context)
        {
            var model = new ContentTypeSettingsViewModel();

            if (await context.Updater.TryUpdateModelAsync(model, Prefix))
            {
                context.Builder.Creatable(model.Creatable);
                context.Builder.Listable(model.Listable);
                context.Builder.Draftable(model.Draftable);
                context.Builder.Versionable(model.Versionable);
                context.Builder.Securable(model.Securable);
                context.Builder.Enabled(model.Enabled);
                context.Builder.HiddenFromPicker(model.HiddenFromPicker);
                var stereotype = model.Stereotype?.Trim();
                context.Builder.Stereotype(stereotype);
                context.Builder.Category(model.Category?.Trim());
                context.Builder.Description(model.Description?.Trim());
                context.Builder.Icon(model.Icon?.Trim());

                if (!IsAlphaNumericOrEmpty(stereotype))
                {
                    context.Updater.ModelState.AddModelError(nameof(ContentTypeSettingsViewModel.Stereotype), S["The stereotype should be alphanumeric."]);
                }
            }

            return(Edit(contentTypeDefinition));
        }
        public override async Task <IDisplayResult> UpdateAsync(ContentTypeDefinition contentTypeDefinition, UpdateTypeEditorContext context)
        {
            var model = new ContentTypeViewModel();

            await context.Updater.TryUpdateModelAsync(model, Prefix);

            context.Builder.DisplayedAs(model.DisplayName);

            if (String.IsNullOrWhiteSpace(model.DisplayName))
            {
                context.Updater.ModelState.AddModelError("DisplayName", S["The Content Type name can't be empty."]);
            }

            return(Edit(contentTypeDefinition));
        }