nopCommerce Dokumentace

Plugin s přístupem k datům

V tomto návodu použiji architekturu pluginů nopCommerce k implementaci sledování zobrazení produktů. Než začneme s vývojem, musíte si přečíst, pochopit a dokončit níže uvedené návody. Některá vysvětlení, která byla probrána v předchozích článcích, přeskočím, ale můžete si je zopakovat pomocí uvedených odkazů.

Začneme psát kód vrstvou přístupu k datům, přejdeme k vrstvě služeb a nakonec skončíme u vkládání závislostí (dependency injection).

Začínáme

Vytvořte nový projekt knihovny tříd „Nop.Plugin.Misc.ProductViewTracker“.

Přidejte soubor plugin.json.

Tip

Informace o souboru plugin.json naleznete v článku Soubor plugin.json.

Poté přidejte reference na projekty Nop.Web.Framework. To nám bude stačit, protože ostatní závislosti, jako Nop.Core a Nop.Data, budou připojeny automaticky

Vrstva přístupu k datům (neboli vytváření nových entit v nopCommerce)

Uvnitř jmenného prostoru „domain“ vytvoříme veřejnou třídu s názvem ProductViewTrackerRecord. Tato třída rozšiřuje BaseEntity, jinak je to ale velmi jednoduchý soubor. Je třeba si zapamatovat, že nemáme navigační vlastnosti (relační vlastnosti), protože framework Linq2DB, který používáme pro práci s databázemi, navigační vlastnosti nepodporuje.

namespace Nop.Plugin.Misc.ProductViewTracker.Domain

public class ProductViewTrackerRecord : BaseEntity
{
    public int ProductId { get; set; }
    public string ProductName { get; set; }
    public int CustomerId { get; set; }
    public string IpAddress { get; set; }
    public bool IsRegistered { get; set; }
}

Další třídou, kterou vytvoříme, je třída builderu entity pro FluentMigrator. V mapovací třídě mapujeme sloupce, vztahy mezi tabulkami a databázovou tabulku.

using FluentMigrator.Builders.Create.Table;
using Nop.Core.Domain.Catalog;
using Nop.Core.Domain.Customers;
using Nop.Data.Mapping.Builders;
using Nop.Plugin.Other.ProductViewTracker.Domains;
using Nop.Data.Extensions;
using System.Data;

namespace Nop.Plugin.Other.ProductViewTracker.Mapping.Builders

public class ProductViewTrackerRecordBuilder : NopEntityBuilder<ProductViewTrackerRecord>
{
    /// <summary>
    /// Apply entity configuration
    /// </summary>
    /// <param name="table">Create table expression builder</param>
    public override void MapEntity(CreateTableExpressionBuilder table)
    {
        //map the primary key (not necessary if it is Id field)
        table.WithColumn(nameof(ProductViewTrackerRecord.Id)).AsInt32().PrimaryKey()
        //map the additional properties as foreign keys
        .WithColumn(nameof(ProductViewTrackerRecord.ProductId)).AsInt32().ForeignKey<Product>(onDelete: Rule.Cascade)
        .WithColumn(nameof(ProductViewTrackerRecord.CustomerId)).AsInt32().ForeignKey<Customer>(onDelete: Rule.Cascade)
        //avoiding truncation/failure
        //so we set the same max length used in the product name
        .WithColumn(nameof(ProductViewTrackerRecord.ProductName)).AsString(400)
        //not necessary if we don't specify any rules
        .WithColumn(nameof(ProductViewTrackerRecord.IpAddress)).AsString()
        .WithColumn(nameof(ProductViewTrackerRecord.IsRegistered)).AsInt32();
    }
}

Další důležitou třídou pro nás bude třída migrace, která vytvoří naši tabulku přímo v databázi. Ve svém pluginu můžete vytvořit libovolný počet migrací, jediné, co musíte sledovat, je verze vaší migrace. Speciálně pro vás jsme vytvořili atribut NopMigration, aby to bylo snazší. Uvedením co nejúplnějšího a nejpřesnějšího data vytvoření souboru prakticky zaručíte jedinečnost čísla vaší migrace.

using FluentMigrator;
using Nop.Data.Extensions;
using Nop.Data.Migrations;
using Nop.Plugin.Other.ProductViewTracker.Domains;

namespace Nop.Plugin.Other.ProductViewTracker.Migrations

[NopSchemaMigration("2020-05-27 08:40:55:1687541", "Other.ProductViewTracker base schema", MigrationProcessType.Installation)]
public class SchemaMigration : ForwardOnlyMigration
{
    public override void Up()
    {
        Create.TableFor<ProductViewTrackerRecord>();            
    }
}

Vrstva služeb

Vrstva služeb propojuje vrstvu přístupu k datům a prezentační vrstvu. Protože sdílení jakéhokoli typu odpovědnosti v kódu je špatný postup, musí být každá vrstva izolovaná. Vrstva služeb obaluje datovou vrstvu obchodní logikou a prezentační vrstva závisí na vrstvě služeb. Protože je náš úkol velmi malý, naše vrstva služeb nedělá nic jiného, než že komunikuje s repozitářem (repozitář v nopCommerce funguje jako fasáda pro kontext objektů).

using Nop.Data;
using Nop.Plugin.Other.ProductViewTracker.Domains;
using System;

namespace Nop.Plugin.Other.ProductViewTracker.Services

public interface IProductViewTrackerService
{
    /// <summary>
    /// Logs the specified record.
    /// </summary>
    /// <param name="record">The record.</param>
    void Log(ProductViewTrackerRecord record);
}


namespace Nop.Plugin.Misc.ProductViewTracker.Services

public class ProductViewTrackerService : IProductViewTrackerService
{
    private readonly IRepository<ProductViewTrackerRecord> _productViewTrackerRecordRepository;
    public ProductViewTrackerService(IRepository<ProductViewTrackerRecord> productViewTrackerRecordRepository)
    {
        _productViewTrackerRecordRepository = productViewTrackerRecordRepository;
    }
    /// <summary>
    /// Logs the specified record.
    /// </summary>
    /// <param name="record">The record.</param>
    public virtual void Log(ProductViewTrackerRecord record)
    {
        if (record == null)
            throw new ArgumentNullException(nameof(record));
        _productViewTrackerRecordRepository.Insert(record);
    }
}

Vkládání závislostí

Martin Fowler napsal skvělý popis vkládání závislostí neboli inverze řízení (Inversion of Control). Nebudu jeho práci opakovat; jeho článek najdete zde. Vkládání závislostí spravuje životní cyklus objektů a poskytuje instance, které mohou závislé objekty používat. Nejprve musíme nakonfigurovat kontejner závislostí, aby věděl, které objekty bude řídit a jaká pravidla se mohou uplatnit při vytváření těchto objektů.

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Nop.Core.Infrastructure;
using Nop.Plugin.Other.ProductViewTracker.Services;

namespace Nop.Plugin.Other.ProductViewTracker.Infrastructure

/// <summary>
/// Represents object for the configuring services on application startup
/// </summary>
public class NopStartup : INopStartup
{
    /// <summary>
    /// Add and configure any of the middleware
    /// </summary>
    /// <param name="services">Collection of service descriptors</param>
    /// <param name="configuration">Configuration of the application</param>
    public void ConfigureServices(IServiceCollection services, IConfiguration configuration)
    {
        services.AddScoped<IProductViewTrackerService, ProductViewTrackerService>();
    }
    /// <summary>
    /// Configure the using of added middleware
    /// </summary>
    /// <param name="application">Builder for configuring an application's request pipeline</param>
    public void Configure(IApplicationBuilder application)
    {
    }
    /// <summary>
    /// Gets order of this startup configuration implementation
    /// </summary>
    public int Order => 3000;
}

Ve výše uvedeném kódu registrujeme různé typy objektů, aby je bylo později možné vkládat do controllerů, služeb a repozitářů. Nyní, když jsme probrali nová témata, vrátím se k některým starším, abychom mohli plugin dokončit.

Komponenta view

Vytvořme komponentu view (view component):

using Microsoft.AspNetCore.Mvc;
using Nop.Core;
using Nop.Plugin.Other.ProductViewTracker.Domains;
using Nop.Plugin.Other.ProductViewTracker.Services;
using Nop.Services.Catalog;
using Nop.Services.Customers;
using Nop.Web.Framework.Components;
using Nop.Web.Models.Catalog;

namespace Nop.Plugin.Other.ProductViewTracker.Components

public class ProductViewTrackerViewComponent : NopViewComponent
{
    private readonly ICustomerService _customerService;
    private readonly IProductService _productService;
    private readonly IProductViewTrackerService _productViewTrackerService;
    private readonly IWorkContext _workContext;
    public ProductViewTrackerViewComponent(ICustomerService customerService,
        IProductService productService,
        IProductViewTrackerService productViewTrackerService,
        IWorkContext workContext)
    {
        _customerService = customerService;
        _productService = productService;
        _productViewTrackerService = productViewTrackerService;
        _workContext = workContext;
    }
    public async Task<IViewComponentResult> InvokeAsync(string widgetZone, object additionalData)
    {
        if (!(additionalData is ProductDetailsModel model))
            return Content("");
        //Read from the product service
        var productById = await _productService.GetProductByIdAsync(model.Id);
        //If the product exists we will log it
        if (productById != null)
        {
            var currentCustomer = await _workContext.CurrentCustomerAsync();
            //Setup the product to save
            var record = new ProductViewTrackerRecord
            {
                ProductId = model.Id,
                ProductName = productById.Name,
                CustomerId = currentCustomer.Id,
                IpAddress = currentCustomer.LastIpAddress,
                IsRegistered = await _customerService.Async(currentCustomer)
            };
            //Map the values we're interested in to our new entity
            _productViewTrackerService.Log(record);
        }
        return Content("");
    }
}

Hlavní třída pluginu

Důležité

Náš plugin implementujeme jako widget. V tomto případě nebudeme muset upravovat soubor cshtml.

using Nop.Services.Cms;
using Nop.Services.Plugins;
using Nop.Web.Framework.Infrastructure;
using System.Collections.Generic;

namespace Nop.Plugin.Other.ProductViewTracker

public class ProductViewTrackerPlugin : BasePlugin, IWidgetPlugin
{
    /// <summary>
    /// Gets a value indicating whether to hide this plugin on the widget list page in the admin area
    /// </summary>
    public bool HideInWidgetList => true;
    /// <summary>
    /// Gets a type of a view component for displaying widget
    /// </summary>
    /// <param name="widgetZone">Name of the widget zone</param>
    /// <returns>View component type</returns>
    public Type GetWidgetViewComponent(string widgetZone)
    {
        return typeof(ProductViewTrackerViewComponent);
    }
    /// <summary>
    /// Gets widget zones where this widget should be rendered
    /// </summary>
    /// <returns>Widget zones</returns>
    public Task<IList<string>> GetWidgetZonesAsync()
    {
        return Task.FromResult<IList<string>>(new List<string> { PublicWidgetZones.ProductDetailsTop });
    }
}