Sunji-posv-net/pos/POSV.Core/Utils/MessageCenterUtils.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using NLog;
using POSV.Common.Http;
using POSV.Common.Transport;
using POSV.Common.Util;
using POSV.Entity;

namespace POSV.Utils
{
    public class MessageCenterUtils
    {
        private static Logger logger = NLog.LogManager.GetCurrentClassLogger();

        private static object _lock = new object();

        private static MessageCenterUtils _instance = null;

        /// <summary>
        /// 消息中心Http服务访问地址
        /// </summary>
        private readonly string _context_path = "/api/v1";

        private string _baseUrl = string.Empty;

        private string _message = string.Empty;

        private HttpManager _httpManager = null;

        public static MessageCenterUtils Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_lock)
                    {
                        _instance = new MessageCenterUtils();

                        _instance.InitMessageCenter();
                    }
                }

                return _instance;
            }
        }

        private void InitMessageCenter()
        {
            try
            {
                this._httpManager = new HttpManager();


                //获取消息中心配置
                var messageCenter = Global.Instance.EnableServiceCenter;

                if (messageCenter.Item1)
                {
                    //Web服务地址
                    string url = messageCenter.Item3;
                    //Web服务端口为基础端口+1
                    int port = messageCenter.Item4 + 1;

                    this._baseUrl = string.Format("http://{0}:{1}{2}", url, port, this._context_path);

                    this._message = messageCenter.Item2;
                }
                else
                {
                    this._baseUrl = string.Empty;

                    this._message = messageCenter.Item2;
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "初始化消息中心异常");
            }
        }

        /// <summary>
        /// 检测消息中心是否正常。1)没有配置消息中心;2)启用了消息中心是否连接；
        /// </summary>
        /// <returns></returns>
        public Tuple<bool, bool> IsAvailable()
        {
            bool enabled = false;
            bool connected = false;

            try
            {
                Stopwatch watch = Stopwatch.StartNew();

                //是否启用消息中心
                bool enabledMessageCenter = Global.Instance.GlobalConfigBoolValue(ConfigConstant.DEVICE_SERVICECENTER_ENABLE, false);
                if (enabledMessageCenter)
                {
                    enabled = true;
                }
                else
                {
                    enabled = false;
                }

                if (enabled)
                {
                    logger.Info("开始检测服务中心是否通畅耗时");

                    //获取配置的参数
                    string host = Global.Instance.GlobalConfigStringValue(ConfigConstant.DEVICE_SERVICECENTER_IP, string.Empty);
                    int port = Global.Instance.GlobalConfigIntValue(ConfigConstant.DEVICE_SERVICECENTER_PORT, 0);

                    //IP和端口配置错误
                    if (string.IsNullOrEmpty(host) || port == 0)
                    {
                        connected = false;
                    }
                    else
                    {
                        //检测IP和端口是否通畅
                        var url = string.Format("{0}{1}", this._baseUrl, "/amok");
                        HttpResult hr = this._httpManager.Get(url, null, 2000);

                        connected = (hr.Code == 200);
                    }
                }
                else
                {
                    connected = false;
                }
                logger.Info("检测服务中心是否通畅[{0}]耗时<{1}>", connected, watch.ElapsedMilliseconds);
            }
            catch (Exception ex)
            {
                logger.Error(ex, "连接消息中心失败");

                enabled = false;
                connected = false;
            }

            return new Tuple<bool, bool>(enabled, connected);
        }


        /// <summary>
        /// 是否采用共享沽清
        /// </summary>
        public bool IsSaleClear
        {
            get
            {
                //是否启用共享沽清
                var enableSaleClear = Global.Instance.GlobalConfigBoolValue(ConfigConstant.DEVICE_SALECLEAR_ENABLE, false);

                //1)启用消息中心;2)消息中心连接正常;3)参数配置中设置了共享沽清
                return Global.Instance.MessageCenterOnline.Item1 && Global.Instance.MessageCenterOnline.Item2 && enableSaleClear;
            }
        }


        /// <summary>
        /// 加载服务中心的全局票号
        /// </summary>
        /// <param name="length"></param>
        /// <returns></returns>
        public Tuple<bool, string, string> GetGlobalTicketNo(int length = 4)
        {
            lock (Global.Instance.CacheLock)
            {
                try
                {
                    if (!string.IsNullOrEmpty(this._baseUrl))
                    {
                        var url = string.Format("{0}{1}{2}", this._baseUrl, "/trade/", length);

                        HttpResult hr = this._httpManager.Get(url, null);

                        if (hr.Code == 200)
                        {
                            return new Tuple<bool, string, string>(true, string.Format("获取到全局票号成功<{0}>", hr.Text), hr.Text);
                        }
                        else
                        {
                            return new Tuple<bool, string, string>(false, string.Format("获取到全局票号失败<{0}>", hr.Text), hr.Text);
                        }
                    }
                    else
                    {
                        return new Tuple<bool, string, string>(false, this._message, string.Empty);
                    }
                }
                catch (Exception ex)
                {
                    logger.Error(ex, "获取全局票号异常");

                    return new Tuple<bool, string, string>(false, "获取全局票号失败", string.Empty);
                }
            }
        }

        /// <summary>
        /// 加载服务中心全局序号
        /// </summary>
        /// <param name="length"></param>
        /// <param name="initialValue"></param>
        /// <returns></returns>
        public Tuple<bool, string, string> GetGlobalOrderNo(int length = 2, int initialValue = 0)
        {
            lock (Global.Instance.CacheLock)
            {
                try
                {
                    if (!string.IsNullOrEmpty(this._baseUrl))
                    {
                        var url = string.Format("{0}{1}{2}/{3}", this._baseUrl, "/order/", length, initialValue);

                        HttpResult hr = this._httpManager.Get(url, null);

                        if (hr.Code == 200)
                        {
                            return new Tuple<bool, string, string>(true, string.Format("获取到全局序号成功<{0}>", hr.Text), hr.Text);
                        }
                        else
                        {
                            return new Tuple<bool, string, string>(false, string.Format("获取到全局序号失败<{0}>", hr.Text), hr.Text);
                        }
                    }
                    else
                    {
                        return new Tuple<bool, string, string>(false, this._message, string.Empty);
                    }
                }
                catch (Exception ex)
                {
                    logger.Error(ex, "获取全局序号异常");

                    return new Tuple<bool, string, string>(false, "获取全局序号失败", string.Empty);
                }
            }
        }

        /// <summary>
        /// 加载全局沽清数据
        /// </summary>
        /// <param name="dateTimer"></param>
        /// <returns></returns>
        public Tuple<bool, string, List<SaleClear>> GetGlobalAvailableSaleClear()
        {
            try
            {
                var url = string.Format("{0}{1}", this._baseUrl, "/sale/clear");

                HttpResult hr = this._httpManager.PostJson(url, "{}", null);
                if (hr.Code == 200)
                {
                    logger.Info(hr.Text);

                    var obj = JsonUtils.Deserialize<TransportResponse<List<SaleClear>>>(hr.Text);

                    logger.Info(obj.Data);

                    if (obj.Status == 1)
                    {
                        return new Tuple<bool, string, List<SaleClear>>(true, obj.Message, obj.Data);
                    }
                    else
                    {
                        return new Tuple<bool, string, List<SaleClear>>(false, obj.Message, new List<SaleClear>());
                    }
                }
                else
                {
                    return new Tuple<bool, string, List<SaleClear>>(false, "获取沽清数据错误", new List<SaleClear>());
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "获取沽清数据异常");

                return new Tuple<bool, string, List<SaleClear>>(false, "获取沽清数据异常", new List<SaleClear>());
            }
        }

        public Tuple<bool, string, List<SaleClear>> GetSaleClearList(string dateTimer = null)
        {
            try
            {
                if (!string.IsNullOrEmpty(this._baseUrl))
                {
                    var url = string.Format("{0}{1}", this._baseUrl, "/sale/clear/list");

                    //构建POST的JSON参数，date为空标识今日沽清
                    var body = new Dictionary<string, string>();
                    body["date"] = string.Empty;

                    //指定日期的沽清
                    if (!string.IsNullOrEmpty(dateTimer))
                    {
                        body["date"] = dateTimer;
                    }

                    HttpResult hr = this._httpManager.PostJson(url, JsonUtils.Serialize(body), null);
                    if (hr.Code == 200)
                    {
                        var obj = JsonUtils.Deserialize<TransportResponse<List<SaleClear>>>(hr.Text);

                        if (obj.Status == 1)
                        {
                            var data = obj.Data as List<SaleClear>;

                            return new Tuple<bool, string, List<SaleClear>>(true, obj.Message, data);
                        }
                        else
                        {
                            return new Tuple<bool, string, List<SaleClear>>(false, obj.Message, new List<SaleClear>());
                        }
                    }
                    else
                    {
                        return new Tuple<bool, string, List<SaleClear>>(false, "获取沽清列表数据错误", new List<SaleClear>());
                    }
                }
                else
                {
                    return new Tuple<bool, string, List<SaleClear>>(false, this._message, new List<SaleClear>());
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "获取沽清列表数据异常");

                return new Tuple<bool, string, List<SaleClear>>(false, "获取沽清列表数据异常", new List<SaleClear>());
            }
        }


        public Tuple<bool, string> ChangeSaleClear(SaleClear saleClear)
        {
            lock (Global.Instance.CacheLock)
            {
                try
                {
                    if (!string.IsNullOrEmpty(this._baseUrl))
                    {
                        var url = string.Format("{0}{1}", this._baseUrl, "/sale/clear/change");

                        //将沽清对象序列化，传递到http
                        var body = JsonUtils.Serialize(saleClear);

                        HttpResult hr = this._httpManager.PostJson(url, body, null);
                        if (hr.Code == 200)
                        {
                            logger.Info("变更沽清信息，服务中心的应答");
                            logger.Info(hr.Text);

                            var obj = JsonUtils.Deserialize<TransportResponse<SaleClear>>(hr.Text);

                            SaleClearUtils.Instance.SaveOrUpdateNoChanged(obj.Data);


                            return new Tuple<bool, string>(true, "获取沽清列表数据错误");
                        }
                        else
                        {
                            return new Tuple<bool, string>(false, "获取沽清列表数据错误");
                        }
                    }
                    else
                    {
                        return new Tuple<bool, string>(false, this._message);
                    }
                }
                catch (Exception ex)
                {
                    logger.Error(ex, "获取沽清列表数据异常");

                    return new Tuple<bool, string>(false, "获取沽清列表数据异常");
                }
            }
        }
    }
}