def order_item_add_membership(self, school_memberships_id, startdate):
"""
:param school_memberships_id: db.school_memberships.id
:return : db.customers_orders_items.id of inserted item
"""
from os_school_membership import SchoolMembership
db = current.db
T = current.T
sme = SchoolMembership(school_memberships_id)
sme_tax_rates = sme.get_tax_rates_on_date(startdate)
coiID = db.customers_orders_items.insert(
customers_orders_id=self.coID,
school_memberships_id=school_memberships_id,
ProductName=T('membership'),
Description=sme.row.Name,
Quantity=1,
Price=sme.get_price_on_date(startdate, formatted=False),
tax_rates_id=sme_tax_rates.tax_rates.id,
accounting_glaccounts_id=sme.row.accounting_glaccounts_id,
accounting_costcenters_id=sme.row.accounting_costcenters_id,
)
self.set_amounts()
return coiID
def log_membership_terms_acceptance(self, school_memberships_id):
"""
:param school_memberships_id: db.school_memberships.id
:return: None
"""
from os_school_membership import SchoolMembership
from tools import OsTools
T = current.T
os_tools = OsTools()
sm = SchoolMembership(school_memberships_id)
terms = [
os_tools.get_sys_property('shop_memberships_terms')
or '', # general terms
sm.row.Terms or '' # membership specific terms
]
full_terms = '\n'.join(terms)
self.log_document_acceptance(
document_name=T("Membership terms"),
document_description=T(
"Terms for all memberships and membership specific terms"),
document_content=full_terms)
def customers_memberships_renew_expired(self, year, month):
"""
Checks if a subscription exceeds the expiration of a membership.
If so it creates a new membership and an invoice for it for the customer
"""
from general_helpers import get_last_day_month
from datetime import timedelta
from os_customer import Customer
from os_invoice import Invoice
from os_school_membership import SchoolMembership
T = current.T
db = current.db
DATE_FORMAT = current.DATE_FORMAT
year = int(year)
month = int(month)
firstdaythismonth = datetime.date(year, month, 1)
lastdaythismonth = get_last_day_month(firstdaythismonth)
firstdaynextmonth = lastdaythismonth + datetime.timedelta(days=1)
query = (db.customers_memberships.Enddate >= firstdaythismonth) & \
(db.customers_memberships.Enddate <= lastdaythismonth)
rows = db(query).select(
db.customers_memberships.ALL
)
renewed = 0
for row in rows:
new_cm_start = row.Enddate + datetime.timedelta(days=1)
# Check if a subscription will be active next month for customer
# if so, add another membership
customer = Customer(row.auth_customer_id)
# Check if a new membership hasn't ben added already
if customer.has_membership_on_date(new_cm_start):
continue
# Ok all good, continue
if customer.has_subscription_on_date(firstdaynextmonth, from_cache=False):
new_cm_start = row.Enddate + datetime.timedelta(days=1)
school_membership = SchoolMembership(row.school_memberships_id)
school_membership.sell_to_customer(
row.auth_customer_id,
new_cm_start,
note=T("Renewal for membership %s" % row.id),
invoice=True,
payment_methods_id=row.payment_methods_id
)
renewed += 1
# else:
#
# print 'no subscription'
# print renewed
##
# For scheduled tasks db connection has to be committed manually
##
db.commit()
return T("Memberships renewed") + ': ' + unicode(renewed)
def deliver(self,
class_online_booking=True,
class_booking_status='booked'):
"""
Create invoice for order and deliver goods
"""
from os_attendance_helper import AttendanceHelper
from os_cache_manager import OsCacheManager
from os_invoice import Invoice
from os_school_classcard import SchoolClasscard
from os_school_subscription import SchoolSubscription
from os_customer_subscription import CustomerSubscription
from os_school_membership import SchoolMembership
from os_customer_membership import CustomerMembership
from os_workshop import Workshop
from os_workshop_product import WorkshopProduct
cache_clear_classschedule_api = current.globalenv[
'cache_clear_classschedule_api']
get_sys_property = current.globalenv['get_sys_property']
TODAY_LOCAL = current.TODAY_LOCAL
ocm = OsCacheManager()
db = current.db
T = current.T
if self.order.Status == 'delivered':
return
create_invoice = False
iID = None
invoice = None
# Only create an invoice if order amount > 0
amounts = self.get_amounts()
sys_property_create_invoice = 'shop_donations_create_invoice'
create_invoice_for_donations = get_sys_property(
sys_property_create_invoice)
if create_invoice_for_donations == 'on':
create_invoice_for_donations = True
else:
create_invoice_for_donations = False
if amounts:
if amounts.TotalPriceVAT > 0:
if not self.order.Donation or (self.order.Donation and
create_invoice_for_donations):
create_invoice = True
# Create blank invoice
igpt = db.invoices_groups_product_types(ProductType='shop')
iID = db.invoices.insert(
invoices_groups_id=igpt.invoices_groups_id,
Description=T('Order #') + unicode(self.coID),
Status='sent')
# Link invoice to order
db.invoices_customers_orders.insert(
customers_orders_id=self.coID, invoices_id=iID)
# Call init function for invoices to set Invoice # , etc.
invoice = Invoice(iID)
invoice.link_to_customer(self.order.auth_customer_id)
# Add items to the invoice
rows = self.get_order_items_rows()
for row in rows:
##
# Only rows where school_classcards_id, workshops_products_id , classes_id or Donation are set
# are put on the invoice
##
# Check for product:
if row.ProductVariant:
if create_invoice:
invoice.item_add_product_variant(
product_name=row.ProductName,
description=row.Description,
quantity=row.Quantity,
price=row.Price,
tax_rates_id=row.tax_rates_id,
accounting_glaccounts_id=row.accounting_glaccounts_id,
accounting_costcenters_id=row.accounting_costcenters_id
)
# Check for classcard
if row.school_classcards_id:
# Deliver card
card_start = TODAY_LOCAL
scd = SchoolClasscard(row.school_classcards_id)
ccdID = scd.sell_to_customer(self.order.auth_customer_id,
card_start,
invoice=False)
# clear cache
ocm.clear_customers_classcards(self.order.auth_customer_id)
# Add card to invoice
if create_invoice:
invoice.item_add_classcard(ccdID)
# Check for subscription
if row.school_subscriptions_id:
## Deliver subscription
# Determine payment method
cs_payment_method = get_sys_property(
'shop_subscriptions_payment_method')
if cs_payment_method == 'mollie':
payment_method_id = 100
else:
payment_method_id = 3
subscription_start = TODAY_LOCAL
ssu = SchoolSubscription(row.school_subscriptions_id)
csID = ssu.sell_to_customer(
self.order.auth_customer_id,
subscription_start,
payment_methods_id=payment_method_id)
# Add credits for the first month
cs = CustomerSubscription(csID)
cs.add_credits_month(subscription_start.year,
subscription_start.month)
# clear cache
ocm.clear_customers_subscriptions(self.order.auth_customer_id)
if create_invoice:
# This will also add the registration fee if required.
iiID = invoice.item_add_subscription(
csID, TODAY_LOCAL.year, TODAY_LOCAL.month)
# Check for membership
if row.school_memberships_id:
# Deliver membership
membership_start = TODAY_LOCAL
sme = SchoolMembership(row.school_memberships_id)
cmID = sme.sell_to_customer(
self.order.auth_customer_id,
membership_start,
invoice=False, # Don't create a separate invoice
)
# clear cache
ocm.clear_customers_memberships(self.order.auth_customer_id)
if create_invoice:
cm = CustomerMembership(cmID)
# Check if price exists and > 0:
if sme.row.Price:
iiID = invoice.item_add_membership(cmID)
# Check for workshop
if row.workshops_products_id:
# Deliver workshop product
wsp = WorkshopProduct(row.workshops_products_id)
wspcID = wsp.sell_to_customer(self.order.auth_customer_id,
invoice=False)
# Add workshop product to invoice
if create_invoice:
invoice.item_add_workshop_product(wspcID)
# Check if sold out
if wsp.is_sold_out():
# Cancel all unpaid orders with a sold out product for this workshop
ws = Workshop(wsp.wsID)
ws.cancel_orders_with_sold_out_products()
# Check for classes
if row.classes_id:
# Deliver class
ah = AttendanceHelper()
if row.AttendanceType == 1:
result = ah.attendance_sign_in_trialclass(
self.order.auth_customer_id,
row.classes_id,
row.ClassDate,
online_booking=class_online_booking,
invoice=False,
booking_status=class_booking_status)
elif row.AttendanceType == 2:
result = ah.attendance_sign_in_dropin(
self.order.auth_customer_id,
row.classes_id,
row.ClassDate,
online_booking=class_online_booking,
invoice=False,
booking_status=class_booking_status,
)
if create_invoice:
invoice.item_add_class_from_order(row, result['caID'])
# Clear api cache to update available spaces
cache_clear_classschedule_api()
# Check for donation
if row.Donation:
# Add donation line to invoice
if create_invoice and create_invoice_for_donations:
invoice.item_add_donation(row.TotalPriceVAT,
row.Description)
# Check for custom item
if row.Custom:
# Add custom line to invoice
if create_invoice:
invoice.item_add_custom_from_order(row)
# Notify customer of new invoice
#if create_invoice:
#invoice.mail_customer_invoice_created()
# Update status
self.set_status_delivered()
# Notify customer of order delivery
self._deliver_mail_customer()
return dict(iID=iID, invoice=invoice)