Adding Admin Search specific index settings

src/Orchard.Web/Modules/Orchard.Indexing/Views/DefinitionTemplates/TypeIndexing.cshtml

@@ -7,16 +7,16 @@
 }
 
 @if (indexProvider != null) {
-    <fieldset>
-        <legend>@T("Index this content type in:")</legend>
-        @{ var i = 0;}
-        <select size="0" name="@Html.FieldNameFor(m => m.List)">
-            @foreach (var index in indexProvider.List()) {
-                <option value="" selected="@(!Model.List.Contains(index + ":latest") && !Model.List.Contains(index))">@index - Not indexed</option>
-                <option value="@index" selected="@(Model.List.Contains(index))">@index - Index published version</option>
-                <option value="@(index):latest" selected="@(Model.List.Contains(index + ":latest"))">@index - Index any version</option>
-                i++;
-            }
-        </select>
-    </fieldset>
+    var i = 0;
+    foreach (var index in indexProvider.List()) {
+        <fieldset>
+            <legend>@T("{0} index", @index)</legend>
+            <select size="0" name="@Html.FieldNameFor(m => m.List)">
+                <option value="" selected="@(!Model.List.Contains(index + ":latest") && !Model.List.Contains(index))">@T("Not indexed")</option>
+                <option value="@index" selected="@(Model.List.Contains(index))">@T("Published version")</option>
+                <option value="@(index):latest" selected="@(Model.List.Contains(index + ":latest"))">@T("Any versions")</option>
+            </select>
+        </fieldset>
+        i++;
+    }
 }

src/Orchard.Web/Modules/Orchard.Search/Controllers/AdminController.cs

@@ -37,13 +37,13 @@ namespace Orchard.Search.Controllers {
 
         public ActionResult Index(PagerParameters pagerParameters, string searchText = "") {
             var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
-            var searchSettingsPart = Services.WorkContext.CurrentSite.As<SearchSettingsPart>();
+            var searchSettingsPart = Services.WorkContext.CurrentSite.As<AdminSearchSettingsPart>();
             
             IPageOfItems<ISearchHit> searchHits = new PageOfItems<ISearchHit>(new ISearchHit[] { });
             try {
 
                 searchHits = _searchService.Query(searchText, pager.Page, pager.PageSize,
-                                                  Services.WorkContext.CurrentSite.As<SearchSettingsPart>().FilterCulture,
+                                                  Services.WorkContext.CurrentSite.As<AdminSearchSettingsPart>().FilterCulture,
                                                   searchSettingsPart.SearchIndex,
                                                   searchSettingsPart.SearchedFields,
                                                   searchHit => searchHit);
@@ -54,8 +54,8 @@ namespace Orchard.Search.Controllers {
             }
 
             var list = Services.New.List();
-            foreach (var contentItem in Services.ContentManager.GetMany<IContent>(searchHits.Select(x => x.ContentItemId), VersionOptions.Published, QueryHints.Empty)) {
-                // ignore search results which content item has been removed or unpublished
+            foreach (var contentItem in Services.ContentManager.GetMany<IContent>(searchHits.Select(x => x.ContentItemId), VersionOptions.Latest, QueryHints.Empty)) {
+                // ignore search results which content item has been removed
                 if (contentItem == null) {
                     searchHits.TotalItemCount--;
                     continue;

src/Orchard.Web/Modules/Orchard.Search/Drivers/AdminSearchSettingsPartDriver.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+using Orchard.ContentManagement;
+using Orchard.ContentManagement.Drivers;
+using Orchard.ContentManagement.Handlers;
+using Orchard.Environment.Extensions;
+using Orchard.Indexing;
+using Orchard.Localization;
+using Orchard.Search.Models;
+using Orchard.Search.ViewModels;
+
+namespace Orchard.Search.Drivers {
+
+    [OrchardFeature("Orchard.Search.Content")]
+    public class AdminSearchSettingsPartDriver : ContentPartDriver<AdminSearchSettingsPart> {
+        private readonly IIndexManager _indexManager;
+
+        public AdminSearchSettingsPartDriver(IIndexManager indexManager) {
+            _indexManager = indexManager;
+            T = NullLocalizer.Instance;
+        }
+
+        public Localizer T { get; set; }
+
+        protected override string Prefix { get { return "AdminSearchSettings"; } }
+
+        protected override DriverResult Editor(AdminSearchSettingsPart part, dynamic shapeHelper) {
+            return Editor(part, null, shapeHelper);
+            
+        }
+
+        protected override DriverResult Editor(AdminSearchSettingsPart part, IUpdateModel updater, dynamic shapeHelper) {
+            return ContentShape("Parts_AdminSearch_SiteSettings", () => {
+                var model = new SearchSettingsViewModel();
+                String[] searchedFields = part.SearchedFields;
+
+                if (updater != null) {
+                    // submitting: rebuild model from form data
+                    if (updater.TryUpdateModel(model, Prefix, null, null)) {
+                        // update part if successful
+                        part.SearchIndex = model.SelectedIndex;
+                        part.SearchedFields = model.Entries.First(e => e.Index == model.SelectedIndex).Fields.Where(e => e.Selected).Select(e => e.Field).ToArray();
+                        part.FilterCulture = model.FilterCulture;
+                    }
+                }
+                else if (_indexManager.HasIndexProvider()) {
+                    // viewing editor: build model from part
+                    model.FilterCulture = part.FilterCulture;
+                    model.SelectedIndex = part.SearchIndex;
+                    model.Entries = _indexManager.GetSearchIndexProvider().List().Select(x => {
+                        var indexSettings = new IndexSettingsEntry {
+                            Index = x,
+                            Fields = new List<SearchSettingsEntry>()
+                        };
+                        foreach (var field in _indexManager.GetSearchIndexProvider().GetFields(x)) {
+                            indexSettings.Fields.Add(new SearchSettingsEntry {Field = field, Selected = (x == part.SearchIndex && searchedFields.Contains(field))});
+                        }
+
+                        return indexSettings;
+                    }).ToList();
+                }
+
+                return shapeHelper.EditorTemplate(TemplateName: "Parts/AdminSearch.SiteSettings", Model: model, Prefix: Prefix);
+            }).OnGroup("admin search");
+        }
+
+        protected override void Exporting(AdminSearchSettingsPart part, ExportContentContext context) {
+            context.Element(part.PartDefinition.Name).Add(new XAttribute("SearchedFields", string.Join(",", part.SearchedFields)));
+        }
+
+        protected override void Importing(AdminSearchSettingsPart part, ImportContentContext context) {
+            var xElement = context.Data.Element(part.PartDefinition.Name);
+            if (xElement == null) return;
+            
+            var searchedFields = xElement.Attribute("SearchedFields");
+            searchedFields.Remove();
+
+            part.SearchedFields = searchedFields.Value.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.Search/Handlers/AdminSearchSettingsPartHandler.cs

@@ -0,0 +1,30 @@
+using Orchard.ContentManagement;
+using Orchard.Localization;
+using Orchard.Search.Models;
+using Orchard.Data;
+using Orchard.ContentManagement.Handlers;
+using Orchard.Environment.Extensions;
+
+namespace Orchard.Search.Handlers {
+    [OrchardFeature("Orchard.Search.Content")]
+    public class AdminSearchSettingsPartHandler : ContentHandler {
+        public AdminSearchSettingsPartHandler() {
+            T = NullLocalizer.Instance;
+            Filters.Add(new ActivatingFilter<AdminSearchSettingsPart>("Site"));
+            
+            OnInitializing<AdminSearchSettingsPart>((context, part) => {
+                part.FilterCulture = false;
+                part.SearchedFields = new [] {"body, title"};
+            });
+        }
+
+        public Localizer T { get; set; }
+
+        protected override void GetItemMetadata(GetContentItemMetadataContext context) {
+            if (context.ContentItem.ContentType != "Site")
+                return;
+            base.GetItemMetadata(context);
+            context.Metadata.EditorGroupInfo.Add(new GroupInfo(T("Admin Search")));
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.Search/Migrations.cs

@@ -57,4 +57,23 @@ namespace Orchard.Search {
             return 1;
         }
     }
+
+
+    [OrchardFeature("Orchard.Search.Content")]
+    public class AdminSearchMigration : DataMigrationImpl {
+        private readonly IIndexManager _indexManager;
+
+        public AdminSearchMigration(IIndexManager indexManager) {
+            _indexManager = indexManager;
+        }
+
+        public int Create() {
+
+            _indexManager.GetSearchIndexProvider().CreateIndex("Admin");
+
+            ContentDefinitionManager.AlterTypeDefinition("Page", cfg => cfg.WithSetting("TypeIndexing.Indexes", "Page:latest"));
+
+            return 1;
+        }
+    }
 }

src/Orchard.Web/Modules/Orchard.Search/Models/AdminSearchSettingsPart.cs

@@ -0,0 +1,23 @@
+using System;
+using Orchard.ContentManagement;
+using Orchard.Environment.Extensions;
+
+namespace Orchard.Search.Models {
+    [OrchardFeature("Orchard.Search.Content")]
+    public class AdminSearchSettingsPart : ContentPart {
+        public string[] SearchedFields {
+            get { return (Retrieve<string>("SearchedFields") ?? "").Split(new[] {',', ' '}, StringSplitOptions.RemoveEmptyEntries);  }
+            set { Store("SearchedFields", String.Join(", ", value));  }
+        }
+
+        public bool FilterCulture {
+            get { return this.Retrieve(x => x.FilterCulture); }
+            set { this.Store(x => x.FilterCulture, value); }
+        }
+
+        public string SearchIndex {
+            get { return this.Retrieve(x => x.SearchIndex); }
+            set { this.Store(x => x.SearchIndex, value); }
+        }
+    }
+}

src/Orchard.Web/Modules/Orchard.Search/Orchard.Search.csproj

@@ -72,7 +72,10 @@
     <Compile Include="Controllers\MediaController.cs" />
     <Compile Include="Drivers\MediaLibraryExplorerPartDriver.cs" />
     <Compile Include="Drivers\SearchFormPartDriver.cs" />
+    <Compile Include="Drivers\AdminSearchSettingsPartDriver.cs" />
+    <Compile Include="Handlers\AdminSearchSettingsPartHandler.cs" />
     <Compile Include="Models\SearchFormPart.cs" />
+    <Compile Include="Models\AdminSearchSettingsPart.cs" />
     <Compile Include="ResourceManifest.cs" />
     <Compile Include="Controllers\SearchController.cs" />
     <Compile Include="Migrations.cs" />
@@ -146,6 +149,9 @@
   <ItemGroup>
     <Content Include="Views\Media\MediaItems.cshtml" />
   </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\EditorTemplates\Parts\AdminSearch.SiteSettings.cshtml" />
+  </ItemGroup>
   <PropertyGroup>
     <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
     <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>

src/Orchard.Web/Modules/Orchard.Search/Placement.info

@@ -1,4 +1,5 @@
 <Placement>
+    <Place Parts_AdminSearch_SiteSettings="Content:1"/>
     <Place Parts_Search_SiteSettings="Content:1"/>
     <Place Parts_Search_SearchForm="Content:1"/>
 

src/Orchard.Web/Modules/Orchard.Search/Views/EditorTemplates/Parts/AdminSearch.SiteSettings.cshtml

@@ -0,0 +1,78 @@
+@using Orchard.Search.ViewModels
+@model SearchSettingsViewModel
+@{
+    Script.Require("jQuery");
+    
+}
+<fieldset>
+    <legend>@T("Admin Search")</legend>
+    <div>
+        <label>@T("Indexes")</label>
+        
+        @if (Model.Entries != null && Model.Entries.Any()) {
+            if (String.IsNullOrWhiteSpace(Model.SelectedIndex)) {
+                Model.Entries.Insert(0, new IndexSettingsEntry { Index = "" });
+            }
+
+        <select id="selectIndex" name="@Html.NameFor(m => m.SelectedIndex)">
+            @foreach (var modelEntry in Model.Entries) {
+            @Html.SelectOption(Model.SelectedIndex, modelEntry.Index, modelEntry.Index)
+            }
+        </select>
+        <span class="hint">@T("Select which index to use in search queries.")</span>
+
+        <label>@T("Fields")</label>
+            <ul>
+                @{var entryIndex = 0;}
+                @foreach(var modelEntry in Model.Entries) {
+                    @Html.HiddenFor(m => m.Entries[entryIndex].Index)
+                    <li data-index="@modelEntry.Index">
+                        @if (modelEntry.Fields != null && modelEntry.Fields.Any()) {
+                            <ul>
+                                @{ var fieldIndex = 0;}
+                                @foreach (var fieldEntry in Model.Entries[entryIndex].Fields) {
+                                    <li>
+                                        @Html.EditorFor(m => m.Entries[entryIndex].Fields[fieldIndex].Selected)
+                                        @Html.HiddenFor(m => m.Entries[entryIndex].Fields[fieldIndex].Field)
+                                        <label class="forcheckbox" for="@Html.FieldIdFor(m => m.Entries[entryIndex].Fields[fieldIndex].Selected)">@Model.Entries[entryIndex].Fields[fieldIndex].Field</label>
+                                    </li>
+                                    fieldIndex++;
+                                }
+                            </ul>
+                        }
+                    </li>
+                    entryIndex++;
+                }
+            </ul>
+            <span class="hint">@T("Check any property which should be used for search queries.")</span>
+
+        }
+        else {
+            <span class="hint">@T("There is currently no index to search from. Please update your index, and check if some indexable content exists.")</span>
+        }
+    </div>
+    <div>
+        <label>@T("Localization")</label>
+        @Html.EditorFor(m => m.FilterCulture)
+        <label class="forcheckbox" for="@Html.FieldIdFor(m => m.FilterCulture)">@T("Narrow search to current culture only")</label>
+        <span class="hint">@T("If checked, search results will only include content items localized in the current culture of the request.")</span>
+    </div>
+
+</fieldset>
+
+@using (Script.Foot()) {
+<script type="text/javascript">
+    //<![CDATA[
+    (function ($) {
+
+        $('li[data-index]').hide();
+        $("li[data-index='@Model.SelectedIndex']").show();
+        $('#selectIndex').change(function () {
+            $('li[data-index]').hide();
+            $("li[data-index='" + $(this).val() + "']").show();
+        });
+
+    })(jQuery);
+//]]>
+</script>
+}