private static async Task DiscordHeartbeated(DiscordClient client, HeartbeatEventArgs _)
{
if (_lavalinkNodeConnection?.IsConnected == true)
{
return;
}
if (_socketAutoReconnect && _wasConnectedToLavalink)
{
return;
}
_lavalinkNodeConnection = await _lavalink.ConnectAsync(_lavalinkConfiguration);
if (!_wasConnectedToLavalink)
{
client.LogMessage("Successfully connected to Lavalink.");
}
else
{
client.LogMessage("The connection to Lavalink has been re-established.");
}
if (!_wasConnectedToLavalink)
{
_wasConnectedToLavalink = true;
}
}
internal static async Task BotClient_Heartbeated(HeartbeatEventArgs e)
{
if (Program.Settings.FunAllowed)
{
if (DateTimeOffset.UtcNow.UtcTicks >= NextTimeChange.UtcTicks)
{ // If it's change time, let's change.
FunMessage newStatus = funMessages[ran.Next(0, funMessages.Count - 1)];
try
{
await e.Client.UpdateStatusAsync
(
new DiscordActivity($"{newStatus.Emoji} {newStatus.Message}", ActivityType.Playing),
UserStatus.Online
);
}
catch { }
// Update next time.
TimeSpan nextUpdate =
TimeSpan.FromMilliseconds(newStatus.MinTime.TotalMilliseconds + (ran.NextDouble() * newStatus.MaxTime.TotalMilliseconds));
NextTimeChange = NextTimeChange.Add(nextUpdate);
}
}
}
private void LoadTestHeartBeat(object sender, HeartbeatEventArgs e)
{
if (!e.IsWarmupComplete)
return;
loadTest.Scenarios[0].CurrentLoad = userLoad;
}
private async Task OnHeartbeated(HeartbeatEventArgs e)
{
if (Heartbeated != null)
{
await Heartbeated(e);
}
}
public static Task HeartBeatRecieved(HeartbeatEventArgs e)
{
if (HeartBeatLogs)
{
Beautify($"Heartbeat recieved: {e.Ping}ms");
}
return(Task.CompletedTask);
}
internal static Task ExportHeartbeatLog(DiscordClient _, HeartbeatEventArgs HeartbeatObjects)
{
string Ping = HeartbeatObjects.Ping.ToString();
Log.Info($"Ping: {Ping}ms");
return(Task.CompletedTask);
}
async Task OnHeartbeat(HeartbeatEventArgs e)
{
try
{
await this.ValidateNodeConnectionAsync();
}
catch (Exception ex)
{
this._log.Error(ex, "Lavalink connection failed.");
}
}
private async Task DiscordHeartbeated(DiscordClient sender, HeartbeatEventArgs e)
{
Log(this, new LogEventArgs {
Type = LogType.Log,
Message = $"Heartbeat triggered: handled = {e.Handled}, ping = {e.Ping}, timestamp = {e.Timestamp}"
});
HeartbeatCheck?.Stop();
HeartbeatCheck?.Start();
await Task.Delay(0);
}
private async Task OnHeartbeat(HeartbeatEventArgs e)
{
//calculate time left till new mission
var timeLeft = TimeSpan.FromMinutes(60 - DateTime.Now.Minute);
//get all the other data in here boys
var serverCount = Bot.Client.Guilds.Count;
var memberCount = Bot.Client.Guilds.Sum(x => x.Value.MemberCount);
var activity = new DiscordActivity($"⚔ {Math.Floor(timeLeft.TotalMinutes)} minutes until next event. [{serverCount} servers with {memberCount} members]", ActivityType.Streaming);
await Bot.Client.UpdateStatusAsync(activity, UserStatus.Online);
}
private Task Heartbeated(HeartbeatEventArgs e)
{
var latency = Duration.FromMilliseconds(e.Ping);
_logger.Information("Shard #{Shard} received heartbeat (latency: {Latency} ms)", e.Client.ShardId, latency.Milliseconds);
var info = TryGetShard(e.Client);
info.LastHeartbeatTime = e.Timestamp.ToInstant();
info.Connected = true;
info.ShardLatency = latency;
return(Task.CompletedTask);
}
async Task Client_Heartbeated(HeartbeatEventArgs e)
{
if (DateTime.Now.DayOfWeek == DayOfWeek.Saturday && DateTime.Now.Hour > 9)
{
DiscordChannel channel = await Client.GetChannelAsync(214523379766525963);
if (channel != null && !weekend)
{
#if DEBUG
#else
await channel.SendMessageAsync("Yay it\'s finally the weekend! Hope everyone is having an amazing Saturday so far!\r\nhttp://i.imgur.com/VKDm9Pj.png");
#endif
weekend = true;
}
}
}
internal async Task OnHeartbeatAckAsync()
{
Interlocked.Decrement(ref this._skippedHeartbeats);
var ping = (int)(DateTime.Now - this._lastHeartbeat).TotalMilliseconds;
this.Logger.LogTrace(LoggerEvents.WebSocketReceive, "Received HEARTBEAT_ACK (OP11, {0}ms)", ping);
Volatile.Write(ref this._ping, ping);
var args = new HeartbeatEventArgs
{
Ping = this.Ping,
Timestamp = DateTimeOffset.Now
};
await _heartbeated.InvokeAsync(this, args).ConfigureAwait(false);
}
public static void OnHeartBeat(object sender, HeartbeatEventArgs e)
{
Heartbeat beat = new Heartbeat
{
AppName = e.AppName,
AppVersion = e.AppVersion,
CreatedAt = e.CreatedAt,
CustomerId = e.CustomerId,
CustomerName = e.CustomerName,
StreamName = e.StreamName,
Id = e.HeartbeatId,
InstanceId = e.InstanceId
};
WebRole.RxHelper.ObservedClients[e.StreamName].OnNext(beat);
AdvaricsHelper.Log(
string.Format("Heartbeat from Client {0} in {1} at {2}",
beat.InstanceId.ToString(),
beat.StreamName,
beat.CustomerName));
}
private async Task CheckBanDatabaseOnHeartbeat(HeartbeatEventArgs e)
{
if (Client.Guilds.Count == 0)
{
return;
}
using (SqliteContext lite = new SqliteContext())
{
var bans = lite.Bans;
DateTime currentTime = DateTime.Now;
var guild = Client.Guilds.Values.FirstOrDefault(x => x.Name == "Bot Testing");
var members = guild.Members.Values;
var roles = guild.Roles.Values;
var straightJacket = roles.First(x => x.Name == "Straight Jacket");
List <ulong> userIDs = new List <ulong>();
foreach (var user in bans)
{
if (user.unbanTime <= currentTime)
{
userIDs.Add(user.userID);
lite.Remove(user);
await lite.SaveChangesAsync();
}
}
foreach (var member in members)
{
foreach (var id in userIDs)
{
if (member.Id == id)
{
await member.RevokeRoleAsync(straightJacket);
}
}
}
}
}
//regeläßiger poster
public async Task HearthBeatPoster(HeartbeatEventArgs e)
{
//di/do reset noch implementiere
//RaidLFG raidLFG = new RaidLFG();
var lfgchannel = await Client.GetChannelAsync(763993776246882314).ConfigureAwait(false);
//wöchentlicher reset
var dt = DateTime.Now;
if (dt.DayOfWeek == DayOfWeek.Tuesday &&
dt.ToShortTimeString() == "22:00")
{
//leeren anmeldungen
DBOperations.LeererDi();
//altes lfg löschen
var msg = await lfgchannel.GetMessagesAsync(1).ConfigureAwait(false);
await lfgchannel.DeleteMessageAsync(msg[0]).ConfigureAwait(false);
//neues (halb) leeres LFG bauen und posten (aus RaidLFG manuell ausführen)
//raidLFG.Manuell(ctx);
}
if (dt.DayOfWeek == DayOfWeek.Thursday &&
dt.ToShortTimeString() == "22:00")
{
//leeren anmeldungen
DBOperations.LeererDo();
//altes lfg löschen
var msg = await lfgchannel.GetMessagesAsync(1).ConfigureAwait(false);
await lfgchannel.DeleteMessageAsync(msg[0]).ConfigureAwait(false);
//neues (halb) leeres LFG bauen und posten (aus RaidLFG manuell ausführen)
//raidLFG.Manuell(ctx);
}
}
// POST: odata/Heartbeats
public async Task <IHttpActionResult> Post(Heartbeat heartbeat)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// each heartbeat must be unique
if (heartbeat.Id == Guid.Empty)
{
heartbeat.Id = Guid.NewGuid();
}
//generate event args for delegate
HeartbeatEventArgs e = RxStreamHelper.GetHeartbeatEventArgs(heartbeat);
//propagate the heartbeat
heartbeatDelegate(this, e);
//insert into db
db.Heartbeats.Add(heartbeat);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (HeartbeatExists(heartbeat.Id))
{
return(Conflict());
}
else
{
throw;
}
}
return(Created(heartbeat));
}
private Task Client_Heartbeat(DiscordClient client, HeartbeatEventArgs e)
{
_logger.Info($"Heartbeat - ping: {e.Ping} ms");
return(Task.CompletedTask);
}
private static async Task Discord_HeartBeated(HeartbeatEventArgs e)
{
}
private void Communication_HeartbeatResponse(object sender, HeartbeatEventArgs e)
{
Messages.Add($"RECV: Heartbeat: value={e.Value}");
}
public static async Task Client_Heartbeated(DiscordClient sender, HeartbeatEventArgs e)
{
var memberCount = sender.Guilds.Sum(x => x.Value.MemberCount);
await sender.UpdateStatusAsync(new DSharpPlus.Entities.DiscordActivity(sender.Guilds.Count + " guilds and " + memberCount + " members.", DSharpPlus.Entities.ActivityType.Watching));
}
private Task Client_Heartbeated(HeartbeatEventArgs e)
{
e.Client.DebugLogger.LogMessage(LogLevel.Info, "BotApp", e.ToString(), DateTime.Now);
return(Task.CompletedTask);
}
static async Task ClientHeartbeated(HeartbeatEventArgs eventArgs)
{
await eventArgs.Client.UpdateStatusAsync(new DiscordActivity($"people get banned on {eventArgs.Client.Guilds.Count} " +
$"{(eventArgs.Client.Guilds.Count == 1 ? "server" : "servers")}", ActivityType.Watching));
}
private Task OnDiscordHeartBeat(HeartbeatEventArgs e)
{
Console.WriteLine($"[Discord] Heartbeat received!", Color.DodgerBlue);
return(Task.FromResult(0));
}
async Task Heartbeated(HeartbeatEventArgs e) => await this.ValidateNodeConnectionAsync();
private static async Task HeartBeatedEvent(HeartbeatEventArgs e)
{
if (Commands.bossList.Count > 0)
{
var isExtended = false;
var boss = Commands.bossList[0];
var spawnTime = (boss.time.AddHours(boss.window)) - DateTime.Now;
var ch = await discord.GetChannelAsync(BotConfig.GetContext.BotChannelID);
if (spawnTime.Hours < 0 || spawnTime.Minutes < 0)
{
spawnTime = (boss.time.AddHours(boss.window).AddHours(boss.extend)) - DateTime.Now;
isExtended = true;
if (spawnTime.Hours < 0 || spawnTime.Minutes < 0)
{
BossCalibrate(boss.name);
isExtended = false;
await discord.SendMessageAsync(ch, $@"@everyone ไม่มีใครรายงานเวลาเกิดบอสจนหมดรอบ 12 ชั่วโมงแล้ว ขอ Recalibrate บอสก่อนนะ ถ้ามากันแล้ว มาเซ็ทเวลาใหม่ด้วย!");
} //even after adding the extend still out of scope then something went wrong
}
var returnString = string.Empty;
if (!isExtended)
{
isAlerted = false;
}
else
{
if (!isAlerted)
{
await discord.SendMessageAsync(ch, $@"@everyone {boss.name} อยู่ในช่วงรอเกิดแล้ว!");
isAlerted = true;
}
}
var prefix = isExtended ? "[*]" : string.Empty;
await discord.UpdateStatusAsync(new DiscordGame()
{
Name = $@"{prefix}Remaining {spawnTime.Hours.ToString().PadLeft(2, '0')} h {spawnTime.Minutes.ToString().PadLeft(2, '0')} m"
});
// remove chat
if (counter == 2)
{
waitForDeleteMessage.ForEach(async m =>
{
try
{
await m.DeleteAsync();
}
catch
{
Console.WriteLine("Message is not found.");
}
waitForDeleteMessage.Remove(m);
await Task.Delay(300); // 3 requests per second
});
counter = 0;
}
else
{
counter++;
}
}
}
private static Task DiscordHeartbeated(HeartbeatEventArgs e)
{
_lastHeartBeat = DateTime.UtcNow;
return(Task.CompletedTask);
}
private void Communication_HeartbeatResponse(object sender, HeartbeatEventArgs e)
{
}
private Task Client_HeartBeated(HeartbeatEventArgs e) => this._heartbeated.InvokeAsync(e);
private void WebsocketPacketHandlerOnSocketHeartbeatReceived(DateTime heartbeatTime)
{
var eventArgs = new HeartbeatEventArgs(heartbeatTime);
HeartbeatReceived?.Invoke(this, eventArgs);
}
private async Task HeartBeatEvent(DiscordClient s, HeartbeatEventArgs e)
{
// DiscordChannel channel = await s.GetChannelAsync(959076723813666816);
// await s.SendMessageAsync(channel, "!lottery");
}
private static Task Client_Heartbeated(HeartbeatEventArgs e)
{
_pingArea.Text = $"Ping: {e.Ping}ms, Chk: {e.IntegrityChecksum}";
return(Task.CompletedTask);
}
