def is_dict_valid(cls, raw_dict: dict) -> bool:
return Draft4Validator(JOB_CONFIG_SCHEMA).is_valid(raw_dict)
action="count", default=0,
help="increases log verbosity for each occurence.")
arguments = parser.parse_args()
logger = colorlog.getLogger()
# Start off at Error, reduce by one level for each -v argument
logger.setLevel(max(4 - arguments.verbose_count, 0) * 10)
handler = colorlog.StreamHandler()
handler.setFormatter(colorlog.ColoredFormatter())
logger.addHandler(handler)
schema = json.load(io.open('schema.json', encoding='utf-8'))
seen_ids = set()
resolver = RefResolver('', None)
validator = Draft4Validator(schema, resolver=resolver)
borkenbuild = False
spacesave = 0
headers = {'User-Agent': 'Mozilla/5.0 (compatible; MSIE 6.0; OpenStreetMap Editor Layer Index CI check)'}
tested_sources_count = 0
for filename in arguments.path:
if not filename.lower()[-8:] == '.geojson':
logger.debug("{} is not a geojson file, skip".format(filename))
continue
if not os.path.exists(filename):
logger.debug("{} does not exist, skip".format(filename))
def __init__(self, schema):
self.validator = Draft4Validator(schema)
import os
from flask import request, redirect, jsonify, flash
from ..flask_itsyouonline import requires_auth
import json as JSON
import jsonschema
from jsonschema import Draft4Validator
from ..models import Farmer, Location
from .reverse_geocode import reverse_geocode
dir_path = os.path.dirname(os.path.realpath(__file__))
Farmer_schema = JSON.load(open(dir_path + '/schema/Farmer_schema.json'))
Farmer_schema_resolver = jsonschema.RefResolver(
'file://' + dir_path + '/schema/', Farmer_schema)
Farmer_schema_validator = Draft4Validator(Farmer_schema,
resolver=Farmer_schema_resolver)
@requires_auth(org_from_request=True)
def UpdateFarmerHandler():
iyo_organization = request.args['organization']
farmer = Farmer.objects.filter(iyo_organization=iyo_organization).first()
if not farmer:
return jsonify(
code=404,
message="itsyou.online organization: {} not found.".format(
iyo_organization)), 404
new_farm_name = request.args.get('name')
if new_farm_name:
farmer.name = new_farm_name
def parse(filename):
try:
schema = json.loads(open("pl.schema").read())
schema = Draft4Validator(schema, format_checker=FormatChecker())
except ValueError as e:
post_error("pl.schema - " + str(e))
return
try:
pl = json.loads(open(filename).read())
except ValueError as e:
post_error(filename + " - " + str(e))
return
for error in schema.iter_errors(pl):
post_error(error.message)
foldernames = []
displaynames = []
repositories = []
os.mkdir("./" + bitness_from_input)
for plugin in pl["npp-plugins"]:
print(plugin["display-name"])
try:
response = requests.get(plugin["repository"])
except requests.exceptions.RequestException as e:
post_error(str(e))
continue
if response.status_code != 200:
post_error(
f'{plugin["display-name"]}: failed to download plugin. Returned code {response.status_code}'
)
continue
# Hash it and make sure its what is expected
hash = sha256(response.content).hexdigest()
if plugin["id"].lower() != hash.lower():
post_error(
f'{plugin["display-name"]}: Invalid hash. Got {hash.lower()} but expected {plugin["id"]}'
)
continue
# Make sure its a valid zip file
try:
zip = zipfile.ZipFile(io.BytesIO(response.content))
except zipfile.BadZipFile as e:
post_error(f'{plugin["display-name"]}: Invalid zip file')
continue
# The expected DLL name
dll_name = f'{plugin["folder-name"]}.dll'.lower()
# Notepad++ is not case sensitive, but extracting files from the zip is,
# so find the exactfile name to use
for file in zip.namelist():
if dll_name == file.lower():
dll_name = file
break
else:
post_error(
f'{plugin["display-name"]}: Zip file does not contain {plugin["folder-name"]}.dll'
)
continue
with zip.open(dll_name) as dll_file, open(
"./" + bitness_from_input + "/" + dll_name, 'wb') as f:
f.write(dll_file.read())
version = plugin["version"]
# Fill in any of the missing numbers as zeros
version = version + (3 - version.count('.')) * ".0"
try:
dll_version = get_version_number("./" + bitness_from_input + "/" +
dll_name)
except win32api.error:
post_error(
f'{plugin["display-name"]}: Does not contain any version information'
)
continue
if dll_version != version:
post_error(
f'{plugin["display-name"]}: Unexpected DLL version. DLL is {dll_version} but expected {version}'
)
continue
#check uniqueness of json folder-name, display-name and repository
found = False
for name in displaynames:
if plugin["display-name"] == name:
post_error(
f'{plugin["display-name"]}: non unique display-name entry')
found = True
if found == False:
displaynames.append(plugin["display-name"])
found = False
for folder in foldernames:
if plugin["folder-name"] == folder:
post_error(
f'{plugin["folder-name"]}: non unique folder-name entry')
found = True
if found == False:
foldernames.append(plugin["folder-name"])
found = False
for repo in repositories:
if plugin["repository"] == repo:
post_error(
f'{plugin["repository"]}: non unique repository entry')
found = True
if found == False:
repositories.append(plugin["repository"])
'type': 'array',
'items': {
'type': 'object',
'properties': {
'deco_id': {
'type': 'number'
},
'level': {
'type': 'number'
},
'master_id': {
'type': 'number'
},
},
'required': ['master_id', 'level', 'deco_id']
}
},
},
'required': [
'unit_list',
'building_list',
'deco_list',
],
},
},
'required': ['friend'],
}
HubUserLoginValidator = Draft4Validator(HubUserLoginSchema)
VisitFriendValidator = Draft4Validator(VisitFriendSchema)
def validate(self, value, model_instance):
# decrypt secret values so we can validate their contents (i.e.,
# ssh_key_data format)
if not isinstance(value, dict):
return super(CredentialInputField,
self).validate(value, model_instance)
# Backwards compatability: in prior versions, if you submit `null` for
# a credential field value, it just considers the value an empty string
for unset in [
key for key, v in model_instance.inputs.items() if not v
]:
default_value = model_instance.credential_type.default_for_field(
unset)
if default_value is not None:
model_instance.inputs[unset] = default_value
decrypted_values = {}
for k, v in value.items():
if all([
k in model_instance.credential_type.secret_fields,
v != '$encrypted$', model_instance.pk
]):
decrypted_values[k] = utils.decrypt_field(model_instance, k)
else:
decrypted_values[k] = v
super(JSONSchemaField, self).validate(decrypted_values, model_instance)
errors = {}
for error in Draft4Validator(
self.schema(model_instance),
format_checker=self.format_checker).iter_errors(
decrypted_values):
if error.validator == 'pattern' and 'error' in error.schema:
error.message = error.schema['error'] % error.instance
if error.validator == 'dependencies':
# replace the default error messaging w/ a better i18n string
# I wish there was a better way to determine the parameters of
# this validation failure, but the exception jsonschema raises
# doesn't include them as attributes (just a hard-coded error
# string)
match = re.search(
# 'foo' is a dependency of 'bar'
"'" # apostrophe
"([^']+)" # one or more non-apostrophes (first group)
"'[\w ]+'" # one or more words/spaces
"([^']+)", # second group
error.message,
)
if match:
label, extraneous = match.groups()
if error.schema['properties'].get(label):
label = error.schema['properties'][label]['label']
errors[extraneous] = [
_('cannot be set unless "%s" is set') % label
]
continue
if 'id' not in error.schema:
# If the error is not for a specific field, it's specific to
# `inputs` in general
raise django_exceptions.ValidationError(
error.message,
code='invalid',
params={'value': value},
)
errors[error.schema['id']] = [error.message]
inputs = model_instance.credential_type.inputs
for field in inputs.get('required', []):
if not value.get(field, None):
errors[field] = [
_('required for %s') %
(model_instance.credential_type.name)
]
# `ssh_key_unlock` requirements are very specific and can't be
# represented without complicated JSON schema
if (model_instance.credential_type.managed_by_tower is True
and 'ssh_key_unlock'
in model_instance.credential_type.defined_fields):
# in order to properly test the necessity of `ssh_key_unlock`, we
# need to know the real value of `ssh_key_data`; for a payload like:
# {
# 'ssh_key_data': '$encrypted$',
# 'ssh_key_unlock': 'do-you-need-me?',
# }
# ...we have to fetch the actual key value from the database
if model_instance.pk and model_instance.ssh_key_data == '$encrypted$':
model_instance.ssh_key_data = model_instance.__class__.objects.get(
pk=model_instance.pk).ssh_key_data
if model_instance.has_encrypted_ssh_key_data and not value.get(
'ssh_key_unlock'):
errors['ssh_key_unlock'] = [
_('must be set when SSH key is encrypted.')
]
if all([
model_instance.ssh_key_data,
value.get('ssh_key_unlock'),
not model_instance.has_encrypted_ssh_key_data
]):
errors['ssh_key_unlock'] = [
_('should not be set when SSH key is not encrypted.')
]
if errors:
raise serializers.ValidationError({'inputs': errors})
# THIS FILE IS SAFE TO EDIT. It will not be overwritten when rerunning go-raml.
from flask import jsonify, request, current_app
import json as JSON
import jsonschema
from jsonschema import Draft4Validator
import os
CLASS='bdomain'
dir_path = os.path.dirname(os.path.realpath(__file__))
json_schema = JSON.load(open(dir_path + '/schema/' + CLASS + '_schema.json'))
schema_resolver = jsonschema.RefResolver('file://' + dir_path + '/schema/', json_schema)
schema_validator = Draft4Validator(json_schema, resolver=schema_resolver)
def updateBdomainHandler(id):
redis = current_app.config['redis']
key = current_app.config['dbkeys'][CLASS]
capnp_schema = current_app.config['capnp'][CLASS]
inputs = request.get_json()
try:
schema_validator.validate(inputs)
except jsonschema.ValidationError as e:
return jsonify(errors="bad request body"), 400
# create capnp object
class SubjectView(View):
schema = Draft4Validator({
'$schema': 'http://json-schema.org/draft-04/schema#',
'type': 'object',
'properties': {
'code': {
'oneOf': [{
'type': 'boolean',
'enum': [False]
}, {
'type': 'string',
'minLength': 1,
'maxLength': 8
}]
},
'name': {
'oneOf': [{
'type': 'boolean',
'enum': [False]
}, {
'type': 'string',
'minLength': 1
}]
},
'hours': {
'oneOf': [{
'type': 'boolean',
'enum': [False]
}, {
'type': 'integer',
'multipleOf': 1,
'maximum': 72,
'minimum': 1,
'exclusiveMaximum': True,
'exclusiveMinimum': False
}]
}
},
'required': ['code', 'name', 'hours']
})
@method_decorator(csrf_protect)
@method_decorator(login_required)
# @method_decorator(role_required('administrator'))
def get(self, request, code=''):
# Try to locate the subject - return 404 Not Found if code is invalid
try:
subject = Subject.objects.get_active(code=code)
except Subject.DoesNotExist:
return JsonResponse({
'version': '0.1.0',
'status': 404
},
status=404)
else:
# Output programs and the position of this subject in the programs
acronyms = Requirement.objects.active(
dependent_id=subject.id).values_list('program__acronym',
flat=True)
programs = {
AcademicProgram.objects.get(acronym=acronym)
for acronym in acronyms
}
# Serialize and send back response
return JsonResponse({
'version': '0.1.0',
'status': 200,
'subject': {
'id':
subject.id,
'code':
subject.code,
'name':
subject.name,
'hours':
subject.hours,
'programs': [{
'acronym':
program.acronym,
'name':
program.name,
'dependencies': [{
'id': s.id,
'code': s.code
} for s in subject.dependencies(program)],
'dependents': [{
'id': s.id,
'code': s.code
} for s in subject.dependents(program)]
} for program in programs]
}
})
@method_decorator(csrf_protect)
# @method_decorator(login_required)
# @method_decorator(role_required('administrator'))
def post(self, request, code=''):
data = loads(request.body)
try:
# Validate and normalize input for linear iteration
SubjectView.schema.validate(data)
# Locate and update the appointed subject
new_code, name, hours = data['code'], data['name'], data['hours']
subject = Subject.objects.get_active(code__iexact=code)
if new_code is not False: subject.code = code.upper()
if name is not False: subject.name = name
if hours is not False: subject.hours = hours
subject.save()
# Serialize and return response
return JsonResponse({
'version': '0.1.0',
'status': 200,
'subject': {
'id': subject.id,
'code': subject.code,
'name': subject.name,
'hours': subject.hours
}
})
except ValidationError:
return JsonResponse({
'version': '0.1.0',
'status': 403
},
status=403)
except Subject.DoesNotExist:
return JsonResponse({
'version': '0.1.0',
'status': 404
},
status=404)
@method_decorator(csrf_protect)
# @method_decorator(login_required)
# @method_decorator(role_required('administrator'))
def delete(self, request, code=''):
try:
subject = Subject.objects.get_active(code__iexact=code)
except Subject.DoesNotExist:
return JsonResponse({
'version': '0.1.0',
'status': 404
},
status=404)
else:
subject.delete(soft=True)
return JsonResponse({'version': '0.1.0', 'status': 200})
class StudentView(View):
schema = Draft4Validator({
'$schema': 'http://json-schema.org/draft-04/schema#',
'type': 'object',
'properties': {
'name': { 'oneOf': [ { 'type': 'boolean', 'enum': [ False ] }, { 'type': 'string', 'minLength': 1 } ] },
'email-address': { 'oneOf': [ { 'type': 'boolean', 'enum': [ False ] }, { 'type': 'string', 'format': 'email', 'minLength': 1 } ] },
'picture': { 'oneOf': [ { 'type': 'boolean', 'enum': [ False ] }, { 'type': 'string', 'minLength': 1 } ] },
'semester': { 'oneOf': [ { 'type': 'boolean', 'enum': [ False ] }, { 'type': 'integer', 'minimum': 0, 'exclusiveMinimum': False } ] },
'subjects': {
'type': 'array',
'uniqueItems': True,
'additionalItems': True,
'items': {
'type': 'object',
'properties': {
'code': { 'type': 'string' },
'action': { 'type': 'string', 'enum': [ 'add', 'rem' ] }
},
'required': [ 'code', 'action' ]
}
}
},
'required': [ 'name', 'email-address', 'picture', 'semester', 'subjects' ]
})
@method_decorator(csrf_protect)
@method_decorator(login_required)
# @method_decorator(role_required('administrator'))
def get(self, request, id = ''):
try: student = Student.objects.select_subclasses().get_active(user_id = id)
except Student.DoesNotExist:
return JsonResponse({ 'version': '0.1.0', 'status': 404 }, status = 404)
else:
# Serialize the student's full data and send the response
return JsonResponse({
'version': '0.1.0',
'status': 200,
'student': {
'id': student.user_id,
'name': student.full_name,
'email': student.email_address,
'picture': student.picture.url,
'created': mktime(student.date_registered.utctimetuple()),
'last-login': mktime(student.last_login.utctimetuple()) if student.last_login else False,
'curriculum': {
'program': student.program_id,
'semester': student.semester,
'current': [
{
'id': s.dependent_id,
'code': s.dependent.code,
'name': s.dependent.name
} for s in student.subjects
],
'candidate': [
{
'id': s.id,
'code': s.code,
'name': s.name
} for s in student.candidate_subjects
]
}
}
})
@method_decorator(csrf_protect)
@method_decorator(login_required)
# @method_decorator(role_required('administrator'))
def post(self, request, id = ''):
data = loads(request.body)
try:
StudentView.schema.validate(data)
student = Student.objects.select_subclasses().get_active(user_id = id)
# Apply the changes in a transaction since we may need to perform several updates at once
with atomic():
# Apply each update available
if data['name'] is not False: student.full_name = data['name']
if data['email-address'] is not False: student.email_address = data['email-address']
if data['semester'] is not False:
# Clear the progress - this is a destructive operation, ye have been warned
student.subjects.clear()
student.set_at_semester(data['semester'])
if data['picture'] is not False:
# In this case, "picture" points to the name of the form element which held the file (for flexibility at frontend)
if data['picture'] not in request.FILES:
return JsonResponse({ 'version': '0.1.0', 'status': 409 }, status = 409)
student.picture = request.FILES[data['picture']]
try:
program = student.program_id
for entry in data['subjects']:
# The subject works using a standard many-to-many relationship, so this is available
subject, action = Requirement.objects.get_active(program_id = program, dependent__code__iexact = entry['code']), entry['action']
if action == 'add': subject.subjects.add(subject)
elif action == 'rem': subject.subjects.remove(subject)
except Subject.DoesNotExist:
return JsonResponse({ 'version': '0.1.0', 'status': 404 }, status = 404)
# Commit the changes now, then serialize the updated student
student.save()
return JsonResponse({
'version': '0.1.0',
'status': 200,
'student': {
'id': student.user_id,
'name': student.full_name,
'email': student.email_address,
'picture': student.picture.url,
'created': mktime(student.date_registered.utctimetuple()),
'last-login': mktime(student.last_login.utctimetuple()) if student.last_login else False,
'curriculum': {
'program': student.program_id,
'semester': student.semester,
'current': [
{
'id': s.dependent_id,
'code': s.dependent.code,
'name': s.dependent.name
} for s in student.subjects
],
'candidate': [
{
'id': s.id,
'code': s.code,
'name': s.name
} for s in student.candidate_subjects
]
}
}
})
except Student.DoesNotExist:
return JsonResponse({ 'version': '0.1.0', 'status': 404 }, status = 404)
except ValidationError:
return JsonResponse({ 'version': '0.1.0', 'status': 403 }, status = 403)
@method_decorator(csrf_protect)
@method_decorator(login_required)
# @method_decorator(role_required('administrator'))
def delete(self, request, id = ''):
try: student = Student.objects.select_subclasses().get_active(user_id = id)
except Student.DoesNotExist:
return JsonResponse({ 'version': '0.1.0', 'status': 404 }, status = 404)
else:
# We use soft-delete here, so no need to worry
student.delete(soft = True)
return JsonResponse({ 'version': '0.1.0', 'status': 200 })
class StudentCreateView(View):
schema = Draft4Validator({
'$schema': 'http://json-schema.org/draft-04/schema#',
'type': 'object',
'properties': {
'id': { 'type': 'string' },
'general': {
'type': 'object',
'properties': {
'name': { 'type': 'string' },
'program': { 'type': 'string' },
'email-address': { 'type': 'string', 'format': 'email' }
},
'required': [ 'name', 'program', 'email-address' ]
},
'semester': { 'type': 'integer' }
},
'required': [ 'id', 'general', 'semester' ]
})
@method_decorator(csrf_protect)
@method_decorator(login_required)
# @method_decorator(role_required('administrator'))
def put(self, request):
data = loads(request.body)
try:
# First, validate the input data through a JSON schema
StudentCreateView.schema.validate(data)
# Check if this user is not a duplicate (enroll ID is ab-so-lute)
if Student.objects.active(user_id = data['id']).exists():
return JsonResponse({ 'version': '0.1.0', 'status': 409 }, status = 409)
program = AcademicProgram.objects.get(acronym__iexact = data['general']['program'])
# Create the student object
student = Student(
user_id = data['id'],
full_name = data['general']['name'],
email_address = data['general']['email-address'],
program = program,
role = Role.objects.get(codename = 'student')
)
# Set the base subjects for the student based on the semester
student.set_at_semester(data['semester'])
# Create a randomized password for the student for now (we will let them change it later on)
password = User.objects.make_random_password(12, allowed_chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789')
student.set_password(password)
student.save()
# Send an email to the user with his/her password, as it was randomly-generated
email = TemplateEmailMessage(
subject = _('Your password for Project Rhea'),
from_email = 'noreply@project_rhea.com',
to = [ student.email_address ],
context = RequestContext(request, {
'student': student,
'password': password
})
)
email.attach_from_template('rhea/email/new-enroll.txt', 'text/plain')
email.send()
return JsonResponse({
'version': '0.1.0',
'status': 201,
'email': email.send(fail_silently = True) == 1,
'student': {
'id': student.user_id,
'name': student.full_name,
'email': student.email_address,
'created': mktime(student.date_registered.utctimetuple())
}
}, status = 201)
except ValidationError:
return JsonResponse({ 'version': '0.1.0', 'status': 403 }, status = 403)
except AcademicProgram.DoesNotExist:
return JsonResponse({ 'version': '0.1.0', 'status': 404 }, status = 404)
def _construct_validator(self):
base_uri = 'file:' + helper.get_base_dir(self.version)
resolver = RefResolver(base_uri=base_uri, referrer={})
validator = Draft4Validator(self._schema, resolver=resolver)
return validator
% (len(errorsMap['schema-errors']), fn)
del errorsMap['schema-errors'][100:]
errorsMap['schema-errors'].append(str(len_error))
return errorsMap
@staticmethod
def getSchema(inputtype):
errorLog = list()
validSchema = None
if inputtype == 'NAMED_ENTITY':
try:
request_schema = requests.get('http://europepmc.org/docs/ne_annotation_schema.json')
ne_schemaObj = request_schema.json()
validSchema = Draft4Validator(ne_schemaObj, format_checker=FormatChecker())
except Exception, nescherr:
errorLog.append(repr(nescherr))
elif inputtype == 'SENTENCE':
try:
request_schema = requests.get('http://europepmc.org/docs/sentence_annotation_schema.json')
sent_schemaObj = request_schema.json()
validSchema = Draft4Validator(sent_schemaObj, format_checker=FormatChecker())
except Exception, sentscherr:
errorLog.append(repr(sentscherr))
return (validSchema, errorLog)
def create_trunk(path, output_mapper, content_reader):
ordered_files = _order_list_by_dots(content_reader.list_sql(path))
if len(ordered_files) == 0:
return None
trunk_map = _build_trunk_map_by_files(ordered_files)
config = content_reader.get_config(path, output_mapper)
input_model_str, output_model_str = "input.model", "output.model"
query_str, path_str, header_str, cookie_str, payload_str = "query", "path", "header", "cookie", "payload"
payload_schema, output_schema = None, None
query_schema, path_schema, header_schema, cookie_schema = None, None, None, None
if config:
input_model = config.get(input_model_str)
if input_model:
payload_schema = _to_lower_keys_deep(input_model.get(payload_str))
query_schema = _to_lower_keys_deep(input_model.get(query_str))
path_schema = _to_lower_keys_deep(input_model.get(path_str))
header_schema = _to_lower_keys_deep(input_model.get(header_str))
cookie_schema = _to_lower_keys_deep(input_model.get(cookie_str))
output_schema = config.get(output_model_str)
if not query_schema:
query_schema = {
"type": "object",
"properties": {}
}
if not path_schema:
path_schema = {
"type": "object",
"properties": {}
}
if not header_schema:
header_schema = {
"type": "object",
"properties": {}
}
if not cookie_schema:
cookie_schema = {
"type": "object",
"properties": {}
}
if not payload_schema:
payload_schema = {
"type": "object",
"properties": {}
}
if not output_schema:
output_schema = {
"type": "array",
"properties": {}
}
trunk = {
"name": "$",
"method": "$",
"path": path,
"model": {
"query": query_schema,
"path": path_schema,
"header": header_schema,
"cookie": cookie_schema,
"payload": payload_schema,
"output": output_schema
}
}
if payload_schema:
payload_validator = Draft4Validator(schema=payload_schema, format_checker=FormatChecker())
else:
payload_validator = None
if query_schema:
parameter_query_validator = Draft4Validator(schema=query_schema, format_checker=FormatChecker())
else:
parameter_query_validator = None
if path_schema:
parameter_path_validator = Draft4Validator(schema=path_schema, format_checker=FormatChecker())
else:
parameter_path_validator = None
if header_schema:
parameter_header_validator = Draft4Validator(schema=header_schema, format_checker=FormatChecker())
else:
parameter_header_validator = None
if cookie_schema:
parameter_cookie_validator = Draft4Validator(schema=cookie_schema, format_checker=FormatChecker())
else:
parameter_cookie_validator = None
bag = {}
_build_branch(trunk, trunk_map["$"], content_reader, payload_schema, output_schema, trunk["model"], bag)
trunk["connections"] = bag["connections"]
validators = {
"query": parameter_query_validator,
"path": parameter_path_validator,
"header": parameter_header_validator,
"cookie": parameter_cookie_validator,
"payload": payload_validator
}
trunk["_validators"] = validators
return trunk
def __init__(self, schemaformat):
#self.name = name
self.schema = schemaformat
checker = FormatChecker()
self.validator = Draft4Validator(self.schema, format_checker=checker)
class SubjectCreateView(View):
schema = Draft4Validator({
'$schema':
'http://json-schema.org/draft-04/schema#',
'definitions': {
'subject': {
'type': 'object',
'properties': {
'code': {
'type': 'string',
'minLength': 1,
'maxLength': 8
},
'name': {
'type': 'string',
'minLength': 1
},
'hours': {
'type': 'integer',
'multipleOf': 1,
'maximum': 10,
'minimum': 1,
'exclusiveMaximum': True,
'exclusiveMinimum': False
}
},
'required': ['code', 'name', 'hours']
}
},
'oneOf': [{
'type': 'array',
'items': {
'$ref': '#/definitions/subject'
}
}, {
'$ref': '#/definitions/subject'
}]
})
@method_decorator(csrf_protect)
@method_decorator(login_required)
# @method_decorator(role_required('administrator'))
def put(self, request):
data = loads(request.body)
try:
# Validate and normalize input for linear iteration
SubjectCreateView.schema.validate(data)
entries = [data] if isinstance(data, dict) else data
# Iterate over each entry, creating a new subject for each
subjects = []
for e in entries:
code, name, hours = e['code'], e['name'], e['hours']
if Subject.objects.active(code__iexact=code).exists():
raise ValueError('Subject with code "%s" already exists' %
code.upper())
subjects.append(
Subject.objects.create(code=code.upper(),
name=name,
hours=hours))
# Serialize and return response
return JsonResponse(
{
'version':
'0.1.0',
'status':
201,
'subjects': [{
'id': s.id,
'code': s.code,
'name': s.name,
'hours': s.hours
} for s in subjects]
},
status=201)
except ValueError:
return JsonResponse({
'version': '0.1.0',
'status': 409
},
status=409)
except ValidationError:
return JsonResponse({
'version': '0.1.0',
'status': 403
},
status=403)
def test_no_errors(self):
validator = Draft4Validator({})
self.assertIsNone(exceptions.best_match(validator.iter_errors({})))
def createCEDARjson(self, work_dir, json_dir, inv_identifier):
log.info("Converting ISA to CEDAR model for ".format(work_dir))
schema_file = "investigation_template.json"
with open(join(CEDAR_SCHEMA_PATH, schema_file)) as json_fp:
schema = json.load(json_fp)
if schema is None:
raise IOError("Could not load schema from {}".format(
join(CEDAR_SCHEMA_PATH, schema_file)))
resolver = RefResolver(
'file://' + join(CEDAR_SCHEMA_PATH, schema_file), schema)
validator = Draft4Validator(schema, resolver=resolver)
isa_tab = isatab_parser.parse(work_dir)
if isa_tab is None:
log.info("No ISAtab dataset found")
else:
if isa_tab.metadata != {}:
investigationObject = dict([
("@id",
"https://repo.metadatacenter.org/UUID/" + str(uuid4())),
("_templateId", "http://example.org"),
("@type",
"https://repo.metadatacenter.org/model/Investigation"),
("@context",
dict([
("description",
"https://metadatacenter.org/schemas/description"),
("title", "https://metadatacenter.org/schemas/title"),
("study", "https://metadatacenter.org/schemas/study"),
("submissionDate",
"https://metadatacenter.org/schemas/"
"submissionDate"),
("_value", "https://schema.org/value"),
("publicReleaseDate",
"https://metadatacenter.org/schemas/"
"publicReleaseDate"),
("identifier",
"https://metadatacenter.org/schemas/identifier")
])),
("title",
dict([("_value", isa_tab.metadata['Investigation Title'])
])),
("description",
dict([("_value",
isa_tab.metadata['Investigation Description'])])),
("identifier",
dict([("_value",
isa_tab.metadata['Investigation Identifier'])])),
("submissionDate",
dict([("_value",
isa_tab.metadata['Investigation Submission Date'])
])),
("publicReleaseDate",
dict([(
"_value",
isa_tab.metadata['Investigation Public Release Date'])
])),
("study", self.createStudiesList(isa_tab.studies))
])
else:
investigationObject = dict([
("@id",
"https://repo.metadatacenter.org/UUID" + str(uuid4())),
("_templateId", "http://example.org"),
("@type", "https://repo.metadatacenter.org/model/"
"Investigation"),
("@context",
dict([
("description",
"https://metadatacenter.org/schemas/description"),
("title", "https://metadatacenter.org/schemas/title"),
("study", "https://metadatacenter.org/schemas/study"),
("submissionDate",
"https://metadatacenter.org/schemas/"
"submissionDate"),
("_value", "https://schema.org/value"),
("publicReleaseDate",
"https://metadatacenter.org/schemas/"
"publicReleaseDate"),
("identifier",
"https://metadatacenter.org/schemas/identifier")
])),
("title", dict([("_value", "")])),
("description", dict([("_value", "")])),
("identifier", dict([("_value", "")])),
("submissionDate", dict([("_value", "")])),
("publicReleaseDate", dict([("_value", "")])),
("study", self.createStudiesList(isa_tab.studies)),
])
cedar_json = investigationObject
try:
investigation_identifier = \
isa_tab.metadata['Investigation Identifier']
except KeyError:
investigation_identifier = ""
try:
study_identifier = \
isa_tab.studies[0].metadata['Study Identifier']
except KeyError:
study_identifier = ""
try:
validator.validate(cedar_json, schema)
except ValidationError as e:
error_file_name = os.path.join(json_dir, "error.log")
with open(error_file_name, "w") as errorfile:
errorfile.write(e.message)
errorfile.write(e.cause)
errorfile.close()
if inv_identifier:
file_name = os.path.join(json_dir,
investigation_identifier + ".json")
else:
file_name = os.path.join(json_dir, study_identifier + ".json")
with open(file_name, "w") as outfile:
json.dump(cedar_json, outfile, indent=4, sort_keys=True)
outfile.close()
log.info("... conversion finished.")
"ERROR: mergedfile not found. Cannot continue.")
raise
# exit(1)
except simplejson.scanner.JSONDecodeError:
logging.critical(
"ERROR: mergedfile is not parsing properly. Cannot continue."
)
raise
# exit(1)
# removed schema joining. If you need a merged schema, use mergeSchema.py to generate one. - gdb 061416
else:
IOError("ERROR: mergedfile not found. Cannot continue.")
# exit(1)
# Create validator
validator = Draft4Validator(schema)
# data_paths = []
# if args.path:
# data_paths = args.path
# else: # only use config option if nothing is specified on the command line
# try:
# path_to_parse = cfg.get('input')
# data_paths = path_to_parse.strip().split('\n')
# except ConfigParser.Error:
# logging.warning("No path specified in config file. Using default")
# data_paths = ['.']
# pass
# if "input" in cfg:
# cfg["input"] = [l.strip() for l in cfg["input"].split(" ,")] # spit to list
from flask import jsonify, request
import json as JSON
import jsonschema
from jsonschema import Draft4Validator
import os
from zerorobot import config
from zerorobot.server import auth
dir_path = os.path.dirname(os.path.realpath(__file__))
WebHook_schema = JSON.load(open(dir_path + '/schema/WebHook_schema.json'))
WebHook_schema_resolver = jsonschema.RefResolver('file://' + dir_path + '/schema/', WebHook_schema)
WebHook_schema_validator = Draft4Validator(WebHook_schema, resolver=WebHook_schema_resolver)
@auth.admin.login_required
def AddWebHookHandler():
inputs = request.get_json()
try:
WebHook_schema_validator.validate(inputs)
except jsonschema.ValidationError as e:
return jsonify(code=400, message="bad request body"), 400
webhooks = config.webhooks
webhook = webhooks.add(inputs['url'], inputs['kind'])
}]
}
}
# Mitre want newlines and excess spaces stripped
desc = re.sub('[\n ]+', ' ', desc)
cve['description'] = {"description_data": [{"lang": "eng", "value": desc}]}
cvej.append(cve)
for issue in cvej:
fn = issue['CVE_data_meta']['ID'] + ".json"
if not issue:
continue
f = codecs.open(options.outputdir + "/" + fn, 'w', 'utf-8')
f.write(json.dumps(issue, sort_keys=True, indent=4,
separators=(',', ': ')))
print(f'wrote {options.outputdir+"/"+fn}')
f.close()
try:
validate(issue, schema_doc)
print(f'{fn} passed validation')
except jsonschema.exceptions.ValidationError as incorrect:
v = Draft4Validator(schema_doc)
errors = sorted(v.iter_errors(issue), key=lambda e: e.path)
for error in errors:
print(f'{fn} did not pass validation: {str(error.message)}')
except NameError:
print(f'{fn} skipping validation, no schema defined')
from datetime import datetime
import jsonschema
from jsonschema import Draft4Validator
from flask import jsonify, request
from ..models import NodeRegistration, Resources
from .jwt import FarmerInvalid, validate_farmer_id
dir_path = os.path.dirname(os.path.realpath(__file__))
ReservedCapacity_schema = JSON.load(
open(dir_path + '/schema/ReservedCapacity_schema.json'))
ReservedCapacity_schema_resolver = jsonschema.RefResolver(
'file://' + dir_path + '/schema/', ReservedCapacity_schema)
ReservedCapacity_schema_validator = Draft4Validator(
ReservedCapacity_schema, resolver=ReservedCapacity_schema_resolver)
def UpdateReservedCapacityHandler(node_id):
inputs = request.get_json()
try:
ReservedCapacity_schema_validator.validate(inputs)
except jsonschema.ValidationError as e:
return jsonify(errors="bad request body"), 400
capacity = NodeRegistration.get(node_id)
if capacity.reserved_resources is None:
capacity.reserved_resources = Resources()
def validate_instance(path, filename, schema_filename, error_printing):
"""
:param path:
:param filename:
:param schema_filename:
:param error_printing:
:return:
"""
try:
schema_file = open(join(DATS_schemasPath, schema_filename))
schema = json.load(schema_file)
schemastore = get_schemas_store(DATS_schemasPath)
print(schemastore)
store = {schema['id']: schema}
resolver = RefResolver(base_uri='file://' + DATS_schemasPath + '/' +
schema_filename,
referrer=schema,
store=store)
validator = Draft4Validator(schema,
resolver=resolver,
format_checker=FormatChecker())
logger.info("Validating %s against %s ", filename, schema_filename)
try:
instance_file = open(join(path, filename))
instance = json.load(instance_file)
if error_printing:
errors = sorted(validator.iter_errors(instance),
key=lambda e: e.path)
for error in errors:
print(error.message)
if len(errors) == 0:
return True
else:
return False
elif error_printing == 0:
errors = sorted(validator.iter_errors(instance),
key=lambda e: e.path)
for error in errors:
for suberror in sorted(error.context,
key=lambda e: e.schema_path):
print(list(suberror.schema_path), suberror.message)
if len(errors) == 0:
logger.info("...done")
return True
else:
return False
else:
try:
validator.validate(instance, schema)
logger.info("...done")
return True
except Exception as e:
logger.error(e)
return False
except IOError as ioe:
print(ioe)
# finally:
# instance_file.close()
except IOError as ioe2:
print(ioe2)
finally:
schema_file.close()
def validate(json_to_validate, schema):
validator = Draft4Validator(schema, format_checker=format_checker)
errors = list(validator.iter_errors(json_to_validate))
if errors.__len__() > 0:
raise ValidationError(build_error_message(errors))
return json_to_validate
def validate(cls, data):
errors = ErrorTree(Draft4Validator(
cls.schema).iter_errors(data)).errors
if errors:
raise HTTPException(400, msg=str(errors))
return data
from jsonschema import Draft4Validator, RefResolver
from issues_geometry.schemata import GEOJSON_GEOMETRY_SCHEMA, GEOJSON_SCHEMA
class LocalRefResolver(RefResolver):
def resolve_remote(self, uri): # pragma: no cover
# (this should never happen)
raise NotImplementedError("remote refs not supported (uri: %s)" % uri)
Draft4Validator.check_schema(GEOJSON_SCHEMA)
Draft4Validator.check_schema(GEOJSON_GEOMETRY_SCHEMA)
resolver = LocalRefResolver.from_schema(GEOJSON_SCHEMA)
resolver.store[GEOJSON_GEOMETRY_SCHEMA['id']] = GEOJSON_GEOMETRY_SCHEMA
GeoJSONValidator = Draft4Validator(schema=GEOJSON_SCHEMA, resolver=resolver)
def validate():
result = best_match(
Draft4Validator(Verification.conSchema,
format_checker=FormatChecker()).iter_errors(
Verification.constants))
if result:
index_range = len(list(result.schema_path))
if index_range > 4:
print("FAILURE: " + list(result.schema_path)[4],
result.message,
sep=", ")
return False
elif index_range == 4:
print("FAILURE: " + list(result.schema_path)[3],
result.message,
sep=", ")
return False
elif index_range == 3:
print("FAILURE: " + list(result.schema_path)[2],
result.message,
sep=", ")
return False
elif index_range == 2:
print("FAILURE: " + list(result.schema_path)[1],
result.message,
sep=", ")
return False
else:
print("FAILURE: " + list(result.schema_path)[0],
result.message,
sep=", ")
return False
else:
servo_lists = [
value["servo_list"]
for (key,
value) in Verification.constants['components'].items()
]
motor_lists = [
value["motor_list"]
for (key,
value) in Verification.constants['components'].items()
]
servo_pins = [
value["pin"] for group in servo_lists
for (key, value) in group.items()
]
motor_pins = [
value["pin"] for group in motor_lists
for (key, value) in group.items()
]
if len(servo_pins + motor_pins) == len(set(servo_pins +
motor_pins)):
for (key,
value) in Verification.constants['components'].items():
servo_schemes = [
value["color_scheme"]
for (key, value) in value["servo_list"].items()
]
motor_schemes = [
value["color_scheme"]
for (key, value) in value["motor_list"].items()
]
if not len(servo_schemes + motor_schemes) == len(
set(servo_schemes + motor_schemes)):
print(
"FAILURE: Multiple use of a color-scheme in one component."
)
return False
print("Validation of 'constants.json' was successful.")
return True
else:
print("FAILURE: Pins are double used.")
return False
def validate(json_to_validate, schema):
validator = Draft4Validator(schema)
validator.validate(json_to_validate, schema)
"properties": {
"header": header_part,
"parent_header": header_part,
"metadata": {
"type": "object"
},
"content": {
"type": "object"
}, # Checked separately
"buffers": {
"type": "array"
}
},
"required": ["header", "parent_header", "metadata", "content"],
}
msg_structure_validator = Draft4Validator(msg_schema)
def get_error_reply_validator(version_minor):
return Draft4Validator({
"$schema":
"http://json-schema.org/draft-04/schema#",
"description":
"Jupyter 'error' reply schema",
"type":
"object",
"properties": {
"status": {
"const": "error"
},
"ename": {
self._topic_validator_dict[topic_id] = validator_to_use
else:
#如果校验器存在该主题ID而主题管理器没有,则说明是删除的
if not self._topic_manager.topic_dict.has_key(reload_id):
if self._topic_validator_dict.has_key(reload_id):
del self._topic_validator_dict[reload_id]
else:
validator_to_use = None
try:
schema_obj = self._topic_manager.topic_dict[reload_id][
'schema_obj']
Draft4Validator.check_schema(schema_obj)
validator_to_use = Draft4Validator(
schema_obj,
resolver=RefResolver.from_schema(
schema_obj,
handlers={
'haizhi': self._haizhi_ref_resolver.resolve_url
}))
log.info(
'JsonSchemaValidator.init: Schema loaded successfully! topic.id[%s], topic.name[%s]'
% (reload_id, self._topic_manager.topic_dict[reload_id]
['name'].encode('utf8')))
except jsonschema.SchemaError, se:
validator_to_use = AlwaysFailValidator(
reason=
'Schema is invalid!! topic.id[%s], topic.name[%s]' %
(reload_id, self._topic_manager.topic_dict[reload_id]))
# TODO: 这里是否应该继续抛出异常, 使得程序退出?
