public static void SendModeration(string targetUserId, ModerationType mType, string reason, ModerationTimeRange expires, string worldId = "", string worldInstanceId = "", Action <ApiModelContainer <ApiModeration> > successCallback = null, Action <ApiModelContainer <ApiModeration> > errorCallback = null)
{
ApiModeration apiModeration = new ApiModeration(targetUserId);
apiModeration.moderationType = mType;
apiModeration.reasonMessage = reason;
apiModeration.worldId = worldId;
apiModeration.instanceId = worldInstanceId;
apiModeration.expiresRange = expires;
ApiModeration apiModeration2 = apiModeration;
apiModeration2.Save(delegate(ApiContainer c)
{
if (successCallback != null)
{
successCallback(c as ApiModelContainer <ApiModeration>);
}
}, delegate(ApiContainer c)
{
if (errorCallback != null)
{
errorCallback(c as ApiModelContainer <ApiModeration>);
}
});
}
public TimeLimitedInfraction(DateTimeOffset ends, ulong userId, ulong guildId, ModerationType type)
{
Ends = ends;
UserId = userId;
GuildId = guildId;
Type = type;
}
/// <summary>
/// Initializes a new instance of the <see cref="ModeratedClientEntity"/> struct.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="moderatorDatabaseId">The moderator database id.</param>
/// <param name="userDatabaseId">The user database id.</param>
/// <param name="serverGroup">The server group.</param>
public ModeratedClientEntity(ModerationType type, uint moderatorDatabaseId, uint userDatabaseId, uint serverGroup)
{
Type = type;
Moderator = moderatorDatabaseId;
User = userDatabaseId;
ServerGroup = serverGroup;
Moderated = DateTime.UtcNow;
}
/// <summary>
/// Initializes a new instance of the <see cref="ModeratedClientEntity"/> struct.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="moderatorDatabaseId">The moderator database id.</param>
/// <param name="userDatabaseId">The user database id.</param>
/// <param name="serverGroup">The server group.</param>
public ModeratedClientEntity(ModerationType type, uint moderatorDatabaseId, uint userDatabaseId, uint serverGroup)
{
Type = type;
Moderator = moderatorDatabaseId;
User = userDatabaseId;
ServerGroup = serverGroup;
Moderated = DateTime.UtcNow;
}
public static void SendModeration(string targetUserId, ModerationType type)
{
if (!string.IsNullOrEmpty(targetUserId))
{
VRCApi.Request <ApiPlayerModeration>(MainForm.Instance.OnSendModeration, "auth/user/playermoderations", ApiMethod.POST, new Dictionary <string, object>
{
["moderated"] = targetUserId,
["type"] = ModerationTypeToAPIString(type)
});
}
}
public static void DeleteModeration(string targetUserId, ModerationType type)
{
if (!string.IsNullOrEmpty(targetUserId))
{
VRCApi.Request <ApiResponse>(MainForm.Instance.OnDeleteModeration, "auth/user/unplayermoderate", ApiMethod.PUT, new Dictionary <string, object>
{
["moderated"] = targetUserId,
["type"] = ModerationTypeToAPIString(type)
});
}
}
private static EmbedBuilder GetBaseEmbed(ModerationType type)
{
return(new EmbedBuilder()
{
Author = new EmbedAuthorBuilder()
{
Name = type.ToString()
},
Timestamp = DateTimeOffset.UtcNow,
Color = BotCore.EmbedColor
});
}
private static string ModerationTypeToAPIString(ModerationType type)
{
switch (type)
{
case ModerationType.ShowAvatar:
return("showAvatar");
case ModerationType.HideAvatar:
return("hideAvatar");
default:
return(type.ToString().ToLower());
}
}
/// <summary>
/// Captures the moderation.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="moderatorDatabaseId">The moderator database id.</param>
/// <param name="clientDatabaseId">The client database id.</param>
/// <param name="serverGroupId">The server group id.</param>
public void CaptureModeration(ModerationType type, uint moderatorDatabaseId, uint clientDatabaseId, uint serverGroupId)
{
lock (Container.lockModeratedClientList)
{
lock (Repository.Container.lockDatabase)
{
using (var command = new SQLiteCommand(this.Container.DatabaseConnection))
{
command.CommandText = string.Format("INSERT INTO Moderate(ClientDatabaseId, ModeratorDatabaseId, ServerGroupId, Type, CreationDate) VALUES({0}, {1}, {2}, {3}, {4})", clientDatabaseId, moderatorDatabaseId, serverGroupId, (int)type, DateTime.UtcNow.ToTimeStamp());
command.ExecuteNonQuery();
}
}
}
}
private static bool TryGetLogChannel(SocketGuild guild, ModerationType type, out SocketTextChannel channel, out EmbedBuilder baseEmbed)
{
if (GuildEventLoggerSettings.TryGetValue(guild.Id, out EventLoggerSettings settings))
{
if (settings.UserModLogChannels.TryGetValue(type, out ulong channelId))
{
channel = guild.GetTextChannel(channelId);
baseEmbed = GetBaseEmbed(type);
return(channel != null);
}
}
channel = default;
baseEmbed = null;
return(false);
}
public UserModerationEntry(ulong guildId, ModerationType type, DateTimeOffset?timestamp, SocketGuildUser actor, string reason = null, string info = null)
{
GuildId = guildId;
Type = type;
if (timestamp.HasValue)
{
Timestamp = timestamp.Value;
}
else
{
Timestamp = DateTimeOffset.UtcNow;
}
Reason = reason;
Info = info;
ActorId = actor.Id;
ActorName = actor.ToString();
}
/// <summary>
/// Captures the moderation.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="moderatorDatabaseId">The moderator database id.</param>
/// <param name="clientDatabaseId">The client database id.</param>
/// <param name="serverGroupId">The server group id.</param>
public void CaptureModeration(ModerationType type, uint moderatorDatabaseId, uint clientDatabaseId, uint serverGroupId)
{
lock (Container.lockModeratedClientList)
{
lock (Repository.Container.lockDatabase)
{
Repository.Container.Database.Moderate.AddObject(new Moderate
{
Id = Guid.NewGuid(),
ClientDatabaseId = (int)clientDatabaseId,
ModeratorDatabaseId = (int)moderatorDatabaseId,
Creation = DateTime.UtcNow,
ServerGroup = (int)serverGroupId,
Type = (byte)type
});
Repository.Container.Database.SaveChanges();
}
}
}
public static void DeleteModeration(string targetUserId, ModerationType mType, Action <ApiPlayerModeration> successCallback, Action <string> errorCallback)
{
ApiPlayerModeration apiPlayerModeration = CreateRemovalModeration();
Dictionary <string, object> dictionary = new Dictionary <string, object>();
dictionary["moderated"] = targetUserId;
dictionary["type"] = ModerationTypeToAPIString(mType);
apiPlayerModeration.Put(delegate(ApiContainer c)
{
if (successCallback != null)
{
successCallback(c.Model as ApiPlayerModeration);
}
}, delegate(ApiContainer c)
{
if (errorCallback != null)
{
errorCallback(c.Error);
}
}, dictionary);
}
public static void SendModeration(string targetUserId, ModerationType mType, Action <ApiPlayerModeration> successCallback = null, Action <string> errorCallback = null)
{
ApiPlayerModeration apiPlayerModeration = new ApiPlayerModeration();
apiPlayerModeration.targetUserId = targetUserId;
apiPlayerModeration.moderationType = mType;
ApiPlayerModeration apiPlayerModeration2 = apiPlayerModeration;
apiPlayerModeration2.Save(delegate(ApiContainer c)
{
if (successCallback != null)
{
successCallback(c.Model as ApiPlayerModeration);
}
}, delegate(ApiContainer c)
{
if (errorCallback != null)
{
errorCallback(c.Error);
}
});
}
/// <summary>
/// Gets the moderation.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="fromDate">From date.</param>
/// <param name="toDate">To date.</param>
/// <returns></returns>
public IEnumerable <ModeratedClientEntity> GetModeration(ModerationType type, DateTime?fromDate, DateTime?toDate)
{
lock (Container.lockModeratedClientList)
{
lock (Repository.Container.lockDatabase)
{
using (var command = new SQLiteCommand(this.Container.DatabaseConnection))
{
command.CommandText = string.Format("SELECT ClientDatabaseId, ModeratorDatabaseId, ServerGroupId, Type, CreationDate FROM Moderate WHERE Type = {0}", (int)type);
if (fromDate.HasValue)
{
command.CommandText += string.Format(" AND CreationDate > {0}", fromDate.Value.ToTimeStamp());
}
if (toDate.HasValue)
{
command.CommandText += string.Format(" AND CreationDate < {0}", toDate.Value.ToTimeStamp());
}
var result = new List <ModeratedClientEntity>();
using (var reader = command.ExecuteReader())
{
while (reader.HasRows && reader.Read())
{
result.Add(new ModeratedClientEntity
{
User = (uint)reader.GetInt32(0),
Moderator = (uint)reader.GetInt32(1),
ServerGroup = (uint)reader.GetInt32(2),
Type = type,
Moderated = reader.GetInt64(4).ToDateTime()
});
}
}
return(result);
}
}
}
}
/// <summary>
/// Gets the moderation.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="fromDate">From date.</param>
/// <param name="toDate">To date.</param>
/// <returns></returns>
public IEnumerable <Moderate> GetModeration(ModerationType type, DateTime?fromDate, DateTime?toDate)
{
lock (Container.lockModeratedClientList)
{
var moderationType = (byte)type;
lock (Repository.Container.lockDatabase)
{
var entities = Repository.Container.Database.Moderate.Where(m => m.Type == moderationType);
if (fromDate.HasValue)
{
entities = entities.Where(m => m.Creation > fromDate);
}
if (toDate.HasValue)
{
entities = entities.Where(m => m.Creation < toDate);
}
return(entities.ToList());
}
}
}
public static string Convert(this ModerationType type)
{
switch (type)
{
default:
return(null);
case ModerationType.Block:
return("block");
case ModerationType.HideAvatar:
return("hideAvatar");
case ModerationType.Mute:
return("mute");
case ModerationType.ShowAvatar:
return("showAvatar");
case ModerationType.Unmute:
return("unmute");
}
}
public void LogTopic(User user, ModerationType moderationType, Topic topic, Forum forum, string comment)
{
_moderationLogRepo.Log(DateTime.UtcNow, user.UserID, user.Name, (int)moderationType, forum != null ? forum.ForumID : (int?)null, topic.TopicID, null, comment, String.Empty);
}
public async Task LogTopic(User user, ModerationType moderationType, Topic topic, Forum forum)
{
await LogTopic(user, moderationType, topic, forum, String.Empty);
}
public async Task LogTopic(ModerationType moderationType, int topicID)
{
await _moderationLogRepo.Log(DateTime.UtcNow, 0, "System", (int)moderationType, null, topicID, null, string.Empty, string.Empty);
}
public void LogPost(User user, ModerationType moderationType, Post post, string comment, string oldText)
{
_moderationLogRepo.Log(DateTime.UtcNow, user.UserID, user.Name, (int)moderationType, null, post.TopicID, post.PostID, comment, oldText);
}
/// <summary>
/// Captures the moderation.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="moderatorDatabaseId">The moderator database id.</param>
/// <param name="clientDatabaseId">The client database id.</param>
/// <param name="serverGroupId">The server group id.</param>
public void CaptureModeration(ModerationType type, uint moderatorDatabaseId, uint clientDatabaseId, uint serverGroupId)
{
lock (Container.lockModeratedClientList)
{
lock (Repository.Container.lockDatabase)
{
using (var command = new SQLiteCommand(this.Container.DatabaseConnection))
{
command.CommandText = string.Format("INSERT INTO Moderate(ClientDatabaseId, ModeratorDatabaseId, ServerGroupId, Type, CreationDate) VALUES({0}, {1}, {2}, {3}, {4})", clientDatabaseId, moderatorDatabaseId, serverGroupId, (int)type, DateTime.UtcNow.ToTimeStamp());
command.ExecuteNonQuery();
}
}
}
}
/// <summary>
/// Gets the moderation.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="fromDate">From date.</param>
/// <param name="toDate">To date.</param>
/// <returns></returns>
public IEnumerable<ModeratedClientEntity> GetModeration(ModerationType type, DateTime? fromDate, DateTime? toDate)
{
lock (Container.lockModeratedClientList)
{
lock (Repository.Container.lockDatabase)
{
using (var command = new SQLiteCommand(this.Container.DatabaseConnection))
{
command.CommandText = string.Format("SELECT ClientDatabaseId, ModeratorDatabaseId, ServerGroupId, Type, CreationDate FROM Moderate WHERE Type = {0}", (int)type);
if (fromDate.HasValue) command.CommandText += string.Format(" AND CreationDate > {0}", fromDate.Value.ToTimeStamp());
if (toDate.HasValue) command.CommandText += string.Format(" AND CreationDate < {0}", toDate.Value.ToTimeStamp());
var result = new List<ModeratedClientEntity>();
using (var reader = command.ExecuteReader())
{
while (reader.HasRows && reader.Read())
{
result.Add(new ModeratedClientEntity
{
User = (uint)reader.GetInt32(0),
Moderator = (uint)reader.GetInt32(1),
ServerGroup = (uint)reader.GetInt32(2),
Type = type,
Moderated = reader.GetInt64(4).ToDateTime()
});
}
}
return result;
}
}
}
}
public static async Task <bool> Moderate(this VRCSharpSession session, APIUser user, ModerationType type)
{
HttpClientHandler handler = null;
HttpClient client = new HttpClient();
if (session.UseProxies)
{
//Load proxies from Proxies.txt
handler = new HttpClientHandler();
handler.Proxy = APIExtensions.GetRandomProxy();
client = new HttpClient(handler);
}
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Add("Authorization", session.AuthToken);
var payload = JsonConvert.SerializeObject(new ModerationPayload()
{
moderated = user.id, type = type.Convert()
});
var response = await client.PostAsync($"https://vrchat.com/api/1/auth/user/playermoderations?apiKey={GlobalVars.ApiKey}&userId={user.id}", new StringContent(payload, Encoding.UTF8, "application/json"));
if (response.StatusCode == HttpStatusCode.OK)
{
return(true);
}
else
{
return(false);
}
}
public void LogTopic(User user, ModerationType moderationType, Topic topic, Forum forum)
{
LogTopic(user, moderationType, topic, forum, String.Empty);
}
