public SessionCreatedEvent(ISession session) : base(session, true)
{
LastPing = session.LastPing;
IsConnected = session.IsConnected;
RemoteAddress = session.RemoteAddress;
Capabilities = session.Capabilities;
}
// GET: /token
public ActionResult Index()
{
// Load Twilio configuration from Web.config
var accountSid = ConfigurationManager.AppSettings["TwilioAccountSid"];
var authToken = ConfigurationManager.AppSettings["TwilioAuthToken"];
var appSid = ConfigurationManager.AppSettings["TwilioTwimlAppSid"];
// Create a random identity for the client
var identity = Internet.UserName().AlphanumericOnly();
// Create an Access Token generator
var scopes = new HashSet <IScope>
{
{ new IncomingClientScope(identity) },
{ new OutgoingClientScope(appSid) }
};
var capability = new ClientCapability(accountSid, authToken, scopes: scopes);
var token = capability.ToJwt();
return(Json(new
{
identity,
token
}, JsonRequestBehavior.AllowGet));
}
public void HandlePacket(PacketHandlerContext ctx)
{
if (!ctx.HasSession)
{
return;
}
ClientCapability caps = 0;
IEnumerable <string> capStrs = ctx.Args.ElementAtOrDefault(1)?.Split(' ');
if (capStrs != null && capStrs.Any())
{
foreach (string capStr in capStrs)
{
if (Enum.TryParse(typeof(ClientCapability), capStr.ToUpperInvariant(), out object cap))
{
caps |= (ClientCapability)cap;
}
}
}
ctx.Connection.SendPacket(new CapabilityConfirmationPacket(caps));
ctx.Connection.Capabilities = caps;
}
public string GetToken(Agent agent, int seconds = 60 * 60 * 24)
{
var scopes = new HashSet <IScope>
{
new IncomingClientScope(agent.ClientID)
};
var capability = new ClientCapability(accountSid, authToken, scopes: scopes);
return(capability.ToJwt());
}
public void SetCapabilities(ISession session, ClientCapability caps)
{
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
lock (Sync)
Dispatcher.DispatchEvent(this, new SessionCapabilitiesEvent(session, caps));
}
public void TestEmptyToken()
{
var jwt = new ClientCapability(AccountSid, Secret).ToJwt();
var token = new DecodedJwt(jwt, Secret);
var payload = token.Payload;
Assert.AreEqual(AccountSid, payload["iss"]);
Assert.Greater(Convert.ToInt64(payload["exp"]), BaseJwt.ConvertToUnixTimestamp(DateTime.UtcNow));
}
public static string Generate(string agentId)
{
var scopes = new HashSet <IScope>
{
{ new IncomingClientScope(agentId) }
};
var clientCapibility = new ClientCapability(Config.AccountSid, Config.AuthToken, scopes: scopes);
return(clientCapibility.ToJwt());
}
public async Task <IActionResult> PostCallToken()
{
var scopes = new HashSet <IScope>
{
new OutgoingClientScope(_twilioCallSettings.AppSid),
new IncomingClientScope("tester")
};
var capability = new ClientCapability(_twilioSettings.AccountSid, _twilioSettings.AuthToken, scopes: scopes);
return(await Task.FromResult(Content(capability.ToJwt(), "application/jwt")));
}
public ClientCapability GetCapabilities(IUser user)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
ClientCapability caps = 0;
GetSessions(user, sessions => caps = sessions.Select(s => s.Capabilities).Aggregate((x, y) => x | y));
return(caps);
}
public string Generate(string role)
{
var scopes = new HashSet <IScope>
{
new IncomingClientScope(role),
new OutgoingClientScope(_credentials.TwiMLApplicationSID)
};
var capability = new ClientCapability(_credentials.AccountSID,
_credentials.AuthToken,
scopes: scopes);
return(capability.ToJwt());
}
public string Generate()//string role
{
//var scopes = new HashSet<IScope>
//{
// new IncomingClientScope(role),
// new OutgoingClientScope(_credentials.TwiMLApplicationSID)
//};
var capability = new ClientCapability(_credentials.AccountSID,
_credentials.AuthToken
);
return(capability.ToJwt());
}
// GET: Token
public ActionResult Index()
{
// Put your Twilio API credentials here
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string authToken = "your_auth_token";
var scopes = new HashSet <IScope>
{
new IncomingClientScope("jenny")
};
var capability = new ClientCapability(accountSid, authToken, scopes: scopes);
return(Content(capability.ToJwt(), "application/jwt"));
}
// GET: Token
public ActionResult Index()
{
// Put your Twilio API credentials here
// To set up environmental variables, see http://twil.io/secure
const string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
const string authToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");
var scopes = new HashSet <IScope>
{
new IncomingClientScope("joey")
};
var capability = new ClientCapability(accountSid, authToken, scopes: scopes);
return(Content(capability.ToJwt(), "application/jwt"));
}
// GET: Token
public ActionResult Index()
{
// put your Twilio API credentials here
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string authToken = "your_auth_token";
// put your Twilio Application SID here
const string appSid = "APXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
var scopes = new HashSet <IScope>
{
new OutgoingClientScope(appSid),
new IncomingClientScope(Request["ClientName"])
};
var capability = new ClientCapability(accountSid, authToken, scopes: scopes);
return(Content(capability.ToJwt(), "application/jwt"));
}
public ActionResult Get()
{
// Put your Twilio API credentials here
const string accountSid = "";
const string authToken = "";
// Put your Twilio Application SID here
const string appSid = "";
var scopes = new HashSet <IScope>
{
new OutgoingClientScope(appSid),
new IncomingClientScope("ak")
};
var capability = new ClientCapability(accountSid, authToken, scopes: scopes);
return(Content(capability.ToJwt(), "application/jwt"));
}
public void ProcessRequest(HttpContext context)
{
context.Response.ContentType = "application/json";
// Create a random identity for the client
var identity = context.Request.QueryString["name"];
// Create an Access Token generator
var scopes = new HashSet <IScope>
{
{ new IncomingClientScope(identity) },
{ new OutgoingClientScope("[YOUR_TWILIO_TWIML_APPLICATION_SID]") }
};
var capability = new ClientCapability("[YOUR_TWILIO_ACCOUNT_SID]", "[YOUR_TWILIO_AUTH_TOKEN]", null, scopes);
var token = capability.ToJwt();
context.Response.Write(
JsonConvert.SerializeObject(new { identity = identity, token = token })
);
}
public Session(
string serverId,
string sessionId,
DateTimeOffset?lastPing = null,
IUser user = null,
bool isConnected = false,
IPAddress remoteAddress = null,
ClientCapability capabilities = 0
)
{
ServerId = serverId ?? throw new ArgumentNullException(nameof(serverId));
SessionId = sessionId ?? throw new ArgumentNullException(nameof(sessionId));
LastPing = lastPing ?? DateTimeOffset.MinValue;
User = user;
IsConnected = isConnected;
RemoteAddress = remoteAddress ?? IPAddress.None;
Capabilities = capabilities;
if (!IsConnected)
{
PacketQueue = new Queue <IServerPacket>();
}
}
public ActionResult Tokenforincomming(string CallerName)
{
try
{
if (CallerName == "empty")
{
if (User.IsInRole("Liaison"))
{
var userid = User.Identity.GetUserId();
var liasion = _db.Liaisons.AsNoTracking().Where(x => x.UserId == userid).FirstOrDefault();
if (liasion != null)
{
CallerName = liasion.FirstName + liasion.LastName;
}
}
else
{
CallerName = "Admin";
}
}
}
catch (System.Exception ex)
{
}
var identity = CallerName;
var token = new ClientCapability(
ConfigurationManager.AppSettings["TwilioAccountSid"],
ConfigurationManager.AppSettings["TwilioAuthToken"],
scopes: new HashSet <IScope> {
new IncomingClientScope(CallerName)
}
).ToJwt();
// return Content(token, "application/jwt");
return(Json(new { identity, token }, JsonRequestBehavior.AllowGet));
}
public void TestToken()
{
var scopes = new HashSet <IScope>
{
{ new IncomingClientScope("incomingClient") },
{ new EventStreamScope() },
{ new OutgoingClientScope("AP123") }
};
var jwt = new ClientCapability(AccountSid, Secret, scopes: scopes).ToJwt();
var token = new DecodedJwt(jwt, Secret);
var payload = token.Payload;
Assert.AreEqual(AccountSid, payload["iss"]);
Assert.Greater(Convert.ToInt64(payload["exp"]), BaseJwt.ConvertToUnixTimestamp(DateTime.UtcNow));
Assert.AreEqual(
"scope:client:incoming?clientName=incomingClient " +
"scope:stream:subscribe?path=/2010-04-01/Events " +
"scope:client:outgoing?appSid=AP123",
payload["scope"]
);
}
public CapabilityConfirmationPacket(ClientCapability caps)
{
Capabilities = GetStrings((int)caps);
}
public SessionCapabilitiesEvent(ISession session, ClientCapability caps) : base(session, false)
{
Capabilities = caps;
}
public static bool HasCapability(this ISession session, ClientCapability capability) => (session.Capabilities & capability) == capability;
//private readonly ApplicationdbContect _db = new ApplicationdbContect();
public ActionResult Index(string CallerName)
{
try
{
if (CallerName == "empty")
{
if (User.IsInRole("Liaison"))
{
var userid = User.Identity.GetUserId();
var liasion = _db.Liaisons.AsNoTracking().Where(x => x.UserId == userid).FirstOrDefault();
if (liasion != null)
{
CallerName = liasion.FirstName + liasion.LastName;
}
}
else
{
CallerName = "Admin";
}
}
}
catch (System.Exception ex)
{
HelperExtensions.WriteErrorLog(ex);
}
////CallerName = CallerName.Replace("+1", "");
////CallerName = "Phonenum" + CallerName;
//var identity = CallerName;
try
{
if (User.IsInRole("Liaison"))
{
var token = new ClientCapability(
ConfigurationManager.AppSettings["TwilioAccountSid"],
ConfigurationManager.AppSettings["TwilioAuthToken"],
scopes: new HashSet <IScope> {
new OutgoingClientScope(
ConfigurationManager.AppSettings["TwilioTwimlAppSid"]), new IncomingClientScope(CallerName)
}
).ToJwt();
// return Content(token, "application/jwt");
return(Json(new { token }, JsonRequestBehavior.AllowGet));
}
else
{
var token = new ClientCapability(
ConfigurationManager.AppSettings["TwilioAccountSid"],
ConfigurationManager.AppSettings["TwilioAuthToken"],
scopes: new HashSet <IScope> {
new OutgoingClientScope(
ConfigurationManager.AppSettings["TwilioTwimlAppSid"])
}
).ToJwt();
// return Content(token, "application/jwt");
return(Json(new { token }, JsonRequestBehavior.AllowGet));
}
}
catch (System.Exception ex)
{
return(Json(ex.Message + ex.InnerException));
}
}
public bool HasCapability(ClientCapability capability) => (Capabilities & capability) == capability;
public ActionResult Agent_desktop()
{
string workerSid = Request.Params.Get("WorkerSid");
TwilioClient.Init(_accountSid, _authToken);
var activityDictionary = new Dictionary <string, string>();
var activities = ActivityResource.Read(_workspaceSid);
foreach (var activity in activities)
{
activityDictionary.Add(activity.FriendlyName, activity.Sid);
}
var updateActivityFilter = new Dictionary <string, Policy.FilterRequirement>
{
{ "ActivitySid", Policy.FilterRequirement.Required }
};
var urls = new PolicyUrlUtils(_workspaceSid, workerSid);
var allowActivityUpdates = new Policy(urls.Worker,
HttpMethod.Post,
postFilter: updateActivityFilter);
var allowTasksUpdate = new Policy(urls.AllTasks, HttpMethod.Post);
var allowReservationUpdate = new Policy(urls.AllReservations, HttpMethod.Post);
var allowWorkerFetches = new Policy(urls.Worker, HttpMethod.Get);
var allowTasksFetches = new Policy(urls.AllTasks, HttpMethod.Get);
var allowReservationFetches = new Policy(urls.AllReservations, HttpMethod.Get);
var allowActivityFetches = new Policy(urls.Activities, HttpMethod.Get);
var policies = new List <Policy>
{
allowActivityUpdates,
allowTasksUpdate,
allowReservationUpdate,
allowWorkerFetches,
allowTasksFetches,
allowReservationFetches
};
var capability = new TaskRouterCapability(
_accountSid,
_authToken,
_workspaceSid,
workerSid,
policies: policies);
var workerToken = capability.ToJwt();
var scopes = new HashSet <IScope>
{
{ new IncomingClientScope(Request.Params.Get("WorkerSid")) },
{ new OutgoingClientScope(_applicationSid) }
};
var webClientCapability = new ClientCapability(_accountSid, _authToken, scopes: scopes);
var token = capability.ToJwt();
ViewBag.worker_token = workerToken;
ViewBag.client_token = webClientCapability.ToJwt();
ViewBag.caller_ID = _called_id;
ViewBag.activties = activityDictionary;
return(View());
}
