PDF补丁丁（ PDFPatcher.）

PDF补丁丁是一个用于修改PDF文件信息的工具。它具有以下功能：

修改PDF信息：修改文档属性、页码编号、页面链接、页面尺寸；删除自动打开网页等动作，去除复制及打印限制；设置阅读器初始模式。
贴心PDF书签编辑器：可批量修改PDF书签属性（颜色、样式、目标页码、缩放比例等），在书签中执行查找替换（支持正则表达式及XPath匹配）。
生成PDF书签：无需手工输入，自动识别正文标题或目录，为PDF文档生成书签。
制作PDF文件：合并已有PDF文件或图片，生成新的PDF文件（可挂上书签）。
拆分或合并PDF文件，并保留原文件的书签或挂上新的书签。
高速无损导出PDF文档的图片。
提取或删除PDF文档中指定的页面，调整PDF文档的页面顺序。
根据PDF文档元数据重命名PDF文件名。
调用微软 Office 的图像识别引擎分析PDF文档图片中的文字；将图片PDF的目录页转换为PDF书签。识别结果可写入PDF文件。
分析文档结构：以树视图显示PDF文档结构，可编辑修改PDF文档节点，或将PDF文档导出成XML文件，供PDF爱好者分析、调试之用。
永久免费，绝不过期，无广告，无弹出废话对话框。

文件：590m.com/f/25127180-488777471-b9f9b4（访问密码：551685）

以下内容无关：

-------------------------------------------分割线---------------------------------------------

简介
关于这个框架的背景，在前面我已经交代过了。不清楚的可以查看这个链接 极简实用的Asp.NetCore模块化框架决定免费开源了

在最近一段时间内，对这个框架新增了以下功能：

1、新增了CMS模块，目前整体都比较简单，适合个人博客使用。

2、新增了AOP缓存，使用AspectCore,缓存可做到Memarycache和redis一件切换。

3、新增AOP事务，服务层和控制器都可以打上特性标签使用。

4、对多租户使用Filter，不管是添加还是更新、查询即可自动赋值。

5、新增七牛云图片上传功能。

6、对于单表的增删改查，在控制器内做了封装，有新的业务按约定建立对应的CRUD实体，一套API自动完成。

7、后台管理新增站群管理。

说了那么多，让我们上点代码和截图来瞧一瞧吧。

AOP缓存
复制代码
public class CacheInterceptorAttribute : AbstractInterceptorAttribute
{
private static readonly ConcurrentDictionary<Type, MethodInfo> TypeofTaskResultMethod = new ConcurrentDictionary<Type, MethodInfo>();
readonly int _expireSecond;
readonly string _cacheKey;

    #region 拦截处理
    /// <summary>
    /// 过期时间，单位：分
    /// </summary>
    /// <param name="expireMin"></param>
    public CacheInterceptorAttribute(string cacheKey = null, int expireMin = -1)
    {
        _expireSecond = expireMin * 60;
        _cacheKey = cacheKey;
    }

    public async override Task Invoke(AspectContext context, AspectDelegate next)
    {
        try
        {
            string key = string.Empty;
            //自定义的缓存key不存在，再获取类名+方法名或类名+方法名+参数名的组合式key
            if (!string.IsNullOrEmpty(_cacheKey))
            {
                key = _cacheKey;
            }
            else
            {
                key = GetKey(context.ServiceMethod, context.Parameters);
            }

            var returnType = GetReturnType(context);
            var cache = context.ServiceProvider.GetService<ICacheHelper>();
            if (!cache.Exists(key))
            {
                return;
            }
            var strResult = cache.Get<string>(key);
            var result = JsonConvert.DeserializeObject(strResult, returnType);
            if (result != null)
            {
                context.ReturnValue = ResultFactory(result, returnType, context.IsAsync());
            }
            else
            {
                result = await RunAndGetReturn(context, next);
                if (_expireSecond > 0)
                {
                    cache.Set(key, result, TimeSpan.FromMinutes(_expireSecond));
                }
                else
                {
                    cache.Set(key, result);
                }
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }

    private static string GetKey(MethodInfo method, object[] parameters)
    {
        return GetKey(method.DeclaringType.Name, method.Name, parameters);
    }
    private static string GetKey(string className, string methodName, object[] parameters)
    {
        var paramConcat = parameters.Length == 0 ? string.Empty : ":" + JsonConvert.SerializeObject(parameters);
        return $"{className}:{methodName}{paramConcat}";
    }


    /// <summary>
    /// 获取被拦截方法返回值类型
    /// </summary>
    /// <param name="context"></param>
    /// <returns></returns>
    private Type GetReturnType(AspectContext context)
    {
        return context.IsAsync()
            ? context.ServiceMethod.ReturnType.GetGenericArguments().First()
            : context.ServiceMethod.ReturnType;
    }

    /// <summary>
    /// 执行被拦截方法
    /// </summary>
    /// <param name="context"></param>
    /// <param name="next"></param>
    /// <returns></returns>
    private async Task<object> RunAndGetReturn(AspectContext context, AspectDelegate next)
    {
        await context.Invoke(next);
        return context.IsAsync()
        ? await context.UnwrapAsyncReturnValue()
        : context.ReturnValue;
    }

    /// <summary>
    /// 处理拦截器返回结果
    /// </summary>
    /// <param name="result"></param>
    /// <param name="returnType"></param>
    /// <param name="isAsync"></param>
    /// <returns></returns>
    private object ResultFactory(object result, Type returnType, bool isAsync)
    {
        return !isAsync
            ? result
            : TypeofTaskResultMethod
                .GetOrAdd(returnType, t => typeof(Task)
                .GetMethods()
                .First(p => p.Name == "FromResult" && p.ContainsGenericParameters)
                .MakeGenericMethod(returnType))
                .Invoke(null, new object[] { result });
    }
    #endregion

复制代码
多租户
复制代码
public class MultiTenantAttribute : ActionFilterAttribute, IActionFilter
{
///
/// 全局注册过滤器 ，自动为添加 更新方法赋值。也可自行手动打上特性标签
///
///
//private string[] methods = new string[] { “add”, “modify” };
public override void OnActionExecuting(ActionExecutingContext context)
{
var actionDescriptor = context.ActionDescriptor as ControllerActionDescriptor;
var actionName = actionDescriptor.ActionName.ToLower();
ICacheHelper cache = context.HttpContext.RequestServices.GetRequiredService(typeof(ICacheHelper)) as ICacheHelper;
var siteId = cache.Get(KeyHelper.Cms.CurrentSite)?.Id;
//如果是增加和修改方法 根据站群id
//if (methods.Any(o => actionName.Contains(o)))
//{
foreach (var parameter in actionDescriptor.Parameters)
{
var parameterName = parameter.Name;//获取Action方法中参数的名字
var parameterType = parameter.ParameterType;//获取Action方法中参数的类型
//if (!typeof(int).IsAssignableFrom(parameterType))//如果不是ID类型
//{
// continue;
//}
//自动添加租户id
if (typeof(IGlobalSite).IsAssignableFrom(parameterType))
{
var model = context.ActionArguments[parameterName] as IGlobalSite;
if (siteId != null)
{

                        model.SiteId = siteId.Value;
                    }
                }
            }
        //}
    }
}

}
复制代码
控制器单表CRUD API
复制代码
///
/// 适用于多租户模块使用
///
/// 实体
/// 详情查询参数实体
/// 删除实体
/// 列表分页查询参数实体
/// 创建实体
/// 更新实体
[Route(“api/[controller]/[action]”)]
[ApiController]
[Authorize]
[MultiTenant]
public abstract class ApiTenantBaseController<TEntity, TDetailQuery, TDeleteInput, TListQuery, TCreateInput, TUpdateInput> : ControllerBase
where TEntity : BaseSiteEntity, new()
where TDetailQuery : DetailSiteQuery
where TDeleteInput : DeletesSiteInput
where TListQuery : ListSiteQuery
where TCreateInput : class
where TUpdateInput : class
{
private readonly IBaseServer _service;
private readonly IMapper _mapper;

    public ApiTenantBaseController(IBaseServer<TEntity> service, IMapper mapper)
    {
        _service = service;
        _mapper = mapper;
    }
    /// <summary>
    /// 批量真实删除
    /// </summary>
    /// <param name="deleteInput"></param>
    /// <returns></returns>
    [HttpDelete]
    public virtual async Task<ApiResult> Deletes([FromBody] TDeleteInput deleteInput)
    {
        var res = await _service.DeleteAsync(deleteInput.Ids);
        if (res <= 0)
        {
            throw new FriendlyException("删除失败了！");
        }
        return new ApiResult();
    }
    /// <summary>
    /// 单个真实删除
    /// </summary>
    /// <param name="deleteInput"></param>
    /// <returns></returns>
    [HttpDelete]
    public virtual async Task<ApiResult> Delete([FromBody] TDeleteInput deleteInput)
    {
        foreach (var item in deleteInput.Ids)
        {
            var res = await _service.DeleteAsync(d => d.Id == item && d.SiteId == deleteInput.SiteId);
            if (res <= 0)
            {
                throw new FriendlyException("删除失败了！");
            }
        }
        return new ApiResult();
    }
    /// <summary>
    /// 软删除
    /// </summary>
    /// <param name="deleteInput"></param>
    /// <returns></returns>
    [HttpDelete]
    public virtual async Task<ApiResult> SoftDelete([FromBody] TDeleteInput deleteInput)
    {
        foreach (var item in deleteInput.Ids)
        {
            var res = await _service.UpdateAsync(d => new TEntity() { Status = false }, d => d.Id == item && d.SiteId == deleteInput.SiteId&&d.Status==true);
            if (res <= 0)
            {
                throw new FriendlyException("删除失败了！");
            }
        }
        return new ApiResult();
    }
    /// <summary>
    /// 列表分页
    /// </summary>
    /// <param name="listQuery">参数实体</param>
    /// <returns></returns>
    [HttpGet]
    public virtual async Task<ApiResult> GetListPages([FromQuery] TListQuery listQuery)
    {
        var res = await _service.GetPagesAsync(listQuery.Page, listQuery.Limit, d => d.SiteId == listQuery.SiteId&&d.Status==true, d => d.Id, false);
        return new ApiResult(data: new { count = res.TotalItems, items = res.Items });
    }

    /// <summary>
    /// 详情
    /// </summary>
    /// <param name="detailQuery">参数实体</param>
    /// <returns></returns>
    [HttpGet]
    public virtual async Task<ApiResult> Detail([FromQuery] TDetailQuery detailQuery)
    {
        var res = await _service.GetModelAsync(d => d.Id == detailQuery.Id && d.SiteId == detailQuery.SiteId&&d.Status==true);
        return new ApiResult(data: res);
    }
    /// <summary>
    /// 添加
    /// </summary>
    /// <param name="createInput">添加实体</param>
    /// <returns></returns>
    [HttpPost]
    public virtual async Task<ApiResult> Add([FromBody] TCreateInput createInput)
    {
        var entity = _mapper.Map<TEntity>(createInput);
        var res = await _service.AddAsync(entity);
        if (res <= 0)
        {
            throw new FriendlyException("添加失败了！");
        }
        return new ApiResult(data: res);
    }
    /// <summary>
    /// 修改-默认忽略更新CreateTime字段
    /// </summary>
    /// <param name="updateInput">修改实体</param>
    /// <returns></returns>
    [HttpPut]
    public virtual async Task<ApiResult> Modify([FromBody] TUpdateInput updateInput)
    {
        var entity = _mapper.Map<TEntity>(updateInput);
        var res = await _service.UpdateAsync(entity, d => new { d.CreateTime });
        if (res <= 0)
        {
            throw new FriendlyException("修改失败了！");
        }
        return new ApiResult(data: res);
    }
}

复制代码
效果图

总结
好了，又要到说再见的时候了，框架我只要有时间就会一直更新下去，不合理的地方欢迎浏览代码指导批评，我希望这个框架从简单的一点一滴做起，慢慢地把它做大做强。算是程序员阶段最后一次做框架了，什么时候不更新了，有可能就转行了。大家也可以不使用这个框架，只要里面地思路能帮助到一部分人，我认为这就足够了。