public async Task <IRestResponse> RegisterDomainToWhitelist(IMessagingHubSender sender, List <string> urls)
{
var pageAccessToken = await GetPageAccessToken(sender);
if (pageAccessToken.Trim().IsNullOrEmpty())
{
throw (new Exception("Could not get PageAccessToken"));
}
var client = new RestClient("https://graph.facebook.com/v2.6/me");
var request = new RestRequest("thread_settings?access_token={PageAccessToken}", Method.POST);
request.AddUrlSegment("PageAccessToken", pageAccessToken);
var UrlList = new List <string>();
foreach (var url in urls)
{
UrlList.Add(url);
}
var UrlListJson = JsonConvert.SerializeObject(UrlList);
request.AddParameter("setting_type", "domain_whitelisting");
request.AddParameter("whitelisted_domains", UrlListJson);
request.AddParameter("domain_action_type", "add");
request.AddHeader("Content-Type", "application/json");
var result = await client.ExecuteTaskAsync(request);
return(result);
}
private async Task <string> GetPageAccessToken(IMessagingHubSender sender)
{
JToken JValuePageAccessToken = "";
try
{
var commandResponse = await sender.SendCommandAsync(new Command()
{
Id = EnvelopeId.NewId(), Method = CommandMethod.Get, Uri = new LimeUri("/configuration/caller")
});
foreach (var item in (commandResponse.Resource as DocumentCollection).Items)
{
JToken JValueKey = "";
var JObjectItem = JObject.FromObject(item);
var foundKey = JObjectItem.TryGetValue("name", out JValueKey);
if ((JValueKey as JValue).Value.ToString().Equals("PageAccessToken"))
{
var foundValue = JObjectItem.TryGetValue("value", out JValuePageAccessToken);
break;
}
}
}
catch (Exception e)
{
throw new Exception("Error trying to get PageAccessToken", e);
}
return((JValuePageAccessToken as JValue).Value.ToString());
}
public SavePhoneNumber(
IMessagingHubSender sender, IStateManager stateManager, ISMSAuthenticator smsAuthenticator,
Settings settings, RoutineRepository routineRepository, ReschedulerTask reschedulerTask)
: base(sender, stateManager, settings, routineRepository, reschedulerTask)
{
_smsAuthenticator = smsAuthenticator;
}
protected EnvelopeReceivedHandler(
IMessagingHubSender sender,
EnvelopeReceiverManager registrar,
CancellationTokenSource cts)
{
Sender = sender;
_registrar = registrar;
_cts = cts;
_envelopeActionBlock = new ActionBlock <TEnvelope>(async envelope =>
{
try
{
await CallReceiversAsync(envelope, _cts.Token);
}
catch (Exception ex)
{
//TODO: Create a ILogger interface to notify about errors on EnvelopeProcessor.
Trace.TraceError(ex.ToString());
}
},
new ExecutionDataflowBlockOptions
{
MaxDegreeOfParallelism = DataflowBlockOptions.Unbounded,
BoundedCapacity = DataflowBlockOptions.Unbounded
});
}
public CommandsNoActionHandler(IMessagingHubSender sender, INavigationExtension navigation, ILogger logger, INLPService nlpService)
{
_logger = logger;
_sender = sender;
_navigation = navigation;
_nlpService = nlpService;
}
public Startup(IMessagingHubSender sender, IDictionary <string, object> settings)
{
_sender = sender;
_messageInterval = TimeSpan.Parse((string)settings["messageInterval"]);
_messages = ((IEnumerable)settings["messages"]).Cast <JValue>().Select(j => j.Value.ToString()).ToArray();
_cts = new CancellationTokenSource();
}
public MessagingHubListener(IMessagingHubConnection connection, IMessagingHubSender sender = null, bool autoNotify = true)
{
_connection = connection;
_sender = sender ?? new MessagingHubSender(connection);
EnvelopeManager = new EnvelopeReceiverManager(this);
_autoNotify = autoNotify;
}
private async Task ProcessMessagesAsync(IMessagingHubSender sender, Message message, CancellationToken cancellationToken)
{
var keyword = message.Content.ToString();
if (keyword.First() == '#')
{
keyword = keyword.Substring(Math.Min(keyword.Length, 5)).Trim();
}
if (await HandleStartMessageAsync(sender, message, keyword, cancellationToken))
{
return;
}
if (await HandleEndOfSearchAsync(sender, message, keyword, cancellationToken))
{
return;
}
if (await HandleNextPageRequestAsync(sender, message, keyword, cancellationToken))
{
return;
}
keyword = HandleNextPageKeywordAsync(message, keyword);
var uri = await ComposeSearchUriAsync(message, keyword);
await ExecuteSearchAsync(sender, message, uri, cancellationToken);
}
public TestCommandProcessor(IMessagingHubSender sender, IDictionary <string, object> settings)
{
Sender = sender;
Settings = settings;
Instantiated = true;
InstanceCount++;
}
/// <summary>
/// Initializes a new instance of the <see cref="ComposingMessageReceiver"/> class.
/// </summary>
/// <param name="sender">The sender.</param>
/// <exception cref="System.ArgumentNullException"></exception>
public ComposingMessageReceiver(IMessagingHubSender sender)
{
if (sender == null)
{
throw new ArgumentNullException(nameof(sender));
}
_sender = sender;
}
public PlainTextMessageReceiver(
IMessagingHubSender sender,
INavigationExtension navigateExtension
)
{
_sender = sender;
_navigateExtension = navigateExtension;
}
public MessagingHubClient(IMessagingHubConnection connection, bool autoNotify = true)
{
Connection = connection;
Sender = new MessagingHubSender(connection);
Listener = new MessagingHubListener(connection, Sender, autoNotify);
_semaphore = new SemaphoreSlim(1, 1);
_started = false;
}
public MessageOutputProcessor(IMessagingHubSender sender)
{
if (sender == null)
{
throw new ArgumentNullException(nameof(sender));
}
_sender = sender;
}
public PlainTextMessageReceiver(IMessagingHubSender sender, AppSettings appSettings)
{
_sender = sender;
Session = new Dictionary <string, State>();
Top5Movies = new Dictionary <string, List <Movie> >();
Bot = new MoviesRecommendBot(_sender);
_apiClient = new ApiClient(appSettings);
}
public PlainTextMessageReceiver(IMessagingHubSender sender, IApiAiAppServiceFactory apiAiAppServiceFactory,
IBlipAiMessageTranslator blipAiMessageTranslator, ExampleSettings settings)
{
_apiAiAppServiceFactory = apiAiAppServiceFactory;
_blipAiMessageTranslator = blipAiMessageTranslator;
_sender = sender;
_settings = settings;
}
/// <summary>
/// Send chat state message
/// </summary>
/// <param name="document"></param>
/// <param name="sender"></param>
/// <param name="to"></param>
/// <param name="cancellationToken"></param>
/// <param name="index">Current index in document collection</param>
/// <param name="length">Document collection length</param>
/// <returns></returns>
public async static Task SendChatStateAsync(this Document document, IMessagingHubSender sender, string to, CancellationToken cancellationToken, int index, int length)
{
if (index < length - 1)
{
await sender.SendMessageAsync(new ChatState { State = ChatStateEvent.Composing }, to, cancellationToken);
await ChatStateDelayAsync(document);
}
}
public PlainTextMessageReceiver(
IMessagingHubSender sender,
BotSettings settings
)
{
_sender = sender;
_settings = settings;
}
public PlainTextMessageReceiver(IMessagingHubSender sender, IDirectoryExtension directory, Settings settings, IBucketExtension bucket, ISchedulerExtension scheduler, IBroadcastExtension broadcaster)
{
_settings = settings;
_scheduler = scheduler;
_bucket = bucket;
_directory = directory;
_broadcaster = broadcaster;
_sender = sender;
}
public PlainTextMessageReceiver(
IMessagingHubSender sender,
IEventTrackExtension eventTracker,
IAttendanceExtension attendanceExtension)
{
_sender = sender;
_eventTracker = eventTracker;
_attendance = attendanceExtension;
}
public PlainTextMessageReceiver(IMessagingHubSender sender, IContactExtension contacts, ISchedulerExtension scheduler, IDirectoryExtension directory, IBucketExtension bucket)
{
_sender = sender;
//_contacts = contacts;
_scheduler = scheduler;
_directory = directory;
_bucket = bucket;
SState = "initialState";
Medicine = string.Empty;
}
public AttendanceReplyMessageReceiver(
IMessagingHubSender sender,
IAttendanceExtension attendanceExtension,
IDictionary <string, object> receiverSettings)
{
_sender = sender;
_attendanceExtension = attendanceExtension;
_operatorIdentity = new Lazy <string>(GetOperatorIdentityFromReceiverSettings, true);
_receiverSettings = receiverSettings;
}
/// <summary>
/// Initializes a new instance of the <see cref="HandleExceptionMessageReceiver"/> class.
/// </summary>
/// <param name="receiver">The receiver to intercept the errors.</param>
/// <param name="sender">The sender.</param>
/// <param name="exceptionDocument">The exception document.</param>
/// <exception cref="System.ArgumentNullException"></exception>
public HandleExceptionMessageReceiver(IMessageReceiver receiver, IMessagingHubSender sender, Document exceptionDocument)
{
if (receiver == null)
{
throw new ArgumentNullException(nameof(receiver));
}
_receiver = receiver;
_sendResponseMessageReceiver = new SendResponseMessageReceiver(sender, exceptionDocument);
}
protected BaseMessageReceiver(
IMessagingHubSender sender, IStateManager stateManager,
Settings settings, RoutineRepository routineRepository, ReschedulerTask reschedulerTask)
{
_routineRepository = routineRepository;
_reschedulerTask = reschedulerTask;
StateManager = stateManager;
Sender = sender;
Settings = settings;
}
private static async Task <bool> HandleEndOfSearchAsync(IMessagingHubSender sender, Message message, string keyword, CancellationToken cancellationToken)
{
if (keyword != FinishMessage)
{
return(false);
}
await sender.SendMessageAsync(@"Obrigado por usar o aplicativo OMNI!", message.From, cancellationToken);
return(true);
}
public CommandsNoActionHandler(IMessagingHubSender sender, INavigationExtension navigation, ILogger logger,
INLPService nlpService, IGitService gitService, IContactService contactService, IMpaService mpaService)
{
_logger = logger;
_sender = sender;
_navigation = navigation;
_nlpService = nlpService;
_gitService = gitService;
_contactService = contactService;
_mpaService = mpaService;
}
public DefaultMessageReceiver(
IMessagingHubSender sender,
MySettings settings,
IContextManager context,
IContactService contactService,
IMpaService mpaService,
IGenericErrorService genericErrorService,
ILogger logger)
: base(sender, settings, context, contactService, mpaService, genericErrorService, logger)
{
}
private static async Task <bool> HandleStartMessageAsync(IMessagingHubSender sender, Message message, string keyword, CancellationToken cancellationToken)
{
if (keyword != StartMessage && keyword != TelegramStartMessage)
{
return(false);
}
Console.WriteLine($"Start message received from {message.From}!");
await sender.SendMessageAsync(@"Tudo pronto. Qual produto deseja pesquisar?", message.From, cancellationToken);
return(true);
}
public DefaultMessageReceiver(
IMessagingHubSender sender,
MySettings settings,
IContextManager context,
IContactService contactService,
IMpaService mpaService,
IGenericErrorService genericErrorService,
ILogger logger,
INavigationExtension navigation)
: base(sender, settings, context, contactService, mpaService, genericErrorService, logger, navigation)
{
_navigation = navigation;
}
public InputMessageReceiver(
IMessagingHubSender sender,
ISessionManager sessionManager,
IStateManager stateManager,
IDictionary <string, object> settings)
{
_sender = sender;
_sessionManager = sessionManager;
_settings = InputSettings.Parse(settings);
_settings.Validate();
_documentSerializer = new DocumentSerializer();
_stateManager = stateManager;
}
public MediaReceiver(
IMessagingHubSender sender,
MySettings settings,
IContextManager context,
IContactService contactService,
IMpaService mpaService,
IGenericErrorService genericErrorService,
ILogger logger,
IMediaService mediaService)
: base(sender, settings, context, contactService, mpaService, genericErrorService, logger)
{
_mediaService = mediaService;
}
