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')
