def getPackageCount(request, action):
packageCount = []
if not action == "revoked":
try:
mm = marketing_member(request)
subscriber = mm.subscriber
imprt = ShippingPackage.objects.filter(
(Q(shipping_chain__subscriber=subscriber)
| Q(origin_warehouse__offered_by=subscriber)
| Q(destination_warehouse__offered_by=subscriber)),
Q(ordered=True), Q(is_estimate=False), Q(deleted=False))
except:
subscriber = request_subscriber(request)
imprt = ShippingPackage.objects.filter(
(Q(shipping_chain__subscriber=subscriber)
| Q(origin_warehouse__offered_by=subscriber)
| Q(destination_warehouse__offered_by=subscriber)),
Q(ordered=True), Q(is_estimate=False), Q(deleted=False))
# Sub_WHM = subscriber.get_warehouses()
# if Sub_WHM:
# imprt = ShippingPackage.objects.filter((Q(origin_warehouse__offered_by = subscriber) | Q(destination_warehouse__offered_by = subscriber)), Q(ordered = True), Q(is_estimate=False), Q(deleted=False))
# else:
# imprt = ShippingPackage.objects.filter(Q(shipping_chain__subscriber=subscriber), Q(ordered = True), Q(is_estimate=False), Q(deleted=False))
# export = ExportPackage.objects.filter(Q(user__useraccount__marketer = mm), Q(ordered = True), Q(is_estimate=False))
# export_packages = export.filter(status=action).count()
packageCount = imprt.filter(status=action).count()
else:
try:
mm = marketing_member(request)
subscriber = mm.subscriber
imprt = ShippingPackage.objects.filter(
(Q(shipping_chain__subscriber=subscriber)
| Q(origin_warehouse__offered_by=subscriber)
| Q(destination_warehouse__offered_by=subscriber)),
Q(ordered=True), Q(is_estimate=False), Q(deleted=True))
except:
subscriber = request_subscriber(request)
imprt = ShippingPackage.objects.filter(
(Q(shipping_chain__subscriber=subscriber)
| Q(origin_warehouse__offered_by=subscriber)
| Q(destination_warehouse__offered_by=subscriber)),
Q(ordered=True), Q(is_estimate=False), Q(deleted=True))
packageCount = imprt.count()
# packageCount = export_packages + import_packages
return packageCount
def emailtemplate(request):
try:
mm = marketing_member(request)
except:
mm = request.user.useraccount.marketer
emailtext = mm.email_text
return render(request, 'general_client/emaildemo.html', {'emailtext': emailtext})
def admin_access(request, user_obj):
# groups = Group.objects.all()
# groups.delete()
# useraccount = UserAccount.objects.filter(user__is_staff = True, marketer = mm)
# return render(request, 'sokohaliAdmin_snippet/access_table.html', {'useraccount': useraccount})
#print "rP: ",request.POST
user_action = request.POST.get('user_action')
user_action_stripped = str(request.POST.get('user_action')).replace(
'_', ' ')
content_type = ContentType.objects.get_for_model(User)
mm = marketing_member(request)
useraccount = UserAccount.objects.filter(user__is_staff=True, marketer=mm)
permission, created = Permission.objects.get_or_create(
codename=user_action,
name=user_action_stripped,
content_type=content_type)
user_obj = User.objects.get(id=user_obj)
if request.POST.get('action') == 'add':
group, created = Group.objects.get_or_create(name=user_action_stripped)
group.permissions.add(permission)
user_obj.groups.add(group)
else:
group = Group.objects.get(name=user_action_stripped)
user_obj.groups.remove(group)
#print "my groups: ", user_obj.groups.all()
return render(request, 'sokohaliadmin_snippet/access_table.html',
{'useraccount': useraccount})
def add_funds_volk_card(request):
template_name = 'volkmann/vei_wallet_card.html'
mm = marketing_member(request)
#print form.errors
return render(request, template_name, {'mm':mm})
def pay_with_paypal(request, obj, user, amount_to_pay_D):
useraccount = UserAccount.objects.get(user=user)
dollar_exchange_rate = obj.costcalc_instance.dollar_exchange_rate
amount_to_pay_N = amount_to_pay_D * float(dollar_exchange_rate)
obj.balance_D -= amount_to_pay_D
obj.balance_N -= amount_to_pay_N
obj.balance_paid_D += amount_to_pay_D
obj.balance_paid_N += amount_to_pay_N
if useraccount.country == "United States":
amount_N = amount_to_pay_D
else:
amount_N = amount_to_pay_N
ref_no = creditpurchase_ref(obj.id)
paypal_obj = MarketerPayment.objects.create(
user=request.user.useraccount,
payment_channel="PayPal",
created_at=datetime.now(),
message='Payment for package - %s' % (obj.tracking_number),
amount=amount_to_pay_D,
package=obj,
marketer=marketing_member(request),
status="Successful")
# paypal_obj = SokoPay.objects.create(user = user, amount = amount_to_pay_D, purchase_type_1 = 'PayPal',
# purchase_type_2 = 'Add', ref_no = ref_no, bank = 'PayPal', teller_no = obj.tracking_number,
# status = 'Successful', message = 'Applied to %s' %(obj.tracking_number))
paypal_obj.save()
obj.save()
return obj
def profile_volk(request, username):
try:
shipping_item = ShippingItem.objects.filter(user=request.user)
count_items = shipping_item.filter(ordered=False).count()
except:
count_items = 0
bvn_no = None
if request.user.is_staff:
username = username
else:
username = request.user
mm = marketing_member(request)
profile = get_object_or_404(UserAccount, user__username=username, marketer=mm)
if profile.bvn_no != "":
if profile.bvn_no[-1] == "=":
bvn_no = value_decryption(profile.bvn_no)
else:
bvn_no = None
# if profile.address_activation_completed:
# address_string = OperatingCountry.objects.get(country = "uk").delivery_address
# uk_shipping_address = address_string %(" Suite No %s, " %profile.suite_no)
#
# address_string = OperatingCountry.objects.get(country = "us").delivery_address
# us_shipping_address = address_string %("%s" %profile.suite_no)
#
# #delivery_addresses = [uk_shipping_address]
#
# delivery_addresses = [us_shipping_address, uk_shipping_address]
mm.storefront_name == "volkmannexpress"
return render(request, 'volkmann/profile_view.html', {'profile': profile, 'decrypt_bvn_no': bvn_no,
'count_items': count_items}) # 'delivery_addresses': delivery_addresses},
def custom_password_reset(
request,
template_name=None,
email_template_name='registration/password_reset_email.html',
subject_template_name='registration/password_reset_subject.txt',
password_reset_form=CustomPasswordResetForm,
token_generator=default_token_generator,
post_reset_redirect=None,
from_email=None,
extra_context=None,
html_email_template_name=None,
extra_email_context=None):
# warnings.warn("The password_reset() view is superseded by the "
# "class-based PasswordResetView().",
# RemovedInDjango21Warning, stacklevel=2)
marketer = marketing_member(request)
if post_reset_redirect is None:
post_reset_redirect = reverse('password_reset_done')
else:
post_reset_redirect = resolve_url(post_reset_redirect)
if request.method == "POST":
if marketer.storefront_name == "volkmannexpress":
template_name = 'registration/password_reset_form_volk.html'
else:
template_name = 'registration/password_reset_form.html'
kwargs = {
'marketer': marketer,
'subdomain_name': marketer.subdomain_name,
'storefront_name': marketer.storefront_name
}
form = password_reset_form(request.POST, **kwargs)
if form.is_valid():
opts = {
'use_https': request.is_secure(),
'token_generator': token_generator,
'from_email': from_email,
'email_template_name': email_template_name,
'subject_template_name': subject_template_name,
'request': request,
'html_email_template_name': html_email_template_name,
#'extra_email_context': extra_email_context,
}
form.save(**opts)
return HttpResponseRedirect(post_reset_redirect)
else:
form = password_reset_form()
context = {
'form': form,
'title': _('Password reset'),
}
if extra_context is not None:
context.update(extra_context)
if marketer.storefront_name == "volkmannexpress":
template_name = 'registration/password_reset_form_volk.html'
else:
template_name = 'registration/password_reset_form.html'
return TemplateResponse(request, template_name, context)
def staff_check(request):
if request.user.is_staff:
try:
return marketing_member(
request) == request.user.useraccount.marketer
except:
return True
return False
def getBatchCount(request, status):
try:
marketer = marketing_member(request)
subscriber = marketer.subscriber
except:
subscriber = request_subscriber(request)
return Batch.objects.filter(deleted=False,
subscriber=subscriber,
status=status).count()
def select_payment_option(request):
try:
local_pkg = request.session['local_pkg']
tracking_number = local_pkg.tracking_number
except:
tracking_number = request.GET.get('tracking_number')
mm = marketing_member(request)
print "mm:", mm
#print 'tracking_number: ',tracking_number
return render(request, "soko_pay/select_payment_option.html", {'tracking_number': tracking_number, 'mm': mm})
def pay_for_shipments(request):
context = {}
try:
mm = marketing_member(request)
context['mm'] = mm
except:
count_items = 0
shipments = ShippingPackage.objects.filter(user = request.user, deleted=False)
context['shipments'] = shipments
return render(request,'volkmann/payforshipments.html',context)
def getMessages(request, status):
mm = marketing_member(request)
messageObject = MessageCenter.objects.filter(
user__useraccount__marketer=mm)
if status == "New":
message_count = messageObject.filter(new=True)
elif status == "replied":
message_count = messageObject.filter(replied=True)
else:
message_count = messageObject.filter(archive=True)
return message_count.count()
def get_unprocessed_packages(request):
mm = marketing_member(request)
try:
mm = marketing_member(request)
subscriber = mm.subscriber
unprocessed_packages_count = ShippingPackage.objects.filter(
(Q(shipping_chain__subscriber=subscriber)
| Q(origin_warehouse__offered_by=subscriber)
| Q(destination_warehouse__offered_by=subscriber)),
Q(ordered=True), Q(is_estimate=False),
Q(prepared_for_shipping=False)).count()
except:
subscriber = request_subscriber(request)
unprocessed_packages_count = ShippingPackage.objects.filter(
(Q(shipping_chain__subscriber=subscriber)
| Q(origin_warehouse__offered_by=subscriber)
| Q(destination_warehouse__offered_by=subscriber)),
Q(ordered=True), Q(is_estimate=False),
Q(prepared_for_shipping=False)).count()
return unprocessed_packages_count
def notificationCount(request, action):
mm = marketing_member(request)
counter = 0
# useraccounts = get_marketing_member_users(request)
if action == "All":
counter = ShippingItem.objects.filter(~Q(tag="Shopping"),
user__useraccount__marketer=mm)
elif action == "Received":
counter = ShippingItem.objects.filter(~Q(tag="Shopping"),
user__useraccount__marketer=mm,
status="Received")
return counter.count()
def get_active_batches(request):
try:
marketer = marketing_member(request)
subscriber = marketer.subscriber
except:
subscriber = request_subscriber(request)
# print "the subscriber: ",subscriber
# print "marketer: ",marketer
new_batch_count = Batch.objects.filter(deleted=False,
subscriber=subscriber,
status="New")
return new_batch_count.count()
def edit_profile_volk(request, username=None):
# try:
# user = User.objects.get(username = username)
# except User.DoesNotExist:
# raise Http404
try:
shipping_item = ShippingItem.objects.filter(user=request.user)
count_items = shipping_item.filter(ordered=False).count()
except:
count_items = 0
mm = marketing_member(request)
if request.user.is_authenticated():
if username == "None":
mm.storefront_name == "volkmannexpress"
return redirect("/volk/login/?next=" + reverse("general:edit_profile_volk", args=[None]))
username = request.user
# user = get_object_or_404(User, username = username)
user = get_marketing_member_user(request, username)
if request.method == "POST":
form = EditProfileForm()
form = EditProfileForm(request.POST, request.FILES, instance=user.useraccount)
if form.is_valid():
# address_book = AddressBook.objects.filter(user = request.user)
# for a in address_book:
# b = AddressBook(title = form.cleaned_data['title'],telephone = form.cleaned_data['telephone'],\
# address = form.cleaned_data['address'],city = form.cleaned_data['city'], postal_code = form.cleaned_data['postal_code'], state = form.cleaned_data['state'],\
# country = form.cleaned_data['country'])
# b.save()
form.save()
# update first and last name of the user
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.save()
# if form.cleaned_data['country']:
# address = AddressBook.objects.filter(user = request.user)[:0]
return redirect(reverse("general:profile", args=[username]))
# print form.errors
else:
form = EditProfileForm(instance=user.useraccount)
mm.storefront_name == "volkmannexpress"
return render(request, 'volkmann/profile.html',
{'form': form, 'user_details': user, 'count_items': count_items})
# return render(request, 'user_profile/edit_profile.html', {'form': form, 'user_details': user},
else:
mm.storefront_name == "volkmannexpress"
return redirect("/volk/login/?next=" + reverse("general:edit_profile_volk", args=[None]))
def edit_emailtemplate(request):
try:
mm = marketing_member(request)
except:
mm = request.user.useraccount.marketer
if request.user.is_authenticated():
if request.method == "POST":
form = EmailTextForm(request.POST, instance = mm)
if form.is_valid():
form.save()
return redirect(reverse('service_provider:emailtemplate_setup'))
else:
print form.errors
else:
form = EmailTextForm(instance=mm)
return render (request, 'sokohaliAdmin/emailform.html', {'form':form})
def editFAQ(request):
try:
mm = marketing_member(request)
except:
mm = request.user.useraccount.marketer
if request.user.is_authenticated():
if request.method == "POST":
form = FAQForm(request.POST, instance = mm)
if form.is_valid():
form.save()
return redirect(reverse('general:faq'))
else:
print form.errors
else:
form = FAQForm(instance=mm)
return render (request, 'sokohaliAdmin/faqform.html', {'form':form})
def calculate_last_mile_charges(request, pkg, origin, destination, direction):
mm = marketing_member(request)
print 'origin -- destination:', origin, destination
if origin == 'United States':
lb_country = destination
elif request.session.has_key('lb_country'):
lb_country = request.session.get('lb_country')
else:
lb_country = origin
costcalc = marketingmember_costcalc(request, lb_country)
WHaddress = request.session.get('WHaddress')
print "wha2:", WHaddress
Location = WarehouseLocation.objects.get(id=WHaddress)
print "la:", Location
distributor = mm.get_route_shipping_distributor(origin, destination,
direction)
print 'calculate_last_mile_charges | distributor: ', distributor
if distributor == None:
pick_up_charge_D = pick_up_charge_N = 0.0
return pick_up_charge_D, pick_up_charge_N
elif distributor.has_api:
print "its here"
destZipCode = Location.zip_code
print "DZC:", destZipCode
pick_up_charge_D = get_pickup_charge(request, pkg, "usps", destZipCode)
print "pick_up_charge_D: ", pick_up_charge_D
print type(pick_up_charge_D)
if type(pick_up_charge_D) != str or type(pick_up_charge_D) != int:
pick_up_charge_D = 0.0
else:
pass
pick_up_charge_N = float(pick_up_charge_D) * float(
costcalc.dollar_exchange_rate)
# del request.session['WHaddress']
return pick_up_charge_D, pick_up_charge_N
else:
#return get_local_freight_from_state(request, pkg.box_weight_higher(), distributor.id)
# print "pkg: ",pkg
# print "got here"
print "state of origin:", pkg.delivery_address.state
# print "weight:",pkg.box_weight_higher()
return get_local_freight_from_state_hd(request,
pkg.box_weight_higher(),
pkg.delivery_address.state,
destination)
def add_funds_volk(request):
template_name = 'volkmann/vei_wallet.html'
mm = marketing_member(request)
ref_no = creditpurchase_ref(request)
todaysdate = datetime.now()
form = MarketerPaymentForm()
print request.POST
if request.method == 'POST':
form = MarketerPaymentForm(request.POST)
if form.is_valid():
marketer_form = form.save(commit=False)
marketer_form.purchase_type_3 = "veiwallet"
marketer_form.user = request.user.useraccount
marketer_form.message = "Funding veiwallet"
marketer_form.marketer = mm
marketer_form.save()
# print form
print "here"
# success = buy_jejepay_credit_deposit_general(form)
# if (success):
username = request.user.username # UserAccount.objects.get(user = request.user).username
# return redirect (reverse ('userAccount.views.user_jeje_pay_info', args=[username]))
messages.info(request, "Your vei wallet add credit was successful. Our Finance department will approve it shortly after confirmation. Thank you.")
return redirect (reverse ('soko_pay:user_transactions'))
# return redirect (reverse ('userAccount:user_jeje_pay_info', args=[username]))
# print form.errors
# else:
# error_alert = 'Amount Entered must be greater than 0.'
# return render(request, "soko_pay/add_funds.html",
# {'error_alert': error_alert, 'form': form, 'ref_no': ref_no,
# 'todaysdate': todaysdate, 'user': request.user})
else:
print form.errors
print form
error_alert = 'Please correct the highlighted field(s).'
return render(request, template_name,
{'error_alert': error_alert, 'form': form, 'ref_no': ref_no,
'todaysdate': todaysdate, 'user': request.user,'mm':mm})
#print form.errors
return render(request, template_name,
{'form': form, 'ref_no': ref_no, 'todaysdate': todaysdate, 'user': request.user,'mm':mm})
def editTermsConditions(request):
try:
mm = marketing_member(request)
except:
mm = request.user.useraccount.marketer
print "i reach o"
form = EditMarketingMemberForm(instance=mm)
if request.user.is_authenticated():
if request.method == "POST":
print request.POST
#form = EditMarketingMemberForm()
form = EditMarketingMemberForm(request.POST, instance=mm)
if form.is_valid():
form.save()
print "i reach 2 o"
return redirect(reverse('general:legal'))
else:
print form.errors
else:
form = EditMarketingMemberForm(instance=mm)
return render (request, 'sokohaliAdmin/legalform.html', {'form': form})
def custom_password_reset_done(request,
template_name=None,
current_app=None,
extra_context=None):
context = {
'title': _('Password reset sent'),
}
marketer = marketing_member(request)
if marketer.storefront_name == "volkmannexpress":
template_name = 'registration/password_reset_done_volk.html'
else:
template_name = 'registration/password_reset_done.html'
if extra_context is not None:
context.update(extra_context)
if current_app is not None:
request.current_app = current_app
return TemplateResponse(request, template_name, context)
def update_payment_record_for_packages(request, packages, jejepay_ref=None):
print 'applying payment'
if jejepay_ref == None:
jejepay_ref = request.GET.get('jejepay_ref')
print 'jejepay_ref: ', jejepay_ref
#jejepay = SokoPay.objects.get(ref_no = jejepay_ref)
#status = (jejepay.status).lower()
#jejepay = MarketerPayment.objects.get(ref_no = jejepay_ref)
#status = (jejepay.status).lower()
mm = marketing_member(request)
status = request.session['status'].lower()
#tranx_id = request.session['tranx_id']
tranx_id = jejepay_ref
print 'status: ', status
if 'approved' in status or 'success' in status:
#import_shipment.save()
print 'packages 2nd: ', packages
for pkg in packages:
print 'pkg.admin_total_payable_D: ', pkg.admin_total_payable_D
pkg.balance_paid_D = pkg.user_total_payable_D
pkg.balance_paid_N = pkg.user_total_payable_N
pkg.user_total_payable_D = pkg.admin_total_payable_D = pkg.balance_D = 0
pkg.user_total_payable_N = pkg.admin_total_payable_N = pkg.balance_N = 0
#apply_shipping_credit(request, pkg)
pkg.save()
payment = MarketerPayment.objects.create(
user=request.user.useraccount,
payment_channel='Card Payment',
created_at=datetime.now(),
ref_no=jejepay_ref,
amount=pkg.balance_paid_D,
package=pkg,
marketer=mm,
status="Successful",
payment_gateway_tranx_id=tranx_id)
payment.save()
def pay_balance(request):
#username = request.user
user = request.user
mm = marketing_member(request)
context_dict = {}
'''check if POST is not coming from PayStack or PayPal'''
#if not request.GET.has_key('trxref') or request.GET.has_key("tx"):
#keep user selected options in memory
#print 'keeping request.GET for paystack/paypal'
if request.method == "GET" and not request.GET.has_key('resp'):
request.session['requestGET'] = request.GET
requestGET = request.session['requestGET']
tracking_number = requestGET.get('tracking_number')
pay_method = requestGET.get('pay_method')
print 'pay_method - tracking_number ',pay_method, tracking_number
pkg = get_pkg(user, tracking_number)
if request.GET.has_key('resp'):
print "I got back from flutterwave"
pay_response = str(request.GET.get('resp'))
#pay_response = ast.literal_eval(request.GET.get('resp'))
jejepay_ref = request.GET.get('jejepay_ref')
#jejepay_ref = pay_response['merchtransactionreference']
pay_response_msg = pay_response
#pay_response_msg = pay_response['responsemessage']
request.session['status'] = pay_response_msg
print pay_response_msg
if pay_response_msg != "success":
#if pay_response_msg != "Approved": #or pay_response_msg != "Success":
#messages.error(request, pay_response_msg)
print "Am going home"
tranx_id = jejepay_ref
#tranx_id = pay_response['merchtransactionreference']
request.session['tranx_id'] = tranx_id
# for pkg in packages:
# print "PKG:",pkg.tracking_number
payment = MarketerPayment.objects.create(user=request.user.useraccount,payment_channel='Card Payment',created_at=datetime.now(),ref_no=jejepay_ref,
amount=pkg.user_total_payable_D,package=pkg,marketer=mm,status=pay_response_msg,payment_gateway_tranx_id =tranx_id)
payment.save()
messages.error(request, "Your Payment is "+ pay_response_msg)
else:
print "flutter"
packages = ShippingPackage.objects.filter(tracking_number=tracking_number)
update_payment_record_for_packages(request, packages, jejepay_ref)
messages.success(request, "Your Payment is Successful")
return redirect (reverse('general:my_shipments'))
if request.method == "POST" or (request.GET.has_key("tx") and request.GET.has_key("st")):
print 'i am coming from paypal'
if pay_method == "Card":
amount_paid_D = pkg.balance_D
amount_paid_N = pkg.balance_N
msg_info = "You have successfully paid $%s for package %s" %(str(amount_paid_D), tracking_number)
dest_namespace_2 = 'soko_pay:pay_balance'
#dest_namespace_2 = 'soko_pay:pay_balance'
#return call_initiate_payment(request, amount_paid_N, dest_namespace)
lb_country = "Nigeria"
dest_namespace = 'soko_pay:pay_balance'
kwargs_dict = {'actual_amount_D': amount_paid_D, 'dest_namespace_1': None, 'lb_country':lb_country,
'dest_namespace_2': dest_namespace_2, 'txn_desc': 'Pay for package balance'}
return payment_helpers.card_payment(request, **kwargs_dict)
#response_dict = payment_helpers.card_payment(request, **kwargs_dict)
# print "Respo:", response_dict.content
# print type(response_dict)
# #pay_response = response_dict.content
# try:
# pay_response = ast.literal_eval(response_dict.content)
# #print 'pay_response: ',pay_response
# pay_response_msg = pay_response['response_msg']
# if 'success' in pay_response_msg.lower():
# payment_helpers.apply_shipping_credit(reuest, pkg)
# return response_dict
# except Exception as e:
# print "inner e:", e
# return response_dict
if pay_method == "SokoPay":
print "see me for sokopay"
amount_to_pay_D = pkg.balance_D
# amount_to_pay_N = abs(float(remove_from_string(request.POST.get('amount'), ',')))
#
# if amount_to_pay_N > pkg.balance_N:
# messages.error(request, "The specified amount is greater than package balance. It should be less.")
# return redirect(reverse('general:my_shipments'))
payment_helpers.apply_shipping_credit(request, pkg, pkg.user, amount_to_pay_D)
payment_helpers.marketer_payment(request, "SokoPay", "Paid",amount_to_pay_D,pkg,mm,"Approved")
msg_info = "Payment successfully applied to %s" %pkg.tracking_number
messages.success(request, msg_info)
return redirect(reverse('general:my_shipments'))
if pay_method == "PP":
print "see me for paypal"
amount_to_pay_D = pkg.balance_D
# amount_to_pay_N = abs(float(remove_from_string(request.POST.get('amount'), ',')))
#
# if amount_to_pay_N > pkg.balance_N:
# messages.error(request, "The specified amount is greater than package balance. It should be less.")
# return redirect(reverse('general:my_shipments'))
payment_helpers.pay_with_paypal(request, pkg, pkg.user, amount_to_pay_D)
msg_info = "Payment successfully applied to %s" %pkg.tracking_number
messages.success(request, msg_info)
return redirect(reverse('general:my_shipments'))
else:
# '''Verify PayStack payment status and apply'''
# if pay_method == "Card" and request.GET.has_key('trxref') and request.GET.has_key('jejepay_ref'):
# pkgs = [pkg]
# update_payment_record_for_packages(request, pkgs)
# messages.success(request, msg_info)
# return redirect(reverse('general:my_shipments'))
user_credit_amount_N, user_credit_amount_D = account_standing(request, user)
obj = get_pkg(user, tracking_number)
if pay_method == 'PP' and not (request.GET.has_key("tx") and request.GET.has_key("st")):
print 'i wanna go pay at paypal'
request.session['tracking_number'] = tracking_number
request.session['pay_method'] = pay_method
return_url = 'http://127.0.0.1:8000/confirm_paypal_payment/'
receiver_mail = '*****@*****.**'
markedup_amount = round(pkg.balance_D * (102.9/100), 2) #amount + 2.9% charge
kwargs = {'actual_amount': pkg.balance_D, 'markedup_amount': markedup_amount, 'site_redirect_url': return_url, 'receiver_mail': receiver_mail, 'PayPal':'PayPal','pay_balance':'pay_balnace'}
return initialize_paypal_payment(request, **kwargs)
elif pay_method == 'Card' and not (request.GET.has_key('resp')):
template_name = "soko_pay/pay-with-card.html"
txn_ref = creditpurchase_ref()
context_dict.update({'txn_ref': txn_ref,
'months_list': flutterwave_helpers.months_list(),
'years_list': flutterwave_helpers.years_list()})
elif pay_method == 'SokoPay':
#if user_credit_amount_D >= obj.balance_D:
if user_credit_amount_D >= obj.balance_D:
template_name = "soko_pay/pay-with-sokopay-credit.html"
context_dict.update({'user_credit_amount_D': user_credit_amount_D})
else:
# balance_D = obj.balance_D - user_credit_amount_D
messages.error(request, "Your SokoPay balance of ${} is insufficient to pay for this package.".format(round(user_credit_amount_D, 2)))
# messages.error(request, "You need to top up your wallet with atleast ${} through Buy Credit or use other payment methods.".format(round(balance_D, 2)))
return redirect(reverse('general:my_shipments'))
context_dict.update({'obj': obj, 'pay_method': pay_method})
return render(request, template_name, context_dict)
def apply_shipping_credit(request, obj, user=None, amount_to_pay_D=None):
if user == None:
shipping_credit_N, shipping_credit_D = account_standing(
request, request.user)
user = request.user
else:
shipping_credit_N, shipping_credit_D = account_standing(request, user)
useraccount = UserAccount.objects.get(user=user)
#convert shipping_credit_D using exchange_rate of obj
#exchange_rate = country_exchange_rate(obj.country, costcalc_settings())
#dollar_exchange_rate = marketingmember_costcalc(request).dollar_exchange_rate
dollar_exchange_rate = obj.costcalc_instance.dollar_exchange_rate
if not useraccount.country == "United States":
shipping_credit_D = float(shipping_credit_N) / dollar_exchange_rate
prev_balance_N = obj.balance_N
else:
shipping_credit_N = float(shipping_credit_D) * dollar_exchange_rate
prev_balance_N = obj.balance_D
#shipping
#if hasattr(obj, 'user_total_payable_N'):
#prev_balance_N = obj.balance_N
shipping_cost_D = obj.admin_total_payable_D
shipping_cost_N = obj.admin_total_payable_N
if amount_to_pay_D == None:
if shipping_credit_N >= shipping_cost_N:
obj.balance_D = 0
obj.balance_N = 0
obj.balance_paid_D = shipping_cost_D
obj.balance_paid_N = shipping_cost_N
#Amount applied
if useraccount.country == "United States":
amount_N = shipping_cost_D
else:
amount_N = shipping_cost_N
# else:
# if shipping_credit_N > 0:
# obj.balance_D = shipping_cost_D - shipping_credit_D
# obj.balance_N = shipping_cost_N - shipping_credit_N
# obj.balance_paid_D = shipping_credit_D
# obj.balance_paid_N = shipping_credit_N
#
# #Amount applied
# amount_N = shipping_credit_N
else:
amount_to_pay_N = amount_to_pay_D * float(dollar_exchange_rate)
obj.balance_D -= amount_to_pay_D
obj.balance_N -= amount_to_pay_N
obj.balance_paid_D += amount_to_pay_D
obj.balance_paid_N += amount_to_pay_N
if useraccount.country == "United States":
amount_N = amount_to_pay_D
else:
amount_N = amount_to_pay_N
#amount_N = amount_to_pay_N
#obj.apply_shipping_credit = True
if useraccount.country == "United States":
new_balance_N = obj.balance_D
else:
new_balance_N = obj.balance_N
ref_no = creditpurchase_ref(obj.id)
mm = marketing_member(request)
use_shipping_credit(request, amount_N, ref_no, prev_balance_N,
new_balance_N, obj, user)
marketer_payment(request, "SokoPay", "Paid", shipping_cost_D, obj, mm,
"Approved")
obj.save()
return obj
def is_bvn_used(request, bvn):
encrypted_val = value_encryption(bvn)
mm = marketing_member(request)
return UserAccount.objects.filter(marketer=mm, bvn_no=encrypted_val).exists()
def getReceivedItems(request):
mm = marketing_member(request)
return NotifyUser.objects.filter(user__useraccount__marketer=mm).count()
def mobile_packages_process(request):
# print request.POST
rp = request.POST
tracking_number = str(rp.get('tracking_number'))
quantity = 1
post = get_object_or_404(ShippingPackage, tracking_number=tracking_number)
try:
mm = UserAccount.objects.get(
user__username__iexact=rp.get('email')).marketer
except:
mm = UserAccount.objects.get(
user__email__iexact=rp.get('email')).marketer
# print "marketer: ", mm
request.session['package'] = post
# print model_to_dict(post)
previous = {
"height": post.box_height,
"length": post.box_length,
"width": post.box_width,
"weight": post.box_weight,
"weight_k": post.box_weight_K,
"insurance": post.insure,
"Shipping-method": post.shipping_method
}
# print "previous:", previous
costcalc = post.costcalc_instance
weightFactor = costcalc.dim_weight_factor
# print "weight_factor: ",weightFactor
lb_kg_factor = costcalc.lb_kg_factor
kg_lb_factor = costcalc.kg_lb_factor
exchange_rate = costcalc.dollar_exchange_rate
costcalc = post.costcalc_instance
weightFactor = costcalc.dim_weight_factor
lb_kg_factor = costcalc.lb_kg_factor
kg_lb_factor = costcalc.kg_lb_factor
exchange_rate = costcalc.dollar_exchange_rate
# for field,value in post._meta.get_all_field_names():
# print field
weight_unit = str(rp.get("unit"))
# post_values = model_to_dict(post)
new_tracking_number = post.tracking_number[15:].split('-')
ship_origin = new_tracking_number[0]
ship_destination = new_tracking_number[1]
shipping_origin = country = get_counntry_from_short_code(ship_origin)
# print 'shipping_origin:',shipping_origin
shipping_destination = get_counntry_from_short_code(ship_destination)
# print "shipping_destination:",shipping_destination
check_exp_sea_or_air_freight = str(post.shipping_method)
check_home_or_ofice = str(post.delivery_method)
# print "Exp_Air_Sea - Home_Office: ",check_exp_sea_or_air_freight,check_home_or_ofice
if check_exp_sea_or_air_freight == "Air Freight" and post.delivery_method == "Home delivery":
request.session['dvm'] = "AF - HD"
elif check_exp_sea_or_air_freight == "Air Freight" and post.delivery_method == "Office pickup":
request.session['dvm'] = "AF - OP"
elif check_exp_sea_or_air_freight == "Sea Freight" and post.delivery_method == "Office pickup":
request.session['dvm'] = "SF - OP"
elif check_exp_sea_or_air_freight == "Sea Freight" and post.delivery_method == "Home delivery":
request.session['dvm'] = "SF - HD"
elif check_exp_sea_or_air_freight == "Express" and post.delivery_method == "Home delivery":
request.session['dvm'] = "EX - HD"
elif check_exp_sea_or_air_freight == "Express" and post.delivery_method == "Office pickup":
request.session['dvm'] = "EX - OP"
request.session['handling_option'] = post.handling_option
freight_VAT_SC_D = PSDG_D = VAT_D = coverage_amount_D = 0
pick_up_charge_D = pick_up_charge_N = 0.0
if request.method == "POST":
form = ShippingPackageForm(request.POST, request.FILES, instance=post)
if form.is_valid():
post = form.save(commit=False)
post.box_length = float(str(rp.get('lenght')))
post.box_width = float(str(rp.get('width')))
post.box_height = float(str(rp.get('height')))
post.box_weight = float(str(rp.get('weight')))
# post.pkg_image = truncateCharacters(str(rp.get('contact_image_1')))
imageURL = rp.get('id_file', '')
# x= imageURL[23:]
image_data = b64decode(imageURL)
photo_code = ''
characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890'
photo_code_length = 20
for x in range(photo_code_length):
photo_code += characters[random.randint(
0,
len(characters) - 1)]
photo_name = photo_code + '.jpeg'
photo = ContentFile(image_data, photo_name)
post.pkg_image = photo
# print "photo", photo
if weight_unit == "lbs":
post.box_weight_Dim = quantity * (
post.box_length * post.box_width *
post.box_height) / weightFactor
post.box_weight_Dim_K = post.box_weight_Dim * lb_kg_factor
# print "lbs wgt_d - wgt_k: ",post.box_weight_Dim,post.box_weight_Dim_K
post.box_weight_K = post.box_weight * lb_kg_factor
post.box_weight_Actual = post.box_weight * quantity
post.box_weight_Actual_K = post.box_weight * lb_kg_factor * quantity
post.shipping_method = check_exp_sea_or_air_freight
else:
post.box_weight_Dim = quantity * (
post.box_length * post.box_width *
post.box_height) / weightFactor
post.box_weight_Dim_K = post.box_weight_Dim * lb_kg_factor
# print "kgs wgt_d - wgt_k: ",post.box_weight_Dim,post.box_weight_Dim_K
post.box_weight_K = post.box_weight * lb_kg_factor
post.box_weight_Actual = post.box_weight * 2.20462 * quantity
post.box_weight_Actual_K = post.box_weight * lb_kg_factor * quantity
try:
user = User.objects.get(username=rp.get('email'))
except:
user = User.objects.get(email=rp.get('email'))
post.updated_by = user.username
post.updated_on = timezone.now()
# post.delivery_method = request.POST.get('pkg_delivery_method')
post.approved = True
post.prepared_for_shipping = True
post.status = "Prepared for shipping"
linked_items = post.item_packages()
cart_value = linked_items.aggregate(
value=Sum('total_value'))['value']
item_count = linked_items.count()
new_post = []
new_post.append(post)
shipping_weight = post.box_weight_higher()
# region = location.region
# local_freight_cost_D, local_freight_cost_N = region_local_freight_costs(request,region, shipping_weight)
local_freight_cost_D = post.local_freight_D
# print "local_freight_cost_N , local_freight_cost_D:",local_freight_cost_D
delivery_intl_freight_D, delivery_local_freight_D, delivery_total_freight_D = get_freight_costs(
request, new_post, shipping_origin[0], shipping_destination[0],
costcalc)
total_freight_D = delivery_intl_freight_D + local_freight_cost_D
# print "total_freight_D = delivery_intl_freight_D + local_freight_cost_D :",delivery_intl_freight_D + local_freight_cost_D
# print "shipping_weight: ", post.box_weight_higher()
pkg_info = {
'pkg_count': post.box_quantity,
'item_count': item_count,
'shippingWeight': shipping_weight,
'cart_value': cart_value,
'total_freight_D': delivery_total_freight_D
}
total_freight_D_val, VAT_D_val, totalServiceCharge_D_val, \
CON_D_val, PSDG_D_val, SMP_D_val, freight_VAT_SC_D_val, coverage_amount_D_val, exchange_rate = CreateShipmentCostCalc(request, pkg_info, country, post.costcalc_instance)
freight_VAT_SC_D += freight_VAT_SC_D_val
PSDG_D += PSDG_D_val
VAT_D += VAT_D_val
coverage_amount_D += coverage_amount_D_val
post.insurance_fee_D = PSDG_D_val
post.insurance_fee_N = PSDG_D_val * exchange_rate
post.VAT_charge_D = VAT_D_val
post.VAT_charge_N = VAT_D_val * exchange_rate
post.service_charge_D = totalServiceCharge_D_val
post.service_charge_N = totalServiceCharge_D_val * exchange_rate
if post.discount_percentage:
post.admin_total_payable_D = post.user_total_payable_D = local_freight_cost_D + freight_VAT_SC_D_val + PSDG_D_val
post.admin_total_payable_N = post.user_total_payable_N = (
local_freight_cost_D + freight_VAT_SC_D_val +
PSDG_D_val) * exchange_rate
post.discount_D = (post.discount_percentage *
post.admin_total_payable_D) / 100
post.discount_N = (post.discount_percentage *
post.admin_total_payable_N) / 100
else:
post.admin_total_payable_D = post.user_total_payable_D = local_freight_cost_D + freight_VAT_SC_D_val + PSDG_D_val
post.admin_total_payable_N = post.user_total_payable_N = (
local_freight_cost_D + freight_VAT_SC_D_val +
PSDG_D_val) * exchange_rate
post.coverage_amount_D = coverage_amount_D_val
post.coverage_amount_N = coverage_amount_D_val * exchange_rate
# post.pick_up_charge_D = pick_up_charge_D
# post.pick_up_charge_N = pick_up_charge_N
if not post.balance_paid_D > post.admin_total_payable_D:
if post.discount_percentage:
post.balance_D = (post.user_total_payable_D -
post.balance_paid_D) - post.discount_D
post.balance_N = (post.user_total_payable_N -
post.balance_paid_N) - post.discount_N
else:
post.balance_D = (post.user_total_payable_D -
post.balance_paid_D)
post.balance_N = (post.user_total_payable_N -
post.balance_paid_N)
else:
user = UserAccount.objects.get(user=post.user)
user_country = user.country
#print "balance_D", post.balance_D
#print "balance_paid_D", post.balance_paid_D
if user_country == "United States" or user_country == "USA":
amount = post.balance_paid_D - post.admin_total_payable_D
else:
amount = post.balance_paid_N - post.admin_total_payable_N
#print "amount", amount
post.balance_paid_D = post.admin_total_payable_D
post.balance_paid_N = post.admin_total_payable_N
post.balance_D = post.balance_N = 0.00
jejepay_obj = SokoPay.objects.create(
user=post.user,
purchase_type_1="Refund",
purchase_type_2="Add",
status="Approved",
ref_no=creditpurchase_ref(request),
amount=amount,
bank="Admin",
message="Excess amount added to customer Vei wallet")
#print "jeje", jejepay_obj
# post.balance_D = 0.00
# post.balance_N = 0.00
post.intl_freight_D = delivery_intl_freight_D
post.intl_freight_N = delivery_intl_freight_D * exchange_rate
post.local_freight_D = local_freight_cost_D
post.local_freight_N = local_freight_cost_D * exchange_rate
post.save()
for item in linked_items:
item.status = "Received"
item.save()
edit = {
"height": post.box_height,
"length": post.box_length,
"width": post.box_width,
"weight": post.box_weight,
"weight_k": post.box_weight_K,
"insurance": post.insure,
"Shipping-method": post.shipping_method
}
pkg_model = "ShippingPackage"
# print "edit:", edit
status = post.status
action = "This package was prepared for shipping"
#pkg_status_list(post.pk,pkg_model,request.user,status)
shipment_history(user, post.pk, pkg_model, status, action)
# del request.session['pkg_location_id']
try:
del request.session['dvm']
except:
pass
if post.user.useraccount.marketer.storefront_name == "volkmannexpress":
marketer = marketing_member(request)
print "the marketer is %s" % (marketer)
user_client = UserAccount.objects.get(user=post.user)
payment_channel = 'Bank Deposit'
message = 'Being Payment for package balance'
amount = post.admin_total_payable_D
ref_no = generate_creditpurchase_ref()
bank = None
teller_no = None
local_package = None
payment = MarketerPayment.objects.create(
user=user_client,
payment_channel=payment_channel,
created_at=datetime.now(),
message=message,
amount=amount,
package=post,
ref_no=ref_no,
marketer=marketer,
bank=bank,
teller_no=teller_no,
local_package=local_package)
payment.save()
del request.session['handling_option']
del request.session['package']
try:
#user = User.objects.get(email=post.user.email)
user = get_marketing_member_user(request, post.user.username)
pkg = post
subject = "%s Package-%s Invoice" % (
mm.storefront_name.title(), pkg.tracking_number)
# sokohali_sendmail(request, user, subject, "email/package_invoice_email_template.html", pkg)
print 'email was sent to', user
except Exception as e:
print "email not sent because: %s" % (str(e))
pass
return JsonResponse({"success": 1, "error": 0})
else:
print form.errors
return JsonResponse({"success": 0, "error": 1})
else:
return JsonResponse({"success": 0, "error": 1})
return JsonResponse({"success": 0, "error": 1})
def editTermsConditions(request):
mm = marketing_member(request)
form = EditMarketingMemberForm(instance=mm)
return form
def get_new_messages_count(request):
mm = marketing_member(request)
message_object = MessageCenter.objects.filter(
user__useraccount__marketer=mm, new=True).count()
return message_object
