def _UpdateEntities(kind, master, bot, start_cursor=None):
    """Update `internal_only` flags of `kind` entities to match their Bot.
  """
    datastore_hooks.SetPrivilegedRequest()
    internal_only = graph_data.Bot.GetInternalOnlySync(master, bot)

    query = ndb.Query(kind=kind).filter(
        ndb.GenericProperty('master_name') == master,
        ndb.GenericProperty('bot_name') == bot,
        ndb.GenericProperty('internal_only') == (not internal_only))
    entities, next_cursor, more = query.fetch_page(PAGE_LIMIT,
                                                   start_cursor=start_cursor)
    for entity in entities:
        entity.internal_only = internal_only
    ndb.put_multi(entities)

    logging.info('updated %d entities', len(entities))
    if more and next_cursor:
        logging.info('continuing')
        deferred.defer(_UpdateEntities,
                       kind,
                       master,
                       bot,
                       next_cursor,
                       _queue=QUEUE_NAME)
    else:
        logging.info('complete')
    def get(self, **kwargs):

        check = self.request.get('check', default_value=None)
        uName = self.request.get('username', default_value=None)
        pWord = self.request.get('password', default_value=None)

        #Checks for JSON
        if 'application/json' not in self.request.accept:
            self.response.status = 406
            self.response.status_message = "Error, this API requires JSON objects"
            return

        #Writes the contents of that user id to the page
        if 'id' in kwargs:
            out = ndb.Key(db.User, int(kwargs['id'])).get().to_dict()
            self.response.write(json.dumps(out))

        if check:
            q = db.User.query(ndb.GenericProperty('password') == pWord)
            #q = db.User.filter(ndb.GenericProperty('username') == uName)
            result = q.get(keys_only=True)
            self.response.write(result.id())

        #otherwise, if no id is specified, all users will be listed
        else:
            q = db.User.query(ndb.GenericProperty('password') == pWord)
            #q = db.User.query(ndb.GenericProperty('username') == uName)
            result = q.get(keys_only=True)
            out = ndb.Key(db.User, result.id()).get().to_dict()
            self.response.write(json.dumps(out))
Example #3
0
    def filter_queryset(self):
        """
        Default queryset filter. List all model properties and compare to query params.
        All intersected attributes are applied ad filters on the queryset
        """
        if not self.query_params:
            return self.queryset

        _model = get_model_class_from_query(self.queryset)
        fields = get_model_fields(_model)
        queryset = self.get_queryset()

        for field_name, field_class in fields:
            if field_name in self.query_params:
                filter_value = self.query_params[field_name]
                if field_class == KeyProperty:
                    _key = get_key_from_urlsafe(filter_value)
                    queryset = queryset.filter(
                        ndb.GenericProperty(field_name) == _key)
                else:
                    """
                    We use the property serializer to be able to make the filter with the good type.
                    For instance if we want to filter an IntergerProperty, the self.query_params, will
                    have only string values. We need to use the serializer to cast the param to the
                    good type.
                    """
                    filter_value = TYPE_MAPPING[field_class.__name__](
                        data=filter_value).data
                    queryset = queryset.filter(
                        ndb.GenericProperty(field_name) == filter_value)

        return queryset
Example #4
0
    def post(self):

        form_usu = cgi.escape(self.request.get('usuario'))
        form_clave = cgi.escape(self.request.get('password'))

        usuarios = Usuario.query().filter(
            ndb.GenericProperty('usuario') == form_usu).fetch(1)
        if usuarios:
            for element in usuarios:
                if element.usuario == form_usu:
                    n_hash = MD5.new(form_clave).hexdigest()

                    if element.clave == n_hash:

                        val_template = {'url': '', 'nombre': ''}
                        list_val = []
                        dict_permisos = {'permisos': []}
                        permisos = Profile.query().filter(
                            ndb.GenericProperty('usuario') == form_usu).fetch(
                                1)
                        if permisos:
                            for permiso in permisos:
                                if permiso.operaciones == True:
                                    val_template = {'url': '', 'nombre': ''}
                                    val_template[
                                        'url'] = '/operaciones?usuario=' + form_usu
                                    val_template['nombre'] = 'operaciones'
                                    list_val.append(val_template)

                                if permiso.reportes == True:
                                    val_template = {'url': '', 'nombre': ''}
                                    val_template[
                                        'url'] = '/reportes?usuario=' + form_usu
                                    val_template['nombre'] = 'reportes'
                                    list_val.append(val_template)

                                if permiso.inventario == True:
                                    val_template = {'url': '', 'nombre': ''}
                                    val_template[
                                        'url'] = '/inventario?usuario=' + form_usu
                                    val_template['nombre'] = 'inventario'
                                    list_val.append(val_template)

                                logging.info('lista: %s', list_val)
                                dict_permisos['permisos'] = list_val

                        template = jinja_environment.get_template(
                            'pagina0.html')

                        self.response.out.write(template.render(dict_permisos))
                        #self.response.out.write(template.render(c))
                    else:
                        self.printmensaje('index.html', 'Clave incorrecta')
                else:
                    self.printmensaje('index.html', 'Usuario no existe')
        else:
            self.printmensaje('index.html', 'Usuario no existe')
Example #5
0
def __order_query(order_json, query):
    for order in order_json:
        order_direction = order['direction']
        order_field = order['field']

        if order_direction == 'ASC':
            query = query.order(ndb.GenericProperty(order_field))
        else:
            query = query.order(-ndb.GenericProperty(order_field))

    return query
Example #6
0
class MyAudit(ndb.Model):
	# when
	created_time=ndb.DateTimeProperty(auto_now_add=True)
	# by whome
	owner=ndb.KeyProperty(kind='Contact')
	# field name
	field_name=ndb.StringProperty(required=True)
	# old value
	old_value=ndb.GenericProperty()
	# new value
	new_value=ndb.GenericProperty()
Example #7
0
  def get(self):
    user_email = self.request.get('email').lower()
    logging.info("AddUserAsFriend "+user_email)
    user = User.query(ndb.GenericProperty('email_address') == user_email).get()
    if not user:
          user = User.query(ndb.GenericProperty('email_address') == user_email).get()

    if user.get_id() == self.user_id:
      self.response.out.write("EMAIL TO SELF")
      return
    if user:
      InviteInternal.add_invite(self.user_id, user.key.id())
      self.response.out.write("FOUND")
    else:
      self.response.out.write("NOT FOUND")
Example #8
0
class Stream(ndb.Model):
    """A main model for representing an individual Stream entry."""
    author = ndb.StructuredProperty(Author)
    name = ndb.StringProperty()
    subscribers = ndb.GenericProperty(repeated=True)
    cover_url = ndb.StringProperty(indexed=False)
    tags = ndb.GenericProperty(repeated=True)
    view_count = ndb.IntegerProperty(indexed=False)
    last_date = ndb.DateProperty()
    photos = ndb.StructuredProperty(Photo, repeated=True)
    photos_original = ndb.StructuredProperty(Photo, repeated=True)
    photos2 = ndb.StructuredProperty(Photo, repeated=True)
    view_history = ndb.DateTimeProperty(repeated=True)
    history_len = ndb.ComputedProperty(lambda self: len(self.view_history))
    create_time = ndb.DateTimeProperty(auto_now_add=True)
Example #9
0
    def _getSessionQuery(self, request, ancestor=None, required_fields=[]):
        """Return formatted query from the submitted filters."""
        if ancestor:
            q = Session.query(ancestor=ancestor)
        else:
            q = Session.query()

        inequality_filter, filters = self._formatFilters(
            request.filters, SESSION_FIELDS, OPERATORS)
        # all required_fields must appear in filters field
        included_fields = [f['field'] for f in filters]
        missing_fields = [
            rf for rf in required_fields if rf not in included_fields
        ]
        if missing_fields:
            raise endpoints.BadRequestException("Session '%s' field required" %
                                                "', '".join(missing_fields))

        # If exists, sort on inequality filter first
        if inequality_filter:
            q = q.order(ndb.GenericProperty(inequality_filter))
        q = q.order(Session.name)

        for filtr in filters:
            if filtr["field"] in ["duration"]:
                filtr["value"] = int(filtr["value"])
            elif filtr["field"] in ["highlights"]:
                filtr["value"] = str(filtr["value"]).lower() == 'true'
            formatted_query = ndb.query.FilterNode(filtr["field"],
                                                   filtr["operator"],
                                                   filtr["value"])
            q = q.filter(formatted_query)
        return q
Example #10
0
def GetTestDescendantsAsync(test_key,
                            has_rows=None,
                            deprecated=None,
                            keys_only=True):
    """Returns all the tests which are subtests of the test with the given key.

  Args:
    test_key: The key of the TestMetadata entity to get descendants of.
    has_rows: If set, filter the query for this value of has_rows.
    deprecated: If set, filter the query for this value of deprecated.

  Returns:
    A future for a list of keys of all descendants of the given test.
  """
    test_parts = utils.TestPath(test_key).split('/')
    query_parts = [
        ('master_name', test_parts[0]),
        ('bot_name', test_parts[1]),
        ('suite_name', test_parts[2]),
    ]
    for index, part in enumerate(test_parts[3:]):
        query_parts.append(('test_part%d_name' % (index + 1), part))
    query = graph_data.TestMetadata.query()
    for part in query_parts:
        query = query.filter(ndb.GenericProperty(part[0]) == part[1])
    if has_rows is not None:
        query = query.filter(graph_data.TestMetadata.has_rows == has_rows)
    if deprecated is not None:
        query = query.filter(graph_data.TestMetadata.deprecated == deprecated)
    futures = query.fetch_async(keys_only=keys_only)
    return futures
Example #11
0
    def get(self, source_short_name, id):
        if source_short_name == 'googleplus':
            # turned off in march 2019: https://github.com/snarfed/bridgy/issues/846
            self.source = None
            self.response.status_int = 404
            return super(UserHandler, self).get()

        cls = models.sources[source_short_name]
        self.source = cls.lookup(id)

        if not self.source:
            id = urllib.unquote(id).decode('utf-8')
            key = cls.query(
                ndb.OR(*[
                    ndb.GenericProperty(prop) == id for prop in 'domains',
                    'inferred_username', 'name', 'username'
                ])).get(keys_only=True)
            if key:
                return self.redirect(cls(key=key).bridgy_path(),
                                     permanent=True)

        if self.source and self.source.features:
            self.source.verify()
            self.source = self.preprocess_source(self.source)
        else:
            self.response.status_int = 404
        super(UserHandler, self).get()
Example #12
0
    def get(self):
        dNow = datetime.now()
        sNM = dNow.month
        sNY = dNow.year
        sNum = (sNY - BASE_SESSION_YEAR) * 3 + mapYear(sNM) + 1

        candidate_query = Feedback.query(
            ndb.GenericProperty('cycle') == int(sNum))
        candidates = candidate_query.fetch(keys_only=True)

        cycles = []
        for c in candidates:
            if c.parent() not in cycles:
                cycles.append(c.parent())

        candidates = cycles

        interviewer_query = Interviewer.query().order(Interviewer.last_name)
        interviewers = interviewer_query.fetch()

        template_values = {
            'candidates': candidates,
            'interviewers': interviewers,
        }

        template = JINJA_ENVIRONMENT.get_template('index.html')
        self.response.write(template.render(template_values))
    def _getQuerySession(self, request):
        """Return formatted query from the submitted filters."""
        q = Session.query()
        inequality_filter, filters = self._formatFilters(request.filters,
                                                         type='Session')

        # If exists, sort on inequality filter first
        if not inequality_filter:
            q = q.order(Session.name)
        else:
            q = q.order(ndb.GenericProperty(inequality_filter))
            q = q.order(Session.name)

        for filtr in filters:
            if filtr["field"] in ["duration"]:
                filtr["value"] = int(filtr["value"])
            elif filtr["field"] in ["startTime"]:
                filtr["value"] = datetime.datetime.strptime(
                    "1970-01-01" + ' ' + filtr['value'][:], "%Y-%m-%d %H:%M")

            formatted_query = ndb.query.FilterNode(filtr["field"],
                                                   filtr["operator"],
                                                   filtr["value"])
            q = q.filter(formatted_query)

        return q
Example #14
0
 def post(self):
     usuario = cgi.escape(self.request.get('login_usuario'))
     password = cgi.escape(self.request.get('login_password'))
     
     
     if (len(usuario) > 0) and (len(password) > 0):
         usuarios = Usuario.query().filter(ndb.GenericProperty('usuario') == usuario).fetch(1) 
         if usuarios:              
             for element in usuarios:                    
                 if element.usuario == usuario:                        
                     n_hash = MD5.new(password).hexdigest()                       
                     if element.clave == n_hash:                           
                         if element.rol == 'rol02' or element.rol == 'rol03':
                             #ojo al llenado al reves           
                             ckb1 = cgi.escape(self.request.get('ckb3'))
                             ckb2 = cgi.escape(self.request.get('ckb2'))
                             ckb3 = cgi.escape(self.request.get('ckb1'))
                                                             
                             valopciones = {'val1':str(ckb1), 'val2': str(ckb2), 'val3': str(ckb3) }
                             opciones = self.setnewopciones(valopciones)
                             if self.updateprofile(usuario, opciones):
                                 self.printmensaje('t_adm_respuesta_rol.html','Actualizacion correcta')
                             else:
                                 self.printmensaje('t_adm_respuesta_rol.html','Existen problemas para actualizar los datos')
                         else:                                
                             self.printmensaje(destino_login,'su usuario no tiene permisos en esta seccion')
                     else:                            
                         self.printmensaje(destino_login,'clave incorrecta')
                 else:                        
                     self.printmensaje(destino_login,'usuario no registrado')
         else:                
             self.printmensaje(destino_login,'usuario no existe')
Example #15
0
    def _getSessionQuery(self, request, ancestor=None):
        """Return formatted query from the submitted filter"""
        if not ancestor:
            q = Session.query()
        else:
            a_key = ancestor
            q = Session.query(ancestor=ndb.Key(urlsafe=a_key))

        inequality_filter, filters = self._formatFilters(request.filters)

        # If exists, sort on inequality filter first
        if not inequality_filter:
            q = q.order(Session.name)
        else:
            q = q.order(ndb.GenericProperty(inequality_filter))
            q = q.order(Session.name)

        for filtr in filters:
            if filtr["field"] in ["duration"]:
                filtr["value"] = int(filtr["value"])
            formatted_query = ndb.query.FilterNode(filtr["field"],
                                                   filtr["operator"],
                                                   filtr["value"])
            q = q.filter(formatted_query)
        return q
Example #16
0
class Invitation(ndb.Model):
    invitor = ndb.KeyProperty(kind=Student)
    invitee = ndb.KeyProperty(kind=Student)
    assignment_number = ndb.IntegerProperty()
    active = ndb.GenericProperty()
    accepted = ndb.BooleanProperty(default=False)
    created = ndb.DateTimeProperty(auto_now_add=True)
    def get(self, id, pair_no):
        ''' Returns the opaque pair ID for pair with pair nubmer pair_no in this
        Tournament.

        Args: 
          id: Tournament ID for this tournament.
          pair_no: The pair number whose ID has to be looked up.
    '''
        if not is_int(pair_no):
            SetErrorStatus(
                self.response, 404, "Invalid Pair Number",
                "Pair number must be an integer, was {}".format(pair_no))
            return

        tourney = GetTourneyWithIdAndMaybeReturnStatus(self.response, id)
        if not tourney:
            return

        if not CheckUserOwnsTournamentAndMaybeReturnStatus(
                self.response, users.get_current_user(), tourney):
            return
        player_pairs = PlayerPair._query(
            ndb.GenericProperty('pair_no') == int(pair_no),
            ancestor=tourney.key).fetch(1, projection=[PlayerPair.id])
        if not player_pairs:
            SetErrorStatus(
                self.response, 404, "Invalid Id",
                "Pair pair number {} does not exist in this " +
                "tournament".format(pair_no))
            return
        self.response.headers['Content-Type'] = 'application/json'
        self.response.set_status(200)
        self.response.out.write(
            json.dumps({'pair_id': player_pairs[0].id}, indent=2))
Example #18
0
File: member.py Project: bklang/GO2
def search_for_members(order=True,
                       keys_only=False,
                       verified_only=False,
                       pagelen=0,
                       page=0,
                       search=None):
    """ Return all member objects """

    args = []
    if verified_only:
        args = [ndb.GenericProperty('verified') == True]

    if search:
        args.append(ndb.StringProperty('local_email_address') == search)

    # print('\n\n{0}\n\n'.format(*args))

    if order:
        member_query = Member.lquery(*args).order(Member.lower_name)
    else:
        member_query = Member.lquery(*args)

    if pagelen == 0:
        members = member_query.fetch(keys_only=keys_only)
    else:
        members = member_query.fetch(keys_only=keys_only,
                                     offset=page * pagelen,
                                     limit=pagelen)

    return members
Example #19
0
    def get_query(self,
                  filters,
                  order_by_field='name',
                  websafe_conference_key=None):
        """Return formatted query from the submitted filters."""
        if websafe_conference_key:
            query = self.kind.query(
                self.kind.websafeConferenceKey == websafe_conference_key)
        else:
            query = self.kind.query()

        inequality_filter, filters = self.format_filters(filters)

        # If exists, sort on inequality filter first
        if not inequality_filter:
            query = query.order(getattr(self.kind, order_by_field))
        else:
            query = query.order(ndb.GenericProperty(inequality_filter))
            query = query.order(getattr(self.kind, order_by_field))

        for filtr in filters:
            if filtr["field"] in self.int_values:
                filtr["value"] = int(filtr["value"])
            if filtr["field"] in self.date_values:
                filtr["value"] = datetime.strptime(filtr["value"],
                                                   "%Y-%m-%d").date()
            formatted_query = ndb.query.FilterNode(filtr["field"],
                                                   filtr["operator"],
                                                   filtr["value"])
            query = query.filter(formatted_query)
        return query
Example #20
0
 def admin_exists(cls):
     '''
     Returns True if an admin user already exists in the DB, else False.
     '''
     admin = User.query().filter(
         ndb.GenericProperty('is_admin') == 'YES').get()
     return admin is not None
Example #21
0
    def _getSessionQuery(self, request):
        """Return formatted query from the submitted filters."""
        q = Session.query()
        inequality_filter, filters = self._formatFilters(request.filters, SESSION_FIELDS)

        # If exists, sort on inequality filter first
        if not inequality_filter:
            q = q.order(Session.name)
        else:
            q = q.order(ndb.GenericProperty(inequality_filter))
            q = q.order(Session.name)

        for filtr in filters:
            if filtr["field"] == "startTime":
                testTime = datetime.strptime(filtr["value"], "%H:%M").time()
                # filtr["value"] = datetime.strptime(filtr["value"], "%H:%M").time()
                # formatted_query = ndb.query.FilterNode(Session.startTime._to_base_type, filtr["operator"], testTime)
                if filtr["operator"] == '=':
                    q = q.filter(Session.startTime == testTime)

                elif filtr["operator"] == '>=':
                    q = q.filter(Session.startTime >= testTime)

                elif filtr["operator"] == '<=':
                    q = q.filter(
                        ndb.AND(Session.startTime <= testTime),
                                (Session.startTime >= datetime.strptime("00:00", "%H:%M").time()))
                else:
                    raise endpoints.BadRequestException("Unsupported filter for time.")
            else:
                formatted_query = ndb.query.FilterNode(filtr["field"], filtr["operator"], filtr["value"])
                q = q.filter(formatted_query)
        return q
Example #22
0
  def list_devices(
      cls, enrolled=True, keys_only=False, page_size=100, next_cursor=None,
      **kwargs):
    """Returns a list of devices using given filters.

    Args:
      enrolled: bool, set True if only active devices should be queried,
          else False if only inactive.
      keys_only: bool, set True if only device keys should be returned.
      page_size: int, the number of devices to query for.
      next_cursor: datastore_query.Cursor, set when next page of results need to
          be queried.
      **kwargs: in which each kwarg name is the name of a Device property by
          which to filter the query, and its value is the filter value (str,
          int, etc.).

    Returns:
      A tuple consisting of a list of device keys, Cursor, and a bool.
    """
    # pylint: disable=g-explicit-bool-comparison
    query = cls.query(cls.enrolled == enrolled)
    # pylint: enable=g-explicit-bool-comparison
    for filters, filter_values in kwargs.items():
      if not isinstance(filter_values, (list, tuple)):
        filter_values = (filter_values,)
      for value in filter_values:
        query = query.filter(ndb.GenericProperty(filters) == value)
    return query.fetch_page(
        keys_only=keys_only, page_size=page_size, start_cursor=next_cursor)
Example #23
0
    def get(self, **kwargs):

        uName = self.request.get('username', default_value=None)
        pWord = self.request.get('password', default_value=None)

        #Checks for JSON
        if 'application/json' not in self.request.accept:
            self.response.status = 406
            self.response.status_message = "Error, this API requires JSON objects"
            return

        #Displays the contents of that score if an id is passed
        if 'id' in kwargs:
            out = ndb.Key(db.Score, int(kwargs['id'])).get().to_dict()
            self.response.write(json.dumps(out))

        if uName:
            q = db.Score.query(ndb.GenericProperty('password') == pWord)
            #q = db.Score.query(ndb.GenericProperty('username') == uName)
            result = q.get(keys_only=True)
            self.response.write(result.id())

        #Otherwise just displays the keys for all the scores
        else:
            q = db.Score.query()
            keys = q.fetch(keys_only=True)
            results = {'keys': [x.id() for x in keys]}
            self.response.write(json.dumps(results))
Example #24
0
    def post(self):
        term = self.request.get('content')
        valid_input = func.valid_input(term)
        # self.response.write("%s is a valid term: %s <br>" % (term, valid_input))
        is_url = func.is_url(term)
        if is_url:
            # Write to see what crawl_page returns
            #self.response.write(func.crawl_page(term))
            crawl = func.crawl_page(term)
            if crawl:
                url_term = WordLink()
                url_term.author = users.get_current_user()
                url_term.words = json.dumps(list(crawl))
                url_term.link = term

                url_term.put()
                self.response.write("%s is saved successfully!" % term)
            else:
                self.response.write("The URL %s was not searchable. \
                    Try again!" % term)

        else:  # It's a Query
            url_query = WordLink.query()
            url_words = url_query.filter(
                ndb.GenericProperty('author') ==
                users.get_current_user())  #fetch()
            #self.response.write("%s <br><br>" % term)

            self.response.write("%s <br>" % term)
            for entry in url_words:
                for word in json.loads(entry.words):
                    if word == str(term.lower().strip()):
                        self.response.write("<a href=%s>%s</a><br>" %
                                            (entry.link, entry.link))
                        break
Example #25
0
    def list(cls,
             question_type=None,
             enabled=True,
             page_size=100,
             next_cursor=None,
             **kwargs):
        """List all questions with filters.

    Args:
      question_type: QuestionType, The type of question to be queried for.
      enabled: bool, True to retrieve enabled surveys.
      page_size: int, The number of answers to return.
      next_cursor: datastore_query.Cursor, Next page of results.
      **kwargs: each kwarg name is the name of a Question property by
          which to filter the query and its value (string, integer, boolean,
          etc.).

    Returns:
      A tuple of a list of Question instances, datastore_query.Cursor
      instance, and a boolean representing whether or not there are more to
      retrieve.
    """
        query = cls.query(
            cls.enabled == enabled,  # pylint: disable=g-explicit-bool-comparison
            ndb.AND(cls.question_type == question_type))
        for filters, values in kwargs.items():
            if not isinstance(values, (list, tuple)):
                values = (values, )
            for value in values:
                query = query.filter(ndb.GenericProperty(filters) == value)
        return query.fetch_page(page_size=page_size, start_cursor=next_cursor)
Example #26
0
    def get_stats(cls,
                  cursor_key=None,
                  limit=None,
                  year=None,
                  topic=None,
                  sort_by=None,
                  **kw):
        if topic:
            return RoshReviewUserTopicStats.get_stats(topic,
                                                      cursor_key=cursor_key,
                                                      limit=limit,
                                                      year=year,
                                                      **kw)

        limit = limit if limit else 20
        sort_by = sort_by if sort_by else 'performance'
        cursor = Cursor(urlsafe=cursor_key) if cursor_key else None

        q = cls.query()
        if year:
            q = q.filter(cls.year == year)
        q = q.order(-ndb.GenericProperty(sort_by))

        stats, cursor, _ = q.fetch_page(limit, start_cursor=cursor, **kw)
        return stats, (cursor.urlsafe() if cursor else None),
Example #27
0
def __get_only_fields(json):
    projections = []
    if 'fields' in json:
        for field in json['fields']:
            projections.append((ndb.GenericProperty(field)))

    return projections
Example #28
0
def clean_up_verified():
    """ find members that have not been verified for some reason """
    
    """ first, find people who have seen the welcome message but are not verified. Weird. """
#     member_query = Member.query(ndb.AND(Member.seen_welcome == True, ndb.GenericProperty('verified')==False))
# 
#     members = member_query.fetch()
#     logging.info('fixed verified for {0} members'.format(len(members)))
#     
#     for m in members:
#         m.verified = True
#     
#     ndb.put_multi(members)
    
    """ now, find any members who have made plans but are not verified. really weird. """
    member_query = Member.query(ndb.GenericProperty('verified')==False)
    members = member_query.fetch()

    set = []
    for m in members:
        plan_query = plan.Plan.lquery(plan.Plan.member==m.key)
        plans = plan_query.fetch(keys_only=True)
        if plans:
            m.verified=True
            set.append(m)
            logging.info("found an unverified with plans! {0}".format(m.name))

    if set:
        ndb.put_multi(set)
    def _getQuery(self, request):
        """Return formatted query from the submitted filters."""

        q = Conference.query()
        
        inequality_filter, filters = self._formatFilters(request.filters)
        
        # If exists, sort on inequality filter first
        if not inequality_filter:
        
            q = q.order(Conference.name)
        
        else:
        
            q = q.order(ndb.GenericProperty(inequality_filter))
        
            q = q.order(Conference.name)
        
        for filtr in filters:

            if filtr["field"] in ["month", "maxAttendees"]:
            
                filtr["value"] = int(filtr["value"])
            
            formatted_query = ndb.query.FilterNode(filtr["field"],
                                                   filtr["operator"],
                                                   filtr["value"])
            q = q.filter(formatted_query)
        
        return q
Example #30
0
def generateQuery(filters):
	q = DBObject.query()
	for f in filters:
		parts = f.split('::')
		q = q.filter(ndb.GenericProperty(parts[0]) == parts[1])
	#q = q.order(-DBObject.date) # We can't do this because only simple queries are allowed on Expandos
	return q