def update(self, id):
"""Update a keyboard and return it.
:URL: ``PUT /keyboards/id``
:Request body: JSON object representing the keyboard with updated
attribute values.
:param str id: the ``id`` value of the keyboard to be updated.
:returns: the updated keyboard model.
"""
keyboard = Session.query(Keyboard).get(int(id))
if keyboard:
try:
schema = KeyboardSchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.id = id
data = schema.to_python(values, state)
keyboard = update_keyboard(keyboard, data)
# keyboard will be False if there are no changes (cf.
# update_keyboard).
if keyboard:
Session.add(keyboard)
Session.commit()
return keyboard
else:
response.status_int = 400
return {'error': (u'The update request failed because the'
u' submitted data were not new.')}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def create(self):
"""Create a new user resource and return it.
:URL: ``POST /users``
:request body: JSON object representing the user to create.
:returns: the newly created user.
.. note::
Only administrators are authorized to create users.
"""
try:
schema = UserSchema()
values = json.loads(unicode(request.body, request.charset))
data = schema.to_python(values)
user = create_new_user(data)
Session.add(user)
Session.commit()
return user.get_full_dict()
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def update(self, id):
"""Update a page and return it.
:URL: ``PUT /pages/id``
:Request body: JSON object representing the page with updated attribute values.
:param str id: the ``id`` value of the page to be updated.
:returns: the updated page model.
"""
page = Session.query(Page).get(int(id))
if page:
try:
schema = PageSchema()
values = json.loads(unicode(request.body, request.charset))
data = schema.to_python(values)
page = update_page(page, data)
# page will be False if there are no changes (cf. update_page).
if page:
Session.add(page)
Session.commit()
return page
else:
response.status_int = 400
return {'error':
u'The update request failed because the submitted data were not new.'}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def createForm(i, commit=False):
f = model.Form()
f.transcription = u'transcription'
g1 = model.Gloss()
g1.gloss = u'gloss'
f.glosses.append(g1)
if i % 2 == 0:
g2 = model.Gloss()
g2.gloss = u'gloss'
f.glosses.append(g2)
u = model.User()
u.name = u'name'
f.elicitor = u
if i % 3 == 0:
f1 = model.File()
f1.filename = u'file%s-1.wav' % str(i)
f2 = model.File()
f2.filename = u'file%s-2.wav' % str(i)
f3 = model.File()
f3.filename = u'file%s-3.wav' % str(i)
f.files = [f1, f2, f3]
Session.add(f)
if commit:
Session.commit()
return f
def _create_test_form_searches(n=100):
"""Create n form searches with various properties. A testing ground for searches!
"""
users = h.get_users()
contributor = [u for u in users if u.role == u'contributor'][0]
for i in range(1, n + 1):
fs = model.FormSearch()
fs.enterer_id = contributor.id
fs.search = unicode(json.dumps(
{'query': {'filter': ['Form', 'transcription', 'regex', '%d' % i]}}))
if i % 2 == 0:
fs.name = u'Form Search %d' % i
else:
fs.name = u'form search %d' % i
if i > 50:
fs.description = u'I really like this search and my favourite number is %d' % i
if i > 20:
fs.datetime_modified = today_timestamp
else:
fs.datetime_modified = yesterday_timestamp
Session.add(fs)
Session.commit()
def update(self, id):
"""Update a user and return it.
:URL: ``PUT /users/id``
:Request body: JSON object representing the user with updated attribute values.
:param str id: the ``id`` value of the user to be updated.
:returns: the updated user model.
"""
user = Session.query(User).get(int(id))
if user:
try:
schema = UserSchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.user_to_update = user.get_full_dict()
current_user = Session.query(User).get(session['user'].id)
state.user = current_user.get_full_dict()
data = schema.to_python(values, state)
user = update_user(user, data)
# user will be False if there are no changes (cf. update_user).
if user:
Session.add(user)
Session.commit()
return user.get_full_dict()
else:
response.status_int = 400
return {'error':
u'The update request failed because the submitted data were not new.'}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def update(self, id):
"""Update a morpheme language model and return it.
:URL: ``PUT /morphemelanguagemodels/id``
:Request body: JSON object representing the morpheme language model with updated attribute values.
:param str id: the ``id`` value of the morpheme language model to be updated.
:returns: the updated morpheme language model model.
"""
morpheme_language_model = h.eagerload_morpheme_language_model(Session.query(MorphemeLanguageModel)).get(int(id))
if morpheme_language_model:
try:
schema = MorphemeLanguageModelSchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.id = id
data = schema.to_python(values, state)
morpheme_language_model_dict = morpheme_language_model.get_dict()
morpheme_language_model = update_morpheme_language_model(morpheme_language_model, data)
# morpheme_language_model will be False if there are no changes (cf. update_morpheme_language_model).
if morpheme_language_model:
backup_morpheme_language_model(morpheme_language_model_dict)
Session.add(morpheme_language_model)
Session.commit()
return morpheme_language_model
else:
response.status_int = 400
return {'error': u'The update request failed because the submitted data were not new.'}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def create(self):
"""Create a new collection resource and return it.
:URL: ``POST /collections``
:request body: JSON object representing the collection to create.
:returns: the newly created collection.
"""
try:
unrestricted_users = h.get_unrestricted_users()
user = session['user']
schema = CollectionSchema()
values = json.loads(unicode(request.body, request.charset))
collections_referenced = get_collections_referenced(values['contents'],
user, unrestricted_users)
values = add_contents_unpacked_to_values(values, collections_referenced)
values = add_form_ids_list_to_values(values)
state = h.get_state_object(values)
data = schema.to_python(values, state)
collection = create_new_collection(data, collections_referenced)
Session.add(collection)
Session.commit()
return collection.get_full_dict()
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except InvalidCollectionReferenceError, e:
response.status_int = 400
return {'error': u'Invalid collection reference error: there is no collection with id %d' % e.args[0]}
def create(self):
"""Create a new user resource and return it.
:URL: ``POST /users``
:request body: JSON object representing the user to create.
:returns: the newly created user.
.. note::
Only administrators are authorized to create users.
"""
try:
schema = UserSchema()
values = json.loads(unicode(request.body, request.charset))
data = schema.to_python(values)
user = create_new_user(data)
Session.add(user)
Session.commit()
return user.get_full_dict()
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def update(self, id):
"""Update a speaker and return it.
:URL: ``PUT /speakers/id``
:Request body: JSON object representing the speaker with updated attribute values.
:param str id: the ``id`` value of the speaker to be updated.
:returns: the updated speaker model.
"""
speaker = Session.query(Speaker).get(int(id))
if speaker:
try:
schema = SpeakerSchema()
values = json.loads(unicode(request.body, request.charset))
data = schema.to_python(values)
speaker = update_speaker(speaker, data)
# speaker will be False if there are no changes (cf. update_speaker).
if speaker:
Session.add(speaker)
Session.commit()
return speaker
else:
response.status_int = 400
return {'error':
u'The update request failed because the submitted data were not new.'}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def create(self):
"""Create a new collection resource and return it.
:URL: ``POST /collections``
:request body: JSON object representing the collection to create.
:returns: the newly created collection.
"""
try:
unrestricted_users = h.get_unrestricted_users()
user = session['user']
schema = CollectionSchema()
values = json.loads(unicode(request.body, request.charset))
collections_referenced = get_collections_referenced(
values['contents'], user, unrestricted_users)
values = add_contents_unpacked_to_values(values,
collections_referenced)
values = add_form_ids_list_to_values(values)
state = h.get_state_object(values)
data = schema.to_python(values, state)
collection = create_new_collection(data, collections_referenced)
Session.add(collection)
Session.commit()
return collection.get_full_dict()
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except InvalidCollectionReferenceError, e:
response.status_int = 400
return {
'error':
u'Invalid collection reference error: there is no collection with id %d'
% e.args[0]
}
def update(self, id):
"""Update an elicitation method and return it.
:URL: ``PUT /elicitationmethods/id``
:Request body: JSON object representing the elicitation method with updated attribute values.
:param str id: the ``id`` value of the elicitation method to be updated.
:returns: the updated elicitation method model.
"""
elicitation_method = Session.query(ElicitationMethod).get(int(id))
if elicitation_method:
try:
schema = ElicitationMethodSchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.id = id
data = schema.to_python(values, state)
elicitation_method = update_elicitation_method(elicitation_method, data)
# elicitation_method will be False if there are no changes (cf. update_elicitation_method).
if elicitation_method:
Session.add(elicitation_method)
Session.commit()
return elicitation_method
else:
response.status_int = 400
return {'error':
u'The update request failed because the submitted data were not new.'}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def update(self, id):
"""Update an application settings and return it.
:URL: ``PUT /applicationsettings/id``
:Request body: JSON object representing the application settings with updated attribute values.
:param str id: the ``id`` value of the application settings to be updated.
:returns: the updated application settings model.
"""
application_settings = h.eagerload_application_settings(
Session.query(ApplicationSettings)).get(int(id))
if application_settings:
try:
schema = ApplicationSettingsSchema()
values = json.loads(unicode(request.body, request.charset))
data = schema.to_python(values)
# Try to create an updated ApplicationSetting object.
application_settings = update_application_settings(application_settings, data)
# application_settings will be False if there are no changes
if application_settings:
Session.add(application_settings)
Session.commit()
app_globals.application_settings = h.ApplicationSettings()
return application_settings
else:
response.status_int = 400
return {'error': 'The update request failed because the submitted data were not new.'}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def createForm(i, commit=False):
f = model.Form()
f.transcription = u'transcription'
g1 = model.Gloss()
g1.gloss = u'gloss'
f.glosses.append(g1)
if i % 2 == 0:
g2 = model.Gloss()
g2.gloss = u'gloss'
f.glosses.append(g2)
u = model.User()
u.name = u'name'
f.elicitor = u
if i % 3 == 0:
f1 = model.File()
f1.filename = u'file%s-1.wav' % str(i)
f2 = model.File()
f2.filename = u'file%s-2.wav' % str(i)
f3 = model.File()
f3.filename = u'file%s-3.wav' % str(i)
f.files = [f1, f2, f3]
Session.add(f)
if commit:
Session.commit()
return f
def _create_test_form_searches(n=100):
"""Create n form searches with various properties. A testing ground for searches!
"""
users = h.get_users()
contributor = [u for u in users if u.role == u'contributor'][0]
for i in range(1, n + 1):
fs = model.FormSearch()
fs.enterer_id = contributor.id
fs.search = unicode(
json.dumps({
'query': {
'filter': ['Form', 'transcription', 'regex',
'%d' % i]
}
}))
if i % 2 == 0:
fs.name = u'Form Search %d' % i
else:
fs.name = u'form search %d' % i
if i > 50:
fs.description = u'I really like this search and my favourite number is %d' % i
if i > 20:
fs.datetime_modified = today_timestamp
else:
fs.datetime_modified = yesterday_timestamp
Session.add(fs)
Session.commit()
def update_collection_by_deletion_of_referenced_form(collection,
referenced_form):
"""Update a collection based on the deletion of a form it references.
This function is called in the :class:`FormsController` when a form is
deleted. It is called on each collection that references the deleted form
and the changes to each of those collections are propagated through all of
the collections that reference them, and so on.
:param collection: a collection model object.
:param referenced_form: a form model object.
:returns: ``None``.
"""
collection_dict = collection.get_full_dict()
collection.contents = remove_references_to_this_form(
collection.contents, referenced_form.id)
collections_referenced = get_collections_referenced(collection.contents)
collection.contents_unpacked = generate_contents_unpacked(
collection.contents, collections_referenced)
collection.html = h.get_HTML_from_contents(collection.contents_unpacked,
collection.markup_language)
collection.datetime_modified = datetime.datetime.utcnow()
backup_collection(collection_dict)
update_collections_that_reference_this_collection(
collection,
OldcollectionsController.query_builder,
contents_changed=True)
Session.add(collection)
Session.commit()
def update(self, id):
"""Update a source and return it.
:URL: ``PUT /sources/id``
:Request body: JSON object representing the source with updated attribute values.
:param str id: the ``id`` value of the source to be updated.
:returns: the updated source model.
"""
source = Session.query(Source).get(int(id))
if source:
try:
schema = SourceSchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.id = id
data = schema.to_python(values, state)
source = update_source(source, data)
# source will be False if there are no changes (cf. update_source).
if source:
Session.add(source)
Session.commit()
return source
else:
response.status_int = 400
return {'error':
u'The update request failed because the submitted data were not new.'}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def create(self):
"""Create a new corpus resource and return it.
:URL: ``POST /corpora``
:request body: JSON object representing the corpus to create.
:returns: the newly created corpus.
"""
try:
schema = CorpusSchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.config = config
data = schema.to_python(values, state)
corpus = create_new_corpus(data)
Session.add(corpus)
Session.commit()
create_corpus_dir(corpus)
return corpus
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def update(self, id):
"""Update a syntactic category and return it.
:URL: ``PUT /syntacticcategorys/id``
:Request body: JSON object representing the syntactic category with updated attribute values.
:param str id: the ``id`` value of the syntactic category to be updated.
:returns: the updated syntactic category model.
"""
syntactic_category = Session.query(SyntacticCategory).get(int(id))
if syntactic_category:
try:
old_name = syntactic_category.name
schema = SyntacticCategorySchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.id = id
data = schema.to_python(values, state)
syntactic_category = update_syntactic_category(syntactic_category, data)
# syntactic_category will be False if there are no changes (cf. update_syntactic_category).
if syntactic_category:
Session.add(syntactic_category)
Session.commit()
if syntactic_category.name != old_name:
update_forms_referencing_this_category(syntactic_category)
return syntactic_category
else:
response.status_int = 400
return {"error": u"The update request failed because the submitted data were not new."}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {"errors": e.unpack_errors()}
def update(self, id):
"""Update a form search and return it.
:URL: ``PUT /formsearches/id``
:Request body: JSON object representing the form search with updated
attribute values.
:param str id: the ``id`` value of the form search to be updated.
:returns: the updated form search model.
"""
form_search = h.eagerload_form_search(Session.query(FormSearch)).get(int(id))
if form_search:
try:
schema = FormSearchSchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.id = id
state.config = config
data = schema.to_python(values, state)
form_search = update_form_search(form_search, data)
# form_search will be False if there are no changes (cf. update_form_search).
if form_search:
Session.add(form_search)
Session.commit()
return form_search
else:
response.status_int = 400
return {'error':
u'The update request failed because the submitted data were not new.'}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def update(self, id):
"""Update a tag and return it.
:URL: ``PUT /tags/id``
:Request body: JSON object representing the tag with updated attribute values.
:param str id: the ``id`` value of the tag to be updated.
:returns: the updated tag model.
"""
tag = Session.query(Tag).get(int(id))
if tag:
try:
schema = TagSchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.id = id
data = schema.to_python(values, state)
tag = update_tag(tag, data)
# tag will be False if there are no changes (cf. update_tag).
if tag:
Session.add(tag)
Session.commit()
return tag
else:
response.status_int = 400
return {'error':
u'The update request failed because the submitted data were not new.'}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def create(self):
"""Create a new corpus resource and return it.
:URL: ``POST /corpora``
:request body: JSON object representing the corpus to create.
:returns: the newly created corpus.
"""
try:
schema = CorpusSchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.config = config
data = schema.to_python(values, state)
corpus = create_new_corpus(data)
Session.add(corpus)
Session.commit()
create_corpus_dir(corpus)
return corpus
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def update_collection_by_deletion_of_referenced_form(collection, referenced_form):
"""Update a collection based on the deletion of a form it references.
This function is called in the :class:`FormsController` when a form is
deleted. It is called on each collection that references the deleted form
and the changes to each of those collections are propagated through all of
the collections that reference them, and so on.
:param collection: a collection model object.
:param referenced_form: a form model object.
:returns: ``None``.
"""
collection_dict = collection.get_full_dict()
collection.contents = remove_references_to_this_form(collection.contents, referenced_form.id)
collections_referenced = get_collections_referenced(collection.contents)
collection.contents_unpacked = generate_contents_unpacked(
collection.contents, collections_referenced)
collection.html = h.get_HTML_from_contents(collection.contents_unpacked,
collection.markup_language)
collection.datetime_modified = datetime.datetime.utcnow()
backup_collection(collection_dict)
update_collections_that_reference_this_collection(
collection, OldcollectionsController.query_builder, contents_changed=True)
Session.add(collection)
Session.commit()
def add_default_application_settings():
"""Add the default application settings to the database."""
orthography1 = h.generate_default_orthography1()
orthography2 = h.generate_default_orthography2()
contributor = Session.query(User).filter(User.role==u'contributor').first()
application_settings = h.generate_default_application_settings([orthography1, orthography2], [contributor])
Session.add(application_settings)
Session.commit()
return application_settings
def backup_collection(collection_dict):
"""Backup a collection.
:param dict form_dict: a representation of a collection model.
:returns: ``None``
"""
collection_backup = CollectionBackup()
collection_backup.vivify(collection_dict)
Session.add(collection_backup)
def backup_morphology(morphology_dict):
"""Backup a morphology.
:param dict morphology_dict: a representation of a morphology model.
:returns: ``None``
"""
morphology_backup = MorphologyBackup()
morphology_backup.vivify(morphology_dict)
Session.add(morphology_backup)
def backup_corpus(corpus_dict):
"""Backup a corpus.
:param dict corpus_dict: a representation of a corpus model.
:returns: ``None``
"""
corpus_backup = CorpusBackup()
corpus_backup.vivify(corpus_dict)
Session.add(corpus_backup)
def backup_morphological_parser(morphological_parser_dict):
"""Backup a morphological parser.
:param dict morphological_parser_dict: a representation of a morphological parser model.
:returns: ``None``
"""
morphological_parser_backup = MorphologicalParserBackup()
morphological_parser_backup.vivify(morphological_parser_dict)
Session.add(morphological_parser_backup)
def backup_morphological_parser(morphological_parser_dict):
"""Backup a morphological parser.
:param dict morphological_parser_dict: a representation of a morphological parser model.
:returns: ``None``
"""
morphological_parser_backup = MorphologicalParserBackup()
morphological_parser_backup.vivify(morphological_parser_dict)
Session.add(morphological_parser_backup)
def backup_corpus(corpus_dict):
"""Backup a corpus.
:param dict corpus_dict: a representation of a corpus model.
:returns: ``None``
"""
corpus_backup = CorpusBackup()
corpus_backup.vivify(corpus_dict)
Session.add(corpus_backup)
def backup_morpheme_language_model(morpheme_language_model_dict):
"""Backup a morpheme language model.
:param dict morpheme_language_model_dict: a representation of a morpheme language model model.
:returns: ``None``
"""
morpheme_language_model_backup = MorphemeLanguageModelBackup()
morpheme_language_model_backup.vivify(morpheme_language_model_dict)
Session.add(morpheme_language_model_backup)
def backup_collection(collection_dict):
"""Backup a collection.
:param dict form_dict: a representation of a collection model.
:returns: ``None``
"""
collection_backup = CollectionBackup()
collection_backup.vivify(collection_dict)
Session.add(collection_backup)
def backup_morpheme_language_model(morpheme_language_model_dict):
"""Backup a morpheme language model.
:param dict morpheme_language_model_dict: a representation of a morpheme language model model.
:returns: ``None``
"""
morpheme_language_model_backup = MorphemeLanguageModelBackup()
morpheme_language_model_backup.vivify(morpheme_language_model_dict)
Session.add(morpheme_language_model_backup)
def backup_phonology(phonology_dict):
"""Backup a phonology.
:param dict phonology_dict: a representation of a phonology model.
:returns: ``None``
"""
phonology_backup = PhonologyBackup()
phonology_backup.vivify(phonology_dict)
Session.add(phonology_backup)
def _create_test_models(n=100):
_add_test_models_to_session('Tag', n, ['name'])
_add_test_models_to_session('Speaker', n, ['first_name', 'last_name', 'dialect'])
_add_test_models_to_session('Source', n, ['author_first_name', 'author_last_name',
'title'])
_add_test_models_to_session('ElicitationMethod', n, ['name'])
_add_test_models_to_session('SyntacticCategory', n, ['name'])
_add_test_models_to_session('File', n, ['name'])
restricted_tag = h.generate_restricted_tag()
Session.add(restricted_tag)
Session.commit()
def _create_test_models(n=100):
_add_test_models_to_session('Tag', n, ['name'])
_add_test_models_to_session('Speaker', n,
['first_name', 'last_name', 'dialect'])
_add_test_models_to_session(
'Source', n, ['author_first_name', 'author_last_name', 'title'])
_add_test_models_to_session('ElicitationMethod', n, ['name'])
_add_test_models_to_session('SyntacticCategory', n, ['name'])
_add_test_models_to_session('File', n, ['name'])
restricted_tag = h.generate_restricted_tag()
Session.add(restricted_tag)
Session.commit()
def update(self, id):
"""Update a collection and return it.
:URL: ``PUT /collections/id``
:Request body: JSON object representing the collection with updated attribute values.
:param str id: the ``id`` value of the collection to be updated.
:returns: the updated collection model.
"""
collection = h.eagerload_collection(Session.query(Collection),
eagerload_forms=True).get(int(id))
if collection:
unrestricted_users = h.get_unrestricted_users()
user = session['user']
if h.user_is_authorized_to_access_model(user, collection, unrestricted_users):
try:
schema = CollectionSchema()
values = json.loads(unicode(request.body, request.charset))
collections_referenced = get_collections_referenced(
values['contents'], user, unrestricted_users, id)
values = add_contents_unpacked_to_values(values, collections_referenced)
values = add_form_ids_list_to_values(values)
state = h.get_state_object(values)
data = schema.to_python(values, state)
collection_dict = collection.get_full_dict()
collection, restricted, contents_changed = update_collection(
collection, data, collections_referenced)
# collection will be False if there are no changes (cf. update_collection).
if collection:
backup_collection(collection_dict)
update_collections_that_reference_this_collection(collection, self.query_builder,
restricted=restricted, contents_changed=contents_changed)
Session.add(collection)
Session.commit()
return collection.get_full_dict()
else:
response.status_int = 400
return {'error':
u'The update request failed because the submitted data were not new.'}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except CircularCollectionReferenceError, e:
response.status_int = 400
return {'error':
u'Circular collection reference error: collection %d references collection %d.' % (id, e.args[0])}
except InvalidCollectionReferenceError, e:
response.status_int = 400
return {'error': u'Invalid collection reference error: there is no collection with id %d' % e.args[0]}
except UnauthorizedCollectionReferenceError:
response.status_int = 403
return {'error': u'Unauthorized collection reference error: you are not authorized to access collection %d' % e.args[0]}
def createCollection(i, forms=None, commit=False):
c = model.Collection()
c.title = u'title'
if i % 3 == 0:
c.forms = forms
elif i % 2 == 0:
c.forms = forms[::3]
else:
c.forms = forms[:10]
Session.add(c)
if commit:
Session.commit()
return c
def createCollection(i, forms=None, commit=False):
c = model.Collection()
c.title = u'title'
if i % 3 == 0:
c.forms = forms
elif i % 2 == 0:
c.forms = forms[::3]
else:
c.forms = forms[:10]
Session.add(c)
if commit:
Session.commit()
return c
def update(self, id):
"""Update an orthography and return it.
:URL: ``PUT /orthographies/id``
:Request body: JSON object representing the orthography with updated attribute values.
:param str id: the ``id`` value of the orthography to be updated.
:returns: the updated orthography model.
.. note::
Contributors can only update orthographies that are not used in the
active application settings.
"""
orthography = Session.query(Orthography).get(int(id))
user = session['user']
if orthography:
app_set = h.get_application_settings()
if user.role == u'administrator' or orthography not in (
app_set.storage_orthography, app_set.input_orthography,
app_set.output_orthography):
try:
schema = OrthographySchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.id = id
result = schema.to_python(values, state)
orthography = update_orthography(orthography, result)
# orthography will be False if there are no changes (cf. update_orthography).
if orthography:
Session.add(orthography)
Session.commit()
return orthography
else:
response.status_int = 400
return {
'error':
u'The update request failed because the submitted data were not new.'
}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
else:
response.status = 403
return {
'error':
u'Only administrators are permitted to update orthographies that are used in the active application settings.'
}
def update(self, id):
"""Update an orthography and return it.
:URL: ``PUT /orthographies/id``
:Request body: JSON object representing the orthography with updated attribute values.
:param str id: the ``id`` value of the orthography to be updated.
:returns: the updated orthography model.
.. note::
Contributors can only update orthographies that are not used in the
active application settings.
"""
orthography = Session.query(Orthography).get(int(id))
user = session['user']
if orthography:
app_set = h.get_application_settings()
if user.role == u'administrator' or orthography not in (
app_set.storage_orthography, app_set.input_orthography, app_set.output_orthography):
try:
schema = OrthographySchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.id = id
result = schema.to_python(values, state)
orthography = update_orthography(orthography, result)
# orthography will be False if there are no changes (cf. update_orthography).
if orthography:
Session.add(orthography)
Session.commit()
return orthography
else:
response.status_int = 400
return {'error':
u'The update request failed because the submitted data were not new.'}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
else:
response.status = 403
return {'error': u'Only administrators are permitted to update orthographies that are used in the active application settings.'}
def email_reset_password(self):
"""Reset the user's password and email them a new one.
:URL: ``POST /login/email_reset_password``
:request body: a JSON object with a ``"username"`` attribute.
:returns: a dictionary with ``'valid_username'`` and ``'password_reset'``
keys whose values are booleans.
"""
try:
schema = PasswordResetSchema()
values = json.loads(unicode(request.body, request.charset))
result = schema.to_python(values)
user = Session.query(User).filter(
User.username == result['username']).first()
if user:
try:
new_password = h.generate_password()
h.send_password_reset_email_to(user,
new_password,
config=config)
user.password = unicode(
h.encrypt_password(new_password, str(user.salt)))
Session.add(user)
Session.commit()
if os.path.split(config['__file__'])[-1] == 'test.ini':
return {
'valid_username': True,
'password_reset': True,
'new_password': new_password
}
else:
return {'valid_username': True, 'password_reset': True}
except: # socket.error was too specific ...
response.status_int = 500
return {'error': 'The server is unable to send email.'}
else:
response.status_int = 400
return {'error': 'The username provided is not valid.'}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def test_a_initialize(self):
"""Initialize the database for /rememberedforms tests."""
h.clear_all_models()
administrator = h.generate_default_administrator()
contributor = h.generate_default_contributor()
viewer = h.generate_default_viewer()
Session.add_all([administrator, contributor, viewer])
Session.commit()
_create_test_data(self.n)
self._add_SEARCH_to_web_test_valid_methods()
# Create an application settings where the contributor is unrestricted
viewer, contributor, administrator = get_users()
application_settings = h.generate_default_application_settings()
application_settings.unrestricted_users = [contributor]
Session.add(application_settings)
Session.commit()
def test_a_initialize(self):
"""Initialize the database for /rememberedforms tests."""
h.clear_all_models()
administrator = h.generate_default_administrator()
contributor = h.generate_default_contributor()
viewer = h.generate_default_viewer()
Session.add_all([administrator, contributor, viewer])
Session.commit()
_create_test_data(self.n)
self._add_SEARCH_to_web_test_valid_methods()
# Create an application settings where the contributor is unrestricted
viewer, contributor, administrator = get_users()
application_settings = h.generate_default_application_settings()
application_settings.unrestricted_users = [contributor]
Session.add(application_settings)
Session.commit()
def update(self, id):
"""Update a morpheme language model and return it.
:URL: ``PUT /morphemelanguagemodels/id``
:Request body: JSON object representing the morpheme language model with updated attribute values.
:param str id: the ``id`` value of the morpheme language model to be updated.
:returns: the updated morpheme language model model.
"""
morpheme_language_model = h.eagerload_morpheme_language_model(
Session.query(MorphemeLanguageModel)).get(int(id))
if morpheme_language_model:
try:
schema = MorphemeLanguageModelSchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.id = id
data = schema.to_python(values, state)
morpheme_language_model_dict = morpheme_language_model.get_dict(
)
morpheme_language_model = update_morpheme_language_model(
morpheme_language_model, data)
# morpheme_language_model will be False if there are no changes (cf. update_morpheme_language_model).
if morpheme_language_model:
backup_morpheme_language_model(
morpheme_language_model_dict)
Session.add(morpheme_language_model)
Session.commit()
return morpheme_language_model
else:
response.status_int = 400
return {
'error':
u'The update request failed because the submitted data were not new.'
}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def update(self, id):
"""Update a syntactic category and return it.
:URL: ``PUT /syntacticcategorys/id``
:Request body: JSON object representing the syntactic category with updated attribute values.
:param str id: the ``id`` value of the syntactic category to be updated.
:returns: the updated syntactic category model.
"""
syntactic_category = Session.query(SyntacticCategory).get(int(id))
if syntactic_category:
try:
old_name = syntactic_category.name
schema = SyntacticCategorySchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.id = id
data = schema.to_python(values, state)
syntactic_category = update_syntactic_category(
syntactic_category, data)
# syntactic_category will be False if there are no changes (cf. update_syntactic_category).
if syntactic_category:
Session.add(syntactic_category)
Session.commit()
if syntactic_category.name != old_name:
update_forms_referencing_this_category(
syntactic_category)
return syntactic_category
else:
response.status_int = 400
return {
'error':
u'The update request failed because the submitted data were not new.'
}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def create(self):
"""Create a new keyboard resource and return it.
:URL: ``POST /keyboards``
:request body: JSON object representing the keyboard to create.
:returns: the newly created keyboard.
"""
try:
schema = KeyboardSchema()
values = json.loads(unicode(request.body, request.charset))
data = schema.to_python(values)
keyboard = create_new_keyboard(data)
Session.add(keyboard)
Session.commit()
return keyboard
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def create(self):
"""Create a new orthography resource and return it.
:URL: ``POST /orthographies``
:request body: JSON object representing the orthography to create.
:returns: the newly created orthography.
"""
try:
schema = OrthographySchema()
values = json.loads(unicode(request.body, request.charset))
data = schema.to_python(values)
orthography = create_new_orthography(data)
Session.add(orthography)
Session.commit()
return orthography
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def create(self):
"""Create a new speaker resource and return it.
:URL: ``POST /speakers``
:request body: JSON object representing the speaker to create.
:returns: the newly created speaker.
"""
try:
schema = SpeakerSchema()
values = json.loads(unicode(request.body, request.charset))
data = schema.to_python(values)
speaker = create_new_speaker(data)
Session.add(speaker)
Session.commit()
return speaker
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def create(self):
"""Create a new elicitation method resource and return it.
:URL: ``POST /elicitationmethods``
:request body: JSON object representing the elicitation method to create.
:returns: the newly created elicitation method.
"""
try:
schema = ElicitationMethodSchema()
values = json.loads(unicode(request.body, request.charset))
result = schema.to_python(values)
elicitation_method = create_new_elicitation_method(result)
Session.add(elicitation_method)
Session.commit()
return elicitation_method
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def create(self):
"""Create a new page resource and return it.
:URL: ``POST /pages``
:request body: JSON object representing the page to create.
:returns: the newly created page.
"""
try:
schema = PageSchema()
values = json.loads(unicode(request.body, request.charset))
data = schema.to_python(values)
page = create_new_page(data)
Session.add(page)
Session.commit()
return page
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def create(self):
"""Create a new tag resource and return it.
:URL: ``POST /tags``
:request body: JSON object representing the tag to create.
:returns: the newly created tag.
"""
try:
schema = TagSchema()
values = json.loads(unicode(request.body, request.charset))
data = schema.to_python(values)
tag = create_new_tag(data)
Session.add(tag)
Session.commit()
return tag
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def create(self):
"""Create a new syntactic category resource and return it.
:URL: ``POST /syntacticcategorys``
:request body: JSON object representing the syntactic category to create.
:returns: the newly created syntactic category.
"""
try:
schema = SyntacticCategorySchema()
values = json.loads(unicode(request.body, request.charset))
data = schema.to_python(values)
syntactic_category = create_new_syntactic_category(data)
Session.add(syntactic_category)
Session.commit()
return syntactic_category
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def update(self, id):
"""Update a file and return it.
:URL: ``PUT /files/id``
:Request body: JSON object representing the file with updated attribute values.
:param str id: the ``id`` value of the file to be updated.
:returns: the updated file model.
"""
file = h.eagerload_file(Session.query(File)).get(int(id))
if file:
unrestricted_users = h.get_unrestricted_users()
user = session['user']
if h.user_is_authorized_to_access_model(user, file, unrestricted_users):
try:
if getattr(file, 'parent_file', None):
file = update_subinterval_referencing_file(file)
elif getattr(file, 'url', None):
file = update_externally_hosted_file(file)
else:
file = update_file(file)
# file will be False if there are no changes
if file:
Session.add(file)
Session.commit()
return file
else:
response.status_int = 400
return {'error':
u'The update request failed because the submitted data were not new.'}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
else:
response.status_int = 403
return h.unauthorized_msg
def update(self, id):
"""Update a form search and return it.
:URL: ``PUT /formsearches/id``
:Request body: JSON object representing the form search with updated
attribute values.
:param str id: the ``id`` value of the form search to be updated.
:returns: the updated form search model.
"""
form_search = h.eagerload_form_search(Session.query(FormSearch)).get(
int(id))
if form_search:
try:
schema = FormSearchSchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.id = id
state.config = config
data = schema.to_python(values, state)
form_search = update_form_search(form_search, data)
# form_search will be False if there are no changes (cf. update_form_search).
if form_search:
Session.add(form_search)
Session.commit()
return form_search
else:
response.status_int = 400
return {
'error':
u'The update request failed because the submitted data were not new.'
}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
def update(self, id):
"""Update a corpus and return it.
:URL: ``PUT /corpora/id``
:Request body: JSON object representing the corpus with updated attribute values.
:param str id: the ``id`` value of the corpus to be updated.
:returns: the updated corpus model.
"""
corpus = h.eagerload_corpus(Session.query(Corpus)).get(int(id))
if corpus:
try:
schema = CorpusSchema()
values = json.loads(unicode(request.body, request.charset))
state = h.get_state_object(values)
state.id = id
state.config = config
data = schema.to_python(values, state)
corpus_dict = corpus.get_dict()
corpus = update_corpus(corpus, data)
# corpus will be False if there are no changes (cf. update_corpus).
if corpus:
backup_corpus(corpus_dict)
Session.add(corpus)
Session.commit()
return corpus
else:
response.status_int = 400
return {
'error':
u'The update request failed because the submitted data were not new.'
}
except h.JSONDecodeError:
response.status_int = 400
return h.JSONDecodeErrorResponse
except Invalid, e:
response.status_int = 400
return {'errors': e.unpack_errors()}
