SugarSql果糖的新手福利之WebFirst代码生成脚本

专家-百锦再@新空间代码工作室

已于 2024-01-23 15:36:23 修改

阅读量1.1k

点赞数 32

分类专栏：程序员数据库 .net 文章标签： servlet 前端 c#

于 2024-01-17 08:53:55 首次发布

本文链接：https://blog.csdn.net/sixpp/article/details/135640243

版权

程序员同时被 3 个专栏收录

79 篇文章 0 订阅

订阅专栏

.net

15 篇文章 0 订阅

订阅专栏

数据库

5 篇文章 0 订阅

订阅专栏

我分享一个简单的WebFirst代码生成脚本

这个脚本只对WebFirst有用。
在这里插入图片描述
WebFirst是一个工厂，代码工厂。

Entity 实体生成

在这里插入图片描述
对于 CRUD来说只需要配置主键和自增列就行了，如果类的名称和数据库不一样可以设置数据库中的名称

using System;
using System.Collections.Generic;
using System.Linq;
using SqlSugar;
namespace @Model.name_space
{
    /// <summary>
    /// @((Model.Description+"").Replace("\r","").Replace("\n",""))
    ///@(DateTime.Now.ToString("yyyy年MM月dd日 "))【ZXM】
    ///</summary>
    [SugarTable("@(Model.TableName)")]
    public class @(Model.ClassName)
    {
@foreach (var item in Model.PropertyGens)
{
    var isPrimaryKey = item.IsPrimaryKey ? ",IsPrimaryKey = true" : "";
    var isIdentity = item.IsIdentity ? ",IsIdentity = true" : "";
    var isNull=(item.IsNullable&&item.Type!="string"&&item.IsSpecialType==false&&item.Type!="byte[]")?"?":"";
    var isIgnore=(item.IsIgnore?",IsIgnore = true":"");
    var isJson=(item.CodeType.StartsWith("json")?",IsJson= true":"");

    var newPropertyName=item.PropertyName; //这里可以用C#处理 实体属性的显式格式
    //想和数据库一样就用 newPropertyName=item.DbColumnName
    if(System.Text.RegularExpressions.Regex.IsMatch(newPropertyName.Substring(0,1), "[0-9]"))
    {
        newPropertyName="_"+newPropertyName;//处理属性名开头为数字情况
    }
    if(newPropertyName==Model.ClassName)
    {
        newPropertyName="_"+newPropertyName;//处理属性名不能等于类名
    }


    var desc=(item.Description+"").Replace("\r","").Replace("\n","");//处理换行

    if(isIgnore!="")
    {
       isPrimaryKey =isIdentity =isNull="";
     }
        @:/// <summary>
        @:/// @(desc) 
        @if(item.DefaultValue!=null)
        {
        @:/// 默认值: @Raw(item.DefaultValue)
        }
        @:///</summary>
        @: [SugarColumn(ColumnName="@item.DbColumnName" @(isPrimaryKey) @(isIdentity) @(isIgnore) @(isJson))]
        @: public @Raw(item.Type)@isNull @newPropertyName { get; set; }
    }
    }
}

IRepository接口类和Repository实现类生成

在这里插入图片描述
在典型的三层架构中，Repository通常作为数据访问层（Data Access Layer）的一部分存在，负责处理数据访问的细节。下面是一些Repository的特点：

数据访问：Repository的主要职责是封装底层的数据访问操作，例如CRUD（创建、读取、更新、删除）操作。它提供了数据查询、添加、修改、删除等方法供其他层使用。

抽象封装：Repository通过提供数据操作的接口或抽象类，将数据访问细节隐藏在后台，为上层提供统一的接口，使得业务逻辑层能够以更高层次的抽象来调用和操作数据。

单一职责原则：Repository遵循单一职责原则，将数据访问操作与业务逻辑分离，确保了代码的可维护性和可测试性。

可测试性：由于Repository将数据访问操作进行了封装和抽象，因此可以更方便地进行单元测试，而不需要依赖实际的数据存储。

可扩展性：通过Repository模式，可以轻松地切换或扩展底层数据存储，比如从关系型数据库切换到非关系型数据库。由于上层代码只依赖于Repository接口，而不是具体的实现，所以可以更容易地修改或替换底层实现。


    /// <summary>
    /// @((Model.Description+"").Replace("\r","").Replace("\n",""))
    ///@(DateTime.Now.ToString("yyyy年MM月dd日 "))【ZXM】
    ///</summary>
    public interface I@(Model.ClassName)Repository : IBaseRepository<@(Model.ClassName)>
    {
        Task<Object> AddModel(@(Model.ClassName) model);/*添加实体*/
        Task<Object> GetPageList(search@(Model.ClassName) s);/*分页条件查询*/
        Task<Object> GetById(int id);/*根据id获取实体*/
        Task<Object> UpdateModel(@(Model.ClassName) model);/*更新实体*/
    }


    /// <summary>
    /// @((Model.Description+"").Replace("\r","").Replace("\n",""))
    /// @(DateTime.Now.ToString("yyyy年MM月dd日 "))【ZXM】
    ///</summary>
     public class @(Model.ClassName)Repository : BaseRepository<@(Model.ClassName)>, I@(Model.ClassName)Repository
    {
        
        public @(Model.ClassName)Repository()
        {

        }

        public async Task<Object> AddModel(@(Model.ClassName) model)
        {
            MessageModel<@(Model.ClassName)> message = new MessageModel<@(Model.ClassName)>
            {
                code = 200,
                msg = "添加成功"
            };
            try
            {
                var resId = await Db.Insertable(model).ExecuteReturnBigIdentityAsync();
                var resModel=await Db.Queryable<@(Model.ClassName)>().SingleAsync(it=>it.Id==resId);
                message.data=resModel;
            }
            catch(Exception ex)
            {
               
                message.code = 500;
                message.msg = "请求错误"+ex.Message;
            }
            return message;
        }

          public async Task<Object> UpdateModel(@(Model.ClassName) model)
        {
            var message = new MessageModel<@(Model.ClassName)>()
            {
                msg = "修改成功",
                code = 200
            };
            try{
                var resModel = await Db.Queryable<@(Model.ClassName)>()
                .Where(it => it.Id == model.Id).FirstAsync();
                if (resModel != null)
                {
                    var resInt = await Db.Updateable(model).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
                    message.data = await Db.Queryable<@(Model.ClassName)>()
                    .Where(it => it.Id == model.Id).FirstAsync();;
                }
                else
                {
                    message.code = -1;
                    message.msg = "id不存在";
                }
            }catch(Exception ex)
            {
                message.code = 500;
                message.msg = "请求错误"+ex.Message;
            }
            return message;
        }
        
        public async Task<Object> GetById(int id)
        {
            var message = new MessageModel<@(Model.ClassName)VM>()
            {
                msg = "查询成功",
                code = 200
            };
            try{
                var resModel = await Db.Queryable<@(Model.ClassName)>()
                //.LeftJoin<Dwxx>((it,dw)=>it.Dwbh==dw.dwbh&&dw.sczt==0)
                //.WhereIF(s.Startsbsj!=null,it=>it.Cjsj>=s.Startsbsj)
                .Where(it=>it.Id==id&&it.Sczt==0)//ID==id
                .Select(it => new @(Model.ClassName)VM
                {
                 @foreach (var item in Model.PropertyGens)
                {
                 @: @(item.PropertyName)=it.@(item.PropertyName),
                }
                     /**/
                   
                })
                .FirstAsync();
                if(resModel==null){
                    message.msg="id不存在";
                }
                message.data=resModel;
            }catch(Exception ex)
            {
                message.code = 500;
                message.msg = "请求错误"+ex.Message;
            }
            return message; 
        }

        public async Task<Object> GetPageList(search@(Model.ClassName) s)
        {
            RefAsync<int> dataCount = 0;
            RefAsync<int> pageCount = 0;
            PageModel<@(Model.ClassName)VM> pageModel = new PageModel<@(Model.ClassName)VM>
            {
                page = s.page,
                PageSize = s.pageSize,
                data = new List<@(Model.ClassName)VM>()
            };
            try{
                var list = await Db.Queryable<@(Model.ClassName)>()
                    //.LeftJoin<Dwxx>((it,dw)=>it.Dwbh==dw.dwbh&&dw.sczt==0)
                    //.WhereIF(s.Startsbsj!=null,it=>it.Cjsj>=s.Startsbsj)
                    .Where(it=>it.Sczt==0)//ID==id
                    .Select(it => new @(Model.ClassName)VM
                    {
                        @foreach (var item in Model.PropertyGens)
                        {
                        @: @(item.PropertyName)=it.@(item.PropertyName),
                        }
                        /**/
                    
                    })
                    .ToPageListAsync(s.page, s.pageSize, dataCount, pageCount);
                pageModel.dataCount = dataCount;
                pageModel.pageCount = pageCount;
                pageModel.data = list;
            }catch(Exception ex)
            {
                var message = new MessageModel<JcDwxx1VM>();
                message.code = 500;
                message.msg = "请求错误"+ex.Message;
                return message;
            }
            return pageModel;
        }
    }

IService接口类和Service实现类生成

在这里插入图片描述
Service层通常是指位于业务逻辑层的一部分，负责处理业务逻辑处理和协调各个组件之间的交互。下面是一些Service层的特点：

业务逻辑处理：Service层通常包含应用程序的核心业务逻辑，它负责处理复杂的业务规则、数据转换和计算等。它通过调用数据访问层（如Repository或DAO）来获取数据，然后对数据进行处理、验证和转换，最后将结果返回给表示层。

事务管理：在Service层中，通常会涉及到与数据库和其他外部系统的交互，涉及到多个数据操作的场景。Service层可以负责管理和控制这些操作的事务，以确保数据的一致性和完整性。

接口封装：Service层通过提供接口或抽象类来封装业务逻辑的实现细节。这样，表示层和其他组件只需要依赖于Service层的接口，而不直接依赖于具体的实现，从而实现了解耦和可测试性。

访问授权：Service层可以负责验证和授权用户对系统功能和数据的访问权限。它可以在执行业务逻辑之前，对用户进行身份验证和权限检查，从而保护系统的安全性。

异常处理：Service层通常会处理和处理业务逻辑中可能出现的异常情况。它可以捕获和处理异常，并将适当的异常信息返回给表示层，以便进行错误处理和用户提示。

业务规则校验：Service层会对输入数据进行验证，并执行业务规则的校验。它可以确保数据的有效性、一致性和完整性，遵循应用程序定义的业务规则。


    /// <summary>
    /// @((Model.Description+"").Replace("\r","").Replace("\n",""))
    ///@(DateTime.Now.ToString("yyyy年MM月dd日 "))【ZXM】
    ///</summary>
    public interface I@(Model.ClassName)Service : IBaseService<@(Model.ClassName)>
    {
        Task<Object> AddModel(@(Model.ClassName) model);/*添加实体*/
        Task<Object> GetPageList(search@(Model.ClassName) s);/*分页条件查询*/
        Task<Object> GetById(int id);/*根据id获取实体*/
        Task<Object> UpdateModel(@(Model.ClassName) model);/*更新实体*/
    }


    /// <summary>
    /// @((Model.Description+"").Replace("\r","").Replace("\n",""))
    /// @(DateTime.Now.ToString("yyyy年MM月dd日 "))【ZXM】
    ///</summary>
     public class @(Model.ClassName)Service : BaseService<@(Model.ClassName)>, I@(Model.ClassName)Service
    {
        private readonly I@(Model.ClassName)Repository _@(Model.ClassName)Repository;

        public @(Model.ClassName)Service(IBaseRepository<@(Model.ClassName)> baseRepository,I@(Model.ClassName)Repository @(Model.ClassName)Repository) : base(baseRepository)
        {
            _@(Model.ClassName)Repository = @(Model.ClassName)Repository;
        }

        public async Task<Object> AddModel(@(Model.ClassName) model)
        {
            return await _@(Model.ClassName)Repository.AddModel(model);
        }
        
        public async Task<Object> GetById(int id)
        {
            return await _@(Model.ClassName)Repository.GetById(id);
        }

        public async Task<Object> GetPageList(search@(Model.ClassName) s)
        {
            return await _@(Model.ClassName)Repository.GetPageList(s);
        }
       
        public async Task<Object> UpdateModel(@(Model.ClassName) model)
        {
            return await _@(Model.ClassName)Repository.UpdateModel(model);
        }
    }

Controller 控制器类生成

在这里插入图片描述
"Controller"通常是指模型-视图-控制器（MVC）模式中的控制器部分。MVC是一种常见的架构模式，用于将应用程序分为三个核心组件：模型（Model）、视图（View）和控制器（Controller）。

控制器在MVC模式中，负责协调和处理用户输入、更新模型数据并响应视图的变化。下面是一些Controller的特点：

用户输入处理：控制器接收来自用户界面（视图）的输入，例如按钮点击、表单提交等，并根据这些输入执行相应的操作。
协调与处理逻辑：控制器负责协调模型和视图之间的交互。它从视图获取用户输入，并根据业务逻辑对模型进行更新，然后将更新后的数据返回给视图进行展示。
路由和导航：控制器通常负责路由和导航的任务。它决定将用户请求导向哪个模型以及选择显示哪个视图来响应请求。
业务规则处理：控制器可以处理与业务规则相关的逻辑，例如验证用户输入、执行某些计算以及调用其他服务层或领域层的操作。
执行与更新模型：控制器可以通过调用模型的方法来执行特定的业务操作，例如从数据库中获取数据、新增或更新数据。
视图更新反馈：控制器根据模型的状态或执行结果，决定哪个视图应该被呈现给用户，并相应地更新视图。
单一职责原则：控制器遵循单一职责原则，即负责处理用户输入和协调相关组件的交互，而不涉及过多的业务逻辑和数据访问细节。

总体而言，控制器在MVC架构中充当了功能协调者的角色，连接了模型和视图，并负责处理用户输入、执行业务逻辑以及更新视图。它帮助实现了代码分离、可复用性和可测试性，使得应用程序的各个部分能够更好地解耦和组织。


    /// <summary>
    /// @((Model.Description+"").Replace("\r","").Replace("\n",""))
    /// @(DateTime.Now.ToString("yyyy年MM月dd日 "))【ZXM】
    ///</summary>
    public class @(Model.ClassName)Controller : BaseController
    {
        private readonly I@(Model.ClassName)Service _@(Model.ClassName)Service;
        private readonly ILogger<@(Model.ClassName)Controller> _logger;

        public @(Model.ClassName)Controller(I@(Model.ClassName)Service @(Model.ClassName)Service, ILogger<@(Model.ClassName)Controller> logger)
        {
            _@(Model.ClassName)Service = @(Model.ClassName)Service;
            _logger = logger;
        }
        #region 添加信息
        /// <summary>
        /// 添加信息
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> AddModel(@(Model.ClassName) model)
        {
            if (null == model)
            {
                return Ok(new MessageModel<bool>()
                {
                    code = 400,
                    success = false,
                    msg = "model 参数不可为空！",
                    data = false
                });
            }
           
            @foreach (var item in Model.PropertyGens)
            {
                @if((!item.IsNullable)&&(item.Type.ToString()=="string")){
 
                    @:    if(string.IsNullOrEmpty(model.@(item.PropertyName))){
                    @:        return Ok(new MessageModel<string>()
                    @:        {
                    @:            code = 400,
                    @:            success = false,
                    @:            msg = "参数[@(item.PropertyName)]不可为空！",
                    @:        });
                    @:    }
                }
                @if((!item.IsNullable)&&(item.Type.ToString()!="string")){
                    @:    if(model.@(item.PropertyName)==null){
                    @:        return Ok(new MessageModel<string>()
                    @:        {
                    @:            code = 400,
                    @:            success = false,
                    @:            msg = "参数[@(item.PropertyName)]不可为空！",
                    @:        });
                    @:    }
                }
              
            }
            /*可以添加必要参数校验
            if (string.IsNullOrEmpty(model.name) )
            {
                return Ok(new MessageModel<string>()
                {
                    code = 400,
                    success = false,
                    msg = "参数[name]不可为空！",
                });
            }
            */
            try
            { 
                var resMsg = await _@(Model.ClassName)Service.AddModel(model);
                return Ok(resMsg);
            }
            catch (Exception ex)
            {
                _logger.LogError($"@(Model.ClassName)Controller.AddModel Error: {ex.Message}");
                return Ok(new MessageModel<string>()
                {
                    code = 500,
                    msg = "添加信息异常！" + ex.Message,
                });
            }
        }

        #endregion

        #region 修改信息 

        /// <summary>
        /// 修改信息
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> UpdateModel(@(Model.ClassName) model)
        {
            if (null == model)
            {
                return Ok(new MessageModel<bool>()
                {
                    code = 400,
                    success = false,
                    msg = "model 参数不可为空！",
                });
            }
             if(model.Id==null){
                            return Ok(new MessageModel<string>()
                            {
                                code = 400,
                                success = false,
                                msg = "参数[Id]不可为空！",
                            });
                        }
            /*可以添加必要参数校验
            if (string.IsNullOrEmpty(model.name) )
            {
                return Ok(new MessageModel<bool>()
                {
                    code = 400,
                    success = false,
                    msg = "参数[name]不可为空！",
                    data = false
                });
            }
            */
            try
            {
                var res = await _@(Model.ClassName)Service.UpdateModel(model);
                return Ok(res);
            }
            catch (Exception ex)
            {
                _logger.LogError($"@(Model.ClassName)Controller.UpdateModel Error: {ex.Message}");
                return Ok(new MessageModel<string>()
                {
                    code = 500,
                    msg = "修改信息异常！" + ex.Message,
                });
            }
        }
        #endregion

        #region 删除信息

        /// <summary>
        /// 批量删除信息(逻辑删除)
        /// </summary>
        /// <param name="ids">信息Id，多个英文逗号分隔</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> DeleteModelByIds(string ids)
        {
            if (string.IsNullOrWhiteSpace(ids))
            {
                return Ok(new MessageModel<int>()
                {
                    code = 400,
                    success = false,
                    msg = "ids 参数不可为空！",
                });
            }
            try
            {
                string[] sArrId = ids.Split(',');
                object[] lIds = Array.ConvertAll(sArrId, s => (object)s);
                var v@(Model.ClassName)List = await _@(Model.ClassName)Service.GetInList(lIds);
                var vDelResult = await _@(Model.ClassName)Service.DeleteByIdsAndField(lIds,"sczt");
                return Ok(vDelResult);
            }
            catch (Exception ex)
            {
                _logger.LogError($"@(Model.ClassName)Controller.DeleteModelByIds Error: {ex.Message}");
                return Ok(new MessageModel<string>()
                {
                    code = 500,
                    msg = "删除信息异常！" + ex.Message,
                });
            }
        }

        #endregion

        #region 获取某一信息

        /// <summary>
        /// 获取某一信息
        /// </summary>
        /// <param name="id">信息Id</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> GetModelById(int id)
        {
            if (id==null)
            {
                return Ok(new MessageModel<@(Model.ClassName)VM>()
                {
                    code = 400,
                    success = false,
                    msg = "id 参数不可为空！",
                    data = null
                });
            }

            try
            {
                var res = await _@(Model.ClassName)Service.GetById(id);
                return Ok(res);
            }
            catch (Exception ex)
            {
                _logger.LogError($"@(Model.ClassName)Controller.GetModelById Error: {ex.Message}");
                return Ok(new MessageModel<@(Model.ClassName)VM>()
                {
                    code = 500,
                    msg = "获取信息异常！" + ex.Message,
                });
            }
        }

        #endregion

        #region 分页获取信息列表

        /// <summary>
        /// 分页获取信息列表
        /// </summary>
        /// <param name="s">查询条件</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> GetPageList(search@(Model.ClassName) s)
        {
            try
            {
                var vResult = await _@(Model.ClassName)Service.GetPageList(s);
                return Ok(vResult);
            }
            catch (Exception ex)
            {
                _logger.LogError($"@(Model.ClassName)Controller.GetPageList Error: {ex.Message}");
                return Ok(new MessageModel<PageModel<@(Model.ClassName)VM>>()
                {
                    code = 500,
                    msg = "查询信息异常！" + ex.Message,
                });
            }
        }
        #endregion
    }