LegalServiceV1/SourceCode/V2/ContractService/ContractService.Core/CommonManager/AttachFiles/AttachFileManager.cs

using System;
using System.IO;
using System.Threading.Tasks;
using Abp.Auditing;
using Abp.AutoMapper;
using Abp.Configuration;
using Abp.Dependency;
using Abp.Domain.Repositories;
using Abp.Localization;
using Abp.Localization.Sources;
using Abp.ObjectMapping;
using Abp.UI;
using ContractService.BaseInfo;
using ContractService.Configuration;
using IwbZero;
using IwbZero.ToolCommon.LogHelpers;

namespace ContractService.CommonManager.AttachFiles
{
    public class AttachFileManager : IAttachFileManager, ISingletonDependency
    {
        public AttachFileManager(ISettingManager settingManager, IRepository<SysAttachFile> repository)
        {
            SettingManager = settingManager;
            Repository = repository;
            ObjectMapper = SingletonDependency<AutoMapperObjectMapper>.Instance;
            // ObjectMapper = resolver.Resolve<AutoMapperObjectMapper>();
        }

        private ISettingManager SettingManager { get; }
        private IRepository<SysAttachFile> Repository { get; }
        private IObjectMapper ObjectMapper { get; }

        /// <summary>
        /// 上传附件
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task FileUpload(AttachFileCreateDto input)
        {
            if (await IsValidFileType(input))
            {
                string filePath = string.IsNullOrEmpty(input.FilePath)
                    ? $"{SettingManager.GetSettingValue(IwbSettingNames.DownloadPath)}/{input.TableName}/{input.ColumnName}"
                    : input.FilePath;
                var lcRetVal = Base64ToFile(input.FileInfo, $"{input.FileName}-{DateTime.Now:yyMMddHHmmssfff}", input.FileExt, filePath);
                if (lcRetVal.StartsWith("error@"))
                {
                    throw new UserFriendlyException(lcRetVal.Split(new[] { '@' }, StringSplitOptions.RemoveEmptyEntries)[1]);
                }
                input.FilePath = lcRetVal;
                if (input.IsUpdate)
                {
                    var entity = await Repository.FirstOrDefaultAsync(a =>
                        a.TableName == input.TableName && a.ColumnName == input.ColumnName &&
                        a.SourceKey == input.SourceKey);
                    if (entity == null)
                    {
                        entity = ObjectMapper.Map<SysAttachFile>(input);
                        await Repository.InsertAsync(entity);
                    }
                    else
                    {
                        entity.FileExt = input.FileExt;
                        entity.FileName = input.FileName;
                        entity.FileTitle = input.FileTitle;
                        entity.FilePath = lcRetVal;
                        entity.FileType = input.FileType;
                        await Repository.UpdateAsync(entity);
                    }
                }
                else
                {
                    var entity = ObjectMapper.Map<SysAttachFile>(input);
                    await Repository.InsertAsync(entity);
                }
                
                return;
            }

            var allowExts = string.IsNullOrEmpty(input.AllowExt)
                ? await SettingManager.GetSettingValueAsync(IwbSettingNames.UploadFileExt)
                : input.AllowExt;
            throw new UserFriendlyException(L("FileUploadFileTypeInvalidFormatter", $"{input.FileName}.{input.FileExt}", allowExts));
        }


        /// <summary>
        /// 上传附件
        /// </summary>
        /// <returns></returns>
        [DisableAuditing]
        public async Task FileUpload(string fileInfo, string filePath, string fileName, string fileExt)
        {
            if (await IsValidFileType(fileExt))
            {

                var lcRetVal = Base64ToFile(fileInfo, $"{fileName}", fileExt, filePath);
                if (lcRetVal.StartsWith("error@"))
                {
                    throw new UserFriendlyException(lcRetVal.Split(new[] { '@' }, StringSplitOptions.RemoveEmptyEntries)[1]);
                }
                return;
            }

            var allowExts = await SettingManager.GetSettingValueAsync(IwbSettingNames.UploadFileExt);
            throw new UserFriendlyException(L("FileUploadFileTypeInvalidFormatter", $"{fileName}.{fileExt}", allowExts));
        }

        /// <summary>
        /// 上传附件
        /// </summary>
        /// <returns></returns>
        [DisableAuditing]
        public async Task FileUpload(string fileInfo, string filePath, string fileName, string fileExt, string allowExt)
        {
            if (await IsValidFileType(fileExt, allowExt, false, string.IsNullOrEmpty(allowExt)))
            {

                var lcRetVal = Base64ToFile(fileInfo, $"{fileName}", fileExt, filePath);
                if (lcRetVal.StartsWith("error@"))
                {
                    throw new UserFriendlyException(lcRetVal.Split(new[] { '@' }, StringSplitOptions.RemoveEmptyEntries)[1]);
                }
                this.LogInfo("文件保存路径：" + lcRetVal);
                return;
            }

            allowExt = string.IsNullOrEmpty(allowExt) ? await SettingManager.GetSettingValueAsync(IwbSettingNames.UploadFileExt) : allowExt;
            throw new UserFriendlyException(L("FileUploadFileTypeInvalidFormatter", $"{fileName}.{fileExt}", allowExt));
        }


        private async Task<bool> IsValidFileType(AttachFileCreateDto input)
        {
            return await IsValidFileType(input.FileExt, input.AllowExt, false, string.IsNullOrEmpty(input.AllowExt));
        }

        private async Task<bool> IsValidFileType(string fileName, string allowExts = null, bool isName = false,
            bool checkAll = false)
        {
            string ext = isName ? GetFileExt(fileName) : fileName;
            allowExts = checkAll
                ? $"{allowExts ?? ""},{await SettingManager.GetSettingValueAsync(IwbSettingNames.UploadFileExt)}"
                : allowExts;
            if (string.IsNullOrEmpty(allowExts))
                return true;
            string[] extList = allowExts.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
            foreach (var e in extList)
            {
                if (ext.ToLower() == e.ToLower())
                    return true;
            }
            this.LogError("上传的文件非法:" + fileName);
            return false;
        }

        private string GetFileExt(string fileName)
        {
            string fileExt = fileName.Substring(fileName.LastIndexOf(".", StringComparison.Ordinal) + 1, fileName.Length - fileName.LastIndexOf(".", StringComparison.Ordinal) - 1);
            return fileExt.ToLower();
        }

        private string Base64ToFile(string base64Str, string fileName, string fileExt, string filePath)
        {
            string lcRetVal = "error@";
            try
            {
                fileName = $"{fileName}.{fileExt}";
                filePath = filePath.StartsWith("/") ? filePath : ("/" + filePath);
                filePath = filePath.EndsWith("/") ? filePath : (filePath + "/");

                string path = $"{AppDomain.CurrentDomain.BaseDirectory}{filePath}";
                if (!Directory.Exists(path))
                    Directory.CreateDirectory(path);
                byte[] bytes = Convert.FromBase64String(base64Str);
                using (FileStream fs = new FileStream($"{path}{fileName}", FileMode.Create, FileAccess.Write))
                {
                    fs.Write(bytes, 0, bytes.Length);
                    fs.Close();
                }

                lcRetVal = filePath + fileName;
            }
            catch (Exception e)
            {
                this.LogError(e);
                lcRetVal += "FileUploadException";
            }

            return lcRetVal;
        }
        private string L(string name, params object[] args)
        {
            return LocalizationHelper.GetSource(IwbZeroConsts.LocalizationSourceName).GetString(name, args);
        }
    }
}