Пример #1
0
def create_workshift_instances(sender, instance, created, **kwargs):
    shift = instance
    from workshift import utils
    if shift.active:
        utils.make_instances(shift.pool.semester, shifts=[instance])
    else:
        delete_workshift_instances(sender=sender, instance=shift)
Пример #2
0
def create_workshift_instances(sender, instance, created, **kwargs):
    shift = instance
    if shift.active:
        if created:
            # Make instances for newly created shifts
            utils.make_instances(shift.pool.semester, shifts=[shift])
    else:
        WorkshiftInstance.objects.filter(weekly_workshift=shift, closed=False).delete()
Пример #3
0
 def save(self):
     prev_shift = self.instance
     new = prev_shift.pk is None
     shift = super(RegularWorkshiftForm, self).save()
     if not new:
         # Nuke all future instances and just re-create them anew
         WorkshiftInstance.objects.filter(weekly_workshift=shift, closed=False).delete()
         utils.make_instances(semester=self.semester, shifts=[shift])
     else:
         utils.make_instances(semester=self.semester, shifts=[shift])
     return shift
Пример #4
0
def pre_process_shift(sender, instance, update_fields=None, **kwargs):
    shift = instance

    # Set week_long if day not set
    shift.week_long = shift.day not in [i[0] for i in DAY_CHOICES]

    # Create instances if shift is being changed from inactive to active
    if shift.id and shift.active:
        old_shift = sender.objects.get(pk=shift.id)
        if _check_field_changed(shift, old_shift, "active", update_fields=update_fields):
            utils.make_instances(shift.pool.semester, shifts=[shift])
Пример #5
0
def fill_regular_shifts(regular_hours=5, semester=None):
    if semester is None:
        semester = _get_semester()

    _fill_workshift_types()

    # Regular Weekly Workshift Hours
    pool, created = WorkshiftPool.objects.get_or_create(
        semester=semester,
        is_primary=True,
        defaults=dict(hours=regular_hours, any_blown=True),
        )

    if created:
        pool.managers = Manager.objects.filter(workshift_manager=True)
        pool.save()

    make_workshift_pool_hours(semester, pools=[pool])

    # Regular Workshifts
    for type_title, hours, days, count, start, end in REGULAR_WORKSHIFTS:
        wtype = WorkshiftType.objects.get(title=type_title)
        for day in days:
            RegularWorkshift.objects.get_or_create(
                workshift_type=wtype,
                pool=pool,
                day=day,
                start_time=start,
                end_time=end,
                defaults=dict(
                    count=count,
                    hours=hours,
                    ),
                )

    for type_title, hours, count in WEEK_LONG:
        wtype = WorkshiftType.objects.get(title=type_title)
        RegularWorkshift.objects.get_or_create(
            workshift_type=wtype,
            pool=pool,
            count=count,
            week_long=True,
            defaults=dict(
                start_time=None,
                end_time=None,
                hours=hours,
                ),
            )


    make_instances(semester=semester)
    make_manager_workshifts(semester)
Пример #6
0
    def test_make_instances(self):
        wtype = WorkshiftType.objects.create(
            title="Test Make Instances",
            )
        # Disconnect the handler and run make_instances ourselves
        models.signals.post_save.disconnect(
            signals.create_workshift_instances, sender=RegularWorkshift
        )

        shift = RegularWorkshift.objects.create(
            workshift_type=wtype,
            pool=self.p1,
            day=4,
            hours=7,
        )

        shift.current_assignees = [self.profile]

        today = localtime(now()).date()
        WorkshiftInstance.objects.create(
            weekly_workshift=shift,
            date=today - timedelta(today.weekday()),
        )
        instances = utils.make_instances(
            semester=self.semester,
            shifts=[shift],
        )

        models.signals.post_save.connect(
            signals.create_workshift_instances, sender=RegularWorkshift
        )

        for instance in instances:
            self.assertEqual(wtype.title, instance.title)
            self.assertEqual(shift, instance.weekly_workshift)
            self.assertEqual(shift.hours, instance.hours)
            self.assertEqual(shift.hours, instance.intended_hours)
            self.assertEqual(1, instance.logs.count())

        self.assertEqual(
            set([shift.day]),
            set(i.date.weekday() for i in instances),
        )
Пример #7
0
def main(args):
    # Add Managers
    for title, compensation, hours, email, duties in MANAGERS:
        Manager.objects.create(
            title=title,
            compensation=compensation,
            semester_hours=str(hours),
            summer_hours=str(hours),
            duties=duties,
            email="{0}{1}@bsc.coop".format(settings.HOUSE_ABBREV, email) if email else "",
            president="president" in title.lower(),
            workshift_manager="workshift" in title.lower(),
            )

    # Add Requests
    for name, managers, glyphicon in REQUESTS:
        r = RequestType.objects.create(
            name=name,
            glyphicon=glyphicon,
            )
        r.managers = [Manager.objects.get(title=i) for i in managers]
        r.save()

    if "workshift" in settings.INSTALLED_APPS:
        # Start the Workshift Semester
        year, season = get_year_season()
        start_date, end_date = get_semester_start_end(year, season)
        semester = Semester.objects.create(
            year=year,
            season=season,
            start_date=start_date,
            end_date=end_date,
            )

        for uprofile in UserProfile.objects.filter(status=UserProfile.RESIDENT):
            profile = WorkshiftProfile.objects.create(
                user=uprofile.user,
                semester=semester,
                )

        # Regular Weekly Workshift Hours
        pool = WorkshiftPool.objects.create(
            semester=semester,
            is_primary=True,
            hours=5,
            any_blown=True,
            )
        pool.managers = Manager.objects.filter(workshift_manager=True)
        pool.save()

        # HI Hours
        hi_pool = WorkshiftPool.objects.create(
            title="Home Improvement",
            semester=semester,
            hours=str(4),
            weeks_per_period=0,
            )
        hi_pool.managers = Manager.objects.filter(title="Maintenance Manager")
        hi_pool.save()

        # Social Hours
        social_pool = WorkshiftPool.objects.create(
            title="Social",
            semester=semester,
            hours=str(1),
            weeks_per_period=6,
            )
        social_pool.managers = Manager.objects.filter(title="Social Manager")
        social_pool.save()

        # Humor Shift
        humor_pool = WorkshiftPool.objects.create(
            title="Humor Shift",
            semester=semester,
            any_blown=True,
            hours=str(2),
            weeks_per_period=6,
            )
        humor_pool.managers = Manager.objects.filter(workshift_manager=True)
        humor_pool.save()

        make_workshift_pool_hours(semester)

        # Workshift Types
        for title, description, quick_tips, hours, rateable in WORKSHIFT_TYPES:
            WorkshiftType.objects.create(
                title=title,
                description=description,
                quick_tips=quick_tips,
                hours=str(hours),
                rateable=rateable,
                )

        # Regular Workshifts
        for title, type_title, days, count, start, end in REGULAR_WORKSHIFTS:
            wtype = WorkshiftType.objects.get(title=type_title)
            shift = RegularWorkshift.objects.create(
                workshift_type=wtype,
                title=title,
                pool=pool,
                count=count,
                start_time=start,
                end_time=end,
                hours=wtype.hours,
                )
            shift.days = get_int_days(days)
            shift.save()

        for title, type_title, count in WEEK_LONG:
            wtype = WorkshiftType.objects.get(title=type_title)
            shift = RegularWorkshift.objects.create(
                workshift_type=wtype,
                title=title,
                pool=pool,
                count=count,
                week_long=True,
                start_time=None,
                end_time=None,
                hours=wtype.hours,
                )

        # Humor Workshifts
        for title, type_title, days, start, end in HUMOR_WORKSHIFTS:
            wtype = WorkshiftType.objects.get(title=type_title)
            shift = RegularWorkshift.objects.create(
                workshift_type=wtype,
                title=title,
                pool=humor_pool,
                start_time=start,
                end_time=end,
                hours=wtype.hours,
                )
            shift.days = get_int_days(days)
            shift.save()

        make_instances(semester=semester)
        make_manager_workshifts(semester)
Пример #8
0
def main(args, verbose=True):
    # Add Managers
    managers = 0
    for title, compensation, hours, email, duties in MANAGERS:
        created = Manager.objects.get_or_create(
            title=title,
            defaults=dict(
                compensation=compensation,
                semester_hours=hours,
                summer_hours=hours,
                duties=duties,
                email="{0}{1}@bsc.coop".format(settings.HOUSE_ABBREV, email) if email else "",
                president="president" in title.lower(),
                workshift_manager="workshift" in title.lower(),
                ),
            )[1]
        if created:
            managers += 1

    if verbose:
        print("Created {0} managers".format(managers))

    # Add Requests
    requests = 0
    for name, managers, glyphicon in REQUESTS:
        r, created = RequestType.objects.get_or_create(
            name=name,
            defaults=dict(
                glyphicon=glyphicon,
                ),
            )

        if created:
            r.managers = [Manager.objects.get(title=i) for i in managers]
            r.save()
            requests += 1

    if verbose:
        print("Created {0} request types".format(requests))

    if "workshift" in settings.INSTALLED_APPS:
        # Start the Workshift Semester
        year, season = get_year_season()
        start_date, end_date = get_semester_start_end(year, season)
        try:
            semester = Semester.objects.get(current=True)
        except Semester.DoesNotExist:
            semester, created = Semester.objects.get_or_create(
                year=year,
                season=season,
                defaults=dict(start_date=start_date, end_date=end_date),
                )
        else:
            created = False

        if created and verbose:
            print("Started a new workshift semester")

        # Regular Weekly Workshift Hours
        pool, created = WorkshiftPool.objects.get_or_create(
            semester=semester,
            is_primary=True,
            defaults=dict(hours=5, any_blown=True),
            )
        if created:
            pool.managers = Manager.objects.filter(workshift_manager=True)
            pool.save()

        # HI Hours
        hi_pool, created = WorkshiftPool.objects.get_or_create(
            title="Home Improvement",
            semester=semester,
            defaults=dict(hours=4, weeks_per_period=0),
            )
        if created:
            hi_pool.managers = Manager.objects.filter(title="Maintenance Manager")
            hi_pool.save()

        # Social Hours
        social_pool, created = WorkshiftPool.objects.get_or_create(
            title="Social",
            semester=semester,
            defaults=dict(hours=1, weeks_per_period=0),
            )
        if created:
            social_pool.managers = Manager.objects.filter(title="Social Manager")
            social_pool.save()

        # Humor Shift
        humor_pool, created = WorkshiftPool.objects.get_or_create(
            title="Humor Shift",
            semester=semester,
            defaults=dict(any_blown=True, hours=2, weeks_per_period=6),
            )
        if created:
            humor_pool.managers = Manager.objects.filter(workshift_manager=True)
            humor_pool.save()

        make_workshift_pool_hours(semester)

        # Workshift Types
        for title, description, quick_tips, rateable in WORKSHIFT_TYPES:
            WorkshiftType.objects.get_or_create(
                title=title,
                defaults=dict(
                    description=description,
                    quick_tips=quick_tips,
                    rateable=rateable,
                    ),
                )

        # Regular Workshifts
        for type_title, hours, days, count, start, end in REGULAR_WORKSHIFTS:
            wtype = WorkshiftType.objects.get(title=type_title)
            for day in days:
                RegularWorkshift.objects.get_or_create(
                    workshift_type=wtype,
                    pool=pool,
                    day=day,
                    start_time=start,
                    end_time=end,
                    defaults=dict(
                        count=count,
                        hours=hours,
                        ),
                    )

        for type_title, hours, count in WEEK_LONG:
            wtype = WorkshiftType.objects.get(title=type_title)
            RegularWorkshift.objects.get_or_create(
                workshift_type=wtype,
                pool=pool,
                count=count,
                week_long=True,
                defaults=dict(
                    start_time=None,
                    end_time=None,
                    hours=hours,
                    ),
                )

        # Humor Workshifts
        for type_title, hours, days, start, end in HUMOR_WORKSHIFTS:
            wtype = WorkshiftType.objects.get(title=type_title)
            for day in days:
                RegularWorkshift.objects.get_or_create(
                    workshift_type=wtype,
                    pool=humor_pool,
                    day=day,
                    defaults=dict(
                        start_time=start,
                        end_time=end,
                        hours=hours,
                        ),
                    )

        make_instances(semester=semester)
        make_manager_workshifts(semester)