code-layout/GeneratorCode/Program.cs

using System;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Threading;
using GeneratorCode.Configure;
using GeneratorCode.Logs;
using Newtonsoft.Json;
using TmatrixLibrary;

namespace GeneratorCode
{
    public class GeneratorParams
    {
        public GeneratorParams()
        {
            dpi = new[] { 0, 0, 0, 0 };
            point_type = new[] { 0, 0, 0, 0 };
            image_type = new[] { false, false, false, true };
            StartPageID = 0;
            key = "S0,O000,B0000,P000-255,D2018/12/31;CCAFBQMXYPOAOCIRK52S8QC8SO4A0AGA8Y";
            //filePath = "E:\\NetEase\\轨迹笔\\Sample\\123.pdf"; //"C:\\Works\\pdf\\123.pdf";
            filePath = "C:\\Works\\pdf\\123.pdf";
            sessionId = "4BD5D923-47EA-4DEF-A1CD-9B85B515B191";
        }

        public int[] dpi { get; set; }

        public int[] point_type { get; set; }

        public bool[] image_type { get; set; }

        public string key { get; set; }

        public string filePath { get; set; }

        public int StartPageID { get; set; }

        public string sessionId { get; set; }
    }

    public class GenerCodeRet
    {
        public GenerCodeRet(string sId, int prg)
        {
            sessionId = sId;
            progress = prg;
        }

        public string sessionId { get; set; }

        public int progress { get; set; }
    }

    public class RspMessage
    {
        public RspMessage(string sId)
        {
            err = 0;
            msg = "";
            data = new GenerCodeRet(sId, 0);
        }

        public RspMessage(string sId, int prg)
        {
            err = 0;
            msg = "";
            data = new GenerCodeRet(sId, prg);
        }

        public int err { get; set; }

        public string msg { get; set; }

        public GenerCodeRet data { get; set; }

        public string FormatRspMessage(int errCode, string readme, int prg)
        {
            var rsp = new RspMessage(data.sessionId, prg);
            rsp.err = errCode;
            rsp.msg = (Convert.ToBase64String(Encoding.Default.GetBytes(readme)));

            return JsonConvert.SerializeObject(rsp);
        }

        public static int SendRspMessage(string msg)
        {
            NLog.Debug("Send: " + msg + Environment.NewLine);
            Console.WriteLine(msg);
            return 0;
        }

        public void ProgressMessage(int step)
        {
            var msgContent = FormatRspMessage(0, "Progress", step);
            
            msg = JsonConvert.SerializeObject(msgContent);

            SendRspMessage(msg);
        }
    }

    internal class Program
    {
        private static int Main(string[] args)
        {
            NConfig.InitConfigure();
            NLog.NLog_Init();
            GeneratorParams inParams = null;
            RspMessage rspMsg;
            var tmObj = new TmatrixClass();

            AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
            {
                //Trace.WriteLine("+++++++++++++++++++++++++++++++++++++++++++xajhuang1\n");
            };

            AppDomain.CurrentDomain.DomainUnload += (sender, e) =>
            {
                //Trace.WriteLine("+++++++++++++++++++++++++++++++++++++++++++xajhuang2\n");
            };

            AppDomain.CurrentDomain.ProcessExit += (sender, ev) =>
            {
                try
                {
                    tmObj.TmatrixUninitialize();
                }
                catch (Exception e)
                {
                    //var msg = rspMsg.FormatRspMessage(9, e.Message, 0);
                    //RspMessage.SendRspMessage(msg);
                    NLog.Crash(e.ToString());
                }

                NLog.NLog_Finish();
            };

            //string inputArg =
            //    "eyJkcGkiOlswLDAsMCwwXSwicG9pbnRfdHlwZSI6WzAsMCwwLDBdLCJpbWFnZV90eXBlI" +
            //    "jpbZmFsc2UsZmFsc2UsZmFsc2UsdHJ1ZV0sImtleSI6IlMwLE8wMDAsQjAwMDAsUDAwMC0" +
            //    "yNTUsRDIwMTgvMTIvMzE7Q0NBRkJRTVhZUE9BT0NJUks1MlM4UUM4U080QTBBR0E4WSIsIm" +
            //    "ZpbGVQYXRoIjoiRTpcXE5ldEVhc2VcXLnsvKOxylxcU2FtcGxlXFwxMjMucGRmIiwiU3Rhcn" +
            //    "RQYWdlSUQiOjAsInNlc3Npb25JZCI6IjRCRDVEOTIzLTQ3RUEtNERFRi1BMUNELTlCODVCNT" +
            //    "E1QjE5MSJ9";
            //string inputArg2 = "eyJkcGkiOlswLDAsMCwwXSwicG9pbnRfdHlwZSI6WzAsMCwwLDBdLCJpb" +
            //                   "WFnZV90eXBlIjpbZmFsc2UsZmFsc2UsZmFsc2UsdHJ1ZV0sImtleSI6Il" +
            //                   "MwLE8wMDAsQjAwMDAsUDAwMC0yNTUsRDIwMTgvMTIvMzE7Q0NBRkJRTVh" +
            //                   "ZUE9BT0NJUks1MlM4UUM4U080QTBBR0E4WSIsImZpbGVQYXRoIjoiQzpc" +
            //                   "XFdvcmtzXFxwZGZcXDEyMy5wZGYiLCJTdGFydFBhZ2VJRCI6MCwic2Vzc" +
            //                   "2lvbklkIjoiNEJENUQ5MjMtNDdFQS00REVGLUExQ0QtOUI4NUI1MTVCMTkxIn0=";
            
            try
            {
                if (args.Length == 1)
                {
                    var deCode = Convert.FromBase64String(args[0]);
                    var strParams = Encoding.Default.GetString(deCode);
                    inParams = JsonConvert.DeserializeObject<GeneratorParams>(strParams);
                }
                else if (args.Length == 2)
                {
                    var deCode = Convert.FromBase64String(args[1]);
                    var strParams = Encoding.Default.GetString(deCode);
                    inParams = JsonConvert.DeserializeObject<GeneratorParams>(strParams);
                    inParams.sessionId = args[0];
                }
                else
                {
                    inParams = new GeneratorParams();
                }
            }
            catch (Exception e)
            {
                rspMsg = new RspMessage("");
                var msg = rspMsg.FormatRspMessage(10, e.Message, 0);
                RspMessage.SendRspMessage(msg);
                NLog.Crash(string.Format("[{0}]: ", (inParams == null) ? inParams.sessionId : "UnInit") + e.Message);
                return -(int) ErrCode.ERR_JSON_DECODE;
            }

            rspMsg = new RspMessage(inParams.sessionId);

            tmObj.ProgressChange += rspMsg.ProgressMessage;

            var jsInput = JsonConvert.SerializeObject(inParams);

            NLog.Debug("Input:" + jsInput + Environment.NewLine);
            
            if (!File.Exists(inParams.filePath))
            {
                NLog.Error("File Not Exists: " + inParams.filePath + Environment.NewLine);
                return -(int) ErrCode.ERR_FILE_NOTEXISTS;
            }

            try
            {
                tmObj.TmatrixInitialize();
            }
            catch (Exception e)
            {
                var msg = rspMsg.FormatRspMessage(7, e.Message, 0);
                RspMessage.SendRspMessage(msg);
                NLog.Crash(e.ToString());
                return -(int) ErrCode.ERR_EXCEPT_THROW;
            }
            
            try
            {
                var ret = tmObj.GenerateTmatrixCode_OID4(inParams.key,
                    inParams.filePath, inParams.StartPageID, inParams.point_type,
                    inParams.image_type, inParams.dpi);

                if (ret.Substring(0, 1) != "0")
                {
                    var msg = rspMsg.FormatRspMessage(int.Parse(ret.Substring(0, 1)),
                        ret.Substring(1, ret.Length - 1), tmObj.GetProgerss());

                    NLog.Error(msg + Environment.NewLine);
                    RspMessage.SendRspMessage(msg);
                }
                else
                {
                    var msg = rspMsg.FormatRspMessage(int.Parse(ret.Substring(0, 1)),
                        ret.Substring(1, ret.Length - 1), 100);

                    NLog.Debug(msg + Environment.NewLine);
                    RspMessage.SendRspMessage(msg);
                }
            }
            catch (Exception e)
            {
                var msg = rspMsg.FormatRspMessage(8, e.Message, tmObj.GetProgerss());
                RspMessage.SendRspMessage(msg);
                NLog.Crash(e.ToString());
                return -(int) ErrCode.ERR_EXCEPT_THROW;
            }
            
            return 0;
        }

        private enum ErrCode
        {
            ERR_INPUT_PARAMS = 1,
            ERR_FILE_NOTEXISTS,
            ERR_EXCEPT_THROW,
            ERR_JSON_DECODE
        }
    }
}