~syleam/openobject-server/trunk-manage-tablespace

    pass

 

class YamlTag(object):

    def __init__(self, **kwargs):

        self.__dict__.update(kwargs)

    def __getitem__(self, key):

        super(Record, self).__init__(**kwargs)

    

class Python(YamlTag):

        self.model= model

        self.severity = severity

        self.name = name

        self._report = {}

 

    def record(self, success, severity):

        if severity in self._report:

            self._report[severity][success] += 1

        else:

        res.append("end of report (%s assertion(s) checked)" % success + failure)

        return "\n".join(res)

 

class YamlInterpreter(object):

    def __init__(self, cr, module, id_map, mode, filename, noupdate=False):

        self.cr = cr

        self.filename = filename

        self.assert_report = TestReport()

        self.noupdate = noupdate

        self.pool = pooler.get_pool(cr.dbname)

        self.uid = 1

 

    def _ref(self):

        return lambda xml_id: self.get_id(xml_id)

            if module != self.module:

                module_count = self.pool.get('ir.module.module').search_count(self.cr, self.uid, \

                        ['&', ('name', '=', module), ('state', 'in', ['installed'])])

        if len(id) > 64: # TODO where does 64 come from (DB is 128)? should be a constant or loaded form DB

            self.logger.log(logging.ERROR, 'id: %s is to long (max: 64)', id)

 

    def get_id(self, xml_id):

        if isinstance(xml_id, types.IntType):

            id = xml_id

        elif xml_id in self.id_map:

            self.id_map[xml_id] = id

        return id

    

        context = self.context.copy()

        if node.context:

        return context

 

    def isnoupdate(self, node):

        self.assert_report.record(False, severity)

        self.logger.log(severity, msg, *args)

        if severity >= config['assert_exit_level']:

        return

 

    def _get_assertion_id(self, assertion):

        if assertion.id:

            ids = [self.get_id(assertion.id)]

        elif assertion.search:

            ids = self.pool.get(assertion.model).search(self.cr, self.uid, q, context=assertion.context)

        if not ids:

            raise YamlImportException('Nothing to assert: you must give either an id or a search criteria.')

            args = (assertion.string, assertion.count, len(ids))

            self._log_assert_failure(assertion.severity, msg, *args)

        else:

            for id in ids:

                record = model.browse(self.cr, self.uid, id, context)

                for test in expressions.get('test', ''):

                    if not success:

                        msg = 'Assertion "%s" FAILED\ntest: %s\n'

                        args = (assertion.string, test)

        if self.isnoupdate(record) and self.mode != 'init':

            model = self.get_model(record.model)

            record_dict = self._create_record(model, fields)

            id = self.pool.get('ir.model.data')._update(self.cr, self.uid, record.model, \

                    self.module, record_dict, record.id, noupdate=self.isnoupdate(record), mode=self.mode)

            self.id_map[record.id] = int(id)

        code_context = {'self': model, 'cr': self.cr, 'uid': self.uid, 'log': log, 'context': self.context}

        try:

            code = compile(statements, self.filename, 'exec')

        except AssertionError, e:

            return

        except Exception, e:

            raise YamlImportAbortion(e)

            if not 'model' in value and (not 'eval' in value or not 'search' in value):

                raise YamlImportException('You must provide a "model" and an "eval" or "search" to evaluate.')

            value_model = self.get_model(value['model'])

            local_context.update(self.id_map)

        

        if workflow.uid is not None:

            uid = workflow.uid

        function, values = node.items()[0]

        if self.isnoupdate(function) and self.mode != 'init':

            return

        args = []

        if function.eval:

        for value in values:

            if not 'model' in value and (not 'eval' in value or not 'search' in value):

                raise YamlImportException('You must provide a "model" and an "eval" or "search" to evaluate.')

            value_model = self.get_model(value['model'])

            local_context.update(self.id_map)

            if id != None:

                args.append(id)

        model = self.get_model(function.model)

        view_id = False

        if node.view:

            view_id = self.get_id(node.view)

 

        values = {

            'name': node.name,

    def process_delete(self, node):

        ids = []

        if len(node.search):

        if len(node.id):

            try:

                ids.append(self.get_id(node.id))

        res = {}

        for fieldname, expression in fields.items():

            if isinstance(expression, Eval):

            else:

                value = expression

            res[fieldname] = value

            replace = node.replace or True

            self.pool.get('ir.model.data').ir_set(self.cr, self.uid, 'action', \

                    keyword, values['name'], [values['model']], value, replace=replace, isobject=True, xml_id=xml_id)

 

    def process(self, yaml_string):

        is_preceded_by_comment = False

        for node in yaml.load(yaml_string):

            is_preceded_by_comment = self._log(node, is_preceded_by_comment)

                self.logger.log(logging.ERROR, e)

            except YamlImportAbortion, e:

                self.logger.log(logging.ERROR, e)

                return

    

    def _process_node(self, node):

        if is_comment(node):

                self.process_function(node)

            else:

                self.process_function({node: []})

        else:

            raise YamlImportException("Can not process YAML block: %s" % node)