public void AddChatRequest(ChatRequest request)
{
lock (lChatRequests)
{
lChatRequests.Add(request);
}
}
public async Task<object> TinyInstancePush(ChatRequest.InstanceRequest request, SystemSession session)
{
var tinyInstancePush = new ChatInstancePullInfo { UserId = session.UserName, PageSize = request.PageSize, DrillUp = request.DrillUp, DrillDown = request.DrillDown, Limit = request.Limit, Cursor = request.Cursor, IncludeMsg = request.IncludeMessage, FolderId = request.FolderId };
var response = await Task.Factory.StartNew(() => Client.ChatService.tinyInstancePush(tinyInstancePush, session.GetSession())).ConfigureAwait(false);
return JsonConvert.DeserializeObject(response);
}
public async Task<object> TinyMessagePush(ChatRequest.MessageRequest request, SystemSession session)
{
// var result = new StatusData<object> { Status = SystemDbStatus.Selected };
var tinyMessagePull = new ChatMessagePull { UserId = session.UserName, PageSize = request.PageSize, DrillUp = request.DrillUp, DrillDown = request.DrillDown, Limit = request.Limit, InstanceId = request.InstanceId, LastMsg = request.LastMessage, Cursor = request.Cursor, UnreadMsg = request.UnReadMessage };
var response = await Task.Factory.StartNew(() => Client.ChatService.tinyMsgPush(tinyMessagePull, session.GetSession())).ConfigureAwait(false);
// Helper.Helper.ExtractData(result, response, "error", elementsToBypass: new Collection<string> { "error" });
return JsonConvert.DeserializeObject(response);
}
public void sendText(string s)
{
if (linesDictionary.ContainsKey (s)) {
string l = linesDictionary [s];
ChatRequest c = new ChatRequest (l);
ch.sendRequest (c);
} else {
Debug.LogError ("Key does not exist");
}
}
public void startQuest()
{
foreach (string s in sQLines) {
ChatRequest c = new ChatRequest(s);
ch.sendRequest(c);
}
started = true;
finishValue = 0;
complete = false;
sendExtraLines ();
}
void completeQuest()
{
foreach (string s in fQLines) {
ChatRequest c = new ChatRequest(s);
ch.sendRequest(c);
}
npcb.finishQuest ();
if (cqe != null) {
cqe.complete ();
}
complete = true;
}
private void finishQuest()
{
foreach (string s in fQLines) {
ChatRequest c = new ChatRequest(s);
ch.sendRequest(c);
}
questFinished = true;
oh.removeObjective (rewardParent);
if (oh.isAnObjective (this.gameObject)) {
oh.removeObjective (this.gameObject);
}
}
void Update()
{
if (!doOnce && questComplete && wani.finished){
foreach (string s in ftLines) {
ChatRequest c = new ChatRequest(s);
ch.sendRequest(c);
}
finish ();
doOnce = true;
}
}
public void startQuest()
{
foreach (string s in sQLines) {
ChatRequest c = new ChatRequest(s);
ch.sendRequest(c);
}
questStarted = true;
objectContainer.GetComponent<DestructiblesHandler> ().canDestroy = true;
if (!oh.isAnObjective (this.gameObject)) {
oh.addObjective (this.gameObject);
}
oh.addObjective (transform.GetChild (0).gameObject);
}
public void startQuest()
{
foreach (string s in sQLines) {
ChatRequest c = new ChatRequest(s);
ch.sendRequest(c);
}
questStarted = true;
if (!oh.isAnObjective (this.gameObject)) {
oh.addObjective (this.gameObject);
}
oh.addObjective (rewardParent);
startCheckChat = true;
}
private void failedQuest()
{
foreach (string s in fAQLines) {
ChatRequest c = new ChatRequest(s);
ch.sendRequest(c);
}
//npcb.toggleQuestIcon ();
questStarted = false;
questFinished = false;
oh.removeObjective (rewardParent);
if (oh.isAnObjective (this.gameObject)) {
oh.removeObjective (this.gameObject);
}
}
public async Task<StatusData<object>> InstancePull(ChatRequest.InstanceRequest request, SystemSession session)
{
var result = new StatusData<object> { Status = SystemDbStatus.Selected };
if (request.FolderId == null)
request.FolderId = "0";
var instancePull = new ChatInstancePullInfo { UserId = session.UserName, PageSize = request.PageSize, DrillUp = request.DrillUp, DrillDown = request.DrillDown, Limit = request.Limit, Cursor = request.Cursor, IncludeMsg = request.IncludeMessage, FolderId = request.FolderId };
var response = await Task.Factory.StartNew(() => Client.ChatService.instancePull(instancePull, session.GetSession())).ConfigureAwait(false);
Helper.Helper.ExtractData(result, response, "error", elementsToBypass: new Collection<string> { "error" });
return result;
}
void Update()
{
checkSoundIncrease ();
if (startComic && l2sc.getFinished ()) {
startSoundIncrease = true;
comicUI.SetActive(false);
volumeUI.SetActive(true);
pc.toggleCanMove();
startComic = false;
exitTrigger.SetActive(true);
foreach (string s in endLinesA){
ChatRequest c = new ChatRequest(s);
ch.sendRequest(c);
}
}
}
void Update()
{
if (!once && ca.getFinished ()) {
if (toggleControlMenu){
controlsPanel.SetActive(true);
}
if (showUI){
vui.toggleAll();
}
if (!dc.destroyMode && turnOnDcAfterAni){
dc.checkOverUI = true;
dc.destroyMode = true;
}
foreach(string s in introLines){
ChatRequest c = new ChatRequest(s);
ch.sendRequest(c);
}
once = true;
}
}
public async Task TestFTErrorHandlerDelayedAnswerCallAndRetry()
{
ChatRequest request = new ChatRequest()
{
Channel = "chatweb",
Partner = "AsurionLabs",
Context = "Test",
TimeZone = "-0400" // EDT
};
var actual = await framework.HandleRequest(request);
Assert.IsNotNull(actual, "Initial response is null");
Assert.IsNull(actual.Status.Error, "API Error triggered. {0}", actual.Status.Error);
Assert.IsNotNull(actual.ChatId, "Initial response did not give Chat Id");
request.ChatId = actual.ChatId;
request.UserInput = "ft-ErrorHandler-DelayedAnswer-CallAndRetry";
int step = 1;
var expected = new ChatResponse
{
Steps = new ChatStepId[] {
new ChatStepId("ft-ErrorHandler-DelayedAnswer-CallAndRetry", "1")
},
Messages = new string[]
{
"Phone?"
}
};
await framework.CheckRequest(request, expected, step ++);
request.UserInput = "6505551212";
expected = new ChatResponse
{
Steps = new ChatStepId[] {
new ChatStepId("ft-ErrorHandler-DelayedAnswer-CallAndRetry", "10000568")
}
};
await framework.CheckRequest(request, expected, step ++);
request.UserInput = "*****@*****.**";
expected = new ChatResponse
{
Steps = new ChatStepId[] {
new ChatStepId("ft-ErrorHandler-DelayedAnswer-CallAndRetry", "10002611")
}
};
await framework.CheckRequest(request, expected, step ++);
request.UserInput = "6505551111";
expected = new ChatResponse
{
Steps = new ChatStepId[] {
new ChatStepId("ft-ErrorHandler-DelayedAnswer-CallAndRetry", "10002254"),
new ChatStepId("ft-ErrorHandler-DelayedAnswer-CallAndRetry", "10002611")
}
};
await framework.CheckRequest(request, expected, step ++);
request.UserInput = "1/1/2017";
expected = new ChatResponse
{
Steps = new ChatStepId[] {
new ChatStepId("ft-ErrorHandler-DelayedAnswer-CallAndRetry", "10000569"),
new ChatStepId("GetIntent-AsurionLabs-Test", "10000318")
},
Messages = new string[]
{
"Phone: 6505551111\nEmail: [email protected]\nDate: 1/1/2017",
"What flow would you like to test?"
}
};
await framework.CheckRequest(request, expected, step ++);
}
private CommandTool()
{
Repository = new ChatAccountRepository();
Client = new ConnectorClient();
Request = new ChatRequest();
}
public Task<StatusData<object>> Search(ChatRequest.SearchRequest request, SystemSession session)
{
return _jUnitOfWork.Chat.Search(request, session);
}
public Task<StatusData<Object>> InstancePull(ChatRequest.InstanceRequest request, SystemSession session)
{
return _jUnitOfWork.Chat.InstancePull(request, session);
}
public async Task <IActionResult> Message([FromBody] ChatRequest model)
{
if (model.content == "*추가하기*")
{
return(Json(new MessageResponse
{
keyboard = Models.Response.Keyboard.TextKeyboard,
message = new Message
{
text = "내용을 적어주세요"
}
}));
}
else if (model.content == "*목록 보기*")
{
var tasks = (await _taskService.GetTasksAsync()).ToArray();
return(Json(new MessageResponse
{
keyboard = new Keyboard
{
type = KeyboardType.Buttons,
buttons = tasks.Select(t => t.Title + "\n" + "[" + t.Id.ToString().ToLower() + "]").Concat(new [] { "*처음으로*" }).ToArray()
},
message = new Message
{
text = String.Join("\n", tasks.Select(t => String.Join("", t.Categories.Select(c => "[" + c.Category.FullName + "]")) + " " + t.Title).ToArray())
}
}));
}
else if (model.content == "*처음으로*")
{
return(Json(new MessageResponse
{
keyboard = DefaultKeyboard,
message = new Message
{
text = "명령을 눌러주세요"
}
}));
}
else if (model.content == "*카테고리 보기*")
{
var categories = await _categoryService.GetCategoriesAsync();
return(Json(new MessageResponse
{
keyboard = new Keyboard
{
type = KeyboardType.Buttons,
buttons = categories.Select(c => $"{c.FullName}\n[c-{c.Id}]").Concat(new [] { "*처음으로*" }).ToArray()
},
message = new Message
{
text = String.Join("\n", categories.Select(c => $"[{c.FullName}] {c.Tasks.Count}개"))
}
}));
}
else if (model.content.StartsWith("*완료처리*"))
{
var idPattern = @"\[(?<id>\w{8}-\w{4}-\w{4}-\w{4}-\w{12})\]";
var idMatch = Regex.Match(model.content, idPattern);
if (idMatch.Success)
{
var id = Guid.Parse(idMatch.Groups["id"].Value);
await _taskService.ToggleDoneAsync(id);
return(Json(new MessageResponse
{
keyboard = DefaultKeyboard,
message = new Message
{
text = "명령을 눌러주세요"
}
}));
}
}
else if (model.content.StartsWith("*삭제하기*"))
{
var idPattern = @"\[(?<id>\w{8}-\w{4}-\w{4}-\w{4}-\w{12})\]";
var idMatch = Regex.Match(model.content, idPattern);
if (idMatch.Success)
{
var id = Guid.Parse(idMatch.Groups["id"].Value);
await _taskService.ArchiveAsync(id);
return(Json(new MessageResponse
{
keyboard = DefaultKeyboard,
message = new Message
{
text = "명령을 눌러주세요"
}
}));
}
}
else
{
var idPattern = @"\[(?<id>\w{8}-\w{4}-\w{4}-\w{4}-\w{12})\]";
var catIdPattern = @"\[c-(?<id>\w{8}-\w{4}-\w{4}-\w{4}-\w{12})\]";
var idMatch = Regex.Match(model.content, idPattern);
var catIdMatch = Regex.Match(model.content, catIdPattern);
if (idMatch.Success)
{
var id = Guid.Parse(idMatch.Groups["id"].Value);
var task = await _taskService.FindTaskAsync(id);
return(Json(new MessageResponse
{
keyboard = new Keyboard
{
type = KeyboardType.Buttons,
buttons = new[]
{
$"*완료처리*\n[{id}]",
$"*삭제하기*\n[{id}]",
"*목록 보기*",
"*처음으로*"
}
},
message = new Message
{
text = $"{task.Title}\n" +
(task.Deadline != null ? task.Deadline?.ToString("yy.MM.dd HH:mm") + "까지\n" : "") +
(!String.IsNullOrWhiteSpace(task.Place) ? $"{task.Place}에서" : "")
}
}));
}
else if (catIdMatch.Success)
{
var id = Guid.Parse(catIdMatch.Groups["id"].Value);
var category = await _categoryService.FindCategoryAsync(id);
var tasks = category.Tasks.Select(t => t.Task);
return(Json(new MessageResponse
{
keyboard = new Keyboard
{
type = KeyboardType.Buttons,
buttons = tasks.Select(t => t.Title + "\n" + "[" + t.Id.ToString().ToLower() + "]").Concat(new[] { "*처음으로*" }).ToArray()
},
message = new Message
{
text = String.Join("\n", tasks.Select(t => String.Join("", t.Categories.Select(c => "[" + c.Category.FullName + "]")) + " " + t.Title).ToArray())
}
}));
}
if (!model.content.StartsWith("*"))
{
await _taskService.CreateTaskAsync(model.content, null);
return(Json(new MessageResponse
{
keyboard = DefaultKeyboard,
message = new Message {
text = "추가되었습니다"
}
}));
}
}
return(Json(new MessageResponse
{
keyboard = DefaultKeyboard,
message = new Message
{
text = "명령을 눌러주세요"
}
}));
}
public Task<object> GetMessage(ChatRequest.MessageInformationRequest request, SystemSession session)
{
return _jUnitOfWork.Chat.GetMessage(request, session);
}
private bool Chat(ChatRequest profile, Filter filter)
{
TouchAt(Screen.ChatScreenTextField);
Delay(300);
var messages = ZaloHelper.GetZalomessages(profile.Profile, filter);
foreach (var message in messages)
{
DeleteWordInFocusedTextField(20);
if (message.Type == ZaloMessageType.Text)
{
SendText(message.Value);
Delay(500);
if (!IsDebug)
{
//TouchAt(Screen.ChatScreenSendButton);
SendKey(KeyCode.AkeycodeEnter);
}
ZaloHelper.Output($"Gửi tin nhắn chữ '{message.Value}' tới bạn '{profile.Profile.Name}' thành công");
}
else
{
UpImageChat(new System.IO.FileInfo(message.Value));
Delay(500);
TouchAt(Screen.ChatScreenOpenMoreWindowButton);
Delay(500);
TouchAt(Screen.ChatScreenAddImageButton);
Delay(500);
TouchAt(Screen.UploadAlbumDCimFolter);
Delay(500);
TouchAt(Screen.UploadAlbumFirstImageCheckBox);
if (!Settings.IsDebug)
{
Delay(500);
TouchAt(Screen.UploadAlbumSendButton);
}
else
{
Delay(500);
TouchAtIconTopLeft();
Delay(500);
TouchAtIconTopLeft();
}
ZaloHelper.Output($"Gửi tin nhắn hình '{message.Value}' tới bạn '{profile.Profile.Name}' thành công");
Delay(900);
TouchAt(Screen.ChatScreenCloseMoreWindowButton);
Delay(100);
}
Delay(1000);
switch (profile.Objective)
{
case ChatObjective.FriendInContactList:
DbContext.AddLogMessageSentToFriend(profile.Profile, Settings.User.Username, message.Value);
break;
case ChatObjective.StrangerByPhone:
case ChatObjective.StrangerNearBy:
DbContext.AddLogMessageSentToStranger(profile.Profile, Settings.User.Username, message.Value);
break;
}
}
return(true);
}
public void start()
{
//begin decoding
try
{
string clientmessage = null;
bool rcount = false;
//Logger.getLogger().log(Logger.DEBUG_PRIORITY, "Check for client stats and socket info: " + this._handler._client._status +
// " and " + this._clientsock.Connected);
#region Decoding and Action Loop
while (this._clientsock.Connected && (this._handler._client._status == RuntimeConstants.PENDING || this._handler._client._status == RuntimeConstants.CONNECTED))
{
// Logger.getLogger().log(Logger.DEBUG_PRIORITY, "Here is the status of our connection: " + this._clientsock.Connected);
clientmessage = null;
rcount = this._xsp.getXMLMessage(ref clientmessage);
//rcount = this._clientsock.Receive(recs,recs.Length,0);
if (rcount)
{
try
{
//clientmessage = System.Text.Encoding.ASCII.GetString(recs) ;
//clientmessage = clientmessage.Substring(0,rcount);
Logger.getLogger().log(Logger.DEBUG_PRIORITY, "Here is what they said: " + clientmessage + " and length : " + rcount);
this._xmlReader = new XmlTextReader(new StringReader(clientmessage));
this._xmlReader.ReadStartElement();
this._xmlReader.ReadStartElement();
Logger.getLogger().log(Logger.DEBUG_PRIORITY, "next node: " + this._xmlReader.Name);
/*
*
* Logger.getLogger().log(Logger.DEBUG_PRIORITY, "loaded xml reader: " + this._xmlReader.Name);
*
* Logger.getLogger().log(Logger.DEBUG_PRIORITY, "next node: " + this._xmlReader.Name);
*/
//this._xmlReader.Name
//the current xmlReader.Name is the message name we care about so now we do our if else statements
//the client is requesting a connect here
if (this._xmlReader.Name == RuntimeConstants.XML_MESSAGE_CONNECT)
{
//first we check if the client is in the pending connect state
//if not pending then this request should not be honored
if (!this._handler._client._status.Equals(RuntimeConstants.PENDING))
{
Logger.getLogger().log(Logger.INFO_PRIORITY, "Client - " +
this._handler._client.getChatName() + "@" +
this._handler._client.getIP() +
" send connect request with client status set to: " +
this._handler._client._status);
}
//we handle all the connect stuff
else
{
//we need to pull all the info off the message
//ip address
this._xmlReader.ReadStartElement();
this._handler._client.setIP(this._xmlReader.ReadElementString());
this._handler._client.setChatName(this._xmlReader.ReadElementString());
//now we need to assign the client a unique ID, add client to the hashtable
//of connected clients and return a connection element.
this._handler._client.setID(this._handler._server.getClientID());
this._handler._client._status = RuntimeConstants.CONNECTED;
this._handler._server.addClient(this._handler);
Logger.getLogger().log(Logger.DEBUG_PRIORITY, this._handler._client.ToString());
ThreadPool.QueueUserWorkItem(new WaitCallback(this._handler._responseHandler.connectConfirm));
}
}
else if (this._xmlReader.Name == RuntimeConstants.XML_MESSAGE_CONFIRM_CONNECT)
{
}
else if (this._xmlReader.Name == RuntimeConstants.XML_MESSAGE_DISCONNECT)
{
}
else if (this._xmlReader.Name == RuntimeConstants.XML_MESSAGE_CHAT_INVITE)
{
//the client wants to chat with someone
if (this._handler._client._status.Equals(RuntimeConstants.PENDING))
{
Logger.getLogger().log(Logger.INFO_PRIORITY, "Client must send connection first.");
// SHOULD SEND ERROR MESSAGE BACK TO CLIENT
}
else
{
string ip;
string chatName;
string status;
string id;
//no we go ahead and parse and make the request
this._xmlReader.ReadStartElement();
this._xmlReader.ReadStartElement();
ip = this._xmlReader.ReadElementString();
chatName = this._xmlReader.ReadElementString();
status = this._xmlReader.ReadElementString();
id = this._xmlReader.ReadElementString();
ChatBuddy cb = new ChatBuddy(ip, chatName, status, id);
ChatRequest cr = new ChatRequest(this._handler, this._handler._server.lookupClient(cb), this._handler._server.getChatID());
//now that we have the buddy they want to chat with let's make the right call
ThreadPool.QueueUserWorkItem(new WaitCallback(this._handler._server._chatRequestHandler.chatRequest), cr);
}
}
else if (this._xmlReader.Name == RuntimeConstants.XML_MESSAGE_CONFIRM_CHAT_INVITE)
{
}
else if (this._xmlReader.Name == RuntimeConstants.XML_MESSAGE_REQUEST_CHAT)
{
}
else if (this._xmlReader.Name == RuntimeConstants.XML_MESSAGE_ACCEPT_CHAT)
{
}
else if (this._xmlReader.Name == RuntimeConstants.XML_MESSAGE_DECLINE_CHAT)
{
//decline chat we now need to tell the sorry sucker who wanted to
//chat with this buddy and remove the ChatRequest from the pending chat requests
//hashtable in the ChatRequestHandler
//we let the ChatRequestHandler take care of all of this
string chatID;
//decode the chatID
//this._xmlReader.ReadStartElement();
chatID = this._xmlReader.ReadElementString();
ThreadPool.QueueUserWorkItem(new WaitCallback(this._handler._server._chatRequestHandler.chatRequestReject), chatID);
}
else if (this._xmlReader.Name == RuntimeConstants.XML_MESSAGE_EXIT_CHAT)
{
}
else if (this._xmlReader.Name == RuntimeConstants.XML_MESSAGE_CHAT_UPDATE)
{
}
else if (this._xmlReader.Name == RuntimeConstants.XML_MESSAGE_CLOSE_CHAT)
{
}
else if (this._xmlReader.Name == RuntimeConstants.XML_MESSAGE_CHATTER)
{
}
else if (this._xmlReader.Name == RuntimeConstants.XML_MESSAGE_DATA)
{
}
else if (this._xmlReader.Name == RuntimeConstants.XML_MESSAGE_DECODED_CHATTER)
{
}
else if (this._xmlReader.Name == RuntimeConstants.XML_MESSAGE_ERROR)
{
}
//xml message is not recognized
else
{
}
}
catch (System.Xml.XmlException xmlE)
{
Logger.getLogger().log(Logger.EXCEPTION_PRIORITY, "Could not parse last message", xmlE);
//send out error xml here
}
}
else
{
break;
}
} //while
#endregion
}
catch (System.Exception eee)
{
Logger.getLogger().log(Logger.EXCEPTION_PRIORITY, "Unexpected exception: " + eee.Message, eee);
}
finally
{
this.cleanup();
}
}
public void SendMessageToFriendInContactList(Filter filter)
{
try
{
var countSuccess = 0;
GotoPage(Activity.MainTab);
Delay(1000);
TouchAt(Screen.HomeScreenFriendTab);
if (!string.IsNullOrWhiteSpace(filter.IncludedPeopleNames))
{
SendMessageToFriendWithNames(filter);
return;
}
Delay(1000);
ZaloHelper.Output("Đang phân tích dữ liệu");
var fileCapture = CaptureScreenNow();
var friends = ZaloImageProcessing.GetFriendProfileList(fileCapture, Screen);
ZaloHelper.OutputLine();
friends.ToList().ForEach(x => ZaloHelper.Output(x.Name));
ZaloHelper.OutputLine();
var stack = new Stack <FriendPositionMessage>(friends.Where(x => !string.IsNullOrWhiteSpace(x.Name)).OrderByDescending(x => x.Point.Y));
var profilesPage1 = stack.Select(x => x.Name).ToArray();
while (countSuccess <= filter.NumberOfAction)
{
while (stack.Count == 0)
{
ScrollList(9);
ZaloHelper.Output("Đang phân tích dữ liệu màn hình");
fileCapture = CaptureScreenNow();
friends = ZaloImageProcessing.GetFriendProfileList(fileCapture, Screen);
ZaloHelper.OutputLine();
friends.ToList().ForEach(x => ZaloHelper.Output(x.Name));
ZaloHelper.OutputLine();
stack = new Stack <FriendPositionMessage>(friends.OrderByDescending(x => x.Point.Y));
var profilesPage2 = stack.Select(x => x.Name).ToArray();
if (!profilesPage2.Except(profilesPage1).Any())
{
ZaloHelper.Output("Hết danh sách");
return;
}
profilesPage1 = profilesPage2;
}
Delay(2000);
var rowFriend = stack.Pop();
if (DbContext.LogMessageSentToFriendSet.FirstOrDefault(x => x.Name == rowFriend.Name && x.Account == Settings.User.Username) != null)
{
ZaloHelper.Output($"Đã gửi tin cho bạn {rowFriend.Name} rồi");
continue;
}
var profile = DbContext.ProfileSet.FirstOrDefault(x => x.Name == rowFriend.Name);
var request = new ChatRequest
{
Profile = new ProfileMessage
{
Name = rowFriend.Name,
Location = profile?.Location,
PhoneNumber = profile?.PhoneNumber
},
Objective = ChatObjective.FriendInContactList
};
if (Screen.InfoRect.Contains(rowFriend.Point))
{
TouchAt(rowFriend.Point);
Delay(2000);
NavigateToProfileScreenFromChatScreenToGetInfoThenGoBack(request);
string reason;
if (!filter.IsValidProfile(request.Profile, out reason))
{
ZaloHelper.Output("Bỏ qua bạn này, lý do: " + reason);
TouchAtIconTopLeft(); //Touch to close side bar
Delay(400);
}
else
{
if (Chat(request, filter))
{
countSuccess++;
if (profile == null)
{
DbContext.AddProfile(request.Profile, Settings.User.Username);
}
}
TouchAtIconTopLeft();//GO BACK PROFILE
}
}
}
}
catch (Exception ex) { _log.Error(ex); }
finally
{
ZaloHelper.SendCompletedTaskSignal();
}
}
private void ChatFriendNearBy(int maxFriendToday, Filter filter)
{
ZaloHelper.Output($"!bắt đầu gửi tin cho bạn gần đây. Số bạn yêu cầu tối đa trong ngày hôm nay là {maxFriendToday}");
var countSuccess = 0;
string[] profilesPage1 = null;
string[] profilesPage2 = null;
ZaloHelper.Output("!đang tìm thông tin các bạn");
var friendNotAdded = (GetPositionAccountNotSent(x => profilesPage1 = x)).OrderByDescending(x => x.Point.Y);
var points = new Stack <FriendPositionMessage>(friendNotAdded);
profilesPage1.ToList().ForEach(x => ZaloHelper.Output($"!tìm thấy bạn trên màn hình: {x}"));
ZaloHelper.Output("!--------------------");
friendNotAdded.ToList().ForEach(x => ZaloHelper.Output($"!các bạn chưa được gửi lời mời: {x.Name}"));
while (countSuccess < maxFriendToday)
{
while (points.Count == 0)
{
ZaloHelper.Output("!đang cuộn danh sách bạn");
ScrollList(9);
ZaloHelper.Output("!đang tìm thông tin các bạn");
friendNotAdded = GetPositionAccountNotSent(x => profilesPage2 = x).OrderByDescending(x => x.Point.Y);
points = new Stack <FriendPositionMessage>(friendNotAdded);
profilesPage2.ToList().ForEach(x => ZaloHelper.Output($"!tìm thấy bạn trên màn hình: {x}"));
ZaloHelper.OutputLine();
friendNotAdded.ToList().ForEach(x => ZaloHelper.Output($"!bạn chưa được gửi tin nhắn: {x}"));
ZaloHelper.OutputLine();
if (!profilesPage2.Except(profilesPage1).Any())
{
ZaloHelper.Output("!hết bạn trong danh sách.");
return;
}
profilesPage1 = profilesPage2;
}
Delay(2000);
var pointRowFriend = points.Pop();
var request = new ChatRequest
{
Profile = new ProfileMessage
{
Name = pointRowFriend.Name,
Location = filter.Locations
},
Objective = ChatObjective.StrangerNearBy
};
if (Screen.InfoRect.Contains(pointRowFriend.Point))
{
TouchAt(pointRowFriend.Point);
Delay(2000);//wait to navigate chat screen
var infoGrab = GrabProfileInfo(pointRowFriend.Name);
var profile = request.Profile;
ZaloHelper.CopyProfile(ref profile, infoGrab);
string reason;
if (!filter.IsValidProfile(request.Profile, out reason))
{
ZaloHelper.Output("Bỏ qua bạn này, lý do: " + reason);
TouchAt(Screen.IconTopLeft);
Delay(300);
}
else
{
TouchAt(Screen.IconBottomLeft);
Delay(800);
if (Chat(request, filter))
{
DbContext.AddProfile(request.Profile, Settings.User.Username);
countSuccess++;
ZaloHelper.Output($"!gửi tin nhắn tới: {request.Profile.Name} thành công. Số bạn đã gửi thành công trong phiên này là: {countSuccess}");
TouchAtIconTopLeft(); //Go Back TO PROFILE
TouchAtIconTopLeft(); // GO BACK TO FRIENDLIST
}
}
}
}
}
public void SendMessageByPhoneNumber(Filter filter)
{
try
{
var canSentToday = Settings.MaxMessageStrangerPerDay - DbContext.GetMessageToStragerCount(Settings.User.Username);
var numberOfAction = filter.NumberOfAction > canSentToday ? canSentToday : filter.NumberOfAction;
if (numberOfAction <= 0)
{
ZaloHelper.Output("đã gửi hết số bạn trong ngày rồi");
return;
}
var phonelist = filter.IncludePhoneNumbers.Split(";,|".ToArray()).Where(x => !string.IsNullOrWhiteSpace(x)).ToArray();
var countSuccess = 0;
var stack = new Stack <string>(phonelist);
while (countSuccess < numberOfAction)
{
GotoPage(Activity.FindFriendByPhoneNumber);
var success = false;
while (!success)
{
if (stack.Count == 0)
{
return;
}
var phoneNumber = stack.Pop();
ZaloHelper.Output($"Tiến hành gửi tin qua số đt {phoneNumber}");
if (DbContext.LogMessageSentToStrangerSet.FirstOrDefault(x => x.PhoneNumber == phoneNumber && x.Account == Settings.User.Username) != null)
{
ZaloHelper.Output($"Đã gửi tin cho số đt '{phoneNumber}' rồi");
continue;
}
Thread.Sleep(100);
DeleteWordInFocusedTextField();
SendText(phoneNumber);
SendKey(KeyCode.AkeycodeEnter);
Thread.Sleep(4000);
ZaloHelper.Output("!đang kiểm tra số điện thoại khả dụng");
if (ZaloImageProcessing.HasFindButton(CaptureScreenNow(), Screen))
{
ZaloHelper.Output("!Lỗi, số đt không có");
}
else
{
var profile = GrabProfileInfo();
profile.PhoneNumber = phoneNumber;
string reason;
if (!filter.IsValidProfile(profile, out reason))
{
ZaloHelper.Output("Bỏ qua bạn này, lý do: " + reason);
TouchAtIconTopLeft(); //Go back to phone Entry
Delay(400);
}
else
{
var request = new ChatRequest {
Profile = profile, Objective = ChatObjective.StrangerByPhone
};
TouchAt(Screen.IconBottomLeft);
Delay(800);
if (Chat(request, filter))
{
countSuccess++;
DbContext.AddProfile(request.Profile, Settings.User.Username);
success = true;
}
TouchAtIconTopLeft();//GO BACK FRIENDLIST
}
}
}
}
}
catch (Exception ex)
{
_log.Error(ex);
}
finally
{
ZaloHelper.SendCompletedTaskSignal();
}
}
void ProcessVisitorMessages()
{
try
{
if (_processingVisitorMessages)
{
return;
}
_processingVisitorMessages = true;
var useCallback = ChatController.UseCallbackForVMs();
var useWorkgroupFromProfile = ChatController.UseProfileWorkgroupForVMs();
var vmWorkgroup = ChatController.GetDefaultWorkgroupForVisitorMessages();
var repository = new Repository();
var targetWorkgroup = repository.Workgroups.FirstOrDefault(w => w.DisplayName.ToLower() == vmWorkgroup);
if (repository.VisitorMessages.Any(v => !v.IsProcessed) && (targetWorkgroup != null || useWorkgroupFromProfile))
{
//LoggingService.GetInstance().LogToFile("Visitor Messages Found", ChatServices.FolderNameSafeDate(), true);
var visitorMessages = repository.VisitorMessages.Where(v => !v.IsProcessed).ToList();
var chatAttributes = new Dictionary <string, string>();
var chatSkills = new Collection <RoutingContext>();
foreach (var visitorMessage in visitorMessages)
{
if (!useCallback)
{
if (!ChatServices.VisitorMessageChats.Any(i => i.VisitorMessageId == visitorMessage.VisitorMessageId))
{
var chatRequest = new ChatRequest
{
SupportedContentTypes = "text/plain",
Participant = new Participant
{
Name = "visitormessage",
Credentials = ""
},
TranscriptRequired = false,
EmailAddress = "*****@*****.**",
Target = useWorkgroupFromProfile ? visitorMessage.Workgroup : targetWorkgroup.DisplayName,
TargetType = "Workgroup",
Language = "en-us",
CustomInfo = "",
Attributes = chatAttributes,
RoutingContexts = chatSkills
};
var chatResponse = ChatServices.StartChat(chatRequest);
if (chatResponse != null && chatResponse.Status.Type == "success")
{
var vm = new VisitorMessageChat
{
VisitorMessageId = visitorMessage.VisitorMessageId,
Message = visitorMessage.Message,
ParticipantId = chatResponse.ParticipantID,
State = VisitorMessageState.Connected
};
ChatServices.VisitorMessageChats.Add(vm);
}
}
}
else
{
var callbackAttributes = new Dictionary <string, string>();
if (!String.IsNullOrWhiteSpace(visitorMessage.AttributeNames))
{
var attrNames = visitorMessage.AttributeNames.Split('|');
var attrValues = visitorMessage.AttributeValues.Split('|');
if (attrNames.Length == attrValues.Length)
{
for (int i = 0; i < attrNames.Length; i++)
{
var name = attrNames[i];
var val = attrValues[i];
callbackAttributes.Add(name, val);
}
}
}
var callbackSkills = new Collection <CallbackRoutingContext>();
if (!String.IsNullOrWhiteSpace(visitorMessage.Skills))
{
var skills = visitorMessage.Skills.Split(',');
foreach (var skill in skills)
{
callbackSkills.Add(new CallbackRoutingContext
{
Category = "Product",
Context = skill
});
}
}
var subject = visitorMessage.Message.Length > 2000 ? visitorMessage.Message.Substring(0, 1999) : visitorMessage.Message;
var callbackRequest = new CallbackRequest()
{
Participant = new CallbackParticipant
{
Name = "visitormessage",
Credentials = "",
Telephone = visitorMessage.PhoneNumber
},
Target = useWorkgroupFromProfile ? visitorMessage.Workgroup : targetWorkgroup.DisplayName,
TargetType = "Workgroup",
Language = "en-us",
CustomInfo = visitorMessage.CustomInfo,
Subject = subject,
Attributes = callbackAttributes,
RoutingContexts = callbackSkills
};
var callbackResponse = ChatServices.CreateCallback(callbackRequest);
if (callbackResponse != null && callbackResponse.Status.Type == "success")
{
visitorMessage.IsProcessed = true;
visitorMessage.Type = VisitorMessageType.Callback;
repository.SaveChanges();
}
}
}
}
}
catch (Exception e)
{
LoggingService.GetInstance().LogException(e);
}
_processingVisitorMessages = false;
}
public JoinChatRoomResult JoinChatRoom(string chatRoomId, string href)
{
if (href != null)
{
HttpContext.Current.Items["href"] = href;
}
var result = new JoinChatRoomResult
{
FileTransferEnabled = chatSettingsProvider.EnableFileTransfer,
VideoChatEnabled = chatSettingsProvider.EnableVideoChat,
FlashMediaServer = chatSettingsProvider.FlashMediaServer
};
User user;
try
{
user = chatUserProvider.GetCurrentlyLoggedUser();
}
catch (System.Security.SecurityException err)
{
result.Error = err.Message;
return(result);
}
if (user == null)
{
string loginUrl = chatUserProvider.GetLoginUrl(href);
result.Error = "You need to login in order to use the chat!";
if (loginUrl != null)
{
result.Error += " Redirecting to login page...";
result.RedirectUrl = loginUrl;
}
return(result);
}
Room room = chatRoomProvider.GetChatRoom(chatRoomId);
if (room == null)
{
result.Error = "The specified chat room does not exist!";
return(result);
}
#region Messenger
var url = (new Uri(href));
var queryKeyValues = HttpUtility.ParseQueryString(url.Query);
var isInitiator = queryKeyValues["init"];
var targetUserId = queryKeyValues["target"];
bool alreadyConnected = href.IndexOf('#') == -1 ? false : (href.Substring(href.IndexOf('#')) == "#connected");
#endregion
string reason;
//if messenger
if (room.Id == "-2")
{
//check chat access only for the initiators
if (isInitiator == "1" && !chatRoomProvider.HasChatAccess(user.Id, room.Id, out reason))
{
if (String.IsNullOrEmpty(reason))
{
result.Error = "You don't have access to the messenger.";
}
else
{
result.Error = reason;
}
return(result);
}
}
else
{
if (!chatRoomProvider.HasChatAccess(user.Id, room.Id, out reason))
{
if (String.IsNullOrEmpty(reason))
{
result.Error = String.Format("You don't have access to chat room '{0}'.", room.Name);
}
else
{
result.Error = reason;
}
return(result);
}
}
// Ignore max users limit for messengerRoom (roomId = -2)
if (room.Id != "-2" && chatRoomStorage.GetUsersInRoom(room.Id).Length >= room.MaxUsers)
{
result.Error = String.Format("The chat room '{0}' is full. Please try again later.", room.Name);
return(result);
}
chatRoomStorage.AddUserToRoom(room.Id, user.Id);
chatRoomStorage.AddMessage(room.Id, new Message
{
Content =
string.Format("User {0} has joined the chat.",
user.DisplayName),
FromUserId = user.Id,
ToUserId = String.IsNullOrEmpty(targetUserId) ? null : targetUserId,
MessageType = MessageTypeEnum.UserJoined,
Timestamp = Miscellaneous.GetTimestamp()
});
#region Messenger
//delete all messages when starting messenger (not reloading it)
if (isInitiator != null && !alreadyConnected)
{
chatRoomStorage.DeleteAllMessagesFor(room.Id, user.Id);
}
if (!alreadyConnected && isInitiator == "1" && !String.IsNullOrWhiteSpace(targetUserId))
{
try
{
var targetUser = chatUserProvider.GetUser(targetUserId);
//Not sure that MessengerUrl should be constructed here?! timestamp and hash are tied to
//the implementation
var timestamp = DateTime.Now.ToFileTimeUtc();
var hash = Miscellaneous.CalculateChatAuthHash(targetUserId, user.Id, timestamp.ToString());
var request = new ChatRequest
{
FromThumbnailUrl = user.ThumbnailUrl,
FromProfileUrl = user.ProfileUrl,
FromUserId = user.Id,
FromUsername = user.DisplayName,
ToUserId = targetUserId,
ToUsername = targetUser.DisplayName,
MessengerUrl =
String.Format("{0}?init=0&id={1}&target={2}×tamp={3}&hash={4}",
url.GetLeftPart(UriPartial.Path), targetUserId, user.Id,
timestamp, hash)
};
messengerProvider.AddChatRequest(request);
}
catch (System.Security.SecurityException) { }
}
#endregion
result.ChatRoomName = room.Name;
result.ChatRoomTopic = room.Topic;
result.Users = chatRoomStorage.GetUsersInRoom(room.Id).Select(chatUserProvider.GetUser).ToArray();
result.Token = chatRoomStorage.GenerateUserToken(user.Id);
result.UserId = user.Id;
result.IsAdmin = chatUserProvider.IsChatAdmin(user.Id, room.Id);
StopVideoBroadcast(user.Id, room.Id);
result.Broadcasts = chatRoomStorage.GetBroadcasts(room.Id, user.Id);
return(result);
}
public void TransferChat(ChatRequest chatRequest)
{
ChatService.RequestChat(chatRequest);
}
public Task<StatusData<string>> RemoveUser(ChatRequest.MemberRequest request, SystemSession session)
{
return _jUnitOfWork.Chat.RemoveUser(request, session);
}
private void DisplayMessage(ChatRequest request)
{
GameObject danmaku = Instantiate(danmakuPrefab, transform);
danmaku.GetComponent <ChatDanmaku>().Init($"{request.playerName}: {request.message}");
}
public Task<StatusData<List<string>>> MoveToInbox(ChatRequest.MoveToInboxRequest request, SystemSession session)
{
return _jUnitOfWork.Chat.MoveToInbox(request, session);
}
public void HandleMessage(string incommingMessage, TalkBackDBContext dbContext)
{
MappedType t = MappedType.UNDEFINED;
XDocument serialized = XDocument.Parse(incommingMessage);
XElement typeElement = serialized.Root.Element("Type");
if (typeElement == null)
{
// ignore
return;
}
string type = typeElement.Value;
if (ModelXmlMapper.map.TryGetValue(type, out t))
{
switch (t)
{
case MappedType.MESSAGE:
MessageModel msg = new MessageModel();
if (msg.FromXml(serialized.Root))
{
HandleChatMessageMsg(msg, dbContext);
}
break;
case MappedType.USER:
UserModel user = new UserModel();
user.FromXml(serialized.Root);
break;
case MappedType.CONTACT:
Contact contact = new Contact();
contact.FromXml(serialized.Root);
break;
case MappedType.CHAT_REQUEST:
ChatRequest req = new ChatRequest();
if (req.FromXml(serialized.Root))
{
HandleChatRequestMsg(req, dbContext);
}
break;
case MappedType.CHAT_REQUEST_RESPONSE:
ChatRequestResponse resp = new ChatRequestResponse();
if (resp.FromXml(serialized.Root))
{
HandleChatResponseMsg(resp, dbContext);
}
break;
case MappedType.LOGIN:
Login login = new Login();
if (login.FromXml(serialized.Root))
{
HandleLoginMsg(login, dbContext);
}
break;
case MappedType.LOGIN_RESPONSE:
LoginResponse loginResp = new LoginResponse();
loginResp.FromXml(serialized.Root);
break;
case MappedType.UNDEFINED:
throw new Exception("Don't know how to parse this type");
}
}
}
public async Task <ChatResponse> HandleRequest(ChatRequest request)
{
return(await chatEngine.HandleRequest(request));
}
public Task<StatusData<string>> ChatMemberAddRemove(ChatRequest.BlockUsersRequest request, SystemSession session)
{
return _jUnitOfWork.Chat.ChatMemberAddRemove(request, session);
}
private async Task <Nullable <KeyValuePair <string, IServerStreamWriter <ChatRequest> > > > SendMessageToSubscriber(KeyValuePair <string, IServerStreamWriter <ChatRequest> > user, ChatRequest message)
{
try
{
await user.Value.WriteAsync(message);
return(null);
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(user);
}
}
public Task<StatusData<object>> MessagePull(ChatRequest.MessageRequest request, SystemSession session)
{
return _jUnitOfWork.Chat.MessagePull(request, session);
}
void sendExtraLines()
{
if (hasExtraLines) {
ChatRequest c = new ChatRequest(trigger.getExtraLines());
ch.sendRequest(c);
}
}
public Task<StatusData<string>> UpdateDisposableInstance(ChatRequest.DisposableInstanceRequest request, SystemSession session)
{
return _jUnitOfWork.Chat.UpdateDisposableInstance(request, session);
}
public Task<StatusData<string>> InstanceOperation(ChatRequest.InstanceOperationRequest request, SystemSession session)
{
return _jUnitOfWork.Chat.InstanceOperation(request, session);
}
public Task<List<string>> MessageDelete(ChatRequest.MessageDeleteRequest request, SystemSession session)
{
return _jUnitOfWork.Chat.MessageDelete(request, session);
}
public Task<StatusData<string>> GroupAdd(ChatRequest.ChatGroupRequest request, SystemSession session)
{
return _jUnitOfWork.Chat.GroupAdd(request, session);
}
public Task<object> TinyInstancePush(ChatRequest.InstanceRequest request, SystemSession session)
{
return _jUnitOfWork.Chat.TinyInstancePush(request, session);
}
public static chat.model.User getUser(ChatRequest request)
{
chat.model.User user = new chat.model.User(request.User.Id);
user.Password = request.User.Passwd;
return(user);
}
public Task<StatusData<string>> BlockUsers(ChatRequest.BlockUsersRequest request, SystemSession session)
{
return _jUnitOfWork.Chat.BlockUsers(request, session);
}
public async Task BroadcastMessageAsync(ChatRequest message) => await BroadcastMessages(message);
public async Task <ActionResult <ChatResponse> > Post([FromServices] ChatWeb.Services.ChatEngine chatEngine, [FromBody] ChatRequest chatRequest, string partner = null)
{
// NOTE: We are requiring the partner in the URL so an ALB can easily parse the partner for proper routing through proxies.
if (chatRequest == null)
{
logger.Debug("Chat request is null");
return(BadRequest());
}
if (chatRequest.ClientData == null)
{
chatRequest.ClientData = new ChatClientData();
}
chatRequest.ClientData.ClientIp = NetworkHelpers.GetClientIP(HttpContext);
chatRequest.ClientData.UserAgent = HttpContext.Request.Headers["User-Agent"];
// Ignore debug data if not allowed
if (!chatConfiguration.AllowDebugMode)
{
chatRequest.DebugData = null;
}
bool trustedClient = (!String.IsNullOrEmpty(chatConfiguration.TrustedClientKey) && (HttpContext.Request.Headers["x-api-key"] == chatConfiguration.TrustedClientKey));
if ((chatRequest.TrustedClientData != null) && !trustedClient)
{
logger.WarnFormat("TrustedClientData was present but stripped since the API key did not match.");
chatRequest.TrustedClientData = null;
}
log4net.LogicalThreadContext.Properties["interactionId"] = Guid.NewGuid().ToString();
log4net.LogicalThreadContext.Properties["clientIp"] = chatRequest.ClientData.ClientIp;
if (String.IsNullOrEmpty(partner) || partner != chatRequest.Partner)
{
logger.Warn("Request does not contain the partner in URL parameter");
//return BadRequest("partner is required in URL");
}
try
{
ChatResponse response = null;
// Make initial call to get chat Id if missing and userinput was sent
if (String.IsNullOrEmpty(chatRequest.ChatId) && !String.IsNullOrEmpty(chatRequest.UserInput))
{
response = await chatEngine.HandleRequest(chatRequest);
chatRequest.ChatId = response.ChatId;
}
if (response == null || String.IsNullOrEmpty(response.Status.Error))
{
response = await chatEngine.HandleRequest(chatRequest);
}
if (!trustedClient)
{
response.TrustedClientData = null;
}
return(Ok(response));
}
catch (Exception ex)
{
logger.Error("Post failed.", ex);
}
return(BadRequest());
}
public ChatResult Chat([FromBody] ChatRequest chat)
{
return(Chat(chat.Text, chat.ChatBotId));
}
void failedQuest()
{
foreach (string s in fAQLines) {
ChatRequest c = new ChatRequest(s);
ch.sendRequest(c);
}
npcb.removeQuest ();
complete = true;
started = false;
trigger.reset ();
}
public abstract Guid RequestChat(ChatRequest request);
public void setChatRequest(ChatRequest cr)
{
chatRequest = cr;
}
public ChatServiceRequest(ChatRequest requestType)
: base(Service.Chat)
{
this.requestType = requestType;
}
