예제 #1
0
    async def cmd_galenable(self, ctx):
        """
        [Bot Owner] Enables the gallery feature.

        Useage:
            [prefix]galenable
        """

        # ===== SET LOCAL COG VARIABLE
        self.cogset['enable']= True

        # ===== ADD THE FUNCTION TO THE SCHEDULER
        self.scheduler.add_job(call_schedule,
                                'date',
                                id="_delete_gallery_messages",
                                run_date=get_next(hours=self.cogset['text_expirein']),
                                kwargs={"func": "_delete_gallery_messages"}
                                )

        # ===== SAVE SETTINGS  
        await cogset.SAVE(self.cogset, cogname=self.qualified_name)

        await ctx.channel.send(content="Galleries are **enabled**.")

        return
예제 #2
0
    async def schedule_reopen_guild(self, secondsUntilReopen=3600, **kwargs):
        """
        [Called Close Guild Command]

        Adds re-open guild func to the scheduler.
        """

        # =====
        for job in self.jobstore.get_all_jobs():
            if ["_reopen_guild"] == job.id.split(" "):
                return

        # ===== SEND REPORT MESSAGE TO STAFF
        embed = await GenEmbed.genReopenGuild(secondsUntilReopen)
        await self.bot.send_msg_chid(self.bot.config.channels['bot_log'],
                                     embed=embed)

        # ===== ADD EVENT TO THE SCHEDULER
        self.scheduler.add_job(call_schedule,
                               'date',
                               id=self._reopen_guild.__name__,
                               run_date=get_next(**kwargs),
                               kwargs={"func": "_reopen_guild"})

        return
예제 #3
0
    async def cmd_galsetexpirehours(self, ctx):
        """
        [Bot Owner] Sets how long the bot should wait to delete text only messages from gallery channels

        Useage:
            [prefix]galsetexpirehours <hours>
        """
        new_time = Gallery.time_pat_to_hrs(ctx.message.content)

        await self.db.execute(pgCmds.SET_GUILD_GALL_EXP, new_time)

        resetJob = False

        ###===== RESET THE JOB IF IT EXISTS
        for job in self.jobstore.get_all_jobs():
            if ["_delete_gallery_messages"] == job.id.split(" "):
                self.scheduler.remove_job(job.id)
                resetJob = True

        if resetJob:
            ###===== ADD THE FUNCTION TO THE SCHEDULER
            self.scheduler.add_job(call_schedule,
                                    'date',
                                    id="_delete_gallery_messages",
                                    run_date=get_next(hours=self.gal_text_expirein),
                                    kwargs={"func": "_delete_gallery_messages"}
                                    )

            await ctx.channel.send(content=f"Text message expirey time has been set to {new_time} hours and the scheduler was reset.")
            return

        await ctx.channel.send(content=f"Text message expirey time has been set to {new_time} hours.")
        return
예제 #4
0
    async def cmd_galenable(self, ctx):
        """
        [Bot Owner] Enables the gallery feature.

        Useage:
            [prefix]galenable
        """

        ###===== Write to database
        await self.db.execute(pgCmds.SET_GUILD_GALL_ENABLE, self.gal_guild_id)

        ###===== SET LOCAL COG VARIABLE
        self.gal_enable= True

        ###===== DELETE THE JOB IF IT EXISTS
        for job in self.jobstore.get_all_jobs():
            if ["_delete_gallery_messages"] == job.id.split(" "):
                self.scheduler.remove_job(job.id)

        ###===== ADD THE FUNCTION TO THE SCHEDULER
        self.scheduler.add_job(call_schedule,
                               'date',
                               id="_delete_gallery_messages",
                               run_date=get_next(hours=self.gal_text_expirein),
                               kwargs={"func": "_delete_gallery_messages"}
                               )

        await ctx.channel.send(content="Galleries are disabled.")

        return
예제 #5
0
    async def cmd_galinitiateschedule(self, ctx):
        
        # ===== DELETE THE JOB IF IT ALREADY EXISTS
        for job in self.jobstore.get_all_jobs():
            if ["_delete_gallery_messages"] == job.id.split(" "):
                self.scheduler.remove_job(job.id)

        # ===== ADD THE FUNCTION TO THE SCHEDULER
        self.scheduler.add_job(call_schedule,
                               'date',
                               id="_delete_gallery_messages",
                               run_date=get_next(hours=self.cogset['text_expirein']),
                               kwargs={"func": "_delete_gallery_messages"}
                               )

        # ===== RETURN
        await ctx.channel.send(content=f"Gallery schedule has been set for {get_next(hours=self.cogset['text_expirein'])}")

        return
예제 #6
0
    async def schedule_kick(self,
                            member,
                            daysUntilKick=Days.gated,
                            quiet=False,
                            **kwargs):
        """
        [Called on_member_join and check_new_members]

        Adds the automatic kick of a member from entrance gate after 14 days to the scheduler.
        Handles:
            If member is already scheduled to be kicked.

        It passes on the time allotted for an automatic kick to self._kick_entrance via the scheduler in the form of **kwargs
        """

        for job in self.jobstore.get_all_jobs():
            if ["_kick_entrance", str(member.id)] == job.id.split(" "):
                if not quiet:
                    await self.bot.send_msg_chid(
                        self.bot.config.channels['bot_log'],
                        content="{0.mention} already scheduled for a kick".
                        format(member))
                return

        embed = await GenEmbed.getScheduleKick(
            member=member,
            daysUntilKick=daysUntilKick,
            kickDate=(datetime.datetime.now() + datetime.timedelta(seconds=(
                (daysUntilKick * 24 * 60 * 60) + 3600))))

        await self.bot.send_msg_chid(self.bot.config.channels['bot_log'],
                                     embed=embed)

        #===== add the kicking of member to the scheduler
        self.scheduler.add_job(call_schedule,
                               'date',
                               id=self.get_id_args(self._kick_entrance,
                                                   member.id),
                               run_date=get_next(**kwargs),
                               kwargs={
                                   "func": "_kick_entrance",
                                   "arg": str(member.id)
                               })
예제 #7
0
    async def cmd_galsetexpirehours(self, ctx, timepat):
        """
        [Bot Owner] Sets how long the bot should wait to delete text only messages from gallery channels.
        Can be provided as <XdXh>

        Useage:
            [prefix]galsetexpirehours <hours>
        """
        # ===== CHECK IF VALID
        new_time = Gallery.time_pat_to_hrs(timepat)
        
        if not new_time:
            await ctx.send_help("galsetexpirehours", delete_after=15)
            return

        # ===== SAVE COG SETTINGS
        self.cogset['text_expirein'] = new_time
        await cogset.SAVE(self.cogset, cogname=self.qualified_name)

        resetJob = False

        # ===== RESET THE JOB IF IT EXISTS
        for job in self.jobstore.get_all_jobs():
            if ["_delete_gallery_messages"] == job.id.split(" "):
                self.scheduler.remove_job(job.id)
                resetJob = True

        if resetJob:
            # ===== ADD THE FUNCTION TO THE SCHEDULER
            self.scheduler.add_job(call_schedule,
                                    'date',
                                    id="_delete_gallery_messages",
                                    run_date=get_next(hours=self.cogset['text_expirein']),
                                    kwargs={"func": "_delete_gallery_messages"}
                                    )

            await ctx.channel.send(content=f"Text message expirey time has been set to {new_time} hours and the scheduler was reset.")
            return

        await ctx.channel.send(content=f"Text message expirey time has been set to {new_time} hours.")
        return
예제 #8
0
    async def schedule_rem_newuser_role(self,
                                        member: Union[discord.User,
                                                      discord.Member],
                                        daysUntilRemove=Days.newmember,
                                        **kwargs):
        """
        [Called on_member_update]

        Adds the removal of a new member's fresh role to the scheduler.
        Handles:
            If member is already scheduled.

        It passes on the time allotted for an automatic kick to self._rem_newuser_role via the scheduler in the form of **kwargs
        """

        ###===== IF MEMBER IS ALREADY SCHEDULED TO HAVE NEW MEMBER ROLE REMOVED, QUIT
        for job in self.jobstore.get_all_jobs():
            if ["_rem_newuser_role", str(member.id)] == job.id.split(" "):
                return

        ###===== SEND REPORT MESSAGE TO STAFF
        embed = await GenEmbed.getScheduleRemNewRole(
            member=member, daysUntilRemove=daysUntilRemove)
        await self.bot.send_msg_chid(self.bot.config.channels['bot_log'],
                                     embed=embed)

        ###===== ADD EVENT TO THE SCHEDULER
        self.scheduler.add_job(call_schedule,
                               'date',
                               id=self.get_id_args(self._rem_newuser_role,
                                                   member.id),
                               run_date=get_next(**kwargs),
                               kwargs={
                                   "func": "_rem_newuser_role",
                                   "arg": str(member.id)
                               })

        return
예제 #9
0
    async def _delete_gallery_messages(self, *args):
        # ===== QUIT ID GALLERIES ARE DISABLED.
        if not self.cogset['enable']:
            return 

        # ===== CONNECT TO THE DATABASE
        credentials = {"user": dblogin.user, "password": dblogin.pwrd, "database": dblogin.name, "host": dblogin.host}
        self.db = await asyncpg.create_pool(**credentials)

        after = (datetime.datetime.utcnow() - datetime.timedelta(hours=self.cogset['text_expirein']))

        t = await self.db.fetch(pgCmds.GET_GALL_MSG_BEFORE, after)
        ch_ids = await self.db.fetch(pgCmds.GET_GALL_CHIDS_BEFORE, after)
        await self.db.execute(pgCmds.DEL_GALL_MSGS_BEFORE, self.cogset['guild_id'], after)

        await self.db.close()

        # ===== TURNING THE DATA INTO SOMETHING MORE USEFUL
        ch_ids = [ch_id['ch_id'] for ch_id in ch_ids]
        fast_delete = dict()
        slow_delete = []

        for ch_id in ch_ids:
            fast_delete[ch_id] = []

        now = datetime.datetime.utcnow()
        delta = datetime.timedelta(days=13, hours=12)

        for record in t:
            ###=== IF MESSAGE IS OLDER THAN 13 DAYS AND 12 HOURS
            if bool((now - record['timestamp']) > delta):
                slow_delete.append(record)

            ###=== IF MESSAHE IS YOUNGER THAN 13 DAYS AND 12 HOURS
            else:
                fast_delete[record['ch_id']].append(record['msg_id'])

        # ===== IF THERE IS FAST DELETE DATA   
        # WITH FAST DELETE MESSAGES WE CAN DELETE MESSAGES IN BULK OF 100
        if fast_delete:
            for ch_id in fast_delete.keys():
                msgs_ids = await Gallery.split_list(fast_delete[ch_id], 100)

                for msg_ids in msgs_ids:
                    if len(msg_ids) > 1:

                        await self.bot.http.delete_messages(ch_id, msg_ids, reason="Deleting Gallery Messages")
                        await asyncio.sleep(0.5)

                    else:
                        # SOMETIMES AN EMPTY LIST MAKES IT HERE
                        if msg_ids:
                            msg_id = msg_ids[0]
                            await self.bot.http.delete_message(ch_id, msg_id, reason="Deleting Gallery Messages")
                            await asyncio.sleep(0.5)

        # ===== IF THERE IS SLOW DELETE DATA
        # WE CANNOT DELETE THESE MESSAGES IN BULK, ONLY ONE BY ONE.
        if slow_delete:
            for record in slow_delete:

                await self.bot.http.delete_message(record['ch_id'], record['msg_id'], reason="Deleting Gallery Messages")
                await asyncio.sleep(0.5)


        ###==== LOOP THE SCHEDULER
        self.scheduler.add_job( call_schedule,
                                'date',
                                id="_delete_gallery_messages",
                                run_date=get_next(hours=self.cogset['text_expirein']),
                                kwargs={"func": "_delete_gallery_messages"}
                                )
        return