Example #1
0
 def display_events(self, lhs, rhs):
     if lhs:
         self.display_event(lhs)
         return
     now = utcnow()
     interval = duration_from_string('6h')
     expired = now - interval
     events = Event.objects.filter(date_schedule__gte=expired).order_by('date_schedule')
     tz = self.player.settings.get('timezone')
     last_day = ''
     check_day = ''
     message = list()
     message.append(self.player.render.header("Current Schedule - %s" % self.player.time.display(format='%Z')))
     for event in events:
         check_day = self.caller.display_local_time(date=event.date_schedule, format='%a %b %d %Y')
         if check_day != last_day:
             message.append(self.player.render.subheader(check_day))
         last_day = check_day
         time = self.caller.display_local_time(date=event.date_schedule, format='%I:%M%p')
         tag_mark = ' '
         taggers = set(event.interest.all())
         alts = set(self.player.get_all_characters())
         check_set = taggers.intersection(alts)
         if len(check_set):
             tag_mark = ANSIString('|C*|n')
         if self.character in taggers:
             tag_mark = ANSIString('|r*|n')
         if event.owner == self.character:
             tag_mark = ANSIString('|g*|n')
         tag_count = event.interest.all().count()
         display_string = "{}{:<2} {:<4}{:40.40}{:23.23}{:7}".format(tag_mark, tag_count, event.id, event.title,
                                                                     event.owner, time)
         message.append(display_string)
     message.append(self.player.render.footer())
     self.msg_lines(message)
Example #2
0
 def edit_post(self, find=None, replace=None):
     if not find:
         raise ValueError("No text entered to find.")
     if not replace:
         replace = ''
     self.date_modified = utcnow()
     self.text = self.text.replace(find, replace)
Example #3
0
 def switch_add(self, lhs, rhs):
     if not lhs:
         raise ValueError("What time shall it happen?")
         return
     if '/' not in lhs:
         raise ValueError("What will the scene's title be?")
         return
     time, title = lhs.split('/', 1)
     try:
         check_time = utc_from_string(
             time, self.character.settings.get('timezone'))
     except ValueError as err:
         raise ValueError(str(err))
         return
     if not check_time > utcnow():
         raise ValueError(
             "No scheduling things in the past, that's just silly.")
         return
     if not title:
         raise ValueError("What will the scene's title be?")
         return
     if not rhs:
         raise ValueError("What will the scene's description be?")
         return
     new_event = Event.objects.create(owner=self.character,
                                      title=title,
                                      date_schedule=check_time,
                                      description=rhs)
     new_event.setup()
     self.sys_msg("Your new Event's ID is: %s" % new_event.id)
     return
Example #4
0
 def switch_add(self, lhs, rhs):
     if not lhs:
         self.error("What time shall it happen?")
         return
     if '/' not in lhs:
         self.error("What will the scene's title be?")
         return
     time, title = lhs.split('/', 1)
     try:
         check_time = utc_from_string(time, self.character.settings.get('timezone'))
     except ValueError as err:
         self.error(unicode(err))
         return
     if not check_time > utcnow():
         self.error("No scheduling things in the past, that's just silly.")
         return
     if not title:
         self.error("What will the scene's title be?")
         return
     if not rhs:
         self.error("What will the scene's description be?")
         return
     new_event = Event.objects.create(owner=self.character, title=title, date_schedule=check_time, description=rhs)
     new_event.setup()
     self.sys_msg("Your new Event's ID is: %s" % new_event.id)
     return
Example #5
0
 def process_timeout(self):
     if not self.timeout:
         return
     start_date = self.timeout_date or self.creation_date
     check_date = start_date + self.timeout
     if check_date < utcnow():
         self.delete()
         return True
Example #6
0
 def create_post(self, poster, subject, text, date=None):
     if not date:
         date = utcnow()
     order = self.next_post_number
     new_post = self.post_class.create(self, poster, subject, text, date,
                                       order)
     self.next_post_number = order + 1
     return new_post
Example #7
0
    def get_state(self):
        """

        Returns:
            False if not banned. dict of stuff if yes.
        """
        if (banned_until := self.state.get(
                'until', None)) and banned_until > (now := utcnow()):
Example #8
0
 def display(self, date=None, format=None):
     if not format:
         format = '%b %d %I:%M%p %Z'
     if not date:
         date = utcnow()
     tz = self.config['timezone']
     time = date.astimezone(tz)
     return time.strftime(format)
Example #9
0
 def make_comment(self, comment_mode=1, text=None, is_private=False):
     now = utcnow()
     if not is_private:
         self.job.public_update = now
     self.job.admin_update = now
     return self.comments.create(comment_mode=comment_mode,
                                 text=text,
                                 is_private=is_private,
                                 date_made=now)
Example #10
0
 def update_time(self, fields):
     timestamp = utcnow()
     if isinstance(fields, basestring):
         setattr(self, fields, timestamp)
         self.save(update_fields=[fields])
         return
     for field in fields:
         setattr(self, field, timestamp)
     self.save(update_fields=fields)
Example #11
0
 def set_approved(self, approver=None):
     if not approver:
         raise ValueError("Approver is not defined.")
     if self.approved:
         raise ValueError("File '%s' is already approved." % self.title)
     self.approved = True
     self.approved_by = approver
     self.date_approved = utcnow()
     self.save()
     self.character_obj.sys_msg("File '%s' is now approved." % self.title, sys_name=self.info_type.category.key)
Example #12
0
 def set(self, account, until, reason):
     new_ban = {
         'account': account,
         'until': until,
         'reason': reason,
         'started': utcnow()
     }
     self.account.attributes.add(key='ban',
                                 category='system',
                                 value=new_ban)
     self.load()
Example #13
0
 def remaining_time(self):
     if not self.timeout:
         return '(No Timeout)'
     rem_time = (self.timeout_date or self.creation_date) + self.timeout
     if rem_time > utcnow():
         rem_time = 'Timed out!'
     if not self.board.timeout:
         return '(Board Timeouts Disabled - %s)' % rem_time
     if not self.board.category.timeout:
         return '(Timeouts Disabled - %s)' % rem_time
     else:
         return '(Time Left: %s)' % rem_time
Example #14
0
    def switch_none(self):
        if not self.args:
            current_tz = self.player.player_settings.timezone
            now = utcnow().astimezone(current_tz)

            self.sys_msg("Your Current Timezone is '%s'. Is it %s where you are right now?" % (str(current_tz),
                                                                                               now.strftime('%c %Z')))
            return
        self.player.player_settings.timezone = self.args
        self.player.player_settings.save(update_fields=['timezone'])
        tz = self.player.player_settings.timezone
        self.sys_msg("Your Current Timezone is now '%s'. Is it %s where you are right now?" % (str(tz),
                                                                                               utcnow().astimezone(tz).strftime('%c %Z')))
Example #15
0
 def create_post(self, account, character, subject, text, date=None):
     if not date:
         date = utcnow()
     name = ANSIString(subject)
     if '|' in name:
         raise ValueError("Malformed ANSI in post subject!")
     cname = name.raw()
     next = self.next_post_id
     new_post = self.posts.create(account=account, character=character, name=name.clean(), cname=cname, order=next,
                                  body=text, date_created=date, date_modified=date)
     new_post.update_read(account)
     next += 1
     return new_post
Example #16
0
 def set_contents(self, newtext=None, setby=None):
     if not setby:
         raise ValueError("File setter data not found.")
     if not newtext:
         raise ValueError("No text entered to set!")
     if self.approved:
         raise ValueError("Cannot edit an approved file.")
     self.text = penn_substitutions(newtext)
     self.set_by = setby
     self.date_modified = utcnow()
     self.save()
     self.character_obj.sys_msg("File '%s' has been updated." % self.title,
                                sys_name=self.info_type.category.key)
Example #17
0
 def new(self, viewer):
     interval = utcnow() - duration('14d')
     unseen_ids = self.jobs.exclude(links__account_stub=viewer.stub)
     #updated = Q(submit_date__gte=interval)
     unseen = Q(id__in=unseen_ids)
     if self.locks.check(viewer, 'admin'):
         last = Q(links__account_stub=viewer.stub,
                  admin_update__gt=F('links__check_date'))
     else:
         last = Q(links__account_stub=viewer.stub,
                  public_update__gt=F('links__check_date'))
     jobs = self.jobs.filter(last
                             | unseen).exclude(submit_date__lt=interval)
     return jobs
Example #18
0
 def make_job(self, account, title, opening):
     now = utcnow()
     due = now + self.due
     job = self.jobs.create(title=title,
                            submit_date=now,
                            due_date=due,
                            admin_update=now,
                            public_update=now)
     job.save()
     handler = job.links.create(account_stub=account.stub,
                                link_type=3,
                                check_date=now)
     handler.make_comment(text=opening, comment_mode=0)
     handler.latest_check()
     return job
Example #19
0
 def make_post(self, character=None, subject=None, text=None, announce=True, date=None):
     if not character:
         raise ValueError("No player data to use.")
     if not text:
         raise ValueError("Text field empty.")
     if not subject:
         raise ValueError("Subject field empty.")
     if not date:
         date = utcnow()
     order = self.posts.all().count() + 1
     post = self.posts.create(owner=character, subject=subject, text=text, creation_date=date,
                              modify_date=date, timeout=self.timeout, order=order)
     if announce:
         self.announce_post(post)
     return post
Example #20
0
 def switch_list(self):
     message = []
     message.append(self.player.render.header('Available Timezones'))
     tz_list = pytz.common_timezones
     if self.args:
         tz_list = [tz for tz in tz_list if tz.lower().startswith(self.args.lower())]
     if not tz_list:
         self.error("'%s' returned no matches.")
         return
     tz_table = self.player.render.make_table(['Name', 'Current Time'], width=[35, 43])
     for zone in tz_list:
         now = utcnow().astimezone(pytz.timezone(zone))
         tz_table.add_row(zone, now.strftime('%c %Z'))
     message.append(tz_table)
     message.append(self.player.render.footer())
     self.msg_lines(message)
Example #21
0
 def display_line(self, account, admin, mode=None):
     start = f"{self.unread_star(account, admin)}{self.status_letter()}"
     num = str(self.id).rjust(4).ljust(5)
     owner_link = self.owner
     owner = str(self.owner) if owner_link else ''
     owner = owner[:15].ljust(16)
     title = self.title[:29].ljust(30)
     claimed = self.handler_names()[:12].ljust(13)
     now = utcnow().timestamp()
     last_updated = self.public_update.timestamp()
     if admin:
         last_updated = max(self.admin_update.timestamp(), last_updated)
     due = self.due_date.timestamp() - now
     if due <= 0:
         due = ANSIString("|rOVER|n")
     else:
         due = time_format(due, 1)
     due = due.rjust(6).ljust(7)
     last = time_format(now - last_updated, 1).rjust(4)
     return f"{start} {num}{owner}{title}{claimed}{due}{last}"
Example #22
0
 def display_events(self, lhs, rhs):
     if lhs:
         self.display_event(lhs)
         return
     now = utcnow()
     interval = duration_from_string('6h')
     expired = now - interval
     events = Event.objects.filter(
         date_schedule__gte=expired).order_by('date_schedule')
     tz = self.player.settings.get('timezone')
     last_day = ''
     check_day = ''
     message = list()
     message.append(
         header("Current Schedule - %s" %
                self.caller.display_local_time(format='%Z'),
                viewer=self.caller))
     for event in events:
         check_day = self.caller.display_local_time(
             date=event.date_schedule, format='%a %b %d %Y')
         if check_day != last_day:
             message.append(subheader(check_day))
         last_day = check_day
         time = self.caller.display_local_time(date=event.date_schedule,
                                               format='%I:%M%p')
         tag_mark = ' '
         taggers = set(event.interest.all())
         alts = set(self.player.get_all_characters())
         check_set = taggers.intersection(alts)
         if len(check_set):
             tag_mark = ANSIString('|C*|n')
         if self.character in taggers:
             tag_mark = ANSIString('|r*|n')
         if event.owner == self.character:
             tag_mark = ANSIString('|g*|n')
         tag_count = event.interest.all().count()
         display_string = "{}{:<2} {:<4}{:40.40}{:23.23}{:7}".format(
             tag_mark, tag_count, event.id, event.title, event.owner, time)
         message.append(display_string)
     message.append(header(viewer=self.caller))
     self.msg_lines(message)
Example #23
0
 def switch_reschedule(self, lhs, rhs):
     if not lhs:
         self.error("No scene ID entered to reschedule.")
         return
     event = Event.objects.filter(id=lhs).first()
     if not event:
         self.error("Event not found.")
         return
     if not self.caller.is_admin or event.owner != self.character:
         self.error("Permission denied.")
         return
     try:
         check_time = utc_from_string(rhs, self.character.settings.get('timezone'))
     except ValueError as err:
         self.error(unicode(err))
         return
     if not check_time > utcnow():
         self.error("No scheduling things in the past, that's just silly.")
         return
     event.reschedule(check_time)
     self.sys_msg("Rescheduled to: %s" % self.caller.display_local_time(date=check_time))
Example #24
0
 def switch_reschedule(self, lhs, rhs):
     if not lhs:
         raise ValueError("No scene ID entered to reschedule.")
         return
     event = Event.objects.filter(id=lhs).first()
     if not event:
         raise ValueError("Event not found.")
         return
     if not self.caller.is_admin or event.owner != self.character:
         raise ValueError("Permission denied.")
         return
     try:
         check_time = utc_from_string(
             rhs, self.character.settings.get('timezone'))
     except ValueError as err:
         raise ValueError(str(err))
         return
     if not check_time > utcnow():
         raise ValueError(
             "No scheduling things in the past, that's just silly.")
         return
     event.reschedule(check_time)
     self.sys_msg("Rescheduled to: %s" %
                  self.caller.display_local_time(date=check_time))
Example #25
0
 def update_post(self):
     if self.post:
         self.post.text = self.post_text()
         self.post.modify_date = utcnow()
         self.post.save(update_fields=['text', 'modify_date'])
Example #26
0
 def latest_check(self):
     self.check_date = utcnow()
Example #27
0
 def active(self):
     interval = utcnow() - duration('7d')
     return self.jobs.filter(
         Q(status=0, close_date=None)
         | Q(close_date__gte=interval)).order_by('id').reverse()
Example #28
0
                ) or not enactor.check_lock("pperm(Admin)"):
            raise ValueError("Permission denied.")
        account = self.find_account(account)
        if not account.db._disabled:
            raise ValueError("Account is not disabled!")
        del account.db._disabled
        entities = {'enactor': enactor, 'account': account}
        amsg.EnableMessage(entities).send()

    def ban_account(self, session, account, duration, reason):
        if not (enactor := session.get_account()
                ) or not enactor.check_lock("pperm(Moderator)"):
            raise ValueError("Permission denied.")
        account = self.find_account(account)
        duration = duration_from_string(duration)
        ban_date = utcnow() + duration
        if not reason:
            raise ValueError("Must include a reason!")
        account.db._banned = ban_date
        account.db._ban_reason = reason
        entities = {'enactor': enactor, 'account': account}
        amsg.BanMessage(entities,
                        duration=time_format(duration.total_seconds(),
                                             style=2),
                        ban_date=ban_date.strftime('%c'),
                        reason=reason).send()
        account.force_disconnect(reason)

    def unban_account(self, session, account):
        if not (enactor := session.get_account()
                ) or not enactor.check_lock("pperm(Moderator)"):
Example #29
0
 def save(self, *args, **kwargs):
     self.creation_date = utcnow()
     return super(Message, self).save(*args, **kwargs)
Example #30
0
    def switch_jobs(self):

        # Step one is importing all of the Job Categories from the MUSH data. Each category is a THING object
        # So we don't need mysql just yet.
        cat_dict = dict()
        old_categories = cobj('jobdb').children.all()
        for old_cat in old_categories:
            new_cat, created = JobCategory.objects.get_or_create(key=old_cat.name)
            if created:
                new_cat.setup()
            cat_dict[old_cat.objid] = new_cat

        # Establishing Mysql Connection!
        from commands.mysql import sql_dict
        db = MySQLdb.connect(host=sql_dict['site'], user=sql_dict['username'],
                             passwd=sql_dict['password'], db=sql_dict['database'], cursorclass=cursors.DictCursor)
        c = db.cursor()

        # Our next order of business is retrieving all of the players who've ever posted jobs.
        # This section searches the database by OBJID and creates a dictionary that links the old jobsys player_id
        # to the new communications.ObjectStub, creating them if necessary.
        c.execute("""SELECT * from jobsys_players""")
        old_players = c.fetchall()
        char_dict = dict()
        for old_player in old_players:
            match = objmatch(old_player['objid'])
            if match:
                char = match.obj
            else:
                key = old_player['player_name']
                char = create.create_object(typeclass='classes.characters.BaseCharacter', key=key)
                objid = old_player['objid']
                dbref, csecs = objid.split(':', 1)
                cdate = from_unixtimestring(csecs)
                MushObject.objects.create(objid=objid, dbref=dbref, created=cdate, type=8, recreated=1, obj=char)
            char_dict[old_player['player_id']] = char

        # Now that we have the Player ID->Stub dictionary, we can begin the process of actually importing job data!
        # we only want the jobs from categories that actually exist. Probably rare that any of them wouldn't be, but
        # just in case...
        cat_list = ', '.join("'%s'" % cat for cat in cat_dict.keys())
        c.execute("""SELECT * from jobsys_jobs WHERE job_objid IN (%s) ORDER BY job_id""" % cat_list)
        old_jobs = c.fetchall()
        for row in old_jobs:
            job_id = row['job_id']
            if row['close_date']:
                close_date = row['close_date'].replace(tzinfo=pytz.utc)
            else:
                close_date = None
            if row['due_date']:
                due_date = row['due_date'].replace(tzinfo=pytz.utc)
            else:
                due_date = None
            if row['submit_date']:
                submit_date = row['submit_date'].replace(tzinfo=pytz.utc)
            else:
                submit_date = None
            title = row['job_title']
            status = row['job_status']
            owner = char_dict[row['player_id']]
            text = penn_substitutions(row['job_text'])
            category = cat_dict[row['job_objid']]

            handler_dict = dict()
            # We have our job row data prepped! Now to create the job and its opening comment as well as the owner-handler.
            new_job = category.jobs.create(title=title, submit_date=submit_date, due_date=due_date,
                                           close_date=close_date, status=status)
            new_owner = new_job.characters.create(character=owner, is_owner=True, check_date=utcnow())
            new_owner.comments.create(text=text, date_made=submit_date)
            handler_dict[row['player_id']] = new_owner

            # Here it's time to import all of the job's claims, handlers, watchers, and create JobHandler rows for them.
            c.execute("""SELECT * from jobsys_claim WHERE job_id=%s""", (job_id,))
            claim_data = c.fetchall()
            for old_claim in claim_data:
                stub = char_dict[old_claim['player_id']]
                new_handler, created = new_job.characters.get_or_create(character=stub, check_date=utcnow())
                if old_claim['claim_mode'] == 0:
                    new_handler.is_handler = True
                if old_claim['claim_mode'] == 1:
                    new_handler.is_helper = True
                new_handler.save()
                handler_dict[old_claim['player_id']] = new_handler

            # Unfortunately it's also possible that people who didn't claim it might also need JobHandler entries so...
            c.execute("""SELECT DISTINCT player_id from jobsys_comments WHERE job_id=%s""", (job_id,))
            all_speakers = c.fetchall()
            for speaker in all_speakers:
                if speaker['player_id'] not in handler_dict:
                    new_handler, created = new_job.characters.get_or_create(character=char_dict[speaker['player_id']],
                                                                            check_date=utcnow())
                    handler_dict[speaker['player_id']] = new_handler

            # And another round. This time it's a matter of importing handlers for anyone who ever CHECKED a job.
            # Here we'll also import everyone's 'last date they checked the job'.
            c.execute("""SELECT * FROM jobsys_check WHERE job_id=%s""", (job_id,))
            old_checks = c.fetchall()
            for check in old_checks:
                if check['player_id'] not in handler_dict:
                    handler, created = new_job.characters.get_or_create(character=char_dict[check['player_id']],
                                                                        check_date=utcnow())
                    handler_dict[check['player_id']] = new_handler
                else:
                    handler = handler_dict[check['player_id']]
                handler.check_date = check['check_date'].replace(tzinfo=pytz.utc)
                handler.save(update_fields=['check_date'])

            # Now to import all of the comments and replies.
            c.execute("""SELECT * from jobsys_comments WHERE job_id=%s ORDER BY comment_id""", (job_id,))
            old_comments = c.fetchall()
            for old_com in old_comments:
                handler = handler_dict[old_com['player_id']]
                comment_text = penn_substitutions(old_com['comment_text'])
                comment_date = old_com['comment_date'].replace(tzinfo=pytz.utc)
                private = old_com['comment_type']
                handler.comments.create(text=comment_text, date_made=comment_date, is_private=private)
        db.close()
Example #31
0
 def update_last_played(self):
     self.last_played = utcnow()
     self.save(update_fields=['last_played'])
Example #32
0
 def update_read(self, account):
     acc_read, created = self.read.get_or_create(account=account)
     acc_read.date_read = utcnow()
     acc_read.save()
Example #33
0
 def expired(self):
     return (self.creation_date + self.expires) < utcnow()