『JSA宏神助攻之五』使用搭建本地web服务让JSA宏连接本地文件读写

using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web;

namespace SelfHostedWebApiConsole
{
    class Program
    {
        private static HttpListener _listener;
        private static readonly string _url = $"http://localhost:{Properties.Settings.Default.WebApiPort}/";

        static void Main(string[] args)
        {
            StartServer();

            while (_listener.IsListening) // Loop to keep the main thread running while the listener is active.
            {
                Thread.Sleep(1000);
            }
        }

        public static void StartServer()
        {
            _listener = new HttpListener();
            _listener.Prefixes.Add(_url);
            _listener.Start();

            Console.WriteLine("Listening for connections on {0}", _url);

            Task.Run(() =>
            {
                while (_listener.IsListening)
                {
                    try
                    {
                        var context = _listener.GetContext();
                        ProcessRequest(context);
                    }
                    catch (HttpListenerException)
                    {
                        // This will occur on _listener.Stop()
                        break;
                    }
                }
            });
        }

        public static void StopServer()
        {
            if (_listener != null)
            {
                _listener.Stop();
                _listener.Close();
            }
        }

        private static void ProcessRequest(HttpListenerContext context)
        {
            var request = context.Request;
            var response = context.Response;

            try
            {
                switch (request.Url.AbsolutePath)
                {
                    case "/api/file/read":
                        ProcessFileRead(request, response);
                        break;
                    case "/api/file/write":
                        ProcessFileWrite(request, response);
                        break;
                    default:
                        response.StatusCode = (int)HttpStatusCode.NotFound;
                        break;
                }
            }
            finally
            {
                response.OutputStream.Close();
            }
        }

        private static void ProcessFileRead(HttpListenerRequest request, HttpListenerResponse response)
        {
            string filePath = GetFilePath(request);
            filePath = HttpUtility.UrlDecode(filePath, System.Text.Encoding.UTF8);
            var isBinary = bool.Parse(request.QueryString["isBinary"] ?? "false");
            var encodingName = request.QueryString["encoding"] ?? "utf-8"; // 默认为 UTF-8


            if (!File.Exists(filePath))
            {
                response.StatusCode = (int)HttpStatusCode.NotFound;
                return;
            }

            if (isBinary)
            {
                var fileBytes = File.ReadAllBytes(filePath);
                response.ContentType = "application/octet-stream";
                response.OutputStream.Write(fileBytes, 0, fileBytes.Length);
            }
            else
            {
                Encoding encoding;
                try
                {
                    encoding = Encoding.GetEncoding(encodingName);
                }
                catch (ArgumentException)
                {
                    response.StatusCode = (int)HttpStatusCode.BadRequest;
                    var errorMessage = Encoding.UTF8.GetBytes("Invalid encoding specified.");
                    response.OutputStream.Write(errorMessage, 0, errorMessage.Length);
                    return;
                }

                var fileContent = File.ReadAllText(filePath, encoding);
                var buffer = Encoding.UTF8.GetBytes(fileContent);
                response.ContentType = "text/plain; charset=utf-8";
                response.OutputStream.Write(buffer, 0, buffer.Length);
            }

            response.StatusCode = (int)HttpStatusCode.OK;
        }

        private static string GetFilePath(HttpListenerRequest request)
        {
            string rawUrl = request.RawUrl;
            Uri uri = new Uri("http://dummy" + rawUrl); // 加前缀是因为Uri需要完整的格式

            // 解析查询字符串
            NameValueCollection queryParameters = HttpUtility.ParseQueryString(uri.Query);
            string encodedFilePath = queryParameters["filePath"];
            if (!string.IsNullOrEmpty(encodedFilePath))
            {
                string decodedFilePath = Uri.UnescapeDataString(encodedFilePath);
                return Environment.ExpandEnvironmentVariables(decodedFilePath);
            }
            else
            {
                return string.Empty;
            }

        }

        private static void ProcessFileWrite(HttpListenerRequest request, HttpListenerResponse response)
        {
            string filePath = GetFilePath(request);
            var isBinary = bool.Parse(request.QueryString["isBinary"] ?? "false");
            var encodingName = request.QueryString["encoding"] ?? "utf-8"; // 默认为 UTF-8

            try
            {
                Encoding encoding = Encoding.GetEncoding(encodingName);
                if (isBinary)
                {
                    // 二进制模式，直接从流中读取并写入文件
                    using (var fs = new FileStream(filePath, FileMode.Create, FileAccess.Write))
                    {
                        request.InputStream.CopyTo(fs);
                    }
                }
                else
                {
                    // 文本模式，使用指定的编码读取文本内容并写入文件
                    using (var reader = new StreamReader(request.InputStream, encoding))
                    {
                        var content = reader.ReadToEnd();
                        File.WriteAllText(filePath, content, encoding);  // 使用提供的编码写入文件
                    }
                }
                response.StatusCode = (int)HttpStatusCode.OK;
                var responseMessage = "File written successfully";
                var responseBuffer = Encoding.UTF8.GetBytes(responseMessage);
                response.OutputStream.Write(responseBuffer, 0, responseBuffer.Length);
            }
            catch (ArgumentException)
            {
                // 编码不支持或无效
                response.StatusCode = (int)HttpStatusCode.BadRequest;
                var errorMessage = Encoding.UTF8.GetBytes("Invalid encoding specified.");
                response.OutputStream.Write(errorMessage, 0, errorMessage.Length);
            }
        }


    }
}

async function testTextFileOperations() {
    // 定义读取和写入的文件名及其他参数
    const readFileName = 'C:/Users/19026/Desktop/测试文本.txt';
    const writeFileName = 'C:/Users/19026/Desktop/测试文本写入.txt';
    const isBinary = false; // 明确指定处理非二进制（文本）文件

    // 构建读取请求的URL
    const readUrl = `http://localhost:6789/api/file/read?filePath=${encodeURIComponent(readFileName)}&isBinary=${isBinary}`;

    try {
        // 使用fetch读取文本文件
        const readResponse = await fetch(readUrl);
        if (!readResponse.ok) {
            throw new Error('Failed to read file: ' + await readResponse.text());
        }
        const textContent = await readResponse.text();
        console.log('File read successfully:', textContent);

        // 可以在此处修改textContent，例如添加一些文本
        const modifiedContent = textContent + "\nAdditional line added by the script.";

        // 第二步：将修改后的文本内容写入另一个文件
        const writeUrl = `http://localhost:6789/api/file/write?filePath=${encodeURIComponent(writeFileName)}&isBinary=${isBinary}`;

        // 使用fetch写入文本文件
        const writeResponse = await fetch(writeUrl, {
            method: 'POST',
            headers: {
                'Content-Type': 'text/plain; charset=utf-8'
            },
            body: modifiedContent
        });

        if (!writeResponse.ok) {
            throw new Error('Failed to write file: ' + await writeResponse.text());
        }
        console.log('File written successfully');
    } catch (error) {
        console.error('Error:', error);
    }
}