文本日志查看

huanghongfeng

2024-12-08 05c2e8aadb518a6323ff9fe23051fdbd56097221

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_ISystemServices/ISys_LogService.cs

@@ -1,14 +1,238 @@
using System;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseServices;
using WIDESEAWCS_Model.Models;

namespace WIDESEAWCS_ISystemServices
{
    #region å®žä½“ç±»
    public class DirInfo
    {
        /// <summary>
        /// å½“前路径
        /// </summary>
        public string dirPath { get; set; }

        /// <summary>
        /// å½“前名称
        /// </summary>
        public string dirName { get; set; }

        /// <summary>
        /// å­æ–‡ä»¶
        /// </summary>
        public List<FileDataInfo> files { get; set; }

        /// <summary>
        /// å­æ–‡ä»¶å¤¹
        /// </summary>
        public List<DirInfo> dirs { get; set; }
    }

    public class FileDataInfo
    {
        public string filePath { get; set; }

        public string fileName { get; set; }

        public long fileSize { get; set; }
    }

    public class GetLogParm
    {
        /// <summary>
        /// æ–‡ä»¶åœ°å€
        /// </summary>
        public string path;

        /// <summary>
        /// è¯»å–进度
        /// </summary>
        public float percent;

        /// <summary>
        /// æœ€å¤§è¯»å–大小
        /// </summary>
        public double maxsize_KB = 20;

        /// <summary>
        /// å½“前起始位置
        /// </summary>
        public long topStartPos = 0;
    }
    #endregion
    public interface ISys_LogService : IService<Sys_Log>
    {
        /// <summary>
        /// é€’归获取文件信息
        /// </summary>
        /// <param name="dirPath"></param>
        /// <returns></returns>
        private DirInfo GetDirInfo(string dirPath)
        {
            //当前文件夹
            var dirInfo = new DirInfo();
            dirInfo.dirName = Path.GetFileName(dirPath);

            //子文件
            List<FileDataInfo> files = new List<FileDataInfo>();
            foreach (var file in Directory.GetFiles(dirPath))
            {
                files.Add(new FileDataInfo()
                {
                    filePath = file,
                    fileName = Path.GetFileName(file)
                });
            }

            //子文件夹
            var dirs = Directory.GetDirectories(dirPath);
            dirInfo.dirs = new List<DirInfo>();
            foreach (var dir in dirs)
            {
                dirInfo.dirs.Add(GetDirInfo(dir));
            }

            //子文件夹，与子目录合并
            foreach (var file in files)
            {
                dirInfo.dirs.Add(new DirInfo() { dirPath = file.filePath, dirName = file.fileName });
            }
            return dirInfo;
        }

        /// <summary>
        /// èŽ·å–日志文件列表
        /// </summary>
        /// <returns></returns>
        public WebResponseContent GetLogList()
        {
            WebResponseContent content = new WebResponseContent();
            string path = System.Environment.CurrentDirectory + "/log";
            if (!System.IO.Directory.Exists(path))
            {
                return content.Error("暂无日志文件");
            }

            content.Data = GetDirInfo(path);
            content.OK();
            return content;
        }

        /// <summary>
        /// èŽ·å–文件内容
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public WebResponseContent GetLogData(GetLogParm parm)
        {
            WebResponseContent content = new WebResponseContent();
            string res = "";
            //是否读取到最后
            bool isEnd = false;
            long startIndex = 0;
            //文件大小
            long len = 0;
            try
            {
                if (!System.IO.File.Exists(parm.path))
                {
                    throw new Exception($"文件{parm.path}不存在！");
                }
                using (FileStream fs = new FileStream(parm.path, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    //最大读取大小
                    int maxsize = (int)(1024 * parm.maxsize_KB);
                    len = fs.Length;
                    long startPos = (long)(len * (parm.percent / 100));//起始位置
                    long readLen = len - startPos;//读取长度

                    //向前加载
                    if (parm.topStartPos != 0)
                    {
                        startPos = parm.topStartPos - maxsize;
                        if (startPos < 0)
                        {
                            //已读到起始位
                            startPos = 0;
                            readLen = parm.topStartPos;
                        }
                        else
                        {
                            readLen = maxsize;
                        }
                    }
                    else
                    {
                        //读取大小是否超出最大长度
                        if (readLen > maxsize)
                        {
                            readLen = maxsize;
                        }
                        else
                        {
                            isEnd = true;
                        }
                    }

                    //加载100%，按最大内容读取
                    if (parm.percent == 100)
                    {
                        if (len < maxsize)
                        {
                            startPos = 0;
                            readLen = len;
                        }
                        else
                        {
                            startPos = len - maxsize;
                            readLen = maxsize;
                        }
                    }

                    fs.Seek(startPos, SeekOrigin.Begin);
                    var buffer = new byte[readLen];
                    fs.Read(buffer, 0, (int)readLen);

                    startIndex = startPos;
                    if (startPos != 0 && (parm.percent != 0 || parm.topStartPos != 0))
                    {
                        //不是从头加载，删除可能不完整的第一行
                        int skipCount = 0;
                        for (int i = 0; i < buffer.Length; i++)
                        {
                            if (buffer[i] == 10)
                            {
                                skipCount = i;
                                break;
                            }
                        }
                        if (skipCount != 0)
                        {
                            //去掉换行
                            skipCount++;
                            //下次读取前延
                            startIndex += skipCount;
                        }
                        res = Encoding.UTF8.GetString(buffer.Skip(skipCount).ToArray());
                    }
                    else
                    {
                        res = Encoding.UTF8.GetString(buffer);
                    }
                }
            }
            catch (Exception ex)
            {
                return content.Error(ex.Message);
            }
            return content.OK(data: new { content = res, isEnd, startIndex, len });
        }

    }
}