def store_branding_zip(service_user, zip_, description, skip_meta_file=False):
# type: (users.User, ZipFile, unicode) -> Branding
try:
pokes, html, branding_type, meta_properties = _parse_and_validate_branding_zip(zip_)
# Remove previously added dimensions:
html = re.sub("<meta\\s+property=\\\"rt:dimensions\\\"\\s+content=\\\"\\[\\d+,\\d+,\\d+,\\d+\\]\\\"\\s*/>", "",
html)
try:
zip_content = _create_new_zip(service_user, branding_type, zip_, html, skip_meta_file)
except BadZipfile, e:
raise BadBrandingZipException(reason=e.message)
_validate_branding_size(zip_content, branding_type)
hash_ = calculate_branding_hash(branding_type, zip_content)
b = Branding.get_by_key_name(hash_)
if b and b.user != service_user:
raise BrandingAlreadyExistsException()
def trans():
return _create_branding(hash_, zip_content, description, service_user, branding_type, meta_properties,
pokes)
branding = run_in_transaction(trans, True)
#
# Try to add dimension information
#
if "</head>" in html:
settings = get_server_settings()
if not settings.brandingRendererUrl or branding_type in (Branding.TYPE_APP, Branding.TYPE_CORDOVA,):
return branding
if meta_properties.get('display-type', Branding.DISPLAY_TYPE_WEBVIEW) == Branding.DISPLAY_TYPE_NATIVE:
return branding
try:
url = "%s?%s" % (settings.brandingRendererUrl, urllib.urlencode(
(('url', get_server_settings().baseUrl + '/branding/' + hash_ + '/branding.html?xrender=true'),)))
response = urlfetch.fetch(url, deadline=10)
if response.status_code != 200:
logging.error("Could not render branding to get dimensions.\n%s" % response.content)
return branding
except:
logging.warn("Failed to render dimensions")
return branding
html = html.replace("</head>",
'<meta property="rt:dimensions" content="' + response.content + '" /></head>')
else:
return branding
zip_content = _create_new_zip(service_user, branding_type, zip_, html)
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
app = get_app_by_id(App.APP_ID_ROGERTHAT) # TODO DEFAULT APP ID
if app.user_regex:
regexes = app.user_regex.splitlines()
for regex in regexes:
if re.match(regex, email):
break
else:
return SIGNUP_INVALID_EMAIL_DOMAIN
user = users.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=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", 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()
msg = MIMEMultipart('alternative')
msg['Subject'] = "Rogerthat registration"
msg['From'] = 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(settings.senderEmail, email, msg)
return SIGNUP_SUCCESS
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 get(self):
from rogerthat.settings import get_server_settings
key_name = self.request.get("key_name")
template = QRTemplate.get_by_key_name(key_name)
self.response.headers['Content-Type'] = "image/png"
url = "%s/" % get_server_settings().baseUrl
self.response.out.write(qrcode(url, template.blob, map(int, template.body_color), False))
def get(self):
customer_id = int(self.request.get("customer_id"))
try:
customer = Customer.get_by_id(customer_id)
except CustomerNotFoundException:
self.abort(404)
current_user = users.get_current_user()
current_customer = get_customer(current_user)
sln_settings = get_solution_settings(current_user)
if not sln_settings.can_edit_services(
current_customer) or not current_customer.can_edit_service(
customer):
logging.warn(
'Service or user %s is trying to login to the dashboard of %s',
current_user.email(), customer.name)
self.abort(401)
service_identity_user = create_service_identity_user(
users.User(customer.service_email))
current_session = users.get_current_session()
new_secret, new_session = create_session(service_identity_user,
ignore_expiration=True)
set_cookie(self.response,
get_server_settings().cookieSessionName, new_secret)
new_session = switch_to_service_identity(new_session,
service_identity_user,
read_only=False,
shop=current_session.shop,
layout_only=True)
new_session.parent_session_secret = current_session.secret
new_session.put()
self.redirect("/")
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 _finishup_mobile_registration_step2(mobile_key, invitor_code, invitor_secret, ipaddress, majorVersion,
minorVersion):
mobile = db.get(mobile_key)
mobile_user = mobile.user
server_settings = get_server_settings()
def trans(): # Operates on 2 entity groups
hookup_with_default_services.schedule(mobile_user, ipaddress)
deferred.defer(sync_payment_database, mobile_user, _transactional=True)
if invitor_code and invitor_secret:
pp = ProfilePointer.get(invitor_code)
if not pp:
logging.error("User with userCode %s not found!" % invitor_code)
else:
deferred.defer(ack_invitation_by_invitation_secret, mobile_user, pp.user, invitor_secret,
_transactional=True, _countdown=10)
elif invitor_code:
for ysaaa_hash, static_email in chunks(server_settings.ysaaaMapping, 2):
if invitor_code == ysaaa_hash:
service_user = users.User(static_email)
makeFriends(service_user, mobile_user, original_invitee=None, servicetag=None, origin=ORIGIN_YSAAA)
break
else:
azzert(False, u"ysaaa registration received but not found mapping")
for _, static_email in chunks(server_settings.staticPinCodes, 2):
if mobile_user.email() == static_email:
break
else:
deferred.defer(send_messages_after_registration, mobile_key, _transactional=True)
xg_on = db.create_transaction_options(xg=True)
db.run_in_transaction_options(xg_on, trans)
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 post(self):
settings_yaml = self.request.get("settings", "")
try:
settings = populate_model_by_yaml(get_server_settings(), settings_yaml)
# validate jabberEndPoints
for jabber_endpoint in settings.jabberEndPoints:
parts = jabber_endpoint.split(":")
bizz_check(len(parts) == 2, 'Invalid jabber endpoint: %s' % jabber_endpoint)
ip = [int(p) for p in parts[0].split('.')]
bizz_check(len(ip) == 4, 'Invalid jabber endpoint IP: %s' % ip)
# validate srvEndPoints
for srv_record in settings.srvEndPoints:
parts = srv_record.split(":")
bizz_check(len(parts) == 3, 'Invalid SRV record: %s' % srv_record)
ip = [int(p) for p in parts[0].split('.')]
bizz_check(len(ip) == 4, "Invalid IP '%s' in SRV record: %s" % (ip, srv_record))
# sort srvEndPoints by priority
settings.srvEndPoints = sorted(settings.srvEndPoints, key=lambda x: x.split(':')[2])
if settings.dkimPrivateKey:
# dkimPrivateKey dos2unix
settings.dkimPrivateKey = settings.dkimPrivateKey.replace("\r", "")
settings.put()
result = "Settings saved successfully!"
except Exception, e:
if not isinstance(e, BusinessException):
logging.exception('Error happened while updating setting')
result = 'ERROR: %s' % e.message
def get_pending_payment_details(app_user, transaction_id):
ppr = PaymentPendingReceive.create_key(transaction_id).get()
user_profile = get_user_profile(ppr.app_user)
payment_provider = _validate_transaction_call(ppr, app_user, validate_started=False)
provider_module = get_api_module(ppr.provider_id)
status = PaymentPendingReceive.STATUS_SCANNED
payment_user = get_payment_user(app_user)
enabled = payment_user is not None and payment_user.has_provider(payment_provider.id)
base_url = get_server_settings().baseUrl
provider = AppPaymentProviderTO.from_model(base_url, payment_provider, enabled, app_user)
assets = []
if payment_user and payment_user.has_provider(ppr.provider_id):
assets = provider_module.get_payment_assets(app_user, ppr.currency)
receiver = UserDetailsTO.fromUserProfile(user_profile)
receiver_asset = provider_module.get_payment_asset(ppr.app_user, ppr.asset_id)
ppr.status = status
ppr.pay_user = app_user
if ppr.precision is None:
ppr.precision = 2
ppr.put()
deferred.defer(send_update_payment_status_request, ppr)
return PendingPaymentDetailsTO(status, transaction_id, provider, assets, receiver, receiver_asset, ppr.currency,
ppr.amount, ppr.memo, ppr.timestamp, ppr.precision)
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 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 get(self, app_id):
if not app_id:
self.error(404)
return
language = get_languages_from_header(self.request.headers.get('Accept-Language', None))
logging.info("Getting info about app with id %s", app_id)
app = get_app_by_id(app_id.lower().strip())
if not app or not app.is_in_appstores():
# Unknown app ===> Show sorry page
logging.info("Unknown app ===> Show sorry page ")
context = {'app_id': app_id}
self.response.out.write(render('sorry_app_unknown', language, context, 'web'))
return
user_agent = self.request.environ.get('HTTP_USER_AGENT')
if user_agent:
supported_platform = get_platform_by_user_agent(user_agent)
if supported_platform == "android":
self.redirect(str(app.android_market_web_uri))
return
if supported_platform == "ios":
self.redirect(str(app.ios_appstore_web_uri))
return
logging.info("Unsupported platform ===> Show sorry page with install instructions for android & iphone")
context = {'payload': urllib.urlencode([("chl", "%s/A/%s" % (get_server_settings().baseUrl, app_id))]),
'app_name': app.name}
self.response.out.write(render('sorry_app_not_supported', language, context, 'web'))
def init_env():
from google.appengine.api import datastore_file_stub, apiproxy_stub_map, user_service_stub, mail_stub, urlfetch_stub
from google.appengine.api.app_identity import app_identity_stub
from google.appengine.api.blobstore import blobstore_stub, file_blob_storage
from google.appengine.api.images import images_stub
from google.appengine.api.memcache import memcache_stub
from google.appengine.api.taskqueue import taskqueue_stub
try:
if not apiproxy_stub_map.apiproxy.GetStub('user'):
apiproxy_stub_map.apiproxy.RegisterStub('user', user_service_stub.UserServiceStub())
apiproxy_stub_map.apiproxy.RegisterStub('datastore_v3',
datastore_file_stub.DatastoreFileStub('mobicagecloud', '/dev/null',
'/dev/null'))
apiproxy_stub_map.apiproxy.RegisterStub('mail', mail_stub.MailServiceStub())
apiproxy_stub_map.apiproxy.RegisterStub('blobstore', blobstore_stub.BlobstoreServiceStub(
file_blob_storage.FileBlobStorage('/dev/null', 'mobicagecloud')))
apiproxy_stub_map.apiproxy.RegisterStub('memcache', memcache_stub.MemcacheServiceStub())
apiproxy_stub_map.apiproxy.RegisterStub('images', images_stub.ImagesServiceStub())
apiproxy_stub_map.apiproxy.RegisterStub('urlfetch', urlfetch_stub.URLFetchServiceStub())
apiproxy_stub_map.apiproxy.RegisterStub('taskqueue', taskqueue_stub.TaskQueueServiceStub())
apiproxy_stub_map.apiproxy.RegisterStub('app_identity_service', app_identity_stub.AppIdentityServiceStub())
except Exception as e:
print e
raise
from rogerthat.settings import get_server_settings
settings = get_server_settings()
settings.jabberDomain = "localhost"
def start_admin_debugging(app_user, timeout):
mobiles = list(get_user_active_mobiles(app_user))
azzert(len(mobiles) == 1)
m = mobiles[0]
if m.type in (Mobile.TYPE_IPHONE_HTTP_APNS_KICK,
Mobile.TYPE_IPHONE_HTTP_XMPP_KICK,
Mobile.TYPE_WINDOWS_PHONE) \
or (m.is_android and m.pushId):
# No XMPP account needs to be created
settings = get_server_settings()
jid = base64.b64encode(encrypt_value(md5(settings.secret), users.get_current_user().email().encode('utf8')))
password = None
type_ = CurrentlyForwardingLogs.TYPE_GAE_CHANNEL_API
else:
account = generate_account(u'dbg_%s' % uuid.uuid4().get_hex())
if not APPSCALE:
create_jabber_account(account, None)
jid = account.account
password = account.password
type_ = CurrentlyForwardingLogs.TYPE_XMPP
def trans():
debug_request = StartDebuggingRequest(key=StartDebuggingRequest.create_key(app_user, jid),
timestamp=now())
db.put_async(debug_request)
deferred.defer(stop_debugging, app_user, jid, debug_request=debug_request, notify_user=False,
_countdown=timeout * 60, _transactional=True, _queue=SCHEDULED_QUEUE)
return start_log_forwarding(app_user, jid, xmpp_target_password=password, type_=type_)
xg_on = db.create_transaction_options(xg=True)
return db.run_in_transaction_options(xg_on, trans)
def _finishup_mobile_registration(mobile, invitor_code, invitor_secret, ipaddress, ms_key):
mobile_user = mobile.user
app_settings = get_app_settings(get_app_id_from_app_user(mobile_user))
user_profile = get_user_profile(mobile_user)
server_settings = get_server_settings()
def trans(): # Operates on 2 entity groups
email = get_human_user_from_app_user(mobile_user).email()
for _, static_email in chunks(server_settings.staticPinCodes, 2):
if email == static_email:
break
else:
deferred.defer(send_welcome_message, mobile_user, _transactional=True, _countdown=5)
mobile_settings = db.get(ms_key)
request = UpdateSettingsRequestTO()
request.settings = SettingsTO.fromDBSettings(app_settings, user_profile, mobile_settings)
updateSettings(update_settings_response_handler, logError, mobile_user, request=request)
deferred.defer(_finishup_mobile_registration_step2, mobile.key(), invitor_code, invitor_secret, ipaddress,
mobile_settings.majorVersion, mobile_settings.minorVersion, _transactional=True,
_queue=FAST_QUEUE)
xg_on = db.create_transaction_options(xg=True)
db.run_in_transaction_options(xg_on, trans)
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):
service_user = users.get_current_user()
session_ = users.get_current_session()
service_identity = session_.service_identity
slide_id = self.request.get('i')
if not slide_id:
self.redirect("/ourcityapp")
return
slide_id = long(slide_id)
if is_default_service_identity(service_identity):
service_identity_user = service_user
else:
service_identity_user = create_service_identity_user(service_user, service_identity)
def trans():
slide = SolutionLoyaltySlide.get_by_id(slide_id, parent=parent_key_unsafe(service_identity_user, SOLUTION_COMMON))
return slide
slide = db.run_in_transaction(trans)
if not slide:
self.redirect("/ourcityapp")
return
server_settings = get_server_settings()
jinja_template = JINJA_ENVIRONMENT.get_template('loyalty_preview.html')
self.response.out.write(jinja_template.render({'slide_id': slide_id,
'full_url': slide.slide_url(),
'overlay_url': '%s/common/loyalty/slide/overlay' % (server_settings.baseUrl)}))
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 get_postback_url():
if DEBUG:
return "%s/api/1/callback" % get_server_settings().baseUrl
elif APPSCALE:
return "https://%s/api/1/callback" % os.environ['SERVER_NAME']
else:
return "https://%s.appspot.com/api/1/callback" % APPENGINE_APP_ID
def _validate_hash(self, hash_to_be_validated, user_email, message):
hash_ = hashlib.sha256()
hash_.update(user_email)
hash_.update(message)
hash_.update(get_server_settings().jabberSecret)
hash_ = hash_.hexdigest()
return hash_to_be_validated == hash_
def _send_mail_via_mime(from_, to, mime):
import smtplib
from rogerthat.settings import get_server_settings
settings = get_server_settings()
mime_string = mime.as_string()
logging.info("mime_string type: %s", type(mime_string))
if DEBUG:
logging.warn("Not sending real email via mime\n%s", mime_string)
for part in mime.walk():
logging.info("part.get_content_type(): %s", part.get_content_type())
if part.get_content_type() == 'text/plain':
logging.info(base64.b64decode(part.get_payload()))
return
if settings.dkimPrivateKey:
if from_ == settings.dashboardEmail or "<%s>" % settings.dashboardEmail in from_:
logging.info("Adding dkim signature")
try:
import dkim
signature = dkim.sign(mime_string, 'dashboard.email', settings.dashboardEmail.split('@')[1], settings.dkimPrivateKey, include_headers=['To', 'From', 'Subject'])
logging.info("signature type: %s", type(signature))
mime_string = signature.encode('utf-8') + mime_string
except:
logging.exception("Could not create dkim signature!")
else:
logging.info("Skipping dkim signature because '%s' != '%s'", from_, settings.dashboardEmail)
mailserver = smtplib.SMTP_SSL(settings.smtpserverHost, int(settings.smtpserverPort))
mailserver.ehlo()
mailserver.login(settings.smtpserverLogin, settings.smtpserverPassword)
mailserver.sendmail(from_, to, mime_string)
mailserver.quit()
def _execute_flow(service_identity_user, message_flow_design, message_flow_run_record, members, message_parent_key,
context=None, resultKey=None, force_language=None, broadcast_type=None, broadcast_guid=None, tag=None):
logging.info("Executing message flow for %s with force_language %s" %
(service_identity_user.email(), force_language))
xml_doc = _create_message_flow_run_xml_doc(service_identity_user, message_flow_design, message_flow_run_record,
members, force_language)
logging.info(xml_doc.toxml())
xml = xml_doc.toxml("utf-8")
settings = get_server_settings()
headers = {
'X-Nuntiuz-Service-Identifier-Key': get_mfr_sik(service_identity_user).sik,
'X-Nuntiuz-Service-Identity': base64.b64encode(get_identity_from_service_identity_user(service_identity_user)),
'X-Nuntiuz-Service-API-Key': get_mfr_api_key(service_identity_user).key().name(),
'X-Nuntiuz-Shared-Secret': settings.secret,
'X-Nuntiuz-MessageFlowRunId': message_flow_run_record.messageFlowRunId,
'X-Nuntiuz-MessageParentKey': message_parent_key if message_parent_key else "",
'X-Nuntiuz-Context': context if context else "",
'X-Nuntiuz-ResultKey': resultKey,
'Content-type': 'text/xml'
}
if broadcast_guid:
headers['X-Nuntiuz-BroadcastGuid'] = broadcast_guid
if tag:
headers['X-Nuntiuz-Tag'] = tag.encode('utf')
logging.debug('Executing flow with run id %s for members %s', message_flow_run_record.messageFlowRunId, members)
result = urlfetch.fetch(
"%s/api" % settings.messageFlowRunnerAddress, xml, "POST", headers, False, False, deadline=10 * 60)
if result.status_code != 200:
error_message = "MFR returned status code %d" % result.status_code
if result.status_code == 400:
logging.error(error_message, _suppress=False)
raise deferred.PermanentTaskFailure(error_message)
raise Exception(error_message)
logging.debug('MFR response: %s', result.content)
if len(members) == 1 and result.content:
try:
flow_start_result = parse_complex_value(FlowStartResultCallbackResultTO, json.loads(result.content), False)
if isinstance(flow_start_result.value, MessageCallbackResultTypeTO):
sendMessage(service_identity_user, [UserMemberTO(members[0], flow_start_result.value.alert_flags)],
flow_start_result.value.flags, 0, message_parent_key, flow_start_result.value.message,
flow_start_result.value.answers, None, flow_start_result.value.branding,
flow_start_result.value.tag, flow_start_result.value.dismiss_button_ui_flags, context,
key=resultKey, is_mfr=True, broadcast_type=broadcast_type, broadcast_guid=broadcast_guid,
attachments=flow_start_result.value.attachments,
step_id=None if flow_start_result.value.step_id is MISSING else flow_start_result.value.step_id)
elif isinstance(flow_start_result.value, FormCallbackResultTypeTO):
sendForm(service_identity_user, message_parent_key, members[0], flow_start_result.value.message,
flow_start_result.value.form, flow_start_result.value.flags, flow_start_result.value.branding,
flow_start_result.value.tag, flow_start_result.value.alert_flags, context, key=resultKey,
is_mfr=True, broadcast_type=broadcast_type, attachments=flow_start_result.value.attachments,
broadcast_guid=broadcast_guid,
step_id=None if flow_start_result.value.step_id is MISSING else flow_start_result.value.step_id)
except:
logging.exception("Failed to parse result from message flow runner.")
def _handle_service_interaction_based_invitation(self, entry_point, code, language, su, user_agent, version):
match = re.match("^/q/s/(.+)/(\\d+)$", su.full)
if not match:
self.response.out.write(_TMPL % su.full)
else:
user_code = match.group(1)
service_profile = get_service_profile_via_user_code(user_code)
if not service_profile: # Profile of usercode not found. Sorry we can't help you :(
logging.info("Profile of usercode not found. Sorry we can't help you :(")
self.response.out.write(_TMPL % "/")
return
service_user = service_profile.user
if entry_point == "S": # It's a QR-Code
logging.info("It's a QR-Code")
sid = int(match.group(2))
service_interaction_def = get_service_interaction_def(service_user, int(sid))
service_identity_user = create_service_identity_user(service_user, service_interaction_def.service_identity)
service_identity = get_service_identity(service_identity_user)
self._handle_after_qr_code_scan(user_agent, service_identity, language, sid)
return
if entry_point == "M":
logging.info("It's a Message")
else:
logging.warn("Expected entry_point 'M' but got '%s'." % entry_point)
# Get service identity by sid
sid = int(match.group(2))
service_interaction_def = get_service_interaction_def(service_user, int(sid))
service_identity_user = create_service_identity_user(service_user, service_interaction_def.service_identity)
service_identity = get_service_identity(service_identity_user)
supported_platform = determine_if_platform_supports_rogerthat_by_user_agent(user_agent)
if (version and version == "web") or not supported_platform:
logging.info("Unsupported platform ===> Show sorry page with install instructions for android & iphone")
variables = {'profile': service_identity,
'payload': urllib.urlencode([("chl", "%s/S/%s" % (get_server_settings().baseUrl, code))]),
'app_name': get_app_name_by_id(service_identity.app_id)}
# Unsupported platform ===> Show sorry page with install instructions for android & iphone
self.response.out.write(render('sorry_step2', language, variables, 'web'))
else:
fallback_url = "%s/%s/%s?v=web" % (get_server_settings().baseUrl, entry_point, code)
redirect_to_app(self, user_agent.lower(), service_identity.app_id, su.full, fallback_url)
def add_new_beacon_discovery(app_user, beacon_uuid, beacon_name):
'''A human user has discovered a beacon'''
beacon_uuid = beacon_uuid.lower()
beacon = get_beacon(beacon_uuid, beacon_name)
if not beacon:
logging.warn("Beacon not found: {uuid: %s, name: %s}", beacon_uuid, beacon_name)
return None, None
keyy = BeaconDiscovery.create_key(app_user, beacon.service_identity_user)
beaconDiscovery = BeaconDiscovery.get(keyy)
if beaconDiscovery:
return beacon.service_identity_user, beacon.tag
BeaconDiscovery(key=keyy, creation_time=now()).put()
si = get_service_identity(beacon.service_identity_user)
if not si:
logging.error("Service identity not found for service_identity_user: %s" % beacon.service_identity_user)
elif not si.beacon_auto_invite:
logging.info("Beacon detected but %s does not allow auto invite {user %s, uuid: %s, name: %s}",
beacon.service_identity_user, app_user, beacon_uuid, beacon_name)
elif get_app_id_from_app_user(app_user) not in si.appIds:
logging.info("Beacon detected but %s does not contain app_id of user %s: {uuid: %s, name: %s}",
beacon.service_identity_user, app_user, beacon_uuid, beacon_name)
return None, None
elif get_friend_serviceidentity_connection(app_user, beacon.service_identity_user):
logging.info("Beacon detected but %s and %s were already friends: {uuid: %s, name: %s}",
app_user, beacon.service_identity_user, beacon_uuid, beacon_name)
else:
# Fake a deleted connection between service and human user to be able to show the service's avatar on the phone
friend_map = get_friends_map(app_user)
friend_map.generation += 1
friend_map.version += 1
friend_map.put()
friend_detail = FriendDetails().addNew(remove_slash_default(beacon.service_identity_user),
si.name, si.avatarId, type_=FriendDetail.TYPE_SERVICE)
friend_detail.relationVersion = -1
from rogerthat.bizz.job.update_friends import _do_update_friend_request
_do_update_friend_request(app_user, friend_detail, UpdateFriendRequestTO.STATUS_ADD, friend_map,
extra_conversion_kwargs=dict(existence=FriendTO.FRIEND_EXISTENCE_DELETED,
includeServiceDetails=False))
user_profile = get_user_profile(app_user)
app_name = get_app_name_by_id(user_profile.app_id)
m = localize(user_profile.language, "_automatic_detection_invitation", app_name=app_name, service_name=si.name)
_send_invitation_message_from_service_to_user(app_user, beacon.service_identity_user, m,
si.descriptionBranding, user_profile.language,
ORIGIN_BEACON_DETECTED, BEACON_DISCOVERY)
message = "Beacon detected at %s (%s) with tag: %s" % (si.name.encode('utf8'),
remove_slash_default(si.service_identity_user).email().encode('utf8'),
beacon.tag.encode('utf8'))
server_settings = get_server_settings()
xmpp.send_message(server_settings.xmppInfoMembers, message, message_type=xmpp.MESSAGE_TYPE_CHAT)
return beacon.service_identity_user, beacon.tag
def get(self):
server_settings = get_server_settings()
cookie = self.request.cookies.get(server_settings.cookieQRScanName)
if cookie:
scan_url = parse_cookie(cookie)
self.redirect(scan_url)
else:
self.redirect("rogerthat://i/qr?success=false")
def get(news_id, service_identity=None, include_statistics=False):
t = time.time()
service_user = users.get_current_user()
service_identity_user = get_and_validate_service_identity_user(service_user, service_identity)
news_item = news.get_news(service_identity_user, news_id)
logging.info('Fetching news item took %s', time.time() - t)
statistics = get_news_items_statistics([news_item], True).get(news_id) if include_statistics else None
return NewsItemTO.from_model(news_item, get_server_settings().baseUrl, statistics)
def api_create_payment_provider(data):
"""
Args:
data (CreatePaymentProviderTO)
"""
payment_provider = create_payment_provider(data)
base_url = get_server_settings().baseUrl
return PaymentProviderTO.from_model(base_url, payment_provider)
def slide_url(self):
from rogerthat.settings import get_server_settings
server_settings = get_server_settings()
if self.gcs_filename:
return get_serving_url(self.gcs_filename)
return unicode("%s/unauthenticated/loyalty/slide?%s" %
(server_settings.baseUrl,
urllib.urlencode(dict(slide_key=self.item.key()))))
def get_serving_url(filename):
"""
Args:
filename (unicode)
"""
if DEBUG:
return '%s/_ah/gcs%s' % (get_server_settings().baseUrl, filename)
return 'https://storage.googleapis.com%s' % filename
def post(self):
data = json.loads(self.request.body)
jid = data['jid']
message = data['message']
settings = get_server_settings()
app_user_email = decrypt_value(md5(settings.secret), base64.b64decode(jid))
forward_log(users.User(app_user_email), message)
def post(self):
settings = get_server_settings()
secret = self.request.headers.get("X-Nuntiuz-Secret", None)
if secret != settings.jabberSecret:
logging.error(u"Received unauthenticated callback response, ignoring ...")
return
sik = self.request.headers.get("X-Nuntiuz-Service-Key", None)
if not sik:
logging.error(u"Received invalid Callback response without Service Identifier Key")
return
sik = get_sik(sik)
if not sik:
logging.error("Received invalid Callback response with unknown Service Identifier Key:\nsik: %s\nbody:\n%s" % (
self.request.headers.get("X-Nuntiuz-Service-Key", None), self.request.body))
return
users.set_user(sik.user)
raw_result = self.request.body
try:
from google.appengine.api.memcache import get # @UnresolvedImport
if get(sik.user.email() + "_interactive_logs"):
content_type = self.request.headers.get('content-type', 'unknown')
status = self.request.headers.get('X-Nuntiuz-Service-Status', 'unknown')
if status == "600":
status = "unknown"
result_url = self.request.headers.get('X-Nuntiuz-Service-Result-Url', 'unknown')
channel.send_message(sik.user, "rogerthat.service.interactive_logs", content_type=content_type,
status=status, result_url=result_url, body=raw_result.decode('utf-8', 'replace'))
except:
logging.exception("Error during interactive logging.")
try:
result = json.loads(raw_result)
except Exception:
raw_result_unicode = raw_result.decode('utf-8', 'replace')
logging.warning(u"Could not parse request body as JSON!\n" + raw_result_unicode)
error_code = ERROR_CODE_INVALID_JSON
error_message = u"The JSON_RPC response could not be parsed as a valid JSON."
log_service_activity(sik.user, str(time.time()), ServiceLog.TYPE_CALLBACK, ServiceLog.STATUS_ERROR,
None, None, raw_result_unicode, error_code, error_message)
return
raw_result_unicode = json.dumps(privatize(deepcopy(result)), ensure_ascii=False)
logging.info(u"Incoming call back response:\n" + raw_result_unicode)
if not result:
error_code = ERROR_CODE_INVALID_JSON
error_message = u"The JSON_RPC response could not be parsed as a valid json."
log_service_activity(sik.user, None, ServiceLog.TYPE_CALLBACK, ServiceLog.STATUS_ERROR, None, None,
raw_result_unicode, error_code, error_message)
return
from rogerthat.dal import parent_key
service_api_callback = ServiceAPICallback.get_by_key_name(result["id"], parent=parent_key(sik.user))
if not service_api_callback:
logging.warning(u"Service api call back response record not found !")
return
_process_callback_result(sik, result, raw_result_unicode, service_api_callback, True)
def submit_service_api_callback(profile, service_api_callback, effective_kwargs=None, function=None, synchronous=False,
call_dict=None, response_type=None):
if service_api_callback.is_solution and not service_api_callback.targetMFR:
result = _send_to_solution_context(service_api_callback, profile, effective_kwargs, function, synchronous,
call_dict, response_type)
if synchronous:
return result
return True, None
from rogerthat.bizz.service import get_mfr_sik
settings = get_server_settings()
mfr_uri = "%s/callback_api" % settings.messageFlowRunnerAddress
mobidick_uri = "%s/callback_api" % settings.mobidickAddress
if service_api_callback.targetMFR:
sik = get_mfr_sik(profile.user).sik
uri = mfr_uri
else:
if profile.callBackURI == "mobidick":
uri = mobidick_uri
else:
uri = profile.callBackURI
sik = profile.sik
callback_name = call_dict.get("callback_name") if call_dict else None
tag = call_dict.get("params", dict()).get("tag") if call_dict else None
logging.debug("callback_name: '%s' and tag: '%s'", callback_name, tag)
if callback_name:
scc = ServiceCallBackConfiguration.get(
ServiceCallBackConfiguration.create_key(callback_name, profile.service_user))
if scc:
uri = scc.callBackURI
elif tag:
try:
from rogerthat.dal.service import get_regex_callback_configurations_cached
regex_callbacks = []
for scc in get_regex_callback_configurations_cached(profile.service_user):
if re.match(scc.regex, tag):
regex_callbacks.append(scc)
logging.debug("Matched callback (%s) with regex '%s' to tag '%s'", scc.name, scc.regex, tag)
else:
logging.debug(
"Could NOT match callback (%s) with regex '%s' to tag '%s'", scc.name, scc.regex, tag)
if regex_callbacks:
regex_callback = random.choice(regex_callbacks)
uri = regex_callback.callBackURI
except:
logging.warn("Failed to submit to regex callback with tag '%s'" % tag, exc_info=True)
logging.info("Sending callback to %s, identifying through sik %s @ %s:\n%s"
% (profile.user, sik, uri, service_api_callback.call))
if not (uri and sik):
logging.error("Not enough information present to send the call!")
return False, "Not enough information present to send the call!"
result = send_service_api_callback(service_api_callback, profile.sik, uri, synchronous)
if synchronous:
return result
return True, None
def get(self):
if self.request.headers.get(
'X-Rogerthat-Secret') != get_server_settings().secret:
self.abort(401)
products = export_products()
self.response.headers['Content-Type'] = 'text/json'
self.response.write(json.dumps(products))
def id_to_email(id_):
from rogerthat.settings import get_server_settings
from rogerthat.utils.crypto import sha256, decrypt_value
from mcfw.serialization import ds_str
settings = get_server_settings()
stream = StringIO(base64.decodestring(id_))
tmp_secret = ds_str(stream)
return decrypt_value(sha256("%s%s" % (tmp_secret, settings.secret.encode("utf-8"))), ds_str(stream)).decode('utf-8')
def get(self):
user = users.get_current_user()
template_id = self.request.get("template_id")
logging.info(template_id)
template = QRTemplate.get_by_id(int(template_id[2:], 16), parent_key(user))
self.response.headers['Content-Type'] = "image/png"
logging.info(map(int, template.body_color))
url = "%s/" % get_server_settings().baseUrl
self.response.out.write(qrcode(url, template.blob, map(int, template.body_color), True))
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 feedback response, ignoring ...")
return
device = self.request.get('device')
obsolete_apple_push_device_token(device)
def get_twitter_auth_url(service_user):
server_settings = get_server_settings()
solution_server_settings = get_solution_server_settings()
app_key = str(solution_server_settings.twitter_app_key)
app_secret = str(solution_server_settings.twitter_app_secret)
client = oauth.TwitterClient(
app_key, app_secret, CALLBACK_URL %
(server_settings.baseUrl, urlencode({"s": service_user.email()})))
auth_url = client.get_authorization_url()
return auth_url
def reset():
db.delete(RogerthatBackendErrors.get_key())
db.delete(list(get_monitored_services_in_trouble_qry()))
server_settings = get_server_settings()
send_to = server_settings.supportWorkers
send_to.append(server_settings.dashboardEmail)
send_message(map(users.User, send_to),
'shop.monitoring.reset',
skip_dashboard_user=False)
return RETURNSTATUS_TO_SUCCESS
def get(self):
if self.request.headers.get(
'X-Rogerthat-Secret') != get_server_settings().secret:
self.abort(401)
year = int(self.request.GET['year'])
month = int(self.request.GET['month'])
invoices = export_invoices(year, month)
self.response.headers['Content-Type'] = 'text/json'
self.response.write(json.dumps(invoices))
def find_prospects(app_id,
postal_codes,
sw_lat,
sw_lon,
ne_lat,
ne_lon,
city_name,
check_phone_number,
radius=200):
logging.info(
'Finding prospects for %s',
dict(app_id=app_id,
postal_codes=postal_codes,
south_west=(sw_lat, sw_lon),
north_east=(ne_lat, ne_lon),
check_phone_number=check_phone_number,
city_name=city_name))
google_maps_key = get_server_settings().googleMapsKey
shop_app_key = ShopApp.create_key(app_id)
def trans():
app = get_app_by_id(app_id)
azzert(app)
shop_app = db.get(shop_app_key)
if not shop_app:
shop_app = ShopApp(key=shop_app_key)
shop_app.name = app.name
shop_app.searched_south_west_bounds.append(db.GeoPt(sw_lat, sw_lon))
shop_app.searched_north_east_bounds.append(db.GeoPt(ne_lat, ne_lon))
shop_app.postal_codes = postal_codes
shop_app.put()
deferred.defer(_start_building_grid,
google_maps_key,
app_id,
postal_codes,
radius,
sw_lat,
sw_lon,
ne_lat,
ne_lon,
city_name,
check_phone_number,
_transactional=True,
_queue=HIGH_LOAD_WORKER_QUEUE)
xg_on = db.create_transaction_options(xg=True)
db.run_in_transaction_options(xg_on, trans)
def get(self):
service_user_email = self.request.get("s")
service_user = users.User(service_user_email)
denied = self.request.get("denied")
if denied:
self.response.out.write("""<html>
<body><h1>Twitter login cancelled, you can close this window now.</h1></body>
<script>self.close();</script>
</html>""")
else:
oauth_token = self.request.get("oauth_token")
oauth_verifier = self.request.get("oauth_verifier")
logging.info("service_user_email: %s", service_user_email)
logging.info("oauth_token: %s", oauth_token)
logging.info("oauth_verifier: %s", oauth_verifier)
key = AuthToken.key_name(oauth.TWITTER, oauth_token)
auth_model = AuthToken.get_by_key_name(key)
if auth_model:
server_settings = get_server_settings()
solution_server_settings = get_solution_server_settings()
client = oauth.TwitterClient(
solution_server_settings.twitter_app_key,
solution_server_settings.twitter_app_secret,
CALLBACK_URL % (server_settings.baseUrl,
urlencode({"s": service_user.email()})))
r = client.get_user_info(oauth_token, oauth_verifier, True)
sln_settings = get_solution_settings(service_user)
if sln_settings:
sln_settings.twitter_oauth_token = r["token"]
sln_settings.twitter_oauth_token_secret = r["secret"]
sln_settings.twitter_username = r["username"]
put_and_invalidate_cache(sln_settings)
send_message(service_user,
u"solutions.common.twitter.updated",
username=r["username"])
self.response.out.write("""<html>
<body><h1>witter login success, you can close this window now.</h1></body>
<script>self.close();</script>
</html>""")
def export_menu_to_excel(service_user, sln_settings=None):
"""Exports the menu to excel file
Args:
service_user: users.User
Returns:
Excel file content
"""
if not sln_settings:
sln_settings = get_solution_settings(service_user)
language = sln_settings.main_language
translate = partial(common_translate, language, SOLUTION_COMMON)
menu = get_restaurant_menu(service_user, sln_settings.solution)
workbook = xlwt.Workbook(encoding="utf-8")
sheet = workbook.add_sheet(translate('menu'))
settings = get_server_settings()
row = 0
for i, head in enumerate(MENU_HEADER):
sheet.write(row, i, translate(head).capitalize())
for cat in menu.categories:
for item_idx, item in enumerate(cat.items):
row += 1
if item_idx == 0:
sheet.write(row, 0, cat.name)
sheet.write(row, 1, item.name)
sheet.write(row, 2, item.description)
sheet.write(row, 3, translate(UNITS[item.unit]))
sheet.write(row, 4, item.price / 100.0)
if item.image_id:
sheet.write(row, 5, get_item_image_url(item.image_id,
settings))
excel_file = StringIO()
workbook.save(excel_file)
return excel_file.getvalue()
def init_env():
try:
if not apiproxy_stub_map.apiproxy.GetStub('user'):
apiproxy_stub_map.apiproxy.RegisterStub(
'user', user_service_stub.UserServiceStub())
apiproxy_stub_map.apiproxy.RegisterStub(
'datastore_v3',
datastore_file_stub.DatastoreFileStub('mobicagecloud',
'/dev/null',
'/dev/null'))
apiproxy_stub_map.apiproxy.RegisterStub(
'mail', mail_stub.MailServiceStub())
apiproxy_stub_map.apiproxy.RegisterStub(
'blobstore',
blobstore_stub.BlobstoreServiceStub(
file_blob_storage.FileBlobStorage('/dev/null',
'mobicagecloud')))
apiproxy_stub_map.apiproxy.RegisterStub(
'memcache', memcache_stub.MemcacheServiceStub())
apiproxy_stub_map.apiproxy.RegisterStub(
'images', images_stub.ImagesServiceStub())
apiproxy_stub_map.apiproxy.RegisterStub(
'urlfetch', urlfetch_stub.URLFetchServiceStub())
apiproxy_stub_map.apiproxy.RegisterStub(
'taskqueue', taskqueue_stub.TaskQueueServiceStub())
apiproxy_stub_map.apiproxy.RegisterStub(
'app_identity_service',
app_identity_stub.AppIdentityServiceStub())
except Exception as e:
print e
raise
from rogerthat.settings import get_server_settings
settings = get_server_settings()
settings.jabberDomain = "localhost"
def get(self, app_id):
path = os.path.join(os.path.dirname(__file__), 'html',
'customer_map.html')
settings = get_server_settings()
lang = get_languages_from_request(self.request)[0]
translations = {
'merchants':
shop_translate(lang, 'merchants'),
'merchants_with_terminal':
shop_translate(lang, 'merchants_with_terminal'),
'community_services':
shop_translate(lang, 'community_services'),
'care':
shop_translate(lang, 'care'),
'associations':
shop_translate(lang, 'associations'),
}
params = {
'maps_key': settings.googleMapsKey,
'app_id': app_id,
'translations': json.dumps(translations)
}
self.response.out.write(template.render(path, params))
def get_item_image_url(image_id, settings=None):
if not settings:
settings = get_server_settings()
return u"%s/solutions/common/public/menu/image/%s" % (settings.baseUrl,
image_id)
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 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
def trans():
old_order, team = db.get(
(old_order_key, RegioManagerTeam.create_key(customer.team_id)))
if not old_order:
return BoolReturnStatusTO.create(
False,
translate(
get_solution_settings(service_user).main_language,
SOLUTION_COMMON, u'cart_empty'), False)
# Duplicate the order
to_put = list()
to_delete = list()
properties = copy_model_properties(old_order)
properties['status'] = Order.STATUS_SIGNED
properties['date_signed'] = now()
new_order_key = Order.create_key(
customer.id, OrderNumber.next(team.legal_entity_key))
new_order = Order(key=new_order_key, **properties)
new_order.team_id = team.id
to_delete.append(old_order)
# duplicate all of the order items
old_order_items = OrderItem.list_by_order(old_order_key)
all_products = db.get([
Product.create_key(item.product_code) for item in old_order_items
])
is_subscription_extension_order = False
for product in all_products:
if product.is_subscription_extension:
is_subscription_extension_order = True
break
new_order.is_subscription_extension_order = is_subscription_extension_order
if is_subscription_extension_order:
subscription_order = Order.get_by_order_number(
customer.id, customer.subscription_order_number)
new_order.next_charge_date = subscription_order.next_charge_date
added_apps = list()
should_create_shoptask = False
for old_item in old_order_items:
properties = copy_model_properties(old_item)
new_item = OrderItem(parent=new_order_key, **properties)
to_put.append(new_item)
to_delete.append(old_item)
if hasattr(old_item, 'app_id'):
added_apps.append(old_item.app_id)
else:
should_create_shoptask = True
to_put.append(new_order)
db.put(to_put)
db.delete(to_delete)
deferred.defer(generate_and_put_order_pdf_and_send_mail,
customer,
new_order_key,
service_user,
_transactional=True)
# No need for signing here, immediately create a charge.
azzert(new_order.total_amount > 0)
charge = Charge(parent=new_order_key)
charge.date = now()
charge.type = Charge.TYPE_ORDER_DELIVERY
charge.amount = new_order.amount
charge.vat_pct = new_order.vat_pct
charge.vat = new_order.vat
charge.total_amount = new_order.total_amount
charge.manager = new_order.manager
charge.team_id = new_order.team_id
charge.status = Charge.STATUS_PENDING
charge.date_executed = now()
charge.currency_code = team.legal_entity.currency_code
charge.put()
# Update the regiomanager statistics so these kind of orders show up in the monthly statistics
deferred.defer(update_regiomanager_statistic,
gained_value=new_order.amount / 100,
manager=new_order.manager,
_transactional=True)
# Update the customer service
si = get_default_service_identity(users.User(customer.service_email))
si.appIds.extend(added_apps)
si.put()
deferred.defer(re_index, si.user, _transactional=True)
# Update the customer object so the newly added apps are added.
customer.app_ids.extend(added_apps)
customer.extra_apps_count += len(added_apps)
customer.put()
get_payed(customer.id, new_order, charge)
# charge the credit card
channel.send_message(service_user, 'common.billing.orders.update')
channel_data = {
'customer': customer.name,
'no_manager': True,
'amount': charge.amount / 100,
'currency': charge.currency
}
server_settings = get_server_settings()
send_to = server_settings.supportWorkers
send_to.append(MC_DASHBOARD.email())
channel.send_message(map(users.User, send_to),
'shop.monitoring.signed_order',
info=channel_data)
if should_create_shoptask:
prospect_id = customer.prospect_id
if prospect_id is None:
prospect = create_prospect_from_customer(customer)
prospect_id = prospect.id
deferred.defer(create_task_for_order,
customer.team_id,
prospect_id,
new_order.order_number,
_transactional=True)
return BoolReturnStatusTO.create(True, None)
def create_and_pay_news_order(service_user, news_item_id, order_items_to):
"""
Creates an order, orderitems, charge and executes the charge. Should be executed in a transaction.
Args:
service_user (users.User)
news_item_id (long)
order_items_to (ist of OrderItemTO)
Raises:
NoCreditCardException
ProductNotFoundException
"""
@db.non_transactional
def _get_customer():
return get_customer(service_user)
@db.non_transactional
def _get_contact():
return Contact.get_one(customer)
customer = _get_customer()
azzert(customer)
contact = _get_contact()
azzert(contact)
if not customer.stripe_valid:
raise NoCreditCardException(customer)
extra_city_product_key = Product.create_key(Product.PRODUCT_EXTRA_CITY)
news_product_key = Product.create_key(Product.PRODUCT_NEWS_PROMOTION)
rmt_key = RegioManagerTeam.create_key(customer.team_id)
extra_city_product, news_promotion_product, team = db.get(
(extra_city_product_key, news_product_key, rmt_key))
azzert(extra_city_product)
azzert(news_promotion_product)
azzert(team)
new_order_key = Order.create_key(customer.id,
OrderNumber.next(team.legal_entity_key))
vat_pct = get_vat_pct(customer, team)
total_amount = 0
added_app_ids = []
for order_item in order_items_to:
if order_item.product == Product.PRODUCT_EXTRA_CITY:
total_amount += extra_city_product.price * order_item.count
added_app_ids.append(order_item.app_id)
order_item.price = extra_city_product.price
elif order_item.product == Product.PRODUCT_NEWS_PROMOTION:
total_amount += news_promotion_product.price * order_item.count
order_item.price = news_promotion_product.price
else:
raise BusinessException('Invalid product \'%s\'' %
order_item.product)
si = get_default_service_identity(users.User(customer.service_email))
if added_app_ids:
keys = [App.create_key(app_id) for app_id in added_app_ids]
apps = db.get(keys)
for app_id, app in zip(added_app_ids, apps):
if not app:
raise AppNotFoundException(app_id)
if app_id in si.appIds:
raise BusinessException('Customer %s already has app_id %s' %
(customer.id, app_id))
vat = int(round(vat_pct * total_amount / 100))
total_amount_vat_incl = int(round(total_amount + vat))
now_ = now()
to_put = []
order = Order(key=new_order_key,
date=now_,
amount=total_amount,
vat_pct=vat_pct,
vat=vat,
total_amount=total_amount_vat_incl,
contact_id=contact.id,
status=Order.STATUS_SIGNED,
is_subscription_order=False,
is_subscription_extension_order=False,
date_signed=now_,
manager=STORE_MANAGER,
team_id=team.id)
to_put.append(order)
azzert(order.total_amount >= 0)
for item in order_items_to:
order_item = OrderItem(parent=new_order_key,
number=item.number,
product_code=item.product,
count=item.count,
comment=item.comment,
price=item.price)
order_item.app_id = item.app_id
if order_item.product_code == Product.PRODUCT_NEWS_PROMOTION:
order_item.news_item_id = news_item_id
to_put.append(order_item)
db.put(to_put)
# Not sure if this is necessary
deferred.defer(generate_and_put_order_pdf_and_send_mail,
customer,
new_order_key,
service_user,
_transactional=True)
# No need for signing here, immediately create a charge.
to_put = []
charge = Charge(parent=new_order_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.status = Charge.STATUS_PENDING
charge.date_executed = now()
charge.currency_code = team.legal_entity.currency_code
to_put.append(charge)
# Update the regiomanager statistics so these kind of orders show up in the monthly statistics
deferred.defer(update_regiomanager_statistic,
gained_value=order.amount / 100,
manager=order.manager,
_transactional=True)
# Update the customer service
si.appIds.extend(added_app_ids)
to_put.append(si)
# Update the customer object so the newly added apps are added.
customer.app_ids.extend(added_app_ids)
customer.extra_apps_count += len(added_app_ids)
to_put.append(customer)
db.put(to_put)
deferred.defer(re_index, si.user)
# charge the credit card
if charge.total_amount > 0:
get_payed(customer.id, order, charge)
server_settings = get_server_settings()
send_to = server_settings.supportWorkers
send_to.append(MC_DASHBOARD.email())
channel_data = {
'customer': customer.name,
'no_manager': True,
'amount': charge.amount / 100,
'currency': charge.currency
}
channel.send_message(map(users.User, send_to),
'shop.monitoring.signed_order',
info=channel_data)
else:
charge.status = Charge.STATUS_EXECUTED
charge.date_executed = now()
charge.put()
channel.send_message(service_user, 'common.billing.orders.update')