Пример #1
0
    def setUp(self):
        super(PeriodsTestCase, self).setUp()

        # setup some periods
        self.start = datetime(2000, 1, 1, 0)
        self.end   = self.start + timedelta(hours = 12)
        times = [(datetime(2000, 1, 1, 0), 5.0, "one", "S")
               , (datetime(2000, 1, 1, 5), 3.0, "two", "P")
               , (datetime(2000, 1, 1, 8), 4.0, "three", "S")
               ]
        self.ps = []
        for start, dur, name, st in times:
            s = create_sesshun()
            s.name = name
            s.save()
            scheduled = dur if st == "S" else 0.0
            pa = Period_Accounting(scheduled = scheduled)
            pa.save()
            state = Period_State.objects.get(abbreviation = st)
            p = Period( session    = s
                      , start      = start
                      , duration   = dur
                      , state      = state
                      , accounting = pa
                      )
            p.save()
            self.ps.append(p)
Пример #2
0
    def setUp(self):
        super(TestProposal, self).setUp()

        # this project has no allotments!
        self.project = DSSProject.objects.order_by('pcode').all()[0]

        # setup some periods
        self.start = datetime(2000, 1, 1, 0)
        self.end   = self.start + timedelta(hours = 12)
        times = [(datetime(2000, 1, 1, 0), 5.0, "one")
               , (datetime(2000, 1, 1, 5), 3.0, "two")
               , (datetime(2000, 1, 1, 8), 4.0, "three")
               ]
        self.ps = []
        state = DSSPeriod_State.objects.get(abbreviation = 'P')
        for start, dur, name in times:
            # each session has grade 4, time = 3 
            s = create_sesshun()
            s.name = name
            s.save()
            pa = DSSPeriod_Accounting(scheduled = dur)
            pa.save()
            p = DSSPeriod( session    = s
                      , start      = start
                      , duration   = dur
                      , state      = state
                      , accounting = pa
                      )
            p.save()
            self.ps.append(p)


        # Okay, now set up the corresponding proposal
        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        sqlResult = { 'PROP_ID' : self.project.pcode
                    , 'PROPOSAL_TYPE' : 'Regular'
                    , 'STATUS' : 'Draft'
                    , 'SUBMITTED_DATE' : now 
                    , 'CREATED_DATE' : now 
                    , 'MODIFIED_DATE' : now 
                    , 'TITLE' : 'Lynrd Sknyrd'
                    , 'ABSTRACT' : 'What song do you wanna hear?'
                    , 'proposal_id' : 0
                    , 'JOINT_PROPOSAL_TYPE' : 'Not a joint Proposal'
                    }
        proposal = Proposal.createFromSqlResult(sqlResult)
        proposal.dss_project = self.project
        proposal.setSemester(self.project.semester.semester)
        proposal.save()
        self.proposal = proposal

        self.ta = TimeAccounting()
Пример #3
0
    def read(self, request, *args, **kws):
        if len(args) == 1:
            tz,          = args
            startPeriods = request.GET.get("startPeriods", datetime.now().strftime("%Y-%m-%d"))
            daysPeriods  = request.GET.get("daysPeriods",  '14')

            dt           = TimeAgent.str2dt(startPeriods)
            start        = dt if tz == 'UTC' else TimeAgent.est2utc(dt)
            duration     = int(daysPeriods) * 24 * 60
            periods      = Period.get_periods(start, duration)
            pjson = [DssPeriodHttpAdapter(p).jsondict(tz) for p in periods]
            return HttpResponse(
                json.dumps(dict(total   = len(periods)
                              , periods = pjson
                              , success = 'ok'))
              , content_type = "application/json")
        else:
            tz, id = args
            p      = Period.objects.get(id = id)
            return HttpResponse(
                json.dumps(dict(DssPeriodHttpAdapter(p).jsondict(tz)
                              , success = 'ok'))
              , content_type = "application/json")
Пример #4
0
    def get_maintenance_activity_set2(self):
        """
        Returns a set of maintenance activities occuring during this
        group's duration, in time order.
        """

        unscheduled_maintenance = "Unscheduled Maintenance"

        if not self.period or self.period.session.name == unscheduled_maintenance:
            mas = self.maintenance_activity_set.all()
        else:
            # To handle repeat maintenance activity objects:
            period = self.period

            # Get the templates:
            repeatQ = models.Q(deleted = False) \
                & (models.Q(repeat_interval = 1) \
                       | models.Q(repeat_interval = 7) \
                       | models.Q(repeat_interval = 30)) \
                       & (models.Q(_start__lte = period.end()) \
                              & models.Q(repeat_end__gte = period.end()))

            # Get the time period
            start_endQ = models.Q(start__gte = period.start) \
                & models.Q(start__lte = period.end())
            today = TimeAgent.truncateDt(period.start)
            # Get other groups today.  They will be used below to see
            # if any of them is a better fit.  We must exclude any
            # possible emergency maintenance periods:
            other_groups_today = Maintenance_Activity_Group.objects\
                .filter(period__start__gte = today)\
                .filter(period__start__lt = today + timedelta(1))\
                .exclude(id = self.id) \
                .exclude(period__session__name = unscheduled_maintenance)

            groupQ  = models.Q(group = self)
            dbmas   = Maintenance_Activity.objects.filter(groupQ)
            dbrmas  = Maintenance_Activity.objects.filter(repeatQ)
            mas     = [i for i in dbmas if not i.is_repeat_template()]
            rmas    = [i for i in dbrmas]

            # rmas is the list repeating activity templates that may
            # apply for this period.  We need clones of these to
            # include in mas.  If however there are already clones in
            # mas, we'll want to skip that template.  We will also
            # skip the template if there is a better candidate
            # maintenance activity group on this day (by better, a
            # better match in time, defined by the activity's start
            # time being within the maintenance activity group's time
            # span).

            x = []

            for i in rmas:
                for j in mas:
                    if j.repeat_template == i:
                        x.append(i)

                for g in other_groups_today:
                    if i.get_start().time() >= g.get_start().time() \
                            and i.get_start().time() < g.get_end().time():
                        x.append(i)


            # Weekly repeats have a problem: what if the repeat falls on a
            # day that is not a maintenance day?  Where should we put it?
            # One strategy is to examine the maintenance periods from 3
            # days in the past to 3 days into the future.  if none of
            # those is more suitable, we keep the weekly activity here. If
            # there is a tie, we favor the earlier date. This is done by
            # taking the modulo 7 of start - maintenance_activity.start
            # and mapping it to the values in 'dm'.  Lowest value wins.

            dm = {4: 30, 5: 20, 6: 10, 0: 0, 1: 15, 2: 25, 3: 35}
            delta = timedelta(days = 3)
            today = TimeAgent.truncateDt(period.start)
            p = Period.get_periods_by_observing_type(today - delta,
                                                     today + delta,
                                                     "maintenance")

            for i in rmas:
                if i.repeat_interval > 1:
                    start_date = TimeAgent.truncateDt(i.get_start())
                    diff = (today - start_date).days % i.repeat_interval

                    if diff:
                        # doesn't fall on this date.  Is this the closest
                        # period though?

                        if diff > 6:     # monthly not due
                            x.append(i)
                        else:            # weekly or monthly that is due this week
                            for j in p:
                                if j != period:  # check only other periods
                                    mod = (j.start.date() \
                                               - start_date.date()).days \
                                               % i.repeat_interval

                                    # Test to see if it's a better fit in
                                    # another period.  and if so, don't
                                    # use here.
                                    if mod < 7 and dm[mod] < dm[diff]:
                                        x.append(i)
                                        break

            # Now that we have a list of templates that are not suitable,
            # cull the template list:
            for i in x:
                if i in rmas:
                    rmas.remove(i)

            # The remaining templates may be used:
            for i in rmas:
                ma = i.clone(self)
                mas.append(ma)

        # remove all activities marked deleted.  This must be done
        # after all the above to prevent a replacement being generated
        # for a deleted activity, for repeat activities.
        mas = [i for i in mas if not i.deleted]
        mas.sort(cmp = lambda x, y: cmp(x.get_start(),
                                        y.get_start()))

        return mas
Пример #5
0
    def read(self, request, *args, **kws):

        tz = args[0]
        # one or many?
        if len(args) == 1:
            # we are getting periods from within a range of dates
            sortField = jsonMap.get(request.GET.get("sortField", "start"), "start")
            order = "-" if request.GET.get("sortDir", "ASC") == "DESC" else ""

            # Either filter by date, or by something else.
            filterWnd = request.GET.get("filterWnd", None)

            # make sure we have defaults for dates
            defStart = datetime.now().strftime("%Y-%m-%d") if filterWnd is None else None
            defDays = "1" if filterWnd is None else None

            # Filtering by date involves a pair of keywords
            filterWnd = request.GET.get("filterWnd", None)
            filterElc = request.GET.get("filterElc", None)

            # make sure we have defaults for dates
            defStart = datetime.now().strftime("%Y-%m-%d") if filterWnd is None and filterElc is None else None
            defDays = "1" if filterWnd is None and filterElc is None else None

            startPeriods = request.GET.get("startPeriods", defStart)
            daysPeriods = request.GET.get("daysPeriods", defDays)

            if startPeriods is not None and daysPeriods is not None:
                if startPeriods is None:
                    startPeriods = datetime.now().strftime("%Y-%m-%d")
                if daysPeriods is None:
                    daysPeriods = "1"
                dt = TimeAgent.str2dt(startPeriods)
                start = dt if tz == "UTC" else TimeAgent.est2utc(dt)
                duration = int(daysPeriods) * 24 * 60
                periods = Period.get_periods(start, duration)
            else:
                # filter by something else
                query_set = Period.objects

                # window id
                # filterWnd = request.GET.get("filterWnd", None)
                if filterWnd is not None:
                    wId = int(filterWnd)
                    query_set = query_set.filter(window__id=wId)

                # elective id
                # filterElc = request.GET.get("filterElc", None)
                if filterElc is not None:
                    eId = int(filterElc)
                    query_set = query_set.filter(elective__id=eId)

                periods = query_set.order_by(order + sortField)

            return HttpResponse(
                json.dumps(
                    dict(total=len(periods), periods=[PeriodHttpAdapter(p).jsondict(tz) for p in periods], success="ok")
                ),
                content_type="application/json",
            )
        else:
            # we're getting a single period as specified by ID
            p_id = int(args[1])
            # p       = Period.objects.get(id = p_id)
            p = get_object_or_404(Period, id=p_id)
            adapter = PeriodHttpAdapter(p)
            return HttpResponse(
                json.dumps(dict(period=adapter.jsondict(tz), success="ok")), content_type="application/json"
            )