using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Orchard.ContentManagement.Records;
using Orchard.ContentManagement;

namespace SuccessCenter.Models
{
    public class ProductPartRecord : ContentPartRecord
    {
        public ProductPartRecord()
        {
            Leaves = new List<ProductToLeavesRecord>();
        }
        public virtual IList<ProductToLeavesRecord> Leaves { get; set; }
        public virtual string ProductsContent { get; set; }
    }
    public class ProductPart : ContentPart<ProductPartRecord>
    {
        public string ProductsContent
        {
            get { return Retrieve(r => r.ProductsContent); }
            set { Store(r => r.ProductsContent, value); }
        }

        public IEnumerable<ProductLeavesRecord> Leaves
        {
            get
            {
                return Record.Leaves.Select(r => r.ProductLeavesRecord);
            }
        }


    }

}

using System.Linq;
using JetBrains.Annotations;
using Orchard.ContentManagement;
using Orchard.ContentManagement.Drivers;
using SuccessCenter.Models;
using SuccessCenter.Services;
using SuccessCenter.ViewModels;

namespace SuccessCenter.Drivers
{
    [UsedImplicitly]
    public class ProductDriver : ContentPartDriver<ProductPart>
    {
        private readonly IProductService _productService;

        private const string TemplateName = "Parts/LeavesProduct";

        public ProductDriver(IProductService productService)
        {
            _productService = productService;
        }

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

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

            return ContentShape("Parts_LeavesProduct",
                            () => shapeHelper.Parts_LeavesProduct(
                                ContentPart: part,
                                Leaves: part.Leaves,
                                ProductsContent: part.ProductsContent));
        }

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

            return ContentShape("Parts_LeavesProduct_Edit",
                    () => shapeHelper.EditorTemplate(
                        TemplateName: TemplateName,
                        Model: BuildEditorViewModel(part),
                        Prefix: Prefix));
        }

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

            var model = new EditLeavesViewModel<ProductLeafEntry>();
            updater.TryUpdateModel(model, Prefix, null, null);

            if (part.ContentItem.Id != 0)
            {
                _productService.UpdateLeavesForContentItem(
                    part.ContentItem, model.Leaves);
            }

            return Editor(part, shapeHelper);
        }

        private EditLeavesViewModel<ProductLeafEntry> BuildEditorViewModel(ProductPart part)
        {
            var itemLeaves = part.Leaves.ToLookup(r => r.Id);
            return new EditLeavesViewModel<ProductLeafEntry>
            {
                Leaves = _productService.GetLeaves().Select(
                    r => new ProductLeafEntry
                    {
                        ProductLeaf = r,
                        IsChecked = itemLeaves.Contains(r.Id)
                    }).ToList(),
                ProductsContent = part.ProductsContent
            };
        }
    }
}

using System.Collections.Generic;
using System.Linq;
using Orchard;
using Orchard.ContentManagement;
using Orchard.Data;
using SuccessCenter.Models;
using SuccessCenter.ViewModels;

namespace SuccessCenter.Services
{
    public interface IProductService : IDependency
    {
        void UpdateLeavesForContentItem(
            ContentItem item,
            IEnumerable<ProductLeafEntry> Leaves);
        IEnumerable<ProductLeavesRecord> GetLeaves();
    }

    public class ProductService : IProductService
    {
        private readonly IRepository<ProductLeavesRecord>
            _productLeavesRepository;
        private readonly IRepository<ProductToLeavesRecord>
            _productToLeavesRepository;

        public ProductService(
            IRepository<ProductLeavesRecord> productLeavesRepository,
            IRepository<ProductToLeavesRecord> productToLeavesRepository)
        {

            _productLeavesRepository = productLeavesRepository;
            _productToLeavesRepository = productToLeavesRepository;
        }

        public void UpdateLeavesForContentItem(
            ContentItem item,
            IEnumerable<ProductLeafEntry> Leaves)
        {

            var record = item.As<ProductPart>().Record;
            var oldRewards = _productToLeavesRepository.Fetch(
                r => r.ProductPartRecord == record);
            var lookupNew = Leaves
                .Where(e => e.IsChecked)
                .Select(e => e.ProductLeaf)
                .ToDictionary(r => r, r => false);
            // Delete the rewards that are no longer there
            // and mark the ones that should stay
            foreach (var productToLeavesRecord in oldRewards)
            {
                if (lookupNew.ContainsKey(
                    productToLeavesRecord.ProductLeavesRecord))
                {

                    lookupNew[productToLeavesRecord.ProductLeavesRecord]
                        = true;
                }
                else
                {
                    _productToLeavesRepository.Delete(productToLeavesRecord);
                }
            }
            // Add the new rewards
            foreach (var leaf in lookupNew.Where(kvp => !kvp.Value)
                                           .Select(kvp => kvp.Key))
            {
                _productToLeavesRepository.Create(new ProductToLeavesRecord
                {
                    ProductPartRecord = record,
                    ProductLeavesRecord = leaf
                });
            }
        }

        public IEnumerable<ProductLeavesRecord> GetLeaves()
        {
            return _productLeavesRepository.Table.ToList();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using Orchard.Data;
using Orchard.ContentManagement.Handlers;
using SuccessCenter.Models;

namespace SuccessCenter.Handlers
{
    public class ProductHandler : ContentHandler
    {
        public ProductHandler(IRepository<ProductPartRecord> repository) {
            Filters.Add(StorageFilter.For(repository));
        }
    }
}

using System.Collections.Generic;

namespace SuccessCenter.ViewModels
{
    public class EditLeavesViewModel<T>
    {
        public IList<T> Leaves { get; set; }
        public string ProductsContent { get; set; }
        public string Title { get; set; }

    }
}




using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using SuccessCenter.Models;

namespace SuccessCenter.ViewModels
{
    public class ProductLeafEntry
    {
        public ProductLeavesRecord ProductLeaf {get;set;}
        public bool IsChecked { get; set; }
    }
}

@model SuccessCenter.ViewModels.EditLeavesViewModel<SuccessCenter.ViewModels.ProductLeafEntry>
<fieldset>
    <div class="editor-label">
        Products Widget Content
    </div>
    <div class="editor-field">
        @*@Display.Body_Editor(Text: Model.ProductsContent, EditorFlavor: "html", PropertyName: "ProductsContent")*@
        @Html.TextBoxFor(model => model.ProductsContent)
        @Html.ValidationMessageFor(model => model.ProductsContent)
    </div>

    <br/>
    <div class="editor-label">
        Leaves
    </div>

    <ul>
        @{
            var leafIndex = 0;
        }
        @foreach (var leaf in Model.Leaves)
        {
            <li>
                <input type="hidden" value="@leaf.ProductLeaf.Id"
                       name="@Html.FieldNameFor(m => m.Leaves[leafIndex].ProductLeaf.Id)" />
                <label for="@Html.FieldNameFor(m => m.Leaves[leafIndex].IsChecked)">
                    <input type="checkbox" value="true"
                           name="@Html.FieldNameFor(m => m.Leaves[leafIndex].IsChecked)"
                           id="@Html.FieldNameFor(m => m.Leaves[leafIndex].IsChecked)"
                           @if (leaf.IsChecked) { <text> checked="checked" </text>  } />
                    @leaf.ProductLeaf.Name
                </label>
                @{leafIndex++;}
            </li>
        }
    </ul>
</fieldset>

public int UpdateFrom8()
        {
            // Add a page title field to calloutrecord table
            SchemaBuilder.AlterTable("CalloutRecord", table => table
                .AddColumn<string>("PageTitle", c => c.WithLength(200)));

            SchemaBuilder.CreateTable("ProductPartRecord",
                table => table
                    .ContentPartRecord()
                );

            SchemaBuilder.AlterTable("ProductPartRecord",
                table => table
                    .AddColumn("ProductsContent", DbType.String, c => c.Nullable().Unlimited()));

            SchemaBuilder.CreateTable("ProductLeavesRecord", table => table
                .ContentPartRecord()
                .Column<string>("Name")
                .Column<string>("Url")
                .Column<string>("AltImage")
                .Column<string>("Icon")
                .Column<string>("ImageUrl"));


            ContentDefinitionManager.AlterPartDefinition(
                typeof(ProductLeavesPart).Name, cfg => cfg.Attachable()
                    .WithDescription("Product Leaf Content"));

            ContentDefinitionManager.AlterTypeDefinition("Product Leaf", cfg => cfg
                .Creatable()
                .Listable()
                .Draftable()
                .Securable()
                .WithPart(typeof(ProductLeavesPart).Name)
                .WithPart("CommonPart")
                .WithPart("TitlePart"));

            ContentDefinitionManager.AlterTypeDefinition("Product Leaf Widget", cfg => cfg
                .WithPart(typeof(ProductLeavesPart).Name)
                .WithPart("WidgetPart")
                .WithPart("CommonPart")
                .WithSetting("Stereotype", "Widget"));


            SchemaBuilder.CreateTable("ProductToLeavesRecord",
                table => table
                    .Column<int>("Id", column => column.PrimaryKey().Identity())
                    .Column<int>("ProductPartRecord_Id")
                    .Column<int>("ProductLeavesRecord_Id")
                );

            ContentDefinitionManager.AlterPartDefinition(typeof(ProductPart).Name,
                builder => builder.Attachable()
                    .WithDescription("Product - Collection of Product Leaves"));

            ContentDefinitionManager.AlterTypeDefinition("Product", cfg => cfg
                .Creatable()
                .Listable()
                .Draftable()
                .Securable()
                .WithPart(typeof(ProductPart).Name)
                .WithPart("CommonPart")
                .WithPart("TitlePart"));

            ContentDefinitionManager.AlterTypeDefinition("Product Widget", cfg => cfg
                .WithPart(typeof(ProductPart).Name)
                .WithPart("WidgetPart")
                .WithPart("CommonPart")
                .WithSetting("Stereotype", "Widget"));

            return 9;
        }