def add():
form = AddSeedForm()
similar_seeds = None
add_mode = False
if request.method == 'POST' and form.validate():
seed = form.seed.data
if form.test.data:
if MongoSeed.exists(seed):
form.seed.errors = ('', 'This seed already exists.')
else:
similar_seeds = MongoSeed.find_similar(seed)
add_mode = True
elif form.add.data:
MongoSeed.create(seed, Source(SourceType.USER,
current_user.id)).save()
flash_success("Seed '%s' added !" % seed)
return redirect(url_for('.add'))
else: # cancel was pressed
return redirect(url_for('.add'))
return dict(form=form, add_mode=add_mode, similar_seeds=similar_seeds)
def details(sid):
form = DeleteSentenceForm()
if request.method == 'POST' and form.validate():
MongoSentence.mark_deleted(sid, current_user.id, form.comment.data)
flash.flash_success('Sentence deleted.')
return redirect(request.referrer or '/')
return dict(form=form, s=MongoSentence.objects.get_or_404(id=sid))
def add():
form = AddUrlForm()
if request.method == 'POST':
# submitted either with add1 (first submission) or add2 (there was similar matches, ask for confirmation)
if not form.validate():
return dict(form=form)
url = form.url.data
if MongoURL.exists(url):
return dict(form=form, url_exists=True)
if form.add1.data:
# first submission: check for similar matches
# TODO use urllib.urlparse
base_url = url.split('?')[0]
if base_url.endswith('/'):
base_url = base_url[:-1]
similar_urls = MongoURL.objects(url__icontains=base_url).paginate(
page=1, per_page=10)
if similar_urls.total > 0:
return dict(form=form, similar_urls=similar_urls)
mu = MongoURL.create(url,
source=Source(type_=SourceType.USER,
extra=current_user.id)) #.save()
flash_success(
Markup(
f'The url has been added: <a href=""><code>{mu.id}</code></a>')
)
return redirect(url_for(request.endpoint))
return dict(form=form)
def profile():
page = int(request.args.get('page', 1))
form = ProfileForm()
if request.method == 'POST' and form.validate():
# here, if you don't hold a reference to s, you will randomly get a
# ReferenceError: weakly-reference no longer exists...
s = MongoSentence.objects.with_id(form.sid.data)
s.dialect.remove_label(current_user.id)
flash_success(
Markup(
'Label removed from sentence <a href="%s"><code>%s</code></a>.'
) % (url_for('sentences.details', sid=s.id), s.id))
return redirect(url_for(request.endpoint))
skipped_count = MongoSentence.objects(
dialect__skipped_by=current_user.id).count()
vcount = MongoSentence.objects(validated_by=current_user.id).count()
ss = MongoSentence.objects(dialect__labels__user=current_user.id) \
.fields(**{'dialect.labels.$': True, 'text': True}) \
.order_by('-dialect.labels.date') \
.paginate(page, per_page=10)
return dict(form=form,
valid_count=vcount,
skipped_count=skipped_count,
labelled_sentences=ss)
def view():
if request.method == 'GET':
form = SearchUrlsForm.from_get()
page = form.get_page_and_reset() # get the parameter, then reset
if form.is_blank():
return dict(form=form, urls=[], collapse=False)
else:
query_params = form.get_mongo_params()
urls = MongoURL.objects(**query_params) \
.order_by("%s%s" % ('' if form.sort_order.data else '-', form.sort.data)) \
.paginate(page, per_page=20)
collapse = urls.total > 0
return dict(form=form,
delete_form=DeleteUrlsForm(),
urls=urls,
collapse=collapse)
else:
delete_form = DeleteUrlsForm()
if delete_form.go.data:
# the delete form is only available after search,
# so the url should contain some query parameters
if not delete_form.validate():
# ensure the checkbox is selected to avoid silly mistakes
flash_error('You must know what you are doing.')
return redirect(request.url)
form = SearchUrlsForm.from_get()
if not form.search.data:
# don't let the user delete everything
flash_error('You must have some filtering before delete.')
return redirect(request.url)
urls = MongoURL.objects(**form.get_mongo_params())
ud, sd = 0, 0
for url in urls:
try:
sd += _delete_url(url)
ud += 1
except Exception as e:
print(e)
flash_success(f'Delete {ud}/{len(urls)} urls ({sd} sentences).')
return redirect(request.url)
return SearchUrlsForm.redirect_as_get()
def details(id):
form = DeleteUrlForm()
mu = MongoURL.objects(id=id).get_or_404()
if request.method == 'POST' and form.validate():
num_sentences = _delete_url(mu)
msg = f'URL <small>{mu.url}</small> (id: <code>{mu.id}</code>) has been blacklisted.'
if num_sentences > 0:
msg += f'<br>{num_sentences} sentence(s) deleted.'
flash_success(Markup(msg))
return redirect(request.args.get('next') or url_for('.view'))
page = int(request.args.get('page', 1))
sentences = MongoSentence.objects(
url=mu.url).order_by('-date_added').paginate(page=page, per_page=20)
return dict(form=form, url=mu, sentences=sentences)
def validate():
form = ValidationForm()
param_uid = request.args.get('uid', None)
url = None # set if the uid parameter is present AND valid
if request.method == 'POST' and form.validate():
ss = MongoSentence.objects(id__in=form.sentences_ids.data.split(","))
ss.update(add_to_set__validated_by=current_user.id)
flash.flash_success('%d sentences validated.' % ss.count())
return redirect(
url_for(request.endpoint,
**request.args)) # avoid form resubmission on refresh
mongo_params = dict(validated_by__nin=[current_user.id],
deleted__exists=False)
if param_uid is not None:
# add a filter to the Mongo Query (only if the uid is valid)
mu = MongoURL.get(id=param_uid)
if mu is None:
flash.flash_error(
Markup(f'url <code>{mu.id}</code> does not exist.'))
else:
url = mu.url
mongo_params['url'] = url
sentences = MongoSentence.objects(**mongo_params) \
.order_by('url', 'date_added') \
.limit(_per_page)
if not sentences and param_uid:
# we were displaying urls from a given URL, but they are all
# validated now... Redirect to the main view
flash.flash_warning(
Markup(
f'No more sentences to validate from URL <code>{param_uid}</code>.'
))
return redirect(url_for(request.endpoint))
form.sentences_ids.data = ",".join((s.id for s in sentences))
return dict(form=form, sentences=sentences, url=url)