Пример #1
0
        // ================================================================================================

        public void HSEvent(Enums.HSEvent EventType, object[] parms)
        {
            Console.WriteLine("HSEvent: " + EventType.ToString());
            switch (EventType)
            {
            case Enums.HSEvent.VALUE_CHANGE:
                break;
            }
        }
Пример #2
0
        public bool EvaluateTrigger(Enums.HSEvent eventType, double valueLeft, double valueRight)
        {
            if (Type == TriggerType.DeviceValueChanged && eventType != Enums.HSEvent.VALUE_CHANGE)
            {
                // We don't need to check DeviceValueSet because it also covers changed cases
                return(false);
            }

            return(EvaluateCondition(valueLeft, valueRight));
        }
Пример #3
0
        public override void HSEvent(Enums.HSEvent eventType, object[] parameters)
        {
            // TODO: This is where the bulk of the work happens

            //if (!IsAnyWebHookConfigured())
            //{
            //    Program.WriteLog(LogType.Debug,
            //        "Ignoring event " + eventType + " because no webhook endpoint is configured.");
            //    return;
            //}

            Dictionary <string, object> dict = new Dictionary <string, object> {
                { "eventType", eventType.ToString() }
            };

            try
            {
                int devRef;

                switch (eventType)
                {
                case Enums.HSEvent.VALUE_SET:
                case Enums.HSEvent.VALUE_CHANGE:
                    devRef = (int)parameters[4];
                    dict.Add("address", (string)parameters[1]);
                    dict.Add("newValue", ((double)parameters[2]).ToString(CultureInfo.InvariantCulture));
                    dict.Add("oldValue", ((double)parameters[3]).ToString(CultureInfo.InvariantCulture));
                    dict.Add("ref", devRef);
                    break;

                case Enums.HSEvent.STRING_CHANGE:
                    devRef = (int)parameters[3];
                    dict.Add("address", (string)parameters[1]);
                    dict.Add("newValue", (string)parameters[2]);
                    dict.Add("ref", devRef);
                    break;

                default:
                    HS.WriteLog("Warn", "Unknown event type " + eventType);
                    return;
                }

                string json = JsonConvert.SerializeObject(dict);
                HS.WriteLog("Verbose", json);

                WebSocketServer.Broadcast(json);
            }
            catch (Exception ex)
            {
                HS.WriteLog("Error", ex.ToString());
            }
        }
Пример #4
0
 public override void HSEvent(Enums.HSEvent eventType, [AllowNull] object[] parameters)
 {
     try
     {
         if ((eventType == Enums.HSEvent.VALUE_CHANGE) && (parameters.Length > 4))
         {
             int deviceRefId = Convert.ToInt32(parameters[4]);
             RecordDeviceValue(deviceRefId).Wait(ShutdownCancellationToken);
         }
     }
     catch (Exception ex)
     {
         Trace.TraceWarning(Invariant($"Failed to process HSEvent {eventType} with {ex.GetFullMessage()}"));
     }
 }
Пример #5
0
        public override void HSEvent(Enums.HSEvent eventType, object[] parameters)
        {
            switch (eventType)
            {
            case Enums.HSEvent.CONFIG_CHANGE:
                int type = (int)parameters[1];
                int dac  = (int)parameters[4];
                Program.WriteLog(LogType.Verbose, "HSEvent triggered " + eventType + " type " + type + " DAC " + dac);
                if (type == 0 && (dac == 1 || dac == 2))
                {
                    // Device was added or deleted
                    cacheDeviceList();
                }

                break;

            case Enums.HSEvent.VALUE_SET:
            case Enums.HSEvent.VALUE_CHANGE:
                int devRef = (int)parameters[4];
                Program.WriteLog(LogType.Verbose, "HSEvent triggered " + eventType + " for dev ref " + devRef);

                // Do any of our triggers reference this device?
                foreach (TriggerEntry trig in getTriggerList())
                {
                    if (trig.Data.DevRefLeft == devRef || trig.Data.DevRefRight == devRef)
                    {
                        // Yep.
                        double valueLeft  = hs.DeviceValueEx(trig.Data.DevRefLeft);
                        double valueRight = hs.DeviceValueEx(trig.Data.DevRefRight);
                        if (trig.Data.EvaluateTrigger(eventType, valueLeft, valueRight))
                        {
                            Program.WriteLog(LogType.Info,
                                             "Triggering event " + trig.TrigInfo.evRef + " because " + trig.Data.Type + " and " +
                                             valueLeft + " " + trig.Data.Comparison + " " + valueRight);
                            callbacks.TriggerFire(Name, trig.TrigInfo);
                        }
                    }
                }

                break;

            default:
                Program.WriteLog(LogType.Verbose, "HSEvent triggered " + eventType);
                break;
            }
        }
Пример #6
0
 private async Task HSEventImpl(Enums.HSEvent eventType, object[] parameters)
 {
     try
     {
         if ((eventType == Enums.HSEvent.VALUE_CHANGE) && (parameters.Length > 4))
         {
             int deviceRefId = Convert.ToInt32(parameters[4], CultureInfo.InvariantCulture);
             await RecordDeviceValue(deviceRefId, TrackedType.Value).ConfigureAwait(false);
         }
         else if ((eventType == Enums.HSEvent.STRING_CHANGE) && (parameters.Length > 3))
         {
             int deviceRefId = Convert.ToInt32(parameters[3], CultureInfo.InvariantCulture);
             await RecordDeviceValue(deviceRefId, TrackedType.String).ConfigureAwait(false);
         }
     }
     catch (Exception ex)
     {
         Trace.TraceWarning(Invariant($"Failed to process HSEvent {eventType} with {ex.GetFullMessage()}"));
     }
 }
Пример #7
0
        /// <summary>
        /// When you wish to have HomeSeer call back in to your plug-in or application when certain events happen in the system,
        /// call the RegisterEventCB procedure and provide it with event you wish to monitor.
        /// See RegisterEventCB for more information and an example and event types.
        /// </summary>
        public override void HSEvent(Enums.HSEvent eventType, object[] parameters)
        {
            if (eventType == Enums.HSEvent.VALUE_CHANGE)
            {
                // For HSEvent.VALUE_CHANGE:
                // 0. eventType
                // 1. The device's address (string)
                // 2. The new value of the device (double)
                // 3. The old value of the device (double)
                // 4. The device's reference number (integer)

                // for performace inspect only devices in MonitoredDevices list
                // as they are registered as "Linked Status Device"
                int devID = (int)parameters[4];
                if (controller.DeviceUsed(devID))
                {
                    controller.ValueChanged(parameters: parameters);
                }
            }
            if (eventType == Enums.HSEvent.CONFIG_CHANGE)
            {
                // For HSEvent.CONFIG_CHANGE:
                // 0. eventType
                // 1. Type: 0=a device was changed 1=an event was changed 2=an event group was changed
                // 2. deprecated
                // 3. The device/event/event group reference number. 0 means that the reference is not known.
                // 4. DAC device/event was 0 = not known, 1 = Added, 2 = Deleted, 3 = Changed
                // 5. A string describing what changed
                // So if a used device was deleted:
                if ((int)parameters[1] == 0 && (int)parameters[4] == 2)
                {
                    int devID = (int)parameters[3];
                    if (controller.DeviceUsed(devID))
                    {
                        (controller as Controller).DeviceDeleted(devID);
                    }
                }
            }
        }
Пример #8
0
 public void HsEvent(Enums.HSEvent eventType, object[] parameters)
 {
     //Catch changes to values and store them for the devices we are watching
     _numberOfEventsReceived++;
     if (eventType == Enums.HSEvent.VALUE_CHANGE)
     {
         //_logging.LogDebug("Got an value changed event. Trying to check if we should store it");
         _numberOfValueChanngeEventsReceived++;
         if (parameters != null && parameters.Length > 4 && parameters[2] != null && parameters[4] != null &&
             parameters[2] is double && parameters[4] is int)
         {
             var newValue = (double)parameters[2];
             var deviceId = (int)parameters[4];
             //Console.WriteLine($"Something happened to a value for deviceId {deviceId} (value: {newValue.ToString()})");
             if (DeviceIsWatched(deviceId))
             {
                 _logging.LogDebug($"logging an event with data deviceId:{deviceId} value: {newValue}");
                 _numberOfEventsStored++;
                 _storageHandler.AddDeviceValueToDatabase(newValue, DateTime.Now, deviceId);
             }
         }
     }
 }
Пример #9
0
        public override void HSEvent(Enums.HSEvent eventType, object[] parameters)
        {
            bool canContinue = true;  // this.SettingsManager.Settings.IsEventTypeEnabled((int)eventType);

            if (!canContinue)
            {
                return;
            }

            BaseDocument document = null;

            try
            {
                switch (eventType)
                {
                case Enums.HSEvent.CONFIG_CHANGE:
                {
                    document = new ConfigChangeEvent(parameters);
                }
                break;

                case Enums.HSEvent.LOG:
                    document = new LogEvent(parameters);
                    break;

                case Enums.HSEvent.STRING_CHANGE:
                    document = new StringChangeEvent(parameters);
                    break;

                case Enums.HSEvent.VALUE_CHANGE:
                {
                    document = new ValueChangeEvent(parameters);
                }
                break;

                case Enums.HSEvent.GENERIC:
                {
                    document = new GenericEvent(parameters);
                }
                break;

                case Enums.HSEvent.SETUP_CHANGE:
                {
                    document = new SetupChangeEvent();
                }
                break;

                default:
                    LogInfo(string.Format("No handler yet for HSEvent type {0}", eventType.ToString()));
                    Console.WriteLine(" - HSEvent {0}: {1}", eventType.ToString(), String.Join(" | ", parameters));
                    break;
                }

                if (document != null)
                {
                    this.esManager.WriteDocument(document);
                }
            }
            catch (Exception e)
            {
                LogError(string.Format("Error while handling HS Event: {0}", e.Message));
            }
        }
Пример #10
0
 public override void HSEvent(Enums.HSEvent eventType, object[] parms)
 {
 }
Пример #11
0
        // ================================================================================================

        public void HSEvent(Enums.HSEvent EventType, object[] parms)
        {
            //Don't need anything
        }
Пример #12
0
 /// <summary>
 /// This is called when an event happens, provided you called RegisterEventCB first.
 /// </summary>
 /// <param name="eventType">The type of the event that happened</param>
 /// <param name="parameters">Parameters for the event</param>
 public virtual void HSEvent(Enums.HSEvent eventType, object[] parameters)
 {
 }
Пример #13
0
 public override void HSEvent(Enums.HSEvent eventType, object[] parameters)
 {
     _mainPlugin.HsEvent(eventType, parameters);
 }
Пример #14
0
 public void HSEvent(Enums.HSEvent eventType, object[] parms)
 {
 }
Пример #15
0
 public override void HSEvent(Enums.HSEvent eventType, [AllowNull] object[] parameters)
 {
     HSEventImpl(eventType, parameters).Wait(ShutdownCancellationToken);
 }
Пример #16
0
 public override void HSEvent(Enums.HSEvent eventType, [AllowNull] object[] parameters)
 {
 }
Пример #17
0
 /// <summary>
 ///     When you wish to have HomeSeer call back in to your plug-in or application when certain events happen in the
 ///     system,
 ///     call the RegisterEventCB procedure and provide it with event you wish to monitor.
 ///     See RegisterEventCB for more information and an example and event types.
 /// </summary>
 public abstract void HSEvent(Enums.HSEvent eventType, object[] parameters);
Пример #18
0
        public override void HSEvent(Enums.HSEvent eventType, object[] parameters)
        {
            if (!IsAnyWebHookConfigured())
            {
                Program.WriteLog(LogType.Debug, "Ignoring event " + eventType + " because no webhook endpoint is configured.");
                return;
            }

            Dictionary <string, object> dict = new Dictionary <string, object> {
                { "eventType", eventType.ToString() }
            };

            try {
                int devRef;

                switch (eventType)
                {
                case Enums.HSEvent.VALUE_SET:
                case Enums.HSEvent.VALUE_CHANGE:
                    devRef = (int)parameters[4];
                    if (ignoreUnchangedEvents && (double)parameters[2] == (double)parameters[3])
                    {
                        Program.WriteLog(LogType.Verbose, $"Suppressing {eventType} for device {devRef} because its value did not change ({(double)parameters[2]} == {(double)parameters[3]})");
                        return;
                    }
                    dict.Add("address", (string)parameters[1]);
                    dict.Add("newValue", ((double)parameters[2]).ToString(CultureInfo.InvariantCulture));
                    dict.Add("oldValue", ((double)parameters[3]).ToString(CultureInfo.InvariantCulture));
                    dict.Add("ref", devRef);
                    break;

                case Enums.HSEvent.STRING_CHANGE:
                    devRef = (int)parameters[3];
                    dict.Add("address", (string)parameters[1]);
                    dict.Add("newValue", (string)parameters[2]);
                    dict.Add("ref", devRef);
                    break;

                default:
                    Program.WriteLog(LogType.Warn, "Unknown event type " + eventType);
                    return;
                }

                if (ignoredDeviceRefs.Contains(devRef))
                {
                    Program.WriteLog(LogType.Verbose, $"Suppressing {eventType} for device {devRef} because it is ignored.");
                    return;
                }

                if (ignoreTimerEvents)
                {
                    if (!deviceRefTimerState.ContainsKey(devRef))
                    {
                        // We need to check if this is a timer
                        DeviceClass device = (DeviceClass)hs.GetDeviceByRef(devRef);
                        PlugExtraData.clsPlugExtraData deviceData = device.get_PlugExtraData_Get(hs);
                        deviceRefTimerState[devRef] = deviceData.GetNamed("timername") != null && device.get_Interface(hs) == "";
                    }

                    if (deviceRefTimerState[devRef])
                    {
                        // This is a timer.
                        Program.WriteLog(LogType.Verbose, $"Suppressing {eventType} for device {devRef} because it's a timer.");
                        return;
                    }
                }

                string json = jsonSerializer.Serialize(dict);
                Program.WriteLog(LogType.Verbose, json);

                for (byte i = 0; i < TOTAL_WEBHOOK_SLOTS; i++)
                {
                    if (webHooks[i] == null)
                    {
                        continue;
                    }

                    WebHook webHook = webHooks[i];

                    webHook.Execute(new StringContent(json, Encoding.UTF8, "application/json")).ContinueWith((task) => {
                        Program.WriteLog(LogType.Verbose, "Sent WebHook " + webHook + " with status code " + task.Result.StatusCode);
                        if (!task.Result.IsSuccessStatusCode)
                        {
                            Program.WriteLog(LogType.Warn, "Got non-successful response code from WebHook " + webHook + ": " + task.Result.StatusCode);
                        }

                        task.Result.Dispose();
                    }).ContinueWith((task) => {
                        if (task.Exception?.InnerException != null)
                        {
                            Program.WriteLog(LogType.Error, $"Unable to send WebHook {webHook}: {getInnerExceptionMessage(task.Exception)}");
                        }
                    }, TaskContinuationOptions.OnlyOnFaulted);
                }
            }
            catch (Exception ex) {
                Program.WriteLog(LogType.Error, ex.ToString());
            }
        }