Esempio n. 1
0
def update_max_altitudes_orm():
    """Add max altitudes in logbook when flight is complete (takeoff and landing)."""

    current_app.logger.info("Update logbook max altitude.")

    logbook_entries = (db.session.query(Logbook.id, Sender.name).filter(
        db.and_(Logbook.takeoff_timestamp != db.null(),
                Logbook.landing_timestamp != db.null(),
                Logbook.max_altitude == db.null())).filter(
                    Logbook.sender_id == Sender.id).limit(1).subquery())

    max_altitudes = (db.session.query(
        logbook_entries.c.id,
        db.func.max(SenderPosition.altitude).label("max_altitude")).filter(
            db.and_(
                db.between_(
                    SenderPosition.timestamp >= Logbook.takeoff_timestamp,
                    SenderPosition.timestamp <= Logbook.landing_timestamp),
                SenderPosition.name == logbook_entries.c.name)).group_by(
                    Logbook.id).subquery())

    update_logbooks = db.session.query(Logbook).filter(
        Logbook.id == max_altitudes.c.id).update(
            {Logbook.max_altitude: max_altitudes.c.max_altitude},
            synchronize_session="fetch")

    db.session.commit()

    finish_message = "Logbook (altitude): {} entries updated.".format(
        update_logbooks)
    return finish_message
Esempio n. 2
0
File: api.py Progetto: yinna123/IAT
def taskList():
    user_id = session.get('user_id')
    taskType = request.json.get("taskType")
    listData = Task.query.filter(db.and_(
        Task.task_type == taskType, )).order_by(db.desc(Task.add_time)).all()
    content = []
    for task in listData:
        row_data = users.query.filter(
            db.and_(users.id == task.user_id)).first()
        username = ""
        if row_data:
            username = row_data.username
        update_time = ""
        if task.update_time:
            update_time = task.update_time.strftime('%Y-%m-%d %H:%M:%S')
        content.append({
            "id": task.id,
            "name": task.name,
            "runTime": task.run_time,
            "taskDesc": task.task_desc,
            "add_time": task.add_time.strftime('%Y-%m-%d %H:%M:%S'),
            "add_user": username,
            "update_time": update_time,
            "status": task.status,
        })

    return make_response(jsonify({'code': 0, 'content': content, 'msg': u''}))
Esempio n. 3
0
File: api.py Progetto: yinna123/IAT
def projectList():
    user_id = session.get('user_id')
    status = request.values.get("status")
    if not status:
        status = 3
    if status != 3:
        projectList = Project.query.filter(
            db.and_(Project.status == status)).order_by(
                db.desc(Project.add_time)).all()
    else:
        projectList = Project.query.order_by(db.desc(Project.add_time)).all()
    content = []
    if projectList:
        for item in projectList:
            caseCount = Sample.query.filter(
                db.and_(Sample.project_id == item.id)).count()
            row_data = users.query.filter(db.and_(users.id == user_id)).first()
            username = ""
            if row_data:
                username = row_data.username
            content.append({
                "id":
                item.id,
                "name":
                item.name,
                "add_time":
                item.add_time.strftime('%Y-%m-%d %H:%M:%S'),
                "add_user":
                username,
                "count":
                caseCount,
                "status":
                item.status,
            })
    return make_response(jsonify({'code': 0, 'msg': '', 'content': content}))
Esempio n. 4
0
    def leave_game(self, game_id, sid, player_id):

        player = db.session.query(model.Player).filter(
            db.and_(model.Player.sid == sid,
                    model.Player.game_id == game_id)).first()
        if player is None:
            raise errors.UknownPlayer()
        # Player wants to leave
        if player.id == player_id:

            db.session.query(model.Player).filter(
                db.and_(model.Player.sid == sid,
                        model.Player.game_id == game_id)).delete()
            db.session.query(
                model.Game).filter(model.Game.host_id == player.id).delete()

        # Player wants to kick
        elif db.session.query(model.Game).filter(
                db.and_(model.Game.host_id == player.id,
                        model.Game.id == game_id)).first() is not None:
            db.session.query(model.Player).filter(
                db.and_(model.Player.id == player_id,
                        model.Player.game_id == game_id)).delete()
        else:
            raise errors.ForbiddenAction()

        game = db.session.query(
            model.Game).filter(model.Game.id == game_id).first()
        if game is not None and game.stage != model.GameStage.pending:
            self.reset_game(game)
Esempio n. 5
0
def stations2_filtered_pl(start, end):
    last_10_minutes = datetime.utcnow() - timedelta(minutes=10)

    query = (db.session.query(
        Receiver.name.label("s"),
        db.label(
            "lt",
            db.func.round(db.func.ST_Y(Receiver.location_wkt) * 10000) /
            10000),
        db.label(
            "lg",
            db.func.round(db.func.ST_X(Receiver.location_wkt) * 10000) /
            10000),
        db.case([(Receiver.lastseen > last_10_minutes, "U")],
                else_="D").label("u"),
        Receiver.lastseen.label("ut"),
        db.label("v", Receiver.version + "." + Receiver.platform),
    ).order_by(Receiver.lastseen).filter(
        db.or_(db.and_(start < Receiver.firstseen, end > Receiver.firstseen),
               db.and_(start < Receiver.lastseen, end > Receiver.lastseen))))

    res = db.session.execute(query)
    stations = json.dumps({"stations": [dict(r) for r in res]},
                          default=alchemyencoder)

    return stations
Esempio n. 6
0
def getCustomKeywords(taskId):
    rowData = Task.query.filter_by(id=taskId).first()
    caseIds = json.loads(rowData.case_id)
    projectData = Tree.query.filter_by(id=caseIds[0]).first()
    projectId = projectData.project_id
    keywordRootId = projectData.pid
    keywordRows = Tree.query.filter(
        db.and_(Tree.project_id == projectId, Tree.type == 4)).all()

    keywordRootConfig = CaseProjectSetting.query.filter_by(
        pid=keywordRootId).first()
    keywordRootlibs = []
    if keywordRootConfig:
        keywordRootLibDatas = CaseLibs.query.filter(
            db.and_(CaseLibs.id.in_(json.loads(
                keywordRootConfig.libs)))).all()
        for lib in keywordRootLibDatas:
            keywordRootlibs.append(lib.name)

    keywordDatas = []
    for keyword in keywordRows:
        keywordId = keyword.id
        keyInfo = CaseInfo.query.filter_by(pid=keywordId).first()
        caseSteps = []
        caseStepDatas = CaseStep.query.filter_by(case_id=keywordId).order_by(
            db.asc(CaseStep.indexId)).all()
        for caseStep in caseStepDatas:
            caseSteps.append({'values': json.loads(caseStep.values)})
        keywordDatas.append({
            'name': keyInfo.name,
            'Arguments': json.loads(keyInfo.params),
            'returns': json.loads(keyInfo.return_values),
            'caseSteps': caseSteps,
        })
    return keywordDatas, keywordRootlibs
Esempio n. 7
0
def get_active_posts(mode=None):
    orders = {
        'recent': (db.desc(Post.time), ),
        'popular': (db.desc('commentCount'), db.desc(Post.time)),
        'best': (db.desc('likeCount'), db.desc(Post.time)),
        'early': (db.asc(Post.time), )
    }

    order = orders.get(mode, orders['recent'])

    likes = db.select([db.func.count(Vote.id)]).where(
        db.and_(Vote.value == 1,
                Vote.post_id == Post.id)).as_scalar().label('likeCount')

    dislikes = db.select([db.func.count(Vote.id)]).where(
        db.and_(Vote.value == -1,
                Vote.post_id == Post.id)).as_scalar().label('dislikeCount')

    comments = db.select([
        db.func.count(Comment.id)
    ]).where(Comment.post_id == Post.id).as_scalar().label('commentCount')

    return filter_by_active_posts(
        Post.query.with_entities(Post, likes, dislikes,
                                 comments)).order_by(*order)
Esempio n. 8
0
def get_userinfo():
    sessionKey = request.values.get("sessionKey")
    username = sessionKey2Username.get(sessionKey)

    with db.Session() as session:

        members = session.query(Member).filter(
            db.and_(Member.username == username)).all()

        # todo 定义新的两个model
        histories = session.query(MemberUseLog).filter(
            db.and_(MemberUserLog.username == username)).all()

        favorites = session.query(MemberStar).filter(
            db.and_(MemberStar.username == username)).all()

        if len(members) == 0:
            return jsonify(dict(statusCode="400"))
        else:
            member = members[0]

            return jsonify(
                dict(statusCode="200",
                     nickName=member.nickname,
                     portrait=member.portrait,
                     sex=member.sex,
                     history='\t'.join(
                         list(map(lambda history: history.fil_id, histories))),
                     favority='\t'.join(
                         list(map(lambda favorite: favorite.fil_id,
                                  favorites)))))
Esempio n. 9
0
def index():
    today_beginning = datetime.combine(date.today(), time())

    senders_today = db.session.query(db.func.count(
        Sender.id)).filter(Sender.lastseen >= today_beginning).one()[0]
    receivers_today = db.session.query(db.func.count(
        Receiver.id)).filter(Receiver.lastseen >= today_beginning).one()[0]
    takeoffs_today = db.session.query(db.func.count(TakeoffLanding.id)).filter(
        db.and_(TakeoffLanding.timestamp >= today_beginning,
                TakeoffLanding.is_takeoff == db.true())).one()[0]
    landings_today = db.session.query(db.func.count(TakeoffLanding.id)).filter(
        db.and_(TakeoffLanding.timestamp >= today_beginning,
                TakeoffLanding.is_takeoff == db.false())).one()[0]
    sender_positions_today = db.session.query(
        db.func.sum(ReceiverStatistic.messages_count)).filter(
            ReceiverStatistic.date == date.today()).one()[0]
    sender_positions_total = db.session.query(
        db.func.sum(ReceiverStatistic.messages_count)).one()[0]

    last_logbook_entries = db.session.query(Logbook).order_by(
        Logbook.reference_timestamp.desc()).limit(10)
    return render_template("index.html",
                           senders_today=senders_today,
                           receivers_today=receivers_today,
                           takeoffs_today=takeoffs_today,
                           landings_today=landings_today,
                           sender_positions_today=sender_positions_today,
                           sender_positions_total=sender_positions_total,
                           logbook=last_logbook_entries)
Esempio n. 10
0
    def test_registration(self):
        """
        Test that a user can create a corpus and that this corpus has its data well recorded
        """

        # Click register menu link
        self.driver.find_element_by_id("new_corpus_link").click()
        self.driver.implicitly_wait(15)

        # Fill in registration form
        self.driver.find_element_by_id("corpusName").send_keys(
            PLAINTEXT_CORPORA["Wauchier"]["name"])
        self.writeMultiline(self.driver.find_element_by_id("tokens"),
                            PLAINTEXT_CORPORA["Wauchier"]["data"])
        self.driver.find_element_by_id("label_checkbox_create").click()
        self.driver.find_element_by_id("submit").click()

        self.driver.implicitly_wait(15)
        self.assertIn(url_for('main.corpus_get',
                              corpus_id=1), self.driver.current_url,
                      "Result page is the corpus new page")

        self.assertEqual(
            db.session.query(Corpus).filter(
                Corpus.name == PLAINTEXT_CORPORA["Wauchier"]["name"]).count(),
            1, "There should be one well named corpus")
        corpus = db.session.query(Corpus).filter(
            Corpus.name == PLAINTEXT_CORPORA["Wauchier"]["name"]).first()
        self.assertEqual(corpus.delimiter_token, None,
                         "We did not set a delimiter token")

        tokens = db.session.query(WordToken).filter(
            WordToken.corpus == corpus.id)
        self.assertEqual(tokens.count(), 25, "There should be 25 tokens")

        saint = db.session.query(WordToken).filter(
            db.and_(WordToken.corpus == 1, WordToken.lemma == "saint"))
        self.assertEqual(saint.count(), 1, "There should be the saint lemma")
        saint = saint.first()
        self.assertEqual(saint.form, "seint", "It should be correctly saved")
        self.assertEqual(saint.label_uniform, "saint",
                         "It should be correctly saved and unidecoded")
        self.assertEqual(saint.POS, "ADJqua",
                         "It should be correctly saved with POS")
        self.assertEqual(saint.morph, None,
                         "It should be correctly saved with morph")

        oir = db.session.query(WordToken).filter(
            db.and_(WordToken.corpus == 1, WordToken.lemma == "öir"))
        self.assertEqual(oir.count(), 1, "There should be the oir lemma")
        oir = oir.first()
        self.assertEqual(oir.form, "oïr", "It should be correctly saved")
        self.assertEqual(oir.label_uniform, "oir",
                         "It should be correctly saved and unidecoded")
        self.assertEqual(oir.POS, "VERinf",
                         "It should be correctly saved with POS")
        self.assertEqual(oir.morph, None,
                         "It should be correctly saved with morph")
Esempio n. 11
0
def university_dep(id):
    degrees=degree.query.all()
    univer = university.query.get_or_404(id) 
    university_department = department.query.filter(db.and_(department.university_id == id,department.degree == degree.id)).all()
    text = request.args.get('text')
    search = "%{}%".format(text)
    if request.args.get('degree'):
        university_department = department.query.filter(db.and_(department.university_id == id,department.degree ==request.args.get('degree'), department.name.like(search))).all()
    return render_template('university.html',dep=university_department, univer = univer,degree=degrees)
Esempio n. 12
0
def join_to_room(ws_message):
    channel = Friends.query.filter(
        db.or_(
            db.and_(Friends.user_id == current_user.id,
                    Friends.friend_id == int(ws_message["friend_id"])),
            db.and_(Friends.user_id == int(ws_message["friend_id"]),
                    Friends.friend_id == current_user.id))).order_by(
                        Friends.id).first()
    join_room(str(channel.id))
Esempio n. 13
0
def orders():
    orderByUser = cart.query.filter(
        cart.user_id == session['user']['id']).all()

    user_order = Orders(user_id=session['user']['id'])
    db.session.add(user_order)
    db.session.commit()
    ord = Orders.query.all()
    for newOrder in orderByUser:

        amounts = newOrder.qty * newOrder.priceItem

        delete = cart.query.filter(
            cart.user_id == session['user']['id']).first()
        db.session.delete(delete)

        for i in ord:
            k = orderItems(product=newOrder.product_id,
                           qty=newOrder.qty,
                           price=newOrder.priceItem,
                           amount=amounts,
                           order_id=i.id)
        db.session.add(k)
        db.session.commit()
    mail_user = users.query.filter(users.id == session['user']['id']).all()
    with mail.connect() as conn:
        for us in mail_user:
            order_id = orderItems.query.filter(
                Orders.id == orderItems.order_id).order_by(
                    Orders.id.desc()).first()

            orderByus = Orders.query.filter(
                db.and_(Orders.id == orderItems.order_id,
                        Orders.user_id == session['user']['id'])).all()

            prodName = Product.query.filter(
                Product.id == orderItems.product).first()

            for byUs in orderByus:
                orderItemsByUser = orderItems.query.filter(
                    db.and_(Orders.id == orderItems.order_id,
                            Orders.user_id == session['user']['id'])).all()
                for itemsByuser in orderItemsByUser:
                    message = 'This is your purchase' + '<br>' + 'name: ' + str(byUs.id) + '<br>' \
                                                                                           'qty:' + str(
                        itemsByuser.qty) + '<br>' \
                                           'price:' + str(itemsByuser.price) + '$' + '<br>' \
                                                                                     'Amount:' + str(
                        itemsByuser.amount) + '$' + '<br>'

                    subject = "Your Purchase  %s" % us.username
                    msg = Message(recipients=[us.email],
                                  html=message,
                                  subject=subject)
            conn.send(msg)
    return redirect(url_for('shopping_cart'))
Esempio n. 14
0
def return_message(friend_id):
    all_messages = Message.query.filter(
        db.or_(
            db.and_(Message.sender == int(friend_id),
                    Message.receiver == current_user.id),
            db.and_(Message.sender == current_user.id,
                    Message.receiver == int(friend_id)))).order_by(
                        db.desc(Message.timestamp)).all()

    return jsonify(messages=[m.serialize() for m in all_messages])
Esempio n. 15
0
 def new_fights(self, status=None):
     q = Fight.query.filter(
         db.or_(
             db.and_(Fight.user1_id == self.id, Fight.user1_score == 0),
             db.and_(Fight.user2_id == self.id, Fight.user2_score == 0)
         )
     )
     if status:
         q = q.filter(Fight.status == status)
     return q
Esempio n. 16
0
 def is_host(self, game_id, sid):
     player_id = db.session.query(model.Player.id).filter(
         db.and_(model.Player.sid == sid,
                 model.Player.game_id == game_id)).first()
     if player_id is None:
         raise errors.UknownPlayer()
     elif db.session.query(model.Game).filter(
             db.and_(model.Game.host_id == player_id[0], model.Game.id
                     == game_id)).first() is None:
         return False
     return True
Esempio n. 17
0
    def dialogue_with(self, whom):
        """
        双方都删除也会保留对话内容
        :param whom:对话人物
        :return:
        """

        return Message.query.filter(
            db.or_(db.and_(Message.sender == self, Message.receiver == whom),
                   db.and_(Message.sender == whom, Message.receiver == self)),
            Message.message_type == MessageType.standard)
Esempio n. 18
0
 def search_all(keyword, page, per_page):
     Article = app.article.models.Article
     Book = app.book.models.Book
     query = u"%{0}%".format(keyword)
     publishs = db.session.query(UserPublish, Article, Book).outerjoin(Article, (
         db.and_(UserPublish.source=="article", UserPublish.publish_id==Article.id))).\
         outerjoin(Book, (db.and_(UserPublish.source=="book",
             UserPublish.publish_id == Book.id))).filter(
                 db.or_(Article.access=="public", Book.access=="public")).filter(db.or_(
                 Article.title.ilike(query), Book.name.ilike(query))).order_by(
                 UserPublish.timestamp.desc())
     return paginate(publishs, page, per_page=per_page, error_out=False)
Esempio n. 19
0
 def get_last_message(self):
     return User.query.with_entities(
         User.nickname,
         func.max(Message.id).label("max_id"),
     ).filter(
         db.or_(
             db.and_(User.id == Message.receiver_id,
                     Message.sender_id == self.current_user_id),
             db.and_(
                 User.id == Message.sender_id,
                 Message.receiver_id == self.current_user_id))).group_by(
                     User.nickname).subquery("sub_in_chat")
Esempio n. 20
0
def taskList():
    user_id = session.get('user_id')
    taskType = request.json.get("taskType")
    pageNum = request.json.get("pageNum")
    dataCount = Task.query.filter(db.and_(
        Task.task_type == taskType, )).count()
    top_task = Task.query.filter(
        db.and_(Task.task_type == taskType, Task.name.like("%置顶%"))).order_by(
            db.desc(Task.add_time)).all()
    if pageNum:
        listData = Task.query.filter(
            db.and_(Task.task_type == taskType,
                    Task.name.notlike("%置顶%"))).order_by(db.desc(
                        Task.add_time)).slice((pageNum - 1) * 20,
                                              pageNum * 20).all()
    else:
        listData = Task.query.filter(
            db.and_(Task.task_type == taskType,
                    Task.name.notlike("%置顶%"))).order_by(db.desc(
                        Task.add_time)).all()
    content = {
        'taskContent': [],
        'total': dataCount,
    }
    listData = top_task + listData
    for task in listData:
        row_data = users.query.filter(
            db.and_(users.id == task.user_id)).first()
        username = ""
        if row_data:
            username = row_data.username
        update_time = ""
        if task.update_time:
            update_time = task.update_time.strftime('%Y-%m-%d %H:%M:%S')
        content['taskContent'].append({
            "id":
            task.id,
            "name":
            task.name,
            "runTime":
            task.run_time,
            "add_time":
            task.add_time.strftime('%Y-%m-%d %H:%M:%S'),
            "add_user":
            username,
            "update_time":
            update_time,
            "status":
            task.status,
        })

    return make_response(jsonify({'code': 0, 'content': content, 'msg': u''}))
Esempio n. 21
0
 def newest_publishs(num):
     Article = app.article.models.Article
     Book = app.book.models.Book
     publishs = db.session.query(UserPublish, Article, Book).outerjoin(Article, (
         db.and_(UserPublish.source=="article", UserPublish.publish_id==Article.id))).\
         outerjoin(Book, (db.and_(UserPublish.source=="book",
             UserPublish.publish_id == Book.id))).filter(
                 db.or_(
                     db.and_(Article.access=="public", Article.is_necessary==0),
                     db.and_(Book.access=="public", Book.is_necessary==0)
                 )).group_by(UserPublish.id).order_by(
                 UserPublish.timestamp.desc()).limit(num).all()
     return publishs
Esempio n. 22
0
def get_connect(message):
    taskType = message['taskType']
    pageNum = message['pageNum']
    dataCount = Task.query.filter(db.and_(
        Task.task_type == taskType, )).count()
    top_task = Task.query.filter(
        db.and_(Task.task_type == taskType, Task.name.like("%置顶%"))).order_by(
            db.desc(Task.add_time)).all()
    if pageNum:
        listData = Task.query.filter(
            db.and_(Task.task_type == taskType,
                    Task.name.notlike("%置顶%"))).order_by(db.desc(
                        Task.add_time)).slice((pageNum - 1) * 20,
                                              pageNum * 20).all()
    else:
        listData = Task.query.filter(
            db.and_(Task.task_type == taskType,
                    Task.name.notlike("%置顶%"))).order_by(db.desc(
                        Task.add_time)).all()
    content = {
        'taskContent': [],
        'total': dataCount,
    }
    listData = top_task + listData
    for task in listData:
        row_data = users.query.filter(
            db.and_(users.id == task.user_id)).first()
        username = ""
        if row_data:
            username = row_data.username
        update_time = ""
        if task.update_time:
            update_time = task.update_time.strftime('%Y-%m-%d %H:%M:%S')
        content['taskContent'].append({
            "id":
            task.id,
            "name":
            task.name,
            "runTime":
            task.run_time,
            "add_time":
            task.add_time.strftime('%Y-%m-%d %H:%M:%S'),
            "add_user":
            username,
            "update_time":
            update_time,
            "status":
            task.status,
        })
    return content
Esempio n. 23
0
 def page(page, per_page):
     last_catalog = Book.create_subquery("last_catalog")
     catalogs = db.session.query(Book, BookCatalog) \
         .outerjoin(last_catalog, last_catalog.c.id == Book.id) \
         .outerjoin(BookCatalog, db.and_(
         BookCatalog.book_id == Book.id,
         BookCatalog.publish_order == last_catalog.c.order)) \
         .options(
         db.Load(Book).undefer("brief"),
         db.Load(BookCatalog).undefer("abstract")) \
         .filter(db.and_(
         Book.access == 1,
         last_catalog.c.order.isnot(None))) \
         .order_by(BookCatalog.first_publish.desc())
     return paginate(catalogs, page, per_page=per_page, error_out=False)
Esempio n. 24
0
    def last_message_property(self, friend):
        last_message = Message.query.filter(
            db.or_(
                db.and_(Message.sender == self.id,
                        Message.receiver == friend.id),
                db.and_(Message.sender == friend.id,
                        Message.receiver == self.id))).order_by(
                            db.desc(Message.timestamp)).first()

        if (last_message is None) or (last_message.sender
                                      == friend.id) or (last_message.status
                                                        == 0):
            return True
        else:
            return False
Esempio n. 25
0
def reply(id):
    """
    回复评论里面的评论
    :param id:
    :return:
    """
    reply = Reply.query.get_or_404(id)  # 当前回复
    comment = reply.comment

    user = reply.author  # 我要回复的人
    replies = comment.replies.filter(
        db.or_(db.and_(Reply.author == current_user, Reply.user == user),
               db.and_(Reply.author == user,
                       Reply.user == current_user))).all()

    form = CommentForm()

    if comment.topic_type == 'post':
        return execute_reply(comment,
                             form=form,
                             user=user,
                             topic_type='post',
                             replies=replies)
    elif comment.topic_type == 'question':
        return execute_reply(comment,
                             form=form,
                             user=user,
                             topic_type='question',
                             replies=replies)
    elif comment.topic_type == 'answer':
        return execute_reply(comment,
                             form=form,
                             user=user,
                             topic_type='answer',
                             replies=replies)
    elif comment.topic_type == 'favorite':
        return execute_reply(comment,
                             form=form,
                             user=user,
                             topic_type='favorite',
                             replies=replies)

    else:
        return execute_reply(comment=comment,
                             form=form,
                             user=user,
                             topic_type='',
                             replies=replies)
Esempio n. 26
0
def get_translations_with_limit_and_offset(current_user):
    if not check_session():

      return jsonify({'message': 'You are not logged in!', 'isLoggedIn': False})


    limit = request.args.get('limit')
    offset = request.args.get('offset')
    sort_by = request.args.get('sortBy')
    collectionId = request.args.get('collectionId')
    sort_direction = request.args.get('sortDirection')

    if limit == None or offset == None or collectionId == None:
      
      return jsonify({'message': 'Invalid request. Limit, offset and collectionId arguments have to be instance of Ing', 'contentIsSent': False})

    collection = Collection.query.with_entities(Collection.name, Collection.id, Collection.createdAt, Collection.updatedAt).filter(db.and_(Collection.id==collectionId,Collection.userId==current_user.id)).first()

    if not collection:

      return jsonify({'message': 'Collection is not found!', 'contentIsSent': False})

    order_by_options = {"primaryPhrase": Translation.primaryPhrase, "secondaryPhrase": Translation.secondaryPhrase, "createdAt": TranslationStatus.createdAt, "updatedAt": TranslationStatus.updatedAt, "id": Translation.id,}

    order_by = order_by_options.get(sort_by)

    translations = db.session.query(Translation, TranslationStatus).outerjoin(TranslationStatus, Translation.id == TranslationStatus.translationId).filter(db.and_(TranslationStatus.collectionId==collection.id)).order_by(set_direction(sort_direction)(order_by)).limit(limit).offset(offset).all()

    translationsQuantity = db.session.query(TranslationStatus).filter(db.and_(TranslationStatus.collectionId==collection.id)).count()

    learnedQuantity = db.session.query(TranslationStatus).filter(db.and_(TranslationStatus.collectionId==collection.id, TranslationStatus.isLearned==True)).count()

    translations_response = []

    for translation in translations:
      trans = {}
      trans['id'] = translation[0].id
      trans['primaryLanguage'] = translation[0].primaryLanguage
      trans['secondaryLanguage'] = translation[0].secondaryLanguage
      trans['primaryPhrase'] = translation[0].primaryPhrase
      trans['secondaryPhrase'] = translation[0].secondaryPhrase
      trans['isLearned'] = translation[1].isLearned
      trans['updatedAt'] = translation[1].updatedAt
      trans['collectionId'] = translation[1].collectionId

      translations_response.append(trans)
    
    return jsonify({'translations': translations_response, 'collectionData': {'learnedQuantity' : learnedQuantity, 'translationsQuantity': translationsQuantity, 'id': collection.id, 'name': collection.name, 'updatedAt': collection.updatedAt, 'createdAt': collection.createdAt}, 'isSent': True})
Esempio n. 27
0
def tags():
    search_tags = request.args.get('search', None)
    page = request.args.get('page', 1, type=int)
    the_tags = Tag.query.outerjoin(book_tag).group_by(book_tag.c.tag_id).order_by(
        db.func.count(book_tag.c.book_id).desc()).limit(30).all()
    search_form = SearchForm()
    search_form.search.data = search_tags

    data = None
    pagination = None

    if search_tags:
        tags_list = [s.strip() for s in search_tags.split(',') if len(s.strip()) > 0]
        if len(tags_list) > 0:
            the_books = Book.query
            if not current_user.can(Permission.UPDATE_BOOK_INFORMATION):
                the_books = Book.query.filter_by(hidden=0)
            the_books = the_books.filter(
                db.and_(*[Book.tags.any(Tag.name.ilike(word)) for word in tags_list])).outerjoin(Log).group_by(
                Book.id).order_by(db.func.count(Log.id).desc())
            pagination = the_books.paginate(page, per_page=8)
            data = pagination.items

    return render_template('book_tag.html', tags=the_tags, title='Tags', search_form=search_form, books=data,
                           pagination=pagination)
Esempio n. 28
0
 def get_line(self, start_time, end_time):
     """
     get a slice of raw points of data
     :param start_time:
     :param end_time:
     :return:
     """
     period = self.get_abstract().period
     start_time = utils.iceil(start_time, period)
     end_time = utils.iceil(end_time, period)
     data_raw = Raw.query.filter(
         db.and_(Raw.data_id.is_(self.get_id()),
                 Raw.timestamp.between(start_time, end_time)))
     # data_raw = {point.timestamp: point for point in data_raw}
     line = [
         Raw(timestamp=point.timestamp, value=point.value)
         for point in data_raw
     ]
     # line = []
     # for timestamp in range(start_time, end_time, period):
     #     if timestamp in data_raw:
     #         line.append(data_raw[timestamp])
     #     else:
     #         line.append(Raw(timestamp=timestamp))
     return line
Esempio n. 29
0
def archive(page_nr=1):
    items = News.query.filter(db.and_(News.archive_date < date.today(),
                                      News.archive_date != None))  # noqa

    return render_template('news/list.htm',
                           items=items.paginate(page_nr, 10, False),
                           archive=True)
Esempio n. 30
0
 def login_check(cls, user_name, password):
     user = cls.query.filter(
         db.and_(User.user_name == user_name, User.password == password)
     ).first()
     if not user:
         return None
     return user
Esempio n. 31
0
 def get_ref(self, start_time, end_time):
     """
     get reference lines for data
     :param start_time:
     :param end_time:
     :return:
     """
     period = self.get_abstract().period
     start_time = utils.iceil(start_time, period)
     end_time = utils.iceil(end_time, period)
     ref_names = db.session.query(db.distinct(Point.name)).all()
     lines = []
     for ref_name, in ref_names:
         points = Point.query.filter(
             db.and_(Point.data_id.is_(self.get_id()),
                     Point.name.is_(ref_name),
                     Point.timestamp.between(start_time, end_time)))
         points = {point.timestamp: point for point in points}
         line = []
         for timestamp in range(start_time, end_time, period):
             if timestamp in points:
                 line.append((timestamp, points[timestamp].value,
                              points[timestamp].range))
             else:
                 line.append((timestamp, None, None))
         lines.append((ref_name, line))
     return lines
Esempio n. 32
0
def load_datalist(toadd):
    if toadd == 'round':
        return dict(
            selections=db.session.query(Selection.selection_name).all(),
            primers=db.session.query(Primers.name).filter(
                Primers.role.in_(('SELEX', 'PD'))).all(),
            rounds=db.session.query(Rounds.round_name).all(),
            targets=db.session.query(Selection.target).distinct().all())
    elif toadd == 'selection':
        return dict(
            targets=db.session.query(Selection.target).distinct().all())
    elif toadd == 'sequence_round':
        note = db.session.query(distinct(Sequence.note)).filter(
            db.and_(Sequence.note.isnot(None), Sequence.note != '')).all()
        n = Counter()

        for i in note:
            for j in i[0].split(','):
                if j.strip():
                    n[(j.strip(), )] += 1

        return dict(known_sequence=db.session.query(
            KnownSequence.sequence_name).all(),
                    common_note=[i[0] for i in n.most_common(10)])
    else:
        return {}
Esempio n. 33
0
 def vote(self, user_id):
     """
     allow a user to vote on a post. if we have voted already
     (and they are clicking again), this means that they are trying
     to unvote the post, return status of the vote for that user
     """
     already_voted = self.has_voted(user_id)
     vote_status = None
     if not already_voted:
         # vote up the post
         db.engine.execute(
             post_upvotes.insert(),
             user_id=user_id,
             post_id=self.id
         )
         if self.votes is None:
             self.votes = 1
         self.votes += 1
         vote_status = True
     else:
         # unvote the post
         db.engine.execute(
             post_upvotes.delete(
                 db.and_(
                     post_upvotes.c.user_id == user_id,
                     post_upvotes.c.post_id == self.id
                 )
             )
         )
         self.votes -= 1
         vote_status = False
     db.session.commit()  # for the vote count
     return vote_status
Esempio n. 34
0
def tags():
    search_tags = request.args.get('search', None)
    page = request.args.get('page', 1, type=int)
    the_tags = Tag.query.outerjoin(alcohol_tag).group_by(
        alcohol_tag.c.tag_id).order_by(
            db.func.count(alcohol_tag.c.alcohol_id).desc()).limit(30).all()
    search_form = SearchForm()
    search_form.search.data = search_tags

    data = None
    pagination = None

    if search_tags:
        tags_list = [
            s.strip() for s in search_tags.split(',') if len(s.strip()) > 0
        ]
        if len(tags_list) > 0:
            the_alcohols = Alcohol.query
            if not current_user.can(Permission.UPDATE_ALCOHOL_INFORMATION):
                the_alcohols = Alcohol.query.filter_by(hidden=0)
            the_alcohols = the_alcohols.filter(
                db.and_(*[
                    Alcohol.tags.any(Tag.name.ilike(word))
                    for word in tags_list
                ])).outerjoin(Log).group_by(Alcohol.id).order_by(
                    db.func.count(Log.id).desc())
            pagination = the_alcohols.paginate(page, per_page=8)
            data = pagination.items

    return render_template('alcohol_tag.html',
                           tags=the_tags,
                           title='Tags',
                           search_form=search_form,
                           alcohols=data,
                           pagination=pagination)
Esempio n. 35
0
def counting_shows():
	""" returns a number. counts all show = True from Puppy and is == current_capacity"""
	update_capacity = db.session.query(Shelter).all()
	for shel in update_capacity:
		shel.current_capacity = db.session.query(Puppy, Shelter).join(Shelter).filter(db.and_(Shelter.id == shel.id, Puppy.show==True)).count()
		db.session.add(shel)
		db.session.commit()
Esempio n. 36
0
def counting_shows():
	update_capacity = db.session.query(Shelter).all()
	for shel in update_capacity:
		shel.current_capacity = db.session.query(Puppy, Shelter).join(Shelter).filter(db.and_(Shelter.id == shel.id, Puppy.show==True)).count()
		db.session.add(shel)
		db.session.commit()
	print "Successful update"
Esempio n. 37
0
def api_schedule(semester):
    """Build a per-session schedule using the `sections` URL parameter. It must
    be formatted similarly to `sections=CODE100.01,CODE110.04`, which would
    select the class CODE100 section 1 and CODE110 section 4."""
    # Get the pairs of class codes and section numbers.
    section_pairs = [tuple(pair.split('.')) for pair in
            request.args.get('sections').split(',')]

    try:
        sections = Section.query.join(Semester) \
                .filter(Semester.name == semester.upper()) \
                .filter(db.tuple_(Section.class_code, Section.number)\
                    .in_(section_pairs)).all()
    except DBAPIError:
        app.logger.info("DB Backend does not support compound key 'IN' queries, \
reverting to composed 'OR/AND' query.")
        # Because the backend does not support in_ for tuples, we abuse *args
        # and list comprehensions to create a subsitute query.
        sections = Section.query.join(Semester) \
                .filter(Semester.name == semester.upper()) \
                .filter(db.or_(
                    *tuple((db.and_(
                        Section.class_code == code, Section.number == number)
                        for code, number in section_pairs)))) \
                .all()

    return sections
Esempio n. 38
0
def api_section_events(semester, class_code, section_number):
    """List calendar events for a particular section of a class."""
    section = Section.query.join(Semester) \
            .filter(Semester.name == semester.upper()) \
            .filter(db.and_(Section.class_code == class_code.upper(),
                            Section.number == section_number)).one()
    return section.events()
Esempio n. 39
0
def schedule_events(semester):
    """Build a per-session schedule just like the above endpoint, but also
    generate all events. Also can generate iCalendar format output."""
    # Get the pairs of class codes and section numbers.
    section_pairs = [tuple(pair.split('.')) for pair in
            request.args.get('sections').split(',')]

    s = Semester.query.filter(Semester.name == semester.upper()).one()

    try:
        sections = Section.query.join(Semester) \
                .filter(Semester.name == semester.upper()) \
                .filter(db.tuple_(Section.class_code, Section.number)\
                    .in_(section_pairs)).all()
    except DBAPIError:
        app.logger.info("DB Backend does not support compound key 'IN' queries, \
reverting to composed 'OR/AND' query.")
        # Because the backend does not support in_ for tuples, we abuse *args
        # and list comprehensions to create a subsitute query.
        sections = Section.query.join(Semester) \
                .filter(Semester.name == semester.upper()) \
                .filter(db.or_(
                    *tuple((db.and_(
                        Section.class_code == code, Section.number == number)
                        for code, number in section_pairs)))) \
                .all()

    return itertools.chain(
            *(b.events() for b in s.breaks),
            *(section.events() for section in sections))
Esempio n. 40
0
 def int_for_range(start_id, emd_id):
     if end_id:
         return db.and_(
             column>=start_id,
             column<end_id
         )
     else:
         return column>=start_id
Esempio n. 41
0
def api_section(semester, class_code, section_number):
    section = (
        Section.query.join(Semester)
        .filter(Semester.name == semester.upper())
        .filter(db.and_(Section.class_code == class_code, Section.number == section_number))
        .one()
    )
    print(section)
    return section
Esempio n. 42
0
def archive(page_nr=1):
    if not ModuleAPI.can_read('news'):
        return abort(403)

    items = News.query.filter(db.and_(News.archive_date < date.today(),
                                     News.archive_date != None))  # noqa

    return render_template('news/list.htm',
                           items=items.paginate(page_nr, 10, False),
                           archive=True)
Esempio n. 43
0
def shelter_profile(shelter_id,shelter_name, page=1): 
    SHELTERS = Shelter.query.all()
    PUPPY = Puppy.query.filter(Puppy.shelter_id==shelter_id).all()
    shelter_profile = Shelter.query.filter_by(id=shelter_id).one()
    puppy = Puppy.query.filter(db.and_(Puppy.shelter_id==shelter_id, Puppy.show==True)).paginate(page,4,False)
    return render_template('shelter_profile.html', 
                            shelter_id=shelter_id,
                            shelter_name=shelter_name,
                            shelter_profile=shelter_profile,
                            puppy=puppy,
                            SHELTERS=SHELTERS,
                            PUPPY=PUPPY)
Esempio n. 44
0
 def has_voted(self, user_id):
     """
     did the user vote already
     """
     select_votes = post_upvotes.select(
             db.and_(
                 post_upvotes.c.user_id == user_id,
                 post_upvotes.c.post_id == self.id
             )
     )
     rs = db.engine.execute(select_votes)
     return False if rs.rowcount == 0 else True
Esempio n. 45
0
    def restricted(self, user):
        if user and user.is_moderator:
            return self
       
        q = self.join(Case)
        criteria = [Case.access==Case.PUBLIC]

        if user:
            criteria.append(Case.author_id==user.id)
            if user.friends:
                criteria.append(db.and_(Case.access==Case.FRIENDS,
                                        Case.author_id.in_(user.friends)))
        return q.filter(reduce(db.or_, criteria))
Esempio n. 46
0
def list(page_nr=1):
    if not ModuleAPI.can_read('news'):
        return abort(403)

    items = News.query.filter(
        db.and_(
            db.or_(
                News.archive_date >= date.today(), News.archive_date == None),
            News.publish_date <= date.today()))\
        .order_by(desc(News.publish_date))  # noqa

    return render_template('news/list.htm',
                           items=items.paginate(page_nr, 10, False),
                           archive=False)
Esempio n. 47
0
def home():
    data = ['activities',
            'contact']

    revisions = get_revisions(data)
    news = News.query.filter(
        db.and_(
            db.or_(
                News.archive_date >= date.today(), News.archive_date == None),
            News.publish_date <= date.today()))\
        .order_by(desc(News.publish_date)).limit(8).all()  # noqa

    return render_template('home/home.htm', revisions=revisions,
                           title='Homepage', news=news)
Esempio n. 48
0
def _getreview(grade="All"):
    """获取当前页内容"""
    page=request.args.get("page",type=int)#接收当前页。并非从param返回,是控件自动传递的
    rp=request.args.get("rp",type=int)
    sortcol=request.args.get('sortname')#获取要排序的行
    sorttype=request.args.get('sortorder')#获取排序方式

    if grade=="All":
        _score_items=Score_items.query.filter(Score_items.status==2).all()
    else :
        #按照年级来返回需要审核的内容
        _score_items=Score_items.query.filter(db.and_(Score_items.status==2,User.get_user_byID(Score_items.user_id).grade==grade)).all()


    _score_items_af=sorter(_score_items,sortcol,sorttype)

    return jsonify(pageslicer(page,rp,_score_items_af))
Esempio n. 49
0
    def restricted(self, user=None):
        """
        Returns posts filtered for 
            a) public posts 
            b) posts authored by the user 
            c) posts authored by friends
        """
        if user and user.is_moderator and user.is_admin:
            return self
        
        criteria = [Post.access==Post.PUBLIC]

        if user:
            criteria.append(Post.author_id==user.id)
            if user.friends:
                criteria.append(db.and_(Post.access==Post.FRIENDS,
                                        Post.author_id.in_(user.friends)))
        return self.filter(reduce(db.or_, criteria))
Esempio n. 50
0
    def getUserScoreitems(self,campID,time_st,time_ed,start,end):
        """返回符合条件的全部加分条目
        args:
            campID:一卡通号
            time_st
            time_ed

        """

        user=User.query.filter(User.campID==campID).first()

        if start==None or end==None:
            result=Score_items.query.filter(Score_items.user_id==user.id).all()
        else:
            #单纯求时间差,是可以用字符串的,但是如果要使用timedelta则必须要转换成datetime类型
            # result=Score_items.query.filter(db.and_(time_st,time_ed.between(self.tm.dbTime(start),self.tm.dbTime(end)+timedelta(days=1)),Score_items.user_id==user.id)).all()
            result=Score_items.query.filter(db.and_(time_st.between(self.tm.dbTime(start),self.tm.dbTime(end)),
                                                    time_ed.between(self.tm.dbTime(start),self.tm.dbTime(end)),
                                                    Score_items.user_id==user.id)).all()
        return result
Esempio n. 51
0
def reset_password(hash=0):
    """
    Reset form existing of two fields, password and password_repeat.

    Checks if the hash in the url is found in the database and timestamp
    has not expired.
    """

    form = ResetPassword(request.form)

    # Request the ticket to validate the timer
    ticket = PasswordTicket.query.filter(
        db.and_(PasswordTicket.hash == hash)).first()

    # Check if the request was followed within a hour
    if ticket is None or ((datetime.now() - ticket.created_on).seconds > 3600):
        flash(_('No valid ticket found'))
        return redirect(url_for('user.request_password'))

    if form.validate_on_submit():
        user = User.query.filter(User.id == ticket.user).first()

        if not user:
            flash(_('There is something wrong with the reset link.'), 'danger')
            return redirect(url_for('user.request_password'))

        # Actually reset the password of the user
        user.password = bcrypt.hashpw(form.password.data, bcrypt.gensalt())
        login_user(user)
        db.session.add(user)
        db.session.commit()

        flash(_('Your password has been updated.'), 'success')
        return redirect(url_for('user.view_single', user_id=user.id))

    else:
        flash_form_errors(form)

    return render_template('user/reset_password.htm', form=form)
Esempio n. 52
0
    def test_follow_question(self):
        # Add two users
        u1 = User(email='*****@*****.**', password='******')
        u2 = User(email='*****@*****.**', password='******')
        db.session.add_all([u1, u2])
        db.session.commit()

        # u1 add a question
        q = Question(user=u1, title='abc', content='abc')
        self.assertEqual(u1.questions_count(), 1)

        # u2 follow this question
        u2.follow_question(q)
        user_on_question = UserOnQuestion.query.filter(db.and_(
            UserOnQuestion.user == u2,
            UserOnQuestion.question == q)
        ).first()
        self.assertFalse(user_on_question is None)

        # u2 unfollow this question
        u2.unfollow_question(q)
        self.assertFalse(user_on_question.follow)
Esempio n. 53
0
 def get_confirm_user(cls,code):
     user=cls.query.filter(db.and_(User.reg_token==code,User.active==False)).first()
     return user
Esempio n. 54
0
    def get_data_by_rs_id(rs_id, category=None, label=None):
        """
        Get data by rs_id
        :param rs_id: generated by Data Operator for mapping resources set
        :param category: specific category
        :param label: specific label in category
        :return: JSON
        """
        try:
            # get user_id and resource_set_id by rs_id
            rs = ResourceSet.query.filter_by(rs_id=rs_id).first()
            if rs is None:
                raise NotFound(payload={'detail': ('Invalid parameter <rs_id>:{0}').format(rs_id)})

            user_id = rs.user_id
            resource_set_id = rs.id

            # whether specific an categoriess
            if category is not None:

                # get the id of this category
                ca = Categories.query.filter_by(name=category).first()
                if ca is None:
                    raise NotFound(payload={'detail': ('can not find {0} in source').format(category)})
                    # raise ValueError('Invalid parameter <category>')

                # whether resource has been registered
                u_ca = LinkRsData.query.filter(db.and_(
                    LinkRsData.resource_set_id == resource_set_id,
                    LinkRsData.categories_id == ca.id
                )).first()
                # if not, return None
                if u_ca is None:
                    raise NotFound(payload={
                        'detail': 'the category you request have not been registered in the resource set!'
                        })
                # if yes, return data
                # get all subsets of this category
                if label is not None:
                    lb = Label.query.filter(db.and_(
                        Label.c_id == ca.id,
                        Label.name == label
                    )).all()
                else:
                    lb = Label.query.filter_by(c_id=ca.id).all()

                data = []
                # get data
                for b in lb:
                    cd = Data.query.filter(db.and_(
                        Data.user_id == user_id,
                        Data.label_id == b.id
                    )).order_by(Data.timestamp).all()

                    if b.u_id is None:
                        temp_unit = None
                    else:
                        temp_unit = b.units.name

                    data.append({
                        'label': b.name,
                        'sample': [d.serialized for d in cd],
                        'units': temp_unit
                    })

                return {
                    'name': category,
                    'data': data
                }
            # if not specific categories
            # get all categories in this resource set
            ca = LinkRsData.query.filter_by(resource_set_id=resource_set_id).all()

            if ca is None:
                return None

            result = []

            # get user's data in this resource set by user_id and categories_id
            for i in ca:
                # get all labels of resource set
                lb = Label.query.filter_by(c_id=i.categories_id).all()
                data = []
                for b in lb:
                    cd = Data.query.filter(db.and_(
                        Data.user_id == user_id,
                        Data.label_id == b.id
                    )).order_by(Data.timestamp).all()
                    if b.u_id is None:
                        temp_unit = None
                    else:
                        temp_unit = b.units.name
                    data.append({
                        'label': b.name,
                        'sample': [d.serialized for d in cd],
                        'units': temp_unit
                    })
                result.append({
                    'name': i.categories.name,
                    'data': data
                })

            return result
        except NotFound as e:
            # app_log.error(repr(e), extra={'sender': 'DataSource'})
            raise e
        except Exception as e:
            # app_log.error(repr(e), extra={'sender': 'DataSource'})
            raise e
Esempio n. 55
0
def list():
    s = session_to_user(request, session)
    if s.auth_error: return auth_error_return_helper(s)

    try:
        page = int(request.args.get('page')) or 1
    except Exception:
        page = 1
    terms = request.args.get('term') or None

    orders = []
    filter = []
    filter_user = s.id
    if terms:
        for terms in csv.reader([terms], skipinitialspace=True, delimiter=' '):
            terms = terms
        for term in terms:
            subterm = term.split(':')
            subterm_len = len(subterm)

            # Filter by views
            if subterm[0] == 'views' and subterm_len == 2:
                if subterm[1][0] == '>':
                    filter.append(Object.viewcount >= subterm[1][1:])
                elif subterm[1][0] == '<':
                    filter.append(Object.viewcount <= subterm[1][1:])
                elif subterm[1][0] == '=':
                    filter.append(Object.viewcount == subterm[1][1:])

            # Order by
            elif subterm[0] == 'by' and subterm_len in (2, 3):
                if subterm_len == 3:
                    orders.append([subterm[1], subterm[2]])
                else:
                    orders.append([subterm[1], 'default'])

            # Is ...
            elif subterm[0] == 'is' and subterm_len in (2, 3):
                # Is deleted
                if subterm[1] == 'deleted':
                    if subterm_len == 3 and subterm[2] == 'no':
                        filter.append(Object.deleted == False)  # noqa
                    else:
                        filter.append(Object.deleted == True)  # noqa
                # Is type ...
                if subterm[1] in ('link', 'file'):
                    if subterm_len == 2:
                        filter.append(Object.type == subterm[1])

            # Special search features for admins
            elif s.role_admin and subterm[0] == 'user' and subterm_len == 2:
                filter_user = subterm[1]

            # No special rule, search text fields
            else:
                if not term.strip() == '':
                    term = term.replace('%', '\\%')
                    term = term.replace('*', '%')
                    filter.append(db.or_(Object.oid.like(term),
                                         Object.title.like(format_object_title(term)),
                                         Object.link.like(term)
                                         ))

    data = Object.query

    orders.append(['date_created', 'default'])
    for order in orders:
        if order[0] == 'views':
            order[0] = 'viewcount'
        elif order[0] in ('id', 'object'):
            order[0] = 'oid'
        elif order[0] == 'date':
            order[0] = 'date_created'
        elif order[0] == 'created':
            order[0] = 'date_created'
        elif order[0] == 'modified':
            order[0] = 'date_modified'
        elif order[0] == 'lastviewed':
            order[0] = 'last_viewed'

        # Order by ... string to object
        if not order[0] in ('date_created',
                            'date_modified',
                            'last_viewed',
                            'title',
                            'link',
                            'oid',
                            'viewcount',
                            'size'):
            continue
        ordero = getattr(Object, order[0])
        ordero = ordero.asc() if order[1] == 'asc' else ordero.desc()

        data = data.order_by(ordero)

    if not filter_user == '*':
        filter.append(Object.owner == filter_user)
    data = data.filter(db.and_(*filter))

    data = data.paginate(page=page, per_page=15)

    return render_template('objects/list.html', s=s,
                           data=data,
                           term=request.args.get('term'))
Esempio n. 56
0
 def auth(cls,email,password):
     user = cls.query.filter(db.and_(User.email==email,User.password==password)).first()
     return user,user and user.active
Esempio n. 57
0
 def exist_user(cls,email):
     user = cls.query.filter(db.and_(User.email==email,User.active==True)).first()
     return bool(user)
Esempio n. 58
0
 def gen():
     res = db.session.query(Event.stamp, Event.sensor_id, Event.message).filter(db.and_(Event.stamp>=start, Event.stamp<=end, Event.sensor_id.in_(sids), Event.message.in_(['ON', 'OFF']))).order_by(Event.stamp)
     for row in res.yield_per(5):
         a = '\t'.join([str(str(row.stamp)[:-6]),str(sense[row.sensor_id]), str(row.message), '\n'])
         yield a