class BaseInterface(Interface):
id = ID(required=True)
class UpdateClientInput(InputObjectType):
id = ID(required=True)
first_name = String()
last_name = String()
email = String()
class CreateCareerInput(InputObjectType):
name = String(required=True)
description = String(required=True)
college_id = ID(required=True)
class Score(ObjectType):
id = ID()
pointing = Float()
last_query = String()
class UpdateRefereeInput(InputObjectType, RefereeAttribute):
"""Update Referee Input fields derived from RefereeAttribute"""
id = ID(required=True, description="Global Id of the Referee.")
class Query:
berth_products = DjangoConnectionField(
BerthProductNode,
description="**Requires permissions** to access payments.",
)
berth_product = Node.Field(
BerthProductNode,
description="**Requires permissions** to access payments.",
)
berth_product_for_width = Field(
BerthProductNode,
width=Decimal(required=True),
description="**Requires permissions** to access payments.",
)
winter_storage_products = DjangoConnectionField(
WinterStorageProductNode,
description="**Requires permissions** to access payments.",
)
winter_storage_product = Node.Field(
WinterStorageProductNode,
description="**Requires permissions** to access payments.",
)
additional_products = DjangoConnectionField(
AdditionalProductNode,
product_type=AdditionalProductTypeEnum(),
description="**Requires permissions** to access payments.",
)
additional_product = Node.Field(
AdditionalProductNode,
description="**Requires permissions** to access payments.",
)
additional_product_services = List(
AdditionalProductServiceNode, product_type=AdditionalProductTypeEnum())
order = Node.Field(
OrderNode,
description="**Requires permissions** to access payments.",
)
orders = DjangoConnectionField(
OrderNode,
statuses=List(OrderStatusEnum),
order_type=OrderTypeEnum(),
description="**Requires permissions** to access payments.",
)
order_refunds = DjangoConnectionField(
OrderRefundNode,
order_id=ID(required=True),
description="Returns the Order Refund objects associated to the order."
"\n\n**Requires permissions** to access payments.",
)
berth_switch_offer = Node.Field(
BerthSwitchOfferNode,
description="**Requires permissions** to access offers.",
)
berth_switch_offers = DjangoConnectionField(BerthSwitchOfferNode)
order_details = Field(OrderDetailsType, order_number=String(required=True))
@view_permission_required(BerthProduct)
def resolve_berth_product_for_width(self, info, width, **kwargs):
return BerthProduct.objects.get_in_range(width)
def resolve_additional_products(self, info, **kwargs):
product_type = kwargs.get("product_type")
if product_type:
product_type = AdditionalProductType(product_type)
if product_type == AdditionalProductType.FIXED_SERVICE:
return AdditionalProduct.objects.filter(
service__in=ProductServiceType.FIXED_SERVICES())
elif product_type == AdditionalProductType.OPTIONAL_SERVICE:
return AdditionalProduct.objects.filter(
service__in=ProductServiceType.OPTIONAL_SERVICES())
return AdditionalProduct.objects.all()
def resolve_additional_product_services(self, info, **kwargs):
service_list = list(ProductServiceType)
product_type = kwargs.get("product_type")
if product_type:
product_type = AdditionalProductType(product_type)
if product_type == AdditionalProductType.FIXED_SERVICE:
service_list = ProductServiceType.FIXED_SERVICES()
elif product_type == AdditionalProductType.OPTIONAL_SERVICE:
service_list = ProductServiceType.OPTIONAL_SERVICES()
return [
AdditionalProductServiceNode(service=service)
for service in service_list
]
def resolve_orders(self, info, order_type=None, statuses=None, **kwargs):
qs = Order.objects.all()
if order_type:
if order_type == "BERTH":
qs = Order.objects.berth_orders()
else:
qs = Order.objects.winter_storage_orders()
if statuses:
qs = qs.filter(status__in=statuses)
return qs
def resolve_order_refunds(self, info, order_id, **kwargs):
return OrderRefund.objects.filter(
order_id=from_global_id(order_id, OrderNode))
def resolve_order_details(self, info, order_number):
try:
order = Order.objects.get(order_number=order_number)
except Order.DoesNotExist as e:
raise VenepaikkaGraphQLError(e)
is_application_order = (hasattr(order, "lease") and getattr(
order.lease, "application", None) is not None)
order_type = Query._get_order_type(order)
if isinstance(order.lease, BerthLease):
place_number = order.lease.berth.number
section_identifier = order.lease.berth.pier.identifier
area_name = order.lease.berth.pier.harbor.name
elif isinstance(order.lease, WinterStorageLease):
if order.lease.place:
place_number = str(order.lease.place.number)
section_identifier = order.lease.place.winter_storage_section.identifier
area_name = order.lease.place.winter_storage_section.area.name
else:
# unmarked ws lease
place_number = None
section_identifier = order.lease.section.identifier
area_name = order.lease.section.area.name
else:
place_number = None
section_identifier = None
area_name = None
return OrderDetailsType(
status=order.status,
order_type=order_type,
area=area_name,
section=section_identifier,
place=place_number,
is_application_order=is_application_order,
)
@staticmethod
def _get_order_type(order):
# in graphene-python, all resolvers are implictly staticmethods, so need to make this utility static too.
order_type = OrderTypeEnum.UNKNOWN
if order.order_type == OrderType.ADDITIONAL_PRODUCT_ORDER:
order_type = OrderTypeEnum.ADDITIONAL_PRODUCT
elif order.product:
if isinstance(order.product, BerthProduct):
order_type = OrderTypeEnum.BERTH
elif isinstance(order.product, WinterStorageProduct):
order_type = OrderTypeEnum.WINTER_STORAGE
elif order.lease:
if isinstance(order.lease, BerthLease):
order_type = OrderTypeEnum.BERTH
elif isinstance(order.lease, WinterStorageLease):
order_type = OrderTypeEnum.WINTER_STORAGE
return order_type
class Arguments:
id = ID(required=True)
def convert_field_to_id(field, registry=None):
return ID(description=field.help_text)
class CreditCard(ObjectType):
id = ID()
number = String()
expiration_date = String()
class Investigator(ObjectType):
id = ID()
first_name = String()
surname = String()
email = String()
class UpdateCoachInput(InputObjectType, CoachAttribute):
"""Update Coach Input fields derived from CoachAttribute"""
id = ID(required=True, description="Global Id of the Coach.")
class Arguments:
parent = ID(required=True)
registration_preferences = String()
def __init__(self, type, resolver=default_model_resolver):
super().__init__(type, id=ID(), resolver=resolver)
class GInvestmentBucketConfigurationUpdate(InputObjectType):
"""
Represents one choice of stock for a bucket
"""
id_value = ID()
quantity = Float()
def __init__(self, _type, *args, **kwargs):
kwargs['id'] = ID(
required=True,
description='Django object unique identification field')
super(DjangoObjectField, self).__init__(_type, *args, **kwargs)
class Debt(ObjectType):
id = ID()
name = String()
value = Float()
def convert_field_to_id(field, registry=None):
return ID(description=field.db_field, required=field.required)
class TemplateInput(InputObjectType):
title = String()
description = String()
author = ID()
contents = List(NonNull(TemplateSectionInput))
def convert_field_to_id(field, registry=None):
return ID(description=field.help_text, required=not field.null)
class ProductInterface(CommonAttributes, DBInterface):
company = ID()
product_categories = List(ProductCategory)
class DBInterface(Interface):
_id = ID(required=True)
creation_date = DateTime(required=True)
modified_date = DateTime(required=True)
class Arguments:
company_id = ID(required=True)
product_form_data = NewProductFormInput(required=True)
def convert_form_field_to_id(field):
return ID(required=field.required)
class Input:
id = ID()
text = String(required=True)
class UpdateSkillInput(InputObjectType):
id = ID(required=True)
name = String()
class Input:
id = ID()
data = GenericScalar()
class UpdateCollegeInput(InputObjectType):
id = ID(required=True)
name = String()
class Input:
id = ID()
class UpdateCareerInput(InputObjectType):
id = ID(required=True)
name = String()
description = String()
college_id = ID()
class Query(object):
course = Field(CourseType, course_id=ID())
course_availability = Field(CourseAvailabilityType, availability_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())
interest = Field(InterestType, interest_id=ID())
courses = List(CourseType,
category_id=ID(),
course_ids=List(ID),
user_id=ID())
course_availabilities = List(CourseAvailabilityType,
course_id=ID(),
availability_ids=List(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))
interests = List(InterestType, parent_id=ID(), course_id=ID())
# custom methods
num_recent_sessions = Int(timeframe=LookbackTimeframe(required=True))
popular_categories = List(PopularCategoryType,
timeframe=LookbackTimeframe(required=True))
@login_required
def resolve_course_availability(self, info, **kwargs):
availability_id = kwargs.get("availability_id")
if availability_id:
return CourseAvailability.objects.get(id=availability_id)
return None
@login_required
def resolve_course_availabilities(self, info, **kwargs):
course_id = kwargs.get("course_id")
availability_ids = kwargs.get("availability_ids")
if course_id:
return CourseAvailability.objects.filter(course_id=course_id)
if availability_ids:
return CourseAvailability.objects.filter(id__in=availability_ids)
return None
@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(self, info, **kwargs):
enrollment_id = kwargs.get("enrollment_id")
if enrollment_id:
return Enrollment.objects.get(id=enrollment_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_interest(self, info, **kwargs):
interest_id = kwargs.get("interest_id")
if interest_id:
return Interest.objects.get(id=interest_id)
return None
@login_required
def resolve_courses(self, info, **kwargs):
category_id = kwargs.get("category_id")
course_ids = kwargs.get("course_ids")
user_id = kwargs.get("user_id")
if category_id:
return Course.objects.filter(course_category=category_id)
if course_ids:
course_ids = [
course_id for course_id in course_ids
if Course.objects.filter(id=course_id).exists()
]
return Course.objects.filter(id__in=course_ids)
if user_id:
if Instructor.objects.filter(user_id=user_id).exists():
return Course.objects.filter(instructor_id=user_id)
if Parent.objects.filter(user_id=user_id).exists():
parent = Parent.objects.get(user_id=user_id)
student_course_ids = set()
for student_id in parent.student_list:
for enrollment in Enrollment.objects.filter(
student=student_id):
student_course_ids.add(enrollment.course.id)
return Course.objects.filter(id__in=student_course_ids)
return Course.objects.all()
@login_required
def resolve_course_categories(self, info, **kwargs):
categories = CourseCategory.objects.all()
sorted_categories = sorted(categories,
key=lambda t: -t.active_tuition_rule_count)
return sorted_categories
@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
@login_required
def resolve_interests(self, info, **kwargs):
parent_id = kwargs.get("parent_id")
course_id = kwargs.get("course_id")
if parent_id:
return Interest.objects.filter(parent__user__id=parent_id)
if course_id:
return Interest.objects.filter(course=course_id)
return None
