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)