Example #1
0
def states():
    if request.method == 'GET':
        #get list states
        states_list = []
        states = State.select()
        for state in states:
            states_list.append(state.to_hash())
        return jsonify(states_list)

    elif request.method == 'POST':
        #create new state
        post_name = request.form['name']
        states = State.select()
        for state in states:
            if state.name == post_name:
                message = {
                    'code': 10001,
                    'msg': 'State already exists',
                }
                res = jsonify(message)
                res.status_code = 409
                return res
        else:
            new_state = State.create(name=post_name)
            return jsonify(new_state.to_hash())
Example #2
0
def handle_states():
    '''Returns all the states from the database as JSON objects with a GET
    request, or adds a new state to the database with a POST request. Refer to
    exception rules of peewee `get()` method for additional explanation of
    how the POST request is handled:
    http://docs.peewee-orm.com/en/latest/peewee/api.html#SelectQuery.get
    '''
    if request.method == 'GET':
        list = ListStyle().list(State.select(), request)
        return jsonify(list), 200

    elif request.method == 'POST':
        params = request.values

        '''Check that all the required parameters are made in request.'''
        required = set(["name"]) <= set(request.values.keys())
        if required is False:
            return jsonify(msg="Missing parameter."), 400

        try:
            State.select().where(State.name == request.form['name']).get()
            return jsonify(code=10001, msg="State already exists"), 409
        except State.DoesNotExist:
            state = State.create(name=request.form['name'])
            return jsonify(state.to_dict()), 201
Example #3
0
def get_places_by_city(state_id, city_id):
    """
    Get all places
    List all places in the given city in the database.
    ---
    tags:
        - Place
    parameters:
        -
            name: state_id
            in: path
            type: integer
            required: True
            description: ID of the state
        -
            name: city_id
            in: path
            type: integer
            required: True
            description: ID of the city
    responses:
        200:
            description: List of all places
            schema:
                $ref: '#/definitions/get_places_get_Places'
    """
    try:
        ''' Check if the state_id exists '''
        query = State.select().where(State.id == state_id)
        if not query.exists():
            raise LookupError('state_id')

        ''' Check if the city_id exists '''
        query = City.select().where(City.id == city_id)
        if not query.exists():
            raise LookupError('city_id')

        ''' Check if the city_id is associated to the state_id '''
        city = City.get(City.id == city_id)
        query = State.select().where(State.id == city.state, State.id == state_id)
        if not query.exists():
            raise LookupError('city_id, state_id')

        ''' Return all places in the given city '''
        data = Place.select().where(Place.city == city.id)
        return ListStyle.list(data, request), 200
    except LookupError as e:
        abort(404)
    except Exception as error:
        abort(500)
Example #4
0
def get_states():
    """
    Get all states
    List all states in the database.
    ---
    tags:
        - State
    responses:
        200:
            description: List of all states
            schema:
                id: States
                required:
                    - data
                    - paging
                properties:
                    data:
                        type: array
                        description: states array
                        items:
                            $ref: '#/definitions/get_state_get_State'
                    paging:
                        description: pagination
                        schema:
                            $ref: '#/definitions/get_amenities_get_Paging'
    """
    try:
        ''' Returns a list of states in list named result '''
        data = State.select()
        return ListStyle.list(data, request), 200
    except Exception as e:
        abort(500)
Example #5
0
def create_state():
    """
    Create a state
    """
    data = request.form
    try:
        if 'name' not in data:
            raise KeyError('name')

        state_check = State.select().where(State.name == data['name'])
        new = State.create(name=data['name'])
        res = {}
        res['code'] = 201
        res['msg'] = "State was created successfully"
        return res, 201
    except KeyError as e:
        response = {}
        response['code'] = 40000
        response['msg'] = 'Missing parameters'
        return response, 400
    except Exception as e:
        response = {}
        response['code'] = 10001
        response['msg'] = "State already exists"
        return response, 409
Example #6
0
def handle_state_id(state_id):
    '''Select the state with the id from the database and store as the variable
    `state` with a GET request method. Update the data of the particular state
    with a PUT request method. This will take the parameters passed and update
    only those values. Remove the state with this id from the database with
    a DELETE request method.

    Keyword arguments:
    state_id: The id of the state from the database.
    '''
    try:
        state = State.select().where(State.id == state_id).get()
    except State.DoesNotExist:
        return jsonify(msg="There is no state with this id."), 404

    if request.method == 'GET':
        return jsonify(state.to_dict()), 200

    elif request.method == 'DELETE':
        try:
            state = State.delete().where(State.id == state_id)
        except State.DoesNotExist:
            raise Exception("There is no state with this id.")
        state.execute()
        return jsonify(msg="State deleted successfully."), 200
Example #7
0
def handle_state_id(state_id):
    '''Select the state with the id from the database and store as the variable
    `state` with a GET request method. Update the data of the particular state
    with a PUT request method. This will take the parameters passed and update
    only those values. Remove the state with this id from the database with
    a DELETE request method.

    Keyword arguments:
    state_id: The id of the state from the database.
    '''
    try:
        state = State.select().where(State.id == state_id).get()
    except State.DoesNotExist:
        return jsonify(msg="There is no state with this id."), 404

    if request.method == 'GET':
        return jsonify(state.to_dict()), 200

    elif request.method == 'DELETE':
        try:
            state = State.delete().where(State.id == state_id)
        except State.DoesNotExist:
            raise Exception("There is no state with this id.")
        state.execute()
        return jsonify(msg="State deleted successfully."), 200
Example #8
0
def states():
    """Handle GET and POST requests to /states route.

     Return a list of all states in the database in the case of a GET request.
     Create a new state in the database in the case of a POST request
    """
    # handle GET requests:
    # --------------------------------------------------------------------------
    if request.method == 'GET':
        list = []
        for record in State.select():
            hash = record.to_hash()
            list.append(hash)
        return jsonify(list)

    # handle POST requests:
    # --------------------------------------------------------------------------
    elif request.method == 'POST':
        try:
            record = State(name=request.form["name"])
            record.save()
            return jsonify(record.to_hash())

        # return 409 state with given name already exists
        except IntegrityError:
            return json_response(add_status_=False,
                                 status_=409,
                                 code=10001,
                                 msg="State already exists")
Example #9
0
def states():
    """Handle GET and POST requests to /states route.

     Return a list of all states in the database in the case of a GET request.
     Create a new state in the database in the case of a POST request
    """
    # handle GET requests:
    # --------------------------------------------------------------------------
    if request.method == 'GET':
        list = ListStyle.list(State.select(), request)
        return jsonify(list)

    # handle POST requests:
    # --------------------------------------------------------------------------
    elif request.method == 'POST':
        try:
            record = State(name=request.form["name"])
            record.save()
            return jsonify(record.to_hash())

        # return 409 state with given name already exists
        except IntegrityError:
                return json_response(
                    add_status_=False,
                    status_=409,
                    code=10001,
                    msg="State already exists"
                )
Example #10
0
def handle_place_state_id(state_id):
    '''Retrieve all the places with a state of that passed in the URL.

    Keyword arguments:
    state_id -- The id of the state that this place belongs.
    '''
    if request.method == 'GET':
        try:
            State.select().where(State.id == state_id).get()
        except State.DoesNotExist:
            return jsonify("No state exists with this id."), 400

        list = ListStyle().list((Place.select().join(City).join(State).where(
            State.id == state_id)), request)

        return jsonify(list), 200
Example #11
0
def get_states():
    if request.method == 'GET':
        states = []
        query = State.select()
        for state in query:
            states.append(state.to_hash())
        return jsonify(states)
Example #12
0
def del_state(id):
    id_check = State.select().where(State.id == id)
    if not id_check:
        return {'code': 404, 'msg': 'State not found'}, 404

    item = State.delete().where(State.id == id)
    item.execute()
    return {'code': 200, 'msg': 'Deleted successfully'}, 200
Example #13
0
def get_state(state_id):
    """
    Get the given state
    Returns the given state in the database.
    ---
    tags:
    	- State
    parameters:
    	-
    		in: path
    		name: state_id
    		type: integer
    		required: True
    		description: ID of the state
    responses:
        200:
            description: State returned successfully
            schema:
                id: State
                required:
                    - name
                    - id
                    - created_at
                    - updated_at
                properties:
                    name:
                        type: string
                        description: name of the given state
                        default: None
                    id:
                        type: integer
                        description: id of the state
                        default: 1
                    created_at:
                        type: datetime string
                        description: date and time the state was created in the database
                        default: '2016-08-11 20:30:38'
                    updated_at:
                        type: datetime string
                        description: date and time the state was updated in the database
                        default: '2016-08-11 20:30:38'
        404:
            description: State was not found
        500:
            description: Request could not be processed
    """
    try:
        ''' Check that state_id exists '''
        query = State.select().where(State.id == state_id)
        if not query.exists():
            raise LookupError('state_id')

        state = State.get(State.id == state_id)
        return state.to_dict(), 200
    except LookupError as e:
        abort(404)
    except Exception as e:
        abort(500)
Example #14
0
def state_places(state_id):
	state = State.select().where(State.id == state_id)

	if state.wrapped_count() < 1:
		return json_response(status_=404, code=10002, msg="state not found")

	query = Place.select().join(City).join(State).where(State.id == state_id)

	return ListStyle.list(query, request)
Example #15
0
def state_create_modify():
    if request.method == 'GET':
        state_list = State.select()
        order_values = [i.to_hash() for i in state_list]
        return jsonify(order_values)

    elif request.method == 'POST':

        check_state_name = State.select().where(
            State.name == request.form['name'])

        if check_state_name:
            error_msg = {'code': 10001, 'msg': 'State already exists'}
            return jsonify(error_msg)

        else:
            state = State.create(name=request.form['name'])
        return jsonify(state.to_hash())
Example #16
0
def create_state():
    data = request.form
    name_check = State.select().where(State.name == data['name'])
    if name_check:
        return {'code': 10001, 'msg': 'State already exists'}, 409
    state = State.create(
        name = data['name']
    )
    return {'code': 201,'msg': 'State was created successfully'}, 201
Example #17
0
def create_new_city(state_id):
    post_data = request.values
    if 'name' in post_data:
        city_query = City.select().where(City.name == post_data['name'])
        state_query = State.select().where(State.id == state_id).get()
        if city_query.exists():
            out = {'code': 10002, 'msg': 'City already exists in this state'}
            return out, 409
        city_row = City.create(state=state_query, name=post_data['name'])
        return city_row.to_hash()
    else:
        return {"code":404, "msg":"not found"}, 404
Example #18
0
def state(number):
    if request.method == 'GET':
        query = State.get(State.id == number)
        return query.to_hash()
    else:
        try:
            query = State.select().where(State.id == number).get()
        except:
            return {'code':404, 'msg':'state not found'}, 404
        out_json = query.to_hash()
        query.delete_instance()
        return out_json
Example #19
0
def create_new_state():
    post_data = request.values
    if 'name' not in post_data:
        return {'code':400, 'msg':'bad request'}, 400
    state_query = State.select().where(State.name == post_data['name'])
    if state_query.exists():
        out = {'code': 10001, 'msg': 'State already exists'}
        return out, 409
    try:
        state_row = State.create(name=post_data['name'])
        return state_row.to_hash()
    except:
        return {'code':500, 'msg':'database connection error'}, 500
Example #20
0
def app_states():
    if request.method == "GET":
        try:
            query = State.select()
            return ListStyles.list(query, request), 200
        except State.DoesNotExist:
            return jsonify({"code": 404, "msg": "No tables exist yet"}), 404

    elif request.method == "POST":
        try:
            new = State.create(name=str(request.form['name']))
            return jsonify(new.to_dict()), 201
        except:
            return jsonify({"code": 10001, "msg": "State already exists"}), 409
Example #21
0
def handle_states():
    '''Returns all the states from the database as JSON objects with a GET
    request, or adds a new state to the database with a POST request. Refer to
    exception rules of peewee `get()` method for additional explanation of
    how the POST request is handled:
    http://docs.peewee-orm.com/en/latest/peewee/api.html#SelectQuery.get
    '''
    if request.method == 'GET':
        list = ListStyle().list(State.select(), request)
        return jsonify(list), 200

    elif request.method == 'POST':
        params = request.values
        '''Check that all the required parameters are made in request.'''
        required = set(["name"]) <= set(request.values.keys())
        if required is False:
            return jsonify(msg="Missing parameter."), 400

        try:
            State.select().where(State.name == request.form['name']).get()
            return jsonify(code=10001, msg="State already exists"), 409
        except State.DoesNotExist:
            state = State.create(name=request.form['name'])
            return jsonify(state.to_dict()), 201
Example #22
0
def list_of_states():
    if request.method == 'GET':
        list = ListStyle.list(State.select(), request)
        return jsonify(list)

    if request.method == 'POST':
        # name_state = request.form['name']
        try:
            new_state = State(name=request.form['name'])
            # saving the changes
            new_state.save()
            # returning the new information in hash form
            return "New State entered! -> %s\n" % (new_state.name)
        except:
            return make_response(jsonify({'code': 10000,
                                          'msg': 'State already exist'}), 409)
Example #23
0
def delete_one_state(state_id):
    """
    Delete an state
    Deletes an state based on id.
    ---
    tags:
      - state
    responses:
      200:
        description: Success message
        schema:
          id: success_message
          properties:
            status:
              type: number
              description: status code
              default: 200
            msg:
              type: string
              description: Status message
              default: 'Success'
      400:
          description: Error message
          schema:
            id: error_message
            properties:
              status:
                type: number
                description: status code
                default: 400
              msg:
                type: string
                description: Status message
                default: 'Error'
    """
    try:
        states = State.select().where(State.id == int(state_id))
        state = None
        for u in states:
            state = u
        if state == None:
            return error_msg(400, 400, "Error")
        state.delete_instance()
    except:
        return error_msg(400, 400, "Error")
    return error_msg(200, 200, "Success")
Example #24
0
def states():
	if request.method == 'GET':
		query = State.select()

		return ListStyle.list(query, request), 200

	elif request.method == 'POST':
		try:
			if "name" not in request.form:
				return json_response(status_=400, msg="missing parameters", code=40000)

			insert = State(name=str(request.form["name"]))
			insert.save()
			return jsonify(insert.to_dict()), 201

		except IntegrityError:
			return json_response(status_=409,
								code=10001,
								msg="State already exists")
Example #25
0
def list_of_states():
    if request.method == 'GET':
        list = ListStyle.list(State.select(), request)
        return jsonify(list)

    if request.method == 'POST':
        # name_state = request.form['name']
        try:
            new_state = State(name=request.form['name'])
            # saving the changes
            new_state.save()
            # returning the new information in hash form
            return "New State entered! -> %s\n" % (new_state.name)
        except:
            return make_response(
                jsonify({
                    'code': 10000,
                    'msg': 'State already exist'
                }), 409)
Example #26
0
def get_places_by_state(state_id):
    """
    Get all places by state
    List all places in the given state in the database.
    ---
    tags:
        - Place
    parameters:
        -
            name: state_id
            in: path
            type: integer
            required: True
            description: ID of the state
    responses:
        200:
            description: List of all places in state
            schema:
                $ref: '#/definitions/get_places_get_Places'
    """
    try:
        ''' Check if state exists '''
        query = State.select().where(State.id == state_id)
        if not query.exists():
            raise LookupError('state_id')

        ''' Create a list of city ids in the state '''
        query = City.select().where(City.state == state_id)
        if not query.exists():
            return ListStyle.list(query, request), 200
        cities = []
        for city in query:
            cities.append(city.id)

        ''' Return the places in listed cities '''
        data = Place.select().where(Place.city << cities)
        return ListStyle.list(data, request), 200
    except LookupError as e:
        abort(404)
    except Exception as e:
        print e.message
        abort(500)
Example #27
0
def delete_state(state_id):
    """
    Delete the given state
    Deletes the given state in the database.
    ---
    tags:
        - State
    parameters:
        -
            in: path
            name: state_id
            type: string
            required: True
            description: ID of the state
    responses:
        200:
            description: State deleted successfully
            schema:
                $ref: '#/definitions/delete_amenity_delete_delete_200'
        404:
            description: State was not found
        500:
            description: Request could not be processed
    """
    try:
        ''' Check that state_id exists '''
        query = State.select().where(State.id == state_id)
        if not query.exists():
            raise LookupError('state_id')

        ''' Delete the given state '''
        delete_state = State.delete().where(State.id == state_id)
        delete_state.execute()
        response = {}
        response['code'] = 200
        response['msg'] = "State account was deleted"
        return response, 200
    except LookupError as e:
        abort(404)
    except Exception as error:
        abort(500)
Example #28
0
def get_all_states():
    """
    Get all states
    List all states in the database.
    ---
    tags:
      - state
    responses:
      200:
        description: List of all states
        schema:
          id: states_array
          properties:
            states:
              type: array
              description: states array
              items:
                properties:
                    name:
                        type: string
                        description: name of the state
                        default: "California"
                    id:
                        type: number
                        description: id of the state
                        default: 0
                    created_at:
                        type: datetime string
                        description: date and time the state was created
                        default: '2016-08-11 20:30:38.959846'
                    updated_at:
                        type: datetime string
                        description: date and time the state was updated
                        default: '2016-08-11 20:30:38.959846'
              default: [{"name": "California", "id": 0, "created_at": '2016-08-11 20:30:38.959846', "updated_at": '2016-08-11 20:30:38.959846'}, {"name": "hammock", "id": 1, "created_at": '2016-08-11 20:30:38.959846', "updated_at": '2016-08-11 20:30:38.959846'}]
    """
    states = []
    for state in State.select():
        states.append(state.to_dict())
    return jsonify({"states": states})
Example #29
0
def get_statedddd_by_id(state_id):
    """
    Get one state
    Returns information about one state.
    ---
    tags:
      - state
    responses:
      200:
        description: Information about one state
        schema:
          id: amenity
          properties:
            name:
                type: string
                description: name of the state
                default: "California"
            id:
                type: number
                description: id of the state
                default: 0
            created_at:
                type: datetime string
                description: date and time the state was created
                default: '2016-08-11 20:30:38.959846'
            updated_at:
                type: datetime string
                description: date and time the state was updated
                default: '2016-08-11 20:30:38.959846'
    """
    if not isinstance(int(state_id), int):
        return error_msg(400, 400, "Error")
    states = State.select().where(State.id == int(state_id))
    state = None
    for u in states:
        state = u
    if state == None:
        return error_msg(400, 400, "Error")
    return jsonify(state.to_dict())
Example #30
0
def states(state_id=None):
    
    if request.method == "GET":
        if state_id != None:
            try:
                state = State.get(State.id == int(state_id))
                return state.to_dict()
            except:
                pass
            return { 'code': 404, 'msg': "not found" }, 404

        return { 'data': [state.to_dict() for state in State.select()] }, 200
    
    elif request.method == "POST":
        name = request.form.get('name')
        
        try:
            new_state = State.create(name=name)
        except IntegrityError:
           return { 'code': 10001, 'msg': "State already exists" }, 409
        except Exception as e:
            raise e 
        
        return new_state.to_dict(), 201

    elif request.method == "DELETE":
        if state_id != None:
            state = None
            try:
                state = State.get(State.id == int(state_id))
            except:
                state = None
            
            if state != None:
                state.delete_instance()
                return {}, 200

        return { 'code': 404, 'msg': "not found" }, 404
Example #31
0
    def test_create(self):
        """
        Test proper creation (or non-creation) of state records upon POST
        requests to API.
        """
        # test creation of state with all parameters provided in POST request

        State.drop_table()
        database.create_tables([State], safe=True)

        POST_request1 = self.app.post('/states', data=dict(
            name='namestring'
        ))

        self.assertEqual(POST_request1.status[:3], '200')

        now = datetime.now().strftime('%d/%m/%Y %H:%M')

        self.assertEqual(State.get(State.id == 1).name, 'namestring')
        self.assertEqual(State.get(State.id == 1).created_at.strftime('%d/%m/%Y %H:%M'), now)
        self.assertEqual(State.get(State.id == 1).updated_at.strftime('%d/%m/%Y %H:%M'), now)

        # test creation of state in all cases of a parameter missing in POST request
        POST_request2 = self.app.post('/states', data=dict())
        self.assertEqual(POST_request2.status[:3], '400')

        # test that state ID for sole record in database is correct
        self.assertEqual(State.select().get().id, 1)

        # test that a post request with a duplicate name value is rejected
        POST_request3 = self.app.post('/states', data=dict(
            name='namestring'
        ))

        self.assertEqual(POST_request3.status[:3], '409')
        self.assertEqual(json.loads(POST_request3.data), {'code': 10001, 'msg': 'State already exists'})
Example #32
0
def get_all_states():
    query = State.select()
    return ListStyle.list(query,request)
Example #33
0
def create_place_by_city(state_id, city_id):
    """
    Create a new place
    Create a new place in the given city
    ---
    tags:
        - Place
    parameters:
        -
            name: state_id
            in: path
            type: integer
            required: True
            description: id of the state
        -
            name: city_id
            in: path
            type: integer
            required: True
            description: id of the city
        -
            name: owner_id
            in: form
            type: integer
            required: True
            description: user id of the owner
        -
            name: name
            in: form
            type: string
            required: True
            description: name of the place
        -
            name: description
            in: form
            type: string
            description: description of the place
        -
            name: number_rooms
            in: form
            type: integer
            description: number of rooms
        -
            name: number_bathrooms
            in: form
            type: integer
            description: number of bathrooms
        -
            name: max_guest
            in: form
            type: integer
            description: the max number of guests
        -
            name: price_by_night
            in: form
            type: integer
            description: the price per night of the location
        -
            name: latitude
            in: form
            type: float
            description: the latitude of the place location
        -
            name: longitude
            in: form
            type: float
            description: the longitude of the place location
    responses:
        201:
            description: Place was created
            schema:
                $ref: '#/definitions/create_amenity_post_post_success'
        400:
            description: Issue with place request
        404:
            description: Owner or city was not found
        500:
            description: The request was not able to be processed
    """
    try:
        data = {}
        for key in request.form.keys():
        	for value in request.form.getlist(key):
        		data[key] = value

        ''' Check for required keys '''
        if not 'owner_id' in data:
            raise KeyError('owner_id')
        if not 'name' in data:
            raise KeyError('name')

        ''' Check required key value data types '''
        if not type_test(data['owner_id'], int):
            raise TypeError('owner_id is not an integer')
        if not type_test(data['name'], 'string'):
            raise TypeError('name is not a string')

        ''' Check optional key value data types '''
        if 'description' in data and not type_test(data['description'], 'string'):
            raise TypeError('description is not a string')
        if 'number_rooms' in data and not type_test(data['number_rooms'], int):
            raise TypeError('number_rooms is not an integer')
        if 'number_bathrooms' in data and not type_test(data['number_bathrooms'], int):
            raise TypeError('number_bathrooms is not an integer')
        if 'max_guest' in data and not type_test(data['max_guest'], int):
            raise TypeError('max_guest is not an integer')
        if 'price_by_night' in data and not type_test(data['price_by_night'], int):
            raise TypeError('price_by_night is not an integer')
        if 'latitude' in data and not type_test(data['latitude'], float):
            raise TypeError('latitude is not a float')
        if 'longitude' in data and not type_test(data['longitude'], float):
            raise TypeError('longitude is not a float')

        ''' Check if the state_id exists '''
        query = State.select().where(State.id == state_id)
        if not query.exists():
            raise LookupError('state_id')

        ''' Check if the city_id exists '''
        query = City.select().where(City.id == city_id)
        if not query.exists():
            raise LookupError('city_id')

        ''' Check if the city_id is associated to the state_id '''
        city = City.get(City.id == city_id)
        query = State.select().where(State.id == city.state, State.id == state_id)
        if not query.exists():
            raise LookupError('city_id, state_id')

        ''' Check if the owner_id exists '''
        query = User.select().where(User.id == data['owner_id'])
        if not query.exists():
            raise LookupError('owner_id')

        new = Place(
            owner = data['owner_id'],
            name = data['name'],
            city = city.id
        )
        if data['description']:
            new.description = data['description']
        if data['number_rooms']:
            new.number_rooms = data['number_rooms']
        if data['number_bathrooms']:
            new.number_bathrooms = data['number_bathrooms']
        if data['max_guest']:
            new.max_guest = data['max_guest']
        if data['price_by_night']:
            new.price_by_night = data['price_by_night']
        if data['latitude']:
            new.latitude = data['latitude']
        if data['longitude']:
            new.longitude = data['longitude']
        new.save()
        res = {}
        res['code'] = 201
        res['id'] = new.id
        res['msg'] = "Place was created successfully"
        return res, 201
    except KeyError as e:
        res = {}
        res['code'] = 40000
        res['msg'] = 'Missing parameters'
        return res, 400
    except LookupError as e:
        abort(404)
    except TypeError as e:
        res = {}
        res['code'] = 400
        res['msg'] = e.message
        return res, 400
    except Exception as e:
        print e.message
        abort(500)
Example #34
0
def get_states():
    """
    Get all states
    """
    data = State.select()
    return ListStyle.list(data, request), 200
Example #35
0
def state_city_place(state_id, city_id):
	if request.method == "GET":
		try:
			state_test = State.select().where(State.id == state_id)

			if state_test.wrapped_count() < 1:
				return json_response(status_=404, code=10002, msg="state not found") 

			city_test = City.select().where(City.id == city_id)

			if city_test.wrapped_count() < 1:
				return json_response(status_=404, code=10002, msg="state not found") 

			query = Place.select().where(Place.city == city_id)

			return ListStyle.list(query, request), 200

		except Place.DoesNotExist:
			return json_response(status_=404, code=404, msg="not found")

	elif request.method == "POST":
		if "name" not in request.form or "owner_id" not in request.form:
			return json_response(status_=400, code=40000, msg="missing parameters")

		try:
			city = City.get(City.id == city_id, City.state_id == state_id)

		except City.DoesNotExist:
			return json_response(status_=404, msg="City does not exist")

		try:
			place = Place(owner=request.form['owner_id'],
						city=city_id,
						name=request.form['name'])

			if request.form['description']:
				place.description = str(request.form['description'])

			if request.form['number_rooms']:
				place.number_rooms = int(request.form['number_rooms'])

			if request.form['number_bathrooms']:
				place.number_bathrooms = int(request.form['number_bathrooms'])

			if request.form['max_guest']:
				place.max_guest = int(request.form['max_guest'])

			if request.form['price_by_night']:
				place.price_by_night = int(request.form['price_by_night'])

			if request.form['latitude']:
				place.latitude = float(request.form['latitude'])

			if request.form['longitude']:
				place.longitude = float(request.form['longitude'])

			place.save()

		except IntegrityError:
			return json_response(status_=409, msg="Name already exists")

        return jsonify(place.to_dict()), 201
Example #36
0
def get_states():
    states = []
    query = State.select()
    for i in query:
        states.append(i.to_hash())
    return jsonify(states), 200
Example #37
0
def create_state():
    """
    Create a new state
    Create a new state in the database
    ---
    tags:
        - State
    parameters:
        -
            name: name
            in: form
            type: string
            required: True
            description: Name of the state
    responses:
        201:
            description: State was created
            schema:
                $ref: '#/definitions/create_amenity_post_post_success'
        400:
            description: Issue with state request
        409:
            description: State already exists
        500:
            description: The request was not able to be processed
    """
    data = {}
    for key in request.form.keys():
    	for value in request.form.getlist(key):
    		data[key] = value
    try:
        ''' Check that name key is in data '''
        if not 'name' in data:
            raise KeyError('name')

        ''' Check that name key is not null '''
        if not data['name']:
            raise TypeError("'name' cannot be NULL")

        ''' Check that name key value is a string '''
        if not type_test(data['name'], 'string'):
            raise TypeError("'name' must be a string")

        ''' Check if state already exists '''
        query = State.select().where(State.name == data['name'])
        if query.exists():
            raise ValueError('State already exists')

        new = State.create(
            name = data['name']
        )
        res = {}
        res['code'] = 201
        res['id'] = new.id
        res['msg'] = "State was created successfully"
        return res, 201
    except TypeError as e:
        response = {}
        response['code'] = 400
        response['msg'] = e.message
        return response, 400
    except ValueError as e:
        response = {}
        response['code'] = 10001
        response['msg'] = e.message
        return response, 409
    except KeyError as e:
        response = {}
        response['code'] = 40000
        response['msg'] = 'Missing parameters'
        return response, 400
    except Exception as e:
        print e.message
        abort(500)