private async Task receive(ClientWebSocket socket)
{
var buffer = new ArraySegment <byte>(new byte[2048]);
do
{
WebSocketReceiveResult result;
using (var ms = new MemoryStream())
{
do
{
result = await socket.ReceiveAsync(buffer, cancellationRecieveToken.Token);
ms.Write(buffer.Array, buffer.Offset, result.Count);
} while (!result.EndOfMessage);
if (result.MessageType == WebSocketMessageType.Close)
{
await socket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken.Token);
disconnectInternal();
break;
}
ms.Seek(0, SeekOrigin.Begin);
using (var reader = new StreamReader(ms, Encoding.UTF8))
{
RecievedMessage?.Invoke(JObject.Parse(reader.ReadToEnd()));
}
}
} while (true);
}
/// <summary>
/// Delete Recieved Message from db
/// </summary>
/// <param name="id">id of recieved message for deleting</param>
public void Delete(int id)
{
RecievedMessage recievedMessage = unitOfWork.RecievedMessages.GetById(id);
unitOfWork.RecievedMessages.Delete(recievedMessage);
unitOfWork.Save();
}
private static void SendToPathAsync(HttpClient client, Uri path, RecievedMessage message)
{
var coded = JsonConvert.SerializeObject(message);
var values = new Dictionary <string, string>()
{
{ "message", coded }
};
var toSend = new FormUrlEncodedContent(values);
var result = client.PostAsync(path, toSend).Result;
}
private IEnumerable <RecievedMessage> GetTextMessagesUpdates()
{
var messages = connector.Messages.GetLongPollHistory(new MessagesGetLongPollHistoryParams()
{
Ts = longPoolTs, Pts = longPoolPts
}).
Messages;
foreach (var message in messages)
{
var sender = new ExternalUser((message.FromId ?? -1).ToString());
var text = new MessageBody(message.Body);
var recievedMessage = new RecievedMessage(sender, text);
yield return(recievedMessage);
}
}
public static void Listening()
{
// Call this function in a single thread when the client connects, then one can simply use a function like the above/below
RecievedMessage += SocketConnection_RecievedMessage;
if (hasStarted && Client != null && Client.Connected == true)
{
return;
}
hasStarted = true;
ShouldListen = true;
int err = 0;
while (ShouldListen)
{
try
{
NetworkStream stream = Client.GetStream();
byte[] bytes = new byte[Client.ReceiveBufferSize];
string data = "";
stream.Read(bytes, 0, Client.ReceiveBufferSize);
data = System.Text.Encoding.UTF8.GetString(bytes);
foreach (var msg in data.Split('%').Where(x => !string.IsNullOrWhiteSpace(x)))
{
string message = msg.Substring(0, msg.IndexOf('`'));
RecievedMessage?.Invoke(Client, message);
}
} catch (Exception ex)
{
err++;
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(ex.ToString());
if (err > 3)
{
ShouldListen = false;
}
}
}
}
/// <summary>
/// insert new Recieved Message in bd
/// </summary>
/// <param name="item">RecievedMessageDTO for inserting</param>
public void Insert(RecievedMessageDTO item)
{
RecievedMessage recievedMessage = mapper.Map <RecievedMessageDTO, RecievedMessage>(item);
unitOfWork.Phones.Get(filter: p => p.PhoneNumber == item.SenderPhone);
List <Phone> phone = unitOfWork.Phones.Get(filter: p => p.PhoneNumber == item.SenderPhone).ToList();
if (phone.Count == 0)
{
Phone newPhone = new Phone();
newPhone.PhoneNumber = item.SenderPhone;
unitOfWork.Phones.Insert(newPhone);
unitOfWork.Save();
recievedMessage.Phone = newPhone;
}
else
{
recievedMessage.Phone = phone[0];
}
phone = unitOfWork.Phones.Get(filter: p => p.PhoneNumber == item.RecipientPhone).ToList();
if (phone.Count == 0)
{
return;
}
else
{
List <Company> company = unitOfWork.Companies.Get(filter: c => c.PhoneId == phone[0].Id).ToList();
if (company.Count == 0)
{
return;
}
else
{
recievedMessage.Company = company[0];
}
}
unitOfWork.RecievedMessages.Insert(recievedMessage);
unitOfWork.Save();
}
private void handleRecieveMessage()
{
string data;
NetworkStream RecieveDataStream = Client.GetStream();
byte[] bytes = new byte[256];
int i;
try
{
while (Connected)
{
if ((i = RecieveDataStream.Read(bytes, 0, bytes.Length)) != 0)
{
data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
RecievedMessage?.Invoke(this, data);
}
}
}
catch (Exception ex)
{
this.Disconnect(false);
}
}
// Invoke the Changed event; called whenever message recieved
protected virtual void OnReceivedMessage(MyEventArgs e)
{
RecievedMessage?.Invoke(this, e);
}
private void recievedMessageToMatch(RecievedMessage rm)
{
MatchStartedResult msr = (MatchStartedResult)rm.Result;
Match matchToAdd = new Match(msr.MatchID, msr.TeamA, msr.OddsA, msr.TeamB, msr.OddsB, msr.OddsDraw, msr.Limit, this);
if (!_listOfMatches.Contains(matchToAdd))
{
lock (lockObj)
{
this._listOfMatches.Add(matchToAdd);
}
}
}
public bool endBet(String bookieName, int matchID, string winningTeam, float amountWon)
{
EndBetResult ebr = new EndBetResult(bookieName, matchID, winningTeam, amountWon);
RecievedMessage rm = new RecievedMessage(ebr, RecievedMessage.MessageType.endBet);
return addUpdate(rm);
}
public void SetUp()
{
recievedMessageManager = new RecievedMessageManager(mockUnitOfWork.Object, mockMapper.Object);
TestContext.WriteLine("Overrided");
phoneSender = new Phone()
{
Id = 9, PhoneNumber = "+380999999999"
};
phoneRecipient = new Phone()
{
Id = 10, PhoneNumber = "+380111111111"
};
listPhones = new List <Phone>()
{
phoneSender,
phoneRecipient,
new Phone()
{
Id = 7, PhoneNumber = "+380501465619"
}
};
testCompany = new Company()
{
Id = 1,
PhoneId = 10,
Name = "Test",
ApplicationGroupId = 5
};
listCompanies = new List <Company>()
{
testCompany
};
subscribeWord = new SubscribeWord()
{
Id = 21, Word = "sWord"
};
listSubscribeWords = new List <SubscribeWord>()
{
subscribeWord,
new SubscribeWord()
{
Id = 2, Word = "test2"
}
};
message = new RecievedMessage()
{
Id = 3, CompanyId = testCompany.Id, PhoneId = phoneRecipient.Id, Message = "test"
};
viewMessage = new RecievedMessageViewModel()
{
SenderPhone = "+380999999999",
RecipientPhone = "+380111111111",
MessageText = "sWord"
};
recievedMessageInsert = new RecievedMessageDTO()
{
SenderPhone = viewMessage.SenderPhone,
RecipientPhone = viewMessage.RecipientPhone,
MessageText = "test1"
};
recievedMessageDto = new RecievedMessageDTO()
{
SenderPhone = viewMessage.SenderPhone,
RecipientPhone = viewMessage.RecipientPhone,
MessageText = viewMessage.MessageText
};
stopWord = new StopWord()
{
Id = 1, Word = "sWord"
};
listStopWords = new List <StopWord>()
{
stopWord,
new StopWord()
{
Id = 2, Word = "START"
}
};
}
//4 nhận được tin nhắn
public override void Process(RecievedMessage message)
{
}
/// <summary>
/// Get Recieved Messages by id
/// </summary>
/// <param name="id">id of recieved message</param>
/// <returns>RecievedMessageViewModel</returns>
public RecievedMessageViewModel Get(int id)
{
RecievedMessage recievedMessage = unitOfWork.RecievedMessages.GetById(id);
return(mapper.Map <RecievedMessage, RecievedMessageViewModel>(recievedMessage));
}
private void recievedMessageToBet(RecievedMessage rm)
{
EndBetResult ebr = (EndBetResult)rm.Result;
lock (lockObj)
{
var data = _listOfMatches.Where(t => t.ID.Equals(ebr.MatchID));
try
{
Match matchToUpdate = data.First();
matchToUpdate.closeMatch();
Model.Winnings winnings = new Winnings(ebr.AmountWon, ebr.BookieID, ebr.MatchID, matchToUpdate.BetPlaced);
this._listOfWinnings.Add(winnings);
}
catch
{
Console.WriteLine("Closing match - Unable to find match of ID " + ebr.MatchID + " for the bookie " + ebr.BookieID);
Model.Winnings winnings = new Winnings(ebr.AmountWon, ebr.BookieID, ebr.MatchID, false);
this._listOfWinnings.Add(winnings);
}
var listOfBetsToUpdate = _listOfBets.Where(t => t.MatchID.Equals(ebr.MatchID) && t.BookieID.Equals(this.ID));
foreach(var betToUpdate in listOfBetsToUpdate)
betToUpdate.closeBet();
}
}
//4 nhận được tin nhắn
public override void Process(RecievedMessage message)
{
this.form.richTextBox1.AppendText(string.Format("{0}: {1} \n", message.From, message.Message));
}
private bool addUpdate(RecievedMessage rm)
{
lock (_lock)
{
if (_listOfUpdates.Contains(rm))
return false;
else
{
_listOfUpdates.Add(rm);
return true;
}
}
}
public bool setOdds(String bookieName, int matchID, string team, float newOdds)
{
SetOddsResult sor = new SetOddsResult(bookieName, matchID, team, newOdds);
RecievedMessage rm = new RecievedMessage(sor, RecievedMessage.MessageType.setOdds);
return addUpdate(rm);
}
public bool matchStarted(String bookieName, object recievedMatch)
{
string data = recievedMatch.ToString().Trim('{');
data = data.Trim('}');
data = data.Replace("\r\n", "");
data = data.Replace("\"", "");
data = data.Replace(" ", "");
string[] array = data.Split(',');
string bookieID = string.Empty;
int id = int.MinValue;
string teamA = string.Empty;
string teamB = string.Empty;
float oddsA = float.MinValue;
float oddsB = float.MinValue;
float oddsDraw = float.MinValue;
float limit = float.MinValue;
Gambler.Controller.FunctionController f = Gambler.Controller.FunctionController.getInstance();
foreach (string str in array)
{
if (str.StartsWith("bookieID"))
bookieID = str.Split(':')[1];
else if (str.StartsWith("id") && !f.isInt(str.Split(':')[1], out id))
throw new Exception("Match ID is not in an integer format");
else if (str.StartsWith("teamA"))
teamA = str.Split(':')[1];
else if (str.StartsWith("teamB"))
teamB = str.Split(':')[1];
else if (str.StartsWith("oddsA") && !f.isFloat(str.Split(':')[1], out oddsA))
throw new Exception("Odds A was not a valid float value");
else if (str.StartsWith("oddsB") && !f.isFloat(str.Split(':')[1], out oddsB))
throw new Exception("Odds B was not a valid float value");
else if (str.StartsWith("limit") && !f.isFloat(str.Split(':')[1], out limit))
throw new Exception("The limit was not a valid float value");
else if (str.StartsWith("oddsDraw") && !f.isFloat(str.Split(':')[1], out oddsDraw))
throw new Exception("Odds draw was not a valid float value");
}
if (teamA != string.Empty && teamB != string.Empty && bookieID != string.Empty)
{
MatchStartedResult msr = new MatchStartedResult(bookieID, id, teamA, teamB, oddsA, oddsB, oddsDraw, limit);
RecievedMessage rm = new RecievedMessage(msr, RecievedMessage.MessageType.matchStarted);
return addUpdate(rm);
}
else
return false;
}
