Esempio n. 1
0
    def _get_log_item(line):
        if not line:
            return None
        values = line.split(split_by)
        if len(values) != len(columns):
            return None
        ob = {'filename': filename}

        try:
            for n, column in enumerate(columns):
                ob[column] = values[n].strip()
        except:
            if IsDebug and IsPrintExceptions:
                print_exception()

        try:
            x = datetime.datetime.strptime('%s' % ob['Date'], fmt[1])
            ob['Date'] = cdate(x, date_format)
        except:
            if IsDebug and IsPrintExceptions:
                print_exception()

        if 'Code' in ob:
            ob['Code'] = re.sub(r'[\[\]]', '', ob['Code'].upper())
        return ob
Esempio n. 2
0
def index():
    debug, kw = init_response('WebPerso Order State Page')
    kw['product_version'] = product_version

    command = get_request_item('command')

    if IsDebug:
        print('--> command:%s, order_id:%s, event_id:%s' % (
            command,
            kw.get('order_id'),
            kw.get('event_id')
        ))

    refresh()

    errors = []

    if command and command.startswith('admin'):
        pass

    kw['errors'] = '<br>'.join(errors)
    kw['OK'] = ''

    try:
        kw = _make_page_default(kw)

        if IsTrace:
            print_to(errorlog, '--> orderstate:%s %s %s' % (command, current_user.login, str(kw.get('current_file')),), request=request)
    except:
        print_exception()

    kw['vsc'] = (IsDebug or IsIE or IsForceRefresh) and ('?%s' % str(int(random.random()*10**12))) or ''

    if command and command.startswith('admin'):
        pass

    elif command == 'export':
        columns = kw['config']['orders']['export']
        rows = []
        for data in kw['orders']:
            row = []
            for column in columns:
                if column == 'FinalMessage':
                    continue
                v = data[column]
                if 'Date' in column:
                    v = re.sub(r'\s+', ' ', re.sub(r'<.*?>', ' ', v))
                row.append(v)

            rows.append(row)

        rows.insert(0, columns)

        xls = makeXLSContent(rows, 'Журнал заказов (OrderState)', True)

        response = make_response(xls)
        response.headers["Content-Disposition"] = "attachment; filename=orders.xls"
        return response

    return make_response(render_template('orderstate.html', debug=debug, **kw))
Esempio n. 3
0
    def run(self, sql, args=None, no_cursor=False):
        self.open()

        if self.engine is None or self.conn is None or self.conn.closed:
            return None

        rows = []

        with self.conn.begin() as trans:
            try:
                if args:
                    cursor = self.conn.execute(sql, args)
                else:
                    cursor = self.conn.execute(sql)
                if not no_cursor:
                    rows = [row for row in cursor if cursor]
                trans.commit()
            except:
                try:
                    trans.rollback()
                except:
                    pass

                print_to(None, 'NO SQL EXEC: %s' % sql)

                if IsPrintExceptions:
                    print_exception()

                self.engine_error = True
                rows = None

        self.close()

        return rows
Esempio n. 4
0
    def getItems(self, query=None, id=None, **kw):
        """
            Get reference items list with SQL-query.
            
            Arguments:
                query   -- Dict, query parameters: {'key':'value', ...}
                id      -- Int or String, selected item id

            Returns:
                rows    -- List, mappings list: [{'key':'value', ...}].
        """
        rows = []

        try:
            columns = self.columns
            where = self._set_where(query)
            order = self._set_order(kw.get('order'))
            encode_columns = self._set_encoding()

            rows = self.engine.runQuery(
                self.view,
                columns=columns,
                where=where,
                order=order,
                encode_columns=encode_columns,
                as_dict=True,
                config=self._config,
            )
            self._selected(rows, id)

        except:
            if IsPrintExceptions:
                print_exception()

        return rows
Esempio n. 5
0
def _make_export(kw):
    """
        Экспорт журнала заказов в Excel
    """
    view = kw['config'][default_template]
    columns = view['columns']
    headers = [view['headers'][x][0] for x in columns]
    rows = []

    for data in kw['orders']:
        row = []
        for column in columns:
            if column not in data:
                continue
            try:
                v = data[column]
                if 'Date' in column and v:
                    v = re.sub(r'\s+', ' ', re.sub(r'<.*?>', ' ', str(v))).strip()
                    v = getDate(v, UTC_FULL_TIMESTAMP, is_date=True)
                    v = getDate(v, LOCAL_EXCEL_TIMESTAMP)
                row.append(v)
            except:
                print_exception()

        rows.append(row)

    rows.insert(0, headers)
    return rows
Esempio n. 6
0
 def _decode(text, mode):
     errors = 'ignore'
     try:
         if not mode:
             pass
         elif mode == 'dostowin':
             text = text.encode(default_print_encoding).decode(
                 default_encoding)
         elif mode == 'wintodos':
             text = text.encode(default_encoding,
                                errors).decode(default_print_encoding)
         elif mode == 'wintowin':
             text = text.encode(default_encoding,
                                errors).decode(default_encoding)
         elif mode == 'dostodos':
             text = text.encode(default_print_encoding).decode(
                 default_print_encoding)
         elif mode == 'iso':
             try:
                 text = text.encode(default_print_encoding).decode(
                     default_encoding)
             except:
                 text = text.encode(default_unicode).decode(
                     default_unicode)
     except:
         if IsPrintExceptions:
             print_exception()
     return text
Esempio n. 7
0
    def getBodyState(self,
                     file_status=None,
                     limit=None,
                     is_extra=False,
                     no_cyrillic=False):
        """
            Get $ Make readable file body content
        """
        self.decodeBody(file_status=file_status)

        try:
            if self.image is not None:
                if not no_cyrillic:
                    self.decodeCyrillic(self.image)

                if not is_extra:
                    self.maskContent(self.image)

                self.makeIndents(self.image,
                                 limit=limit and MAX_XML_TREE_NODES or None)
                return self.upload(header=self.header(parser='ET.fromstring'))

        except:
            if IsPrintExceptions:
                print_exception()

        finally:
            self.flash()
Esempio n. 8
0
    def main(self, **kw):
        self._processed = 0
        self._found = {}

        self.stop_requested = False

        self.ReportServiceStatus(win32service.SERVICE_RUNNING)
        self._start_logger()

        if IsTrace and not IsDisableOutput:
            self._out('root: %s' % self._config.get('root'))

        date_from = None

        while True:
            self.restart_requested = False

            try:
                app = self.create_app()
                app._init_state(date_from=date_from, callback=self)

                self.run(app)
                self.start_observer(app)

                if app is not None:
                    app.should_be_stop()

                    is_dead = 0

                    while True:
                        is_finished = app.is_finished()
                        is_dead = app.is_dead(force=1)

                        self._out('... stopping: %s %s' %
                                  (is_finished, is_dead))
                        time.sleep(5)

                        if is_finished or is_dead:
                            break

                    if not is_dead:
                        app._term()

                del app

            except:
                self._out('main thread exception (look at traceback.log)',
                          is_error=True)
                print_exception(1)

            if not self.restart_requested or self.stop_requested:
                break

            self._out('==> Restart...')

            time.sleep(15)

        self._out('==> Finish')

        self._stop_logger()
Esempio n. 9
0
def getTabEventInfo(event_id):
    data = []
    number = str(event_id)

    try:
        if event_id:
            params = "%s, 1, ''" % (event_id)
            cursor = engine.runQuery('orderstate-eventinfo', as_dict=True, params=params)
            for n, row in enumerate(cursor):
                row['PName'] = row['PName'].encode(default_iso).decode(default_encoding)
                row['PValue'] = row['PValue'].encode(default_iso).decode(default_encoding)
                #row['RD'] = getDate(row['RD'], DEFAULT_DATETIME_INLINE_FORMAT)
                data.append(row)

            where = 'TID=%s' % event_id
            cursor = engine.runQuery('orderstate-events', columns=('Action',), where=where)

            if cursor is not None and len(cursor):
                number += ' %s' % str(cursor[0][0])
    except:
        print_exception()

    event = {'id':event_id, 'number':number}

    return number and data or [], event
Esempio n. 10
0
def loader_with_logger():
    #
    # Codes of action:
    #   100 - confirmation for an order
    #   203 - base calculation
    #   204 - custom calculation
    #   205 - save of state
    #   206 - finalize (internal)
    #   207 - order
    #   208 - close of session
    #   209 - cancel (Flash only)
    #   210 - continue (Flash only)
    #   301 - load log page
    #   302 - load selected log item content
    #   303 - load and refresh saved calculation
    #   304 - custom calculation (log+db)
    #   305 - price statistics
    #   307 - order (log+db)
    #   308 - remove log item
    #
    try:
        return loader()
    except:
        #traceback.print_exc(file=open(errorlog, 'a'))
        print_exception()
        raise
Esempio n. 11
0
    def getLinks(self, query, attrs, id, **kw):
        """
            Get linked reference items list with SQL-query.
            
            Arguments:
                query   -- Dict, query parameters: {'key':'value', ...}
                attrs   -- Dict, query attributes:
                
                'FileTypeID'          : Int, file type ID
                'FileTypeBatchTypeID' : Int, file type batch type ID
                'FBLinkID'            : Int, file type batch type ID
                ...
                'BatchTypeID'         : Int, filtered batch type ID
                'Tag'                 : Int or String, filtered tag ID/Name
                'TagValue'            : String, filtered tag value

                id      -- Int or String, selected item id

            Class attributes:
                filtered_columns -- List, list of columns used to filter data by the query

            Returns:
                rows    -- List, mappings list: [{'key':'value', ...}].
        """
        rows = []

        try:
            columns = self.columns
            filtered_columns = self.filtered_columns or columns
            where = self._set_where(query)

            s = ' AND '.join([
                '%s=%s' % (name, isinstance(value, int) and value or
                           ("'%s'" % value)) for name, value in attrs.items()
                if name in filtered_columns and value
            ])

            if s:
                where = where and '(%s) AND (%s)' % (where, s) or s

            order = self._set_order(kw.get('order'))
            encode_columns = self._set_encoding()

            rows = self.engine.runQuery(
                self.view,
                columns=columns,
                where=where,
                order=order,
                encode_columns=encode_columns,
                as_dict=True,
                config=self._config,
            )
            self._selected(rows, id)

        except:
            if IsPrintExceptions:
                print_exception()

        return rows
Esempio n. 12
0
def mdate(filename):
    try:
        t = os.path.getmtime(filename)
        return datetime.datetime.fromtimestamp(t)
    except:
        if IsPrintExceptions:
            print_exception()
        return None
Esempio n. 13
0
def log_with_logger():
    if not request.referrer:
        return redirect(url_for('_ext', _method='GET', **request.args)) # values , _external=True

    try:
        return log(0)
    except:
        print_exception()
        raise
Esempio n. 14
0
def getTabParams(order_id, batch_id, param_name=None, format=None, **kw):
    data = []
    number = 0
    props = {'id' : batch_id}

    try:
        if order_id and batch_id:
            keys = ('OperatorName', 'RD',)
            columns = ('Operator', 'OperatorName', 'OperatorFullName', 'RD',)
            encode_columns = ('OperatorName', 'OperatorFullName',)
            where = "OrderID=%s and BatchID=%s" % (order_id, batch_id)
            cursor = engine.runQuery(_views['actions'], columns=columns, where=where, as_dict=True, encode_columns=encode_columns)

            for n, row in enumerate(cursor):
                try:
                    data = [{'PName':key, 'PType':1, 'PValue':row[key]} for key in keys]
                except:
                    print_exception()

            # -------------------
            # Информация о партии
            # -------------------

            view = _views['batches']
            columns = database_config[view]['export']
            encode_columns = ('BatchType', 'BatchName',)
            where = 'TID=%s' % batch_id
            
            cursor = engine.runQuery(view, columns=columns, top=1, where=where, as_dict=True, encode_columns=encode_columns)

            if cursor is not None and len(cursor):
                row = cursor[0]
                if row:
                    number = row['TZ']
                    props.update({
                        'number' : number,
                        'name'   : row['BatchName'],
                        'no'     : row['ElementQty'],
                    })

            view = _views['orders']
            where = 'TID=%s' % order_id
            cursor = engine.runQuery(view, top=1, where=where, as_dict=True)

            if cursor is not None and len(cursor):
                row = cursor[0]
                if row:
                    props.update({
                        'file'   : row['FName'],
                        'cards'  : row['FQty'],
                    })

    except:
        print_exception()

    return number and data or [], props
Esempio n. 15
0
def loader():
    exchange_error = ''
    exchange_message = ''

    refresh()

    action = get_request_item('action') or '401'

    response = {
        'action': action,
    }

    preload_id = int(get_request_item('preload_id') or '0')
    article = int(get_request_item('article') or '0')

    if IsDebug:
        print('--> action:%s preload_id:%s article:%s' %
              (action, preload_id, article))

    data = ''
    number = ''
    columns = []

    try:
        if not action:
            pass

        elif action == '401':
            view = database_config['persolog']
            columns = _get_view_columns(view)
            data = getTabPersoLog(columns=view['columns'],
                                  preload_id=preload_id)
    except:
        print_exception()

    response.update({
        # --------------
        # Service Errors
        # --------------
        'exchange_error': exchange_error,
        'exchange_message': exchange_message,
        # -----------------------------
        # Results (Log page parameters)
        # -----------------------------
        'preload_id': preload_id,
        'article': article,
        # --------------------------
        # Results (Log page content)
        # --------------------------
        'total': len(data),
        'data': data,
        'number': number,
        'columns': columns,
    })

    return jsonify(response)
Esempio n. 16
0
 def _decompress(self, xml, body):
     try:
         self.file_setter(xml, zlib.decompress(body))
     except:
         if IsTrace:
             print_to(
                 errorlog,
                 'FileImageDecoder._decompress Error:%s' % self._file_id)
         if IsPrintExceptions:
             print_exception()
Esempio n. 17
0
def _generate_barcode(barcode_type, value, text, readable, filename, format, options, **kw):
    """ Internal generator """

    scale = kw.get('scale') or 0.05 * _INCH
    font = kw.get('font') or ('Arial', 12, False)

    # ----------------------
    # Generate barcode image
    # ----------------------

    try:
        GEN = barcode.get_barcode_class(barcode_type)
    except:
        if print_exception is not None and IsPrintExceptions:
            print_exception()
        else:
            raise
    
    # ----------------
    # Save as SVG-file
    # ----------------

    if filename and format == _default_barcode_format:
        output = GEN(value)
        return output.save(filename)
    
    # -----------------------------------
    # Save as image-file (PNG by default)
    # -----------------------------------

    try:
        from PIL import Image
        from barcode.writer import ImageWriter, SVGWriter
    except:
        if print_exception is not None and IsPrintExceptions:
            print_exception()
        else:
            raise

    output = GEN(value, writer=ImageWriter())

    if filename:
        return output.save(filename, options={'type':format})

    # -------------------------
    # Make output BASE64 stream
    # -------------------------

    data = {
        'output'  : _generate(output, options, text),
        'default' : _generate(output, None, text),
        'code'    : output.code,
    }

    return data
Esempio n. 18
0
def send_message(user, params):
    subject = params.get('subject') or gettext('Announcement')
    message = params.get('message')

    is_with_greeting = params.get('with_greeting') and True or False
    is_with_signature = params.get('with_signature') and True or False

    done = 1

    html = _EMAIL_HTML % {
        'Subject': subject,
        'Message': re.sub(r'\n', r'<br>', message),
        'Greeting': _GREETING,
        'Signature': _SIGNATURE %
        (current_user.post, current_user.full_name()),
        'hidden_g': params.get('with_greeting') != 1 and 'hidden' or '',
        'hidden_s': params.get('with_signature') != 1 and 'hidden' or '',
    }

    try:
        users = map(User.get_by_id, params.get('ids') or [])

        default_email = current_user.email

        addr_to = list(filter(
            None, [x.email for x in users if x.confirmed
                   ])) if params.get('to_everybody') else [user.email]
        addr_cc = [default_email] if default_email not in addr_to else None

        if not message or not addr_to:
            return 0

        addr_to = ';'.join(addr_to)
        addr_cc = addr_cc and ';'.join(addr_cc) or ''

        timestamp = getDate(getToday(), format=UTC_FULL_TIMESTAMP)

        if not IsNoEmail:
            done = send_simple_mail(subject, html, addr_to, addr_cc=addr_cc)

        if IsTrace:
            print_to(
                None,
                '>>> mail sent %s, login:%s, to:%s, cc:%s, subject: [%s], done:%s'
                % (timestamp, current_user.login, addr_to, addr_cc, subject,
                   done))

    except:
        if IsPrintExceptions:
            print_exception()

        done = 0

    return done
Esempio n. 19
0
def index():
    debug, kw = init_response('WebPerso Preload Page')

    command = get_request_item('command')

    if IsDebug:
        print('--> command:%s, preload_id:%s, article:%s' %
              (command, kw.get('preload_id'), kw.get('article')))

    refresh()

    errors = []

    if command and command.startswith('admin'):
        pass

    kw['errors'] = '<br>'.join(errors)
    kw['OK'] = ''

    try:
        kw = _make_page_default(kw)
    except:
        print_exception()

    kw['vsc'] = IsDebug and ('?%s' % str(int(random.random() * 10**12))) or ''

    if command and command.startswith('admin'):
        pass

    elif command == 'export':
        columns = kw['config']['preloads']['export']
        rows = []
        for data in kw['preloads']:
            row = []
            for column in columns:
                if column == 'FinalMessage':
                    continue
                v = data[column]
                if 'Date' in column:
                    v = re.sub(r'\s+', ' ', re.sub(r'<.*?>', ' ', v))
                row.append(v)

            rows.append(row)

        rows.insert(0, columns)

        xls = makeXLSContent(rows, 'Журнал предобработки заказов', True)

        response = make_response(xls)
        response.headers[
            "Content-Disposition"] = "attachment; filename=preloads.xls"
        return response

    return make_response(render_template('preload.html', debug=debug, **kw))
Esempio n. 20
0
def loader_ext1():
    exchange_error = ''
    exchange_message = ''

    action = get_request_item('action') or default_action
    selected_menu_action = get_request_item('selected_menu_action') or action != default_action and action or default_log_action

    response = {}

    params = get_request_item('params') or None

    refresh()

    if IsDebug:
        print('--> action:%s' % action)

    if IsTrace:
        print_to(errorlog, '--> loader:%s %s %s' % (
                 action, 
                 current_user.login, 
                 params and ' params:[%s]' % params or '',
            ))

    data = []

    errors = None

    try:
        if action == default_action:
            data = calculate(params)

        if not action:
            pass

    except:
        print_exception()

    response.update({
        'action'           : action,
        # --------------
        # Service Errors
        # --------------
        'exchange_error'   : exchange_error,
        'exchange_message' : exchange_message,
        # --------------------------
        # Results (Log page content)
        # --------------------------
        'total'            : len(data),
        'data'             : data,
        'errors'           : errors,
    })

    return jsonify(response)
Esempio n. 21
0
def loader():
    exchange_error = ''
    exchange_message = ''

    refresh()

    action = get_request_item('action') or default_action
    selected_menu_action = get_request_item(
        'selected_menu_action') or action != default_action and action or '901'

    response = {}

    template = get_request_item('template') or default_template
    lid = get_request_item('lid')

    if IsDebug:
        print('--> action:%s %s lid:%s' % (action, template, lid))

    if IsSemaphoreTrace:
        print_to(
            errorlog, '--> loader:%s [%s:%s:%s] %s' %
            (action, template, lid, selected_menu_action,
             getTime(UTC_FULL_TIMESTAMP)))

    state = {}

    try:
        if action == default_action:
            action = selected_menu_action

        if not action:
            pass

        elif action == '901':
            state = getCurrentState(template, lid)

    except:
        print_exception()

    response.update({ \
        'action'           : action,
        # --------------
        # Service Errors
        # --------------
        'exchange_error'   : exchange_error,
        'exchange_message' : exchange_message,
        # -------------------------
        # Results (Semaphore state)
        # -------------------------
        'state'            : state,
    })

    return jsonify(response)
Esempio n. 22
0
def run(**kw):
    global _processed
    global _found

    ctype = config['ctype'].lower()
    emitter = config.get('emitter') or False
    limit = config.get('limit') or 0

    try:
        if not ctype:
            app = AbstractSource(config, logger)
        elif ctype == 'bankperso':
            app = Bankperso(config, logger)
        elif ctype == 'sdc':
            app = SDC(config, logger)
        elif ctype == 'exchange':
            app = Exchange(config, logger)
        else:
            app = Bankperso(config, logger)

        app._init_state(**kw)

        print_to(None, '>>> Logger Started[%s], date_from: %s, root: %s' % ( \
            config['ctype'],
            kw.get('date_from'),
            config['root'],
        ))

        if app.is_ready():
            if emitter:
                _processed, _found = app.emitter(limit=limit)
            else:
                _processed, _found = app(limit=limit)

        if not IsDisableOutput:
            _pout('>>> New messages found: %d' %
                  (sum([_found[x] for x in _found]) or 0))
            _pout('>>> Total processed: %d orders' % _processed)
            _pout('>>> Unresolved: %d lines' % app._unresolved_lines())

        start_observer(app, **kw)

        app._term()

        print_to(None, '%s>>> Logger Finished[%s]%s' % ( \
            cr,
            config['ctype'],
            cr,
        ))

    except:
        print_exception()
Esempio n. 23
0
def index():
    debug, kw = init_response('WebPerso Calculator Page')
    kw['product_version'] = product_version

    is_admin = current_user.is_administrator()

    command = get_request_item('command')

    refresh()

    IsMakePageDefault = True
    info = ''

    errors = []

    if command.startswith('admin'):
        command = command.split(DEFAULT_HTML_SPLITTER)[1]

        if get_request_item('OK') != 'run':
            command = ''

        if IsDebug:
            print('--> %s' % info)

        if IsTrace:
            print_to(errorlog, '--> command:%s %s [%s]' % (command, current_user.login, info))

    kw['errors'] = '<br>'.join(errors)
    kw['OK'] = ''

    try:
        if IsMakePageDefault:
            kw = _make_page_default(kw)

        if IsTrace:
            print_to(errorlog, '--> calculator:%s %s [%s] %s %s' % ( \
                     command, current_user.login, request.remote_addr, str(kw.get('current_file')), info,), 
                     request=request)
    except:
        print_exception()

    kw['vsc'] = vsc()

    if command:
        if not command.strip():
            pass

        elif command == 'export':
            return _make_xls_content(_make_export(kw), 'Себестоимость ...')

    return make_response(render_template('calculator/%s.html' % default_locator, debug=debug, **kw))
Esempio n. 24
0
def getExchangeLogInfo(**kw):
    global config

    logs = []

    encoding, root, filemask, options = kw.get('config') or getExchangeConfig(
        kw.get('client'))

    if root is None:
        return logs

    set_globals(kw.get('globals'))

    config = exchange_log_config
    root = normpath(os.path.join(root, config['root']))

    kw['filemask'] = filemask
    kw['options'] = options

    if IsTrace:
        keys = _extract_keys(kw.get('keys')) or []
        print_to(
            None, '\n==> CHECK_EXCHANGE_LOG: %s STARTED [%s:%s:%s]' % (
                datetime.datetime.now().strftime(UTC_FULL_TIMESTAMP),
                len(keys) > 0 and keys[0] or '',
                kw.get('client'),
                kw.get('dates'),
            ))

    try:
        if IsCheckFolders:
            logger = Logger('./folders.txt', encoding=default_encoding)
            check_path(".", logger)
            logger.close()

        walk(logs, check_exchange_log, root, encoding=encoding, **kw)
    except Exception as e:
        _register_error(logs, e, **kw)

        if IsPrintExceptions:
            print_exception()

    logs = sorted(logs, key=itemgetter('Date'))

    if IsTrace:
        print_to(
            None, '==> CHECK_EXCHANGE_LOG: %s FINISHED' %
            datetime.datetime.now().strftime(UTC_FULL_TIMESTAMP))

    return logs
Esempio n. 25
0
    def refresh(check, key=None):
        if check and ExchangeRate.is_uptodate():
            return
        
        rating = 'https://www.alphavantage.co'
        
        is_error = is_changed = is_add = False
        ob = None

        for source_code, code in ExchangeRate.currency_codes():
            currency = '%s:%s' % (source_code, code)

            url = '%s/query?function=CURRENCY_EXCHANGE_RATE&from_currency=%s&to_currency=%s&apikey=%s' % (
                rating, source_code, code, key or 'CRRAPQKU6BGLZG7Q')

            is_add = False

            try:
                ob = requests.get(url)
                if ob is not None:
                    data = ob.json().get('Realtime Currency Exchange Rate')
                    if data and isinstance(data, dict):
                        cross = float(data.get('5. Exchange Rate'))
                        timezone = data.get('7. Time Zone')

                        rate = ExchangeRate.query.filter_by(rating=rating).filter_by(currency=currency).first()
                        if rate is None:
                            rate = ExchangeRate(rating, currency, timezone)
                            is_add = True

                        rate.update(cross)

                        if is_add:
                            db.session.add(rate)

                        is_changed = True
            except ConnectionError:
                is_error = True
            except:
                if IsDebug:
                    print(url, repr(ob), ob and ob.json())
                    #raise
                if IsPrintExceptions:
                    print_exception()
                is_error = True
                break

        if is_changed and not is_error:
            _commit(1)
Esempio n. 26
0
    def _clean(self):
        if not IsTmpClean:
            return
        if not (self._tmp and self.tmp_folder in self._tmp):
            return

        try:
            del_file(self.tmp_body)
            del_file(self.tmp_image)
            del_file(self.tmp_xml)

        except Exception as ex:
            print_to(
                None, 'FileImageDecoder.clean Error: [%s] %s' %
                (self.tmp_folder, str(ex)))
            if IsPrintExceptions:
                print_exception()
Esempio n. 27
0
    def execute(self, sql, no_traceback=None, raise_error=None):
        rows = []

        if IsDebug:
            print('>>> execute: %s' % sql)

        cursor = self.engine.execute(sql,
                                     no_traceback=no_traceback,
                                     raise_error=raise_error)

        try:
            rows = list(cursor.fetchall())
        except:
            if IsPrintExceptions:
                print_exception()

        return rows
Esempio n. 28
0
def index():
    debug, kw = init_response('WebPerso Configurator Page')
    kw['product_version'] = product_version

    command = get_request_item('command')

    if IsDebug:
        print('--> command:%s, file_id:%s, batch_id:%s' %
              (command, kw.get('file_id'), kw.get('batch_id')))

    refresh()

    errors = []

    if command and command.startswith('admin'):
        pass

    kw['errors'] = '<br>'.join(errors)
    kw['OK'] = ''

    try:
        kw = _make_page_default(kw)

        if IsTrace:
            print_to(errorlog,
                     '--> profile:%s %s %s' % (
                         command,
                         current_user.login,
                         str(kw.get('current_file')),
                     ),
                     request=request)
    except:
        print_exception()

    kw['vsc'] = (IsDebug or IsIE or IsForceRefresh) and (
        '?%s' % str(int(random.random() * 10**12))) or ''

    if command and command.startswith('admin'):
        pass

    return make_response(render_template('profile.html', debug=debug, **kw))
Esempio n. 29
0
def get_page_params(view=None):
    is_admin = current_user.is_administrator(private=True)
    is_manager = current_user.is_manager(private=True)
    is_operator = current_user.is_operator(private=True)

    page = 0
    per_page = int(
        get_request_item('per_page') or get_request_item('per-page') or 0)

    default_per_page = view and current_user.get_pagesize(view) or (
        #view in ('admin',) and DEFAULT_ADMIN_PER_PAGE or
        is_manager and DEFAULT_MANAGER_PER_PAGE or
        #is_operator and DEFAULT_OPER_PER_PAGE or
        view in ('cards', ) and DEFAULT_PER_PAGE * 2 or DEFAULT_PER_PAGE)

    try:
        if not per_page:
            per_page = default_per_page
        else:
            current_user.set_pagesize(view, per_page)
        page = int(get_request_item('page') or DEFAULT_PAGE)
    except:
        if IsPrintExceptions:
            print_exception()
        per_page = default_per_page
        page = DEFAULT_PAGE
    finally:
        if per_page <= 0 or per_page > 1000:
            per_page = default_per_page
        if page <= 0:
            page = DEFAULT_PAGE

    next = get_request_item('next') and True or False
    prev = get_request_item('prev') and True or False

    if next:
        page += 1
    if prev and page > 1:
        page -= 1

    return page, per_page
Esempio n. 30
0
    def execute(self, sql):
        self.open()

        if self.engine is None:
            return None

        res = None

        try:
            res = self.engine.execute(sql)
        except:
            print_to(None, 'NO SQL EXEC: %s' % sql)

            if IsPrintExceptions:
                print_exception()

            self.engine_error = True

        self.close()

        return res
Esempio n. 31
0
    def run(self, app):
        emitter = self._config.get('emitter') or False
        limit = self._config.get('limit') or 0

        print_to(
            None, '>>> Logger Started[%s], root: %s' % (
                self._config['ctype'],
                self._config['root'],
            ))

        base = BaseEmitter(args=(
            app,
            emitter,
            limit,
            self._logger,
        ))

        try:
            base.start()

            while not (self.stop_requested or base.is_finished()):
                time.sleep(5)

            if self.stop_requested:
                base.should_be_stop()

            self._processed, self._found = base.stop()

        except:
            print_exception()
            self._out('run exception (look at traceback.log)', is_error=True)

        finally:
            base.join()

        if not IsDisableOutput:
            self._out('>>> New messages found: %d' %
                      (sum([self._found[x] for x in self._found]) or 0))
            self._out('>>> Total processed: %d orders' % self._processed)
            self._out('>>> Unresolved: %d lines' % app._unresolved_lines())
Esempio n. 32
0
    def getBodyRaw(self, file_status=None, limit=None, is_extra=False):
        """
            Get $ Make raw file body content
        """
        self.getBody(file_status=file_status)

        try:
            if self.root is not None:
                if not is_extra:
                    self.maskContent(self.root)

                self.makeIndents(self.root,
                                 limit=limit and MAX_XML_TREE_NODES or None)
                return self.upload(item=self.root,
                                   header=self.header(parser='ET.parse'))

        except:
            if IsPrintExceptions:
                print_exception()

        finally:
            self.flash()
Esempio n. 33
0
def index_with_logger(mode, document=None, region=None, country=None, user=None):
    try:
        return index(mode, document=document, region=region, country=country, user=user)
    except:
        print_exception()
        raise