Пример #1
0
        /// <summary>
        /// Anzeige eines Textes auf dem Datafox Gerät
        /// </summary>
        /// <param name="Optionen">Übertragungsoptionen</param>
        /// <param name="MessageText">Text, welcher auf dem Display ausgeben werden soll</param>
        /// <param name="Tonfolge">Tonfolge: 0 - Kein Ton; 1-10 siehe Documentation</param>
        public static bool ZeitEinstellen(OptionenTerminal Optionen, DateTime DatumZeit)
        {
            //Buffer[0] = 20;
            //Buffer[1] = 12;
            //Buffer[2] = 4;
            //Buffer[3] = 6; // 06.04.2012 Datum
            //Buffer[4] = 4;
            //Buffer[5] = 12;
            //Buffer[6] = 0; // 04:12:00 Uhrzeit

            var jahr   = DatumZeit.Year.ToString();
            var buffer = new byte[7];

            buffer[0] = Convert.ToByte(jahr.Substring(0, 2));
            buffer[1] = Convert.ToByte(jahr.Substring(2, 2));;
            buffer[2] = Convert.ToByte(DatumZeit.Month);
            buffer[3] = Convert.ToByte(DatumZeit.Day);
            buffer[4] = Convert.ToByte(DatumZeit.Hour);
            buffer[5] = Convert.ToByte(DatumZeit.Minute);
            buffer[6] = Convert.ToByte(DatumZeit.Second); // 04:12:00 Uhrzeit

            try
            {
                var res = DFComDLL.DFCComSetTime(Optionen.ChannelId, Optionen.DeviceId, buffer);
                return(res != 0);
            }
            catch
            {
                var msg = "Fehler beim Einstellen der Zeit im Terminal";
                Logger.Write(msg, "Service", 0, 0, TraceEventType.Warning);
            }
            return(false);
        }
Пример #2
0
        /// <summary>
        /// Programm zu auslesen er Datensätze aus dem Datsfox Terminal
        /// </summary>
        /// <param name="Optionen">Übertragungsoptionen zum Datafox Terminal</param>
        /// <returns>Ausgelesene Datensätze aus dem Terminal</returns>
        public static List <string> ListeAusTerminalAuslesen(OptionenTerminal Optionen)
        {
            string msg;

            byte[] buf = new byte[256];
            int    length, errorID = 0, result;
            var    listeAntwort = new List <string>();
            var    errorString  = new StringBuilder(255);

            try
            {
                // Schleife nur um mit break abzubrechen, kein goto verwenden.
                do
                {
                    // Lesen der Datensatzbeschreibungen, diese stellen die Tabellendefinitionen dar.
                    DFComDLL.TableDeclarations records = new DFComDLL.TableDeclarations(DFComDLL.TableDeclarations.TableType.Record, "Records.xml");
                    if (records.LoadFromDevice(Optionen.ChannelId, Optionen.DeviceId, "") == false)
                    {
                        // Fehlertext ermitteln
                        DFComDLL.DFCGetErrorText(Optionen.ChannelId, errorID, 0, errorString, errorString.Capacity);
                        msg = $"Lesen der Datensatzbeschreibung ist fehlgeschlagen.\nFehlerbeschreibung: {errorString}";
                        throw new MyException(msg);
                    }

                    if (records.Tables == null)
                    {
                        // Es liegen keine Datensatzbeschreibungen vor.
                        msg = string.Format("Es liegen keine Datensatzbeschreibungen vor.\nBitte prüfen Sie das eingespielte Setup.}");
                        throw new MyException(msg);
                    }

                    do
                    {
                        length = buf.Length;
                        // Datensatz lesen
                        if ((result = DFComDLL.DFCReadRecord(Optionen.ChannelId, Optionen.DeviceId, buf, out length, out errorID)) < 0)
                        {
                            msg = string.Format("Datensatz konnte nicht aus Terminal gelesen werden. Fehlercode: {0}", errorID);
                            throw new MyException(msg);
                        }

                        if (result == 0)
                        {
                            msg = "Es sind keine Anmeldungen im Terminal regiestriert.";
                            Logger.Write(msg, "Service", 0, 0, TraceEventType.Verbose);
                            break;
                        }

                        DFComDLL.DFRecord rs = new DFComDLL.DFRecord(buf, records);
                        listeAntwort.Add(rs.TabbedString());

                        // Datensatz quittieren
                        if (DFComDLL.DFCQuitRecord(Optionen.ChannelId, Optionen.DeviceId, out errorID) < 0)
                        {
                            msg = string.Format("Datensatz konnte nicht im Terminal quittiert werden. Fehlercode: {0}", errorID);
                            throw new MyException(msg);
                        }
                    } while (true);
                } while (false);
            }
            catch (Exception f)
            {
                msg = "Fehler beim einlesen der Anmeldedaten aus dem Terminal";
                throw new Exception(msg, f);
            }

            return(listeAntwort);
        }
        public static void ListenInTerminalSchreiben(OptionenTerminal Optionen, string PfadUpdateBediener)
        {
            string msg;
            var    errorString = new StringBuilder(255);
            int    errorID = 0;
            int    idx, res = 0;
            int    importCount = 0;
            var    import      = new DFComDLL.ListImport();

            try
            {
                // Listenformate aus Terminal auslesen
                var lists = new DFComDLL.TableDeclarations(DFComDLL.TableDeclarations.TableType.List, "Lists.xml");
                if (lists.LoadFromDevice(Optionen.ChannelId, Optionen.DeviceId, "") == false)
                {
                    // Fehlertext ermitteln
                    DFComDLL.DFCGetErrorText(Optionen.ChannelId, errorID, 0, errorString, errorString.Capacity);
                    msg = $"Lesen der Listenbeschreibung ist fehlgeschlagen.\nFehlerbeschreibung: {errorString}";
                    Logger.Write(msg, "Service", 0, 0, TraceEventType.Warning);
                }

                if (lists.Tables == null)
                {
                    msg = $"Es liegen keine Listendefinitionen im Verzeichnis {PfadUpdateBediener} vor.";
                    Logger.Write(msg, "Service", 0, 0, TraceEventType.Warning);
                    return;
                }

                DFComDLL.DFCClrListenBuffer(Optionen.ChannelId);

                // Vorliegende Listendaten importieren und übertragen.
                for (idx = 0; idx < lists.Tables.Length; idx++)
                {
                    string fileName = string.Format("{0}*.txt", lists.Tables[idx].Name);
                    var    files    = Directory.GetFiles(PfadUpdateBediener, fileName);

                    if (files.Length == 0 || files[0].EndsWith("txt") == false)
                    {
                        break;
                    }

                    if (files.Length > 1)
                    {
                        msg = $"Für Liste [{lists.Tables[idx].Name}] liegen mehrere Listendateien vor.";
                        Logger.Write(msg, "Service", 0, 0, TraceEventType.Warning);
                    }

                    try
                    {
                        // Importieren der Listendaten
                        import.Import(lists.Tables[idx], files[0]);
                        res = DFComDLL.DFCMakeListe(Optionen.ChannelId, idx, import.RecordCount, import.Size, import.Mem, 0);

                        if (res == 0)
                        {
                            msg = $"Übergabe der Listendaten aus der Datei [{files[0]}] ist fehlgeschlagen.";
                            Logger.Write(msg, "Service", 0, 0, TraceEventType.Warning);
                            continue;
                        }

                        msg = $"Liste [{lists.Tables[idx].Name} (Datensätze: {lists.Tables[idx].Name})] wurde importiert. Datei: {files[0]}";
                        Logger.Write(msg, "Service", 0, 0, TraceEventType.Verbose);
                    }
                    catch (DFComDLL.ListImportException ex)
                    {
                        msg = $"Import von Liste [{lists.Tables[idx].Name}] schlug fehl. Datei: {files[0]}\nGrund: {ex.Message}";
                        Logger.Write(msg, "Service", 0, 0, TraceEventType.Warning);
                        continue;
                    }

                    importCount++;
                }

                if (importCount == 0)
                {
                    msg = "Es liegen keine Listendaten vor.";
                    Logger.Write(msg, "Service", 0, 0, TraceEventType.Verbose);
                    return;
                }

                res = DFComDLL.DFCLoadListen(Optionen.ChannelId, Optionen.DeviceId, out errorID);
                if (res == 0)
                {
                    // Fehlertext ermitteln
                    DFComDLL.DFCGetErrorText(Optionen.ChannelId, errorID, 0, errorString, errorString.Capacity);
                    msg = $"Übertragung der Listendaten ist fehlgeschlagen.\nGrund: {errorString}";
                    Logger.Write(msg, "Service", 0, 0, TraceEventType.Warning);
                }

                msg = string.Format("Es wurde{0} {1} von {2} Listen übertragen.", (importCount == 1) ? "" : "n", importCount, lists.Tables.Length);
                Logger.Write(msg, "Service", 0, 0, TraceEventType.Information);
            }
            catch (Exception f)
            {
                msg = $"Fehler beim eintragen von Daten in das Terminal !\nGrund: {f.Message}";
                Logger.Write(msg, "Service", 0, 0, TraceEventType.Warning);
            }
        }
Пример #4
0
        public static void TerminaldatenEinUndAuslesen(OptionenArbeitszeit Optionen)
        {
            string msg;

            foreach (var datTerminal in Optionen.ListeTerminals)
            {
                try
                {
                    msg = $"Start Terminal: {datTerminal.Bezeichnung} / {datTerminal.eStandort.Bezeichnung}\n  IP: {datTerminal.IpNummer} Port: {datTerminal.PortNummer}\n-------------------------------------------------";
                    Logger.Write(msg, "Service", 0, 0, TraceEventType.Information);

                    var termAktuell = new OptionenTerminal(datTerminal.IpNummer, datTerminal.PortNummer, Optionen.Terminal_TimeOut);

                    if (!Helper.IstPingOk(termAktuell.IpAdresse, out msg))
                    {
                        Logger.Write(msg, "Service", 0, 0, TraceEventType.Warning);
                        datTerminal.FehlerTerminalAusgeloest = true;
                        continue;
                    }

                    List <string> DatensaetzeVomTerminal = null;

                    try
                    {
                        var offen = ProgDatafox.DatafoxOeffnen(termAktuell);
                        if (!offen)
                        {
                            msg = $"Verbindung zum Terminal konnte nicht geöffnet werden.";
                            Logger.Write(msg, "Service", 0, 0, TraceEventType.Warning);
                            datTerminal.FehlerTerminalAusgeloest = true;
                            continue;
                        }

                        // Zeit mit Termimal abgleichem
                        if (Optionen.DatumZeitAktualisieren)
                        {
                            if (ProgDatafox.ZeitEinstellen(termAktuell, DateTime.Now))
                            {
                                Logger.Write("Zeit Terminal gestellt", "Service", 0, 0, TraceEventType.Information);
                            }
                            else
                            {
                                Logger.Write("Zeit konnte nicht gestellt werden", "Service", 0, 0, TraceEventType.Warning);
                            }
                        }

                        // Kontrolle, ob Benutzer im Terminal geändert werden müssen

                        if (Optionen.UpdateBenutzerAusfuehren && datTerminal.UpdateTerminal)
                        {
                            datTerminal.TerminaldatenWurdenAktualisiert = true;
                            ProgDatafox.ListenInTerminalSchreiben(termAktuell, Optionen.PfadUpdateBediener);
                        }

                        // Anmeldungen aus Terminal auslesen
                        DatensaetzeVomTerminal = ProgDatafox.ListeAusTerminalAuslesen(termAktuell);
                        if (DatensaetzeVomTerminal.Count == 0)
                        {
                            msg = "Keine Datensätze vorhanden.";
                            Logger.Write(msg, "Service", 0, 0, TraceEventType.Verbose);
                        }
                        else
                        {
                            msg = $"Es wurden {DatensaetzeVomTerminal.Count} Arbeitszeiten von Terminal übertragen.";
                            Logger.Write(msg, "Service", 0, 0, TraceEventType.Information);
                        }
                    }
                    catch (Exception f)
                    {
                        msg = "Fehler bei Kommunikation mit Terminal";
                        datTerminal.FehlerTerminalAusgeloest = true;
                        throw new MyException(msg, f);
                    }
                    finally
                    {
                        msg = "Verbindung Terminal schliesen.";
                        Logger.Write(msg, "Service", 0, 0, TraceEventType.Information);
                        ProgDatafox.DatafoxSchliessen(termAktuell);
                    }

                    if (DatensaetzeVomTerminal.Count > 0)
                    {
                        try
                        {
                            var anmeldungen = ProgDatafox.KonvertDatafoxImport(DatensaetzeVomTerminal, datTerminal.fStandort, "MITA_");

                            var lsAnmeldung = anmeldungen.Select(s => $"  {s.MatchCode}   {s.GehGrund} - {s.Datum} /  {s.Vorgang}").ToArray();
                            Logger.Write($"Ausgelesene Anmeldungen\n{Helper.ListeInString(lsAnmeldung)}", "Service", 0, 0, TraceEventType.Information);

                            Optionen.ListeAnmeldungen.AddRange(anmeldungen);
                        }
                        catch (Exception f)
                        {
                            msg = "Fehler beim Konvertieren der Daten.";
                            throw new Exception(msg, f);
                        }
                    }
                }
                catch (Exception f)
                {
                    ExceptionPolicy.HandleException(f, "Policy");
                }
            }
        }