コード例 #1
0
        /// <summary>
        /// Обработчик событий от объекта взаимодействия с БД
        /// </summary>
        /// <param name="obj">Объект с идентификатором события, аргументами события (при необходимости)</param>
        private void writerDbHandler_OnDataAskedHost(object obj)
        {
            ASUTP.Helper.HHandler.INDEX_WAITHANDLE_REASON indxReasonCompleted = (ASUTP.Helper.HHandler.INDEX_WAITHANDLE_REASON)(obj as object[])[0];
            int      idConnSett = (int)(obj as object[])[1];
            DateTime dtRecieved = (DateTime)(obj as object[])[2];

            try {
                var writerDataSet = (from dataSet in _listDataSet where dataSet.m_dtRecieved == dtRecieved select dataSet).ElementAt(0);
                writerDataSet.m_dictDatetimeQuered[idConnSett] =
                    indxReasonCompleted == ASUTP.Helper.HHandler.INDEX_WAITHANDLE_REASON.SUCCESS ? DateTime.UtcNow :
                    indxReasonCompleted == INDEX_WAITHANDLE_REASON.ERROR ? DateTime.MaxValue :
                    DateTime.MinValue;

                if (indxReasonCompleted == INDEX_WAITHANDLE_REASON.ERROR)
                {
                    EvtToFormMain?.Invoke(new object[] {
                        StatesMachine.MESSAGE_TO_STATUSSTRIP
                        , FormMain.StatusStrip.STATE.Error
                        , string.Format(@"WriterHandlerQueue - ошибка при сохранении значений для источника={0} за {1}", idConnSett, dtRecieved)
                    });
                }
                else
                {
                    ;
                }
            } catch (Exception e) {
                Logging.Logg().Exception(e
                                         , string.Format(@"не найден набор для IdConnSett={0}, [{1}]", idConnSett, dtRecieved.ToString())
                                         , Logging.INDEX_MESSAGE.NOT_SET);
            }
        }
コード例 #2
0
        protected override int StateResponse(int state, object obj)
        {
            int       iRes      = 0;
            ItemQueue itemQueue = Peek;

            EvtToFormMain?.Invoke(new object[] {
                StatesMachine.MESSAGE_TO_STATUSSTRIP
                , FormMain.StatusStrip.STATE.Action
                , string.Format(@"WriterHandlerQueue - обработка события {0}", ((StatesMachine)state).ToString())
            });

            switch ((StatesMachine)state)
            {
            case StatesMachine.NEW:     // самый старый набор для постановки в очередь на запись,
                _writer.Request((DATASET_WRITER)obj);
                break;

            case StatesMachine.LIST_DEST:  // получены параметры соединения БД, ответа не требуется
            case StatesMachine.CONNSET_USE_CHANGED:
            case StatesMachine.OPTION:     //
                //Ответа не требуется/не требуют обработки результата
                break;

            case StatesMachine.LIST_DATASET:     // отправить главному окну(для отображения) информацию о поученных/обработанных наборах с данными
            case StatesMachine.DATASET_CONTENT:  // отправить главному окну(для отображения) информацию о выбранном для отображения в главном окне
                //case StatesMachine.STATISTIC: // статический объект (obj = null)
                if ((!(itemQueue == null))
                    //&& (!(itemQueue.m_dataHostRecieved == null)) FormMain не реализует интерфейс 'IDataHost'
                    )
                {
                    // вариант для объекта с интерфейсом 'IDataHost'
                    //itemQueue.m_dataHostRecieved.OnEvtDataRecievedHost(new object[] { state, obj })
                    EvtToFormMain?.Invoke(new object[] { state, obj })
                    ;
                }
                else
                {
                    ;
                }
                break;

            default:
                break;
            }

            //Debug.WriteLine(string.Format(@"WriterHandlerQueue::StateResponse(state={0}) - ...", ((StatesMachine)state).ToString()));

            return(iRes);
        }
コード例 #3
0
        protected override int StateResponse(int state, object obj)
        {
            int       iRes      = 0;
            ItemQueue itemQueue = Peek;

            EvtToFormMain?.Invoke(new object[] {
                StatesMachine.MESSAGE_TO_STATUSSTRIP
                , FormMain.StatusStrip.STATE.Action
                , string.Format(@"PackageHandlerQueue - обработка события {0}", ((StatesMachine)state).ToString())
            });

            switch ((StatesMachine)state)
            {
            case StatesMachine.NEW:     //
            case StatesMachine.OPTION:  //
                //Ответа не требуется/не требуют обработки результата
                break;

            case StatesMachine.LIST_PACKAGE:    //
            case StatesMachine.PACKAGE_CONTENT: //
            case StatesMachine.STATISTIC:       // статический объект
            case StatesMachine.TIMER_TABLERES:
                if ((!(itemQueue == null))
                    //&& (!(itemQueue.m_dataHostRecieved == null)) FormMain не реализует интерфейс 'IDataHost'
                    )
                {
                    // вариант для объекта с интерфейсом 'IDataHost'
                    //itemQueue.m_dataHostRecieved.OnEvtDataRecievedHost(new object[] { state, obj })
                    EvtToFormMain?.Invoke(new object [] { state, obj })
                    ;
                }
                else
                {
                    ;
                }
                break;

            default:
                break;
            }

            return(iRes);
        }
コード例 #4
0
        protected override ASUTP.Helper.HHandler.INDEX_WAITHANDLE_REASON StateErrors(int state, int req, int res)
        {
            EvtToFormMain?.Invoke(new object[] {
                StatesMachine.MESSAGE_TO_STATUSSTRIP
                , FormMain.StatusStrip.STATE.Error
                , string.Format(@"WriterHandlerQueue - обработка события {0}", ((StatesMachine)state).ToString())
            });

            switch ((StatesMachine)state)
            {
            default:
                break;
            }

            Logging.Logg().Error(string.Format(@"WriterHandlerQueue::StateErrors () - не обработана ошибка [{0}, REQ={1}, RES={2}] ..."
                                               , ((StatesMachine)state).ToString(), req, res)
                                 , Logging.INDEX_MESSAGE.NOT_SET);

            return(HHandler.INDEX_WAITHANDLE_REASON.SUCCESS);
        }
コード例 #5
0
        protected override int StateResponse(int state, object obj)
        {
            int       iRes      = 0;
            ItemQueue itemQueue = Peek;

            switch ((StatesMachine)state)
            {
            case StatesMachine.NEW:     //
                //Ответа не требуется/не требуют обработки результата
                break;

            case StatesMachine.LIST_PACKAGE:    //
            case StatesMachine.PACKAGE_CONTENT: //
            case StatesMachine.STATISTIC:       // статический объект
            case StatesMachine.TIMER_TABLERES:
                if ((!(itemQueue == null))
                    //&& (!(itemQueue.m_dataHostRecieved == null)) FormMain не реализует интерфейс 'IDataHost'
                    )
                {
                    // вариант для объекта с интерфейсом 'IDataHost'
                    //itemQueue.m_dataHostRecieved.OnEvtDataRecievedHost(new object[] { state, obj })
                    EvtToFormMain?.Invoke(new object [] { state, obj })
                    ;
                }
                else
                {
                    ;
                }
                break;

            default:
                break;
            }

            return(iRes);
        }
コード例 #6
0
        /// <summary>
        /// Подготовить объект для отправки адресату по его запросу
        /// </summary>
        /// <param name="s">Событие - идентификатор запрашиваемой информации/операции,действия</param>
        /// <param name="error">Признак выполнения операции/действия по запросу</param>
        /// <param name="outobj">Объект для отправления адресату как результат запроса</param>
        /// <returns>Признак выполнения метода (дополнительный)</returns>
        protected override int StateCheckResponse(int s, out bool error, out object outobj)
        {
            int           iRes     = -1;
            StatesMachine state    = (StatesMachine)s;
            string        debugMsg = string.Empty;

            error  = true;
            outobj = null;

            ItemQueue itemQueue = null;

            try {
                switch (state)
                {
                case StatesMachine.UDP_CONNECTED_CHANGE:     // запрос-команда на изменение состояния (от формы)
                case StatesMachine.WRITER_READY_CHANGE:
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    outobj = itemQueue.Pars[0];
                    break;

                case StatesMachine.UDP_CONNECTED_CHANGED:     // событие - факт изменения состояния (от объекта - прослушивателя UDP)
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    EvtToFormMain?.Invoke(new object[] { state, itemQueue.Pars[0] });
                    break;

                case StatesMachine.UDP_LISTENER_PACKAGE_RECIEVED:     // получен очередной XML-пакет
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    EvtToFormMain?.Invoke(new object[] { state, itemQueue.Pars[0], itemQueue.Pars[1] });

                    debugMsg = @"получен XML-пакет, добавлен в очередь для обработки";
                    Logging.Logg().Debug(MethodBase.GetCurrentMethod(), debugMsg, Logging.INDEX_MESSAGE.NOT_SET);
                    Debug.WriteLine(string.Format(@"{0}: {1}", DateTime.Now.ToString(), debugMsg));
                    break;

                case StatesMachine.XML_PACKAGE_VERSION:     // версия(строка) шаблон XML-пакета
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    outobj = m_fileINI.XMLPackageVersion;
                    break;

                case StatesMachine.XML_PACKAGE_TEMPLATE:     // шаблон XML-пакета
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    outobj = m_fileINI.GetXMLPackageTemplate((string)itemQueue.Pars[0]);
                    break;

                case StatesMachine.NUDP_LISTENER:     // номер порта прослушивателя
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    outobj = m_fileINI.NUDPListener;
                    break;

                case StatesMachine.LIST_DEST:     // cписок источников данных (назначение - сохранение полученных значений)
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    EvtToFormMain?.Invoke(new object[] { state, m_fileINI.ListDest });
                    break;

                default:
                    break;
                }
            } catch (Exception e) {
                Logging.Logg().Exception(e, @"HHandlerQueue::StateCheckResponse (state=" + state.ToString() + @") - ...", Logging.INDEX_MESSAGE.NOT_SET);

                error = true;
                iRes  = -1 * (int)state;
            }

            return(iRes);
        }
コード例 #7
0
        /// <summary>
        /// Подготовить объект для отправки адресату по его запросу
        /// </summary>
        /// <param name="s">Событие - идентификатор запрашиваемой информации/операции,действия</param>
        /// <param name="error">Признак выполнения операции/действия по запросу</param>
        /// <param name="outobj">Объект для отправления адресату как результат запроса</param>
        /// <returns>Признак выполнения метода (дополнительный)</returns>
        protected override int StateCheckResponse(int s, out bool error, out object outobj)
        {
            int           iRes  = -1;
            StatesMachine state = (StatesMachine)s;
            PACKAGE       package;
            string        debugMsg = string.Empty;

            error  = true;
            outobj = null;

            ItemQueue itemQueue = null;

            try {
                switch (state)
                {
                case StatesMachine.NEW:     // новый пакет
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    EvtToFormMain?.Invoke(new object[] { PackageHandlerQueue.StatesMachine.MESSAGE_TO_STATUSSTRIP
                                                         , FormMain.STATUS_STRIP_STATE.Debug
                                                         , string.Format(@"Получен новый пакет {0}", (DateTime)itemQueue.Pars[0]) });

                    error = (iRes = addPackage((DateTime)itemQueue.Pars[0], (XmlDocument)itemQueue.Pars[1])) < 0 ? true : false;
                    break;

                case StatesMachine.LIST_PACKAGE:     // список пакетов
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    outobj = listViewPackageItem;
                    break;

                case StatesMachine.PACKAGE_CONTENT:     // пакет
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    var selectPackages = from p in _listPackage where p.m_dtRecieved == (DateTime)itemQueue.Pars[0] select p;
                    if (selectPackages.Count() == 1)
                    {
                        package = selectPackages.ElementAt(0);

                        switch ((FormMain.INDEX_TABPAGE_VIEW_PACKAGE)itemQueue.Pars[1])
                        {
                        case FormMain.INDEX_TABPAGE_VIEW_PACKAGE.XML:
                            outobj = package.m_xmlSource;
                            break;

                        case FormMain.INDEX_TABPAGE_VIEW_PACKAGE.TREE:
                            outobj = package.m_listXmlTree;
                            break;

                        default:         //??? - ошибка неизвестный тип вкладки просмотра XML-документа
                            break;
                        }
                    }
                    else
                    {
                        ;     //??? - ошибка пакет не найден либо пакетов много
                    }
                    break;

                case StatesMachine.STATISTIC:     // статистика
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    //outobj = ??? объект статический
                    break;

                case StatesMachine.TIMER_TABLERES:     // срок отправлять очередной пакет
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    var orderPckages = from p in _listPackage where p.m_dtSended == DateTime.MinValue orderby p.m_dtRecieved descending select p;
                    if (orderPckages.Count() > 0)
                    {
                        package = orderPckages.ElementAt(0);

                        package.m_dtSended = DateTime.UtcNow;

                        outobj = new object[] {
                            package.m_dtSended
                            , package.m_tableValues.Copy()
                            , package.m_tableParameters.Copy()
                        };
                    }
                    else
                    {
                        //??? - ошибка пакет не найден либо пакетов много
                        //    iRes = -1;
                        //    error = true;
                        outobj = false;
                    }
                    break;

                default:
                    break;
                }
            } catch (Exception e) {
                Logging.Logg().Exception(e, @"PackageHandlerQueue::StateCheckResponse (state=" + state.ToString() + @") - ...", Logging.INDEX_MESSAGE.NOT_SET);

                error = true;
                iRes  = -1 * (int)state;
            }

            return(iRes);
        }
コード例 #8
0
        /// <summary>
        /// Подготовить объект для отправки адресату по его запросу
        /// </summary>
        /// <param name="s">Событие - идентификатор запрашиваемой информации/операции,действия</param>
        /// <param name="error">Признак выполнения операции/действия по запросу</param>
        /// <param name="outobj">Объект для отправления адресату как результат запроса</param>
        /// <returns>Признак выполнения метода (дополнительный)</returns>
        protected override int StateCheckResponse(int s, out bool error, out object outobj)
        {
            int           iRes     = -1;
            StatesMachine state    = (StatesMachine)s;
            string        debugMsg = string.Empty;

            error  = true;
            outobj = null;

            ItemQueue itemQueue = null;

            try {
                switch (state)
                {
                case StatesMachine.UDP_CONNECTED_CHANGE:     // запрос-команда на изменение состояния (от формы)
                case StatesMachine.WRITER_READY_CHANGE:
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    outobj = itemQueue.Pars[0];
                    break;

                case StatesMachine.UDP_CONNECTED_CHANGED:     // событие - факт изменения состояния (от объекта - прослушивателя UDP)
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    EvtToFormMain?.Invoke(new object[] { state, itemQueue.Pars[0], itemQueue.Pars[1] });
                    break;

                case StatesMachine.UDP_LISTENER_PACKAGE_RECIEVED:     // получен очередной XML-пакет
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    EvtToFormMain?.Invoke(new object[] { state, itemQueue.Pars[0], itemQueue.Pars[1] });
                    break;

                case StatesMachine.XML_PACKAGE_VERSION:     // версия(строка) шаблон XML-пакета
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    outobj = m_fileINI.XMLPackageVersion;
                    break;

                case StatesMachine.XML_PACKAGE_TEMPLATE:     // шаблон XML-пакета
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    outobj = m_fileINI.GetXMLPackageTemplate((string)itemQueue.Pars[0]);
                    break;

                case StatesMachine.UDP_DEBUG:     // параметры отладки
                    iRes  = 0;
                    error = false;

                    //itemQueue = Peek;

                    outobj = m_fileINI.UDPDebug;
                    break;

                case StatesMachine.UDP_LISTENER:     // номер порта прослушивателя
                    iRes  = 0;
                    error = false;

                    //itemQueue = Peek;

                    outobj = m_fileINI.UDPListener;
                    break;

                case StatesMachine.LOGGING_SET:
                    iRes  = 0;
                    error = false;

                    //itemQueue = Peek;

                    EvtToFormMain?.Invoke(new object[] { state, m_fileINI.LoggingSet });
                    break;

                case StatesMachine.OPTION_PACKAGE:
                    iRes  = 0;
                    error = false;

                    //itemQueue = Peek;

                    EvtToFormMain?.Invoke(new object[] { state, m_fileINI.OptionPackage });
                    break;

                case StatesMachine.OPTION_DEST:
                    iRes  = 0;
                    error = false;

                    //itemQueue = Peek;

                    EvtToFormMain?.Invoke(new object[] { state, m_fileINI.OptionDataSet });
                    break;

                case StatesMachine.LIST_DEST:     // cписок источников данных (назначение - сохранение полученных значений)
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    EvtToFormMain?.Invoke(new object[] { state, m_fileINI.ListDest });
                    break;

                case StatesMachine.DEST_DETAIL:     // параметры соединения с источником данных
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    EvtToFormMain?.Invoke(new object[] { state, m_fileINI.ListDest.Find(connSett => { return(connSett.id == (int)itemQueue.Pars[0]); }) });
                    break;

                case StatesMachine.TIMER_UPDATE:
                    iRes  = 0;
                    error = false;

                    EvtToFormMain?.Invoke(new object[] { state, m_fileINI.TimerUpdate });
                    break;

                default:
                    break;
                }
            } catch (Exception e) {
                Logging.Logg().Exception(e, @"HHandlerQueue::StateCheckResponse (state=" + state.ToString() + @") - ...", Logging.INDEX_MESSAGE.NOT_SET);

                error = true;
                iRes  = -1 * (int)state;
            }

            return(iRes);
        }