public void SendToSignalR(BotResponse botResponse)
{
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(
queue: _rabbitMQSettings.BotResponseQueue.Name,
durable: _rabbitMQSettings.BotResponseQueue.Durable,
exclusive: _rabbitMQSettings.BotResponseQueue.Exclusive,
autoDelete: _rabbitMQSettings.BotResponseQueue.AutoDelete,
arguments: null);
var serializedBotResponse = JsonConvert.SerializeObject(botResponse);
var responseBody = Encoding.UTF8.GetBytes(serializedBotResponse);
channel.BasicPublish(exchange: "",
routingKey: _rabbitMQSettings.BotResponseQueue.Name,
basicProperties: null,
body: responseBody);
Console.WriteLine(" [x] Sent {0}", serializedBotResponse);
}
}
public BotResponse <string> Process(string requestBody)
{
var response = new BotResponse <string>
{
Ok = false,
Description = "Not implemented",
ErrorCode = -1,
Parameters = null,
Result = "Not implemented"
};
if (ExtractUpdate(requestBody))
{
response.Ok = true;
response.Description = "OK";
response.Result = response.Description;
response.ErrorCode = null;
}
else
{
response.Description = "Invalid JSON";
response.Result = response.Description;
response.ErrorCode = 1;
}
return(response);
}
public Task SendAsync(Destination destination, BotResponse botResponse, SkypeSender skypeSender = null)
{
if (_isMocked)
{
Console.WriteLine($"{destination.Messenger.ToString()}, {destination.ChannelId}, {destination.UserId}: {botResponse.Text}");
Console.WriteLine("-------------------------------------------------------");
return(Task.CompletedTask);
}
switch (destination.Messenger)
{
case Messenger.Slack:
return(_slackClient.PostMessageAsync(destination.ChannelId, botResponse.Text));
case Messenger.Telegram:
return(_telegramClient != null?_telegramClient.SendTextMessageAsync(destination.ChannelId, botResponse.Text) : Task.CompletedTask);
case Messenger.Skype:
if (skypeSender == null)
{
// todo: log warning: skypeSender is null
return(Task.CompletedTask);
}
return(Task.Run(() => skypeSender.Write(destination.ChannelId, botResponse.Text)));
default:
// todo: log warning: unsupported messenger
return(Task.CompletedTask);
}
}
private static void Write(Document doc, BotResponse response)
{
if (response == null)
{
return;
}
var sec = doc.Sections.Last;
var par = (Paragraph)null;
var tun = (Textrun)null;
var hyp = (Hyperlink)null;
par = sec.AddParagraph();
tun = par.AddTextrun(RtfUtility.unicodeEncode("Chat Message"));
tun.Style.FontSize = 24F;
tun.Style.TextColor = PrimaryColor;
par = sec.AddParagraph(RtfUtility.unicodeEncode(response.Text));
par.Style.Spacings.SpacingBefore = 5F;
if (response.Rank == Syn.VA.ResponseRank.Low)
{
par.AddTextrun(" ");
tun = par.AddTextrun(RtfUtility.unicodeEncode("Please CLICK HERE to search more info from Google."));
tun = par.GetTextrun(response.Text.Length + 8, 10);
hyp = tun.AddHyperlink(LinkType.WebPage, RtfUtility.unicodeEncode(LinkVariables.FindSearchAddress(LinkVariables.Google, response.From)));
hyp.Textruns.Style.TextColor = Color.Black;
hyp.Textruns.Style.FontStyle.Bold = true;
hyp.Textruns.Style.FontStyle.Underlined = false;
}
sec.AddParagraph();
}
public async Task <DialogTurnResult> GetReturnTimeConfirmTicket(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
var botResponse = new BotResponse("I will book these tickets for you. Please confirm:", "I will book these tickets for you. Please confirm:");
var replyToConversation = sc.Context.Activity.CreateReply(botResponse);
//replyToConversation.AttachmentLayout = AttachmentLayoutTypes.Carousel;
replyToConversation.Attachments = new List <Attachment>();
var replyMessage1 = sc.Context.Activity.CreateAdaptiveCardReply(
botResponse,
"AdaptiveCard/TicketCard.json",
new CardData(),
null,
new StringDictionary()
{
{ "Location", "Beijing - Seattle" }, { "DepartTime", "1/8 12:15" }, { "ArriveTime", "1/8 6:30" }
});
var replyMessage2 = sc.Context.Activity.CreateAdaptiveCardReply(
botResponse,
"AdaptiveCard/TicketCard.json",
new CardData(),
null,
new StringDictionary()
{
{ "Location", "Seattle - Beijing" }, { "DepartTime", "1/13 7:30" }, { "ArriveTime", "1/14 14:45" }
});
replyToConversation.Attachments.Add(replyMessage1.Attachments[0]);
replyToConversation.Attachments.Add(replyMessage2.Attachments[0]);
return(await sc.PromptAsync(promptDialogId, new PromptOptions { Prompt = replyToConversation }, cancellationToken));
}
/// <summary>
/// Generate ToAdaptiveCardAttachmentWithoutSpeech.
/// </summary>
/// <param name="todos">To Do activities.</param>
/// <param name="allTaskCount">all tasks count.</param>
/// <param name="taskContent">the task content.</param>
/// <param name="botResponse1">the bot response 1.</param>
/// <param name="botResponse2">the bot response 2.</param>
/// <returns>Generated adaptive card attachment.</returns>
public static Microsoft.Bot.Schema.Attachment ToAdaptiveCardAttachmentForOtherFlows(
List <ToDoTaskActivityModel> todos,
int allTaskCount,
string taskContent,
BotResponse botResponse1,
BotResponse botResponse2)
{
var toDoCard = new AdaptiveCard();
var showText = Format(botResponse2.Reply.Text, new StringDictionary()
{
{ "taskCount", allTaskCount.ToString() }
});
var speakText = Format(botResponse1.Reply.Speak, new StringDictionary()
{
{ "taskContent", taskContent }
})
+ Format(botResponse2.Reply.Speak, new StringDictionary()
{
{ "taskCount", allTaskCount.ToString() }
});
toDoCard.Speak = speakText;
var body = new List <AdaptiveElement>();
var textBlock = new AdaptiveTextBlock
{
Text = showText,
};
body.Add(textBlock);
var choiceSet = new AdaptiveChoiceSetInput();
choiceSet.IsMultiSelect = true;
string value = Guid.NewGuid().ToString() + ",";
foreach (var todo in todos)
{
var choice = new AdaptiveChoice();
choice.Title = todo.Topic;
choice.Value = todo.Id;
choiceSet.Choices.Add(choice);
if (todo.IsCompleted)
{
value += todo.Id + ",";
}
}
value = value.Remove(value.Length - 1);
choiceSet.Value = value;
body.Add(choiceSet);
toDoCard.Body = body;
var attachment = new Microsoft.Bot.Schema.Attachment()
{
ContentType = AdaptiveCard.ContentType,
Content = toDoCard,
};
return(attachment);
}
public async Task <IActionResult> AddBotResponse([FromBody] BotResponseDto resp)
{
if (resp == null)
{
return(BadRequest());
}
if (!HasAccess(_validationRepo.GetContextOwnerId(resp.PatternId)))
{
return(StatusCode(403));
}
var validationContext = new System.ComponentModel.DataAnnotations.ValidationContext(resp, null, null);
var validationResults = new List <ValidationResult>();
Validator.TryValidateObject(resp, validationContext, validationResults, true);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
BotResponse respObj = _mapper.Map <BotResponse>(resp);
if (await _patternRepo.AddBotResponseToPatternAsync(respObj))
{
return(StatusCode(201));
}
else
{
return(BadRequest());
};
}
public override void OnUserChat(RoomInstance Instance, RoomActor Actor, string MessageText, bool Shout)
{
if (mSelfActor == null || Actor.Type == RoomActorType.AiBot || mServingItemId > 0 ||
(Distance.Calculate(Actor.Position.GetVector2(), mSelfActor.Position.GetVector2()) > mSelfBot.ResponseDistance))
{
return;
}
BotResponse Response = mSelfBot.GetResponseForMessage(MessageText);
if (Response != null)
{
mSelfActor.Chat(Response.GetResponse(), false);
if (Response.ResponseServeId > 0)
{
mMovingToServePos = true;
mServingItemId = Response.ResponseServeId;
mServingActorId = Actor.Id;
mActorServePos = new Vector2(mSelfActor.Position.X, mSelfActor.Position.Y);
mSelfActor.MoveTo(mSelfBot.ServePosition);
if (mNextMovementAttempt < 50)
{
mNextMovementAttempt = 50;
}
}
if (mNextSpeechAttempt < 50)
{
mNextSpeechAttempt += 10;
}
}
}
public async void ReadMessage()
{
var client = new ClientWebSocket();
var cts = new CancellationTokenSource();
await client.ConnectAsync(new Uri(_conversation.StreamUrl), cts.Token);
await Task.Factory.StartNew(async() =>
{
while (true)
{
WebSocketReceiveResult result;
var message = new ArraySegment <byte>(new byte[4096]);
do
{
result = await client.ReceiveAsync(message, cts.Token);
if (result.MessageType != WebSocketMessageType.Text)
{
break;
}
var messageBytes = message.Skip(message.Offset).Take(result.Count).ToArray();
string messageJson = Encoding.UTF8.GetString(messageBytes);
BotResponse botResponse = JsonConvert.DeserializeObject <BotResponse>(messageJson);
var args = new BotResponseEventAgrs();
args.Activities = botResponse.Activities;
MessageRecieved?.Invoke(this, args);
}while (!result.EndOfMessage);
}
}, cts.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
}
void Interaction_ResponseReceived(object sender, ResponseGeneratedEventArgs e)
{
try
{
this.InvokeIfRequired(panel =>
{
BotResponse botResponse = e.Response as BotResponse;
if (botResponse == null)
{
return;
}
try
{
richEditControl.CreateNewDocument();
richEditControl.Document.BeginUpdate();
richEditControl.Document.RtfText = botResponse.RtfText;
richEditControl.Document.CaretPosition = richEditControl.Document.Range.Start;
}
finally { richEditControl.Document.EndUpdate(); }
richEditControl.ScrollToCaret();
waitLabelControl.Visible = false;
richEditControl.Visible = true;
});
}
catch (Exception) { }
}
/// <summary>
/// Executes dialog/button.
/// Dialogs returns redirect or messages. Buttons mostly just result in message;
/// </summary>
public async virtual Task <BotResponse> Execute(IUser user)
{
if (!ValidateUser(user.UserRole))
{
return(new BotExceptionResponse(null, "txt_accessDenied", user, true));
}
OperationResult opResult = new OperationResult();
object data = null;
// aware context controller about op. execution
if (Operation != null)
{
opResult = await Operation.Execute(user);
if (opResult.ResultType == OperationResult.OperationResultType.Failed ||
opResult.ResultType == OperationResult.OperationResultType.Unknown)
{
return(new BotExceptionResponse(opResult.ExceptionMessage, "txt_internalServerError", user, true));
}
else
{
// keep op. data
data = opResult.Result;
}
}
BotResponse response = new BotResponse(data, BotResponse.ResponseType.Dialog, user, this);
return(response);
}
/// <summary>
/// client receive message loop
/// </summary>
/// <returns></returns>
public async Task ClientMessageLoop()
{
while (!cancellationTokenSource.IsCancellationRequested)
{
if (!await client.ResponseStream.MoveNext())
{
break;
}
var response = client.ResponseStream.Current;
if (response.Ctrl != null)
{
Log("Ctrl Message", $"ID={response.Ctrl.Id} Code={response.Ctrl.Code} Text={response.Ctrl.Text} Params={response.Ctrl.Params}");
ExecFuture(response.Ctrl.Id, response.Ctrl.Code, response.Ctrl.Text, response.Ctrl.Topic, response.Ctrl.Params);
}
else if (response.Data != null)
{
OnServerDataEvent(new ServerDataEventArgs(response.Data.Clone()));
if (response.Data.FromUserId != BotUID)
{
ClientPost(NoteRead(response.Data.Topic, response.Data.SeqId));
Thread.Sleep(50);
if (BotResponse != null)
{
var reply = await BotResponse.ThinkAndReply(response.Data.Clone());
//if the response is null, means no need to reply
if (reply != null)
{
ClientPost(Publish(response.Data.Topic, reply));
}
}
else
{
ClientPost(Publish(response.Data.Topic, "I don't know how to talk with you, maybe my father didn't put my brain in my head..."));
}
}
}
else if (response.Pres != null)
{
if (response.Pres.Topic == "me")
{
if ((response.Pres.What == ServerPres.Types.What.On || response.Pres.What == ServerPres.Types.What.Msg) && !subscriptions.ContainsKey(response.Pres.Src))
{
ClientPost(Subscribe(response.Pres.Src));
}
else if (response.Pres.What == ServerPres.Types.What.Off && subscriptions.ContainsKey(response.Pres.Src))
{
ClientPost(Leave(response.Pres.Src));
}
}
OnServerPresEvent(new ServerPresEventArgs(response.Pres.Clone()));
}
else if (response.Meta != null)
{
OnGetMeta(response.Meta);
OnServerMetaEvent(new ServerMetaEventArgs(response.Meta.Clone()));
}
}
}
public async Task <bool> AddBotResponseToPatternAsync(BotResponse botResponse)
{
try
{
_chatBotContext.BotResponses.Add(botResponse);
var res = await _chatBotContext.SaveChangesAsync();
if (!_contextsResponses.ContainsKey(botResponse.PatternId))
{
_contextsResponses.Add(botResponse.PatternId, new List <BotResponse>()
{
botResponse
});
}
else
{
_contextsResponses[botResponse.PatternId].Add(botResponse);
}
_logger.LogInformation("Bot response added ({botResponse.Id})", botResponse.Id);
return(true);
}
catch (Exception ex)
{
_logger.LogError(ex, "can't add response to pattern");
return(false);
}
}
private async Task <Activity> CreateSimpleAnswer(BotResponse botResponse)
{
int random = new Random().Next(botResponse.Text.Count);
var reply = MessageFactory.Text(botResponse.Text[random]);
return(reply);
}
public override async Task <BotResponse> Execute(IUser user)
{
// get next dialog and call it
// if it last or no any dialogs - return container and execute it
Dialog next = Next(BotManager.Core.BotApiManager.ContextController.GetUserState(user).CurrentDialog);
object data = null;
if (next == this)
{
var opResult = await Operation.Execute(user);
if (opResult.ResultType == OperationResult.OperationResultType.Failed || opResult.ResultType == OperationResult.OperationResultType.Unknown)
{
return(new BotExceptionResponse(opResult.ExceptionMessage, "txt_internalServerError", user, true));
}
else
{
data = opResult.Result;
}
BotResponse response = new BotResponse(data, BotResponse.ResponseType.Dialog, user, this);
return(response);
}
return(await next.Execute(user));
}
public async Task <BotResponse> AddBotResponse(BotResponse botResponse)
{
await _konekoContext.BotResponses.AddAsync(botResponse);
await _konekoContext.SaveChangesAsync();
return(botResponse);
}
public async Task BotTalkAsync()
{
if (!BotResponse.IsNullOrEmptyOrWhiteSpace())
{
await Context.PostAsync($"{BotResponse}");
return;
}
}
private async Task <Activity> CreateSimpleAnswer(BotResponse botResponse)
{
int random = new Random().Next(botResponse.Text.Count);
string replySpeak = @"<speak version='1.0' xmlns='https://www.w3.org/2001/10/synthesis' xml:lang='de-DE'>
<voice name='Microsoft Server Speech Text to Speech Voice (es-MX, Raul)'>" +
$"{botResponse.Text[random]}" + "</voice></speak>";
var reply = MessageFactory.Text(botResponse.Text[random], replySpeak);
return(reply);
}
private void RespondToEvent(string Event)
{
BotResponse Response = mSelfBot.GetResponseForMessage(Event);
if (Response != null)
{
mSelfActor.Chat(Response.GetResponse());
}
mChatDelayer = UnixTimestamp.GetCurrent();
}
private static async Task Main(string[] args)
{
// set debug level
foreach (var arg in args)
if (arg == "--debug")
Log.ShowDebug = true;
// selamat datang
Console.Title = AppNameWithVersion;
var log = new Log("Main");
log.Info(AppNameWithVersion);
log.Debug("Working Directory: {0}", WorkingDirectory);
log.Debug("Data Directory: {0}", DataDirectory);
// buka konfigurasi
var isBotConfigLoaded = Bot.Loaded();
var isBotResponseLoaded = BotResponse.Loaded();
if (!isBotConfigLoaded || !isBotResponseLoaded) Terminate(1);
// bot menerima pesan
while (true)
try
{
log.Debug("Mengakses akun bot...");
var receive = await BotClient.StartReceivingMessage();
if (receive) break;
}
catch (Exception ex)
{
log.Error(ex.Message);
Task.Delay(10000).Wait();
}
// reSchedule
Schedule.ReSchedule();
// chatbot load library
await ChatBot.LoadLibraryAsync();
// tunggu key ctrl+c untuk keluar dari aplikasi
var exitEvent = new ManualResetEvent(false);
Console.CancelKeyPress += (sender, eventArgs) =>
{
eventArgs.Cancel = true;
exitEvent.Set();
};
exitEvent.WaitOne();
// keluar dari aplikasi
Terminate();
}
/// <summary>
/// Retrieves the activities of the given conversation.
/// </summary>
/// <param name="conversationId">The conversation ID.</param>
/// <param name="watermark">Indicates the most recent message seen (optional).</param>
/// <returns></returns>
public IEnumerator GetMessagesCoroutine(string conversationId, string watermark = null)
{
if (string.IsNullOrEmpty(conversationId))
{
throw new ArgumentException("Conversation ID cannot be null or empty");
}
if (IsInitialized)
{
Debug.Log("GetMessagesCoroutine: " + conversationId);
string uri = DirectLineConversationsApiUri
+ "/" + conversationId
+ "/" + DirectLineActivitiesApiUriPostfix;
if (!string.IsNullOrEmpty(watermark))
{
uri += "?" + BotJsonProtocol.KeyWatermark + "=" + watermark;
}
UnityWebRequest webRequest = CreateWebRequest(WebRequestMethods.Get, uri);
yield return(webRequest.SendWebRequest());
if (webRequest.isNetworkError)
{
Debug.Log("Web request failed: " + webRequest.error);
}
else
{
string responseAsString = webRequest.downloadHandler.text;
if (!string.IsNullOrEmpty(responseAsString))
{
//Debug.Log("Received response:\n" + responseAsString);
BotResponseEventArgs eventArgs = CreateBotResponseEventArgs(responseAsString);
if (BotResponse != null)
{
BotResponse.Invoke(this, eventArgs);
}
}
else
{
Debug.Log("Received an empty response");
}
}
}
else
{
Debug.Log("Bot Direct Line manager is not initialized");
yield return(null);
}
}
public static Activity CreateReply(this Activity activity, BotResponse response, BotResponseBuilder responseBuilder = null, StringDictionary tokens = null)
{
var reply = activity.CreateReply();
if (responseBuilder == null)
{
responseBuilder = BotResponseBuilder();
}
responseBuilder.BuildMessageReply(reply, response, tokens);
return(reply);
}
public async Task <bool> RemoveBotResponse(BotResponse botResponse)
{
if (botResponse is null)
{
return(false);
}
_konekoContext.Remove(botResponse);
await _konekoContext.SaveChangesAsync();
return(true);
}
/// <summary>
/// Sends the given message to the given conversation.
/// </summary>
/// <param name="conversationId">The conversation ID.</param>
/// <param name="fromId">The ID of the sender.</param>
/// <param name="message">The message to sent.</param>
/// <param name="fromName">The name of the sender (optional).</param>
/// <returns></returns>
public IEnumerator SendMessageCoroutine(string conversationId, string fromId, string message, string fromName = null)
{
if (string.IsNullOrEmpty(conversationId))
{
throw new ArgumentException("Conversation ID cannot be null or empty");
}
if (IsInitialized)
{
Debug.Log("SendMessageCoroutine: " + conversationId + "; " + message);
var body = new MessageActivity(fromId, message, DirectLineChannelId, null, fromName).ToJsonString();
body = body.Replace("\"channelId\": \"directline\", ", "\"locale\": \"en-EN\", ");
UnityWebRequest webRequest = CreateWebRequest(
WebRequestMethods.Post,
DirectLineConversationsApiUri
+ "/" + conversationId
+ "/" + DirectLineActivitiesApiUriPostfix,
body);
yield return(webRequest.SendWebRequest());
if (webRequest.isNetworkError)
{
Debug.Log("Web request failed: " + webRequest.error);
}
else
{
string responseAsString = webRequest.downloadHandler.text;
if (!string.IsNullOrEmpty(responseAsString))
{
//Debug.Log("Received response:\n" + responseAsString);
BotResponseEventArgs eventArgs = CreateBotResponseEventArgs(responseAsString);
if (BotResponse != null)
{
BotResponse.Invoke(this, eventArgs);
}
}
else
{
Debug.Log("Received an empty response");
}
}
}
else
{
Debug.Log("Bot Direct Line manager is not initialized");
yield return(null);
}
}
public static Activity CreateAdaptiveCardReply <T>(this Activity activity, BotResponse response, string cardPath, T cardDataAdapter, BotResponseBuilder responseBuilder = null, StringDictionary tokens = null, Activity replyToUse = null)
where T : CardDataBase
{
var reply = replyToUse ?? activity.CreateReply();
if (responseBuilder == null)
{
responseBuilder = BotResponseBuilder();
}
responseBuilder.BuildAdaptiveCardReply(reply, response, cardPath, cardDataAdapter, tokens);
return(reply);
}
protected Attachment ToAdaptiveCardForOtherFlows(
List<TaskItem> todos,
int allTaskCount,
string taskContent,
BotResponse botResponse1,
BotResponse botResponse2)
{
var toDoCard = new AdaptiveCard();
var showText = Format(botResponse2.Reply.Text, new StringDictionary() { { "taskCount", allTaskCount.ToString() } });
var speakText = Format(botResponse1.Reply.Speak, new StringDictionary() { { "taskContent", taskContent } })
+ Format(botResponse2.Reply.Speak, new StringDictionary() { { "taskCount", allTaskCount.ToString() } });
toDoCard.Speak = speakText;
var body = new List<AdaptiveElement>();
var textBlock = new AdaptiveTextBlock
{
Text = showText,
};
body.Add(textBlock);
var container = new AdaptiveContainer();
foreach (var todo in todos)
{
var columnSet = new AdaptiveColumnSet();
var icon = new AdaptiveImage();
icon.UrlString = todo.IsCompleted ? IconImageSource.CheckIconSource : IconImageSource.UncheckIconSource;
var iconColumn = new AdaptiveColumn();
iconColumn.Width = "auto";
iconColumn.Items.Add(icon);
columnSet.Columns.Add(iconColumn);
var content = new AdaptiveTextBlock(todo.Topic);
var contentColumn = new AdaptiveColumn();
iconColumn.Width = "auto";
contentColumn.Items.Add(content);
columnSet.Columns.Add(contentColumn);
container.Items.Add(columnSet);
}
body.Add(container);
toDoCard.Body = body;
var attachment = new Attachment()
{
ContentType = AdaptiveCard.ContentType,
Content = toDoCard,
};
return attachment;
}
/// <summary>
/// Tries to process a given chat message and checks if the current room bot should respond.
/// </summary>
/// <param name="Text">The chat message to process.</param>
private void handleBotResponse(string Text)
{
if (Session.roomInstance.getRoomBot(Session.roomID) != null)
{
roomUser Me = Session.roomInstance.getRoomUser(Session.ID);
roomUser Bot = Session.roomInstance.getRoomBot(Session.roomID);
if (Bot != null)
{
BotResponse bResponse = Bot.bInfo.GetResponse(Text);
if (bResponse != null)
{
if (bResponse.ResponseText != null && bResponse.ResponseType != null)
{
switch (bResponse.ResponseType)
{
case "say":
Session.roomInstance.sendTalk(Bot.ID, Bot.X, Bot.Y, bResponse.ResponseText);
break;
case "shout":
Session.roomInstance.sendShout(Bot.ID, Bot.X, Bot.Y, bResponse.ResponseText);
break;
}
}
if (bResponse.ServeId != 0)
{
Items.carryItemHelper.setHandItem(ref Me, bResponse.ServeId.ToString());
}
}
}
}
/*if (Bot != null)
* if (Bot.bInfo.triggerResponse != null)
* foreach (KeyValuePair<string, string> pair in Bot.bInfo.triggerResponse)
* if (Text.ToLower().Contains(pair.Key))
* {
* if (pair.Value.Contains("}"))
* {
* String[] pairArgs = pair.Value.Split('}');
* Items.carryItemHelper.setHandItem(ref Me, pairArgs[0]);
* Session.roomInstance.sendShout(Bot.ID, Bot.X, Bot.Y, pairArgs[1]);
* }
* else
* {
* Session.roomInstance.sendShout(Bot.ID, Bot.X, Bot.Y, pair.Value);
* }
* break;
* }
* }*/
}
public async void SendGreeting()
{
var mention = string.Empty;
foreach (var member in _message.NewChatMembers)
{
var usernameExist = !string.IsNullOrWhiteSpace(member.Username);
if (usernameExist && member.Username.Equals(Bot.Username, StringComparison.OrdinalIgnoreCase))
{
Command.Start(_message);
return;
}
if (!string.IsNullOrWhiteSpace(mention))
{
mention += " ";
}
var name = (member.FirstName + " " + member.LastName).Trim();
if (string.IsNullOrWhiteSpace(name))
{
name = member.Username;
}
if (string.IsNullOrWhiteSpace(name))
{
name = member.Id.ToString();
}
mention += $"[{name}](tg://user?id={member.Id}),";
}
if (string.IsNullOrWhiteSpace(mention))
{
return;
}
// cari kontak yg ada
var exist = await _db.FindContact(_message.Chat.Id);
if (!exist.Greeting)
{
return;
}
var welcome = BotResponse.WelcomeToGroup()
.Replace("{member}", mention.TrimEnd(','))
.Replace("{group}", _message.ChatName());
await BotClient.SendTextAsync(_message, welcome, parse : ParseMode.Markdown);
}
public Task <bool> Handle(RepostCommand request, CancellationToken cancellationToken)
{
var destination = new Destination()
{
ChannelId = _appConfig.SkypeOfficeChat, UserId = "", Messenger = Messenger.Skype
};
var botResponse = new BotResponse()
{
Text = request.Text
};
_messageSender.SendAsync(destination, botResponse, _skypeSender);
return(Task.FromResult(true));
}
public BotResponse GetResponse(TimeSpan time)
{
SetDuration(time);
var path = DecisionMaker.GetMove(Field, Opponent, Current, Next, State.Round);
var move = new MoveInstruction(path.Moves.ToArray());
var response = new BotResponse()
{
Move = move,
Log = DecisionMaker.GetLog(),
};
return(response);
}
