public void ReceiveStartMessage(object?sender, DataEventArgs <Message> eventArgs)
{
if (activeMessage != null &&
!config.SplitClass.ReplacesTeachers.Contains(activeMessage.Teacher))
{
logger.Warn("Received new message while last one isn't done");
logger.Debug("Last message: {0}", activeMessage);
logger.Debug("New message: {0}", eventArgs.Data);
logger.Debug("Changing to new message.");
}
if (eventArgs.Data != lastMessage)
{
activeMessage = eventArgs.Data;
}
var bot = sender as ClassroomBot;
if (bot == null)
{
throw new NullReferenceException("Null classroom bot");
}
string link = bot.GetClassroomMeetLink();
if (link != ActiveMeetLink)
{
ActiveMeetLink = link;
logger.Debug("New meet link");
}
}
public override async Task <WebSocketReceiveResult> ReceiveAsync(ArraySegment <byte> output, CancellationToken cancellationToken)
{
Message?input = this.readingInProgress;
if (this.readingInProgress == null)
{
input = this.readingInProgress = await this.ReadQueue.DequeueAsync(cancellationToken);
}
int bytesToCopy = Math.Min(input !.Buffer.Length, output.Count);
input.Buffer.Slice(0, bytesToCopy).CopyTo(output.Array.AsMemory(output.Offset, output.Count));
bool finishedMessage = bytesToCopy == input.Buffer.Length;
if (finishedMessage)
{
this.readingInProgress = null;
}
else
{
input.Buffer = input.Buffer.Slice(bytesToCopy);
}
WebSocketReceiveResult result = new WebSocketReceiveResult(
bytesToCopy,
WebSocketMessageType.Text,
finishedMessage,
bytesToCopy == 0 ? (WebSocketCloseStatus?)WebSocketCloseStatus.Empty : null,
bytesToCopy == 0 ? "empty" : null);
return(result);
}
public ActionResult UserFodmap(Message?message)
{
ViewBag.StatusMessage =
message == Message.AddFodmapSuccess ? "Successfully added new high FODMAP ingredient"
: message == Message.FodmapExists ? "Ingredient already exists in database"
: message == Message.AddFodmapFailure ? "Failed to add new entry to database"
: "";
List <HighRiskLabelledIngredient> eligibleIngredientList = new List <HighRiskLabelledIngredient>();
List <int> highRiskList = db.UserIngredients.Where(u => u.Label == "High-Risk").Select(u => u.LabelledIngredientID).Distinct().ToList();
foreach (int ingredient in highRiskList)
{
LabelledIngredient labelIng = db.LabelledIngredients.Where(l => l.ID == ingredient).FirstOrDefault();
int count = db.UserIngredients.Where(u => u.LabelledIngredientID == ingredient && u.Label == "High-Risk").Count();
bool ingredentExists = db.FODMAPIngredients.FirstOrDefault(x => x.Name.Contains(labelIng.Name)) != null ||
db.FODMAPIngredients.FirstOrDefault(x => x.Aliases.Contains(labelIng.Name)) != null;
if (count > 9 && !ingredentExists)
{
HighRiskLabelledIngredient newIngredient = new HighRiskLabelledIngredient(labelIng, count);
eligibleIngredientList.Add(newIngredient);
}
}
eligibleIngredientList = eligibleIngredientList.OrderByDescending(o => o.countOfLabelOccurences).ToList();
return(View(eligibleIngredientList));
}
/// <summary></summary>
public static void CheckLLRPResponse(
Message?message,
MSG_ERROR_MESSAGE?error)
{
if (message == null && error == null)
{
throw new Exception("timeout");
}
PARAM_LLRPStatus?llrpStatus = null;
// message を優先
llrpStatus = (PARAM_LLRPStatus?)message?
.GetType()
.GetField(name: "LLRPStatus")?
.GetValue(message);
if (llrpStatus == null && error != null)
{
llrpStatus = error.LLRPStatus;
}
if (llrpStatus == null)
{
throw new InvalidOperationException();
}
if (llrpStatus.StatusCode != ENUM_StatusCode.M_Success)
{
throw new LLRPException(
llrpStatus.StatusCode,
llrpStatus.ErrorDescription);
}
}
public ActionResult Remove(int?id)
{
if (id == null || id <= 0)
{
return(BadRequest(new Msg {
Result = "Error", Message = "Remove: id invalid or null."
}));
}
Message?message = _dbContext.Messages.Find(id);
if (message == null)
{
return(BadRequest(new Msg {
Result = "Error", Message = "Remove: id invalid or null."
}));
}
_dbContext.Messages.Remove(message);
int numChanges = _dbContext.SaveChanges();
return(Ok(new Msg {
Result = "Success", Message = $"{numChanges} record(s) removed."
}));
}
public ActionResult Update([FromBody] Message message)
{
if (message == null)
{
return(BadRequest(new Msg {
Result = "Error", Message = "Update: null message."
}));
}
Message?dbMessage = _dbContext.Messages.Find(message.Id);
if (dbMessage == null)
{
return(BadRequest(new Msg {
Result = "Error", Message = "Update: invalid id"
}));
}
dbMessage.Copy(message);
if (ModelState.IsValid)
{
int numChanges = _dbContext.SaveChanges();
return(Ok(new Msg {
Result = "Success", Message = $"{numChanges} record(s) updated."
}));
}
return(BadRequest(new Msg {
Result = "Error", Message = "Update: ModelState invalid."
}));
}
public static void CheckError(Message?msg, MSG_ERROR_MESSAGE?msgErr)
{
if (msg == null && msgErr == null)
{
throw new LLRPTimeoutException();
}
PARAM_LLRPStatus?status = (PARAM_LLRPStatus?)msg?.GetType()
.GetField(name: "LLRPStatus")
.GetValue(msg);
if (msgErr != null)
{
status = msgErr.LLRPStatus;
}
if (status == null)
{
throw new InvalidOperationException();
}
if (status.StatusCode != ENUM_StatusCode.M_Success)
{
throw new LLRPException(status.StatusCode, status.ErrorDescription);
}
}
public async Task <ActionResult> Index(Message?message)
{
ViewBag.StatusMessage = MessageGenerator(message);
var news = await _newsPageLogic.GetAllNews();
return(View(news));
}
public async IAsyncEnumerable <MessageResponse> HandleMessageAsync(Message message, NextHandler nextHandler)
{
Message?respondedMessage = null;
await using var enumerator = nextHandler().GetAsyncEnumerator();
while (true)
{
MessageResponse response;
try
{
if (!await enumerator.MoveNextAsync())
{
break;
}
response = enumerator.Current;
}
catch (HandlerException e)
{
response = e.Message.ToString();
}
await _client.SendChatActionAsync(message.Chat, ChatAction.Typing);
if (respondedMessage is null || response.ForceNewMessage)
{
respondedMessage = await _client.SendTextMessageAsync(message.Chat, response.ToString(),
parseMode : response.ParseMode,
disableWebPagePreview : true,
replyToMessageId : message.Chat.Type != ChatType.Private?message.MessageId : 0,
replyMarkup : GetReplyMarkup(response.ExtraMarkup));
}
/// <summary></summary>
protected void CheckLLRPError(
Message?msg = null,
MSG_ERROR_MESSAGE?error = null)
{
if (msg == null && error == null)
{
throw new NullReferenceException();
}
PARAM_LLRPStatus?status = error?.LLRPStatus;
if (status == null)
{
status = msg?.GetType().GetField("LLRPStatus")?.GetValue(msg) as PARAM_LLRPStatus;
}
if (status == null)
{
throw new NullReferenceException();
}
if (status.StatusCode != ENUM_StatusCode.M_Success)
{
throw new Exception($"{status.ErrorDescription ?? string.Empty}");
}
}
public Message?ReadLine()
{
Message?message = null;
try
{
char direction = ReadChar();
if (direction != '<' && direction != '>')
{
throw new Exception($"Invalid direction prefix, expected '<' or '>', received '{direction}'");
}
message = Read();
message.Incoming = direction == '<';
for (; ;)
{
char c = PeekChar();
if (c == '\r' || c == '\n')
{
ReadChar();
}
else
{
break;
}
}
}
catch (EndOfStreamException)
{
}
return(message);
}
public override Task SendAsync(ArraySegment <byte> input, WebSocketMessageType messageType, bool endOfMessage, CancellationToken cancellationToken)
{
if (this.writingInProgress == null)
{
var bufferCopy = new byte[input.Count];
Buffer.BlockCopy(input.Array !, input.Offset, bufferCopy, 0, input.Count);
this.writingInProgress = new Message {
Buffer = new ArraySegment <byte>(bufferCopy)
};
}
else
{
byte[] bufferCopy = this.writingInProgress.Buffer.Array !;
Array.Resize(ref bufferCopy, bufferCopy.Length + input.Count);
Buffer.BlockCopy(input.Array !, input.Offset, bufferCopy, this.writingInProgress.Buffer.Count, input.Count);
this.writingInProgress.Buffer = new ArraySegment <byte>(bufferCopy);
}
if (endOfMessage)
{
this.WrittenQueue.Enqueue(this.writingInProgress);
this.writingInProgress = null;
}
return(Task.CompletedTask);
}
public static Message Get(Message Original, Message?Override, string Key,
string SenderName, string ReceiverName, string AnotherPlayerName = null)
{
Message message = Get(Original, Override);
bool hasSender = !(SenderName is null);
string msg = (hasSender
? message.MessageWithSenderName
: message.MessageWithoutSenderName);
if (msg is null)
{
return(message);
}
if (Key != null)
{
msg = msg.Replace("{KEY}", Key);
}
if (ReceiverName != null)
{
msg = msg.Replace("{RECEIVER}", ReceiverName);
}
if (hasSender)
{
msg = msg.Replace("{SENDER}", SenderName);
}
if (AnotherPlayerName != null)
{
msg = msg.Replace("{ANOTHERPLAYER}", AnotherPlayerName);
}
message.ResultingMessage = msg;
return(message);
}
public PlayerCheckin(CheckinLister lister, Message checkinEvent,
Predicate allCheckedInPredicate = null,
EventPredicate checkinPredicate = null,
Callback onCheckin = null,
Callback onReset = null,
Message?checkoutEvent = null)
{
this.lister = lister;
if (allCheckedInPredicate != null)
{
this.allCheckedInPredicate = allCheckedInPredicate;
}
if (checkinPredicate != null)
{
this.checkinPredicate = checkinPredicate;
}
if (onCheckin != null)
{
this.onCheckin = onCheckin;
}
if (onReset != null)
{
this.onReset = onReset;
}
GameManager.instance.notificationManager.CallOnMessageWithSender(checkinEvent, Checkin);
if (checkoutEvent.HasValue)
{
GameManager.instance.notificationManager.CallOnMessageWithSender(checkoutEvent.Value, Checkout);
}
}
public static PlayerCheckin TextCountCheckin(
CheckinLister lister, Message checkinEvent,
Text textBox, Predicate allCheckedInPredicate = null,
EventPredicate checkinPredicate = null,
Callback onCheckin = null,
Callback onReset = null,
Message?checkoutEvent = null)
{
PlayerCheckin result = new PlayerCheckin(
lister, checkinEvent, allCheckedInPredicate,
checkinPredicate, checkoutEvent: checkoutEvent);
Callback modifyText = () =>
{
textBox.text = string.Format("{0}/{1}", result.NumberCheckedIn(), lister().Count);
};
onCheckin = onCheckin ?? delegate { };
onCheckin += modifyText;
onReset = onReset ?? delegate { };
onReset += modifyText;
result.onCheckin = onCheckin;
result.onReset = onReset;
return(result);
}
protected void UpdateLoop()
{
while (!abort)
{
EstablishConnectionLoop();
try {
while (!abort)
{
Message?message = ReadMessage();
if (message != null)
{
ReadData((Message)message);
waiting = false;
}
Thread.Sleep(timeout);
if (!NeedsToWait())
{
pendingWrite?.Invoke();
pendingWrite = null;
}
}
}
//For this to work all writes must occur in this thread
catch (NeedsResetException e) {
ForceReset(e);
}
}
}
public void showModal(string modalText, string okText, UnityAction okEvent, bool prior = false)
{
Message message = new Message(modalText, okText, okEvent);
if (GameController.waitModal == true && !displayMessage.Equals(message))
{
if (!messages.Contains(message) && !prior)
{
messages.Enqueue(message);
}
if (!messages.Contains(message) && prior)
{
addToFrontOfQueue(message);
GameController.waitModal = false;
}
return;
}
GameController.waitModal = true;
displayMessage = message;
text.SetText(modalText);
noButtonText.SetText(okText);
noButton.GetComponent <Button>().onClick.RemoveAllListeners();
noButton.GetComponent <Button>().onClick.AddListener(closeModal);
noButton.GetComponent <Button>().onClick.AddListener(okEvent);
yesButton.SetActive(false);
noButton.SetActive(true);
modal.SetActive(true);
iTween.MoveFrom(modal, modal.transform.position + new Vector3(0, 200, 0), 1);
iTween.FadeFrom(modal, 0, 0.2f);
}
public override Task SendAsync(ArraySegment <byte> input, WebSocketMessageType messageType, bool endOfMessage, CancellationToken cancellationToken)
{
if (this.writingInProgress == null)
{
byte[] bufferCopy = new byte[input.Count];
Buffer.BlockCopy(input.Array !, input.Offset, bufferCopy, 0, input.Count);
this.writingInProgress = new Message {
Buffer = new ArraySegment <byte>(bufferCopy)
};
}
else
{
Memory <byte> memory = new byte[this.writingInProgress.Buffer.Length + input.Count];
this.writingInProgress.Buffer.CopyTo(memory);
input.Array.CopyTo(memory.Slice(this.writingInProgress.Buffer.Length));
this.writingInProgress.Buffer = memory;
}
if (endOfMessage)
{
this.WrittenQueue.Enqueue(this.writingInProgress);
this.writingInProgress = null;
}
return(Task.FromResult(0));
}
public Message(
Snowflake id,
MessageType type,
User author,
DateTimeOffset timestamp,
DateTimeOffset?editedTimestamp,
DateTimeOffset?callEndedTimestamp,
bool isPinned,
string content,
IReadOnlyList <Attachment> attachments,
IReadOnlyList <Embed> embeds,
IReadOnlyList <Reaction> reactions,
IReadOnlyList <User> mentionedUsers,
MessageReference?messageReference,
Message?referencedMessage)
{
Id = id;
Type = type;
Author = author;
Timestamp = timestamp;
EditedTimestamp = editedTimestamp;
CallEndedTimestamp = callEndedTimestamp;
IsPinned = isPinned;
Content = content;
Attachments = attachments;
Embeds = embeds;
Reactions = reactions;
MentionedUsers = mentionedUsers;
Reference = messageReference;
ReferencedMessage = referencedMessage;
}
public override void UpdateAfterSimulation()
{
if (!MySandboxGame.IsGameReady)
{
return;
}
if (Game.IsDedicated)
{
return;
}
if (_currentDisplayTime <= 0 && MessageQueue.Count > 0)
{
_currentDisplayTime = 200;
_currentMessage = MessageQueue.Dequeue();
MyAudio.Static.PlaySound(MySoundPair.GetCueId(_currentMessage.Value.Sound));
}
else if (_currentDisplayTime > 0)
{
_currentDisplayTime--;
if (_currentDisplayTime <= 0)
{
_currentMessage = null;
}
}
}
public Message GetMessage(MessageType Type, object Sender, object Receiver, string Key)
{
if (Receiver is null)
{
throw new ArgumentNullException(nameof(Receiver));
}
if (Key is null)
{
throw new ArgumentNullException(nameof(Key));
}
Message?messageOverride = null;
if (OtherFormatOverrides.TryGetValue(Type, out Message msg))
{
messageOverride = msg;
}
string senderName = ((Sender == null || Sender.Equals(RequestsManager.EmptySender))
? null
: RequestsManager.GetPlayerNameFunc?.Invoke(Sender));
string receiverName = RequestsManager.GetPlayerNameFunc?.Invoke(Receiver);
return(Message.Get(GetDefaultOtherMessageFormat(Type),
messageOverride, Key, senderName, receiverName, null));
}
public async Task OnMessageReceived(Message?message)
{
_logger.LogInformation(MessageLogMsg, message?.Chat.Id, message?.From?.Username, message?.Text);
if (message?.Text is null || message.Type != MessageType.Text)
{
return;
}
var command = new CommandParser(message.Text).Parse();
var chatId = message.Chat.Id;
string username;
if (message.From is null)
{
username = "******";
}
else
{
username = string.IsNullOrEmpty(message.From.Username)
? $"{message.From.FirstName} {message.From.LastName}"
: message.From.Username;
}
IAction cmd;
if (_botService.IsPrivateMode && chatId != _botService.PrivateChetId)
{
cmd = new NoCommand();
}
else
{
cmd = command.Name switch
{
"echo" => new Echo(_botService, chatId, command.Arguments),
"hey" => new Hey(_botService, chatId),
"ex" => new CurrencyExchange(_botService, chatId, command.Arguments, _configuration["apiForexKey"]),
"ud" => new UrbanDictionary(_botService, _clientFactory, chatId, command.Arguments),
"go" => new DuckDuckGo(_botService, _clientFactory, chatId, command.Arguments),
"dice" => new RollDice(_botService, chatId, command.Arguments, username),
"l" => new GoogleMaps(_botService, _clientFactory, chatId, command.Arguments,
_configuration["googleApiKey"]),
"weekday" => new WeekDay(_botService, chatId),
"timein" => new TimeInPlace(_botService, _clientFactory, chatId, command.Arguments,
_configuration["googleApiKey"]),
"ball" => new MagicBall(_botService, chatId, command.Arguments),
"weather" => new Weather(_botService, _clientFactory, chatId, command.Arguments),
_ => new NoCommand()
}
};
try
{
await cmd.HandleAsync();
}
catch (Exception e)
{
_logger.LogError("Cannot execute command, error {Message}", e.Message);
}
}
/// <inheritdoc />
public override async Task <int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
Requires.NotNull(buffer, nameof(buffer));
Requires.Range(offset >= 0, nameof(offset));
Requires.Range(count >= 0, nameof(count));
Requires.Range(offset + count <= buffer.Length, nameof(count));
cancellationToken.ThrowIfCancellationRequested();
Message?message = null;
while (message is null)
{
Task?waitTask = null;
lock (this.readQueue)
{
if (this.readQueue.Count > 0)
{
message = this.readQueue[0];
}
else
{
waitTask = this.enqueuedSource.Task;
}
}
if (waitTask is not null)
{
if (cancellationToken.CanBeCanceled)
{
// Arrange to wake up when a new message is posted, or when the caller's CancellationToken is canceled.
var wakeUpEarly = new TaskCompletionSource <object?>();
using (cancellationToken.Register(state => ((TaskCompletionSource <object?>)state !).SetResult(null), wakeUpEarly, false))
{
await Task.WhenAny(waitTask, wakeUpEarly.Task).ConfigureAwait(false);
}
cancellationToken.ThrowIfCancellationRequested();
}
else
{
// The caller didn't pass in a CancellationToken. So just do the cheapest thing.
await waitTask.ConfigureAwait(false);
}
}
}
int copiedBytes = message.Consume(buffer, offset, count);
if (message.IsConsumed)
{
lock (this.readQueue)
{
Assumes.True(this.readQueue[0] == message); // if this fails, the caller is calling Read[Async] in a non-sequential way.
this.readQueue.RemoveAt(0);
}
}
return(copiedBytes);
}
private Task RunAsync([NotNull] MessageDeletePayload payload, [CanBeNull] Message?message)
{
Client.Logger.Information(
"Received Deleted Message [{Id}] with content '{Content}'.", payload.Id,
message?.Content ?? "Unknown.");
return(Task.CompletedTask);
}
public async Task MessageHandlerReturnsExceptionWhenNullServiceBusMessageSupplied()
{
// arrange
Message?serviceBusMessage = null;
// act
await Assert.ThrowsAsync <ArgumentNullException>(async() => await MessageHandler.Run(serviceBusMessage, messageProcessor, messagePropertiesService, logger).ConfigureAwait(false)).ConfigureAwait(false);
}
private string MessageGenerator(Message?message)
{
return(message == Message.AddVacancySuccess ? ""
: message == Message.EditVacancySuccess ? ""
: message == Message.RemoveVacancySuccess ? ""
: message == Message.Error ? ""
: null);
}
private string MessageGenerator(Message?message)
{
return(message == Message.createSuccess ? "Новость успешно создана"
: message == Message.editSuccess ? "Новость обновлена"
: message == Message.removeSuccess ? "Новость успешно удалена"
: message == Message.error ? "Произошла ошибка"
: null);
}
public static void Post(string text, User user, Channel channel, Message?parentMessage = null)
{
MessageDAO.Post(text, user.Id, channel.Id, parentMessage?.Id);
onMessagesFetchedAsSubject.OnNext(Get(channel));
onMessagePostedAsSubject.OnNext(Unit.Default);
}
public void RaiseMouseDownIfNeeded()
{
if (postponedMessage != null)
{
// Activate();
OnNCMouseDown((Message)postponedMessage);
postponedMessage = null;
}
}
public ActionResult AddFodmap(Message?message)
{
ViewBag.StatusMessage =
message == Message.AddFodmapSuccess ? "Successfully added new high FODMAP ingredient"
: message == Message.FodmapExists ? "Ingredient already exists in database"
: message == Message.AddFodmapFailure ? "Failed to add new entry to database"
: "";
return(View());
}
