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_send_free_rewards_with_members_never_rewarded(self):
service = Service.objects.using(UMBRELLA).get(pk=getattr(settings, 'IKWEN_SERVICE_ID'))
db = service.database
add_database(db)
for member in Member.objects.all():
member.customer_on_fk_list = ['56eb6d04b37b3379b531b101', '56eb6d04b37b3379b531b102', '56eb6d04b37b3379b531b103']
member.save()
prepare_free_rewards()
send_free_rewards()
for member in Member.objects.using(db).all():
cr_profile = CRProfile.objects.using(db).get(member=member)
self.assertEqual(cr_profile.reward_score, CRProfile.FREE_REWARD)
total_count = 0
for coupon in Coupon.objects.filter(service=service, status=Coupon.APPROVED, is_active=True):
try:
reward_pack = JoinRewardPack.objects.get(service=service, coupon=coupon, count__gt=0)
cumul = CumulatedCoupon.objects.get(member=member, coupon=coupon)
Reward.objects.get(service=service, member=member, coupon=coupon,
count=reward_pack.count, status=Reward.SENT, type=Reward.JOIN)
self.assertEqual(cumul.count, reward_pack.count)
total_count += reward_pack.count
except JoinRewardPack.DoesNotExist:
pass
summary = CouponSummary.objects.get(service=service, member=member)
self.assertEqual(summary.count, total_count)
def test_send_free_rewards_with_members_previously_rewarded(self):
service = Service.objects.get(pk=getattr(settings, 'IKWEN_SERVICE_ID'))
db = service.database
add_database(db)
last_reward_date = datetime.now() - timedelta(days=10)
c1 = Coupon.objects.get(pk='593928184fc0c279dc0f73b1')
for member in Member.objects.exclude(email=ARCH_EMAIL):
member_local = Member.objects.using(db).get(pk=member.id)
CRProfile.objects.using(db).create(member=member_local, last_reward_date=last_reward_date)
CumulatedCoupon.objects.create(member=member, coupon=c1, count=30)
Reward.objects.create(service=service, member=member, coupon=c1, count=30, type=Reward.JOIN, status=Reward.SENT)
CouponSummary.objects.create(service=service, member=member, count=30)
member.customer_on_fk_list = ['56eb6d04b37b3379b531b101', '56eb6d04b37b3379b531b102', '56eb6d04b37b3379b531b103']
member.save()
prepare_free_rewards()
send_free_rewards()
for member in Member.objects.using(db).exclude(email=ARCH_EMAIL):
cr_profile = CRProfile.objects.using(db).get(member=member)
self.assertEqual(cr_profile.reward_score, CRProfile.FREE_REWARD)
reward = Reward.objects.get(service=service, member=member, status=Reward.SENT, type=Reward.FREE)
coupon = reward.coupon
cumul = CumulatedCoupon.objects.get(member=member, coupon=coupon)
if coupon == c1:
self.assertGreater(cumul.count, 30)
else:
self.assertGreater(cumul.count, 0)
summary = CouponSummary.objects.get(service=service, member=member)
self.assertGreater(summary.count, 30)
def save(self, *args, **kwargs):
if getattr(settings, 'IS_IKWEN', False):
db = self.service.database
add_database(db)
try:
obj_mirror = SchoolConfig.objects.using(db).get(pk=self.id)
obj_mirror.is_public = self.is_public
obj_mirror.my_kids_fees = self.my_kids_fees
obj_mirror.my_kids_fees_term = self.my_kids_fees_term
obj_mirror.my_kids_fees_month = self.my_kids_fees_month
obj_mirror.my_kids_payment_period = self.my_kids_payment_period
obj_mirror.my_kids_share_rate = self.my_kids_share_rate
obj_mirror.ikwen_share_rate = self.ikwen_share_rate
obj_mirror.ikwen_share_fixed = self.ikwen_share_fixed
obj_mirror.cash_out_rate = self.cash_out_rate
super(SchoolConfig, obj_mirror).save(using=db)
except SchoolConfig.DoesNotExist:
pass
super(SchoolConfig, self).save(*args, **kwargs)
else:
before = SchoolConfig.objects.get(pk=self.id)
bts = self.back_to_school_date
# if bts.hour != 7 or bts.min != 30:
if bts and (bts.hour != 7 or bts.min != 30):
# Always set back to school time to 07:30 AM
self.back_to_school_date = datetime(bts.year, bts.month,
bts.day, 7, 30)
super(SchoolConfig, self).save(*args, **kwargs)
if before.my_kids_fees != self.my_kids_fees:
from ikwen_foulassi.school.student.views import reset_my_kids_invoice
if getattr(settings, 'DEBUG', False):
reset_my_kids_invoice()
else:
Thread(target=reset_my_kids_invoice).start()
def after_save(self, request, obj, *args, **kwargs):
""""
Notify the teacher when a student send his homework
"""
try:
foulassi = Service.objects.using(UMBRELLA).get(project_name_slug='foulassi')
except:
foulassi = None
student = obj.student
service = student.school
db = service.database
add_database(db)
classroom = student.classroom
assignment_id = request.POST['assignment']
try:
assignment = Assignment.objects.using(db).get(pk=assignment_id)
except:
raise Http404("Data have been altered")
assignment_subject = assignment.subject
teacher = assignment_subject.get_teacher(classroom) # Retrieve the teacher who gives assignment
school_config = service.config
company_name = school_config.company_name
classroom_name = classroom.name
sender = '%s via ikwen Foulassi <*****@*****.**>' % student
# try:
# # cta_url = 'https://go.ikwen.com' + reverse('foulassi:change_homework', args=(
# # school_config.company_name_slug, student.pk, assignment.pk))
# except:
# cta_url = ''
if teacher.member:
activate(teacher.member.language)
student_name = student.first_name
cta_url = service.url + reverse('school:assignment_reply_list', args=(classroom.pk, assignment.pk))
subject = _(" New homework sent")
extra_context = {'subject': subject, 'teacher': teacher, 'school_name': company_name, 'cta_url': cta_url,
'student_name': student_name, 'assignment': assignment, 'classroom': classroom_name}
try:
html_content = get_mail_content(subject,
template_name='foulassi/mails/submitted_homework.html',
extra_context=extra_context)
teacher_email = teacher.member.email
msg = EmailMessage(subject, html_content, sender,
[teacher_email, '*****@*****.**', '*****@*****.**'])
msg.content_subtype = "html"
try:
msg.send()
except Exception as e:
logger.debug(e.message)
except:
logger.error("Could not generate HTML content from template", exc_info=True)
body = _("%(student_name)s from %(classroom)s sent his assignment of %(subject)s about %(assignment_name)s"
% {'student_name': student_name, 'classroom': classroom_name,
'subject': assignment_subject, 'assignment_name': assignment.title})
send_push(foulassi, teacher.member, subject, body)
return HttpResponseRedirect(reverse("foulassi:kid_detail", args=(kwargs['ikwen_name'], student.pk)) +
"?showTab=assignments")
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_context_data(self, **kwargs):
context = super(KidDetail, self).get_context_data(**kwargs)
user = self.request.user
parent_profile = get_object_or_404(ParentProfile, member=user)
student = context['student']
db = student.school.database
add_database(db)
subject_list = get_subject_list(student.classroom, using=db)
for subject in subject_list:
subject.score_list = student.get_score_list(subject, using=db)
context['subject_list'] = subject_list
kid_list = parent_profile.student_list
now = datetime.now()
end_year_date = datetime(day=31, month=8, year=get_school_year() + 1)
month_expiry = now + timedelta(days=30)
term_expiry = now + timedelta(days=90)
# kid_list.remove(student)
context['kid_list'] = kid_list
context['using'] = db
parent1 = Parent.objects.filter(student=student)[0]
context['is_first_parent'] = parent1.email == user.email or parent1.phone == user.phone
context['has_pending_assignment'] = Assignment.objects.using(db).filter(classroom=student.classroom, deadline__lt=now)
context['has_pending_invoice'] = Invoice.objects.using(db).filter(student=student, status=Invoice.PENDING).count() > 0
context['has_pending_disc'] = DisciplineLogEntry.objects.using(db).filter(student=student, was_viewed=False).count() > 0
context['has_new_score'] = Score.objects.using(db).filter(student=student, was_viewed=False).count() > 0
context['month_expiry'] = min(month_expiry, end_year_date)
context['term_expiry'] = min(term_expiry, end_year_date)
context['year_expiry'] = end_year_date
context['school_config'] = SchoolConfig.objects.using(db).get(service=student.school)
return context
def post(self, request, *args, **kwargs):
context = self.get_context_data(**kwargs)
product = context['product']
merchant = product.provider
bank = get_service_instance()
merchant_db = merchant.database
add_database(merchant_db)
Deal.objects.filter(product_slug=product.slug,
merchant=merchant).delete()
Deal.objects.using(merchant_db).filter(product_slug=product.slug,
merchant=merchant).delete()
i = 0
while True:
try:
is_active = True if request.POST.get('is_active%d' %
i) else False
deal = Deal.objects.create(
product_slug=product.slug,
merchant=merchant,
bank=bank,
frequency=request.POST['frequency%d' % i],
terms_count=request.POST['terms_count%d' % i],
first_term=request.POST['first_term%d' % i],
term_cost=request.POST['term_cost%d' % i],
about=request.POST['about%d' % i],
is_active=is_active)
deal.save(using=merchant_db)
i += 1
except MultiValueDictKeyError:
break
msg = _("Deals for %s successfully saved." % product.name)
messages.success(request, msg)
next_url = reverse('trade:deal_list', args=(product.id, ))
return HttpResponseRedirect(next_url)
def test_notify_profiles_retro_with_suggest_referral(self):
"""
Member newly having a tag in revival should be notified
even if the revival for this tag has already been run before.
"""
db = 'test_ikwen_service_2'
add_database(db)
for fixture in self.fixtures:
call_command('loaddata', fixture, database=db)
call_command('loaddata', 'member_profiles.yaml', database=db)
call_command('loaddata', 'revivals.yaml', database=db)
Balance.objects.using('wallets').get_or_create(service_id='56eb6d04b37b3379b531b102', mail_count=1000)
seven_hours_ago = datetime.now() - timedelta(hours=7)
Member.objects.using(db).all().update(date_joined=seven_hours_ago, is_ghost=True)
Revival.objects.exclude(pk='58eb3eb637b33795ddfd04b3').update(is_active=False)
notify_profiles()
target_count = Target.objects.using(db).filter(revival='58eb3eb637b33795ddfd04b3').all().count()
self.assertEqual(target_count, 1)
for member_profile in MemberProfile.objects.using(db).exclude(member='56eb6d04b37b3379b531e011'):
member_profile.tag_fk_list.append('58088fc0c253e5ddf0563955')
member_profile.save()
notify_profiles_retro()
target_count = Target.objects.using(db).filter(revival='58eb3eb637b33795ddfd04b3').all().count()
self.assertEqual(target_count, 4)
balance = Balance.objects.using('wallets').get(service_id='56eb6d04b37b3379b531b102')
self.assertEqual(balance.mail_count, 996)
def get_context_data(self, **kwargs):
context = super(Dashboard, self).get_context_data(**kwargs)
service = self.get_service(**kwargs)
db = service.database
add_database(db)
customer_list = slice_watch_objects(Customer, 28, using=db)
customers_report = {
'today':
rank_watch_objects(customer_list, 'turnover_history'),
'yesterday':
rank_watch_objects(customer_list, 'turnover_history', 1),
'last_week':
rank_watch_objects(customer_list, 'turnover_history', 7),
'last_28_days':
rank_watch_objects(customer_list, 'turnover_history', 28)
}
context['customers_report'] = customers_report
company_list = list(Service.objects.using(db).all())
for company in company_list:
set_counters(company)
companies_report = {
'today':
rank_watch_objects(company_list, 'earnings_history'),
'yesterday':
rank_watch_objects(company_list, 'earnings_history', 1),
'last_week':
rank_watch_objects(company_list, 'earnings_history', 7),
'last_28_days':
rank_watch_objects(company_list, 'earnings_history', 28)
}
context['companies_report'] = companies_report
return context
def get(self, request, *args, **kwargs):
ikwen_name = kwargs['ikwen_name']
company = get_object_or_404(Service, project_name_slug=ikwen_name)
app = Application.objects.get(slug=DARAJA)
action = request.GET.get('action')
if action == 'accept':
member = request.user
if member.is_anonymous():
response = {'error': "anonymous_user"}
return HttpResponse(json.dumps(response),
'content-type: text/json')
try:
dara_service = Service.objects.get(app=app, member=member)
except Service.DoesNotExist:
response = {'error': "not_yet_dara"}
return HttpResponse(json.dumps(response),
'content-type: text/json')
company_db = company.database
add_database(company_db)
member.save(using=company_db)
UserPermissionList.objects.using(company_db).get_or_create(
user=member)
Dara.objects.using(company_db).get_or_create(member=member)
db = dara_service.database
add_database(db)
company.save(using=db)
response = {'success': True}
return HttpResponse(json.dumps(response),
'content-type: text/json')
return super(InviteDara, self).get(request, *args, **kwargs)
def place_invoice(self, request, *args, **kwargs):
school_name = kwargs['school_name']
weblet = Service.objects.get(project_name_slug=school_name)
try:
db = weblet.database
add_database(db)
school = SchoolConfig.objects.using(db).get(service=weblet)
now = datetime.now()
due_date = now + timedelta(days=7)
number = get_next_invoice_number()
from ikwen.billing.utils import Invoice
app = Application.objects.using(UMBRELLA).get(slug='foulassi')
cost = 12000
item = IkwenInvoiceItem(label='School website', price=cost, amount=cost)
entry = InvoiceEntry(item=item, total=cost)
invoice_entries = [entry]
try:
Invoice.objects.using(UMBRELLA).get(subscription=weblet, months_count=SCHOOL_WEBSITE_MONTH_COUNT)
except:
invoice = Invoice(subscription=weblet, member=weblet.member, amount=cost,
months_count=SCHOOL_WEBSITE_MONTH_COUNT, number=number,
due_date=due_date, last_reminder=now, entries=invoice_entries, is_one_off=True)
invoice.save()
school.has_subscribed_website_service = True
school.save()
return HttpResponse(json.dumps({'success': True}, 'content-type: text/json'))
except:
return HttpResponse(json.dumps({'error': True}, 'content-type: text/json'))
def submit_order_for_bank_approval(request, order, bank_id, account_number, deal_id=None):
merchant = get_service_instance()
bank = Service.objects.get(pk=bank_id)
payment_mean = PaymentMean.objects.get(slug=bank.project_name_slug)
order.payment_mean = payment_mean
entry = order.entries[0]
product = entry.product
product.stock -= entry.count
if product.stock == 0:
sudo_group = Group.objects.get(name=SUDO)
add_event(merchant, SOLD_OUT_EVENT, group_id=sudo_group.id, object_id=product.id)
mark_duplicates(product)
product.save()
bank_db = bank.database
add_database(bank_db)
try:
member = Member.objects.using(bank_db).get(pk=order.member.id)
except Member.DoesNotExist:
member = order.member
member.save(using=bank_db)
group = Group.objects.using(bank_db).get(name=COMMUNITY)
obj_list, created = UserPermissionList.objects.using(bank_db).get_or_create(user=member)
obj_list.group_fk_list.append(group.id)
obj_list.save(using=bank_db)
account_number_slug = slugify(account_number)
try:
BankAccount.objects.using(UMBRELLA).get(slug=account_number_slug)
except BankAccount.DoesNotExist:
m = Member.objects.using(UMBRELLA).get(pk=member.id)
b = Service.objects.using(UMBRELLA).get(pk=bank_id)
BankAccount.objects.using(UMBRELLA).create(member=m, bank=b, number=account_number, slug=account_number_slug)
if deal_id:
if len(order.entries) > 1:
messages.error(request, _("Terms payment is available only for one single product at a time."))
return HttpResponseRedirect(reverse('shopping:cart'))
deal = Deal.objects.using(bank_db).get(pk=deal_id)
else:
deal = Deal(bank=bank)
order.deal = deal
order.account_number = account_number
order.status = Order.PENDING_FOR_APPROVAL
order.save()
order.save(using=bank_db)
try:
del(request.session['object_id'])
except:
pass
subject = _("Order submit for approval")
send_order_confirmation_email(request, subject, member.full_name, member.email, order)
bank_profile_original = OperatorProfile.objects.using(bank_db).get(service=bank)
if bank_profile_original.return_url:
nvp_dict = {'member': member.full_name, 'email': member.email, 'phone': member.phone,
'order_rcc': order.rcc.upper(), 'account_number': account_number,
'deal': str(deal), 'merchant': merchant.project_name}
Thread(target=lambda url, data: requests.post(url, data=data),
args=(bank_profile_original.return_url, nvp_dict)).start()
next_url = reverse('shopping:cart', args=(order.id, ))
return HttpResponseRedirect(next_url)
def reset_notices_counter(request, *args, **kwargs):
member = request.user
for s in member.get_services():
add_database(s.database)
Member.objects.using(
s.database).filter(pk=member.id).update(personal_notices=0)
return HttpResponse(json.dumps({'success': True}),
content_type='application/json')
def propagate_access_token_refresh(payment_mean):
for service in Service.objects.using(UMBRELLA).all():
config = service.basic_config
if config.is_pro_version:
continue
db = service.database
add_database(db)
PaymentMean.objects.using(db).filter(slug=ORANGE_MONEY).update(
credentials=payment_mean.credentials)
def setUp(self):
self.client = Client()
call_command('loaddata', 'rewarding.yaml', database=UMBRELLA)
for fixture in self.fixtures:
call_command('loaddata', fixture)
db = 'test_ikwen_service_2'
add_database(db)
for fixture in self.fixtures:
call_command('loaddata', fixture, database=db)
def synch_invoices():
f = open("synch_traceback.txt", "a+")
foulassi = Application.objects.using(UMBRELLA).get(slug='foulassi')
for school in Service.objects.using(UMBRELLA).filter(app=foulassi):
print "\n\n---------Processing the school %s-----------------\n\n" % school.project_name
f.write("\n\n---------Processing the school %s-----------------\n\n" %
school.project_name)
db = school.database
add_database(db)
for invoice in Invoice.objects.using(db).all():
extra_payments = []
print "Processing invoice %s with amount %d\n" % (
invoice.get_title(), invoice.amount)
f.write("Processing invoice %s with amount %d\n" %
(invoice.get_title(), invoice.amount))
# Store all payments with the same amount and that have the same invoice's id
queryset = Payment.objects.using(db).filter(invoice=invoice)
i = 0
for i in range(queryset.count()):
first_payment = queryset[i]
print "First payment No %s of invoice %s with amount %d \n" % (
first_payment.id, invoice.get_title(),
first_payment.amount)
f.write("First payment No %s of invoice %s with amount %d \n" %
(first_payment.id, invoice.get_title(),
first_payment.amount))
try:
second_payment = queryset[i + 1]
print "Second payment No %s of invoice %s with amount %d \n" % (
second_payment.id, invoice.get_title(),
second_payment.amount)
f.write(
"Second payment No %s of invoice %s with amount %d \n"
% (second_payment.id, invoice.get_title(),
second_payment.amount))
except:
print "No second payment, we skipped\n"
f.write("No second payment, we skipped\n")
break
if first_payment.amount != second_payment.amount:
print "Skipped this both payments 'coz no same amount\n"
f.write("Skipped this both payments 'coz no same amount\n")
continue
diff = second_payment.created_on - first_payment.created_on
if diff.seconds <= 5:
extra_payments.append(second_payment)
for payment in extra_payments:
invoice.paid -= payment.amount
invoice.save(using=db)
payment.delete(using=db)
print "Current invoice amount is now %d\n\n" % invoice.amount
f.write("Current invoice amount is now %d\n\n" %
invoice.amount)
f.close()
def check_setup_status(school):
"""
Checks what has been done so far regarding insertion of Students and Parent contacts
"""
missing_parents = 0
students_reminder = None
db = school.database
add_database(db)
school_config = SchoolConfig.objects.using(db).get(service=school)
now = datetime.now()
if now - timedelta(days=7) != school_config.last_setup_status_check:
return
expected_student_count = school_config.expected_student_count
student_count = Student.objects.using(db).filter(school=school).count()
if student_count < expected_student_count:
missing_students = expected_student_count - student_count
missing_parents = missing_students
print("%s missing students" % missing_students)
students_reminder, change = Reminder.objects.using(db).get_or_create(
type=Reminder.UNREGISTERED_STUDENTS)
students_reminder.missing = missing_students
students_reminder.save()
for classroom in Classroom.objects.using(db).all():
if classroom.student_set.all().count(
) < Classroom.STUDENT_THRESHOLD:
classroom.has_student_reminder = True
classroom.has_parent_reminder = True
else:
classroom.has_student_reminder = False
classroom.save()
else:
Classroom.objects.using(db).update(has_student_reminder=False)
for classroom in Classroom.objects.using(db).all():
has_parent_reminder = False
for student in classroom.student_set.all():
if student.parent_set.all().count() == 0:
has_parent_reminder = True
missing_parents += 1
classroom.has_parent_reminder = has_parent_reminder
classroom.save()
print("%s missing parents" % missing_parents)
share_rate = school.billing_plan.tx_share_rate
estimated_loss = missing_parents * school_config.my_kids_fees * (
100 - share_rate) / 100
parents_reminder, update = Reminder.objects.using(db).get_or_create(
type=Reminder.UNREGISTERED_PARENTS)
parents_reminder.missing = missing_parents
parents_reminder.estimated_loss = estimated_loss
parents_reminder.save()
return parents_reminder, students_reminder, estimated_loss
def set_customer_dara(service, referrer, member):
"""
Binds referrer to member referred.
:param service: Referred Service
:param referrer: Member who referred (The Dara)
:param member: Referred Member
:return:
"""
try:
db = service.database
add_database(db)
app = Application.objects.using(db).get(slug=DARAJA)
dara_service = Service.objects.using(db).get(app=app, member=referrer)
customer, change = Customer.objects.using(db).get_or_create(member=member)
if customer.referrer:
return
dara_umbrella = Dara.objects.using(UMBRELLA).get(member=referrer)
if dara_umbrella.level == 1 and dara_umbrella.xp == 1:
dara_umbrella.xp = 2
dara_umbrella.raise_bonus_cash(100)
dara_umbrella.save()
customer.referrer = dara_service
customer.save()
dara_db = dara_service.database
add_database(dara_db)
member.save(using=dara_db)
customer.save(using=dara_db)
service_mirror = Service.objects.using(dara_db).get(pk=service.id)
set_counters(service_mirror)
increment_history_field(service_mirror, 'community_history')
add_event(service, REFEREE_JOINED_EVENT, member)
diff = datetime.now() - member.date_joined
activate(referrer.language)
sender = "%s via Playground <*****@*****.**>" % member.full_name
if diff.days > 1:
subject = _("I'm back on %s !" % service.project_name)
else:
subject = _("I just joined %s !" % service.project_name)
html_content = get_mail_content(subject, template_name='playground/mails/referee_joined.html',
extra_context={'referred_service_name': service.project_name, 'referee': member,
'dara': dara_umbrella, 'cta_url': 'https://daraja.ikwen.com/'
})
msg = EmailMessage(subject, html_content, sender, [referrer.email])
msg.content_subtype = "html"
Thread(target=lambda m: m.send(), args=(msg, )).start()
except:
logger.error("%s - Error while setting Customer Dara", exc_info=True)
def refuse_suggestion(self, request):
user = request.user
student_id = request.GET['student_id']
student = Student.objects.select_related('school').get(pk=student_id)
db = student.school.database
add_database(db)
Parent.objects.using(db).filter(Q(email=user.email) | Q(phone=user.phone), student=student).delete()
suggestion_key = 'kid_list:suggestion_list:' + user.username
fragment_key = make_template_fragment_key('kid_list', [user.username])
cache.delete(suggestion_key)
cache.delete(fragment_key)
return HttpResponse(json.dumps({'success': True}, 'content-type: text/json'))
def get_object(self, **kwargs):
ikwen_name = kwargs['ikwen_name']
homework_id = kwargs.get('object_id')
try:
school = Service.objects.get(project_name_slug=ikwen_name)
self.db = school.database
add_database(self.db)
# student = Student.objects.using(school.database).select_related('school', 'classroom').get(pk=student_id)
if homework_id:
return Homework.objects.using(self.db).get(pk=homework_id)
except ObjectDoesNotExist:
raise Http404("School or student or homework not found")
def get_object(self, **kwargs):
ikwen_name = kwargs['ikwen_name']
object_id = kwargs['object_id']
try:
school = Service.objects.get(project_name_slug=ikwen_name)
add_database(school.database)
obj = Justificatory.objects.using(school.database).select_related('entry').get(pk=object_id)
# if not student.mykids_fees_paid:
# return HttpResponseRedirect(reverse('foulassi:kid_list', args=(ikwen_name, )))
except Justificatory.DoesNotExist:
raise Http404("No justficicatory found with this ID.")
return obj
def test_KidDetail_tab_billing(self):
"""
Ensure tab billing is accessible
"""
db = 'test_collegembakop'
add_database(db)
for fixture in ['fls_setup_data.yaml', 'school_setup.yaml', 'people.yaml']:
call_command('loaddata', fixture, database=db)
self.client.login(username='******', password='******')
kid_detail_url = reverse('foulassi:kid_detail', args=('collegembakop', '584f03a7bbd6b46a8fc0c244'))
response = self.client.get(kid_detail_url, data={'tab': 'billing'})
self.assertEqual(response.status_code, 200)
def get_context_data(self, **kwargs):
context = super(AdminHome, self).get_context_data(**kwargs)
service = get_service_instance()
db = service.database
add_database(db)
reminder_list = list(Reminder.objects.using(db).all())
total_missing = 0
for reminder in reminder_list:
total_missing += reminder.missing
if total_missing > 0:
context['reminder_list'] = reminder_list
context['total_missing'] = total_missing
return context
def get_context_data(self, **kwargs):
app = Application.objects.get(slug=DARAJA)
dara_service = get_object_or_404(Service,
app=app,
member=self.request.user)
db = dara_service.database
add_database(db)
context = super(CompanyList, self).get_context_data(**kwargs)
queryset = Service.objects.using(db).exclude(pk=dara_service.id)
context_object_name = self.get_context_object_name(self.object_list)
context[context_object_name] = queryset.order_by(
*self.ordering)[:self.page_size]
context['queryset'] = queryset
return context
def payment_means(request):
"""
Adds PaymentMean objects to context.
"""
key = 'payment_means:' + request.user.username
means = cache.get(key)
if means:
return means
mtn_momo, om, paypal = None, None, None
try:
mtn_momo = PaymentMean.objects.get(slug=MTN_MOMO, is_active=True)
except PaymentMean.DoesNotExist:
pass
try:
om = PaymentMean.objects.get(slug=ORANGE_MONEY, is_active=True)
except PaymentMean.DoesNotExist:
pass
try:
paypal = PaymentMean.objects.get(slug='paypal', is_active=True)
except PaymentMean.DoesNotExist:
pass
means = {
'mtn_momo':
mtn_momo,
'om':
om,
'paypal':
paypal,
'payment_mean_list':
list(
PaymentMean.objects.exclude(slug=DARA_CASH).filter(is_active=True))
}
try:
add_database(_umbrella_db)
dara = Dara.objects.using(_umbrella_db).get(member=request.user)
bonus_wallet, update = BonusWallet.objects.using(
'wallets').get_or_create(dara_id=dara.id)
dara_cash = PaymentMean.objects.get(slug='dara-cash', is_active=True)
dara_cash.balance = bonus_wallet.cash
means['dara_cash'] = dara_cash
means['payment_mean_list'].append(dara_cash)
except:
pass
cache_timeout = getattr(settings, 'CACHE_TIMEOUT', 5)
cache.set(key, means, cache_timeout * 60)
return means
def save(self, *args, **kwargs):
if getattr(settings, 'IS_IKWEN', False):
db = self.service.database
add_database(db)
try:
obj_mirror = OperatorProfile.objects.using(db).get(pk=self.id)
obj_mirror.currency_code = self.currency_code
obj_mirror.currency_symbol = self.currency_symbol
obj_mirror.cash_out_min = self.cash_out_min
obj_mirror.is_pro_version = self.is_pro_version
obj_mirror.can_manage_currencies = self.can_manage_currencies
super(OperatorProfile, obj_mirror).save(using=db)
except OperatorProfile.DoesNotExist:
pass
super(OperatorProfile, self).save(*args, **kwargs)
def test_notify_profiles_with_member_having_joined_less_than_seven_hours_ago(self):
"""
Smart revival sends message at minimum 7 hours after
Member joins the platform. This test is supposed to invoke
revival with ID 58eb3eb637b33795ddfd04b1
"""
db = 'test_ikwen_service_2'
add_database(db)
for fixture in self.fixtures:
call_command('loaddata', fixture, database=db)
call_command('loaddata', 'member_profiles.yaml', database=db)
call_command('loaddata', 'revivals.yaml', database=db)
Balance.objects.using('wallets').get_or_create(service_id='56eb6d04b37b3379b531b102', mail_count=1000)
notify_profiles()
target_count = Target.objects.using(db).filter(revival='58eb3eb637b33795ddfd04b1').all().count()
self.assertEqual(target_count, 0)
def get_context_data(self, **kwargs):
context = super(SingleProduct, self).get_context_data(**kwargs)
context['template_cache_duration'] = 400
service = get_service_instance()
db = service.database
add_database(db)
# try:
# current_product = Product.objects.select_related('provider').filter(category=category)[0]
# except IndexError:
# raise Http404('No product matches the given query.')
current_product = Product.objects.using(db).filter(visible=True)[0]
product = apply_promotion_discount([current_product])[0]
category = product.category
context['product'] = product
context['category'] = category
return context
def test_KidDetail_with_authorized_parent(self):
"""
Ensure Main page and tabs are accessible
"""
db = 'test_collegembakop'
add_database(db)
for fixture in ['fls_setup_data.yaml', 'school_setup.yaml', 'people.yaml']:
call_command('loaddata', fixture, database=db)
self.client.login(username='******', password='******')
kid_detail_url = reverse('foulassi:kid_detail', args=('collegembakop', '584f03a7bbd6b46a8fc0c244'))
response = self.client.get(kid_detail_url)
self.assertEqual(response.status_code, 200)
student = response.context['student']
self.assertEqual(student.id, '584f03a7bbd6b46a8fc0c244')
response = self.client.get(kid_detail_url, data={'tab': 'billing'})
self.assertEqual(response.status_code, 200)
