protected string SendCallEndStatus(CallInstance ci, NameValueCollection nvc, string Reason)
{
ci.CallStatus = CallStatus.CallbackSent;
var a = "";
var v = new LogObj()
{
LogSymbol = LogSymbol.TwilioToWeb,
CallInstance = ci,
Caption = "Call End Status to " + ci.CallOptions.StatusCallback + " " + Reason
};
try
{
nvc.Add("CallDuration", (DateTime.Now.ToUniversalTime() - ci.CallForGet.StartTime.Value).TotalSeconds.ToString());
v.AddNode("Request", nvc);
a = ci.BrowserClient.DoRequest(ci.CallOptions.StatusCallback, nvc);
v.AddNode("Response", a);
}
catch (Exception ex)
{
v.Caption = "<- Exception on Call Start Call Back to " + ci.CallOptions.StatusCallback + ex.Message;
v.AddException(ex);
}
SystemController.Instance.Logger.LogObj(v);
ci.CallStatus = CallStatus.Ended;
return(a);
}
private CallInstance CreateACall(CallOptions co, bool IsInbound)
{
// preassign some info to the call if it has not already been specified
if (co.StatusCallback == null)
{
co.StatusCallback = Settings.Default.StatusCallBackUrl;
}
CallInstance c = new CallInstance()
{
CallForCreate = new Call()
{
Sid = CreateSid(),
Status = TwilioCallStatuses.QUEUED,
Direction = IsInbound?"inbound":"outbound-api",
DateCreated = DateTime.Now.ToUniversalTime(),
DateUpdated = DateTime.Now.ToUniversalTime(),
To = co.To,
From = co.From,
},
CallDirection = IsInbound?CallDirection.In: CallDirection.Out,
CallOptions = co,
};
CallList.Add(c);
return(c);
}
private TreeNode CreateNewCallListEntry(CallInstance cInst)
{
var cll = cInst.CallForGet;
TreeNode tn = new TreeNode(cInst.CallDirection + " " + cll.From + " -> " + cll.To);
tn.BackColor = cInst.CallColor;
tn.Name = cll.Sid;
trvCallView.Nodes.Add(tn);
return(tn);
}
/// <summary>
/// Here you get the value in cache, you get the connection, then StringGetAsync is in charge of getting the value
/// </summary>
/// <param name="name"></param>
/// <param name="template"></param>
public async Task <CallInstance> GetById(int id, bool isForCallback)
{
var cache = cacheConnection.GetDatabase();
var callInstance = new CallInstance
{
Id = id,
InstanceData = await cache.StringGetAsync(isForCallback?$"Call_{id}" : id.ToString())
};
return(callInstance);
}
private void HangUpThePhoneConnectionFromTheserver(CallInstance ci, string Reason)
{
var v = new LogObj()
{
Caption = "X Server hung up call " + Reason,
LogSymbol = Code.LogSymbol.TwilioToPhone,
CallInstance = ci
}.LogIt();
SystemController.Instance.PhoneManager.CallHungUp(ci.CallOptions.To, Reason);
}
public void ApplyImageToNode(CallInstance cInst, TreeNode tn)
{
var multip = 0;
switch (cInst.CallForGet.Status)
{
case "queued":
{
multip = 0;
break;
}
case "ringing":
{
multip = 1;
break;
}
case "in-progress":
{
multip = 2;
break;
}
case "completed":
{
multip = 3;
break;
}
default:
{
multip = 4;
break;
}
}
;
multip = multip + (cInst.CallDirection == CallDirection.Out ? 0 : 5);
tn.ImageIndex = multip;
tn.SelectedImageIndex = multip;
tn.StateImageIndex = multip;
}
void ProcessCallInstance(CallInstance ci)
{
if (ci.CallStatus == CallStatus.Queued && ci.CallDirection == CallDirection.Out)
{
// start the phone call
ProcessCallPhone(ci);
}
if (ci.CallStatus == CallStatus.ReadyForProcessing ||
(ci.CallStatus == CallStatus.Queued && ci.CallDirection == CallDirection.In))
{
// we are processing twiml
ci.CallForSet.StartTime = DateTime.Now.ToUniversalTime();
ci.CallStatus = CallStatus.ReadyForProcessing;
ci.CallForSet.Status = TwilioCallStatuses.INPROGRESS;
ci.FlowEngine.StartCallFlow();
}
}
/// <summary>
/// Click to call
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public static async Task <LG.Data.Models.Doctors.ConsultWizard.CallInstance> StartClickToCall(LG.Data.Models.Doctors.ConsultWizard.StartClickToCall entity)
{
var client = ClientConnection.GetOMS_Connection();
var result = new CallInstance()
{
ConsultationID = entity.ConsultationID
};
try
{
client.Open();
var response = await client.StartClickToCallPhoneConsultationAsync(new StartClickToCallPhoneConsultationRequest()
{
PropBag = PropBag,
MessageGuid = Guid.NewGuid(),
ConsultationID = entity.ConsultationID,
MedicalPractitionerRID = entity.MedicalPractionerRID,
MedicalPractitionerPhoneNumber = entity.MedicalPractionerPhoneNumber,
});
result.PinCode = response.PinCode;
result.CallSid = response.CallSid;
entity.IsError = response.ReturnStatus.IsError;
entity.Message = response.ReturnStatus.ErrorMessage;
}
catch (Exception ex)
{
client.Abort();
entity.IsError = true;
entity.Message = ex.ToString();
}
finally
{
if (client.State != CommunicationState.Closed)
{
client.Close();
}
}
return(result);
}
public static NameValueCollection GenerateCallBackValue(this CallInstance c)
{
var call = c.CallForGet;
var v = new NameValueCollection()
{
{ "AccountSid", call.AccountSid },
{ "CallSid", call.Sid },
{ "CallStatus", call.Status },
{ "From", call.From },
{ "To", call.To },
{ "Direction", call.Direction }
};
if (c.Digits != "")
{
v.Add("Digits", c.Digits);
}
if (call.AnsweredBy != "")
{
v.Add("AnsweredBy", call.AnsweredBy);
}
return(v);
}
public void MarkCallEnded(CallInstance ci, string reason, bool FromTheServer)
{
// run this in its own thread to ensure it runs
Task.Factory.StartNew(() =>
{
var a = ci.CallForSet;
if (a.Status == TwilioCallStatuses.INPROGRESS || a.Status == TwilioCallStatuses.QUEUED)
{
a.EndTime = DateTime.Now.ToUniversalTime();
a.Duration = Convert.ToInt32((a.EndTime.Value - a.DateCreated).TotalSeconds);
a.Status = TwilioCallStatuses.COMPLETED;
// set the price on the call
var nummins = Convert.ToInt32(Math.Floor((a.EndTime.Value - ci.CallForGet.StartTime).Value.TotalMinutes)) + 1;
var price = 2.0; //default to outbound
if (a.Direction == "inbound")
{
price = Regex.IsMatch(a.To, @"1(\s?|-?)800(\s?|-?)\d{3}(\s?|-?)\d{4}")?4:1;
}
a.Price = (decimal)price * (decimal)nummins;
}
ci.AbortCallFlow();
ci.CallStatus = CallStatus.Ended;
if (FromTheServer)
{
HangUpThePhoneConnectionFromTheserver(ci, reason);
}
SendCallEndStatus(ci, ci.GenerateCallBackValue(), reason);
});
}
get => this.GetOptional(CallInstance, Expression.Parse);
private void HangupCallRequest(CallInstance d, string stat)
{
HangUpThePhoneConnectionFromTheserver(d, stat);
}
public void SayToPhone(CallInstance ci, string Word)
{
SystemController.Instance.PhoneManager.SayReceived(ci.CallOptions.To, Word);
}
private void ProcessCallPhone(CallInstance ci)
{
// when we go to multi phones we will look up by phone number etc... - but for now
// we will look at the first phone
// if there is no first phone then fire the need phone eventhandler
Boolean Callok = false;
var c = ci.CallForGet;
c.StartTime = DateTime.Now.ToUniversalTime();
var v = SystemController.Instance.PhoneManager.AttemptDial(ci.CallForGet.To);
switch (v)
{
case PhoneStatus.Busy:
{
ci.CallForSet.Status = TwilioCallStatuses.BUSY;
break;
}
case PhoneStatus.Ringing:
{
Callok = true;
ci.CallForSet.Status = TwilioCallStatuses.RINGING;
break;
}
case PhoneStatus.NotInService:
{
ci.CallForSet.Status = TwilioCallStatuses.FAILED;
break;
}
case PhoneStatus.NoAnswer:
{
ci.CallForSet.Status = TwilioCallStatuses.NOANSWER;
break;
}
default:
break;
}
// if it is not a good call send back a error call status and mark the call done
// else mark it as waiting for the phone
if (!Callok)
{
MarkCallEnded(ci, "Phone in status " + c.Status.ToString(), false);
}
else
{
ci.CallStatus = CallStatus.WaitingRinging;
ci.CallForGet.Status = TwilioCallStatuses.RINGING;
}
SystemController.Instance.Logger.LogObj(new LogObj()
{
Caption = "Dial to Phone",
LogSymbol = LogSymbol.TwilioToPhone,
CallInstance = ci
}.AddNode("Incoming Number", ci.CallOptions.To).AddNode("Phone Status", v.ToString()));
}
