/// <summary>
        /// Shows advanced settings window.
        /// </summary>
        /// <param name="owner">owner</param>
        public void ShowAdvancedSettings(Window owner)
        {
            try
            {
                // get chosen printer by color setting
                Printer pr = GetChosenPrinterWithSettings(PrintWithColor);
                if (pr == null)
                {
                    return;
                }

                UISettingsExtractor extractor = new UISettingsExtractor(ChosenPrinter.Name, DesktopHelper.GetDesktopWindow());
                extractor.Start();

                MainController.Singleton.ShowAdvancedPrinterSettings(new WindowInteropHelper(owner).Handle, ChosenPrinter.Name, ref PrinterSettings);

                extractor.Stop();

                PrintBooklet = extractor.Booklet;
                LogHelper.LogDebug(PrintBooklet);

                pr.Settings = PrinterSettings;
                SetByPrinterSettings();
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
            }
        }
Пример #2
0
        /// <summary>
        /// Updates available printers
        /// </summary>
        /// <returns>available printers</returns>
        public Printers UpdateAvailablePrinters()
        {
            LogHelper.LogDebug();

            try
            {
                _availablePrinters = null;
                // just retrieve new data
                var xxx = AvailablePrinters;

                LogHelper.LogDebug("HasAvailablePrinters : " + HasAvailablePrinters);

                // change (real) printers of local print event watcher
                if (localPrintEventWatcher != null)
                {
                    localPrintEventWatcher.PrintersToPauseAndShow = new List <string>();

                    // check if there are available printers
                    if (HasAvailablePrinters)
                    {
                        LogHelper.LogDebug("AvailablePrinters : " + AvailablePrinters.NamesInSystem.Count);

                        // add (real) printers
                        localPrintEventWatcher.PrintersToPauseAndShow.AddRange(AvailablePrinters.NamesInSystem);
                    }
                }

                return(_availablePrinters);
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
                return(null);
            }
        }
        /// Dispose
        #region Dispose

        /// <summary>
        /// Disposes data
        /// </summary>
        public void Dispose()
        {
            // get rid of event watcher
            if (_eventWatcher != null)
            {
                try
                {
                    _eventWatcher.EventArrived -= mewPrintJobs_JobArrived;
                    _eventWatcher.Stop();

                    _eventWatcher.Dispose();
                    _eventWatcher = null;
                }
                catch (Exception ex)
                {
                    WPFNotifier.DebugError(ex);
                }
            }

            // get rid of management scope
            if (managementScope != null)
            {
                try
                {
                    managementScope = null;
                }
                catch (Exception ex)
                {
                    WPFNotifier.DebugError(ex);
                }
            }
        }
        /// <summary>
        /// Gets value from the postscript file line
        /// </summary>
        /// <param name="line">postscript file line</param>
        /// <returns>value from the postscript file line</returns>
        private static string GetLineValue(string line)
        {
            try
            {
                // find semicolon
                int index = line.IndexOf(':');
                if (index > 0)
                {
                    // find star
                    int index2 = line.LastIndexOf('*');
                    if (index2 > index)
                    {
                        // find first space after star
                        int index3 = line.IndexOf(' ', index2);
                        if (index3 > index2)
                        {
                            // extract starred value
                            return(line.Substring(index3).Trim());
                        }
                    }
                    else
                    {
                        // extract simple value
                        return(line.Substring(index + 1).Trim());
                    }
                }
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
            }

            return(null);
        }
        /// <summary>
        /// Gets value from the postscript file line
        /// </summary>
        /// <param name="line">postscript file line</param>
        /// <returns>value from the postscript file line</returns>
        private static string GetLineValue2(string line)
        {
            try
            {
                int index = line.IndexOf('=');
                if (index > 0)
                {
                    int index2 = line.IndexOf('"', index + 1) + 1;
                    if (index2 > index)
                    {
                        int index3 = line.IndexOf('"', index2);
                        if (index3 > index2)
                        {
                            // extract value
                            return(line.Substring(index2, index3 - index2).Trim());
                        }
                    }
                    else
                    {
                        // extract simple value
                        return(line.Substring(index + 1).Trim());
                    }
                }
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
            }

            return(null);
        }
        /// <summary>
        /// Gets proper library
        /// </summary>
        /// <returns>path to the library</returns>
        private static string GetLib()
        {
            try
            {
                string path = getLib(true);
                if (File.Exists(path))
                {
                    return(path);
                }

                path = getLib(false);
                if (File.Exists(path))
                {
                    return(path);
                }

                path = Path.Combine(Path.GetDirectoryName(Application.ExecutablePath), getLib(false));
                if (File.Exists(path))
                {
                    return(path);
                }

                throw new ArgumentNullException("File not found! " + Environment.NewLine + Application.ExecutablePath);
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
                return(null);
            }
        }
Пример #7
0
        /// Post
        #region Post

        /// <summary>
        /// Initiates post request
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        public static IRestResponse Post(string url, Dictionary <string, string> queryParameters = null)
        {
            try
            {
                string req = url;
                if (queryParameters != null && queryParameters.Count > 0)
                {
                    req += "?" + queryParameters.GetAsQueryString();
                }

                LastCall = req;

                LogHelper.LogDebug(new Uri(req).AbsoluteUri);

                RestClient  client  = new RestClient(new Uri(req));
                RestRequest request = new RestRequest(Method.POST);
                request.Timeout = 5000;
                request.AddParameter("undefined", "{}", ParameterType.RequestBody);
                IRestResponse response = client.Execute(request);

                return(response);
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
                return(null);
            }
        }
Пример #8
0
        /// Print
        #region Print

        /// <summary>
        /// Prints file with specified printer and settings
        /// </summary>
        /// <param name="fileName">file name</param>
        /// <param name="printer">printer settings</param>
        public static void Print(string fileName, string documentName, PrinterSettings printer, PostScriptMetaData data)
        {
            if (String.IsNullOrWhiteSpace(fileName))
            {
                return;
            }

            if (printer == null)
            {
                return;
            }

            if (data == null)
            {
                return;
            }

            try
            {
                // check the existence of the file
                if (!File.Exists(fileName))
                {
                    return;
                }

                // get file format
                SupportedPrintFormat format = GetFileFormat(fileName);
                string newFileName          = fileName;
                // if Postscript file
                if (format == SupportedPrintFormat.PS)
                {
                    newFileName = fileName + ".pdf";
                    // convert to .pdf
                    GhostScriptHelper.ConvertPStoPDF(fileName, newFileName);
                }

                // create corresponding print job title
                PrintJobTitle title = new PrintJobTitle(printer.PrinterName, documentName, Environment.UserName, Environment.MachineName, -1);

                // skip this title
                SkipMethod(title);

                // print document
                if (PDFHelper.Print(printer, newFileName, documentName, Environment.UserName, Environment.MachineName))
                {
                    // add title watcher
                    AddWatcher(title);

                    // log printed data
                    LogPrint(ConfigData.FilePath_PrintLog, documentName, printer, data.NumberOfPages);
                }
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
            }
        }
Пример #9
0
        /// HasColor
        #region HasColor

        /// <summary>
        /// Indicates whether the image has color or not
        /// </summary>
        /// <param name="image">image to be inspected</param>
        /// <returns>true if has color; otherwise false</returns>
        public static bool HasColor(Image image)
        {
            try
            {
                return(!IsGrayScale(new Bitmap(image)));
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
                return(false);
            }
        }
Пример #10
0
 /// <summary>
 ///
 /// </summary>
 /// <returns></returns>
 private MethodInfo[] GetMethods()
 {
     try
     {
         return((typeof(API)).GetMethods(BindingFlags.Public | BindingFlags.Static));
     }
     catch (Exception ex)
     {
         WPFNotifier.DebugError(ex);
         return(null);
     }
 }
Пример #11
0
        /// GetPrinters
        #region GetPrinters

        /// <summary>
        /// Gets printer list from the specified config file
        /// </summary>
        /// <param name="fullPath">config file</param>
        /// <returns>printers</returns>
        public static Printers GetPrintersFromConfig(string fullPath)
        {
            LogHelper.LogDebug(fullPath);
            if (String.IsNullOrWhiteSpace(fullPath))
            {
                return(null);
            }

            try
            {
                if (!File.Exists(fullPath))
                {
                    return(null);
                }

                string data = File.ReadAllText(fullPath);
                if (String.IsNullOrWhiteSpace(data))
                {
                    return(null);
                }

                LogHelper.LogDebug("From file: " + data);

                JArray jArray = JArray.Parse(data);
                foreach (JObject jObject in jArray.Children <JObject>())
                {
                    var workstation = jObject["workstation"];
                    if (workstation != null)
                    {
                        if (workstation.ToString() == Environment.MachineName)
                        {
                            LogHelper.LogDebug("Printer data found");
                            return(JsonConvert.DeserializeObject <Printers>(jObject["printers"].ToString()));
                        }
                    }
                    else
                    {
                        return(JsonConvert.DeserializeObject <Printers>(jArray.ToString()));
                    }
                }
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
            }

            LogHelper.LogDebug("Printer data not found");
            return(null);
        }
Пример #12
0
        /// PrinterIssue
        #region PrinterIssue

        /// <summary>
        /// Sends printer issue if any exist
        /// </summary>
        /// <param name="printerName">printer name</param>
        /// <param name="issue">printer issue</param>
        public static void PrinterIssue(string machineName, string userName, string printerName, string issue)
        {
            try
            {
                LogHelper.LogDebug(printerName);

                var res = API.PrinterIssue(machineName, userName, printerName, issue);

                LogHelper.LogDebug(res);
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
            }
        }
Пример #13
0
        /// LogPrint
        #region LogPrint

        /// <summary>
        /// Logs print entry data
        /// </summary>
        /// <param name="machineName">computer name</param>
        /// <param name="userName">user name</param>
        /// <param name="printerName">printer name</param>
        /// <param name="isColored">is colored?</param>
        /// <param name="numberOfPrints">number of prints</param>
        /// <param name="doubleSided">double-sided print</param>
        public static void LogPrint(string machineName, string userName, string printerName, bool isColored, int numberOfPrints, bool doubleSided)
        {
            try
            {
                LogHelper.LogDebug(machineName);

                var res = API.LogPrint(machineName, userName, isColored, numberOfPrints, printerName, doubleSided);

                LogHelper.LogDebug(res);
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
            }
        }
Пример #14
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void watcher_CanBeDisposed(object sender, EventArgs e)
        {
            PrintJobWatcher w = sender as PrintJobWatcher;

            if (w != null)
            {
                try
                {
                    this.Remove(w);
                    w.Dispose();
                }
                catch (Exception ex)
                {
                    WPFNotifier.DebugError(ex);
                }
            }
        }
Пример #15
0
        /// HasColor
        #region HasColor

        /// <summary>
        /// Checks whether the postscript file has color inside
        /// </summary>
        /// <param name="psFileName">file to be inspected</param>
        /// <returns>true if colored; otherwise false</returns>
        public static bool?HasColor(string psFileName)
        {
            if (string.IsNullOrWhiteSpace(psFileName))
            {
                return(null);
            }

            LogHelper.LogDebug();

            try
            {
                if (!File.Exists(psFileName))
                {
                    return(null);
                }

                string pdfTMPFileName = Path.GetTempFileName() + ".pdf";

                // and convert PS file to PDF
                GhostScriptHelper.ConvertPStoPDF(psFileName, pdfTMPFileName);

                // find out do PDF has color or not?
                bool hasColor = GhostScriptHelper.HasColor(pdfTMPFileName);

                try
                {
                    File.Delete(pdfTMPFileName);
                }
                catch (Exception ex)
                {
                    LogHelper.Log(ex);
                }

                return(hasColor);
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
                return(null);
            }
        }
        /// HasColor
        #region HasColor

        /// <summary>
        /// Determines if the specified file has color
        /// </summary>
        /// <param name="fileName">file to be inspected</param>
        /// <returns>true if has color; otherwise false</returns>
        public static bool HasColor(string fileName, int desired_x_dpi = 96, int desired_y_dpi = 96)
        {
            LogHelper.LogDebug(fileName);
            try
            {
                GhostscriptVersionInfo gsVersion = new GhostscriptVersionInfo(GetLib());
                using (GhostscriptRasterizer rasterizer = new GhostscriptRasterizer())
                {
                    rasterizer.Open(fileName, gsVersion, false);

                    for (int pageNumber = 1; pageNumber <= rasterizer.PageCount; pageNumber++)
                    {
                        try
                        {
                            using (Image img = rasterizer.GetPage(desired_x_dpi, desired_y_dpi, pageNumber))
                            {
                                if (img.HasColor())
                                {
                                    LogHelper.LogDebug("Has Color");
                                    return(true);
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            LogHelper.LogDebug(ex);
                        }
                    }

                    rasterizer.Close();
                }
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
            }

            LogHelper.LogDebug("No Color");
            return(false);
        }
Пример #17
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="printerName"></param>
        /// <param name="documentName"></param>
        /// <param name="color"></param>
        /// <param name="numberOfPrints"></param>
        /// <param name="duplex"></param>
        private static void LogPrint(string fileName, string printerName, string documentName, bool color, int numberOfPrints, Duplex duplex)
        {
            if (String.IsNullOrWhiteSpace(fileName))
            {
                return;
            }

            if (String.IsNullOrWhiteSpace(printerName))
            {
                return;
            }

            APIWrapper.LogPrint(Environment.MachineName, Environment.UserName, printerName, color, numberOfPrints, duplex != Duplex.Simplex);

            try
            {
                string path = Path.GetDirectoryName(fileName);
                if (!string.IsNullOrWhiteSpace(path))
                {
                    if (!Directory.Exists(path))
                    {
                        IO.CreateHiddenDirectory(path, false);
                    }
                }

                object[] data = new object[] { Environment.MachineName, Environment.UserName, printerName, documentName, color, duplex, numberOfPrints };
                using (FileStream fs = new FileStream(fileName, FileMode.Append, FileAccess.Write, FileShare.Write))
                {
                    LogHelper.LogDebug(fileName);
                    using (StreamWriter sw = new StreamWriter(fs, Encoding.Unicode))
                    {
                        sw.WriteLine(data.ToCSV());
                    }
                }
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(fileName + " " + ex);
            }
        }
Пример #18
0
        /// GetPrinters
        #region GetPrinters

        /// <summary>
        /// Gets list of available printers
        /// </summary>
        /// <param name="machineName">computer name</param>
        /// <returns>list of available printers</returns>
        public static Printers GetPrinters(string machineName)
        {
            try
            {
                LogHelper.LogDebug(machineName);

                string res = API.GetPrinters(machineName);

                LogHelper.Log(res);

                if (string.IsNullOrWhiteSpace(res))
                {
                    return(null);
                }

                return(JsonConvert.DeserializeObject <Printers>(res));
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
                return(null);
            }
        }
Пример #19
0
        /// CheckIfCanPrint
        #region CheckIfCanPrint

        /// <summary>
        /// Checks if the user is able to print
        /// </summary>
        /// <param name="machineName">computer name</param>
        /// <param name="userName">user name</param>
        /// <param name="isColored">is colored?</param>
        /// <param name="numberOfPrints">number of prints</param>
        /// <param name="printerName">printer name</param>
        /// <returns>is user able to print?</returns>
        public static AllowedToPrintResponse CheckIfCanPrint(string machineName, string userName, bool isColored, int numberOfPrints, string printerName)
        {
            try
            {
                LogHelper.LogDebug(machineName);

                var res = API.CheckIfCanPrint(machineName, userName, isColored, numberOfPrints, printerName);

                LogHelper.LogDebug(res);

                if (string.IsNullOrWhiteSpace(res))
                {
                    return(null);
                }

                return(JsonConvert.DeserializeObject <AllowedToPrintResponse>(res));
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
                return(null);
            }
        }
Пример #20
0
        /// GetEnvironment
        #region GetEnvironment

        /// <summary>
        /// Gets environment data.
        /// </summary>
        /// <returns>environment data</returns>
        public static object GetEnvironment()
        {
            try
            {
                string res = API.GetEnvironment();

                LogHelper.Log(res);

                if (string.IsNullOrWhiteSpace(res))
                {
                    return(null);
                }

                //return null;

                return(JToken.Parse(res));
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
                return(null);
            }
        }
        /// Convert
        #region Convert

        /// <summary>
        /// Converts postscript file to pdf
        /// </summary>
        /// <param name="psFileName">postscript file name</param>
        /// <returns>pdf file name</returns>
        public static void ConvertPStoPDF(string psFileName, string pdfFileName)
        {
            if (string.IsNullOrWhiteSpace(psFileName))
            {
                return;
            }

            if (string.IsNullOrWhiteSpace(pdfFileName))
            {
                return;
            }

            try
            {
                GhostscriptProcessor process = CreateProcessor();
                process.Process(ConvertPStoPDFArgs(psFileName, pdfFileName));
                process.Dispose();
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
            }
        }
Пример #22
0
        private void bExecuteRaw_Click(object sender, EventArgs e)
        {
            if (string.IsNullOrWhiteSpace(textBoxRequest.Text))
            {
                return;
            }

            try
            {
                var res = Connection.Get(textBoxRequest.Text);
                if (res == null)
                {
                    textBoxResults.Text = "Null result";
                }
                else
                {
                    textBoxResults.Text = res.ToString();
                }
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
            }
        }
Пример #23
0
        /// <summary>
        /// Checks print job and printer status
        /// </summary>
        private void TimerCall()
        {
            timer.Enabled = false;

            bool jobfound   = false;
            bool hasTrouble = false;

            try
            {
                string statusReport = "";
                //_printerStatus |= PrintHelper.GetPrinterStatus(_printJob.ServerHost, _printJob.PrintJobTitle.PrinterName, out statusReport);
                _printerStatus |= PrintHelper.GetPrinterStatus(PrintJobTitle.Host, PrintJobTitle.PrinterName, out statusReport);

                if ((_printerStatus | PrinterTrouble.None) == PrinterTrouble.None)
                {
                    hasTrouble = false;
                }
                else
                {
                    hasTrouble = true;
                }

                // if issue found
                if (hasTrouble)
                {
                    // send data to server
                    //OnIssueFound(new PrinterIssueEventArgs(_printJob.PrintJobTitle.PrinterName, _printerStatus, statusReport));
                    OnIssueFound(new PrinterIssueEventArgs(PrintJobTitle.PrinterName, _printerStatus, statusReport));
                    OnCanBeDisposed(EventArgs.Empty);
                    return;
                }

                // find the job
                //foreach (var printJob in PrintHelper.GetPrintJobs(_printJob.ServerHost, _printJob.PrintJobTitle.PrinterName))
                foreach (var printJob in PrintHelper.GetPrintJobs(PrintJobTitle.Host, PrintJobTitle.PrinterName))
                {
                    //if (PrintHelper.ExtractDocumentName(printJob) == _printJob.PrintJobTitle.Document)
                    if (PrintHelper.ExtractDocumentName(printJob) == PrintJobTitle.Document)
                    {
                        jobfound = true;
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
            }

            // if job found
            if (jobfound)
            {
                // continue watching
                timer.Enabled = true;
            }
            else
            {
                // finish watching
                OnJobCompleted(new PrintJobDataEventArgs(null));
                OnCanBeDisposed(EventArgs.Empty);
            }
        }
        /// ReadFile
        #region ReadFile

        /// <summary>
        /// Reads postscript file and extracts file data
        /// </summary>
        /// <param name="fileName">file to be inspected</param>
        /// <returns>postscript file data</returns>
        public static PostScriptMetaData ReadFile(string fileName)
        {
            if (string.IsNullOrWhiteSpace(fileName))
            {
                return(null);
            }

            try
            {
                if (!File.Exists(fileName))
                {
                    return(null);
                }

                // extract all the text
                string text = File.ReadAllText(fileName);
                if (string.IsNullOrWhiteSpace(text))
                {
                    return(null);
                }

                // get lines of text
                string[] textss = text.Split(new string[] { Environment.NewLine, "\n" }, StringSplitOptions.RemoveEmptyEntries);
                if (textss == null || textss.Length < 1)
                {
                    return(null);
                }

                // create meta data
                PostScriptMetaData data = new PostScriptMetaData();

                // fill meta data
                foreach (string line in textss)
                {
                    if (line.Contains(@"%Title:")) // Title
                    {
                        if (string.IsNullOrWhiteSpace(data.Title))
                        {
                            data.Title = GetLineValue(line);
                        }
                    }
                    else if (line.Contains(@"@PJL JOB NAME")) // Title
                    {
                        data.Title = GetLineValue2(line);
                    }
                    else if (line.Contains(@"%Orientation:")) // Orientation
                    {
                        data.Orientation = GetLineValue(line);
                    }
                    else if (line.Contains(@"%BeginFeature: *PageSize")) // PageSize
                    {
                        data.PageSizeName = GetLineValue(line);
                    }
                    else if (line.Contains(@"%BeginFeature: *Resolution")) // Resolution
                    {
                        data.Resolution = GetLineValue(line);
                    }
                    else if (line.Contains(@"%Pages:")) // Number of pages
                    {
                        int count;
                        if (int.TryParse(GetLineValue(line), out count))
                        {
                            data.NumberOfPages = count;
                        }
                    }
                }

                return(data);
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
                return(null);
            }
        }
Пример #25
0
        /// Methods
        #region Methods

        /// <summary>
        ///
        /// </summary>
        /// <param name="method"></param>
        private void ExecuteMethod(MethodInfo method)
        {
            List <string> datas = new List <string>();

            foreach (Control c in flowLayoutPanelParameters.Controls)
            {
                if (c as TextBox != null)
                {
                    datas.Add(c.Text);
                }
            }

            List <object> data = new List <object>();

            int i = 0;

            foreach (var parameter in method.GetParameters())
            {
                if (parameter.ParameterType == typeof(bool))
                {
                    bool b = false;
                    bool.TryParse(datas[i], out b);
                    data.Add(b);
                }
                else if (parameter.ParameterType == typeof(int))
                {
                    int num = 0;
                    int.TryParse(datas[i], out num);
                    data.Add(num);
                }
                else if (parameter.ParameterType == typeof(string))
                {
                    data.Add(datas[i]);
                }

                i++;
            }

            try
            {
                var res = method.Invoke(null, data.ToArray());

                if (res != null)
                {
                    string result = res.ToString();//.Replace("\\", "");
                    if (string.IsNullOrWhiteSpace(result))
                    {
                        textBoxResults.Text = "Null result X";
                        return;
                    }

                    textBoxResults.Text = result;

                    try
                    {
                        JArray json = JArray.Parse(result);
                        if (json == null)
                        {
                            //textBoxResults.Text = result.ToString();
                        }
                        else
                        {
                            //textBoxResults.Text = JsonConvert.SerializeObject(json);
                        }
                    }
                    catch (Exception exx)
                    {
                        WPFNotifier.DebugError(exx);
                    }


                    /*
                     * try
                     * {
                     *  JObject json = JObject.Parse(result);
                     *  if (json == null)
                     *  {
                     *      //textBoxResults.Text = result.ToString();
                     *  }
                     *  else
                     *  {
                     *      //textBoxResults.Text = JsonConvert.SerializeObject(json);
                     *  }
                     * }
                     * catch (Exception exx)
                     * {
                     *  WPFNotifier.DebugError(exx);
                     * }
                     */
                    /*
                     * try
                     * {
                     *  Printers xxxx = JsonConvert.DeserializeObject<Printers>(result);
                     * }
                     * catch (Exception exx)
                     * {
                     *  WPFNotifier.DebugError(exx);
                     * }*/
                }
                else
                {
                    textBoxResults.Text = "Null result";
                }
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
            }
        }
Пример #26
0
        /// LoadConfig
        #region LoadConfig

        /// <summary>
        /// Loads API config data
        /// </summary>
        /// <param name="fileName"></param>
        public static string LoadConfig(string fileName)
        {
            LogHelper.LogDebug();

            if (string.IsNullOrWhiteSpace(fileName))
            {
                return(null);
            }

            try
            {
                if (!File.Exists(fileName))
                {
                    return(null);
                }

                string text = File.ReadAllText(fileName);
                if (string.IsNullOrWhiteSpace(text))
                {
                    return(null);
                }

                string[] sstext = text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
                if (sstext == null || sstext.Length < 1)
                {
                    return(null);
                }

                LogHelper.LogDebug("API config : " + fileName);
                StringBuilder sb = new StringBuilder();
                foreach (string line in sstext)
                {
                    string[] liness = line.Split(new string[] { "=" }, StringSplitOptions.RemoveEmptyEntries);
                    if (liness == null || liness.Length != 2)
                    {
                        continue;
                    }

                    string key   = liness[0].Trim();
                    string value = liness[1].Trim();
                    switch (key)
                    {
                    case "API_MainURL":
                        _url = value;
                        sb.AppendLine(line);
                        break;

                    case "API_GetPrinters":
                        _url_GetPrinters = value;
                        sb.AppendLine(line);
                        break;

                    case "API_GetEnvironment":
                        _url_GetEnvironment = value;
                        sb.AppendLine(line);
                        break;

                    case "API_CheckIfCanPrint":
                        _url_CheckIfCanPrint = value;
                        sb.AppendLine(line);
                        break;

                    case "API_LogPrint":
                        _url_LogPrint = value;
                        sb.AppendLine(line);
                        break;

                    case "API_PrinterIssue":
                        _url_PrinterIssue = value;
                        sb.AppendLine(line);
                        break;
                    }
                }

                return(sb.ToString());
            }
            catch (Exception ex)
            {
                WPFNotifier.DebugError(ex);
                return(null);
            }
        }