class Query(ObjectType): reporter = Field(ReporterType) def resolve_reporter(self, _info): return session.query(Reporter).first()
def get_retrieve_def(cls): return Field(cls.model_object, pk=Int())
class UserModel(ObjectType): first_name = String() last_name = String() email = String() username = String() role = Field(List(Role)) def has_role(self, role, partner=None): """ Check whether this user has a role for a partner. Parameters ---------- role : RoleType The role, such as `TAC_CHAIR` or `SALT_ASTRONOMER`. partner The partner for which the role is checked. Returns ------- hasrole: bool Bool indicating whether this user has the role for the partner. """ # the administrator and SALT Astronomer roles apply to all partners if role in (RoleType.ADMINISTRATOR, RoleType.SALT_ASTRONOMER): return any(r.type == role for r in self.role) return any(r.type == role and partner in r.partners for r in self.role) def may_perform(self, action, **kwargs): """ Check whether this user may perform an action. Parameters ---------- action : util.Action The action. **kwargs : kwargs Additional keyword arguments, as required by the action. Returns ------- mayperform : bool Bool indicating whether this user may perform the action. """ partner = kwargs.get('partner') proposal_code = kwargs.get('proposal_code') if action == Action.UPDATE_TIME_ALLOCATIONS or action == Action.UPDATE_TAC_COMMENTS: return self.has_role(RoleType.ADMINISTRATOR, partner) or self.has_role( RoleType.TAC_CHAIR, partner) if action == Action.VIEW_PARTNER_PROPOSALS: return self.has_role(RoleType.ADMINISTRATOR, partner) or \ self.has_role(RoleType.TAC_CHAIR, partner) or \ self.has_role(RoleType.TAC_MEMBER, partner) or \ self.has_role(RoleType.SALT_ASTRONOMER, partner) if action == Action.UPDATE_TAC_COMMENTS: return self.has_role(RoleType.ADMINISTRATOR, partner) if action == Action.UPDATE_LIAISON_ASTRONOMER: assigned_liaison = kwargs['liaison_astronomer'] current_liaison = liaison_astronomer(proposal_code) return self.has_role(RoleType.ADMINISTRATOR, partner) or \ (self.has_role(RoleType.SALT_ASTRONOMER, partner) and (current_liaison is None or current_liaison == assigned_liaison) and assigned_liaison == g.user.username) and \ assigned_liaison is not None if action == Action.UPDATE_TECHNICAL_REVIEWS: assigned_reviewer = kwargs['reviewer'] current_reviewer = technical_reviewer(proposal_code) return self.has_role(RoleType.ADMINISTRATOR, partner) or \ (self.has_role(RoleType.SALT_ASTRONOMER, partner) and (current_reviewer is None or current_reviewer == assigned_reviewer)) and \ assigned_reviewer is not None if action == Action.VIEW_PROPOSAL: if self.has_role(RoleType.ADMINISTRATOR) or self.has_role( RoleType.SALT_ASTRONOMER): return True if is_investigator(g.user.username, proposal_code): return True # Is the user on the TAC for a partner from which time is requested? proposal_partners = set([ tr.partner for tr in time_requests(proposal_code) if tr.time_request > 1 ]) for partner in proposal_partners: if self.has_role(RoleType.TAC_CHAIR, partner) or self.has_role( RoleType.TAC_MEMBER, partner): return True # The user doesn't have permission to view the proposal. return False if action == Action.SWITCH_USER: return self.has_role(RoleType.ADMINISTRATOR) return False def __str__(self): return "username: {username}, role: {role}".format( username=self.username, role=self.role)
class Login(JSONWebTokenMutation): user = Field(UserType) @classmethod def resolve(cls, root, info, **kwargs): return cls(user=info.context.user)
class Query(ObjectType): file = Field(lambda: FileNode)
class EdgeBase(object): node = Field(cls._meta.node, description='The item at the end of the edge', required=True) cursor = String(required=True, description='A cursor for use in pagination')
class PopularCategoryType(ObjectType): category = Field(CourseCategoryType) num_sessions = Int()
class PetMutation(DjangoModelFormMutation): pet = Field(PetType) class Meta: form_class = PetForm
class OPCUANode(ObjectType): """ Retrieves specified attributes of this node from OPC UA server. Represents an OPC UA node with relevant attributes. API only retrieves the specified attribute fields from the OPC UA server. """ name = String(description=d.name) description = String(description=d.description) node_class = String(description=d.node_class) variable = Field(lambda: OPCUAVariable, description=d.variable) path = String(description=d.path) node_id = String(description=d.node_id) sub_nodes = List(lambda: OPCUANode, description=d.sub_nodes) variable_sub_nodes = List(lambda: OPCUANode, description=d.variable_sub_nodes) server = String(description=d.server) node = None server_object = None node_key = None def set_node(self): if self.node is None: if self.server_object is None: self.server_object = getServer(self.server) self.node = self.server_object.get_node(self.node_id) self.node_key = self.server + "/" + self.node_id return """ Resolvers for the fields above so that only requested fields are fetched from the OPC UA server """ async def resolve_name(self, info): self.set_node() attributeKey = self.node_key + "/DisplayName" x = await attribute_loader.load(attributeKey) return x[0].Value.Value.Text async def resolve_description(self, info): self.set_node() attributeKey = self.node_key + "/Description" x = await attribute_loader.load(attributeKey) return x[0].Value.Value.Text async def resolve_node_class(self, info): self.set_node() attributeKey = self.node_key + "/NodeClass" x = await attribute_loader.load(attributeKey) return x[0].Value.Value.name async def resolve_variable(self, info): self.set_node() if subscribeVariables is True: variable = self.server_object.subscriptions.get(self.node_id) if variable is not None: return OPCUAVariable(value=variable.Value.Value, data_type=variable.Value.VariantType.name, source_timestamp=variable.SourceTimestamp, status_code=variable.StatusCode.name) else: self.server_object.subscribe_variable(self.node_id) else: attributeKey = self.node_key + "/Value" x = await attribute_loader.load(attributeKey) return OPCUAVariable(value=x[0].Value.Value, data_type=x[0].Value.VariantType.name, source_timestamp=x[0].SourceTimestamp, status_code=x[0].StatusCode.name, read_time=x[1]) def resolve_path(self, info): self.set_node() return self.server_object.get_node_path(self.node_id) def resolve_node_id(self, info): return self.node_id def resolve_sub_nodes(self, info): self.set_node() subNodes = [] for subNode in self.node.get_children(): subNodes.append( OPCUANode(server=self.server, node_id=subNode.nodeid.to_string())) return subNodes async def resolve_variable_sub_nodes(self, info): self.set_node() variableNodes = await self.server_object.get_variable_nodes(self.node) nodes = [] for variable in variableNodes: node_id = variable.nodeid.to_string() nodes.append(OPCUANode(server=self.server, node_id=node_id)) return nodes def resolve_server(self, info): return self.server
def dynamic_type(): _type = registry.get_type_for_model(model) if not _type: return return Field(_type, description=field.help_text)
class UpdatePelanggan(relay.ClientIDMutation): pelanggan = Field(PelangganNode) class Input: id = String(required=True) nama = String(required=False) pic_id = String(required=False) paket = String(required=False) ip_gpon_id = String(required=False) slot_port = String(required=False) onu_id = String(required=False) sn_ont = String(required=False) vendor = String(required=False) harga = Float(required=False) status = String(required=False) inet_fk__nomor = String(required=False) inet_fk__password = String(required=False) iptv_fk__nomor = String(required=False) iptv_fk__id = String(required=False) iptv_fk__password = String(required=False) @classmethod @transaction.atomic def mutate_and_get_payload(cls, root, info, **input): pelanggan = Pelanggan.objects.get( pk=from_global_id(input.get('id'))[1]) nama = input.get('nama') if 'nama' in input else pelanggan.nama pic_id = input.get('pic_id') if 'pic_id' in input else None paket = input.get('paket') if 'paket' in input else pelanggan.paket ip_gpon_id = input.get('ip_gpon_id') if 'ip_gpon_id' in input else None slot_port = input.get( 'slot_port') if 'slot_port' in input else pelanggan.slot_port onu_id = input.get('onu_id') if 'onu_id' in input else pelanggan.onu_id sn_ont = input.get('sn_ont') if 'sn_ont' in input else pelanggan.sn_ont vendor = input.get('vendor') if 'vendor' in input else pelanggan.vendor harga = input.get('harga') if 'harga' in input else pelanggan.harga status = input.get('status') if 'status' in input else pelanggan.status inet_fk__nomor = input.get( 'inet_fk__nomor') if 'inet_fk__nomor' in input else None inet_fk__password = input.get( 'inet_fk__password') if 'inet_fk__password' in input else None iptv_fk__nomor = input.get( 'iptv_fk__nomor') if 'iptv_fk__nomor' in input else None iptv_fk__id = input.get( 'iptv_fk__id') if 'iptv_fk__id' in input else None iptv_fk__password = input.get( 'iptv_fk__password') if 'iptv_fk__password' in input else None pelanggan.nama = nama if pic_id is not None: pelanggan.pic_id = from_global_id(pic_id)[1] pelanggan.paket = paket if ip_gpon_id is not None: pelanggan.ip_gpon_id = from_global_id(ip_gpon_id)[1] pelanggan.slot_port = slot_port pelanggan.onu_id = onu_id pelanggan.sn_ont = sn_ont pelanggan.vendor = vendor pelanggan.harga = harga pelanggan.status = status pelanggan.save() if inet_fk__nomor is not None or inet_fk__password is not None: countInternet = Internet.objects.filter( pelanggan_id=pelanggan.pk).count() if countInternet > 0: internet = Internet.objects.get(pelanggan_id=pelanggan.pk) internet.nomor = inet_fk__nomor internet.password = inet_fk__password else: internet = Internet(pelanggan=pelanggan, nomor=inet_fk__nomor, password=inet_fk__password) internet.save() if iptv_fk__nomor is not None or iptv_fk__password is not None: countIptv = Iptv.objects.filter(pelanggan_id=pelanggan.pk).count() if countIptv > 0 and iptv_fk__id is not None: iptv = Iptv.objects.get(pk=from_global_id(iptv_fk__id)[1], pelanggan_id=pelanggan.pk) iptv.nomor = iptv_fk__nomor iptv.password = iptv_fk__password else: iptv = Iptv(pelanggan=pelanggan, nomor=iptv_fk__nomor, password=iptv_fk__password) iptv.save() return UpdatePelanggan(pelanggan=pelanggan)
def dynamic_type(): _type = registry.get_type_for_model(model) if not _type: return return Field(_type)
class RootType(ObjectType): pokemons = Field(Pokemon)
def get_dynamic(): cls = self.create_type() if self._is_list is False: return Field(lambda: self.node_type, resolver=self.resolve) return relay.ConnectionField(cls, resolver=self.resolve)
class Query(ObjectType): """ Graphql Class """ alert = Field(Alert, project_name=String(required=True), organization=String(required=True)) event = Field(Events, identifier=String(required=True)) events = List(Events, project_name=String(required=True)) finding = Field(Finding, identifier=String(required=True)) login = Field(Login) resources = Field(Resource, project_name=String(required=True)) user_data = Field(User, project_name=String(required=True), user_email=String(required=True)) project = Field(Project, project_name=String(required=True)) # pylint: disable=invalid-name me = Field(Me) @require_login @require_role(['analyst', 'customer', 'admin']) @require_project_access_gql @get_cached def resolve_alert(self, info, project_name=None, organization=None): """ Resolve for alert """ del info return Alert(project_name, organization) @require_login @require_role(['analyst', 'customer', 'admin']) @require_event_access_gql @get_cached def resolve_event(self, info, identifier=None): """ Resolve for event """ util.cloudwatch_log(info.context, 'Security: Access to \ Event: {event_id} succesfully'.format(event_id=identifier)) return Events(identifier) @require_login @require_role(['analyst', 'customer', 'admin']) @require_project_access_gql def resolve_events(self, info, project_name=""): """ Resolve for eventualities """ del info resp = FormstackAPI().get_eventualities(str(project_name)) project_exist = integrates_dao.get_project_attributes_dynamo( project_name.lower(), ['project_name']) data = [] if project_exist: if "submissions" in resp: data = [Events(i["id"]) for i in resp["submissions"]] else: raise InvalidProject return data @require_login @require_role(['analyst', 'customer', 'admin']) @require_finding_access_gql @get_cached def resolve_finding(self, info, identifier=None): """Resolve for finding.""" util.cloudwatch_log(info.context, 'Security: Access to \ finding: {finding_id} succesfully'.format(finding_id=identifier)) return Finding(identifier) def resolve_login(self, info): """ Resolve for login info """ user_email = info.context.session["username"] return Login(user_email, info.context.session) @require_login @require_role(['analyst', 'customer', 'admin']) @require_project_access_gql def resolve_resources(self, info, project_name): """ Resolve for project resources """ util.cloudwatch_log(info.context, 'Security: Access to \ resources: {resources_id} succesfully'.format(resources_id=project_name)) return Resource(project_name) @require_login @require_role(['analyst', 'customeradmin', 'admin']) @require_project_access_gql @get_cached def resolve_user_data(self, info, project_name, user_email): """ Resolve for user data """ del info return User(project_name, user_email) @require_login @require_role(['analyst', 'customer', 'admin']) @require_project_access_gql def resolve_project(self, info, project_name): """Resolve for projects.""" util.cloudwatch_log(info.context, 'Security: Access to \ project: {project} succesfully'.format(project=project_name)) return Project(project_name) @require_login def resolve_me(self, info): """Resolve for current user's data """ del info return Me()
class TimeRequest(ObjectType): partner = Field(Partner) time = Int()
class Meta: model = Reporter custom_option = 'custom_option' custom_fields = OrderedDict([('custom_field', Field(Int()))])
class TacComment(ObjectType): partner = Field(Partner) comment = String() def __eq__(self, other): return self.partner.code == other.partner.code and self.comment == other.comment
class TripIntervalMetrics(ObjectType): dates = List(String) startTime = String() endTime = String() waitTimes = Field(WaitTimeStats) scheduledWaitTimes = Field(WaitTimeStats) headways = Field(BasicStats) scheduledHeadways = Field(BasicStats) tripTimes = Field(BasicStats) scheduledTripTimes = Field(BasicStats) departures = Int() scheduledDepartures = Int() arrivals = Int() scheduledArrivals = Int() departureScheduleAdherence = Field( ScheduleAdherence, early_sec=Int(required=False, default_value=60), late_sec=Int(required=False, default_value=300), ) arrivalScheduleAdherence = Field( ScheduleAdherence, early_sec=Int(required=False, default_value=60), late_sec=Int(required=False, default_value=300), ) headwayScheduleDeltas = Field(BasicStats) # parent is a metrics.TripIntervalMetrics object def resolve_dates(trip_interval_metrics, info): return [str(d) for d in trip_interval_metrics.rng.dates] def resolve_waitTimes(trip_interval_metrics, info): return trip_interval_metrics.get_wait_time_stats(scheduled=False) def resolve_scheduledWaitTimes(trip_interval_metrics, info): return trip_interval_metrics.get_wait_time_stats(scheduled=True) def resolve_headways(trip_interval_metrics, info): return trip_interval_metrics.get_headways(scheduled=False) def resolve_scheduledHeadways(trip_interval_metrics, info): return trip_interval_metrics.get_headways(scheduled=True) def resolve_tripTimes(trip_interval_metrics, info): return trip_interval_metrics.get_trip_times(scheduled=False) def resolve_scheduledTripTimes(trip_interval_metrics, info): return trip_interval_metrics.get_trip_times(scheduled=True) def resolve_departures(trip_interval_metrics, info): return trip_interval_metrics.get_departures(scheduled=False) def resolve_scheduledDepartures(trip_interval_metrics, info): return trip_interval_metrics.get_departures(scheduled=True) def resolve_arrivals(trip_interval_metrics, info): return trip_interval_metrics.get_arrivals(scheduled=False) def resolve_scheduledArrivals(trip_interval_metrics, info): return trip_interval_metrics.get_arrivals(scheduled=True) def resolve_departureScheduleAdherence(trip_interval_metrics, info, early_sec, late_sec): return trip_interval_metrics.get_departure_schedule_adherence( early_sec=early_sec, late_sec=late_sec, ) def resolve_arrivalScheduleAdherence(trip_interval_metrics, info, early_sec, late_sec): return trip_interval_metrics.get_arrival_schedule_adherence( early_sec=early_sec, late_sec=late_sec, ) def resolve_headwayScheduleDeltas(trip_interval_metrics, info): return trip_interval_metrics.get_headway_schedule_deltas() def resolve_startTime(trip_interval_metrics, info): return trip_interval_metrics.rng.start_time_str def resolve_endTime(trip_interval_metrics, info): return trip_interval_metrics.rng.end_time_str
class TechReview(ObjectType): semester = String() reviewer = Field(User) report = String()
class Query(object): course = Field(CourseType, course_id=ID()) course_category = Field(CourseCategoryType, category_id=ID()) course_note = Field(CourseNoteType, note_id=ID()) enrollment = Field(EnrollmentType, enrollment_id=ID()) enrollment_note = Field(EnrollmentNoteType, note_id=ID()) courses = List(CourseType, category_id=ID(), course_ids=List(ID), instructor_id=ID()) course_categories = List(CourseCategoryType) course_notes = List(CourseNoteType, course_id=ID(required=True)) enrollments = List(EnrollmentType, student_id=ID(), course_id=ID(), student_ids=List(ID)) enrollment_notes = List(EnrollmentNoteType, enrollment_id=ID(required=True)) # custom methods num_recent_sessions = Int(timeframe=LookbackTimeframe(required=True)) popular_categories = List(PopularCategoryType, timeframe=LookbackTimeframe(required=True)) @login_required def resolve_course(self, info, **kwargs): course_id = kwargs.get('course_id') if course_id: return Course.objects.get(id=course_id) return None @login_required def resolve_course_category(self, info, **kwargs): category_id = kwargs.get('category_id') if category_id: return CourseCategory.objects.get(id=category_id) return None @login_required def resolve_course_note(self, info, **kwargs): note_id = kwargs.get('course_note') if note_id: return CourseNote.objects.get(id=note_id) return None @login_required def resolve_enrollment_note(self, info, **kwargs): note_id = kwargs.get('note_id') if note_id: return Enrollment.objects.get(id=note_id) return None @login_required def resolve_courses(self, info, **kwargs): category_id = kwargs.get('category_id') course_ids = kwargs.get('course_ids') instructor_id = kwargs.get('instructor_id') course_list = [] if category_id: return Course.objects.filter(course_category=category_id) if course_ids: for course_id in course_ids: if Course.objects.filter(id=course_id).exists(): course_list.append(Course.objects.get(id=course_id)) if instructor_id: return Course.objects.filter(instructor_id=instructor_id) return course_list or Course.objects.all() @login_required def resolve_course_categories(self, info, **kwargs): return CourseCategory.objects.all() @login_required def resolve_course_notes(self, info, **kwargs): course_id = kwargs.get('course_id') return CourseNote.objects.filter(course__id=course_id) @login_required def resolve_enrollments(self, info, **kwargs): student_id = kwargs.get('student_id') course_id = kwargs.get('course_id') student_ids = kwargs.get('student_ids') enrollment_list = [] queryset = Enrollment.objects if student_id: queryset = queryset.filter(student=student_id) if course_id: queryset = queryset.filter(course=course_id) if student_ids: enrollment_list = Enrollment.objects.filter( student_id__in=student_ids) return enrollment_list or queryset.all() @login_required def resolve_enrollment_notes(self, info, **kwargs): enrollment_id = kwargs.get('enrollment_id') return EnrollmentNote.objects.filter(enrollment_id=enrollment_id) def resolve_num_recent_sessions(self, info, timeframe, **kwargs): now = arrow.now() if timeframe == LookbackTimeframe.YESTERDAY: return Session.objects.filter( start_datetime__gte=now.shift(days=-1).datetime, start_datetime__lte=now.datetime).count() elif timeframe == LookbackTimeframe.LAST_WEEK: return Session.objects.filter( start_datetime__gte=now.shift(weeks=-1).datetime, start_datetime__lte=now.datetime).count() elif timeframe == LookbackTimeframe.LAST_MONTH: return Session.objects.filter( start_datetime__gte=now.shift(months=-1).datetime, start_datetime__lte=now.datetime).count() elif timeframe == LookbackTimeframe.ALL_TIME: return Session.objects.filter( start_datetime__lte=now.datetime).count() return None def resolve_popular_categories(self, info, timeframe, **kwargs): category_counts = [] categories = CourseCategory.objects.all() for category in categories: courses = category.course_set.all() num_sessions = 0 now = arrow.now() for course in courses: if timeframe == LookbackTimeframe.YESTERDAY: num_sessions += course.session_set.filter( start_datetime__gte=now.shift(days=-1).datetime, start_datetime__lte=now.datetime).count() elif timeframe == LookbackTimeframe.LAST_WEEK: num_sessions += course.session_set.filter( start_datetime__gte=now.shift(weeks=-1).datetime, start_datetime__lte=now.datetime).count() elif timeframe == LookbackTimeframe.LAST_MONTH: num_sessions += course.session_set.filter( start_datetime__gte=now.shift(months=-1).datetime, start_datetime__lte=now.datetime).count() elif timeframe == LookbackTimeframe.ALL_TIME: num_sessions += course.session_set.filter( start_datetime__lte=now.datetime).count() category_counts.append({ 'category': category, 'num_sessions': num_sessions }) top_5_categories = sorted(category_counts, key=lambda item: item['num_sessions'], reverse=True)[:5] return top_5_categories
class Summoner(RiotGrapheneObject): profile_icon_id = Int() name = String() puuid = String() summonerLevel = Int() revisionDate = Int() id = String() accountId = String() championMasteryScore = Int() championMasteries = List(lambda: ChampionMastery) championMastery = Field(lambda: ChampionMastery, championId=Int()) currentGame = Field(lambda: CurrentGameInfo) leagues = Field(List(lambda: LeagueEntry)) matchlist = Field(lambda: Matchlist) thirdPartyCode = String() def resolve_championMasteryScore(self, info): watcher: RiotWatcher = info.context return watcher.champion_mastery.scores_by_summoner( self.region, self.id) def resolve_championMasteries(self, info): watcher: RiotWatcher = info.context masteries = watcher.champion_mastery.by_summoner(self.region, self.id) return [ChampionMastery(self.region, mastery) for mastery in masteries] def resolve_championMastery(self, info, championId): watcher: RiotWatcher = info.context mastery = watcher.champion_mastery.by_summoner_by_champion( self.region, self.id, championId) return ChampionMastery(self.region, mastery) def resolve_currentGame(self, info): watcher: RiotWatcher = info.context try: game = watcher.spectator.by_summoner(self.region, self.id) except ApiError as e: if e.response.status_code == 404: return None raise return CurrentGameInfo(self.region, game) def resolve_leagues(self, info): watcher: RiotWatcher = info.context try: leagues = watcher.league.by_summoner(self.region, self.id) except ApiError as e: if e.response.status_code == 404: return [] raise return [LeagueEntry(self.region, league) for league in leagues] def resolve_matchlist(self, info): watcher: RiotWatcher = info.context matchlist = watcher.match.matchlist_by_account(self.region, self.accountId) return Matchlist(self.region, matchlist) def resolve_thirdPartyCode(self, info): watcher: RiotWatcher = info.context try: return watcher.third_party_code.by_summoner(self.region, self.id) except ApiError as e: if e.response.status_code == 404: return None raise
class Query(ObjectType): all_reporters = DjangoFilterConnectionField(ReporterFilterNode) all_articles = DjangoFilterConnectionField(ArticleFilterNode) reporter = Field(ReporterFilterNode) article = Field(ArticleFilterNode)
class EmployeePage(ObjectType): """Retrieve a page of employees. Required args: page_num - Page number to retrieve. page_size - Number of items per page. Optional args: sorting_field - Field to sort by. Only supports 'department' (department name) and 'salary' right now. sorting_dir - Sorting direction enum. Either ASC or DESC. If the sorting_field is present but sorting_dir is not, defaults to ASC. """ class Meta: model = EmployeeModel def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.paging_parameters = args[0] paging_info = Field(PagingInfo, page_num=Int(), page_size=Int(), total_num_pages=Int(), has_next_page=Boolean(), has_prev_page=Boolean()) employee_page = List(Employee) # Generate paging information metadata. def resolve_paging_info(parent, info): total_num_items = Employee.get_query(info).count() params = parent.paging_parameters # Bound given page_size if <1 or >total number of items if params.page_size < 0 or params.page_size > total_num_items: params.page_size = DEFAULT_PAGE_SIZE total_num_pages = math.ceil(total_num_items / params.page_size) # Bound given page_num if <1 or >max number of pages if params.page_num < 0 or params.page_num > total_num_pages: params.page_num = 1 return PagingInfo( page_num=params.page_num, page_size=params.page_size, total_num_pages=total_num_pages, has_next_page=not (params.page_num >= total_num_pages), has_prev_page=params.page_num != 1) # Fetch a page via offset pagination. Pages are 1-indexed! def resolve_employee_page(parent, info): page_num = parent.paging_parameters.page_num page_size = parent.paging_parameters.page_size offset = (page_num - 1) * page_size # For 1-indexed pages query = Employee.get_query(info).offset(offset).limit( page_size).from_self() # Check for applicable sorting column and direction sorting_by = parent.paging_parameters.sorting_field sorting_dir = parent.paging_parameters.sorting_dir if sorting_by == 'department': if sorting_dir == SortingDirection.DESC.value: query = query.join(DepartmentModel).order_by( DepartmentModel.name.desc()) else: query = query.join(DepartmentModel).order_by( DepartmentModel.name.asc()) elif sorting_by == 'salary': if sorting_dir == SortingDirection.DESC.value: query = query.order_by(EmployeeModel.salary.desc()) else: query = query.order_by(EmployeeModel.salary.asc()) return query.all()
def get_list_def(cls): return Field(GqlList(cls.model_object), args=cls.get_list_args())
class StatsQueries: dashboard_statistics = Field(Statistics, customer=ID(), days=Int()) def resolve_dashboard_statistics(self, info, **kwargs): print(kwargs) return True
class Role(ObjectType): type = RoleType() partners = Field(List(String)) def resolve_type(self, *args, **kwargs): return self.type.value
class Statistics(ObjectType): class Input: days = Int() total = Field(KwCounts, days=Int()) routine = Field(KwCounts, days=Int()) project = Field(KwCounts, days=Int()) services = Field(KwCounts, days=Int()) ex = Field(KwCounts, days=Int()) def resolve_total(self, info, days): orders_filters = {'is_active': True} filters = {'req_id__is_active': True} if days: today = jdatetime.date.today() start_date = today - jdatetime.timedelta(days) orders_filters.update({'date_fa__gte': start_date}) filters.update({'req_id__date_fa__gte': start_date}) orders_active = Requests.objects.filter(**orders_filters) count = orders_active.count() rspec = ReqSpec.objects.filter(**filters) kw = calculate_kw(rspec) kw = 0 if not kw else kw count = 0 if not count else count return KwCounts(title='تعداد درخواست ها', kw=kw, count=count) def resolve_routine(self, info, days=None): filters = {'type__title': 'روتین'} if days: today = jdatetime.date.today() start_date = today - jdatetime.timedelta(days) filters.update({ 'req_id__date_fa__gte': start_date, }) specs = reqspecs_raw().filter(**filters) kw = calculate_kw(specs) count = specs.values('req_id').distinct().count() kw = 0 if not kw else kw count = 0 if not count else count return KwCounts(title='روتین (KW)', kw=kw, count=count) def resolve_ex(self, info, days=None): filters = {'type__title': 'ضد انفجار'} if days: today = jdatetime.date.today() start_date = today - jdatetime.timedelta(days) filters.update({ 'req_id__date_fa__gte': start_date, }) specs = reqspecs_raw().filter(**filters) kw = calculate_kw(specs) count = specs.values('req_id').distinct().count() kw = 0 if not kw else kw count = 0 if not count else count return KwCounts(title='ضدانفجار (KW)', kw=kw, count=count) def resolve_services(self, info, days=None): filters = {'type__title': 'تعمیرات'} if days: today = jdatetime.date.today() start_date = today - jdatetime.timedelta(days) filters.update({ 'req_id__date_fa__gte': start_date, }) specs = reqspecs_raw().filter(**filters) kw = calculate_kw(specs) count = specs.values('req_id').distinct().count() kw = 0 if not kw else kw count = 0 if not count else count # kw = kw_per_project_type('تعمیرات') # count = count_per_project_type('تعمیرات') return KwCounts(title='تعمیرات (KW)', kw=kw, count=count) def resolve_project(self, info, days=None): filters = {'type__title': 'پروژه'} if days: today = jdatetime.date.today() start_date = today - jdatetime.timedelta(days) filters.update({ 'req_id__date_fa__gte': start_date, }) specs = reqspecs_raw().filter(**filters) kw = calculate_kw(specs) count = specs.values('req_id').distinct().count() kw = 0 if not kw else kw count = 0 if not count else count # kw = kw_per_project_type('پروژه') # count = count_per_project_type('پروژه') return KwCounts(title='پروژه (KW)', count=count, kw=kw)
def __init_subclass_with_meta__(cls, model=None, results_field_name=None, pagination=None, only_fields=(), exclude_fields=(), filter_fields=None, queryset=None, filterset_class=None, **options): assert is_valid_django_model(model), ( 'You need to pass a valid Django Model in {}.Meta, received "{}".' ).format(cls.__name__, model) if not DJANGO_FILTER_INSTALLED and filter_fields: raise Exception( "Can only set filter_fields if Django-Filter is installed") assert isinstance(queryset, QuerySet) or queryset is None, ( 'The attribute queryset in {} needs to be an instance of ' 'Django model queryset, received "{}".').format( cls.__name__, queryset) results_field_name = results_field_name or 'results' baseType = get_global_registry().get_type_for_model(model) if not baseType: factory_kwargs = { 'model': model, 'only_fields': only_fields, 'exclude_fields': exclude_fields, 'filter_fields': filter_fields, 'filterset_class': filterset_class, 'pagination': pagination, 'queryset': queryset, 'skip_registry': False } baseType = factory_type('output', DjangoObjectType, **factory_kwargs) filter_fields = filter_fields or baseType._meta.filter_fields if pagination: result_container = pagination.get_pagination_field(baseType) else: global_paginator = graphql_api_settings.DEFAULT_PAGINATION_CLASS if global_paginator: assert issubclass( global_paginator, BaseDjangoGraphqlPagination ), ('You need to pass a valid DjangoGraphqlPagination class in {}.Meta, received "{}".' ).format(cls.__name__, global_paginator) global_paginator = global_paginator() result_container = global_paginator.get_pagination_field( baseType) else: result_container = DjangoListField(baseType) _meta = DjangoObjectOptions(cls) _meta.model = model _meta.queryset = queryset _meta.baseType = baseType _meta.results_field_name = results_field_name _meta.filter_fields = filter_fields _meta.exclude_fields = exclude_fields _meta.only_fields = only_fields _meta.filterset_class = filterset_class _meta.fields = OrderedDict([ (results_field_name, result_container), ('count', Field(Int, name='totalCount', description="Total count of matches elements")) ]) super(DjangoListObjectType, cls).__init_subclass_with_meta__(_meta=_meta, **options)
class Query( pokedex.schema.Query, ObjectType, ): debug = Field(DjangoDebug, name='__debug')