Publish directory

publish/wwwroot/Modules/Templates/External/Server/AssemblyInfo.cs

@@ -0,0 +1,4 @@
+using System.Resources;
+using Microsoft.Extensions.Localization;
+
+[assembly: RootNamespace("[Owner].Module.[Module].Server")]

publish/wwwroot/Modules/Templates/External/Server/Controllers/[Module]Controller.cs

@@ -0,0 +1,114 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using System.Collections.Generic;
+using Microsoft.AspNetCore.Http;
+using Oqtane.Shared;
+using Oqtane.Enums;
+using Oqtane.Infrastructure;
+using [Owner].Module.[Module].Services;
+using Oqtane.Controllers;
+using System.Net;
+using System.Threading.Tasks;
+
+namespace [Owner].Module.[Module].Controllers
+{
+    [Route(ControllerRoutes.ApiRoute)]
+    public class [Module]Controller : ModuleControllerBase
+    {
+        private readonly I[Module]Service _[Module]Service;
+
+        public [Module]Controller(I[Module]Service [Module]Service, ILogManager logger, IHttpContextAccessor accessor) : base(logger, accessor)
+        {
+            _[Module]Service = [Module]Service;
+        }
+
+        // GET: api/<controller>?moduleid=x
+        [HttpGet]
+        [Authorize(Policy = PolicyNames.ViewModule)]
+        public async Task<IEnumerable<Models.[Module]>> Get(string moduleid)
+        {
+            int ModuleId;
+            if (int.TryParse(moduleid, out ModuleId) && IsAuthorizedEntityId(EntityNames.Module, ModuleId))
+            {
+                return await _[Module]Service.Get[Module]sAsync(ModuleId);
+            }
+            else
+            {
+                _logger.Log(LogLevel.Error, this, LogFunction.Security, "Unauthorized [Module] Get Attempt {ModuleId}", moduleid);
+                HttpContext.Response.StatusCode = (int)HttpStatusCode.Forbidden;
+                return null;
+            }
+        }
+
+        // GET api/<controller>/5
+        [HttpGet("{id}/{moduleid}")]
+        [Authorize(Policy = PolicyNames.ViewModule)]
+        public async Task<Models.[Module]> Get(int id, int moduleid)
+        {
+            Models.[Module] [Module] = await _[Module]Service.Get[Module]Async(id, moduleid);
+            if ([Module] != null && IsAuthorizedEntityId(EntityNames.Module, [Module].ModuleId))
+            {
+                return [Module];
+            }
+            else
+            { 
+                _logger.Log(LogLevel.Error, this, LogFunction.Security, "Unauthorized [Module] Get Attempt {[Module]Id} {ModuleId}", id, moduleid);
+                HttpContext.Response.StatusCode = (int)HttpStatusCode.Forbidden;
+                return null;
+            }
+        }
+
+        // POST api/<controller>
+        [HttpPost]
+        [Authorize(Policy = PolicyNames.EditModule)]
+        public async Task<Models.[Module]> Post([FromBody] Models.[Module] [Module])
+        {
+            if (ModelState.IsValid && IsAuthorizedEntityId(EntityNames.Module, [Module].ModuleId))
+            {
+                [Module] = await _[Module]Service.Add[Module]Async([Module]);
+            }
+            else
+            {
+                _logger.Log(LogLevel.Error, this, LogFunction.Security, "Unauthorized [Module] Post Attempt {[Module]}", [Module]);
+                HttpContext.Response.StatusCode = (int)HttpStatusCode.Forbidden;
+                [Module] = null;
+            }
+            return [Module];
+        }
+
+        // PUT api/<controller>/5
+        [HttpPut("{id}")]
+        [Authorize(Policy = PolicyNames.EditModule)]
+        public async Task<Models.[Module]> Put(int id, [FromBody] Models.[Module] [Module])
+        {
+            if (ModelState.IsValid && [Module].[Module]Id == id && IsAuthorizedEntityId(EntityNames.Module, [Module].ModuleId))
+            {
+                [Module] = await _[Module]Service.Update[Module]Async([Module]);
+            }
+            else
+            {
+                _logger.Log(LogLevel.Error, this, LogFunction.Security, "Unauthorized [Module] Put Attempt {[Module]}", [Module]);
+                HttpContext.Response.StatusCode = (int)HttpStatusCode.Forbidden;
+                [Module] = null;
+            }
+            return [Module];
+        }
+
+        // DELETE api/<controller>/5
+        [HttpDelete("{id}/{moduleid}")]
+        [Authorize(Policy = PolicyNames.EditModule)]
+        public async Task Delete(int id, int moduleid)
+        {
+            Models.[Module] [Module] = await _[Module]Service.Get[Module]Async(id, moduleid);
+            if ([Module] != null && IsAuthorizedEntityId(EntityNames.Module, [Module].ModuleId))
+            {
+                await _[Module]Service.Delete[Module]Async(id, [Module].ModuleId);
+            }
+            else
+            {
+                _logger.Log(LogLevel.Error, this, LogFunction.Security, "Unauthorized [Module] Delete Attempt {[Module]Id} {ModuleId}", id, moduleid);
+                HttpContext.Response.StatusCode = (int)HttpStatusCode.Forbidden;
+            }
+        }
+    }
+}

publish/wwwroot/Modules/Templates/External/Server/Manager/[Module]Manager.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using Oqtane.Modules;
+using Oqtane.Models;
+using Oqtane.Infrastructure;
+using Oqtane.Interfaces;
+using Oqtane.Enums;
+using Oqtane.Repository;
+using [Owner].Module.[Module].Repository;
+using System.Threading.Tasks;
+
+namespace [Owner].Module.[Module].Manager
+{
+    public class [Module]Manager : MigratableModuleBase, IInstallable, IPortable, ISearchable
+    {
+        private readonly I[Module]Repository _[Module]Repository;
+        private readonly IDBContextDependencies _DBContextDependencies;
+
+        public [Module]Manager(I[Module]Repository [Module]Repository, IDBContextDependencies DBContextDependencies)
+        {
+            _[Module]Repository = [Module]Repository;
+            _DBContextDependencies = DBContextDependencies;
+        }
+
+        public bool Install(Tenant tenant, string version)
+        {
+            return Migrate(new [Module]Context(_DBContextDependencies), tenant, MigrationType.Up);
+        }
+
+        public bool Uninstall(Tenant tenant)
+        {
+            return Migrate(new [Module]Context(_DBContextDependencies), tenant, MigrationType.Down);
+        }
+
+        public string ExportModule(Oqtane.Models.Module module)
+        {
+            string content = "";
+            List<Models.[Module]> [Module]s = _[Module]Repository.Get[Module]s(module.ModuleId).ToList();
+            if ([Module]s != null)
+            {
+                content = JsonSerializer.Serialize([Module]s);
+            }
+            return content;
+        }
+
+        public void ImportModule(Oqtane.Models.Module module, string content, string version)
+        {
+            List<Models.[Module]> [Module]s = null;
+            if (!string.IsNullOrEmpty(content))
+            {
+                [Module]s = JsonSerializer.Deserialize<List<Models.[Module]>>(content);
+            }
+            if ([Module]s != null)
+            {
+                foreach(var [Module] in [Module]s)
+                {
+                    _[Module]Repository.Add[Module](new Models.[Module] { ModuleId = module.ModuleId, Name = [Module].Name });
+                }
+            }
+        }
+
+        public Task<List<SearchContent>> GetSearchContentsAsync(PageModule pageModule, DateTime lastIndexedOn)
+        {
+           var searchContentList = new List<SearchContent>();
+
+           foreach (var [Module] in _[Module]Repository.Get[Module]s(pageModule.ModuleId))
+           {
+               if ([Module].ModifiedOn >= lastIndexedOn)
+               {
+                   searchContentList.Add(new SearchContent
+                   {
+                       EntityName = "[Owner][Module]",
+                       EntityId = [Module].[Module]Id.ToString(),
+                       Title = [Module].Name,
+                       Body = [Module].Name,
+                       ContentModifiedBy = [Module].ModifiedBy,
+                       ContentModifiedOn = [Module].ModifiedOn
+                   });
+               }
+           }
+
+           return Task.FromResult(searchContentList);
+        }
+    }
+}

publish/wwwroot/Modules/Templates/External/Server/Migrations/01000000_InitializeModule.cs

@@ -0,0 +1,30 @@
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Oqtane.Databases.Interfaces;
+using Oqtane.Migrations;
+using [Owner].Module.[Module].Migrations.EntityBuilders;
+using [Owner].Module.[Module].Repository;
+
+namespace [Owner].Module.[Module].Migrations
+{
+    [DbContext(typeof([Module]Context))]
+    [Migration("[Owner].Module.[Module].01.00.00.00")]
+    public class InitializeModule : MultiDatabaseMigration
+    {
+        public InitializeModule(IDatabase database) : base(database)
+        {
+        }
+
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            var entityBuilder = new [Module]EntityBuilder(migrationBuilder, ActiveDatabase);
+            entityBuilder.Create();
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            var entityBuilder = new [Module]EntityBuilder(migrationBuilder, ActiveDatabase);
+            entityBuilder.Drop();
+        }
+    }
+}

publish/wwwroot/Modules/Templates/External/Server/Migrations/EntityBuilders/[Module]EntityBuilder.cs

@@ -0,0 +1,36 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Migrations.Operations;
+using Microsoft.EntityFrameworkCore.Migrations.Operations.Builders;
+using Oqtane.Databases.Interfaces;
+using Oqtane.Migrations;
+using Oqtane.Migrations.EntityBuilders;
+
+namespace [Owner].Module.[Module].Migrations.EntityBuilders
+{
+    public class [Module]EntityBuilder : AuditableBaseEntityBuilder<[Module]EntityBuilder>
+    {
+        private const string _entityTableName = "[Owner][Module]";
+        private readonly PrimaryKey<[Module]EntityBuilder> _primaryKey = new("PK_[Owner][Module]", x => x.[Module]Id);
+        private readonly ForeignKey<[Module]EntityBuilder> _moduleForeignKey = new("FK_[Owner][Module]_Module", x => x.ModuleId, "Module", "ModuleId", ReferentialAction.Cascade);
+
+        public [Module]EntityBuilder(MigrationBuilder migrationBuilder, IDatabase database) : base(migrationBuilder, database)
+        {
+            EntityTableName = _entityTableName;
+            PrimaryKey = _primaryKey;
+            ForeignKeys.Add(_moduleForeignKey);
+        }
+
+        protected override [Module]EntityBuilder BuildTable(ColumnsBuilder table)
+        {
+            [Module]Id = AddAutoIncrementColumn(table,"[Module]Id");
+            ModuleId = AddIntegerColumn(table,"ModuleId");
+            Name = AddMaxStringColumn(table,"Name");
+            AddAuditableColumns(table);
+            return this;
+        }
+
+        public OperationBuilder<AddColumnOperation> [Module]Id { get; set; }
+        public OperationBuilder<AddColumnOperation> ModuleId { get; set; }
+        public OperationBuilder<AddColumnOperation> Name { get; set; }
+    }
+}

publish/wwwroot/Modules/Templates/External/Server/Repository/I[Module]Repository.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace [Owner].Module.[Module].Repository
+{
+    public interface I[Module]Repository
+    {
+        IEnumerable<Models.[Module]> Get[Module]s(int ModuleId);
+        Models.[Module] Get[Module](int [Module]Id);
+        Models.[Module] Get[Module](int [Module]Id, bool tracking);
+        Models.[Module] Add[Module](Models.[Module] [Module]);
+        Models.[Module] Update[Module](Models.[Module] [Module]);
+        void Delete[Module](int [Module]Id);
+    }
+}

publish/wwwroot/Modules/Templates/External/Server/Repository/[Module]Context.cs

@@ -0,0 +1,26 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.AspNetCore.Http;
+using Oqtane.Modules;
+using Oqtane.Repository;
+using Oqtane.Infrastructure;
+using Oqtane.Repository.Databases.Interfaces;
+
+namespace [Owner].Module.[Module].Repository
+{
+    public class [Module]Context : DBContextBase, ITransientService, IMultiDatabase
+    {
+        public virtual DbSet<Models.[Module]> [Module] { get; set; }
+
+        public [Module]Context(IDBContextDependencies DBContextDependencies) : base(DBContextDependencies)
+        {
+            // ContextBase handles multi-tenant database connections
+        }
+
+        protected override void OnModelCreating(ModelBuilder builder)
+        {
+            base.OnModelCreating(builder);
+
+            builder.Entity<Models.[Module]>().ToTable(ActiveDatabase.RewriteName("[Owner][Module]"));
+        }
+    }
+}

publish/wwwroot/Modules/Templates/External/Server/Repository/[Module]Repository.cs

@@ -0,0 +1,65 @@
+using Microsoft.EntityFrameworkCore;
+using System.Linq;
+using System.Collections.Generic;
+using Oqtane.Modules;
+
+namespace [Owner].Module.[Module].Repository
+{
+    public class [Module]Repository : I[Module]Repository, ITransientService
+    {
+        private readonly IDbContextFactory<[Module]Context> _factory;
+
+        public [Module]Repository(IDbContextFactory<[Module]Context> factory)
+        {
+            _factory = factory;
+        }
+
+        public IEnumerable<Models.[Module]> Get[Module]s(int ModuleId)
+        {
+            using var db = _factory.CreateDbContext();
+            return db.[Module].Where(item => item.ModuleId == ModuleId).ToList();
+        }
+
+        public Models.[Module] Get[Module](int [Module]Id)
+        {
+            return Get[Module]([Module]Id, true);
+        }
+
+        public Models.[Module] Get[Module](int [Module]Id, bool tracking)
+        {
+            using var db = _factory.CreateDbContext();
+            if (tracking)
+            {
+                return db.[Module].Find([Module]Id);
+            }
+            else
+            {
+                return db.[Module].AsNoTracking().FirstOrDefault(item => item.[Module]Id == [Module]Id);
+            }
+        }
+
+        public Models.[Module] Add[Module](Models.[Module] [Module])
+        {
+            using var db = _factory.CreateDbContext();
+            db.[Module].Add([Module]);
+            db.SaveChanges();
+            return [Module];
+        }
+
+        public Models.[Module] Update[Module](Models.[Module] [Module])
+        {
+            using var db = _factory.CreateDbContext();
+            db.Entry([Module]).State = EntityState.Modified;
+            db.SaveChanges();
+            return [Module];
+        }
+
+        public void Delete[Module](int [Module]Id)
+        {
+            using var db = _factory.CreateDbContext();
+            Models.[Module] [Module] = db.[Module].Find([Module]Id);
+            db.[Module].Remove([Module]);
+            db.SaveChanges();
+        }
+    }
+}

publish/wwwroot/Modules/Templates/External/Server/Services/[Module]Service.cs

@@ -0,0 +1,101 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Oqtane.Enums;
+using Oqtane.Infrastructure;
+using Oqtane.Models;
+using Oqtane.Security;
+using Oqtane.Shared;
+using [Owner].Module.[Module].Repository;
+
+namespace [Owner].Module.[Module].Services
+{
+    public class Server[Module]Service : I[Module]Service
+    {
+        private readonly I[Module]Repository _[Module]Repository;
+        private readonly IUserPermissions _userPermissions;
+        private readonly ILogManager _logger;
+        private readonly IHttpContextAccessor _accessor;
+        private readonly Alias _alias;
+
+        public Server[Module]Service(I[Module]Repository [Module]Repository, IUserPermissions userPermissions, ITenantManager tenantManager, ILogManager logger, IHttpContextAccessor accessor)
+        {
+            _[Module]Repository = [Module]Repository;
+            _userPermissions = userPermissions;
+            _logger = logger;
+            _accessor = accessor;
+            _alias = tenantManager.GetAlias();
+        }
+
+        public Task<List<Models.[Module]>> Get[Module]sAsync(int ModuleId)
+        {
+            if (_userPermissions.IsAuthorized(_accessor.HttpContext.User, _alias.SiteId, EntityNames.Module, ModuleId, PermissionNames.View))
+            {
+                return Task.FromResult(_[Module]Repository.Get[Module]s(ModuleId).ToList());
+            }
+            else
+            {
+                _logger.Log(LogLevel.Error, this, LogFunction.Security, "Unauthorized [Module] Get Attempt {ModuleId}", ModuleId);
+                return null;
+            }
+        }
+
+        public Task<Models.[Module]> Get[Module]Async(int [Module]Id, int ModuleId)
+        {
+            if (_userPermissions.IsAuthorized(_accessor.HttpContext.User, _alias.SiteId, EntityNames.Module, ModuleId, PermissionNames.View))
+            {
+                return Task.FromResult(_[Module]Repository.Get[Module]([Module]Id));
+            }
+            else
+            {
+                _logger.Log(LogLevel.Error, this, LogFunction.Security, "Unauthorized [Module] Get Attempt {[Module]Id} {ModuleId}", [Module]Id, ModuleId);
+                return null;
+            }
+        }
+
+        public Task<Models.[Module]> Add[Module]Async(Models.[Module] [Module])
+        {
+            if (_userPermissions.IsAuthorized(_accessor.HttpContext.User, _alias.SiteId, EntityNames.Module, [Module].ModuleId, PermissionNames.Edit))
+            {
+                [Module] = _[Module]Repository.Add[Module]([Module]);
+                _logger.Log(LogLevel.Information, this, LogFunction.Create, "[Module] Added {[Module]}", [Module]);
+            }
+            else
+            {
+                _logger.Log(LogLevel.Error, this, LogFunction.Security, "Unauthorized [Module] Add Attempt {[Module]}", [Module]);
+                [Module] = null;
+            }
+            return Task.FromResult([Module]);
+        }
+
+        public Task<Models.[Module]> Update[Module]Async(Models.[Module] [Module])
+        {
+            if (_userPermissions.IsAuthorized(_accessor.HttpContext.User, _alias.SiteId, EntityNames.Module, [Module].ModuleId, PermissionNames.Edit))
+            {
+                [Module] = _[Module]Repository.Update[Module]([Module]);
+                _logger.Log(LogLevel.Information, this, LogFunction.Update, "[Module] Updated {[Module]}", [Module]);
+            }
+            else
+            {
+                _logger.Log(LogLevel.Error, this, LogFunction.Security, "Unauthorized [Module] Update Attempt {[Module]}", [Module]);
+                [Module] = null;
+            }
+            return Task.FromResult([Module]);
+        }
+
+        public Task Delete[Module]Async(int [Module]Id, int ModuleId)
+        {
+            if (_userPermissions.IsAuthorized(_accessor.HttpContext.User, _alias.SiteId, EntityNames.Module, ModuleId, PermissionNames.Edit))
+            {
+                _[Module]Repository.Delete[Module]([Module]Id);
+                _logger.Log(LogLevel.Information, this, LogFunction.Delete, "[Module] Deleted {[Module]Id}", [Module]Id);
+            }
+            else
+            {
+                _logger.Log(LogLevel.Error, this, LogFunction.Security, "Unauthorized [Module] Delete Attempt {[Module]Id} {ModuleId}", [Module]Id, ModuleId);
+            }
+            return Task.CompletedTask;
+        }
+    }
+}

publish/wwwroot/Modules/Templates/External/Server/Startup/ServerStartup.cs

@@ -0,0 +1,28 @@
+using Microsoft.AspNetCore.Builder; 
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+using Oqtane.Infrastructure;
+using [Owner].Module.[Module].Repository;
+using [Owner].Module.[Module].Services;
+
+namespace [Owner].Module.[Module].Startup
+{
+    public class ServerStartup : IServerStartup
+    {
+        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
+        {
+            // not implemented
+        }
+
+        public void ConfigureMvc(IMvcBuilder mvcBuilder)
+        {
+            // not implemented
+        }
+
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.AddTransient<I[Module]Service, Server[Module]Service>();
+            services.AddDbContextFactory<[Module]Context>(opt => { }, ServiceLifetime.Transient);
+        }
+    }
+}

publish/wwwroot/Modules/Templates/External/Server/[Owner].Module.[Module].Server.csproj

@@ -0,0 +1,36 @@
+<Project Sdk="Microsoft.NET.Sdk.Razor">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <AddRazorSupportForMvc>true</AddRazorSupportForMvc>
+    <Version>1.0.0</Version>
+    <Product>[Owner].Module.[Module]</Product>
+    <Authors>[Owner]</Authors>
+    <Company>[Owner]</Company>
+    <Description>[Description]</Description>
+    <Copyright>[Owner]</Copyright>
+    <AssemblyName>[Owner].Module.[Module].Server.Oqtane</AssemblyName>
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Content Remove="wwwroot\_content\**\*.*" />
+    <None Include="wwwroot\_content\**\*.*" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.Server" Version="9.0.5" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="9.0.5" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.5" />
+    <PackageReference Include="Microsoft.Extensions.Localization" Version="9.0.5" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Shared\[Owner].Module.[Module].Shared.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    [ServerReference]
+    [SharedReference]
+  </ItemGroup>
+</Project>

publish/wwwroot/Modules/Templates/External/Server/wwwroot/Modules/[Owner].Module.[Module]/Module.css

@@ -0,0 +1 @@
+/* Module Custom Styles */

publish/wwwroot/Modules/Templates/External/Server/wwwroot/Modules/[Owner].Module.[Module]/Module.js

@@ -0,0 +1,5 @@
+/* Module Script */
+var [Owner] = [Owner] || {};
+
+[Owner].[Module] = {
+};

publish/wwwroot/Modules/Templates/External/Server/wwwroot/_content/Placeholder.txt

@@ -0,0 +1,11 @@
+The _content folder should only contain static resources from shared razor component libraries (RCLs). Static resources can be extracted from shared RCL Nuget packages by executing a Publish task on the module's Server project to a local folder and copying the files from the _content folder which is created. Each shared RCL would have its own appropriately named subfolder within the module's _content folder.
+
+ie.
+
+/_content
+  /Radzen.Blazor
+    /css
+    /fonts
+  /syncfusion.blazor
+    /scripts
+    /styles