Exemplo n.º 1
0
Arquivo: views.py Projeto: qpwang/lisa
def notice(request):
    data = request.REQUEST
    size = int(data.get("size", 50))
    timestamp = int(data.get("time"))
    if not timestamp:
        return json_response_error(PARAM_REQUIRED, "time")
    time_type = data.get("type", "after")
    if time_type not in ["before", "after"]:
        return json_response_error(PARAM_REQUIRED, "type")

    size = min(size, 100)

    user = request.META["user"]

    if time_type == "before":
        notices = (
            Notice.objects.filter(receive_user_id=user.id)
            .filter(status=0)
            .filter(create_time__lt=timestamp_to_datetime(timestamp))
            .order_by("-id")
            .all()[:size]
        )
    else:
        notices = (
            Notice.objects.filter(receive_user_id=user.id)
            .filter(status=0)
            .filter(create_time__gte=timestamp_to_datetime(timestamp))
            .order_by("-id")
            .all()[:size]
        )

    result = {"notices": []}

    for notice in notices:
        try:
            reply_id = notice.comment_id
            comment = Comment.objects.get(id=reply_id)
            secret = Secret.objects.get(id=comment.secret_id)
            r = {
                "id": notice.id,
                "reply_id": reply_id,
                "secret": {
                    "id": secret.id,
                    "group_id": secret.group_id,
                    "content": secret.content,
                    "time": datetime_to_timestamp(secret.create_time),
                },
                "reply_time": datetime_to_timestamp(comment.create_time),
                "reply_content": comment.content,
            }
            if comment.reply_to_id:
                replied_content = Comment.objects.get(id=comment.reply_to_id).content
                r["replied_content"] = replied_content
            result["notices"].append(r)
        except Exception as e:
            return json_response_error(DATA_ERROR, e)

    return json_response_ok(result)
Exemplo n.º 2
0
Arquivo: views.py Projeto: qpwang/lisa
def comments(request, secret_id):
    data = request.REQUEST
    size = int(data.get("size", 50))
    timestamp = int(data.get("time"))
    if not timestamp:
        return json_response_error(PARAM_REQUIRED, "time")
    time_type = data.get("type", "after")
    if time_type not in ["before", "after"]:
        return json_response_error(PARAM_REQUIRED, "type")

    size = min(size, 100)

    if time_type == "before":
        comments = (
            Comment.objects.filter(secret_id=secret_id)
            .filter(create_time__lt=timestamp_to_datetime(timestamp))
            .order_by("-id")
            .all()[:size]
        )
    else:
        comments = (
            Comment.objects.filter(secret_id=secret_id)
            .filter(create_time__gte=timestamp_to_datetime(timestamp))
            .order_by("-id")
            .all()[:size]
        )

    result = {"comments": []}

    for comment in comments:
        if comment.reply_to_id:
            replied_floor = Comment.objects.get(id=comment.reply_to_id).floor
            result["comments"].append(
                {
                    "id": comment.id,
                    "content": comment.content,
                    "time": datetime_to_timestamp(comment.create_time),
                    "floor": comment.floor,
                    "replied_floor": replied_floor,
                }
            )
        else:
            result["comments"].append(
                {
                    "id": comment.id,
                    "content": comment.content,
                    "time": datetime_to_timestamp(comment.create_time),
                    "floor": comment.floor,
                }
            )

    return json_response_ok(result)
Exemplo n.º 3
0
Arquivo: views.py Projeto: qpwang/lisa
def add_comments(request, secret_id):
    data = request.POST
    content = data.get("content")
    if not content:
        return json_response_error(PARAM_REQUIRED, "content")

    reply_to = data.get("reply_to")

    user = request.META["user"]

    new_comment = Comment.objects.filter(secret_id=secret_id).order_by("-floor").all()
    if new_comment:
        floor = new_comment[0].floor + 1
    else:
        floor = 1

    try:
        if reply_to:
            reply_to = int(reply_to)
            replied_comment = Comment.objects.get(id=reply_to)
            receive_user_id = replied_comment.author_id
            comment = Comment._add_comment(content, user.id, secret_id, reply_to, floor)
        else:
            replied_secret = Secret.objects.get(id=secret_id)
            receive_user_id = replied_secret.author_id
            comment = Comment._add_comment(content, user.id, secret_id, reply_to, floor)
        Notice._add_notice(receive_user_id, comment)
    except Exception as e:
        return json_response_error(DATA_ERROR, e)

    result = {"id": comment.id, "time": datetime_to_timestamp(comment.create_time), "floor": floor}

    return json_response_ok(result)
Exemplo n.º 4
0
Arquivo: views.py Projeto: qpwang/lisa
def secrets(request, group_id):
    data = request.POST
    size = int(data.get("size", 50))
    timestamp = int(data.get("time"))
    if not timestamp:
        return json_response_error(PARAM_REQUIRED, "time")
    time_type = data.get("type")
    if time_type not in ["before", "after"]:
        return json_response_error(PARAM_REQUIRED, "type")

    size = min(size, 100)

    if time_type == "before":
        secrets = (
            Secret.objects.filter(create_time__lt=timestamp_to_datetime(timestamp), group_id=group_id)
            .order_by("-id")
            .all()[:size]
        )
    else:
        secrets = (
            Secret.objects.filter(create_time__gte=timestamp_to_datetime(timestamp), group_id=group_id)
            .order_by("-id")
            .all()[:size]
        )

    result = {"secrets": []}
    for secret in secrets:
        hot = Comment.objects.filter(secret_id=secret.id).count()
        result["secrets"].append(
            {"id": secret.id, "content": secret.content, "hot": hot, "time": datetime_to_timestamp(secret.create_time)}
        )

    return json_response_ok(result)
Exemplo n.º 5
0
Arquivo: views.py Projeto: qpwang/lisa
def add_secrets(request, group_id):
    data = request.POST
    content = data.get("content")
    if not content:
        return json_response_error(PARAM_REQUIRED, "content")

    user = request.META["user"]

    try:
        secret = Secret._add_secret(user, group_id, content)
    except Exception as e:
        return json_response_error(DATA_ERROR, e)

    result = {"id": secret.id, "time": datetime_to_timestamp(secret.create_time)}

    return json_response_ok(result)
Exemplo n.º 6
0
Arquivo: views.py Projeto: qpwang/lisa
def sample(request):
    size = 20
    secrets = Secret.objects.order_by("-id").all()[:size]

    result = {"secrets": []}
    for secret in secrets:
        hot = Comment.objects.filter(secret_id=secret.id).count()
        result["secrets"].append(
            {
                "id": secret.id,
                "content": secret.content,
                "group_id": secret.group_id,
                "hot": hot,
                "time": datetime_to_timestamp(secret.create_time),
            }
        )

    return json_response_ok(result)
Exemplo n.º 7
0
Arquivo: views.py Projeto: qpwang/lisa
def mine(request):
    data = request.REQUEST
    size = int(data.get("size", 50))
    timestamp = int(data.get("time"))
    if not timestamp:
        return json_response_error(PARAM_REQUIRED, "time")
    time_type = data.get("type", "after")
    if time_type not in ["before", "after"]:
        return json_response_error(PARAM_REQUIRED, "type")

    size = min(size, 100)

    user = request.META["user"]

    if time_type == "before":
        secrets = (
            Secret.objects.filter(author_id=user.id)
            .filter(create_time__lt=timestamp_to_datetime(timestamp))
            .order_by("-id")
            .all()[:size]
        )
    else:
        secrets = (
            Secret.objects.filter(author_id=user.id)
            .filter(create_time__gte=timestamp_to_datetime(timestamp))
            .order_by("-id")
            .all()[:size]
        )

    result = {"secrets": []}

    for secret in secrets:
        result["secrets"].append(
            {
                "id": secret.id,
                "time": datetime_to_timestamp(secret.create_time),
                "content": secret.content,
                "group_id": secret.group_id,
            }
        )

    return json_response_ok(result)
Exemplo n.º 8
0
Arquivo: views.py Projeto: qpwang/lisa
def group_list(request):

    user = request.META["user"]

    user_group_list = GroupUserRelation.objects.filter(user_id=user.id, status=0).all()

    group_id_list = [relation.group_id for relation in user_group_list]
    relation_time_dict = dict([(relation.group_id, relation.update_time) for relation in user_group_list])

    group_list = Group.objects.filter(id__in=group_id_list).all()

    result = []
    for group in group_list:
        result.append(
            {
                "id": group.id,
                "name": group.name,
                "pinyin": group.pinyin,
                "py_first": group.py_first,
                "time": datetime_to_timestamp(relation_time_dict[group.id]),
            }
        )

    return json_response_ok(result)
Exemplo n.º 9
0
Arquivo: views.py Projeto: qpwang/lisa
            secrets = (
                Secret.objects.filter(create_time__gte=timestamp_to_datetime(timestamp)).order_by("-id").all()[:size]
            )
    except Exception, e:
        return json_response_error(DATA_ERROR, e)

    result = {"secrets": []}
    for secret in secrets:
        hot = Comment.objects.filter(secret_id=secret.id).count()
        result["secrets"].append(
            {
                "id": secret.id,
                "content": secret.content,
                "group_id": secret.group_id,
                "hot": hot,
                "time": datetime_to_timestamp(secret.create_time),
            }
        )

    return json_response_ok(result)


@user_auth
def my_secrets(request):
    data = request.POST
    size = data.get("size", 50)
    timestamp = data.get("time")
    if not timestamp:
        return json_response_error(PARAM_REQUIRED, "time")
    time_type = data.get("type", "after")
    if time_type not in ["before", "after"]: