FISLib_Old/Vinno.FIS.Sonopost/WebApi/Controllers/SystemController.cs

using FISLib.LiveVideo;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Vinno.FIS.Sonopost.Common;
using Vinno.FIS.Sonopost.Features.Oled;
using Vinno.FIS.Sonopost.Helpers;
using Vinno.FIS.Sonopost.Settings;
using Vinno.FIS.Sonopost.WebApi.Models;
using Vinno.IUS.Common.Log;

namespace Vinno.FIS.Sonopost.WebApi.Controllers
{
    [WebApiController]
    internal class SystemController : BaseController
    {
        /// <summary>
        /// 重置
        /// </summary>
        /// <returns></returns>
        [WebApiAction]
        public Result Reset()
        {
            Task.Run(() =>
            {
                Task.Delay(1000);
                Logger.WriteLineInfo($"Sonopost Reset Invoke");
                OledManager.ShowStatus(OledMessage.Restore);
                SystemHelper.ResetSystem();
            });
            return Result.Success();
        }

        /// <summary>
        /// 重启
        /// </summary>
        /// <returns></returns>
        [WebApiAction]
        public Result Reboot()
        {
            Task.Run(() =>
            {
                Task.Delay(1000);
                Logger.WriteLineInfo($"Sonopost Reboot Invoke");
                OledManager.ShowStatus(OledMessage.Reboot);
                SystemHelper.RebootSystem();
            });
            return Result.Success();
        }

        /// <summary>
        /// 删除自定义配置
        /// </summary>
        /// <returns></returns>
        [WebApiAction]
        public Result DeleteUserDefinedSetting()
        {
            Task.Run(() =>
            {
                Task.Delay(1000);
                SonopostUserDefinedSettings.Instance.Reset();
                Logger.WriteLineInfo($"Sonopost DeleteUserDefinedSetting Invoke");
                OledManager.ShowStatus(OledMessage.Reboot);
                SystemHelper.RebootSystem();
            });
            return Result.Success();
        }

        /// <summary>
        /// 获取迷你屏语言
        /// </summary>
        /// <returns></returns>
        [WebApiAction]
        public Result GetOledLanguage()
        {
            return Result.Success(OledManager.CurrentLanguage.ToString());
        }

        /// <summary>
        /// 设置迷你屏语言
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [WebApiAction]
        public Result SetOledLanguage(SetLanguageRequest request)
        {
            var language = (Language)Enum.Parse(typeof(Language), request.Language);
            OledManager.SetLanguage(language);
            return Result.Success();
        }

        /// <summary>
        /// 获取页面语言
        /// </summary>
        /// <returns></returns>
        [WebApiAction]
        public Result GetPageLanguage()
        {
            switch (SonopostUserDefinedSettings.Instance.LanguageSetting.PageLanguage)
            {
                case Language.Chinese:
                    return Result.Success("zh-cn");

                case Language.Spanish:
                    return Result.Success("es-es");

                case Language.Russian:
                    return Result.Success("ru-ru");

                case Language.English:
                default:
                    return Result.Success("en-us");
            }
        }

        /// <summary>
        /// 设置页面语言
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [WebApiAction]
        public Result SetPageLanguage(SetLanguageRequest request)
        {
            if (request == null)
            {
                return Result.Fail();
            }
            if (request.Language.ToLower() == "zh-cn")
            {
                SonopostUserDefinedSettings.Instance.LanguageSetting.PageLanguage = Language.Chinese;
            }
            else if (request.Language.ToLower() == "ru-ru")
            {
                SonopostUserDefinedSettings.Instance.LanguageSetting.PageLanguage = Language.Russian;
            }
            else if (request.Language.ToLower() == "es-es")
            {
                SonopostUserDefinedSettings.Instance.LanguageSetting.PageLanguage = Language.Spanish;
            }
            else
            {
                SonopostUserDefinedSettings.Instance.LanguageSetting.PageLanguage = Language.English;
            }
            ConfigManager.Save();
            return Result.Success();
        }

        /// <summary>
        /// 设置语言,包含页面语言和OLED语言
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [WebApiAction]
        public Result SetLanguage(SetLanguageRequest request)
        {
            var requestString = JsonHelper.ToJson(request);
            Logger.WriteLineInfo($"Sonopost SetLanguage Invoke,{requestString}");
            if (request == null)
            {
                return Result.Fail();
            }
            if (request.Language.ToLower() == "zh-cn")
            {
                SonopostUserDefinedSettings.Instance.LanguageSetting.PageLanguage = Language.Chinese;
                OledManager.SetLanguage(Language.Chinese);
            }
            else if (request.Language.ToLower() == "ru-ru")
            {
                SonopostUserDefinedSettings.Instance.LanguageSetting.PageLanguage = Language.Russian;
                OledManager.SetLanguage(Language.English);
            }
            else if (request.Language.ToLower() == "es-es")
            {
                SonopostUserDefinedSettings.Instance.LanguageSetting.PageLanguage = Language.Spanish;
                OledManager.SetLanguage(Language.English);
            }
            else
            {
                SonopostUserDefinedSettings.Instance.LanguageSetting.PageLanguage = Language.English;
                OledManager.SetLanguage(Language.English);
            }
            ConfigManager.Save();
            return Result.Success();
        }

        /// <summary>
        /// 获取版本
        /// </summary>
        /// <returns></returns>
        [WebApiAction]
        public Result GetVersion()
        {
            string version = VersionCheckManager.GetVersion();
            return Result.Success(version);
        }

        /// <summary>
        /// 获取日志文本
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [WebApiAction]
        public Result GetLogText(SystemGetLogRequest request)
        {
            try
            {
                string path;
                path = Path.Combine(SonopostConstants.DataFolder, request.Path);
                string text = FileHelper.GetText(path);
                return Result.Success(text);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"[{nameof(SystemController)}]{nameof(GetLogText)} error:{ex}");
                return Result.Fail();
            }
        }

        /// <summary>
        /// 获取日志文件树
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [WebApiAction]
        public Result GetLogFileTree(SystemGetLogRequest request)
        {
            try
            {
                EnumLogType logType;
                var path = Path.Combine(SonopostConstants.DataFolder, request.Key);
                switch (request?.Key)
                {
                    case "Logs":
                        logType = EnumLogType.Logs;
                        break;

                    case "SmartLogs":
                        logType = EnumLogType.SmartLogs;
                        break;

                    case "TRTCLogs":
                        logType = EnumLogType.TRTCLogs;
                        break;

                    case "TRTCClientLogs":
                        logType = EnumLogType.TRTCClientLogs;
                        break;

                    default:
                        return Result.Fail();
                }
                var tree = GetLogDirSources(path, logType);
                return Result.Success(tree);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"[{nameof(SystemController)}]{nameof(GetLogFileTree)} error:{ex}");
                return Result.Fail();
            }
        }

        /// <summary>
        /// 读取彩虹图监测设置
        /// </summary>
        /// <returns></returns>
        [WebApiAction]
        public Result LoadRainbowImageDetectSetting()
        {
            try
            {
                var fisRainbowImageDetectConfig = new FISRainbowImageDetectConfig()
                {
                    IsDetectRainbowImage = SonopostSystemSettings.Instance.RainbowImageDetectSetting.IsDetectRainbowImage,
                    ScanIntervalTime = SonopostSystemSettings.Instance.RainbowImageDetectSetting.ScanIntervalTime,
                    BeforeDisableIntervalTime = SonopostSystemSettings.Instance.RainbowImageDetectSetting.BeforeDisableIntervalTime,
                    BeforeEnableIntervalTime = SonopostSystemSettings.Instance.RainbowImageDetectSetting.BeforeEnableIntervalTime,
                    AfterEnableIntervalTime = SonopostSystemSettings.Instance.RainbowImageDetectSetting.AfterEnableIntervalTime,
                };

                return Result.Success(fisRainbowImageDetectConfig);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Load Rainbow Image Detect Setting Error:{ex}");
                return Result.Fail();
            }
        }

        /// <summary>
        /// 设置彩虹图监测开关
        /// </summary>
        /// <returns></returns>
        [WebApiAction]
        public Result SaveRainbowImageDetectSetting(FISRainbowImageDetectConfig fisRainbowImageDetectConfig)
        {
            try
            {
                if (fisRainbowImageDetectConfig == null || fisRainbowImageDetectConfig.BeforeDisableIntervalTime <= 0 || fisRainbowImageDetectConfig.BeforeEnableIntervalTime <= 0 || fisRainbowImageDetectConfig.AfterEnableIntervalTime <= 0 || fisRainbowImageDetectConfig.ScanIntervalTime <= 0)
                {
                    return Result.Fail("PositiveIntFormatError");
                }
                SonopostSystemSettings.Instance.RainbowImageDetectSetting.BeforeEnableIntervalTime = fisRainbowImageDetectConfig.BeforeEnableIntervalTime;
                SonopostSystemSettings.Instance.RainbowImageDetectSetting.BeforeDisableIntervalTime = fisRainbowImageDetectConfig.BeforeDisableIntervalTime;
                SonopostSystemSettings.Instance.RainbowImageDetectSetting.AfterEnableIntervalTime = fisRainbowImageDetectConfig.AfterEnableIntervalTime;
                SonopostSystemSettings.Instance.RainbowImageDetectSetting.ScanIntervalTime = fisRainbowImageDetectConfig.ScanIntervalTime;
                SonopostSystemSettings.Instance.RainbowImageDetectSetting.IsDetectRainbowImage = fisRainbowImageDetectConfig.IsDetectRainbowImage;
                ConfigManager.Save();
                LiveVideoManager.UpdateRainbowImageDetectSetting();
                return Result.Success();
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Set Rainbow Image Detect Setting Error:{ex}");
                return Result.Fail();
            }
        }

        #region Private Methods

        private static dynamic GetLogDirSources(string path, EnumLogType logType)
        {
            int basePathLength = 0;
            switch (logType)
            {
                case EnumLogType.SmartLogs:
                case EnumLogType.TRTCLogs:
                case EnumLogType.TRTCClientLogs:
                case EnumLogType.Logs:
                    basePathLength = SonopostConstants.DataFolder.Length + "\\".Length;
                    break;
            }
            List<dynamic> array = new List<dynamic>();
            if (!Directory.Exists(path)) return array;

            DirectoryInfo directoryInfo = new DirectoryInfo(path);
            var subDirectories = directoryInfo.GetDirectories()?.OrderBy(x => x.CreationTime);
            if (subDirectories != null)
            {
                foreach (var item in subDirectories)
                {
                    array.Add(new
                    {
                        Name = item.Name,
                        Path = item.FullName.Substring(basePathLength),
                        Children = GetLogDirSources(item.FullName, logType)
                    });
                }
            }
            var fileInfos = directoryInfo.GetFiles()?.OrderBy(x => x.CreationTime);
            if (fileInfos != null)
            {
                foreach (var item in fileInfos)
                {
                    array.Add(new
                    {
                        Name = item.Name,
                        Path = item.FullName.Substring(basePathLength)
                    });
                }
            }
            return array;
        }

        #endregion Private Methods
    }
}