def order(request):
if request.method == 'GET':
beers = Card.objects.all()
context = {'beers': beers}
return render(request, 'order_page.html', context)
elif request.method == 'POST' and 'back' in request.POST:
return redirect('main_page')
elif request.method == 'POST' and 'confirm' in request.POST:
name = request.POST.get('name_1')
address = request.POST.get('address')
if not name or not address:
beers = Card.objects.all()
context = {'beers': beers, 'valid': 'Please, fill in your name and address'}
return render(request, 'order_page.html', context)
else:
customer = Customer(name=name, address=address)
customer.save()
all_card = Card.objects.all()
for orders in all_card:
Order.objects.create(beer=orders.beer, value=orders.value, customer=customer)
card = Card.objects.all()
card.delete()
return render(request, 'succ_page.html')
else:
id_del = request.POST.get('id')
all_card = Card.objects.get(id=id_del)
all_card.delete()
beers = Card.objects.all()
context = {'beers': beers}
return render(request, 'order_page.html', context)
def link_stripe_to_customer(customer_id_or_service_email, stripe_token,
stripe_token_created, contact_id):
solution_server_settings = get_solution_server_settings()
stripe.api_key = solution_server_settings.stripe_secret_key
if isinstance(customer_id_or_service_email, unicode):
customer = Customer.get_by_service_email(customer_id_or_service_email)
else:
customer = Customer.get_by_id(customer_id_or_service_email)
# Resellers and their customers should not be able to do this
google_user = gusers.get_current_user()
if not customer.team.legal_entity.is_mobicage:
logging.error(
"user %s tried to access function 'link_stripe_to_customer'",
google_user.email())
raise NoPermissionException()
if google_user:
azzert(user_has_permissions_to_team(google_user, customer.team_id))
if customer.stripe_id:
stripe_customer = stripe.Customer.retrieve(customer.stripe_id)
card = stripe_customer.cards.create(card=stripe_token)
stripe_customer.default_card = card.id
stripe_customer.save()
else:
stripe_customer = stripe.Customer.create(
card=stripe_token,
description=u"%s %s -- %s, %s, %s, %s, %s, %s" %
(customer.id, customer.vat, customer.name, customer.address1,
customer.address2, customer.zip_code, customer.city,
customer.country))
card = stripe_customer.cards.data[0]
try_or_defer(store_stripe_link_to_datastore, customer.key(),
stripe_customer.id, card.id, stripe_token_created, contact_id)
def post(self, request):
if request.POST.get('email'):
name = request.POST.get('name')
phone = request.POST.get('phone')
email = request.POST.get('email')
customer = Customer(name=name, phone=phone, email=email)
customer.save()
qrcode_path = customer.qrcode_create()
customer.qrcode = qrcode_path
customer.save()
order = Order(customer=customer, )
order.save()
cart = request.session.get('cart')
if cart:
for product_id, quantity in cart.items():
cart = Cart(product_id=product_id,
quantity=quantity,
order=order,
complete=True)
cart.save()
del request.session['cart']
request.session.save()
cart = order.cart_set.all()
context = {'cart': cart, 'order': order}
return render(request, 'shop/order.html', context)
def get_customer_subscription_length(customer_id):
customer = Customer.get_by_id(customer_id)
if not customer.subscription_order_number:
raise NoSubscriptionFoundException(customer)
months_till_charge, _ = get_subscription_order_remaining_length(
customer_id, customer.subscription_order_number)
return months_till_charge
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 set_service_disabled(customer_or_id, disabled_reason_int):
"""
Disables the customer his service, disconnects all users and sets the service invisible.
Args:
customer_or_id (int, long, Customer): customer or id
disabled_reason_int (int, long): reason why the service has been disabled
Raises:
NoSubscriptionException
BusinessException
"""
if isinstance(customer_or_id, Customer):
customer = customer_or_id
else:
customer = Customer.get_by_id(customer_or_id)
if not customer.service_email:
raise NoSubscriptionException(customer)
if disabled_reason_int not in Customer.DISABLED_REASONS:
raise BusinessException('Invalid disable service reason')
service_user = users.User(customer.service_email)
sln_settings = get_solution_settings(service_user)
customer.default_app_id = None
customer.app_ids = []
customer.service_disabled_at = now()
customer.disabled_reason_int = disabled_reason_int
customer.subscription_cancel_pending_date = 0
sln_settings.search_enabled = False
sln_settings.service_disabled = True
db.put([customer, sln_settings])
rogerthat_set_service_disabled(service_user)
def create_task_if_not_order(customer_id):
customer = Customer.get_by_id(customer_id)
# Check if the customer has linked his credit card after he clicked the 'pay' button
# If he didn't (one hour after the last time he tried to pay), create a new ShopTask to call this customer.
if not customer.stripe_valid and customer.team_id:
if customer.prospect_id:
rmt, prospect = db.get([
RegioManagerTeam.create_key(customer.team_id),
Prospect.create_key(customer.prospect_id)
])
else:
prospect = create_prospect_from_customer(customer)
rmt = RegioManagerTeam.get(
RegioManagerTeam.create_key(customer.team_id))
azzert(rmt.support_manager,
'No support manager found for team %s' % rmt.name)
task = create_task(
prospect_or_key=prospect,
status=ShopTask.STATUS_NEW,
task_type=ShopTask.TYPE_SUPPORT_NEEDED,
address=None,
created_by=STORE_MANAGER.email(),
assignee=rmt.support_manager,
execution_time=today() + 86400 + 11 * 3600, # tomorrow, 11:00,
app_id=prospect.app_id,
comment=u"Customer wanted to pay an order in the customer store, "
"but didn't succeed because he did not link his creditcard.",
notify_by_email=True)
task.put()
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 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 _fix_charge(charge_key):
charge = Charge.get(charge_key)
charge.team_id = Customer.get(charge.customer_key).team_id
if not charge.team_id:
logging.error(
'Cannot fix charge {}: No team set on customer {}'.format(
charge.id, charge.customer_id))
charge.put()
def get_customer(service_user):
"""
Args:
service_user (users.User): service user
Returns:
customer(Customer)
"""
return Customer.get_by_service_email(service_user.email())
def job():
customers = Customer.all()
to_put = list()
for c in customers:
if not c.language:
if not c.country:
raise Exception('Customer %s has no country assigned' % c.name)
c.language = COUNTRY_DEFAULT_LANGUAGES[c.country]
to_put.append(c)
db.put(to_put)
def get_subscription_order(customer_id):
customer = Customer.get_by_id(customer_id)
if not customer.subscription_order_number:
raise NoSubscriptionException(customer)
order = Order.get_by_order_number(customer.id,
customer.subscription_order_number)
if not order.status == Order.STATUS_SIGNED:
raise BusinessException(
'The customer his subscription order has not been signed yet.')
return order
def _change_customers_manager(manager_email):
logging.info(
'Unsetting regional manager on customers with assigned manager \'%s\'',
manager_email)
to_put = []
manager_user = users.User(manager_email)
for customer in Customer.all():
if customer.manager == manager_user:
customer.manager = None
to_put.append(customer)
put_in_chunks(to_put)
def set_next_charge_date(customer_id, next_charge_date):
customer = Customer.get_by_id(customer_id)
if not customer.subscription_order_number:
raise NoSubscriptionException(customer)
order = Order.get_by_order_number(customer_id,
customer.subscription_order_number)
if not order.status == Order.STATUS_SIGNED:
raise BusinessException(
'The customer his subscription order has not been signed yet.')
order.next_charge_date = next_charge_date
order.put()
def customer_get_editable_organization_types(customer_id):
request = GenericRESTRequestHandler.getCurrentRequest()
language = get_languages_from_request(request)[0]
try:
customer = Customer.get_by_id(customer_id)
if not language:
language = customer.language
return dict(get_organization_types(customer, language))
except CustomerNotFoundException:
return {}
def _gather_events_for_customer(customer_key, cap_key, organization_type):
customer = Customer.get(customer_key)
if not customer.service_email:
logging.debug('This customer has no service yet: %s',
db.to_dict(customer))
return
if cap_key.parent().name() == customer.service_email:
# do not gather own events
return
sln_settings = get_solution_settings(customer.service_user)
if SolutionModule.AGENDA not in sln_settings.modules:
return
if sln_settings.default_calendar is None:
logging.error(
'This customer has no default calendar!\n\nSolutionSettings: %s\n\nCustomer: %s',
db.to_dict(sln_settings),
db.to_dict(customer),
_suppress=False)
return
sc = SolutionCalendar.get_by_id(
sln_settings.default_calendar,
parent_key(customer.service_user, sln_settings.solution))
if not sc:
return
event_items = []
for event in sc.events:
event_item = EventItemTO.fromEventItemObject(event)
event_item.calendar_id = organization_type
event_items.append(event_item)
if event_items:
new_events = serialize_complex_value(event_items, EventItemTO, True)
gather_events_key = u"%s" % organization_type
def trans():
cap = CityAppProfile.get(cap_key)
stream = cap.gather_events.get(gather_events_key)
if stream:
json_list = json.load(stream)
else:
json_list = list()
json_list.extend(new_events)
with closing(StringIO()) as stream:
json.dump(json_list, stream)
cap.gather_events[gather_events_key] = stream
cap.put()
db.run_in_transaction(trans)
sln_settings.put_identity_pending = True
sln_settings.put()
def get_customer_locations_for_app(app_id):
query_string = (u'app_ids:"%s"' % app_id)
query = search.Query(query_string=query_string,
options=search.QueryOptions(returned_fields=[
'service', 'name', 'location', 'description'
],
limit=1000))
search_result = search.Index(name=SERVICE_LOCATION_INDEX).search(query)
customers = {
customer.service_email: customer
for customer in Customer.list_by_app_id(app_id)
}
def map_result(service_search_result):
customer_location = CustomerLocationTO()
for field in service_search_result.fields:
if field.name == 'service':
customer = customers.get(field.value.split('/')[0])
if customer:
customer_location.has_terminal = customer.has_loyalty
customer_location.address = customer.address1
customer_location.type = customer.organization_type
if customer.address2:
customer_location.address += '\n%s' % customer.address2
if customer.zip_code or customer.city:
customer_location.address += '\n'
if customer.zip_code:
customer_location.address += customer.zip_code
if customer.zip_code and customer.city:
customer_location.address += ' '
if customer.city:
customer_location.address += customer.city
else:
customer_location.type = ServiceProfile.ORGANIZATION_TYPE_PROFIT
continue
if field.name == 'name':
customer_location.name = field.value
continue
if field.name == 'location':
customer_location.lat = field.value.latitude
customer_location.lon = field.value.longitude
continue
if field.name == 'description':
customer_location.description = field.value
continue
return customer_location
return json.dumps(
serialize_complex_value([map_result(r) for r in search_result.results],
CustomerLocationTO, True))
def get_services(organization_type, cursor=None, limit=50):
city_service_user = users.get_current_user()
si = system.get_identity()
# get all the services in this city
app_id = si.app_ids[0]
city_customer = get_customer(city_service_user)
azzert(organization_type in city_customer.editable_organization_types)
service_customers_qry = Customer.list_enabled_by_organization_type_in_app(app_id, organization_type)
service_customers_qry.with_cursor(cursor)
service_customers = service_customers_qry.fetch(limit)
new_cursor = unicode(service_customers_qry.cursor())
services = []
statistics = get_services_statistics(app_id)
sln_settings_keys = [SolutionSettings.create_key(city_service_user)]
for customer in service_customers:
if not customer.service_email:
logging.error('Customer %d (%s) has default_app_id, but has no service!', customer.id, customer.name)
elif customer.app_id == app_id:
sln_settings_keys.append(SolutionSettings.create_key(users.User(customer.service_email)))
sln_settings_list = db.get(sln_settings_keys)
city_sln_settings = sln_settings_list.pop(0) # type: SolutionSettings
azzert(city_sln_settings.can_edit_services(city_customer))
city_service_email = city_sln_settings.service_user.email()
for customer in service_customers:
service_email = customer.service_email
# Exclude the city app's own service
if customer.app_id == app_id and service_email != city_service_email:
future_events_count = 0
broadcasts_last_month = 0
static_content_count = 0
last_unanswered_question_timestamp = 0
modules = []
for sln_settings in sln_settings_list:
if sln_settings.key().name() == service_email:
modules = sln_settings.modules
if statistics:
for mail in statistics.customer_emails:
if mail == service_email:
index = statistics.customer_emails.index(mail)
future_events_count = statistics.future_events_count[index]
broadcasts_last_month = statistics.broadcasts_last_month[index]
static_content_count = statistics.static_content_count[index]
last_unanswered_question_timestamp = statistics.last_unanswered_questions_timestamps[index]
statistic = ServiceStatisticTO.create(future_events_count, broadcasts_last_month, static_content_count,
last_unanswered_question_timestamp)
services.append(ServiceListTO(service_email, customer.name, statistic, modules, customer.id))
generated_on = statistics.generated_on if statistics else None
return ServicesTO(sorted(services, key=lambda x: x.name.lower()), generated_on, new_cursor)
def remind_user_with_expired_vouchers(sln_settings_key, today_timestamp):
"""Remind voucher owners (users) before the expiration date by n days"""
sln_settings = SolutionSettings.get(sln_settings_key)
if not sln_settings:
return
customer = Customer.get_by_service_email(sln_settings.service_user.email())
if not customer:
return
for days in EXPIRED_VOUCHERS_REMINDER:
run_job(expired_vouchers_qry,
[customer.app_id, today_timestamp + days],
send_expired_voucher_message, [sln_settings, days / DAY])
def get_service_users_for_city(app_id):
result = []
for customer in Customer.all().filter('organization_type =',
OrganizationType.CITY):
if customer.app_ids and app_id == customer.app_id:
if customer.service_email:
sln_settings = get_solution_settings(customer.service_user)
if SolutionModule.CITY_APP in sln_settings.modules:
result.append(customer.service_user)
elif not customer.app_ids:
logging.debug(
"get_service_user_for_city failed for customer_id: %s",
customer.id)
return result
def get_service(service_email):
city_service_user = users.get_current_user()
city_customer = get_customer(city_service_user)
service_user = users.User(email=service_email)
customer = Customer.get_by_service_email(service_email)
if not city_customer.can_edit_service(customer):
logging.warn(u'Service %s tried to save service information for customer %d', city_service_user, customer.id)
lang = get_solution_settings(city_service_user).main_language
return ReturnStatusTO.create(False, translate(lang, SOLUTION_COMMON, 'no_permission'))
contact = Contact.get_one(customer.key())
solution_settings = get_solution_settings(service_user)
return ServiceTO(customer.id, customer.name, customer.address1, customer.address2, customer.zip_code, customer.city,
customer.user_email, contact.phone_number, solution_settings.main_language,
solution_settings.modules, solution_settings.broadcast_types, customer.organization_type,
customer.vat, customer.website, customer.facebook_page)
def cancel_charge(customer_id, order_number, charge_id):
"""Cancels a charge so adjustments can be made to the order. Rolls back the next charge date of the subscription order.
Args:
customer_id:
order_number:
charge_id:
Returns:
None
"""
to_put = list()
now_ = now()
charge, order, customer = db.get([Charge.create_key(charge_id, order_number, customer_id),
Order.create_key(customer_id, order_number),
Customer.create_key(customer_id)])
charge.date_cancelled = now_
charge.status = Charge.STATUS_CANCELLED
to_put.append(charge)
order_items = list(OrderItem.list_by_order(order.key()))
if order.is_subscription_order:
months = 0
for item in order_items:
product = item.product
if product.is_subscription and product.price > 0:
months += item.count
if not product.is_subscription and product.extra_subscription_months > 0:
months += product.extra_subscription_months
if months > 0:
next_charge_datetime = datetime.datetime.utcfromtimestamp(now()) - relativedelta(months=months)
order.next_charge_date = get_epoch_from_datetime(next_charge_datetime)
else:
order.next_charge_date = Order.default_next_charge_date()
else:
extra_months = 0
for item in order_items:
product = item.product
if not product.is_subscription and product.extra_subscription_months > 0:
extra_months += product.extra_subscription_months
if extra_months > 0:
sub_order = Order.get_by_order_number(customer_id, customer.subscription_order_number)
next_charge_datetime = datetime.datetime.utcfromtimestamp(sub_order.next_charge_date) - relativedelta(
months=extra_months)
sub_order.next_charge_date = get_epoch_from_datetime(next_charge_datetime)
to_put.append(sub_order)
db.put(to_put)
def _put_customers(cursor=None):
qry = Customer.all()
if cursor:
qry.with_cursor(cursor)
customers = qry.fetch(200)
if not customers:
return
cursor = qry.cursor()
to_put = list()
for c in customers:
if c.service_disabled_at == 0:
c.service_disabled_at = 0
to_put.append(c)
db.put(to_put)
_put_customers(cursor)
def rest_delete_service(service_email):
city_service_user = users.get_current_user()
city_customer = get_customer(city_service_user)
customer = Customer.get_by_service_email(service_email)
if not city_customer.can_edit_service(customer):
lang = get_solution_settings(city_service_user).main_language
logging.warn(u'Service %s tried to save service information for customer %d', city_service_user, customer.id)
return ReturnStatusTO.create(False, translate(lang, SOLUTION_COMMON, 'no_permission'))
cancel_subscription(customer.id, Customer.DISABLED_REASONS[Customer.DISABLED_ASSOCIATION_BY_CITY], True)
session = users.get_current_session()
service_identity = session.service_identity
send_message_to_session(city_service_user, session,
[{u"type": u"solutions.common.services.deleted",
u'service_email': service_email,
u'service_organization_type': customer.organization_type}],
si=service_identity)
return RETURNSTATUS_TO_SUCCESS
def migrate_and_create_user_profile(executor_user, from_service_user, to_user):
from shop.models import Customer
bizz_check(from_service_user.email() != to_user.email(), 'FROM and TO should not be equal')
from_profile = _get_profile_not_cached(from_service_user)
bizz_check(from_profile, 'ServiceProfile %s not found' % from_service_user)
bizz_check(isinstance(from_profile, ServiceProfile),
'Profile %s is not of expected type ServiceProfile, but of type %s' % (from_service_user, from_profile.kind()))
service_email = u"*****@*****.**" % uuid.uuid4()
to_profile = _get_profile_not_cached(to_user)
if to_profile:
bizz_check(isinstance(to_profile, UserProfile),
'Profile %s is not of expected type UserProfile, but of type %s' % (to_user, to_profile.kind()))
if service_email not in to_profile.owningServiceEmails:
to_profile.owningServiceEmails.append(service_email)
else:
to_profile = create_user_profile(to_user, to_user.email(), from_profile.defaultLanguage)
to_profile.isCreatedForService = True
to_profile.owningServiceEmails = [service_email]
update_password_hash(to_profile, from_profile.passwordHash, now())
si = get_default_service_identity_not_cached(from_service_user)
si.qualifiedIdentifier = to_user.email()
settings = get_solution_settings(from_service_user)
settings.qualified_identifier = to_user.email()
settings.login = to_user
put_and_invalidate_cache(to_profile, si, settings)
customer = Customer.all().filter('service_email', from_service_user.email()).get()
if customer:
def trans(customer_key):
customer = db.get(customer_key)
customer.user_email = to_user.email()
customer.put()
db.run_in_transaction(trans, customer.key())
if SolutionModule.CITY_APP in settings.modules:
for app_id in customer.app_ids:
invalidate_service_user_for_city(app_id)
else:
logging.debug('There was no customer')
return migrate(executor_user, from_service_user, users.User(service_email))
def cancel_subscription(customer_id, cancel_reason, immediately=False):
"""
Marks the customer his subscription as disabled.
Recurrent billing will disable the service and disconnect all users after the subscription has ended.
When the 'immediately' parameter is set, the service will be disabled immediately.
Args:
customer_id (int, long): Customer id
cancel_reason (unicode): Reason why the subscription has been canceled.
immediately (bool): Set to True to disable the service immediately
Returns: None
Raises:
EmptyValueException
CustomerNotFoundException
NoSubscriptionException
"""
if not cancel_reason:
raise EmptyValueException('cancel_reason')
customer = Customer.get_by_id(customer_id)
if not customer.subscription_order_number:
raise NoSubscriptionException(customer)
order = Order.get_by_order_number(customer_id,
customer.subscription_order_number)
if immediately or order.status != Order.STATUS_SIGNED:
def trans():
try:
cancel_order(customer, customer.subscription_order_number)
except OrderAlreadyCanceledException as exception:
logging.info('Order %s already canceled, continueing...' %
exception.order.order_number)
customer.disabled_reason = cancel_reason
set_service_disabled(customer, Customer.DISABLED_OTHER)
run_in_xg_transaction(trans)
else:
customer.disabled_reason = cancel_reason
customer.subscription_cancel_pending_date = now()
customer.put()
def trans():
to_put = list()
customer = Customer.get(customer_key)
if App.APP_ID_ROGERTHAT not in customer.app_ids and customer.service_email:
customer.app_ids.append(App.APP_ID_ROGERTHAT)
to_put.append(customer)
service_identity = get_default_service_identity(
customer.service_user)
if App.APP_ID_ROGERTHAT not in service_identity.appIds:
service_identity.appIds.append(App.APP_ID_ROGERTHAT)
deferred.defer(re_index,
service_identity.service_identity_user,
_queue=MIGRATION_QUEUE,
_transactional=True)
to_put.append(service_identity)
deferred.defer(re_index_customer,
customer.key(),
_queue=MIGRATION_QUEUE,
_transactional=True)
put_and_invalidate_cache(*to_put)
def set_service_enabled(customer_id):
customer = Customer.get_by_id(customer_id)
if not customer.service_email:
raise NoSubscriptionException(customer)
service_user = users.User(customer.service_email)
service_identity_user = create_service_identity_user(service_user)
si = get_service_identity(service_identity_user)
sln_settings = get_solution_settings(service_user)
sln_settings.service_disabled = False
customer.service_disabled_at = 0
customer.disabled_reason = u''
customer.disabled_reason_int = 0
customer.subscription_cancel_pending_date = 0
# restore app ids
customer.app_ids = si.sorted_app_ids
customer.default_app_id = si.app_id
db.put([customer, sln_settings])
rogerthat_re_enable_service(service_user)
def get_all_signup_enabled_apps():
signup_enabled_app_keys = ShopApp.all(keys_only=True).filter(
'signup_enabled', True)
signup_enabled_apps = filter(
lambda app: app.main_service,
db.get([
App.create_key(app_key.name())
for app_key in signup_enabled_app_keys
]))
for app in reversed(signup_enabled_apps):
# TODO: cache Customer.get_by_service_email(app.main_service)
customer = Customer.get_by_service_email(app.main_service)
if not customer:
signup_enabled_apps.remove(app)
continue
app.customer_id = customer.id
app.country = customer.country
return signup_enabled_apps
def results(request):
if request.method == 'POST': # Submitted the purchase form:
form = PurchaseForm(request.POST)
print 'GOT POST'
if not request.user.is_authenticated():
errors = form._errors.setdefault("loggedin", ErrorList())
errors.append("Please log in before ordering")
elif form.is_valid(): # TODO if form is not valid because no items in cart, say so! item_list is hidden field so user cannot see error.
hasError = False
user_email = request.user.username # form.cleaned_data['email']
email_html = '<p>Name: ' + form.cleaned_data['name'] + '<br />Email: ' + user_email + '<br />Address: ' + form.cleaned_data['living_group'] + '<br />Room number: ' + form.cleaned_data['room_number'] + '<br />Phone number: ' + form.cleaned_data['phone_number'] + '</p><p><b>Delivery date: Saturday, April 6, 2013</b></p><p><b>Order:</b></p>'
cart_items = json.loads(form.cleaned_data['items_list'])
cart_total = 0
print 'cart items: ', cart_items
for cart_item_id in cart_items:
# make sure JSON output in cart_item_id form field is int as saved by browser, on chrome is. Otherwise would need to cast.
qty = cart_items[cart_item_id]
item = ShopItem.objects.get(pk=cart_item_id)
cart_total += (item.item_price * qty)
email_html += '<p>' + str(qty) + 'x ' + item.item_name + ' @ ' + pretty_price(item.item_price) + ' = ' + pretty_price(item.item_price * qty) + ' </p>'
email_html += '<p>Order total: ' + pretty_price(cart_total) + '</p>'
# Should also check cart matches the one saved in databse.
card_dictionary = {
'number': form.cleaned_data['card_number'],
'exp_month': form.cleaned_data['card_expiration_month'],
'exp_year': form.cleaned_data['card_expiration_year'],
'cvc': form.cleaned_data['card_cvc'],
'address_zip': form.cleaned_data['card_zip'],
}
# process order immediately
"""
charge = stripe.Charge.create(
amount=cart_total,
currency='usd',
card=card_dictionary,
description='SnapShop order for ' + form.cleaned_data['name'],
)
"""
useCard = False
if form.cleaned_data['payment_choices'] == 'use_old':
try:
customer = Customer.objects.get(user=request.user)
try:
card = CreditCard.objects.get(cc_owner=customer)
# TODO increase balance from Stripe
except CreditCard.DoesNotExist:
hasError = True
errors = form._errors.setdefault("username", ErrorList())
errors.append("An error ocurred in retreiving your saved card. Please re-enter the information below.")
except Customer.DoesNotExist:
hasError = True
errors = form._errors.setdefault("username", ErrorList())
errors.append("An error ocurred in retreiving your saved card. Please re-enter the information below.")
else: # payment_choices == 'save_new' or 'no_save'
# Try only creating customer: should account for customer already created, and save in DB.
# Catching errors in: https://stripe.com/docs/api?lang=python
try:
stripe_customer = stripe.Customer.create(
# use SnapShop username?
description="Customer " + form.cleaned_data['name'],
card=card_dictionary,
account_balance=cart_total,
email=user_email, #request.user.username
)
print stripe_customer
except stripe.CardError, e:
print e
errors = form._errors.setdefault("card_number", ErrorList())
errors.append("Card error: " + e.message)
hasError = True
except stripe.StripeError, e:
print e
errors = form._errors.setdefault("card_number", ErrorList())
errors.append("A stripe error has ocurred. Please contact the site administrator")
hasError = True
if not hasError:
try:
our_customer = Customer.objects.get(user=request.user)
except Customer.DoesNotExist:
our_customer = Customer(stripe_token=stripe_customer.id, phone_number='', delivery_time=datetime.datetime(2013, 03, 16), user=request.user)
our_customer.save()
# TODO will this create duplicate credit card entries
if form.cleaned_data['payment_choices'] == 'save_new':
card_number = form.cleaned_data['card_number']
our_card = CreditCard(cc_stub=card_number[-4:], cc_type=0, cc_owner=our_customer)
our_card.save()
if not hasError:
# Send email to us - admins
admin_msg = EmailMessage('New Snapshop order!', email_html, '*****@*****.**', ['*****@*****.**', '*****@*****.**'])
admin_msg.content_subtype = 'html'
admin_msg.send(fail_silently=False)
# Senc copy of email to customer
user_msg = EmailMessage('Thank you for your SnapShop order!', email_html, '*****@*****.**', [user_email])
user_msg.content_subtype = 'html'
user_msg.send(fail_silently=True)
return HttpResponseRedirect('/thanks/')
def post(self):
logging.debug(self.request.POST)
data = self.request.get("data", None)
if not data:
self.redirect('/mobiadmin/google/news')
return
self.response.headers['Content-Type'] = 'text/json'
data = json.loads(data)
service_user_email = data.get("service_user_email", None)
action = data.get("action", None)
nss = NewsSettingsService.create_key(users.User(service_user_email)).get()
if action == 'delete':
should_delete = False
try:
from shop.models import Customer
c = Customer.get_by_service_email(service_user_email)
if c and c.service_disabled_at:
should_delete = True
except:
pass
total_user_count = 0
for si in get_service_identities(nss.service_user):
user_count = count_users_connected_to_service_identity(si.user)
total_user_count += user_count
if total_user_count == 0:
should_delete = True
last_activity = get_last_activity(nss.service_user)
if not should_delete and not last_activity:
self.response.out.write(json.dumps({'success': False,
'errormsg': 'Delete failed could not find last activity'}))
return
latest_activity_days = get_days_between_last_activity(last_activity) if last_activity else -1
if not should_delete and latest_activity_days <= 300:
self.response.out.write(json.dumps({'success': False,
'errormsg': 'Service was active in the last 300 days'}))
return
nss.setup_needed_id = 998
nss.put()
service_profile = get_service_profile(nss.service_user, False)
if service_profile.solution:
from solutions.common.bizz.jobs import delete_solution
delete_solution(nss.service_user, True)
else:
from rogerthat.bizz.job import delete_service
delete_service.job(nss.service_user, nss.service_user)
elif action == 'skip':
nss.setup_needed_id = 999
nss.put()
elif action == 'save_group':
groups = data.get("groups", None)
if not groups:
self.response.out.write(json.dumps({'success': False,
'errormsg': 'This is awkward... (groups not found)'}))
return
nss.groups = []
if nss.setup_needed_id == 1:
nss.setup_needed_id = 11
else:
nss.setup_needed_id = random.randint(12, 20)
if groups == 'city':
nss.groups.append(NewsSettingsServiceGroup(group_type=NewsGroup.TYPE_CITY,
filter=None,
broadcast_types=[]))
nss.groups.append(NewsSettingsServiceGroup(group_type=NewsGroup.TYPE_TRAFFIC,
filter=None,
broadcast_types=[]))
nss.groups.append(NewsSettingsServiceGroup(group_type=NewsGroup.TYPE_EVENTS,
filter=None,
broadcast_types=[]))
elif groups == 'food':
nss.groups.append(NewsSettingsServiceGroup(group_type=NewsGroup.TYPE_PROMOTIONS,
filter=NewsGroup.FILTER_PROMOTIONS_FOOD,
broadcast_types=[]))
nss.groups.append(NewsSettingsServiceGroup(group_type=NewsGroup.TYPE_EVENTS,
filter=None,
broadcast_types=[]))
elif groups == 'restaurant':
nss.groups.append(NewsSettingsServiceGroup(group_type=NewsGroup.TYPE_PROMOTIONS,
filter=NewsGroup.FILTER_PROMOTIONS_RESTAURANT,
broadcast_types=[]))
nss.groups.append(NewsSettingsServiceGroup(group_type=NewsGroup.TYPE_EVENTS,
filter=None,
broadcast_types=[]))
elif groups == 'clothing':
nss.groups.append(NewsSettingsServiceGroup(group_type=NewsGroup.TYPE_PROMOTIONS,
filter=NewsGroup.FILTER_PROMOTIONS_CLOTHING,
broadcast_types=[]))
nss.groups.append(NewsSettingsServiceGroup(group_type=NewsGroup.TYPE_EVENTS,
filter=None,
broadcast_types=[]))
elif groups == 'associations':
nss.groups.append(NewsSettingsServiceGroup(group_type=NewsGroup.TYPE_PROMOTIONS,
filter=NewsGroup.FILTER_PROMOTIONS_ASSOCIATIONS,
broadcast_types=[]))
nss.groups.append(NewsSettingsServiceGroup(group_type=NewsGroup.TYPE_EVENTS,
filter=None,
broadcast_types=[]))
elif groups == 'other':
nss.groups.append(NewsSettingsServiceGroup(group_type=NewsGroup.TYPE_PROMOTIONS,
filter=NewsGroup.FILTER_PROMOTIONS_OTHER,
broadcast_types=[]))
nss.groups.append(NewsSettingsServiceGroup(group_type=NewsGroup.TYPE_EVENTS,
filter=None,
broadcast_types=[]))
else:
self.response.out.write(json.dumps({'success': False,
'errormsg': 'This is awkward... (group not found)'}))
return
nss.put()
elif action == 'save_mapping':
broadcast_types = get_service_profile(nss.service_user).broadcastTypes
nss.setup_needed_id = 0
mapping = data.get("mapping", None)
if mapping:
for group_type, broadcast_mapping in mapping.iteritems():
g = nss.get_group(group_type)
if not g:
self.response.out.write(json.dumps({'success': False,
'errormsg': 'You need to map every broadcast_type to 1 group (group "%s" missing)' % group_type}))
return
for broadcast_type in broadcast_mapping:
if broadcast_type not in broadcast_types:
self.response.out.write(json.dumps({'success': False,
'errormsg': 'You need to map every broadcast_type to 1 group (broadcast_type "%s" missing)' % broadcast_type}))
return
broadcast_types.remove(broadcast_type)
g.broadcast_types = broadcast_mapping
if broadcast_types:
self.response.out.write(json.dumps({'success': False,
'errormsg': 'You need to map every broadcast_type to 1 group (broadcast_type incomplete)'}))
return
nss.put()
deferred.defer(migrate_service, nss.service_user, dry_run=False,
force=True, _countdown=5, _queue=NEWS_MATCHING_QUEUE)
self.response.out.write(json.dumps({'success': True}))
def get(self):
app_id = self.request.get("app_id", None)
sni = self.request.get("sni", None)
if not app_id or not sni:
self.redirect('/mobiadmin/google/news')
return
sni = int(sni)
qry = NewsSettingsService.list_setup_needed(app_id, sni)
item = qry.get()
if not item:
self.redirect('/mobiadmin/google/news?app_id=%s' % app_id)
return
sp = get_service_profile(item.service_user)
last_activity = get_last_activity(item.service_user)
latest_activity_days = get_days_between_last_activity(last_activity) if last_activity else -1
disabled_reason = None
if sp.solution and sp.solution == u'flex':
try:
from shop.models import Customer
c = Customer.get_by_service_email(item.service_user.email())
if c and c.service_disabled_at:
disabled_reason = c.disabled_reason
except:
pass
identities = []
total_user_count = 0
all_hidden = True
for si in get_service_identities(item.service_user):
news_count = NewsItem.query().filter(NewsItem.sender == si.user).count(None)
user_count = count_users_connected_to_service_identity(si.user)
total_user_count += user_count
sc, _ = get_search_config(si.user)
if sc.enabled and all_hidden:
all_hidden = False
identities.append(dict(id=si.identifier,
name=si.name,
news_count=news_count,
user_count=user_count,
app_ids=si.appIds,
search_enabled=sc.enabled))
delete_enabled = False
if disabled_reason:
delete_enabled = True
elif total_user_count == 0 and all_hidden:
delete_enabled = True
elif latest_activity_days > 300 and total_user_count < 20 and all_hidden:
delete_enabled = True
context = dict(sni=sni,
count=qry.count(None),
item=item,
sp=sp,
auto_login_url=generate_auto_login_url(item.service_user),
latest_activity=dict(date=str(last_activity) if last_activity else 'never', days=latest_activity_days),
delete_enabled=delete_enabled,
disabled_reason=disabled_reason,
identities=identities)
path = os.path.join(os.path.dirname(__file__), 'services_detail.html')
channel.append_firebase_params(context)
self.response.out.write(template.render(path, context))
