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)