Пример #1
0
class ExpireDateMixin(object):
    """ A mixin for providing expire dates. """

    expire_attr = 'expire_date'
    expire_dates = [None, now() - DateTimeDelta(10), now() + DateTimeDelta(10)]

    def __init__(self):
        parent = super(ExpireDateMixin, self)
        if hasattr(parent, '__init__'):
            getattr(parent, '__init__')()

        self.register_attr(self.expire_attr, self.get_expire_date)

    def get_expire_date(self, ident):
        """ Get the expire_date for a given ident.

        @type ident: str
        @param ident: The 'ident' or 'id of an item

        @rtype: mx.DateTime.DateTime or NoneType
        @return: An expire date or None

        """
        if ident in getattr(self, 'items'):
            return getattr(self, 'items')[ident][self.expire_attr]

        return self._get_cyclic_value(ident, self.expire_dates)
Пример #2
0
 def storicizza(self, tipologia="Documento", id_pdc=None, id_doc=None):
     if self.msg is None:
         raise Exception, "Impossibile storicizzare una mail non inizializzata"
     import Env
     bt = Env.Azienda.BaseTab
     adb = Env.adb
     from mx.DateTime import now
     s = adb.DbTable(bt.TABNAME_DOCSEMAIL, 'docsemail')
     s.CreateNewRow()
     s.datcoda = now()
     s.datsend = now()
     s.id_pdc = id_pdc
     s.id_doc = id_doc
     s.tipologia = tipologia
     s.mittente = self.SendFrom
     s.destinat = ', '.join(self.SendTo)
     s.oggetto = self.Subject
     s.testo = self.Message
     stream = None
     if self.Attachments:
         try:
             f = open(self.Attachments[0], 'rb')
             stream = f.read()
             f.close()
         except:
             pass
     if stream:
         s.documento = stream
     if not s.Save():
         raise Exception, repr(s.GetError())
Пример #3
0
 def write_forkurs_info(self, pre_course_file):
     from mx.DateTime import now
     logger.info("Writing pre-course file to '%s'", pre_course_file)
     f = SimilarSizeWriter(pre_course_file, mode='w', encoding=XML_ENCODING)
     f.max_pct_change = 50
     cols, course_attendants = self._ext_cols(self.fs.forkurs.list())
     f.write(xml.xml_hdr + "<data>\n")
     for a in course_attendants:
         f.write(
             '<regkort fodselsdato="{}" personnr="{}" dato_endring="{}" '
             'dato_opprettet="{}"/>\n'.format(a['fodselsdato'],
                                              a['personnr'], str(now()),
                                              str(now())))
         f.write('<emnestud fodselsdato="{}" personnr="{}" etternavn="{}" '
                 'fornavn="{}" adrlin2_semadr="" postnr_semadr="" '
                 'adrlin3_semadr="" adrlin2_hjemsted="" postnr_hjemsted="" '
                 'adrlin3_hjemsted="" sprakkode_malform="NYNORSK" '
                 'kjonn="X" studentnr_tildelt="{}" emnekode="FORGLU" '
                 'versjonskode="1" terminkode="VÅR" arstall="2016" '
                 'telefonlandnr_mobil="{}" telefonnr_mobil="{}"/>\n'.format(
                     a['fodselsdato'], a['personnr'], a['etternavn'],
                     a['fornavn'], a['studentnr_tildelt'],
                     a['telefonlandnr'], a['telefonnr']))
     f.write("</data>\n")
     f.close()
Пример #4
0
def enforce_user_constraints(db):
    """ Check a number of business rules for our users. """
    account = Factory.get("Account")(db)
    const = Factory.get("Constants")()
    for row in account.list(filter_expired=False):
        # We check FA/VA only
        if row["np_type"] not in (const.fedaccount_type,
                                  const.virtaccount_type):
            continue

        account.clear()
        account.find(row["entity_id"])
        # Expiration is not set -> force it to default
        if row["expire_date"] is None:
            logger.warn("Account %s (id=%s) is missing expiration date.",
                        account.account_name, account.entity_id)
            account.expire_date = now() + account.DEFAULT_ACCOUNT_LIFETIME
            account.write_db()

        # Expiration is too far in the future -> force it to default
        if row["expire_date"] - now() > account.DEFAULT_ACCOUNT_LIFETIME:
            logger.warn(
                "Account %s (id=%s) has expire date too far in the"
                " future.", account.account_name, account.entity_id)
            account.expire_date = now() + account.DEFAULT_ACCOUNT_LIFETIME
            account.write_db()
Пример #5
0
	def actionScheduleAlarm(self, cmsg, dbcom):
	
		sms_dict = self.alarm.retrieveData(cmsg)

		activity = ACTIVE

		if sms_dict == NOTFOUND:
			self.log.LOG(LOG_ERROR, "sms.actionScheduleAlarm()", "TAGs are missing in the requisition to schedule an alarm. Aborting schedule.")
			return "NOTFOUND"

		blow = self.shared.mountTime(sms_dict[DATA_BLOW])


		if blow == INVALID:
			return "INVALID"

		elif blow < now() or blow == now():
			activity = FAILED

		ret = dbcom.registerSMS(sms_dict[DATA_ORG], sms_dict[DATA_EXT+"0"], sms_dict[DATA_BLOW], sms_dict[DATA_OPER], sms_dict[DATA_MSG], activity)

		if ret == OK and activity == ACTIVE:
			alarm_thread = Thread(target=self.alarm.launch, args=(blow,))
			alarm_thread.start()
			self.log.LOG(LOG_INFO, "sms", "New alarm thread has been started.")
			return "OK"

		elif ret == NOTFOUND:
			return "NOTFOUND"

		elif activity == FAILED:
			return "INVALID"

		else:
			return "ERROR"
Пример #6
0
 def default_get(self, cr, uid, fields, context=None):
     '''
     Get the default values for the replenishment rule
     '''
     res = super(stock_warehouse_order_cycle, self).default_get(cr, uid, fields, context=context)
     
     company_id = res.get('company_id')
     warehouse_id = res.get('warehouse_id')
     
     if not 'company_id' in res:
         company_id = self.pool.get('res.company')._company_default_get(cr, uid, 'stock.warehouse.automatic.supply', context=context)
         res.update({'company_id': company_id})
     
     if not 'warehouse_id' in res:
         warehouse_id = self.pool.get('stock.warehouse').search(cr, uid, [('company_id', '=', company_id)], context=context)[0]
         res.update({'warehouse_id': warehouse_id})
         
     if not 'location_id' in res:
         location_id = self.pool.get('stock.warehouse').browse(cr, uid, warehouse_id, context=context).lot_stock_id.id
         res.update({'location_id': location_id})
         
     if not 'consumption_period_from' in res:
         res.update({'consumption_period_from': (DateFrom(now()) + RelativeDate(day=1)).strftime('%Y-%m-%d')})
         
     if not 'consumption_period_to' in res:
         res.update({'consumption_period_to': (DateFrom(now()) + RelativeDate(months=1, day=1, days=-1)).strftime('%Y-%m-%d')})
     
     return res
Пример #7
0
 def test_classCreate(self):
     if not supports('fromDatabase'):
         return
     class OldAutoTest(SQLObject):
         _connection = getConnection()
         class sqlmeta(sqlmeta):
             idName = 'auto_id'
             fromDatabase = True
     john = OldAutoTest(firstName='john',
                        lastName='doe',
                        age=10,
                        created=now(),
                        wannahavefun=False,
                        longField='x'*1000)
     jane = OldAutoTest(firstName='jane',
                        lastName='doe',
                        happy='N',
                        created=now(),
                        wannahavefun=True,
                        longField='x'*1000)
     assert not john.wannahavefun
     assert jane.wannahavefun
     assert john.longField == 'x'*1000
     assert jane.longField == 'x'*1000
     del classregistry.registry(
         OldAutoTest.sqlmeta.registry).classes['OldAutoTest']
def _empty_inventory(self, cr, uid, data, context):
    """empty a location"""
    pool = pooler.get_pool(cr.dbname)
    inventory_line_obj = pooler.get_pool(cr.dbname).get('stock.inventory.line')
    location_obj = pooler.get_pool(cr.dbname).get('stock.location')
    res = {}
    res_location = {}
    if data['id']:
        # pylint: disable-msg=W0212
        res = location_obj._product_get(cr, uid, data['id'], context = context)
        res_location[data['id']] = res
        product_ids = []
        inventory_id = pool.get('stock.inventory').create(cr, uid, {'name': "INV:" + now().strftime('%Y-%m-%d %H:%M:%S'),
                                                                  'date': now().strftime('%Y-%m-%d %H:%M:%S'),
                                           })
        for location in res_location.keys():
            res = res_location[location]
            for product_id in res.keys():
                cr.execute('select prodlot_id, name as id from stock_report_prodlots where location_id = %s and product_id = %s and name > 0', (location, product_id))
                prodlots = cr.fetchall()
                for prodlot in prodlots:
                    prod = pool.get('product.template').browse(cr, uid, product_id)
                    amount = prodlot[1]

                    if(amount):
                        inventory_line = {'inventory_id':inventory_id, 'location_id':location, 'product_id':product_id, 'product_uom':prod.uom_id.id, 'product_qty':0, 'prodlot_id':prodlot[0]}
                        inventory_line_obj.create(cr, uid, inventory_line)
                        product_ids.append(product_id)
        pool.get('stock.inventory').action_done(cr, uid, [inventory_id], context = context)

    if len(product_ids) == 0:
        raise wizard.except_wizard(_('Message !'), _('No product in this location.'))
    return {}
Пример #9
0
    def check_too_many_attempts(self, account):
        """
        Checks if a user has tried to use the service too many times. Creates
        the trait if it doesn't exist, and increments the numval. Raises an
        exception when too many attempts occur in the block period.

        """
        attempts = 0
        trait = account.get_trait(self.co.trait_password_failed_attempts)
        block_period = now() - RelativeDateTime(
            seconds=cereconf.INDIVIDUATION_ATTEMPTS_BLOCK_PERIOD)
        if trait and trait['date'] > block_period:
            attempts = int(trait['numval'])
        logger.debug('User %r has tried %r times', account.account_name,
                     attempts)
        if attempts > cereconf.INDIVIDUATION_ATTEMPTS:
            logger.info("User %r too many attempts, temporarily blocked",
                        account.account_name)
            raise Errors.CerebrumRPCException('toomanyattempts')
        account.populate_trait(code=self.co.trait_password_failed_attempts,
                               target_id=account.entity_id,
                               date=now(),
                               numval=attempts + 1)
        account.write_db()
        account._db.commit()
Пример #10
0
 def storicizza(self, tipologia="Documento", id_pdc=None, id_doc=None):
     if self.msg is None:
         raise Exception, "Impossibile storicizzare una mail non inizializzata"
     import Env
     bt = Env.Azienda.BaseTab
     adb = Env.adb
     from mx.DateTime import now
     s = adb.DbTable(bt.TABNAME_DOCSEMAIL, 'docsemail')
     s.CreateNewRow()
     s.datcoda = now()
     s.datsend = now()
     s.id_pdc = id_pdc
     s.id_doc = id_doc
     s.tipologia = tipologia
     s.mittente = self.SendFrom
     s.destinat = ', '.join(self.SendTo)
     s.oggetto = self.Subject
     s.testo = self.Message
     stream = None
     if self.Attachments:
         try:
             f = open(self.Attachments[0], 'rb')
             stream = f.read()
             f.close()
         except:
             pass
     if stream:
         s.documento = stream
     if not s.Save():
         raise Exception, repr(s.GetError())
Пример #11
0
def enforce_user_constraints(db):
    """ Check a number of business rules for our users. """
    account = Factory.get("Account")(db)
    const = Factory.get("Constants")()
    for row in account.list(filter_expired=False):
        # We check FA/VA only
        if row["np_type"] not in (const.fedaccount_type,
                                  const.virtaccount_type):
            continue

        account.clear()
        account.find(row["entity_id"])
        # Expiration is not set -> force it to default
        if row["expire_date"] is None:
            logger.warn("Account %s (id=%s) is missing expiration date.",
                        account.account_name,
                        account.entity_id)
            account.expire_date = now() + account.DEFAULT_ACCOUNT_LIFETIME
            account.write_db()

        # Expiration is too far in the future -> force it to default
        if row["expire_date"] - now() > account.DEFAULT_ACCOUNT_LIFETIME:
            logger.warn("Account %s (id=%s) has expire date too far in the"
                        " future.", account.account_name, account.entity_id)
            account.expire_date = now() + account.DEFAULT_ACCOUNT_LIFETIME
            account.write_db()
Пример #12
0
def remove_expired_groups(db, days, pretend):
    """
    Removes groups that have reached number of `days' past expiration-date.

    :param Cerebrum.Database db: The database connection
    :param int days: Amount of days after past expiration-date
    :param bool pretend: If True, do not actually remove from DB
    """
    try:
        amount_to_be_removed_groups = 0
        amount_removed_groups = 0
        if pretend:
            logger.info('DRYRUN: Rolling back all changes')
        gr = Factory.get('Group')(db)
        expired_groups = gr.search(filter_expired=False, expired_only=True)
        for group in expired_groups:
            removal_deadline = group['expire_date'] + days
            if now() > removal_deadline:  # deadline passed. remove!
                amount_to_be_removed_groups += 1
                try:
                    gr.clear()
                    gr.find(group['group_id'])
                    exts = gr.get_extensions()
                    if exts:
                        logger.debug("Skipping group %r, has extensions %r",
                                     gr.group_name, exts)
                        continue
                    gr.delete()
                    if not pretend:
                        db.commit()
                    else:  # do not actually remove when running with -d
                        db.rollback()
                    amount_removed_groups += 1
                    logger.info(
                        'Expired group (%s - %s) removed' % (
                            group['name'],
                            group['description']))
                except DatabaseError, e:
                    logger.error(
                        'Database error: Could not delete expired group '
                        '(%s - %s): %s. Skipping' % (
                            group['name'],
                            group['description'],
                            str(e)),
                        exc_info=True)
                    db.rollback()
                    continue
            else:
                time_until_removal = removal_deadline - now()
                logger.debug(
                    'Expired group (%s - %s), will be removed in %d days' % (
                        group['name'],
                        group['description'],
                        int(time_until_removal.days)))
    except Exception, e:
        logger.critical('Unexpected exception: %s' % (str(e)), exc_info=True)
        db.rollback()
        raise
Пример #13
0
def remove_expired_groups(db, days, pretend):
    """
    Removes groups that have reached number of `days' past expiration-date.

    :param Cerebrum.Database db: The database connection
    :param int days: Amount of days after past expiration-date
    :param bool pretend: If True, do not actually remove from DB
    """
    try:
        amount_to_be_removed_groups = 0
        amount_removed_groups = 0
        if pretend:
            logger.info('DRYRUN: Rolling back all changes')
        gr = Factory.get('Group')(db)
        expired_groups = gr.search(filter_expired=False, expired_only=True)
        for group in expired_groups:
            removal_deadline = group['expire_date'] + days
            if now() > removal_deadline:  # deadline passed. remove!
                amount_to_be_removed_groups += 1
                try:
                    gr.clear()
                    gr.find(group['group_id'])
                    exts = gr.get_extensions()
                    if exts:
                        logger.debug("Skipping group %r, has extensions %r",
                                     gr.group_name, exts)
                        continue
                    gr.delete()
                    if not pretend:
                        db.commit()
                    else:  # do not actually remove when running with -d
                        db.rollback()
                    amount_removed_groups += 1
                    logger.info('Expired group (%s - %s) removed' %
                                (group['name'], group['description']))
                except DatabaseError, e:
                    logger.error(
                        'Database error: Could not delete expired group '
                        '(%s - %s): %s. Skipping' %
                        (group['name'], group['description'], str(e)),
                        exc_info=True)
                    db.rollback()
                    continue
            else:
                time_until_removal = removal_deadline - now()
                logger.debug(
                    'Expired group (%s - %s), will be removed in %d days' %
                    (group['name'], group['description'],
                     int(time_until_removal.days)))
    except Exception, e:
        logger.critical('Unexpected exception: %s' % (str(e)), exc_info=True)
        db.rollback()
        raise
    def action_no_picking(self, cr, uid, ids):
        """creates the final move for the production and a move by product in the bom from
        product's procurement location or a child her to production location"""
        for production in self.browse(cr, uid, ids):
            original_product_lines = map(lambda x: x.id, production.product_lines)
            self.pool.get('mrp.production.product.line').write(cr, uid, map(lambda x: x.id, production.product_lines), {'production_id': None})
            production = self.browse(cr, uid, production.id)
            #create empty picking, delete
            super(mrp_production, self).action_confirm(cr, uid, ids)
            self.pool.get('mrp.production.product.line').write(cr, uid, original_product_lines, {'production_id': production.id})
            production = self.browse(cr, uid, production.id)
            
            #final move
            final_moves_ids = self.pool.get('stock.move').search(cr, uid, [('production_id', '=', production.id)])

            res_final_id = final_moves_ids[0]

            if production.product_lines:
                notvalidprodlots = []
                order_product_lines = self.pool.get('mrp.production.product.line').search(cr, uid, [('production_id', '=', production.id)], order="product_qty DESC")
                for line in order_product_lines:
                    obj_line = self.pool.get('mrp.production.product.line').browse(cr, uid, line)
                    
                    #search the default prodlot and the location of this prodlot
                    default_prodlot, prodlot_location, default_qty = self.pool.get('stock.production.lot').get_default_production_lot(cr, uid, obj_line.product_id.product_tmpl_id.property_stock_procurement.id,
                    obj_line.product_id.id, obj_line.product_qty, True, notvalidprodlots)

                    notvalidprodlots.append((default_prodlot, prodlot_location, default_qty))
                    if not prodlot_location:
                        prodlot_location = obj_line.product_id.product_tmpl_id.property_stock_procurement.id
                    #creates the move in stock_move for the product not procure from deafult location of prodlot to production location
                    production_move = self.pool.get('stock.move').create(cr, uid, vals={
                                                      'product_uom' : obj_line.product_uom.id,
                                                      'product_uos_qty' : obj_line.product_uos_qty,
                                                      'date' : now().strftime('%Y-%m-%d %H:%M:%S'),
                                                      'product_qty' : obj_line.product_qty,
                                                      'product_uos' : obj_line.product_uos,
                                                      'location_id' : prodlot_location,
                                                      'product_id' : obj_line.product_id.id,
                                                      'prodlot_id' : default_prodlot,
                                                      'name' : 'NoProc:' + str(obj_line.product_id.product_tmpl_id.property_stock_procurement.id) + str(production.product_lines.index(obj_line)) + 'TO' + now().strftime('%Y-%m-%d %H:%M:%S'),
                                                      'date_planned' : now().strftime('%Y-%m-%d %H:%M:%S'),
                                                      'state' : 'draft',
                                                      'move_dest_id': res_final_id,
                                                      'location_dest_id' : obj_line.product_id.product_tmpl_id.property_stock_production.id,
                                                  })
                    #searches the final move in production and insert a registry in mrp_production_move_ids
                    if res_final_id:
                        cr.execute('insert into mrp_production_move_ids (production_id, move_id) values (%s,%s)', (production.id, production_move))

            self.write(cr, uid, [production.id], {'state':'confirmed'})
        return True
Пример #15
0
 def on_change_method(self, cr, uid, ids, method):
     '''
     Unfill the consumption period if the method is FMC
     '''
     res = {}
     
     if method and method == 'fmc':
         res.update({'consumption_period_from': False, 'consumption_period_to': False})
     elif method and method == 'amc':
         res.update({'consumption_period_from': (now() + RelativeDate(day=1, months=-2)).strftime('%Y-%m-%d'),
                     'consumption_period_to': (now() + RelativeDate(day=1, months=1, days=-1)).strftime('%Y-%m-%d')})
     
     return {'value': res}
Пример #16
0
class BasicPersonSource(BaseDataSource):

    birth_dates = [
        now(),
        now() - DateTimeDelta(365 * 100),
        now() - DateTimeDelta(356 * 20)
    ]

    genders = ['M', 'F', None]

    birth_date_attr = 'birth_date'
    gender_attr = 'gender'

    def __init__(self):
        parent = super(BasicPersonSource, self)
        if hasattr(parent, '__init__'):
            getattr(parent, '__init__')()

        self.register_attr(self.birth_date_attr, self.get_birth_date)
        self.register_attr(self.gender_attr, self.get_gender)

    def get_gender(self, ident):
        """ Get the gender for a given ident.

        @type ident: str
        @param ident: The 'ident' or 'id of an item

        @rtype: str or NoneType
        @return: One of the values in self.genders

        """
        if ident in getattr(self, 'items'):
            return getattr(self, 'items')[ident][self.expire_attr]

        return self._get_cyclic_value(ident, self.genders)

    def get_birth_date(self, ident):
        """ Get the expire_date for a given ident.

        @type ident: str
        @param ident: The 'ident' or 'id of an item

        @rtype: mx.DateTime.DateTime or NoneType
        @return: One of the values in self.birth_dates

        """
        if ident in getattr(self, 'items'):
            return getattr(self, 'items')[ident][self.expire_attr]

        return self._get_cyclic_value(ident, self.birth_dates)
Пример #17
0
def delete_stale_events(cl_events, db):
    """Remove all events of type cl_events older than GRACE_PERIOD.

    cl_events is an iterable listing change_log event types that we want
    expunged. These events cannot require any state change in Cerebrum (other
    than their own deletion). It is the caller's responsibility to check that
    this is so.
    """

    if not isinstance(cl_events, (list, tuple, set)):
        cl_events = [
            cl_events,
        ]

    const = Factory.get("Constants")()
    typeset_request = ", ".join(str(const.ChangeType(x)) for x in cl_events)
    logger.debug("Deleting stale requests: %s", typeset_request)
    for event in db.get_log_events(types=cl_events):
        tstamp = event["tstamp"]
        timeout = cereconf.GRACE_PERIOD
        try:
            params = pickle.loads(event["change_params"])
            if params['timeout'] is not None:
                timeout = DateTimeDelta(params['timeout'])
                logger.debug('Timeout set to %s for %s',
                             (now() + timeout).strftime('%Y-%m-%d'),
                             event['change_id'])

                if timeout > cereconf.MAX_INVITE_PERIOD:
                    logger.warning('Too long timeout (%s) for for %s',
                                   timeout.strftime('%Y-%m-%d'),
                                   event['change_id'])
                    timeout = cereconf.MAX_INVITE_PERIOD
        except KeyError:
            pass
        if now() - tstamp <= timeout:
            continue

        logger.debug("Deleting stale event %s (@%s) for entity %s (id=%s)",
                     str(const.ChangeType(event["change_type_id"])),
                     event["tstamp"].strftime("%Y-%m-%d"),
                     fetch_name(event["subject_entity"],
                                db), event["subject_entity"])

        db.remove_log_event(event["change_id"])
        db.commit()

    logger.debug("Deleted all stale requests: %s", typeset_request)
Пример #18
0
    def onchange_partner_id(self, cr, uid, ids, move_id, partner_id, account_id=None, debit=0, credit=0, date=False, journal=False):
        val = {}
        val['date_maturity'] = False

        if not partner_id:
            return {'value':val}
        if not date:
            date = now().strftime('%Y-%m-%d')
        part = self.pool.get('res.partner').browse(cr, uid, partner_id)

        if part.property_payment_term:
            res = self.pool.get('account.payment.term').compute(cr, uid, part.property_payment_term.id, 100, date)
            if res:
                val['date_maturity'] = res[0][0]
        if not account_id:
            id1 = part.property_account_payable.id
            id2 =  part.property_account_receivable.id
            if journal:
                jt = self.pool.get('account.journal').browse(cr, uid, journal).type
                if jt == 'sale':
                    val['account_id'] = self.pool.get('account.fiscal.position').map_account(cr, uid, part and part.property_account_position or False, id2)

                elif jt == 'purchase':
                    val['account_id'] = self.pool.get('account.fiscal.position').map_account(cr, uid, part and part.property_account_position or False, id1)
                if val.get('account_id', False):
                    d = self.onchange_account_id(cr, uid, ids, val['account_id'])
                    val.update(d['value'])

        return {'value':val}
Пример #19
0
def populate_fagmiljo(person_id, fagmiljo):
    """Add a given fagmiljo string to the given person."""
    logger.debug("Populating fagmiljo for person_id=%s", person_id)
    pe.clear()
    pe.find(person_id)
    pe.populate_trait(code=co.trait_fagmiljo, date=now(), strval=fagmiljo)
    pe.write_db()
Пример #20
0
    def test_mxDateTime():
        setupClass(DateTime2)
        _now = now()
        dt2 = DateTime2(col1=_now,
                        col2=_now.pydate(),
                        col3=Time(_now.hour, _now.minute, _now.second))

        assert isinstance(dt2.col1, col.DateTimeType)
        assert dt2.col1.year == _now.year
        assert dt2.col1.month == _now.month
        assert dt2.col1.day == _now.day
        assert dt2.col1.hour == _now.hour
        assert dt2.col1.minute == _now.minute
        assert dt2.col1.second == int(_now.second)

        assert isinstance(dt2.col2, col.DateTimeType)
        assert dt2.col2.year == _now.year
        assert dt2.col2.month == _now.month
        assert dt2.col2.day == _now.day
        assert dt2.col2.hour == 0
        assert dt2.col2.minute == 0
        assert dt2.col2.second == 0

        assert isinstance(dt2.col3, (col.DateTimeType, col.TimeType))
        assert dt2.col3.hour == _now.hour
        assert dt2.col3.minute == _now.minute
        assert dt2.col3.second == int(_now.second)
Пример #21
0
    def update_trait(self):
        """ Update the 'trait_user_notified' trait by:
          1. Creating it, if it doesn't exist
          2. Resetting it if the date attribute is more than
             days_reset days old.
          3. Incrementing the numval attribute. 
        """
        # Initial values for new trait
        last_reset = now()
        num_sent = 0
        trait = self.ac.get_trait(self.co.trait_user_notified)

        # Trait date exists, and is not older than days_reset old.
        if trait and (last_reset - self.days_reset) < trait.get("date"):
            last_reset = trait.get("date")
            num_sent = trait.get("numval") or 0
        # Else, reset trait

        # Increment and write the updated trait values
        num_sent += 1

        self.ac.populate_trait(self.co.trait_user_notified, numval=num_sent, date=last_reset)
        self.ac.write_db()

        if self.dryrun:
            self.logger.warn(
                "Dryrun, not writing trait '%s' for user '%s" % (str(self.co.trait_user_notified), self.ac.account_name)
            )
            self.ac._db.rollback()
        else:
            self.ac._db.commit()
Пример #22
0
 def loadPAClass(self):
     pa_query = """select fk_pupil, fk_subject from prearranged_classes
         where (time_start <= '%s' and time_end >= '%s') and fk_tutor = %d
         """
     date = now()
     d = self.db.db.runQuery(pa_query, (date, date, int(self.avId)))
     d.addCallback(self._loadPupilAndSubject)
Пример #23
0
    def test_mxDateTime():
        setupClass(DateTime2)
        _now = now()
        dt2 = DateTime2(col1=_now,
                        col2=_now,
                        col3=Time(_now.hour, _now.minute, int(_now.second)))

        assert isinstance(dt2.col1, col.DateTimeType)
        assert dt2.col1.year == _now.year
        assert dt2.col1.month == _now.month
        assert dt2.col1.day == _now.day
        assert dt2.col1.hour == _now.hour
        assert dt2.col1.minute == _now.minute
        assert dt2.col1.second == int(_now.second)

        assert isinstance(dt2.col2, col.DateTimeType)
        assert dt2.col2.year == _now.year
        assert dt2.col2.month == _now.month
        assert dt2.col2.day == _now.day
        if getConnection().dbName == "sqlite":
            assert dt2.col2.hour == _now.hour
            assert dt2.col2.minute == _now.minute
            assert dt2.col2.second == int(_now.second)
        else:
            assert dt2.col2.hour == 0
            assert dt2.col2.minute == 0
            assert dt2.col2.second == 0

        assert isinstance(dt2.col3, (col.DateTimeType, col.TimeType))
        assert dt2.col3.hour == _now.hour
        assert dt2.col3.minute == _now.minute
        assert dt2.col3.second == int(_now.second)
Пример #24
0
    def entity_is_fresh(self, person, account):
        """Check if a person or account is 'fresh', i.e. if the account or
        person is newly created, or if the account has been restored lately.

        This is to be able to avoid blocking new phone numbers from systems
        where the account is just activated.

        """
        delay = now() - getattr(cisconf, 'FRESH_DAYS', 10)

        # Check for traits only set for 'fresh' accounts:
        for tr in (self.co.trait_student_new, self.co.trait_sms_welcome):
            trait = account.get_trait(tr)
            if trait and trait['date'] > delay:
                logger.debug('Fresh trait %r for account %r, '
                             'so considered fresh', tr, account.account_name)
                return True
        # Check if person has recently been created:
        for row in self.db.get_log_events(types=(self.clconst.person_create),
                                          any_entity=person.entity_id,
                                          sdate=delay):
            logger.debug("Person %r is fresh", person.entity_id)
            return True
        logger.debug("Person %r (account %r) is not fresh",
                     person.entity_id, account.entity_id)
        return False
Пример #25
0
 def _pending_amount(self, cr, uid, ids, name, arg, context=None):
     res = {}
     today = now().strftime('%Y-%m-%d')
     for partner in self.browse(cr, uid, ids, context):
         accounts = []
         if partner.property_account_receivable:
             accounts.append(partner.property_account_receivable.id)
         if partner.property_account_payable:
             accounts.append(partner.property_account_payable.id)
         line_ids = self.pool.get('account.move.line').search(
             cr,
             uid, [('partner_id', '=', partner.id),
                   ('account_id', 'in', accounts),
                   ('reconcile_id', '=', False), '|',
                   ('date_maturity', '>=', today),
                   ('date_maturity', '=', False)],
             context=context)
         # Those that have amount_to_pay == 0, will mean that they're circulating. The payment request has been sent
         # to the bank but have not yet been reconciled (or the date_maturity has not been reached).
         amount = 0.0
         for line in self.pool.get('account.move.line').browse(
                 cr, uid, line_ids, context):
             #amount += line.debit - line.credit
             amount += -line.amount_to_pay
         res[partner.id] = amount
     return res
Пример #26
0
def current_time(db, layer_code='', time_zone=None):
    """
        Получение текущего времени с учетом time zone
    """
    if layer_code != '':
        if not time_zone:
            sql_text = 'select * from MY_GETDATETIME(?,?)'
            sql_params = [None, 'DT']
            res = db.dbExec(sql_text,
                            params=sql_params,
                            fetch='one')
            return res['DATETIMEZONE']
        else:
            return now() + timedelta(hours=time_zone)
    else:
        return now()
Пример #27
0
    def update_trait(self):
        """ Update the 'trait_user_notified' trait by:
          1. Creating it, if it doesn't exist
          2. Resetting it if the date attribute is more than
             days_reset days old.
          3. Incrementing the numval attribute.
        """
        # Initial values for new trait
        last_reset = now()
        num_sent = 0
        trait = self.ac.get_trait(self.co.trait_user_notified)

        # Trait date exists, and is not older than days_reset old.
        if trait and (last_reset - self.days_reset) < trait.get('date'):
            last_reset = trait.get('date')
            num_sent = trait.get('numval') or 0
        # Else, reset trait

        # Increment and write the updated trait values
        num_sent += 1

        self.ac.populate_trait(self.co.trait_user_notified,
                               numval=num_sent,
                               date=last_reset)
        self.ac.write_db()

        if self.dryrun:
            self.logger.warn("Dryrun, not writing trait '%s' for user '%s",
                             str(self.co.trait_user_notified),
                             self.ac.account_name)
            self.ac._db.rollback()
        else:
            self.ac._db.commit()
Пример #28
0
    def entity_is_fresh(self, person, account):
        """Check if a person or account is 'fresh', i.e. if the account or
        person is newly created, or if the account has been restored lately.

        This is to be able to avoid blocking new phone numbers from systems
        where the account is just activated.

        """
        delay = now() - getattr(cisconf, 'FRESH_DAYS', 10)

        # Check for traits only set for 'fresh' accounts:
        for tr in (self.co.trait_student_new, self.co.trait_sms_welcome):
            trait = account.get_trait(tr)
            if trait and trait['date'] > delay:
                log.debug(
                    'Fresh trait %s for account %s, so considered fresh' %
                    (tr, account.account_name))
                return True
        # Check if person has recently been created:
        for row in self.db.get_log_events(types=(self.co.person_create),
                                          any_entity=person.entity_id,
                                          sdate=delay):
            log.debug("Person %s is fresh" % person.entity_id)
            return True
        log.debug("Person %s (account %s) is not fresh" %
                  (person.entity_id, account.entity_id))
        return False
Пример #29
0
    def test_mxDateTime():
        setupClass(DateTime2)
        _now = now()
        dt2 = DateTime2(col1=_now, col2=_now.pydate(),
                        col3=Time(_now.hour, _now.minute, _now.second))

        assert isinstance(dt2.col1, col.DateTimeType)
        assert dt2.col1.year == _now.year
        assert dt2.col1.month == _now.month
        assert dt2.col1.day == _now.day
        assert dt2.col1.hour == _now.hour
        assert dt2.col1.minute == _now.minute
        assert dt2.col1.second == int(_now.second)

        assert isinstance(dt2.col2, col.DateTimeType)
        assert dt2.col2.year == _now.year
        assert dt2.col2.month == _now.month
        assert dt2.col2.day == _now.day
        assert dt2.col2.hour == 0
        assert dt2.col2.minute == 0
        assert dt2.col2.second == 0

        assert isinstance(dt2.col3, (col.DateTimeType, col.TimeType))
        assert dt2.col3.hour == _now.hour
        assert dt2.col3.minute == _now.minute
        assert dt2.col3.second == int(_now.second)
Пример #30
0
    def test_mxDateTime():
        setupClass(DateTime2)
        _now = now()
        dt2 = DateTime2(col1=_now, col2=_now, col3=Time(_now.hour, _now.minute, _now.second))

        assert isinstance(dt2.col1, col.DateTimeType)
        assert dt2.col1.year == _now.year
        assert dt2.col1.month == _now.month
        assert dt2.col1.day == _now.day
        assert dt2.col1.hour == _now.hour
        assert dt2.col1.minute == _now.minute
        assert dt2.col1.second == int(_now.second)

        assert isinstance(dt2.col2, col.DateTimeType)
        assert dt2.col2.year == _now.year
        assert dt2.col2.month == _now.month
        assert dt2.col2.day == _now.day
        if getConnection().dbName == "sqlite":
            assert dt2.col2.hour == _now.hour
            assert dt2.col2.minute == _now.minute
            assert dt2.col2.second == int(_now.second)
        else:
            assert dt2.col2.hour == 0
            assert dt2.col2.minute == 0
            assert dt2.col2.second == 0

        assert isinstance(dt2.col3, (col.DateTimeType, col.TimeType))
        assert dt2.col3.hour == _now.hour
        assert dt2.col3.minute == _now.minute
        assert dt2.col3.second == int(_now.second)
Пример #31
0
 def removeClient(self, perspective):
     """Quita al cliente de id clientId de la lista de clientes actuales.
     """
     #si era tutor elimino su room
     if perspective.perspective_whoami() == TUTOR:
         self.removeRoom(perspective.avId)
     else:
         if perspective.viewing != None:
             self.wbRooms[perspective.viewing].roomViewerExit(perspective.avId)
         #si esperaba lo elimino de la cola
         if perspective.waitingInQueue != None:
             self.wbQueues.leaveQueue(perspective.waitingInQueue, perspective.avId)
         #si estaba en "observacion"
         if perspective.waitingInRoom != None:
             self.wbRooms[perspective.waitingInRoom].roomPupilStopWaiting()
             avTutor = self.wbClients[perspective.waitingInRoom]
             avTutor.cleanWhiteBoard()
             self.exitViewers(perspective.waitingInRoom)
             self.manageNextPupil(perspective.waitingInRoom, self.sessions.pupilEnd)
         if perspective.roomId != None:
             self.wbRooms[perspective.roomId].roomPupilExit(perspective.avId)
             discount = (now().minute - perspective.lastMinute) % 60
             perspective.discountIA(discount)
             avTutor = self.wbClients[perspective.roomId]
             try:
                 self.notifyClient(perspective.roomId, "El alumno abandono")
                 avTutor.saveClassStatus()
                 avTutor.cleanWhiteBoard()
             except (pb.DeadReferenceError):
                 pass
             self.exitViewers(perspective.roomId)
             self.manageNextPupil(perspective.roomId, self.sessions.pupilEnd)
     del(self.wbClients[perspective.avId])
     del(self.wbClientStatus[perspective.avId])
Пример #32
0
def delete_stale_events(cl_events, db):
    """Remove all events of type cl_events older than GRACE_PERIOD.

    cl_events is an iterable listing change_log event types that we want
    expunged. These events cannot require any state change in Cerebrum (other
    than their own deletion). It is the caller's responsibility to check that
    this is so.
    """

    if not isinstance(cl_events, (list, tuple, set)):
        cl_events = [cl_events, ]

    clconst = Factory.get("CLConstants")()
    typeset_request = ", ".join(str(clconst.ChangeType(x))
                                for x in cl_events)
    logger.debug("Deleting stale requests: %s", typeset_request)
    for event in db.get_log_events(types=cl_events):
        tstamp = event["tstamp"]
        timeout = cereconf.GRACE_PERIOD
        try:
            params = json.loads(event["change_params"])
            if params['timeout'] is not None:
                timeout = DateTimeDelta(params['timeout'])
                logger.debug('Timeout set to %s for %s',
                             (now() + timeout).strftime('%Y-%m-%d'),
                             event['change_id'])

                if timeout > cereconf.MAX_INVITE_PERIOD:
                    logger.warning('Too long timeout (%s) for for %s',
                                   timeout.strftime('%Y-%m-%d'),
                                   event['change_id'])
                    timeout = cereconf.MAX_INVITE_PERIOD
        except KeyError:
            pass
        if now() - tstamp <= timeout:
            continue

        logger.debug("Deleting stale event %s (@%s) for entity %s (id=%s)",
                     str(clconst.ChangeType(event["change_type_id"])),
                     event["tstamp"].strftime("%Y-%m-%d"),
                     fetch_name(event["subject_entity"], db),
                     event["subject_entity"])

        db.remove_log_event(event["change_id"])
        db.commit()

    logger.debug("Deleted all stale requests: %s", typeset_request)
Пример #33
0
 def compute(self, cr, uid, id, value, paydays, date_ref=False, context={}):
     if not date_ref:
         date_ref = now().strftime('%Y-%m-%d')
     pt = self.browse(cr, uid, id, context)
     amount = value
     result = []
     aux_date = mx.DateTime.strptime(date_ref, '%Y-%m-%d')
     #        logger.notifyChannel('aux_date',netsvc.LOG_INFO, aux_date)
     for line in pt.line_ids:
         if line.value == 'fixed':
             amt = line.value_amount
         elif line.value == 'procent':
             amt = round(amount * line.value_amount, 2)
         elif line.value == 'balance':
             amt = amount
         if amt:
             next_date = aux_date + RelativeDateTime(days=line.days)
             #                logger.notifyChannel('_date',netsvc.LOG_INFO, next_date)
             if line.condition == 'end of month':
                 next_date += RelativeDateTime(day=-1)
             # Esta condición es la que se añade. Se crea una lista a partir de la cadena de 'Días de Pago'
             # y se ordena. Trás aplicar los días de plazo par el efecto se recorre la lista y se calcula
             # la fecha de vencimiento. Se ha añadido un día extra "en el mes siguiente" para vencimientos
             # posteriores a la última fecha. Dicho día es el primero de la lista del mes siguiente. Ejemplo: día 35 de
             # noviembre = 5 de Diciembre
             if line.condition == 'payment days' and paydays:
                 payment_days_list = map(int, paydays.split('-'))
                 #                    logger.notifyChannel('Dias de pago',netsvc.LOG_INFO, payment_days_list)
                 payment_days_list.sort()
                 #                    logger.notifyChannel('Dias de pago,2',netsvc.LOG_INFO, payment_days_list)
                 payment_days_list.append(next_date.days_in_month +
                                          payment_days_list[0])
                 #                    logger.notifyChannel('Dias de pago 3',netsvc.LOG_INFO, payment_days_list)
                 for pay_day in payment_days_list:
                     if next_date <= next_date + RelativeDateTime(
                             day=pay_day):
                         #                            logger.notifyChannel('next_date1',netsvc.LOG_INFO, next_date)
                         #                            logger.notifyChannel('next_date1',netsvc.LOG_INFO, pay_day)
                         next_date = next_date + RelativeDateTime(
                             day=pay_day)
                         #                            logger.notifyChannel('next_date1',netsvc.LOG_INFO, next_date)
                         # Se debe establecer un criterio de como actuar en el caso
                         # de que en un mes no exista el día de pago. ¿Qué se hace
                         # si el día de pago es el 30 y estamos en febrero?. Las
                         # tres siguiente líneas hacen que en este caso
                         # se tome como día de pago el último día del mes.
                         # Si se comentan estas líneas el día de pago será el
                         # día 1 o 2 del mes siguiente.
                         previous_month = next_date - RelativeDateTime(
                             months=1)
                         while next_date.day not in payment_days_list + [
                                 previous_month.days_in_month
                         ]:
                             next_date = next_date - RelativeDateTime(
                                 days=1)
                         break
             result.append((next_date.strftime('%Y-%m-%d'), amt))
             amount -= amt
     return result
Пример #34
0
 def __absolute_time(self, time_str):
     if time_str[0] == "+":
         # Relative time
         time = round_datetime(now() + Parser.TimeDeltaFromString(time_str[1:]))
     else:
         time = Parser.DateTimeFromString(time_str)
         
     return time
Пример #35
0
 def __absolute_time(self, time_str):
     if time_str[0] == "+":
         # Relative time
         time = round_datetime(now() + ISO.ParseTime(time_str[1:]))
     else:
         time = Parser.ParseDateTime(time_str)
         
     return time
Пример #36
0
    def __absolute_time(self, time_str):
        if time_str[0] == "+":
            # Relative time
            time = round_datetime(now() + ISO.ParseTime(time_str[1:]))
        else:
            time = Parser.ParseDateTime(time_str)

        return time
Пример #37
0
 def set_time():
    h = int(time_field_hour.get())
    m = int(time_field_min.get())
    s = int(time_field_sec.get())
    self.go_time = DateTime(now().year,now().month,now().day,h,m,s)
    if self.go_time < now():
       self.go_time = DateTime(now().year, now().month, now().day + 1, h, m, s)
    self.dt = self.go_time - now()
    self.armed = True
    run_alarm()
Пример #38
0
def sync_group(affil, gname, descr, mtype, memb, recurse=True):
    logger.debug(
        ("sync_group(parent:'%s'; groupname:'%s'; description:'%s'; " +
         "membertype:'%s'; members:'%s'; recurse:'%s')") %
        (affil, gname, descr, mtype, memb.keys(), recurse))
    if mtype == constants.entity_group:  # memb has group_name as keys
        members = {}
        for tmp_gname in memb.keys():
            grp = get_group(tmp_gname)
            members[int(grp.entity_id)] = 1
    else:
        # memb has account_id as keys
        members = memb.copy()

    if affil is not None:
        AffiliatedGroups.setdefault(affil, {})[gname] = 1

    try:
        group = get_group(gname)
    except Errors.NotFoundError:
        group = Factory.get('Group')(db)
        group.clear()
        group.populate(
            creator_id=group_creator,
            visibility=constants.group_visibility_all,
            name=gname,
            description=descr,
            group_type=constants.group_type_unknown,
        )
        group.write_db()
    else:
        # Update description if it has changed
        if group.description != descr:
            group.description = descr
            group.write_db()

        if group.is_expired():
            # Extend the group's life by 6 months
            from mx.DateTime import now, DateTimeDelta
            group.expire_date = now() + DateTimeDelta(6 * 30)
            group.write_db()

        # Make sure the group is listed for export to LMS
        if not group.has_spread(constants.spread_lms_group):
            group.add_spread(constants.spread_lms_group)

        for member in group.search_members(group_id=group.entity_id,
                                           member_type=mtype,
                                           member_filter_expired=False):
            member = int(member["member_id"])
            if members.has_key(member):
                del members[member]
            else:
                logger.debug("sync_group(): Deleting member %d" % member)
                group.remove_member(member)

    for member in members.keys():
        group.add_member(member)
Пример #39
0
    def _makeOrder(self, cr, uid, data, context):
        pool = pooler.get_pool(cr.dbname)
        purchase_obj = pool.get('purchase.order')
        sale_obj = pool.get('sale.order')

        shop_obj = pool.get('sale.shop')
        shop_id = shop_obj.search(cr, uid, [])[0]

        partner_obj = pool.get('res.partner')
        sale_line_obj = pool.get('sale.order.line')

        new_ids = []

        user = pool.get('res.users').browse(cr, uid, uid)
        partner_id = user.company_id.partner_id.id
        partner_addr = partner_obj.address_get(
            cr, uid, [partner_id], ['invoice', 'delivery', 'contact'])
        default_pricelist = partner_obj.browse(
            cr, uid, partner_id, context).property_product_pricelist.id
        fpos = partner_obj.browse(cr, uid, partner_id,
                                  context).property_account_position
        fpos_id = fpos and fpos.id or False

        for purchase in purchase_obj.browse(cr, uid, data['ids']):
            vals = {
                'origin': 'PO:%s' % str(purchase.name),
                'picking_policy': 'direct',
                'shop_id': shop_id,
                'partner_id': partner_id,
                'pricelist_id': default_pricelist,
                'partner_invoice_id': partner_addr['invoice'],
                'partner_order_id': partner_addr['contact'],
                'partner_shipping_id': partner_addr['delivery'],
                'order_policy': 'manual',
                'date_order': now(),
                'fiscal_position': fpos_id
            }
            new_id = sale_obj.create(cr, uid, vals)
            fpos = user.company_id.partner_id.property_account_position and user.company_id.partner_id.property_account_position.id or False
            for line in purchase.order_line:
                value = sale_line_obj.product_id_change(
                    cr,
                    uid, [],
                    default_pricelist,
                    line.product_id.id,
                    qty=line.product_qty,
                    partner_id=partner_id,
                    fiscal_position=fpos)['value']
                value['price_unit'] = line.price_unit
                value['product_id'] = line.product_id.id
                value['product_uos'] = value.get('product_uos') and value.get(
                    'product_uos')[0] or False
                value['product_uom_qty'] = line.product_qty
                value['order_id'] = new_id
                sale_line_obj.create(cr, uid, value)

        return {}
Пример #40
0
 def testRegisterDocument(self):
     self.pos.registerDocument(documentClass=Invoice,
                               number='some number',
                               type='X',
                               detail='blah blah blah',
                               amount=100,
                               actualDate=now(),
                               otherParty=self.client)
     self.trans.save()
Пример #41
0
 def __init__(self,
              number=0,
              recordTime=None,
              pos=None,
              customerAccount=None):
     self.number = number
     self.recordTime = recordTime or now()
     self.pointOfSale = pos
     self.customerAccount = customerAccount
Пример #42
0
    def _opening(self, query, roomList, kind):
        day = now()
        if kind == IACLASS:
            day = DateTime(2005, 5, (1 + day.day_of_week) % 7 + 1, day.hour, day.minute)
        day = day + RelativeDateTime(minute=day.minute+2)

        d = self.db.db.runQuery(query, (day,))
        d.addCallback(self._updateRooms, roomList)
        d.addCallback(self._openRooms, roomList, kind)
Пример #43
0
    def get_phone_numbers(self, person, only_first_affiliation=True):
        """Return a list of the registered phone numbers for a given person.
        Only the defined source systems and contact types are searched for, and
        the person must have an active affiliation from a system before a number
        could be retrieved from that same system.

        Note that only the person affiliation with the highest priority is
        checked for phone numbers, as long as L{only_first_affiliation} is True.
        This is to separate the user types and avoid e.g. a student's phone
        getting changed and thus be able to get hold of the employee account for
        the same person.

        """
        old_limit = now() - RelativeDateTime(
            days=cereconf.INDIVIDUATION_AFF_GRACE_PERIOD)
        pe_systems = [
            int(af['source_system'])
            for af in person.list_affiliations(person_id=person.entity_id,
                                               include_deleted=True)
            if (af['deleted_date'] is None or af['deleted_date'] > old_limit)
        ]
        log.debug("Person has affiliations in the systems: %s" % pe_systems)
        phones = []
        for systems in self._get_priorities():
            sys_codes = [getattr(self.co, s) for s in systems]
            if not any(s in sys_codes for s in pe_systems):
                # person has no affiliation at this priority go to next priority
                continue
            for system, values in systems.iteritems():
                types = [getattr(self.co, t) for t in values['types']]
                sys = getattr(self.co, system)
                if not types:
                    # support empty lists, to be able to block e.g. employees
                    # from the service
                    continue
                for row in person.list_contact_info(entity_id=person.entity_id,
                                                    contact_type=types,
                                                    source_system=sys):
                    phones.append({
                        'number':
                        row['contact_value'],
                        'system':
                        sys,
                        'system_name':
                        system,
                        'type':
                        self.co.ContactInfo(row['contact_type']),
                    })
            log.debug(
                "Phones for person_id:%s from (%s): %s" %
                (person.entity_id, ','.join(s for s in systems), ','.join(
                    '%s:%s:%s' % (p['system_name'], p['type'], p['number'])
                    for p in phones)))
            if only_first_affiliation:
                return phones
        return phones
 def testRegisterDocument(self):
     self.pos.registerDocument(documentClass=Invoice,
                               number='some number',
                               type='X',
                               detail='blah blah blah',
                               amount=100,
                               actualDate=now(),
                               otherParty=self.client
                               )
     self.trans.save()
Пример #45
0
        def testMxDateTime(self):
            _now = now()
            dt2 = DateTime2(col1=_now, col2=_now)
            self.failUnless(isinstance(dt2.col1, col.DateTimeType))
            self.failUnless(isinstance(dt2.col2, col.DateTimeType))

            today_str = _now.strftime("%Y-%m-%d 00:00:00.00")
            now_str = _now.strftime("%Y-%m-%d %T.00")
            self.assertEqual(str(dt2.col1), today_str)
            self.assertEqual(str(dt2.col2), now_str)
Пример #46
0
    def _restoringPA(self, query, roomList, kind):
        day = now()
        day1 = DateTime(2005, 5, (1 + day.day_of_week) % 7 + 1, day.hour, day.minute)
        day2 = DateTime(2005, 5, (1 + day.day_of_week) % 7 + 8, day.hour, day.minute)
        day1_start = day1 + RelativeDateTime(minute=day.minute+2)
        day2_start = day2 + RelativeDateTime(minute=day.minute+2)

        d = self.db.db.runQuery(query, (day1_start, day1, day2_start, day2))
        d.addCallback(self._updateRooms, roomList)
        d.addCallback(self._openRooms, roomList, kind)
Пример #47
0
        def testDateTime(self):
            _now = now()
            dt1 = DateTime1(col1=_now, col2=_now)
            self.failUnless(isinstance(dt1.col1, date))
            self.failUnless(isinstance(dt1.col2, datetime))

            today_str = _now.strftime("%Y-%m-%d")
            now_str = _now.strftime("%Y-%m-%d %T")
            self.assertEqual(str(dt1.col1), today_str)
            self.assertEqual(str(dt1.col2), now_str)
Пример #48
0
    def _makeOrder(self, cr, uid, data, context):
        pool = pooler.get_pool(cr.dbname)
        purchase_obj = pool.get('purchase.order')
        sale_obj = pool.get('sale.order')
        
        shop_obj = pool.get('sale.shop')
        shop_check = shop_obj.search(cr, uid, [])
        if shop_check:
            shop_id = shop_check[0]
        else :
            raise osv.except_osv(_('Error !'), _('No Shop defined for this Company !\nPlease create Shop for this Company.'))

        partner_obj = pool.get('res.partner')
        sale_line_obj = pool.get('sale.order.line')


        new_ids = []

        user = pool.get('res.users').browse(cr, uid, uid)
        partner_id = user.company_id.partner_id.id
        partner_addr = partner_obj.address_get(cr, uid, [partner_id],
                ['invoice', 'delivery', 'contact'])
        default_pricelist = partner_obj.browse(cr, uid, partner_id,
                    context).property_product_pricelist.id
        fpos = partner_obj.browse(cr, uid, partner_id,
                    context).property_account_position
        fpos_id = fpos and fpos.id or False

        for purchase in purchase_obj.browse(cr, uid, data['ids']):
            vals = {
                'origin': 'PO:%s' % str(purchase.name),
                'picking_policy': 'direct',
                'shop_id': shop_id,
                'partner_id': partner_id,
                'pricelist_id': default_pricelist,
                'partner_invoice_id': partner_addr['invoice'],
                'partner_order_id': partner_addr['contact'],
                'partner_shipping_id': partner_addr['delivery'],
                'order_policy': 'manual',
                'date_order': now(),
                'fiscal_position': fpos_id
            }
            new_id = sale_obj.create(cr, uid, vals)
            fpos = user.company_id.partner_id.property_account_position and user.company_id.partner_id.property_account_position.id or False
            for line in purchase.order_line:
                value = sale_line_obj.product_id_change(cr, uid, [], default_pricelist,
                        line.product_id.id, qty=line.product_qty, partner_id=partner_id, fiscal_position=fpos)['value']
                value['price_unit'] = line.price_unit
                value['product_id'] = line.product_id.id
                value['product_uos'] = value.get('product_uos') and  value.get('product_uos')[0] or False
                value['product_uom_qty'] = line.product_qty
                value['order_id'] = new_id
                sale_line_obj.create(cr, uid, value)

        return {}
Пример #49
0
 def testClassCreate(self):
     if not self.supportAuto:
         return
     class AutoTest(SQLObject):
         _fromDatabase = True
         _idName = 'auto_id'
         _connection = connection()
     john = AutoTest(firstName='john',
                     lastName='doe',
                     age=10,
                     created=now(),
                     wannahavefun=False)
     jane = AutoTest(firstName='jane',
                     lastName='doe',
                     happy='N',
                     created=now(),
                     wannahavefun=True)
     self.failIf(john.wannahavefun)
     self.failUnless(jane.wannahavefun)
     del classregistry.registry(AutoTest._registry).classes['AutoTest']
Пример #50
0
 def _saveStatus(self):
     date = now()
     status = self.server.wbClientStatus[self.avId].pickle()
     queryIdSubject = """select id from subject where name=%s"""
     query = """insert into offline_questions (fk_pupil, fk_subject, time_submit, status)
         values (%s, %s, '%s', %s)
         """
     status = QuotedString(status)
     d = self.db.db.runQuery(queryIdSubject, (self.selectedSubject,))
     d.addCallback(lambda idRes: self.db.db.runOperation(query, (self.avId, idRes[0][0], date, status)))
     return d       
Пример #51
0
def ous_with_quarantines(ou_object, ou_quarantine, initial_account):
    from mx.DateTime import now
    ous = list()
    for e in _populator(ou_object):
        ou_object.find(e.get('entity_id'))
        ou_object.add_entity_quarantine(ou_quarantine,
                                        initial_account.entity_id,
                                        "Description", now())
        ou_object.clear()
        ous.append(e)
    return ous
Пример #52
0
    def test_dateTime():
        setupClass(DateTime1)
        _now = now()
        dt1 = DateTime1(col1=_now, col2=_now)
        assert isinstance(dt1.col1, date)
        assert isinstance(dt1.col2, datetime)

        today_str = _now.strftime("%Y-%m-%d")
        now_str = _now.strftime("%Y-%m-%d %T")
        assert str(dt1.col1) == today_str
        assert str(dt1.col2) == now_str
Пример #53
0
    def test_mxDateTime():
        setupClass(DateTime2)
        _now = now()
        dt2 = DateTime2(col1=_now, col2=_now)
        assert isinstance(dt2.col1, col.DateTimeType)
        assert isinstance(dt2.col2, col.DateTimeType)

        today_str = _now.strftime("%Y-%m-%d 00:00:00.00")
        now_str = _now.strftime("%Y-%m-%d %T.00")
        assert str(dt2.col1) == today_str
        assert str(dt2.col2) == now_str
Пример #54
0
 def set_start(self, cr, uid, ids, context={}):
     self.write(cr, uid, ids, {'state': 'ready'})
     cron_id = self.browse(cr, uid, ids[0], {}).cron_id.id
     nextcall = (now() + DateTime.RelativeDateTime(seconds=30)
                 ).strftime('%Y-%m-%d %H:%M:%S')
     self.pool.get('ir.cron').write(cr, uid, cron_id, {
         'numbercall': 1,
         'active': True,
         'nextcall': nextcall
     })
     return True
Пример #55
0
    def actionScheduleAlarm(self, cmsg, dbcom):

        sms_dict = self.alarm.retrieveData(cmsg)

        activity = ACTIVE

        if sms_dict == NOTFOUND:
            self.log.LOG(
                LOG_ERROR, "sms.actionScheduleAlarm()",
                "TAGs are missing in the requisition to schedule an alarm. Aborting schedule."
            )
            return "NOTFOUND"

        blow = self.shared.mountTime(sms_dict[DATA_BLOW])

        if blow == INVALID:
            return "INVALID"

        elif blow < now() or blow == now():
            activity = FAILED

        ret = dbcom.registerSMS(sms_dict[DATA_ORG], sms_dict[DATA_EXT + "0"],
                                sms_dict[DATA_BLOW], sms_dict[DATA_OPER],
                                sms_dict[DATA_MSG], activity)

        if ret == OK and activity == ACTIVE:
            alarm_thread = Thread(target=self.alarm.launch, args=(blow, ))
            alarm_thread.start()
            self.log.LOG(LOG_INFO, "sms", "New alarm thread has been started.")
            return "OK"

        elif ret == NOTFOUND:
            return "NOTFOUND"

        elif activity == FAILED:
            return "INVALID"

        else:
            return "ERROR"
Пример #56
0
	def launch(self, blow):

		try:
			sleep_time = int(blow - now())

			self.log.LOG(LOG_INFO, "alarm", "New alarm has been scheduled. Blow date/time in %s. It's take %d seconds from now." % (blow, sleep_time))

			time.sleep(sleep_time)

			self.log.LOG(LOG_INFO, "alarm", "THE ALARM HAS EXPLODED!!!.")

		except:
			self.log.LOG(LOG_CRITICAL, "alarm.launch()", "The alarm thread has a problem and will be aborted.")	
def main(inargs=None):
    parser = argparse.ArgumentParser(
        description="Generate an html formatted report of accounts with"
                    " active quarantines")

    parser.add_argument(
        '-o', '--output',
        metavar='FILE',
        type=argparse.FileType('w'),
        default='-',
        help='Output file for report, defaults to stdout')
    parser.add_argument(
        '-e', '--encoding',
        dest='codec',
        default=DEFAULT_ENCODING,
        type=codec_type,
        help="Output file encoding, defaults to %(default)s")

    age_arg = parser.add_mutually_exclusive_group(required=True)
    age_arg.add_argument(
        '-s', '--start_date',
        metavar='DATE',
        dest='start_date',
        type=ISO.ParseDate,
        help='Report quarantines set by date (YYYY-MM-DD)')
    age_arg.add_argument(
        '-a', '--age',
        metavar='DAYS',
        dest='start_date',
        type=lambda x: now() + RelativeDateTime(days=-abs(int(x))),
        help='Report quarantines set by age (in days)')

    Cerebrum.logutils.options.install_subparser(parser)
    args = parser.parse_args(inargs)
    Cerebrum.logutils.autoconf('cronjob', args)

    db = Factory.get('Database')()

    logger.info('Start of script %s', parser.prog)
    logger.debug("args: %r", args)

    quarantines = list(get_quarantine_data(db, args.start_date))

    write_html_report(args.output, args.codec, quarantines, args.start_date)

    args.output.flush()
    if args.output is not sys.stdout:
        args.output.close()

    logger.info('Report written to %s', args.output.name)
    logger.info('Done with script %s', parser.prog)
Пример #58
0
def write_html_report(stream, codec, matches):
    output = codec.streamwriter(stream)
    template_env = Environment(trim_blocks=True, lstrip_blocks=True)
    report = template_env.from_string(template)

    num_accounts = sum(len(v) for v in matches.values())
    output.write(
        report.render({
            'encoding': codec.name,
            'num_accounts': num_accounts,
            'matches': matches,
            'when': now().strftime('%Y-%m-%d %H:%M:%S'),
        }))
    output.write('\n')
Пример #59
0
 def purgeOldResults(self):
     """removes old records in the results table"""
     tresholdDate = now() - ONE_HOUR
     query = 'DELETE FROM results WHERE record_ts < %(treshold)s'
     cursor = self._cnx.cursor()
     try:
         cursor.execute(query, {'treshold': tresholdDate})
     except:
         traceback.print_exc()
         cursor.close()
         self._cnx.rollback()
     else:
         cursor.close()
         self._cnx.commit()