class Rider(ObjectType): id = Int(required=True) firstName = String(required=True) lastName = String(required=True) email = String(required=True) birthday = DateTime(required=True) teams = List(NonNull(Team), required=True) rides = List(NonNull(Ride), required=True) def resolve_teams(rider, info): db_cursor.execute( """ SELECT team.id, website, contactEmail, since FROM team INNER JOIN teamMember tm ON team.id = tm.teamId WHERE tm.cyclistId = %(rider_pk)s """, {"rider_pk": rider['rider_id']}) return [Rider(**row_data) for row_data in db_cursor.fetchall()] def resolve_rides(rider, info): db_cursor.execute( """ SELECT ride.cyclistId, trailId, date, distance FROM ride INNER JOIN rider ON rider.id = ride.cyclistId WHERE ride.cyclistId = %(rider_pk)s """, {"rider_pk": rider['rider_id']}) return [Rider(**row_data) for row_data in db_cursor.fetchall()]
def __init__(self, _type, ordering="-created", cursor_query_param="cursor", *args, **kwargs): kwargs.setdefault("args", {}) self.page_size = graphql_api_settings.DEFAULT_PAGE_SIZE self.page_size_query_param = "page_size" if not self.page_size else None self.cursor_query_param = cursor_query_param self.ordering = ordering self.cursor_query_description = "The pagination cursor value." self.page_size_query_description = "Number of results to return per page." kwargs[self.cursor_query_param] = NonNull( String, description=self.cursor_query_description) if self.page_size_query_param: if not self.page_size: kwargs[self.page_size_query_param] = NonNull( Int, description=self.page_size_query_description) else: kwargs[self.page_size_query_param] = Int( description=self.page_size_query_description) super(CursorPaginationField, self).__init__(List(_type), *args, **kwargs)
class Company(ObjectType): id = ID(required=True) name = String(required=True) address_line1 = String(required=False) address_line2 = String(required=False) address_line3 = String(required=False) postal_code = String(required=True) city = String(required=True) industry = Field(Industry, required=False) contact = Field(CompanyContact, required=True) # lazy demands = List(lambda: NonNull(Demand), resolver=demands_by_company) supplies = List(lambda: NonNull(Supply), resolver=supplies_by_company) # def resolve_contact(root, info): # if root. def resolve_industry(root, info): if root.industry_id is None: return [] return g.industry_loader.load(root.industry_id)
class Input(object): """ We need the ticker, bucket and quantity to create the connection """ stock_id = NonNull(ID) bucket_id = NonNull(ID) quantity = NonNull(Float)
class Input(object): """ We need the description and the bucket as input """ desc = NonNull(String) bucket_id = NonNull(ID) is_good = NonNull(Boolean)
class PrivacySettings(MongoengineObjectType): class Meta: model = PrivacySettingsModel users_access = NonNull(List(NonNull(UserPrivacySettings))) visibility = VisibilityEnum(required=True) public_access_type = AccessEnum(required=True)
class CreatePerson(Mutation): """Create a new person. """ # class Meta(object): # interfaces = (Person, ) # TODO: REFACTOR! id = NonNull(ID, description="Unique ID.") name = NonNull(String, description="Name, full name or username.") age = Field(Int, description="Age in years.") # person = Field(Person) # TODO class Arguments: name = Argument(String, required=True, description="Name, full name or username.") age = Argument(Int, default_value=-1, description="Age in years.") def mutate(root, info, name, **kwargs): id = uuid.uuid4() age = kwargs.get("age") person = Person(id=id, name=name, age=age) faux_database[id] = person return CreatePerson(id=id, name=name, age=age)
class Arguments(object): """ Arguments to create a trade. Right now it's only ticker and quantity. """ id_value = NonNull(String) quantity = NonNull(Int) account_name = NonNull(String)
class UpdateSamplesMutation(Mutation): class Arguments: samples = NonNull(List(NonNull(SampleInput))) committed = NonNull(Boolean) diff = NonNull(SamplesDiff) @classmethod def mutate(cls, root, info, samples, *args, **kwargs): committed = False with transaction.atomic(): # retrieve samples from db samples_db = models.Sample.objects.all() # validate (with renamed fk field) samples_to_compare = deserialise_samples(samples) # compute diff diff = diff_samples(samples_db, samples_to_compare) # only update if there are no missing institutions if len(diff["missing_institutions"]) == 0: # clear samples table in db samples_db.delete() # insert new entries models.Sample.objects.bulk_create(samples_to_compare) committed = True return UpdateSamplesMutation(committed=committed, diff=diff)
class Arguments(object): """ We need quantity, account id and bucket id """ quantity = NonNull(Float) trading_acc_id = NonNull(ID) bucket_id = NonNull(ID)
class GTradingAccount(DjangoObjectType): """ Exposing the whole TradingAccount to GraphQL """ total_value = NonNull(Float) available_cash = NonNull(Float) class Meta(object): """ Meta Model for TradingAccount """ model = TradingAccount interfaces = (relay.Node, ) @staticmethod def resolve_total_value(data, _info, **_args): """ Returns the total value that the account currently holds """ return data.total_value() @staticmethod def resolve_available_cash(data, _info, **_args): """ Returns the amount of cash the user has available """ return data.available_cash(False)
class Rocket_Type(ObjectType): rocket_id = NonNull(String) rocket_name = NonNull(String) rocket_type = NonNull(String) first_stage = NonNull(First_Stage_Type) second_stage = NonNull(Second_Stage_Type) fairings = Field(Fairings)
class Input(object): """ We only need the name of the new bucket to create it """ name = NonNull(String) investment = NonNull(Float) public = NonNull(Boolean)
class Query(ObjectType): user = Field(githubUserType, username=NonNull(String)) repo = List(RepositoryType, username=NonNull(String)) project = List(ProjectType, username=NonNull(String)) def resolve_user(self, info, username): cache_key = 'user-{}'.format(username) cached_user = cache.get(cache_key) if cached_user: return convertJsonToObject(cached_user, "user") return resolveUser(username) def resolve_repo(self, info, username): cache_key = 'repo-{}'.format(username) cached_repo = cache.get(cache_key) if cached_repo: return convertJsonToObject(cached_repo, "user") return resolveUserRepos(username) def resolve_project(self, info, username): cache_key = 'project-{}'.format(username) cached_project = cache.get(cache_key) if cached_project: return convertJsonToObject(cached_project, "project") return resolveUserProject(username)
class SlotType(ObjectType): class Meta: name = "Slot" id = NonNull(ID) talk = Field(TalkType) session = NonNull(lambda: SessionType) room = NonNull(RoomType)
class CountryQuery(object): countries = NonNull(List(NonNull(CountryType))) def resolve_countries(root, info): return [{ "code": key, "name": value } for key, value in dict(countries).items()]
class UserInfo(ObjectType): class Meta: interfaces = (UserInterface, ) follower_count = NonNull(Int) following_count = NonNull(Int) biography = NonNull(String) feed = Field(NonNull(Feed))
class GridType(ObjectType): class Meta: name = "Grid" sessions = NonNull(List(NonNull(SessionType))) @staticmethod def resolve_sessions(parent, info): return parent["sessions"].order_by("start_time")
def test_handles_non_null_list_of_non_null_nested_type(self): InnerType = create_obj_type_mock(Field(String)) OuterType = create_obj_type_mock(NonNull(List(NonNull(InnerType)))) data = {'field': [{'field': 'a'}, {'field': 'b'}]} stitched = stitch(OuterType)(data) outer = stitched.resolve_field(None) print(outer) assert [x.resolve_field(None) for x in outer] == ['a', 'b']
class SpeakerType(ObjectType): class Meta: name = "Speaker" id = NonNull(ID) name = NonNull(String) @staticmethod def resolve_name(parent: User, info): return parent.username
class Person(ObjectType): id = NonNull(ID) first_name = NonNull(String) last_name = NonNull(String) age = NonNull(Int) profile_url = NonNull(String) @staticmethod def resolve_profile_url(root: 'Person', info): return info.context.loaders.person_profile_pictures.load(root.id)
class Arguments: username = String(required=True) taskid = Int(required=True) title = String(required=True) description = String() starttime = types.DateTime() endtime = types.DateTime() priority = String() preqtaskid = List(NonNull(Int)) assignedto = NonNull(List(NonNull(String)))
class Arguments: assignedby = String(required=True) assignedto = NonNull(List(NonNull(String))) projectid = Int(required=True) title = String(required=True) description = String() startdate = types.DateTime() enddate = types.DateTime() priority = String() preqtaskid = List(NonNull(Int))
class Page(ObjectType): name = NonNull(String) title = NonNull(String) contenttype = PageType content = String def __init__(self, name, title, contenttype): self.name = name self.title = title self.contenttype = contenttype self.content = ''
class Engines(ObjectType): number = NonNull(Int) type = NonNull(String) version = NonNull(String) layout = NonNull(String) engine_loss_max = NonNull(Int) propellant_1 = NonNull(String) propellant_2 = NonNull(String) thrust_sea_level = NonNull(Thrust_Sea_Level) thrust_vacuum = NonNull(Thrust_Vacuum) thrust_to_weight = NonNull(Float)
class Payload(ObjectType): payload_id = NonNull(String) reused = NonNull(Boolean) nationality = NonNull(String) manufacturer = NonNull(String) payload_type = NonNull(String) payload_mass_kg = NonNull(Int) payload_mass_lbs = NonNull(Int) orbit = NonNull(String) orbit_params = NonNull(Orbit_Params) customers = List(NonNull(String)) norad_id = List(Int)
class Chat(DjangoObjectType): page_limit = 256 class Meta: model = models.Chat exclude_fields = ('password', ) log_list = graphene.Field(LogList, password=graphene.String(), page=graphene.Int(), tag_id=graphene.String()) has_password = NonNull(graphene.Boolean) counter = NonNull(graphene.Int) page_counter = NonNull(graphene.Int) @staticmethod def resolve_has_password(chat: models.Chat, info): return bool(chat.password) @staticmethod def resolve_page_counter(chat: models.Chat, info): return chat.all_log().count() % Chat.page_limit @staticmethod def resolve_log_list(chat: models.Chat, info, password='', tag_id=None, page=1): if page < 1: page = 1 limit = Chat.page_limit offset = (page - 1) * Chat.page_limit tag_name = None if not chat.password or (chat.password and chat.validate(password)): query_set = chat.all_log() if tag_id: tag: Optional[models.Tag] = models.Tag.objects.filter( id=int(tag_id), chat=chat).first() if tag: query_set = tag.log_set.all() log_counter = query_set.count() log_list = LogList(tag_name=tag_name, log_list=query_set[offset:offset + limit].all(), total_page=log_counter // Chat.page_limit + 1) return log_list else: return None @staticmethod def resolve_counter(chat: models.Chat, info): return chat.log_count()
class Post(ObjectType): """A text published by an author. """ """ type Post { id: ID! text: String! author: Person! } """ id = NonNull(ID, description="Unique ID.") text = NonNull(String, description="UTF-8 content.") author = NonNull(Person, description="Text author.")
class Person(ObjectType): """User which can author posts. """ """ type Person { id: ID! name: String! age: Int # posts: [Post!]! } """ id = NonNull(ID, description="Unique ID.") name = NonNull(String, description="Name, full name or username.") age = Field(Int, description="Age in years.")
class Query(ObjectType): articles = List(NonNull(lambda: Article)) articles_with_author_age_provide = List( NonNull(lambda: ArticleThatProvideAuthorAge)) def resolve_articles(self, info): return [Article(id=1, text='some text', author=User(id=5))] def resolve_articles_with_author_age_provide(self, info): return [ ArticleThatProvideAuthorAge(id=1, text='some text', author=User(id=5)) ]