Python DateTime.dow方法代码示例

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import dow [as 别名]
    def getDateRangeFromWeek(self, start_week, start_year, end_week=None, end_year=None):
        """Returns tuple of DateTime. Compute this tuple from weeks. A week
        begins monday and ends sunday.
        """
        if end_week is None:
            end_week = start_week

        if end_year is None:
            end_year = start_year

        # Get first day of start year
        date_first_day = DateTime(start_year, 1, 1)
        day_minus = (date_first_day.dow() - 1) % 7
        day_plus = 0
        start_day = (start_week * 7) - 6 - day_minus
        start_date = DateTime(start_year, start_day)

        if start_date.week() != start_week:
            day_plus = 7
            start_date = start_date + day_plus

        # Get first day of end year
        date_first_day = DateTime(end_year, 1, 1)
        day_minus = (date_first_day.dow() - 1) % 7
        end_day = (end_week * 7) - day_minus + day_plus
        end_date = DateTime(end_year, end_day)

        # Finished at 23:59:59
        end_date = DateTime(end_date.year(),
                      end_date.month(),
                      end_date.day(),
                      23, 59, 59)

        return (start_date, end_date)

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import dow [as 别名]
    def getAny(self,query_year=None):
        """
        """

        hores_s = ['horesatreballargeneriques','horesatreballar','horestreballades','horesimputables','horesimputades','horespendents','horesvacances','horespermisos']
        query = self.request.get('query',query_year)
        start_date = query==None and ('01','01',self.now[2]) or tuple(query.split('-')[::-1])
        year = start_date[2]
        start_month = int(start_date[1])
        start_day = start_date[0]

        fdom = DateTime('%s-01-01' % (year))
        fdom_dow = fdom.dow()==0 and 7 or fdom.dow()
        fdow = addDays(fdom,(fdom_dow*-1)+1)

        needHistoric = self.needHistoric(self.now,DateTimeToTT(fdom))
        dies = self.getDies(needHistoric,first_day=fdom,last_day=lastDayOfYear(fdom))


        mesos = []

        #inicialitzar totes les variables d'hores a 0
        totals = {}
        for hs in hores_s:
            totals[hs]='00:00'

        for nummonth in range(1,13):
            startday = start_month==nummonth and start_day or '01'
            query_date = '%s-%02d-%s' % (year,nummonth,startday)
            print query_date
            newneedHistoric = self.needHistoric(self.now,DateTimeToTT(DateTime(query_date)))
            if newneedHistoric!=needHistoric:
                needHistoric = newneedHistoric
                dtq = DateTime(query_date)
                dies = self.getDies(needHistoric,first_day=dtq,last_day=lastDayOfYear(dtq))
            mes = self.getMes(query_date=query_date,dies_param=dies)

            if nummonth<start_month:
                # incialitzar les varibles d'hores del mes a 0 si estem filtrant
                for hs in hores_s:
                    mes[hs]='00:00'                                                          

            mes['query_date']=query_date

            # suma totes les variables d'hores de cada mes als totals
            for hs in hores_s:
                totals[hs]=sumaHM(totals[hs],mes[hs])

            mesos.append(mes)

        totals['horespendents']=MinutsAHM(HMaMinuts(totals['horesatreballar'])-HMaMinuts(totals['horestreballades']))

        minutsvacances = HMaMinuts(totals['horesvacances'])
        diesvacances = minutsvacances/(7*60)
        restahoresvacances = (minutsvacances - (diesvacances*7*60))/60
        totals['dv']=diesvacances
        totals['hv']=restahoresvacances

        return dict(title=year,mesos=mesos,totals=totals)

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import dow [as 别名]
    def getMes(self,query_date=None, dies_param=None):
        """
        """
        self.options = self.epiUtility.getEPIOptions(self.request, self.username)
        self.descompte_descans = self.options['descomptar_30'] and 30 or 0


        query = query_date==None and self.request.get('query','%s-%s-%s' % (self.now[2],self.now[1],'01')) or query_date
        base = query==None and DateTime() or DateTime(query)
        base = base.earliestTime()

        fdom = DateTime('%d-%02d-%02d' % (base.year(), base.month(), base.day()) )
        fdom_dow = fdom.dow()==0 and 7 or fdom.dow()
        fdow = addDays(fdom,(fdom_dow*-1)+1)
        week = 0

        # Si estem executant la vista anual, ja haurem recollit els dies, i els tindrem a dies_param
        # d'aquesta manera ens evitem les inicialitzacions de presencia i gestor que es fan a getDies, (tot i cachejades, cnosumeixen algun segon)
        # i fem 1 única petició per tot l'historic
        dies = dies_param==None and self.getDies(self.needHistoric(self.now,DateTimeToTT(fdom)),first_day=fdom,last_day=lastDayOfMonth(fdom)) or dies_param

        setmanes = []

        mes = dict( id='%d%s' % (base.year(), base.month().__str__().rjust(2,'0')),
                    monthname=MONTH_NAMES[base.Month()],
                    year=base.year(),
                    horesatreballargeneriques='00:00',
                    horestreballades='00:00',
                    horesatreballar='00:00',
                    horesimputades='00:00',
                    horesimputables='00:00',
                    horespermisos='00:00',
                    horesvacances='00:00',
                    setmanes = [],
                    mesanterior = self.getPreviousMonth(fdom),
                    messeguent = fdom.year()!=self.now[2] and self.getNextMonth(fdom) or None
                    )
        while fdow.month()==base.month() or week==0:
            setmana = self.getSetmana(dies,fdow,day_filter=base)
            if setmana['dies']!=[]:
                setmanes.insert(0,setmana)
                mes['horesatreballar']=sumaHM(mes['horesatreballar'],setmana['horesatreballar'])
                mes['horesatreballargeneriques']=sumaHM(mes['horesatreballargeneriques'],setmana['horesatreballargeneriques'])
                mes['horestreballades']=sumaHM(mes['horestreballades'],setmana['horestreballades'])
                mes['horesimputables']=sumaHM(mes['horesimputables'],setmana['horesimputables'])
                mes['horesimputades']=sumaHM(mes['horesimputades'],setmana['horesimputades'])
                mes['horespermisos']=sumaHM(mes['horespermisos'],setmana['horespermisos'])
                mes['horesvacances']=sumaHM(mes['horesvacances'],setmana['horesvacances'])
            week = week+1
            fdow = addDays(fdow,7)
        mes['setmanes']=setmanes
        try:
            mes['percentatgeimputat']= '%.1f' % ( (HMaMinuts(mes['horesimputades'])*100)/HMaMinuts(mes['horesimputables']) )
        except:
            mes['percentatgeimputat']= 0
        mes['horespendents'] = MinutsAHM(HMaMinuts(mes['horesatreballar'])-HMaMinuts(mes['horestreballades']))
        return mes

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import dow [as 别名]
 def getMonthGrid(self, month):
     '''Creates a list of lists of DateTime objects representing the calendar
        grid to render for a given p_month.'''
     # Month is a string "YYYY/mm".
     currentDay = DateTime('%s/01 12:00' % month)
     currentMonth = currentDay.month()
     res = [[]]
     dayOneNb = currentDay.dow() or 7 # This way, Sunday is 7 and not 0.
     if dayOneNb != 1:
         previousDate = DateTime(currentDay)
         # If the 1st day of the month is not a Monday, start the row with
         # the last days of the previous month.
         for i in range(1, dayOneNb):
             previousDate = previousDate - 1
             res[0].insert(0, previousDate)
     finished = False
     while not finished:
         # Insert currentDay in the grid
         if len(res[-1]) == 7:
             # Create a new row
             res.append([currentDay])
         else:
             res[-1].append(currentDay)
         currentDay = currentDay + 1
         if currentDay.month() != currentMonth:
             finished = True
     # Complete, if needed, the last row with the first days of the next
     # month.
     if len(res[-1]) != 7:
         while len(res[-1]) != 7:
             res[-1].append(currentDay)
             currentDay = currentDay + 1
     return res

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import dow [as 别名]
    def lectureTakesPlace(self, datetime=None):
        """
        Return True if the lecture takes place on the given date. If
        no date is specified, the current date will be used.

        TODO: Currently not implemented for monthly and yearly recurrence.
        """
        
        result = False
        if not datetime:
            datetime = DateTime()

        if datetime >= self.startDate.earliestTime() \
               and datetime <= self.endDate.latestTime():
            if self.recurrence == NO_RECURRENCE:
                result = self.startDate.isCurrentDay()
            elif self.recurrence == DAILY:
                result = True
            elif self.recurrence == WEEKLY:
                result = datetime.dow() == self.startDate.dow()
            elif self.recurrence == MONTHLY:
                # TODO
                result = False
            elif self.recurrence == YEARLY:
                # TODO
                result = False
        return result

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import dow [as 别名]
    def getSetmanes(self):
        """
        """
        self.options = self.epiUtility.getEPIOptions(self.request, self.username)
        self.descompte_descans = self.options['descomptar_30'] and 30 or 0

        NUMSETMANES = 4
        setmanes = []
        now = DateTime()
        dow = now.dow()==0 and 7 or now.dow()
        #fdofw = primer dia de la primera setmana que mostrarem segons NUMSETMANES a mostrar
        fdofw = addDays(now,1-dow-(NUMSETMANES*7))
        dies = self.getDies(first_day = fdofw,last_day = lastDayOfWeek())
        for setmana in range(0,NUMSETMANES):
            diesarestar = 7*setmana
            fdow = addDays(now,1-dow-diesarestar)
            setmanes.append(self.getSetmana(dies,fdow))
        return setmanes

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import dow [as 别名]
 def testsNextWeek(self):
     today = DateTime()
     dow = today.dow()
     firstDayOfNextWeek = today - dow + 7
     lastDayOfNextWeek = today + (6 - dow) + 7
     self.reportTitle = 'Tests Next Week: %s - %s' % (firstDayOfNextWeek.strftime(self.dateFormat), lastDayOfNextWeek.strftime(self.dateFormat))
     brains = self.portal_catalog.searchResults(sort_on='testDate', portal_type='BlueSheet',
                                                    review_state=self.statesFromOfficeApprovalToAdministerTest)
     filteredBrains = filter((lambda b: b['testDate'] >= firstDayOfNextWeek.earliestTime() and b['testDate'] <= lastDayOfNextWeek.latestTime()), brains)
     self.results = self._convertBrainsToResultsDict(filteredBrains)
     return self.resultTemplate()

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import dow [as 别名]
    def getDate(self, globdate='', new_year='', new_month='', new_day=''):
        today = DateTime()
        year,month,day = today.year(), today.month(), today.day()
        today_start = DateTime(year, month, day)

        if globdate == 'today':
            return today_start
        elif globdate == 'tomorrow':
            return today_start + 1
        elif globdate == 'thisweek':
            dow = today.dow()
            return today_start + 5 - dow
        elif globdate == 'nextweek':
            dow = today.dow()
            return today_start + 12 - dow
        elif globdate == 'later':
            return None
        else:
            if not new_year or not new_month or not new_day:
                return None
            try:
                return DateTime(int(new_year), int(new_month), int(new_day))
            except:
                return 'Error'

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import dow [as 别名]
    def __init__(self, context, request):
        super(WeekReport, self).__init__(context, request)

        start = self.request.get('startdate', None)
        if start:
            start = DateTime(start)
        else:
            start = DateTime()
        self.start = start.earliestTime() - (start.dow() - 1) % 7 # Find monday
        self.end = self.start + 7 # next monday 00:00
        self.now = DateTime()

        self.tool = getToolByName(context, TOOLNAME)
        self.ettool = getToolByName(self.context, 'extropy_timetracker_tool')
        self.barview = getMultiAdapter((self.context, self.request),
                                       name=u'smallprogressbar')

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import dow [as 别名]
    def totals(self):
        """Gets the content."""
        etool = getToolByName(self.context, TIMETOOLNAME)
        membership = getToolByName(self.context, 'portal_membership')
        portal = self.portal_state.portal()
        now = DateTime()
        startOfWeek = now.earliestTime() - (now.dow()-1)%7
        endOfWeek = (startOfWeek + 6).latestTime()

        brains = list(etool.getHours(node=portal, start=startOfWeek,
                                      end=endOfWeek, REQUEST=None))
        results = []
        creator = attrgetter('Creator')
        brains.sort(key=creator)
        for person, hours in groupby(brains, creator):
            member = membership.getMemberInfo(person)
            fullname = member.get('fullname', person)
            results.append(((fullname, person), etool.countHours(hours)))
        results.sort()
        return results

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import dow [as 别名]
def DateToPeriod(period="week", date=None):
    """Return the start and end dates for a time period defined by a
    length and a date.
    """

    if date is None:
        date=DateTime()

    if period=="day":
        start=date.earliestTime()
        end=date.latestTime()
    elif period=="week":
        start=(date-((date.dow()+6)%7)).earliestTime()
        end=(start+6).latestTime()
    elif period=="month":
        start=(date-(date.day()-1)).earliestTime()
        end=(start+31).latestTime()
        if end.day()<28:
            end-=end.day()
    else:
        raise ValueError("undefined period")

    return (start, end)

# 需要导入模块: from DateTime import DateTime [as 别名]
# 或者: from DateTime.DateTime import dow [as 别名]
    def getAllItemsByDue(self, getResponsibleParty=''):

        now = DateTime()
        today = DateTime(now.year(), now.month(), now.day())

        ctool = getToolByName(self.context, 'portal_catalog')

        #在站点首页显示所有项目的活动任务，在项目中仅显示当前项目（或任务列表）的活动任务
        if self.context.getPortalTypeName()=='Plone Site':
            active_projects = ctool(portal_type='Project', review_state='active')
            paths = [p.getPath() for p in active_projects]
        else:
            paths = '/'.join(self.context.getPhysicalPath())

        # 加一个判断，可让按时间分组的任务显示所有的任务
        if getResponsibleParty=='ALL':
            results = ctool.searchResults( path = paths, portal_type = 'TodoItem', review_state = 'active',)
        else:
            results = ctool.searchResults(
               path = paths,
               portal_type = 'TodoItem',
               review_state = 'active',
               getResponsibleParty=[getResponsibleParty],
               )

        last_items, today_items, tomorrow_items, this_week_items, next_week_items, other_items, no_end_items = [], [], [], [], [], [], [] 
        for item in results:
            path = item.getPath().split('/')
            projectid = path[-4]
            listid = path[-2]
            item_info = (item, projectid, listid)

            if not item.end:
                no_end_items.append(item_info)

            else:
                item_end = item.end
                end_time = DateTime(item_end.year(), item_end.month(), item_end.day())

                dow = today.dow()
                to_date = end_time - today

                if to_date < 0:
                    last_items.append(item_info)
                elif to_date == 0:
                    today_items.append(item_info)
                elif to_date == 1:
                    tomorrow_items.append(item_info)
                elif to_date in range(2, 8):
                    this_week_items.append(item_info) 
                elif to_date in range(9, 15):
                    next_week_items.append(item_info)
                else:
                    other_items.append(item_info)

        last_items.sort(lambda x,y:cmp(x[0].end, y[0].end))
        this_week_items.sort(lambda x,y:cmp(x[0].end, y[0].end))
        next_week_items.sort(lambda x,y:cmp(x[0].end, y[0].end))
        other_items.sort(lambda x,y:cmp(x[0].end, y[0].end))
        
        return last_items, today_items, tomorrow_items, this_week_items, next_week_items, other_items, no_end_items