vStationURM/Server/ReportConverter/GetReportInfo.cs

using System;
using System.IO;
using System.Threading.Tasks;
using Vinno.IUS.Common.IO;
using Vinno.vCloud.Common.Storage.Download;
using Vinno.vCloud.Report.Models;

namespace ReportConverter
{
    class GetReportInfo
    {
        private readonly string _storageServerUrl = string.Empty;
        private readonly int _storageType = 0;
        private readonly string _fileCacheFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DownloadFileCacheFolder");
      
        public GetReportInfo(string storageServerUrl, int storageType)
        {
            _storageServerUrl = storageServerUrl ?? string.Empty;
            _storageType = storageType;
        }

        /// <summary>
        /// get report image from storage server
        /// </summary>
        /// <param name="reportInfo">reportInfo entitys</param>
        /// <returns></returns>
        public async Task<ReportInfo> GetReportInfoAsync(ReportInfo reportInfo)
        {
            foreach (var elementValue in reportInfo.ElementValues.Values)
            {
                if (elementValue is ImageListElementValue imageListElementValue)
                {
                    var fileImageValues = imageListElementValue.Value;
                    if (fileImageValues != null)
                    {
                        foreach (var fileImage in fileImageValues)
                        {
                            if (fileImage is FileImageValue fileImageValue)
                            {
                                if (!string.IsNullOrEmpty(fileImageValue.Value) && !fileImageValue.Value.Equals(fileImageValue.ExamDataId))
                                {
                                    fileImageValue.ImageBuffer = new ByteBuffer(await GetFileAsync(fileImageValue.Value));
                                }
                                else
                                {
                                    WriteErrorLog($"GetFileAsync {fileImageValue.Value} error");
                                    return null;
                                }
                            }
                        }
                    }
                }
                else if (elementValue is FileImageValue fileImageValue)
                {
                    fileImageValue.ImageBuffer = new ByteBuffer(await GetFileAsync(fileImageValue.Value));
                }
            }
            return reportInfo;
        }

        private async Task<byte[]> GetFileAsync(string token)
        {
            try
            {
                var buffer = await DownloadHelper.GetFileAsync(token, _fileCacheFolder, null, null, 10000);
                var data = new byte[0];
                if (buffer is ByteBuffer byteBuffer)
                {
                    data = byteBuffer.GetBytes();
                }
                else if (buffer is FileBuffer fileBuffer)
                {
                    data = fileBuffer.ReadBytes(0, fileBuffer.Size);
                    fileBuffer.DeleteFile();
                }
                return data;
            }
            catch (Exception e)
            {
                WriteErrorLog($"GetFileAsync {token} error:{e}");
                return new byte[0];
            }
        }

        private void WriteErrorLog(string content)
        {
            string errPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Error");
            if (!Directory.Exists(errPath)) {
                Directory.CreateDirectory(errPath); 
            }
            File.AppendAllText(Path.Combine(errPath, $"{DateTime.Now.ToString("yyyyMMdd_HHmmss")}.log"),content);
        }
    }
}