def test_clone(self):
api = Namespace("test")
parent = api.model("Parent", {})
api.clone("Child", parent, {})
assert "Child" in api.models
assert "Parent" in api.models
def test_clone(self):
api = Namespace('test')
parent = api.model('Parent', {})
api.clone('Child', parent, {})
assert 'Child' in api.models
assert 'Parent' in api.models
def create_restful_namespace(self, name: str,
description: str) -> Namespace:
current_app.logger.debug(f"Creating the {name} Namespace")
# create and set up namespace
ns = Namespace(name, description=description)
response_env = ns.model(response_envelope.get("name"),
response_envelope.get("fields"))
meta_env = ns.model(meta_envelope.get("name"),
meta_envelope.get("fields"))
links_env = ns.model(links_envelope.get("name"),
links_envelope.get("fields"))
get_entity_model = ns.clone(f"get_entity_model", response_envelope,
{"data": fields.Raw})
get_entity_list_model = ns.clone(
f"get_entity_list_model",
response_envelope,
{
"data": fields.List(fields.Raw),
"_meta": fields.Nested(meta_env),
"_links": fields.Nested(links_env),
},
)
self._ns = ns
return ns
def test_clone_with_multiple_parents(self):
api = Namespace('test')
grand_parent = api.model('GrandParent', {})
parent = api.model('Parent', {})
api.clone('Child', grand_parent, parent, {})
assert 'Child' in api.models
assert 'Parent' in api.models
assert 'GrandParent' in api.models
def test_clone_with_multiple_parents(self):
api = Namespace("test")
grand_parent = api.model("GrandParent", {})
parent = api.model("Parent", {})
api.clone("Child", grand_parent, parent, {})
assert "Child" in api.models
assert "Parent" in api.models
assert "GrandParent" in api.models
),
"end":
fields.String(
description="end-time of the time program entry",
required=True,
example="11:15",
),
},
)
time_prog_with_entries_model = api.clone(
"time_prog_with_entries_model",
time_prog_model,
{
"entries":
fields.List(
fields.List(fields.Nested(time_prog_entry_model, required=True),
required=True),
required=True,
),
},
)
@api.route("/")
class TimeProgs(Resource):
@api.marshal_list_with(time_prog_model, skip_none=True)
def get(self):
""" Returns a list of all available time programs of the heat pump. """
_LOGGER.info("*** [GET] %s", request.url)
with HtContext(ht_heatpump):
time_progs = ht_heatpump.get_time_progs()
description="Detailed description of the purpose of the field"),
"args":
ArgsField(),
"kwargs":
fields.Raw(),
"name":
fields.String(),
"fields":
fields.List(SubformField),
},
)
field_model_ni = api.clone(
"Field (no cv items)",
field_model,
{
"property": fields.Nested(property_model_ni_id),
},
)
form_model = api.model(
"Forms",
{
"label":
fields.String(description="Human readable name of the entry"),
"name":
fields.String(
description="Internal representation of the entry (in snake_case)"
),
"description":
fields.String(description="Detailed description of the intended use",
from ..schemas import IngredientSchema
from ..utils import (
generate_link_metadata,
generate_query_metadata,
set_search_filter,
set_sort_order,
)
ns = Namespace("Ingredients", description="Ingredient Operations")
response_env = ns.model(response_envelope.get("name"), response_envelope.get("fields"))
meta_env = ns.model(meta_envelope.get("name"), meta_envelope.get("fields"))
links_env = ns.model(links_envelope.get("name"), links_envelope.get("fields"))
get_ingredient_model = ns.clone(
"get_ingredient_model", response_env, {"data": fields.Raw}
)
get_ingredient_list_model = ns.inherit(
"get_ingredient_list_model",
response_env,
{
"data": fields.List(fields.Raw),
"_meta": fields.Nested(meta_env),
"_links": fields.Nested(links_env),
},
)
@ns.route("", endpoint="list_ingredients")
@ns.response(HTTPStatus.OK.value, HTTPStatus.OK.phrase, model=get_ingredient_list_model)
@ns.response(HTTPStatus.BAD_REQUEST.value, HTTPStatus.BAD_REQUEST.phrase)
from ..models import links_envelope, meta_envelope, response_envelope
from ..schemas import CuisineSchema
from ..utils import role_required
from ..dao import SqlalchemyDAO
ns = Namespace("Cuisines", description="Cuisine Operations")
response_env = ns.model(response_envelope.get("name"),
response_envelope.get("fields"))
meta_env = ns.model(meta_envelope.get("name"), meta_envelope.get("fields"))
links_env = ns.model(links_envelope.get("name"), links_envelope.get("fields"))
cuisine_model = ns.model(CuisineSchema.get_restx_model().name,
CuisineSchema.get_restx_model())
get_cuisine_model = ns.clone("get_cuisine_model", response_env,
{"data": fields.Nested(cuisine_model)})
get_cuisine_list_model = ns.inherit(
"get_cuisine_list_model",
response_env,
{
"data": fields.List(fields.Nested(cuisine_model)),
"_meta": fields.Nested(meta_env),
"_links": fields.Nested(links_env),
},
)
@ns.route("", endpoint="list_cuisines")
class CuisineListResource(Resource):
@ns.marshal_with(get_cuisine_list_model)
def get(self):
fields.Nested(cv_model),
"synonyms":
fields.List(
fields.String(description="Alternatives to the primary name")),
"description":
fields.String(description="A detailed description of the intended use",
default=""),
"deprecated":
fields.Boolean(default=False),
},
)
property_model_ni = api.clone(
"Property (no cv items)",
property_model,
{
"value_type": fields.Nested(cv_model_ni),
},
)
property_model_id = api.inherit(
"Property with id",
property_model,
{
"id":
fields.String(attribute="id",
description="The unique identifier of the entry"),
},
)
property_model_ni_id = api.inherit(
"description": "更新demo",
"properties": {
"demo_name": {
"description": "demo名称",
"type": "string",
"max_bytes_len": 15
},
},
"additionalProperties": False
}
demo_api.models[
marshalling_models.base_resp.name] = marshalling_models.base_resp
demo_api.models[
marshalling_models.demo_model.name] = marshalling_models.demo_model
crud_resp = demo_api.clone(
'demo_resp', marshalling_models.base_resp,
{'data': fields.Nested(marshalling_models.demo_model, skip_none=True)})
list_resp = demo_api.clone(
'demos_resp', marshalling_models.base_resp, {
'data':
fields.Nested(demo_api.model(
'demos_data', {
'demos':
fields.List(
fields.Nested(marshalling_models.demo_model,
skip_none=True))
}),
skip_none=True)
})
from flask_restx import Namespace, fields
# Make a common namespace for all the models
ns = Namespace("Models")
repost = ns.model(
'repost', {
"repost_item_id": fields.String(required=True),
"repost_type": fields.String(required=True),
"user_id": fields.String(required=True)
})
repost_full = ns.clone(
"repost_full", repost, {
"blockhash": fields.String(required=True),
"blocknumber": fields.Integer(required=True),
"created_at": fields.String(required=True),
"is_current": fields.Boolean(required=True),
"is_delete": fields.Boolean(required=True),
})
favorite = ns.model(
'favorite', {
"favorite_item_id": fields.String(required=True),
"favorite_type": fields.String(required=True),
"user_id": fields.String(required=True)
})
favorite_full = ns.clone(
"favorite_full", favorite, {
"blockhash": fields.String(required=True),
"blocknumber": fields.Integer(required=True),
from housechef.database.models import User
from housechef.extensions import db
from ..models import links_envelope, meta_envelope, response_envelope
from ..schemas import UserSchema
from ..utils import role_required, requested_user_matches_jwt_user
ns = Namespace("Users", description="User Operations")
response_env = ns.model(response_envelope.get("name"), response_envelope.get("fields"))
meta_env = ns.model(meta_envelope.get("name"), meta_envelope.get("fields"))
links_env = ns.model(links_envelope.get("name"), links_envelope.get("fields"))
user_model = ns.model(UserSchema.get_restx_model().name, UserSchema.get_restx_model())
get_user_model = ns.clone(
"get_user_model", response_env, {"data": fields.Nested(user_model)}
)
get_user_list_model = ns.inherit(
"get_user_list_model",
response_env,
{
"data": fields.List(fields.Nested(user_model)),
"_meta": fields.Nested(meta_env),
"_links": fields.Nested(links_env),
},
)
@ns.route("/<int:user_id>", endpoint="get_user")
@ns.response(HTTPStatus.OK.value, HTTPStatus.OK.phrase)
@ns.response(HTTPStatus.BAD_REQUEST.value, HTTPStatus.BAD_REQUEST.phrase)
},
"telephone": {
"description": "联系电话",
"type": "string",
"max_bytes_len": 20
}
},
"additionalProperties": False
}
# 响应体model
user_api.models[
marshalling_models.base_resp.name] = marshalling_models.base_resp
user_api.models[
marshalling_models.user_model.name] = marshalling_models.user_model
crud_resp = user_api.clone(
'user_resp', marshalling_models.base_resp,
{'data': fields.Nested(marshalling_models.user_model, skip_none=True)})
list_resp = user_api.clone(
'user_list_resp', marshalling_models.base_resp, {
'data':
fields.Nested(user_api.model(
'user_list_data', {
'users':
fields.List(
fields.Nested(marshalling_models.user_model,
skip_none=True))
}),
skip_none=True)
})
from sqlalchemy.orm.exc import NoResultFound
import voluptuous as v
import voluptuous.error as verr
import voluptuous.humanize as vhum
from werkzeug.exceptions import BadRequest, Conflict, Unauthorized
from app.models import UserAccount
from app import db
from app.apis.users import Users, base_user_model, user_model
api = Namespace('auth', description='Authentication related operations')
basic_auth = HTTPBasicAuth()
token_auth = HTTPTokenAuth()
register_model = api.clone(
'Register', base_user_model, {
'password': fields.String(required=True, discriminator=True),
})
login_model = api.model(
'Login', {
'email': fields.String(required=True),
'password': fields.String(required=True)
})
token_model = api.model(
'Token', {
'token_type': fields.String(default='bearer'),
'access_token': fields.String(),
'expires_in': fields.Integer(default=600),
})
from ..models import links_envelope, meta_envelope, response_envelope, pagination_parser
from ..schemas import DietTypeSchema
from ..utils import role_required
from ..dao import SqlalchemyDAO
ns = Namespace("Diet Types", description="Diet Type Operations")
response_env = ns.model(response_envelope.get("name"),
response_envelope.get("fields"))
meta_env = ns.model(meta_envelope.get("name"), meta_envelope.get("fields"))
links_env = ns.model(links_envelope.get("name"), links_envelope.get("fields"))
diet_type_model = ns.model(DietTypeSchema.get_restx_model().name,
DietTypeSchema.get_restx_model())
get_diet_type_model = ns.clone("get_diet_type_model", response_env,
{"data": fields.Nested(diet_type_model)})
get_diet_type_list_model = ns.inherit(
"get_diet_type_list_model",
response_env,
{
"data": fields.List(fields.Nested(diet_type_model)),
"_meta": fields.Nested(meta_env),
"_links": fields.Nested(links_env),
},
)
@ns.route("", endpoint="list_diet_types")
@ns.response(HTTPStatus.OK.value, HTTPStatus.OK.phrase)
@ns.response(HTTPStatus.INTERNAL_SERVER_ERROR.value,
HTTPStatus.INTERNAL_SERVER_ERROR.phrase)
post_parser.add_argument(JobFields.BBOX)
post_parser.add_argument(JobFields.PROVIDER)
post_parser.add_argument(JobFields.ROUTER)
post_parser.add_argument(JobFields.INTERVAL)
post_parser.add_argument(JobFields.COMPRESSION)
get_parser = reqparse.RequestParser()
get_parser.add_argument(JobFields.PROVIDER)
get_parser.add_argument(JobFields.ROUTER)
get_parser.add_argument(JobFields.BBOX)
get_parser.add_argument(JobFields.STATUS)
get_parser.add_argument(JobFields.INTERVAL)
job_base_model = ns.model('JobBase', job_base_schema)
job_response_model = ns.clone('JobResp', job_response_schema, job_base_model)
@ns.route('/')
@ns.response(HTTPStatus.BAD_REQUEST, 'Invalid request parameters.')
@ns.response(HTTPStatus.INTERNAL_SERVER_ERROR, 'Unknown error.')
class Jobs(Resource):
"""Manipulates User table"""
@ns.doc(
params={
JobFields.ROUTER: {
'in': 'query',
'description': 'Filter for routing engine.',
"enum": ROUTERS
},
JobFields.PROVIDER: {
example="2020-08-04 09:00:00",
),
"duration_in_hours":
fields.Integer(
attribute="duration",
description=
"The number of hours for which the booking must be registered.",
example="2",
),
"room_code":
fields.String(description="Identifier code of the booked room.",
example="room0")
})
booking_model = api.clone(
"single_booking", booking_short_model, {
"room":
fields.Nested(room_model,
description="Full information about the booked room.")
})
# Definitions of inputs parser(s) and/or validator(s):
def _list_parser() -> RequestParser:
parser = RequestParser()
parser.add_argument("author",
type=str,
help="Filter bookings by the name of author.",
location="args")
parser.add_argument(
"day",
type=inputs.date_from_iso8601,
default=lambda: dt.datetime.now().date().isoformat(),
from app import bcrypt
from app.api.models import User
from app.api.utils import add_user, get_user_by_email, get_user_by_id
auth_namespace = Namespace("auth")
user = auth_namespace.model(
"User",
{
"username": fields.String(required=True),
"email": fields.String(required=True)
},
)
full_user = auth_namespace.clone("Full User", user,
{"password": fields.String(required=True)})
login = auth_namespace.model(
"User",
{
"email": fields.String(required=True),
"password": fields.String(required=True)
},
)
refresh = auth_namespace.model("Refresh",
{"refresh_token": fields.String(required=True)})
tokens = auth_namespace.clone("Access and refresh_tokens", refresh,
{"access_token": fields.String(required=True)})
"question": fields.String(
description="The question being asked", required=True
),
"user_id": fields.Integer(
description="The user asking the question", required=True
),
},
)
publication_question_model = api.clone(
"Publication Model",
new_publication_question_model,
{
"id": fields.Integer(
description="The unique identifier for the question", readonly=True
),
"reply": fields.String(description="The reply to the question", required=False),
"created_at": fields.DateTime(
description="Timestamp the question was asked at"
),
"replied_at": fields.DateTime(description="Timestamp the question was replied"),
},
)
reply_model = api.model(
"Reply model",
{"reply": fields.String(description="The reply to the question", required=True)},
)
@api.route("/<int:publication_id>/questions")
@api.param("publication_id", "The publication unique identifier")
api = Namespace('users', description='User related operations')
base_user_model = api.model('BaseUser', {
'first_name': fields.String(required=True),
'middle_name': fields.String(),
'father_surname': fields.String(required=True),
'mother_surname': fields.String(required=True),
'gender': fields.String(required=True, enum=['M', 'F', 'O', 'U'],
attribute=lambda x: x.gender.name),
'email': fields.String(required=True),
'birth_date': fields.Date(required=True),
'cellphone': fields.String(required=True),
})
user_model = api.clone('UserAccount', base_user_model, {
'id': fields.Integer(discriminator=True),
})
@api.route('/')
class Users(Resource):
USER_VALIDATOR = v.Schema({
'first_name': v.All(str, v.Length(min=1)),
v.Optional('middle_name'): str,
'father_surname': v.All(str, v.Length(min=1)),
'mother_surname': v.All(str, v.Length(min=1)),
'gender': v.In(['M', 'F', 'O', 'U'],
"Allowed values 'M', 'F', 'O', 'U'"),
'email': v.Email(),
'birth_date': v.Date(),
description="Unique email address.",
example="*****@*****.**"),
"password":
fields.String(
required=True, description="User Password.", example="password"),
},
)
signup_model = api.clone(
"Signup",
login_model,
{
"firstName":
fields.String(
required=True, description="User first name.", example="Joana"),
"lastName":
fields.String(
required=True, description="User last name.", example="Kamp"),
"phoneNumber":
fields.String(required=True,
description="User phone number.",
example="555-444-6666"),
},
)
@api.route("/signup")
class Signup(Resource):
@api.doc("signup_user")
@api.expect(signup_model)
def post(self):
"""Create a user record on a signup"""
from ...utils.db_utils import add_or_abort
# Mandatory, will be added by api_vX.__init__
ns = Namespace('users', description='User related operations')
# Parse POST request
parser = reqparse.RequestParser()
parser.add_argument(UserFields.EMAIL)
parser.add_argument(UserFields.PASSWORD)
# Set up different schemas for request and response
user_base_schema = ns.model(
'UserBase', {
UserFields.EMAIL: fields.String(example='*****@*****.**'),
})
user_response_schema = ns.clone('UserResp', user_base_schema,
{UserFields.ID: fields.Integer})
user_body_schema = ns.clone('UserReq', user_base_schema,
{UserFields.PASSWORD: fields.String})
@ns.route('/')
@ns.response(HTTPStatus.INTERNAL_SERVER_ERROR, 'Unknown error.')
class UserRegistration(Resource):
"""Manipulates User table"""
@basic_auth.login_required
@ns.doc(security='basic')
@ns.expect(user_body_schema)
@ns.marshal_with(user_response_schema)
@ns.response(HTTPStatus.BAD_REQUEST, 'Invalid request parameters.')
@ns.response(HTTPStatus.CONFLICT, 'User already exists.')
@ns.response(HTTPStatus.UNAUTHORIZED,
"format": "email",
"max_bytes_len": 50
},
"telephone": {
"description": "联系电话",
"type": "string",
"max_bytes_len": 20
}
},
"additionalProperties": False
}
login_resp = user_api.clone(
'login_resp', marshalling_models.base_resp, {
'data':
fields.Nested(user_api.model(
'login_data', {
'check_result': fields.Boolean(title='验证结果', required=True),
'token': fields.String(title='调用接口所需token')
}),
skip_none=True)
})
user_api.models[
marshalling_models.base_resp.name] = marshalling_models.base_resp
user_api.models[
marshalling_models.user_model.name] = marshalling_models.user_model
crud_resp = user_api.clone(
'user_resp', marshalling_models.base_resp,
{'data': fields.Nested(marshalling_models.user_model, skip_none=True)})
@user_api.route('/<int:uid>')
@user_api.param('uid', description='用户id', _in='path')
from ..schemas import HouseholdSchema, MealSchema
from ..utils import (
generate_link_metadata,
generate_query_metadata,
role_required,
set_sort_order,
)
ns = Namespace("Households", description="Household Operations")
response_env = ns.model(response_envelope.get("name"),
response_envelope.get("fields"))
meta_env = ns.model(meta_envelope.get("name"), meta_envelope.get("fields"))
links_env = ns.model(links_envelope.get("name"), links_envelope.get("fields"))
get_household_model = ns.clone("get_household_model", response_env,
{"data": fields.Raw})
get_household_list_model = ns.inherit(
"get_household_list_model",
response_env,
{
"data": fields.List(fields.Raw),
"_meta": fields.Nested(meta_env),
"_links": fields.Nested(links_env),
},
)
ns.models[meal_model.name] = meal_model
@ns.route("", endpoint="list_households")
@ns.response(HTTPStatus.OK.value,
from flask_restx import Namespace, Resource, fields
from project.api.users.crud import add_user, get_user_by_email, get_user_by_id
from project.api.users.models import User
namespace = Namespace("auth")
user_result = namespace.model(
"User Result",
{
"username": fields.String(required=True),
"email": fields.String(required=True)
},
)
user_payload = namespace.clone("User Payload", user_result,
{"password": fields.String(required=True)})
login = namespace.model(
"User",
{
"email": fields.String(required=True),
"password": fields.String(required=True)
},
)
refresh = namespace.model("Refresh",
{"refresh_token": fields.String(required=True)})
tokens = namespace.clone("Access and Refresh Tokens", refresh,
{"access_token": fields.String(required=True)})
room_short_model = api.model(
"rooms_collection_item", {
"code":
fields.String(description="Identifier code of the room.",
example="room0",
required=True),
"name":
fields.String(description="Full name of the room.",
example="The first room",
required=True),
})
room_model = api.clone(
"single_room", room_short_model, {
"floor":
fields.Integer(description="The floor at which the room can be found.",
example=0),
"capacity":
fields.Integer(
description="The maximum number of people who can sit in the room.",
example=12)
})
# Inputs parser (for filters):
def _list_parser() -> RequestParser:
parser = RequestParser()
parser.add_argument("search_in_name",
type=str,
help="Filter rooms which name contains this text.",
location="args")
parser.add_argument(
"floor",
