예제 #1
0
        public static void TranslateEvent(DbMCInterface.ID_EVENT ev, out DbMCInterface.EVENT evRes)
        {
            evRes = EVENT.Unknown;

            switch (ev)
            {
            case ID_EVENT.GENOBJECT_MODIFIED:
                evRes = EVENT.OnData53500Modified;
                break;

            case ID_EVENT.NEW_PLAN_VALUES:
            case ID_EVENT.REQUEST_PLAN_VALUES:
                evRes = EVENT.OnPlanDataChanged;
                break;

            case ID_EVENT.RELOAD_PLAN_VALUES:
            case ID_EVENT.PHANTOM_RELOAD_PLAN_VALUES:
                evRes = EVENT.OnMaket53500Changed;
                break;

            case ID_EVENT.MC_SERVICE:
                evRes = EVENT.OnModesEvent;
                break;

            default:
                break;
            }
        }
예제 #2
0
        public static DbMCInterface.EVENT TranslateEvent(DbMCInterface.ID_EVENT ev)
        {
            DbMCInterface.EVENT evRes = EVENT.Unknown;

            TranslateEvent(ev, out evRes);

            return(evRes);
        }
예제 #3
0
            public EventArgs(DbMCInterface.ID_EVENT id, DateTime date, ReadOnlyCollection <T> listParameters)
                : base()
            {
                m_id = id;

                m_Date = date;

                m_listParameters = new ReadOnlyCollection <T> (listParameters);
            }
예제 #4
0
        private void dbMCSources_OnEventHandler(object obj)
        {
            DbMCInterface.ID_EVENT id_event = DbMCInterface.ID_EVENT.Unknown;
            EventArgs argEventChanged       = null; // оборудование для которого произошло событие
            TEC       tec;                          // для оборудования которой произошло событие
            Tuple <DbMCInterface.EVENT, bool> tupleConnectHandler;

            Func <DateTime, TimeSpan> difference = delegate(DateTime target) {
                // разница целевой даты объекта события и текущей даты
                return(target - ASUTP.Core.HDateTime.ToMoscowTimeZone());
            };

            Func <DateTime, bool> isRequired = delegate(DateTime target) {
                // разница целевой даты объекта события и текущей даты; для проверки необходимости обработки события (только текущие сутки)
                TimeSpan diff = difference(target);

                return(diff.TotalDays > -1 &&
                       diff.TotalDays < ASUTP.Core.HDateTime.TS_MSK_OFFSET_OF_UTCTIMEZONE.TotalDays);
            };

            Func <DbMCInterface.ID_EVENT, DateTime, DateTime> translate = delegate(DbMCInterface.ID_EVENT id, DateTime datetime) {
                return(((id == DbMCInterface.ID_EVENT.RELOAD_PLAN_VALUES) || (id == DbMCInterface.ID_EVENT.NEW_PLAN_VALUES))
                    ? datetime.SystemToLocalHqEx()
                        : ((id == DbMCInterface.ID_EVENT.PHANTOM_RELOAD_PLAN_VALUES) || (id == DbMCInterface.ID_EVENT.REQUEST_PLAN_VALUES))
                            ? datetime
                                : datetime);
            };

            if (obj is Array)
            {
                id_event = (DbMCInterface.ID_EVENT)(obj as object []) [0];

                if (id_event == DbMCInterface.ID_EVENT.GENOBJECT_MODIFIED)
                {
                    Modes.NetAccess.EventRefreshData53500 ev = (obj as object []) [1] as Modes.NetAccess.EventRefreshData53500;

                    #region Подготовка текста сообщения в журнал о событии
                    string msg      = string.Empty
                    , listEquipment = string.Empty;
                    msg = string.Format(@"AdminMC::dbMCSources_OnEventHandler((ID_MC_EVENT={1}) - обработчик события - изменения[кол-во={2}]{0}для оборудования {3}..."
                                        , Environment.NewLine, id_event, ev.Equipments.Count, @"СПИСОК");
                    foreach (KeyValuePair <DateTime, List <int> > pair in ev.Equipments)
                    {
                        listEquipment += string.Format(@"[Дата={0}, список=({1})],", pair.Key.ToString(), string.Join(", ", pair.Value));
                    }
                    listEquipment = listEquipment.Remove(listEquipment.Length - 1);
                    msg           = msg.Replace(@"СПИСОК", listEquipment);
                    #endregion

                    Logging.Logg().Action(msg, Logging.INDEX_MESSAGE.NOT_SET);
                }
                else if ((id_event == DbMCInterface.ID_EVENT.RELOAD_PLAN_VALUES) ||
                         (id_event == DbMCInterface.ID_EVENT.PHANTOM_RELOAD_PLAN_VALUES))
                {
                    Modes.NetAccess.EventRefreshJournalMaket53500 ev = (obj as object []) [1] as Modes.NetAccess.EventRefreshJournalMaket53500;

                    DateTime dateTarget;
                    ReadOnlyCollection <Guid> makets;
                    string abbr = string.Empty
                    , taskModes = string.Empty;

                    dateTarget = translate(id_event, ev.dtTarget.GetValueOrDefault());
                    makets     = ev.makets as ReadOnlyCollection <Guid>;
                    abbr       = ev.Task.GetAbbr();
                    taskModes  = ev.Task.ModesTaskToString();

                    Logging.Logg().Action(string.Format(@"AdminMC::dbMCSources_OnEventHandler(ID_MC_EVENT={0}) - обработчик события - переопубликация[на дату={1}, кол-во макетов={2}], Аббр={3}, описание={4}..."
                                                        , id_event.ToString(), dateTarget.ToString(), makets.Count, abbr, taskModes)
                                          , Logging.INDEX_MESSAGE.NOT_SET);

                    if (isRequired(dateTarget) == true)
                    {
                        argEventChanged = new EventArgs <Guid> (id_event, dateTarget, makets);
                    }
                    else
                    {
                        Logging.Logg().Debug($"AdminMC::dbMCSources_OnEventHandler(ID_MC_EVENT={id_event.ToString ()}) - дата нового не актуальна; Day=[{dateTarget}], разн.(сутки)=[{difference (dateTarget).TotalDays}]..."
                                             , Logging.INDEX_MESSAGE.NOT_SET);
                    }
                }
                else if ((id_event == DbMCInterface.ID_EVENT.NEW_PLAN_VALUES) ||
                         (id_event == DbMCInterface.ID_EVENT.REQUEST_PLAN_VALUES))
                {
                    Modes.NetAccess.EventPlanDataChanged ev = (obj as object []) [1] as Modes.NetAccess.EventPlanDataChanged;

                    DateTime day
                    , version;
                    string pbr_number = string.Empty
                    , id_mc_tec       = string.Empty;
                    int id_gate       = -1;

                    day        = translate(id_event, ev.Day);
                    pbr_number = ev.Type.PlanTypeToString();
                    version    = translate(id_event, ev.Version);
                    id_mc_tec  = ev.ClientId;
                    id_gate    = ev.IdGate;

                    Logging.Logg().Action(string.Format(@"AdminMC::dbMCSources_OnEventHandler(ID_MC_EVENT={0}) - обработчик события - {6} план[на дату={1}, номер={2}, версия={3}, для подразделения={4}, IdGate={5}]..."
                                                        , id_event.ToString(), day.ToString(), pbr_number, version.ToString(), id_mc_tec, id_gate
                                                        , id_event == DbMCInterface.ID_EVENT.NEW_PLAN_VALUES ? "новый" : id_event == DbMCInterface.ID_EVENT.REQUEST_PLAN_VALUES ? "<запрос>" : "НЕ ИЗВЕСТНО")
                                          , Logging.INDEX_MESSAGE.NOT_SET);

                    // проверить дату за которую получен новый план: только сегодняшние и следующие сутки сутки
                    if (isRequired(day) == true)
                    {
                        tec = m_list_tec.Find(t => {
                            return(t.name_MC.Trim().Equals(id_mc_tec.ToString()));
                        });

                        argEventChanged = new EventArgs <FormChangeMode.KeyDevice> (id_event, day, new ReadOnlyCollection <FormChangeMode.KeyDevice> (
                                                                                        allTECComponents.FindAll(comp => {
                            return((comp.IsGTP == true) &&
                                   (comp.tec.m_id == tec.m_id));
                        }).ConvertAll(comp => new FormChangeMode.KeyDevice()
                        {
                            Id = comp.m_id, Mode = FormChangeMode.MODE_TECCOMPONENT.GTP
                        })
                                                                                        ));
                    }
                    else
                    {
                        Logging.Logg().Debug($"AdminMC::dbMCSources_OnEventHandler(ID_MC_EVENT={id_event.ToString ()}) - дата не актуальная; Day=[{day}], разн.(сутки)=[{difference (day).TotalDays}]..."
                                             , Logging.INDEX_MESSAGE.NOT_SET);
                    }
                }
                else
                {
                    ;
                }
                // проверить сфорирован ли аргумент для события
                // , имеется ли обработчик; иначе из коллекции не смогут быть удалены элементы(удаление только из-вне)
                // , а значит коллекция увеличивается без ограничений, а элементы никаким образом не обрабатываются
                if ((Equals(argEventChanged, null) == false) &&
                    (isHandlerMCEvent(id_event) == true))
                {
                    AddEvent(argEventChanged);
                }
                else
                {
                    ;
                }
            }
            else if (typeof(Tuple <DbMCInterface.EVENT, bool>).IsAssignableFrom(obj.GetType()) == true)
            {
                //TODO: ретранслировать для формы произошла подписка/отписка от события Модес-Центра
                tupleConnectHandler = obj as Tuple <DbMCInterface.EVENT, bool>;

                _dictNotify [DbMCInterface.ID_EVENT.HANDLER_CONNECT]?.Invoke(this, new EventArgs <bool>(DbMCInterface.TranslateEvent(tupleConnectHandler.Item1), DateTime.MinValue, new ReadOnlyCollection <bool> (new List <bool>()
                {
                    tupleConnectHandler.Item2
                })));
            }
            else if (typeof(bool).IsAssignableFrom(obj.GetType()) == true)
            {
                id_event = DbMCInterface.ID_EVENT.Unknown;

                //TODO: проверить результат попытки установки соединения
                Logging.Logg().Action($"AdminMC::dbMCSources_OnEventHandler(ID_MC_EVENT={id_event.ToString ()}) - изменение состояния соединения УСТАНОВЛЕНО = {(bool)obj})...", Logging.INDEX_MESSAGE.NOT_SET);

                switch ((bool)obj == true ? 1 : 0)
                {
                case 0:
                    _eventConnected.Reset();
                    break;

                case 1:
                    _eventConnected.Set();
                    FetchEvent(false);
                    break;

                default:
                    break;
                }
            }
            else
            {
                throw new Exception(@"AdminMC::dbMCSources_OnEventHandler () - неизвестное событие от DbMCSources...");
            }
        }
예제 #5
0
        private void listMCEventArgs_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            IEventArgs arg = null;

            DbMCInterface.ID_EVENT id = trans_mc.DbMCInterface.ID_EVENT.Unknown;
            string mesLog             = string.Empty;

            //Func<IEventArgs, DbMCInterface.ID_EVENT> contextId = delegate (IEventArgs ev) {
            //    DbMCInterface.ID_EVENT id_event = DbMCInterface.ID_EVENT.Unknown;

            //    if (typeof (Guid).IsAssignableFrom (ev.) == true)
            //        id_event = DbMCInterface.ID_EVENT.RELOAD_PLAN_VALUES;
            //    else if (typeof (FormChangeMode.KeyDevice).IsAssignableFrom (ev.m_type) == true)
            //        id_event = DbMCInterface.ID_EVENT.NEW_PLAN_VALUES;
            //    else
            //        ;

            //    return id_event;
            //};

            Func <IEventArgs, bool> doWork = delegate(IEventArgs ev) {
                bool bRes = false;

                bRes = isHandlerMCEvent(ev.m_id);

                if (bRes == true)
                {
                    // "?" на всякий случай, т.к. проверка уже выполнена
                    _dictNotify [ev.m_id]?.Invoke(this, (ev as EventArgs));
                }
                else
                {
                    ;
                }

                return(bRes);
            }
            , delegateDoWork = null;

            switch (e.Action)
            {
            case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
                id =
                    //contextId ((IEventArgs)e.NewItems[0])
                    ((IEventArgs)e.NewItems [0]).m_id
                ;

                if (e.NewStartingIndex == 0)
                {
                    arg = (IEventArgs)e.NewItems [0];

                    activateTimerFetchWaking(false);
                }
                else
                {
                    // новые элементы будут ожидать обработки
                    ;
                }
                break;

            case System.Collections.Specialized.NotifyCollectionChangedAction.Reset:
            case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:
                if ((sender as ObservableCollection <EventArgs>).Count > 0)
                {
                    arg = (IEventArgs)(sender as ObservableCollection <EventArgs>) [0];
                    id  =
                        //contextId (arg)
                        arg.m_id
                    ;
                }
                else
                {
                    //??? в случае 'Reset' - исключение, т.к. 'e.OldItems' = NullReference
                    try {
                        id =
                            //contextId ((IEventArgs)e.OldItems [0])
                            ((IEventArgs)e.OldItems [0]).m_id
                        ;
                    } catch (Exception excp) {
                        Logging.Logg().Exception(excp, $"AdminMC::listMCEventArgs_CollectionChanged (Act.={e.Action}) - Connected={isConnected}, ", Logging.INDEX_MESSAGE.NOT_SET);
                    } finally {
                        activateTimerFetchWaking(true);
                    }
                }
                break;

            default:
                break;
            }

            mesLog = $"AdminMC::listMCEventArgs_CollectionChanged (Act.={e.Action}, ID_EVENT={id}) - Connected={isConnected}, ";

            if ((Equals(arg, null) == false) &&
                isConnected == true)
            {
                delegateDoWork = doWork;

                mesLog = $"{mesLog}Count={_listMCEventArgs.Count}, NewIndex={e.NewStartingIndex}, OldIndex={e.OldStartingIndex}...";
            }
            else
            {
                if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add)
                {
                    mesLog = $@"{mesLog}ожидание обработки({e.NewStartingIndex}-й в списке): {((IEventArgs)(sender as ObservableCollection<EventArgs>) [e.NewStartingIndex]).m_id.ToString()}...";
                }
                else if ((e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Remove) &&
                         ((sender as ObservableCollection <EventArgs>).Count == 0))
                {
                    mesLog = $@"{mesLog}из коллекции удален крайний элемент ...";
                }
                else
                {
                    ;
                }
            }

            Logging.Logg().Debug(mesLog, Logging.INDEX_MESSAGE.NOT_SET);

            // не выпполнять, если 'delegateDoWork' = null (при 'arg' = null)
            delegateDoWork?.Invoke(arg);

            _autoResetEvent_MCArgs_CollectionChanged.Set();
        }
예제 #6
0
 public void AddEventHandler(DbMCInterface.ID_EVENT id_event, EventHandler handler)
 {
     _dictNotify.Add(id_event, handler);
 }
예제 #7
0
 /// <summary>
 /// Возвратить признак наличия обработчика события указанного в аргументе типа
 /// </summary>
 /// <param name="idMCEvent">Тип события Модес-Центр</param>
 /// <returns>Признак наличия обработчика</returns>
 private bool isHandlerMCEvent(DbMCInterface.ID_EVENT idMCEvent)
 {
     return((_dictNotify.ContainsKey(idMCEvent) == true)
         ? (Equals(_dictNotify[idMCEvent], null) == false)
             : false);
 }