Python fields.date方法代码示例

# 需要导入模块: from openerp.osv import fields [as 别名]
# 或者: from openerp.osv.fields import date [as 别名]
def _check_remind_delay(self, cr, uid, goal, context=None):
        """Verify if a goal has not been updated for some time and send a
        reminder message of needed.

        :return: data to write on the goal object
        """
        if goal.remind_update_delay and goal.last_update:
            delta_max = timedelta(days=goal.remind_update_delay)
            last_update = datetime.strptime(goal.last_update, DF).date()
            if date.today() - last_update > delta_max:
                # generate a remind report
                temp_obj = self.pool.get('email.template')
                template_id = self.pool['ir.model.data'].get_object(cr, uid, 'gamification', 'email_template_goal_reminder', context)
                body_html = temp_obj.render_template(cr, uid, template_id.body_html, 'gamification.goal', goal.id, context=context)
                self.pool['mail.thread'].message_post(cr, uid, 0, body=body_html, partner_ids=[goal.user_id.partner_id.id], context=context, subtype='mail.mt_comment')
                return {'to_update': True}
        return {} 

# 需要导入模块: from openerp.osv import fields [as 别名]
# 或者: from openerp.osv.fields import date [as 别名]
def _get_write_values(self, cr, uid, goal, new_value, context=None):
        """Generate values to write after recomputation of a goal score"""
        if new_value == goal.current:
            # avoid useless write if the new value is the same as the old one
            return {}

        result = {goal.id: {'current': new_value}}
        if (goal.definition_id.condition == 'higher' and new_value >= goal.target_goal) \
          or (goal.definition_id.condition == 'lower' and new_value <= goal.target_goal):
            # success, do no set closed as can still change
            result[goal.id]['state'] = 'reached'

        elif goal.end_date and fields.date.today() > goal.end_date:
            # check goal failure
            result[goal.id]['state'] = 'failed'
            result[goal.id]['closed'] = True

        return result 

# 需要导入模块: from openerp.osv import fields [as 别名]
# 或者: from openerp.osv.fields import date [as 别名]
def write(self, cr, uid, ids, vals, context=None):
        """Overwrite the write method to update the last_update field to today

        If the current value is changed and the report frequency is set to On
        change, a report is generated
        """
        if context is None:
            context = {}
        vals['last_update'] = fields.date.today()
        result = super(gamification_goal, self).write(cr, uid, ids, vals, context=context)
        for goal in self.browse(cr, uid, ids, context=context):
            if goal.state != "draft" and ('definition_id' in vals or 'user_id' in vals):
                # avoid drag&drop in kanban view
                raise osv.except_osv(_('Error!'), _('Can not modify the configuration of a started goal'))

            if vals.get('current'):
                if 'no_remind_goal' in context:
                    # new goals should not be reported
                    continue

                if goal.challenge_id and goal.challenge_id.report_message_frequency == 'onchange':
                    self.pool.get('gamification.challenge').report_progress(cr, SUPERUSER_ID, goal.challenge_id, users=[goal.user_id], context=context)
        return result 

# 需要导入模块: from openerp.osv import fields [as 别名]
# 或者: from openerp.osv.fields import date [as 别名]
def _get_next_report_date(self, cr, uid, ids, field_name, arg, context=None):
        """Return the next report date based on the last report date and report
        period.

        :return: a string in DEFAULT_SERVER_DATE_FORMAT representing the date"""
        res = {}
        for challenge in self.browse(cr, uid, ids, context=context):
            last = datetime.strptime(challenge.last_report_date, DF).date()
            if challenge.report_message_frequency == 'daily':
                next = last + timedelta(days=1)
                res[challenge.id] = next.strftime(DF)
            elif challenge.report_message_frequency == 'weekly':
                next = last + timedelta(days=7)
                res[challenge.id] = next.strftime(DF)
            elif challenge.report_message_frequency == 'monthly':
                month_range = calendar.monthrange(last.year, last.month)
                next = last.replace(day=month_range[1]) + timedelta(days=1)
                res[challenge.id] = next.strftime(DF)
            elif challenge.report_message_frequency == 'yearly':
                res[challenge.id] = last.replace(year=last.year + 1).strftime(DF)
            # frequency == 'once', reported when closed only
            else:
                res[challenge.id] = False

        return res 

# 需要导入模块: from openerp.osv import fields [as 别名]
# 或者: from openerp.osv.fields import date [as 别名]
def on_change_date_end(self, cr, uid, date_end, context=None):
        date_end = date.strptime(date_end, DATE_FMT)
        today = date.today()
        if date_end <= today:
            return {
                'value': {'loan_duration': 0},
                'warning': {
                    'title': 'expired membership',
                    'message': 'This member membership has expired',
                },
            } 

# 需要导入模块: from openerp.osv import fields [as 别名]
# 或者: from openerp.osv.fields import date [as 别名]
def _compute_date_due(self, cr, uid, ids,
                          fields, arg, context=None):
        res = {}
        for loan in self.browse(cr, uid, ids, context=context):
            start_date = date.strptime(loan.date, DATE_FMT)
            due_date = start_date + timedelta(days=loan.duration)
            res[loan.id] = due_date.strftime(DATE_FMT)
        return res 

# 需要导入模块: from openerp.osv import fields [as 别名]
# 或者: from openerp.osv.fields import date [as 别名]
def _default_date(self, cr, uid, context=None):
        return date.today().strftime(DATE_FMT) 

# 需要导入模块: from openerp.osv import fields [as 别名]
# 或者: from openerp.osv.fields import date [as 别名]
def action_reach(self, cr, uid, ids, context=None):
        """Mark a goal as reached.

        If the target goal condition is not met, the state will be reset to In
        Progress at the next goal update until the end date."""
        return self.write(cr, uid, ids, {'state': 'reached'}, context=context) 

# 需要导入模块: from openerp.osv import fields [as 别名]
# 或者: from openerp.osv.fields import date [as 别名]
def action_cancel(self, cr, uid, ids, context=None):
        """Reset the completion after setting a goal as reached or failed.

        This is only the current state, if the date and/or target criterias
        match the conditions for a change of state, this will be applied at the
        next goal update."""
        return self.write(cr, uid, ids, {'state': 'inprogress'}, context=context) 

# 需要导入模块: from openerp.osv import fields [as 别名]
# 或者: from openerp.osv.fields import date [as 别名]
def _cron_update(self, cr, uid, context=None, ids=False):
        """Daily cron check.

        - Start planned challenges (in draft and with start_date = today)
        - Create the missing goals (eg: modified the challenge to add lines)
        - Update every running challenge
        """
        if context is None:
            context = {}

        # start scheduled challenges
        planned_challenge_ids = self.search(cr, uid, [
            ('state', '=', 'draft'),
            ('start_date', '<=', fields.date.today())])
        if planned_challenge_ids:
            self.write(cr, uid, planned_challenge_ids, {'state': 'inprogress'}, context=context)

        # close scheduled challenges
        planned_challenge_ids = self.search(cr, uid, [
            ('state', '=', 'inprogress'),
            ('end_date', '>=', fields.date.today())])
        if planned_challenge_ids:
            self.write(cr, uid, planned_challenge_ids, {'state': 'done'}, context=context)

        if not ids:
            ids = self.search(cr, uid, [('state', '=', 'inprogress')], context=context)

        # in cron mode, will do intermediate commits
        # TODO in trunk: replace by parameter
        context = dict(context, commit_gamification=True)
        return self._update_all(cr, uid, ids, context=context) 

# 需要导入模块: from openerp.osv import fields [as 别名]
# 或者: from openerp.osv.fields import date [as 别名]
def get_today(self):
        """??????"""
        tz = pytz.timezone('Asia/Shanghai')
        return datetime.now(tz).date() 

# 需要导入模块: from openerp.osv import fields [as 别名]
# 或者: from openerp.osv.fields import date [as 别名]
def _update_all(self, cr, uid, ids, context=None):
        """Update the challenges and related goals

        :param list(int) ids: the ids of the challenges to update, if False will
        update only challenges in progress."""
        if not ids:
            return True

        if isinstance(ids, (int,long)):
            ids = [ids]

        goal_obj = self.pool.get('gamification.goal')

        # include yesterday goals to update the goals that just ended
        # exclude goals for users that did not connect since the last update
        yesterday = date.today() - timedelta(days=1)
        cr.execute("""SELECT gg.id
                        FROM gamification_goal as gg,
                             gamification_challenge as gc,
                             res_users as ru
                       WHERE gg.challenge_id = gc.id
                         AND gg.user_id = ru.id
                         AND gg.write_date < ru.login_date
                         AND gg.closed IS false
                         AND gc.id IN %s
                         AND (gg.state = 'inprogress'
                              OR (gg.state = 'reached'
                                  AND (gg.end_date >= %s OR gg.end_date IS NULL)))
        """, (tuple(ids), yesterday.strftime(DF)))
        goal_ids = [res[0] for res in cr.fetchall()]
        # update every running goal already generated linked to selected challenges
        goal_obj.update(cr, uid, goal_ids, context=context)

        self._recompute_challenge_users(cr, uid, ids, context=context)
        self._generate_goals_from_challenge(cr, uid, ids, context=context)

        for challenge in self.browse(cr, uid, ids, context=context):

            if challenge.last_report_date != fields.date.today():
                # goals closed but still opened at the last report date
                closed_goals_to_report = goal_obj.search(cr, uid, [
                    ('challenge_id', '=', challenge.id),
                    ('start_date', '>=', challenge.last_report_date),
                    ('end_date', '<=', challenge.last_report_date)
                ])

                if challenge.next_report_date and fields.date.today() >= challenge.next_report_date:
                    self.report_progress(cr, uid, challenge, context=context)

                elif len(closed_goals_to_report) > 0:
                    # some goals need a final report
                    self.report_progress(cr, uid, challenge, subset_goal_ids=closed_goals_to_report, context=context)

        self.check_challenge_reward(cr, uid, ids, context=context)
        return True