Laservall_solidworks_inject/Server/Handlers/SettingsHandler.cs

using Laservall.Solidworks.Model;
using Laservall.Solidworks.Server.Dto;
using Newtonsoft.Json;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Laservall.Solidworks.Server.Handlers
{
    internal sealed class SettingsHandler
    {
        private readonly IBomDataProvider _dataProvider;

        public SettingsHandler(IBomDataProvider dataProvider)
        {
            _dataProvider = dataProvider;
        }

        public async Task HandleGet(HttpListenerContext context, CancellationToken ct)
        {
            var settings = _dataProvider.GetSettings();
            var dto = new SettingsDto
            {
                Columns = settings.Columns.Select(c => new ColumnConfigDto
                {
                    Name = c.Name,
                    IsVisible = c.IsVisible,
                    IsExport = c.IsExport,
                    IsFixed = c.IsFixed,
                    IsUserAdded = c.IsUserAdded
                }).ToList(),
                RemovedKeys = settings.RemovedKeys?.ToList() ?? new List<string>()
            };

            await WriteJson(context.Response, dto, ct);
        }

        public async Task HandlePost(HttpListenerContext context, CancellationToken ct)
        {
            string body;
            using (var reader = new StreamReader(context.Request.InputStream, Encoding.UTF8))
            {
                body = await reader.ReadToEndAsync();
            }

            var dto = JsonConvert.DeserializeObject<SettingsDto>(body);
            if (dto == null)
            {
                context.Response.StatusCode = 400;
                byte[] err = Encoding.UTF8.GetBytes("{\"error\":\"Invalid settings\"}");
                context.Response.ContentType = "application/json; charset=utf-8";
                context.Response.ContentLength64 = err.Length;
                await context.Response.OutputStream.WriteAsync(err, 0, err.Length, ct);
                context.Response.Close();
                return;
            }

            var settings = _dataProvider.GetSettings();
            settings.Columns = dto.Columns.Select(c => new BomColumnConfig
            {
                Name = c.Name,
                IsVisible = c.IsVisible,
                IsExport = c.IsExport,
                IsFixed = c.IsFixed,
                IsUserAdded = c.IsUserAdded
            }).ToList();
            settings.RemovedKeys = new HashSet<string>(dto.RemovedKeys ?? new List<string>());

            _dataProvider.SaveSettings(settings);

            await WriteJson(context.Response, new { success = true }, ct);
        }

        private static async Task WriteJson(HttpListenerResponse response, object data, CancellationToken ct)
        {
            response.StatusCode = 200;
            response.ContentType = "application/json; charset=utf-8";
            string json = JsonConvert.SerializeObject(data);
            byte[] bytes = Encoding.UTF8.GetBytes(json);
            response.ContentLength64 = bytes.Length;
            await response.OutputStream.WriteAsync(bytes, 0, bytes.Length, ct);
            response.Close();
        }
    }
}