Python OpenERPJobStorage.load方法代码示例

# 需要导入模块: from openerp.addons.connector.queue.job import OpenERPJobStorage [as 别名]
# 或者: from openerp.addons.connector.queue.job.OpenERPJobStorage import load [as 别名]
 def test_job_unlinked(self):
     test_job = Job(func=dummy_task_args, model_name="res.users", args=("o", "k"), kwargs={"c": "!"})
     storage = OpenERPJobStorage(self.session)
     storage.store(test_job)
     stored = self.queue_job.search([("uuid", "=", test_job.uuid)])
     stored.unlink()
     with self.assertRaises(NoSuchJobError):
         storage.load(test_job.uuid)

# 需要导入模块: from openerp.addons.connector.queue.job import OpenERPJobStorage [as 别名]
# 或者: from openerp.addons.connector.queue.job.OpenERPJobStorage import load [as 别名]
    def test_read(self):
        eta = datetime.now() + timedelta(hours=5)
        test_job = Job(func=dummy_task_args,
                       model_name='res.users',
                       args=('o', 'k'),
                       kwargs={'c': '!'},
                       priority=15,
                       eta=eta,
                       description="My description")
        test_job.user_id = 1
        test_job.company_id = self.env.ref("base.main_company").id
        storage = OpenERPJobStorage(self.session)
        storage.store(test_job)
        job_read = storage.load(test_job.uuid)
        self.assertEqual(test_job.uuid, job_read.uuid)
        self.assertEqual(test_job.model_name, job_read.model_name)
        self.assertEqual(test_job.func, job_read.func)
        self.assertEqual(test_job.args, job_read.args)
        self.assertEqual(test_job.kwargs, job_read.kwargs)
        self.assertEqual(test_job.func_name, job_read.func_name)
        self.assertEqual(test_job.func_string, job_read.func_string)
        self.assertEqual(test_job.description, job_read.description)
        self.assertEqual(test_job.state, job_read.state)
        self.assertEqual(test_job.priority, job_read.priority)
        self.assertEqual(test_job.exc_info, job_read.exc_info)
        self.assertEqual(test_job.result, job_read.result)
        self.assertEqual(test_job.user_id, job_read.user_id)
        self.assertEqual(test_job.company_id, job_read.company_id)
        delta = timedelta(seconds=1)  # DB does not keep milliseconds
        self.assertAlmostEqual(test_job.date_created, job_read.date_created,
                               delta=delta)
        self.assertAlmostEqual(test_job.date_started, job_read.date_started,
                               delta=delta)
        self.assertAlmostEqual(test_job.date_enqueued, job_read.date_enqueued,
                               delta=delta)
        self.assertAlmostEqual(test_job.date_done, job_read.date_done,
                               delta=delta)
        self.assertAlmostEqual(test_job.eta, job_read.eta,
                               delta=delta)

        test_date = datetime(2015, 3, 15, 21, 7, 0)
        job_read.date_enqueued = test_date
        job_read.date_started = test_date
        job_read.date_done = test_date
        job_read.canceled = True
        storage.store(job_read)

        job_read = storage.load(test_job.uuid)
        self.assertAlmostEqual(job_read.date_started, test_date,
                               delta=delta)
        self.assertAlmostEqual(job_read.date_enqueued, test_date,
                               delta=delta)
        self.assertAlmostEqual(job_read.date_done, test_date,
                               delta=delta)
        self.assertEqual(job_read.canceled, True)

# 需要导入模块: from openerp.addons.connector.queue.job import OpenERPJobStorage [as 别名]
# 或者: from openerp.addons.connector.queue.job.OpenERPJobStorage import load [as 别名]
 def test_job_unlinked(self):
     test_job = Job(func=dummy_task_args,
                    model_name='res.users',
                    args=('o', 'k'),
                    kwargs={'c': '!'})
     storage = OpenERPJobStorage(self.session)
     storage.store(test_job)
     stored = self.queue_job.search([('uuid', '=', test_job.uuid)])
     stored.unlink()
     with self.assertRaises(NoSuchJobError):
         storage.load(test_job.uuid)

# 需要导入模块: from openerp.addons.connector.queue.job import OpenERPJobStorage [as 别名]
# 或者: from openerp.addons.connector.queue.job.OpenERPJobStorage import load [as 别名]
    def _cancel_jobs(self, cr, uid, context=None):
        """Find moves where the mark has been removed and cancel the jobs.

        For the moves that are posted already it's too late: we skip them.

        """

        if context is None:
            context = {}

        session = ConnectorSession(cr, uid, context=context)
        storage = OpenERPJobStorage(session)

        move_ids = self.search(cr, uid, [
            ('to_post', '=', False),
            ('post_job_uuid', '!=', False),
            ('state', '=', 'draft'),
        ], context=context)

        for move in self.browse(cr, uid, move_ids, context=context):
            job = storage.load(move.post_job_uuid)
            if job.state in (u'pending', u'enqueued'):
                job.set_done(result=_(
                    u'Task set to Done because the user unmarked the move'
                ))
                storage.store(job)

# 需要导入模块: from openerp.addons.connector.queue.job import OpenERPJobStorage [as 别名]
# 或者: from openerp.addons.connector.queue.job.OpenERPJobStorage import load [as 别名]
 def test_job_worker(self):
     worker = self.env["queue.worker"].create({"uuid": "57569b99-c2c1-47b6-aad1-72f953c92c87"})
     test_job = Job(func=dummy_task_args, model_name="res.users", args=("o", "k"), kwargs={"c": "!"})
     test_job.worker_uuid = worker.uuid
     storage = OpenERPJobStorage(self.session)
     self.assertEqual(storage._worker_id(worker.uuid), worker.id)
     storage.store(test_job)
     job_read = storage.load(test_job.uuid)
     self.assertEqual(job_read.worker_uuid, worker.uuid)

# 需要导入模块: from openerp.addons.connector.queue.job import OpenERPJobStorage [as 别名]
# 或者: from openerp.addons.connector.queue.job.OpenERPJobStorage import load [as 别名]
 def test_job_worker(self):
     worker = self.env['queue.worker'].create(
         {'uuid': '57569b99-c2c1-47b6-aad1-72f953c92c87'}
     )
     test_job = Job(func=dummy_task_args,
                    model_name='res.users',
                    args=('o', 'k'),
                    kwargs={'c': '!'})
     test_job.worker_uuid = worker.uuid
     storage = OpenERPJobStorage(self.session)
     self.assertEqual(storage._worker_id(worker.uuid), worker.id)
     storage.store(test_job)
     job_read = storage.load(test_job.uuid)
     self.assertEqual(job_read.worker_uuid, worker.uuid)

# 需要导入模块: from openerp.addons.connector.queue.job import OpenERPJobStorage [as 别名]
# 或者: from openerp.addons.connector.queue.job.OpenERPJobStorage import load [as 别名]
 def test_unicode(self):
     test_job = Job(func=dummy_task_args,
                    model_name='res.users',
                    args=(u'öô¿‽', u'ñě'),
                    kwargs={'c': u'ßø'},
                    priority=15,
                    description=u"My dé^Wdescription")
     test_job.user_id = 1
     storage = OpenERPJobStorage(self.session)
     storage.store(test_job)
     job_read = storage.load(test_job.uuid)
     self.assertEqual(test_job.args, job_read.args)
     self.assertEqual(job_read.args, ('res.users', u'öô¿‽', u'ñě'))
     self.assertEqual(test_job.kwargs, job_read.kwargs)
     self.assertEqual(job_read.kwargs, {'c': u'ßø'})
     self.assertEqual(test_job.description, job_read.description)
     self.assertEqual(job_read.description, u"My dé^Wdescription")

# 需要导入模块: from openerp.addons.connector.queue.job import OpenERPJobStorage [as 别名]
# 或者: from openerp.addons.connector.queue.job.OpenERPJobStorage import load [as 别名]
 def test_unicode(self):
     test_job = Job(
         func=dummy_task_args,
         model_name="res.users",
         args=(u"öô¿‽", u"ñě"),
         kwargs={"c": u"ßø"},
         priority=15,
         description=u"My dé^Wdescription",
     )
     test_job.user_id = 1
     storage = OpenERPJobStorage(self.session)
     storage.store(test_job)
     job_read = storage.load(test_job.uuid)
     self.assertEqual(test_job.args, job_read.args)
     self.assertEqual(job_read.args, ("res.users", u"öô¿‽", u"ñě"))
     self.assertEqual(test_job.kwargs, job_read.kwargs)
     self.assertEqual(job_read.kwargs, {"c": u"ßø"})
     self.assertEqual(test_job.description, job_read.description)
     self.assertEqual(job_read.description, u"My dé^Wdescription")

# 需要导入模块: from openerp.addons.connector.queue.job import OpenERPJobStorage [as 别名]
# 或者: from openerp.addons.connector.queue.job.OpenERPJobStorage import load [as 别名]
 def test_accented_bytestring(self):
     job = Job(func=dummy_task_args,
               model_name='res.users',
               args=('öô¿‽', 'ñě'),
               kwargs={'c': 'ßø'},
               priority=15,
               description="My dé^Wdescription")
     job.user_id = 1
     storage = OpenERPJobStorage(self.session)
     storage.store(job)
     job_read = storage.load(job.uuid)
     self.assertEqual(job.args, job_read.args)
     self.assertEqual(job_read.args, ('res.users', 'öô¿‽', 'ñě'))
     self.assertEqual(job.kwargs, job_read.kwargs)
     self.assertEqual(job_read.kwargs, {'c': 'ßø'})
     # the job's description has been created as bytestring but is
     # decoded to utf8 by the ORM so make them comparable
     self.assertEqual(job.description, job_read.description.encode('utf8'))
     self.assertEqual(job_read.description, "My dé^Wdescription".decode('utf8'))

# 需要导入模块: from openerp.addons.connector.queue.job import OpenERPJobStorage [as 别名]
# 或者: from openerp.addons.connector.queue.job.OpenERPJobStorage import load [as 别名]
 def test_accented_bytestring(self):
     test_job = Job(
         func=dummy_task_args,
         model_name="res.users",
         args=("öô¿‽", "ñě"),
         kwargs={"c": "ßø"},
         priority=15,
         description="My dé^Wdescription",
     )
     test_job.user_id = 1
     storage = OpenERPJobStorage(self.session)
     storage.store(test_job)
     job_read = storage.load(test_job.uuid)
     self.assertEqual(test_job.args, job_read.args)
     self.assertEqual(job_read.args, ("res.users", "öô¿‽", "ñě"))
     self.assertEqual(test_job.kwargs, job_read.kwargs)
     self.assertEqual(job_read.kwargs, {"c": "ßø"})
     # the job's description has been created as bytestring but is
     # decoded to utf8 by the ORM so make them comparable
     self.assertEqual(test_job.description, job_read.description.encode("utf8"))
     self.assertEqual(job_read.description, "My dé^Wdescription".decode("utf8"))

# 需要导入模块: from openerp.addons.connector.queue.job import OpenERPJobStorage [as 别名]
# 或者: from openerp.addons.connector.queue.job.OpenERPJobStorage import load [as 别名]
    def _cancel_jobs(self, cr, uid, context=None):
        """Find payment.orders where the mark has been removed and cancel the jobs.
        """

        if context is None:
            context = {}

        session = ConnectorSession(cr, uid, context=context)
        storage = OpenERPJobStorage(session)

        paymentorder_ids = self.search(cr, uid, [
            ('to_process', '=', False),
            ('post_job_uuid', '!=', False)
        ], context=context)

        for paymentorder in self.browse(cr, uid, paymentorder_ids, context=context):
            job_rec = storage.load(paymentorder.post_job_uuid)
            if job_rec.state in (u'pending', u'enqueued'):
                job_rec.set_done(result=_(
                    u'Task set to Done because the user unmarked the payment order'
                ))
                storage.store(job_rec)

# 需要导入模块: from openerp.addons.connector.queue.job import OpenERPJobStorage [as 别名]
# 或者: from openerp.addons.connector.queue.job.OpenERPJobStorage import load [as 别名]
 def test_read(self):
     eta = datetime.now() + timedelta(hours=5)
     job = Job(func=dummy_task_args,
               model_name='res.users',
               args=('o', 'k'),
               kwargs={'c': '!'},
               priority=15,
               eta=eta,
               description="My description")
     job.user_id = 1
     storage = OpenERPJobStorage(self.session)
     storage.store(job)
     job_read = storage.load(job.uuid)
     self.assertEqual(job.uuid, job_read.uuid)
     self.assertEqual(job.model_name, job_read.model_name)
     self.assertEqual(job.func, job_read.func)
     self.assertEqual(job.args, job_read.args)
     self.assertEqual(job.kwargs, job_read.kwargs)
     self.assertEqual(job.func_name, job_read.func_name)
     self.assertEqual(job.func_string, job_read.func_string)
     self.assertEqual(job.description, job_read.description)
     self.assertEqual(job.state, job_read.state)
     self.assertEqual(job.priority, job_read.priority)
     self.assertEqual(job.exc_info, job_read.exc_info)
     self.assertEqual(job.result, job_read.result)
     self.assertEqual(job.user_id, job_read.user_id)
     delta = timedelta(seconds=1)  # DB does not keep milliseconds
     self.assertAlmostEqual(job.date_created, job_read.date_created,
                            delta=delta)
     self.assertAlmostEqual(job.date_started, job_read.date_started,
                            delta=delta)
     self.assertAlmostEqual(job.date_enqueued, job_read.date_enqueued,
                            delta=delta)
     self.assertAlmostEqual(job.date_done, job_read.date_done,
                            delta=delta)
     self.assertAlmostEqual(job.eta, job_read.eta,
                            delta=delta)