public async Task <IActionResult> EmergencyCall(TwilioModel obj)
        {
            try
            {
                var to     = new PhoneNumber(string.Concat("+", _twilioOptions.Value.EmergencyPhoneNumber));
                var from   = new PhoneNumber(string.Concat("+", _twilioOptions.Value.PhoneNumber));
                var result = new TwilioModel();
                if (_twilioOptions.Value.BypassCalling == "1" || _twilioOptions.Value.BypassCalling.ToLower() == "true")
                {
                    result.CallSID = Guid.Empty.ToString();
                    result.Message = "Call Bypassed";
                }
                else
                {
                    var call = await CallResource.CreateAsync(to, from, url : new Uri(_twilioOptions.Value.ProxyServerUrl));

                    result = new TwilioModel()
                    {
                        CallSID = call.Sid,
                        Message = obj.Message
                    };
                }

                return(Ok(result));
            }
            catch (Exception e)
            {
                return(StatusCode(StatusCodes.Status502BadGateway, e.Message));
            }
        }
        public async Task <TwilioModel> EmergencyCall(TwilioModel twilioReq)
        {
            RestRequest request = await PrepareQuery("Twilio/Emergency", Method.POST);

            request.AddParameter("application/json", JsonConvert.SerializeObject(twilioReq), ParameterType.RequestBody);
            var queryResult = await _client.ExecuteTaskAsync <TwilioModel>(request);

            if (queryResult.IsSuccessful)
            {
                //return the Twilio call SID
                return(queryResult.Data);
            }
            else
            {
                _logger.LogError($"EmergencyCall: Error: {queryResult.StatusCode}");
            }
            return(null);
        }
示例#3
0
        public async Task Consume(ConsumeContext <IActionTwilioEvent> context)
        {
            DateTime actionStartDate = DateTime.UtcNow;

            try
            {
                if (context.Message != null && context.Message as IActionTwilioEvent != null)
                {
                    IActionTwilioEvent action = context.Message;
                    _logger.LogDebug($"ResponseActionTwilioEventConsumer: ActionId: '{action.ActionId}'.");
                    _logger.LogDebug($"ResponseActionTwilioEventConsumer: Message: '{action.Message}'.");

                    TwilioModel result = await _twilioRestService.EmergencyCall(new TwilioModel()
                    {
                        Message = action.Message
                    });

                    //Success
                    if (result != null)
                    {
                        await GenerateActionCallback(context, ActionStatus.Success, actionStartDate);

                        _logger.LogDebug($"ResponseActionTwilioEventConsumer: SID: '{result.CallSID}' connected.");
                        return;
                    }

                    //Error
                    await GenerateActionCallback(context, ActionStatus.Error, actionStartDate, $"The twilio call could not be completed");

                    _logger.LogError("ResponseActionTwilioEventConsumer: The call could not be connected.");
                }
                _logger.LogError("ResponseActionTwilioEventConsumer: Invalid Null or Empty Action Notification");
                throw new Exception("Invalid or Null Action Twilio Call");
            }
            catch (Exception e)
            {
                await GenerateActionCallback(context, ActionStatus.Error, actionStartDate, $"There was an issue handling the action: {e.Message}.");

                _logger.LogError($"ResponseActionTwilioEventConsumer: {e.Message}");
                throw e;
            }
        }