def _generate_unassigned_qr_codes_excel_for_app(app_id, amount, user_email):
logging.info('Generating %d qr code urls and saving to excel sheet' %
amount)
qr_codes = generate_unassigned_short_urls(app_id, amount)
solution_server_settings = get_solution_server_settings()
book = xlwt.Workbook(encoding="utf-8")
qr_sheet = book.add_sheet('qrcodes')
base_url = get_server_settings().baseUrl
for i, short_url in enumerate(qr_codes):
qr_sheet.write(i, 0, short_url.qr_code_content_with_base_url(base_url))
excel_file = StringIO()
book.save(excel_file)
current_date = format_date(datetime.date.today(), locale=DEFAULT_LANGUAGE)
subject = 'Generated QR code links (%d) for %s' % (amount, str(app_id))
from_email = solution_server_settings.shop_export_email
to_emails = [user_email]
body_text = 'See attachment for the requested links to the QR codes.'
attachments = []
attachments.append(('%s generated QR codes(%d) %s.xls' %
(str(app_id), amount, current_date),
base64.b64encode(excel_file.getvalue())))
send_mail(from_email,
to_emails,
subject,
body_text,
attachments=attachments)
def get(self):
settings = get_server_settings()
secret = self.request.headers.get("X-Nuntiuz-Secret", None)
if secret != settings.jabberSecret:
logging.error("Received unauthenticated apple certificate request, ignoring ...")
return
app_id = self.request.get("id")
if not app_id:
return
app = get_app_by_id(app_id)
if not app:
return
if app.apple_push_cert_valid_until < now() + 30 * DAY:
send_mail(settings.dashboardEmail,
settings.supportWorkers,
"The APN cert of %s is about to expire" % app_id,
"The APN cert of %s is valid until %s GMT" % (app_id, time.ctime(app.apple_push_cert_valid_until)))
if app.apple_push_cert_valid_until < now() + 15 * DAY:
logging.error("The APN cert of %s is valid until %s GMT" % (app_id, time.ctime(app.apple_push_cert_valid_until)))
result = json.dumps(dict(cert=app.apple_push_cert, key=app.apple_push_key, valid_until=app.apple_push_cert_valid_until))
self.response.headers['Content-Type'] = 'application/binary'
_, data = encrypt_for_jabber_cloud(secret, result)
self.response.write(data)
def reset_password(email, sender_name=u'Rogerthat', set_password_route=None):
# XXX: Validating the email would be an improvement
user = users.User(email)
profile_info = get_profile_info(user)
if not profile_info:
return False
if not rate_signup_reset_password(user, os.environ.get('HTTP_X_FORWARDED_FOR', None)):
return False
request = GenericRESTRequestHandler.getCurrentRequest()
language = get_languages_from_request(request)[0]
settings = get_server_settings()
if not set_password_route:
set_password_route = '/setpassword'
action = localize(language, "password reset")
name = profile_info.name
url_params = get_reset_password_url_params(name, user, action)
link = '%s%s?%s' % (settings.baseUrl, set_password_route, url_params)
# The use of the variable "key" is to let it pass the unittests
key = 'app_website_' + sender_name.lower()
sender_website = localize(language, key)
key = sender_name
sender_name = localize(language, key)
vars_ = dict(link=link, name=name, app_name=sender_name, app_website=sender_website, language=language)
body = JINJA_ENVIRONMENT.get_template('generic/reset_password.tmpl').render(vars_)
html = JINJA_ENVIRONMENT.get_template('generic/reset_password_html.tmpl').render(vars_)
logging.info("Sending message to %s\n%s" % (email, body))
subject = u' - '.join((sender_name, action))
utils.send_mail(settings.senderEmail2ToBeReplaced, email, subject, body, html=html)
return True
def _generate_unassigned_qr_codes_svgs_for_app(app_id, amount, user_email):
logging.info('Generating %d qr code urls and rendering them as svg' %
amount)
qr_codes = generate_unassigned_short_urls(app_id, amount)
base_url = get_server_settings().baseUrl
stream = StringIO()
with zipfile.ZipFile(stream, 'w', zipfile.ZIP_DEFLATED) as zip_file:
for i, short_url in enumerate(qr_codes):
url = short_url.qr_code_content_with_base_url(base_url)
qr_content = generate_qr_code(url, None, '000000', None, svg=True)
zip_file.writestr('qr-%s.svg' % i, qr_content)
stream.seek(0)
zip_content = stream.getvalue()
if DEBUG:
from google.appengine.tools.devappserver2.python.stubs import FakeFile
FakeFile.ALLOWED_MODES = frozenset(['a', 'r', 'w', 'rb', 'U', 'rU'])
with open('qrcodes.zip', 'w') as f:
f.write(zip_content)
else:
solution_server_settings = get_solution_server_settings()
current_date = format_date(datetime.date.today(),
locale=DEFAULT_LANGUAGE)
subject = 'Generated QR code links (%d) for %s' % (amount, str(app_id))
from_email = solution_server_settings.shop_export_email
to_emails = [user_email]
body_text = 'See attachment for the QR codes in SVG format.'
attachments = []
attachments.append(('%s generated QR codes(%d) %s.xls' %
(str(app_id), amount, current_date),
base64.b64encode(zip_content)))
send_mail(from_email,
to_emails,
subject,
body_text,
attachments=attachments)
def get(self):
queries = {}
for ns in NewsStream.query():
ng_count = NewsGroup.list_by_app_id(ns.app_id).count(None)
if ng_count == 0:
continue
ids = [i for i in xrange(1, 21)]
ids.append(999)
queries[ns.app_id] = [NewsSettingsService.list_setup_needed(ns.app_id, i).count_async(None) for i in ids]
data = []
for app_id in queries:
setup_count = 0
for qry in queries[app_id]:
setup_count += qry.get_result()
if setup_count > 0:
data.append({'app_id': app_id, 'count': setup_count})
if not data:
return
r = ''
for d in sorted(data, key=lambda x:-x['count']):
r += '%s: %s services\n' % (d['app_id'], d['count'])
server_settings = get_server_settings()
send_mail(server_settings.dashboardEmail,
server_settings.news_admin_emails,
'News group setup required',
'Setup services here: %s/mobiadmin/google/news\nThe following apps have unconnected news services:\n\n%s' % (server_settings.baseUrl, r))
def job():
settings = get_server_settings()
customers = list(Customer.all().fetch(10))
customers_per_app = defaultdict(list)
for customer in customers:
customers_per_app[customer.default_app_id].append(customer)
book = xlwt.Workbook(encoding='utf-8')
for app_id in customers_per_app:
if not app_id:
continue
sheet = book.add_sheet(app_id)
row = 0
sheet.write(row, 0, 'Customer name')
for customer in customers_per_app[app_id]:
row += 1
url = '%s/internal/shop/login_as?customer_id=%d' % (settings.baseUrl, customer.id)
sheet.write(row, 0, xlwt.Formula('HYPERLINK("%s";"%s")' % (url, customer.name.replace('"', ''))))
excel = StringIO()
book.save(excel)
excel_string = excel.getvalue()
current_date = format_datetime(datetime.datetime.now(), locale=DEFAULT_LANGUAGE)
to_emails = [u'*****@*****.**', u'*****@*****.**', u'*****@*****.**']
attachments = []
attachments.append(('Customers %s.xls' % current_date,
base64.b64encode(excel_string)))
subject = 'List of all customers'
message = 'See attachment.'
send_mail('*****@*****.**', to_emails, subject, message, attachments=attachments)
def trans():
sln_cwl.pending = False
sln_cwl.winners = winners
sln_cwl.winners_info = json.dumps(
serialize_complex_value(winners_info, ExtendedUserDetailsTO, True))
sln_cwl.put()
deferred.defer(_redeem_city_wide_lottery_visits,
service_user,
sln_cwl_lottery_key,
now(),
_transactional=True)
to_emails = sln_settings.inbox_mail_forwarders
if to_emails:
solution_server_settings = get_solution_server_settings()
subject = 'Winnaars gemeentelijke tombola'
body = """Beste,
Volgende mensen hebben gewonnen met de tombola: %s
Met vriendelijke groeten,
Het Onze Stad App Team
""" % winner_text
send_mail(solution_server_settings.shop_export_email, to_emails,
subject, body)
def _send_statistics_for_service_identity_user(si, admin_emails, default_language, settings, sisTO):
stats_usage = list()
for i in sisTO.menu_item_press:
count = 0
max_length = 8
if len(i.data) < max_length:
max_length = len(i.data)
for d in range(1, max_length):
count = count + i.data[d].count
if count > 0:
stats_usage.append({"name":i.name, "count":count})
stats_usage.sort(cmp=_usage_compare)
emails_to_send = [e.strip() for e in admin_emails.split(',') if e.strip()]
variables = dict(service=si.name,
users={"today":sisTO.number_of_users,
"week":{"gained":sum(c.count for c in sisTO.users_gained[:8]),
"lost":sum(c.count for c in sisTO.users_lost[:8])},
"month":{"gained":sum(c.count for c in sisTO.users_gained[:31]),
"lost":sum(c.count for c in sisTO.users_lost[:31])}},
usage=stats_usage,
usage_length=len(stats_usage))
body = render("service_identity_statistics_email", [default_language], variables)
html = render("service_identity_statistics_email_html", [default_language], variables)
subject = "Weekly statistics for %s" % si.name
send_mail(settings.dashboardEmail, emails_to_send, subject, body, html=html)
def report_on_site_payments():
one_month_ago = datetime.datetime.today() - relativedelta(months=1)
min_date = int(time.mktime(one_month_ago.timetuple()))
invoices = Invoice.all().filter('payment_type',
Invoice.PAYMENT_ON_SITE).filter(
'date >=', min_date)
charges = Charge.get((i.charge_key for i in invoices))
customers = Customer.get((i.order_key.parent() for i in invoices))
l = [
'[%(date_str)s][%(customer)s][%(manager)s][%(amount).02f][%(charge_number)s]'
% dict(customer=c.name,
manager=i.operator,
amount=i.amount / 100.0,
date=i.date,
date_str=time.ctime(i.date),
charge_number=charge.charge_number)
for (i, charge, c) in sorted(zip(invoices, charges, customers),
key=lambda t: t[0].date)
]
body = "\n".join(l) or u"There were no on site payments for the last month"
logging.info(body)
server_settings = get_server_settings()
solution_server_settings = get_solution_server_settings()
subject = u'On site payments for the last month'
send_mail(server_settings.dashboardEmail,
solution_server_settings.shop_payment_admin_emails, subject,
body)
def _send_denied_signup_email(city_customer, signup, lang, reason):
subject = common_translate(city_customer.language,
SOLUTION_COMMON,
u'signup_request_denied_by_city',
city=city_customer.name)
message = common_translate(city_customer.language,
SOLUTION_COMMON,
u'signup_request_denial_reason',
reason=reason)
city_from = '%s <%s>' % (city_customer.name, city_customer.user_email)
send_mail(city_from, signup.customer_email, subject, message)
def reportObjectionableContent(request):
report = Report(reported_by=users.get_current_user(),
reason=request.reason,
type=request.type,
object=json.loads(request.object))
report.put()
object_str = pprint.pformat(report.object)
app = get_app_by_id(users.get_current_app_id())
send_mail(app.dashboard_email_address, get_server_settings().supportEmail,
u'User reports objectionable content',
u'User: %s\nType: %s\nReason:%s\nContent:\n%s'
% (report.reported_by.email(), request.type, request.reason, object_str))
def get(self):
expired_apps = [(app.app_id, time.ctime(app.apple_push_cert_valid_until))
for app in App.all() \
.filter('apple_push_cert_valid_until !=', None) \
.filter('apple_push_cert_valid_until <', now() + 60 * 86400) \
.order('apple_push_cert_valid_until')]
if expired_apps:
expired_apps_str = pprint.pformat(expired_apps)
settings = get_server_settings()
send_mail(settings.dashboardEmail,
settings.supportWorkers,
"There are APN certs that are about to expire",
"The following APN certs are about to expire:\n%s" % expired_apps_str)
logging.error("The following APN certs are about to expire:\n%s" % expired_apps_str)
def trans(owner_profile, ts, is_new_trial_service):
if is_new_trial_service:
deferred.defer(_configure_mobidick, ts.service, _transactional=True)
deferred.defer(_friend_trial_service, user, ts.service, _transactional=True, _countdown=5)
context = dict(name=owner_profile.name, email=ts.service.email(), password=ts.password)
body = render("trial_service_signup", [DEFAULT_LANGUAGE], context)
html = render("trial_service_signup_html", [DEFAULT_LANGUAGE], context)
logging.info("Sending message to %s\n%s" % (ts.owner.email(), body))
send_mail(server_settings.senderEmail, ts.owner.email(), "Rogerthat trial service", body, html=html)
return TrialServiceTO.fromDBTrialServiceAccount(ts)
def signup(name, email, cont):
if not name or not name.strip():
return SIGNUP_INVALID_NAME
if not email or not email.strip():
return SIGNUP_INVALID_EMAIL
if not EMAIL_REGEX.match(email):
return SIGNUP_INVALID_EMAIL
default_app = app.get_default_app()
if default_app.user_regex:
regexes = default_app.user_regex.splitlines()
for regex in regexes:
if re.match(regex, email):
break
else:
return SIGNUP_INVALID_EMAIL_DOMAIN
app_user_email = create_app_user_by_email(email).email()
user = users.User(app_user_email)
profile = get_service_or_user_profile(user)
if profile and profile.passwordHash:
return SIGNUP_ACCOUNT_EXISTS
deactivated_profile = get_deactivated_user_profile(user)
if deactivated_profile and deactivated_profile.passwordHash:
return SIGNUP_ACCOUNT_EXISTS
if not rate_signup_reset_password(user, os.environ.get('HTTP_X_FORWARDED_FOR', None)):
return SIGNUP_RATE_LIMITED
timestamp = now() + 5 * 24 * 3600
data = dict(n=name, e=app_user_email, t=timestamp, a="registration", c=cont)
data["d"] = calculate_secure_url_digest(data)
data = encrypt(user, json.dumps(data))
link = '%s/setpassword?%s' % (get_server_settings().baseUrl,
urllib.urlencode((("email", app_user_email), ("data", base64.encodestring(data)),)))
vars_ = dict(link=link, name=name, site=get_server_settings().baseUrl)
body = render("signup", [DEFAULT_LANGUAGE], vars_)
html = render("signup_html", [DEFAULT_LANGUAGE], vars_)
logging.info("Sending message to %s\n%s" % (email, body))
settings = get_server_settings()
from_ = settings.senderEmail if default_app.type == App.APP_TYPE_ROGERTHAT else ("%s <%s>" % (default_app.name, default_app.dashboard_email_address))
send_mail(from_, email, "Rogerthat registration", body, html=html)
return SIGNUP_SUCCESS
def feedback(user, type_, subject, message):
email_subject = "Feedback - %s - %s" % (type_, subject)
friend_count = len(get_friends_map(user).friends)
message_count = get_messages_count(user)
mobiles = get_user_active_mobiles(user)
email = user.email()
timestamp = now()
profile_info = get_profile_info(user)
d = dict(type_=type_, subject=subject, message=message, email=email,
profile_info=profile_info, friend_count=friend_count, message_count=message_count,
mobiles=mobiles, timestamp=timestamp)
body = render("feedback", [DEFAULT_LANGUAGE], d)
server_settings = get_server_settings()
send_mail(server_settings.senderEmail, server_settings.supportEmail, email_subject, body)
def send_mail(self, final_stats_per_app, min_time, max_time, interval, skip_messages_sent_by_js_mfr):
min_date = datetime.datetime.utcfromtimestamp(min_time)
max_date = datetime.datetime.utcfromtimestamp(max_time)
min_date_str = min_date.strftime('%d %b %Y')
max_date_str = max_date.strftime('%d %b %Y')
with closing(StringIO()) as s:
s.write('User stats from %s until %s with %s interval'
% (min_date_str, max_date_str,
('%s month(s)' % interval.months) if interval.months else ('%s day(s)' % interval.days)))
if skip_messages_sent_by_js_mfr:
s.write(' (messages sent by JS_MFR are skipped)')
s.write('.\nSee attached document for details per app.\n\nSummary:\n')
# TOTAL STATS PER PERIOD
result_length = get_interval_index(max_time, min_time, interval) + 1
total_stats_list = [Stats(0, 0, 0, 0) for _ in xrange(result_length)]
for stats_list in final_stats_per_app.itervalues():
for i, stats in enumerate(total_stats_list):
total_stats_list[i] = _combine([total_stats_list[i], stats_list[i]])
if DEBUG:
logging.warn('ProcessOutputPipeline: total_stats_list = %s', total_stats_list)
for i, stats in enumerate(total_stats_list):
stats = Stats(*stats)
s.write('''
%s
total: %s
received: %s/%s (%s of total)
read: %s/%s (%s of received, %s of total)
acked: %s/%s (%s of read, %s of received, %s of total)
''' % (get_period_str(i, min_date, max_date, interval), stats.total,
stats.received, stats.total, percent(stats.received, stats.total),
stats.read, stats.received, percent(stats.read, stats.received), percent(stats.read, stats.total),
stats.acked, stats.read, percent(stats.acked, stats.read), percent(stats.acked, stats.received), percent(stats.acked, stats.total)))
body = s.getvalue()
server_settings = get_server_settings()
mail_receivers = server_settings.supportWorkers
subject = u'Rogerthat user stats: %s - %s' % (min_date_str, max_date_str)
attachments = [self.create_xls_attachment(final_stats_per_app, total_stats_list, min_date, max_date, interval)]
send_mail(server_settings.dashboardEmail, mail_receivers, subject, body, attachments=attachments)
def _send_export_email(result_path, human_user_email, app_id, data_export_email, download_url):
logging.info(download_url)
app_user = create_app_user_by_email(human_user_email, app_id)
user_profile, app = db.get([get_profile_key(app_user), App.create_key(app_id)])
subject = localize(user_profile.language, "user_data_download_ready_summary")
variables = dict(name=user_profile.name,
link=download_url,
app=app)
body = render("data_download_ready_email", [user_profile.language], variables)
html = render("data_download_ready_email_html", [user_profile.language], variables)
server_settings = get_server_settings()
email_receivers = [data_export_email]
if app.is_default:
email_sender = server_settings.senderEmail
else:
email_sender = ("%s <%s>" % (app.name, app.dashboard_email_address))
send_mail(email_sender, email_receivers, subject, body, html=html)
deferred.defer(_cleanup_export, result_path, _countdown=4 * DAY, _queue=DATA_EXPORT_QUEUE)
def reset_password(email):
# XXX: Validating the email would be an improvement
user = users.User(email)
profile_info = get_profile_info(user)
if not profile_info:
return False
if not rate_signup_reset_password(user, os.environ.get('HTTP_X_FORWARDED_FOR', None)):
return False
name = profile_info.name
timestamp = now() + 5 * 24 * 3600
data = dict(n=name, e=email, t=timestamp, a="reset password", c=None)
data["d"] = calculate_secure_url_digest(data)
data = encrypt(user, json.dumps(data))
link = '%s/setpassword?%s' % (get_server_settings().baseUrl, urllib.urlencode((("email", email), ("data", base64.encodestring(data)),)))
vars_ = dict(link=link, name=name)
body = render("reset_password", [DEFAULT_LANGUAGE], vars_)
html = render("reset_password_html", [DEFAULT_LANGUAGE], vars_)
logging.info("Sending message to %s\n%s" % (email, body))
settings = get_server_settings()
utils.send_mail(settings.senderEmail2ToBeReplaced, email, "Rogerthat password reset", body, html=html)
return True
def trans():
db_puts = list()
# Create registration entry.
installation = Installation.get_by_key_name(install_id) if install_id else None
app_user = create_app_user(users.User(email), app_id)
registration = None
if version == 2:
registration = Registration.get_by_key_name(registration_id, parent_key(app_user))
if registration and registration.request_id == request_id:
InstallationLog(parent=registration.installation, timestamp=now(), registration=registration,
pin=registration.pin,
description="Received a HTTP request retry for 'request pin'. Not sending a new mail.").put()
return
rogerthat_profile = get_service_or_user_profile(users.User(email))
if rogerthat_profile and isinstance(rogerthat_profile, ServiceProfile):
# some guy tries to register a mobile on a service account ?!?
variables = dict(email=email)
body = render("somebody_tries_to_register_his_mobile_on_your_service_account_warning", [language], variables)
html = render("somebody_tries_to_register_his_mobile_on_your_service_account_warning_html", [language], variables)
logging.info("Sending message to %s\n%s" % (email, body))
recipients = [email]
for admin in get_service_admins_non_transactional(app_user):
recipients.append(admin.user_email)
msg = MIMEMultipart('alternative')
msg['Subject'] = "Warning, possibly somebody tries to hack your service account."
msg['From'] = server_settings.senderEmail
msg['To'] = ', '.join(recipients)
msg.attach(MIMEText(body.encode('utf-8'), 'plain', 'utf-8'))
msg.attach(MIMEText(html.encode('utf-8'), 'html', 'utf-8'))
send_mail_via_mime(server_settings.senderEmail, recipients, msg)
warning = InstallationLog(parent=installation, timestamp=now(),
description="Warning somebody tries to register a mobile with the email address of service account %s" % email)
db_puts.append(warning)
else:
profile = get_user_profile(app_user)
if profile:
name = profile.name
else:
deactivated_profile = get_deactivated_user_profile(app_user)
name = deactivated_profile.name if deactivated_profile else None
if not registration:
registration = Registration(parent=parent_key(app_user), key_name=registration_id)
registration.timestamp = registration_time
registration.device_id = device_id
server_settings = get_server_settings()
for pin, static_email in chunks(server_settings.staticPinCodes, 2):
if email == static_email and len(pin) == 4:
registration.pin = int(pin)
pin_str = unicode(registration.pin).rjust(4, '0')
utils.send_mail(server_settings.dashboardEmail,
server_settings.supportWorkers,
pin_str,
u'Configured pin code %s for %s' % (pin_str, app_user.email()))
break
else:
registration.pin = random.randint(1000, 9999)
registration.timesleft = 3
registration.installation = installation
registration.request_id = request_id
registration.language = language
db_puts.append(registration)
i1 = InstallationLog(parent=registration.installation, timestamp=now(), registration=registration, pin=registration.pin,
description="%s requested pin" % email)
db_puts.append(i1)
# Send email with pin.
app = get_app_by_id(app_id)
variables = dict(pin=registration.pin, name=name, app=app)
body = render("activation_code_email", [language], variables)
html = render("activation_code_email_html", [language], variables)
logging.info("Sending message to %s\n%s" % (email, body))
msg = MIMEMultipart('alternative')
msg['Subject'] = localize(language, "%(app_name)s mobile registration", app_name=app.name)
msg['From'] = server_settings.senderEmail if app.type == App.APP_TYPE_ROGERTHAT else ("%s <%s>" % (app.name, app.dashboard_email_address))
msg['To'] = email
msg.attach(MIMEText(body.encode('utf-8'), 'plain', 'utf-8'))
msg.attach(MIMEText(html.encode('utf-8'), 'html', 'utf-8'))
send_mail_via_mime(server_settings.senderEmail, email, msg)
i2 = InstallationLog(parent=registration.installation, timestamp=now(), registration=registration, pin=registration.pin,
description="Sent email to %s with pin %s" % (email, registration.pin))
db_puts.append(i2)
db.put(db_puts)
def _send_statistics_for_service_user(si, admin_emails, default_language, settings):
service_identities = list(get_service_identities(si.service_user))
book = xlwt.Workbook(encoding="utf-8")
sheet = book.add_sheet("Statistics")
wrap_alignment = xlwt.Alignment()
wrap_alignment.wrap = xlwt.Alignment.WRAP_AT_RIGHT
wrap_alignment.horz = xlwt.Alignment.HORZ_LEFT
wrap_alignment.vert = xlwt.Alignment.VERT_CENTER
red_font = xlwt.Font()
red_font.colour_index = 10
pattern_white = xlwt.Pattern()
pattern_white.pattern = xlwt.Pattern.SOLID_PATTERN
pattern_white.pattern_fore_colour = 1
pattern_dark = xlwt.Pattern()
pattern_dark.pattern = xlwt.Pattern.SOLID_PATTERN
pattern_dark.pattern_fore_colour = 41
regular_style1 = xlwt.XFStyle()
regular_style1.alignment = wrap_alignment
regular_style1.pattern = pattern_white
red_style2 = xlwt.XFStyle()
red_style2.alignment = wrap_alignment
red_style2.pattern = pattern_dark
red_style2.font = red_font
START_USERS_DETAIL = 15
START_USAGE_DETAIL = 26
sheet.col(0).width = 5000
sheet.col(1).width = 7000
sheet.write(1, 0, "Summary users", red_style2)
if len(service_identities) >= 2:
col = 0
sheet.write(3, 1, "Total")
sheet.write(START_USERS_DETAIL - 1, 1, "Total", regular_style1)
else:
col = 1
# SET summary users names
sheet.write(4, col, "Today")
sheet.write(5, col, "Last 7 days:")
sheet.write(6, col, " - gained")
sheet.write(7, col, " - lost")
sheet.write(8, col, "Last 30 days:")
sheet.write(9, col, " - gained")
sheet.write(10, col, " - lost")
row = START_USERS_DETAIL
sheet.write(START_USERS_DETAIL - 3, 0, "Detail users", red_style2)
sheet.write(START_USERS_DETAIL - 1, col, "Week", regular_style1)
now_ = datetime.datetime.utcnow()
now_date_today = datetime.date(now_.year, now_.month, now_.day).today()
# SET detail users dates
for i in range(1, 8):
day_stats = now_date_today - datetime.timedelta(i * 7)
dt = datetime.date(day_stats.year, day_stats.month, day_stats.day)
sheet.write(row, col, dt.isocalendar()[1], regular_style1)
row += 1
# SET detail usage dates
row = START_USAGE_DETAIL
sheet.write(START_USAGE_DETAIL - 3, 0, "Detail usage", red_style2)
sheet.write(START_USAGE_DETAIL - 1, 0, "Week", regular_style1)
sheet.write(START_USAGE_DETAIL - 1, 1, "Menu item label", regular_style1)
service_menu_items = get_service_menu_items(si.service_user)
smi_labels = sorted([smi.label for smi in service_menu_items], key=lambda x: x.lower())
for i in range(1, 8):
day_stats = now_date_today - datetime.timedelta(i * 7)
dt = datetime.date(day_stats.year, day_stats.month, day_stats.day)
for label in smi_labels:
sheet.write(row, 0, dt.isocalendar()[1], regular_style1)
sheet.write(row, 1, label, regular_style1)
row += 1
row += 1
col = 2
summary_users_total = dict()
summary_users_total["number_of_users"] = 0
summary_users_total["w_user_gained"] = 0
summary_users_total["w_user_lost"] = 0
summary_users_total["m_user_gained"] = 0
summary_users_total["m_user_lost"] = 0
detail_users_total = [0, 0, 0, 0, 0, 0, 0]
for service_identity in service_identities:
ss = get_identity_statistics(service_identity.user)
sis = get_statistics_list(ss)
if len(sis["users_gained"]) >= 8:
# Service has statistics for longer than 7 days
# SET summary users data
sheet.write(2, col, service_identity.name, regular_style1)
sheet.write(3, col, service_identity.identifier, regular_style1)
sheet.write(4, col, ss.number_of_users)
sheet.write(6, col, sum(sis["users_gained"][:8]))
sheet.write(7, col, sum(sis["users_lost"][:8]))
sheet.write(9, col, sum(sis["users_gained"][:31]))
sheet.write(10, col, sum(sis["users_lost"][:31]))
summary_users_total["number_of_users"] += ss.number_of_users
summary_users_total["w_user_gained"] += sum(sis["users_gained"][:8])
summary_users_total["w_user_lost"] += sum(sis["users_lost"][:8])
summary_users_total["m_user_gained"] += sum(sis["users_gained"][:31])
summary_users_total["m_user_lost"] += sum(sis["users_lost"][:31])
# SET detail users data
row = START_USERS_DETAIL
total_users = ss.number_of_users
sheet.write(START_USERS_DETAIL - 2, col, service_identity.name, regular_style1)
sheet.write(START_USERS_DETAIL - 1, col, service_identity.identifier, regular_style1)
for i in range(1, 8): # last 7 weeks
weekly_total_users = total_users - sum(sis["users_gained"][:7 * i]) + sum(sis["users_lost"][:7 * i])
sheet.write(row, col, weekly_total_users)
detail_users_total[i - 1] += weekly_total_users
row += 1
# SET detail usage data
row = START_USAGE_DETAIL
sheet.write(START_USAGE_DETAIL - 2, col, service_identity.name, regular_style1)
sheet.write(START_USAGE_DETAIL - 1, col, service_identity.identifier, regular_style1)
for i in range(1, 8): # last 7 weeks
for label in smi_labels:
if label in sis["labels"]:
sheet.write(row, col, sum(sis[label][7 * (i - 1):7 * i]))
else:
sheet.write(row, col, 0)
row += 1
row += 1
col += 1
if len(service_identities) >= 2:
sheet.write(4, 1, summary_users_total["number_of_users"])
sheet.write(6, 1, summary_users_total["w_user_gained"])
sheet.write(7, 1, summary_users_total["w_user_lost"])
sheet.write(9, 1, summary_users_total["m_user_gained"])
sheet.write(10, 1, summary_users_total["m_user_lost"])
row = START_USERS_DETAIL
for i in range(7):
sheet.write(row, 1, detail_users_total[i])
row += 1
if col > 2:
output = StringIO()
book.save(output)
output.seek(0)
emails_to_send = [e.strip() for e in admin_emails.split(',') if e.strip()]
variables = dict(service=si.name)
body = render("service_statistics_email", [default_language], variables)
subject = "Weekly statistics for your identities of %s" % si.name
attachments = []
attachments.append(('filename=stats_%s_w_%s.xls' % (now_date_today.year, now_date_today.isocalendar()[1]),
base64.b64encode(output.getvalue())))
send_mail(settings.dashboardEmail, emails_to_send, subject, body, attachments=attachments)
def create_reseller_invoice_for_legal_entity(legal_entity,
start_date,
end_date,
do_send_email=True):
"""
Args:
legal_entity (LegalEntity)
start_date (long)
end_date (long)
do_send_email (bool)
"""
if legal_entity.is_mobicage:
# To avoid a composite index we don't filter on is_mobicage
return
solution_server_settings = get_solution_server_settings()
from_email = solution_server_settings.shop_no_reply_email
to_emails = solution_server_settings.shop_payment_admin_emails
mobicage_legal_entity = get_mobicage_legal_entity()
logging.info(
'Exporting reseller invoices for legal entity %s(id %d) from %s(%s) to %s(%s)',
legal_entity.name, legal_entity.id, start_date, time.ctime(start_date),
end_date, time.ctime(end_date))
invoices = list(Invoice.all().filter(
'legal_entity_id',
legal_entity.id).filter('paid_timestamp >', start_date).filter(
'paid_timestamp <', end_date).filter('paid', True).filter(
'payment_type IN',
(Invoice.PAYMENT_MANUAL, Invoice.PAYMENT_MANUAL_AFTER)))
start_time = time.strftime('%m/%d/%Y', time.gmtime(int(start_date)))
end_time = time.strftime('%m/%d/%Y', time.gmtime(int(end_date)))
if not invoices:
message = 'No new invoices for reseller %s for period %s - %s' % (
legal_entity.name, start_time, end_time)
logging.info(message)
if do_send_email:
send_mail(from_email, to_emails, message, message)
return
items_per_customer = {}
customers_to_get = set()
products = {
p.code: p
for p in Product.list_by_legal_entity(legal_entity.id)
}
for invoice in invoices:
# get all subscription order items
order_items = list(OrderItem.list_by_order(invoice.order_key))
for item in reversed(order_items):
product = products[item.product_code]
# We're only interested in subscription items
if product.is_subscription or product.is_subscription_extension or product.is_subscription_discount:
if invoice.customer_id not in items_per_customer:
items_per_customer[invoice.customer_id] = []
customers_to_get.add(
Customer.create_key(invoice.customer_id))
items_per_customer[invoice.customer_id].append(item)
else:
order_items.remove(item)
if not customers_to_get:
message = 'No new invoices containing subscriptions for reseller %s for period %s - %s' % (
legal_entity.name, start_time, end_time)
logging.info(message)
if do_send_email:
send_mail(from_email, to_emails, message, message)
return
customers = {c.id: c for c in db.get(customers_to_get)}
product_totals = {}
for customer_id in items_per_customer:
items = items_per_customer[customer_id]
for item in items:
if item.product_code not in product_totals:
product_totals[item.product_code] = {
'count': 0,
'price': int(item.price * legal_entity.revenue_percent)
}
product_totals[item.product_code]['count'] += item.count
total_amount = 0
for product in product_totals:
p = product_totals[product]
price = p['count'] * p['price']
p['total_price'] = format_currency(
price / 100.,
legal_entity.currency_code,
locale=mobicage_legal_entity.country_code)
total_amount += price
total_amount_formatted = format_currency(
total_amount / 100.,
legal_entity.currency_code,
locale=mobicage_legal_entity.country_code)
vat_amount = total_amount / mobicage_legal_entity.vat_percent if mobicage_legal_entity.country_code == legal_entity.country_code else 0
vat_amount_formatted = format_currency(
vat_amount / 100.,
legal_entity.currency_code,
locale=mobicage_legal_entity.country_code)
from_date = format_datetime(datetime.utcfromtimestamp(start_date),
locale=SHOP_DEFAULT_LANGUAGE,
format='dd/MM/yyyy HH:mm')
until_date = format_datetime(datetime.utcfromtimestamp(end_date),
locale=SHOP_DEFAULT_LANGUAGE,
format='dd/MM/yyyy HH:mm')
solution_server_settings = get_solution_server_settings()
template_variables = {
'products':
products,
'customers':
customers,
'invoices':
invoices,
'items_per_customer':
items_per_customer,
'product_totals':
product_totals.items(),
'mobicage_legal_entity':
mobicage_legal_entity,
'legal_entity':
legal_entity,
'language':
SHOP_DEFAULT_LANGUAGE,
'from_date':
from_date,
'until_date':
until_date,
'revenue_percent':
legal_entity.revenue_percent,
'vat_amount_formatted':
vat_amount_formatted,
'total_amount_formatted':
total_amount_formatted,
'logo_path':
'../html/img/osa_white_en_250.jpg',
'tos_link':
'<a href="%s">%s</a>' %
(solution_server_settings.shop_privacy_policy_url,
solution_server_settings.shop_privacy_policy_url)
}
source_html = SHOP_JINJA_ENVIRONMENT.get_template(
'invoice/reseller_invoice.html').render(template_variables)
output_stream = StringIO()
pisa.CreatePDF(src=source_html,
dest=output_stream,
path='%s/invoice' % SHOP_TEMPLATES_FOLDER)
invoice_pdf_contents = output_stream.getvalue()
output_stream.close()
# Create an order, order items, charge and invoice.
_now = now()
customer = legal_entity.get_or_create_customer()
mobicage_team = RegioManagerTeam.get_mobicage()
def trans():
to_put = list()
order_number = OrderNumber.next(mobicage_legal_entity)
order_key = db.Key.from_path(Order.kind(),
order_number,
parent=customer.key())
order = Order(key=order_key)
order.contact_id = legal_entity.contact_id
order.date = _now
order.vat_pct = mobicage_legal_entity.vat_percent if legal_entity.country_code == mobicage_legal_entity.country_code else 0
order.amount = int(round(total_amount))
order.vat = int(round(vat_amount))
order.total_amount = int(round(total_amount + vat_amount))
order.is_subscription_order = False
order.is_subscription_extension_order = False
order.team_id = mobicage_team.id
order.manager = customer.manager
order.status = Order.STATUS_SIGNED
to_put.append(order)
for i, (product_code, item) in enumerate(product_totals.iteritems()):
order_item = OrderItem(parent=order_key)
order_item.number = i + 1
order_item.comment = products[product_code].default_comment(
SHOP_DEFAULT_LANGUAGE)
order_item.product_code = product_code
order_item.count = item['count']
order_item.price = item['price']
to_put.append(order_item)
charge_key = Charge.create_key(allocate_id(Charge), order_number,
customer.id)
charge = Charge(key=charge_key)
charge.date = _now
charge.type = Charge.TYPE_ORDER_DELIVERY
charge.amount = order.amount
charge.vat_pct = order.vat_pct
charge.vat = order.vat
charge.total_amount = order.total_amount
charge.manager = order.manager
charge.team_id = order.team_id
charge.charge_number = ChargeNumber.next(mobicage_legal_entity)
charge.currency_code = legal_entity.currency_code
to_put.append(charge)
invoice_number = InvoiceNumber.next(mobicage_legal_entity)
invoice = Invoice(key_name=invoice_number,
parent=charge,
amount=charge.amount,
vat_pct=charge.vat_pct,
vat=charge.vat,
total_amount=charge.total_amount,
currency_code=legal_entity.currency_code,
date=_now,
payment_type=Invoice.PAYMENT_MANUAL_AFTER,
operator=charge.manager,
paid=False,
legal_entity_id=mobicage_legal_entity.id,
pdf=invoice_pdf_contents)
charge.invoice_number = invoice_number
to_put.append(invoice)
put_and_invalidate_cache(*to_put)
return order, charge, invoice
order, charge, invoice = run_in_xg_transaction(trans)
if do_send_email:
serving_url = '%s/internal/shop/invoice/pdf?customer_id=%d&order_number=%s&charge_id=%d&invoice_number=%s' % (
get_server_settings().baseUrl, customer.id, order.order_number,
charge.id, invoice.invoice_number)
subject = 'New reseller invoice for %s, %s - %s' % (
legal_entity.name, start_time, end_time)
body_text = 'A new invoice is available for reseller %s for period %s to %s here: %s' % (
legal_entity.name, start_time, end_time, serving_url)
send_mail(from_email, to_emails, subject, body_text)
def generate_prospect_export_excel(prospect_ids, do_send_email=True, recipients=None):
if not prospect_ids:
raise BusinessException('No prospects to export')
azzert(not do_send_email or recipients)
bold_style = xlwt.XFStyle()
bold_style.font.bold = True
column_name, column_address, column_city, column_phone, column_status, column_type, column_categories, column_comments = range(8)
book = xlwt.Workbook(encoding="utf-8")
sheet = book.add_sheet('Prospects')
prospects = Prospect.get(map(Prospect.create_key, prospect_ids))
app_id = None
sheet.write(0, column_name, 'Name', bold_style)
sheet.write(0, column_address, 'Address', bold_style)
sheet.write(0, column_city, 'City', bold_style)
sheet.write(0, column_phone, 'Phone', bold_style)
sheet.write(0, column_status, 'Status', bold_style)
sheet.write(0, column_type, 'Type', bold_style)
sheet.write(0, column_categories, 'Category', bold_style)
sheet.write(0, column_comments, 'Comments', bold_style)
for i, prospect in enumerate(prospects):
row = i + 1
comments_str = '\n'.join(['* %s' % comment.text for comment in prospect.comments])
sheet.write(row, column_name, prospect.name)
formatted_address = format_address(prospect.address)
sheet.write(row, column_address, formatted_address[0])
sheet.write(row, column_city, formatted_address[1])
sheet.write(row, column_phone, prospect.phone)
sheet.write(row, column_status, Prospect.STATUS_TYPES[prospect.status])
sheet.write(row, column_type, ', '.join(prospect.type))
sheet.write(row, column_categories, ', '.join(prospect.categories))
sheet.write(row, column_comments, comments_str)
sheet.col(column_name).width = 5000
sheet.col(column_address).width = 5000
sheet.col(column_phone).width = 5000
sheet.col(column_status).width = 5000
sheet.col(column_type).width = 10000
sheet.col(column_categories).width = 10000
sheet.col(column_comments).width = 20000
if not app_id:
app_id = prospect.app_id
excel = StringIO()
book.save(excel)
excel_string = excel.getvalue()
if do_send_email:
app = get_app_by_id(app_id)
solution_server_settings = get_solution_server_settings()
current_date = format_datetime(datetime.datetime.now(), locale=DEFAULT_LANGUAGE)
subject = 'Exported prospects of %s %s' % (app.name, current_date)
from_email = solution_server_settings.shop_export_email
to_emails = recipients
body_text = 'See attachment for the exported prospects'
attachments = []
attachments.append(('Prospects %s %s.xls' % (app.name, current_date),
base64.b64encode(excel_string)))
send_mail(from_email, to_emails, subject, body_text, attachments=attachments)
return excel_string
def create_voucher_statistics_for_city_service(service_user, language,
first_day_of_last_month,
first_day_of_current_month):
customer = Customer.get_by_service_email(service_user.email())
translate = partial(common_translate, language, SOLUTION_COMMON)
if not customer:
logging.error("failed to create voucher statistics customer not found")
return
sln_settings = get_solution_settings(service_user)
users.set_user(service_user)
try:
si = system.get_identity()
finally:
users.clear_user()
app_id = si.app_ids[0]
ancestor_key = SolutionCityVoucher.create_parent_key(app_id)
qry = SolutionCityVoucherTransaction.all().ancestor(ancestor_key)
qry.filter("action =", SolutionCityVoucherTransaction.ACTION_REDEEMED)
qry.filter("created >=", first_day_of_last_month)
qry.filter("created <", first_day_of_current_month)
transactions = []
merchant_transactions = dict()
merchants = dict()
unique_vouchers = dict()
for t in qry:
t.dt = format_timestamp(t.created, sln_settings)
t.voucher = t.parent()
transactions.append(t)
if t.service_user not in merchant_transactions:
merchant_transactions[t.service_user] = {
"value": 0,
"transactions": []
}
merchant_transactions[t.service_user]["value"] += t.value
merchant_transactions[t.service_user]["transactions"].append(t.key())
unique_vouchers[t.voucher.key()] = t.voucher
for merchant_service_user in merchant_transactions.keys():
merchants[merchant_service_user] = get_solution_settings(
merchant_service_user)
qry = SolutionCityVoucher.all().ancestor(ancestor_key)
qry.filter("activated =", True)
qry.filter("redeemed = ", False)
vouchers = []
expired_vouchers = []
for v in qry:
v.dt = format_timestamp(v.created, sln_settings)
if v.expired:
if v.expiration_date >= first_day_of_last_month and \
v.expiration_date < first_day_of_current_month:
expired_vouchers.append(v)
else:
vouchers.append(v)
book = xlwt.Workbook(encoding="utf-8")
# TAB 1
sheet_transactions = book.add_sheet(translate("Transactions"))
row = 0
write_header(sheet_transactions, row, translate, "Date", "Voucher",
"Internal account", "Cost center", "merchant",
"Withdrawn value")
for transaction in transactions:
row += 1
sheet_transactions.write(row, 0, transaction.dt)
sheet_transactions.write(row, 1, transaction.voucher.uid)
sheet_transactions.write(row, 2, transaction.voucher.internal_account)
sheet_transactions.write(row, 3, transaction.voucher.cost_center)
sheet_transactions.write(row, 4,
merchants[transaction.service_user].name)
sheet_transactions.write(row, 5, round(transaction.value / 100.0, 2))
row += 2
sheet_transactions.write(row, 0, translate("total"))
sheet_transactions.write(row, 5, xlwt.Formula('SUM(F2:F%s)' % (row - 1)))
# TAB 2
sheet_merchants = book.add_sheet(translate("merchants"))
row = 0
sheet_merchants.write(row, 0, translate("merchant"))
sheet_merchants.write(row, 1, translate("address"))
sheet_merchants.write(row, 2, "IBAN")
sheet_merchants.write(row, 3, "BIC")
sheet_merchants.write(row, 4, translate("Total value to be paid"))
for merchant_service_user in merchants.keys():
merchant = merchants[merchant_service_user]
row += 1
sheet_merchants.write(row, 0, merchant.name)
sheet_merchants.write(row, 1, merchant.address)
sheet_merchants.write(row, 2, merchant.iban or u"")
sheet_merchants.write(row, 3, merchant.bic or u"")
sheet_merchants.write(
row, 4,
round(
merchant_transactions[merchant_service_user]["value"] / 100.0,
2))
row += 2
sheet_merchants.write(row, 0, translate("total"))
sheet_merchants.write(row, 4, xlwt.Formula('SUM(E2:E%s)' % (row - 1)))
# TAB 3
sheet_vouchers = book.add_sheet(translate("Vouchers in circulation"))
row = 0
write_header(sheet_vouchers, row, translate, "Voucher", "Internal account",
"Cost center", "Date", "Remaining value")
for voucher in vouchers:
unique_vouchers[voucher.key()] = voucher
row += 1
sheet_vouchers.write(row, 0, voucher.uid)
sheet_vouchers.write(row, 1, voucher.internal_account)
sheet_vouchers.write(row, 2, voucher.cost_center)
sheet_vouchers.write(row, 3, voucher.dt)
value = voucher.value - voucher.redeemed_value
sheet_vouchers.write(row, 4, round(value / 100.0, 2))
row += 2
sheet_vouchers.write(row, 0, translate("total"))
sheet_vouchers.write(row, 2, xlwt.Formula('SUM(E2:E%s)' % (row - 1)))
# TAB 4
expired_vouchers_sheet = book.add_sheet(translate("expired"))
row = 0
write_header(expired_vouchers_sheet, row, translate, "Voucher",
"Internal account", "Cost center", "Date", "Expiration date",
"Remaining value")
for voucher in expired_vouchers:
row += 1
expired_vouchers_sheet.write(row, 0, voucher.uid)
expired_vouchers_sheet.write(row, 1, voucher.internal_account)
expired_vouchers_sheet.write(row, 2, voucher.cost_center)
expired_vouchers_sheet.write(
row, 3, format_timestamp(voucher.created, sln_settings))
expired_vouchers_sheet.write(
row, 4,
format_timestamp(voucher.expiration_date,
sln_settings,
format='yyyy-MM-dd'))
value = voucher.value - voucher.redeemed_value
expired_vouchers_sheet.write(row, 5, round(value / 100.0, 2))
row += 2
expired_vouchers_sheet.write(row, 0, translate("total"))
expired_vouchers_sheet.write(row, 5,
xlwt.Formula('SUM(F2:F%s)' % (row - 1)))
# TAB 5
sheet_voucher_details = book.add_sheet(translate("Voucher details"))
row = 0
for voucher in sorted(unique_vouchers.itervalues(),
key=lambda v: v.created):
voucher_transactions = [h for h in voucher.load_transactions()]
sheet_voucher_details.write(row, 0, translate("Voucher"))
sheet_voucher_details.write(row, 1, voucher.uid)
sheet_voucher_details.write(row, 2, translate("Remaining value"))
sheet_voucher_details.write(
row, 3,
xlwt.Formula('SUM(D%s:D%s)' %
(row + 2, row + 1 + len(voucher_transactions))))
row += 1
sheet_voucher_details.write(row, 0, translate("Internal account"))
sheet_voucher_details.write(row, 1, voucher.internal_account)
sheet_voucher_details.write(row, 2, translate("Cost center"))
sheet_voucher_details.write(row, 3, voucher.cost_center)
for history in reversed(voucher_transactions):
merchant_service_user = history.service_user or service_user
if merchant_service_user not in merchants:
merchants[merchant_service_user] = get_solution_settings(
merchant_service_user)
row += 1
dt = format_timestamp(history.created, sln_settings)
sheet_voucher_details.write(row, 0, dt)
sheet_voucher_details.write(row, 1,
merchants[merchant_service_user].name)
sheet_voucher_details.write(row, 2, history.action_str)
if history.action == SolutionCityVoucherTransaction.ACTION_ACTIVATED or \
history.action == SolutionCityVoucherTransaction.ACTION_REDEEMED:
sheet_voucher_details.write(row, 3,
round(history.value / 100.0, 2))
row += 2
excel_file = StringIO()
book.save(excel_file)
excel_string = excel_file.getvalue()
second_day_of_last_month = first_day_of_last_month + 86400
d = datetime.fromtimestamp(second_day_of_last_month)
sln_city_voucher_export_key = SolutionCityVoucherExport.create_key(
app_id, d.year, d.month)
sln_city_voucher_export = SolutionCityVoucherExport(
key=sln_city_voucher_export_key)
sln_city_voucher_export.xls = excel_string
sln_city_voucher_export.year_month = d.year * 100 + d.month
sln_city_voucher_export.put()
for merchant_service_user in merchant_transactions.keys():
deferred.defer(
create_voucher_statistics_for_service,
merchants[merchant_service_user], app_id, customer.language,
merchant_transactions[merchant_service_user]["transactions"],
d.year, d.month)
to_emails = sln_settings.inbox_mail_forwarders
if to_emails:
solution_server_settings = get_solution_server_settings()
attachments = []
attachments.append(
('%s %s-%s.xls' % (translate('Vouchers'), d.year, d.month),
base64.b64encode(excel_string)))
subject = translate('Vouchers export')
message = translate('see_attachment_for_vouchers_export')
send_mail(solution_server_settings.shop_export_email,
to_emails,
subject,
message,
attachments=attachments)
def solution_add_to_calender_event(service_user, email, method, params, tag,
service_identity, user_details):
rogerthat_settings = get_server_settings()
settings = get_solution_settings(service_user)
service_name = settings.name
app = get_app_by_id(user_details[0].app_id)
jsondata = json.loads(params)
emailSubject = "Event: %s" % jsondata['eventTitle']
if jsondata['eventPlace']:
eventPlace = "Place: %s " % jsondata['eventPlace']
else:
eventPlace = ''
emailBody = u"Title: %s \nDate: %s \nDescription: %s \n%s \n" % (
jsondata['eventTitle'], jsondata['eventDate'],
jsondata['eventDescription'], eventPlace)
cal = Calendar()
cal.add('prodid', '-//My calendar product//mxm.dk//')
cal.add('version', '2.0')
cal.add('method', 'REQUEST')
event = ICalenderEvent()
event.add('summary', jsondata['eventTitle'])
event.add('description', jsondata['eventDescription'])
event.add('location', jsondata['eventPlace'])
startDate = datetime.utcfromtimestamp(int(jsondata['eventStart']))
try:
endDate = datetime.utcfromtimestamp(int(jsondata['eventEnd']))
except TypeError:
endDate = None
nowDate = datetime.utcfromtimestamp(time.time())
dtstart = datetime(startDate.year,
startDate.month,
startDate.day,
startDate.hour,
startDate.minute,
startDate.second,
tzinfo=pytz.utc)
dtstamp = datetime(nowDate.year,
nowDate.month,
nowDate.day,
nowDate.hour,
nowDate.minute,
nowDate.second,
tzinfo=pytz.utc)
event.add('dtstart', dtstart)
if endDate:
dtend = datetime(endDate.year,
endDate.month,
endDate.day,
endDate.hour,
endDate.minute,
endDate.second,
tzinfo=pytz.utc)
event.add('dtend', dtend)
event.add('dtstamp', dtstamp)
event.add('uid',
"%s %s" % (app.dashboard_email_address, jsondata['eventId']))
organizer = vCalAddress('MAILTO:%s' % app.dashboard_email_address)
organizer.params['cn'] = vText(service_name)
event.add('organizer', organizer)
cal.add_component(event)
icall = cal.to_ical()
attachments = []
attachments.append(("event.ics", base64.b64encode(icall)))
from_ = rogerthat_settings.senderEmail if app.type == App.APP_TYPE_ROGERTHAT else (
"%s <%s>" % (app.name, app.dashboard_email_address))
send_mail(from_, email, emailSubject, emailBody, attachments=attachments)
r = SendApiCallCallbackResultTO()
r.result = u"successfully reminded"
r.error = None
return r
