Plugin s přístupem k datům (4.20 a starší)
V tomto návodu použiji architekturu pluginů nopCommerce k implementaci sledování zobrazení produktů. Než se pustíme do vývoje, je velmi důležité, abyste si přečetli, pochopili a úspěšně dokončili 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 4.20
Začneme programovat vrstvou pro přístup k datům, přesuneme se na servisní vrstvu a nakonec skončíme u vkládání závislostí (dependency injection).
Poznámka
Praktické využití tohoto pluginu je sporné, ale nenapadla mě žádná funkce, která by nebyla součástí nopCommerce a vešla by se do článku rozumné délky. Pokud tento plugin použijete v produkčním prostředí, neposkytuji žádné záruky. Vždy mě zajímají příběhy úspěchu a rád uslyším, že článek přinesl více než jen vzdělávací hodnotu.
Začínáme
Vytvořte nový projekt knihovny tříd „Nop.Plugin.Other.ProductViewTracker“.

Přidejte následující složky a soubor plugin.json.

Informace o souboru plugin.json naleznete v článku Soubor plugin.json.
Poté přidejte reference na následující projekty: Nop.Core, Nop.Data, Nop.Web.Framework
Vrstva pro přístup k datům (neboli vytváření nových entit v nopCommerce)
V jmenném prostoru „domain“ vytvoříme veřejnou třídu s názvem ProductViewTrackerRecord. Tato třída rozšiřuje BaseEntity, jinak je to ale velmi nezáživný soubor. Je třeba si zapamatovat, že všechny vlastnosti jsou označeny jako virtual, a není to jen pro zábavu. Virtuální vlastnosti jsou u databázových entit vyžadovány kvůli tomu, jak Entity Framework vytváří instance tříd a sleduje je. Další věcí, které je třeba si všimnout, je, že nemáme navigační vlastnosti (relační vlastnosti); těm se podrobněji budu věnovat později.
namespace Nop.Plugin.Other.ProductViewTracker.Domain
{
public class ProductViewTrackerRecord : BaseEntity
{
public virtual int ProductId { get; set; }
public virtual string ProductName { get; set; }
public virtual int CustomerId { get; set; }
public virtual string IpAddress { get; set; }
public virtual bool IsRegistered { get; set; }
}
}
Umístění souborů: Chcete-li zjistit, kde mají jednotlivé soubory být, prozkoumejte jmenný prostor a soubor podle něj vytvořte.
Další třídou, kterou vytvoříme, je mapovací třída Entity Framework. V mapovací třídě mapujeme sloupce, vztahy mezi tabulkami a databázovou tabulku.
namespace Nop.Plugin.Other.ProductViewTracker.Data
{
public class ProductViewTrackerRecordMap : NopEntityTypeConfiguration<ProductViewTrackerRecord>
{
/// <summary>
/// Configures the entity
/// </summary>
/// <param name="builder">The builder to be used to configure the entity</param>
public override void Configure(EntityTypeBuilder<ProductViewTrackerRecord> builder)
{
builder.ToTable(nameof(ProductViewTrackerRecord));
//Map the primary key
builder.HasKey(record => record.Id);
//Map the additional properties
builder.Property(record => record.ProductId);
//Avoiding truncation/failure
//so we set the same max length used in the product tame
builder.Property(record => record.ProductName).HasMaxLength(400);
builder.Property(record => record.IpAddress);
builder.Property(record => record.CustomerId);
builder.Property(record => record.IsRegistered);
}
}
}
Následující třída je nejsložitější a nejdůležitější třídou ve vrstvě pro přístup k datům. Objektový kontext Entity Framework je průchozí třída, která nám poskytuje přístup k databázi a pomáhá sledovat stav entit (např. přidání, aktualizace, odstranění). Kontext se také používá ke generování databázového schématu nebo k aktualizaci existujícího schématu. Ve vlastních třídách kontextu nemůžeme odkazovat na dříve existující entity, protože tyto typy jsou již přidruženy k jinému objektovému kontextu. To je také důvod, proč v našem sledovacím záznamu nemáme složité navigační vlastnosti.
namespace Nop.Plugin.Other.ProductViewTracker.Data
{
public class ProductViewTrackerRecordObjectContext : DbContext, IDbContext
{
public ProductViewTrackerRecordObjectContext(DbContextOptions<ProductViewTrackerRecordObjectContext> options) : base(options)
{
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.ApplyConfiguration(new ProductViewTrackerRecordMap());
base.OnModelCreating(modelBuilder);
}
public new virtual DbSet<TEntity> Set<TEntity>() where TEntity : BaseEntity
{
return base.Set<TEntity>();
}
public virtual string GenerateCreateScript()
{
return Database.GenerateCreateScript();
}
public virtual IQueryable<TQuery> QueryFromSql<TQuery>(string sql) where TQuery : class
{
throw new NotImplementedException();
}
public virtual IQueryable<TEntity> EntityFromSql<TEntity>(string sql, params object[] parameters) where TEntity : BaseEntity
{
throw new NotImplementedException();
}
public virtual int ExecuteSqlCommand(RawSqlString sql, bool doNotEnsureTransaction = false, int? timeout = null, params object[] parameters)
{
using (var transaction = Database.BeginTransaction())
{
var result = Database.ExecuteSqlCommand(sql, parameters);
transaction.Commit();
return result;
}
}
public void Install()
{
//create the table
this.ExecuteSqlScript(GenerateCreateScript());
}
public void Uninstall()
{
//drop the table
this.DropPluginTable(nameof(ProductViewTrackerRecord));
}
public IList<TEntity> ExecuteStoredProcedureList<TEntity>(string commandText, params object[] parameters) where TEntity : BaseEntity, new()
{
throw new NotImplementedException();
}
public IEnumerable<TElement> SqlQuery<TElement>(string sql, params object[] parameters)
{
throw new NotImplementedException();
}
public int ExecuteSqlCommand(string sql, bool doNotEnsureTransaction = false, int? timeout = null, params object[] parameters)
{
throw new NotImplementedException();
}
public virtual void Detach<TEntity>(TEntity entity) where TEntity : BaseEntity
{
throw new NotImplementedException();
}
public IQueryable<TQuery> QueryFromSql<TQuery>(string sql, params object[] parameters) where TQuery : class
{
throw new NotImplementedException();
}
public virtual bool ProxyCreationEnabled
{
get => ProxyCreationEnabled;
set => ProxyCreationEnabled = value;
}
public virtual bool AutoDetectChangesEnabled
{
get => AutoDetectChangesEnabled;
set => AutoDetectChangesEnabled = value;
}
}
}
Spuštění aplikace
Tato část registruje objektový kontext záznamu, který jsme vytvořili v předchozím kroku.
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Nop.Core.Infrastructure;
using Nop.Plugin.Other.ProductViewTracker.Data;
using Nop.Web.Framework.Infrastructure.Extensions;
namespace Nop.Plugin.Misc.RepCred.Infrastructure
{
/// <summary>
/// Represents object for the configuring plugin DB context on application startup
/// </summary>
public class PluginDbStartup : 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)
{
//add object context
services.AddDbContext<ProductViewTrackerRecordObjectContext>(optionsBuilder =>
{
optionsBuilder.UseSqlServerWithLazyLoading(services);
});
}
/// <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 => 11;
}
}
Servisní vrstva
Servisní vrstva propojuje vrstvu pro přístup k datům a prezentační vrstvu. Protože sdílet v kódu jakýkoli typ odpovědnosti je špatný zvyk, musí být každá vrstva izolovaná. Servisní vrstva obaluje datovou vrstvu obchodní logikou a prezentační vrstva závisí na servisní vrstvě. Protože je náš úkol velmi malý, naše servisní vrstva nedělá nic jiného, než že komunikuje s repozitářem (repozitář v nopCommerce funguje jako fasáda objektového kontextu).
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.Other.ProductViewTracker.Services
{
public class ProductViewTrackerService : IProductViewTrackerService
{
private readonly IRepository<ProductViewTrackerRecord> _productViewTrackerRecordRepository;
public ViewTrackingService(IRepository<ProductViewTrackingRecord> 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í (Dependency Injection)
Martin Fowler napsal skvělý popis vkládání závislostí neboli obrácení ří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 používat závislé objekty. Nejprve musíme nakonfigurovat kontejner závislostí, aby věděl, které objekty bude řídit a jaká pravidla se mohou vztahovat na vytváření těchto objektů.
namespace Nop.Plugin.Other.ProductViewTracker.Infrastructure
{
public class DependencyRegistrar : IDependencyRegistrar
{
private const string CONTEXT_NAME = "nop_object_context_product_view_tracker";
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder, NopConfig config)
{
builder.RegisterType<ProductViewTrackerService>().As<IProductViewTrackerService>().InstancePerLifetimeScope();
//data context
builder.RegisterPluginDataContext<ProductViewTrackerRecordObjectContext>(CONTEXT_NAME);
//override required repository with our custom context
builder.RegisterType<EfRepository<ProductViewTrackerRecord>>()
.As<IRepository<ProductViewTrackerRecord>>()
.WithParameter(ResolvedParameter.ForNamed<IDbContext>(CONTEXT_NAME))
.InstancePerLifetimeScope();
}
public int Order => 1;
}
}
Ve výše uvedeném kódu registrujeme různé typy objektů, aby je bylo možné později vložit do controllerů, služeb a repozitářů. Nyní, když jsme probrali nová témata, se vrátím k některým starším, abychom mohli plugin dokončit.
Komponenta view
Vytvořme komponentu view (view component):
namespace Nop.Plugin.Other.ProductViewTracker.Components
{
[ViewComponent(Name = "ProductViewTracker")]
public class ProductViewTrackerViewComponent : NopViewComponent
{
private readonly IProductService _productService;
private readonly IProductViewTrackerService _productViewTrackerService;
private readonly IWorkContext _workContext;
public ProductViewTrackerViewComponent(IWorkContext workContext,
IProductViewTrackerService productViewTrackerService,
IProductService productService)
{
_workContext = workContext;
_productViewTrackerService = productViewTrackerService;
_productService = productService;
}
public IViewComponentResult Invoke(int productId)
{
//Read from the product service
Product productById = _productService.GetProductById(productId);
//If the product exists we will log it
if (productById != null)
{
//Setup the product to save
var record = new ProductViewTrackerRecord();
record.ProductId = productId;
record.ProductName = productById.Name;
record.CustomerId = _workContext.CurrentCustomer.Id;
record.IpAddress = _workContext.CurrentCustomer.LastIpAddress;
record.IsRegistered = _workContext.CurrentCustomer.IsRegistered();
//Map the values we're interested in to our new entity
_productViewTrackerService.Log(record);
}
return Content("");
}
}
}
Instalátor pluginu
namespace Nop.Plugin.Other.ProductViewTracker
{
public class ProductViewTrackerPlugin : BasePlugin
{
private readonly ProductViewTrackerRecordObjectContext _context;
public ProductViewTrackerPlugin(ProductViewTrackerRecordObjectContext context)
{
_context = context;
}
public override void Install()
{
_context.Install();
base.Install();
}
public override void Uninstall()
{
_context.Uninstall();
base.Uninstall();
}
}
}
Použití
Sledovací kód je třeba přidat do souborů ProductTemplate.Simple.cshtml a ProductTemplate.Grouped.cshtml. Jde o šablony produktů.
@await Component.InvokeAsync("ProductViewTrackerIndex", new { productId = Model.Id })
P.S. Můžete jej implementovat také jako widget. V takovém případě nebudete muset upravovat soubor cshtml.