def after_save(self, request, obj, *args, **kwargs):
company_id = request.POST['company_id']
weblet = get_service_instance()
weblet_config = weblet.config
if company_id and company_id != weblet.id:
company = Service.objects.using(UMBRELLA).get(pk=company_id)
company_config = company.config
if request.POST.get('auth_code') != company_config.auth_code:
messages.error(
request,
_("AUTH CODE is invalid, please verify. If the problem persists, please "
"contact %s to get the good one." %
company_config.company_name))
return
try:
Service.objects.get(pk=company_id)
except Service.DoesNotExist:
company.save(using='default')
company_config.save(using='default')
company = Service.objects.get(pk=company_id)
db = company.database
add_database(db)
try:
Service.objects.using(db).get(pk=weblet.id)
except Service.DoesNotExist:
weblet.save(using=db)
weblet_config.save(using=db)
else:
company = get_service_instance()
obj.company = company
obj.save()
def test_confirm_shipping_with_retailer_as_delivery_man(self):
"""
Earnings of retailers are set upon confirmation of an Order by the delivery person
"""
yesterday = timezone.now() - timedelta(days=1)
for db in ('default', 'test_kc_ems', UMBRELLA):
for profile in OperatorProfile.objects.using(db).all():
profile.counters_reset_on = yesterday
profile.payment_delay = OperatorProfile.UPON_CONFIRMATION
profile.save()
self.client.login(username='******', password='******')
order = Order.objects.get(pk='55d1feb60008099bd4151fa3')
order.split_into_packages() # Simulates order confirmation
order.delivery_option.company = get_service_instance(
) # Simulates retailer taking responsibility to deliver
order.save(using='default')
response = self.client.get(reverse('trade:confirm_shipping'),
{'order_id': '55d1feb60008099bd4151fa3'})
json_response = json.loads(response.content)
self.assertTrue(json_response['success'])
order = Order.objects.get(pk='55d1feb60008099bd4151fa3')
self.assertEqual(order.status, Order.SHIPPED)
# Check counters
cache.clear()
retailer_profile = get_service_instance(using='test_kc_foka').config
self.assertEqual(retailer_profile.earnings_history,
[4150, 1900, 36608, 3040, 9175, 52469.2])
wallet = OperatorWallet.objects.using(WALLETS_DB_ALIAS).get(
nonrel_id='56eb6d04b37b3379b531b103', provider='paypal')
self.assertEqual(wallet.balance, 52469.2)
def get(self, request, *args, **kwargs):
action = request.GET.get('action')
if action == 'update_domain':
new_domain = request.GET['new_domain']
is_naked_domain = True if request.GET[
'type'] == Service.MAIN else False
try:
service = get_service_instance(using=UMBRELLA)
service.update_domain(new_domain, is_naked_domain)
except:
logger.error("Failed to update domain to %s" % new_domain)
response = {'error': _("Unknown error occured.")}
return HttpResponse(json.dumps(response),
'content-type: text/json')
elif action == 'invite_to_transfer_ownership':
if not request.user.is_bao:
response = {'error': _("You are not allowed here.")}
return HttpResponse(json.dumps(response),
'content-type: text/json')
email = request.GET['email']
try:
member = Member.objects.using(UMBRELLA).get(email=email)
service = get_service_instance(using=UMBRELLA)
transfer = OwnershipTransfer.objects.create(
sender=request.user, target_id=member.id)
subject = _("Ownership transfer invitation")
transfer_url = reverse('ikwen:transfer_ownership',
args=(transfer.id, ))
transfer_url = service.url + strip_base_alias(transfer_url)
html_content = get_mail_content(
subject,
template_name='core/mails/ownership_transfer.html',
extra_context={
'owner_name': request.user.full_name,
'transfer_url': transfer_url,
'member': member
})
sender = '%s <no-reply@%s>' % (service.project_name,
service.domain)
msg = EmailMessage(subject, html_content, sender,
[member.email])
msg.content_subtype = "html"
Thread(target=lambda m: m.send(), args=(msg, )).start()
response = {'success': True, 'transfer_id': transfer.id}
return HttpResponse(json.dumps(response),
'content-type: text/json')
except Member.DoesNotExist:
response = {
'error': _("%s does not have an account on ikwen." % email)
}
return HttpResponse(json.dumps(response),
'content-type: text/json')
return super(ServiceDetail, self).get(request, *args, **kwargs)
def render(self, request=None):
if self.content_type == FLAT:
c = Context({'section': self})
config = get_service_instance().config
tpl = 'webnode/snippets/homepage_section_flat.html'
if config.theme and config.theme.template.slug != "":
if config.theme.template.slug == 'optimum' or config.theme.template.slug == 'improve':
tpl = 'webnode/snippets/homepage_section_flat.html'
else:
tokens = tpl.split('/')
tokens.insert(1, config.theme.template.slug)
tpl = '/'.join(tokens)
html_template = get_template(tpl)
return html_template.render(c)
else: # The section points to a Menu
try:
# The actual menu points to an Item List
smart_category = SmartCategory.objects.get(
slug=self.description)
item_list = []
config = get_service_instance().config
for category in smart_category.get_category_queryset():
item_list.extend(
list(
Item.objects.filter(category=category,
visible=True,
in_trash=False)))
c = Context({
'item_list': item_list[:self._get_row_len()],
'density': self.density,
'title': smart_category.title,
'config': config
})
tpl = 'webnode/snippets/homepage_section_item_list.html'
# refix template URI according to the theme used
if config.theme and config.theme.template.slug != "":
if config.theme.template.slug == 'optimum' or config.theme.template.slug == 'improve':
tpl = 'webnode/snippets/homepage_section_item_list.html'
else:
tokens = tpl.split('/')
tokens.insert(1, config.theme.template.slug)
tpl = '/'.join(tokens)
html_template = get_template(tpl)
return html_template.render(c)
except SmartCategory.DoesNotExist:
# The actual menu points to a Module
mod = Module.objects.get(slug=self.description)
renderer = import_by_path(mod.homepage_section_renderer)
return renderer(self, request)
def set_student_counts():
"""
Sets student_count for each Classroom, Level and School
"""
total_boys, total_girls = 0, 0
school_year = get_school_year()
for level in Level.objects.filter(school_year=school_year):
level_boys, level_girls = 0, 0
for classroom in level.classroom_set.all():
classroom.girls_count = classroom.student_set.filter(
gender=FEMALE, is_excluded=False).count()
classroom.boys_count = classroom.student_set.filter(
gender=MALE, is_excluded=False).count()
classroom.save()
level_girls += classroom.girls_count
level_boys += classroom.boys_count
level.girls_count = level_girls
level.boys_count = level_boys
level.save()
total_girls += level_girls
total_boys += level_boys
school = get_service_instance().config
school.girls_count = total_girls
school.boys_count = total_boys
school.save()
def set_momo_order_checkout(request, payment_mean, *args, **kwargs):
"""
This function has no URL associated with it.
It serves as ikwen setting "MOMO_BEFORE_CHECKOUT"
"""
service = get_service_instance()
config = service.config
if getattr(settings, 'DEBUG', False):
order = parse_order_info(request)
else:
try:
order = parse_order_info(request)
except:
return HttpResponseRedirect(reverse('shopping:checkout'))
order.retailer = service
order.payment_mean = payment_mean
order.save() # Save first to generate the Order id
order = Order.objects.get(pk=order.id) # Grab the newly created object to avoid create another one in subsequent save()
member = request.user
if member.is_authenticated():
order.member = member
else:
order.aotc = generate_tx_code(order.id, order.anonymous_buyer.auto_inc)
order.rcc = generate_tx_code(order.id, config.rel_id)
order.save()
request.session['object_id'] = order.id
request.session['amount'] = order.total_cost
def is_admin(member):
service = get_service_instance()
if service.member == member:
return True
if service in member.collaborates_on:
pass
return False
def test_Configuration_activate(self):
self.client.login(username='******', password='******')
response = self.client.get(reverse('rewarding:configuration'),
{'action': 'activate'})
self.assertEqual(response.status_code, 302)
service = get_service_instance()
CROperatorProfile.objects.using(UMBRELLA).get(service=service)
def test_submit_item_with_existing_item(self):
"""
submit_item view updates item information if it previously exists.
Only retail_price can be set if user is a Retailer
"""
copy_service_and_config_to_default_db()
call_command('loaddata', 'wn_members.yaml', database=UMBRELLA)
call_command('loaddata', 'wn_setup_data.yaml')
call_command('loaddata', 'wn_operators_configs.yaml')
call_command('loaddata', 'items.yaml')
self.client.login(username='******', password='******')
item = Item.objects.get(pk='55d1fa8feb60008099bd4152')
item.provider = get_service_instance() # Make provider of this item the current retailer
item.save()
p_dict = item.__dict__
p_dict['category'] = '569228a9b37b3301e0706b51'
p_dict['name'] = 'Black Chocolate'
p_dict['brand'] = 'Mambo'
p_dict['summary'] = 'Some summary'
p_dict['description'] = 'Some description'
p_dict['retail_price'] = 500
response = self.client.post(reverse('items:change_item', args=('55d1fa8feb60008099bd4152', )), p_dict)
item = Item.objects.get(pk='55d1fa8feb60008099bd4152')
self.assertEqual(item.name, 'Black Chocolate')
self.assertEqual(item.slug, 'black-chocolate') # Slug must be correctly set
self.assertEqual(item.category, ItemCategory.objects.get(pk='569228a9b37b3301e0706b51'))
self.assertEqual(item.retail_price, 500)
self.assertEqual(item.summary, 'Some summary')
self.assertEqual(item.description, 'Some description')
def notify_staff(backup):
# now = datetime.now()
# start = now - timedelta(days=7)
# for backup in Backup.objects.order_by('-id').filter(status=FAILED):
sender = 'ikwen DBBACKUP <*****@*****.**>'
subject = _("New failed backup")
recipient_list = [get_service_instance().member.email]
staff_list = [
staff.email for staff in Member.objects.filter(is_staff=True)
]
job_config = backup.job_config
extra_context = {
'hostname': job_config.hostname,
'db_name': job_config.db_name,
'db_type': job_config.db_type,
'status': backup.status,
'start_time': backup.created_on,
'file_size_hr': backup.file_size_hr,
'error_messages': backup.error_messages
}
activate('en')
try:
html_content = get_mail_content(
subject,
template_name='dbbackup/mails/failed_backup_notification.html',
extra_context=extra_context)
except:
logger.error("Could not generate HTML content from template",
exc_info=True)
return
msg = EmailMessage(subject, html_content, sender, recipient_list)
msg.content_subtype = "html"
msg.bcc = staff_list
msg.send()
def _get_row_len(self):
config = get_service_instance().config
if config.theme and config.theme.display == COMFORTABLE:
return 2
elif config.theme and config.theme.display == COZY:
return 3
return 4
def set_session_data(request, *args, **kwargs):
manage_packages = False
manage_drivy = False
if getattr(settings, 'IS_DELIVERY_COMPANY', False):
manage_packages = True
if getattr(settings, 'IS_PROVIDER', False):
service = get_service_instance()
if DeliveryOption.objects.exclude(company=service).count() > 0:
manage_packages = True
if DeliveryOption.objects.filter(type=DeliveryOption.PICK_UP_IN_STORE,
is_active=True).count() > 0:
manage_drivy = True
request.session['manage_packages'] = manage_packages
request.session['manage_drivy'] = manage_drivy
try:
from daraja.models import DARAJA
app = Application.objects.get(slug=DARAJA)
member = request.user
if member.is_authenticated():
Service.objects.get(app=app, member=member)
customer, change = Customer.objects.get_or_create(member=member)
if not customer.referrer:
customer.referrer = member
customer.save()
request.session['is_dara'] = True
except:
pass
def list_available_companies(request, *args, **kwargs):
"""
Used for company auto-complete in delivery option admin upon
creation of an Option and also when adding a Bank.
"""
q = request.GET['q'].lower()
if len(q) < 2:
return
companies = []
business_type = request.GET.get('business_type', OperatorProfile.LOGISTICS)
queryset = OperatorProfile.objects.using(UMBRELLA).filter(
business_type=business_type)
word = slugify(q)[:4]
if word:
companies = list(queryset.filter(company_name__icontains=word)[:10])
suggestions = [c.service.to_dict() for c in companies]
if business_type == OperatorProfile.LOGISTICS:
service = get_service_instance()
# Add current Provider among potential delivery companies as he can deliver himself
yourself = service.to_dict()
yourself['project_name'] = _('Yourself')
suggestions.insert(0, yourself)
return HttpResponse(json.dumps(suggestions),
content_type='application/json')
def test_set_stock(self):
"""
set_stock sets stock to the number of units, all passed as url parameter
"""
call_command('loaddata', 'kc_members.yaml', database=UMBRELLA)
call_command('loaddata', 'kc_setup_data.yaml')
call_command('loaddata', 'kc_operators_configs.yaml')
call_command('loaddata', 'products.yaml')
service = Service.objects.using(UMBRELLA).get(
pk='56eb6d04b37b3379b531b103')
add_database_to_settings(service.database)
Product.objects.using(service.database).all().delete()
call_command('loaddata', 'products.yaml', database=service.database)
response = self.client.get(
reverse('kako:set_stock',
args=('api-signature2', '55d1fa8feb60008099bd4152', 12)))
response = json.loads(response.content)
self.assertTrue(response['success'])
self.assertDictEqual(response['details'], {
'kcid': '55d1fa8feb60008099bd4152',
'stock': 12
})
product = Product.objects.using(
service.database).get(pk='55d1fa8feb60008099bd4152')
self.assertEqual(product.stock, 12)
config = get_service_instance(UMBRELLA).config
self.assertEqual(config.last_stock_update_method,
OperatorProfile.AUTO_UPDATE)
def get_member_cumulated_coupon(request, *args, **kwargs):
member_id = request.GET.get('customer_id')
member = Member.objects.using('umbrella').get(pk=member_id)
service = get_service_instance()
coupon_qs = Coupon.objects.using('umbrella').filter(service=service,
status=Coupon.APPROVED,
is_active=True)
coupon_list = []
for coupon in coupon_qs:
try:
cumul = CumulatedCoupon.objects.using('umbrella').get(
coupon=coupon, member=member)
coupon.count = cumul.count
coupon.ratio = float(cumul.count) / coupon.heap_size * 100
except CumulatedCoupon.DoesNotExist:
coupon.count = 0
coupon.ratio = 0
coupon_list.append(coupon)
context = {
'coupons': coupon_list,
}
return render(request, 'cci/snippets/user_coupon_list.html', context)
def get_context_data(self, **kwargs):
context = super(Dashboard, self).get_context_data(**kwargs)
service = get_service_instance()
set_counters(service)
customers = list(Service.objects.all())
for customer in customers:
set_counters(customer)
customers_report = {
'today': rank_watch_objects(customers, 'earnings_history'),
'yesterday': rank_watch_objects(customers, 'earnings_history', 1),
'last_week': rank_watch_objects(customers, 'earnings_history', 7),
'last_28_days': rank_watch_objects(customers, 'earnings_history', 28)
}
apps = list(Application.objects.all())
for app in apps:
set_counters(app)
apps_report = {
'today': rank_watch_objects(apps, 'earnings_history'),
'yesterday': rank_watch_objects(apps, 'earnings_history', 1),
'last_week': rank_watch_objects(apps, 'earnings_history', 7),
'last_28_days': rank_watch_objects(apps, 'earnings_history', 28)
}
context['customers_report'] = customers_report
context['apps_report'] = apps_report
return context
def send_dara_notification_email(dara_service, order):
service = get_service_instance()
config = service.config
template_name = 'daraja/mails/new_transaction.html'
activate(dara_service.member.language)
subject = _("New transaction on %s" % config.company_name)
try:
dashboard_url = 'http://daraja.ikwen.com' + reverse('daraja:dashboard')
extra_context = {'currency_symbol': config.currency_symbol, 'amount': order.items_cost,
'dara_earnings': order.referrer_earnings,
'tx_date': order.updated_on.strftime('%Y-%m-%d'),
'tx_time': order.updated_on.strftime('%H:%M:%S'),
'account_balance': dara_service.balance,
'dashboard_url': dashboard_url}
try:
dara = Dara.objects.using(UMBRELLA).get(member=dara_service.member)
extra_context['dara'] = dara
except:
pass
html_content = get_mail_content(subject, template_name=template_name, extra_context=extra_context)
sender = 'ikwen Daraja <*****@*****.**>'
msg = XEmailMessage(subject, html_content, sender, [dara_service.member.email])
msg.content_subtype = "html"
Thread(target=lambda m: m.send(), args=(msg,)).start()
except:
logger.error("Failed to notify %s Dara after follower purchase." % service, exc_info=True)
def notify_staff():
now = datetime.now()
weblet = get_service_instance()
config = weblet.config
for obj in PaymentOrder.objects.filter(due_date__lt=now.date()):
print "Processing notification of payment %f of ref %s\n" % (
obj.amount, obj.reference_id)
if obj.last_notice_date:
diff = now - obj.last_notice_date
if diff.total_seconds() < 86400:
print "Skipping Payment of ref: %s\n" % obj.reference_id
continue
# Send notification here by email
subject = _("Outdated Payment Order")
html_content = get_mail_content(
subject,
template_name='council/mails/outdate_payment_orders_notice.html',
extra_context={
'currency_symbol': config.currency_symbol,
'payment_order': obj,
'ref_id': obj.reference_id,
'provider': obj.provider,
'due_date': obj.due_date.strftime('%Y-%m-%d'),
'issue_date': obj.created_on.strftime('%Y-%m-%d')
})
sender = '%s <no-reply@%s>' % (weblet.project_name, weblet.domain)
msg = EmailMessage(subject, html_content, sender,
[config.contact_email])
msg.content_subtype = "html"
if getattr(settings, 'UNIT_TESTING', False):
msg.send()
else:
Thread(target=lambda m: m.send(), args=(msg, )).start()
print "Sending email of outdated payment order to %s\n" % config.contact_email
def save_object_profile_tags(self, request, obj, *args, **kwargs):
auto_profiletag_id_list = kwargs.pop('auto_profiletag_id_list', [])
profiletag_ids = request.GET.get('profiletag_ids', '').strip()
revival_mail_renderer = kwargs.pop('revival_mail_renderer',
self.revival_mail_renderer)
if not (profiletag_ids or auto_profiletag_id_list):
return
do_revive = kwargs.pop(
'do_revive', None) # Set a revival if explicitly stated to do so
if do_revive is None and not kwargs.get('object_id'):
do_revive = True # Set a revival in any case for a newly added item
profiletag_id_list = []
if profiletag_ids:
profiletag_id_list = profiletag_ids.split(',')
profiletag_id_list.extend(auto_profiletag_id_list)
model_name = obj._meta.app_label + '.' + obj._meta.model_name
if do_revive and revival_mail_renderer: # This is a newly created object
service = get_service_instance()
srvce = Service.objects.using(UMBRELLA).get(pk=service.id)
for tag_id in profiletag_id_list:
revival, update = Revival.objects.get_or_create(
service=service,
model_name=model_name,
object_id=obj.id,
profile_tag_id=tag_id,
mail_renderer=revival_mail_renderer)
Revival.objects.using(UMBRELLA).get_or_create(
id=revival.id,
service=srvce,
model_name=model_name,
object_id=obj.id,
profile_tag_id=tag_id,
mail_renderer=revival_mail_renderer)
def save_model(self, request, obj, form, change):
# Send e-mail for manually generated Invoice upon creation
if change:
super(InvoiceAdmin, self).save_model(request, obj, form, change)
return
obj.number = get_next_invoice_number(auto=False)
super(InvoiceAdmin, self).save_model(request, obj, form, change)
member = obj.subscription.member
service = get_service_instance()
config = service.config
subject, message, sms_text = get_invoice_generated_message(obj)
if member.email:
add_event(service, NEW_INVOICE_EVENT, member=member, object_id=obj.id)
invoice_url = service.url + reverse('billing:invoice_detail', args=(obj.id,))
html_content = get_mail_content(subject, message, template_name='billing/mails/notice.html',
extra_context={'invoice_url': invoice_url})
# Sender is simulated as being no-reply@company_name_slug.com to avoid the mail
# to be delivered to Spams because of origin check.
sender = '%s <no-reply@%s>' % (service.project_name, service.domain)
msg = EmailMessage(subject, html_content, sender, [member.email])
msg.content_subtype = "html"
if msg.send(fail_silently=True):
obj.reminders_sent = 1
obj.last_reminder = timezone.now()
if sms_text:
if member.phone:
if config.sms_sending_method == Config.HTTP_API:
send_sms(member.phone, sms_text)
else:
QueuedSMS.objects.create(recipient=member.phone, text=sms_text)
def test_submit_item_with_existing_service(self):
"""
submit_item view update information of a previously existing RecurringPaymentService
"""
copy_service_and_config_to_default_db()
call_command('loaddata', 'wn_members.yaml', database=UMBRELLA)
call_command('loaddata', 'items.yaml')
self.client.login(username='******', password='******')
service = RecurringPaymentService.objects.get(pk='55d1fa8feb60008099bd4154')
service.provider = get_service_instance() # Make provider of this service the current retailer
service.save()
response = self.client.post(reverse('items:change_item'),
{'item_id': '55d1fa8feb60008099bd4154',
'category': '569228a9b37b3301e0706b54',
'name': 'Loss insurance',
'item_type': 'service',
'duration': service.duration,
'duration_text': service.duration_text,
'retail_price': '6000',
'summary': 'Some summary',
'description': 'Some description'})
service = RecurringPaymentService.objects.get(pk='55d1fa8feb60008099bd4154')
self.assertEqual(service.name, 'Loss insurance')
self.assertEqual(service.slug, 'loss-insurance') # Slug must be correctly set
self.assertEqual(service.category, ItemCategory.objects.get(pk='569228a9b37b3301e0706b54'))
self.assertEqual(service.retail_price, 6000) # retail_price cannot be bigger than max_price
self.assertEqual(service.summary, 'Some summary')
self.assertEqual(service.description, 'Some description')
def save_model(self, request, obj, form, change):
# Send e-mail for manually generated Invoice upon creation
super(SubscriptionAdmin, self).save_model(request, obj, form, change)
if change:
return
# Send e-mail only if e-mail is a valid one. It will be agreed that if a client
# does not have an e-mail. we create a fake e-mail that contains his phone number.
# So e-mail containing phone number are invalid.
member = obj.member
service = get_service_instance()
config = service.config
subject, message, sms_text = get_subscription_registered_message(obj)
# This helps differentiates from fake email accounts created as [email protected]
if member.email.find(member.phone) < 0:
add_event(service, SUBSCRIPTION_EVENT, member=member, object_id=obj.id, model=subscription_model_name)
html_content = get_mail_content(subject, message, template_name='billing/mails/notice.html')
# Sender is simulated as being no-reply@company_name_slug.com to avoid the mail
# to be delivered to Spams because of origin check.
sender = '%s <no-reply@%s>' % (service.project_name, service.domain)
msg = EmailMessage(subject, html_content, sender, [member.email])
msg.content_subtype = "html"
Thread(target=lambda m: m.send(), args=(msg,)).start()
if sms_text:
if member.phone:
if config.sms_sending_method == Config.HTTP_API:
send_sms(member.phone, sms_text)
else:
QueuedSMS.objects.create(recipient=member.phone, text=sms_text)
def get_context_data(self, **kwargs):
context = super(CCMDashboard, self).get_context_data(**kwargs)
service = get_service_instance()
CA = service.turnover_history[0]
set_counters(service)
community_count = Member.objects.filter(is_active=True).count()
community_today = calculate_watch_info(service.community_history)
community_yesterday = calculate_watch_info(service.community_history,
1)
community_last_week = calculate_watch_info(service.community_history,
7)
community_last_28_days = calculate_watch_info(
service.community_history, 28)
community_report = {
'today': community_today,
'yesterday': community_yesterday,
'last_week': community_last_week,
'last_28_days': community_last_28_days
}
joins = Member.objects.all().order_by('-date_joined')[:5]
context['estimated_worth'] = 0
context['community_report'] = community_report
context['last_joined'] = joins
context['ca'] = CA / community_count
return context
def get_context_data(self, **kwargs):
context = super(DeployCloud, self).get_context_data(**kwargs)
context['billing_cycles'] = Service.BILLING_CYCLES_CHOICES
app_slug = kwargs['app_slug']
app = Application.objects.using(UMBRELLA).get(slug=app_slug)
context['app'] = app
if getattr(settings, 'IS_IKWEN', False):
billing_plan_list = CloudBillingPlan.objects.using(
UMBRELLA).filter(app=app, partner__isnull=True)
if billing_plan_list.count() == 0:
setup_months_count = 3
context[
'ikwen_setup_cost'] = app.base_monthly_cost * setup_months_count
context['ikwen_monthly_cost'] = app.base_monthly_cost
context['setup_months_count'] = setup_months_count
else:
service = get_service_instance()
billing_plan_list = CloudBillingPlan.objects.using(
UMBRELLA).filter(app=app, partner=service)
if billing_plan_list.count() == 0:
retail_config = ApplicationRetailConfig.objects.using(
UMBRELLA).get(app=app, partner=service)
setup_months_count = 3
context[
'ikwen_setup_cost'] = retail_config.ikwen_monthly_cost * setup_months_count
context[
'ikwen_monthly_cost'] = retail_config.ikwen_monthly_cost
context['setup_months_count'] = setup_months_count
if billing_plan_list.count() > 0:
context['billing_plan_list'] = billing_plan_list
context['setup_months_count'] = billing_plan_list[
0].setup_months_count
return context
def upload_complete(self, request, filename, *args, **kwargs):
path = self.UPLOAD_DIR + "/" + filename
self._dest.close()
media_root = getattr(settings, 'MEDIA_ROOT')
try:
with open(media_root + path, 'r') as f:
content = File(f)
destination = media_root + BatchUpload.UPLOAD_TO + "/" + filename
batch_upload = BatchUpload()
batch_upload.spreadsheet.save(destination, content)
service = get_service_instance()
product_resource = ProductResource()
product_resource.provider = service
product_resource.retail_price_is_modifiable = True if request.GET.get('retail_price_is_modifiable') else False
dataset = tablib.Dataset()
dataset.xls = open(destination).read()
col_id = ['' for i in range(dataset.height)]
dataset.insert_col(0, col_id, header='id')
try:
result = product_resource.import_data(dataset, dry_run=True)
result.has_errors()
except Exception as e:
return {
'exception': e.message
}
os.unlink(media_root + path)
return {
'id': batch_upload.id,
'url': batch_upload.image.thumb_url
}
except IOError as e:
if settings.DEBUG:
raise e
return {'error': 'File failed to upload. May be invalid or corrupted image file'}
def set_credentials(request, *args, **kwargs):
"""
Set credentials of a payment mean on an IAO Website
"""
config = get_service_instance().config
if not config.is_pro_version:
return HttpResponse(json.dumps({'error': "Operation not allowed"}),
'content-type: text/json')
mean_id = request.GET['mean_id']
credentials = request.GET['credentials']
payment_mean = PaymentMean.objects.get(pk=mean_id)
try:
credentials = json.loads(credentials.strip())
cleaned = {}
for key, val in credentials.items():
cleaned[key] = val.strip()
except:
return HttpResponse(
json.dumps({
'error':
"Invalid credentials. Could not be parsed successfully"
}), 'content-type: text/json')
payment_mean.credentials = json.dumps(cleaned)
payment_mean.save()
return HttpResponse(json.dumps({'success': True}),
'content-type: text/json')
def sync_teacher(sender, **kwargs):
"""
Receiver of the post_save signals of UserPermissionList. It creates
the corresponding Teacher when a Member is moved to the Teacher Group
and delete the Teacher object when the Member is moved out of the
Teacher Group
"""
if sender != UserPermissionList: # Avoid unending recursive call
return
if get_service_instance().app.slug != 'foulassi':
return
instance = kwargs['instance']
try:
group_id = Group.objects.get(name=TEACHERS).id
school_year = get_school_year()
if group_id in instance.group_fk_list:
Teacher.objects.get_or_create(member=instance.user,
school_year=school_year)
else:
try:
teacher = Teacher.objects.get(member=instance.user,
school_year=school_year)
if teacher.teacherresponsibility_set.all().count() == 0:
teacher.delete()
except Teacher.DoesNotExist:
pass
except Group.DoesNotExist:
pass
def get_context_data(self, **kwargs):
context = super(ProductDetail, self).get_context_data(**kwargs)
add_member_auto_profiletag(self.request, **kwargs)
category_slug = kwargs['category_slug']
product_slug = kwargs['product_slug']
category = ProductCategory.objects.get(slug=category_slug)
try:
current_product = Product.objects.select_related('provider').filter(category=category, slug=product_slug)[0]
except IndexError:
raise Http404('No product matches the given query.')
product = apply_promotion_discount([current_product])[0]
category = product.category
context['product'] = product
product_uri = reverse('shopping:product_detail', args=(category.slug, product.slug))
product_uri = product_uri.replace(getattr(settings, 'WSGI_SCRIPT_ALIAS', ''), '')
context['product_uri'] = product_uri
base_queryset = Product.objects.select_related('provider')\
.exclude(pk=product.id).filter(visible=True, is_duplicate=False)
suggestions = base_queryset.filter(category=category, brand=product.brand).order_by('-updated_on')[:6]
if suggestions.count() < 6:
additional = 6 - suggestions.count()
exclude_list = [p.pk for p in suggestions]
suggestions = list(suggestions)
suggestions.extend(list(base_queryset.exclude(pk__in=exclude_list).filter(category=product.category)
.order_by('-updated_on')[:additional]))
suggestions = apply_promotion_discount(list(suggestions))
context['suggestion_list'] = suggestions
context['review_count'] = Review.objects.filter(product=product).count()
context['review_list'] = Review.objects.filter(product=product).order_by('-id')[:50]
service = get_service_instance()
banks = []
for p in OperatorProfile.objects.filter(business_type=OperatorProfile.BANK):
try:
banks.append(p.service)
except:
continue
deal_list = []
for bank in banks:
try:
bank_db = bank.database
add_database(bank_db)
deal = Deal.objects.using(bank_db)\
.filter(product_slug=product.slug, merchant=service, bank=bank).order_by('term_cost')[0]
deal_list.append(deal)
except:
continue
context['deal_list'] = deal_list
member = self.request.user
from daraja.models import Dara
if member.is_authenticated():
try:
Review.objects.get(member=member, product=product)
except Review.DoesNotExist:
context['can_review'] = True
try:
Dara.objects.get(member=member)
context['is_dara'] = True
except Dara.DoesNotExist:
pass
return context
def get_payment_confirmation_email_message(payment, parent_name, student_name):
"""
Returns a tuple (mail subject, mail body) to send to
member as receipt of Invoice payment.
"""
config = get_service_instance().config
invoice = payment.invoice
subject = _("Invoice Payment Confirmation")
message = _(
"Dear %(parent_name)s,<br><br>"
"This is a payment receipt of %(currency)s %(amount).2f "
"for Invoice <strong>No. %(invoice_number)s</strong> generated on %(date_issued)s "
"for %(student_name)s. Below is a summary of your payment.<br><br>"
"<span style='color: #666'>%(invoice_title)s</span><br><br>"
"Thank you for your "
"payment." % {
'parent_name': parent_name,
'invoice_number': invoice.number,
'student_name': student_name,
'amount': payment.amount,
'currency': config.currency_symbol,
'date_issued': invoice.date_issued.strftime('%B %d, %Y'),
'invoice_title': invoice.get_title()
})
return subject, message
def send_code(self, request, new_code=False):
member = request.user
code = ''.join(
[random.SystemRandom().choice(string.digits) for _ in range(4)])
do_send = False
try:
current = request.session['code']
if new_code:
request.session['code'] = code
do_send = True
except KeyError:
request.session['code'] = code
do_send = True
if do_send:
phone = slugify(member.phone).replace('-', '')
if len(phone) == 9:
phone = '237' + phone
service = get_service_instance()
requests.get('http://5.39.75.139:22090/message',
params={
'user': '******',
'pass': '******',
'from': service.project_name,
'to': phone,
'text': 'Confirmation code: ' + code,
'dlrreq': 0
})
