Exemplo n.º 1
0
def executor(queue,task, out):
    """ the background process """
    logging.debug('    task started')

    class LogOutput(object):
        """Facility to log output at intervals"""
        def __init__(self, out_queue):
            self.out_queue = out_queue
            self.stdout = sys.stdout
            sys.stdout = self
            self.istr = ""
        def __del__(self):
            sys.stdout = self.stdout
        def write(self,data):
            self.out_queue.put(data)
            self.istr += data
        def getvalue(self):
            return self.istr
    
    #stdout, sys.stdout = sys.stdout, cStringIO.StringIO()
    stdout = LogOutput(out)
    try:
        if task.app:
            os.chdir(os.environ['WEB2PY_PATH'])
            from gluon.shell import env, parse_path_info
            from gluon.dal import BaseAdapter
            from gluon import current
            level = logging.getLogger().getEffectiveLevel()
            logging.getLogger().setLevel(logging.WARN)
            # Get controller-specific subdirectory if task.app is of
            # form 'app/controller'
            (a,c,f) = parse_path_info(task.app)
            _env = env(a=a,c=c,import_models=True)
            logging.getLogger().setLevel(level)
            scheduler = current._scheduler
            f = task.function
            functions = current._scheduler.tasks
            if not functions:
                #look into env
                _function = _env.get(f)
            else:
                _function = functions.get(f)
            if not isinstance(_function, CALLABLETYPES):
                raise NameError("name '%s' not found in scheduler's environment" % f)
            globals().update(_env)
            args = loads(task.args)
            vars = loads(task.vars, object_hook=_decode_dict)
            result = dumps(_function(*args,**vars))
        else:
            ### for testing purpose only
            result = eval(task.function)(
                *loads(task.args, object_hook=_decode_dict),
                 **loads(task.vars, object_hook=_decode_dict))
        #stdout, sys.stdout = sys.stdout, stdout
        sys.stdout = stdout.stdout
        queue.put(TaskReport(COMPLETED, result,stdout.getvalue()))
    except BaseException,e:
        sys.stdout = stdout.stdout
        tb = traceback.format_exc()
        queue.put(TaskReport(FAILED,tb=tb, output=stdout.getvalue()))
Exemplo n.º 2
0
def executor(queue, task, out):
    """ the background process """
    logger.debug("    task started")

    class LogOutput(object):
        """Facility to log output at intervals"""

        def __init__(self, out_queue):
            self.out_queue = out_queue
            self.stdout = sys.stdout
            sys.stdout = self

        def __del__(self):
            sys.stdout = self.stdout

        def flush(self):
            pass

        def write(self, data):
            self.out_queue.put(data)

    W2P_TASK = Storage({"id": task.task_id, "uuid": task.uuid})
    stdout = LogOutput(out)
    try:
        if task.app:
            os.chdir(os.environ["WEB2PY_PATH"])
            from gluon.shell import env, parse_path_info
            from gluon import current

            level = logging.getLogger().getEffectiveLevel()
            logging.getLogger().setLevel(logging.WARN)
            # Get controller-specific subdirectory if task.app is of
            # form 'app/controller'
            (a, c, f) = parse_path_info(task.app)
            _env = env(a=a, c=c, import_models=True)
            logging.getLogger().setLevel(level)
            f = task.function
            functions = current._scheduler.tasks
            if not functions:
                # look into env
                _function = _env.get(f)
            else:
                _function = functions.get(f)
            if not isinstance(_function, CALLABLETYPES):
                raise NameError("name '%s' not found in scheduler's environment" % f)
            # Inject W2P_TASK into environment
            _env.update({"W2P_TASK": W2P_TASK})
            globals().update(_env)
            args = loads(task.args)
            vars = loads(task.vars, object_hook=_decode_dict)
            result = dumps(_function(*args, **vars))
        else:
            ### for testing purpose only
            result = eval(task.function)(
                *loads(task.args, object_hook=_decode_dict), **loads(task.vars, object_hook=_decode_dict)
            )
        queue.put(TaskReport(COMPLETED, result=result))
    except BaseException, e:
        tb = traceback.format_exc()
        queue.put(TaskReport(FAILED, tb=tb))
Exemplo n.º 3
0
def choose_condition():
    soft_assert(request.assid!='ASSIGNMENT_ID_NOT_AVAILABLE',
                "Can't call choose condition on preview.")

    # if this assignment exists, return its condition
    action = db.actions(assid=request.assid)
    if action:
        request.condition = sj.loads(action.condition.json)
        request.phase = action.phase
        log('Choosing existing assignment condition')
        return

    # Compute the phase of study
    request.phase = (int((now - request.study.launch_date).total_seconds()
                         / options.phase_change_time)
                     if options.phase_change_time else None)

    # If workerid already has a condition for this phase, return it
    c = db.condition_choices(workerid=request.workerid, 
                             study=request.study,
                             phase=request.phase)
    if c:
        log('Choosing existing phase condition')
        request.condition = sj.loads(c.condition.json)
        return

    # Else, let's make a new one.

    # First we'll choose the stuff we want in the condition.
    for probability, condition in options[request.task]['special_conditions'] or []:
        # First, give special conditions a shot
        random.seed()
        if random.random() < probability:
            request.condition = condition.copy()
            break
    else:
        # If none of them match, grab the next condition possible in round-robin fashion.
        next_index = db((db.condition_choices.phase==request.phase)
                        &(db.condition_choices.study==request.study)).count()
        request.condition = condition_by_index(experimental_vars_vals(request.study),
                                               next_index)

    # Now add the non-experimental variables back into the condition...
    for k, v in sj.loads(request.study.conditions).items():
        if not isinstance(v, list): request.condition[k] = v

    # Insert this choice into the database
    log('Choosing a new available condition')
    db.condition_choices.insert(study=request.study,
                                phase=request.phase,
                                condition=get_condition(request.condition),
                                workerid=request.workerid, time_assigned=now)
    
    # If this is a CHANGE of condition for the worker (because they
    # were working in a prior phase), let's set a flag so that the
    # view can tell the worker to pay attention to the difference
    if db((db.condition_choices.phase < request.phase)
          & (db.condition_choices.study == request.study)
          & (db.condition_choices.workerid == request.workerid)).count() > 0:
        request.new_phase = True
Exemplo n.º 4
0
 def get_workers(self, only_ticker=False):
     """ Returns a dict holding worker_name : {**columns}
     representing all "registered" workers
     only_ticker returns only the worker running as a TICKER,
     if there is any
     """
     r_server = self.r_server
     status_keyset = self._nkey('worker_statuses')
     registered_workers = r_server.smembers(status_keyset)
     all_workers = {}
     for worker in registered_workers:
         w = r_server.hgetall(worker)
         w = Storage(w)
         if not w:
             continue
         all_workers[w.worker_name] = Storage(
             status=w.status,
             first_heartbeat=self.str2date(w.first_heartbeat),
             last_heartbeat=self.str2date(w.last_heartbeat),
             group_names=loads(w.group_names, object_hook=_decode_dict),
             is_ticker=w.is_ticker == 'True' and True or False,
             worker_stats=loads(w.worker_stats, object_hook=_decode_dict)
         )
     if only_ticker:
         for k, v in all_workers.iteritems():
             if v['is_ticker']:
                 return {k: v}
         return {}
     return all_workers
Exemplo n.º 5
0
Arquivo: data.py Projeto: molhokwai/a
def save():
    try:
        q = db(db.json.name == request.vars.name)
        if len(q.select()):
            _id = q.update(
                name = request.vars.name,
                data = request.vars.data
            )
            return response.json({
                            'status' : 1,
                            'message' : 'update done',
                            'result' : simplejson.loads(q.select()[0].data)
            })
        else:
            _id = db.json.insert(
                name = request.vars.name,
                data = request.vars.data
            )
            return response.json({
                            'status' : 1,
                            'message' : 'insert done',
                            'result' : simplejson.loads(q.select()[0].data)
            })
    except Exception, ex:
        return response.json({
                            'status' : 0,
                            'message' : 'error',
                            'result' : str(ex)
        })
Exemplo n.º 6
0
 def on_accept(form):
     from gluon.contrib import simplejson
     global sampling_time_old
     global execonsuccess
     #update time of cutT, nodiffT, dropT and evenT when sampling time is changed + subintervals definition
     if float(form.vars.sampling_time)>0:
         sfactor = float(form.vars.sampling_time) / sampling_time_old
     else:
         sfactor = 1 #do nothing
     if sfactor != 1:
         dropT = [[x * sfactor for x in y] for y in simplejson.loads(db.flise_file[form.vars.id].dropT)] if (db.flise_file[form.vars.id].dropT != None) else []
         db.flise_file[form.vars.id].update_record(dropT=simplejson.dumps(dropT))
         cutT = [x * sfactor for x in simplejson.loads(db.flise_file[form.vars.id].cutT)] if (db.flise_file[form.vars.id].cutT != None) else []
         db.flise_file[form.vars.id].update_record(cutT=simplejson.dumps(cutT))
         nodiffT = [[x * sfactor for x in y] for y in simplejson.loads(db.flise_file[form.vars.id].nodiffT)] if (db.flise_file[form.vars.id].nodiffT != None) else []
         db.flise_file[form.vars.id].update_record(nodiffT=simplejson.dumps(nodiffT))
         eventT = [x * sfactor for x in simplejson.loads(db.flise_file[form.vars.id].eventT)] if (db.flise_file[form.vars.id].eventT != None) else []
         db.flise_file[form.vars.id].update_record(eventT=simplejson.dumps(eventT))
         for record in db(db.event.flise_file_id == form.vars.id).select():
             time = record.time * sfactor
             record.update_record(time=time)
         for record in db(db.subintervals.flise_file_id == form.vars.id).select():
             extract_time = record.extract_time
             str_time = extract_time.split(':')
             intStart = float(str_time[0]) * sfactor
             intEnd = float(str_time[1]) * sfactor
             extract_time = '%g:%g' % (intStart, intEnd)
             record.update_record(extract_time=extract_time)
         execonsuccess = 'updateGraph("%s");' % form.vars.name
     else:
         execonsuccess = 'web2py_ajax_page("GET","%s","","my_records"); $(".current_record").html("%s"); cur_id=%s; ' % (URL(r=request, f='files'), form.vars.name, form.vars.id)
Exemplo n.º 7
0
def executor(queue,task):
    """ the background process """
    logging.debug('    task started')
    stdout, sys.stdout = sys.stdout, cStringIO.StringIO()
    try:
        if task.app:
            os.chdir(os.environ['WEB2PY_PATH'])
            from gluon.shell import env
            from gluon.dal import BaseAdapter
            from gluon import current
            level = logging.getLogger().getEffectiveLevel()
            logging.getLogger().setLevel(logging.WARN)
            _env = env(task.app,import_models=True)
            logging.getLogger().setLevel(level)
            scheduler = current._scheduler
            scheduler_tasks = current._scheduler.tasks
            _function = scheduler_tasks[task.function]
            globals().update(_env)
            args = loads(task.args)
            vars = loads(task.vars, object_hook=_decode_dict)
            result = dumps(_function(*args,**vars))
        else:
            ### for testing purpose only
            result = eval(task.function)(
                *loads(task.args, object_hook=_decode_dict),
                 **loads(task.vars, object_hook=_decode_dict))
        stdout, sys.stdout = sys.stdout, stdout
        queue.put(TaskReport(COMPLETED, result,stdout.getvalue()))
    except BaseException,e:
        sys.stdout = stdout
        tb = traceback.format_exc()
        queue.put(TaskReport(FAILED,tb=tb))
Exemplo n.º 8
0
def set_graph_data(map_id, hash, nodes, edges, origin):
    '''
    Set the graph data based on the incoming node and edge strings.
    '''
    if not can_update(map_id, auth.user.id, hash):
        return dict(success=False)
        
    # Delete old nodes and edges
    db(db.Node.id_map == map_id).delete()
    db(db.Connection.id_map == map_id).delete()

    # Parse the input data
    nodes_to_add = json.loads(nodes)
    edges_to_add = json.loads(edges)
    origin = json.loads(origin)
    
    node_ids = {}
    edge_ids = {}
    
    for token, node in nodes_to_add.items():
        dim = node['dim']
        node_id = db.Node.insert(id_map = map_id, valence = node['valence'], x = dim['x'], y = dim['y'], width = dim['width'], height = dim['height'], name = node['text'], special = node['special'])
        node_ids[token] = node_id
    
    for token, edge in edges_to_add.items():
        start = node_ids[edge['from']]
        end = node_ids[edge['to']]
        points = json.dumps(edge['innerPoints'])
        connection_id = db.Connection.insert(id_first_node = start, id_second_node = end, valence = edge['valence'], inner_points = points, id_map = map_id)
        edge_ids[token] = connection_id
    
    db.Map[map_id] = dict(originX = origin['x'], originY = origin['y'])
    db.Map[map_id] = dict(date_modified = datetime.utcnow(), modified_by = auth.user.email)
    
    return dict(success=True, node_ids=node_ids, edge_ids=edge_ids)        
Exemplo n.º 9
0
    def get_missing(self, seriesid, seasonnumber):
        db = current.w2p_tvseries.database
        fname = 'get_missing'
        ss_tb = db.seasons_settings
        se_tb = db.series
        gs = w2p_tvseries_settings().global_settings()

        path_format = gs.path_format or '%(seasonnumber).2d'

        season = db(
           (ss_tb.series_id == seriesid) &
           (ss_tb.seasonnumber == seasonnumber) &
           (se_tb.id == ss_tb.series_id)
            ).select().first()

        bpath = season and season.series.basepath or ''

        if bpath == '':
            return dict(err='No basepath found')

        path = os.path.join(bpath, path_format % dict(seasonnumber = season.seasons_settings.seasonnumber))

        tracking = season and season.seasons_settings.subtitle_tracking or None
        sub_settings = season and season.seasons_settings.subtitle_settings or None
        quality = simplejson.loads(sub_settings).get('quality', 'Normal')
        language = simplejson.loads(sub_settings).get('language', 'eng')
        name = season and season.series.name or None
        id = season and season.seasons_settings.id or None
        if tracking and name and id:
            data = simplejson.loads(season.seasons_settings.season_status)
            missingsubs = data.get('missingsubs', [])
            if len(missingsubs) == 0:
                message="No missing subs for %s, season %s, type %s, in path %s" % (name, seasonnumber, quality, path)
                self.log(fname, message)
                return dict(message=message)
            errs = ''
            subtitles_list, errs = self.search_subtitles(id, name, seasonnumber, missingsubs, quality, language)
            if errs <> '':
                return dict(err=errs)
            else:
                res = self.download_subtitles(subtitles_list, path)
                found = [a['number'] for a in subtitles_list]
                not_found = []
                for a in missingsubs:
                    if a not in found:
                        not_found.append(a)
                data['missingsubs'] = not_found
                data = simplejson.dumps(data)
                db(ss_tb.id == season.seasons_settings.id).update(season_status=data)
                db.commit()
                message="Searching subs for %s, season %s, type %s, in path %s, were %s, are %s" % (name, seasonnumber, quality, path, missingsubs, not_found)
                self.log(fname, message)
                return dict(message=message)
        else:
            err = 'settings deny to download subtitles'
            self.error('fetch_subtitles', err)
            return dict(err=err)
Exemplo n.º 10
0
def step1():
    from gluon.contrib.simplejson import loads
    import urllib
    if not session.themes:
        url = LAYOUTS_APP + '/default/layouts.json'
        try:
            data = urllib.urlopen(url).read()
            session.themes = ['Default'] + loads(data)['layouts']
        except:
            session.themes = ['Default']
    themes = session.themes
    if not session.plugins:
        url = PLUGINS_APP + '/default/plugins.json'
        try:
            data = urllib.urlopen(url).read()
            session.plugins = loads(data)['plugins']
        except:
            session.plugins = []
    plugins = [x.split('.')[2] for x in session.plugins]
    response.view = 'wizard/step.html'
    params = dict(session.app['params'])
    form = SQLFORM.factory(
        Field('title', default=params.get('title', None),
              requires=IS_NOT_EMPTY()),
        Field('subtitle', default=params.get('subtitle', None)),
        Field('author', default=params.get('author', None)),
        Field(
            'author_email', default=params.get('author_email', None)),
        Field('keywords', default=params.get('keywords', None)),
        Field('description', 'text',
              default=params.get('description', None)),
        Field('layout_theme', requires=IS_IN_SET(themes),
              default=params.get('layout_theme', themes[0])),
        Field(
            'database_uri', default=params.get('database_uri', None)),
        Field(
            'security_key', default=params.get('security_key', None)),
        Field(
            'email_server', default=params.get('email_server', None)),
        Field(
            'email_sender', default=params.get('email_sender', None)),
        Field('email_login', default=params.get('email_login', None)),
        Field('login_method', requires=IS_IN_SET(('local', 'janrain')),
              default=params.get('login_method', 'local')),
        Field(
            'login_config', default=params.get('login_config', None)),
        Field('plugins', 'list:string', requires=IS_IN_SET(plugins, multiple=True)),
        _class='span7 well well-small')

    if form.accepts(request.vars):
        session.app['params'] = [(key, form.vars.get(key, None))
                                 for key, value in session.app['params']]
        redirect(URL('step2')  + '/#xwizard_form')
    return dict(step='1: Setting Parameters', form=form)
Exemplo n.º 11
0
def get_savgol():
    response.generic_patterns = ['json']
    import savgol
    from gluon.contrib import simplejson
    data2derive = simplejson.loads(request.vars.data)
    deriv = simplejson.loads(request.vars.deriv)
    result = []
    for iD in range(len(deriv)):
        result.append([])
        myinstance = savgol.Savgol(int(request.vars.w), int(request.vars.w), int(request.vars.order), deriv[iD])
        for iI in range(len(data2derive)):
            result[iD].append([])
            for iS in range(len(data2derive[iI])):
                result[iD][iI].append(myinstance.filterTS(data2derive[iI][iS]))
    return dict(result=result)
Exemplo n.º 12
0
def call_py (m):
    connection = deployment_settings.postgis.connection ()
    #file_id = str (uuid4 ().int)
    mod = get_module (m['filename'])
    attr = {}
    #attr['file'] = open ('applications/' + request.application + '/tool/results/' + file_id, 'w')
    for t in m['args']:
        key = t[0]
        label = t[1]
        ttype = t[2]
        val = request.vars.get (key)
        if ttype == 'poly_map':
            # Fix this later. Send only id in request
            ob = json.loads (val)
            map_data = dm.get ('maps', ob['id'])
            
            mapname = map_data.prefix + ':' + map_data.filename #json.loads (val)['filename']
            attr[key] = loadMap (mapname, enum.POLYGON, enum.GEOSERVER, location = map_data.src)
        elif ttype == 'point_map':
            # Fix this later. Send only id in request
            ob = json.loads (val)
            map_data = dm.get ('maps', ob['id'])
            
            mapname = map_data.prefix + ':' + map_data.filename #json.loads (val)['filename']
            attr[key] = loadMap (mapname, enum.POINT, enum.GEOSERVER, location = map_data.src)
        elif ttype == 'agg':
            attr[key] = recursiveJSON (val)
        elif ttype == 'text':
            if len (val) > 0:
                attr[key] = val
            else:
                attr[key] = None
        else:
            attr[key] = val
    buffers = []
    def request_new_buffer (name = None):
        b_id = uuid4 ().hex
        if name is None:
            name = b_id
        buffers.append ({'id': b_id, 'name': name})
        return TempBuffer (name, b_id)
    mod.request_new_buffer = request_new_buffer
    mod.mime = mime
    try:
        r_type = mod.ctool (**attr)
    except Exception as ex:
        return attr_dict (err = str (ex))
    return attr_dict (file_ids = buffers)
Exemplo n.º 13
0
    def testExportOptionsAllOptsJSON(self):
        """ Test export options, JSON, all options """

        assertEqual = self.assertEqual
        assertTrue = self.assertTrue

        options = dict(self.records)

        # Request options
        resource = current.s3db.resource("fotest_table")
        result = resource.export_options(fields=["lookup"],
                                         as_json=True)
        fo = json.loads(result)

        # Inspect result
        has_empty = False
        assertTrue(isinstance(fo, dict))
        assertTrue("option" in fo)
        assertTrue(isinstance(fo["option"], list))
        assertEqual(len(fo["option"]), len(options) + 1)
        for opt in fo["option"]:
            value = opt["@value"]
            if value == "":
                has_empty = True
                self.assertFalse("$" in opt)
                continue
            else:
                value = int(value)
            assertTrue(value in options)
            assertEqual(opt["$"], options[value]["name"])
        assertTrue(has_empty, msg="Empty-option missing")
Exemplo n.º 14
0
def _climate_chart(content_type):
    """
    """

    kwargs = dict(request.vars)
    import gluon.contrib.simplejson as json
    specs = json.loads(kwargs.pop("spec"))
    def list_of(converter):
        def convert_list(choices):
            return map(converter, choices)
        return convert_list
    checked_specs = []
    for label, spec in specs.iteritems():
        arguments = {}
        errors = []
        for name, converter in dict(
            query_expression = str,
            place_ids = list_of(int)
        ).iteritems():
            try:
                value = spec.pop(name)
            except KeyError:
                errors.append("%s missing" % name)
            else:
                try:
                    arguments[name] = converter(value)
                except TypeError:
                    errors.append("%s is wrong type" % name)
                except AssertionError, assertion_error:
                    errors.append("%s: %s" % (name, assertion_error))
        if spec:
            errors.append("Unexpected arguments: %s" % spec.keys())
        checked_specs.append((label, arguments))
Exemplo n.º 15
0
    def testExportOptionsLastOptJSON(self):
        """ Test export of last option, JSON """

        assertEqual = self.assertEqual
        assertTrue = self.assertTrue

        options = dict(self.records)

        # Get the last record
        db = current.db
        table = db.fotest_lookup_table
        last = db(table.id>0).select(limitby=(0, 1),
                                     orderby=~table.id).first()
        self.assertNotEqual(last, None)

        # Request last option
        resource = current.s3db.resource("fotest_table")
        result = resource.export_options(fields=["lookup"],
                                         only_last=True,
                                         as_json=True)
        fo = json.loads(result)

        # Inspect result
        assertTrue(isinstance(fo, dict))

        assertTrue("option" in fo)
        assertTrue(isinstance(fo["option"], list))
        assertEqual(len(fo["option"]), 1)

        opt = fo["option"][0]
        value = opt["@value"]
        assertEqual(options[value]["uuid"], last.uuid)
        assertEqual(opt["$"], options[value]["name"])
Exemplo n.º 16
0
    def testValidateMainTableError(self):
        """ Test error in main table validation """

        request = self.request
        crud = self.resource.crud

        jsonstr = """{"name":"", "acronym":"TO"}"""
        request.body = StringIO(jsonstr)

        output = crud.validate(request)

        self.assertTrue(isinstance(output, basestring))
        from gluon.contrib import simplejson as json
        data = json.loads(output)
        self.assertTrue(isinstance(data, dict))
        self.assertEqual(len(data), 2)
        self.assertTrue("name" in data)
        name = data["name"]
        self.assertTrue(isinstance(name, dict))
        self.assertTrue("value" in name)
        self.assertFalse("text" in name)
        self.assertTrue("_error" in name)

        acronym = data["acronym"]
        self.assertTrue(isinstance(acronym, dict))
        self.assertTrue("value" in acronym)
        self.assertTrue("text" in acronym)
        self.assertTrue(isinstance(acronym["text"], basestring))
        self.assertFalse("_error" in acronym)
Exemplo n.º 17
0
    def testTypeConversionFeature(self):
        """ Check that values get converted into the field type during validation """

        s3db = current.s3db

        # Create a fake request
        resource = s3db.resource("project_organisation")
        request = Storage(prefix="project",
                          name="organisation",
                          resource=resource,
                          table=resource.table,
                          tablename=resource.tablename,
                          method="validate",
                          get_vars=Storage(),
                          representation="json",
                          http="GET")

        crud = resource.crud

        jsonstr = """{"organisation_id":"1", "role":"1"}"""
        request.body = StringIO(jsonstr)

        output = crud.validate(request)
        self.assertTrue(isinstance(output, basestring))
        from gluon.contrib import simplejson as json
        data = json.loads(output)
        self.assertTrue(isinstance(data, dict))
        self.assertEqual(len(data), 2)

        self.assertTrue("role" in data)
        role = data["role"]
        self.assertTrue(isinstance(role, dict))
        self.assertTrue("value" in role)
        self.assertTrue(isinstance(role["value"], int))
Exemplo n.º 18
0
def check_season():
    session.forget(response)
    series_id, seasonnumber = request.args(0), request.args(1)
    if not (series_id and seasonnumber):
        return json({})

    status = db(
       (db.seasons_settings.series_id == series_id) &
       (db.seasons_settings.seasonnumber == seasonnumber)
       ).select(db.seasons_settings.season_status, db.seasons_settings.updated_on).first()

    if not status.updated_on:
        status.updated_on = request.now
    episodes = db(
        (db.series.id == series_id) &
        (db.episodes.seriesid == db.series.seriesid) &
        (db.episodes.seasonnumber == seasonnumber) &
        (db.episodes.inserted_on > status.updated_on)
        ).select(db.episodes.epnumber)

    rtn = status.season_status
    if len(episodes) > 0:
        st_ = sj.loads(status.season_status)
        missing = st_.get('missing', [])
        for ep in episodes:
            missing.append(ep.epnumber)
        st_['missing'] = missing
        rtn = sj.dumps(st_)
    return rtn
Exemplo n.º 19
0
def twitter():
    session.forget()
    session._unlock(response)
    import urllib
    import gluon.contrib.simplejson as sj
    try:
        if TWITTER_HASH:
            # tweets = urllib.urlopen('http://twitter.com/%s?format=json' % TWITTER_HASH).read()
            try: 
                tweets = cache.disk(request.env.path_info + ".tweets", 
                                               lambda: urllib.urlopen("http://search.twitter.com/search.json?q=%s" % TWITTER_HASH).read(), 
                                               time_expire=60*15)
            except:
               import os
               # manually clean cache (TODO: check why it can get corrupt!)
               path = os.path.join(request.folder,'cache')
               for f in os.listdir(path):
                    try:
                        if f[:1]!='.': os.unlink(os.path.join(path,f))
                    except IOError:
                        r = False
               # try to reload
               redirect(URL("twitter"))       
            
            data = sj.loads(tweets, encoding="utf-8")
            the_tweets = dict()
            
            for obj in data["results"]:
                the_tweets[obj["id"]] = (obj["created_at"], obj["from_user"], obj["profile_image_url"], obj["text"])
            ret = dict(message = None, tweets = the_tweets)
        else:
            ret = dict(tweets = None, message = 'disabled')

    except Exception, e:
        ret = dict(tweets = None, message = DIV(T('Unable to download because:'),BR(),str(e)))
Exemplo n.º 20
0
def edit_ordering():
    """ Edit last ordering."""
    # Gets the information on the venue and comparison.
    venue = db.venue(request.args[0]) or redirect(URL('default', 'index'))
    last_comparison = db.comparison(request.args[1]) or redirect(URL('default', 'index'))
    if last_comparison.author != auth.user_id:
        session.flash = T('Invalid request.')
        redirect(URL('default', 'index'))

    # Check that the venue rating deadline is currently open, or that the ranker
    # is a manager or observer.
    if ((auth.user.email not in util.get_list(venue.managers)) and
	(auth.user.email not in util.get_list(venue.observers)) and 
	(datetime.utcnow() < venue.rate_open_date or datetime.utcnow() > venue.rate_close_date)):
	session.flash = T('The review deadline for this venue is closed.')
        redirect(URL('venues', 'view_venue', args=[venue.id]))

    # Ok, the task belongs to the user.
    # Gets the last reviewing task done for the same venue.
    if last_comparison == None:
        last_ordering = []
    else:
        last_ordering = util.get_list(last_comparison.ordering)

    # Finds the grades that were given for the submissions previously reviewed.
    if last_comparison == None or last_comparison.grades == None:
	str_grades = {}
    else:
	try:
	    str_grades = simplejson.loads(last_comparison.grades)
	except Exception, e:
	    str_grades = {}
	    logger.warning("Grades cannot be read: " + str(last_comparison.grades))
Exemplo n.º 21
0
    def call(self, method, *args):
        "JSON RPC communication (method invocation)"

        # build data sent to the service
        request_id = random.randint(0, sys.maxint)
        data = {'id': request_id, 'method': method, 'params': args, }
        if self.version:
            data['jsonrpc'] = self.version #mandatory key/value for jsonrpc2 validation else err -32600
        request = json.dumps(data)

        # make HTTP request (retry if connection is lost)
        response = self.__transport.request(
            self.__host,
            self.__handler,
            request,
            verbose=self.__verbose
        )

        # store plain request and response for further debugging
        self.json_request = request
        self.json_response = response

        # parse json data coming from service
        # {'version': '1.1', 'id': id, 'result': result, 'error': None}
        response = json.loads(response)

        self.error = response.get('error', {})
        if self.error and self.exceptions:
            raise JSONRPCError(self.error.get('code', 0),
                               self.error.get('message', ''),
                               self.error.get('data', None))
        if response['id'] != request_id:
            raise JSONRPCError(0, "JSON Request ID != Response ID")

        return response.get('result')
Exemplo n.º 22
0
def add_crew(room, wefsk, people):
	people = json.loads(people)
	id = db.crew.insert(room=room, wefsk=wefsk)
	for p in people:
		db(db.person.id==p).update(crew=id)

	return dict(id=id)
Exemplo n.º 23
0
def _climate_chart(content_type):
    kwargs = dict(request.vars)
    import gluon.contrib.simplejson as JSON
    specs = JSON.loads(kwargs.pop("spec"))

    checked_specs = []
    for spec in specs:
        arguments = {}
        errors = []
        for name, converter in dict(
            query_expression = str,
            place_ids = list_of(int)
        ).iteritems():
            try:
                value = spec.pop(name)
            except KeyError:
                errors.append("%s missing" % name)
            else:
                try:
                    arguments[name] = converter(value)
                except TypeError:
                    errors.append("%s is wrong type" % name)
                except AssertionError, assertion_error:
                    errors.append("%s: %s" % (name, assertion_error))
        if spec:
            errors.append("Unexpected arguments: %s" % spec.keys())
        checked_specs.append(arguments)
Exemplo n.º 24
0
    def call(self, method, *args):
        "JSON RPC communication (method invocation)"

        # build data sent to the service
        request_id = random.randint(0, sys.maxint)
        data = {"id": request_id, "method": method, "params": args}
        request = json.dumps(data)

        # make HTTP request (retry if connection is lost)
        response = self.__transport.request(self.__host, self.__handler, request, verbose=self.__verbose)

        # store plain request and response for further debugging
        self.json_request = request
        self.json_response = response

        # parse json data coming from service
        # {'version': '1.1', 'id': id, 'result': result, 'error': None}
        response = json.loads(response)

        if response["id"] != request_id:
            raise JSONRPCError(0, "JSON Request ID != Response ID")

        self.error = response.get("error", {})
        if self.error and self.exceptions:
            raise JSONRPCError(self.error.get("code", 0), self.error.get("message", ""), self.error.get("data", None))

        return response.get("result")
Exemplo n.º 25
0
 def get_user(self):
     request = self.request
     user = None
     if request.vars.connection_token:
         auth_url = "https://%s.api.oneall.com/connections/%s.json"  % \
                    (self.domain, request.vars.connection_token)
         auth_pw = "%s:%s" % (self.public_key,self.private_key)
         auth_pw = base64.b64encode(auth_pw)
         headers = dict(Authorization="Basic %s" % auth_pw)
         try:
             auth_info_json = fetch(auth_url,headers=headers)
             auth_info = json.loads(auth_info_json)
             data = auth_info['response']['result']['data']
             if data['plugin']['key'] == 'social_login':
                 if data['plugin']['data']['status'] == 'success':
                     userdata = data['user']
                     self.profile = userdata['identity']
                     source = self.profile['source']['key']
                     mapping = self.mappings.get(source,self.mappings['default'])
                     user = mapping(self.profile)
         except (JSONDecodeError, KeyError):
             pass
         if user is None and self.on_login_failure:
                 redirect(self.on_login_failure)
     return user
Exemplo n.º 26
0
def ajax_cargar_pedido_mesa():

	mmct = db(
		db.mesa_mozo_caja_turno.mesa == request.get_vars.get('mesa') and\
		db.mesa_mozo_caja_turno.caja == Helper.get_caja_abierta().id and\
		db.mesa_mozo_caja_turno.turno == Helper.get_current_turno().id).select()[0]

	pedido = db.pedidos.insert(caja=mmct.caja)

	for x in sj.loads(request.get_vars.get('productos')):

		linea_pedido = db.linea_pedido.insert(
			pedido=pedido.id,
			producto=x['id_producto'],
			cantidad=x['cantidad']
		)

	pedidos_mesas = db.pedidos_mesas.insert(
		pedido = pedido,
		mesa = mmct.mesa,
		mozo = mmct.mozo,
		turno = mmct.turno,
		caja = mmct.caja
 	)

	return pedido.id
Exemplo n.º 27
0
def cargar_pedido_ajax():

	pedido = db.pedidos.insert(caja=Helper.get_caja_abierta())

	for x in sj.loads(request.vars['productos']):

		linea_pedido = db.linea_pedido.insert(
			pedido=pedido.id,
			producto=x['id_producto'],
			cantidad=x['cantidad'])

	return redirect(
		URL(
			'single_pedido_template_'+request.vars['tipo_pedido'],
			vars=dict(
					id_pedido=pedido.id,
					nombre=request.vars['nombre'],
					direccion=request.vars['direccion'],
					mesa=request.vars['mesa'],
					kilometraje = request.vars['kilometraje'],
					precio = request.vars['precio'],
					tipo_factura=request.vars["tipo_factura"]
				)
		)
	)
Exemplo n.º 28
0
    def add_to_targetgroup(self, target_id, group_id=None, group_name=None):
        """
        Adds the target with id target_id to the targetgroup with id
        group_id.
        Returns True if the operation was successful
        """
        if group_name:
            group_id = self.get_group_id(group_name)
        target_row = self._db(self._db.target.id==target_id).select().first()
        group_row = self._db(self._db.targetgroup.id==group_id
                            ).select().first()
        result = False
        if target_row is not None and group_row is not None:
            targets_j = group_row.targets
            if not targets_j:
                # Dumps the json to the group table
                targets_j = json.dumps([target_id])
            else:
                tmp_j = json.loads(targets_j)
                tmp_j.append(target_id)
                targets_j = json.dumps(tmp_j)
            result = self._db(self._db.targetgroup.id==group_id
                             ).update(targets=targets_j)
            self._db.commit()

        return result
Exemplo n.º 29
0
    def decode_order(form):
	logger.debug("request.vars.order: " + request.vars.order)
	logger.debug("request.vars.grades: " + request.vars.grades)
	if request.vars.order == None or request.vars.grades == None:
	    form.errors.comments = T('Error in the received ranking')
	    session.flash = T('Error in the received ranking')
	    return
	# Verifies the order.
	try:
	    decoded_order = [int(x) for x in request.vars.order.split()]
	    for i in decoded_order:
		if i != subm_id:
		    # This must correspond to a previously done task.
		    mt = db((db.task.submission_id == i) &
			    (db.task.user_id == auth.user_id)).select().first()
		    if mt == None or mt.completed_date > datetime.utcnow():
			form.errors.comments = T('Corruputed data received')
			session.flash = T('Corrupted data received')
			break
	    form.vars.order = decoded_order
	except ValueError:
	    form.errors.comments = T('Error in the received ranking')
	    session.flash = T('Error in the received ranking')
	    return
	# Verifies the grades.
	try:
	    decoded_grades = simplejson.loads(request.vars.grades)
	    grade_subm = [(float(g), long(s)) for (s, g) in decoded_grades.iteritems()]
	    # Check that all grades are between 0 and 10.
	    for (g, s) in grade_subm:
		if g < 0.0 or g > 10.0:
		    form.errors.comments = T('Grades should be in the interval [0..10]')
		    session.flash = T('Errors in the received grades')
		    return
	    # Sorts the grades in decreasing order.
	    grade_subm.sort()
	    grade_subm.reverse()
	    # Checks that there are no duplicate grades.
	    if len(grade_subm) == 0:
		form.errors.comments = T('No grades specified')
		session.flash = T('Errors in the received grades')
		return
	    (prev, _) = grade_subm[0]
	    for (g, s) in grade_subm[1:]:
		if g == prev:
		    form.errors.comments = T('There is a repeated grade: grades need to be unique.')
		    session.flash = T('Errors in the received grades')
		    return
	    # Checks that the order of the grades matches the one of the submissions.
	    subm_order = [s for (g, s) in grade_subm]
	    if subm_order != form.vars.order:
		form.errors.comments = T('The ranking of the submissions does not reflect the grades.')
		session.flash = T('Errors in the received grades.')
		return
	    # Copies the grades in the form variable.
	    form.vars.grades = request.vars.grades
	except Exception, e:
	    form.errors.comments = T('Error in the received grades')
	    session.flash = T('Error in the received grades')
	    return
Exemplo n.º 30
0
    def get_targets(self, group_set, target_set=[]):
        """
        If target_set is not a list it returns a rowset with all
        targets.
        If target_set is a list of groups it returns a rowset of targets
        that belong to these groups.
        """
        result_id = []
        if not isinstance(group_set, list):
            for target in self._db(self._db.target).select():
                result_id.append(target.id)
        else:
            rows = self._db(self._db.targetgroup).select()
            for row in rows:
                if row.id in group_set:
                    targets = json.loads(row.targets)
                    for t_id in targets:
                        result_id.append(self._db(self._db.target.id==t_id
                                                 ).select().first().id)
        result_id += target_set

        result = []
        for target_id in set(result_id):
            result.append(self.get_target(target_id))

        return result
Exemplo n.º 31
0
def twitter():
    session.forget()
    session._unlock(response)
    import gluon.tools
    import gluon.contrib.simplejson as sj
    try:
        if TWITTER_HASH:
            page = gluon.tools.fetch('http://twitter.com/%s?format=json' %
                                     TWITTER_HASH)
            return sj.loads(page)['#timeline']
        else:
            return 'disabled'
    except Exception, e:
        return DIV(T('Unable to download because:'), BR(), str(e))
Exemplo n.º 32
0
def update_names(names):
    names = json.loads(names)
    response = []
    for name in names:
        r = db.module_names.update_or_insert(name=name['name'],
                                             label=name['value'])
        response.append(r)

    errors = list()
    for i in range(len(response)):
        if response[i] == 0:
            errors.append(names[i])

    return dict(errors=errors)
Exemplo n.º 33
0
 def __call__(self, value):
     from gluon import current
     try:
         obj = loads(value)
     except:
         return (value, current.T('invalid json'))
     else:
         if isinstance(obj, self.myclass):
             if self.parse:
                 return (obj, None)
             else:
                 return (value, None)
         else:
             return (value, current.T('Not of type: %s') % self.myclass)
Exemplo n.º 34
0
    def rename(self, seriesid, seasonnumber, mode):
        db = current.w2p_tvseries.database
        self.log(
            'rename', "Checking for series with id %s and season %s" %
            (seriesid, seasonnumber))
        bit = db.rename_log
        ss_tb = db.seasons_settings
        datarec = db((ss_tb.series_id == seriesid)
                     & (ss_tb.seasonnumber == seasonnumber)).select().first()
        data = datarec and datarec.season_status
        data = simplejson.loads(data)
        if not data:
            return
        rename = data['rename']

        now = datetime.datetime.now()
        db.commit()
        existing = []
        while True:
            try:
                rename_ = rename.pop()
            except:
                break
            source, dest = rename_
            self.log(
                'rename', "trying to do %s --> %s" %
                (os.path.basename(source), os.path.basename(dest)))
            if os.path.exists(dest):
                existing.append((dest, source))
            if os.path.exists(dest) or not os.path.exists(source):
                continue
            try:
                bit.insert(series_id=seriesid,
                           seasonnumber=seasonnumber,
                           file_from=source,
                           file_to=dest)
                os.rename(source, dest)
                db.commit()
            except:
                db.rollback()
        data['rename'] = rename
        if mode == 'video':
            data['existingvideo'] = existing
        elif mode == 'subs':
            data['existingsubs'] = existing
        datarec.update_record(season_status=simplejson.dumps(data),
                              updated_on=now)
        db.commit()
        return datarec
Exemplo n.º 35
0
def test_school_classcards_get_json(client, web2py):
    """
        Are the class cards returned correctly?
    """
    populate_api_users(web2py)

    populate_school_classcards(web2py, 2)

    url = base_url + '/api/school_classcards_get.json?user=test&key=test'
    page = urllib.urlopen(url).read()
    print page
    json = sj.loads(page)

    classcard = web2py.db.school_classcards(1)
    assert json['data'][0]['Name'] == classcard.Name
Exemplo n.º 36
0
def lite_wager_end(wager, winned):
    from gluon.tools import fetch

    args = ''
    for w in winned:
        cond = db.wager_conds[w]
        if not cond: continue
        args += '%s/' % cond.bill_id
    url = LITEcash.url + LITEcash.end_wager % (wager.lite_wager_id,
                                               wager.lite_wager_key, args)
    #print url
    resp = fetch(url)
    import gluon.contrib.simplejson as sj
    res = sj.loads(resp)
    return res
Exemplo n.º 37
0
 def process(self, data):
     data = simplejson.loads(data)
     id, method, params = data["id"], data["method"], data["params"]
     if method in self.methods:
         try:
             result = self.methods[method](*params)
             return self.response(id, result)
         except BaseException:
             etype, eval, etb = sys.exc_info()
             return self.error(id, 100, '%s: %s' % (etype.__name__, eval))
         except:
             etype, eval, etb = sys.exc_info()
             return self.error(id, 100, 'Exception %s: %s' % (etype, eval))
     else:
         return self.error(id, 100, 'method "%s" does not exist' % method)
Exemplo n.º 38
0
def test_school_classcards_get_json(client, web2py):
    """
        Are the class cards returned correctly?
    """
    populate_api_users(web2py)

    populate_school_classcards(web2py, 2)

    url = base_url + '/api/school_classcards_get.json?user=test&key=test'
    with urllib.request.urlopen(url) as page:
        content = page.read().decode('utf-8')
    json = sj.loads(content)

    classcard = web2py.db.school_classcards(1)
    assert json['data'][0]['Name'] == classcard.Name
Exemplo n.º 39
0
    def test__book_pages_as_json(self):
        as_json = book_pages_as_json(db, self._book.id)
        data = loads(as_json)
        self.assertTrue('files' in data)
        self.assertEqual(len(data['files']), 2)
        self.assertEqual(sorted(data['files'][0].keys()), [
            'deleteType',
            'deleteUrl',
            'name',
            'size',
            'thumbnailUrl',
            'url',
        ])
        self.assertEqual(data['files'][0]['name'], 'file.jpg')
        self.assertEqual(data['files'][1]['name'], 'file_2.jpg')

        # Test book_page_ids param.
        as_json = book_pages_as_json(db,
                                     self._book.id,
                                     book_page_ids=[self._book_page.id])
        data = loads(as_json)
        self.assertTrue('files' in data)
        self.assertEqual(len(data['files']), 1)
        self.assertEqual(data['files'][0]['name'], 'file.jpg')
Exemplo n.º 40
0
def represent_ordering(v, r):
    if v is None:
        return ''
    try:
        id_to_nicks = simplejson.loads(r.submission_nicknames)
        urls = [
            SPAN(
                A(str(id_to_nicks.get(str(el), '')),
                  _href=URL('feedback', 'view_feedback', args=[el])), ' ')
            for el in v
        ]
        attributes = {}
        return SPAN(*urls, **attributes)
    except Exception, e:
        return '-- data error --'
Exemplo n.º 41
0
    def testExtendedErrorMessageWithTree(self):
        """ Test error message with specified error code, text and JSON tree """

        json_message = current.xml.json_message

        msg = json_message(False, 405, message="Test", tree='{"test": "value"}')
        msg = json.loads(msg)
        self.assertEqual(len(msg), 4)
        self.assertEqual(msg["status"], "failed")
        self.assertEqual(msg["statuscode"], "405")
        self.assertEqual(msg["message"], "Test")
        self.assertTrue(isinstance(msg["tree"], dict))
        tree = msg["tree"]
        self.assertEqual(len(tree), 1)
        self.assertEqual(tree["test"], "value")
Exemplo n.º 42
0
def test_school_subscriptions_get_json(client, web2py):
    """
        Are the subscriptions returned correctly?
    """
    populate_api_users(web2py)

    populate_school_subscriptions(web2py)

    url = base_url + '/api/school_subscriptions_get.json?user=test&key=test'
    page = urllib.urlopen(url).read()
    json = sj.loads(page)

    subscription = web2py.db.school_subscriptions(1)
    subscription_price = web2py.db.school_subscriptions_price(1)
    assert json['data'][0]['Name'] == subscription.Name
    assert json['data'][0]['Price'] == subscription_price.Price
Exemplo n.º 43
0
def login():
    data = json.loads(request.body.read())
    ssn = db(db.citizen.ssn == data['ssn']).select().first()
    if ssn:
        verification_code = id_generator()
        db.register_codes.insert(verification_code=verification_code,
                                 code_date=data['code_date'],
                                 citizen_id=ssn['id'])
        subject = 'Código de inicio de sesión'
        message = 'El código de inicio de sesión es: \n'
        message += str(verification_code)
        message += '\n Ingreselo en la aplicación para acceder al sistema'
        mail.send(to=ssn['email'], subject=subject, message=message)
        return dict(status="login_successful")
    else:
        return dict(status="error")
 def get_user(self):
     request = self.request
     if request.vars.token:
         user = Storage()
         data = urllib.urlencode(dict(apiKey = self.api_key, token=request.vars.token))
         auth_info_json = fetch(self.auth_url+'?'+data)
         auth_info = json.loads(auth_info_json)
         
         if auth_info['stat'] == 'ok':
             self.profile = auth_info['profile']
             provider = re.sub('[^\w\-]','',self.profile['providerName'])
             user = self.mappings.get(provider,self.mappings.default)(self.profile)
             return user
         elif self.on_login_failure:
             redirect(self.on_login_failure)
     return None
Exemplo n.º 45
0
 def get_user(self):
     request = self.request
     user = None
     if request.vars.token:
         try:
             auth_url = self.auth_base_url + self.api_secret + "/" + request.vars.token
             json_data = fetch(auth_url, headers={'User-Agent': "LoginRadius - Python - SDK"})
             self.profile = json.loads(json_data)
             provider = self.profile['Provider']
             mapping = self.mappings.get(provider, self.mappings['default'])
             user = mapping(self.profile)
         except (JSONDecodeError, KeyError):
             pass
         if user is None and self.on_login_failure:
             redirect(self.on_login_failure)
     return user
Exemplo n.º 46
0
def test_school_teachers_get_json(client, web2py):
    """
        Are the teachers returned correctly?
    """
    from populate_os_tables import populate_auth_user_teachers

    populate_api_users(web2py)

    populate_auth_user_teachers(web2py)

    url = base_url + '/api/school_teachers_get.json?user=test&key=test'
    page = urllib.urlopen(url).read()
    json = sj.loads(page)

    teacher = web2py.db.auth_user(2)
    assert json['data'][0]['Name'] == teacher.full_name
Exemplo n.º 47
0
def message():
    from gluon.contrib.websocket_messaging import websocket_send
    msg = request.body.read()
    data = json.loads(msg)
    insert = db.plates.insert(
        plate=data['results'][0]['plate'],
        confidence=data['results'][0]['confidence'],
        total_processing_time=data['processing_time_ms'],
        plate_processing_time=data['results'][0]['processing_time_ms'],
        epoch_time=data['epoch_time'],
        camera_id=data['camera_id'],
        site_id=data['site_id'],
        img_width=data['img_width'],
        img_height=data['img_height'],
        plate_img_uuid=data['uuid'])
    websocket_send('http://127.0.0.1:8888', msg, 'mykey', 'live_stream')
    pass
Exemplo n.º 48
0
def test_school_subscriptions_get_json(client, web2py):
    """
        Are the subscriptions returned correctly?
    """
    populate_api_users(web2py)

    populate_school_subscriptions(web2py)

    url = base_url + '/api/school_subscriptions_get.json?user=test&key=test'
    with urllib.request.urlopen(url) as page:
        content = page.read().decode('utf-8')
    json = sj.loads(content)

    subscription = web2py.db.school_subscriptions(1)
    subscription_price = web2py.db.school_subscriptions_price(1)
    assert json['data'][0]['Name'] == subscription.Name
    assert json['data'][0]['Price'] == subscription_price.Price
Exemplo n.º 49
0
def test_school_teachers_get_json(client, web2py):
    """
        Are the teachers returned correctly?
    """
    from populate_os_tables import populate_auth_user_teachers

    populate_api_users(web2py)

    populate_auth_user_teachers(web2py)

    url = base_url + '/api/school_teachers_get.json?user=test&key=test'
    with urllib.request.urlopen(url) as page:
        content = page.read().decode('utf-8')
    json = sj.loads(content)

    teacher = web2py.db.auth_user(2)
    assert json['data'][0]['Name'] == teacher.full_name
Exemplo n.º 50
0
 def get_user(self):
     request = self.request
     if request.vars.assertion:
         audience = self.audience
         issuer = self.issuer
         assertion = XML(request.vars.assertion, sanitize=True)
         verify_data = {'assertion': assertion, 'audience': audience}
         auth_info_json = fetch(self.verify_url, data=verify_data)
         j = json.loads(auth_info_json)
         epoch_time = int(time.time() * 1000)  # we need 13 digit epoch time
         if j["status"] == "okay" and j["audience"] == audience and j['issuer'] == issuer and j['expires'] >= epoch_time:
             return dict(email=j['email'])
         elif self.on_login_failure:
             redirect('http://google.com')
         else:
             redirect('http://google.com')
     return None
Exemplo n.º 51
0
def in_btc():
    man_id = session.man_id
    if not man_id:
        return 'session error 1'
    man_bal_id = request.args(0)
    if not man_bal_id:
        return 'empty man_bal_id'
    man_bal = db.man_bals[man_bal_id]
    if not man_bal:
        return 'empty man_bal'
    if man_bal.man_id != man_id:
        return 'session error 2'

    man = db.men[man_bal.man_id]
    if not man:
        return 'error man'

    cash = db.cash[man_bal.cash_id]
    if not cash:
        return 'error cash'

    if cash.system_id != myconf.take('cash.bitcoin_id', cast=int):
        return T('В разработке')

    if not man_bal.dep_bill or len(man_bal.dep_bill) < 2:
        ## make a bill on LITE.cash

        url = 'http://lite.cash/api_bill/make.json/325?order=%s' % man.ref_key
        #print url
        #return url

        from gluon.tools import fetch
        resp = fetch(url)
        #print resp
        import gluon.contrib.simplejson as sj
        if not resp[:2].isdigit():
            # если тут не число - значит ошибка
            res = sj.loads(resp)  # {'bill': bill_id }
            err = res.get('error')
            if err:
                return dict(err=err)

        ## bill_id, _, skey = resp.partition('.')
        man_bal.update_record(dep_bill=resp)

    redirect('http://lite.cash/bill/show/' + man_bal.dep_bill)
Exemplo n.º 52
0
    def task_status(self, ref, output=False):
        """
        Shortcut for task status retrieval

        :param ref: can be
            - integer --> lookup will be done by scheduler_task.id
            - string  --> lookup will be done by scheduler_task.uuid
            - query   --> lookup as you wish (as in db.scheduler_task.task_name == 'test1')
        :param output: fetch also the scheduler_run record

        Returns a single Row object, for the last queued task
        If output == True, returns also the last scheduler_run record
            scheduler_run record is fetched by a left join, so it can
            have all fields == None

        """
        from gluon.dal import Query
        sr, st = self.db.scheduler_run, self.db.scheduler_task
        if isinstance(ref, int):
            q = st.id == ref
        elif isinstance(ref, str):
            q = st.uuid == ref
        elif isinstance(ref, Query):
            q = ref
        else:
            raise SyntaxError(
                "You can retrieve results only by id, uuid or Query")
        fields = st.ALL
        left = False
        orderby = ~st.id
        if output:
            fields = st.ALL, sr.ALL
            left = sr.on(sr.scheduler_task == st.id)
            orderby = ~st.id | ~sr.id
        row = self.db(q).select(
            *fields,
            **dict(orderby=orderby,
                   left=left,
                   limitby=(0, 1))
             ).first()
        if output:
            row.result = row.scheduler_run.run_result and \
                loads(row.scheduler_run.run_result,
                      object_hook=_decode_dict) or None
        return row
Exemplo n.º 53
0
def subtitle():
    from gluon.contrib import simplejson
    T.lazy = False

    if request.args(1) == "create":
        starts = seconds_to_time(request.vars.starts)
        ends = seconds_to_time(request.vars.ends)
        subtitle_id = db.subtitle.insert(
            subtitulation_id=request.vars.subtitulation_id,
            starts=starts,
            ends=ends)
        subtitle = db.subtitle[subtitle_id]
        option = SUBTITLE(subtitle)
        subtitle = subtitle.as_dict()
        subtitle["starts"] = str(subtitle["starts"])
        subtitle["ends"] = str(subtitle["ends"])
        subtitle["body"] = ""
        result = simplejson.dumps(dict(option=option.xml(), subtitle=subtitle))
        return result

    elif request.args(1) == "update":

        def update_record(sub):
            del (sub["startEvent"])
            del (sub["endEvent"])
            subtitulation_id = db.subtitle[sub["id"]].subtitulation_id
            authorize("subtitulation", subtitulation_id)
            db.subtitle[sub["id"]].update_record(**sub)

        payload = simplejson.loads(request.vars.data)
        if isinstance(payload, dict):
            update_record(payload)
        elif isinstance(payload, list):
            for item in payload:
                update_record(item)
        else:
            raise HTTP(500, "Unexpected data format")
        return simplejson.dumps("Done!")
    elif request.args(1) == "delete":
        subtitulation_id = db.subtitle[request.vars.id].subtitulation_id
        authorize("subtitulation", subtitulation_id)
        result = db.subtitle[request.vars.id].delete_record()
        return simplejson.dumps("ok")
    else:
        raise HTTP(501, "Not implemented")
Exemplo n.º 54
0
def reassign_ingredient():
    jsonData = simplejson.loads(request.body.read()) if request.body else {}
    layoutName = jsonData.get("layoutName")
    oldID = jsonData.get("oldID")
    newID = jsonData.get("newID")
    removeOld = jsonData.get("removeOld")
    updated = False
    if layoutName and oldID and newID:
        from Embed import Embed
        embedDao = Embed(db)
        updated = embedDao.edit_ingredient_mapping(layoutName, oldID, newID)
        if updated and removeOld:
            query = db.ingredients.id == oldID
            db(query).delete()
    if updated:
        return api_response(update="success")
    else:
        return api_error('Input01', "I'm not angry, just disappointed")
Exemplo n.º 55
0
 def get_user(self):
     request = self.request
     if request.vars.token:
         user = Storage()
         data = urllib.urlencode(dict(token = request.vars.token))
         auth_info_json = fetch(self.auth_url+'?'+data)
         #print auth_info_json
         auth_info = json.loads(auth_info_json)
         if auth_info["identity"] != None:
             self.profile = auth_info
             provider = self.profile["provider"]
             user = self.mappings.get(provider, self.mappings.default)(self.profile)
             #user["password"] = ???
             #user["avatar"] = ???
             return user
         elif self.on_login_failure:
             redirect(self.on_login_failure)
     return None
Exemplo n.º 56
0
def count_syllables(str):
    import urllib
    import urllib2
    from gluon.contrib import simplejson

    # GET JSONP from RhymeBrain API and parse
    url = 'http://rhymebrain.com/talk'
    data = {}
    data['function'] = 'getWordInfo'
    data['word'] = str
    url_values = urllib.urlencode(data)
    full_url = url + '?' + url_values
    data = urllib2.urlopen(full_url)
    result = data.read()
    parsed_json = simplejson.loads(result)

    # Return number of syllables cast as int
    return int(parsed_json['syllables'])
Exemplo n.º 57
0
    def get_user(self):
        import string
        request = self.environment.request

        if request.vars.token:
            user = Storage()
            data = urllib.urlencode(
                dict(apiKey=self.api_key, token=request.vars.token))
            auth_info_json = fetch("?".join([self.auth_url, data]))
            auth_info = json.loads(auth_info_json)
            if auth_info['stat'] == 'ok':
                self.profile = auth_info['profile']
                provider = self.profile['providerName']
                provider = ''.join(c for c in provider
                                   if c in string.ascii_letters)
                for field in self.auth.settings.table_user.fields:
                    user[field] = self.get_mapping(provider, field)
                if self.on_mapped and user:
                    user = self.on_mapped(user, provider)
                if self.allow_local:
                    db = self.db
                    user_table = self.auth.settings.table_user
                    if 'username' in user_table.fields:
                        username = '******'
                    else:
                        username = '******'
                    existing = db(
                        user_table[username] == user[username]).select()
                    if len(existing):
                        dbuser = existing.first()
                        if dbuser[self.auth.settings.password_field] != None:
                            self.environment.session.flash = '%s already in use' % username.capitalize(
                            )
                            return None
                        if 'registration_key' in user_table.fields:
                            if dbuser['registration_key']:
                                self.environment.session.flash = '%s already in use' % username.capitalize(
                                )
                                return None
                return user
            else:
                return None
                #auth_info['err']['msg']
        return None
Exemplo n.º 58
0
def activation():
    data = json.loads(request.body.read())
    if data['ssn']:
        citizen_id = db(db.citizen.ssn == data['ssn']).select().first()
        code = db((db.register_codes.used == False) & (
            db.register_codes.citizen_id == citizen_id['id'])).select().last()
    if code:
        if data['verification_code'] == code['verification_code']:
            code.update_record(used=True,
                               code_date=data['code_date'],
                               citizen_id=citizen_id['id'])
            citizen_id.update_record(active_user=True,
                                     citizen_id=citizen_id['id'])
            return dict(status="activation_successful",
                        citizen_id=citizen_id['id'])
        else:
            return dict(status="activation_error")
    else:
        return dict(status="error")
Exemplo n.º 59
0
def get_currs(currs):
    curr_in = 'USD'
    pars_enc = 'q=select * from yahoo.finance.xchange where pair in ('
    for code in currs:
        pars_enc += '"%s%s",' % (curr_in, code)
    pars_enc = pars_enc[:-1]

    pars_enc += ')&env=store://datatables.org/alltableswithkeys&format=json'
    #return None, pars_enc
    import urllib2
    req = urllib2.Request(
        'http://query.yahooapis.com/v1/public/yql',
        pars_enc,
        #headers,
    )
    #return None, '%s' % req
    page = urllib2.urlopen(req)
    res = page.read()
    #print res
    import gluon.contrib.simplejson as sj
    res = sj.loads(res)
    #print res
    currs = res.get('query')
    currs = currs and currs.get('results')
    currs = currs and currs.get('rate')
    if not currs:
        print res
        return res, None
    #print currs
    res = {}
    # если на входе одна пара то на выходе нет массива
    if type(currs) != type([]):
        currs = [currs]
    for curr in currs:
        if curr['Name'] == 'N/A':
            continue
        code = curr['id'][3:]
        rate = 1 / float(curr['Rate'] or -1)
        #rate = 1/ float(curr['Ask'] or -1)
        dd = curr['Date']
        tt = curr['Time']
        res[code] = rate
    return None, res
Exemplo n.º 60
0
def add_to_group(group_id, person_id=0, people=None, multiple=False):
    """Adds a person to the group

	:param person_id: the id of the person
	:param group_id: the id of the group
	:returns: a dictionary with the id of the record for the group
	"""
    if multiple and people:
        people = json.loads(people)
        response = list()
        for person_id in people:
            rec_id = db.group_rec.insert(person_id=person_id,
                                         group_id=group_id)
            response.append(dict(group_rec_id=rec_id))
        return dict(response=response)
    else:
        rec_id = db.group_rec.insert(person_id=person_id, group_id=group_id)

        return dict(group_rec_id=rec_id)