class ItemAddInput(InputObjectType):
"""Input for add item"""
title = String(required=True)
about = String()
access_level = Argument(ItemQl._meta.fields['access_level'].type)
list_id = ID()
degree = Argument(ItemQl._meta.fields['degree'].type)
class Arguments:
id = Int(required=True)
tradingName = String(required=True)
ownerName = String(required=True)
document = String(required=True)
coverageArea = Argument(GQLInputCoverageArea, required=True)
address = Argument(GQLInputAddress, required=True)
class AnswerNode(DjangoObjectType):
url = String(user_hash=Argument(String))
is_visited = Boolean(user_hash=Argument(String, required=True))
is_long = String()
is_complex = String()
is_science = String()
helpful_count = Int()
class Meta:
model = Answer
only_fields = ('id', 'title', 'url', 'created_by', 'created_at', 'is_long', 'is_complex', 'is_science', 'is_visited')
def resolve_is_long(self, info):
return self.is_long
def resolve_is_complex(self, info):
return self.is_complex
def resolve_url(self, info, **kwargs):
try:
return self.redirect_url(kwargs['user_hash'])
except KeyError:
return self.url
def resolve_is_visited(self, info, **kwargs):
return SourceEntry.objects.filter(user__hash_id=kwargs['user_hash'], answer=self)
def resolve_is_science(self, info):
return self.is_science
def resolve_created_by(self, info):
return self.created_by
def resolve_helpful_count(self, info):
return self.rating_set.filter(rating_type=Rating.IS_HELPFUL, rate=True).count()
class Query(ObjectType):
"""Create Query object list"""
node = relay.Node.Field()
city_state = Field(CityStateNode,
postalcode=String(required=True),
resolver=resolve_city_states)
address = Field(AddressNode,
postalcode=Argument(String, required=True),
address1=Argument(String, required=True),
address2=Argument(String),
city=Argument(String),
state=Argument(String),
resolver=resolve_address)
# address = relay.Node.Field(AddressNode)
# citystate = relay.Node.Field(CityStateNode)
sport = relay.Node.Field(SportNode)
team = relay.Node.Field(TeamNode)
referee = relay.Node.Field(RefereeNode)
coach = relay.Node.Field(CoachNode)
player = relay.Node.Field(PlayerNode)
all_team = FilterableConnectionField(TeamConnection)
all_sport = FilterConnectionField(SportConnection)
all_referee = FilterConnectionField(RefereeConnection)
all_coach = FilterConnectionField(CoachConnection)
all_player = FilterConnectionField(PlayerConnection)
class Query(ObjectType):
# Define a field with arguments
hello = String(name=Argument(String, default_value='stranger'),
age=Argument(Int))
def resolve_hello(self, info, name, age):
return 'Hi {} you are {} years old.'.format(name, age)
def __init__(self, _type, fields=None, extra_filter_meta=None,
filterset_class=None, *args, **kwargs):
if DJANGO_FILTER_INSTALLED:
_fields = _type._meta.filter_fields
_model = _type._meta.model
self.fields = fields or _fields
meta = dict(model=_model, fields=self.fields)
if extra_filter_meta:
meta.update(extra_filter_meta)
filterset_class = filterset_class or _type._meta.filterset_class
self.filterset_class = get_filterset_class(filterset_class, **meta)
self.filtering_args = get_filtering_args_from_filterset(self.filterset_class, _type)
kwargs.setdefault('args', {})
kwargs['args'].update(self.filtering_args)
if 'id' not in kwargs['args'].keys():
self.filtering_args.update({'id': Argument(ID,
description='Django object unique identification field')})
kwargs['args'].update({
'id': Argument(ID, description='Django object unique identification field')
})
if not kwargs.get('description', None):
kwargs['description'] = '{} list'.format(
_type._meta.model.__name__
)
super(DjangoFilterListField, self).__init__(
List(_type), *args, **kwargs
)
class Query(ObjectType):
hello = String(name=Argument(String, default_value="Stranger"),
age=Argument(Int))
def resolve_hello(self, args, context, info):
return "👋 Hello {} your are {} old, welcome to DevFest Delhi".format(
args['name'], args['age'])
def __init__(
self,
_type,
pagination=None,
fields=None,
extra_filter_meta=None,
filterset_class=None,
*args,
**kwargs,
):
_fields = _type._meta.filter_fields
_model = _type._meta.model
self.fields = fields or _fields
meta = dict(model=_model, fields=self.fields)
if extra_filter_meta:
meta.update(extra_filter_meta)
filterset_class = filterset_class or _type._meta.filterset_class
self.filterset_class = get_filterset_class(filterset_class, **meta)
self.filtering_args = get_filtering_args_from_filterset(
self.filterset_class, _type)
kwargs.setdefault("args", {})
kwargs["args"].update(self.filtering_args)
if "id" not in kwargs["args"].keys():
self.filtering_args.update({
"id":
Argument(
ID,
description="Django object unique identification field")
})
kwargs["args"].update({
"id":
Argument(
ID,
description="Django object unique identification field")
})
pagination = pagination or graphql_api_settings.DEFAULT_PAGINATION_CLASS(
)
if pagination is not None:
assert isinstance(pagination, BaseDjangoGraphqlPagination), (
'You need to pass a valid DjangoGraphqlPagination in DjangoFilterPaginateListField, received "{}".'
).format(pagination)
pagination_kwargs = pagination.to_graphql_fields()
self.pagination = pagination
kwargs.update(**pagination_kwargs)
if not kwargs.get("description", None):
kwargs["description"] = "{} list".format(
_type._meta.model.__name__)
super(DjangoFilterPaginateListField,
self).__init__(List(_type), *args, **kwargs)
class ItemEditInput(InputObjectType):
"""Input for edit item"""
item_id = ID()
title = String()
about = String()
access_level = Argument(ItemQl._meta.fields['access_level'].type)
list_id = ID()
degree = Argument(ItemQl._meta.fields['degree'].type)
def __init__(self, type, *args, **kwargs):
kwargs.update({
FILTERS_FIELD: Argument(GenericScalar),
ORDER_BY_FIELD: Argument(List(String)),
PAGE_FIELD: Argument(Int),
PAGINATE_BY_FIELD: Argument(Int),
})
super(PeeweeConnectionField, self).__init__(type, *args, **kwargs)
def __init__(self,
_type,
pagination=None,
fields=None,
extra_filter_meta=None,
filterset_class=None,
preprocess_kwargs=None,
*args,
**kwargs):
_fields = _type._meta.filter_fields
_model = _type._meta.model
self.fields = fields or _fields
meta = dict(model=_model, fields=self.fields)
if extra_filter_meta:
meta.update(extra_filter_meta)
self.filterset_class = get_filterset_class(filterset_class, **meta)
self.filtering_args = get_filtering_args_from_filterset(
self.filterset_class, _type)
kwargs.setdefault('args', {})
kwargs['args'].update(self.filtering_args)
if 'id' not in kwargs['args'].keys():
self.filtering_args.update({
'id':
Argument(
ID,
description='Django object unique identification field')
})
kwargs['args'].update({
'id':
Argument(
ID,
description='Django object unique identification field')
})
pagination = pagination or graphql_api_settings.DEFAULT_PAGINATION_CLASS
if pagination is not None:
assert isinstance(pagination, BaseDjangoGraphqlPagination), (
'You need to pass a valid DjangoGraphqlPagination in DjangoFilterPaginateListField, received "{}".'
).format(pagination)
pagination_kwargs = list_pagination_factory(pagination)
self.pagination = pagination
kwargs.update(**pagination_kwargs)
if not kwargs.get('description', None):
kwargs['description'] = '{} list'.format(
_type._meta.model.__name__)
preprocess_kwargs = preprocess_kwargs or kwargs_formatter
kwargs = preprocess_kwargs(**kwargs)
super(DjangoFilterPaginateListField,
self).__init__(List(_type), *args, **kwargs)
class AddGroupInput(InputObjectType):
"""Input for add group"""
title = String(required=True)
about = String()
access_level = Argument(GroupQl._meta.fields['access_level'].type)
date = Date(required=True)
admin_role = Argument(
GroupUserQl._meta.fields['role_in_group'].type,
description=
'The group model will depend on the role of the administrator')
def __init__(self,
_type,
pagination=None,
fields=None,
extra_filter_meta=None,
filterset_class=None,
preprocess_kwargs=None,
*args,
**kwargs):
_fields = _type._meta.filter_fields
_model = _type._meta.model
self.fields = fields or _fields
meta = dict(model=_model, fields=self.fields)
if extra_filter_meta:
meta.update(extra_filter_meta)
self.filterset_class = get_filterset_class(filterset_class, **meta)
self.filtering_args = get_filtering_args_from_filterset(
self.filterset_class, _type)
kwargs.setdefault('args', {})
kwargs['args'].update(self.filtering_args)
if 'id' not in kwargs['args'].keys():
self.filtering_args.update({
'id':
Argument(
ID,
description='Django object unique identification field')
})
kwargs['args'].update({
'id':
Argument(
ID,
description='Django object unique identification field')
})
if pagination:
pagination_kwargs = list_pagination_factory(pagination)
self.pagination = pagination
kwargs.update(**pagination_kwargs)
if not kwargs.get('description', None):
kwargs['description'] = '{} list'.format(
_type._meta.model.__name__)
preprocess_kwargs = preprocess_kwargs or kwargs_formatter
kwargs = preprocess_kwargs(**kwargs)
super(DjangoFilterPaginateListField,
self).__init__(List(_type), *args, **kwargs)
class Query(ObjectType):
me = Field(NonNull(User), resolver=resolveme)
companies = List(NonNull(Company), resolver=companies_by_principal)
active_demands = List(Demand, resolver=active_demands_by_principal)
active_supplies = List(Supply, resolver=active_supplies_by_principal)
demand = Field(Demand, id=ID(required=True), resolver=demand_by_id)
supply = Field(Supply, id=ID(required=True), resolver=supply_by_id)
# company = Field(Company, id=ID(required=True), resolver=company_by_id)
skills = List(NonNull(Skill), required=True, resolver=skills_resolver)
industries = List(NonNull(Industry), required=True, resolver=industies_resolver)
team_names = List(NonNull(String), required=True, resolver=team_names)
match_demand = Field(
MatchSupplyResult,
cursor=Argument(CursorInput),
id=Argument(ID, required=True),
radius = Argument(Int),
required=True,
resolver=match_demand_by_id,
)
match_supply = Field(
MatchDemandResult,
cursor=Argument(CursorInput),
id=Argument(ID, required=True),
radius = Argument(Int),
required=True,
resolver=match_supply_by_id,
)
match_supplies = Field(
MatchSupplyResult,
cursor=Argument(CursorInput),
query=Argument(MatchQueryInput, required=True),
required=True,
resolver=match_supplies_by_query,
)
match_demands = Field(
MatchDemandResult,
cursor=Argument(CursorInput),
query=Argument(MatchQueryInput, required=True),
required=True,
resolver=match_demands_by_query,
)
class QueryRoot(ObjectType):
string_value = String(value=Argument(String))
int_value = Int(value=Argument(Int))
float_value = Float(value=Argument(Float))
@graphene.resolve_only_args
def resolve_string_value(self, value=None):
return value
@graphene.resolve_only_args
def resolve_int_value(self, value=None):
return value
@graphene.resolve_only_args
def resolve_float_value(self, value=None):
return value
class Arguments():
finding_id = String(required=True)
justification = Argument(Enum('DeleteFindingJustification',
[('DUPLICATED', 'DUPLICATED'),
('FALSE_POSITIVE', 'FALSE_POSITIVE'),
('NOT_REQUIRED', 'NOT_REQUIRED')]),
required=True)
class EmployeeQuery(ObjectType):
"""
Get Employee
"""
employees = List(EmployeeType)
employee = Field(EmployeeType, employee_id=Argument(String, required=True))
def resolve_employees(self, info):
"""
Get list of employees
:param info:
:return: List employees
"""
user = info.context.user
print(user)
print(user.is_anonymous)
if user.is_anonymous:
raise GraphQLError("Log in to get all Employee!")
return Employee.objects.all()
def resolve_employee(self, info, employee_id):
"""
Get Employee by id
:param info:
:param employee_id: Id of employee
:return:
"""
user = info.context.user
if user.is_anonymous:
raise GraphQLError("Log in to add a Employee!")
return Employee.objects.get(id=employee_id)
class EditGroupInput(InputObjectType):
"""Input for editing group"""
group_id = ID(requiered=True)
title = String()
about = String()
access_level = Argument(GroupQl._meta.fields['access_level'].type)
date = Date()
class ClassType(ObjectType):
cid = ID()
name = String(name=Argument(String), default_value=None)
students = List(StudentType)
class Meta:
filter_fields = ['name']
class ChannelFilterInputObjectType(FilterInputObjectType):
channel = Argument(
String, description="Specifies the channel by which the data should be sorted.",
)
class Meta:
abstract = True
class ItemNode(SQLAlchemyObjectType):
"""
Схема запросов пунктов
"""
id = ID(required=True, description='Уникальный идентификатор пункта')
children = List(lambda: NonNull(ItemNode),
filters=Argument(ItemFilter,
description='Фильтры пунктов'),
description='Пункты меню, начиная со второго уровня')
class Meta:
model = ItemModel
description = 'Пункты меню первого уровня'
interfaces = (Node, )
connection_class = ItemConnection
async def resolve_children(self, info: ResolveInfo,
**kwargs) -> typing.List[ItemModel]:
approved_children = self.children
# фильтр пунктов, начиная со второго уровня
filters = kwargs.get('filters', {})
# фильтр по пунктам, к которым предоставлены права доступа
if 'permission_filter' in info.context:
filters.update(permission=info.context['permission_filter'])
if filters:
item_filter = ItemFilter(approved_children, filters)
approved_children = await item_filter.filter_items()
return sorted(
approved_children,
key=lambda x: x.sorted_id) # сортировка по порядковому ID
def filter_class_for_module(cls):
name = cls.__name__ + "InputFilter"
if name in _INPUT_CACHE:
return Argument(_INPUT_CACHE[name])
class InputFilterBase:
pass
fields = OrderedDict()
for column in inspect(cls).columns.values():
maybe_field = create_input_filter_field(column)
if maybe_field:
fields[column.name] = maybe_field
input_class = type(name, (InputFilterBase, graphene.InputObjectType), {})
input_class._meta.fields.update(fields)
_INPUT_CACHE[name] = input_class
return Argument(input_class)
def __init__(self, *args, **kwargs):
kwargs["args"] = {
"ordering":
Argument(
graphene.String,
description="String of comma-sepratated fields to order by.")
}
super().__init__(*args, **kwargs)
def __init__(self, type, order_by=None, *args, **kwargs):
kwargs.setdefault(
'ordering',
String(default_value=order_by) if order_by else String())
super(DjangoConnectionPageLimitField,
self).__init__(type, *args, **kwargs)
self.args["first"] = Argument(
Int, default_value=graphql_api_settings.DEFAULT_PAGE_SIZE)
class Arguments():
companies = List(String, required=True)
description = String(required=True)
project_name = String(required=True)
subscription = Argument(Enum('Subscription', [
('Continuous', 'continuous'), ('Oneshot', 'oneshot')]),
required=False)
has_forces = Boolean(required=False)
def sort_argument_for_model(cls, has_default=True):
"""Returns a Graphene argument for the sort field that accepts a list of sorting directions for a model.
If `has_default` is True (the default) it will sort the result by the primary key(s)
"""
enum, default = _sort_enum_for_model(cls)
if not has_default:
default = None
return Argument(List(enum), default_value=default)
class Arguments():
content = String(required=True)
finding_id = String(required=True)
parent = String(required=True)
type = Argument(Enum('FindingCommentType',
[('COMMENT', 'comment'),
('OBSERVATION', 'observation')]),
required=True)
def _bundle_all_arguments(cls, args_type, input_fields):
input_field_name = cls.input_field_name
if input_field_name:
arguments = OrderedDict(
{input_field_name: Argument(args_type, required=True)})
arguments.update(cls._meta.arguments_props)
return arguments
argument = OrderedDict({
i: Argument(type_=t.type,
description=t.description,
name=t.name,
required=getattr(t, 'required', None))
for i, t in input_fields.items()
})
argument.update(cls._meta.arguments_props)
return argument
class Query(ObjectType):
hello = String(name=Argument(
String, default_value='stranger'
))
def resolve_hello(self, args: dict, context, info):
# print(f'args: {args};\tcontext:{context};\tinfo:{info};')
# val = args['name']
return
class Query(ObjectType):
hotels = DjangoConnectionField(HotelType)
Hotel = Field(HotelType, id=Argument(ID, required=True))
def resolve_Hotels(root, info, **kwargs):
return Hotel.objects.all()
def resolve_Hotel(root, info, **kwargs):
return Hotel.objects.get(id=kwargs.get('id'))
