class AnimalAttributes(object):
id = ID(required=False)
name = String(required=False)
species = String(required=False)
insertDate = String(required=False)
gender = String(required=False)
size = String(required=False)
city = String(required=False)
imageURL = String(required=False)
detail = String(required=False)
category = String(required=False)
userId = Int(required=False)
class IProductImagesType(ObjectType):
id = ID()
img150 = String(required=False)
img245 = String(required=False)
img500 = String(required=False)
img800 = String(required=False)
img245x245 = String(required=False)
img150x150 = String(required=False)
img500x500 = String(required=False)
img800x800 = String(required=False)
main = Boolean(required=False)
dimension = Field(ImageDimensionType)
class CoreQuery(object):
uploads = Field(List(UploadType))
upload = Field(UploadType, id=ID(required=True))
@login_required
def resolve_upload(self, info, id):
return Upload.objects.get(id=Node.gid2id(id))
@login_required
def resolve_uploads(self, info):
return Upload.objects.filter(user=info.context.user).order_by(
'-created_at') # noqa: E501
class Query(ObjectType):
"""
Graphql Queries
"""
get_all_laws = Field(
LawsPageType,
page=Int(),
search_filter=String(),
description=_('Gets all laws')
)
get_questions_by_law = List(
LawType,
id_law=ID(required=True, description=_('Get questions by id of law'))
)
get_favorites = Field(
LawsPageType,
page=Int(),
search_filter=String(),
description=_('Get favorites laws')
)
@staticmethod
def resolve_get_all_laws(self, info, **kwargs):
page = kwargs.get('page', 1)
search_filter = kwargs.get('search_filter', '')
query_set = Law.objects.filter(
Q(title__icontains=search_filter)
| Q(description__icontains=search_filter)
).order_by('title')
return get_paginator(query_set, PAGE_SIZE, page, LawsPageType)
@login_required
def resolve_get_favorites(self, info, **kwargs):
user = info.context.user
page = kwargs.get('page', 1)
search_filter = kwargs.get('search_filter', '')
query_set = user.favorites.filter(
Q(title__icontains=search_filter)
| Q(description__icontains=search_filter)
).order_by('title')
return get_paginator(query_set, PAGE_SIZE, page, LawsPageType)
@staticmethod
def resolve_get_questions_by_law(self, info, **kwargs):
id_law = kwargs.get('id_law')
query_set = Law.objects.filter(pk=id_law)
return query_set
class Queries(ObjectType):
workflows = List(Workflow,
ids=List(ID, default_value=[]),
exids=List(ID, default_value=[]),
resolver=get_workflows)
job = Field(Job, id=ID(required=True), resolver=get_node_by_id)
jobs = List(Job, args=all_jobs_args, resolver=get_nodes_all)
task = Field(Task, id=ID(required=True), resolver=get_node_by_id)
tasks = List(Task, args=all_def_args, resolver=get_nodes_all)
task_proxy = Field(TaskProxy,
id=ID(required=True),
resolver=get_node_by_id)
task_proxies = List(TaskProxy, args=all_proxy_args, resolver=get_nodes_all)
family = Field(Family, id=ID(required=True), resolver=get_node_by_id)
families = List(Family, args=all_def_args, resolver=get_nodes_all)
family_proxy = Field(FamilyProxy,
id=ID(required=True),
resolver=get_node_by_id)
family_proxies = List(FamilyProxy,
args=all_proxy_args,
resolver=get_nodes_all)
edges = List(Edge, args=all_edge_args, resolver=get_edges_all)
class QueryEvent(ObjectType):
events = List(Event,
limit=Int(required=True),
offset=Int(),
description="Fetches lists of events")
searchEvent = Field(Event,
id=ID(required=True),
description="Fetches a single event by id")
eventCharacters = List(
Character,
id=ID(required=True),
limit=Int(required=True),
offset=Int(),
description="Fetches lists of characters filtered by an event id")
eventComics = List(
Comics,
id=ID(required=True),
limit=Int(required=True),
offset=Int(),
description="Fetches lists of comics filtered by an event id")
eventCreators = List(
Creator,
id=ID(required=True),
limit=Int(required=True),
offset=Int(),
description="Fetches lists of creators filtered by an event id")
eventSeries = List(
Series,
id=ID(required=True),
limit=Int(required=True),
offset=Int(),
description="Fetches lists of series filtered by an event id")
eventStories = List(
Story,
id=ID(required=True),
limit=Int(required=True),
offset=Int(),
description="Fetches lists of stories filtered by an event id")
def resolve_events(root, info, limit=None, offset=None):
return resolve_event.list_events(limit, offset)
def resolve_searchEvent(root, info, id):
return resolve_event.search_event(id)
def resolve_eventCharacters(root, info, id, limit, offset=None):
return resolve_event.find_event_characters(id, limit, offset)
def resolve_eventComics(root, info, id, limit, offset=None):
return resolve_event.find_event_comics(id, limit, offset)
def resolve_eventCreators(root, info, id, limit, offset=None):
return resolve_event.find_event_creators(id, limit, offset)
def resolve_eventSeries(root, info, id, limit, offset=None):
return resolve_event.find_event_series(id, limit, offset)
def resolve_eventStories(root, info, id, limit, offset=None):
return resolve_event.find_event_stories(id, limit, offset)
class Task(ObjectType):
"""Task definition, static fields"""
id = ID(required=True)
name = String(required=True)
meta = Field(Meta)
mean_elapsed_time = Float()
depth = Int()
proxies = List(
lambda: TaskProxy,
description="""Associated cycle point proxies""",
args=proxy_args,
resolver=get_nodes_by_id)
namespace = List(String, required=True)
class QueryStory(ObjectType):
stories = List(Story,
limit=Int(required=True),
offset=Int(),
description="Fetches lists of stories")
searchStory = Field(Story,
id=ID(required=True),
description="Fetches a single comic story by id")
storyCharacters = List(
Character,
id=ID(required=True),
limit=Int(required=True),
offset=Int(),
description="Fetches lists of characters filtered by a story id")
storyComics = List(
Comics,
id=ID(required=True),
limit=Int(required=True),
offset=Int(),
description="Fetches lists of comics filtered by a story id")
storyCreators = List(
Creator,
id=ID(required=True),
limit=Int(required=True),
offset=Int(),
description="Fetches lists of creators filtered by a story id")
storyEvents = List(
Event,
id=ID(required=True),
limit=Int(required=True),
offset=Int(),
description="Fetches lists of events filtered by a story id")
storySeries = List(
Series,
id=ID(required=True),
limit=Int(required=True),
offset=Int(),
description="Fetches lists of series filtered by a story id")
def resolve_stories(root, info, limit=None, offset=None):
return resolve_story.list_stories(limit, offset)
def resolve_searchStory(root, info, id):
return resolve_story.search_storie(id)
def resolve_storyCharacters(root, info, id, limit, offset=None):
return resolve_story.find_story_characters(id, limit, offset)
def resolve_storyComics(root, info, id, limit, offset=None):
return resolve_story.find_story_comics(id, limit, offset)
def resolve_storyCreators(root, info, id, limit, offset=None):
return resolve_story.find_story_creators(id, limit, offset)
def resolve_storyEvents(root, info, id, limit, offset=None):
return resolve_story.find_story_events(id, limit, offset)
def resolve_storySeries(root, info, id, limit, offset=None):
return resolve_story.find_story_series(id, limit, offset)
class Proposals(ObjectType):
id = ID()
code = String()
title = String()
abstract = String()
semester = String()
general_info = Field(ProposalInfoM)
time_requests = List(RequestedTimeM)
total_time_requested = Int()
minimum_useful_time = Int()
is_thesis = Boolean()
instruments = Field(Instruments)
pi = Field(PI)
class Devotional(ObjectType):
"""Devotional graphql type definition."""
id = ID()
title = String()
passage = String()
body = String()
creation_date = DateTime()
publish_date = Date()
author = Field(lambda: User)
comments = List(lambda: Comment)
def __init__(self, model, *args, **kwargs):
super().__init__(*args, **kwargs)
self.model = model
@classmethod
def get_devotional(cls, id):
"""Class method to get a Devotional instance given an id"""
model = DevotionalModel.query.filter_by(id=id).first()
return cls.create_devotional_from_model(model)
@classmethod
def create_devotional_from_model(cls, model):
"""
Class method to create a Devotional instance given an SQLAlchemy model
"""
return cls(
id=model.id,
title=model.title,
passage=model.passage,
body=model.body,
creation_date=model.creation_date,
publish_date=model.publish_date,
model=model
)
def resolve_author(self, info):
"""Author resolver"""
return User.create_user_from_model(self.model.author)
def resolve_comments(self, info):
"""Comments resolver"""
print(len(self.model.comments))
print(self.model.comments[0])
result = [Comment.create_comment_from_model(c) for c in self.model.comments]
print(result)
return result
class DraftEdit(Mutation):
pk = ID()
content = String()
feedback = String()
class Arguments:
content = String()
pk = ID(required=False)
title = String(required=False)
@staticmethod
@login_required
def mutate(_root, info, content, pk=None, title=None):
validate_user_text(content, exctype=ValueError)
if pk:
entry = Entry.objects_all.get(is_draft=True,
author=info.context.user,
pk=pk)
entry.content = content
entry.date_edited = timezone.now()
entry.save(update_fields=["content", "date_edited"])
return DraftEdit(
pk=entry.pk,
content=linebreaksbr(formatted(entry.content)),
feedback=_("your changes have been saved as draft"),
)
if title:
topic = Topic.objects.get_or_pseudo(unicode_string=title)
if (topic.exists and topic.is_banned) or not topic.valid:
raise ValueError(
_("we couldn't handle your request. try again later."))
if not topic.exists:
topic = Topic.objects.create_topic(title=topic.title)
entry = Entry(author=info.context.user,
topic=topic,
content=content,
is_draft=True)
entry.save()
return DraftEdit(
pk=entry.pk,
content=linebreaksbr(formatted(entry.content)),
feedback=_("your entry has been saved as draft"),
)
raise ValueError(
_("we couldn't handle your request. try again later."))
class Job(ObjectType):
class Meta:
description = """Jobs."""
id = ID(required=True)
submit_num = Int()
state = String()
# name and cycle_point for filtering/sorting
name = String(required=True)
cycle_point = String(required=True)
task_proxy = Field(lambda: TaskProxy,
description="""Associated Task Proxy""",
required=True,
resolver=get_node_by_id)
submitted_time = String()
started_time = String()
finished_time = String()
batch_sys_job_id = ID()
batch_sys_name = String()
env_script = String()
err_script = String()
exit_script = String()
execution_time_limit = Float()
host = String()
init_script = String()
job_log_dir = String()
owner = String()
post_script = String()
pre_script = String()
script = String()
work_sub_dir = String()
batch_sys_conf = List(String)
environment = List(String)
directives = List(String)
param_env_tmpl = List(String)
param_var = List(String)
extra_logs = List(String)
messages = List(String)
class ProductcontainersCustom(ObjectType):
id = ID()
deleteContainerAmount = String()
containernameid = String()
productid = String()
amount = List(ProcessedStockAmountsType, prod=graphene.String())
time = List(TimeStampType)
def resolve_amount(self, context, **kwargs):
productid = kwargs.get('prod')
print(kwargs)
# return ProcessedStockAmounts.objects.filter(Q(timeStampID__id=2) & Q(prodName__id=productid))
return ProcessedStockAmounts.objects.filter(
prodName__productid=productid)
def __init_subclass_with_meta__(
cls,
model=None,
create=False,
delete=False,
registry=None,
arguments=None,
only_fields=(),
structure: Type[Structure] = None,
exclude_fields=(),
**options,
):
meta = SQLAlchemyMutationOptions(cls)
meta.create = create
meta.model = model
meta.delete = delete
if arguments is None and not hasattr(cls, "Arguments"):
arguments = {}
# don't include id argument on create
if not meta.create:
arguments["id"] = ID(required=True)
# don't include input argument on delete
if not meta.delete:
inputMeta = type(
"Meta",
(object, ),
{
"model": model,
"exclude_fields": exclude_fields,
"only_fields": only_fields,
},
)
inputType = type(
cls.__name__ + "Input",
(SQLAlchemyInputObjectType, ),
{"Meta": inputMeta},
)
arguments = {"input": inputType(required=True)}
if not registry:
registry = get_global_registry()
output_type: ObjectType = registry.get_type_for_model(model)
if structure:
output_type = structure(output_type)
super(SQLAlchemyMutation,
cls).__init_subclass_with_meta__(_meta=meta,
output=output_type,
arguments=arguments,
**options)
class Result(ObjectType):
# This is resolved by Query.Result
run_ID = ID()
# This is resolved here at Result.bucket
bucket = Field(MinioBucket)
def resolve_bucket(parent, info):
bucket_name = parent['run_ID']
try:
if minio_client.bucket_exists(bucket_name):
return {'bucket_name': bucket_name}
except ResponseError as err:
print(err)
class MatchDetails(ObjectType):
"""This needs refactoring for all resource types: Address"""
id = ID(required=True)
name = String(required=True)
first_name = String(required=True)
last_name = String(required=True)
picture_url = String(required=False)
email = String(required=True)
address_line1 = String(required=True)
postal_code = String(required=True)
city = String(required=True)
class OWMPointWeather(ObjectType):
id = ID()
main = String()
description = String()
icon = String()
def resolve_main(parent, info):
return parent.get('main')
def resolve_description(parent, info):
return parent.get('description')
def resolve_icon(parent, info):
return parent.get('icon')
class post(ObjectType):
id = ID()
title = String()
user = Field(user)
def resolve_user(root, context):
response = requests.get('https://jsonplaceholder.typicode.com/users')
response = response.json()
output = {}
for item in response:
if item["id"] == root.userId:
output = item
break
return json2obj(json.dumps(output))
class Arguments:
course_id = ID(name="id")
course_type = CourseTypeEnum()
academic_level = AcademicLevelEnum()
title = String()
description = String()
instructor_id = ID(name="instructor")
hourly_tuition = Decimal()
total_tuition = Decimal()
course_category_id = ID(name="courseCategory")
course_link = String()
course_link_description = String()
google_class_code = String()
# Logistical information
room = String()
start_date = DateTime()
end_date = DateTime()
max_capacity = Int()
is_confirmed = Boolean()
availabilities = List(CourseAvailabilityInput)
class PopularProductByModelType(ObjectType):
id = ID()
slug = String(required=True)
name = String(required=True)
name2 = String(required=False)
full_name = String(required=False)
one_c_id = String(required=False)
sku = String(required=False)
model = List(NewCarModelType, required=True)
images = List(IProductImagesType)
cat_number = String(required=True)
bages = List(String, required=False)
stocks = List(ProductStocksType, required=False)
brand = Field(BrandType)
class Story(ObjectType):
id = ID()
title = String()
description = String()
resourceURI = String()
type = String()
modified = Date()
thumbnail = Field(Image)
comics = Field(AllList)
series = Field(AllList)
events = Field(AllList)
characters = Field(AllList)
creators = Field(AllList)
originalissue = Field(Summary)
class Creator(ObjectType):
id = ID()
firstName = String()
middleName = String()
lastName = String()
suffic = String()
fullName = String()
resourceURI = String()
urls = List(MarvelUrl)
thumbnail = Field(Image)
series = Field(AllList)
stories = Field(AllList)
comics = Field(AllList)
events = Field(AllList)
def dynamic_type():
# Avoid create field for auto generate OneToOneField product of an inheritance
if isinstance(field, models.OneToOneField) and issubclass(
field.model, field.related_model):
return
if input_flag and not nested_field:
return ID(description=field.help_text or field.verbose_name,
required=is_required(field) and input_flag == 'create')
_type = registry.get_type_for_model(model, for_input=input_flag)
if not _type:
return
return Field(_type,
description=field.help_text or field.verbose_name,
required=is_required(field) and input_flag == 'create')
class Task(ObjectType):
id = ID()
task_id = ID()
priority = Int()
name = String()
notes = String()
added = DateTime()
deadline = DateTime()
completed = DateTime()
tags = String()
def resolve_id(parent, info):
return parent.task_id
def resolve_task_id(parent, info):
return parent.task_id
def resolve_priority(parent, info):
return parent.priority
def resolve_name(parent, info):
return f"{parent.name}"
def resolve_notes(parent, info):
return parent.notes
def resolve_added(parent, info):
return parent.added
def resolve_deadline(parent, info):
return parent.deadline
def resolve_completed(parent, info):
return parent.completed
def resolve_tags(parent, info):
return parent.tags
class PostLikeMutation(relay.ClientIDMutation):
class Input:
like_data = AddPostLikeInput(required=True)
message = String()
id = ID()
count = Int()
@classmethod
def mutate_and_get_payload(cls, root, info, like_data):
current_user = info.context.user.is_authenticated
if current_user is False:
return GraphQLError("No permissions.")
post = Post.objects.get(pk=from_global_id(like_data.post_id)[1])
like = post.likes.filter(like__author_id=current_user.id).first()
message = None
if like is not None:
id = like.id
post.likes_count -= 1
post.likes.remove(like)
message = "deleted"
else:
post.likes.add(
from_global_id(like_data.like_id)[1],
through_defaults={
"author_id": 1,
},
)
like = Like.objects.filter(
post_id=post.id,
author_id=current_user.id,
type_id=from_global_id(like_data.like_id)[1],
).first()
post.likes_count += 1
message = "added"
id = like.id
post.save()
return PostLikeMutation(
message=message,
count=post.likes_count,
id=to_global_id(id=id, type="PostLike"),
)
class Individual(ObjectType):
id = ID()
name = String()
datasetId = String()
description = String()
variants = List(lambda: Variant)
def resolve_variants(self, info, **kwargs):
variants = get_variants(info, **kwargs)
myvariants = []
for var in variants:
for call in var['calls']:
if call['callSetName'] == self.name:
myvariants.append(var)
return json2obj(json.dumps(myvariants))
class DeleteDirectory(relay.ClientIDMutation):
class Input:
id = ID()
ok = Boolean()
id = ID()
@classmethod
def mutate_and_get_payload(cls, root, info, id, client_mutation_id):
_type, path = from_global_id(id)
try:
remove_directory(path)
return DeleteDirectory(ok=True, id=id)
except FileNotFoundError:
return DeleteDirectory(ok=False)
class PostType(ObjectType):
id = ID()
slug = String()
image = String()
title = String()
excerpt = String()
text = String()
partsCategory = List(CategoryType)
category = List(CategoryType)
date = Date()
author = String()
car = List(NewCarModelType)
totalCount = Int()
count = Int()
tags = List(String)
class Workflow(ObjectType):
class Meta:
description = """Global workflow info."""
id = ID(required=True)
name = String()
status = String()
status_msg = String()
host = String()
port = Int()
owner = String()
tasks = List(lambda: Task,
description="""Task definitions.""",
args=def_args,
resolver=get_nodes_by_ids)
families = List(lambda: Family,
description="""Family definitions.""",
args=def_args,
resolver=get_nodes_by_ids)
task_proxies = List(lambda: TaskProxy,
description="""Task cycle instances.""",
args=proxy_args,
resolver=get_nodes_by_ids)
family_proxies = List(lambda: FamilyProxy,
description="""Family cycle instances.""",
args=proxy_args,
resolver=get_nodes_by_ids)
edges = Field(lambda: Edges, args=edge_args, description="""Graph edges""")
nodes_edges = Field(lambda: NodesEdges,
args=nodes_edges_args,
resolver=get_nodes_edges)
api_version = Int()
cylc_version = String()
last_updated = Float()
meta = Field(DefMeta)
newest_runahead_cycle_point = String()
newest_cycle_point = String()
oldest_cycle_point = String()
reloaded = Boolean()
run_mode = String()
is_held_total = Int()
state_totals = GenericScalar(resolver=resolve_state_totals)
workflow_log_dir = String()
time_zone_info = Field(TimeZone)
tree_depth = Int()
ns_defn_order = List(String)
job_log_names = List(String)
states = List(String)
class Event(ObjectType):
id = ID()
title = String()
description = String()
resourceURI = String()
urls = List(MarvelUrl)
start = Date()
end = Date()
thumbnail = Field(Image)
comics = Field(AllList)
stories = Field(AllList)
series = Field(AllList)
characters = Field(AllList)
creators = Field(AllList)
next = Field(Summary)
previous = Field(Summary)
