Modifica di Nop4.40.3

== Installare Nop 4.40.3 ==
In questa guida saranno evidenziati in <code style="color:red;font-weight:bold;">rosso</code> tutti i file del core di Nop che verranno toccati.

=== Operazioni sul DB ===
* Creare un dump del database di produzione (Nop 4.3)
* Ripristinarlo
* Per ripristinare l'utente '''wmuser''' è necessario disassociarlo dal catalogo fulltext
* Da SQL Management Aprire <code>Storage -> Fulltext Catalogs -> nopCommerceFullTextCatalog</code>, nella tab ''General'' impostare come ''Owner'' => '''dbo'''
* Eliminare l'utente '''wmuser'''
* Ri-mappare l'utente '''wmuser''' sul database nuovo
* Aprire di nuovo <code>Storage -> Fulltext Catalogs -> nopCommerceFullTextCatalog</code>, nella tab ''General'' inserire come ''Owner'' => '''wmuser'''
* Aprire di nuovo <code>Storage -> Fulltext Catalogs -> nopCommerceFullTextCatalog</code>, nella tab ''Tables/Views'', pannello ''Eligible columns'' impostare '''italian''' per tutti i campi
* Creazione dei sinonimi: <syntaxhighlight lang="sql">CREATE SYNONYM [dbo].[Db_NopMapping_Occasioni] FOR [_Designbest].[dbo].[NopMapping_Occasioni]
CREATE SYNONYM [dbo].[TP_Occasioni] FOR [_Trovaprodotti].[dbo].[Occasioni]</syntaxhighlight>

=== Configurazione della Solution ===
* Aggiornare i file <code>Presentation\Nop.Web\App_Data\dataSettings.json</code> e <code>Presentation\Nop.Web\App_Data\appsettings.json</code>
* Copiare i plugin di terze parti nella cartella <code>Plugins\Nop.Plugin.Compiled</code>
* Aggiungere il seguente codice nei ''build events'' => ''post build event'' progetto Nop.Web <syntaxhighlight>xcopy /y /E $(SolutionDir)Plugins\Nop.Plugin.Compiled $(SolutionDir)Presentation\Nop.Web\Plugins</syntaxhighlight> per copiare i plugin compilati (7spikes & co) nel corretto folder durante il build.
* Creare dal ''Configuration Manager'' una nuova ''Solution Configuration'' chiamata '''ReleaseTest'''
* Tasto destro sul '''web.config''' e cliccare su ''Add Configs Transform'' per creare i '''web.Release.config''' e '''web.ReleaseTest.config'''
** Nel '''web.config''' aggiungere la variabile d'ambiente ASPNETCORE_ENVIRONMENT con valore ''Development'' sotto la sezione ''aspNetCore'' <syntaxhighlight lang="xml"><environmentVariables>
  <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Development" />
</environmentVariables></syntaxhighlight>
** Nel '''web.ReleaseTest.config''' mettere il valore ''Testing'' <syntaxhighlight lang="xml"><environmentVariables>
  <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Testing" xdt:Transform="SetAttributes" xdt:Locator="Match(name)" />
</environmentVariables></syntaxhighlight>
** nel '''web.Release.config''' mettere il valore ''Production'' <syntaxhighlight lang="xml"><environmentVariables>
  <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Production" xdt:Transform="SetAttributes" xdt:Locator="Match(name)" />
</environmentVariables></syntaxhighlight>
* Dalle proprietà del progetto ''Nop.Web'' andare sulla tab ''Build'', selezionare la configurazione ''Release'' e aggiungere il simbolo condizionale '''OFFICIAL'''
* Configuriamo l'applicazione in modo che cambi file di configurazione a seconda della Solution Configuration selezionata
** In <code style="color:red;font-weight:bold;">Libraries\Nop.Data\NopDataSettingsDefaults.cs</code> cambiare l'assegnamento di '''FilePath''' con quanto segue <syntaxhighlight lang="c#">        public static string FilePath =>
#if DEBUG
            "~/App_Data/dataSettings.development.json";

#elif !OFFICIAL
            "~/App_Data/dataSettings.testing.json";

#else
            "~/App_Data/dataSettings.json";

#endif</syntaxhighlight>
** In <code style="color:red;font-weight:bold;">Libraries\Nop.Services\Configuration\NopConfigurationDefaults.cs</code> cambiare l'assegnamento di '''AppSettingsFilePath''' con quanto segue <syntaxhighlight lang="c#">        public static string AppSettingsFilePath =>
#if DEBUG
            "App_Data/appsettings.development.json";

#elif !OFFICIAL
            "App_Data/appsettings.testing.json";

#else
            "App_Data/appsettings.json";

#endif</syntaxhighlight>
* Addare alla Solution (cartella Libraries) i progetti ''GenericUtilites'', ''WM4Search'', ''WM_Core'' e ''USO''
* Runnando la Solution dovrebbe partire con tutti i plugin disabilitati. Una volta entrati in admin è possibile vederli dall'elenco e installarli.
* Non ci saranno tutti i plugin, in tal caso cliccare su '''ricaricare la lista di plugin''', la soluzione si chiuderà da sola, ma al successivo login la lista dovrebbe essere aggiornata.
* Aggiornare tutti i pacchetti nuGet della Solution che abbiano un update minor (dalla seconda cifra in poi)
* Creazione di '''IWMCoreModelFactory''' per le chiamate alla WMCore.
** INTERFACCIA: creare <code>Presentation\Nop.Web\Factories\IWMCoreModelFactory.cs</code> così <syntaxhighlight lang="c#">using GPC.WM_Core;

namespace Nop.Web.Factories {
  public interface IWMCoreModelFactory {
    WMRetriever WMCore { get; }
  }
}</syntaxhighlight>
** IMPLEMENTAZIONE: creare <code>Presentation\Nop.Web\Factories\IWMCoreModelFactory.cs</code> così <syntaxhighlight lang="c#">using GPC.WM_Core;
using Microsoft.Extensions.Configuration;

namespace Nop.Web.Factories {
  public class WMCoreModelFactory : IWMCoreModelFactory {
    public WMRetriever WMCore { get; } = null;

    public WMCoreModelFactory(IConfiguration configuration) {
      WMCore = new WMRetriever(
        configuration.GetSection("WMConnectionStrings")["Designbest"],
        configuration.GetSection("WMConnectionStrings")["Designbest"],
        configuration.GetSection("WMConnectionStrings")["Trovaprodotti"],
        configuration.GetSection("WMApplicationSettings")["ResourcesPath"],
        "Test_WM47");
    }
  }
}</syntaxhighlight>
** BINDING: comunicare la sua esistenza al framework modificando <code style="color:red;font-weight:bold;">Presentation\Nop.Web\Startup.cs</code> aggiungendo una riga a ConfigureServices() così <syntaxhighlight lang="c#">public void ConfigureServices(IServiceCollection services)
{
  // aggiunta di IWMCoreModelFactory
  services.AddSingleton<IWMCoreModelFactory, WMCoreModelFactory>();
  services.ConfigureApplicationServices(_configuration, _webHostEnvironment);
}</syntaxhighlight>
* Inserimento di '''UsoUtilitiesController''' uguale a quello precedente con la differenza che le chiamate a services sono diventate tutte ASYNC e perciò il trucco è aggiungere al fondo <code>.Result</code> per le variabili o <code>.Wait()</code> per i metodi come ad esempio <syntaxhighlight lang="c#">Customer customer = _customerService.GetCustomerByGuidAsync(customerGuid).Result;
_authenticationService.SignInAsync(customer, true).Wait();</syntaxhighlight>

=== Url Rewrite ===
Cambiare le regole di rewrite, i '''prodotti''' sotto <code>/catalogo-prodotti</code> , le '''categorie''' sotto <code>/catalogo</code> e i '''cataloghi''' sotto <code>/brand</code>

Modificare in <code>Nop.Web\Infrastructure\GenericUrlRouteProvider.cs</code>
<syntaxhighlight lang="c#">
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Routing;
using Nop.Data;
using Nop.Web.Framework.Mvc.Routing;

namespace Nop.Web.Infrastructure {
  /// <summary>
  /// Represents provider that provided generic routes
  /// </summary>
  public partial class GenericUrlRouteProvider : BaseRouteProvider, IRouteProvider {
    #region Methods

    /// <summary>
    /// Register routes
    /// </summary>
    /// <param name="endpointRouteBuilder">Route builder</param>
    public void RegisterRoutes(IEndpointRouteBuilder endpointRouteBuilder) {
      var lang = GetLanguageRoutePattern();
      #region WEBMOBILI
      string constProducts = "catalogo-prodotti";
      string constCategories = "catalogo";
      string constManufacturers = "brand";
      #endregion
      //default routes
      //these routes are not generic, they are just default to map requests that don't match other patterns, 
      //but we define them here since this route provider is with the lowest priority, to allow to add additional routes before them
      if (!string.IsNullOrEmpty(lang)) {
        endpointRouteBuilder.MapControllerRoute(name: "DefaultWithLanguageCode",
            pattern: $"{lang}/{{controller=Home}}/{{action=Index}}/{{id?}}");
      }

      endpointRouteBuilder.MapControllerRoute(name: "Default",
          pattern: "{controller=Home}/{action=Index}/{id?}");

      if (!DataSettingsManager.IsDatabaseInstalled())
        return;

      //generic routes
      var genericPattern = $"{lang}/{{SeName}}";
      
      #region WEBMOBILI
      endpointRouteBuilder.MapDynamicControllerRoute<SlugRouteTransformer>(constProducts + "/{SeName}");
      endpointRouteBuilder.MapDynamicControllerRoute<SlugRouteTransformer>(constCategories + "/{SeName}");
      endpointRouteBuilder.MapDynamicControllerRoute<SlugRouteTransformer>(constManufacturers + "/{SeName}");
      #endregion

      endpointRouteBuilder.MapDynamicControllerRoute<SlugRouteTransformer>(genericPattern);

      endpointRouteBuilder.MapControllerRoute(name: "GenericUrl",
          pattern: "{genericSeName}",
          defaults: new { controller = "Common", action = "GenericUrl" });

      endpointRouteBuilder.MapControllerRoute(name: "GenericUrlWithParameter",
          pattern: "{genericSeName}/{genericParameter}",
          defaults: new { controller = "Common", action = "GenericUrl" });

      endpointRouteBuilder.MapControllerRoute(name: "Product",
          pattern: $"{lang}/{constProducts}/{{SeName}}",
          defaults: new { controller = "Product", action = "ProductDetails" });

      endpointRouteBuilder.MapControllerRoute(name: "Category",
          pattern: $"{lang}/{constCategories}/{{SeName}}",
          defaults: new { controller = "Catalog", action = "Category" });

      endpointRouteBuilder.MapControllerRoute(name: "Manufacturer",
          pattern: $"{lang}/{constManufacturers}/{{SeName}}",
          defaults: new { controller = "Catalog", action = "Manufacturer" });

      endpointRouteBuilder.MapControllerRoute(name: "Vendor",
          pattern: genericPattern,
          defaults: new { controller = "Catalog", action = "Vendor" });

      endpointRouteBuilder.MapControllerRoute(name: "NewsItem",
          pattern: genericPattern,
          defaults: new { controller = "News", action = "NewsItem" });

      endpointRouteBuilder.MapControllerRoute(name: "BlogPost",
          pattern: genericPattern,
          defaults: new { controller = "Blog", action = "BlogPost" });

      endpointRouteBuilder.MapControllerRoute(name: "Topic",
          pattern: genericPattern,
          defaults: new { controller = "Topic", action = "TopicDetails" });

      endpointRouteBuilder.MapControllerRoute(name: "ProductsByTag",
          pattern: genericPattern,
          defaults: new { controller = "Catalog", action = "ProductsByTag" });
    }

    #endregion

    #region Properties

    /// <summary>
    /// Gets a priority of route provider
    /// </summary>
    /// <remarks>
    /// it should be the last route. we do not set it to -int.MaxValue so it could be overridden (if required)
    /// </remarks>
    public int Priority => -1000000;

    #endregion
  }
}
</syntaxhighlight>

=== Prodotto ===
* Aggiunta metodi frmt() di utilità nelle viste per restituire decimali in <code>Nop.Web\Extensions\HtmlExtensions.cs</code>:
<syntaxhighlight lang="c#">
    /// Restituisce (come stringa) il numero decimale specificato inserendo il punto
    /// ogni tre cifre. I numeri decimali sono limitati a 2
    /// </summary>
    /// <param name="val">Un decimal</param>
    /// <returns>Il numero nella forma mmm.kkk.uuu,dd</returns>
    public static string frmt(this decimal val) {
      var ci = new CultureInfo("it-IT");
      ci.NumberFormat.NumberDecimalDigits = 2;
      return val.ToString("N", ci);
    }

    /// Restituisce (come stringa) il numero intero specificato inserendo il punto
    /// ogni tre cifre.
    /// </summary>
    /// <param name="val">Un decimal</param>
    /// <returns>Il numero nella forma mmm.kkk.uuu,dd</returns>
    public static string frmt(this int val) {
      var ci = new CultureInfo("it-IT");
      ci.NumberFormat.NumberDecimalDigits = 2;
      return val.ToString("N", ci);
    }
</syntaxhighlight>

* Nel '''modello''' del prodotto in <code>Nop.Web\Models\Catalog\ProductDetailsModel.cs</code> aggiungere:
<syntaxhighlight lang="c#">
 #region WEBMOBILI
    /// <summary>
    /// Nella nostra struttura c'è sempre un solo manufacturer per prodotto. Questa property lo restituisce.
    /// In caso di manufacturer non settato (errore di dati) restituisce un manu vuoto per evitare una NullPointerException
    /// </summary>
    public ManufacturerBriefInfoModel Manufacturer {
      get {
        if (ProductManufacturers.Count > 0) {
          return ProductManufacturers[0];
        }
        return new ManufacturerBriefInfoModel { Name = "", SeName = "", IsActive = false };
      }
    }

    public string ShopCity { get; set; }

    public decimal AdditionalShippingCharge { get; set; }

    #endregion
</syntaxhighlight>

* '''ProductController''': al momento dichiarata l'istanza dell'interfaccia IWMCoreModelFactory, ma non utilizzata, i campi necessari sono stati aggiunti direttamente nel modello del prodotto, aggiungiamo quindi solo questa istruzione nel metodo ''ProductDetails(int productId, int updatecartitemid = 0)'':
<syntaxhighlight lang="c#">
#region WEBMOBILI
      model.AdditionalShippingCharge = product.AdditionalShippingCharge; // spese di spedizione da stampare in frontend
#endregion
</syntaxhighlight>

* Nella '''vista''' del prodotto, copiare la vista del tema base <code>Nop.Web\Views\Product\_DeliveryInfo.cs</code> in <code>Nop.Web\Themes\Brooklyn\Views\Product\_DeliveryInfo.cs</code> e modificarla così:
<syntaxhighlight lang="c#">
@model ProductDetailsModel
@if (Model.FreeShippingNotificationEnabled && Model.IsFreeShipping@*|| !string.IsNullOrWhiteSpace(Model.DeliveryDate)*@) {
<div class="delivery">
  <script asp-location="Footer">
    $(document).on("product_attributes_changed", function (data) {
      if (data.changedData.isFreeShipping) {
        $("#free-shipping-" + data.changedData.productId).removeClass("invisible");
      } else {
        $("#free-shipping-" + data.changedData.productId).addClass("invisible");
      }
    });
  </script>
  @if (Model.FreeShippingNotificationEnabled && Model.IsFreeShipping) {
    <div id="free-shipping-@Model.Id" class="free-shipping">@T("Products.FreeShipping")</div>
  }
  @if (!string.IsNullOrWhiteSpace(Model.DeliveryDate)) {
    <div class="delivery-date">
      <span class="label">@T("Products.DeliveryDate"):</span>
      <span class="value">@Model.DeliveryDate</span>
    </div>
  }
</div>
}
else {
<div class="delivery">
  @if (Model.IsShipEnabled) {
    <div class="free-shipping">
      <span class="label">SPEDIZIONE STANDARD ITALIA € @Model.AdditionalShippingCharge.frmt() <span class="testo-minuscolo">(cad.)</span></span>
    </div>
    @if (!string.IsNullOrWhiteSpace(Model.DeliveryDate)) {
      <div class="delivery-date">
        <span class="label">@T("Products.DeliveryDate"):</span>
        <span class="value">@Model.DeliveryDate</span>
      </div>
    }
  }
  else {
    <div class="free-shipping">
      <span class="label">SPEDIZIONE PERSONALIZZATA A PREVENTIVO</span>
    </div>
  }
</div>
}
</syntaxhighlight>

=== LATO ADMIN ===

Per cambiare l'immagine in alto a sinistra bisogna sovrascriverla qui <code>P:\DesignbestCommerce3\Presentation\Nop.Web\wwwroot\css\admin\images</code> per 2 versioni del menu(compatto e non) <code>logo.png 250x57</code> e <code>logo-mini.png</code>

==== Home - Vendor ====
* Nascondere il pulsante ''Visualizza'' nei best seller(un Vendor non deve entrare nella pagina di modifica del prodotto lato NOP), bisogna commentare l'ultima <code>ColumnProperty</code> in queste 2 viste:
<code>Nop.Web\Areas\Admin\Views\Home\_BestsellersBriefReportByAmount.cshtml</code> e 
<code>Nop.Web\Areas\Admin\Views\Home\_BestsellersBriefReportByQuantity.cshtml</code>

==== Vendite - Ordini del Cliente ====
* Nascondere il filtro ''Magazzino'' (aggiungere la classe '''d-none'''), altrimenti un vendor potrebbe vedere le vendite degli altri vendor, vista da modificare <code>Nop.Web\Areas\Admin\Views\Order\List.cshtml</code>.
<syntaxhighlight lang="c#">
<div class="form-group row d-none" @(Model.AvailableWarehouses.SelectionIsNotPossible() ? Html.Raw("style=\"display:none\"") : null)>
   <div class="col-md-4">
     <nop-label asp-for="WarehouseId" />
   </div>
   <div class="col-md-8">
      <nop-select asp-for="WarehouseId" asp-items="Model.AvailableWarehouses" />
   </div>
</div>
</syntaxhighlight>

==== Ordine - dettaglio ====
* Modificare il '''modello''' <code>Nop.Web\Areas\Admin\Models\Orders\OrderItemModel.cs</code> aggiungendo <code>public string ProductSeoName { get; set; }</code>

* '''Factory''' <code>Nop.Web\Areas\Admin\Factories\OrderModelFactory.cs</code> valorizzare il campo ProductSeoName usando la WMCore, nel metodo <code>PrepareOrderItemModelsAsync</code>
<syntaxhighlight lang="c#">
ProductSeoName = _wmcore.WMCore.GetNopProductSeoName(orderItem.ProductId),
</syntaxhighlight>

* Nel box dove sono elencati i prodotti, il link del prodotti rimanderà alla scheda del prodotto nel frontend, mentre solo se siamo Admin entreremo nell'edit del prodotto di NOP [[File:Nop440_ordine_prodotti.PNG|center]] modificare in <code>Nop.Web\Areas\Admin\Views\Order\_OrderDetails.Products.cshtml</code>
** Dobbiamo recuperare il VendorID del dropship di Webmobili: <syntaxhighlight lang="c#">
@inject Nop.Services.Catalog.IProductService prodService;
@inject Microsoft.Extensions.Configuration.IConfiguration configuration;
@{
  int vendorWMDropship = 0;
  int.TryParse(configuration.GetSection("WMApplicationSettings")["DropshipVendorID"], out vendorWMDropship);
}
</syntaxhighlight>
** Controllo se l'utente è un Vendor o Admin <syntaxhighlight lang="c#">
<em>
@if (!Model.IsLoggedInAsVendor) {
  <a asp-controller="Product" asp-action="Edit" asp-route-id="@item.ProductId">@item.ProductName</a>
}else {
  <a href="@Url.RouteUrl("Product", new { SeName = item.ProductSeoName })" target="_blank">@item.ProductName</a>
}</em>
</syntaxhighlight>
** Se il vendorID è quello di Webmobili-dropship mostro il pulsante '''CLONA e ASSEGNA a RIVENDITORE'''.  Attenzione il metodo è cambiato da code>prodService.GetProductById(item.ProductId).VendorId</code> a <code>GetProductByIdAsync</code>: <syntaxhighlight lang="c#">
@{
	var productById = await prodService.GetProductByIdAsync(item.ProductId);
 }
@if (productById != null) {
 if (productById.VendorId == vendorWMDropship) {
  <button type="button" id="setProductToVendor" name="setProductToVendor" class="btn bg-olive" onclick="apriModaleAssegnazione(@item.ProductId,@item.Id,'@item.ProductName','@item.PictureThumbnailUrl');" data-toggle="modal" data-target="#setProductToVendor-window"><i class="fa fa-clone"></i>
CLONA e ASSEGNA a RIVENDITORE</button>
 }
}
</syntaxhighlight>
** Il pulsante '''CLONA e ASSEGNA a RIVENDITORE''' apre un modale in cui selezionare il rivenditore, innanzitutto dobbiamo creare la vista/componente del modale ''ProductToVendorModal'''. <br/>Creiamo il componente in <code>Nop.Web\Areas\Admin\Components\ProductToVendorModal.cs</code> così: <syntaxhighlight lang="c#">
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Nop.Web.Framework.Components;
using Microsoft.Extensions.Configuration;
using Nop.Services.Vendors;

namespace Nop.Web.Areas.Admin.Components {
  public class ProductToVendorModal : NopViewComponent {
    private readonly IVendorService _vendorService;
    private readonly IConfiguration _configuration;

    public ProductToVendorModal(IVendorService vendorService, IConfiguration configuration) {
      _vendorService = vendorService;
      _configuration = configuration;
    }

    public IViewComponentResult Invoke() {
      int dropshippingVendorId = 0;
      int.TryParse(_configuration.GetSection("WMApplicationSettings")["DropshipVendorID"], out dropshippingVendorId);     

      var vendorList = _vendorService.GetAllVendorsAsync().Result
        .Where(c => c.Id != dropshippingVendorId)
        .OrderBy(o => o.Name).ToList();

      return View(vendorList);
    }
  }
}
</syntaxhighlight>
Creiamo la cartella e la vista del componente in <code>Nop.Web\Areas\Admin\Views\Shared\Components\ProductToVendorModal\Default.cshtml</code> così:
<syntaxhighlight lang="c#">
@model List<Nop.Core.Domain.Vendors.Vendor>

<div id="setProductToVendor-window" class="modal fade" tabindex="-1" role="dialog" aria-labelledby="setProductToVendor-window-title">
  <div class="modal-dialog">
    <div class="modal-content">
      <div class="modal-header">
        <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
        <h4 class="modal-title" id="copyproduct-window-title">Seleziona il rivenditore a cui assegnare il prodotto venduto</h4>
      </div>
      <form asp-controller="Order" asp-action="CopyAndSetProductWMtoVendor" method="post">
        <div class="form-horizontal">
          <div class="modal-body">
            <input type="hidden" id="hdnProductId" name="productId" value="" />
            <input type="hidden" id="hdnOrderItemId" name="orderItemId" value="" />
            <div class="media">
              <a class="pull-left" href="#">
                <img id="modalProductToAssignThumb" class="media-object" src="">
              </a>
              <div class="media-body">
                <h4 id="modalProductToAssign" class="media-heading">...</h4>
                <p></p>
              </div>
            </div>
            <hr />
            <div class="form-group">
              <div class="col-md-8 mx-auto">
                <label>Seleziona il rivenditore:</label>
                <select name="vendorId" class="form-control">
                  @foreach (var vendor in Model) {
                    <option value="@vendor.Id">@vendor.Name</option>
                  }
                </select>
              </div>

            </div>
            <hr />
            <div>
              <span>Il prodotto verrà:</span>
              <ul>
                <li>clonato;</li>
                <li>assegnato al rivenditore selezionato;</li>
                <li>segnato come non pubblicato, ma sarà cmq visibile dal pannello di gestione del Rivenditore;</li>
                <li>segnato con quantita' di pezzi a 0 (al prodotto clonato, non all'originale).</li>
              </ul>
            </div>
          </div>
          <div class="modal-footer">
            <button type="submit" class="btn btn-primary">
              CLONA E ASSEGNA IL PRODOTTO
            </button>
          </div>
        </div>
      </form>
    </div>
  </div>
</div>
</syntaxhighlight>

Torniamo nella pagina contenitore di dettaglio dell'ordine in <code>Nop.Web\Areas\Admin\Views\Order\Edit.cshtml</code> e inseriamo al fondo la chiamata al nostro component modale appena creato con questa riga di codice:
<syntaxhighlight lang="c#">
@*Modal product to Vendor*@
@await Component.InvokeAsync("ProductToVendorModal")
</syntaxhighlight>

Aggiungere il seguente script:
<syntaxhighlight lang="c#">
function apriModaleAssegnazione(idProduct, idOrderitem, productName, imgThumb) {
  $('#hdnProductId').val(idProduct);
  $('#hdnOrderItemId').val(idOrderitem);
  $('#modalProductToAssign').text(productName);
  $('#modalProductToAssignThumb').attr('src', imgThumb);
}
</syntaxhighlight>

* '''ERRORI'''
<blockquote>
Durante il test di acquisto di prodotto DesignbestShop, in fase di selezione della spedizione 
non ci sono opzioni e rimane lì e non avanza, probabilmente per assenza plugin spedizione.
</blockquote>


=== Update dei MessageTokens ===
Nel <code style="color:red;font-weight:bold;">Libraries\Nop.Services\Messages\MessageTokeProvider.cs</code> aggiungere i riferimenti ai servizi
* IVendorService
* IConfiguration

Nella property '''AllowedTokens''' aggiungere al fondo ''%Order.VendorDetail(s)%'' <syntaxhighlight lang="c#"> //order tokens
_allowedTokens.Add(TokenGroupNames.OrderTokens, new[]
{
	"%Order.OrderNumber%",
	"%Order.CustomerFullName%",
	"%Order.CustomerEmail%",
	"%Order.BillingFirstName%",
	"%Order.BillingLastName%",
	"%Order.BillingPhoneNumber%",
	"%Order.BillingEmail%",
	"%Order.BillingFaxNumber%",
	"%Order.BillingCompany%",
	"%Order.BillingAddress1%",
	"%Order.BillingAddress2%",
	"%Order.BillingCity%",
	"%Order.BillingCounty%",
	"%Order.BillingStateProvince%",
	"%Order.BillingZipPostalCode%",
	"%Order.BillingCountry%",
	"%Order.BillingCustomAttributes%",
	"%Order.Shippable%",
	"%Order.ShippingMethod%",
	"%Order.ShippingFirstName%",
	"%Order.ShippingLastName%",
	"%Order.ShippingPhoneNumber%",
	"%Order.ShippingEmail%",
	"%Order.ShippingFaxNumber%",
	"%Order.ShippingCompany%",
	"%Order.ShippingAddress1%",
	"%Order.ShippingAddress2%",
	"%Order.ShippingCity%",
	"%Order.ShippingCounty%",
	"%Order.ShippingStateProvince%",
	"%Order.ShippingZipPostalCode%",
	"%Order.ShippingCountry%",
	"%Order.ShippingCustomAttributes%",
	"%Order.PaymentMethod%",
	"%Order.VatNumber%",
	"%Order.CustomValues%",
	"%Order.Product(s)%",
	"%Order.CreatedOn%",
	"%Order.OrderURLForCustomer%",
	"%Order.PickupInStore%",
	"%Order.OrderId%",
	"%Order.VendorDetail(s)%" // custom token by Webmobili
});</syntaxhighlight>

Nel metodo '''AdOrderTokensAsync''' aggiungere la riga <syntaxhighlight lang="c#">tokens.Add(new Token("Order.VendorDetail(s)", await VendorDetailsAsync(order, languageId), true)); // custom token by Webmobili</syntaxhighlight>

E creare tutto il metodo '''VendorDetailsAsync''' <syntaxhighlight lang="c#">/// <summary>
/// Custom by Webmobili
/// </summary>
/// <param name="order"></param>
/// <param name="languageId"></param>
/// <returns></returns>
protected virtual async Task<string> VendorDetailsAsync(Order order, int languageId) {
	//if (vendorId == 0) return "";

	var sb = new StringBuilder();
	// intestazioni
	sb.AppendLine("<table border=\"0\" style=\"width:100%;\">");
	sb.AppendLine($"<tr style=\"background-color:{_templatesSettings.Color1};text-align:center;\">");
	sb.AppendLine($"<th>Prodotto</th>");
	sb.AppendLine($"<th>Negozio</th>");
	sb.AppendLine("</tr>");

	int vendorWMDropship = 0;
	int.TryParse(_configurationService.GetSection("WMApplicationSettings")["DropshipVendorID"], out vendorWMDropship);

	var orderItems = await _orderService.GetOrderItemsAsync(order.Id);
	foreach (var ord in orderItems) {
		sb.AppendLine($"<tr style=\"background-color: {_templatesSettings.Color2};text-align: center;\">");

		var product = await _productService.GetProductByIdAsync(ord.ProductId);
		var vendor = await _vendorService.GetVendorByIdAsync(product.VendorId);
		var address = await _addressService.GetAddressByIdAsync(vendor.AddressId);
		var stateProvince = await _stateProvinceService.GetStateProvinceByIdAsync(address.StateProvinceId.Value);
		sb.AppendLine($"<td style=\"padding: 0.6em 0.4em;text-align: left;\">{product.Name}</td>");
		if (vendorWMDropship != vendor.Id) {
			sb.AppendLine($"<td style=\"padding: 0.6em 0.4em;text-align: left;\">{vendor.Name} - {address.Address1}, {address.City} ({stateProvince.Abbreviation})<br/>Email: <a href=\"mailto:{vendor.Email}\">{vendor.Email}</a> \t Telefono: {address.PhoneNumber}</td>");
		}
		else {
			sb.AppendLine($"<td style=\"padding: 0.6em 0.4em;text-align: left;\">{vendor.Name}, a breve riceverai l'informazione del negozio di riferimento per il tuo ordine.<br/>Email: <a href=\"mailto:{vendor.Email}\">{vendor.Email}</a> \t Telefono: {address.PhoneNumber}</td>");
		}

		sb.AppendLine("</tr>");
	}
	sb.AppendLine("</table>");
	return sb.ToString();
}

#endregion</syntaxhighlight>

Nella '''WriteTotalsAsync''' aggiungere il parametro opzionale ''int vendorId = 0'' e una region iniziale <syntaxhighlight lang="c#">protected virtual async Task WriteTotalsAsync(Order order, Language language, StringBuilder sb, int vendorId = 0) {
	#region Costi spedizione per negozio
	if (vendorId != 0) {
		order.OrderSubtotalInclTax = 0;
		order.OrderSubtotalExclTax = 0;
		order.OrderShippingInclTax = 0; // azzero perché lo calcolo parziale per il vendor selezionato
		order.OrderShippingExclTax = 0;
		order.OrderTotal = 0;
		var orderItems = await _orderService.GetOrderItemsAsync(order.Id);
		foreach (var ord in orderItems) {
			var product = await _productService.GetProductByIdAsync(ord.ProductId);
			if (product.VendorId == vendorId) {
				if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax) {
					order.OrderSubtotalInclTax += (product.Price * ord.Quantity);
					order.OrderShippingInclTax += product.AdditionalShippingCharge;
				}
				else {
					order.OrderSubtotalExclTax += (product.Price * ord.Quantity);
					order.OrderShippingExclTax += product.AdditionalShippingCharge;
				}
				order.OrderTotal += (product.Price * ord.Quantity) + product.AdditionalShippingCharge;
			}
		}
	}
	#endregion
	//...</syntaxhighlight>

Nella '''ProductListToHtmlTableAsync(Order order, int languageId, int vendorId)''' modificare la chiamata alla '''WriteTotalAsync''' passando anche il ''vendorId''. Togliere ''if(vendorId == 0)'' come di seguito <syntaxhighlight lang="c#">//if (vendorId == 0)
//{
//we render checkout attributes and totals only for store owners (hide for vendors)

if (!string.IsNullOrEmpty(order.CheckoutAttributeDescription)) {
	sb.AppendLine("<tr><td style=\"text-align:right;\" colspan=\"1\">&nbsp;</td><td colspan=\"3\" style=\"text-align:right\">");
	sb.AppendLine(order.CheckoutAttributeDescription);
	sb.AppendLine("</td></tr>");
}

//totals
await WriteTotalsAsync(order, language, sb, vendorId);
//}
// ....</syntaxhighlight>

=== Aggiunta di un nuovo MessageTemplate ===
Con il '''dropshipping''' si rende necessario aggiungere un nuovo template di messaggi.

In <code style="color:red;font-weight:bold">Libraries\Nop.Core\Domain\Messages\MessageTemplateSystemNames.cs</code> aggiungere il nuovo nome (dopo ''OrderPaidCustomerNotification'') <syntaxhighlight lang="c#">#region Webmobili
/// <summary>
/// Represents system name of notification customer about paid order after a dropshipping sale.
/// </summary>
public const string OrderPaidDropshipCustomerNotification = "OrderPaid.DropShipCustomerNotification";
#endregion
</syntaxhighlight>

Per creare la logica di spedizione, prima aggiungiamo il metodo nell'interfaccia in <code style="color:red;font-weight:bold">Libraries\Nop.Services\Messages\IWorkflowMessageService.cs</code> (dopo ''SendOrderPaidCustomerNotification'') <syntaxhighlight lang="c#">#region WEBMOBILI
/// <summary>
/// Sends an order paid notification to a customer after a dropshipping sale.
/// </summary>
/// <param name="order">Order instance</param>
/// <param name="languageId">Message language identifier</param>
/// <param name="attachmentFilePath">Attachment file path</param>
/// <param name="attachmentFileName">Attachment file name. If specified, then this file name will be sent to a recipient. Otherwise, "AttachmentFilePath" name will be used.</param>
/// <returns>Queued email identifier</returns>
Task<IList<int>> SendOrderPaidDropshipCustomerNotificationAsync(Order order, int languageId,
			 string attachmentFilePath = null, string attachmentFileName = null);
#endregion</syntaxhighlight>

e l'implementazione in <code style="color:red;font-weight:bold">Libraries\Nop.Services\Messages\WorkflowMessageService.cs</code> <syntaxhighlight lang="c#">
    #region WEBMOBILI
    public virtual async Task<IList<int>> SendOrderPaidDropshipCustomerNotificationAsync(Order order, int languageId,
      string attachmentFilePath = null, string attachmentFileName = null) {
      if (order == null)
        throw new ArgumentNullException(nameof(order));

      var store = await _storeService.GetStoreByIdAsync(order.StoreId) ?? _storeContext.GetCurrentStore();
      languageId = await EnsureLanguageIsActiveAsync(languageId, store.Id);

      var messageTemplates = await GetActiveMessageTemplatesAsync(MessageTemplateSystemNames.OrderPaidDropshipCustomerNotification, store.Id);
      if (!messageTemplates.Any())
        return new List<int>();

      //tokens
      var commonTokens = new List<Token>();
      await _messageTokenProvider.AddOrderTokensAsync(commonTokens, order, languageId);
      await _messageTokenProvider.AddCustomerTokensAsync(commonTokens, order.CustomerId);

      return await messageTemplates.SelectAwait( async messageTemplate =>
      {
        //email account
        var emailAccount = await GetEmailAccountOfMessageTemplateAsync(messageTemplate, languageId);

        var tokens = new List<Token>(commonTokens);
        await _messageTokenProvider.AddStoreTokensAsync(tokens, store, emailAccount);

        //event notification
        await _eventPublisher.MessageTokensAddedAsync(messageTemplate, tokens);

        var billingAddress = await _addressService.GetAddressByIdAsync(order.BillingAddressId);

        var toEmail = billingAddress.Email;
        var toName = $"{billingAddress.FirstName} {billingAddress.LastName}";

        return await SendNotificationAsync(messageTemplate, emailAccount, languageId, tokens, toEmail, toName, attachmentFilePath, attachmentFileName);
      }).ToListAsync();
    }

    #endregion
</syntaxhighlight>

A questo punto è necessario aggiungere via SQL il messaggio (comprensivo di token) alla tabella '''MessageTemplate''' <syntaxhighlight lang="sql">INSERT INTO [MessageTemplate]([Name],[BccEmailAddresses],[Subject],[Body],[IsActive],[DelayBeforeSend],[DelayPeriodId],[AttachedDownloadId],[EmailAccountId],[LimitedToStores])
VALUES ('OrderPaid.DropShipCustomerNotification',NULL,'%Store.Name% | Pagamento effettuato per l''ordine #%Order.OrderNumber%','Compilare il BODY',1,NULL,0,0,1,0)</syntaxhighlight>

'''Lato admin''' è necessario modificare il controller <code>Presentation\Nop.Web\Areas\Admin\Controllers\OrderController.cs</code> in modo che chiami la nuova funzione quando necessario.
Aggiungere i seguenti Services:
* ICopyProductService
* IVendorService
* LocalizationSettings
Dopo il metodo(AddProductToOrderDetails), aggiungere:
<syntaxhighlight lang="c#">
#region DROPSHIPPING

    public virtual async Task<IActionResult> CopyAndSetProductWMtoVendor(int productId, int vendorId, int orderItemId) {

      if (!await _permissionService.AuthorizeAsync(StandardPermissionProvider.ManageProducts))
        return AccessDeniedView();
      var orderId = 0;
      //var copyModel = new CopyProductModel { CopyImages = true, Published = false, Name = "prodotto_" + productId }; //model.CopyProductModel;
      try {
        var originalProduct = await _productService.GetProductByIdAsync(productId);

        // Clonazione prodotto dell'ordine              

        var newProduct = await _copyProductService.CopyProductAsync(originalProduct, originalProduct.Name, false,
#if DEBUG
                  false
#else
                  true
#endif
                  ); // false = publish, true = copyImages

        newProduct.Sku = originalProduct.Sku + "-" + newProduct.Id;   // nuovo SKU con presiffo del prodotto originale
        newProduct.Name = originalProduct.Name + " #";
        newProduct.StockQuantity = 0;
        newProduct.VisibleIndividually = true;
        newProduct.VendorId = vendorId; // aggiorniamo il Vendor a quello scelto dalla tendina
        await _productService.UpdateProductAsync(newProduct);

        // Recuperiamo i dettagli del OrderItem in cui si trova il prodotto da clonare
        var tmpOrderItem = await _orderService.GetOrderItemByIdAsync(orderItemId);

        tmpOrderItem.ProductId = newProduct.Id; // IMPORTANTE!!! aggiornare il productId dell' orderitem con il productId del nuovo prodotto clonato
        await _orderService.UpdateOrderItemAsync(tmpOrderItem);

        orderId = tmpOrderItem.OrderId;

        // INVIO EMAIL ORDINE AL RIVENDITORE              
        Order currentOrder = await _orderService.GetOrderByOrderItemAsync(orderItemId);
        Vendor newVendor = await _vendorService.GetVendorByIdAsync(vendorId);

        // Controllo se ordine è già stato pagato tramite Paypal o Stripe
        // In base a questo decido il template della mail

        switch (currentOrder.PaymentMethodSystemName) {

          case "Payments.CheckMoneyOrder":
            await _workflowMessageService.SendOrderPlacedVendorNotificationAsync(currentOrder, newVendor, _localizationSettings.DefaultAdminLanguageId);
            break;

          case "FoxNetSoft.StripeDirect":
          case "Payments.PayPalSmartPaymentButtons":
            await _workflowMessageService.SendOrderPaidVendorNotificationAsync(currentOrder, newVendor, _localizationSettings.DefaultAdminLanguageId);
            await _workflowMessageService.SendOrderPaidDropshipCustomerNotificationAsync(currentOrder, _localizationSettings.DefaultAdminLanguageId);
            break;

        }

      }
      catch (Exception exc) {
        _notificationService.ErrorNotification(exc.Message);
      }

      return RedirectToAction("Edit", "Order", new { id = orderId });

    }

    #endregion
</syntaxhighlight>


== Installare Plugin ==
Il nuovo tema è '''Pacific'''<br/>
Per installare seguire questo ordine updatando il file <code>Presentation\Nop.Web\App_Data\Plugins.json</code>
* Installare '''7Spikes Core''' <syntaxhighlight lang="json">"PluginNamesToInstall": [
    {
      "Item1": "SevenSpikes.Core",
      "Item2": "277c962d-b286-4311-b2a7-9b2ff68bb7ac"
    }
  ]</syntaxhighlight> (il guid è generato casualmente)