Produits Entr'ouvert » OLAP / Business Intelligence pour Publik

                     items=['foo', 'bar', 'baz'], varname='item'),

    fields.BoolField(id='3', label='3rd field', type='bool', varname='bool'),

    fields.ItemField(id='4', label='4rth field', type='item', varname='itemOpen'),

]

formdef.store()

    formdata = formdef.data_class()()

    formdata.just_created()

    formdata.receipt_time = datetime.datetime(2018, random.randrange(1, 13), random.randrange(1, 29)).timetuple()

    if i%4 == 0:

        formdata.data['2'] = 'foo'

        formdata.data['2_display'] = 'foo'

            {

               "filter": true,

               "label": "5th field",

               "type": "string",

            }

         ],

         "fact_table" : "\"formdata_demande\"",

import json

import pytest

        ('formdata_demande', 'field_item'),

        ('formdata_demande', 'field_bool'),

        ('formdata_demande', 'field_itemOpen'),

        ('formdata_demande', 'function__receiver'),

        ('formdata_demande_field_item', 'id'),

        ('formdata_demande_field_item', 'label'),

# -*- coding: utf-8 -*-

import datetime

import six

import copy

from cached_property import cached_property

from wcs_olap.wcs_api import WcsApiError

def quote(name):

    return '"%s"' % name

class WcsOlapFeeder(object):

    channels = [

    ]

    channel_to_id = dict((c[1], c[0]) for c in channels)

    id_to_channel = dict((c[0], c[1]) for c in channels)

        }

        cube = {

            'name': 'all_formdata',

            'fact_table': 'formdata',

            'key': 'id',

            'joins': [

        self.connection = psycopg2.connect(dsn=pg_dsn)

        self.connection.autocommit = True

        self.cur = self.connection.cursor()

        try:

            self.has_jsonb = self.detect_jsonb()

        if len(table_name) < 64 and not force_hash:

            return table_name

        else:

    @property

    def default_ctx(self):

    def do_base_table(self):

        # channels

        self.create_labeled_table('channel', [[c[0], c[2]] for c in self.channels],

        # roles

        roles = dict((i, role.name) for i, role in enumerate(self.roles))

        self.role_mapping = dict(

            (role.id, tmp_role_map[role.name]) for role in self.roles)

        # categories

        tmp_cat_map = self.create_labeled_table(

        self.categories_mapping = dict((c.id, tmp_cat_map[c.name]) for c in self.categories)

        self.create_labeled_table('hour', zip(range(0, 24), map(str, range(0, 24))),

        self.create_labeled_table('status', self.status,

        self.ex('CREATE TABLE {form_table} (id serial PRIMARY KEY,'

                ' category_id integer REFERENCES {category_table} (id),'

                ' label varchar)')

        # agents

        self.columns = [

            ['id', 'serial primary key'],

        if self.has_jsonb:

            self.columns.append(['json_data', 'JSONB NULL'])

        self.comments = {

        }

        self.create_table('{generic_formdata_table}', self.columns)

        for at, comment in self.comments.iteritems():

            self.ex('COMMENT ON COLUMN {generic_formdata_table}.%s IS %%s' % at, vars=(comment,))

        # evolutions

        self.create_table('{generic_evolution_table}', [

            ['id', 'serial primary key'],

            ['date', 'date'],

            ['hour_id', 'smallint REFERENCES {hour_table} (id)'],

        ])

    def feed(self):

        try:

                    formdef_feeder = WcsFormdefFeeder(self, formdef, do_feed=self.do_feed)

                    formdef_feeder.feed()

                except WcsApiError as e:

            if 'cubes_model_dirs' in self.config:

                model_path = os.path.join(self.config['cubes_model_dirs'], '%s.model' % self.schema)

                with open(model_path, 'w') as f:

        statuses = self.formdef.schema.workflow.statuses

        tmp_status_map = self.olap_feeder.create_labeled_table(

            self.status_table_name, enumerate([s.name for s in statuses]),

        self.status_mapping = dict((s.id, tmp_status_map[s.name]) for s in statuses)

    def do_data_table(self):

                continue

            already_seen_varnames.add(field.varname)

            if field.type == 'item':

                           % (field.label, self.formdef.schema.name))

                table_name = self.hash_table_name('%s_field_%s' % (self.table_name, field.varname))

                # create table and mapping

        for function, name in self.formdef.schema.workflow.functions.iteritems():

            at = 'function_%s' % slugify(function)

            columns.append([at, 'smallint REFERENCES {role_table} (id)'])

        self.columns = ([name for name, _type in self.olap_feeder.columns] + [

            name for name, _type in columns])

        self.columns.remove('geolocation_base')

        self.create_table(self.table_name, columns, inherits='{generic_formdata_table}',

        for at, comment in comments.iteritems():

            self.ex('COMMENT ON COLUMN {formdata_table}.%s IS %%s' % quote(at), vars=(comment,))

            ['hour_id', 'smallint REFERENCES {hour_table} (id)'],

        ])

        self.ex('COMMENT ON TABLE {evolution_table} IS %s',

    def insert_item_value(self, field, value):

        table_name = self.hash_table_name('%s_field_%s' % (self.table_name, field.varname))

                at = 'function_%s' % slugify(function)

                row[at] = v

            # inert evolutions

            generic_evolution = []

            evolution = []

        if not values:

            self.logger.warning('no data')

            return

        self.ex('INSERT INTO {formdata_table} ({columns}) VALUES {values} RETURNING id',

        # insert generic evolutions

        generic_evolutions = []

            })

            cube['dimensions'].append({

                'name': at,

                'join': [at],

                'type': 'integer',

                'value': '%s.id' % quote(at),