mirror of
https://gitlab.ub.uni-bielefeld.de/sfb1288inf/nopaque.git
synced 2025-06-12 00:50:40 +00:00
integrate nopaque repo
This commit is contained in:
Patrick Jentsch
@ -1,5 +0,0 @@
|
||||
from flask import Blueprint
|
||||
|
||||
|
||||
corpora = Blueprint('corpora', __name__)
|
||||
from . import events, views # noqa
|
||||
@ -1,209 +0,0 @@
|
||||
from flask import current_app, request
|
||||
from flask_login import current_user
|
||||
from socket import gaierror
|
||||
from .. import db, socketio
|
||||
from ..decorators import socketio_login_required
|
||||
from ..events import connected_sessions
|
||||
from ..models import Corpus, User
|
||||
import cqi
|
||||
import math
|
||||
from app import logger
|
||||
from datetime import datetime
|
||||
|
||||
|
||||
'''
|
||||
' A dictionary containing lists of, with corpus ids associated, Socket.IO
|
||||
' session ids (sid). {<corpus_id>: [<sid>, ...], ...}
|
||||
'''
|
||||
corpus_analysis_sessions = {}
|
||||
'''
|
||||
' A dictionary containing Socket.IO session id - CQi client pairs.
|
||||
' {<sid>: CQiClient, ...}
|
||||
'''
|
||||
corpus_analysis_clients = {}
|
||||
|
||||
|
||||
@socketio.on('corpus_analysis_init')
|
||||
@socketio_login_required
|
||||
def init_corpus_analysis(corpus_id):
|
||||
socketio.start_background_task(corpus_analysis_session_handler,
|
||||
current_app._get_current_object(),
|
||||
corpus_id, current_user.id, request.sid)
|
||||
|
||||
|
||||
@socketio.on('corpus_analysis_get_meta_data')
|
||||
@socketio_login_required
|
||||
def corpus_analysis_get_meta_data(corpus_id):
|
||||
# get meta data from db
|
||||
db_corpus = Corpus.query.get(corpus_id)
|
||||
# TODO: Check if current user is actually the creator of the corpus?
|
||||
metadata = {}
|
||||
metadata['corpus_name'] = db_corpus.title
|
||||
metadata['corpus_description'] = db_corpus.description
|
||||
metadata['corpus_creation_date'] = db_corpus.creation_date.isoformat()
|
||||
metadata['corpus_last_edited_date'] = db_corpus.last_edited_date.isoformat()
|
||||
# get meta data from corpus in cqp server
|
||||
client = corpus_analysis_clients.get(request.sid)
|
||||
client_corpus = client.corpora.get('CORPUS')
|
||||
metadata['corpus_properties'] = client_corpus.attrs['properties']
|
||||
metadata['corpus_size_tokens'] = client_corpus.attrs['size']
|
||||
|
||||
text_attr = client_corpus.structural_attributes.get('text')
|
||||
struct_attrs = client_corpus.structural_attributes.list(filters={'part_of': text_attr})
|
||||
text_ids = range(0, (text_attr.attrs['size']))
|
||||
texts_metadata = {}
|
||||
for text_id in text_ids:
|
||||
texts_metadata[text_id] = {}
|
||||
for struct_attr in struct_attrs:
|
||||
texts_metadata[text_id][struct_attr.attrs['name'][(len(text_attr.attrs['name']) + 1):]] = struct_attr.values_by_ids(list(range(struct_attr.attrs['size'])))[text_id]
|
||||
metadata['corpus_all_texts'] = texts_metadata
|
||||
metadata['corpus_analysis_date'] = datetime.utcnow().isoformat()
|
||||
metadata['corpus_cqi_py_version'] = cqi.version
|
||||
metadata['corpus_cqpserver_version'] = 'CQPserver v3.4.22' # TODO: make this dynamically
|
||||
|
||||
# write some metadata to the db
|
||||
db_corpus.current_nr_of_tokens = metadata['corpus_size_tokens']
|
||||
db.session.commit()
|
||||
|
||||
# emit data
|
||||
payload = metadata
|
||||
response = {'code': 200, 'desc': 'Corpus meta data', 'msg': 'OK', 'payload': payload}
|
||||
socketio.emit('corpus_analysis_send_meta_data', response, room=request.sid)
|
||||
|
||||
|
||||
@socketio.on('corpus_analysis_query')
|
||||
@socketio_login_required
|
||||
def corpus_analysis_query(query):
|
||||
client = corpus_analysis_clients.get(request.sid)
|
||||
if client is None:
|
||||
response = {'code': 424, 'desc': 'No client found for this session',
|
||||
'msg': 'Failed Dependency'}
|
||||
socketio.emit('corpus_analysis_query', response, room=request.sid)
|
||||
return
|
||||
if client.status == 'running':
|
||||
client.status = 'abort'
|
||||
while client.status != 'ready':
|
||||
socketio.sleep(0.1)
|
||||
try:
|
||||
corpus = client.corpora.get('CORPUS')
|
||||
query_status = corpus.query(query)
|
||||
results = corpus.subcorpora.get('Results')
|
||||
except cqi.errors.CQiException as e:
|
||||
payload = {'code': e.code, 'desc': e.description, 'msg': e.name}
|
||||
response = {'code': 500, 'desc': None, 'msg': 'Internal Server Error',
|
||||
'payload': payload}
|
||||
socketio.emit('corpus_analysis_query', response, room=request.sid)
|
||||
return
|
||||
payload = {**query_status, 'match_count': results.attrs['size']}
|
||||
response = {'code': 200, 'desc': None, 'msg': 'OK', 'payload': payload}
|
||||
socketio.emit('corpus_analysis_query', response, room=request.sid)
|
||||
# TODO: Stop here and add a new method for transmission
|
||||
chunk_size = 100
|
||||
chunk_start = 0
|
||||
context = 50
|
||||
progress = 0
|
||||
client.status = 'running'
|
||||
while chunk_start <= results.attrs['size']:
|
||||
if client.status == 'abort':
|
||||
break
|
||||
chunk = results.export(context=context, cutoff=chunk_size,
|
||||
expand_lists=False, offset=chunk_start)
|
||||
chunk['cpos_ranges'] = True
|
||||
if (results.attrs['size'] == 0):
|
||||
progress = 100
|
||||
else:
|
||||
progress = ((chunk_start + chunk_size) / results.attrs['size']) * 100
|
||||
progress = min(100, int(math.ceil(progress)))
|
||||
response = {'code': 200, 'desc': None, 'msg': 'OK',
|
||||
'payload': {'chunk': chunk, 'progress': progress}}
|
||||
socketio.emit('corpus_analysis_query_results', response,
|
||||
room=request.sid)
|
||||
chunk_start += chunk_size
|
||||
client.status = 'ready'
|
||||
|
||||
|
||||
@socketio.on('corpus_analysis_inspect_match')
|
||||
@socketio_login_required
|
||||
def corpus_analysis_inspect_match(payload):
|
||||
payload = payload["payload"]
|
||||
client = corpus_analysis_clients.get(request.sid)
|
||||
if client is None:
|
||||
response = {'code': 424, 'desc': 'No client found for this session',
|
||||
'msg': 'Failed Dependency'}
|
||||
socketio.emit('corpus_analysis_inspect_match', response, room=request.sid)
|
||||
return
|
||||
try:
|
||||
corpus = client.corpora.get('CORPUS')
|
||||
s = corpus.structural_attributes.get('s')
|
||||
payload = s.export(payload['first_cpos'], payload['last_cpos'], context=10)
|
||||
payload['cpos_ranges'] = True
|
||||
except cqi.errors.CQiException as e:
|
||||
payload = {'code': e.code, 'desc': e.description, 'msg': e.name}
|
||||
response = {'code': 500, 'desc': None, 'msg': 'Internal Server Error',
|
||||
'payload': payload}
|
||||
else:
|
||||
response = {'code': 200, 'desc': None, 'msg': 'OK', 'payload': payload}
|
||||
socketio.emit('corpus_analysis_inspect_match', response, room=request.sid)
|
||||
|
||||
|
||||
def corpus_analysis_session_handler(app, corpus_id, user_id, session_id):
|
||||
with app.app_context():
|
||||
''' Setup analysis session '''
|
||||
corpus = Corpus.query.get(corpus_id)
|
||||
user = User.query.get(user_id)
|
||||
if corpus is None:
|
||||
response = {'code': 404, 'desc': None, 'msg': 'Not Found'}
|
||||
socketio.emit('corpus_analysis_init', response, room=session_id)
|
||||
return
|
||||
elif not (corpus.creator == user or user.is_administrator()):
|
||||
response = {'code': 403, 'desc': None, 'msg': 'Forbidden'}
|
||||
socketio.emit('corpus_analysis_init', response, room=session_id)
|
||||
return
|
||||
elif corpus.status == 'unprepared':
|
||||
response = {'code': 424, 'desc': 'Corpus is not prepared',
|
||||
'msg': 'Failed Dependency'}
|
||||
socketio.emit('corpus_analysis_init', response, room=request.sid)
|
||||
return
|
||||
while corpus.status != 'analysing':
|
||||
db.session.refresh(corpus)
|
||||
socketio.sleep(3)
|
||||
client = cqi.CQiClient('cqpserver_{}'.format(corpus_id))
|
||||
try:
|
||||
payload = client.connect()
|
||||
except cqi.errors.CQiException as e:
|
||||
payload = {'code': e.code, 'desc': e.description, 'msg': e.name}
|
||||
response = {'code': 500, 'desc': None,
|
||||
'msg': 'Internal Server Error', 'payload': payload}
|
||||
socketio.emit('corpus_analysis_init', response, room=session_id)
|
||||
return
|
||||
except gaierror:
|
||||
response = {'code': 500, 'desc': None,
|
||||
'msg': 'Internal Server Error'}
|
||||
socketio.emit('corpus_analysis_init', response, room=session_id)
|
||||
return
|
||||
corpus_analysis_clients[session_id] = client
|
||||
if corpus_id not in corpus_analysis_sessions:
|
||||
corpus_analysis_sessions[corpus_id] = [session_id]
|
||||
else:
|
||||
corpus_analysis_sessions[corpus_id].append(session_id)
|
||||
client.status = 'ready'
|
||||
response = {'code': 200, 'desc': None, 'msg': 'OK', 'payload': payload}
|
||||
socketio.emit('corpus_analysis_init', response, room=session_id)
|
||||
''' Observe analysis session '''
|
||||
while session_id in connected_sessions:
|
||||
socketio.sleep(3)
|
||||
''' Teardown analysis session '''
|
||||
if client.status == 'running':
|
||||
client.status = 'abort'
|
||||
while client.status != 'ready':
|
||||
socketio.sleep(0.1)
|
||||
try:
|
||||
client.disconnect()
|
||||
except cqi.errors.CQiException:
|
||||
pass
|
||||
corpus_analysis_clients.pop(session_id, None)
|
||||
corpus_analysis_sessions[corpus_id].remove(session_id)
|
||||
if not corpus_analysis_sessions[corpus_id]:
|
||||
corpus_analysis_sessions.pop(corpus_id, None)
|
||||
corpus.status = 'stop analysis'
|
||||
db.session.commit()
|
||||
@ -1,102 +0,0 @@
|
||||
from flask_wtf import FlaskForm
|
||||
from werkzeug.utils import secure_filename
|
||||
from wtforms import (BooleanField, FileField, StringField, SubmitField,
|
||||
ValidationError, IntegerField, SelectField)
|
||||
from wtforms.validators import DataRequired, Length, NumberRange
|
||||
|
||||
|
||||
class AddCorpusFileForm(FlaskForm):
|
||||
address = StringField('Adress', validators=[Length(0, 255)])
|
||||
author = StringField('Author', validators=[DataRequired(), Length(1, 255)])
|
||||
booktitle = StringField('Booktitle', validators=[Length(0, 255)])
|
||||
chapter = StringField('Chapter', validators=[Length(0, 255)])
|
||||
editor = StringField('Editor', validators=[Length(0, 255)])
|
||||
file = FileField('File', validators=[DataRequired()])
|
||||
institution = StringField('Institution', validators=[Length(0, 255)])
|
||||
journal = StringField('Journal', validators=[Length(0, 255)])
|
||||
pages = StringField('Pages', validators=[Length(0, 255)])
|
||||
publisher = StringField('Publisher', validators=[Length(0, 255)])
|
||||
publishing_year = IntegerField('Publishing year',
|
||||
validators=[DataRequired()])
|
||||
school = StringField('School', validators=[Length(0, 255)])
|
||||
submit = SubmitField()
|
||||
title = StringField('Title', validators=[DataRequired(), Length(1, 255)])
|
||||
|
||||
def __init__(self, corpus, *args, **kwargs):
|
||||
super(AddCorpusFileForm, self).__init__(*args, **kwargs)
|
||||
self.corpus = corpus
|
||||
|
||||
def validate_file(self, field):
|
||||
if not field.data.filename.lower().endswith('.vrt'):
|
||||
raise ValidationError('File does not have an approved extension: '
|
||||
'.vrt')
|
||||
field.data.filename = secure_filename(field.data.filename)
|
||||
for corpus_file in self.corpus.files:
|
||||
if field.data.filename == corpus_file.filename:
|
||||
raise ValidationError('File already registered to corpus.')
|
||||
|
||||
|
||||
class EditCorpusFileForm(FlaskForm):
|
||||
address = StringField('Adress', validators=[Length(0, 255)])
|
||||
author = StringField('Author', validators=[DataRequired(), Length(1, 255)])
|
||||
booktitle = StringField('Booktitle', validators=[Length(0, 255)])
|
||||
chapter = StringField('Chapter', validators=[Length(0, 255)])
|
||||
editor = StringField('Editor', validators=[Length(0, 255)])
|
||||
institution = StringField('Institution', validators=[Length(0, 255)])
|
||||
journal = StringField('Journal', validators=[Length(0, 255)])
|
||||
pages = StringField('Pages', validators=[Length(0, 255)])
|
||||
publisher = StringField('Publisher', validators=[Length(0, 255)])
|
||||
publishing_year = IntegerField('Publishing year',
|
||||
validators=[DataRequired()])
|
||||
school = StringField('School', validators=[Length(0, 255)])
|
||||
submit = SubmitField()
|
||||
title = StringField('Title', validators=[DataRequired(), Length(1, 255)])
|
||||
|
||||
|
||||
class AddCorpusForm(FlaskForm):
|
||||
description = StringField('Description',
|
||||
validators=[DataRequired(), Length(1, 255)])
|
||||
submit = SubmitField()
|
||||
title = StringField('Title', validators=[DataRequired(), Length(1, 32)])
|
||||
|
||||
|
||||
class QueryForm(FlaskForm):
|
||||
query = StringField('Query',
|
||||
validators=[DataRequired(), Length(1, 1024)])
|
||||
submit = SubmitField('Send query')
|
||||
|
||||
|
||||
class DisplayOptionsForm(FlaskForm):
|
||||
expert_mode = BooleanField('Expert mode')
|
||||
result_context = SelectField('Result context',
|
||||
choices=[('', 'Choose your option'),
|
||||
('10', '10'),
|
||||
('20', '20'),
|
||||
('30', '30'),
|
||||
('40', '40'),
|
||||
('50', '50')])
|
||||
results_per_page = SelectField('Results per page',
|
||||
choices=[('', 'Choose your option'),
|
||||
('10', '10'),
|
||||
('20', '20'),
|
||||
('30', '30'),
|
||||
('40', '40'),
|
||||
('50', '50')])
|
||||
|
||||
|
||||
class InspectDisplayOptionsForm(FlaskForm):
|
||||
expert_mode_inspect = BooleanField('Expert mode')
|
||||
highlight_sentences = BooleanField('Split sentences')
|
||||
context_sentences = IntegerField('Context sentences',
|
||||
validators=[NumberRange(min=0, max=10)],
|
||||
default=3)
|
||||
|
||||
|
||||
class QueryDownloadForm(FlaskForm):
|
||||
file_type = SelectField('File type',
|
||||
choices=[('', 'Choose file type'),
|
||||
('csv', 'csv'),
|
||||
('json', 'json'),
|
||||
('excel', 'excel'),
|
||||
('html', 'html-table')],
|
||||
validators=[DataRequired()])
|
||||
@ -1,80 +0,0 @@
|
||||
from datetime import datetime
|
||||
from .. import db
|
||||
from ..decorators import background
|
||||
from ..models import Corpus, CorpusFile
|
||||
import xml.etree.ElementTree as ET
|
||||
import os
|
||||
import shutil
|
||||
|
||||
|
||||
@background
|
||||
def build_corpus(corpus_id, *args, **kwargs):
|
||||
app = kwargs['app']
|
||||
with app.app_context():
|
||||
corpus = Corpus.query.get(corpus_id)
|
||||
if corpus is None:
|
||||
return
|
||||
corpus.status = 'File processing'
|
||||
db.session.commit()
|
||||
corpus_dir = os.path.join(app.config['NOPAQUE_STORAGE'],
|
||||
str(corpus.user_id), 'corpora',
|
||||
str(corpus.id))
|
||||
output_dir = os.path.join(corpus_dir, 'merged')
|
||||
shutil.rmtree(output_dir, ignore_errors=True)
|
||||
os.mkdir(output_dir)
|
||||
master_element_tree = ET.ElementTree(
|
||||
ET.fromstring('<corpus>\n</corpus>'))
|
||||
for corpus_file in corpus.files:
|
||||
file = os.path.join(corpus_dir, corpus_file.filename)
|
||||
element_tree = ET.parse(file)
|
||||
text_node = element_tree.find('text')
|
||||
text_node.set('address', corpus_file.address or "NULL")
|
||||
text_node.set('author', corpus_file.author)
|
||||
text_node.set('booktitle', corpus_file.booktitle or "NULL")
|
||||
text_node.set('chapter', corpus_file.chapter or "NULL")
|
||||
text_node.set('editor', corpus_file.editor or "NULL")
|
||||
text_node.set('institution', corpus_file.institution or "NULL")
|
||||
text_node.set('journal', corpus_file.journal or "NULL")
|
||||
text_node.set('pages', corpus_file.pages or "NULL")
|
||||
text_node.set('publisher', corpus_file.publisher or "NULL")
|
||||
text_node.set('publishing_year', str(corpus_file.publishing_year))
|
||||
text_node.set('school', corpus_file.school or "NULL")
|
||||
text_node.set('title', corpus_file.title)
|
||||
element_tree.write(file)
|
||||
master_element_tree.getroot().insert(1, text_node)
|
||||
output_file = os.path.join(output_dir, 'corpus.vrt')
|
||||
master_element_tree.write(output_file, xml_declaration=True,
|
||||
encoding='utf-8')
|
||||
corpus.status = 'submitted'
|
||||
corpus.last_edited_date = datetime.utcnow()
|
||||
db.session.commit()
|
||||
|
||||
|
||||
@background
|
||||
def delete_corpus(corpus_id, *args, **kwargs):
|
||||
app = kwargs['app']
|
||||
with app.app_context():
|
||||
corpus = Corpus.query.get(corpus_id)
|
||||
if corpus is None:
|
||||
return
|
||||
path = os.path.join(app.config['NOPAQUE_STORAGE'], str(corpus.user_id),
|
||||
'corpora', str(corpus.id))
|
||||
shutil.rmtree(path, ignore_errors=True)
|
||||
corpus.delete()
|
||||
|
||||
|
||||
@background
|
||||
def delete_corpus_file(corpus_file_id, *args, **kwargs):
|
||||
app = kwargs['app']
|
||||
with app.app_context():
|
||||
corpus_file = CorpusFile.query.get(corpus_file_id)
|
||||
if corpus_file is None:
|
||||
return
|
||||
path = os.path.join(app.config['NOPAQUE_STORAGE'], corpus_file.dir,
|
||||
corpus_file.filename)
|
||||
try:
|
||||
os.remove(path)
|
||||
except Exception:
|
||||
pass
|
||||
else:
|
||||
corpus_file.delete()
|
||||
@ -1,222 +0,0 @@
|
||||
from flask import (abort, current_app, flash, make_response, redirect, request,
|
||||
render_template, url_for, send_from_directory)
|
||||
from flask_login import current_user, login_required
|
||||
from . import corpora
|
||||
from . import tasks
|
||||
from .forms import (AddCorpusFileForm, AddCorpusForm, EditCorpusFileForm,
|
||||
QueryDownloadForm, QueryForm, DisplayOptionsForm,
|
||||
InspectDisplayOptionsForm)
|
||||
from .. import db
|
||||
from ..models import Corpus, CorpusFile
|
||||
import os
|
||||
|
||||
|
||||
@corpora.route('/add', methods=['GET', 'POST'])
|
||||
@login_required
|
||||
def add_corpus():
|
||||
add_corpus_form = AddCorpusForm()
|
||||
if add_corpus_form.validate_on_submit():
|
||||
corpus = Corpus(creator=current_user,
|
||||
description=add_corpus_form.description.data,
|
||||
status='unprepared', title=add_corpus_form.title.data)
|
||||
db.session.add(corpus)
|
||||
db.session.commit()
|
||||
dir = os.path.join(current_app.config['NOPAQUE_STORAGE'],
|
||||
str(corpus.user_id), 'corpora', str(corpus.id))
|
||||
try:
|
||||
os.makedirs(dir)
|
||||
except OSError:
|
||||
flash('[ERROR]: Could not add corpus!', 'corpus')
|
||||
corpus.delete()
|
||||
else:
|
||||
url = url_for('corpora.corpus', corpus_id=corpus.id)
|
||||
flash('[<a href="{}">{}</a>] added'.format(url, corpus.title),
|
||||
'corpus')
|
||||
return redirect(url_for('corpora.corpus', corpus_id=corpus.id))
|
||||
return render_template('corpora/add_corpus.html.j2',
|
||||
add_corpus_form=add_corpus_form,
|
||||
title='Add corpus')
|
||||
|
||||
|
||||
@corpora.route('/<int:corpus_id>')
|
||||
@login_required
|
||||
def corpus(corpus_id):
|
||||
corpus = Corpus.query.get_or_404(corpus_id)
|
||||
if not (corpus.creator == current_user or current_user.is_administrator()):
|
||||
abort(403)
|
||||
return render_template('corpora/corpus.html.j2', corpus=corpus,
|
||||
title='Corpus')
|
||||
|
||||
|
||||
@corpora.route('/<int:corpus_id>/analyse')
|
||||
@login_required
|
||||
def analyse_corpus(corpus_id):
|
||||
corpus = Corpus.query.get_or_404(corpus_id)
|
||||
if corpus.status == 'prepared':
|
||||
corpus.status = 'start analysis'
|
||||
db.session.commit()
|
||||
display_options_form = DisplayOptionsForm(
|
||||
prefix='display-options-form',
|
||||
result_context=request.args.get('context', 20),
|
||||
results_per_page=request.args.get('results_per_page', 30))
|
||||
query_form = QueryForm(prefix='query-form',
|
||||
query=request.args.get('query'))
|
||||
query_download_form = QueryDownloadForm(prefix='query-download-form')
|
||||
inspect_display_options_form = InspectDisplayOptionsForm(
|
||||
prefix='inspect-display-options-form')
|
||||
return render_template(
|
||||
'corpora/analyse_corpus.html.j2',
|
||||
corpus_id=corpus_id,
|
||||
display_options_form=display_options_form,
|
||||
query_form=query_form,
|
||||
query_download_form=query_download_form,
|
||||
inspect_display_options_form=inspect_display_options_form,
|
||||
title='Corpus analysis')
|
||||
|
||||
|
||||
@corpora.route('/<int:corpus_id>/delete')
|
||||
@login_required
|
||||
def delete_corpus(corpus_id):
|
||||
corpus = Corpus.query.get_or_404(corpus_id)
|
||||
if not (corpus.creator == current_user or current_user.is_administrator()):
|
||||
abort(403)
|
||||
tasks.delete_corpus(corpus_id)
|
||||
flash('Corpus deleted!', 'corpus')
|
||||
return redirect(url_for('main.dashboard'))
|
||||
|
||||
|
||||
@corpora.route('/<int:corpus_id>/files/add', methods=['GET', 'POST'])
|
||||
@login_required
|
||||
def add_corpus_file(corpus_id):
|
||||
corpus = Corpus.query.get_or_404(corpus_id)
|
||||
if not (corpus.creator == current_user or current_user.is_administrator()):
|
||||
abort(403)
|
||||
add_corpus_file_form = AddCorpusFileForm(corpus,
|
||||
prefix='add-corpus-file-form')
|
||||
if add_corpus_file_form.is_submitted():
|
||||
if not add_corpus_file_form.validate():
|
||||
return make_response(add_corpus_file_form.errors, 400)
|
||||
# Save the file
|
||||
dir = os.path.join(str(corpus.user_id), 'corpora', str(corpus.id))
|
||||
add_corpus_file_form.file.data.save(
|
||||
os.path.join(current_app.config['NOPAQUE_STORAGE'], dir,
|
||||
add_corpus_file_form.file.data.filename))
|
||||
corpus_file = CorpusFile(
|
||||
address=add_corpus_file_form.address.data,
|
||||
author=add_corpus_file_form.author.data,
|
||||
booktitle=add_corpus_file_form.booktitle.data,
|
||||
chapter=add_corpus_file_form.chapter.data,
|
||||
corpus=corpus,
|
||||
dir=dir,
|
||||
editor=add_corpus_file_form.editor.data,
|
||||
filename=add_corpus_file_form.file.data.filename,
|
||||
institution=add_corpus_file_form.institution.data,
|
||||
journal=add_corpus_file_form.journal.data,
|
||||
pages=add_corpus_file_form.pages.data,
|
||||
publisher=add_corpus_file_form.publisher.data,
|
||||
publishing_year=add_corpus_file_form.publishing_year.data,
|
||||
school=add_corpus_file_form.school.data,
|
||||
title=add_corpus_file_form.title.data)
|
||||
db.session.add(corpus_file)
|
||||
corpus.status = 'unprepared'
|
||||
db.session.commit()
|
||||
flash('Corpus file added!', 'corpus')
|
||||
return make_response(
|
||||
{'redirect_url': url_for('corpora.corpus', corpus_id=corpus.id)},
|
||||
201)
|
||||
return render_template('corpora/add_corpus_file.html.j2',
|
||||
corpus=corpus,
|
||||
add_corpus_file_form=add_corpus_file_form,
|
||||
title='Add corpus file')
|
||||
|
||||
|
||||
@corpora.route('/<int:corpus_id>/files/<int:corpus_file_id>/delete')
|
||||
@login_required
|
||||
def delete_corpus_file(corpus_id, corpus_file_id):
|
||||
corpus_file = CorpusFile.query.get_or_404(corpus_file_id)
|
||||
if not corpus_file.corpus_id == corpus_id:
|
||||
abort(404)
|
||||
if not (corpus_file.corpus.creator == current_user
|
||||
or current_user.is_administrator()):
|
||||
abort(403)
|
||||
tasks.delete_corpus_file(corpus_file_id)
|
||||
flash('Corpus file deleted!', 'corpus')
|
||||
return redirect(url_for('corpora.corpus', corpus_id=corpus_id))
|
||||
|
||||
|
||||
@corpora.route('/<int:corpus_id>/files/<int:corpus_file_id>/download')
|
||||
@login_required
|
||||
def download_corpus_file(corpus_id, corpus_file_id):
|
||||
corpus_file = CorpusFile.query.get_or_404(corpus_file_id)
|
||||
if not corpus_file.corpus_id == corpus_id:
|
||||
abort(404)
|
||||
if not (corpus_file.corpus.creator == current_user
|
||||
or current_user.is_administrator()):
|
||||
abort(403)
|
||||
dir = os.path.join(current_app.config['NOPAQUE_STORAGE'],
|
||||
corpus_file.dir)
|
||||
return send_from_directory(as_attachment=True, directory=dir,
|
||||
filename=corpus_file.filename)
|
||||
|
||||
|
||||
@corpora.route('/<int:corpus_id>/files/<int:corpus_file_id>/edit',
|
||||
methods=['GET', 'POST'])
|
||||
@login_required
|
||||
def edit_corpus_file(corpus_id, corpus_file_id):
|
||||
corpus = Corpus.query.get_or_404(corpus_id)
|
||||
corpus_file = CorpusFile.query.get_or_404(corpus_file_id)
|
||||
if not corpus_file.corpus_id == corpus_id:
|
||||
abort(404)
|
||||
if not (corpus_file.corpus.creator == current_user
|
||||
or current_user.is_administrator()):
|
||||
abort(403)
|
||||
edit_corpus_file_form = EditCorpusFileForm(prefix='edit-corpus-file-form')
|
||||
if edit_corpus_file_form.validate_on_submit():
|
||||
corpus_file.address = edit_corpus_file_form.address.data
|
||||
corpus_file.author = edit_corpus_file_form.author.data
|
||||
corpus_file.booktitle = edit_corpus_file_form.booktitle.data
|
||||
corpus_file.chapter = edit_corpus_file_form.chapter.data
|
||||
corpus_file.editor = edit_corpus_file_form.editor.data
|
||||
corpus_file.institution = edit_corpus_file_form.institution.data
|
||||
corpus_file.journal = edit_corpus_file_form.journal.data
|
||||
corpus_file.pages = edit_corpus_file_form.pages.data
|
||||
corpus_file.publisher = edit_corpus_file_form.publisher.data
|
||||
corpus_file.publishing_year = \
|
||||
edit_corpus_file_form.publishing_year.data
|
||||
corpus_file.school = edit_corpus_file_form.school.data
|
||||
corpus_file.title = edit_corpus_file_form.title.data
|
||||
corpus.status = 'unprepared'
|
||||
db.session.commit()
|
||||
flash('Corpus file edited!', 'corpus')
|
||||
return redirect(url_for('corpora.corpus', corpus_id=corpus_id))
|
||||
# If no form is submitted or valid, fill out fields with current values
|
||||
edit_corpus_file_form.address.data = corpus_file.address
|
||||
edit_corpus_file_form.author.data = corpus_file.author
|
||||
edit_corpus_file_form.booktitle.data = corpus_file.booktitle
|
||||
edit_corpus_file_form.chapter.data = corpus_file.chapter
|
||||
edit_corpus_file_form.editor.data = corpus_file.editor
|
||||
edit_corpus_file_form.institution.data = corpus_file.institution
|
||||
edit_corpus_file_form.journal.data = corpus_file.journal
|
||||
edit_corpus_file_form.pages.data = corpus_file.pages
|
||||
edit_corpus_file_form.publisher.data = corpus_file.publisher
|
||||
edit_corpus_file_form.publishing_year.data = corpus_file.publishing_year
|
||||
edit_corpus_file_form.school.data = corpus_file.school
|
||||
edit_corpus_file_form.title.data = corpus_file.title
|
||||
return render_template('corpora/edit_corpus_file.html.j2',
|
||||
corpus_file=corpus_file, corpus=corpus,
|
||||
edit_corpus_file_form=edit_corpus_file_form,
|
||||
title='Edit corpus file')
|
||||
|
||||
|
||||
@corpora.route('/<int:corpus_id>/prepare')
|
||||
@login_required
|
||||
def prepare_corpus(corpus_id):
|
||||
corpus = Corpus.query.get_or_404(corpus_id)
|
||||
if not (corpus.creator == current_user or current_user.is_administrator()):
|
||||
abort(403)
|
||||
if corpus.files.all():
|
||||
tasks.build_corpus(corpus_id)
|
||||
flash('Corpus gets build now.', 'corpus')
|
||||
else:
|
||||
flash('Can not build corpus, please add corpus file(s).', 'corpus')
|
||||
return redirect(url_for('corpora.corpus', corpus_id=corpus_id))
|
||||
Reference in New Issue
Block a user