Exemple #1
0
def getLogItem(action, request, session):
    """
        Get Log item from DB by selected log item's ID.

        Arguments:
            action  - 302|303|304|307
            request - form (selected_item)
            session - current session

        Returns:
            exchange_error, exchange_message - exchange error info
            id      - parsed ID of selected_item
            data    - XML (Order.data)
    """
    form = request.form

    print_action(action, 'DBase.GetLogItem')

    exchange_message = ''
    exchange_error = 0
    order = None

    id = form.get('selected_item', None)

    if IsDebug:
        print '>>> Selected LogItem ID: [%s]' % id

    if id:
        order = Order.get_by_id(id)
    else:
        exchange_message = '%s: <id>' % gettext('Missing argument')
        exchange_error = -10

    return (exchange_error, exchange_message, id, order)
Exemple #2
0
def getStatictics(action, request, session):
    """
        Get Price items from DB by selected log item's ID.

        Arguments:
            action  - 305
            request - form (selected_item)
            session - current session

        Returns:
            exchange_error, exchange_message - exchange error info
            id      - parsed ID of selected_item
            data    - XML (Order.data)
    """
    form = request.form

    print_action(action, 'DBase.GetLogStatistics')

    exchange_message = ''
    exchange_error = 0
    response = None
    order = None

    id = form.get('selected_item', None)

    if IsDebug:
        print '>>> Selected LogItem ID: [%s]' % id

    if id:
        order = Order.get_by_id(id)
    else:
        exchange_message = '%s: <id>' % gettext('Missing argument')
        exchange_error = -10

    total, order_id, data, query = statistics(DEFAULT_LOG_MODE, order=order)

    items = []
    headers = get_statistics_headers()
    line_in_page = 0

    for row in data:
        x = dict(zip(headers[0], row))
        line_in_page += 1

        x['root'] = '%s' % request.script_root
        x['num'] = line_in_page
        x['cdate'] = cdate(x['reg_date'], fmt=LOCAL_EASY_TIMESTAMP)

        for n, column in enumerate(headers[1]):
            x['%s_title' % column['id']] = column['title']

        items.append([x['id'], [ column.has_key('value') and (column['value'] % x) or x[column['id']]
            for n, column in enumerate(headers[1])
                if column.get('visible') ]
        ])

    return (exchange_error, exchange_message, id, total, items)
Exemple #3
0
def getLogTotal(attrs, force=None):
    """
        Get Log rows count filtered by optional user, module, order type.

        Arguments:
            attrs   - attributes (userID, wizardID, otype)

        Filter by (attrs):
            userID  - user ID
            wizardID- wizard ID
            otype   - order type (Config.valid_order_types)

        Returns:
            total   - page items count
    """
    print_db_state()

    userID = attrs.get('userID', None)
    user = userID and User.query.filter_by(userID=userID).first()

    if IsDebug and userID:
        print '>>> User[%s]: %s' % (userID, user and user.userID == userID and 'OK' or 'invalid!')

    wizardID = attrs.get('wizardID', None)
    module = wizardID and Module.query.filter_by(wizardID=wizardID).first()

    if IsDebug and wizardID:
        print '>>> Module[%s]: %s' % (wizardID, module and module.wizardID == wizardID and 'OK' or 'invalid!')

    otype = int(attrs.get('otype', 0))

    if IsDebug and otype in valid_order_types:
        print '>>> Order type[%s]: %s' % (otype, valid_order_names[otype])

    query = Order.query

    if user:
        query = query.filter_by(user=user)
    if module:
        query = query.filter_by(module=module)
    if otype:
        query = query.filter_by(otype=otype)

    if user and module or force:
        total = query.count()
    else:
        total = 0

    print_action(total, 'DBase.getLogTotal')

    return total
Exemple #4
0
def receive(action, request, session, **kw):
    """
        Receive XML from **kw (DB) or requested WEB-form, parse DOM and XML-Items and return its to the caller.
        From **kw(data) or requested WEB-form XML is ready.

        Arguments:
            action  - 203|204|205|206 for Internal, 303 for Log
            request - form.data (XML, Internal)
            session - current session
            kw      - data (XML, DB).

        Returns:
            dom     - DOM object
            data    - Data Dictionary (XML-Items).
    """
    error = None
    dom = None

    print_action(action, 'Exchange.Receive')

    form = request.form

    _print_form(form)

    data = kw.get('data') or form.get('data') or ''

    # unicode -> utf8
    if isinstance(data, unicode):
        data = data.encode(default_unicode, 'ignore')

    data = data.strip()

    if data and data.startswith(CDATA):
        data = data[9:-3]

    try:
        dom = parseString(data)
    except Exception, error:
        msg = '--> Invalid XML content!'
        # ---------------
        # Unvalid XML DOM
        # ---------------
        print_to(errorlog, [msg, data], request=request)
        #traceback.print_exc(file=open(errorlog, 'a'))
        raise
Exemple #5
0
def removeLogItem(action, request, session):
    """
        Remove Log item from DB by selected log item's ID.

        Arguments:
            action  - 308
            request - form (selected_item)
            session - current session

        Returns:
            exchange_error, exchange_message - exchange error info
    """
    form = request.form

    print_action(action, 'DBase.RemoveLogItem')

    exchange_message = ''
    exchange_error = 0

    IsDone = False

    id = form.get('selected_item', None)

    if id:
        order =get_order(id)
        if order and order.otype not in (ORDER_STANDARD, ORDER_DONE):
            _delete(order)
            _commit(True)

            IsDone = True
    else:
        exchange_message = 'Error %s: <%s>' % (gettext('Missing argument'), id)
        exchange_error = -10

    if IsDebug:
        if IsDone and not exchange_error:
            print '>>> Removed LogItem ID: [%s]' % id
        elif exchange_error:
            print '>>> [%s] %s' % (exchange_error, exchange_message)
        else:
            print '>>> [%s] %s' % (id, gettext('Cannot be removed'))

    return getLogPage(action, request, session)
Exemple #6
0
def send(action, request, session, **kw):
    """
        Get XML from **kw or build it from the WEB-form, and send request to the External WEB-Service.
        WEB-form parameters are Helper tags: products, parameters and other.
        From **kw(data) XML is ready.

        Arguments:
            action  - 203|204|205|206 for External
            request - form (Helper tags)
            session - current session
            kw      - data (XML).

        Returns:
            exchange_error, exchange_message - exchange error info
            dom     - DOM object
            data    - XML (response of WEB-Service).
    """
    global BASE_URL, BASE_PATH, REFERENCE_PATH, HELPER_URL
    BASE_URL, BASE_PATH, REFERENCE_PATH, HELPER_URL = getReference()

    exchange_error = 0
    exchange_message = ''
    response = None
    error = None
    data = None
    dom = None

    print_action(action, 'Exchange.Send')

    form = request.form

    _print_form(form)

    if kw and 'data' in kw and kw.get('data'):
        data = kw['data']
        check = 1
    else:
        check, data = setRequestXML(action == '205' and '204' or action, request, session, **kw)

    _print_item(check, 'ready')

    if not check:
        # ----------------------------------
        # Request is not ready, data missing
        # ----------------------------------
        pass

    else:
        _print_xml(data, 'XML Request')

        url = HELPER_URL

        _print_item(url, 'URL')

        # unicode -> utf8
        if isinstance(data, unicode):
            data = data.encode(default_unicode, 'ignore')

        query = data.strip()

        # -----------------------
        # Send request to Service
        # -----------------------
        request = urllib2.Request( \
            url=url, 
            data=urlencode({'queryDocument':query}), 
            headers={'Content-Type': 'application/x-www-form-urlencoded'}
        )

        data = None

        try:
            response = urllib2.urlopen(request)
            data = response.read()

        except Exception, error:
            exchange_message = '%s [%s]' % (gettext('No connection!'), url)
            # -----------------------
            # Server connection error
            # -----------------------
            exchange_error = -1

        if exchange_error and demo():
            # --------------------------------------------------
            # Only for demo purposes, web-service is unavailable
            # --------------------------------------------------
            return (0, exchange_message, parseString(query), query,)

        elif data and XML_PREFIX in data:
            # --------------
            # Response is OK
            # --------------
            data = data.replace(data[0:data.find(XML_PREFIX)], '').strip()

        elif not exchange_error:
            # --------------------------------------------
            # No XML Response (error from the application)
            # --------------------------------------------
            exchange_error = -2

        _print_xml(data, 'XML Response')

        try:
            # ---------
            # Parse DOM
            # ---------
            if not exchange_error and data:
                dom = parseString(data)

        except Exception, error:
            exchange_message = gettext('Not valid response!'),
            # ---------------
            # Unvalid XML DOM
            # ---------------
            exchange_error = -3
Exemple #7
0
def setRequestXML(action, request, session):
    """
        Generate XML from the WEB-form.
        Get XML-Items and DOM from **kw (WEB-form), generate XML and return it to the caller.

        Arguments:
            action  - 203|204|207 for Internal/External
            request - form.data (product/parameters/options)
            session - current session.

        Returns:
            data    - XML (String).
    """
    form = request.form

    print_action(action, 'Exchange.setRequestXML')

    level0 = ' '*6
    level1 = ' '*8
    level2 = ' '*10

    helperXMLVersion = form.get('helperXMLVersion', None) or '1'

    if helperXMLVersion == '2':
        # -------------
        # XML VERSION 2
        # -------------
        products = []

        for key in 'abcde':
            option = form.get('options[%s]' % key, None)
            if not option:
                break
            if IsDebug:
                print '--> option[%s]:%s' % (key, option)

            is_default = key == 'a' and True or False
            product = {
                'option'  : option,
                'default' : is_default and ' default="1"' or '',
                'content' : ''
            }

            check, parameters, options = setRequestContent(form, level2, (PARAMETER_XML_TEMPLATE, OPTION_XML_TEMPLATE,), key, is_default)
            
            #product['parameters'] = parameters.strip() and level1 + (PARAMETERS_XML_V2_TEMPLATE % parameters).strip() or ''
            #product['options'] = options.strip() and level1 + (OPTIONS_XML_V2_TEMPLATE % options).strip() or ''

            product['content'] = \
                (options.strip() and EOL+level1+(OPTIONS_XML_V2_TEMPLATE % options).strip() or '') + \
                (parameters.strip() and EOL+level1+(PARAMETERS_XML_V2_TEMPLATE % parameters).strip() or '')

            if product['content']:
                product['content'] += EOL+level0

            products.append(level0 + (PRODUCT_XML_V2_TEMPLATE % product).strip())

        content = CONTENT_XML_V2_TEMPLATE % EOL.join(products)

    else:
        # -----------------------
        # XML VERSION 1 (DEFAULT)
        # -----------------------
        check, parameters, products = setRequestContent(form, level1, (PARAMETER_XML_TEMPLATE, PRODUCT_XML_TEMPLATE,))

        if form.get('defaultConstruct', None) and form.get('defaultConstructCount', None):
            products = CONSTRUCT_XML_TEMPLATE % {'indent':level1, 'code':form['defaultConstruct'], 'value':form['defaultConstructCount'], 'n_a':n_a} + \
                EOL + products

        content = CONTENT_XML_V1_TEMPLATE % {
            'products'   : (PRODUCTS_XML_V1_TEMPLATE % products).strip(),
            'parameters' : (PARAMETERS_XML_V1_TEMPLATE % parameters).strip(),
        }

    attrs = _create_request_attrs(action, request, session, content=content, version=helperXMLVersion)

    return check, (REQUEST_XML_TEMPLATE % attrs).strip()
Exemple #8
0
def getRequestXML(action, request, session, data=None, dom=None, title=None, page=None, url=None):
    """
        Generate XML from DB.
        Get XML-Items and DOM from **kw (DB), generate XML and return it to the caller.

        Arguments:
            action  - 303|304|307 for Log
            request - form.data
            session - current session
            kw      - Data (Data Dictionary made by receive) and DOM-object.

        Returns:
            data    - XML (String).
    """
    if not data or not dom:
        return ''

    print_action(action, 'Exchange.getRequestXML')

    form = request.form

    level0 = ' '*6
    level1 = ' '*8
    level2 = ' '*10

    helperXMLVersion = form.get('helperXMLVersion', None) or '1'

    # unicode -> utf8
    if title and not isinstance(title, unicode):
        title = title.decode(default_unicode, 'ignore')

    content = ''

    if helperXMLVersion == '1':
        # -------------
        # XML VERSION 1
        # -------------

        products = ''
        for x in data['products']:
            x['indent'] = level1
            x['code'] = x['id']
            x['price'] = n_a
            if x['unit'] == n_a:
                x['unit'] = ''
            products += (products and EOL or '')+(PRODUCT_XML_TEMPLATE % x)

        parameters = ''
        for x in data['parameters']:
            x['indent'] = level1
            x['cis'] = x['id']
            if x['parent']:
                x['parent'] = ' parent="%s"' % x['parent']
            x['price'] = n_a
            if x['unit'] == n_a:
                x['unit'] = ''
            parameters += (parameters and EOL or '')+(PARAMETER_XML_TEMPLATE % x)

        content = CONTENT_XML_V1_TEMPLATE % {
            'products'   : (PRODUCTS_XML_V1_TEMPLATE % products).strip(),
            'parameters' : (PARAMETERS_XML_V1_TEMPLATE % parameters).strip(),
        }
        
        check = (products or parameters) and 1 or 0

    else:
        # -----------------------
        # XML VERSION 2 and other
        # -----------------------

        content = \
            re.sub(r'\n\s+<parameter\s+id="\w{8,}?-\w{4,}?-\w{4,}?-\w{4,}?-\w{12,}?".*?\/(parameter)?>', r'',
            re.sub(r'\s+(article|title)=".*?"', '', 
            re.sub(r'price=".*?"', 'price="%s"' % n_a, 
            getDOMTagValue(dom, 'products'))))

        check = 1

    _print_xml(content, 'XML Content')

    attrs = _create_request_attrs(action, request, session, content=content, version=helperXMLVersion, 
        title=title, page=page, url=url) #, url=HELPER_URL

    return check, (REQUEST_XML_TEMPLATE % attrs).strip() # data
Exemple #9
0
def respond_log(action):
    exchange_error = 0
    exchange_message = ''

    page = None

    current_page, pages, per_page, has_prev, has_next, total, id = (0, 0, 0, False, False, 0, None)
    iter_pages = []
    order = None
    data = None
    dom = None
    items = None
    title = ''

    print_action(action, 'Respond.Log')

    locale = request.form.get('currentUsedLocalization') or ''

    try:
        # ----------------
        # Get Data from DB
        # ----------------
        if not action:
            pass
        elif action == '301':
            exchange_error, exchange_message, page, data = getLogPage(action, request, session)
        elif action == '305':
            exchange_error, exchange_message, id, total, data = getStatictics(action, request, session)
        elif action == '308':
            exchange_error, exchange_message, page, data = removeLogItem(action, request, session)
        else: #if action in ('302','303','304','307',):
            exchange_error, exchange_message, id, order = getLogItem(action, request, session)
    except:
        msg = '--> Database error!'
        # -------------
        # DB Log failed
        # --------------
        print_to(errorlog, msg, request=request)
        raise

    if not (action and action in valid_action_types):
        pass

    elif action in ('301','308',):
        # --------------------
        # Get Log-page content
        # --------------------
        if page:
            current_page, pages, per_page, has_prev, has_next, total = page.get_page_params()
            iter_pages = page.iter_pages()

        if IsDebug:
            print '--> LogPage[%s]: items:[%s] %s-%s-%s-%s iter:%s' % ( \
                current_page, len(data), pages, per_page, has_prev, has_next, iter_pages)
    
    elif action in ('302',):
        # ------------------------------
        # DOM and XML-Items (Dictionary)
        # ------------------------------
        dom, data = receive(action, request, session, data=order.data) #, products_sorted=True

        if IsDebug:
            print '--> LogPageItem[%s]: Data %s, Products %s, Parameters %s' % ( \
                id, len(order.data), len(data['products']), len(data['parameters']))
    
    elif action in ('303','304','307',):
        # ---------
        # Clean XML
        # ---------
        data = order.data #_data(coding='encode')

        # ------------------------------
        # DOM and XML-Items (Dictionary)
        # ------------------------------
        dom, items = receive(action, request, session, data=data)

        title = order.title

        if IsDebug:
            print '--> Loaded LogPageItem[%s]: Data %s, Products %s, Parameters %s' % ( \
                id, len(order.data), len(items['products']), len(items['parameters']))

    elif action in ('305',):

        if IsDebug:
            print '--> LogStatictics[%s]: Data %s' % ( \
                id, data and len(data), )

    if exchange_error:
        if IsDebug:
            print '--> ExchangeError[%s]: %s' % (exchange_error, exchange_message)

    return { \
        'action'            : action,
        'op'                : '',
        # --------------
        # Service Errors
        # --------------
        'exchange_error'    : exchange_error, 
        'exchange_message'  : exchange_message,
        # -----------------------------
        # Results (Log page parameters)
        # -----------------------------
        'id'                : id,
        'rows_on_page'      : len(data),
        'total'             : total,
        'page'              : current_page,
        'pages'             : pages,
        'per_page'          : per_page,
        'has_prev'          : has_prev, 
        'has_next'          : has_next,
        'iter_pages'        : iter_pages,
        # --------------------------
        # Results (Log page content)
        # --------------------------
        'custom_code'       : order and order.code or '',
        'title'             : title,
        'price'             : '',
        'data'              : data,
        'dom'               : dom,
        'items'             : items,
    }
Exemple #10
0
def respond_external(action, **kw):
    exchange_error = 0
    exchange_message = ''
    error_code = ''
    error_description = ''
    errors = ''
    response = {}
    dom = None
    data = ''
    total = ''
    price = ''
    currency = ''
    document = ''
    order_number = ''
    order_date = ''

    print_action(action, 'Respond.External')

    locale = request.form.get('currentUsedLocalization') or ''
    wizard = request.form.get('wizardID') or ''

    try:
        # -------------------------------------
        # Get DOM and XML response from Service
        # -------------------------------------
        exchange_error, exchange_message, dom, data = send(action, request, session, **kw)

        if demo():
            exchange_error, exchange_message, total, currency = _demo_price(action)
            order_number, order_date = _demo_order(action)
        elif exchange_error:
            total = 0.0
        elif dom is not None:
            total = float(getDOMItemValue(dom, 'total') or '0')
            currency = CURRENCIES.get(getDOMItemValue(dom, 'currency'), gettext('undefined'))
            error_code = getDOMItemValue(dom, 'errorCode').strip()
            error_description = getDOMItemValue(dom, 'errorDescription')

            if action == '207':
                order = _order(dom)
                order_number = order.get('number', '')
                order_date = order.get('date', '')
        elif data:
            x = request.form.get('price')
            total = x and float(x.split()[0])*1.288726 or 0
    except:
        msg = '--> Send error!'
        print_to(errorlog, [msg, data], request=request)
        # ----------------------
        # Service Exchange Error
        # ----------------------
        if IsDeepDebug:
            print msg
        raise

    #print_to(errorlog, ['>>> Data:', data])

    IsValid = data and True or False

    if exchange_message and exchange_message == exchange_error:
        exchange_message = ''
    if error_description and error_description == error_code:
        error_description = ''

    # -----------------
    # Response is valid
    # -----------------

    if IsValid:
        errors = getDOMErrors(dom) or ''

        if IsDeepDebug:
            print errors

        if currency in ('undefined', n_a, '') or not total:
            if not exchange_message:
                if action == '203' and error_code in ('', '0',):
                    pass
                else:
                    exchange_message = gettext('Calculation is not performed.')
            IsValid = False

        total = IsValid and '%.2f' % total or ''
        price = IsValid and '%s %s' % (total, currency) or ''

        if IsDebug:
            print '--> Total: %s' % price

        document = order_number and ('# %s %s %s' % (order_number, gettext('at'), order_date)) or ''

    # -------------------------------------------
    # Make parameters and Register response in DB
    # -------------------------------------------

    attrs = { \
        'locale'            : locale,
        'selected_item'     : kw.get('id') or request.form.get('selected_item'),
        'title'             : request.form.get('title') or '',
        'document'          : document or action,
        'total'             : total,
        'currency'          : currency,
        'countryID'         : getCountryID(getDOMItemValue(dom, 'countryID'), locale),
        'regionID'          : getRegionID(getDOMItemValue(dom, 'regionID'), locale),
        'userID'            : getUserID(getDOMItemValue(dom, 'userID'), locale),
        'userName'          : getClient(getDOMItemValue(dom, 'userName'), locale),
        'wizardID'          : wizard,
        'wizardName'        : request.form.get('wizardName') or '',
        'custom_code'       : request.form.get('custom_code') or '',
        'option_update'     : request.form.get('option_update') or '',
        'option_cost'       : request.form.get('option_cost') or '',
        'data'              : data, #getDOMTagStrippedValue(dom, 'parameters'),
    }

    #print_to(errorlog, ['>>> Total:', total])

    if IsValid and action in ('203','204','205','207',): # and dom
        response = register(action, dom, attrs)

        if IsDeepDebug:
            print '>>> DB Response:%s' % response

    order = action == '205' and response.get('custom_code') or document

    return { \
        'action'            : action,
        'op'                : '',
        # --------------
        # Service Errors
        # --------------
        'exchange_error'    : exchange_error, 
        'exchange_message'  : exchange_message,
        'error_code'        : error_code,
        'error_description' : error_description,
        'errors'            : errors,
        # ---
        # IDs
        # ---
        'countryID'         : getDOMItemValue(dom, 'countryID') or '',
        'regionID'          : getDOMItemValue(dom, 'regionID') or '',
        'userID'            : attrs['userID'],
        # --------------
        # Client Details
        # --------------
        'country_name'      : getDOMItemValue(dom, 'countryName') or getCountry(getDOMItemValue(dom, 'countryID'), locale),
        'region_name'       : getDOMItemValue(dom, 'regionName') or getRegion(getDOMItemValue(dom, 'regionID'), locale),
        'client_name'       : attrs['userName'],
        # ----------
        # Order Info
        # ----------
        'document_number'   : order_number,
        'document_date'     : order_date,
        'order'             : order,
        # -------
        # DB Data
        # -------
        'total_log_rows'    : getLogTotal({'userID' : attrs['userID'], 'wizardID' : wizard}),
        'custom_code'       : response.get('custom_code', ''),
        'next_custom_code'  : response.get('next_custom_code', ''),
        'option_update'     : response.get('option_update', ''),
        'option_cost'       : response.get('option_cost', ''),
        'title'             : response.get('title', ''),
        # ------------------------------
        # Results (Price & XML-Response)
        # ------------------------------
        'price'             : price,
        'data'              : data,
    }
Exemple #11
0
def respond_internal(action, **kw):
    exchange_error = 0
    exchange_message = ''
    error_code = ''
    error_description = ''
    response = {}
    dom = None
    data = ''
    currency = ''
    order_number = ''
    order_date = ''

    print_action(action, 'Respond.Internal')

    op = request.form.get('op') or kw.get('op')

    if IsDebug:
        print '--> op: [%s]' % op

    if not op:
        pass

    elif op == 'get':
        # --------------------------------------------------------------
        # Generate and Send XML to Service (from WEB-form to JavaScript)
        # --------------------------------------------------------------
        data = getXml(action, request, session)
        errors = []

    elif op == 'set':
        # -----------------------------------------------
        # Receive XML from Service (loaded by JavaScript)
        # -----------------------------------------------
        dom, data = receive(action, request, session, **kw)

        if demo():
            exchange_error, exchange_message, total, currency = _demo_price(action)
            order_number, order_date = _demo_order(action)
        else:
            total = float(getDOMItemValue(dom, 'total'))
            currency = CURRENCIES.get(getDOMItemValue(dom, 'currency'), gettext('undefined'))
            error_code = getDOMItemValue(dom, 'errorCode').strip()
            error_description = getDOMItemValue(dom, 'errorDescription')

        errors = getDOMErrors(dom) or ''

        if IsDebug:
            print '--> Total: %s %s' % (total, currency)

        total = '%.2f' % total or ''
        price = '%s %s' % (total, currency) or ''

    return { \
        'action'            : action,
        'op'                : op,
        # --------------
        # Service Errors
        # --------------
        'exchange_error'    : exchange_error, 
        'exchange_message'  : exchange_message,
        'error_code'        : error_code,
        'error_description' : error_description,
        'errors'            : errors,
        # ---
        # IDs
        # ---
        'countryID'         : getDOMItemValue(dom, 'countryID') or '',
        'regionID'          : getDOMItemValue(dom, 'regionID') or '',
        'userID'            : getUserID(getDOMItemValue(dom, 'userID')),
        # --------------
        # Client Details
        # --------------
        'country_name'      : getDOMItemValue(dom, 'countryName') or getCountry(getDOMItemValue(dom, 'countryID')),
        'region_name'       : getDOMItemValue(dom, 'regionName') or getRegion(getDOMItemValue(dom, 'regionID')),
        'client_name'       : getClient(getDOMItemValue(dom, 'userName')),
        # ------------------------------
        # Results (Price & XML-Response)
        # ------------------------------
        'price'             : price,
        'data'              : data,
    }
Exemple #12
0
def register(action, dom, attrs):
    """
        Register XML-response in DB. Get items form DOM and clear XML. 
        Valid actions: 203|204|205|207.

        Arguments:
            dom     - DOM object
            attrs   - Dictionary (requested items: action, data (XML), selected_item, custom_code and another...)

        Returns:
            data    - Dictionary (next_custom_code)
    """
    print_db_state()

    IsError = False

    print_action(action, 'DBase.Register')

    # ----
    # User
    # ----
    userID = get_item(dom, attrs, 'userID')
    user = userID and User.query.filter_by(userID=userID).first()
    if not user:
        user = User(userID, title=get_item(dom, attrs, 'userName'), email=getDOMItemValue(dom, 'orderEmail'))
        _add(user)

    # ------
    # Module
    # ------
    wizardID = get_item(dom, attrs, 'wizardID')
    module = wizardID and Module.query.filter_by(wizardID=wizardID).first()
    if not module:
        module = Module(wizardID, title=re.sub(r'\s+', ' ', re.sub(r'<.*?>', '', get_item(dom, attrs, 'wizardName'))))
        m = re.search(r'.*(DUS-[\d-]*)', module.wizardName)
        if m:
            module.DUS = m.group(1)
        _add(module)

    # ------------------
    # Parameters & Items
    # ------------------
    for n, x in enumerate(getDOMParameters(dom, False)):
        parameter = Parameter.query.filter_by(CIS=x['id']).first()
        if not parameter:
            parameter = Parameter(x['id'], valid_parameter_names.get(x['type'].upper()), unit=x['unit'])
            _add(parameter)

        item = Item.query.filter_by(parameter=parameter, module=module).first()
        if not item:
            item = Item(parameter, module)
            _add(item)

    # ---------------------
    # Order & Prices & Data
    # ---------------------
    if action not in valid_action_types:
        IsError = True
        otype = -1

    id = get_item(dom, attrs, 'selected_item')
    code = get_item(dom, attrs, 'custom_code')

    IsAddOrder = False
    IsUpdateOrder = False
    custom_code = ''
    order = None

    if IsError:
        pass

    # ----------------------------------------------
    # Get Order item from DB and update or add a new
    # ----------------------------------------------
    elif action == '203':
        if not id:
            otype = ORDER_STANDARD
            order = Order.query.filter_by(user=user, module=module, otype=otype).first()
        else:
            order = get_order(id, None)
            custom_code = order and order.code
            otype = -1
    elif action == '204':
        otype = ORDER_CUSTOM
        order = get_order(id, code, user=user, module=module)
    elif action == '205':
        otype = ORDER_CUSTOM
        #order = get_order(None, code, user=user, module=module)
    elif action == '207':
        otype = ORDER_DONE
    else:
        otype = -1

    if IsDebug:
        print '>>> Order: %s %s %s' % (order, str(code), str(id))

    if otype in valid_order_types:
        price_columns = get_columns(dom, attrs, model_price_columns)

        if not attrs.get('title'):
            attrs['title'] = gettext(valid_order_names[otype])

        if not order:
            order = Order(user, module, otype, get_columns(dom, attrs, model_order_columns))

            #if otype == ORDER_DONE:
            #    order.code = Order.generate_custom_code(user, module, otype=ORDER_DONE)
            #elif otype == ORDER_CUSTOM:
            #    order.code = get_item(dom, attrs, 'custom_code') or \
            #        Order.generate_custom_code(user, module, otype=otype)

            IsAddOrder = True
        else:
            if action in ('203','207'):
                pass
            elif action == '204':
                if order.option_update:
                    order.data = order._data(get_item(dom, attrs, 'data'))
                    IsUpdateOrder = True
            elif action == '205':
                order.set_attrs(get_columns(dom, attrs, model_order_columns))
                IsUpdateOrder = True

        current_price = Order.generate_current_price(int(float(price_columns['total']) * 100), \
            price_columns['currency'])

        if IsAddOrder:
            last_price = ''
            order.current_price = current_price
        else:
            last_price = order.current_price
            if order.otype in (ORDER_STANDARD, ORDER_CUSTOM,):
                order.current_price = current_price
                order.rating = order.current_price < last_price and RATING_DOWN or \
                               order.current_price > last_price and RATING_UP or \
                               RATING_EQUAL
            else:
                order.rating = current_price > last_price and RATING_DOWN or \
                               current_price < last_price and RATING_UP or \
                               RATING_EQUAL

        if IsDebug:
            print '>>> Current price: %s %s %s' % (last_price, order.current_price, order.rating)

        if order and IsAddOrder:
            _add(order)

        if order and (IsAddOrder or (order.option_cost and last_price != current_price)):
            _add(Price(order, price_columns))

    # ----------
    # Save to DB
    # ----------
    _commit(IsUpdateOrder and True or False)

    # ---------------------
    # Get data for response
    # ---------------------
    data = {}
    next_custom_code = Order.generate_custom_code(user, module)

    if action in ('203','204','205',):
        if order:
            data['title'] = order.title
            data['custom_code'] = order.code or custom_code
            data['next_custom_code'] = order.option_update and order.code or next_custom_code
            data['option_update'] = order.option_update
            data['option_cost'] = order.option_cost
        else:
            data['next_custom_code'] = next_custom_code
            data['custom_code'] = custom_code

    return data
Exemple #13
0
def getLogPage(action, request, session):
    """
        Get Log page from DB by selected number filtered by requested userID and wizardID.

        Arguments:
            action  - 301
            request - form (page, per_page, userID, wizardID)
            session - current session

        Filter by (attrs):
            userID  - user ID
            wizardID- wizard ID
            otype   - order type (Config.valid_order_types)
            context - search context

        Returns:
            exchange_error, exchange_message - exchange error info
            data    - Pagination object from DB models
            items   - page column items
    """
    print_db_state()

    form = request.form

    print_action(action, 'DBase.GetLogPage')

    exchange_message = ''
    exchange_error = 0
    data = None

    page = int(form.get('page', 0)) or 1
    per_page = int(form.get('per_page', 0)) or DEFAULT_PER_PAGE

    sort = form.get('sort') or ''

    userID = form.get('userID', None)
    user = userID and User.query.filter_by(userID=userID).first()

    if IsDebug and userID:
        print '>>> User[%s]: %s' % (userID, user and user.userID == userID and 'OK' or 'invalid!')

    wizardID = form.get('wizardID', None)
    module = wizardID and Module.query.filter_by(wizardID=wizardID).first()

    if IsDebug and wizardID:
        print '>>> Module[%s]: %s' % (wizardID, module and module.wizardID == wizardID and 'OK' or 'invalid!')

    otype = int(form.get('otype', -1))

    if IsDebug and otype in valid_order_types:
        print '>>> Order type[%s]: %s' % (otype, valid_order_names[otype])

    context = form.get('search_context', None)

    if IsDebug and context:
        print '>>> Search context: [%s]' % context

    data = log(DEFAULT_LOG_MODE, page, per_page, user=user, module=module, otype=otype, context=context, check=IsDBCheck, sort=sort)

    items = []
    headers = get_log_headers()
    line_in_page = 0 #(page-1) * per_page

    for row in data.items:
        x = dict(zip(headers[0], row))
        line_in_page += 1

        s = x['document'] or ''
        if s and s.startswith('#'):
            x['document'] = s[1:].strip()

        x['root'] = '%s' % request.script_root
        x['image'] = '%s-16.png' % ( \
            x['rating'] == RATING_UP and 'up' or x['rating'] == RATING_DOWN and 'down' or 
            x['rating'] == RATING_EQUAL and 'equal' or 'undef')
        x['num'] = line_in_page
        x['cdate'] = cdate(x['reg_date'], fmt=LOCAL_EASY_TIMESTAMP)
        x['price'], x['currency'] = x['current_price'].split()
        x['code'] = x['otype'] == ORDER_DONE and x['document'] or x['code']
        x['updatable'] = x['option_update'] and 'updatable' or x['option_cost'] and 'cost' or 'fixed'

        for n, column in enumerate(headers[1]):
            x['%s_title' % column['id']] = column['title']

        items.append([x['id'], [ column.has_key('value') and (column['value'] % x) or x[column['id']]
            for n, column in enumerate(headers[1])
                if column.get('visible') ]
        ])

    return (exchange_error, exchange_message, data, items)