public UserCommands(TimerService timer,
Logger.Logger logger,
IPrefixService prefixService,
GuildService guildService,
LastFMService lastFmService,
IIndexService indexService,
UserService userService,
FriendsService friendsService)
{
this._timer = timer;
this._logger = logger;
this._prefixService = prefixService;
this._guildService = guildService;
this._friendsService = friendsService;
this._userService = userService;
this._lastFmService = lastFmService;
this._indexService = indexService;
this._embed = new EmbedBuilder()
.WithColor(Constants.LastFMColorRed);
this._embedAuthor = new EmbedAuthorBuilder();
this._embedFooter = new EmbedFooterBuilder();
}
private static void HandleServices(GameSession session, PacketReader packet)
{
int serviceId = packet.ReadInt();
Guild guild = GameServer.GuildManager.GetGuildById(session.Player.Guild.Id);
if (guild == null)
{
return;
}
int currentLevel = 0;
GuildService service = guild.Services.FirstOrDefault(x => x.Id == serviceId);
if (service != null)
{
service.Level = currentLevel;
}
GuildServiceMetadata serviceMetadata = GuildServiceMetadataStorage.GetMetadata(serviceId, currentLevel);
if (serviceMetadata == null)
{
return;
}
GuildPropertyMetadata propertyMetadata = GuildPropertyMetadataStorage.GetMetadata(guild.Exp);
if (guild.HouseRank < serviceMetadata.HouseLevelRequirement ||
propertyMetadata.Level < serviceMetadata.LevelRequirement ||
guild.Funds < serviceMetadata.UpgradeCost)
{
return;
}
guild.ModifyFunds(session, propertyMetadata, -serviceMetadata.UpgradeCost);
guild.BroadcastPacketGuild(GuildPacket.UpgradeService(session.Player, serviceId, serviceMetadata.Level));
}
private async Task Startup()
{
DBHelper db = new DBHelper();
var PM = new PlayerModule();
var RS = new RaidService();
PM.UpdateAll();
var list = db.GetAllSubscribedChannels();
var ss = new SubscribedChannelService();
if (list.Count != 0)
{
list = list.Where(x => x.Type == SubscribeType.Raid).ToList();
list.ForEach(async o => await ss.Attach(o));
}
ss.ObserveRaids();
RS.ObserveThread();
var player = db.GetAll <Player>().Where(o => o.DiscordName == "Nillertron#5220").FirstOrDefault();
var msgService = new LogMessageService();
await msgService.Attach(player);
var guildService = new GuildService();
}
public void CanUpdateGuildAndSaveToDatabase()
{
DbContextOptions <GuildAPIDbContext> options = new DbContextOptionsBuilder <GuildAPIDbContext>()
.UseInMemoryDatabase("CanUpdateGuildAndSaveToDatabase")
.Options;
using GuildAPIDbContext context = new GuildAPIDbContext(options);
GamesService gameService = new GamesService(context);
GamesDTO gamesDTO = new GamesDTO()
{
Name = "Odins Game"
};
var createdGame = gameService.Create(gamesDTO);
GuildService guildService = new GuildService(context, gameService);
Assert.Equal(1, context.Games.CountAsync().Result);
GuildsDTO guild = new GuildsDTO()
{
Name = "Odin Slayers"
};
var creation = guildService.Create(guild);
var association = gameService.AddGameGuild(createdGame.Result.Id, creation.Result.Id);
GuildsDTO guildsDTO = new GuildsDTO()
{
Id = 1,
Name = "I am updated"
};
var update = guildService.Update(guildsDTO).Result;
var actual = context.Guilds.FindAsync(update.Id).Result;
Assert.Equal(1, context.Guilds.CountAsync().Result);
Assert.IsType <Guilds>(actual);
Assert.Equal(1, actual.Id);
Assert.Equal("I am updated", actual.Name);
}
public void GetConfigAsync()
{
var mock = new Mock <IGuildData>(MockBehavior.Strict);
mock.Setup(x => x.GetGuildConfigAsync(0)).Returns(
Task.FromResult(new Sharp.Data.Config()
{
mod_Channel_Id = "123456789123456789",
prefix = '-',
message_log = false
}));
var guildService = new GuildService(mock.Object);
var actual = guildService.GetConfigAsync(0);
var expected = Task.FromResult(new Sharp.Service.Config
{
ModChannelId = 123456789123456789,
Prefix = '-',
MessageLog = false
});
Assert.Equal(expected.Result, actual.Result);
}
public bool SetDailyGPLimit()
{
string argString = base.Operation.GetArgString(0, "");
Dictionary <string, string> dictionary = new Dictionary <string, string>();
dictionary.Add("GuildLevel_DailyGPLimit", argString);
FeatureMatrix.OverrideFeature(dictionary);
GuildContents.LoadGuildDailyGPLimit();
GuildService guildService = base.Entity.Service;
if (guildService != null)
{
UpdateFeatureMatrix op = new UpdateFeatureMatrix(dictionary);
foreach (IEntity entity in guildService.Entities)
{
GuildEntity guildEntity = entity.Tag as GuildEntity;
foreach (OnlineGuildMember onlineGuildMember in guildEntity.OnlineMembers.Values)
{
onlineGuildMember.FrontendConn.RequestOperation(op);
}
}
}
return(true);
}
private void LoadTaskDetailsPage()
{
var player = GetPC();
var model = GetDialogCustomData <Model>();
var task = DataService.GuildTask.GetByID(model.TaskID);
var quest = QuestService.GetQuestByID(task.QuestID);
var status = DataService.PCQuestStatus.GetByPlayerAndQuestIDOrDefault(player.GlobalID, task.QuestID);
bool showQuestAccept = status == null || status.CompletionDate != null; // Never accepted, or has already been completed once.
bool showGiveReport = status != null && status.CompletionDate == null; // Accepted, but not completed.
var gpRewards = quest.GetRewards().Where(x => x.GetType() == typeof(QuestGPReward)).Cast <QuestGPReward>();
var goldRewards = quest.GetRewards().Where(x => x.GetType() == typeof(QuestGoldReward)).Cast <QuestGoldReward>();
int gpAmount = 0;
int goldAmount = 0;
foreach (var gpReward in gpRewards)
{
gpAmount += GuildService.CalculateGPReward(player, gpReward.Guild, gpReward.Amount);
}
foreach (var goldReward in goldRewards)
{
goldAmount += goldReward.Amount;
}
string header = ColorTokenService.Green("Task: ") + quest.Name + "\n\n";
header += "Rewards:\n\n";
header += ColorTokenService.Green("Credits: ") + goldAmount + "\n";
header += ColorTokenService.Green("Guild Points: ") + gpAmount;
SetPageHeader("TaskDetailsPage", header);
SetResponseVisible("TaskDetailsPage", 1, showQuestAccept);
SetResponseVisible("TaskDetailsPage", 2, showGiveReport);
}
private static void RunServer()
{
Data.Data.DataPath = "data/";
Stopwatch sw = Stopwatch.StartNew();
AppDomain.CurrentDomain.UnhandledException += UnhandledException;
Console.WriteLine("----===== Tera-Project C# GameServer Emulator =====----\n\n");
Console.WriteLine("Starting Game Server!\n"
+ "-------------------------------------------");
TcpServer = new TcpServer("*", Config.GetServerPort(), Config.GetServerMaxCon());
Connection.SendAllThread.Start();
OpCodes.Init();
Console.WriteLine("OpCodes - Revision 1725 initialized!\n"
+ "-------------------------------------------\n");
#region global_components
//services
FeedbackService = new FeedbackService();
AccountService = new AccountService();
PlayerService = new PlayerService();
MapService = new MapService();
ChatService = new ChatService();
VisibleService = new VisibleService();
ControllerService = new ControllerService();
CraftService = new CraftService();
ItemService = new ItemService();
AiService = new AiService();
GeoService = new GeoService();
StatsService = new StatsService();
ObserverService = new ObserverService();
AreaService = new AreaService();
InformerService = new InformerService();
TeleportService = new TeleportService();
PartyService = new PartyService();
SkillsLearnService = new SkillsLearnService();
CraftLearnService = new CraftLearnService();
GuildService = new GuildService();
EmotionService = new EmotionService();
RelationService = new RelationService();
DuelService = new DuelService();
StorageService = new StorageService();
TradeService = new TradeService();
MountService = new MountService();
//engines
ActionEngine = new ActionEngine.ActionEngine();
AdminEngine = new AdminEngine.AdminEngine();
SkillEngine = new SkillEngine.SkillEngine();
QuestEngine = new QuestEngine.QuestEngine();
#endregion
GlobalLogic.ServerStart("SERVER=" + Config.GetDatabaseHost() + ";DATABASE=" + Config.GetDatabaseName() + ";UID=" + Config.GetDatabaseUser() + ";PASSWORD="******";PORT=" + Config.GetDatabasePort() + ";charset=utf8");
Console.WriteLine("-------------------------------------------\n"
+ "Loading Tcp Service.\n"
+ "-------------------------------------------");
TcpServer.BeginListening();
try
{
ServiceApplication = ScsServiceBuilder.CreateService(new ScsTcpEndPoint(23232));
ServiceApplication.AddService <IInformerService, InformerService>((InformerService)InformerService);
ServiceApplication.Start();
Log.Info("InformerService started at *:23232.");
var webservices = new ServiceManager();
webservices.Run();
}
catch (Exception ex)
{
Log.ErrorException("InformerService can not be started.", ex);
}
sw.Stop();
Console.WriteLine("-------------------------------------------");
Console.WriteLine(" Server start in {0}", (sw.ElapsedMilliseconds / 1000.0).ToString("0.00s"));
Console.WriteLine("-------------------------------------------");
}
public UpdateGuildInventoryProcessor(GuildService service, UpdateGuildInventory op) : base(op)
{
this.service = service;
}
public DoGuildOperationProcessor(GuildService service, DoGuildOperation op) : base(op)
{
this.service = service;
}
public GuildModule(GuildService guildService)
{
_guildService = guildService;
}
public QueryGuildIDProcessor(GuildService service, QueryGuildID op) : base(op)
{
this.service = service;
}
public ReportGuildMemberChangedProcessor(GuildService service, ReportGuildMemberChanged op) : base(op)
{
this.service = service;
}
public StrikeModule(StrikeService strikesHandler, GuildService guildService, CommandExtentions commandExtentions)
{
_strikesHandler = strikesHandler;
_guildHandler = guildService;
_commandExtentions = commandExtentions;
}
public InviteGuildProcessor(GuildService service, InviteGuild op) : base(op)
{
this.service = service;
}
public UpdateGuildStorageSettingsProcessor(GuildService service, UpdateGuildStorageSettings op) : base(op)
{
this.service = service;
}
public GuildChatProcessor(GuildService service, GuildChat op) : base(op)
{
this.service = service;
}
public ChangeGuildMasterProcessor(GuildService service, ChangeGuildMaster op) : base(op)
{
this.service = service;
}
protected override void Setup()
{
try {
Instance = this;
this.InitLogging();
log.InfoFormat("Setup: serverId={0}", ServerId);
Clients = new ClientCollection();
Notifications = new NotificationService(this);
#if LOCAL
string databaseConnectionFile = System.IO.Path.Combine(BinaryPath, "assets/database_connection_local.txt");
#else
string databaseConnectionFile = System.IO.Path.Combine(BinaryPath, "assets/database_connection.txt");
#endif
string databaseConnectionString = File.ReadAllText(databaseConnectionFile).Trim();
this.DB = new DbReader();
this.DB.Setup(databaseConnectionString, SelectCharacterSettings.Default.DatabaseName, SelectCharacterSettings.Default.DatabaseCollectionName);
Mail = new MailManager(this);
Guilds = new GuildService(this);
Chat = new ChatService(this);
Groups = new GroupService(this);
Stores = new PlayerStoreService(this);
Auction = new AuctionService(this);
RaceCommands = new RaceCommandService(this);
this.Players = new PlayerService(this);
this.StartModules = new StartPlayerModuleRes();
this.StartModules.LoadFromFile(Path.Combine(this.BinaryPath, "assets/start_player_modules.xml"));
bankSlotPrices = new BankSlotPriceCollection();
bankSlotPrices.LoadFromFile(Path.Combine(this.BinaryPath, "assets/bank_slot_price.xml"));
leveling = new Leveling();
leveling.Load(Path.Combine(BinaryPath, "assets"));
itemPriceCollection = new ItemPriceCollection();
itemPriceCollection.Load(BinaryPath);
consumableItems = new ConsumableItemCollection();
consumableItems.Load(BinaryPath);
StartLocations = new StartLocationCollection();
StartLocations.LoadFromFile(Path.Combine(BinaryPath, "assets/start_locations.xml"));
log.Info(StartLocations.GetWorld(Race.Humans, Workshop.DarthTribe));
pvpStoreItems = new PvpStoreItemCollection();
pvpStoreItems.Load(Path.Combine(BinaryPath, "assets/pvp_store.xml"));
log.InfoFormat("store items loaded = {0} [red]", pvpStoreItems.count);
serverSettings = new ServerInputsRes();
serverSettings.Load(BinaryPath, "Data/server_inputs.xml");
resource = new Res(BinaryPath);
resource.Load();
Election = new CommanderElection(this);
raceStats = new RaceStatsService(this);
friends = new FriendService(this);
pvpStore = new PvpStoreManager(this);
achievmentCache = new Achievments.AchievmentCache(this);
Protocol.AllowRawCustomValues = true;
this.PublicIpAddress = PublicIPAddressReader.ParsePublicIpAddress(SelectCharacterSettings.Default.PublicIPAddress);
this.ConnectToMaster();
this.executionFiber = new PoolFiber();
this.executionFiber.Start();
this.executionFiber.ScheduleOnInterval(this.Update,
SelectCharacterSettings.Default.DatabaseSaveInterval * 1000,
SelectCharacterSettings.Default.DatabaseSaveInterval * 1000);
}catch (Exception ex) {
log.Error(ex);
log.Error(ex.StackTrace);
}
}
private static void RunServer()
{
//Start ServerStartTime
Stopwatch serverStartStopwatch = Stopwatch.StartNew();
AppDomain.CurrentDomain.UnhandledException += UnhandledException;
//CheckServerMode
CheckServerMode();
//ConsoleOutput-Infos
PrintServerLicence();
PrintServerInfo();
//Initialize TcpServer
TcpServer = new TcpServer("*", Configuration.Network.GetServerPort(), Configuration.Network.GetServerMaxCon());
Connection.SendAllThread.Start();
//Initialize Server OpCodes
OpCodes.Init();
Console.WriteLine("----------------------------------------------------------------------------\n"
+ "---===== OpCodes - Revision: " + OpCodes.Version + " EU initialized!");
//Global Services
#region global_components
//Services
FeedbackService = new FeedbackService();
AccountService = new AccountService();
PlayerService = new PlayerService();
MapService = new MapService();
ChatService = new ChatService();
VisibleService = new VisibleService();
ControllerService = new ControllerService();
CraftService = new CraftService();
ItemService = new ItemService();
AiService = new AiService();
GeoService = new GeoService();
StatsService = new StatsService();
ObserverService = new ObserverService();
AreaService = new AreaService();
TeleportService = new TeleportService();
PartyService = new PartyService();
SkillsLearnService = new SkillsLearnService();
CraftLearnService = new CraftLearnService();
GuildService = new GuildService();
EmotionService = new EmotionService();
RelationService = new RelationService();
DuelService = new DuelService();
StorageService = new StorageService();
TradeService = new TradeService();
MountService = new MountService();
//Engines
ActionEngine = new ActionEngine.ActionEngine();
AdminEngine = new AdminEngine.AdminEngine();
SkillEngine = new SkillEngine.SkillEngine();
QuestEngine = new QuestEngine.QuestEngine();
#endregion
//Set SqlDatabase Connection
GlobalLogic.ServerStart("SERVER=" + DAOManager.MySql_Host + ";DATABASE=" + DAOManager.MySql_Database + ";UID=" + DAOManager.MySql_User + ";PASSWORD="******";PORT=" + DAOManager.MySql_Port + ";charset=utf8");
Console.ForegroundColor = ConsoleColor.Gray;
//Start Tcp-Server Listening
Console.WriteLine("----------------------------------------------------------------------------\n"
+ "---===== Loading GameServer Service.\n"
+ "----------------------------------------------------------------------------");
TcpServer.BeginListening();
//Stop ServerStartTime
serverStartStopwatch.Stop();
Console.WriteLine("----------------------------------------------------------------------------");
Console.WriteLine("---===== GameServer start in {0}", (serverStartStopwatch.ElapsedMilliseconds / 1000.0).ToString("0.00s"));
Console.WriteLine("----------------------------------------------------------------------------");
}
public ConnectGuildProcessor(GuildService service, ConnectGuild op) : base(op)
{
this.service = service;
}
public async Task HandleReaction(DiscordSocketClient discordSocketClient, SocketReaction reaction, ISocketMessageChannel channel, Dictionary <string, string> _reactionWatcher, Program program)
{
if (reaction.MessageId.ToString() == "586248421715738629")
{
var eventDetailChannel = (ISocketMessageChannel)discordSocketClient.GetChannel(572721078359556097);
var embededMessage = (IUserMessage)await eventDetailChannel.GetMessageAsync(586248421715738629);
var embedInfo = embededMessage.Embeds.First();
var guild = discordSocketClient.Guilds.FirstOrDefault(x => x.Id == (ulong)505485680344956928);
var user = guild.GetUser(reaction.User.Value.Id);
var embedBuilder = new EmbedBuilder
{
Title = embedInfo.Title,
Description = embedInfo.Description + "\n" + user.Username,
Footer = new EmbedFooterBuilder {
Text = embedInfo.Footer.ToString()
},
Color = embedInfo.Color
};
await embededMessage.ModifyAsync(msg => msg.Embed = embedBuilder.Build());
}
var data = JsonExtension.GetJsonData("../../../Resources/irleventdata.txt");
if (reaction.UserId != 504633036902498314 && data.Keys.Contains(reaction.MessageId.ToString()))
{
if (reaction.Emote.ToString() == "<:green_check:671412276594475018>")
{
var deelnemersMsgData =
JsonExtension.ToDictionary <string[]>(data[reaction.MessageId.ToString()]);
var eventDetailChannel = reaction.Channel;
var msgId = deelnemersMsgData.First().Key;
var embededMessage =
(IUserMessage)await eventDetailChannel.GetMessageAsync(ulong.Parse(msgId));
var embedInfo = embededMessage.Embeds.First();
var user = discordSocketClient.GetUser(reaction.User.Value.Id);
var embedBuilder = new EmbedBuilder
{
Title = embedInfo.Title,
Description = embedInfo.Description + "\n" + "<@!" + user.Id + ">",
Footer = new EmbedFooterBuilder {
Text = embedInfo.Footer.ToString()
},
Color = embedInfo.Color
};
//Add permissions to see the general event channel
var d = deelnemersMsgData[reaction.MessageId + "0"];
var generalChannel = discordSocketClient.GetGuild(505485680344956928)
.GetChannel(ulong.Parse(d.First()));
await generalChannel.AddPermissionOverwriteAsync(user,
new OverwritePermissions().Modify(sendMessages: PermValue.Allow,
viewChannel: PermValue.Allow, readMessageHistory: PermValue.Allow));
await embededMessage.ModifyAsync(msg => msg.Embed = embedBuilder.Build());
}
else if (reaction.Emote.ToString() == "<:blue_check:671413239992549387>")
{
var user = discordSocketClient.GetUser(reaction.User.Value.Id);
var deelnemersMsgData =
JsonExtension.ToDictionary <string[]>(data[reaction.MessageId.ToString()]);
var d = deelnemersMsgData[reaction.MessageId + "0"];
var generalChannel = discordSocketClient.GetGuild(505485680344956928)
.GetChannel(ulong.Parse(d.First()));
await generalChannel.AddPermissionOverwriteAsync(user,
new OverwritePermissions().Modify(sendMessages: PermValue.Allow,
viewChannel: PermValue.Allow, readMessageHistory: PermValue.Allow));
}
else if (reaction.Emote.ToString() == "<:red_check:671413258468720650>")
{
var user = discordSocketClient.GetUser(reaction.User.Value.Id);
var generalChannel = discordSocketClient.GetGuild(505485680344956928)
.GetChannel(reaction.Channel.Id);
await generalChannel.AddPermissionOverwriteAsync(user,
new OverwritePermissions().Modify(sendMessages: PermValue.Deny, viewChannel: PermValue.Deny,
readMessageHistory: PermValue.Deny));
}
}
if (reaction.MessageId.ToString() == "586248421715738629")
{
var messageID = reaction.MessageId;
var userID = reaction.UserId;
}
if (channel.Id == 549343990957211658)
{
var guild = discordSocketClient.Guilds.FirstOrDefault(x => x.Id == (ulong)505485680344956928);
var user = guild.GetUser(reaction.User.Value.Id);
var userRoles = user.Roles;
foreach (var role in userRoles)
{
if (role.Name == "Nieuwkomer")
{
var addRole = guild.Roles.FirstOrDefault(x => x.Name == "Koos Rankloos");
var deleteRole = guild.Roles.FirstOrDefault(x => x.Name == "Nieuwkomer");
await user.AddRoleAsync(addRole);
await user.RemoveRoleAsync(deleteRole);
}
}
}
if (channel.Id == 549350982081970176)
{
bool authenticationCheck()
{
var guild = discordSocketClient.Guilds.FirstOrDefault(x => x.Id == (ulong)505485680344956928);
var userRoles = guild.GetUser(reaction.User.Value.Id).Roles;
foreach (var role in userRoles)
{
if (role.Name == "Staff")
{
return(true);
}
}
return(false);
}
if (authenticationCheck())
{
//{✅}
//{⛔}
// vinkje = status veranderen en actie uitvoeren om er in te zetten
// denied is status veranderen en user mention gebruiken
var messageFromReaction = await reaction.Channel.GetMessageAsync(reaction.MessageId);
var casted = (IUserMessage)messageFromReaction;
var usedEmbed = casted.Embeds.First();
if (reaction.Emote.Name == "⛔")
{
var deniedEmbed = new EmbedBuilder();
//need staff check
try
{
deniedEmbed = new EmbedBuilder
{
Title = usedEmbed.Title,
Description = usedEmbed.Description.Replace("Waiting for approval", "Denied"),
ThumbnailUrl = usedEmbed.Thumbnail.Value.Url,
Color = Color.Red
};
}
catch
{
deniedEmbed = new EmbedBuilder
{
Title = usedEmbed.Title,
Description = usedEmbed.Description.Replace("Waiting for approval", "Denied"),
Color = Color.Red
};
}
await casted.ModifyAsync(msg => msg.Embed = deniedEmbed.Build());
await casted.RemoveAllReactionsAsync();
}
if (reaction.Emote.Name == "✅")
{
var digitsOnly = new Regex(@"[^\d]");
var oneSpace = new Regex("[ ]{2,}");
var IDS = oneSpace.Replace(digitsOnly.Replace(usedEmbed.Description, " "), "-").Split("-");
var discordId = IDS[2];
var scoresaberId = IDS[1];
var approvedEmbed = new EmbedBuilder();
try
{
approvedEmbed = new EmbedBuilder
{
Title = usedEmbed.Title,
Description = usedEmbed.Description.Replace("Waiting for approval", "Approved"),
ThumbnailUrl = usedEmbed.Thumbnail.Value.Url,
Color = Color.Green
};
}
catch
{
approvedEmbed = new EmbedBuilder
{
Title = usedEmbed.Title,
Description = usedEmbed.Description.Replace("Waiting for approval", "Approved"),
Color = Color.Green
};
}
var check = await new RoleAssignment(discordSocketClient).LinkAccount(discordId,
scoresaberId);
if (check)
{
await casted.ModifyAsync(msg => msg.Embed = approvedEmbed.Build());
await casted.RemoveAllReactionsAsync();
}
var player = await new ScoresaberAPI(scoresaberId).GetPlayerFull();
DutchRankFeed.GiveRoleWithRank(player.playerInfo.CountryRank, scoresaberId, discordSocketClient);
var dutchGuild = new GuildService(discordSocketClient, 505485680344956928);
var linkingUser = dutchGuild.Guild.GetUser(new RoleAssignment(discordSocketClient).GetDiscordIdWithScoresaberId(scoresaberId));
await dutchGuild.AddRole("Verified", linkingUser);
await dutchGuild.DeleteRole("Link my discord please", linkingUser);
await dutchGuild.DeleteRole("Koos Rankloos", linkingUser);
await program.UserJoinedMessage(linkingUser);
}
}
}
//Add Roles from reactions added to specific channels
if (channel.Id == 510227606822584330 || channel.Id == 627292184143724544)
{
var guild = discordSocketClient.GetGuild(505485680344956928);
if (channel.Id == 510227606822584330)
{
guild = discordSocketClient.GetGuild(505485680344956928);
}
else if (channel.Id == 627292184143724544)
{
guild = discordSocketClient.GetGuild(627156958880858113);
}
var user = guild.GetUser(reaction.UserId);
var t = reaction.Emote.ToString().Replace("<a:", "<:");
foreach (var reactionDic in _reactionWatcher)
{
if (reactionDic.Key == t)
{
var role = guild.Roles.FirstOrDefault(x => x.Name == reactionDic.Value);
await(user as IGuildUser).AddRoleAsync(role);
}
}
}
if (reaction.UserId != 504633036902498314)
{
//Turn page from help command
//right (681843066104971287)
//left (681842980134584355)
if (reaction.Emote.ToString() == "<:right:681843066104971287>")
{
var t = reaction.Message.ToString();
var message = await channel.GetMessageAsync(reaction.MessageId);
var casted = (IUserMessage)message;
var usedEmbed = casted.Embeds.First();
var pagenr = usedEmbed.Title.Split("[")[1].Split("]")[0];
var currentNr = int.Parse(pagenr.Split("/")[0]);
var maxNr = int.Parse(pagenr.Split("/")[1]);
if (currentNr >= maxNr)
{
return;
}
casted.ModifyAsync(msg =>
msg.Embed = Help.GetHelpList(discordSocketClient, int.Parse(pagenr.Split("/").First())));
}
if (reaction.Emote.ToString() == "<:left:681842980134584355>")
{
var t = reaction.Message.ToString();
var message = await channel.GetMessageAsync(reaction.MessageId);
var casted = (IUserMessage)message;
var usedEmbed = casted.Embeds.First();
var pagenr = usedEmbed.Title.Split("[")[1].Split("]")[0];
var currentNr = int.Parse(pagenr.Split("/")[0]);
if (currentNr <= 0)
{
return;
}
casted.ModifyAsync(msg =>
msg.Embed = Help.GetHelpList(discordSocketClient,
int.Parse(pagenr.Split("/").First()) - 2));
}
}
}
public UpdateGuildCharacterNameProcessor(GuildService service, UpdateGuildCharacterName op) : base(op)
{
this.service = service;
}
public AdminCommandProcessor(GuildService sv, AdminCommand op) : base(op)
{
this.service = sv;
}
public ELOEventHandler(DiscordShardedClient client, CommandService commandService, GuildService guildService, LocalManagementService local, LogHandler handler, IServiceProvider provider) : base(client, commandService, guildService, local, handler, provider)
{
GuildSchedule.Service = commandService;
GuildSchedule.Provider = provider;
}
public ConfigController(GuildService configService)
{
_guildService = configService;
}
public PurchaseGuildStorageProcessor(GuildService service, PurchaseGuildStorage op) : base(op)
{
this.service = service;
}
public ArrangeGuildStorageItemProcessor(GuildService service, ArrangeGuildStorageItem op) : base(op)
{
this.service = service;
}
/// <inheritdoc />
public async Task CreateInfractionAsync(InfractionType type, ulong subjectId, string reason, TimeSpan?duration)
{
AuthorizationService.RequireAuthenticatedGuild();
AuthorizationService.RequireAuthenticatedUser();
AuthorizationService.RequireClaims(_createInfractionClaimsByType[type]);
var guild = await GuildService.GetGuildAsync(AuthorizationService.CurrentGuildId.Value);
var subject = await UserService.GetGuildUserAsync(guild.Id, subjectId);
if (reason == null)
{
throw new ArgumentNullException(nameof(reason));
}
if (((type == InfractionType.Notice) || (type == InfractionType.Warning)) &&
string.IsNullOrWhiteSpace(reason))
{
throw new InvalidOperationException($"{type.ToString()} infractions require a reason to be given");
}
using (var transaction = await InfractionRepository.BeginCreateTransactionAsync())
{
if ((type == InfractionType.Mute) || (type == InfractionType.Ban))
{
if (await InfractionRepository.AnyAsync(new InfractionSearchCriteria()
{
GuildId = guild.Id,
Types = new[] { type },
SubjectId = subject.Id,
IsRescinded = false,
IsDeleted = false
}))
{
throw new InvalidOperationException($"Discord user {subjectId} already has an active {type} infraction");
}
}
await InfractionRepository.CreateAsync(
new InfractionCreationData()
{
GuildId = guild.Id,
Type = type,
SubjectId = subjectId,
Reason = reason,
Duration = duration,
CreatedById = AuthorizationService.CurrentUserId.Value
});
transaction.Commit();
}
// TODO: Implement ModerationSyncBehavior to listen for mutes and bans that happen directly in Discord, instead of through bot commands,
// and to read the Discord Audit Log to check for mutes and bans that were missed during downtime, and add all such actions to
// the Infractions and ModerationActions repositories.
// Note that we'll need to upgrade to the latest Discord.NET version to get access to the audit log.
// Assuming that our Infractions repository is always correct, regarding the state of the Discord API.
switch (type)
{
case InfractionType.Mute:
await subject.AddRoleAsync(
await GetOrCreateMuteRoleInGuildAsync(guild));
break;
case InfractionType.Ban:
await guild.AddBanAsync(subject, reason : reason);
break;
}
}
public async Task Victoria(CommandContext context, [Description("El usuario al que le ganaste")] DiscordMember targetUser = null, [RemainingText] string resultStr = null)
{
var callingUser = context.Member;
if (callingUser == targetUser)
{
return;
}
if (targetUser == null)
{
await context.ReplyAsync("Faltó escribir el oponente.");
return;
}
if (targetUser.IsBot)
{
await context.ReplyAsync("No puedes reportar una victoria contra un bot!");
return;
}
if (string.IsNullOrWhiteSpace(resultStr))
{
await context.ReplyAsync("Faltó escribir el resultado");
return;
}
var messageValid = ResultService.GetResult(callingUser, targetUser, resultStr, out Result result);
if (!messageValid)
{
await context.ReplyAsync($"No se escribió bien el resultado: {resultStr}. Ejemplo: 2-1");
return;
}
var generalMessage = $"Resultado: \n\t{result.winner}\t{result.loser}. {result.message}";
await targetUser.SendMessageAsync($"El usuario {callingUser.Mention} reportó una victoria {result.winner.score}-{result.loser.score} contra ti.");
var channelName = ChannelRedirection.GetRedirectedChannel(context.Channel.Name);
var channel = GuildService.FindTextChannel(context, channelName);
var admins = GuildService.FindRole(context, "admin");
if (channel == null)
{
var roles = callingUser.Roles;
var roleText = GuildService.GetEntityNames(roles);
generalMessage = $"{generalMessage}\nCanal: {context.Channel.Name} Roles: {roleText}";
channelName = ChannelRedirection.TargetChannelName;
channel = GuildService.FindTextChannel(context, channelName);
if (channel == null)
{
await context.ReplyAsync($"{generalMessage}");
return;
}
}
await GuildService.SendMessageToTextChannel(channel, generalMessage, admins);
await context.ReplyAsync($"{generalMessage}");
var hasAdmin = callingUser.Roles.Where(role => role.Name.Contains("admin")).Count() > 0;
if (!hasAdmin)
{
var interaction = context.Client.GetInteractivity();
await context.RespondAsync($"{targetUser.Mention} confirma la victoria de {callingUser.DisplayName}. Sólo escribe sí o no.");
var response = await interaction.WaitForMessageAsync(context.WithPredicate().ToUser (targetUser).InSameChannel());
if (response.TimedOut || response.Result.Content.Contains("no"))
{
await context.RespondAsync(
$"{callingUser.Mention} no se ha aceptado tu victoria. Revisa si hay un problema o contacta a un administrador.");
return;
}
}
if (await DBConection.SetMatch(context.Guild.Id, callingUser, targetUser))
{
await context.RespondAsync($"Se ha reportado la victoria de {callingUser.DisplayName}");
}
else
{
await context.RespondAsync($"No hay peleas pendientes contra {targetUser.DisplayName}!");
}
}
