class Vulnerability(ObjectType):
"""Vulnerability Class."""
id = String() # noqa pylint: disable=invalid-name
analyst = String()
finding_id = String()
vuln_type = String()
where = String()
specific = String()
historic_state = List(GenericScalar)
current_state = String()
current_approval_status = String()
last_analyst = String()
last_approved_status = String()
acceptance_date = String()
treatment = String()
external_bts = String()
treatment_justification = String()
treatment_manager = String()
severity = String()
tag = String()
tags = List(String)
remediated = Boolean()
verification = String()
def __getitem__(self, key: str) -> str:
if key == 'UUID':
key = 'id'
return getattr(self, key)
def resolve_acceptance_date(self, info: object) -> String:
"""Resolve Acceptance Date"""
del info
return self.acceptance_date
def resolve_treatment_manager(self, info: object) -> String:
"""Resolve Treatment Manager"""
del info
return self.treatment_manager
def resolve_treatment_justification(self, info: object) -> String:
"""Resolve Treatment Justification"""
del info
return self.treatment_justification
def resolve_external_bts(self, info: object) -> String:
"""Resolve External Bts"""
del info
return self.external_bts
def resolve_id(self, info: object) -> String:
"""Resolve id attribute."""
del info
return self.id
def resolve_treatment(self, info: object) -> String:
"""Resolve treatment attribute."""
del info
return self.treatment
def resolve_finding_id(self, info: object) -> String:
"""Resolve vulnerabilities attribute."""
del info
return self.finding_id
def resolve_vuln_type(self, info: object) -> String:
"""Resolve vulnerabilities attribute."""
del info
return self.vuln_type
def resolve_where(self, info: object) -> String:
"""Resolve vulnerabilities attribute."""
del info
return self.where
def resolve_specific(self, info: object) -> String:
"""Resolve vulnerabilities attribute."""
del info
return self.specific
def resolve_historic_state(self, info: object) -> List:
"""Resolve vulnerabilities attribute."""
del info
return self.historic_state
def resolve_current_state(self, info: object) -> String:
"""Resolve vulnerabilities attribute."""
del info
return self.current_state
def resolve_severity(self, info: object) -> String:
"""Resolve vulnerabilities attribute."""
del info
return self.severity
def resolve_tag(self, info: object) -> str:
"""Resolve vulnerabilities attribute."""
del info
return ', '.join(cast(Iterable[str], self.tags))
def resolve_current_approval_status(self, info: object) -> String:
"""Resolve vulnerabilities attribute."""
del info
return self.current_approval_status
def resolve_last_approved_status(self, info: object) -> String:
"""Resolve vulnerabilities attribute."""
del info
return self.last_approved_status
@enforce_authz
def resolve_last_analyst(self, info: object) -> String:
""" Resolve last approved analyst attribute """
del info
return self.last_analyst
@enforce_authz
def resolve_analyst(self, info: object) -> String:
""" Resolve analyst attribute """
del info
return self.analyst
def resolve_remediated(self, info: object) -> Boolean:
"""Resolve vulnerabilities attribute."""
del info
return self.remediated
def resolve_verification(self, info: object) -> String:
"""Resolve vulnerabilities attribute."""
del info
return self.verification
def convert_field_to_boolean(field, registry=None):
return Boolean(description=field.help_text, required=field.get('required', False))
class Query(ObjectType):
sites = List(Site)
sessions = List(Session, parked=Boolean(default_value=False))
users = List(User)
user_permissions = List(Permission, user_id=String())
available_permissions = List(ApiPermission)
releasing = List(Releasing)
@staticmethod
def sessions_list(repo):
for site in repo.sites:
site = Site(**site)
for session in site.sessions or ():
yield dict(**session, site=site)
@inject_permissions
async def resolve_sites(self, info, permissions):
repo = info.context['repo']
return [
Site(**x) for x in repo.sites
if ADMIN in permissions or f'user:{x["site_id"]}' in permissions
]
@inject_permissions
async def resolve_sessions(self, info, parked, permissions):
repo = info.context['repo']
await repo.init_sessions()
sessions = (Session(**x) for x in Query.sessions_list(repo))
return [
x for x in sessions if (bool(x.edit_url) != parked and (
ADMIN in permissions or f'user:{x.site.site_id}' in permissions
))
]
@inject_permissions(admin=True)
async def resolve_users(self, info, permissions):
auth0_client = info.context['auth0_client']
return [User(**x) for x in await auth0_client.get_users()]
@inject_permissions(admin=True)
async def resolve_user_permissions(self, info, user_id, permissions):
auth0_client = info.context['auth0_client']
return [
Permission(**x)
for x in await auth0_client.get_user_permissions(user_id)
]
@inject_permissions(admin=True)
async def resolve_available_permissions(self, info, permissions):
repo = info.context['repo']
return [
ApiPermission(v, v) for v in (
'admin',
*(f'user:{x["site_id"]}' for x in repo.sites),
)
]
@inject_permissions
async def resolve_releasing(self, info, permissions):
repo = info.context['repo']
return [Releasing(**x) for x in repo.releasing]
class ShardStatusIncident(RiotGrapheneObject):
active = Boolean()
created_at = String()
id = Int()
updates = List(ShardStatusMessage)
class BooleanField(ObjectType):
boolean = Boolean()
def convert_column_to_boolean(type, attribute, registry=None):
return Boolean(description=attribute.attr_name,
required=not attribute.null)
class AddFiles(Mutation):
""" Update evidence files """
class Arguments(object):
files_data = JSONString()
project_name = String()
resources = Field(Resource)
success = Boolean()
@require_login
@require_role(['analyst', 'customer', 'admin'])
@require_project_access_gql
def mutate(self, info, **parameters):
success = False
json_data = []
files_data = parameters['files_data']
project_name = parameters['project_name'].lower()
for file_info in files_data:
json_data.append({
'fileName':
file_info.get('fileName'),
'description':
file_info.get('description'),
'uploadDate':
str(datetime.now().replace(second=0, microsecond=0))[:-3],
'uploader':
info.context.session['username']
})
uploaded_file = info.context.FILES.get('document', '')
file_id = '{project}/{file_name}'.format(project=project_name,
file_name=uploaded_file)
try:
file_size = 100
resources.validate_file_size(uploaded_file, file_size)
except InvalidFileSize:
raise GraphQLError('File exceeds the size limits')
files = integrates_dao.get_project_attributes_dynamo(
project_name, ['files'])
project_files = files.get('files')
if project_files:
contains_repeated = [
f.get('fileName') for f in project_files
if f.get('fileName') == uploaded_file.name
]
if contains_repeated:
raise GraphQLError('File already exist')
else:
# File is unique
pass
else:
# Project doesn't have files
pass
if util.is_valid_file_name(uploaded_file):
try:
resources.upload_file_to_s3(uploaded_file, file_id)
integrates_dao.add_list_resource_dynamo(
'FI_projects', 'project_name', project_name, json_data,
'files')
user_email = info.context.session['username']
resources.send_mail(project_name, user_email, json_data,
'added', 'file')
success = True
except ErrorUploadingFileS3:
raise GraphQLError('Error uploading file')
if success:
util.cloudwatch_log(
info.context, 'Security: Added evidence files to \
{project} project succesfully'.format(project=project_name))
else:
util.cloudwatch_log(
info.context, 'Security: Attempted to add evidence files \
from {project} project'.format(project=project_name))
ret = AddFiles(success=success, resources=Resource(project_name))
util.invalidate_cache(project_name)
return ret
class Person(graphene.ObjectType):
"""定义创建对象 """
name = String()
age = Int()
gender = Boolean()
def convert_field_to_boolean(field, registry=None):
return Boolean(description=field.help_text)
class OrderByType(InputObjectType):
field = String(required=True)
desk = Boolean(default_value=False)
class Events(ObjectType): # noqa pylint: disable=too-many-instance-attributes
""" Formstack Events Class """
id = String() # noqa pylint: disable=invalid-name
success = Boolean()
error_message = String()
analyst = String()
client = String()
project_name = String()
client_project = String()
detail = String()
evidence = String()
event_type = String()
event_date = String()
event_status = String()
affectation = String()
accessibility = String()
affected_components = String()
context = String()
subscription = String()
evidence_file = String()
def __init__(self, identifier):
""" Class constructor """
self.id = '' # noqa pylint: disable=invalid-name
self.analyst = ''
self.client = ''
self.project_name = ''
self.client_project = ''
self.event_type = ''
self.event_date = ''
self.detail = ''
self.affectation = ''
self.event_status = ''
self.evidence = ''
self.accessibility = ''
self.affected_components = ''
self.context = ''
self.subscription = ''
self.evidence_file = ''
event_id = str(identifier)
resp = event_data(event_id)
if resp:
self.id = event_id
self.analyst = resp.get('analyst')
self.client = resp.get('client')
self.project_name = resp.get('projectName')
self.client_project = resp.get('clientProject')
self.event_type = resp.get('eventType')
self.event_date = resp.get('eventDate')
self.detail = resp.get('detail')
self.affectation = resp.get('affectation')
self.event_status = resp.get('eventStatus')
self.evidence = resp.get('evidence', '')
self.evidence_file = resp.get('evidence_file', '')
self.accessibility = resp.get('accessibility')
self.affected_components = resp.get('affectedComponents')
self.context = resp.get('context')
self.subscription = resp.get('subscription')
else:
self.success = False
self.error_message = 'Finding does not exist'
self.success = True
def resolve_id(self, info):
""" Resolve id attribute """
del info
return self.id
def resolve_analyst(self, info):
""" Resolve analyst attribute """
del info
return self.analyst
def resolve_client(self, info):
""" Resolve client attribute """
del info
return self.client
def resolve_evidence(self, info):
""" Resolve evidence attribute """
del info
return self.evidence
def resolve_project_name(self, info):
""" Resolve project_name attribute """
del info
return self.project_name
def resolve_client_project(self, info):
""" Resolve client_project attribute """
del info
return self.client_project
def resolve_event_type(self, info):
""" Resolve event_type attribute """
del info
return self.event_type
def resolve_detail(self, info):
""" Resolve detail attribute """
del info
return self.detail
def resolve_event_date(self, info):
""" Resolve date attribute """
del info
return self.event_date
def resolve_event_status(self, info):
""" Resolve status attribute """
del info
return self.event_status
def resolve_affectation(self, info):
""" Resolve affectation attribute """
del info
if not self.affectation:
return ''
return self.affectation
def resolve_accessibility(self, info):
""" Resolve accessibility attribute """
del info
if not self.accessibility:
return ''
return self.accessibility
def resolve_affected_components(self, info):
""" Resolve affected components attribute """
del info
if not self.affected_components:
return ''
return self.affected_components
def resolve_context(self, info):
""" Resolve context attribute """
del info
return self.context
def resolve_subscription(self, info):
""" Resolve subscription attribute """
del info
return self.subscription
def resolve_evidence_file(self, info):
""" Resolve evidence file attribute """
del info
return self.evidence_file
def create_standard_changelog_graphql_mixin(
diffable_models,
models_enum=None,
model_fields_enum=None,
page_size=50,
field_name="changelog",
):
# will use models_enum and model_fields_enum if provided, otherwise generates those
if models_enum is None:
model_enum = create_model_enum_type(diffable_models)
if model_fields_enum is None:
model_fields_enum = create_model_field_enum_type(diffable_models)
field = graphene.Field(
ChangelogPage,
page_num=Int(required=True),
models=List(model_enum, required=False),
user_ids=List(Int, required=False),
fields=List(model_fields_enum, required=False),
exclude_create=Boolean(required=False),
only_creates=Boolean(required=False),
start_date=DateTime(required=False),
end_date=DateTime(required=False),
)
def resolver(
_parent,
_info,
page_num=None,
models=None,
user_ids=None,
fields=None,
exclude_create=False,
only_creates=False,
start_date=None,
end_date=None,
):
if models and fields:
raise Exception(
"use models or fields but not both - TODO: split this up in 2 different fields"
)
if models:
model_classes = [
m for m in diffable_models if m.__name__ in models
]
else:
model_classes = [*diffable_models]
if fields:
fields_by_model = convert_enum_list_to_dict(model_classes, fields)
else:
fields_by_model = None
fetcher = ConsecutiveVersionsFetcher(
page_size=get_changelog_page_size(page_size),
page_num=page_num,
models=model_classes,
user_ids=user_ids,
exclude_create=exclude_create,
only_creates=only_creates,
fields_by_model=fields_by_model,
start_date=start_date,
end_date=end_date,
)
return {"fetcher": fetcher}
return type(
"StandardChangelogMixin",
(graphene.ObjectType, ),
{
field_name: field,
f"resolve_{field_name}": staticmethod(resolver)
},
)
def convert_field_to_nullboolean(field,
registry=None,
input_flag=None,
nested_field=False):
return Boolean(description=field.help_text or field.verbose_name,
required=is_required(field) and input_flag == 'create')
def convert_form_field_to_boolean(field):
return Boolean(description=field.help_text, required=field.required)
def convert_field_to_nullboolean(field, registry=None):
return Boolean(description=field.help_text, required=not field.null)
class Query(ObjectType):
countries = List(CountryType)
institutions = List(InstitutionType,
archived=Boolean(),
year_archived=Int())
memorandums = List(MemorandumType, archived=Boolean(), year_archived=Int())
academic_years = List(AcademicYearType)
terms = List(TermType, year=Int())
outbound_programs = List(OutboundProgramType,
institution=Int(),
year=Int(),
term=Int())
inbound_programs = List(InboundProgramType, year=Int(), term=Int())
outbound_requirements = List(OutboundRequirementType)
inbound_requirements = List(InboundRequirementType)
institution = Field(InstitutionType, id=Int())
memorandum = Field(MemorandumType, id=Int())
outbound_program = Field(OutboundProgramType, id=Int())
inbound_program = Field(InboundProgramType, id=Int())
def resolve_academic_years(self, info, **kwargs):
return AcademicYear.objects.all()
def resolve_countries(self, info, **kwargs):
return [
country for country in Country.objects.all()
if country.institution_set.filter(
archived_at__isnull=True).count() > 0
]
def resolve_institutions(self, info, **kwargs):
archived = kwargs.get('archived', False)
year_archived = kwargs.get('year_archived')
return Institution.archived.filter(
archived_at__year=year_archived
) if archived else Institution.current.all()
def resolve_memorandums(self, info, **kwargs):
archived = kwargs.get('archived', False)
year_archived = kwargs.get('year_archived')
return Memorandum.archived.filter(
archived_at__year=year_archived
) if archived else Memorandum.current.all()
def resolve_memorandum(self, info, **kwargs):
id = kwargs.get('id')
return Memorandum.current.get(pk=id)
def resolve_institution(self, info, **kwargs):
id = kwargs.get('id')
return Institution.objects.get(pk=id)
def resolve_terms(self, info, **kwargs):
terms = Term.current.all()
year = kwargs.get('year')
if year:
terms = terms.filter(academic_year__academic_year_start=year)
return terms
def resolve_outbound_programs(self, info, **kwargs):
institution = kwargs.get('institution', False)
year = kwargs.get('year', False)
term = kwargs.get('term', False)
outbound_programs = OutboundProgram.objects.all()
if year:
outbound_programs = outbound_programs.filter(
program__academic_year__academic_year_start=year)
if institution:
outbound_programs = outbound_programs.filter(
institution_id=institution)
if term:
outbound_programs = outbound_programs.filter(
program__terms_available__number=term)
return outbound_programs
def resolve_outbound_program(self, info, **kwargs):
id = kwargs.get('id')
return OutboundProgram.objects.get(pk=id)
def resolve_inbound_programs(self, info, **kwargs):
year = kwargs.get('year', False)
term = kwargs.get('term', False)
inbound_programs = InboundProgram.objects.all()
if year:
inbound_programs = inbound_programs.filter(
program__academic_year__academic_year_start=year)
if term:
inbound_programs = inbound_programs.filter(
program__terms_available__number=term)
return inbound_programs
def resolve_inbound_program(self, info, **kwargs):
id = kwargs.get('id')
return InboundProgram.objects.get(pk=id)
def resolve_inbound_requirements(self, info, **kwargs):
return InboundRequirement.objects.all()
def resolve_outbound_requirements(self, info, **kwargs):
return OutboundRequirement.objects.all()
class ValidateScheduleType(ObjectType):
status = Boolean()
reason = String()
class DjangoSerializerMutation(ObjectType):
"""
Serializer Mutation Type Definition
"""
ok = Boolean(
description="Boolean field that return mutation result request.")
errors = List(ErrorType, description="Errors list for the field")
class Meta:
abstract = True
@classmethod
def __init_subclass_with_meta__(
cls,
serializer_class=None,
only_fields=(),
include_fields=(),
exclude_fields=(),
input_field_name=None,
output_field_name=None,
description="",
nested_fields=(),
**options,
):
if not serializer_class:
raise Exception(
"serializer_class is required on all DjangoSerializerMutation")
model = serializer_class.Meta.model
description = description or "SerializerMutation for {} model".format(
model.__name__)
input_field_name = input_field_name or "new_{}".format(
model._meta.model_name)
output_field_name = output_field_name or model._meta.model_name
input_class = getattr(cls, "Arguments", None)
if not input_class:
input_class = getattr(cls, "Input", None)
if input_class:
warn_deprecation((
"Please use {name}.Arguments instead of {name}.Input."
"Input is now only used in ClientMutationID.\nRead more: "
"https://github.com/graphql-python/graphene/blob/2.0/UPGRADE-v2.0.md#mutation-input"
).format(name=cls.__name__))
if input_class:
arguments = props(input_class)
else:
arguments = {}
registry = get_global_registry()
factory_kwargs = {
"model": model,
"only_fields": only_fields,
"include_fields": include_fields,
"exclude_fields": exclude_fields,
"nested_fields": nested_fields,
"registry": registry,
"skip_registry": False,
}
output_type = registry.get_type_for_model(model)
if not output_type:
output_type = factory_type("output", DjangoObjectType,
**factory_kwargs)
django_fields = OrderedDict({output_field_name: Field(output_type)})
global_arguments = {}
for operation in ("create", "delete", "update"):
global_arguments.update({operation: OrderedDict()})
if operation != "delete":
input_type = registry.get_type_for_model(model,
for_input=operation)
if not input_type:
# factory_kwargs.update({'skip_registry': True})
input_type = factory_type("input", DjangoInputObjectType,
operation, **factory_kwargs)
global_arguments[operation].update(
{input_field_name: Argument(input_type, required=True)})
else:
global_arguments[operation].update({
"id":
Argument(
ID,
required=True,
description="Django object unique identification field",
)
})
global_arguments[operation].update(arguments)
_meta = SerializerMutationOptions(cls)
_meta.output = cls
_meta.arguments = global_arguments
_meta.fields = django_fields
_meta.output_type = output_type
_meta.model = model
_meta.serializer_class = serializer_class
_meta.input_field_name = input_field_name
_meta.output_field_name = output_field_name
_meta.nested_fields = nested_fields
super(DjangoSerializerMutation,
cls).__init_subclass_with_meta__(_meta=_meta,
description=description,
**options)
@classmethod
def get_errors(cls, errors):
errors_dict = {
cls._meta.output_field_name: None,
"ok": False,
"errors": errors
}
return cls(**errors_dict)
@classmethod
def perform_mutate(cls, obj, info):
resp = {cls._meta.output_field_name: obj, "ok": True, "errors": None}
return cls(**resp)
@classmethod
def get_serializer_kwargs(cls, root, info, **kwargs):
return {}
@classmethod
def manage_nested_fields(cls, data, root, info):
nested_objs = {}
if cls._meta.nested_fields and type(cls._meta.nested_fields) == dict:
for field in cls._meta.nested_fields:
sub_data = data.pop(field, None)
if sub_data:
serialized_data = cls._meta.nested_fields[field](
data=sub_data,
many=True if type(sub_data) == list else False)
ok, result = cls.save(serialized_data, root, info)
if not ok:
return cls.get_errors(result)
if type(sub_data) == list:
nested_objs.update({field: result})
else:
data.update({field: result.id})
return nested_objs
@classmethod
def create(cls, root, info, **kwargs):
data = kwargs.get(cls._meta.input_field_name)
request_type = info.context.META.get("CONTENT_TYPE", "")
if "multipart/form-data" in request_type:
data.update(
{name: value
for name, value in info.context.FILES.items()})
nested_objs = cls.manage_nested_fields(data, root, info)
serializer = cls._meta.serializer_class(data=data,
**cls.get_serializer_kwargs(
root, info, **kwargs))
ok, obj = cls.save(serializer, root, info)
if not ok:
return cls.get_errors(obj)
elif nested_objs:
[
getattr(obj, field).add(*objs)
for field, objs in nested_objs.items()
]
return cls.perform_mutate(obj, info)
@classmethod
def delete(cls, root, info, **kwargs):
pk = kwargs.get("id")
old_obj = get_Object_or_None(cls._meta.model, pk=pk)
if old_obj:
old_obj.delete()
old_obj.id = pk
return cls.perform_mutate(old_obj, info)
else:
return cls.get_errors([
ErrorType(
field="id",
messages=[
"A {} obj with id {} do not exist".format(
cls._meta.model.__name__, pk)
],
)
])
@classmethod
def update(cls, root, info, **kwargs):
data = kwargs.get(cls._meta.input_field_name)
request_type = info.context.META.get("CONTENT_TYPE", "")
if "multipart/form-data" in request_type:
data.update(
{name: value
for name, value in info.context.FILES.items()})
pk = data.pop("id")
old_obj = get_Object_or_None(cls._meta.model, pk=pk)
if old_obj:
nested_objs = cls.manage_nested_fields(data, root, info)
serializer = cls._meta.serializer_class(
old_obj,
data=data,
partial=True,
**cls.get_serializer_kwargs(root, info, **kwargs),
)
ok, obj = cls.save(serializer, root, info)
if not ok:
return cls.get_errors(obj)
elif nested_objs:
[
getattr(obj, field).add(*objs)
for field, objs in nested_objs.items()
]
return cls.perform_mutate(obj, info)
else:
return cls.get_errors([
ErrorType(
field="id",
messages=[
"A {} obj with id: {} do not exist".format(
cls._meta.model.__name__, pk)
],
)
])
@classmethod
def save(cls, serialized_obj, root, info, **kwargs):
if serialized_obj.is_valid():
obj = serialized_obj.save()
return True, obj
else:
errors = [
ErrorType(field=key, messages=value)
for key, value in serialized_obj.errors.items()
]
return False, errors
@classmethod
def CreateField(cls, *args, **kwargs):
return Field(
cls._meta.output,
args=cls._meta.arguments["create"],
resolver=cls.create,
**kwargs,
)
@classmethod
def DeleteField(cls, *args, **kwargs):
return Field(
cls._meta.output,
args=cls._meta.arguments["delete"],
resolver=cls.delete,
**kwargs,
)
@classmethod
def UpdateField(cls, *args, **kwargs):
return Field(
cls._meta.output,
args=cls._meta.arguments["update"],
resolver=cls.update,
**kwargs,
)
@classmethod
def MutationFields(cls, *args, **kwargs):
create_field = cls.CreateField(*args, **kwargs)
delete_field = cls.DeleteField(*args, **kwargs)
update_field = cls.UpdateField(*args, **kwargs)
return create_field, delete_field, update_field
class Arguments:
workflows = List(WorkflowID, required=True)
cylc_version = CylcVersion(description=sstrip('''
Set the Cylc version that the workflow starts with.
'''))
initial_cycle_point = CyclePoint(description=sstrip('''
Set the initial cycle point.
Required if not defined in flow.cylc.
'''))
start_cycle_point = CyclePoint(description=sstrip('''
Set the start cycle point, which may be after the initial cycle
point.
If the specified start point is not in the sequence, the next
on-sequence point will be used.
(Not to be confused with the initial cycle point).
This replaces the Cylc 7 --warm option.
'''))
final_cycle_point = CyclePoint(description=sstrip('''
Set the final cycle point. This command line option overrides
the workflow config option `[scheduling]final cycle point`.
'''))
stop_cycle_point = CyclePoint(description=sstrip('''
Set the stop cycle point. Shut down after all tasks have PASSED
this cycle point. (Not to be confused with the final cycle
point.) This command line option overrides the workflow config
option `[scheduling]stop after cycle point`.
'''))
pause = Boolean(description=sstrip('''
Pause workflow immediately on starting.
'''))
hold_cycle_point = CyclePoint(description=sstrip('''
Hold all tasks after this cycle point.
'''))
mode = RunMode()
host = String(description=sstrip('''
Specify the host on which to start-up the workflow. If not
specified, a host will be selected using the
`[scheduler]run hosts` global config.
'''))
main_loop = List(String,
description=sstrip('''
Specify an additional plugin to run in the main loop. These
are used in combination with those specified in
`[scheduler][main loop]plugins`. Can be used multiple times.
'''))
abort_if_any_task_fails = Boolean(default_value=False,
description=sstrip('''
If set workflow will abort with status 1 if any task fails.
'''))
debug = Boolean(default_value=False,
description=sstrip('''
Output developer information and show exception tracebacks.
'''))
no_timestamp = Boolean(default_value=False,
description=sstrip('''
Don't timestamp logged messages.
'''))
set = List( # noqa: A003 (graphql field name)
String,
description=sstrip('''
Set the value of a Jinja2 template variable in the workflow
definition. Values should be valid Python literals so strings
must be quoted e.g. `STR="string"`, `INT=43`, `BOOL=True`.
This option can be used multiple times on the command line.
NOTE: these settings persist across workflow restarts, but can
be set again on the `cylc play` command line if they need to be
overridden.
'''))
set_file = String(description=sstrip('''
Set the value of Jinja2 template variables in the workflow
definition from a file containing NAME=VALUE pairs (one per
line). As with "set" values should be valid Python literals so
strings must be quoted e.g. `STR='string'`. NOTE: these
settings persist across workflow restarts, but can be set again
on the `cylc play` command line if they need to be overridden.
'''))
def convert_column_to_boolean(type, column, registry=None):
return Boolean(description=get_column_doc(column),
required=not (is_column_nullable(column)))
class Query(ObjectType):
all_reporters = DjangoFilterConnectionField(
ReporterType, reverse_order=Boolean()
)
class QueryType(ObjectType):
class Meta:
name = "Query"
description = "..."
# User
login = Field(Login,
email=String(required=True),
password=String(required=True),
remember_me=Boolean(),
required=True)
# Company
company = Field(CompanyType, _id=ID(required=True))
company_list = List(CompanyType)
company_members = List(UserType, company_id=ID(required=True))
# Product
product_category_list = List(ProductCategoryType)
product_category = Field(ProductCategoryType, _id=ID(required=True))
product = Field(ProductType, _id=ID(required=True))
product_list = List(ProductType, company_id=ID(required=True))
# Contact
customer = Field(CustomerType, _id=ID(required=True))
customer_list = List(CustomerType, company_id=ID(required=True))
# Campaign
campaign = Field(CampaignType, _id=ID(required=True))
campaign_list = List(CampaignType, company_id=ID(required=True))
# RESOLVERS
@staticmethod
def resolve_login(root, info, email, password, remember_me=False):
user = UserModel.find_by_email(email)
if user and check_password_hash(user.password, password):
return Login(user=user, token=create_tokens(user, remember_me))
raise Exception("email or password were incorrect")
@staticmethod
def resolve_company(root, info, _id):
return CompanyModel.find_by_id(_id)
@staticmethod
def resolve_company_list(root, info):
return CompanyModel.find_all()
@staticmethod
def resolve_company_members(root, info, company_id):
return UserModel.find_many_by("company", company_id)
@staticmethod
def resolve_product_category_list(root, info):
return ProductCategoryModel.find_all()
@staticmethod
def resolve_product_category(root, info, _id):
return ProductCategoryModel.find_by_id(_id)
@staticmethod
def resolve_product_list(root, info, company_id):
return ProductModel.find_many_by(company_id)
@staticmethod
def resolve_product(root, info, _id):
return ProductModel.find_by_id(_id)
@staticmethod
def resolve_customer(root, info, _id):
return CustomerModel.find_by_id(_id)
@staticmethod
def resolve_customer_list(root, info, company_id):
return CustomerModel.find_many_by(company_id)
@staticmethod
def resolve_campaign(root, info, _id):
return CampaignModel.find_by_id(_id)
@staticmethod
def resolve_campaign_list(root, info, company_id):
return CampaignModel.find_many_by(company_id)
class DjangoSerializerType(ObjectType):
"""
DjangoSerializerType definition
"""
ok = Boolean(
description='Boolean field that return mutation result request.')
errors = List(ErrorType, description='Errors list for the field')
class Meta:
abstract = True
@classmethod
def __init_subclass_with_meta__(cls,
serializer_class=None,
queryset=None,
only_fields=(),
exclude_fields=(),
pagination=None,
input_field_name=None,
output_field_name=None,
results_field_name=None,
nested_fields=False,
filter_fields=None,
description='',
**options):
if not serializer_class:
raise Exception(
'serializer_class is required on all ModelSerializerType')
model = serializer_class.Meta.model
description = description or 'ModelSerializerType for {} model'.format(
model.__name__)
input_field_name = input_field_name or 'new_{}'.format(
model._meta.model_name)
output_field_name = output_field_name or model._meta.model_name
input_class = getattr(cls, 'Arguments', None)
if not input_class:
input_class = getattr(cls, 'Input', None)
if input_class:
warn_deprecation((
"Please use {name}.Arguments instead of {name}.Input."
"Input is now only used in ClientMutationID.\nRead more: "
"https://github.com/graphql-python/graphene/blob/2.0/UPGRADE-v2.0.md#mutation-input"
).format(name=cls.__name__))
if input_class:
arguments = props(input_class)
else:
arguments = {}
registry = get_global_registry()
factory_kwargs = {
'model': model,
'only_fields': only_fields,
'exclude_fields': exclude_fields,
'filter_fields': filter_fields,
'pagination': pagination,
'queryset': queryset,
'nested_fields': nested_fields,
'registry': registry,
'skip_registry': False
}
output_type = registry.get_type_for_model(model)
if not output_type:
output_type = factory_type('output', DjangoObjectType,
**factory_kwargs)
output_list_type = factory_type('list', DjangoListObjectType,
**factory_kwargs)
django_fields = OrderedDict({output_field_name: Field(output_type)})
global_arguments = {}
for operation in ('create', 'delete', 'update'):
global_arguments.update({operation: OrderedDict()})
if operation != 'delete':
input_type = registry.get_type_for_model(model,
for_input=operation)
if not input_type:
factory_kwargs.update({'skip_registry': True})
input_type = factory_type('input', DjangoInputObjectType,
operation, **factory_kwargs)
global_arguments[operation].update(
{input_field_name: Argument(input_type, required=True)})
else:
global_arguments[operation].update({
'id':
Argument(
ID,
required=True,
description='Django object unique identification field'
)
})
global_arguments[operation].update(arguments)
_meta = DjangoSerializerOptions(cls)
_meta.mutation_output = cls
_meta.arguments = global_arguments
_meta.fields = django_fields
_meta.output_type = output_type
_meta.output_list_type = output_list_type
_meta.model = model
_meta.queryset = queryset or model._default_manager
_meta.serializer_class = serializer_class
_meta.input_field_name = input_field_name
_meta.output_field_name = output_field_name
super(DjangoSerializerType,
cls).__init_subclass_with_meta__(_meta=_meta,
description=description,
**options)
@classmethod
def list_object_type(cls):
return cls._meta.output_list_type
@classmethod
def object_type(cls):
return cls._meta.output_type
@classmethod
def get_errors(cls, errors):
errors_dict = {
cls._meta.output_field_name: None,
'ok': False,
'errors': errors
}
return cls(**errors_dict)
@classmethod
def perform_mutate(cls, obj, info):
resp = {cls._meta.output_field_name: obj, 'ok': True, 'errors': None}
return cls(**resp)
@classmethod
def get_serializer_kwargs(cls, root, info, **kwargs):
return {}
@classmethod
def create(cls, root, info, **kwargs):
new_obj = kwargs.get(cls._meta.input_field_name, None)
if new_obj:
serializer = cls._meta.serializer_class(
data=new_obj,
**cls.get_serializer_kwargs(root, info, **kwargs))
if serializer.is_valid():
obj = serializer.save()
return cls.perform_mutate(obj, info)
else:
errors = [
ErrorType(field=key, messages=value)
for key, value in serializer.errors.items()
]
return cls.get_errors(errors)
@classmethod
def delete(cls, root, info, **kwargs):
pk = kwargs.get('id', None)
if id:
model = cls._meta.model
old_obj = get_Object_or_None(model, pk=pk)
if old_obj:
old_obj.delete()
old_obj.id = pk
return cls.perform_mutate(old_obj, info)
else:
errors = [
ErrorType(field='id',
messages=[
'A {} obj with id {} do not exist'.format(
model.__name__, pk)
])
]
return cls.get_errors(errors)
@classmethod
def update(cls, root, info, **kwargs):
new_obj = kwargs.get(cls._meta.input_field_name, None)
if new_obj:
model = cls._meta.model
id = new_obj.pop('id')
old_obj = get_Object_or_None(model, pk=id)
if old_obj:
new_obj_serialized = dict(
cls._meta.serializer_class(
old_obj,
**cls.get_serializer_kwargs(root, info,
**kwargs)).data)
new_obj_serialized.update(new_obj)
serializer = cls._meta.serializer_class(
old_obj,
data=new_obj_serialized,
**cls.get_serializer_kwargs(root, info, **kwargs))
if serializer.is_valid():
obj = serializer.save()
return cls.perform_mutate(obj, info)
else:
errors = [
ErrorType(field=key, messages=value)
for key, value in serializer.errors.items()
]
else:
errors = [
ErrorType(field='id',
messages=[
'A {} obj with id: {} do not exist'.format(
model.__name__, id)
])
]
return cls.get_errors(errors)
@classmethod
def retrieve(cls, manager, root, info, **kwargs):
id = kwargs.pop('id', None)
try:
return manager.get_queryset().get(pk=id)
except manager.model.DoesNotExist:
return None
@classmethod
def list(cls, manager, filterset_class, filtering_args, root, info,
**kwargs):
qs = queryset_factory(cls._meta.queryset or manager, info.field_asts,
info.fragments, **kwargs)
filter_kwargs = {
k: v
for k, v in kwargs.items() if k in filtering_args
}
qs = filterset_class(data=filter_kwargs, queryset=qs).qs
count = qs.count()
return DjangoListObjectBase(
count=count,
results=maybe_queryset(qs),
results_field_name=cls.list_object_type()._meta.results_field_name)
@classmethod
def RetrieveField(cls, *args, **kwargs):
return DjangoObjectField(cls._meta.output_type,
resolver=cls.retrieve,
**kwargs)
@classmethod
def ListField(cls, *args, **kwargs):
return DjangoListObjectField(cls._meta.output_list_type,
resolver=cls.list,
**kwargs)
@classmethod
def CreateField(cls, *args, **kwargs):
return Field(cls._meta.mutation_output,
args=cls._meta.arguments['create'],
resolver=cls.create,
**kwargs)
@classmethod
def DeleteField(cls, *args, **kwargs):
return Field(cls._meta.mutation_output,
args=cls._meta.arguments['delete'],
resolver=cls.delete,
**kwargs)
@classmethod
def UpdateField(cls, *args, **kwargs):
return Field(cls._meta.mutation_output,
args=cls._meta.arguments['update'],
resolver=cls.update,
**kwargs)
@classmethod
def QueryFields(cls, *args, **kwargs):
retrieve_field = cls.RetrieveField(*args, **kwargs)
list_field = cls.ListField(*args, **kwargs)
return retrieve_field, list_field
@classmethod
def MutationFields(cls, *args, **kwargs):
create_field = cls.CreateField(*args, **kwargs)
delete_field = cls.DeleteField(*args, **kwargs)
update_field = cls.UpdateField(*args, **kwargs)
return create_field, delete_field, update_field
class TopicListQuery(ObjectType):
topics = Field(
TopicList,
slug=String(required=True),
year=Int(),
page=Int(),
search_keys=String(),
refresh=Boolean(),
tab=String(),
exclusions=List(String),
extra=JSONString(),
)
@staticmethod
def resolve_topics(_parent, info, slug, **kwargs):
# Convert string query parameters to actual dictionary to use it in TopicListHandler
search_keys = dict(parse_qsl(
kwargs.get("search_keys"))) if kwargs.get("search_keys") else {}
manager = TopicListManager(
slug,
info.context.user,
kwargs.get("year"),
search_keys,
kwargs.get("tab"),
kwargs.get("exclusions"),
extra=kwargs.get("extra"),
)
if kwargs.get("refresh"):
manager.delete_cache(delimiter=True)
frame = LeftFrame(manager, kwargs.get("page"))
page = frame.page # May raise PermissionDenied or Http404
object_list = [
Topic(title=t["title"],
slug=t["slug"],
count=humanize_count(t.get("count")))
for t in page["object_list"]
]
paginator = {
"num_pages": page["paginator"]["num_pages"],
"page_range": page["paginator"]["page_range"]
}
tabs = (Tabs(
current=frame.tabs["current"],
available=[
Tab(name=key, safename=value)
for key, value in frame.tabs["available"].items()
],
) if frame.tabs else None)
exclusions = (Exclusions(active=frame.exclusions["active"],
available=frame.exclusions["available"])
if frame.exclusions else None)
extra = [
Extra(name=key, value=value) for key, value in frame.extra.items()
] if frame.extra else None
page_data = {
"has_next": page.get("has_next"),
"has_other_pages": page.get("has_other_pages"),
"has_previous": page.get("has_previous"),
"number": page.get("number"),
"object_list": object_list,
"paginator": Paginator(**paginator),
}
data = {
"page": Page(**page_data),
"parameters": frame.parameters,
"refresh_count": frame.refresh_count,
"year": frame.year,
"year_range": frame.year_range,
"safename": frame.safename,
"slug": frame.slug,
"slug_identifier": frame.slug_identifier,
"tabs": tabs,
"exclusions": exclusions,
"extra": extra,
}
return TopicList(**data)
class Query(ObjectType):
paged_logistics_request = Field(PagedLogisticsRequestType,
paged=PagedInput(required=True),
filters=LogisticsRequestFilter())
transfer_request = Field(TransferRequestData,
requestId=IntID(required=True),
sort_by=String(),
desc=Boolean())
get_logistics_request = Field(LogisticsRequestType, id=IntID())
paged_transfer_requests = Field(PagedTransferRequestsType,
paged=PagedInput(required=True),
filters=TransferRequestsFilter())
paged_logistics_request_position = Field(
PagedLogisticsRequestPositionType,
paged=PagedInput(required=True),
filters=LogisticsRequestPositionFilter())
transfer_request_position_info = List(TransferRequestType,
position_id=IntID(required=True))
good_location_info = List(GoodLocationInfoType,
position_id=IntID(required=True))
get_logistics_request_id = IntID()
get_logistics_request_project_id = IntID()
def resolve_paged_logistics_request(self, info, paged, **kwargs):
logistics_requests, total_count = LogisticsRequest.objects.list_paged_logistics_requests(
info.context.user, **paged, **kwargs)
return PagedLogisticsRequestType(logistics_requests=logistics_requests,
total_count=total_count)
def resolve_transfer_request(self, info, **kwargs):
transfer_request, transfer_positions = TransferRequest.objects.transfer_request(
info, **kwargs)
return TransferRequestData(transfer_request=transfer_request,
transfer_positions=transfer_positions)
def resolve_get_logistics_request(self, info, id):
return LogisticsRequest.objects.get(id=id)
def resolve_paged_transfer_requests(self, info, paged, **kwargs):
transfer_requests, total_count = TransferRequest.objects.list_paged_transfer_requests(
info.context.user, **paged, **kwargs)
return PagedTransferRequestsType(transfer_requests=transfer_requests,
total_count=total_count)
def resolve_paged_logistics_request_position(self, info, paged, **kwargs):
logistics_request_positions, total_count = LogisticsRequestPosition.objects.list_paged_logistics_request_position(
info.context.user, **paged, **kwargs)
return PagedLogisticsRequestPositionType(
logistics_request_positions=logistics_request_positions,
total_count=total_count)
def resolve_transfer_request_position_info(self, info, position_id):
try:
position = LogisticsRequestPosition.objects.get(id=position_id)
except LogisticsRequestPosition.DoesNotExist:
return []
transfer_requests = []
for tp in TransferPosition.objects.filter(
good__good_kind=position.good_kind,
good__unit=position.unit,
transfer_request__completed=False).exclude(
logistics_request_position=position):
transfer_request = tp.transfer_request
transfer_request.count = '%s %s' % (str(
int(tp.count) if isinstance(tp.count, float) and tp.count.
is_integer() else tp.count), tp.good.unit.short_name)
transfer_requests.append(transfer_request)
transfer_requests = list(set(transfer_requests))
return transfer_requests
def resolve_good_location_info(self, info, position_id):
try:
position = LogisticsRequestPosition.objects.get(id=position_id)
except LogisticsRequestPosition.DoesNotExist:
return []
result = []
for g in Good.objects.filter(
good_kind=position.good_kind,
unit=position.unit).exclude(location_id__in=(1, 646)):
if (g.project and g.project.id == position.request.reason.project.id) or \
(g.location.project and g.location.project.id == position.request.reason.project.id):
continue
result.append(
GoodLocationInfoType(project=g.location.project, good=g))
return result
def resolve_get_logistics_request_id(self, info):
lr = LogisticsRequest.objects.filter(
logisticsrequestposition__transferposition__transfer_request__ready_to_go
=False,
logisticsrequestposition__transferposition__transfer_request__who_requested
=info.context.user).distinct()
if lr:
lr = lr[0].id
return lr
else:
return -1
def resolve_get_logistics_request_project_id(self, info):
proj = None
tr = TransferRequest.objects.filter(ready_to_go=False,
who_requested=info.context.user)
if tr:
tp = TransferPosition.objects.filter(
transfer_request=tr[0]).select_related(
'logistics_request_position__request')
proj = tp[0].logistics_request_position.request.reason.project
if proj:
proj = proj.id
return proj
else:
return -1
def convert_column_to_boolean(type, column, registry=None):
return Boolean(description=column.doc, required=not (column.nullable))
class Input:
first_name = String(required=True)
last_name = String(required=True)
is_alive = Boolean(required=True)
origin_id = Int(required=True)
seasons = List(Int)
def convert_field_to_boolean(field, registry=None, input_flag=None, nested_field=False):
required = is_required(field) and input_flag == "create"
if required:
return NonNull(Boolean, description=field.help_text)
return Boolean(description=field.help_text)
class MutationResult(ObjectType):
ok = Boolean()
class Arguments():
"""Arguments of the class."""
uuid = String()
finding_id = String(required=True)
approval_status = Boolean(required=True)
