コード例 #1
0
ファイル: test_db.py プロジェクト: Couchers-org/couchers
def test_get_parent_node_at_location(testing_communities):
    with session_scope() as session:
        w_id = get_community_id(session, "Global")  # 0 to 100
        c1_id = get_community_id(session, "Country 1")  # 0 to 50
        c1r1_id = get_community_id(session, "Country 1, Region 1")  # 0 to 10
        c1r1c1_id = get_community_id(session,
                                     "Country 1, Region 1, City 1")  # 0 to 5
        c1r1c2_id = get_community_id(session,
                                     "Country 1, Region 1, City 2")  # 7 to 10
        c1r2_id = get_community_id(session, "Country 1, Region 2")  # 20 to 25
        c1r2c1_id = get_community_id(session,
                                     "Country 1, Region 2, City 1")  # 21 to 23
        c2_id = get_community_id(session, "Country 2")  # 52 to 100
        c2r1_id = get_community_id(session, "Country 2, Region 1")  # 52 to 71
        c2r1c1_id = get_community_id(session,
                                     "Country 2, Region 1, City 1")  # 53 to 70

        assert get_parent_node_at_location(session,
                                           create_1d_point(1)).id == c1r1c1_id
        assert get_parent_node_at_location(session,
                                           create_1d_point(3)).id == c1r1c1_id
        assert get_parent_node_at_location(session,
                                           create_1d_point(6)).id == c1r1_id
        assert get_parent_node_at_location(session,
                                           create_1d_point(8)).id == c1r1c2_id
        assert get_parent_node_at_location(session,
                                           create_1d_point(15)).id == c1_id
        assert get_parent_node_at_location(session,
                                           create_1d_point(51)).id == w_id
コード例 #2
0
ファイル: pages.py プロジェクト: telalpal/couchers
    def CreatePlace(self, request, context):
        if not request.title:
            context.abort(grpc.StatusCode.INVALID_ARGUMENT,
                          errors.MISSING_PAGE_TITLE)
        if not request.content:
            context.abort(grpc.StatusCode.INVALID_ARGUMENT,
                          errors.MISSING_PAGE_CONTENT)
        if not request.address:
            context.abort(grpc.StatusCode.INVALID_ARGUMENT,
                          errors.MISSING_PAGE_ADDRESS)
        if not request.HasField("location"):
            context.abort(grpc.StatusCode.INVALID_ARGUMENT,
                          errors.MISSING_PAGE_LOCATION)
        if request.location.lat == 0 and request.location.lng == 0:
            context.abort(grpc.StatusCode.INVALID_ARGUMENT,
                          errors.INVALID_COORDINATE)

        geom = create_coordinate(request.location.lat, request.location.lng)

        with session_scope() as session:
            if request.photo_key and not session.query(Upload).filter(
                    Upload.key == request.photo_key).one_or_none():
                context.abort(grpc.StatusCode.INVALID_ARGUMENT,
                              errors.PHOTO_NOT_FOUND)

            page = Page(
                parent_node=get_parent_node_at_location(session, geom),
                type=PageType.place,
                creator_user_id=context.user_id,
                owner_user_id=context.user_id,
                thread=Thread(),
            )
            session.add(page)
            session.flush()
            page_version = PageVersion(
                page=page,
                editor_user_id=context.user_id,
                title=request.title,
                content=request.content,
                photo_key=request.photo_key if request.photo_key else None,
                address=request.address,
                geom=geom,
            )
            session.add(page_version)
            session.commit()
            return page_to_pb(page, context.user_id)
コード例 #3
0
ファイル: events.py プロジェクト: Couchers-org/couchers
    def CreateEvent(self, request, context):
        if not request.title:
            context.abort(grpc.StatusCode.INVALID_ARGUMENT,
                          errors.MISSING_EVENT_TITLE)
        if not request.content:
            context.abort(grpc.StatusCode.INVALID_ARGUMENT,
                          errors.MISSING_EVENT_CONTENT)
        if request.HasField("online_information"):
            online = True
            geom = None
            address = None
            if not request.online_information.link:
                context.abort(grpc.StatusCode.INVALID_ARGUMENT,
                              errors.ONLINE_EVENT_REQUIRES_LINK)
            link = request.online_information.link
        elif request.HasField("offline_information"):
            online = False
            if not (request.offline_information.address
                    and request.offline_information.lat
                    and request.offline_information.lng):
                context.abort(grpc.StatusCode.INVALID_ARGUMENT,
                              errors.MISSING_EVENT_ADDRESS_OR_LOCATION)
            if request.offline_information.lat == 0 and request.offline_information.lng == 0:
                context.abort(grpc.StatusCode.INVALID_ARGUMENT,
                              errors.INVALID_COORDINATE)
            geom = create_coordinate(request.offline_information.lat,
                                     request.offline_information.lng)
            address = request.offline_information.address
            link = None
        else:
            context.abort(grpc.StatusCode.INVALID_ARGUMENT,
                          errors.MISSING_EVENT_ADDRESS_LOCATION_OR_LINK)

        start_time = to_aware_datetime(request.start_time)
        end_time = to_aware_datetime(request.end_time)

        _check_occurrence_time_validity(start_time, end_time, context)

        with session_scope() as session:
            if request.parent_community_id:
                parent_node = session.execute(
                    select(Node).where(Node.id == request.parent_community_id)
                ).scalar_one_or_none()
            else:
                if online:
                    context.abort(grpc.StatusCode.INVALID_ARGUMENT,
                                  errors.ONLINE_EVENT_MISSING_PARENT_COMMUNITY)
                # parent community computed from geom
                parent_node = get_parent_node_at_location(session, geom)

            if not parent_node:
                context.abort(grpc.StatusCode.INVALID_ARGUMENT,
                              errors.COMMUNITY_NOT_FOUND)

            if (request.photo_key and not session.execute(
                    select(Upload).where(Upload.key == request.photo_key)).
                    scalar_one_or_none()):
                context.abort(grpc.StatusCode.INVALID_ARGUMENT,
                              errors.PHOTO_NOT_FOUND)

            event = Event(
                title=request.title,
                parent_node_id=parent_node.id,
                owner_user_id=context.user_id,
                thread=Thread(),
                creator_user_id=context.user_id,
            )
            session.add(event)

            occurrence = EventOccurrence(
                event=event,
                content=request.content,
                geom=geom,
                address=address,
                link=link,
                photo_key=request.photo_key
                if request.photo_key != "" else None,
                # timezone=timezone,
                during=DateTimeTZRange(start_time, end_time),
                creator_user_id=context.user_id,
            )
            session.add(occurrence)

            organizer = EventOrganizer(
                user_id=context.user_id,
                event=event,
            )
            session.add(organizer)

            subscription = EventSubscription(
                user_id=context.user_id,
                event=event,
            )
            session.add(subscription)

            attendee = EventOccurrenceAttendee(
                user_id=context.user_id,
                occurrence=occurrence,
                attendee_status=AttendeeStatus.going,
            )
            session.add(attendee)

            session.commit()

            return event_to_pb(session, occurrence, context)