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ů.
- Návody pro vývojáře
- Aktualizace existující entity. Jak přidat novou vlastnost.
- Jak napsat plugin pro nopCommerce 5.00
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 });
}
}