class Book(DjangoObject):
model = BookModel
custom_actions = {
"getById": Action(parameters={"id": IntegerType(validators=And(NotNegative, NotZero))},
return_value=ObjectType("self"),
validators=NotRestrictedBook,
exec_fn=get_by_id),
"getById2": Action(parameters={"id": IntegerType(validators=NotNegative)},
data={"Title": StringType(validators=LongerThen3Characters)},
return_value=ObjectType("self"),
validators=NotRestrictedBook,
exec_fn=get_by_id)}
def convert(self, adapter, **kwargs):
self.set_ref()
object_name = self.to.__name__
object_module = self.to.__module__
cls = object_storage.get(object_module, object_name)
self.parameters = {
"filters": ObjectType(cls.filter_type, nullable=True)
}
list_cls = object_storage.get(object_module, object_name + "List")
obj = ObjectType(list_cls, parameters=self.parameters)
obj.resolver = self.resolver
return obj.convert(adapter, **kwargs)
class ActionInfo(Object):
fields = {
"name": StringType(),
"parameters": PlainListType(ObjectType(FieldInfo)),
"data": PlainListType(ObjectType(FieldInfo)),
"return_type": StringType(),
"permitted": BooleanType(),
"deny_reason": StringType(nullable=True),
"retry_in": DurationType(nullable=True),
"mutation": BooleanType()
}
hidden = True
def determine_parameters(self):
if self._determined_parameters is None:
self._determined_parameters = ({
"filters":
ObjectType(self.parent_class.filter_type, nullable=True)
})
self._determined_parameters.update(self.parameters)
class ObjectInfo(Object):
fields = {
"name": StringType(),
"pk_field": StringType(nullable=True),
"actions": PlainListType(ObjectType(ActionInfo)),
}
hidden = True
def convert_to_object_type(field, field_name, both_fields, input_fields,
output_fields):
target_model = field.remote_field.model
target_pk_field_name, target_pk_field = get_pk_field(target_model)
converted_pk_field = DJANGO_SIMPLE_API_MAP[target_pk_field.__class__]
validators = [DjangoValidator(x) for x in field.validators]
validators.append(ForeignKeyValidator(target_model))
input_fields[field_name + "_id"] = converted_pk_field(
nullable=field.null, exclude_filters=(), validators=validators)
output_fields[field_name] = ObjectType(target_model,
nullable=field.null,
exclude_filters=())
class PersonList(Object):
fields = {
"count":
IntegerType(),
"records":
PlainListType(ObjectType(Person),
parameters={
"limit": IntegerType(nullable=True, default=20),
"offset": IntegerType(nullable=True, default=0),
},
resolver=resolve)
}
class IntList(Object):
fields = {
"count": IntegerType(),
"all_records": PlainListType(IntegerType()),
"records": ObjectType(
"self",
parameters={
"limit": IntegerType(nullable=True, default=20),
"offset": IntegerType(nullable=True, default=0),
},
resolver=resolve
)
}
def inject_references(mcs, cls):
for field in {
**cls.fields,
**cls.input_fields,
**cls.output_fields
}.values():
field.set_parent_class(cls)
for action_name, action in cls.actions.items():
action.set_parent_class(cls)
action.set_name(action_name)
if not getattr(cls, "hidden", False):
cls.output_fields["__actions"] = PlainListType(
ObjectType("simple_api.object.meta_types.ActionInfo"),
resolver=build_actions_resolver(cls))
def __init__(self,
parameters=None,
data=None,
return_value=None,
get_fn=None,
exec_fn=None,
permissions=None,
**kwargs):
return_value = return_value or ObjectType("self")
super().__init__(parameters=parameters,
data=data,
return_value=return_value,
exec_fn=exec_fn,
permissions=permissions,
**kwargs)
self.get_fn = get_fn
self._determined_get_fn = None
def __init__(self,
parameters=None,
data=None,
return_value=None,
exec_fn=None,
permissions=None,
**kwargs):
self.parameters = parameters or {}
self.data = data or {}
self.return_value = return_value or ObjectType("self")
self.exec_fn = exec_fn
self.permissions = ensure_tuple(permissions)
self.kwargs = kwargs
# these attributes exist to ensure that 1) the input from the user is stored unmodified in the attributes above
# and 2) everything is determined just once (better performance, less error-prone)
self._determined_exec_fn = None
self._determined_parameters = None
self._determined_permissions = None
self._determined_data = None
self._action = None
super().__init__()
def create_associated_list_type(cls):
def resolve_pagination(request, parent_val, params, **kwargs):
return parent_val[params["offset"]:(params["offset"] +
params["limit"])]
attrs = {
"fields": {
"count":
IntegerType(),
"data":
PlainListType(ObjectType(cls),
parameters={
"limit":
IntegerType(nullable=True,
default=DEFAULT_LIMIT),
"offset":
IntegerType(nullable=True, default=0),
},
resolver=resolve_pagination)
},
"hidden": True,
}
ObjectMeta(cls.__name__ + "List", (Object, ), attrs, module=cls.__module__)
return parent_val[params["offset"]:(params["offset"] + params["limit"])]
class IntList(Object):
fields = {
"count":
IntegerType(),
"records":
PlainListType(IntegerType(),
parameters={
"limit": IntegerType(nullable=True, default=20),
"offset": IntegerType(nullable=True, default=0),
},
resolver=resolve)
}
def get(request, params, **kwargs):
return AttrDict(count=len(params["input"]), records=params["input"])
actions = {
"get":
Action(parameters={"input": PlainListType(IntegerType())},
return_value=ObjectType(IntList),
exec_fn=get)
}
schema = generate(GraphQLAdapter, actions)
patterns = build_patterns("api/", schema)
def convert_to_readonly_object_type(field, field_name, both_fields,
input_fields, output_fields):
target_model = field.remote_field.model
# for OneToOneRel, we don't want to generate filters, as one_to_one_rel_id does not exist in Django
output_fields[field_name] = ObjectType(target_model, nullable=field.null)
def build_type_info():
return Action(return_value=PlainListType(ObjectType(TypeInfo)),
exec_fn=type_info)
return [
{
"int1": 0,
"int2": 10
},
None,
{
"int1": 2,
"int2": 12
},
]
actions = {
"getNonNull":
Action(return_value=PlainListType(ObjectType(TestObject)),
exec_fn=non_null),
"getNull":
Action(return_value=PlainListType(ObjectType(TestObject, nullable=True),
nullable=True),
exec_fn=null),
"getListNullElemNonNull":
Action(return_value=PlainListType(ObjectType(TestObject), nullable=True),
exec_fn=null),
"getListNonNullElemNull":
Action(return_value=PlainListType(ObjectType(TestObject, nullable=True)),
exec_fn=list_non_null_elem_null),
}
schema = generate(GraphQLAdapter, actions)
patterns = build_patterns("api/", schema)
from simple_api.object.datatypes import IntegerType, ObjectType
from simple_api.object.object import Object
from simple_api.utils import AttrDict
from simple_api.adapters.graphql.utils import build_patterns
def get(request, params, **kwargs):
return AttrDict(number=20, number_def=5)
def get_number(request, parent_val, params, **kwargs):
return params.get("num") or parent_val
class TestObject(Object):
fields = {
"number":
IntegerType(parameters={"num": IntegerType(nullable=True)},
resolver=get_number),
"number_def":
IntegerType(parameters={"num": IntegerType(nullable=True, default=5)},
resolver=get_number),
}
actions = {"get": Action(return_value=ObjectType(TestObject), exec_fn=get)}
schema = generate(GraphQLAdapter, actions)
patterns = build_patterns("api/", schema)
class Location(Object):
fields = {"name": StringType(), "coords": ObjectType(Coordinates)}
"time": params.get("time"),
"datetime": params.get("datetime")
}
class TestObject(Object):
fields = {
"date": DateType(),
"time": TimeType(),
"datetime": DateTimeType(),
}
actions = {
"getObject":
Action(return_value=ObjectType(TestObject), exec_fn=get_object),
"getDate":
Action(return_value=DateType(), exec_fn=get_date),
"getTime":
Action(return_value=TimeType(), exec_fn=get_time),
"getDatetime":
Action(return_value=DateTimeType(), exec_fn=get_datetime),
"echo":
Action(parameters={
"date": DateType(),
"time": TimeType(),
"datetime": DateTimeType()
},
return_value=ObjectType(TestObject),
exec_fn=echo),
}
class TestObject(Object):
fields = {
"self": ObjectType("self", nullable=True)
}
from simple_api.adapters.graphql.graphql import GraphQLAdapter
from simple_api.adapters.utils import generate
from simple_api.object.actions import Action
from simple_api.object.datatypes import ObjectType, StringType, IntegerType
from simple_api.object.object import Object
from simple_api.adapters.graphql.utils import build_patterns
class Coordinates(Object):
fields = {"lat": IntegerType(), "lng": IntegerType()}
class Location(Object):
fields = {"name": StringType(), "coords": ObjectType(Coordinates)}
def echo(request, params, **kwargs):
return params["loc"]
actions = {
"echo":
Action(parameters={"loc": ObjectType(Location)},
return_value=ObjectType(Location),
exec_fn=echo)
}
schema = generate(GraphQLAdapter, actions)
patterns = build_patterns("api/", schema)
def get(request, params, **kwargs):
if "id" in params:
return "{}.{}".format(params["id"]["int1"], params["id"]["int2"])
return "no params passed"
class TestObject(Object):
fields = {
"int1": IntegerType(),
"int2": IntegerType(),
}
actions = {
"get":
Action(parameters={"id": ObjectType(TestObject)},
return_value=StringType(),
exec_fn=get),
"getNull":
Action(parameters={"id": ObjectType(TestObject, nullable=True)},
return_value=StringType(),
exec_fn=get),
"getNullDefault":
Action(parameters={
"id":
ObjectType(TestObject, nullable=True, default={
"int1": 10,
"int2": 20
})
},
return_value=StringType(),
from simple_api.adapters.graphql.graphql import GraphQLAdapter
from simple_api.adapters.utils import generate
from simple_api.object.actions import Action
from simple_api.object.datatypes import ObjectType
from simple_api.adapters.graphql.utils import build_patterns
from .b import get
actions = {
"get": Action(return_value=ObjectType("C"), exec_fn=get)
}
schema = generate(GraphQLAdapter, actions)
patterns = build_patterns("api/", schema)
from simple_api.adapters.graphql.graphql import GraphQLAdapter
from simple_api.adapters.utils import generate
from simple_api.object.actions import Action
from simple_api.object.datatypes import ObjectType, DurationType
from simple_api.object.object import Object
from simple_api.adapters.graphql.utils import build_patterns
def echo(request, params, **kwargs):
return params["in"]
class TestObject(Object):
fields = {"duration": DurationType()}
actions = {
"get":
Action(return_value=DurationType(),
parameters={"in": DurationType()},
exec_fn=echo),
"getObject":
Action(return_value=ObjectType(TestObject),
parameters={"in": ObjectType(TestObject)},
exec_fn=echo)
}
schema = generate(GraphQLAdapter, actions)
patterns = build_patterns("api/", schema)
}
class PersonList(Object):
fields = {
"count":
IntegerType(),
"records":
PlainListType(ObjectType(Person),
parameters={
"limit": IntegerType(nullable=True, default=20),
"offset": IntegerType(nullable=True, default=0),
},
resolver=resolve)
}
def get(request, params, **kwargs):
return AttrDict(count=len(params["input"]), records=params["input"])
actions = {
"get":
Action(parameters={"input": PlainListType(ObjectType(Person))},
return_value=ObjectType(PersonList),
exec_fn=get)
}
schema = generate(GraphQLAdapter, actions)
patterns = build_patterns("api/", schema)
def build_action_info(actions):
return Action(return_value=PlainListType(ObjectType(ActionInfo)),
exec_fn=build_action_info_fn(actions))
class C(Object):
fields = {"a": ObjectType(A), "b": ObjectType("B")}
def resolve(request, parent_val, params, **kwargs):
res = parent_val[params["offset"]:(params["offset"]+params["limit"])]
return AttrDict(count=len(res), all_records=res, records=res)
class IntList(Object):
fields = {
"count": IntegerType(),
"all_records": PlainListType(IntegerType()),
"records": ObjectType(
"self",
parameters={
"limit": IntegerType(nullable=True, default=20),
"offset": IntegerType(nullable=True, default=0),
},
resolver=resolve
)
}
def get(request, params, **kwargs):
return AttrDict(count=len(params["input"]), all_records=params["input"], records=params["input"])
actions = {
"get": Action(parameters={"input": PlainListType(IntegerType())}, return_value=ObjectType(IntList), exec_fn=get)
}
schema = generate(GraphQLAdapter, actions)
patterns = build_patterns("api/", schema)
class A(Object):
fields = {
"s1": StringType(),
"s2": ObjectType("self", nullable=True)
}
from simple_api.adapters.graphql.graphql import GraphQLAdapter
from simple_api.adapters.utils import generate
from simple_api.object.actions import Action
from simple_api.object.datatypes import ObjectType
from simple_api.object.object import Object
from simple_api.adapters.graphql.utils import build_patterns
def get(request, params, **kwargs):
return None
class TestObject(Object):
fields = {
"self": ObjectType("self", nullable=True)
}
actions = {
"get": Action(return_value=ObjectType(TestObject, nullable=True), exec_fn=get)
}
schema = generate(GraphQLAdapter, actions)
patterns = build_patterns("api/", schema)