private void ApiPost(IApiContext apiContext)
        {
            var sequence = apiContext.Request["sequence"].ToObject<JArray>();
            if (sequence.Count == 0)
            {
                return;
            }

            var codeSequence = new LPD433MHzCodeSequence();
            foreach (var item in sequence)
            {
                var code = item.ToObject<JObject>();

                var value = (uint)code["value"];
                var length = (byte)code["length"];
                var repeats = (byte)code["repeats"];

                if (value == 0 || length == 0)
                {
                    throw new InvalidOperationException("Value or length is null.");
                }

                codeSequence.WithCode(new LPD433MHzCode(value, length, repeats));
            }

            Send(codeSequence);
        }

        public override void HandleApiCall(IApiContext apiContext)
        {
            var request = apiContext.Request.ToObject<ApiCallRequest>();

            if (!string.IsNullOrEmpty(request.Action))
            {
                if (request.Action == "nextState")
                {
                    SetState(GetNextState(GetState()));
                }

                return;
            }

            if (!string.IsNullOrEmpty(request.State))
            {
                var stateId = new ComponentState(request.State);
                if (!SupportsState(stateId))
                {
                    apiContext.ResultCode = ApiResultCode.InvalidBody;
                    apiContext.Response["Message"] = "State ID not supported.";
                }

                SetState(stateId);
            }
        }

        public async Task ProcessEventAsync(IApiContext apiContext, Event eventPayLoad)
        {
            try
            {
                Trace.CorrelationManager.ActivityId = !String.IsNullOrEmpty(apiContext.CorrelationId)
                    ? Guid.Parse(apiContext.CorrelationId)
                    : Guid.NewGuid();

                _logger.Info(String.Format("Got Event {0} for tenant {1}", eventPayLoad.Topic, apiContext.TenantId));


                var eventType = eventPayLoad.Topic.Split('.');
                var topic = eventType[0];

                if (String.IsNullOrEmpty(topic))
                    throw new ArgumentException("Topic cannot be null or empty");

                var eventCategory = (EventCategory) (Enum.Parse(typeof (EventCategory), topic, true));
                var eventProcessor = _container.ResolveKeyed<IEventProcessor>(eventCategory);
                await eventProcessor.ProcessAsync(_container, apiContext, eventPayLoad);
            }
            catch (Exception exc)
            {
                _emailHandler.SendErrorEmail(new ErrorInfo{Message = "Error Processing Event : "+ JsonConvert.SerializeObject(eventPayLoad), Context = apiContext, Exception = exc});
                throw exc;
            }
        }

 public void HandleApiCall(IApiContext apiContext)
 {
     lock (_syncRoot)
     {
         apiContext.Response = JObject.FromObject(_schedules);
     }
 }

        private async Task<bool> IsAppEnabled(IApiContext apiContext)
        {
            var applicationResource = new ApplicationResource(apiContext);
            var application = await applicationResource.ThirdPartyGetApplicationAsync();

            return application.Enabled.GetValueOrDefault(false);
        }

        public PipelineContinuation Execute(IApiContext context)
        {
            ValidateContext(context);

            _log.InfoFormat("Creating a web request for {0}", context.Request.Uri);

            var request = WebRequest.Create(context.Request.Uri);

            request.Timeout = context.Request.Timeout;
            request.Method = context.Request.HttpMethod;

            if (context.Request.Headers != null)
                foreach (var header in context.Request.Headers)
                    request.Headers[header.Key] = header.Value;

            if (context.UseFiddler)
            {
                _log.InfoFormat("Setting proxy to enable Fiddle");
                request.Proxy = new WebProxy("127.0.0.1", 8888);
            }

            context.Request.Request = request;

            return PipelineContinuation.Continue;
        }

        public async Task<GeneralSettings> GetGeneralSettings(IApiContext apiContext, string responseFields = null)
        {
            if (apiContext.SiteId.GetValueOrDefault(0) == 0)
                throw new Exception("Site ID is missing in api context");

            var settingResource = new GeneralSettingsResource(apiContext);
            return await settingResource.GetGeneralSettingsAsync(responseFields);
        }

        public async Task<TimeZone> GetTimezone(IApiContext apiContext, GeneralSettings generalSettings = null)
        {
            if (generalSettings == null)
                generalSettings = await GetGeneralSettings(apiContext,"siteTimeZone");

            var referenceApi = new ReferenceDataResource();
            var timeZones = await referenceApi.GetTimeZonesAsync();
            return timeZones.Items.SingleOrDefault(x => x.Id.Equals(generalSettings.SiteTimeZone));
        }

        public void History(IApiContext apiContext)
        {
            if (apiContext == null) throw new ArgumentNullException(nameof(apiContext));

            lock (_syncRoot)
            {
                apiContext.Response = JObject.FromObject(_history);
            }
        }

        public void RestoreBackup(IApiContext apiContext)
        {
            if (apiContext.Request.Type != JTokenType.Object)
            {
                throw new NotSupportedException();
            }

            var eventArgs = new BackupEventArgs(apiContext.Request);
            RestoringBackup?.Invoke(this, eventArgs);
        }

 public override void HandleApiCall(IApiContext apiContext)
 {
     var action = (string)apiContext.Request["Duration"];
     if (!string.IsNullOrEmpty(action) && action.Equals(ButtonPressedDuration.Long.ToString(), StringComparison.OrdinalIgnoreCase))
     {
         OnPressedLong();
     }
     else
     {
         OnPressedShortlyShort();
     }
 }

        public PipelineContinuation Execute(IApiContext context)
        {
            if(context.Request.Data != null && context.Request.Data.GetType() != typeof(string))
            {
                var metadata = _resourceSpaceConfig.Get(context.Request.Data.GetType());
                var codec = _pipeline.GetCodec(metadata.ContentType);

                context.Request.Data = codec.Encode(context.Request.Data);
            }

            return PipelineContinuation.Continue;
        }

        public override void HandleApiCall(IApiContext apiContext)
        {
            var action = (string)apiContext.Request["Action"];

            if (action.Equals("detected", StringComparison.OrdinalIgnoreCase))
            {
                UpdateState(MotionDetectorStateId.MotionDetected);
            }
            else if (action.Equals("detectionCompleted", StringComparison.OrdinalIgnoreCase))
            {
                UpdateState(MotionDetectorStateId.Idle);
            }
        }

 public async Task ProcessEventAsync(IApiContext apiContext, Event eventPayLoad)
 {
     try
     {
         var eventProcessor = _container.Resolve<IGenericEventProcessor>();
         await eventProcessor.ProcessEvent(apiContext, eventPayLoad);
     }
     catch (Exception exc)
     {
         _emailHandler.SendErrorEmail(new ErrorInfo { Message = "Error Processing Event : " + JsonConvert.SerializeObject(eventPayLoad), Context = apiContext, Exception = exc });
         throw;
     }
 }

        public void Ask(IApiContext apiContext)
        {
            var message = (string)apiContext.Request["Message"];
            if (string.IsNullOrEmpty(message))
            {
                apiContext.ResultCode = ApiResultCode.InvalidBody;
                return;
            }

            var inboundMessage = new ApiInboundMessage(DateTime.Now, message);
            var answer = ProcessMessage(inboundMessage);

            apiContext.Response["Answer"] = answer;
        }

        public void CreateBackup(IApiContext apiContext)
        {
            var backup = new JObject
            {
                ["Type"] = "HA4IoT.Backup",
                ["Timestamp"] = DateTime.Now.ToString("O"),
                ["Version"] = 1
            };

            var eventArgs = new BackupEventArgs(backup);
            CreatingBackup?.Invoke(this, eventArgs);

            apiContext.Response = backup;
        }

 public void Execute(IApiContext context)
 {
     foreach (var contributor in Contributors)
     {
         try
         {
             if(contributor.Execute(context) == PipelineContinuation.Abort)
                 break;
         }
         catch (Exception ex)
         {
             context.PipelineException = ex;
             break;
         }
     }
 }

        public async Task<Site> GetSite(IApiContext apiContext)
        {
            if (apiContext.SiteId.GetValueOrDefault(0) == 0)
                throw new Exception("Site ID is missing in api context");

            var tenant = apiContext.Tenant;
            if (tenant == null)
            {
                var tenantResource = new TenantResource();
                tenant = await tenantResource.GetTenantAsync(apiContext.TenantId);
            }

            var site = tenant.Sites.SingleOrDefault(x => x.Id == apiContext.SiteId);
            if (site == null)
                throw new Exception("Site " + apiContext.SiteId + " not found for tenant " + tenant.Name);
            return site;
        }

        public PipelineContinuation Execute(IApiContext context)
        {
            WriteDataToStream(context.Request);

            var webRequest = context.Request.Request;

            try
            {
                context.Response.Response = (HttpWebResponse)webRequest.GetResponse();
            }
            catch (WebException ex)
            {
                context.Response.Response = (HttpWebResponse)ex.Response;
            }

            return PipelineContinuation.Continue;
        }

 public async Task<EntityList> GetEntityListAsync(IApiContext apiContext, String name, string nameSpace)
 {
     var entityListResource = new EntityListResource(apiContext);
     String listFQN = GetListFQN(name, nameSpace);
     EntityList entityList = null;
     try
     {
         entityList = await entityListResource.GetEntityListAsync(listFQN);
     }
     catch (AggregateException ae)
     {
         if (ae.InnerException.GetType() == typeof (ApiException)) throw;
         var aex = (ApiException)ae.InnerException;
         _logger.Error(aex.Message, aex);
         throw aex;
     }
     return entityList;
 }