def test_filter_shortcut_filterset_orderable_headline():
field = DjangoFilterConnectionField(ArticleNode, order_by=['headline'])
assert_orderable(field)
class Query(graphene.ObjectType):
customer_report = graphene.relay.Node.Field(CustomerReportsType)
all_customer_reports = DjangoFilterConnectionField(
CustomerReportsType, filterset_class=CustomerReportsFilter)
company_report = graphene.relay.Node.Field(CompanyReportsType)
all_company_reports = DjangoFilterConnectionField(
CompanyReportsType, filterset_class=CompanyReportsFilter)
companies_names = graphene.List(graphene.String)
total_company_reports = graphene.Int(company_name=graphene.String())
total_company_replies = graphene.Int(company_name=graphene.String())
overall_company_rating = graphene.Float(company_name=graphene.String())
reports_per_date = graphene.List(
CompanyReportsPerDate,
company_name=graphene.String())
companies_reports_count = graphene.List(CompanyReportsCount)
company_reports_per_region = graphene.List(
CompanyReportsPerRegion,
company_name=graphene.String())
company_reports_per_age = graphene.List(
CompanyReportsPerAgeRange,
company_name=graphene.String())
company_rating_per_year = graphene.Int(company_name=graphene.String())
company_rating_per_year = graphene.List(
CompanyRatingPerYear,
company_name=graphene.String())
company_reports_per_gender = graphene.List(
CompanyReportsPerGender,
company_name=graphene.String())
def resolve_companies_names(self, info, **kwargs):
return CompanyReports.objects.mongo_distinct('company_name')
def resolve_total_company_reports(self, info, company_name, **kwargs):
return CompanyReports.objects.mongo_count(
{'company_name': company_name})
def resolve_total_company_replies(self, info, company_name, **kwargs):
return CompanyReports.objects.mongo_count(
{'company_name': company_name, 'company_replied': True})
def resolve_overall_company_rating(self, info, company_name, **kwargs):
result = [i for i in CompanyReports.objects.mongo_aggregate([
{
'$match': {
'company_name': company_name
}
},
{
'$group': {
'_id': 'null',
'average_rating': {
'$avg': '$customer_rating'
}
}
}
])]
return round(result[0]['average_rating'], 2)
def resolve_reports_per_date(self, info, company_name, **kwargs):
results = [i for i in CompanyReports.objects.mongo_aggregate([
{
'$match': {
'company_name': company_name
}
},
{
'$group': {
'_id': {
'year': {'$year': '$conclusion_date'}
},
'count': {'$sum': 1}
}
},
{'$sort': {'year': -1}}
])]
return parse_as_graphene_object(
'year',
'count',
results,
CompanyReportsPerDate
)
def resolve_companies_reports_count(self, info, **kwargs):
results = [i for i in CompanyReports.objects.mongo_aggregate([
{
'$group': {
'_id': {
'company_name': '$company_name'
},
'count': {'$sum': 1}
}
},
{'$sort': {'count': -1}},
{'$limit': 10}
])]
return parse_as_graphene_object(
'company_name',
'count',
results,
CompanyReportsCount
)
def resolve_company_reports_per_region(self, info, company_name, **kwargs):
results = [i for i in CompanyReports.objects.mongo_aggregate([
{
'$match': {
'company_name': company_name
}
},
{
'$group': {
'_id': {
'region': '$region'
},
'count': {'$sum': 1}
}
},
{'$sort': {'count': -1}}
])]
return parse_as_graphene_object(
'region',
'count',
results,
CompanyReportsPerRegion
)
def resolve_company_reports_per_age(self, info, company_name, **kwargs):
results = [i for i in CompanyReports.objects.mongo_aggregate([
{
'$match': {
'company_name': company_name
}
},
{
'$group': {
'_id': {
'age_range': '$age_range'
},
'count': {'$sum': 1}
}
},
{'$sort': {'count': -1}}
])]
return parse_as_graphene_object(
'age_range',
'count',
results,
CompanyReportsPerAgeRange
)
def resolve_company_rating_per_year(self, info, company_name, **kwargs):
results = [i for i in CompanyReports.objects.mongo_aggregate([
{
'$match': {
'company_name': company_name
}
},
{
'$group': {
'_id': {
'year': {'$year': '$conclusion_date'},
},
'average': {'$avg': '$customer_rating'}
}
},
{'$sort': {'year': -1}}
])]
return parse_as_graphene_object(
'year',
'average',
results,
CompanyRatingPerYear
)
def resolve_company_reports_per_gender(self, info, company_name, **kwargs):
results = [i for i in CompanyReports.objects.mongo_aggregate([
{
'$match': {
'company_name': company_name
}
},
{
'$group': {
'_id': {
'gender': '$gender',
},
'count': {'$sum': 1}
}
},
{'$sort': {'gender': -1}}
])]
return parse_as_graphene_object(
'gender',
'count',
results,
CompanyReportsPerGender
)
class Query(ObjectType):
"""Endpoint para consultar registros"""
delivery = Node.Field(DeliveryNode)
courier = Node.Field(CourierNode)
client = Node.Field(ClientNode)
enterprise = Node.Field(EnterpriseNode)
order = Node.Field(OrderNode)
product = Node.Field(ProductNode)
manager = Node.Field(ManagerNode)
detail = Node.Field(DetailNode)
user = Node.Field(UserNode)
management = Node.Field(ManagementNode)
payment = Node.Field(PaymentNode)
all_deliveries = DjangoFilterConnectionField(DeliveryNode)
all_couriers = DjangoFilterConnectionField(CourierNode)
all_clients = DjangoFilterConnectionField(ClientNode)
all_enterprises = DjangoFilterConnectionField(EnterpriseNode)
all_orders = DjangoFilterConnectionField(OrderNode)
all_products = DjangoFilterConnectionField(ProductNode)
all_managers = DjangoFilterConnectionField(ManagerNode)
all_details = DjangoFilterConnectionField(DetailNode)
all_users = DjangoFilterConnectionField(UserNode)
all_management = DjangoFilterConnectionField(ManagementNode)
all_payments = DjangoFilterConnectionField(PaymentNode)
class RelayQuery(graphene.ObjectType):
# 4: Uses the LinkNode with the relay_link field inside your new query.
relay_link = graphene.relay.Node.Field(LinkNode)
# 5: Defines the relay_links field as a Connection, which implements the pagination structure.
relay_links = DjangoFilterConnectionField(LinkNode,
filterset_class=LinkFilter)
class ProductQueries(graphene.ObjectType):
attributes = DjangoFilterConnectionField(
Attribute,
query=graphene.String(description=DESCRIPTIONS['attributes']),
in_category=graphene.Argument(graphene.ID),
description='List of the shop\'s attributes.')
categories = DjangoFilterConnectionField(
Category,
query=graphene.String(description=DESCRIPTIONS['category']),
level=graphene.Argument(graphene.Int),
description='List of the shop\'s categories.')
category = graphene.Field(Category,
id=graphene.Argument(graphene.ID),
description='Lookup a category by ID.')
collection = graphene.Field(Collection,
id=graphene.Argument(graphene.ID),
description='Lookup a collection by ID.')
collections = DjangoFilterConnectionField(
Collection,
query=graphene.String(description=DESCRIPTIONS['collection']),
description='List of the shop\'s collections.')
product = graphene.Field(Product,
id=graphene.Argument(graphene.ID),
description='Lookup a product by ID.')
products = DjangoFilterConnectionField(
Product,
filterset_class=ProductFilterSet,
query=graphene.String(description=DESCRIPTIONS['product']),
stock_availability=graphene.Argument(
StockAvailability,
description='Filter products by the stock availability'),
description='List of the shop\'s products.')
product_type = graphene.Field(ProductType,
id=graphene.Argument(graphene.ID),
description='Lookup a product type by ID.')
product_types = DjangoFilterConnectionField(
ProductType, description='List of the shop\'s product types.')
product_variant = graphene.Field(ProductVariant,
id=graphene.Argument(graphene.ID),
description='Lookup a variant by ID.')
product_variants = DjangoFilterConnectionField(
ProductVariant,
ids=graphene.List(graphene.ID),
description='Lookup multiple variants by ID')
report_product_sales = DjangoFilterConnectionField(
ProductVariant,
period=graphene.Argument(ReportingPeriod,
required=True,
description='Span of time.'),
description='List of top selling products.')
def resolve_attributes(self, info, in_category=None, query=None, **kwargs):
return resolve_attributes(info, in_category, query)
def resolve_category(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, Category)
def resolve_categories(self, info, level=None, query=None, **kwargs):
return resolve_categories(info, level=level, query=query)
def resolve_collection(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, Collection)
def resolve_collections(self, info, query=None, **kwargs):
return resolve_collections(info, query)
def resolve_product(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, Product)
def resolve_products(self,
info,
category_id=None,
stock_availability=None,
query=None,
**kwargs):
return resolve_products(info, category_id, stock_availability, query)
def resolve_product_type(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, ProductType)
def resolve_product_types(self, info, **kwargs):
return resolve_product_types()
def resolve_product_variant(self, info, id):
return graphene.Node.get_node_from_global_id(info, id, ProductVariant)
def resolve_product_variants(self, info, ids=None, **kwargs):
return resolve_product_variants(info, ids)
@permission_required(['order.manage_orders', 'product.manage_products'])
def resolve_report_product_sales(self, info, period, **kwargs):
return resolve_report_product_sales(info, period)
class Query(ObjectType):
pokemon = Node.Field(PokedexNode)
all_pokemons = DjangoFilterConnectionField(PokedexNode)
category = Node.Field(CategoryNode)
all_categories = DjangoFilterConnectionField(CategoryNode)
class PublicationQuery(graphene.ObjectType):
publication = relay.Node.Field(PublicationNode)
all_publications = DjangoFilterConnectionField(PublicationNode)
def test_filter_shortcut_filterset_extra_meta():
field = DjangoFilterConnectionField(
ArticleNode, extra_filter_meta={"exclude": ("headline", )})
assert "headline" not in field.filterset_class.get_fields()
class Query(ObjectType):
context_articles = DjangoFilterConnectionField(
ArticleNode, filterset_class=ArticleContextFilter)
def test_filter_explicit_filterset_orderable():
field = DjangoFilterConnectionField(ReporterNode,
filterset_class=ReporterFilter)
assert_orderable(field)
def test_filter_explicit_filterset_not_orderable():
field = DjangoFilterConnectionField(PetNode, filterset_class=PetFilter)
assert_not_orderable(field)
class Query(graphene.ObjectType):
all_posts = DjangoFilterConnectionField(PostType)
all_writers = DjangoFilterConnectionField(UserType)
post = Node.Field(PostType)
user = Node.Field(UserType)
def test_global_id_field_implicit():
field = DjangoFilterConnectionField(ArticleNode, fields=['id'])
filterset_class = field.filterset_class
id_filter = filterset_class.base_filters['id']
assert isinstance(id_filter, GlobalIDFilter)
assert id_filter.field_class == GlobalIDFormField
def test_filter_shortcut_filterset_extra_meta():
field = DjangoFilterConnectionField(ArticleNode,
extra_filter_meta={'order_by': True})
assert_orderable(field)
class ReviewQuery(graphene.ObjectType):
review_set = DjangoFilterConnectionField(ReviewType,
filterset_class=ReviewFilter)
review = graphene.relay.Node.Field(ReviewType)
class Query(ObjectType):
all_reporters = DjangoFilterConnectionField(ReporterFilterNode)
all_articles = DjangoFilterConnectionField(ArticleFilterNode)
reporter = Field(ReporterFilterNode)
article = Field(ArticleFilterNode)
class Query(graphene.AbstractType):
user = relay.Node.Field(UserType)
all_users = DjangoFilterConnectionField(UserType)
def test_global_id_field_relation():
field = DjangoFilterConnectionField(ArticleNode, fields=["reporter"])
filterset_class = field.filterset_class
id_filter = filterset_class.base_filters["reporter"]
assert isinstance(id_filter, GlobalIDFilter)
assert id_filter.field_class == GlobalIDFormField
class Query(ObjectType):
category = relay.Node.Field(CategoryNode)
all_categories = DjangoFilterConnectionField(CategoryNode)
album = relay.Node.Field(AlbumNode)
all_albums = DjangoFilterConnectionField(AlbumNode)
def test_global_id_multiple_field_implicit_reverse():
field = DjangoFilterConnectionField(ReporterNode, fields=["articles"])
filterset_class = field.filterset_class
multiple_filter = filterset_class.base_filters["articles"]
assert isinstance(multiple_filter, GlobalIDMultipleChoiceFilter)
assert multiple_filter.field_class == GlobalIDMultipleChoiceField
class Query(ObjectType):
category = relay.Node.Field(CategoryNode)
all_categories = DjangoFilterConnectionField(CategoryNode)
ingredient = relay.Node.Field(IngredientNode)
all_ingredients = DjangoFilterConnectionField(IngredientNode)
class Query(ObjectType):
all_reporters = DjangoFilterConnectionField(ReporterFilterNode)
class TenancyQuery(AbstractType):
tenant_groups = DjangoFilterConnectionField(TenantGroupNode)
tenants = DjangoFilterConnectionField(TenantNode)
class Query(ObjectType):
all_reporters = DjangoFilterConnectionField(
ReporterType, filterset_class=ReporterFilter)
def resolve_all_reporters(self, info, **args):
return Reporter.objects.order_by("a_choice")[:2]
class Query(ObjectType):
user = graphene.Field(UserType, userCD=graphene.String())
interest = graphene.Field(InterestType, pk=graphene.Int())
deal = graphene.List(lambda: graphene.List(YesdealType),
userCD=graphene.String(),
token=graphene.String(required=True))
jeep = graphene.String()
userVendor = graphene.List(UserVendorType,
user=graphene.String(required=True),
vendor=graphene.String())
dealImages = graphene.List(ImageType,
vendor=graphene.String(),
product=graphene.String(),
provider=graphene.String())
catImages = graphene.List(ImageType,
category=graphene.String(),
provider=graphene.String())
vendor_product = graphene.List(ProductType, vendor=graphene.String())
get_user_deal = graphene.List(UserDealType,
user=graphene.String(),
deal=graphene.String())
get_rating = DjangoFilterConnectionField(RatingType)
all_user = DjangoFilterConnectionField(UserType)
all_interest = DjangoFilterConnectionField(InterestType)
all_device = DjangoFilterConnectionField(DeviceType)
all_deal = DjangoFilterConnectionField(YesdealType)
all_vendor = DjangoFilterConnectionField(VendorType)
all_images = DjangoFilterConnectionField(ImageType)
all_product = DjangoFilterConnectionField(ProductType)
get_logo = DjangoFilterConnectionField(LogoType)
#def resolve_car(self,info):
#return Car.objects.all()
def resolve_get_logo(self, info, **kwargs):
return Deal_scratch.objects.all()
def resolve_user(self, info, **kwargs):
userCD = kwargs.get("userCD")
user = info.context.user
print(user)
if userCD is not None:
return User.objects.get(userCD=userCD)
#return f"Mercedes Benz | Model:23qwer | Color: Black"'''
def resolve_userVendor(self, info, **kwargs):
user = kwargs.get("user")
vendor = kwargs.get("vendor")
user_obj = User.objects.get(userCD=user)
vendor_obj = Vendor.objects.get(vendor_cd=vendor)
return User_Vendor.objects.filter(user=user_obj.id,
vendor=vendor_obj.id)
def resolve_get_user_deal(self, info, **kwargs):
user = kwargs.get("user")
deal = kwargs.get("deal")
deal_obj = Yesdeal.objects.get(deal_id=deal)
user_obj = User.objects.get(userCD=user)
return User_Deal.objects.filter(user=user_obj.id, deal=deal_obj.id)
def resolve_catImages(self, info, **kwargs):
print("here")
category = kwargs.get("category")
provider = kwargs.get("provider")
cat_obj = Interest.objects.get(category_id=category)
print(cat_obj.id)
return Images.objects.filter(category_id=cat_obj.id, provider=provider)
def resolve_dealImages(self, info, **kwargs):
print("here")
vendor = kwargs.get("vendor")
product = kwargs.get("product")
provider = kwargs.get("provider")
vendor_obj = Vendor.objects.get(vendor_cd=vendor)
prd_obj = Product.objects.get(product_cd=product)
print(vendor, product)
return Images.objects.filter(vendor_id=vendor_obj.id,
product_id=prd_obj.id,
provider=provider)
def resolve_vendor_product(self, info, **kwargs):
vendor = kwargs.get("vendor")
vendor_obj = Vendor.objects.get(vendor_cd=vendor)
return Product.objects.filter(vendor_id=vendor_obj.id)
def resolve_deal(self, info, **kwargs):
userCD = kwargs.get("userCD")
user_token = kwargs.get("token")
if userCD is not None:
user = User.objects.get(userCD=userCD)
#a=app_user_interest.objects.all()
#print(a)
#intr=a.category_name.all(user_id=user.id)
#print(user.id)
if user.user_token == user_token:
user_deal = []
interest = user.interest.all().values('id')
print(interest)
for value in interest:
for key, id in value.items():
#print(id)
coll_deal = Yesdeal.objects.filter(deal_category_id=id)
print(id, coll_deal)
if coll_deal:
user_deal.append(coll_deal)
return user_deal
else:
raise GraphQLError('User must be authenticated')
else:
raise GraphQLError("UserCD must be passed as input argument")
def resolve_all_deal(self, info, **kwargs):
return Yesdeal.objects.all()
def resolve_jeep(self, info):
return f'ya hoo!!!'
def resolve_all_user(self, info, **kwargs):
return User.objects.all()
def resolve_interest(self, info, **kwargs):
id = kwargs.get("pk")
if id is not None:
return Interest.objects.get(id=id)
def resolve_all_interest(self, info, **kwargs):
return Interest.objects.all()
def resolve_all_device(self, info, **kwargs):
return Device.objects.all()
def resolve_all_vendor(self, info, **kwargs):
return Vendor.objects.all()
def resolve_all_images(self, info, **kwargs):
return Images.objects.all()
def resolve_all_product(self, info, **kwargs):
return Product.objects.all()
def test_filter_shortcut_filterset_arguments_list():
field = DjangoFilterConnectionField(ArticleNode,
fields=["pub_date", "reporter"])
assert_arguments(field, "pub_date", "reporter")
class Query(graphene.ObjectType):
food_type = graphene.List(FoodType, search_by_name=graphene.String(required=False), category_id=graphene.String())
get_products = DjangoFilterConnectionField(ProductType, category=graphene.String(), store_id=graphene.Int(), price=graphene.String())
products_group_by_category = graphene.List(ProductByCategoryType, store_id=graphene.Int())
get_modifiers = DjangoFilterConnectionField(ModifierType, store_id=graphene.Int(), id__in=graphene.List(graphene.ID, required=False))
get_modifiers_by_product = graphene.List(ModifierType, product_id=graphene.String())
get_categories = graphene.List(CategoryType, store_id=graphene.Int())
get_allow_categories = graphene.List(CategoryType, store_id=graphene.Int())
def resolve_food_type(self, info, **kwargs):
type = Type.objects.all().order_by('-id')
if 'search_by_name' in kwargs:
type = type.filter(type_name__icontains=kwargs['search_by_name']).order_by('-id')
if 'category_id' in kwargs:
type = type.filter(type_category__category_name=kwargs['category_id'])
try:
store = info.context.store_profile.store
permits = store.categories_allowed
if permits['allow'][0]== '*':
type = type.exclude(type_category__category_name__in=permits['restricted']).distinct()
else:
type = type.filter(type_category__category_name__in=permits['allow'])
finally:
return type
def resolve_get_categories(self, info, store_id):
store_id_ = StoreLocations.objects.filter(id=store_id).first().store
permits = store_id_.categories_allowed
type_ = Type.objects.filter(in_used=store_id_).values('id')
category = Category.objects.filter(type_category__in=type_)
if permits['allow'][0]== '*':
category = category.exclude(category_name__in=permits['restricted']).distinct()
else:
category = category.filter(category_name__in=permits['allow'])
return category
def resolve_get_allow_categories(self, info, store_id):
store_id_ = StoreLocations.objects.filter(id=store_id).first().store
permits = Store.objects.get(id=store_id_.id).categories_allowed
category = []
if permits['allow'][0] == '*':
category = Category.objects.exclude(category_name__in=permits['restricted']).distinct()
else:
category = Category.objects.filter(category_name__in=permits['allow'])
return category
def resolve_get_products(self, info, store_id, **kwargs):
store_id_ = StoreLocations.objects.filter(id=store_id).first().store
product = Product.objects.filter(store=store_id_)
if('price' in kwargs):
if(kwargs['price'] == '>'):
product = product.order_by('-price')
elif(kwargs['price'] == '<'):
product = product.order_by('price')
else:
product = product.order_by('-id')
if('type' in kwargs and kwargs['type'].isnumeric()):
product = product.filter(type__id=kwargs['type'])
elif 'category' in kwargs:
category = Category.objects.filter(category_name__iexact=kwargs['category'])
product = product.filter(type__id__in=[type_.type_category.all().values('id') for type_ in category])
return product
def resolve_get_modifiers(self, info, store_id, **kwargs):
store_id_ = StoreLocations.objects.filter(id=store_id).first().store
modifiers = Modifier.objects.filter(store=store_id_).order_by('id')
if 'id__in' in kwargs:
modifiers = modifiers.filter(id__in=kwargs['id__in'])
return modifiers
def resolve_products_group_by_category(self, info, store_id):
store_id_ = StoreLocations.objects.filter(id=store_id).first().store
data = Type.objects.filter(in_used=store_id_)
data = Product.objects.filter(type__in=data, store=store_id_).order_by('type')
data = [{'type_name': key.type_name, 'products' : list(result)} for key, result in groupby(data, key=lambda item: item.type)]
return data
def resolve_get_modifiers_by_product(self, info, product_id):
modifiers = Product.objects.get(slug=product_id)
return modifiers.modifications.all()
class Query(ObjectType):
treebank = relay.Node.Field(TreebankNode)
treebanks = DjangoFilterConnectionField(TreebankNode)
class SpaceContract(graphene.Mutation):
"""
Mutation to Space Contract
"""
class Arguments:
startDate = graphene.String(required=True)
endDate = graphene.String(required=True)
spaceId = graphene.String(required=True)
order = graphene.List(graphene.String)
success = graphene.Boolean()
errors = graphene.List(ErrorsType)
space = graphene.Field(SpaceType)
contract_spaces = DjangoFilterConnectionField(SpaceType, )
@staticmethod
def mutate(_, info, **kwargs):
try:
start_date = string_to_date(kwargs.get('startDate'))
end_date = string_to_date(kwargs.get('endDate'))
space_id = kwargs.get('spaceId')
token = get_auth_token(info.context)
account_token = AccountToken.get_account({'token': token})
if account_token is None:
return SpaceContract(
success=False,
errors=[ErrorsType(field='token', message='トークンが無効です。')])
if account_token.expire < datetime.now():
account_token.delete()
return SpaceContract(
success=False,
errors=[ErrorsType(field='expired', message='期限切れです。')])
space = Space.get_empty_space_by_id(space_id)
if space is None:
return SpaceContract(
success=False,
errors=[ErrorsType(field='space', message='既に契約してます。')])
space.contract_status = True
space.contract_start = start_date
space.contract_end = end_date
space.account = account_token.account
space.save()
order = kwargs.get('order')
if order is None:
order = ['-created_date']
contract_spaces = Space.get_spaces({
'account':
account_token.account,
'contract_end__gte':
datetime.now(),
}).order_by(*order)
return SpaceContract(
success=True,
space=space,
contract_spaces=contract_spaces,
)
except Exception as e:
return SpaceContract(
success=False,
errors=[ErrorsType(field='exception', message=str(e))])
def test_filter_shortcut_filterset_orderable_true():
field = DjangoFilterConnectionField(ArticleNode, order_by=True)
assert_orderable(field)
