def get_tip_export(store, user_id, rtip_id, language):
rtip = db_access_rtip(store, user_id, rtip_id)
receiver = rtip.receiver
rtip_dict = serialize_rtip(store, rtip, language)
export_dict = {
'type': u'export_template',
'node': db_admin_serialize_node(store, language),
'notification': db_get_notification(store, language),
'tip': serialize_rtip(store, rtip, language),
'context': admin_serialize_context(store, rtip.internaltip.context, language),
'receiver': admin_serialize_receiver(receiver, language),
'comments': rtip_dict['comments'],
'messages': rtip_dict['messages'],
'files': []
}
export_template = Templating().format_template(export_dict['notification']['export_template'], export_dict).encode('utf-8')
export_dict['files'].append({'buf': export_template, 'name': "data.txt"})
for rf in store.find(models.ReceiverFile, models.ReceiverFile.receivertip_id == rtip_id):
rf.downloads += 1
file_dict = serialize_receiver_file(rf)
file_dict['name'] = 'files/' + file_dict['name']
export_dict['files'].append(copy.deepcopy(file_dict))
return export_dict
def get_tip_export(store, user_id, rtip_id, language):
rtip = db_access_rtip(store, user_id, rtip_id)
receiver = rtip.receiver
rtip_dict = serialize_rtip(store, rtip, language)
export_dict = {
'type':
u'export_template',
'node':
db_admin_serialize_node(store, language),
'notification':
db_get_notification(store, language),
'tip':
serialize_rtip(store, rtip, language),
'context':
admin_serialize_context(store, rtip.internaltip.context, language),
'receiver':
admin_serialize_receiver(store, receiver, language),
'comments':
rtip_dict['comments'],
'messages':
rtip_dict['messages'],
'files': []
}
export_template = Templating().format_template(
export_dict['notification']['export_template'],
export_dict).encode('utf-8')
export_template = msdos_encode(export_template)
export_dict['files'].append({'buf': export_template, 'name': "data.txt"})
for rf in store.find(models.ReceiverFile,
models.ReceiverFile.receivertip_id == rtip_id):
rf.downloads += 1
file_dict = models.serializers.serialize_rfile(rf)
file_dict['name'] = 'files/' + file_dict['name']
export_dict['files'].append(file_dict)
rtips_ids = [rt.id for rt in rtip.internaltip.receivertips]
wfs = store.find(models.WhistleblowerFile,
In(models.WhistleblowerFile.receivertip_id, rtips_ids))
for wf in wfs:
file_dict = models.serializers.serialize_wbfile(wf)
file_dict['name'] = 'files_from_recipients/' + file_dict['name']
export_dict['files'].append(file_dict)
return export_dict
def serialize_obj(self, store, key, obj, language):
obj_id = obj.id
cache_key = key + '-' + obj_id + '-' + language
cache_obj = None
if cache_key not in self.cache:
if key == 'user':
cache_obj = user_serialize_user(store, obj, language)
elif key == 'context':
cache_obj = admin_serialize_context(store, obj, language)
elif key == 'tip':
itip = store.find(models.InternalTip,
id=obj.internaltip_id).one()
cache_obj = serialize_rtip(store, obj, itip, language)
elif key == 'message':
cache_obj = serialize_message(store, obj)
elif key == 'comment':
cache_obj = serialize_comment(store, obj)
elif key == 'file':
cache_obj = models.serializers.serialize_ifile(store, obj)
self.cache[cache_key] = cache_obj
return self.cache[cache_key]
def process_event(self, store, comment):
comment_desc = serialize_comment(comment)
context_desc = admin.context.admin_serialize_context(store,
comment.internaltip.context,
self.language)
# for every comment, iterate on the associated receiver(s)
log.debug("Comments from %s - Receiver(s) %d" % \
(comment.author, comment.internaltip.receivers.count()))
for receiver in comment.internaltip.receivers:
if comment.type == u'receiver' and comment.author == receiver.user.name:
log.debug("Receiver is the Author (%s): skipped" % receiver.user.username)
return
receivertip = store.find(models.ReceiverTip,
(models.ReceiverTip.internaltip_id == comment.internaltip_id,
models.ReceiverTip.receiver_id == receiver.id)).one()
tip_desc = serialize_rtip(store, receivertip, self.language)
do_mail, receiver_desc = self.import_receiver(receiver)
self.events.append(Event(type=self.template_type,
trigger=self.trigger,
node_info={},
receiver_info=receiver_desc,
context_info=context_desc,
tip_info=tip_desc,
subevent_info=comment_desc,
do_mail=do_mail))
def process_event(self, store, comment):
comment_desc = serialize_comment(comment)
context_desc = admin.context.admin_serialize_context(
store, comment.internaltip.context, self.language)
# for every comment, iterate on the associated receiver(s)
log.debug("Comments from %s - Receiver(s) %d" % \
(comment.author, comment.internaltip.receivers.count()))
for receiver in comment.internaltip.receivers:
if comment.type == u'receiver' and comment.author == receiver.user.name:
log.debug("Receiver is the Author (%s): skipped" %
receiver.user.username)
return
receivertip = store.find(
models.ReceiverTip,
(models.ReceiverTip.internaltip_id == comment.internaltip_id,
models.ReceiverTip.receiver_id == receiver.id)).one()
tip_desc = serialize_rtip(store, receivertip, self.language)
do_mail, receiver_desc = self.import_receiver(receiver)
self.events.append(
Event(type=self.template_type,
trigger=self.trigger,
node_info={},
receiver_info=receiver_desc,
context_info=context_desc,
tip_info=tip_desc,
subevent_info=comment_desc,
do_mail=do_mail))
def get_rtips(self, store):
ret = []
for r, i in store.find((models.ReceiverTip, models.InternalTip),
models.ReceiverTip.internaltip_id == models.InternalTip.id):
ret.append(rtip.serialize_rtip(store, r, i, 'en'))
return ret
def serialize_obj(self, session, key, obj, tid, language):
obj_id = obj.id
cache_key = gen_cache_key(key, tid, obj_id, language)
cache_obj = None
if cache_key not in self.cache:
if key == 'user':
cache_obj = user_serialize_user(session, obj, language)
elif key == 'context':
cache_obj = admin_serialize_context(session, obj, language)
elif key == 'tip':
itip = session.query(models.InternalTip).filter(
models.InternalTip.id == obj.internaltip_id).one()
cache_obj = serialize_rtip(session, obj, itip, language)
elif key == 'message':
cache_obj = serialize_message(session, obj)
elif key == 'comment':
cache_obj = serialize_comment(session, obj)
elif key == 'file':
cache_obj = models.serializers.serialize_ifile(session, obj)
self.cache[cache_key] = cache_obj
return self.cache[cache_key]
def check_for_expiring_submissions(self, store):
threshold = datetime_now() - timedelta(
GLSettings.memory_copy.tip_expiration_threshold)
for itip in store.find(models.InternalTip,
models.InternalTip.expiration_date < threshold):
for rtip in itip.receivertips:
user = rtip.receiver.user
language = user.language
node_desc = db_admin_serialize_node(store, language)
notification_desc = db_get_notification(store, language)
context_desc = admin_serialize_context(
store, rtip.internaltip.context, language)
receiver_desc = admin_serialize_receiver(
rtip.receiver, language)
tip_desc = serialize_rtip(store, rtip, user.language)
data = {
'type': u'tip_expiration',
'node': node_desc,
'context': context_desc,
'receiver': receiver_desc,
'notification': notification_desc,
'tip': tip_desc
}
subject, body = Templating().get_mail_subject_and_body(data)
mail = models.Mail({
'address': data['receiver']['mail_address'],
'subject': subject,
'body': body
})
store.add(mail)
def get_tip_export(store, user_id, rtip_id, language):
rtip = db_access_rtip(store, user_id, rtip_id)
receiver = rtip.receiver
export_dict = {
'type': u'export_template',
'node': db_admin_serialize_node(store, language),
'notification': db_get_notification(store, language),
'tip': serialize_rtip(store, rtip, language),
'context': admin_serialize_context(store, rtip.internaltip.context, language),
'receiver': admin_serialize_receiver(receiver, language),
'comments': db_get_comment_list(rtip),
'messages': db_get_message_list(rtip),
'files': []
}
export_template = Templating().format_template(export_dict['notification']['export_template'], export_dict).encode('utf-8')
export_dict['files'].append({'buf': export_template, 'name': "data.txt"})
for rf in store.find(models.ReceiverFile, models.ReceiverFile.receivertip_id == rtip_id):
rf.downloads += 1
file_dict = serialize_receiver_file(rf)
file_dict['name'] = 'files/' + file_dict['name']
export_dict['files'].append(copy.deepcopy(file_dict))
return export_dict
def check_for_expiring_submissions(self, store):
threshold = datetime_now() + timedelta(GLSettings.memory_copy.notif.tip_expiration_threshold)
for rtip in store.find(models.ReceiverTip, models.ReceiverTip.internaltip_id == models.InternalTip.id,
models.InternalTip.expiration_date < threshold):
user = rtip.receiver.user
language = user.language
node_desc = db_admin_serialize_node(store, language)
notification_desc = db_get_notification(store, language)
context_desc = admin_serialize_context(store, rtip.internaltip.context, language)
receiver_desc = admin_serialize_receiver(rtip.receiver, language)
tip_desc = serialize_rtip(store, rtip, user.language)
data = {
'type': u'tip_expiration',
'node': node_desc,
'context': context_desc,
'receiver': receiver_desc,
'notification': notification_desc,
'tip': tip_desc
}
subject, body = Templating().get_mail_subject_and_body(data)
mail = models.Mail({
'address': data['receiver']['mail_address'],
'subject': subject,
'body': body
})
store.add(mail)
def get_tip_export(session, tid, user_id, rtip_id, language):
rtip, itip = db_access_rtip(session, tid, user_id, rtip_id)
user, context = session.query(models.User, models.Context) \
.filter(models.User.id == rtip.receiver_id,
models.Context.id == models.InternalTip.context_id,
models.InternalTip.id == rtip.internaltip_id,
models.User.tid == tid).one()
rtip_dict = serialize_rtip(session, rtip, itip, language)
export_dict = {
'type':
'export_template',
'node':
db_admin_serialize_node(session, tid, language),
'notification':
db_get_notification(session, tid, language),
'tip':
rtip_dict,
'crypto_tip_prv_key':
rtip.crypto_tip_prv_key,
'user':
user_serialize_user(session, user, language),
'context':
admin_serialize_context(session, context, language),
'comments':
rtip_dict['comments'],
'messages':
rtip_dict['messages'],
'files': [],
'submission_statuses':
db_retrieve_all_submission_statuses(session, tid, language)
}
for rfile in session.query(models.ReceiverFile).filter(
models.ReceiverFile.receivertip_id == rtip_id):
rfile.last_access = datetime_now()
rfile.downloads += 1
file_dict = models.serializers.serialize_rfile(session, tid, rfile)
file_dict['name'] = 'files/' + file_dict['name']
file_dict['path'] = os.path.join(Settings.attachments_path,
file_dict['filename'])
file_dict['forged'] = False
export_dict['files'].append(file_dict)
for wf in session.query(models.WhistleblowerFile).filter(
models.WhistleblowerFile.receivertip_id == models.ReceiverTip.id,
models.ReceiverTip.internaltip_id == rtip.internaltip_id,
models.InternalTip.id == rtip.internaltip_id):
file_dict = models.serializers.serialize_wbfile(session, tid, wf)
file_dict['name'] = 'files_from_recipients/' + file_dict['name']
file_dict['path'] = os.path.join(Settings.attachments_path,
file_dict['filename'])
file_dict[
'forged'] = True # To be removed as soon it will be encrypted
export_dict['files'].append(file_dict)
return export_dict
def get_rtips(self, store):
ret = []
for tip in store.find(models.ReceiverTip):
x = rtip.serialize_rtip(store, tip, 'en')
x['receiver_id'] = tip.receiver.id
ret.append(x)
return ret
def get_rtips(self, session):
ret = []
for r, i in session.query(models.ReceiverTip, models.InternalTip) \
.filter(models.ReceiverTip.internaltip_id == models.InternalTip.id,
models.InternalTip.tid == 1):
ret.append(rtip.serialize_rtip(session, r, i, 'en'))
return ret
def process_ReceiverTip(self, store, rtip, data):
language = rtip.receiver.user.language
data['tip'] = serialize_rtip(store, rtip, language)
data['context'] = admin_serialize_context(store, rtip.internaltip.context, language)
data['receiver'] = admin_serialize_receiver(rtip.receiver, language)
self.process_mail_creation(store, data)
def get_rtips(self, session):
ret = []
for r, i in session.query(models.ReceiverTip, models.InternalTip) \
.filter(models.ReceiverTip.internaltip_id == models.InternalTip.id,
models.InternalTip.tid == 1):
ret.append(rtip.serialize_rtip(session, r, i, 'en'))
return ret
def get_rtips(self, store):
ret = []
for tip in store.find(models.ReceiverTip):
x = rtip.serialize_rtip(store, tip, 'en')
x['receiver_id'] = tip.receiver_id
ret.append(x)
return ret
def get_tip_export(session, tid, user_id, rtip_id, language):
rtip, itip = db_access_rtip(session, tid, user_id, rtip_id)
user, context = session.query(models.User, models.Context) \
.filter(models.User.id == rtip.receiver_id,
models.Context.id == models.InternalTip.context_id,
models.InternalTip.id == rtip.internaltip_id,
models.UserTenant.user_id == models.User.id,
models.UserTenant.tenant_id == tid).one()
rtip_dict = serialize_rtip(session, rtip, itip, language)
export_dict = {
'type': u'export_template',
'node': db_admin_serialize_node(session, tid, language),
'notification': db_get_notification(session, tid, language),
'tip': rtip_dict,
'user': user_serialize_user(session, user, language),
'context': admin_serialize_context(session, context, language),
'comments': rtip_dict['comments'],
'messages': rtip_dict['messages'],
'files': []
}
export_template = Templating().format_template(
export_dict['notification']['export_template'],
export_dict).encode('utf-8')
export_template = msdos_encode(text_type(export_template,
'utf-8')).encode('utf-8')
export_dict['files'].append({
'fo': BytesIO(export_template),
'name': "data.txt"
})
for rfile in session.query(models.ReceiverFile).filter(
models.ReceiverFile.receivertip_id == rtip_id):
rfile.last_access = datetime_now()
rfile.downloads += 1
file_dict = models.serializers.serialize_rfile(session, tid, rfile)
file_dict['name'] = 'files/' + file_dict['name']
file_dict['path'] = os.path.join(Settings.attachments_path,
file_dict['filename'])
export_dict['files'].append(file_dict)
for wf in session.query(models.WhistleblowerFile).filter(
models.WhistleblowerFile.receivertip_id == models.ReceiverTip.id,
models.ReceiverTip.internaltip_id == rtip.internaltip_id,
models.InternalTip.id == rtip.internaltip_id):
file_dict = models.serializers.serialize_wbfile(session, tid, wf)
file_dict['name'] = 'files_from_recipients/' + file_dict['name']
file_dict['path'] = os.path.join(Settings.attachments_path,
file_dict['filename'])
export_dict['files'].append(file_dict)
return export_dict
def process_Message(self, store, message, data):
# if the message is destinated to the whistleblower no mail should be sent
if message.type == u"receiver":
return
language = message.receivertip.receiver.user.language
data['message'] = serialize_message(message)
data['tip'] = serialize_rtip(store, message.receivertip, language)
data['context'] = admin_serialize_context(store, message.receivertip.internaltip.context, language)
data['receiver'] = admin_serialize_receiver(message.receivertip.receiver, language)
self.process_mail_creation(store, data)
def process_Comment(self, store, comment, data):
for rtip in comment.internaltip.receivertips:
if comment.type == u'receiver' and comment.author == rtip.receiver.user.name:
continue
language = rtip.receiver.user.language
dataX = copy.deepcopy(data)
dataX['comment'] = serialize_comment(comment)
dataX['tip'] = serialize_rtip(store, rtip, language)
dataX['context'] = admin_serialize_context(store, comment.internaltip.context, language)
dataX['receiver'] = admin_serialize_receiver(rtip.receiver, language)
self.process_mail_creation(store, dataX)
def process_event(self, store, rfile):
context_desc = admin.context.admin_serialize_context(
store, rfile.internalfile.internaltip.context, self.language)
tip_desc = serialize_rtip(store, rfile.receivertip, self.language)
file_desc = serialize_internalfile(rfile.internalfile)
do_mail, receiver_desc = self.import_receiver(rfile.receiver)
self.events.append(
Event(type=self.template_type,
trigger=self.trigger,
node_info={},
receiver_info=receiver_desc,
context_info=context_desc,
tip_info=tip_desc,
subevent_info=file_desc,
do_mail=do_mail))
def process_event(self, store, rtip):
do_mail, receiver_desc = self.import_receiver(rtip.receiver)
context_desc = admin.admin_serialize_context(store,
rtip.internaltip.context,
self.language)
expiring_tip_desc = serialize_rtip(store, rtip, self.language)
self.events.append(Event(type=self.template_type,
trigger=self.trigger,
node_info={},
receiver_info=receiver_desc,
context_info=context_desc,
tip_info=expiring_tip_desc,
subevent_info=None,
do_mail=do_mail))
def process_event(self, store, rfile):
context_desc = admin.context.admin_serialize_context(store,
rfile.internalfile.internaltip.context,
self.language)
tip_desc = serialize_rtip(store, rfile.receivertip, self.language)
file_desc = serialize_internalfile(rfile.internalfile)
do_mail, receiver_desc = self.import_receiver(rfile.receiver)
self.events.append(Event(type=self.template_type,
trigger=self.trigger,
node_info={},
receiver_info=receiver_desc,
context_info=context_desc,
tip_info=tip_desc,
subevent_info=file_desc,
do_mail=do_mail))
def db_create_identity_access_reply_notifications(session, itip, rtip, iar):
"""
Transaction for the creation of notifications related to identity access replies
:param session: An ORM session
:param itip: A itip ID of the tip involved in the request
:param iar: A identity access request model
"""
from globaleaks.handlers.rtip import serialize_rtip
for user in session.query(models.User) \
.filter(models.User.id == rtip.receiver_id,
models.User.notification.is_(True)):
context = session.query(
models.Context).filter(models.Context.id == itip.context_id).one()
data = {
'type':
'identity_access_authorized'
if iar.reply == 'authorized' else 'identity_access_denied'
}
data['user'] = user_serialize_user(session, user, user.language)
data['tip'] = serialize_rtip(session, rtip, itip, user.language)
data['context'] = admin_serialize_context(session, context,
user.language)
data['iar'] = serialize_identityaccessrequest(session, iar)
data['node'] = db_admin_serialize_node(session, user.tid,
user.language)
if data['node']['mode'] == 'default':
data['notification'] = db_get_notification(session, user.tid,
user.language)
else:
data['notification'] = db_get_notification(session, 1,
user.language)
subject, body = Templating().get_mail_subject_and_body(data)
session.add(
models.Mail({
'address': data['user']['mail_address'],
'subject': subject,
'body': body,
'tid': user.tid
}))
def process_event(self, store, rtip):
do_mail, receiver_desc = self.import_receiver(rtip.receiver)
context_desc = admin.admin_serialize_context(store,
rtip.internaltip.context,
self.language)
expiring_tip_desc = serialize_rtip(store, rtip, self.language)
self.events.append(
Event(type=self.template_type,
trigger=self.trigger,
node_info={},
receiver_info=receiver_desc,
context_info=context_desc,
tip_info=expiring_tip_desc,
subevent_info=None,
do_mail=do_mail))
def serialize_obj(self, store, key, obj, language):
obj_id = obj.id
cache_key = key + '-' + obj_id + '-' + language
if cache_key not in self.cache:
if key == 'tip':
cache_obj = serialize_rtip(store, obj, language)
elif key == 'context':
cache_obj = admin_serialize_context(store, obj, language)
elif key == 'receiver':
cache_obj = admin_serialize_receiver(obj, language)
elif key == 'message':
cache_obj = serialize_message(obj)
elif key == 'comment':
cache_obj = serialize_comment(obj)
elif key == 'file':
cache_obj = serialize_internalfile(obj)
self.cache[cache_key] = cache_obj
return self.cache[cache_key]
def serialize_obj(self, store, key, obj, language):
obj_id = obj.id
cache_key = key + '-' + obj_id + '-' + language
if cache_key not in self.cache:
if key == 'tip':
cache_obj = serialize_rtip(store, obj, language)
elif key == 'context':
cache_obj = admin_serialize_context(store, obj, language)
elif key == 'receiver':
cache_obj = admin_serialize_receiver(obj, language)
elif key == 'message':
cache_obj = serialize_message(obj)
elif key == 'comment':
cache_obj = serialize_comment(obj)
elif key == 'file':
cache_obj = serialize_internalfile(obj)
self.cache[cache_key] = cache_obj
return self.cache[cache_key]
def serialize_content(store, cache, key, obj, language):
obj_id = obj.id
cache_key = key + obj_id + language
if cache_key not in cache:
if key == 'tip':
cache_obj = serialize_rtip(store, obj, language)
elif key == 'context':
cache_obj = admin_serialize_context(store, obj, language)
elif key == 'receiver':
cache_obj = admin_serialize_receiver(obj, language)
elif key == 'message':
cache_obj = serialize_message(obj)
elif key == 'comment':
cache_obj = serialize_comment(obj)
elif key == 'file':
cache_obj = serialize_internalfile(obj)
cache[cache_key] = cache_obj
return copy.deepcopy(cache[cache_key])
def serialize_content(store, cache, key, obj, language):
obj_id = obj.id
cache_key = key + obj_id + language
if cache_key not in cache:
if key == 'tip':
cache_obj = serialize_rtip(store, obj, language)
elif key == 'context':
cache_obj = admin_serialize_context(store, obj, language)
elif key == 'receiver':
cache_obj = admin_serialize_receiver(obj, language)
elif key == 'message':
cache_obj = serialize_message(obj)
elif key == 'comment':
cache_obj = serialize_comment(obj)
elif key == 'file':
cache_obj = serialize_internalfile(obj)
cache[cache_key] = cache_obj
return copy.deepcopy(cache[cache_key])
def get_tip_export(session, tid, user_id, rtip_id, language):
rtip, itip = db_access_rtip(session, tid, user_id, rtip_id)
user, context = session.query(models.User, models.Context) \
.filter(models.User.id == rtip.receiver_id,
models.Context.id == models.InternalTip.context_id,
models.InternalTip.id == rtip.internaltip_id,
models.User.tid == tid).one()
rtip_dict = serialize_rtip(session, rtip, itip, language)
return {
'type': 'export_template',
'node': db_admin_serialize_node(session, tid, language),
'notification': db_get_notification(session, tid, language),
'tip': rtip_dict,
'crypto_tip_prv_key': Base64Encoder.decode(rtip.crypto_tip_prv_key),
'user': user_serialize_user(session, user, language),
'context': admin_serialize_context(session, context, language),
'submission_statuses':
db_get_submission_statuses(session, tid, language)
}
def process_event(self, store, message):
message_desc = serialize_message(message)
# message.type can be 'receiver' or 'wb' at the moment, we care of the latter
if message.type == u"receiver":
return
tip_desc = serialize_rtip(store, message.receivertip, self.language)
context_desc = admin.context.admin_serialize_context(store,
message.receivertip.internaltip.context,
self.language)
do_mail, receiver_desc = self.import_receiver(message.receivertip.receiver)
self.events.append(Event(type=self.template_type,
trigger=self.trigger,
node_info={},
receiver_info=receiver_desc,
context_info=context_desc,
tip_info=tip_desc,
subevent_info=message_desc,
do_mail=do_mail))
def serialize_obj(self, session, key, obj, tid, language):
obj_id = obj.id
cache_key = gen_cache_key(key, tid, obj_id, language)
cache_obj = None
if cache_key not in self.cache:
if key == 'user':
cache_obj = user_serialize_user(session, obj, language)
elif key == 'context':
cache_obj = admin_serialize_context(session, obj, language)
elif key == 'tip':
itip = session.query(models.InternalTip).filter(models.InternalTip.id == obj.internaltip_id).one()
cache_obj = serialize_rtip(session, obj, itip, language)
elif key == 'message':
cache_obj = serialize_message(session, obj)
elif key == 'comment':
cache_obj = serialize_comment(session, obj)
elif key == 'file':
cache_obj = models.serializers.serialize_ifile(session, obj)
self.cache[cache_key] = cache_obj
return self.cache[cache_key]
def process_event(self, store, message):
message_desc = serialize_message(message)
# message.type can be 'receiver' or 'wb' at the moment, we care of the latter
if message.type == u"receiver":
return
tip_desc = serialize_rtip(store, message.receivertip, self.language)
context_desc = admin.context.admin_serialize_context(
store, message.receivertip.internaltip.context, self.language)
do_mail, receiver_desc = self.import_receiver(
message.receivertip.receiver)
self.events.append(
Event(type=self.template_type,
trigger=self.trigger,
node_info={},
receiver_info=receiver_desc,
context_info=context_desc,
tip_info=tip_desc,
subevent_info=message_desc,
do_mail=do_mail))
def get_file_collection(store, user_id, rtip_id):
rtip = db_access_rtip(store, user_id, rtip_id)
archive_dict = {'files': [], 'file_counter': 0, 'total_size': 0}
file_list = []
for rf in store.find(models.ReceiverFile, models.ReceiverFile.receivertip_id == rtip_id):
rf.downloads += 1
file_list.append(serialize_receiver_file(rf))
archive_dict['file_counter'] += 1
archive_dict['total_size'] += rf.size
archive_dict['files'].append(serialize_receiver_file(rf))
receiver = rtip.receiver
user_language = receiver.user.language
data = {
'type': u'archive_description',
'node': db_admin_serialize_node(store, user_language),
'notification': db_get_notification(store, user_language),
'tip': serialize_rtip(store, rtip, user_language),
'context': admin_serialize_context(store, rtip.internaltip.context, user_language),
'receiver': admin_serialize_receiver(receiver, user_language),
'archive': archive_dict
}
archive_description = Templating().format_template(data['notification']['archive_description'], data).encode('utf-8')
file_list.append(
{
'buf': archive_description,
'name': "COLLECTION_INFO.txt"
}
)
return file_list
def generate(self, session):
mailcount = 0
now = datetime_now()
rtips_ids = {}
silent_tids = []
reminder_time = self.state.tenant_cache[1].unread_reminder_time if 1 in self.state.tenant_cache else 7
for tid, cache_item in self.state.tenant_cache.items():
if cache_item.notification and cache_item.notification.disable_receiver_notification_emails:
silent_tids.append(tid)
results1 = session.query(models.User, models.ReceiverTip, models.InternalTip, models.ReceiverTip) \
.filter(models.User.id == models.ReceiverTip.receiver_id,
models.InternalTip.id == models.ReceiverTip.internaltip_id,
models.ReceiverTip.new.is_(True)) \
.order_by(models.InternalTip.creation_date)
results2 = session.query(models.User, models.ReceiverTip, models.InternalTip, models.Comment) \
.filter(models.User.id == models.ReceiverTip.receiver_id,
models.ReceiverTip.internaltip_id == models.Comment.internaltip_id,
models.InternalTip.id == models.ReceiverTip.internaltip_id,
models.Comment.new.is_(True)) \
.order_by(models.Comment.creation_date)
results3 = session.query(models.User, models.ReceiverTip, models.InternalTip, models.Message) \
.filter(models.User.id == models.ReceiverTip.receiver_id,
models.ReceiverTip.id == models.Message.receivertip_id,
models.InternalTip.id == models.ReceiverTip.internaltip_id,
models.Message.new.is_(True)) \
.order_by(models.Message.creation_date)
results4 = session.query(models.User, models.ReceiverTip, models.InternalTip, models.ReceiverFile) \
.filter(models.User.id == models.ReceiverTip.receiver_id,
models.ReceiverTip.id == models.ReceiverFile.receivertip_id,
models.InternalTip.id == models.ReceiverTip.internaltip_id,
models.InternalFile.id == models.ReceiverFile.internalfile_id,
models.InternalFile.submission.is_(False),
models.ReceiverFile.new.is_(True)) \
.order_by(models.InternalFile.creation_date)
for user, rtip, itip, obj in itertools.chain(results1, results2, results3, results4):
tid = user.tid
if (rtips_ids.get(rtip.id, False) or tid in silent_tids) or \
(isinstance(obj, models.Comment) and obj.type != 'whistleblower' and obj.author_id == user.id) or \
(isinstance(obj, models.Message) and obj.type == 'receiver'):
obj.new = False
continue
elif mailcount >= 20:
continue
obj.new = False
rtips_ids[rtip.id] = True
try:
if isinstance(obj, models.ReceiverTip):
data = {'type': 'tip'}
else:
data = {'type': 'tip_update'}
data['user'] = user_serialize_user(session, user, user.language)
data['tip'] = serialize_rtip(session, rtip, itip, user.language)
self.process_mail_creation(session, tid, data)
except:
pass
mailcount += 1
for user in session.query(models.User).filter(and_(models.User.reminder_date < now - timedelta(reminder_time),
or_(and_(models.User.id == models.ReceiverTip.receiver_id,
models.ReceiverTip.access_counter == 0,
models.ReceiverTip.internaltip_id == models.InternalTip.id,
models.InternalTip.creation_date < now - timedelta(reminder_time))),
and_(models.User.id == models.ReceiverTip.receiver_id,
models.ReceiverTip.last_access < models.InternalTip.update_date,
models.ReceiverTip.internaltip_id == models.InternalTip.id,
models.InternalTip.update_date < now - timedelta(reminder_time)))).distinct():
tid = user.tid
if tid in silent_tids:
continue
elif mailcount >= 20:
return
user.reminder_date = now
data = {'type': 'unread_tips'}
try:
data['user'] = self.serialize_obj(session, 'user', user, tid, user.language)
self.process_mail_creation(session, tid, data)
except:
pass
mailcount += 1
def check_for_expiring_submissions(self, store):
threshold = datetime_now() + timedelta(
hours=GLSettings.memory_copy.notif.tip_expiration_threshold)
receivers = store.find(models.Receiver)
for receiver in receivers:
rtips = store.find(
models.ReceiverTip,
models.ReceiverTip.internaltip_id == models.InternalTip.id,
models.InternalTip.expiration_date < threshold,
models.ReceiverTip.receiver_id == models.Receiver.id,
models.Receiver.id == receiver.id)
if rtips.count() == 0:
continue
user = receiver.user
language = user.language
node_desc = db_admin_serialize_node(store, language)
notification_desc = db_get_notification(store, language)
receiver_desc = admin_serialize_receiver(store, receiver, language)
if rtips.count() == 1:
rtip = rtips[0]
tip_desc = serialize_rtip(store, rtip, user.language)
context_desc = admin_serialize_context(
store, rtip.internaltip.context, language)
data = {
'type': u'tip_expiration',
'node': node_desc,
'context': context_desc,
'receiver': receiver_desc,
'notification': notification_desc,
'tip': tip_desc
}
else:
tips_desc = []
earliest_expiration_date = datetime_never()
for rtip in rtips:
if rtip.internaltip.expiration_date < earliest_expiration_date:
earliest_expiration_date = rtip.internaltip.expiration_date
tips_desc.append(serialize_rtip(store, rtip,
user.language))
data = {
'type':
u'tip_expiration_summary',
'node':
node_desc,
'notification':
notification_desc,
'receiver':
receiver_desc,
'expiring_submission_count':
rtips.count(),
'earliest_expiration_date':
datetime_to_ISO8601(earliest_expiration_date)
}
subject, body = Templating().get_mail_subject_and_body(data)
mail = models.Mail({
'address': receiver_desc['mail_address'],
'subject': subject,
'body': body
})
store.add(mail)
