Ejemplo n.º 1
0
def plugin_jqgrid(table,fieldname=None,fieldvalue=None,col_widths={},
                  _id=None,columns=None,col_width=80,width=700,height=300):
    """
    just do to embed the jqGrid with ajax search capability and pagination
    {{=plugin_jqgrid(db.tablename)}}
    - table is the db.tablename
    - fieldname, fieldvalue are an optional filter (fieldname==fieldvalue)
    - _id is the "id" of the DIV that contains the jqGrid
    - columns is a list of columns names to be displayed
    - cold_width is the width of each column
    - height is the height of the jqGrid
    """
    from gluon.serializers import json
    _id = 'jqgrid_%s' % table
    columns = columns or [x for x in table.fields if table[x].readable]
    colnames = [x.replace('_',' ').capitalize() for x in columns]
    colmodel = [{'name':x,'index':x, 'width':col_widths.get(x,col_width), 'sortable':True} \
                    for x in columns if table[x].readable]
    callback = URL(r=request,c='plugin_jqgrid',f='data',
                   vars=dict(tablename=table._tablename,
                             columns=','.join(columns),
                             fieldname=fieldname or '',
                             fieldvalue=fieldvalue,
                             ))
    script="""
jQuery(document).ready(function(){jQuery("#%(id)s").jqGrid({ url:'%(callback)s', datatype: "json", colNames: %(colnames)s,colModel:%(colmodel)s, rowNum:10, rowList:[20,50,100], pager: '#%(id)s_pager', viewrecords: true,height:%(height)s});jQuery("#%(id)s").jqGrid('navGrid','#%(id)s_pager',{search:true,add:false,edit:false,del:false});jQuery("#%(id)s").setGridWidth(%(width)s,false);});
""" % dict(callback=callback,colnames=json(colnames),
           colmodel=json(colmodel),id=_id,height=height,width=width)
    return TAG[''](TABLE(_id=_id),
                   DIV(_id=_id+"_pager"),
                   SCRIPT(script))
Ejemplo n.º 2
0
def cantidad_eventos_area():
    query_desde_hasta = (db.reclamo.horario_llamada >= request.args[0]) & (
        db.reclamo.horario_llamada <= request.args[1])
    areas_eventos_cantidades = []
    for area in [1, 2, 3, 4]:
        eventos = {}
        for evento in db().select(db.evento.nombre):
            cantidad = db((db.reclamo.area == area)
                          & (db.reclamo.evento == evento.nombre)
                          & query_desde_hasta).count()
            eventos[evento.nombre] = cantidad

        import operator
        eventos_mayores = sorted(eventos.items(),
                                 key=operator.itemgetter(1),
                                 reverse=True)
        lista_eventos = []
        lista_cantidad = []
        for item in range(5):
            lista_eventos.append(eventos_mayores[item][0])
            lista_cantidad.append(eventos_mayores[item][1])
        from gluon.serializers import json
        areas_eventos_cantidades.append(
            [str(area), json(lista_eventos),
             json(lista_cantidad)])
    return dict(areas_eventos_cantidades=areas_eventos_cantidades)
Ejemplo n.º 3
0
    def __orderby(self):
        """
        :raises HTTP: http.BAD_REQUEST
        :rtype: str
        """
        order_field = self.request_vars["orderby"]
        sort_order = self.request_vars['sort'] or 'ASC'

        if order_field:
            order_field = order_field.lower()  # todo: Essa é a melhor forma ?
            if order_field not in self.table.fields:
                headers = {"InvalidParameters": json(order_field)}
                raise HTTP(
                    http.BAD_REQUEST,
                    "%s não é um campo válido para ordenação." % order_field,
                    **headers)
            if sort_order not in self.__sorting_options:
                headers = {"InvalidParameters": json(sort_order)}
                raise HTTP(http.BAD_REQUEST,
                           "%s não é uma ordenacão válida." % sort_order,
                           **headers)
            return "%s %s" % (self.table[order_field], sort_order)
        elif self.table._primarykey:
            return self.table._primarykey
        return self.table.fields[0]
Ejemplo n.º 4
0
def index():
    # Serves a badge SVG file if the badge argument is present
    if request.args(0) == 'badge':
        # Return to dashboard if project not found
        q = db(db.project.project_name == request.vars.id).select()[0]
        if request.args(0) is None or q is None:
            redirect('default', 'index')
            session.flash = T('Project not found')
        experiment = db(db.experiment.build_id == q.id).select(
            orderby=~db.experiment.id)[0]
        # Return to dashboard if not the owner of the project
        if db(db.build.id ==
              experiment.build_id).select()[0].user_id != auth.user.id:
            redirect('default', 'index')
            session.flash = T('Permission denied')
        # Set the view to the SVG file
        response.view = 'default/badge.svg'
        return dict(status=experiment.status)
    # Fetch and return the project, build, and experiment lists in JSON format otherwise
    project_list = XML(json(load_projects()))
    build_list = XML(json(load_builds(request.vars.id)))
    experiment_list = XML(
        json(load_experiments(request.vars.id, request.vars.build)))
    validation_list = XML(
        json(
            load_validations(request.vars.id, request.vars.build,
                             request.vars.experiment)))
    print load_validations(request.vars.id, request.vars.build,
                           request.vars.experiment)
    return dict(project_list=project_list,
                build_list=build_list,
                experiment_list=experiment_list,
                validation_list=validation_list)
Ejemplo n.º 5
0
def admin_upload_file():
    """
    File upload handler for the ajax form of the plugin jquery-file-upload
    Return the response in JSON required by the plugin
    """
    try:
        import re
        from gluon.serializers import json

        resource_file = request.vars['files[]']
        resource_type = re.compile(
            '^(\s|\.|-|\w|á|é|í|ó|ú|ñ|Á|É|Í|Ó|Ú|Ñ){1,40}\.(pdf|epub|png)$')
        filename = resource_file.filename

        if resource_type.match(filename):
            # Store file
            id = db.resource.insert(resource=db.resource.resource.store(
                request.vars['files[]'], request.vars['files[]'].filename),
                                    title=request.vars['files[]'].filename,
                                    category=request.vars['category'],
                                    rtype=request.vars['rtype'])
            response.flash = CAT(T("I uploaded resource named"), " ",
                                 request.vars['files[]'].filename)
            return response.json(json({True}))
        else:
            response.flash = CAT(T("Error filename"), " ",
                                 request.vars['files[]'].filename)
            return response.json(json({False}))
    except:
        response.flash = T("Failed uploading file")
        return response.json(json({False}))
Ejemplo n.º 6
0
def editarUsuario():
    if request.vars:
        idusuario = request.vars.id
        nome = request.vars.nome
        sobrenome = request.vars.sobrenome
        email = request.vars.email
        senha = request.vars.senha

        if request.vars.tipo:
            tipo = request.vars.tipo
        else:
            tipo = 2

        from gluon.serializers import json

        try:
            db(db.auth_user.id == idusuario).update(first_name=nome,
                                                    last_name=sobrenome,
                                                    email=email,
                                                    password=senha,
                                                    senha=senha)
        except Exception as e:
            error = [{'code': 0, 'error': e}]
            return XML(json(error))
        else:
            return XML(json([{'code': 1}]))
Ejemplo n.º 7
0
def op_status():
    session.forget(response)
    st = db2.scheduler_task
    sw = db2.scheduler_worker
    operations = db2(
                    (st.task_name.startswith('now_or_never')) |
                    (st.task_name.startswith('spec'))
                    ).select()

    timelimit = request.now - datetime.timedelta(seconds=10)
    worker = db2(sw.last_heartbeat > timelimit).select(sw.id).first()

    if not operations.first():
        rtn = dict(status='complete', text='0/0', perc=0, worker=worker)
        return json(rtn)

    todo = operations.find(lambda row: (row.times_run == 0 and row.status not in ('RUNNING', 'FAILED')))

    todo = len(todo)
    operations = len(operations)

    text = "%s/%s" % (operations-todo,operations)
    perc = "%s%%" % ((operations - todo) * 1.0 / operations * 100)
    rtn = dict(status='loading', text=text, perc=perc, worker=worker)
    return json(rtn)
Ejemplo n.º 8
0
def login():
    if request.vars:
        email = request.vars.email
        senha = request.vars.senha
        usuarios = db(db.auth_user.id > 0).select()
        tam = len(usuarios)
        login = False
        usuarioLogin = None
        for usuario in usuarios:

            if email == usuario.email:

                if senha == usuario.senha:
                    login = True
                    usuarioLogin = usuario

        if login:

            resultado = [{'resultado': 1, 'dados': [usuarioLogin]}]

            from gluon.serializers import json
            return XML(json(resultado))
        else:
            resultado = [{'resultado': 0}]
            from gluon.serializers import json
            return XML(json(resultado))
Ejemplo n.º 9
0
    def callback(self):
        from gluon.serializers import json
        if 'request_json' in self.request.vars and self.request.vars.request_json == 'True':
            query = None
            if 'prefetch' in self.request.vars and self.request.vars.prefetch == 'True':
                self.limitby = None
                if not self.query:
                    query = self.fields[0]
                else:
                    query = self.query
            if 'remote' in self.request.vars:
                if not self.query:
                    query = self.fields[0].contains(self.request.vars.remote)
                else:
                    query = self.query & self.fields[0].contains(
                        self.request.vars.remote)

            rows = self.db(query).select(orderby=self.orderby,
                                         limitby=self.limitby,
                                         distinct=self.distinct,
                                         *self.fields)

            if rows:
                raise HTTP(200, json(rows))
            else:
                raise HTTP(200, json([]))
Ejemplo n.º 10
0
def plugin_jqgrid(table,fieldname=None,fieldvalue=None,col_widths={},
                  _id=None,columns=None,col_width=80,width=700,height=300, onselect=""):
    """
    just do to embed the jqGrid with ajax search capability and pagination
    {{=plugin_jqgrid(db.tablename)}}
    - table is the db.tablename
    - fieldname, fieldvalue are an optional filter (fieldname==fieldvalue)
    - _id is the "id" of the DIV that contains the jqGrid
    - columns is a list of columns names to be displayed
    - cold_width is the width of each column
    - height is the height of the jqGrid
    """
    from gluon.serializers import json
    _id = 'jqgrid_%s' % table
    columns = columns or [x for x in table.fields if table[x].readable]
    colnames = [str(table[x].label) for x in columns]
    #colnames = [x.replace('_',' ').capitalize() for x in columns]
    colmodel = [{'name':x,'index':x, 'width':col_widths.get(x,col_width), 'sortable':True} \
                    for x in columns if table[x].readable]    
    callback = URL(r=request,c='plugin_jqgrid',f='data',
                   vars=dict(tablename=table._tablename,
                             columns=','.join(columns),
                             fieldname=fieldname or '',
                             fieldvalue=fieldvalue,
                             ))
    script="""
jQuery(document).ready(function(){jQuery("#%(id)s").jqGrid({ url:'%(callback)s', datatype: "json", colNames: %(colnames)s,colModel:%(colmodel)s, rowNum:50, rowList:[20,50,100], pager: '#%(id)s_pager', viewrecords: true,height:%(height)s, onSelectRow: function(id){%(onselect)s}});jQuery("#%(id)s").jqGrid('navGrid','#%(id)s_pager',{search:true,add:false,edit:false,del:false});jQuery("#%(id)s").hideCol("id").setGridWidth(%(width)s,false);});
""" % dict(callback=callback,colnames=json(colnames),
           colmodel=json(colmodel),id=_id,height=height,width=width, onselect=onselect)
    return TAG[''](TABLE(_id=_id),
                   DIV(_id=_id+"_pager"),
                   SCRIPT(script))
Ejemplo n.º 11
0
    def callback(self):
        from gluon.serializers import json
        if 'request_json' in self.request.vars and self.request.vars.request_json == 'True':
            query = None
            if 'prefetch' in self.request.vars and self.request.vars.prefetch == 'True':
                self.limitby = None
                if not self.query:
                    query = self.fields[0]
                else:
                    query = self.query
            if 'remote' in self.request.vars:
                if not self.query:
                    query = self.fields[0].contains(self.request.vars.remote)
                else:
                    query = self.query & self.fields[0].contains(self.request.vars.remote)

            rows = self.db(query).select(
                orderby=self.orderby,
                limitby=self.limitby,
                distinct=self.distinct,
                *self.fields
            )

            if rows:
                raise HTTP(200, json(rows))
            else:
                raise HTTP(200, json([]))
Ejemplo n.º 12
0
    def jqgrid(table,
               fieldname=None,
               fieldvalue=None,
               col_widths='',
               colnames=None,
               _id=None,
               fields='',
               col_width=80,
               width=700,
               height=300):
        """
        ## Embed a jqGrid plugin
        - ``table`` is the table name
        - ``fieldname``, ``fieldvalue`` are an optional filter (fieldname==fieldvalue)
        - ``_id`` is the "id" of the DIV that contains the jqGrid
        - ``fields`` is a list of columns names to be displayed
        - ``colnames`` is a list of column headers
        - ``col_width`` is the width of each column (default) 
        - ``height`` is the height of the jqGrid
        - ``width`` is the width of the jqGrid
        """
        from gluon.serializers import json
        _id = 'jqgrid_%s' % table
        if not fields:
            fields = [
                x.strip() for x in db[table].fields
                if db[table][x.strip()].readable
            ]
        elif isinstance(fields, str):
            fields = [x.strip() for x in fields.split(',')]
        else:
            fields = fields
        if col_widths:
            col_widths = [x.strip() for x in col_widths.split(',')]
        elif not col_widths:
            col_widths = [col_width for x in fields]
        if not colnames:
            colnames = [(db[table][x].label or x) for x in fields]
        elif isinstance(colnames, str):
            colnames = [x.strip() for x in colnames]
        colmodel = [{'name':x,'index':x, 'width':col_widths[i], 'sortable':True} \
                        for i,x in enumerate(fields)]
        callback = URL('plugin_wiki',
                       'jqgrid',
                       vars=dict(
                           tablename=table,
                           columns=','.join(fields),
                           fieldname=fieldname or '',
                           fieldvalue=fieldvalue,
                       ))
        script = """
jQuery(document).ready(function(){jQuery("#%(id)s").jqGrid({ url:'%(callback)s', datatype: "json", colNames: %(colnames)s,colModel:%(colmodel)s, rowNum:10, rowList:[20,50,100], pager: '#%(id)s_pager', viewrecords: true,height:%(height)s});jQuery("#%(id)s").jqGrid('navGrid','#%(id)s_pager',{search:true,add:false,edit:false,del:false});jQuery("#%(id)s").setGridWidth(%(width)s,false);});
""" % dict(callback=callback,
           colnames=json(colnames),
           colmodel=json(colmodel),
           id=_id,
           height=height,
           width=width)
        return TAG[''](TABLE(_id=_id), DIV(_id=_id + "_pager"), SCRIPT(script))
Ejemplo n.º 13
0
def persona_ajax():
    query = str(request.vars.query)
    result = db(Persona.fsearch.lower().contains(query.lower()))
    if not result.isempty():
        return json([{'id': r.id, 'value': Persona._format % r.as_dict()} \
                    for r in result.select()])
    else:
        return json([{'id': '',
                      'value': '<span style="color:red">Sin resultados</span>'}])
Ejemplo n.º 14
0
    def jqgrid(table,fieldname=None,fieldvalue=None,col_widths='',
               colnames=None,_id=None,fields='',
               col_width=80,width=700,height=300,dbname='db'):
        """
        ## Embed a jqGrid plugin
        - ``table`` is the table name
        - ``fieldname``, ``fieldvalue`` are an optional filter (fieldname==fieldvalue)
        - ``_id`` is the "id" of the TABLE that contains the jqGrid
        - ``fields`` is a list of columns names to be displayed
        - ``colnames`` is a list of column headers
        - ``col_width`` is the width of each column (default) 
        - ``height`` is the height of the jqGrid
        - ``width`` is the width of the jqGrid
        """
        from gluon.serializers import json
        _id = _id or 'jqgrid_%s' % table
        db = globals()[dbname]
        if not fields:
            fields = [x.strip() for x in db[table].fields if db[table][x.strip()].readable]
        elif isinstance(fields,str):
            fields = [x.strip() for x in fields.split(',')]
        else:
            fields = fields
        if col_widths:
            if isinstance(col_widths,(list,tuple)):
                col_widths = [str(x) for x in col_widths]
            else:
                col_widths = [x.strip() for x in col_widths.split(',')]
	    if width=='auto':
		width=sum([int(x) for x in col_widths])
	elif not col_widths:
            col_widths = [col_width for x in fields]
        if isinstance(colnames,str):
            colnames = [x.strip() for x in colnames.split(',')]
        else:
            colnames = [(db[table][x].label or x) for x in fields]
        colmodel = [{'name':x,'index':x, 'width':col_widths[i], 'sortable':True}\
                        for i,x in enumerate(fields)]
        callback = URL('plugin_wiki','jqgrid',
                       vars=dict(dbname=dbname,
                                 tablename=table,
                                 columns=','.join(fields),
                                 fieldname=fieldname or '',
                                 fieldvalue=fieldvalue,
                                 ),
                       hmac_key=auth.settings.hmac_key,
                       salt=auth.user_id
                       )
        script="""
jQuery(document).ready(function(){jQuery("#%(id)s").jqGrid({ url:'%(callback)s', datatype: "json", colNames: %(colnames)s,colModel:%(colmodel)s, rowNum:10, rowList:[20,50,100], pager: '#%(id)s_pager', viewrecords: true,height:%(height)s});jQuery("#%(id)s").jqGrid('navGrid','#%(id)s_pager',{search:true,add:false,edit:false,del:false});jQuery("#%(id)s").setGridWidth(%(width)s,false);jQuery('select.ui-pg-selbox,input.ui-pg-input').css('width','50px');});
""" % dict(callback=callback,colnames=json(colnames),
           colmodel=json(colmodel),id=_id,height=height,width=width)
        return TAG[''](TABLE(_id=_id),
                       DIV(_id=_id+"_pager"),
                       SCRIPT(script))
Ejemplo n.º 15
0
def _sync(dataset, params, procedure):
    try:
        response_dataset = result = procedure.perform_work(dataset)

        if params['fields']:
            response_dataset = {k: v for k, v in result.iteritems() if k in params['fields']}

        raise HTTP(http.CREATED, json(response_dataset))
    except ProcedureException as e:
        headers = {'error': e.cause}
        raise HTTP(http.INTERNAL_SERVER_ERROR, json(dataset), **headers)
Ejemplo n.º 16
0
def _grading(userId, course, exercise):

	response = dict()

	enrollment = db((db.enrollment.course == course) & (db.enrollment.student == userId)).select()

	# no enrollment found
	if len(enrollment) < 1:
		response['error'] = T('You are not enrolled to the course you tried to get grades for')
		raise HTTP(422, XML(json(response)))

	exerciseAssignment = db((db.course_exercise.exercise == exercise) & (db.course_exercise.course == course)).select()

	# no enrollment found
	if len(exerciseAssignment) < 1:
		response['error'] = T('There is no such exercise in this course')
		raise HTTP(422, XML(json(response)))

	exerciseAssignment = exerciseAssignment.first()

	grades = db((db.grading.enrollment == enrollment.first()) & (db.grading.exercise == exerciseAssignment.id)).select()

	# no grades found
	if len(grades) < 1:
		response['error'] = T('It seems like there is no grading for this exercise')
		raise HTTP(422, XML(json(response)))

	# in an exercise is assigned multiple times
	response['grades'] = []
	for grade in grades:
		# get the point groups
		currentGrading = dict()
		pointGroups = db((db.points_grading.grading == grade.id)).select()
		
		currentGrading['overallPoints'] = 0
		currentGrading['pointGroups'] = []

		# iterate over them and build processable dicts
		for pointGroup in pointGroups:
			# fetch the referenced point group to gather data
			referencedPointGroup = db((db.points.id == pointGroup.points)).select().first()

			currentGrading['pointGroups'].append(dict(number=referencedPointGroup.number_of_points, passed=pointGroup.succeeded))
			
			# sum up the results
			if pointGroup.succeeded:
				currentGrading['overallPoints'] += referencedPointGroup.number_of_points

		# put the grading into the array
		response['grades'].append(currentGrading)

	return response	
Ejemplo n.º 17
0
def submit():
	project=request.vars.project
	course=request.vars.course
	main=request.vars.execute
	buildId = runsystem.generateBuildId(BUILD_ID_LENGTH)

	if len(course) == 0:
		raise HTTP(422, XML(json(dict(error=T('We can\'t do anything for you until you specify a course')))))

	try:
		runsystem.invokeBuild(mode='submit', buildId=buildId, project=project, course=course, main=main, userId=auth.user_id)
	except Exception, e:
		raise HTTP(500, XML(json(dict(error=T('We got an error while trying to build the project: ') + T(str(e))))))
Ejemplo n.º 18
0
def _sync(dataset, params, procedure):
    try:
        response_dataset = result = procedure.perform_work(dataset)

        if params['fields']:
            response_dataset = {
                k: v
                for k, v in result.iteritems() if k in params['fields']
            }

        raise HTTP(http.CREATED, json(response_dataset))
    except ProcedureException as e:
        headers = {'error': e.cause}
        raise HTTP(http.INTERNAL_SERVER_ERROR, json(dataset), **headers)
Ejemplo n.º 19
0
def message_updates(db):
    cursor = int(current.session.cursor or 0)

    q = db.chat.id > cursor
    rows = db(q).select()
    if not rows:
        new_message_event.wait()
        rows = db(q).select()

    if rows:  # This should be always True
        current.session.cursor = rows.last().id
        return json({'messages': rows.as_list()})

    # Should never happen. Just in case
    return json({'messages': []})
Ejemplo n.º 20
0
def update_from_tvdb():
    series_id = request.args(0)
    if not series_id:
        return ''
    rtn = myscheduler.queue_task(
            'update_single_series',
            [series_id],
            {},
            task_name = 'spec:update_single_series',
            timeout=180,
            immediate=True)
    if rtn.id:
        return json(dict(result='ok'))
    else:
        return json(dict(result='error'))
Ejemplo n.º 21
0
def check():
    session.forget(response)
    if not request.vars.directory:
        return 0

    base, hint = os.path.split(request.vars.directory)
    if not base:
        return json([])
    if not os.access(base, os.R_OK):
        return json([])
    res = find_matching_subdir(base, hint)
    if res:
        return res
    else:
        return json([])
Ejemplo n.º 22
0
def message_updates(db):
    cursor = int(current.session.cursor or 0)

    q = db.chat.id > cursor
    rows = db(q).select()
    if not rows:
        new_message_event.wait()
        rows = db(q).select()

    if rows:  # This should be always True
        current.session.cursor = rows.last().id
        return json({'messages': rows.as_list()})

    # Should never happen. Just in case
    return json({'messages': []})
Ejemplo n.º 23
0
def upload_file():
    """
    File upload handler for the ajax form of the plugin jquery-file-upload
    Return the response in JSON required by the plugin
    """
    try:
        import re
        from gluon.serializers import json

        resource_file = request.vars['files[]']
        resource_type = re.compile(
            '^(\s|\.|-|\w|á|é|í|ó|ú|ñ|Á|É|Í|Ó|Ú|Ñ){1,40}\.(pdf|epub|png)$')
        filename = resource_file.filename

        if resource_type.match(filename):
            # Store file
            id = db.resource.insert(resource=db.resource.resource.store(
                resource_file, filename),
                                    title=filename)
            response.flash = CAT(T("I uploaded resource named "), filename)
            return response.json(
                json({
                    "name":
                    filename,
                    "success":
                    True,
                    "url":
                    URL('resource',
                        'edites',
                        args=['edit', 'resource', id],
                        user_signature=True)
                }))
        else:
            return response.json(
                json({
                    "name": filename,
                    "success": False,
                    "message": T("Invalid file name")
                }))

    except Exception, e:
        response.flash = T("Failed uploading file")
        return response.json(
            json({
                "name": resource_file.filename,
                "success": False,
                "message": str(e)
            }))
Ejemplo n.º 24
0
    def _validate_fields(self):
        """
        Método que verifica se os parâmetros passados são válidos ou não. Um dicionário
        com duas chaves é retornado:

        `valid` uma lista de campos cujos nomes estão contidos na lista de colunas da
        tabela requisitada
        `special` uma lista de campos cujos nomes, com um sufixo válido, estão contidos
        na lista de colunas da tabela requisitada

        :rtype : dict
        :return: Um dicionário contendo os campos válidos
        """
        endpoint_fields = self.datasource[self.endpoint].fields
        fields = {"valid": [], "special": []}
        invalid_fields = []
        for k in self.lower_vars.keys():
            if k in endpoint_fields:
                fields['valid'].append(k)
            elif self._is_valid_field_with_sufix(k):
                fields['special'].append(k)
            else:
                if k not in self.valid_parameters:
                    invalid_fields.append(k)
        if invalid_fields:
            headers = {"InvalidParameters": json(invalid_fields)}
            raise HTTP(http.BAD_REQUEST, "Alguns parâmetros da requisição são incompatíveis.", **headers)
        return fields
Ejemplo n.º 25
0
def form_archivo():
    from gluon.serializers import json
    solicitud = db(db.solicitud.estado_solicitud == "Pendiente").select()

    an = json(solicitud)

    return dict(an=an, solicitud=solicitud)
Ejemplo n.º 26
0
def index():
    last_time = session.refresh_log
    if not last_time or request.vars.refresh == '1':
        last_records = db(db.global_log.id > 0).select(
            orderby=~db.global_log.id, limitby=(0, 20))
        session.refresh_log_lastid = last_records.first(
        ) and last_records.first().id or 0
    else:
        last_records = db(
            db.global_log.id > session.refresh_log_lastid).select(
                orderby=~db.global_log.id, limitby=(0, 20))
        session.refresh_log_lastid = last_records.first(
        ) and last_records.first().id or session.refresh_log_lastid

    rtn = []
    for row in last_records:
        type = 'ok'
        trclass = 'info'
        if row.log_error:
            type = 'ko'
            trclass = 'error'
            row.log_operation = row.log_error
        rtn.append(
            str(
                TR(TD(
                    SPAN(
                        w2p_icon(type), "%s: %s - %s " %
                        (row.dat_insert, row.log_module, row.log_function)), ),
                   TD(SPAN(row.log_operation)),
                   _class=trclass)))
    rtn = json(rtn)
    session.refresh_log = 1
    return rtn
Ejemplo n.º 27
0
def history():
    if request.args(0) not in INSTANCE_VALID_ARG:
        non_valid_instance()
    curr_env = {
        'base_url': URL('console', 'history')
    }
    return dict(curr_env=json(curr_env))
Ejemplo n.º 28
0
def concat():
    if request.vars:
        a = request.vars.a
        b = request.vars.b
        result = {'Resultado': a + b}
        from gluon.serializers import json
        return XML(json(result))
Ejemplo n.º 29
0
def por_sistema():
    from gluon.serializers import json  #importo json
    setsoli = db(db.solicitud.estado_solicitud == "Confeccion").select(
    )  #realizo un set de los registros con estado confeccion
    co = json(setsoli)  #trasformo el set a formato json

    return dict(co=co)
Ejemplo n.º 30
0
def add():
    rows = db(db.tpp_education_degrees.id > 0).select()
    degrees = TAG.select(_id='degree', _name='degree', *[TAG.option(  r['name'], _value=r['id'] ) for r in rows])
    
    
    rows2 = db((db.tpp_user_educations.school == db.tpp_schools.id)
               & (db.tpp_cities.id == db.tpp_schools.city)
               & (db.tpp_user_educations.degree == db.tpp_education_degrees.id) 
               & (db.tpp_user_educations.created_by == auth.user_id) ).select(
                                                                             db.tpp_user_educations.start, 
                                                                             db.tpp_user_educations.end,
                                                                             db.tpp_user_educations.note,
                                                                             db.tpp_user_educations.major,
                                                                             db.tpp_education_degrees.name,
                                                                             db.tpp_user_educations.id,
                                                                             db.tpp_schools.name,
                                                                             db.tpp_cities.name,
                                                                             db.tpp_school_majors.name,
                                                                             left=db.tpp_school_majors.on(db.tpp_user_educations.major==db.tpp_school_majors.id) )
    
    temp = {};
    for edu in rows2:
        temp[edu.tpp_user_educations.id] = db.tpp_user_educations.major.represent(edu.tpp_user_educations.major) ;
    
    result = {};
    result['majors'] = temp
    result['edu'] = rows2
    
    return dict(degrees=degrees, education =  json(result) )
Ejemplo n.º 31
0
def get_data():
    import pandas
    import numpy as np
    from gluon.serializers import json
    import os
    
    path = os.path.join(request.folder)

    df = pandas.read_csv(path + 'private\\data\\dataset_1\\Video_Games_Sales_as_at_22_Dec_2016.csv')
        
    publishersTop = df['Publisher'].value_counts().nlargest(10).axes[0].tolist()
    publishersTop.append('Bethesda Softworks')
    
    output = {}    
    output['publishers'] = publishersTop

    for p in publishersTop:        
        tempdf = df[df['Publisher'] == p]
        scatter_data = []
        pie_data = []
        line_data_labels = []
        line_data_values = []

        for i, row in tempdf.iterrows():                                
            scatter_data.append([row[5], row[6], str(row[0])])        
            line_data_labels.append(str(row[0]))
            line_data_values.append(row[5])        
            pie_data.append({'name': str(row[0]), 'value': row[5]})
            
        output[p] = {'scatter_data': scatter_data}, {'pie_data': pie_data}, {'line_data': {'labels': line_data_labels, 'values': line_data_values}}
           
    # import ipdb; ipdb.set_trace()
    return json(output)
Ejemplo n.º 32
0
def index():
    last_time = session.refresh_log
    if not last_time or request.vars.refresh == '1':
        last_records = db(db.global_log.id>0).select(orderby=~db.global_log.id, limitby=(0,20))
        session.refresh_log_lastid = last_records.first() and last_records.first().id or 0
    else:
        last_records = db(db.global_log.id>session.refresh_log_lastid).select(orderby=~db.global_log.id, limitby=(0,20))
        session.refresh_log_lastid = last_records.first() and last_records.first().id or session.refresh_log_lastid

    rtn = []
    for row in last_records:
        type = 'ok'
        trclass = 'info'
        if row.log_error:
            type = 'ko'
            trclass = 'error'
            row.log_operation = row.log_error
        rtn.append(
            str(TR(
                TD(
                    SPAN(w2p_icon(type), "%s: %s - %s " % (row.dat_insert, row.log_module, row.log_function)),
                    ),
                TD(
                    SPAN(row.log_operation)
                    ),
                _class=trclass)
                )
            )
    rtn = json(rtn)
    session.refresh_log = 1
    return rtn
Ejemplo n.º 33
0
def index():
    from gluon.serializers import json
    json_list = dict(xml_url='')
    locale = 'de_DE'
    if session.forced_language == 'en':
        locale = 'en_US'
    book_id = request.args[0]
    file_id = request.args[1]

    # check if it is xml
    if str(file_id).endswith('.xml'):
        query = ((db.submission_settings.submission_id == int(book_id))
                 & (db.submission_settings.locale == locale))
        author_q = ((db.authors.submission_id == book_id))
        authors_list = db(author_q).select(
            db.authors.first_name, db.authors.last_name)
        authors = ''
        for i in authors_list:
            authors += i.first_name + ' ' + i.last_name + ', '
        if authors.endswith(', '):
            authors = authors[:-2]
        return dict(json_list=XML(json(json_list)), authors=authors)
    else:
        path = os.path.join(request.folder, 'static/monographs',
                            book_id, 'submission/', file_id)
        return response.stream(path)
Ejemplo n.º 34
0
    def _validate_fields(self):
        """
        Método que verifica se os parâmetros passados são válidos ou não. Um dicionário
        com duas chaves é retornado:

        `valid` uma lista de campos cujos nomes estão contidos na lista de colunas da
        tabela requisitada
        `special` uma lista de campos cujos nomes, com um sufixo válido, estão contidos
        na lista de colunas da tabela requisitada

        :rtype : dict
        :return: Um dicionário contendo os campos válidos
        """
        endpoint_fields = self.datasource[self.endpoint].fields
        fields = {"valid": [], "special": []}
        invalid_fields = []
        for k in self.lower_vars.keys():
            if k in endpoint_fields:
                fields['valid'].append(k)
            elif self._is_valid_field_with_sufix(k):
                fields['special'].append(k)
            else:
                if k not in self.valid_parameters:
                    invalid_fields.append(k)
        if invalid_fields:
            headers = {"InvalidParameters": json(invalid_fields)}
            raise HTTP(http.BAD_REQUEST,
                       "Alguns parâmetros da requisição são incompatíveis.",
                       **headers)
        return fields
Ejemplo n.º 35
0
def pesquisaAreaPorId():
    if request.vars:
        idArea = request.vars.id
        #setor = db(Setor.id == idSetor).select()
        area = db.executesql("SELECT a.id, a.setor as idsetor, s.numero as setor, a.coordenador as idcoordenador, au.first_name as coordenador FROM area as s INNER JOIN auth_user as au on au.id = s.coordenador INNER JOIN setor as s on s.id=a.setor WHERE s.id = %s" %idSetor, as_dict=True)
        from gluon.serializers import json
        return XML(json(setor))
Ejemplo n.º 36
0
def jqgrid():
    from gluon.serializers import json
    import cgi
    hash_vars = 'dbname|tablename|columns|fieldname|fieldvalue|user'.split('|')
    if not URL.verify(request,hmac_key=auth.settings.hmac_key,
              hash_vars=hash_vars,salt=auth.user_id):
        raise HTTP(404)
    dbname = request.vars.dbname or 'db'
    tablename = request.vars.tablename or error()
    columns = (request.vars.columns or error()).split(',')
    rows=int(request.vars.rows or 25)
    page=int(request.vars.page or 0)
    sidx=request.vars.sidx or 'id'
    sord=request.vars.sord or 'asc'
    searchField=request.vars.searchField
    searchString=request.vars.searchString
    searchOper={'eq':lambda a,b: a==b,
                'nq':lambda a,b: a!=b,
                'gt':lambda a,b: a>b,
                'ge':lambda a,b: a>=b,
                'lt':lambda a,b: a<b,
                'le':lambda a,b: a<=b,
                'bw':lambda a,b: a.startswith(b),
                'bn':lambda a,b: ~a.startswith(b),
                'ew':lambda a,b: a.endswith(b),
                'en':lambda a,b: ~a.endswith(b),
                'cn':lambda a,b: a.contains(b),
                'nc':lambda a,b: ~a.contains(b),
                'in':lambda a,b: a.belongs(b.split()),
                'ni':lambda a,b: ~a.belongs(b.split())}\
                [request.vars.searchOper or 'eq']
    table=globals()[dbname][tablename]
    if request.vars.fieldname:
        names = request.vars.fieldname.split('|')
        values = request.vars.fieldvalue.split('|')
        query = reduce(lambda a,b:a&b,
                       [table[names[i]]==values[i] for i in range(len(names))])
    else:
        query = table.id>0
    dbset = table._db(query)
    if searchField: dbset=dbset(searchOper(table[searchField],searchString))
    orderby = table[sidx]
    if sord=='desc': orderby=~orderby
    limitby=(rows*(page-1),rows*page)
    fields = [table[f] for f in columns]
    records = dbset.select(orderby=orderby,limitby=limitby,*fields)
    nrecords = dbset.count()
    items = {}
    items['page']=page
    items['total']=int((nrecords+(rows-1))/rows)
    items['records']=nrecords
    readable_fields=[f.name for f in fields if f.readable]
    def f(value,fieldname):
        r = table[fieldname].represent
        if r: value=r(value)
        try: return value.xml()
        except: return cgi.escape(str(value))
    items['rows']=[{'id':r.id,'cell':[f(r[x],x) for x in readable_fields]} \
                       for r in records]
    return json(items)
Ejemplo n.º 37
0
def listaSetores():
    #setores = db(Setor.id > 0).select()
    setores = db.executesql(
        "SELECT s.id, s.numero, s.coordenador as idcoordenador, au.first_name as coordenador FROM setor as s INNER JOIN auth_user as au on au.id = s.coordenador",
        as_dict=True)
    from gluon.serializers import json
    return XML(json(setores))
Ejemplo n.º 38
0
def extract_examles():
    """Извлечение примеров из словаря"""
    db = current.db
    slovar = db.slovar
    i,j,k,l=0,0,0,0
    rows=db((slovar.is_example==False)&(slovar.processed==False))
    n=rows.count()
    for x in rows.iterselect(slovar.id,slovar.perevod):
        i+=1
        updated,inserted=extract_save_examples(x.perevod, x.id)
        j+=updated+inserted
        k+=updated
        l+=inserted
        msg=json(
                dict(id=x.id,
                     progress=round(float(i)/n*100, 2),
                     founded=j,
                     updated=k,
                     inserted=l
                    ))
        current.W2P_TASK.logger.write('!clear!%s'%msg)
        x.processed=True
        x.update_record()
        # if j%10000==0:db.commit() # Фиксируем каждые 10000 обновлений
        db.commit()
    return "Complite"

# from bkrstools import extract

# def extract_save_examples(perevod,id=None):
    """Извлечение и сохранение примеров из перевода"""
    """slovar=current.slovar
Ejemplo n.º 39
0
def createlinks():
    """Создание ссылок между записями словарных статей"""
    db = current.db
    slovar = db.slovar
    reg_ref=re.compile(r"\[ref\](.*?)\[/ref\]")
    i,j=0,0
    n=db(slovar.id>0).count()
    for x in db(slovar.id>0).iterselect():
        i+=1
        for slovlnk in reg_ref.findall(x.perevod):
            row=db(slovar.slovo==slovlnk).select().first()
            if row==None:continue

            tolist=x.linksto if x.linksto!=None else []
            if row.id not in tolist:
                tolist.append(row.id)
                x.update_record(linksto=tolist)

            fromlist=row.linksfrom if row.linksfrom!=None else []
            if x.id not in fromlist:
                fromlist.append(x.id)
                row.update_record(linksfrom=fromlist)
            j+=1
        if j%1000==0:
            db.commit() # Фиксируем каждые 1000 вставок

        msg=json(
                dict(founded=j,
                     progress=round(float(i)/n*100, 2)
                    ))
        current.W2P_TASK.logger.write('!clear!%s'%msg)
    db.commit()
    return "Complite"
Ejemplo n.º 40
0
 def f(_action=action, *a, **b):
     request.is_restful = True
     env = request.env
     is_json = env.content_type == 'application/json'
     method = env.request_method
     if len(request.args) and '.' in request.args[-1]:
         request.args[-1], _, request.extension = request.args[
             -1].rpartition('.')
         current.response.headers['Content-Type'] = \
             contenttype('.' + request.extension.lower())
     rest_action = _action().get(method, None)
     if not (rest_action and method == method.upper()
             and callable(rest_action)):
         raise HTTP(405, "method not allowed")
     try:
         res = rest_action(*request.args, **request.vars)
         if is_json and not isinstance(res, str):
             res = json(res)
         return res
     except TypeError, e:
         exc_type, exc_value, exc_traceback = sys.exc_info()
         if len(traceback.extract_tb(exc_traceback)) == 1:
             raise HTTP(400, "invalid arguments")
         else:
             raise
Ejemplo n.º 41
0
def sozdanie_bazy(file, truncate=False):
    """Заполнение базы из файла словаря в формате DSL."""
    if not os.path.exists(file): file=os.path.normpath(os.path.join(current.request.folder, file))
    if not os.path.exists(file): return "Файл не найден"
    # convertfile(file)#Пересохраняем в utf-8
    db = current.db
    slovar = db.slovar
    if truncate:slovar.truncate()#Опустошаем таблицу базы данных, если надо
    inserted, updated = 0, 0  #Счетчик вставленных и обновленных записей в базе данных
    parser = dsl_parser(r"(?m)^([^\s].*?)\n\s(.*?)\n\s(.*?)$")
    for blocktext, progress in read_by_blocks(file):
        for slovo, pinyin, perevod in parser.send(blocktext):
            try:
                slovar.insert(slovo = slovo,
                              pinyin = pinyin,
                              perevod = perevod
                             )
                inserted+=1
            except:
                db.commit()
                row=db(slovar.slovo == slovo).select().first()
                if not row:
                    continue
                row.pinyin = pinyin
                row.perevod = perevod
                row.update_record()
                updated += 1
        if inserted%5000==0:
            db.commit()
            msg=dict(inserted=inserted, updated=updated, progress=progress)
            current.W2P_TASK.logger.write('!clear!%s'%json(msg))
    parser.close()
    db.commit()
Ejemplo n.º 42
0
 def f(_action=action, *a, **b):
     request.is_restful = True
     env = request.env
     is_json = env.content_type == "application/json"
     method = env.request_method
     if len(request.args) and "." in request.args[-1]:
         request.args[-1], _, request.extension = request.args[-1].rpartition(".")
         current.response.headers["Content-Type"] = contenttype("." + request.extension.lower())
     rest_action = _action().get(method, None)
     if not (rest_action and method == method.upper() and callable(rest_action)):
         raise HTTP(405, "method not allowed")
     try:
         vars = request.vars
         if method == "POST" and is_json:
             body = request.body.read()
             if len(body):
                 vars = sj.loads(body)
         res = rest_action(*request.args, **vars)
         if is_json and not isinstance(res, str):
             res = json(res)
         return res
     except TypeError, e:
         exc_type, exc_value, exc_traceback = sys.exc_info()
         if len(traceback.extract_tb(exc_traceback)) == 1:
             raise HTTP(400, "invalid arguments")
         else:
             raise
Ejemplo n.º 43
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
Ejemplo n.º 44
0
def jqgrid():
    """
    jqgrid callback retrieves records
    http://trirand.com/blog/jqgrid/server.php?q=1&_search=false&nd=1267835445772&rows=10&page=1&sidx=amount&sord=asc&searchField=&searchString=&searchOper=
    """
    from gluon.serializers import json
    import cgi
    tablename = request.vars.tablename or error()
    columns = (request.vars.columns or error()).split(',')
    rows=int(request.vars.rows or 25)
    page=int(request.vars.page or 0)
    sidx=request.vars.sidx or 'id'
    sord=request.vars.sord or 'asc'
    searchField=request.vars.searchField
    searchString=request.vars.searchString
    searchOper={'eq':lambda a,b: a==b,
                'nq':lambda a,b: a!=b,
                'gt':lambda a,b: a>b,
                'ge':lambda a,b: a>=b,
                'lt':lambda a,b: a<b,
                'le':lambda a,b: a<=b,
                'bw':lambda a,b: a.like(b+'%'),
                'bn':lambda a,b: ~a.like(b+'%'),
                'ew':lambda a,b: a.like('%'+b),
                'en':lambda a,b: ~a.like('%'+b),
                'cn':lambda a,b: a.like('%'+b+'%'),
                'nc':lambda a,b: ~a.like('%'+b+'%'),
                'in':lambda a,b: a.belongs(b.split()),
                'ni':lambda a,b: ~a.belongs(b.split())}\
                [request.vars.searchOper or 'eq']
    table=db[tablename]
    if request.vars.fieldname:
        names = request.vars.fieldname.split('|')
        values = request.vars.fieldvalue.split('|')
        query = reduce(lambda a,b:a&b,
                       [table[names[i]]==values[i] for i in range(len(names))])
    else:
        query = table.id>0
    dbset = table._db(query)
    if searchField: dbset=dbset(searchOper(table[searchField],searchString))
    orderby = table[sidx]
    if sord=='desc': orderby=~orderby
    limitby=(rows*(page-1),rows*page)
    fields = [table[f] for f in columns]
    records = dbset.select(orderby=orderby,limitby=limitby,*fields)
    nrecords = dbset.count()
    items = {}
    items['page']=page
    items['total']=int((nrecords+(rows-1))/rows)
    items['records']=nrecords
    readable_fields=[f.name for f in fields if f.readable]
    def f(value,fieldname):
        r = table[fieldname].represent
        if r: value=r(value)
        try: return value.xml()
        except: return cgi.escape(str(value))
    items['rows']=[{'id':r.id,'cell':[f(r[x],x) for x in readable_fields]} \
                       for r in records]
    return json(items)
Ejemplo n.º 45
0
def jqgrid():
    """
    jqgrid callback retrieves records
    http://trirand.com/blog/jqgrid/server.php?q=1&_search=false&nd=1267835445772&rows=10&page=1&sidx=amount&sord=asc&searchField=&searchString=&searchOper=
    """
    from gluon.serializers import json
    import cgi
    tablename = request.vars.tablename or error()
    columns = (request.vars.columns or error()).split(',')
    rows = int(request.vars.rows or 25)
    page = int(request.vars.page or 0)
    sidx = request.vars.sidx or 'id'
    sord = request.vars.sord or 'asc'
    searchField = request.vars.searchField
    searchString = request.vars.searchString
    searchOper={'eq':lambda a,b: a==b,
                'nq':lambda a,b: a!=b,
                'gt':lambda a,b: a>b,
                'ge':lambda a,b: a>=b,
                'lt':lambda a,b: a<b,
                'le':lambda a,b: a<=b,
                'bw':lambda a,b: a.like(b+'%'),
                'bn':lambda a,b: ~a.like(b+'%'),
                'ew':lambda a,b: a.like('%'+b),
                'en':lambda a,b: ~a.like('%'+b),
                'cn':lambda a,b: a.like('%'+b+'%'),
                'nc':lambda a,b: ~a.like('%'+b+'%'),
                'in':lambda a,b: a.belongs(b.split()),
                'ni':lambda a,b: ~a.belongs(b.split())}\
                [request.vars.searchOper or 'eq']
    table = db[tablename]
    if request.vars.fieldname:
        dbset = table._db(
            table[request.vars.fieldname] == request.vars.fieldvalue)
    else:
        dbset = table._db(table.id > 0)
    if searchField: dbset = dbset(searchOper(table[searchField], searchString))
    orderby = table[sidx]
    if sord == 'desc': orderby = ~orderby
    limitby = (rows * (page - 1), rows * page)
    fields = [table[f] for f in columns]
    records = dbset.select(orderby=orderby, limitby=limitby, *fields)
    nrecords = dbset.count()
    items = {}
    items['page'] = page
    items['total'] = int((nrecords + (rows - 1)) / rows)
    items['records'] = nrecords
    readable_fields = [f.name for f in fields if f.readable]

    def f(value, fieldname):
        r = table[fieldname].represent
        if r: value = r(value)
        try:
            return value.xml()
        except:
            return cgi.escape(str(value))
    items['rows']=[{'id':r.id,'cell':[f(r[x],x) for x in readable_fields]} \
                       for r in records]
    return json(items)
Ejemplo n.º 46
0
def _serialize(data):
    if request.extension == 'json':
        return XML(json(data))
    elif request.extension == 'xml':
        return XML(xml(data))

    # use the html view
    return data
Ejemplo n.º 47
0
def find_matching_subdir(base, hint):
    session.forget(response)
    topdirs = [name for name in os.listdir(base) if os.path.isdir(os.path.join(base, name))]
    res = []
    for a in topdirs:
        if a.startswith(hint):
            res.append(os.path.join(base, a, ''))
    return json(res)
Ejemplo n.º 48
0
def overview():
    if request.args(0) not in INSTANCE_VALID_ARG:
        non_valid_instance()
    curr_env = {
        'base_url': URL('console', 'overview'),
    }

    return dict(curr_env=json(curr_env))
Ejemplo n.º 49
0
def message_new(db):
    name = current.session.auth.user.first_name

    body = current.request.vars.body
    msg = _create_message(db, name, body)

    new_message_event.set()
    new_message_event.clear()
    return json(msg)
Ejemplo n.º 50
0
 def _notify_clients(self, message, group='default'):
     try:
         websocket_send("http://%s:%s" % (self.host, self.port), json(message), self.password, group)
     except IOError as e:
         if self.verbose:
             print("{notifier}: Unable to notify clients \"{exception}\". "
                   "The server is up and running? Follow the instructions "
                   "at \"gluon/contrib/websocket_messaging.py\"".format(notifier=self.__class__.__name__,
                                                                        exception=e.strerror))
Ejemplo n.º 51
0
    def aadata(self, totalrows, displayrows, id, sEcho, flist, stringify=True, action_col=None, **attr):
        """
            Method to render the data into a json object

            @param totalrows: The total rows in the unfiltered query.
            @param displayrows: The total rows in the filtered query.
            @param id: The id of the table for which this ajax call will
                       respond to.
            @param sEcho: An unaltered copy of sEcho sent from the client used
                          by dataTables as a draw count.
            @param flist: The list of fields
            @param attr: dictionary of attributes which can be passed in
                   dt_action_col: The column where the action buttons will be placed
                   dt_bulk_actions: list of labels for the bulk actions.
                   dt_bulk_col: The column in which the checkboxes will appear,
                                by default it will be the column immediately
                                before the first data item
                   dt_group_totals: The number of record in each group.
                                    This will be displayed in parenthesis
                                    after the group title.
        """

        data = self.data
        if not flist:
            flist = self.lfields
        start = self.start
        end = self.end
        if action_col is None:
            action_col = attr.get("dt_action_col", 0)
        structure = {}
        aadata = []
        for i in xrange(start, end):
            row = data[i]
            details = []
            for field in flist:
                if field == "BULK":
                    details.append(
                        "<INPUT id='select%s' type='checkbox' class='bulkcheckbox'>" % row[flist[action_col]]
                    )
                else:
                    details.append(s3_unicode(row[field]))
            aadata.append(details)
        structure["dataTable_id"] = id
        structure["dataTable_filter"] = self.filterString
        structure["dataTable_groupTotals"] = attr.get("dt_group_totals", [])
        structure["dataTable_sort"] = self.orderby
        structure["aaData"] = aadata
        structure["iTotalRecords"] = totalrows
        structure["iTotalDisplayRecords"] = displayrows
        structure["sEcho"] = sEcho
        if stringify:
            from gluon.serializers import json

            return json(structure)
        else:
            return structure
Ejemplo n.º 52
0
def post():
    if request.extension=='json' and 'X-Progress-ID' in request.get_vars:
        cache_key = 'X-Progress-ID:'+request.get_vars['X-Progress-ID']
        length=cache.ram(cache_key+':length', lambda: 0, None)
        uploaded=cache.ram(cache_key+':uploaded', lambda: 0, None)
        from gluon.serializers import json
        return json(dict(length=length, uploaded=uploaded))
    form = FORM(INPUT(_type='file', _name='file',requires=IS_NOT_EMPTY()),
                INPUT(_type='submit', _value='SUBMIT'))
    return dict(form=form, myuuid = "1234567890abcdefgh")
Ejemplo n.º 53
0
def email():
	if session.Username:
		for user in db(db.EmailIds.Username == session.Username).select():
			ctr = 1
			if user['EID2']:
				ctr = ctr + 1
			if user['EID3']:
				ctr = ctr + 1
			if user['EID4']:
				ctr = ctr + 1
			if user['EID5']:
				ctr = ctr + 1
			emailids = []
			unreads = []
			unread_messages = []
			for i in range(ctr):
				i = i + 1
				emailid = 'EID' + str(i)
				pwdid = 'Pass' + str(i)
				eid = user[emailid]
				pwd = user[pwdid]
				emailids.append(eid)
				with MailBox(eid,pwd) as mbox:
					unread = mbox.get_count()
					#x = 'unread' + str(i)
					unreads.append(unread)
					unread_msg_ids = mbox.get_msg_ids()
					unread_msgs = []
					#print unread_msg_ids
					if unread_msg_ids != []:
						ctr2 = 0
						for i in unread_msg_ids:
							ctr2 = ctr2 + 1
							if ctr2 == 11:
								break
							unread_msg = get_msg(eid,pwd,unread,i)
							unread_msgs.append(unread_msg)
					#y = 'unread_msgs' + str(i)
					unread_messages.append(unread_msgs)
			return dict(ctr=ctr,emailids=json(emailids),unreads=json(unreads),unread_messages=json(unread_messages))
		#return dict(unread1=unread1,unread_msg_ids=json(unread_msg_ids))
	else:
		redirect(URL('login'))
Ejemplo n.º 54
0
def get_chart1_data_json():
    '''
    Wrapper for get_chart1_data() to allow getting a json-formatted return val.

    '''
    user_id = request.vars['user_id'] if 'user_id' in request.vars else auth.user_id
    set = request.vars['set'] if 'set' in request.vars else None
    tag = request.vars['tag'] if 'tag' in request.vars else None
    chart1_data = get_chart1_data(user_id=user_id, set=set, tag=tag)
    return json(chart1_data['chart1_data'])
Ejemplo n.º 55
0
def result():
	data = db(db.current_builds.BuildId == request.vars.buildId).select().first()

	# if the data is not available throw an error
	if data == None:
		errorObject = {'message': T('Build ID does not exist')}
		raise HTTP(422, json(errorObject))

	# if data is available and the build has finsihed return the outputs
	if data.finished:
		out = dict(finished=data.finished, output=data.output, error=data.error)
		
		if data.buildError:
			raise HTTP(500, XML(json(out)))

		return out

	# if data is available and the build is still running tell the client to wait
	else:
		return dict(finished=data.finished, timeout=CLIENT_TIMEOUT)