Exemple #1
0
        /// <summary>
        ///
        /// </summary>
        public void Start()
        {
            //初始化插件容器。
            CQAppContainer.GetInstance();

            string ipAddress = "127.0.0.1";
            int    port      = 18139;

            string folder = Path.Combine(CQ.GetCQAppFolder(), "app");

            folder = Path.Combine(folder, "cc.flexlive.cqeproxy");

            if (Directory.Exists(folder))
            {
                string iniFile = Path.Combine(folder, "cc.flexlive.cqeproxy.ini");

                if (File.Exists(iniFile))
                {
                    ipAddress = IniFileHelper.GetStringValue(iniFile, "代理配置", "服务器地址", "127.0.0.1");
                    string strPort = IniFileHelper.GetStringValue(iniFile, "代理配置", "服务器端口", "18139");
                    port = Convert.ToInt32(strPort);
                }
            }

            IPAddress ip         = IPAddress.Parse(ipAddress);
            int       listenPort = port;

            IPEndPoint listenIPEndPoint = new IPEndPoint(ip, listenPort);

            //定义网络类型,数据连接类型和网络协议UDP
            this.mySocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            //绑定网络地址
            this.mySocket.Bind(listenIPEndPoint);

            //得到客户机IP
            int        clientPort = 18131;
            IPEndPoint ipep       = new IPEndPoint(ip, clientPort);

            RemotePoint = (EndPoint)(ipep);

            //启动一个新的线程,执行方法this.ReceiveHandle,
            //以便在一个独立的进程中执行数据接收的操作
            RunningFlag = true;
            Thread thread = new Thread(new ThreadStart(this.ReceiveMessage));

            thread.IsBackground = true;
            thread.Start();


            HttpListener httpListener = new HttpListener();

            httpListener.AuthenticationSchemes = AuthenticationSchemes.Anonymous;
            httpListener.Prefixes.Add("http://localhost:3147/");
            httpListener.Start();
            new Thread(new ThreadStart(delegate
            {
                while (true)
                {
                    HttpListenerContext httpListenerContext = httpListener.GetContext();
                    httpListenerContext.Response.StatusCode = 200;
                    String uri = httpListenerContext.Request.Url.LocalPath;
                    if (!uri.Equals("/ssAPI/jabber.ashx"))
                    {
                        continue;
                    }
                    try
                    {
                        long groupId = long.Parse(httpListenerContext.Request.QueryString["groupId"]);
                        String msg   = httpListenerContext.Request.QueryString["msg"];
                        if (msg == null || msg.Equals(""))
                        {
                            continue;
                        }
                        CQ.SendGroupMessage(groupId, msg);
                        using (StreamWriter writer = new StreamWriter(httpListenerContext.Response.OutputStream))
                        {
                            writer.WriteLine("OK");
                        }
                    }
                    catch (Exception ex)
                    {
                        using (StreamWriter writer = new StreamWriter(httpListenerContext.Response.OutputStream))
                        {
                            writer.WriteLine("ERROR:" + ex.Message);
                        }
                    }
                }
            })).Start();
        }
Exemple #2
0
 private void comboBox1_DropDownClosed(object sender, System.EventArgs e)
 {
     var  cbx    = comboBox1;
     bool result = IniFileHelper.WriteValue("Printer", "Printer", cbx.SelectedItem.ToString(), Path.GetFullPath(dc.pathIni));
 }
Exemple #3
0
        private static void Main(string[] args)
        {
            dirty     = true;
            _filename = DateTime.Now.ToString("yyyyMMdd_HHmmss") + ".txt";
            Console.BackgroundColor = ConsoleColor.Black;
            ConsoleHelper.FixEncoding();
            Console.Title = Commons.GetTitle();
            Commons.PrintLogo();
            Commons.EmptyOneRow();

            if (!Commons.IsConfigFileExist())
            {
                try
                {
                    Commons.CreateConfigFile();
                }
                catch (Exception ex)
                {
                    Commons.ShowError(ex.ToString());
                    ConsoleHelper.Wait();
                }
            }

            try
            {
                ini             = new IniFileHelper("config.ini");
                portName        = ini.Read("portName", "SerialPort");
                baudRate        = int.Parse(ini.Read("baudRate", "SerialPort"));
                parity          = Commons.ParseEnum <Parity>(ini.Read("parity", "SerialPort"));
                dataBits        = int.Parse(ini.Read("dataBits", "SerialPort"));
                stopBits        = Commons.ParseEnum <StopBits>(ini.Read("stopBits", "SerialPort"));
                handshake       = Commons.ParseEnum <Handshake>(ini.Read("handshake", "SerialPort"));
                readTimeout     = int.Parse(ini.Read("readTimeout", "SerialPort"));
                loggingInterval = int.Parse(ini.Read("loggingInterval", "Logging"));

                Commons.ShowCurrentSettings(portName, baudRate, parity, dataBits, stopBits, handshake, readTimeout, loggingInterval);

                listening = true;
                if (_serialPort == null)
                {
                    _serialPort = new SerialPort();
                }
            }
            catch (Exception ex)
            {
                Commons.ShowError(ex.ToString());
                ConsoleHelper.Wait();
            }

            while (true)
            {
                if (listening == true)
                {
                    InterpretInput(Console.ReadLine());
                }
                else
                {
                    break;
                }
            }

            string folder = AppDomain.CurrentDomain.BaseDirectory + "\\datalogs";

            Directory.CreateDirectory(folder);

            _timer          = new System.Timers.Timer();
            _timer.Elapsed += new System.Timers.ElapsedEventHandler(OnTimed);
            _timer.Interval = loggingInterval;
            _timer.Enabled  = true;

            if (listening == false)
            {
                string file = AppDomain.CurrentDomain.BaseDirectory + "\\datalogs\\" + _filename;
                try
                {
                    File.WriteAllText(file, "# This file is auto-generated on " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff tt") + "." + Environment.NewLine);
                }
                catch (Exception ex)
                {
                    Commons.ShowError(ex.ToString());
                    ConsoleHelper.Wait();
                }

                Start();

                ConsoleHelper.WriteLine("Logging is now running...", ConsoleColor.Green);
            }
        }
Exemple #4
0
        public static string GetText(string funcName, string[] funcParamArray)
        {
            //*common
            if (funcName.ToLower() == "empty" | funcName.ToLower() == "null")
            {
                return(string.Empty);
            }
            else if (funcName.ToLower() == "DateTime".ToLower())
            {
                var customFormat = "yyyy-MM-dd HH:mm:ss";
                if (funcParamArray[0].ToLower() == "UtcNow".ToLower())
                {
                    var time = SystemTimeHelper.UtcNow(); //
                    return(time.ToString(customFormat, DateTimeFormatInfo.InvariantInfo));
                }
                else if (funcParamArray[0].ToLower() == "Now".ToLower())
                {
                    var time = SystemTimeHelper.Now(); //
                    return(time.ToString(customFormat, DateTimeFormatInfo.InvariantInfo));
                }
                else
                {
                    throw new ArgumentException("funcName: " + funcName + " has no param " + funcParamArray[0] + "! ");
                }
            }
            else if (funcName.ToLower() == "UniqueCode".ToLower())
            {
                if (funcParamArray[0] == "ByNow")
                {
                    var baseStr   = funcParamArray.Length > 1 ? funcParamArray[1] : "";
                    var separator = funcParamArray.Length > 2 ? funcParamArray[2] : "";
                    return(baseStr.ToUniqueStringByNow(separator));
                }
                else if (funcName.ToLower() == "ShortGuid".ToLower())
                {
                    var baseStr   = funcParamArray.Length > 1 ? funcParamArray[1] : "";
                    var separator = funcParamArray.Length > 2 ? funcParamArray[2] : "";
                    return(baseStr.ToUniqueStringByShortGuid(separator));
                }
                else
                {
                    throw new ArgumentException("funcName: " + funcName + " has no param '" + funcParamArray[0] + "'! ");
                }
            }

            else if (funcName.ToLower() == "Format".ToLower())
            {
                if (funcParamArray[0].ToLower() == "upper")
                {
                    return(funcParamArray[1].ToUpper());
                }
                else if (funcParamArray[0].ToLower() == "lower")
                {
                    return(funcParamArray[1].ToLower());
                }
                else if (funcParamArray[0].ToLower() == "timespan")
                {
                    return(SystemTimeHelper.GetTimeSpanString(Convert.ToDouble(funcParamArray[1]), funcParamArray[2],
                                                              false));
                }
                else if (funcParamArray[0].ToLower() == "real")
                {
                    return(string.Format(funcParamArray[2], Convert.ToDouble(funcParamArray[1])));
                }

                else if (funcParamArray[0].ToLower() == "FormatString")
                {
                    return(string.Format(funcParamArray[1], funcParamArray[2]));
                }
                else
                {
                    throw new ArgumentException(funcName + " has no param '" + funcParamArray[0] + "'! ");
                }
            }
            else if (funcName.ToLower() == "Replace".ToLower())
            {
                return(funcParamArray[1].Length == 0 ? funcParamArray[0]
                    : funcParamArray[0].Replace(funcParamArray[1], funcParamArray[2]));
            }
            else if (funcName.ToLower() == "Split".ToLower())
            {
                var separator   = funcParamArray[1][0];
                var tmpStrArray = funcParamArray[0].Split(separator);
                var index       = Convert.ToInt16(funcParamArray[2]);
                if (index > tmpStrArray.Length || index == tmpStrArray.Length)
                {
                    return("");
                }
                else
                {
                    return(tmpStrArray[index]);
                }
            }
            else if (funcName.ToLower() == "Combine".ToLower())
            {
                var tmpStrArray = funcParamArray[0].GetSubParamArray(false, false);
                var rtStr       = "";
                if (funcParamArray.Length > 1)
                {
                    var joinSeparator = funcParamArray[1].Length == 1 ? Convert.ToChar(funcParamArray[1]) : ' ';
                    rtStr = Ligg.Infrastructure.Base.Helpers.StringHelper.UnwrapStringArrayBySeparator(tmpStrArray, joinSeparator);
                }
                else
                {
                    foreach (var tmpStr in tmpStrArray)
                    {
                        rtStr = rtStr + tmpStr;
                    }
                }
                return(rtStr);
            }
            else if (funcName.ToLower() == "SubString".ToLower())
            {
                var   tmStr    = funcParamArray[0];
                Int16 sttIndex = Convert.ToInt16(funcParamArray[1]);
                Int16 len      = Convert.ToInt16(funcParamArray[2]);
                return(tmStr.Substring(sttIndex, len));
            }
            else if (funcName.ToLower() == "AddOrRemoveSubParam".ToLower())
            {
                var separator = ',';
                if (funcParamArray[0].ContainsSubParamSeparator())
                {
                    separator = funcParamArray[0].GetSubParamSeparator();
                }

                var add = funcParamArray[2].ToLower() == "true" ? true : false;
                return(funcParamArray[0].AddOrDelToSeparatedStrings(funcParamArray[1], add, separator));
            }

            //*get
            else if (funcName.ToLower() == "GetLineQty".ToLower())
            {
                int qty = funcParamArray[0].Split('\n').Length;
                return(Convert.ToString(qty));
            }
            else if (funcName.ToLower() == "GetLinesBySearch".ToLower())
            {
                var strArry    = funcParamArray[0].Split('\n');
                var schStrArry = funcParamArray[1].Split(',');
                var strList    = new List <string>();
                foreach (var v in strArry)
                {
                    foreach (var s in schStrArry)
                    {
                        if (v.ToLower().Contains(s.ToLower()))
                        {
                            strList.Add(v);
                        }
                    }
                }

                var strList1 = strList.Distinct();
                var strBlder = new StringBuilder();
                foreach (var v in strList1)
                {
                    if (!string.IsNullOrEmpty(v))
                    {
                        strBlder.AppendLine(v);
                    }
                }

                return(strBlder.ToString());
            }

            //*convert
            else if (funcName.ToLower() == "ConvertJsonToRichText".ToLower())
            {
                var  jsonStr = funcParamArray[0];
                var  dt      = JsonHelper.ConvertToDataTable(jsonStr);
                bool hasHead = false;
                if (funcParamArray.Length > 1)
                {
                    if (funcParamArray[1].ToLower() == "true")
                    {
                        hasHead = true;
                    }
                }

                String[] strArray = null;
                if (funcParamArray.Length > 2)
                {
                    if (!funcParamArray[2].IsNullOrEmpty())
                    {
                        strArray = funcParamArray[2].GetSubParamArray(true, true);
                    }
                }
                var rtStr = DataTableHelper.ConvertToRichText(dt, hasHead, strArray);

                return(rtStr);
            }

            //*file
            else if (funcName.ToLower() == "FileDetail".ToLower())
            {
                if (funcParamArray[1].IsNullOrEmpty())
                {
                    throw new ArgumentException("file path can't be empty! ");
                }
                if (funcParamArray[0].ToLower() == "Directory".ToLower())
                {
                    return(FileHelper.GetFileDetailByOption(funcParamArray[1], FilePathComposition.Directory));
                }
                else if (funcParamArray[0].ToLower() == "FileName".ToLower())
                {
                    return(FileHelper.GetFileDetailByOption(funcParamArray[1], FilePathComposition.FileName));
                }
                else if (funcParamArray[0].ToLower() == "FileTitle".ToLower())
                {
                    return(FileHelper.GetFileDetailByOption(funcParamArray[1], FilePathComposition.FileTitle));
                }
                else if (funcParamArray[0].ToLower() == "Suffix".ToLower())
                {
                    return(FileHelper.GetFileDetailByOption(funcParamArray[1], FilePathComposition.Suffix));
                }
                else if (funcParamArray[0].ToLower() == "Postfix".ToLower())
                {
                    return(FileHelper.GetFileDetailByOption(funcParamArray[1], FilePathComposition.Postfix));
                }
                else
                {
                    throw new ArgumentException("funcName: " + funcName + " has no param '" + funcParamArray[0] + "'! ");
                }
            }
            //*no use yet
            else if (funcName.ToLower() == "CompareFile".ToLower())
            {
                //var result = FileHelper.Compare2Files(funcParamArray[1], funcParamArray[2]).ToString();
                return(string.Empty);
            }


            else if (funcName.ToLower() == "GetContentFromTextFile".ToLower() | funcName.ToLower() == "GetCttFrTextFile".ToLower())
            {
                return(FileHelper.GetContentFromTextFile(funcParamArray[0]));
            }

            else if (funcName.ToLower() == "GetIniFileSetting".ToLower())
            {
                var filePath = funcParamArray[0];
                FileHelper.CheckFilePathExistence(filePath);
                var key    = funcParamArray[1];
                var defVal = funcParamArray.Length > 2 ? funcParamArray[2] : "";
                return(IniFileHelper.ReadIniString(filePath, "setting", key, defVal));
            }

            //*Json

            //*calc
            else if (funcName.ToLower() == "Calc".ToLower())
            {
                if (funcParamArray[0].ToLower() == "add".ToLower())
                {
                    return((Convert.ToDouble(funcParamArray[1]) + Convert.ToDouble(funcParamArray[2])).ToString());
                }
                else if (funcParamArray[0].ToLower() == "sub".ToLower())
                {
                    return((Convert.ToDouble(funcParamArray[1]) - Convert.ToDouble(funcParamArray[2])).ToString());
                }
                else if (funcParamArray[0].ToLower() == "mtp".ToLower())
                {
                    return((Convert.ToDouble(funcParamArray[1]) * Convert.ToDouble(funcParamArray[2])).ToString());
                }
                else if (funcParamArray[0].ToLower() == "div".ToLower())
                {
                    return((Convert.ToDouble(funcParamArray[1]) / Convert.ToDouble(funcParamArray[2])).ToString());
                }
                else if (funcParamArray[0].ToLower() == "rnd".ToLower())
                {
                    return((Math.Round(Convert.ToDouble(funcParamArray[1]))).ToString());
                }
                else if (funcParamArray[0].ToLower() == "spls".ToLower())
                {
                    return((Convert.ToDouble(funcParamArray[1]) % (Convert.ToDouble(funcParamArray[2]))).ToString());
                }
                else
                {
                    throw new ArgumentException("funcName: " + funcName + " has no param: " + funcParamArray[0] + "! ");
                }
            }

            //*Status
            else if (funcName.ToLower() == "GetFinalStatus".ToLower())
            {
                if (funcParamArray.All(v => v.ToLower() == "true"))
                {
                    return("true");
                }
                if (funcParamArray.Any(v => v.ToLower() == "unknown"))
                {
                    return("unknown");
                }
                return("false");
            }

            //*bool
            else if (funcName.ToLower() == "GetBool".ToLower())
            {
                if (funcParamArray[0].ToLower() == "TotalStatus".ToLower())
                {
                    var returnStr         = "true";
                    var subfuncParamArray = funcParamArray[1].Split(',');
                    if (subfuncParamArray.Any(v => v.ToLower() != "1"))
                    {
                        returnStr = "false";
                    }
                    return(returnStr);
                }
                else if (funcParamArray[0].ToLower() == "And".ToLower())
                {
                    var returnStr         = "true";
                    var subfuncParamArray = funcParamArray[1].Split(',');
                    if (subfuncParamArray.Any(v => v.ToLower() != "true"))
                    {
                        returnStr = "false";
                    }
                    return(returnStr);
                }
                else if (funcParamArray[0].ToLower() == "Or".ToLower())
                {
                    var returnStr         = "false";
                    var subfuncParamArray = funcParamArray[1].Split(',');
                    if (subfuncParamArray.Any(v => v.ToLower() == "true"))
                    {
                        returnStr = "true";
                    }
                    return(returnStr);
                }
                else if (funcParamArray[0].ToLower() == "Not".ToLower())
                {
                    var returnStr = "true";
                    if (funcParamArray[1].ToLower() == "true")
                    {
                        returnStr = "false";
                    }
                    return(returnStr);
                }

                else if (funcParamArray[0].ToLower() == "IsDirectoryExisting".ToLower())
                {
                    var returnStr = "false";
                    if (Directory.Exists(funcParamArray[1]))
                    {
                        returnStr = "true";
                    }
                    return(returnStr);
                }
                else if (funcParamArray[0].ToLower() == "IsDirectoryHidden".ToLower())
                {
                    if (!Directory.Exists(funcParamArray[1]))
                    {
                        return("false");
                    }
                    var returnStr = "false";
                    var di        = new DirectoryInfo(funcParamArray[1]);
                    if ((di.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden)
                    {
                        returnStr = "true";
                    }
                    return(returnStr);
                }
                else if (funcParamArray[0].ToLower() == "IsFileExisting".ToLower())
                {
                    var returnStr = "false";
                    if (File.Exists(funcParamArray[1]))
                    {
                        returnStr = "true";
                    }
                    return(returnStr);
                }

                else if (funcParamArray[0].ToLower() == "IfElse".ToLower())
                {
                    var con        = funcParamArray[1];
                    var conArry    = con.GetSubParamArray(true, false);
                    var judgedText = conArry[0];
                    var judgeFlag  = conArry[1];
                    var val        = "";
                    if (conArry.Length > 2)
                    {
                        val = conArry[2];
                    }
                    if (GetHelper.Judge(judgeFlag, judgedText, val))
                    {
                        return("true");
                    }
                    return("false");
                }

                else
                {
                    throw new ArgumentException("funcName: " + funcName + " has no param: " + funcParamArray[0] + "! ");
                }
            }

            //*if
            else if (funcName.ToLower() == "IfElse".ToLower())
            {
                var con        = funcParamArray[0];
                var returnVal  = funcParamArray[1];
                var returnVal1 = funcParamArray[2];
                var conArry    = con.GetSubParamArray(true, false);
                var judgedText = conArry[0];
                var judgeFlag  = conArry[1];
                var val        = "";
                if (conArry.Length > 2)
                {
                    val = conArry[2];
                }
                if (GetHelper.Judge(judgeFlag, judgedText, val))
                {
                    return(returnVal);
                }
                return(returnVal1);
            }
            //*encrypt
            else if (funcName.ToLower() == "EncryptText".ToLower())
            {
                if (funcParamArray[0].ToLower() == "Md5".ToLower())
                {
                    return(EncryptionHelper.Md5Encrypt(funcParamArray[1]));
                }

                else
                {
                    throw new ArgumentException("funcName: " + funcName + " has no param: " + funcParamArray[0] + "! ");
                }
            }


            else if (funcName.ToLower() == "Validate".ToLower())
            {
                var retStr = Validator.Validate(funcParamArray[0], funcParamArray[1]);
                if (retStr == "OutOfScopeOfValidator")
                {
                    return("OutOfScope");
                }
                else
                {
                    return(retStr);
                }
            }

            else
            {
                return("OutOfScope");
            }
        }
Exemple #5
0
 public static void SetUserSetting(UserSetting userSetting)
 {
     IniFileHelper.IniWriteValue(UserSetting, ProjectKey, userSetting.ProjectName);
     IniFileHelper.IniWriteValue(UserSetting, AccountKey, userSetting.Account);
     IniFileHelper.IniWriteValue(UserSetting, PasswordKey, userSetting.Password);
 }
Exemple #6
0
        private static void UpdateSettings(string label, string value)
        {
            label = label.Trim();

            if (_serialPort == null)
            {
                _serialPort = new SerialPort();
            }

            if (ini == null)
            {
                ini = new IniFileHelper("config.ini");
            }

            try
            {
                if (label.ToLower() == "baudrate")
                {
                    baudRate             = int.Parse(value);
                    _serialPort.BaudRate = baudRate;
                    ini.Write("baudRate", value, "SerialPort");
                }
                else if (label.ToLower() == "databits")
                {
                    dataBits             = int.Parse(value);
                    _serialPort.DataBits = dataBits;
                    ini.Write("dataBits", value, "SerialPort");
                }
                else if (label.ToLower() == "parity")
                {
                    parity             = Commons.ParseEnum <Parity>(value);
                    _serialPort.Parity = parity;
                    ini.Write("parity", parity.ToString(), "SerialPort");
                }
                else if (label.ToLower() == "stopbits")
                {
                    stopBits             = Commons.ParseEnum <StopBits>(value);
                    _serialPort.StopBits = stopBits;
                    ini.Write("stopBits", stopBits.ToString(), "SerialPort");
                }
                else if (label.ToLower() == "handshake")
                {
                    handshake             = Commons.ParseEnum <Handshake>(value);
                    _serialPort.Handshake = handshake;
                    ini.Write("handshake", handshake.ToString(), "SerialPort");
                }
                else if (label.ToLower() == "timeout")
                {
                    readTimeout             = int.Parse(value);
                    _serialPort.ReadTimeout = readTimeout;
                    ini.Write("readTimeout", value, "SerialPort");
                }
                else if (label.ToLower() == "portname")
                {
                    portName             = value.ToUpper();
                    _serialPort.PortName = portName;
                    ini.Write("portName", portName, "SerialPort");
                }
                else if (label.ToLower() == "loginterval")
                {
                    loggingInterval = int.Parse(value);
                    ini.Write("loggingInterval", value, "Logging");
                }
            }
            catch (Exception ex)
            {
                Commons.ShowError(ex.ToString());
                ConsoleHelper.Wait();
            }

            Console.Clear();
            Commons.PrintLogo();
            Commons.EmptyOneRow();
            Commons.ShowCurrentSettings(portName, baudRate, parity, dataBits, stopBits, handshake, readTimeout, loggingInterval);
        }
Exemple #7
0
 private void BackToWordViewButton_OnClick(object sender, RoutedEventArgs e)
 {
     IniFileHelper.IniWriteValue(CustomUtils.UserLayoutSection, CustomUtils.LastViewKey, nameof(SearchWordView));
     ShowWordView();
 }
Exemple #8
0
 private void ShowTranslationViewButton_OnClick(object sender, RoutedEventArgs e)
 {
     IniFileHelper.IniWriteValue(CustomUtils.UserLayoutSection, CustomUtils.LastViewKey, nameof(TranslationView));
     ShowTranslationView();
 }
    public static void ReadCallback(IAsyncResult ar)
    {
        String content = String.Empty;

        //IniFileHelper
        IniFileHelper iniFile = new IniFileHelper();

        // Retrieve the state object and the handler socket
        // from the asynchronous state object.
        StateObject state   = (StateObject)ar.AsyncState;
        Socket      handler = state.workSocket;

        // Read data from the client socket.
        int bytesRead = handler.EndReceive(ar);

        if (bytesRead > 0)
        {
            // There  might be more data, so store the data received so far.
            state.sb.Append(Encoding.ASCII.GetString(
                                state.buffer, 0, bytesRead));

            // Check for end-of-file tag. If it is not there, read
            // more data.
            content = state.sb.ToString();
            if (content.IndexOf("\r") > -1)
            {
                string ReceivedOutput = null;

                switch (content.Substring(0, 3))
                {
                case "611":
                    string device1Result = iniFile.ReadValue("Device1", "status", System.IO.Path.GetFullPath("IniFile.ini"));
                    string device2Result = iniFile.ReadValue("Device2", "status", System.IO.Path.GetFullPath("IniFile.ini"));
                    string resultOutput  = null;
                    if (device1Result == "-1" && device2Result == "-1")
                    {
                        resultOutput = "0";
                    }
                    else
                    {
                        resultOutput = "1";
                    }

                    ReceivedOutput = "621" + DateTime.Now.ToString("HHmmss") + "015" + "|" + content.Substring(13, 6) + "|" + resultOutput + "|01|02|";

                    if (device1Result != "-1")
                    {
                        bool result = IniFileHelper.WriteValue("Device1", "status", " 1", System.IO.Path.GetFullPath("IniFile.ini"));
                    }
                    if (device2Result != "-1")
                    {
                        bool results = IniFileHelper.WriteValue("Device2", "status", " 1", System.IO.Path.GetFullPath("IniFile.ini"));
                    }
                    break;

                case "612":
                    string device1Reset = iniFile.ReadValue("Device1", "status", System.IO.Path.GetFullPath("IniFile.ini"));
                    string device2Reset = iniFile.ReadValue("Device2", "status", System.IO.Path.GetFullPath("IniFile.ini"));
                    string resetOutput1 = null;
                    string resetOutput2 = null;
                    if (device1Reset == "-1")
                    {
                        resetOutput1 = "1";
                    }
                    else
                    {
                        resetOutput1 = "0";
                    }

                    if (device2Reset == "-1")
                    {
                        resetOutput2 = "1";
                    }
                    else
                    {
                        resetOutput2 = "0";
                    }
                    ReceivedOutput = "622" + DateTime.Now.ToString("HHmmss") + "010" + "|" + content.Substring(13, 6) + "|" + resetOutput1 + "|" + resetOutput2 + "|";

                    if (device1Reset != "-1")
                    {
                        bool result = IniFileHelper.WriteValue("Device1", "status", "0", System.IO.Path.GetFullPath("IniFile.ini"));
                    }
                    if (device2Reset != "-1")
                    {
                        bool results = IniFileHelper.WriteValue("Device2", "status", "0", System.IO.Path.GetFullPath("IniFile.ini"));
                    }
                    //modbusClient.Connect();
                    //modbusClient.WriteSingleCoil(0001, false);
                    //modbusClient.Disconnect();
                    break;

                case "619":
                    string device1Status = iniFile.ReadValue("Device1", "status", System.IO.Path.GetFullPath("IniFile.ini"));
                    string device2Status = iniFile.ReadValue("Device2", "status", System.IO.Path.GetFullPath("IniFile.ini"));

                    ReceivedOutput = "629" + DateTime.Now.ToString("HHmmss") + "011" + "|" + content.Substring(13, 6) + "|" + device1Status + "|" + device2Status + "|";
                    break;

                default:
                    ReceivedOutput = "invalid command code";
                    break;
                }

                // All the data has been read from the
                // client. Display it on the console.
                Console.WriteLine("Read {0} bytes from socket.\nData : {1}",
                                  content.Length, content);

                // Echo the data back to the client.
                Send(handler, ReceivedOutput + "\r");
            }
            else
            {
                // Not all data received. Get more.
                handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                                     new AsyncCallback(ReadCallback), state);
            }
        }
    }
Exemple #10
0
        /// <summary>
        /// Load Dcc Settings
        /// </summary>
        /// <param name="ini"></param>
        /// <param name="startupPath"></param>
        /// <returns></returns>
        public static DCC Read(string startupPath)
        {
            var ini = startupPath + @"\data\config\dcc.ini";
            var dcc = new DCC();
            var i   = 0;
            var n   = 0;

            dcc.FileExistsAction = (DccFileExistsAction)Convert.ToInt32(IniFileHelper.ReadINI(ini, "Settings", "FileExistsAction", "1"));
            n = Convert.ToInt32(IniFileHelper.ReadINI(ini, "Settings", "ChatPrompt", "1"));
            if (n == 1)
            {
                dcc.ChatPrompt = DccPrompt.Prompt;
            }
            else if (n == 2)
            {
                dcc.ChatPrompt = DccPrompt.AcceptAll;
            }
            else if (n == 3)
            {
                dcc.ChatPrompt = DccPrompt.Ignore;
            }
            n = Convert.ToInt32(IniFileHelper.ReadINI(ini, "Settings", "SendPrompt", "1"));
            if (n == 1)
            {
                dcc.SendPrompt = DccPrompt.Prompt;
            }
            else if (n == 2)
            {
                dcc.SendPrompt = DccPrompt.AcceptAll;
            }
            else if (n == 3)
            {
                dcc.SendPrompt = DccPrompt.Ignore;
            }
            dcc.PopupDownloadManager = Convert.ToBoolean(IniFileHelper.ReadINI(ini, "Settings", "PopupDownloadManager", "False"));
            dcc.DownloadDirectory    = IniFileHelper.ReadINI(ini, "Settings", "DownloadDirectory", "");
            if (string.IsNullOrEmpty(dcc.DownloadDirectory) == true)
            {
                dcc.DownloadDirectory = startupPath + "\\";
            }
            dcc.DownloadDirectory = dcc.DownloadDirectory.Replace("\\\\", "");
            dcc.BufferSize        = Convert.ToInt64(IniFileHelper.ReadINI(ini, "Settings", "BufferSize", "1024"));
            dcc.UseIpAddress      = Convert.ToBoolean(IniFileHelper.ReadINI(ini, "Settings", "UseIpAddress", "False"));
            dcc.CustomIpAddress   = IniFileHelper.ReadINI(ini, "Settings", "CustomIpAddress", "");
            if (dcc.CustomIpAddress.Length == 0)
            {
                dcc.CustomIpAddress = DccSettings.IpAddress();
            }
            dcc.Ignorelist.Count = Convert.ToInt32(IniFileHelper.ReadINI(ini, "Settings", "IgnoreCount", "0"));
            dcc.SendPort         = IniFileHelper.ReadINI(ini, "Settings", "SendPort", "1024");
            dcc.RandomizePort    = Convert.ToBoolean(IniFileHelper.ReadINI(ini, "Settings", "RandomizePort", "True"));
            dcc.Ignorelist.Count = Convert.ToInt32(IniFileHelper.ReadINI(ini, "Settings", "IgnoreCount", dcc.Ignorelist.Count.ToString()));
            dcc.AutoIgnore       = Convert.ToBoolean(IniFileHelper.ReadINI(ini, "Settings", "AutoIgnore", "True"));
            dcc.AutoCloseDialogs = Convert.ToBoolean(IniFileHelper.ReadINI(ini, "Settings", "AutoCloseDialogs", "False"));
            for (i = 1; i <= dcc.Ignorelist.Count; i++)
            {
                //var _with2 = dcc.dIgnorelist.dItem[i];
                dcc.Ignorelist.Item[i].Data = IniFileHelper.ReadINI(ini, i.ToString(), "Data", "");
                dcc.Type = (DCCIgnoreType)Convert.ToInt32(IniFileHelper.ReadINI(ini, i.ToString(), "Type", "0"));
                switch (dcc.Type)
                {
                case DCCIgnoreType.Nicknames:
                    dcc.Type = DCCIgnoreType.Nicknames;
                    break;

                case DCCIgnoreType.Hostnames:
                    dcc.Type = DCCIgnoreType.Hostnames;
                    break;

                case DCCIgnoreType.FileTypes:
                    dcc.Type = DCCIgnoreType.FileTypes;
                    break;
                }
            }
            return(dcc);
        }
Exemple #11
0
        private void cbxPrinter_DropDownClosed(object sender, EventArgs e)
        {
            bool result = IniFileHelper.WriteValue("Printer", "Printer", cbxPrinter.SelectedItem.ToString(), Path.GetFullPath(dc.pathIni));

            ReadIniFile();
        }