Content management system Orchard CMS驱动程序&x27；s编辑器覆盖不触发

使用Orchard 1.7。

目标：是创建一个我们称之为页面过滤器的集合

为了创建多对多零件，我遵循了所描述的教程步骤

问题：我的驱动程序类中的编辑器覆盖从未被点击，并且返回一个空的创建页面，除了保存按钮外什么都没有

模型类：

namespace MyLib.Orchard.HyperlinkItemManager.Models
{
    public class HyperlinkPageFilterRecord
    {
        public virtual int Id { get; set; }
        public virtual int PageId { get; set; }
    }
}

namespace MyLib.Orchard.HyperlinkItemManager.Models
{
    public class HyperlinkPageFiltersContentRecord
    {
        public virtual int Id { get; set; }
        public virtual HyperlinkPageFiltersPartRecord HyperlinkPageFiltersPartRecord { get; set; }
        public virtual HyperlinkPageFilterRecord HyperlinkPageFilterRecord { get; set; }
    }

}
namespace MyLib.Orchard.HyperlinkItemManager.Models
{
    public class HyperlinkPageFiltersPart : ContentPart<HyperlinkPageFiltersPartRecord>
    {
        public IEnumerable<HyperlinkPageFilterRecord> HyperlinkPageFilters
        {
            get
            {
                return Record.HyperlinkPageFilters.Select(r => r.HyperlinkPageFilterRecord);
            }
        }
    }
}


namespace MyLib.Orchard.HyperlinkItemManager.Models
{
    public class HyperlinkPageFiltersPartRecord : ContentPartRecord
    {
        public virtual IList<HyperlinkPageFiltersContentRecord> HyperlinkPageFilters { get; set; }
        public HyperlinkPageFiltersPartRecord()
        {
            HyperlinkPageFilters = new List<HyperlinkPageFiltersContentRecord>();
        }
    }
}

名称空间MyLib.Orchard.HyperlinkItemManager.Models
{
公共类HyperlinkPageFilterRecord
{
公共虚拟整数Id{get；set；}
公共虚拟int PageId{get；set；}
}
}
命名空间MyLib.Orchard.HyperlinkItemManager.Models
{
公共类HyperlinkPageFiltersContentRecord
{
公共虚拟整数Id{get；set；}
公共虚拟HyperlinkPageFiltersPartRecord HyperlinkPageFiltersPartRecord{get；set；}
公共虚拟HyperlinkPageFilterRecord HyperlinkPageFilterRecord{get；set；}
}
}
命名空间MyLib.Orchard.HyperlinkItemManager.Models
{
公共类HyperlinkPageFiltersPart:ContentPart
{
公共IEnumerable HyperlinkPageFilters
{
得到
{
返回记录.HyperlinkPageFilters.Select（r=>r.HyperlinkPageFilterRecord）；
}
}
}
}
命名空间MyLib.Orchard.HyperlinkItemManager.Models
{
公共类HyperlinkPageFiltersPartRecord:ContentPartRecord
{
公共虚拟IList HyperlinkPageFilters{get；set；}
公共HyperlinkPageFiltersPartRecord（）
{
HyperlinkPageFilters=新列表（）；
}
}
}

查看模型类：

namespace MyLib.Orchard.HyperlinkItemManager.Models
{
    public class HyperlinkPageFiltersEditViewModel
    {
        public IList<HyperlinkPageFilterEntry> HyperlinkPageFilters { get; set; }
    }

    public class HyperlinkPageFilterEntry
    {
        public HyperlinkPageFilterRecord HyperlinkPageFilter { get; set; }
        public bool IsChecked { get; set; }
    }
}

名称空间MyLib.Orchard.HyperlinkItemManager.Models
{
公共类HyperlinkPageFiltersEditViewModel
{
公共IList HyperlinkPageFilters{get；set；}
}
公共类HyperlinkPageFilterEntry
{
公共HyperlinkPageFilterRecord HyperlinkPageFilter{get；set；}
已检查公共布尔值{get；set；}
}
}

服务：

   namespace MyLib.Orchard.HyperlinkItemManager.Services
    {
        public interface IHyperlinkPageFiltersService : IDependency
        {
            void UpdateHyperlinkPageFiltersForContentItem(
                ContentItem item,
                IEnumerable<HyperlinkPageFilterEntry> HyperlinkPageFilters);
            IEnumerable<HyperlinkPageFilterRecord> GetHyperlinkPageFilters();
        }

        public class HyperlinkPageFiltersService : IHyperlinkPageFiltersService
        {
            private readonly IRepository<HyperlinkPageFilterRecord>
                _HyperlinkPageFilterRepository;
            private readonly IRepository<HyperlinkPageFiltersContentRecord>
                _contentHyperlinkPageFiltersRepository;

            public HyperlinkPageFiltersService(
                IRepository<HyperlinkPageFilterRecord> HyperlinkPageFilterRepository,
                IRepository<HyperlinkPageFiltersContentRecord> contentHyperlinkPageFiltersRepository)
            {

                _HyperlinkPageFilterRepository = HyperlinkPageFilterRepository;
                _contentHyperlinkPageFiltersRepository = contentHyperlinkPageFiltersRepository;
            }

            public void UpdateHyperlinkPageFiltersForContentItem(
                ContentItem item,
                IEnumerable<HyperlinkPageFilterEntry> HyperlinkPageFilters)
            {

                var record = item.As<HyperlinkPageFiltersPart>().Record;
                var oldHyperlinkPageFilters = _contentHyperlinkPageFiltersRepository.Fetch(
                    r => r.HyperlinkPageFiltersPartRecord == record);
                var lookupNew = HyperlinkPageFilters
                    .Where(e => e.IsChecked)
                    .Select(e => e.HyperlinkPageFilter)
                    .ToDictionary(r => r, r => false);
                // Delete the rewards that are no longer there
                // and mark the ones that should stay
                foreach (var contentHyperlinkPageFiltersRecord in oldHyperlinkPageFilters)
                {
                    if (lookupNew.ContainsKey(
                        contentHyperlinkPageFiltersRecord.HyperlinkPageFilterRecord))
                    {

                        lookupNew[contentHyperlinkPageFiltersRecord.HyperlinkPageFilterRecord]
                            = true;
                    }
                    else
                    {
                        _contentHyperlinkPageFiltersRepository.Delete(contentHyperlinkPageFiltersRecord);
                    }
                }
                // Add the new rewards
                foreach (var HyperlinkPageFilter in lookupNew.Where(kvp => !kvp.Value)
                                               .Select(kvp => kvp.Key))
                {
                    _contentHyperlinkPageFiltersRepository.Create(new HyperlinkPageFiltersContentRecord
                    {
                        HyperlinkPageFiltersPartRecord = record,
                        HyperlinkPageFilterRecord = HyperlinkPageFilter
                    });
                }
            }

            public IEnumerable<HyperlinkPageFilterRecord> GetHyperlinkPageFilters()
            {
                return _HyperlinkPageFilterRepository.Table.ToList();
            }

名称空间MyLib.Orchard.HyperlinkItemManager.Services
{
公共接口IHyperlinkPageFiltersService:IDependency
{
无效更新HyperlinkPageFiltersforContentItem(
ContentItem项目，
i可数超链接页面过滤器）；
IEnumerable GetHyperlinkPageFilters（）；
}
公共类HyperlinkPageFiltersService:IHyperlinkPageFiltersService
{
私有只读存储
_HyperlinkPageFilterRepository；
私有只读存储
_contentHyperlinkPageFiltersRepository；
公共超链接页面过滤器服务(
IRepository HyperlinkPageFilterRepository，
i存储内容HyperlinkPageFiltersRepository）
{
_HyperlinkPageFilterRepository=HyperlinkPageFilterRepository；
_contentHyperlinkPageFiltersRepository=contentHyperlinkPageFiltersRepository；
}
公共无效更新HyperlinkPageFiltersforContentItem(
ContentItem项目，
IEnumerable HyperlinkPageFilters）
{
var记录=项.As（）.record；
var oldHyperlinkPageFilters=\u contentHyperlinkPageFiltersRepository.Fetch(
r=>r.HyperlinkPageFiltersPartRecord==record）；
var lookupNew=HyperlinkPageFilters
.其中（e=>e.IsChecked）
.选择（e=>e.HyperlinkPageFilter）
.ToDictionary（r=>r，r=>false）；
//删除不再存在的奖励
//并标出应该留下的
foreach（旧HyperlinkPageFilters中的var contentHyperlinkPageFilters记录）
{
if（lookupNew.ContainsKey(
ContentHyperlinkPageFilterRecord.HyperlinkPageFilterRecord）
{
lookupNew[ContentHyperlinkPageFilterRecord.HyperlinkPageFilterRecord]
=正确；
}
其他的
{
_contentHyperlinkPageFiltersRepository.Delete（contentHyperlinkPageFiltersRecord）；
}
}
//添加新的奖励
foreach（lookupNew.Where中的var HyperlinkPageFilter（kvp=>！kvp.Value）
.Select（kvp=>kvp.Key））
{
_contentHyperlinkPageFiltersRepository.Create（新建HyperlinkPageFiltersContentRecord
{
HyperlinkPageFiltersPartRecord=记录，
HyperlinkPageFilterRecord=HyperlinkPageFilter
});
}
}
公共IEnumerable GetHyperlinkPageFilters（）
{
return _HyperlinkPageFilterRepository.Table.ToList（）；
}

迁移：

    public int UpdateFrom11()
    {
        SchemaBuilder.CreateTable("HyperlinkPageFiltersPartRecord",
        table => table
            .ContentPartRecord()
        );

        SchemaBuilder.CreateTable("HyperlinkPageFilterRecord",
        table => table
            .Column<int>("Id", column => column.PrimaryKey().Identity())
            .Column<int>("PageId")
        );

        SchemaBuilder.CreateTable("HyperlinkPageFiltersContentRecord",
            table => table
                .Column<int>("Id", column => column.PrimaryKey().Identity())
                .Column<int>("HyperlinkPageFiltersPartRecord_Id")
                .Column<int>("HyperlinkPageFilterRecord_Id")
            );
        return 12;
    }



    public int UpdateFrom12() {
        ContentDefinitionManager.AlterTypeDefinition("HyperlinkPageFiltersPart", builder => builder
            .DisplayedAs("Hyperlink Page Filters")
            .WithPart("HyperlinkPageFiltersPart")
            );
        return 13;
    }
    public int UpdateFrom13()
    {
        ContentDefinitionManager.AlterPartDefinition(
            "HyperlinkPageFiltersPart",
            builder => builder.Attachable());
        return 14;
    }
    }
}

public int UpdateFrom11（）
{
SchemaBuilder.CreateTable（“HyperlinkPageFiltersPartRecord”，
表=>表
.ContentPartRecord（）
);
SchemaBuilder.CreateTable（“HyperlinkPageFilterRecord”，
表=>表
.Column（“Id”，Column=>Column.PrimaryKey（）.Identity（））
.列（“页面ID”）
);
SchemaBuilder.CreateTable（“HyperlinkPageFiltersContentRecord”，
表=>表
.Column（“Id”，Column=>Column.PrimaryKey（）.Identity（））
.列（“HyperlinkPageFiltersPartRecord\u Id”）
.列（“HyperlinkPageFilterRecord_Id”）
);
返回12；
}
public int UpdateFrom12（）{
ContentDefinitionManager.AlterTypeDefinition（“HyperlinkPageFiltersPart”，生成器=>builder
.DisplayedAs（“超链接页面过滤器”）
W
namespace MyLib.Orchard.HyperlinkItemManager.Drivers
{
    [UsedImplicitly]
    public class HyperlinkPageFiltersPartDriver : ContentPartDriver<HyperlinkPageFiltersPart>
    {
        private readonly IHyperlinkPageFiltersService _hyperlinkPageFiltersService;
        private IContentManager _contentManager;

        //private const string TemplateName = "Parts/HyperlinkPageFilters";

        public HyperlinkPageFiltersPartDriver(IHyperlinkPageFiltersService hyperlinkPageFiltersService, IContentManager contentManager)
        {
            _hyperlinkPageFiltersService = hyperlinkPageFiltersService;
            _contentManager = contentManager;
        }

        protected override string Prefix
        {
            get { return "HyperlinkPageFilters"; }
        }

        protected override DriverResult Display(HyperlinkPageFiltersPart part,string displayType,dynamic shapeHelper)
        {

            return ContentShape("Parts_HyperlinkPageFilters", () => shapeHelper.Parts_HyperlinkPageFilters(
                                ContentPart: part,
                                HyperlinkPageFilters: part.HyperlinkPageFilters));
        }

        protected override DriverResult Editor(HyperlinkPageFiltersPart part, dynamic shapeHelper)
        {


            return ContentShape("Parts_HyperlinkPageFilters_Edit",
                    () => shapeHelper.EditorTemplate(
                        TemplateName: "Parts.HyperlinkPageFilters.Edit",
                        Model: BuildEditorViewModel(part),
                        Prefix: Prefix));
        }

        protected override DriverResult Editor(HyperlinkPageFiltersPart part, IUpdateModel updater, dynamic shapeHelper)
        {

            var model = new HyperlinkPageFiltersEditViewModel();
            updater.TryUpdateModel(model, Prefix, null, null);

            if (part.ContentItem.Id != 0)
            {
                _hyperlinkPageFiltersService.UpdateHyperlinkPageFiltersForContentItem(
                    part.ContentItem, model.HyperlinkPageFilters);
            }

            return Editor(part, shapeHelper);
        }

        private HyperlinkPageFiltersEditViewModel BuildEditorViewModel(HyperlinkPageFiltersPart part)
        {

            //get all pages
            var pages = _contentManager.Query("Pages");

            //get pagesfilters

            //check pages

            var itemRewards = part.HyperlinkPageFilters.ToLookup(r => r.Id);
            return new HyperlinkPageFiltersEditViewModel
            {
                HyperlinkPageFilters = _hyperlinkPageFiltersService.GetHyperlinkPageFilters().Select(
                    r => new HyperlinkPageFilterEntry
                    {
                        HyperlinkPageFilter = r,
                        IsChecked = itemRewards.Contains(r.Id)
                    }).ToList()
            };
        }
    }
}

namespace MyLib.Orchard.HyperlinkItemManager.Handlers {
    public class HyperlinkPageFiltersPartHandler : ContentHandler {
        public HyperlinkPageFiltersPartHandler(IRepository<HyperlinkPageFiltersPartRecord> repository) {
            Filters.Add(StorageFilter.For(repository));
        }
    }
}