class LoginUser(graphene.Mutation):
token = graphene.String()
errors = GenericScalar()
class Arguments:
login = graphene.String()
password = graphene.String()
def mutate(self, info, login, password):
errors = {
'login': [],
'password': []
}
valid = True
login_type = 'email' if '@' in login else 'username'
login = login.strip()
password = password.strip()
if len(login) == 0:
errors['login'].append('Please, enter your login.')
valid = False
elif not Siteuser.objects.filter(**{login_type: login}).exists():
errors['login'].append(login_type.capitalize() + ' does not exist.')
valid = False
else:
hashed = Siteuser.objects.filter(**{login_type: login})[0].password[2:-1]
if len(password) > 0 and not bcrypt.checkpw(password.encode('utf8'), hashed.encode('utf8')):
errors['password'].append('Password does not match.')
valid = False
if len(password) == 0:
errors['password'].append('Please, enter your password.')
valid = False
if valid:
user = Siteuser.objects.get(**{login_type: login})
# refresh_token = jwt.encode({
# 'id': user.id,
# 'username': user.username,
# 'email': user.email,
# 'exp': int(time.time()) + 31536000
# }, 'mySuperSecretRefreshKey', algorithm='HS256').decode('utf-8')
# print(refresh_token)
auth_token = jwt.encode({
'id': user.id,
'username': user.username,
'email': user.email,
'added': user.added,
# 'exp': int(time.time()) + 300
}, 'myTestKey!noiceone', algorithm='HS256').decode('utf-8')
return AuthToken(auth_token)
return ValidationErrors(errors)
class Power(MongoengineObjectType):
# powers = graphene.List('levels.types.Power',
# blockchain=graphene.String(required=True),
# host = graphene.String(required=True),
# first=graphene.Int(),
# last=graphene.Int())
# def resolve_powers(self, info, blockchain, host):
# qs = PowerModel.objects(blockchain=blockchain, username = self.username, host=host)
# return qs;
badges = graphene.List(
'badges.types.Badge',
first=graphene.Int(),
last=graphene.Int(),
)
json_metadata = GenericScalar()
avatar = graphene.String()
def resolve_avatar(self, info):
user = LevelModel.objects(username=self.author,
blockchain=self.blockchain).first()
if (user):
meta = prepare_json(user.meta)
else:
meta = {}
if 'img' in meta:
return meta['img']
else:
return "/ava.png"
def resolve_json_metadata(self, info):
User = LevelModel.objects(username=self.username,
blockchain=self.blockchain).first()
return prepare_json(User.meta)
# if isinstance(self.meta, BaseDict):
# return prepare_json(self.meta)
# else:
# return {}
def resolve_badges(self, info):
qs = BadgeModel.objects(blockchain=self.blockchain,
username=self.username)
#TODO find badges and construct
return qs
class Meta:
model = PowerModel
interfaces = (Node, )
class OutputType(graphene.ObjectType):
name = 'Output'
description = '...'
condition = GenericScalar()
public_keys = graphene.List(graphene.String)
amount = graphene.String()
@classmethod
def from_json(cls, output):
return cls(**output)
class OrderLineObjectType(DjangoObjectType):
product_thumbnail_url = graphene.Field(graphene.String)
product_details = GenericScalar()
def resolve_product_thumbnail_url(self, info, **kwargs):
if self.product_thumbnail:
return self.product_thumbnail.url
return ''
class Meta:
model = OrderLine
class Page(DjangoObjectType):
body_json = GenericScalar(required=True)
class Meta:
model = SitePage
def resolve_body(self, info):
return self.body
def resolve_body_json(self, info):
return self.body.stream_data
class VerifyMutation(graphene.Mutation):
payload = GenericScalar(required=True)
class Arguments:
token = graphene.String(required=True)
def mutate(self, info, token):
payload = get_payload(token)
if Blacklist.is_blacklisted(payload['refresh_token']):
raise JSONWebTokenExpired
return VerifyMutation(payload=payload)
class UserTokenRefresh(Refresh):
permission = GenericScalar()
user = graphene.Field(UserType)
@classmethod
def mutate(cls, *arg, **kwargs):
result = cls.refresh(*arg, **kwargs)
user = get_user_by_payload(result.payload)
result.user = user
result.permission = list(user.get_all_permissions())
return result
class TaskActions(Mutation):
class Meta:
description = """Task actions:
- Prepare job file for task(s).
- Hold tasks.
- Insert task proxies.
- Kill task jobs.
- Return True if task_id exists (and running).
- Unhold tasks.
- Remove tasks from task pool.
- Reset statuses tasks.
- Spawn tasks.
- Trigger submission of task jobs where possible."""
resolver = nodes_mutator
class Arguments:
workflows = List(String)
command = String(
description="""Task actions:
- `dry_run_tasks`
- `hold_tasks`
- `insert_tasks`
- `kill_tasks`
- `poll_tasks`
- `release_tasks`
- `remove_tasks`
- `reset_task_states`
- `spawn_tasks`
- `trigger_tasks`""",
required=True,
)
ids = List(String,
description="""Used with:
- All Commands
A list of identifiers (family%glob%id) for matching task proxies, i.e.
```
[
"owner%workflow%201905*%foo",
"foo.201901*:failed",
"201901*%baa:failed",
"FAM.20190101T0000Z",
"FAM2",
"*.20190101T0000Z"
]
```
(where % is the delimiter)
Splits argument into components, creates workflows argument if non-existent.
""",
required=True)
args = TaskArgs()
result = GenericScalar()
class Register(graphene.Mutation):
class Arguments:
username = graphene.String(required=True)
password = graphene.String(required=True)
email = graphene.String(required=True)
display_name = graphene.String(required=True)
school = graphene.String()
company = graphene.String()
location = graphene.String()
token = graphene.String()
payload = GenericScalar()
permission = GenericScalar()
user = graphene.Field(UserType)
def mutate(self, info, **kwargs):
from .form import UserSignupForm
SignupForm = UserSignupForm(kwargs)
if SignupForm.is_valid():
values = SignupForm.cleaned_data
new_user = User(
username=values['username'],
email=values['email'],
display_name=values['display_name'],
school=values['school'],
company=values['company'],
location=values['location'],
is_staff=False,
is_superuser=False,
)
new_user.set_password(values['password'])
new_user.save()
new_user.set_group(Group.NORMAL_USER)
token = get_token(new_user)
payload = get_payload(token, info.context)
return Register(payload=payload,
token=token,
permission=list(new_user.get_all_permissions()),
user=new_user)
else:
raise RuntimeError(SignupForm.errors.as_json())
class ExternalTrigger(Mutation):
class Meta:
description = """Server-side external event trigger interface."""
resolver = mutator
class Arguments:
workflows = List(String, required=True)
command = String(default_value='put_external_trigger')
event_message = String(required=True)
event_id = String(required=True)
result = GenericScalar()
class UserLogin(graphene.Mutation):
class Arguments:
username = graphene.String(required=True)
password = graphene.String(required=True)
token = graphene.String()
payload = GenericScalar()
permission = GenericScalar()
user = graphene.Field(UserType)
def mutate(self, info: ResolveInfo, **kwargs):
login_form = UserLoginForm(kwargs)
if login_form.is_valid():
values = login_form.cleaned_data
usr = User.objects.get(username=values.get('username'))
token = get_token(usr)
payload = get_payload(token, info.context)
update_last_login(None, usr)
return UserLogin(payload=payload, token=token, permission=list(usr.get_all_permissions()), user=usr)
else:
raise RuntimeError(login_form.errors.as_json())
class StructBlock(graphene.ObjectType):
class Meta:
interfaces = (StreamFieldInterface, )
value = GenericScalar()
items = graphene.List(StreamFieldInterface)
def resolve_items(self, info, **kwargs):
return [
StructBlockItem(name, self.block.child_blocks[name], value)
for name, value in self.value.items()
]
class ExpireBroadcast(Mutation):
class Meta:
description = """Clear settings globally,
or for listed namespaces and/or points."""
resolver = mutator
class Arguments:
workflows = List(String, required=True)
command = String(default_value='expire_broadcast')
cutoff = String(description="""String""")
result = GenericScalar()
class AssignmentType(DjangoObjectType):
"""
Object type for each Assignment
"""
class Meta:
model = Assignment
fields = ('assignment_id', )
filter_fields = ['assignment_id']
problems_below = graphene.List(ProblemType)
# statistic = graphene.Field(StatisticType)
assignment_name = graphene.String()
aggregate_errors = graphene.Int()
problem_errors = GenericScalar()
type_of_errors = GenericScalar()
students_by_errors = GenericScalar()
def resolve_problems_below(parent, info):
return parent.problems.all()
def resolve_aggregate_errors(parent, info):
return aggregate_errors(parent)
def resolve_problem_errors(parent, info):
return problem_errors(parent)
def resolve_type_of_errors(parent, info):
return type_of_errors(parent)
def resolve_students_by_errors(parent, info):
return students_by_errors(parent)
def resolve_assignment_name(parent, info):
name = parent.assignment_name
if name:
return name
else:
return ""
class SetVerbosity(Mutation):
class Meta:
description = """Set workflow verbosity to new level."""
resolver = mutator
class Arguments:
workflows = List(String, required=True)
command = String(default_value='set_verbosity')
level = String(description="""levels:
`INFO`, `WARNING`, `NORMAL`, `CRITICAL`, `ERROR`, `DEBUG`""",
required=True)
result = GenericScalar()
class TakeCheckpoint(Mutation):
class Meta:
description = """Checkpoint current task pool."""
resolver = mutator
class Arguments:
workflows = List(String, required=True)
command = String(default_value='take_checkpoints')
name = String(
description="""The checkpoint name""",
required=True,)
result = GenericScalar()
class ServicePageStepLocationBlock(graphene.ObjectType):
# This uses graphene ObjectType resolvers, see:
# https://docs.graphene-python.org/en/latest/types/objecttypes/#resolvers
value = GenericScalar()
location_page = graphene.Field(LocationPageNode)
def resolve_location_page(self, info):
page = None
try:
page = LocationPage.objects.get(id=self.value)
except ObjectDoesNotExist:
pass
return page
def _add_form(cls: Type[AbstractForm], node: str, dict_params: dict) -> Type[graphene.Mutation]:
if node in registry.forms: # pragma: no cover
return registry.forms[node]
registry.page_prefetch_fields.add(cls.__name__.lower())
dict_params['Meta'].interfaces += (Page,)
dict_params['form_fields'] = graphene.List(FormField)
def form_fields(self, _info):
return list(FormField(name=field_.clean_name, field_type=field_.field_type,
label=field_.label, required=field_.required,
help_text=field_.help_text, choices=field_.choices,
default_value=field_.default_value)
for field_ in self.form_fields.all())
dict_params['resolve_form_fields'] = form_fields
registry.pages[cls] = type(node, (DjangoObjectType,), dict_params)
args = type("Arguments", (), {'values': GenericScalar(),
"url": graphene.String(required=True),
"token": graphene.String(required=True)})
_node = node
@login_required
def mutate(_self, info, token, url, values):
url_prefix = url_prefix_for_site(info)
query = wagtailPage.objects.filter(url_path=url_prefix + url.rstrip('/') + '/')
instance = with_page_permissions(
info.context,
query.specific()
).live().first()
user = info.context.user
# convert camelcase to dashes
values = {camel_case_to_spaces(k).replace(' ', '-'): v for k, v in values.items()}
form = instance.get_form(values, None, page=instance, user=user)
if form.is_valid():
# form_submission
instance.process_form_submission(form)
return registry.forms[_node](result="OK")
else:
return registry.forms[_node](result="FAIL", errors=[FormError(*err) for err in form.errors.items()])
dict_params = {
"Arguments": args,
"mutate": mutate,
"result": graphene.String(),
"errors": graphene.List(FormError),
}
tp = type(node + "Mutation", (graphene.Mutation,), dict_params) # type: Type[graphene.Mutation]
registry.forms[node] = tp
return tp
class UserRegister(graphene.Mutation):
class Arguments:
username = graphene.String(required=True)
password = graphene.String(required=True)
email = graphene.String(required=True)
school = graphene.String()
company = graphene.String()
location = graphene.String()
about = graphene.String()
codeforces = graphene.String()
atcoder = graphene.String()
studentid = graphene.String()
gender = graphene.Boolean()
token = graphene.String()
payload = GenericScalar()
permission = GenericScalar()
user = graphene.Field(UserType)
def mutate(self, info: ResolveInfo, **kwargs):
signup_form = UserSignupForm(kwargs)
if signup_form.is_valid():
values = signup_form.cleaned_data
usr = User()
attach_info = AttachInfo()
assign(usr, **values)
assign(attach_info, **values)
usr.set_password(usr.password)
attach_info.save()
usr.attach_info = attach_info
usr.save()
token = get_token(usr)
payload = get_payload(token, info.context)
return UserRegister(payload=payload, token=token, permission=list(usr.get_all_permissions()), user=usr)
else:
raise RuntimeError(signup_form.errors.as_json())
class Parameters(ObjectType):
class Meta:
interfaces = relay.Node,
name = String(description="The true path to the parameter file. Internal use only")
path = String(description="The true path to the parameter file. Internal use only")
keys = List(String, description="list of parameter keys")
value = GenericScalar(description="the json value for the parameters")
raw = GenericScalar(description="the raw data object for the parameters")
flat = GenericScalar(description="the raw data object for the parameters")
def resolve_name(self, info):
return basename(self.id)
def resolve_path(self, info):
return self.id
def resolve_keys(self, info):
value = reduce(assign, read_json(join(Args.logdir, self.id[1:])) or [{}])
return dot_keys(value)
def resolve_value(self, info, **kwargs):
return reduce(assign, read_json(join(Args.logdir, self.id[1:])) or [{}])
def resolve_raw(self, info, **kwargs):
return read_json(join(Args.logdir, self.id[1:]))
def resolve_flat(self, info, **kwargs):
value = reduce(assign, read_json(join(Args.logdir, self.id[1:])) or [{}])
return dot_flatten(value)
# description = String(description='string serialized data')
# experiments = List(lambda: schema.Experiments)
@classmethod
def get_node(cls, info, id):
return get_parameters(id)
def arguments_from_fields(fields, model):
PeeweeModelField = Dynamic
arguments = {}
for name, field in fields.items():
if isinstance(field, PeeweeModelField):
if get_backref_by_name(model, name):
arg = GenericScalar().Argument()
else:
arg = Int().Argument()
elif isinstance(field.type, NonNull):
arg = field.type.of_type().Argument()
else:
arg = field.type().Argument() # TODO: get rid of strange `NotNull is not callable` warning
arguments[name] = arg
return arguments
class ServicePageStep(graphene.ObjectType):
value = GenericScalar()
locations = graphene.List(ServicePageStepLocationBlock)
step_type = graphene.String()
def resolve_locations(self, info):
repr_locations = []
# since we still want to be able to use value, we need to see
# if it's a string before grabbing locations to avoid errors
if self.step_type == "step_with_locations":
for location in self.value['locations']:
repr_locations.append(
ServicePageStepLocationBlock(value=location))
return repr_locations
class JSONWebTokenMixin:
payload = GenericScalar(required=True)
refresh_expires_in = graphene.Int(required=True)
@classmethod
def Field(cls, *args, **kwargs):
if not jwt_settings.JWT_HIDE_TOKEN_FIELDS:
cls._meta.fields['token'] =\
graphene.Field(graphene.String, required=True)
if jwt_settings.JWT_LONG_RUNNING_REFRESH_TOKEN:
cls._meta.fields['refresh_token'] =\
graphene.Field(graphene.String, required=True)
return super().Field(*args, **kwargs)
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 PersonalType(DjangoObjectType):
info = GenericScalar()
persona_str = graphene.String()
can_delete = graphene.Boolean()
class Meta:
model = Personal
def resolve_persona_str(self: Personal, info):
return self.persona.__str__()
def resolve_can_delete(self: Personal, info):
return validate_can_delete(self.aula_set.count()) \
and validate_can_delete(self.coordinador.count()) \
and validate_can_delete(self.sub_coordinador.count()) \
and validate_can_delete(self.director.count())
class Account(MongoengineObjectType):
meta = graphene.Field(AccountMeta)
json_metadata = GenericScalar()
def resolve_json_metadata(self, info):
return prepare_json(self.json_metadata)
class Meta:
model = AccountModel
interfaces = (Node, )
def resolve_meta(self, info):
if isinstance(self.json_metadata, BaseDict):
return self.json_metadata
else:
return {}
class HoldWorkflow(Mutation):
class Meta:
description = """Hold workflow.
- hold on workflow. (default)
- hold point of workflow."""
resolver = mutator
class Arguments:
command = String(description="""options:
- `hold_suite` (default)
- `hold_after_point_string`""",
default_value='hold_suite')
point_string = String()
workflows = List(String, required=True)
result = GenericScalar()
def _add_form(cls: Type[AbstractForm], node: str, dict_params: dict,
url_prefix: str) -> Type[graphene.Mutation]:
registry.page_prefetch_fields.add(cls.__name__.lower())
dict_params['Meta'].interfaces = (PageInterface, )
dict_params['form_fields'] = graphene.List(FormField)
def form_fields(self, _info):
return list(
FormField(name=field_.clean_name, field_type=field_.field_type)
for field_ in self.form_fields.all())
dict_params['resolve_form_fields'] = form_fields
tp = type(node, (DjangoObjectType, ), dict_params)
registry.pages[cls] = tp
args = type("Arguments", (), {
'values': GenericScalar(),
"url": graphene.String(required=True)
})
_node = node
def mutate(_self, info, url, values):
query = wagtailPage.objects.filter(url_path=url_prefix +
url.rstrip('/') + '/')
instance = with_page_permissions(info.context,
query.specific()).live().first()
user = info.context.user
form = instance.get_form(values, None, page=instance, user=user)
if form.is_valid():
# form_submission
instance.process_form_submission(form)
return registry.forms[_node](result="OK")
else:
return registry.forms[_node](
result="FAIL",
errors=[FormError(*err) for err in form.errors.items()])
dict_params = {
"Arguments": args,
"mutate": mutate,
"result": graphene.String(),
"errors": graphene.List(FormError),
}
tp = type(node + "Mutation", (graphene.Mutation, ),
dict_params) # type: Type[Mutation]
registry.forms[node] = tp
return tp
class Metrics(ObjectType):
class Meta:
interfaces = relay.Node,
path = String(description="path to the file")
name = String(description="path to the file")
stem = String(description="stem of the file name")
def resolve_path(self, info):
return self.id
def resolve_stem(
self,
info,
):
return self.name.split('.')[0]
keys = List(String, description="list of keys for the metrics")
# value = List(GenericScalar, description="the raw value")
value = GenericScalar(description="The value of the metrics file",
keys=List(String),
k=Int(required=False),
last=Int(required=False),
window=Int(required=False))
def resolve_keys(self, info):
df = read_dataframe(join(Args.logdir, self.id[1:]))
keys = df.dropna().keys()
return list(keys)
# todo: add more complex queries.
def resolve_value(self, info, keys=None, k=None, last=None, window=None):
path = join(Args.logdir, self.id[1:])
realpath(path)
_ = read_dataframe(path)
if keys:
df = _[keys].dropna()
return {k: df[k].values.tolist() for k in keys}
else:
df = _.dropna()
return {k: v.values.tolist() for k, v in df.items()}
@classmethod
def get_node(cls, info, id):
return Metrics(id, )
def arguments_from_fields(fields, model):
PeeweeModelField = Dynamic
arguments = {}
for name, field in fields.items():
if isinstance(field, PeeweeModelField):
if name in model._meta.reverse_rel:
arg = GenericScalar().Argument()
else:
arg = Int().Argument()
elif isinstance(field.type, type):
arg = field.type().Argument()
else:
if isinstance(field.type, NonNull):
arg = field.type.of_type().Argument()
else:
arg = field.type.Argument()
arguments[name] = arg
return arguments
