def setUp(self):
database.new()
config.deploy("nominal")
scripts.deleteAll()
self.serverProcess = yadomsServer.start()
self.browser = webdriver.Firefox()
self.browser.implicitly_wait(10)
yadomsServer.openClient(self.browser)
def setUp(self):
yadomsServer.ensureStopped()
database.new()
config.deploy("nominal")
scripts.deleteAll()
self.serverProcess = yadomsServer.start()
self.browser = webdriver.Chrome(options=tools.ChromeOptionsHelper.get())
self.browser.implicitly_wait(10)
yadomsServer.openClient(self.browser)
def setUp(self):
yadomsServer.ensureStopped()
database.new()
config.deploy("nominal")
scripts.deleteAll()
# We have to activate log to be able to check rules logs
self.serverProcess = yadomsServer.start(["logLevel=trace"])
self.browser = webdriver.Chrome()
self.browser.implicitly_wait(10)
yadomsServer.openClient(self.browser)
def save_resume_token(self, params):
event = params["event"]
handler_name = params["handler_name"]
resume_token = event["_id"]
operation_type = event["operationType"]
database_name = event["ns"]["db"]
collection_name = event["ns"]["coll"]
document_key = event["documentKey"]["_id"]
mgd_timestamp = event["clusterTime"]
now_time = int(time.time() * 1000)
resume_history_rec = self.dispatchDB.db_sys_resume_history.find_one({
"collection":
collection_name,
"handler_name":
handler_name
})
if resume_history_rec != None:
self.dispatchDB.db_sys_resume_history.update(
{
"collection": collection_name,
"handler_name": handler_name
}, {
"$set": {
"resume_token": resume_token,
"operation_type": operation_type,
"document_key": document_key,
"cluster_time": mgd_timestamp,
"rec_timestamp": now_time
}
})
else:
sys_resume_history = database.new(self.dispatchDB,
"db_sys_resume_history")
sys_resume_history.put("resume_token", resume_token)
sys_resume_history.put("operation_type", operation_type)
sys_resume_history.put("document_key", document_key)
sys_resume_history.put("cluster_time", mgd_timestamp)
sys_resume_history.put("handler_name", handler_name)
sys_resume_history.put("collection", collection_name)
sys_resume_history.insert()
def edit_document(meeting_id, document_id=None):
app = flask.current_app
session = database.get_session()
meeting = sugar.get_object_or_404(models.Meeting, id=meeting_id)
page_info = {}
if document_id:
document_row = database.get_or_404('document', document_id)
document = schema.Document.from_flat(document_row)
page_info['title'] = 'Edit %s' % document['name']
else:
document_row = None
document = None
page_info['title'] = 'Add document'
if flask.request.method == 'POST':
doc = flask.request.files['file']
form_dict = flask.request.form.to_dict()
form_data = dict(schema.DocumentSchema.from_defaults().flatten())
form_data.update(form_dict)
lang = form_dict['language']
form_data['meeting_id'] = meeting.id
form_data['date'] = str(date.today())
# old files should be kept
db_file = session.get_db_file()
if document_row:
form_data['doc_id_E'] = document_row['doc_id_E']
form_data['doc_id_F'] = document_row['doc_id_F']
form_data['doc_id_S'] = document_row['doc_id_S']
form_data['filename_E'] = document_row['filename_E']
form_data['filename_F'] = document_row['filename_F']
form_data['filename_S'] = document_row['filename_S']
if doc.filename:
form_data['doc_id_%s' % lang] = db_file.id
form_data['filename_%s' % lang] = doc.filename
document_schema = schema.DocumentSchema.from_flat(form_data)
if document_schema.validate():
db_file.save_from(doc)
if document_row is None:
document_row = database.new('document')
document_row.update(document_schema.flatten())
session.save(document_row)
session.commit()
flask.flash('Document saved', 'success')
location = flask.url_for('meeting.documents',
meeting_id=meeting.id)
return flask.redirect(location)
else:
flask.flash(u'Errors in document information', 'error')
else:
if document_id:
document_schema = schema.DocumentSchema.from_flat(document_row)
else:
document_schema = schema.DocumentSchema()
return {
'mk': sugar.MarkupGenerator(
app.jinja_env.get_template('widgets/widgets_documents.html')
),
'meeting': meeting,
'document': document,
'document_schema': document_schema,
'document_id': document_id,
'page_info': page_info,
}
def send_mail(meeting_id):
app = flask.current_app
session = database.get_session()
meeting = sugar.get_object_or_404(models.Meeting, id=meeting_id)
all_categories = meeting.get_categories()
if flask.request.method == 'POST':
mail = Mail(app)
initial_form_data = flask.request.form
form_data = initial_form_data.to_dict()
categories = initial_form_data.getlist('mail_categories')
categories = map(int, categories)
mail_schema = schema.BulkMailSchema.from_flat(form_data)
mail_schema['categories'].set(categories)
mail_schema.set_category_labels(all_categories)
if mail_schema.validate():
mail_data = {}
mail_data.update(mail_schema.flatten())
mail_data['mail_categories'] = categories
lang = form_data['mail_to']
filters = {
'personal_language': lang
}
if not categories:
persons = (models.Person.select().where(data__contains=filters))
persons = sugar.append_persons_query(persons, meeting_id)
recipients = set([p.data['personal_email']
for p in persons if p.data.get('personal_email')])
else:
persons = (
models.Person.select().where(data__contains=filters)
.where(data_value_in('personal_category',
map(str, categories)))
)
persons = sugar.append_persons_query(persons, meeting_id)
recipients = set([p.data['personal_email']
for p in persons if p.data.get('personal_email')])
with mail.connect() as conn:
for person in recipients:
msg = Message(mail_data['mail_subject'],
sender=meeting.data['info_admin_email'],
recipients=[person],
body=mail_data['mail_message'])
conn.send(msg)
mail_log_data = {
'date': date.today(),
'meeting_id': meeting.id,
'type': 'bulk_mail',
}
mail_log_data.update(mail_data)
mail_log_schema = schema.BulkMailLogSchema.from_flat(mail_log_data)
mail_log_schema.set_category_labels(all_categories)
if mail_log_schema.validate():
mail_log_row = database.new('mail_log')
mail_log_row.update(mail_log_schema.flatten())
session.save(mail_log_row)
session.commit()
language = refdata.language.get(lang)
if app.config['MAIL_SUPPRESS_SEND']:
flask.flash(u'This is a demo, no real email was sent', 'info')
else:
success_msg = u'Mail sent to all %s speakers' % language
flask.flash(success_msg, 'success')
return flask.redirect(flask.url_for('meeting.send_mail',
meeting_id=meeting.id))
else:
flask.flash(u'Errors in mail information', 'error')
else:
mail_schema = schema.BulkMailSchema({})
mail_schema.set_category_labels(all_categories)
return {
'mk': sugar.MarkupGenerator(
app.jinja_env.get_template('widgets/widgets_mail.html')
),
'meeting': meeting,
'mail_schema': mail_schema,
}
def test_noExistingDatabase(self):
database.new()
self.checkMigrationOk()
def send_mail(meeting_id, person_id):
app = flask.current_app
meeting = sugar.get_object_or_404(models.Meeting, id=meeting_id)
session = database.get_session()
person = sugar.get_person_or_404(meeting_id, person_id)
lang_code = person.decoded_data['personal_language'] or 'en'
labeled = schema.labels_for_values(person.data, meeting_id,
in_participant_language=True)
category = person.category_model(meeting_id)
cc_addresses = []
phrases = {p.data['name']: p for p in meeting.get_phrases}
event_form = EventCitesForm(meeting_model=meeting, person=person)
if flask.request.method == "POST":
mail = Mail(app)
form_data = flask.request.form.to_dict()
if form_data['mail_to'].find(',') != -1:
to_addresses = form_data['mail_to'].split(',')
if form_data.get('mail_cc'):
cc_addresses = form_data['mail_cc'].split(',')
else:
to_addresses = form_data["mail_to"].split(";")
if form_data.get('mail_cc'):
cc_addresses = form_data["mail_cc"].split(";")
# populate schema with data from POST
mail_schema = schema.MailSchema.from_flat(form_data)
to_member_schema = mail_schema['to'].member_schema
cc_member_schema = mail_schema['cc'].member_schema
for address in to_addresses:
mail_schema['to'].append(to_member_schema(address))
for address in cc_addresses:
mail_schema['cc'].append(cc_member_schema(address))
if mail_schema.validate():
# flatten schema
mail_data = {}
mail_data.update(mail_schema.flatten())
mail_data['mail_to'] = to_addresses
mail_data['mail_cc'] = cc_addresses
# construct recipients from "to"
recipients = mail_data['mail_to']
# send email
msg = Message(mail_data['mail_subject'],
sender = meeting.decoded_data['info_admin_email'],
recipients=recipients,
cc=mail_data['mail_cc'],
body=mail_data['mail_message'])
# render form in participant language
participant_lang = {"E": "en", "S": "es", "F": "fr"}.get(person.lang, "E")
sugar.set_lang(participant_lang)
pdf = sugar.generate_pdf_from_html(
flask.render_template('participant/credentials.html', **{
'person': person,
'meeting': meeting,
'credentials_strings': refdata.credentials_strings,
'labeled': labeled,
'phrases': phrases,
'category': category,
'event_form': event_form,
})
)
msg.attach('registration_details.pdf', 'application/pdf', pdf)
mail.send(msg)
# log mail
mail_log_data = {
'date': date.today(),
'meeting_id': meeting.id,
'person_id': person_id,
'type': 'single_mail',
}
mail_log_data.update(mail_data)
mail_log_schema = schema.MailLogSchema.from_flat(mail_log_data)
if mail_log_schema.validate():
mail_log_row = database.new('mail_log')
mail_log_row.update(mail_log_schema.flatten())
session.save(mail_log_row)
session.commit()
# update acknowledged date
person.update_meeting_flags(meeting_id, {
'meeting_flags_acknowledged': str(datetime.now().replace(
second=0, microsecond=0))
})
if app.config['MAIL_SUPPRESS_SEND']:
flask.flash(u'This is a demo, no real email was sent', 'info')
else:
# flash a success message
success_msg = u'Mail sent to %d recipients.' % (
len(to_addresses) + len(cc_addresses))
flask.flash(success_msg, 'success')
return flask.redirect(
flask.url_for('participant.send_mail',
meeting_id=meeting_id,
person_id=person_id))
else:
flask.flash(u'Errors in mail information', 'error')
else:
# create a schema with default data
mail_schema = schema.MailSchema({
'to': [person.data['personal_email']],
'subject': phrases['EM_Subj'].decoded_data['description_%s' % lang_code],
'message': '\n\n\n%s' % phrases['Intro'].decoded_data['description_%s' % lang_code],
})
return {
'mk': sugar.MarkupGenerator(
app.jinja_env.get_template('widgets/widgets_mail.html')
),
'person': person,
'category': category,
'mail_schema': mail_schema,
'meeting': meeting,
'phrases': phrases,
}
