void OnMessageSet(MessageEventArgs args)
{
string msg = args.GetMessage<string>("Message");
message.text = msg;
msgList.Clear();
msgList.Add(msg);
}
public void printMsg(MessageEventArgs e)
{
if (e.messageSet)
{
Message receivedMsg = e.newMessage;
String user = receivedMsg.sndUser.username;
String time = AddUserTime(user, false);
String messageStr;
if (chatUser.isPasswordProtected())
{
String encStr = receivedMsg.messageStr;
messageStr = Message.xorMsg(encStr, chatUser.getPassword());
}
else
{
messageStr = receivedMsg.messageStr;
}
DisplayMsg(time, messageStr, user);
// Memory handle
time = null;
}
}
private void Session_MessageReceived(object sender, MessageEventArgs<Message> e)
{
var groupMessage = e.Message as KeyExchangeDhGroupExchangeGroup;
if (groupMessage != null)
{
// Unregister message once received
this.Session.UnRegisterMessage("SSH_MSG_KEX_DH_GEX_GROUP");
// 2. Receive SSH_MSG_KEX_DH_GEX_GROUP
this._prime = groupMessage.SafePrime;
this._group = groupMessage.SubGroup;
this.PopulateClientExchangeValue();
// 3. Send SSH_MSG_KEX_DH_GEX_INIT
this.Session.SendMessage(new KeyExchangeDhGroupExchangeInit(this._clientExchangeValue));
}
var replyMessage = e.Message as KeyExchangeDhGroupExchangeReply;
if (replyMessage != null)
{
// Unregister message once received
this.Session.UnRegisterMessage("SSH_MSG_KEX_DH_GEX_REPLY");
this.HandleServerDhReply(replyMessage.HostKey, replyMessage.F, replyMessage.Signature);
// When SSH_MSG_KEX_DH_GEX_REPLY received key exchange is completed
this.Finish();
}
}
void OnMessageUpdate(MessageEventArgs args)
{
string msg = args.GetMessage<string>("Message");
//handle msgList
msgList.Add(msg);
while(msgList.Count > MAX_MSG_COUNT)
{
msgList.RemoveAt(0);
}
//handle alignment
if (msgList.Count >= ALIGNMENT_MSG_COUNT)
{
message.alignment = TextAnchor.LowerLeft;
}
else
{
message.alignment = TextAnchor.UpperLeft;
}
//reassamble message
message.text = "";
for(int i = 0; i < msgList.Count - 1; i++)
{
message.text += msgList[i] + "\n";
}
//highlight latest message with animation
message.DOKill();
message.DOText(message.text + "<color=yellow>" + msgList[msgList.Count - 1] + "</color>", 0.5f).SetEase(Ease.Linear);
}
public bool changeResourceStock(object sender, MessageEventArgs e, TypeResource resourceType, int value)
{
//Debug.Log("Changing resource stock : " + resourceType.ToString() + " - " + value.ToString());
char islandNumber = ((string)e.message.Split('@').GetValue(1))[1];
if (!gameObject.name.Contains(islandNumber))
{
//Island not concerned
return false;
}
//Debug.Log("Stock update : " + e.message);
Resource resource = this.getResource(resourceType);
bool result = false;
if (resource != null)
{
result = resource.changeStock(value);
}
else
{
if (value >= 0)
{
this.addResource(resourceType, value);
result = true;
}
else
{
return false;
}
}
//The board shouldn't notice the network of an gloabl stock update
if(this.ChangeResourceStockEvent != null) // && result)
{
this.ChangeResourceStockEvent(this, new ChangeResourceStockEventArgs { resourceType = resourceType, stock = value }); // resource.Stock });
}
return result;
}
/*UI CALLBACK*/
public void EnterBattle(int battleType)
{
MessageEventArgs arg = new MessageEventArgs();
arg.AddMessage("WindowID", UIWindowID.BattleWindow);
EventManager.Instance.PostEvent(UIEvent.OpenUIWindow, arg);
MessageEventArgs args = new MessageEventArgs ();
args.AddMessage("BattleType",battleType);
if(battleType == 0)
{
args.AddMessage("Man",true);
args.AddMessage("Girl",true);
args.AddMessage("Enemy",new int[3]{101,102,103});
}
else if(battleType == 1)
{
args.AddMessage("Man",true);
args.AddMessage("Girl",true);
args.AddMessage("Enemy",new int[1]{104});
}
else
{
args.AddMessage("Man",true);
args.AddMessage("Enemy",new int[1]{105});
}
EventManager.Instance.PostEvent (BattleEvent.OnBattleEnter, args);
}
void OnCommandShowUp(MessageEventArgs args)
{
commandPanel.SetActive(true);
subCommandPanel.SetActive (true);
commandPanel.GetComponent<CommandPanelUIEvent>().SetButtonActive();
EventManager.Instance.PostEvent(UIEvent.OnMessageHide);
}
void OnItemClicked(MessageEventArgs args)
{
int itemID = args.GetMessage<int>("ItemID");
ItemData itemData = DataManager.Instance.GetItemDataSet().GetItemData(itemID);
args.AddMessage ("Message", itemData.description);
EventManager.Instance.PostEvent (UIEvent.OnMessageSet, args);
}
private void OnMessageEvent(string messagetype, string message)
{
MessageEventArgs mea = new MessageEventArgs();
mea.messagetype = messagetype;
mea.message = message;
OnMessage.BeginInvoke(this, mea, null, null);
}
private void OnChannelOpenConfirmation(object sender, MessageEventArgs<ChannelOpenConfirmationMessage> e)
{
if (e.Message.LocalChannelNumber == this.LocalChannelNumber)
{
this.OnOpenConfirmation(e.Message.RemoteChannelNumber, e.Message.InitialWindowSize, e.Message.MaximumPacketSize);
}
}
void OpenUIWindow(MessageEventArgs args)
{
UIWindowID windowID = args.GetMessage<UIWindowID>("WindowID");
if(windowStack.Count > 0)
{
GameObject lastWindow = windowStack[windowStack.Count - 1];
CanvasGroup canvasGroup = lastWindow.GetComponent<CanvasGroup>();
canvasGroup.alpha = 1;
canvasGroup.DOFade(0, 0.25f).OnComplete(()=>{lastWindow.SetActive(false);});
}
GameObject window = windowStack.Find((GameObject x)=>{return x.name.Contains(windowID.ToString());});
if(window != null)
{
window.SetActive(true);
windowStack.Remove(window);
windowStack.Add(window);
}
else
{
window = GameObject.Instantiate(Resources.Load(GlobalDataStructure.PATH_UIPREFAB_WINDOW + windowID.ToString()) as GameObject);
windowStack.Add(window);
}
if(windowStack.Count > 1)
{
CanvasGroup canvasGroup = window.GetComponent<CanvasGroup>();
canvasGroup.alpha = 0;
canvasGroup.DOFade(1, 0.5f);
}
}
public IMessageResponse Execute()
{
if (Subject.Queue.Count == 0)
return MessageResult.Empty;
var ctx = (MessageResult)Subject.Queue.Dequeue();
var handlers = Subject.Subscriber.Observers;
if (handlers.Count == 0)
OnCompleted(ctx);
else
{
var e = new MessageEventArgs(ctx);
ListnerManager.OnSending(e);
if (e.Context.Response.Canceled)
{
ListnerManager.OnSent(e);
OnCompleted(ctx);
return ctx;
}
Dispatch(ctx);
}
return ctx;
}
private void OnChannelOpenFailure(object sender, MessageEventArgs<ChannelOpenFailureMessage> e)
{
if (e.Message.LocalChannelNumber == this.LocalChannelNumber)
{
this.OnOpenFailure(e.Message.ReasonCode, e.Message.Description, e.Message.Language);
}
}
private void Session_ChannelOpening(object sender, MessageEventArgs<ChannelOpenMessage> e)
{
// Ensure that this is corresponding request
var info = e.Message.Info as ForwardedTcpipChannelInfo;
if (info != null)
{
if (info.ConnectedAddress == this.BoundHost && info.ConnectedPort == this.BoundPort)
{
this.ExecuteThread(() =>
{
try
{
this.RaiseRequestReceived(info.OriginatorAddress, info.OriginatorPort);
var channel = this.Session.CreateChannel<ChannelForwardedTcpip>(e.Message.LocalChannelNumber, e.Message.InitialWindowSize, e.Message.MaximumPacketSize);
channel.Bind(this.Host, this.Port);
}
catch (Exception exp)
{
this.RaiseExceptionEvent(exp);
}
});
}
}
}
/// <summary>
/// Constructor that takes the given message event args, bilingual document, source segment and target segment.
/// </summary>
/// <param name="messageEventArgs">message event arguments</param>
/// <param name="bilingualDocument">bilingual document</param>
/// <param name="sourceSegment">source segment</param>
/// <param name="targetSegment">target segment</param>
public CustomMessageControl(MessageEventArgs messageEventArgs, IBilingualDocument bilingualDocument, ISegment sourceSegment, ISegment targetSegment)
{
MessageEventArgs = messageEventArgs;
BilingualDocument = bilingualDocument;
SourceSegment = sourceSegment;
TargetSegment = targetSegment;
InitializeComponent();
_sourceSegmentControl.Dock = DockStyle.Fill;
_sourceSegmentPanel.Controls.Add(_sourceSegmentControl);
_targetSegmentControl.Dock = DockStyle.Fill;
_targetSegmentPanel.Controls.Add(_targetSegmentControl);
UpdateMessage(messageEventArgs);
UpdateSourceSegment(sourceSegment);
UpdateTargetSegment((ISegment)targetSegment.Clone());
UpdateProblemDescription(messageEventArgs);
UpdateSuggestions(messageEventArgs);
// make the target segment editable
_targetSegmentControl.IsReadOnly = false;
_suggestionsList.SelectedIndexChanged += _suggestionsList_SelectedIndexChanged;
}
private void OnMarketPricesStreamMessageReceived(object sender, MessageEventArgs<PriceDTO> e)
{
if (!_listening || _ordered || Market == null) return;
_ordered = true;
var order = new NewTradeOrderRequestDTO
{
MarketId = e.Data.MarketId,
BidPrice = e.Data.Bid,
OfferPrice = e.Data.Offer,
AuditId = e.Data.AuditId,
Quantity = Market.WebMinSize.GetValueOrDefault() + 1,
TradingAccountId = Account.TradingAccounts[0].TradingAccountId,
Direction = "buy"
};
Dispatcher.BeginInvoke(() => listBox1.Items.Add("price update arrived, making a new trade"));
RpcClient.TradesAndOrders.BeginTrade(order, ar =>
{
var result = RpcClient.TradesAndOrders.EndTrade(ar);
var newOrder = result.Orders.Length > 0 && result.Orders[0].OrderId == result.OrderId
? result.Orders[0]
: null;
if (newOrder != null && newOrder.Status == 8 && newOrder.StatusReason == 140)
{
Dispatcher.BeginInvoke(() =>
{
listBox1.Items.Add("the account is on a dealer watchlist!");
listBox1.Items.Add("waiting for the order approval...");
});
}
}, null);
}
private void OnMarketPricesStreamMessageReceived(object sender, MessageEventArgs<PriceDTO> e)
{
if (!_listening) return;
Dispatcher.BeginInvoke(() => listBox1.Items.Add("anonymous price arrived!"));
Dispatcher.BeginInvoke(() => button1.IsEnabled = true);
_listening = false;
}
private void SocketMessage(object sender, MessageEventArgs e)
{
if ( e!= null && e.Message.Event == "message") {
string msg = e.Message.MessageText;
Debug.Log("socket message: " + msg);
}
}
void onMessageReceived(object sender, MessageEventArgs e)
{
try
{
var json = JSON.Parse(e.Data.Substring(2));
string tag = json.AsArray[0];
JSONNode objJson = json.AsArray[1];
switch (tag) {
// from web client
case "obj" :
int objType = objJson["id"].AsInt;
int position = objJson["pos"].AsInt;
resources.Add(new ResourceObject(objType, position));
break;
// from unity, so this would be other unity clients. May handle in future
case "pos" :
break;
case "score":
break;
case "invW":
break;
case "invR":
break;
case "invG":
break;
default :
break;
}
}
catch (System.Exception error) {/* Debug.log(error.StackTrace) */ }
}
public NumberVerifierMessageUI(MessageEventArgs messageEventArgs, IBilingualDocument bilingualDocument, ISegment sourceSegment, ISegment targetSegment)
{
MessageEventArgs = messageEventArgs;
BilingualDocument = bilingualDocument;
SourceSegment = sourceSegment;
TargetSegment = targetSegment;
InitializeComponent();
_sourceSegmentControl.Dock = DockStyle.Fill;
_sourceSegmentControl.IsReadOnly = false;
_sourceSegmentControl.ReplaceDocumentSegment(sourceSegment.Clone() as ISegment);
panel_Source.Controls.Add(_sourceSegmentControl);
_sourceSegmentControl.ReplaceDocumentSegment(sourceSegment);
_targetSegmentControl.Dock = DockStyle.Fill;
_targetSegmentControl.IsReadOnly = false;
_targetSegmentControl.ReplaceDocumentSegment(targetSegment.Clone() as ISegment);
panel_Target.Controls.Add(_targetSegmentControl);
_targetSegmentControl.ReplaceDocumentSegment((ISegment)targetSegment.Clone());
_targetSegmentControl.SegmentContentChanged += OnSegmentContentChanged;
_hasSegmentChanged = false;
UpdateMessage(messageEventArgs);
}
protected override void Revert()
{
source.buffFrozenTime = 0;
MessageEventArgs args = new MessageEventArgs ();
args.AddMessage("Message",string.Format("{0}不再<冰冻>了!", source.GetName()));
EventManager.Instance.PostEvent (BattleEvent.OnBuffDeactivated, args);
}
public void MessageQueuedForReceive_without_transaction_should_increment_ArrivedMessages()
{
Setup();
_performanceMonitor.InboundPerfomanceCounters.ArrivedMessages = 0;
var e = new MessageEventArgs(null, new Message { Queue = "q" });
_queueManager.Raise(qm => qm.MessageQueuedForReceive += null, null, e);
Assert.Equal(1, _performanceMonitor.InboundPerfomanceCounters.ArrivedMessages);
}
protected override void Init()
{
source.timelinePosition = 0;
MessageEventArgs args = new MessageEventArgs ();
args.AddMessage("Message",string.Format("{0}被<击倒>了!", source.GetName()));
EventManager.Instance.PostEvent (BattleEvent.OnBuffActivated, args);
}
protected override void Execute()
{
source.damageTaken.interrupt = 0;
MessageEventArgs args = new MessageEventArgs ();
args.AddMessage("Message",string.Format("{0}因为<霸体>,没有被击退!", source.GetName()));
EventManager.Instance.PostEvent (BattleEvent.OnBuffActivated, args);
}
protected override void Init()
{
source.buffFrozenTime = 5;
MessageEventArgs args = new MessageEventArgs ();
args.AddMessage("Message",string.Format("{0}因为<冰冻>,暂时不能行动!", source.GetName()));
EventManager.Instance.PostEvent (BattleEvent.OnBuffActivated, args);
}
private static void NewsStream_NewMessage(object sender, MessageEventArgs<NewsDTO> eventArgs)
{
if (eventArgs.Data != null)
{
var newsDTO = eventArgs.Data;
Console.WriteLine("News headline: " + newsDTO.Headline);
}
}
internal void OnCreateNewsMessage(MessageEventArgs<NewsDTO> e)
{
Action<MessageEventArgs<NewsDTO>> handler = CreateNewsMessage;
if (handler != null)
{
handler(e);
}
}
private static void PriceStream_PriceChanged(object sender, MessageEventArgs<PriceDTO> e)
{
if (e.Data != null)
{
var priceDTO = e.Data;
Console.WriteLine("MarketId: " + priceDTO.MarketId + ", Bid price: " + priceDTO.Bid);
}
}
static void OrderStream_OrderMessageRecieved(object sender, MessageEventArgs<OrderDTO> eventArgs)
{
if (eventArgs.Data != null)
{
var orderDTO = eventArgs.Data;
Console.WriteLine("Client account id: " + orderDTO.ClientAccountId + ", Order id: " + orderDTO.OrderId + ", Direction: " + orderDTO.Direction);
}
}
private void OnResponseScreenshotMessageReceived(MessageEventArgs<ResponseScreenshotMessage> e)
{
Trace.WriteLine(String.Format("Received ResponseScreenshotMessage, Number: {0}, Size: {1} KB", e.Message.Number, GetKBFromBytes(e.Message.Image.Length)));
uint num = e.Message.Number;
// Slowly build our image bytes
Buffer.BlockCopy(e.Message.Image, 0, pendingScreenshots[num].Image, e.Message.SendIndex * Server.LiveControlProvider.mtu, e.Message.Image.Length);
}
public void OnMessage(object sender, MessageEventArgs messageEventArgs)
{
tempMessage = messageEventArgs.Data;
}
public abstract void Execute(MessageEventArgs e);
public void GiveBonus(Character p_targetCharacter)
{
if (State == EInteractiveObjectState.BARREL_EMPTY)
{
return;
}
String text = String.Empty;
switch (m_targetAttribute)
{
case EPotionTarget.MIGHT:
{
Attributes baseAttributes = p_targetCharacter.BaseAttributes;
baseAttributes.Might += m_value;
p_targetCharacter.BaseAttributes = baseAttributes;
text = "BARREL_DARK_RED_LIQUID_EFFECT_TEXT";
break;
}
case EPotionTarget.MAGIC:
{
Attributes baseAttributes = p_targetCharacter.BaseAttributes;
baseAttributes.Magic += m_value;
p_targetCharacter.BaseAttributes = baseAttributes;
text = "BARREL_DARK_BLUE_LIQUID_EFFECT_TEXT";
break;
}
case EPotionTarget.PERCEPTION:
{
Attributes baseAttributes = p_targetCharacter.BaseAttributes;
baseAttributes.Perception += m_value;
p_targetCharacter.BaseAttributes = baseAttributes;
text = "BARREL_WHITE_LIQUID_EFFECT_TEXT";
break;
}
case EPotionTarget.DESTINY:
{
Attributes baseAttributes = p_targetCharacter.BaseAttributes;
baseAttributes.Destiny += m_value;
p_targetCharacter.BaseAttributes = baseAttributes;
text = "BARREL_PURPLE_LIQUID_EFFECT_TEXT";
break;
}
case EPotionTarget.FIRE_RESISTANCE:
p_targetCharacter.BaseResistance.Add(EDamageType.FIRE, m_value);
text = "BARREL_PULSING_RED_LIQUID_EFFECT_TEXT";
break;
case EPotionTarget.WATER_RESISTANCE:
p_targetCharacter.BaseResistance.Add(EDamageType.WATER, m_value);
text = "BARREL_PULSING_BLUE_LIQUID_EFFECT_TEXT";
break;
case EPotionTarget.AIR_RESISTANCE:
p_targetCharacter.BaseResistance.Add(EDamageType.AIR, m_value);
text = "BARREL_PULSING_YELLOW_LIQUID_EFFECT_TEXT";
break;
case EPotionTarget.EARTH_RESISTANCE:
p_targetCharacter.BaseResistance.Add(EDamageType.EARTH, m_value);
text = "BARREL_PULSING_GREEN_LIQUID_EFFECT_TEXT";
break;
case EPotionTarget.LIGHT_RESISTANCE:
p_targetCharacter.BaseResistance.Add(EDamageType.LIGHT, m_value);
text = "BARREL_PULSING_WHITE_LIQUID_EFFECT_TEXT";
break;
case EPotionTarget.DARK_RESISTANCE:
p_targetCharacter.BaseResistance.Add(EDamageType.DARK, m_value);
text = "BARREL_PULSING_BLACK_LIQUID_EFFECT_TEXT";
break;
case EPotionTarget.PRIME_RESISTANCE:
p_targetCharacter.BaseResistance.Add(EDamageType.PRIMORDIAL, m_value);
text = "BARREL_PULSING_PURPLE_LIQUID_EFFECT_TEXT";
break;
}
p_targetCharacter.CalculateCurrentAttributes();
State = EInteractiveObjectState.BARREL_EMPTY;
BaseObjectEventArgs p_eventArgs = new BaseObjectEventArgs(this, Position);
LegacyLogic.Instance.EventManager.InvokeEvent(this, EEventType.BARREL_STATE_CHANGE, p_eventArgs);
if (p_targetCharacter.Gender == EGender.MALE)
{
text += "_M";
}
else
{
text += "_F";
}
String text2 = Localization.Instance.GetText(text, "[00FF00]" + p_targetCharacter.Name + "[-]", m_value);
GameMessageEventArgs p_eventArgs2 = new GameMessageEventArgs(text2, 0f, false);
LegacyLogic.Instance.EventManager.InvokeEvent(null, EEventType.BARREL_BONUS, p_eventArgs2);
MessageEventArgs p_args = new MessageEventArgs(text2, true);
LegacyLogic.Instance.ActionLog.PushEntry(p_args);
}
/// <summary>
/// Handles the FailedToUnderstand event of the bot control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="BuildABot.Core.MessageEventArgs"/> instance containing the event data.</param>
static void bot_FailedToUnderstand(object sender, MessageEventArgs e)
{
Console.WriteLine("Bot says: sorry but I didn't get you");
}
/// <summary>
/// Called when the <see cref="WebSocket"/> used in a session receives a message.
/// </summary>
/// <param name="e">
/// A <see cref="MessageEventArgs"/> that represents the event data passed to
/// a <see cref="WebSocket.OnMessage"/> event.
/// </param>
protected virtual void OnMessage(MessageEventArgs e)
{
}
public void FrameMessageHandler(MessageEventArgs message)
{
m_Frame = message.data.Deserialize <SerializableFrame>();
}
protected override void OnMessage(MessageEventArgs e)
{
SDPAnswerReceived(WebRtcSession, e.Data);
this.Close();
}
protected override void OnMessage(MessageEventArgs e)
{
base.OnMessage(e);
}
protected override void OnMessage(MessageEventArgs e)
{
base.OnMessage(e);
Pub.AddTalkTask(e.Data);
}
private async void BotOnMessageReceivedEx(object sender, MessageEventArgs messageEventArgs)
{
var message = messageEventArgs.Message;
if (message == null || message.Type != MessageType.Text)
{
return;
}
switch (message.Text.Split(' ').First())
{
// Send inline keyboard
case "/inline":
await SendInlineKeyboard(message);
break;
// send custom keyboard
case "/keyboard":
await SendReplyKeyboard(message);
break;
// send a photo
case "/photo":
await SendDocument(message);
break;
// request location or contact
case "/request":
await RequestContactAndLocation(message);
break;
default:
await Usage(message);
break;
}
// Send inline keyboard
// You can process responses in BotOnCallbackQueryReceived handler
async Task SendInlineKeyboard(Message message)
{
await Bot.SendChatActionAsync(message.Chat.Id, ChatAction.Typing);
// Simulate longer running task
await Task.Delay(500);
var inlineKeyboard = new InlineKeyboardMarkup(new[]
{
// first row
new []
{
InlineKeyboardButton.WithCallbackData("1.1", "11"),
InlineKeyboardButton.WithCallbackData("1.2", "12"),
},
// second row
new []
{
InlineKeyboardButton.WithCallbackData("2.1", "21"),
InlineKeyboardButton.WithCallbackData("2.2", "22"),
}
});
await Bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : "Choose",
replyMarkup : inlineKeyboard
);
}
async Task SendReplyKeyboard(Message message)
{
var replyKeyboardMarkup = new ReplyKeyboardMarkup(
new KeyboardButton[][]
{
new KeyboardButton[] { "5.1", "1.2" },
new KeyboardButton[] { "6.1", "2.2" },
},
resizeKeyboard: true
);
await Bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : "Choose",
replyMarkup : replyKeyboardMarkup
);
}
async Task SendDocument(Message message)
{
await Bot.SendChatActionAsync(message.Chat.Id, ChatAction.UploadPhoto);
const string filePath = @"Files/tux.png";
using var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
var fileName = filePath.Split(Path.DirectorySeparatorChar).Last();
await Bot.SendPhotoAsync(
chatId : message.Chat.Id,
photo : new InputOnlineFile(fileStream, fileName),
caption : "Nice Picture"
);
}
async Task RequestContactAndLocation(Message message)
{
var RequestReplyKeyboard = new ReplyKeyboardMarkup(new[]
{
KeyboardButton.WithRequestLocation("Location"),
KeyboardButton.WithRequestContact("Contact"),
});
await Bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : "Who or Where are you?",
replyMarkup : RequestReplyKeyboard
);
}
async Task Usage(Message message)
{
const string usage = "Usage:\n" +
"/inline - send inline keyboard\n" +
"/keyboard - send custom keyboard\n" +
"/photo - send a photo\n" +
"/request - request location or contact";
await Bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : usage,
replyMarkup : new ReplyKeyboardRemove()
);
}
}
private void WSSharpSocket_OnMessage(object sender, MessageEventArgs e)
{
OnMessageReceived?.Invoke(sender, new SockJs.MessageReceivedEventArgs(e.Data));
}
private void onMessage(object sender, MessageEventArgs e)
{
OnMessage(e);
}
/// <summary>
/// Handles MessageReceived events of all clients, evaluates each message, finds appropriate
/// service object and invokes appropriate method.
/// </summary>
/// <param name="sender">Source of event</param>
/// <param name="e">Event arguments</param>
private void Client_MessageReceived(object sender, MessageEventArgs e)
{
// Get RequestReplyMessenger object (sender of event) to get client
RequestReplyMessenger <IScsServerClient> requestReplyMessenger = (RequestReplyMessenger <IScsServerClient>)sender;
// Cast message to ScsRemoteInvokeMessage and check it
ScsRemoteInvokeMessage invokeMessage = e.Message as ScsRemoteInvokeMessage;
if (invokeMessage == null)
{
return;
}
try
{
// Get client object
IScsServiceClient client = _serviceClients[requestReplyMessenger.Messenger.ClientId];
if (client == null)
{
requestReplyMessenger.Messenger.Disconnect();
return;
}
// Get service object
ServiceObject serviceObject = _serviceObjects[invokeMessage.ServiceClassName];
if (serviceObject == null)
{
SendInvokeResponse(requestReplyMessenger, invokeMessage, null, new ScsRemoteException("There is no service with name '" + invokeMessage.ServiceClassName + "'"));
return;
}
// Invoke method
try
{
// Set client to service, so user service can get client in service method using
// CurrentClient property.
object returnValue;
serviceObject.Service.CurrentClient = client;
try
{
returnValue = serviceObject.InvokeMethod(invokeMessage.MethodName, invokeMessage.Parameters);
}
finally
{
// Set CurrentClient as null since method call completed
serviceObject.Service.CurrentClient = null;
}
// Send method invocation return value to the client
SendInvokeResponse(requestReplyMessenger, invokeMessage, returnValue, null);
}
catch (TargetInvocationException ex)
{
Exception innerEx = ex.InnerException;
if (innerEx != null)
{
SendInvokeResponse(requestReplyMessenger, invokeMessage, null, new ScsRemoteException(innerEx.Message + Environment.NewLine + "Service Version: " + serviceObject.ServiceAttribute.Version, innerEx));
}
}
catch (Exception ex)
{
SendInvokeResponse(requestReplyMessenger, invokeMessage, null, new ScsRemoteException(ex.Message + Environment.NewLine + "Service Version: " + serviceObject.ServiceAttribute.Version, ex));
}
}
catch (Exception ex)
{
SendInvokeResponse(requestReplyMessenger, invokeMessage, null, new ScsRemoteException("An error occured during remote service method call.", ex));
}
}
protected override void MessageLoop_SentMessage(object sender, MessageEventArgs e)
{
}
protected override void OnMessage(MessageEventArgs e) => Parent?.OnMessage(e, Context);
/// <summary>
/// Called when the <see cref="WebSocket"/> used in a session receives a message.
/// </summary>
/// <param name="e">
/// A <see cref="MessageEventArgs"/> that represents the event data passed to
/// a <see cref="WebSocket.OnMessage"/> event.
/// </param>
protected virtual void OnMessage(object sender, MessageEventArgs e)
{
}
public async Task CommandHandler_BuisnessRegistrationKorporativ(long chatid, string message, MessageEventArgs messageObject)
{
if (provider.userService == null)
{
await client.SendTextMessageAsync(chatid, "strange");
}
int currentStep = await provider.userService.GetCurrentActionStep(chatid);
UserDTO user = await provider.userService.FindById(chatid);
DronDTO dron = new DronDTO();
if (currentStep == 1)
{
user.FIO = message;
await provider.userService.Update(user);
await provider.userService.ChangeAction(chatid, "Corporate registration", ++currentStep);
await client.SendTextMessageAsync(chatid, "Your telephone number");
return;
}
if (currentStep == 2)
{
if (RegularExpression.IsTelephoneCorrect(message))
{
user.Phone = message;
user.BusinessPrivilage = 1;
await provider.userService.Update(user);
await provider.userService.ChangeAction(chatid, "NULL", 0);
await client.SendTextMessageAsync(chatid, "Registered", 0, false, false, 0, KeyboardHandler.Markup_BuisnessmanMenu());
await provider.managerPush.SendMessage(client, chatid);
return;
}
else
{
await client.SendTextMessageAsync(chatid, "Wrong telephone number");
}
}
}
private void GameChannel_TargetChangeTooFast(object sender, MessageEventArgs e)
{
connectionManager.MainChannel.AddMessage(new ChatMessage(Color.White, e.Message));
ClearGameJoinAttempt((Channel)sender);
}
protected override void OnMessage(MessageEventArgs e)
{
ProperMessage recmsg = JsonConvert.DeserializeObject <ProperMessage>(e.Data);
Console.WriteLine($"Message received: {e.Data}");
if (recmsg.messageType == MessageType.Join)
{
Console.WriteLine("Player joined");
Console.WriteLine($"Data: {recmsg.messageData}");
List <Player> _players = _game.getPlayers();
if (_players.Count < 2)
{
Player player = JsonConvert.DeserializeObject <Player>(recmsg.messageData);
player.sessionId = ID;
//_players.Add(player);
_game.AddPlayer(player);
Console.WriteLine(_game.getPlayers().Count);
Console.WriteLine(JsonConvert.SerializeObject(_game.getPlayers()));
ProperMessage response = new ProperMessage
{
messageType = MessageType.JoinAccept,
messageData = JsonConvert.SerializeObject(player)
};
SendTest(JsonConvert.SerializeObject(response));
//response = new ProperMessage { messageType = MessageType.OpponentInfo, messageData = JsonConvert.SerializeObject(_players[0])};
//Send(JsonConvert.SerializeObject(response));
if (_players.Count == 2)
{
//response = new ProperMessage { messageType = MessageType.OpponentInfo, messageData = JsonConvert.SerializeObject(player)};
//Sessions.SendTo(JsonConvert.SerializeObject(response), _players[0].sessionId);
}
}
else
{
ProperMessage response = new ProperMessage
{
messageType = MessageType.JoinDeny, messageData = null
};
SendTest(JsonConvert.SerializeObject(response));
}
}
if (recmsg.messageType == MessageType.RoundPlay)
{
List <Player> _players = _game.getPlayers();
Player player = JsonConvert.DeserializeObject <Player>(recmsg.messageData);
if (VerifyRoundPlay(player))
{
player.lockedIn = true;
var thisPlayerIndex = _players.IndexOf(_players.Find(p => p.sessionId == ID));
Console.WriteLine($"Index: {thisPlayerIndex}");
player.sessionId = ID;
_players[thisPlayerIndex] = player;
Console.WriteLine("Accepted Player Move");
Console.WriteLine($"Data: {e.Data}");
ProperMessage response = new ProperMessage {
messageType = MessageType.RoundPlayAccept, messageData = null
};
SendTest(JsonConvert.SerializeObject(response));
}
else
{
Console.WriteLine("Denied Player Move");
Console.WriteLine($"Data: {e.Data}");
ProperMessage response = new ProperMessage {
messageType = MessageType.RoundPlayDeny, messageData = null
};
SendTest(JsonConvert.SerializeObject(response));
}
if (_players.Count == 2 && (_players[0].lockedIn && _players[1].lockedIn))
{
var gameRound = DetermineRound(_players[0], _players[1]);
Console.WriteLine(JsonConvert.SerializeObject(gameRound));
ProperMessage response = new ProperMessage
{
messageType = MessageType.RoundResult, messageData = JsonConvert.SerializeObject(gameRound)
};
Sessions.Broadcast(JsonConvert.SerializeObject(response));
ResetRound();
}
}
}
private void OnMessageReceived(object sender, MessageEventArgs eventArgs)
{
var message = eventArgs.Message;
MessageHandler(message);
}
protected override void OnMessage(MessageEventArgs e)
{
Sessions.Broadcast(String.Format("{0}: {1}", _name, e.Data));
}
protected override void OnMessage(MessageEventArgs e)
{
emu.ManageMessage(e.RawData);
}
private static async void BotOnMessageRecieved(object sender, MessageEventArgs e)
{
var message = e.Message;
if (message == null || message.Type != MessageType.Text)
{
return;
}
string name = $"{message.From.FirstName} {message.From.LastName}";
Console.WriteLine(name + ": " + message.Text);
//Program p = new Program();
if (IsButton)
{
if (message.From.Id == 363450022 || message.From.Id == 806879827 || message.From.Id == 250899062)
{
List <int> ID = new List <int>();
string response;
using (StreamReader stream = new StreamReader("DataUsers.json"))
{
while (!String.IsNullOrEmpty(response = stream.ReadLine()))
{
Users Response = JsonConvert.DeserializeObject <Users>(response);
//uSers.Add(Response);
ID.Add(Response.ID);
}
}
foreach (var usr in ID)
{
//string t = e.Message;
await bot.SendTextMessageAsync(usr, message.Text, ParseMode.Html, false, false, 0);
}
IsButton = false;
}
}
if (isQuestion)
{
int[] Admins = new int[3];
Admins[0] = 363450022;
Admins[1] = 806879827;
Admins[2] = 250899062;
for (int i = 0; i < Admins.GetLength(0); i++)
{
await bot.SendTextMessageAsync(Admins[i], $"" +
$" \n Вопрос : {message.Text} " +
$" \n id: {message.From.Id}" +
$" \n Username: {message.From.Username}" +
$" \n Имя: {message.From.FirstName}" +
$" \n Время(UTC): {message.Date.TimeOfDay}" +
$" \n Дата: {message.Date} ", ParseMode.Html, false, false, 0);
}
isQuestion = false;
}
switch (message.Text) // Команды для бота
{
case "/start":
List <int> ID = new List <int>();
string response;
using (StreamReader stream = new StreamReader("DataUsers.json"))
{
while (!String.IsNullOrEmpty(response = stream.ReadLine()))
{
Users Response = JsonConvert.DeserializeObject <Users>(response);
ID.Add(Response.ID);
}
}
var sticker = new InputOnlineFile("CAACAgIAAxkBAALwi2BE04ZTyadk2ufx3khKlil1K7RjAAJ0AAM7YCQUs8te1W3kR_QeBA");
await bot.SendStickerAsync(message.Chat.Id, sticker);
string text = "\U0001F525 Добро пожаловать! \U0001F525" +
"\n" +
"\n \U0001F527 Спасибо, что подключили бота! \U0001F527" +
"\n " +
"\n \U0001F381 Лови кнопочки! \U0001F381";
ReplyKeyboardMarkup keyboard = new ReplyKeyboardMarkup
{
Keyboard = new[]
{
new[]
{
new KeyboardButton("\U0001F4CB FAQ \U0001F4AC"),
new KeyboardButton(" Календарь событий \U0001F4C5 ")
},
new []
{
new KeyboardButton("\U0001F4BB Кафедры \U0001F393"),
new KeyboardButton("Администрация \U0001F5C4")
},
new[]
{
new KeyboardButton("Если не нашёл(а) свой вопрос в FAQ"),
new KeyboardButton("Справка \U0001F4CC")
},
}
};
await bot.SendTextMessageAsync(message.From.Id, text, ParseMode.Html, false, false, 0, keyboard);
if (!ID.Contains(message.From.Id))
{
Users user = new Users(message.From.FirstName, message.From.Id);
var json = JsonConvert.SerializeObject(user);
using (StreamWriter stream = new StreamWriter("DataUsers.json", true))
{
stream.WriteLine(json);
}
}
else
{
}
break;
case "\U0001F4CB FAQ \U0001F4AC":
var inlineKeyboard = new InlineKeyboardMarkup(new[]
{
new []
{
InlineKeyboardButton.WithCallbackData("Заселение", "dormitory"), // готово
InlineKeyboardButton.WithCallbackData("Как добраться ?", "howToGetThere") // готово
},
new[]
{
InlineKeyboardButton.WithCallbackData("Документы", "documents"), // готово
InlineKeyboardButton.WithCallbackData("Деканат", "dean office") //готово
},
new[]
{
InlineKeyboardButton.WithCallbackData("Расписание", "schedule"), //готово
InlineKeyboardButton.WithCallbackData("Где покушать ?", "whereEat")
},
new []
{
InlineKeyboardButton.WithCallbackData("Студенческий совет", "studentSov"), //готово
InlineKeyboardButton.WithCallbackData("Устройство двойки", "two") //готово
}
});
await bot.SendTextMessageAsync(message.From.Id, $"Выбери интересующий тебя вопрос : ", replyMarkup : inlineKeyboard);
break;
case "Справка \U0001F4CC":
var Keyboard_Note = new InlineKeyboardMarkup(new[] {
new []
{
InlineKeyboardButton.WithUrl("Автор", "https://t.me/ar_gin"),
},
new[]
{
InlineKeyboardButton.WithUrl("Автор", "https://t.me/auter1"),
},
new []
{
InlineKeyboardButton.WithUrl("Автор", "https://t.me/ROwaGO")
},
new []
{
InlineKeyboardButton.WithCallbackData("О функциях бота", "ab")
}
});
await bot.SendTextMessageAsync(message.From.Id, $"Справка : ", replyMarkup : Keyboard_Note);
break;
case "Календарь событий \U0001F4C5":
string mes = "Ой, пока запланированных событий нет \U0001F61E";
await bot.SendTextMessageAsync(message.From.Id, mes, ParseMode.Html, false, false, 0);
break;
case "\U0001F4BB Кафедры \U0001F393":
var Keyboard_Department = new InlineKeyboardMarkup(new[] {
new []
{
InlineKeyboardButton.WithUrl("Кафедра прикладной математики", "https://kpfu.ru/computing-technology/struktura/kafedry/kafedra-prikladnoj-matematiki"),
},
new[]
{
InlineKeyboardButton.WithUrl("Кафедра вычислительной математики", "https://kpfu.ru/computing-technology/struktura/kafedry/kafedra-vychislitelnoj-matematiki"),
},
new []
{
InlineKeyboardButton.WithUrl("Кафедра теоретической кибернетики", "https://kpfu.ru/computing-technology/struktura/kafedry/kafedra-teoreticheskoj-kibernetiki")
},
new []
{
InlineKeyboardButton.WithUrl("Кафедра анализа данных и исследования операций", "https://kpfu.ru/computing-technology/struktura/kafedry/kafedra-analiza-dannyh-i-issledovaniya-operacij")
},
new []
{
InlineKeyboardButton.WithUrl("Кафедра технологий программирования", "https://kpfu.ru/computing-technology/struktura/kafedry/kafedra-tehnologij-programmirovaniya")
},
new []
{
InlineKeyboardButton.WithUrl("Кафедра системного анализа и информационных технологий", "https://kpfu.ru/computing-technology/struktura/kafedry/kafedra-sistemnogo-analiza-i-informacionnyh")
},
new []
{
InlineKeyboardButton.WithUrl("Кафедра информационных систем", "https://kpfu.ru/computing-technology/struktura/kafedry/kafedra-informacionnyh-sistem")
},
});
await bot.SendTextMessageAsync(message.From.Id, $"Выбери кафедру, о которой ты хочешь узнать : ", replyMarkup : Keyboard_Department);
break;
case "Администрация \U0001F5C4":
var AdminKeyboard = new InlineKeyboardMarkup(new[] {
new []
{
InlineKeyboardButton.WithCallbackData("Директорат", "AdminDir")
},
new[]
{
InlineKeyboardButton.WithUrl("Ученый совет", "https://kpfu.ru/computing-technology/struktura/uchenyj-sovet")
},
new[]
{
InlineKeyboardButton.WithUrl("Сотрудники", "https://kpfu.ru/computing-technology/sotrudniki")
}
});
await bot.SendTextMessageAsync(message.From.Id, $"Информация об ИВМИИТ:", replyMarkup : AdminKeyboard);
break;
case "/MessageToEveryone":
string m = "Администратор, мы рады видеть тебя!" +
"Напиши сообщение, которое мы отправим всем!";
IsButton = true;
await bot.SendTextMessageAsync(message.From.Id, m, ParseMode.Html, false, false, 0);
break;
case "Если не нашёл(а) свой вопрос в FAQ":
string q = "Жаль, что ты не смог(а) найти ответ" +
" на свой вопрос в разделе FAQ. \U0001F61E\n" +
"Напиши вопрос, который ты хочешь задать Админу : ";
isQuestion = true;
await bot.SendTextMessageAsync(message.From.Id, q, ParseMode.Html, false, false, 0);
break;
}
}
private void OnMessage(object sender, MessageEventArgs messageEventArgs)
{
Debug.Log(messageEventArgs.Data);
tempMessageString = messageEventArgs.Data;
}
public void PlaneRemovedMessageHandler(MessageEventArgs message)
{
OnPlaneRemoved(message.data.Deserialize <SerializableBoundedPlane>());
}
/// <summary>
/// Event argument for item notification events.
/// </summary>
/// <param name="NodeName">Node name.</param>
/// <param name="SubscriptionId">Subscription ID</param>
/// <param name="e">Message event arguments</param>
public NodeNotificationEventArgs(string NodeName, string SubscriptionId, MessageEventArgs e)
: base(e)
{
this.nodeName = NodeName;
this.subscriptionId = SubscriptionId;
}
public abstract void CallbackKeyboard(TelegramBotClient telegramBotClient, MessageEventArgs messageEventArgs);
public void LightEstimateMessageHandler(MessageEventArgs message)
{
m_LightEstimate = message.data.Deserialize <SerializableLightEstimate>();
}
public void RecieveMessage(object sender, MessageEventArgs e)
{
IMessage = e.Message;
}
public abstract void Response(TelegramBotClient telegramBotClient, MessageEventArgs messageEventArgs);
