def create_order():
data = request.json
if data is None:
abort(400, description=gettext('invalid json request'))
validate_amounts_fields_in_orders(data)
order = Order(**data)
order.generate_order_no()
order.save_and_flush()
customer = Customer.find(order.customer_id)
customer.status = 'ordered'
Appointment.cancel_all_for_sales_customer(
order.sales_id, order.customer_id,
'Order: ' + str(order.id) + ' is created')
Reception.complete_all_for_sales_customer(
order.sales_id, order.customer_id,
'Order: ' + str(order.id) + ' is created')
return Order.find(order.id), 201, add_location_header(
dict(), url_for('api.get_order', uid=order.id))
def reassign(self, new_sales_id):
from application.models.appointment import Appointment
if not new_sales_id or self.sales_id == new_sales_id:
return
Appointment.cancel_all_for_sales_customer(self.sales_id, self.id, u'重新分配客户')
self.reassigned = True
self.sales_id = new_sales_id
def defeated(self, reason=''):
self.status = 'defeated'
self.intent_level = '-100'
self.defeated_reason = reason
# cancel all active appointments and receptions
from application.models.appointment import Appointment
from application.models.reception import Reception
Appointment.cancel_all_for_sales_customer(self.sales_id, self.id, self.status + ': ' + reason)
Reception.complete_all_for_sales_customer(self.sales_id, self.id, self.status + ': ' + reason)
def cancel_customer(cid):
replaced_by_customer_id = request.json.get('by_customer_id')
customer = get_customer(cid)
customer.status = 'cancelled'
customer.save_and_flush()
replaced_by_customer = get_customer(replaced_by_customer_id)
Appointment.reset_customer_id(customer, replaced_by_customer)
Reception.reset_customer_id(customer, replaced_by_customer)
Order.reset_customer_id(customer, replaced_by_customer)
return replaced_by_customer
def get_latest_appointments_by_store(store_id):
days = request.args.get('days', 4)
start_date = date.today()
end_date = start_date + relativedelta(days=(days - 1))
return Appointment.find_all_between_dates_in_store(start_date, end_date,
store_id)
def validate(self, appt_data):
now_time = datetime.now()
appt_type = appt_data.get('type', None)
appt_time = parse(appt_data.get('appt_datetime'))
store_id = appt_data.get('store_id')
if appt_type and appt_type == 'followup':
customer = appt_data.get('customer', None)
if customer and customer.is_active():
# 1. 未成交客户, 预约回访时间不得晚于当前时间+7天
general_time_limit = now_time + timedelta(days=7)
if appt_time > general_time_limit:
abort(
400,
description=gettext(
'appt_datetime can not be later than %(days)s days',
days=7))
# 2. 如果客户是首次客户, 首次预约回访时间不得晚于到店第二天晚上24时
receptions = Reception.find_all_by_customer_sales(customer.id)
if receptions and len(receptions) == 1:
last_rx_date = receptions[0].rx_date
rx_limit = last_rx_date + timedelta(days=1)
if not Appointment.exist_followup_between_dates_by_customer(parse_date(now_time), parse_date(
rx_limit), customer.id, store_id) and parse_date(now_time) <= parse_date(rx_limit) \
< parse_date(appt_time):
abort(
400,
description=gettext(
'appt_datetime can not be later than 1 days for new customer'
))
def morning_call():
current_user = g.user
store_id = get_or_set_store_id()
today = datetime.date.today()
yesterday = today - datetime.timedelta(days=1)
orders_stats = dict()
orders_stats['yesterday_orders_count'] = Order.count_orders_by_date_and_store(yesterday, store_id)
orders_stats['current_month_orders_count'] = Order.count_orders_from_date_and_store(
datetime.date.today().replace(day=1),
store_id)
current_month_ta = TaSetting.find_active_monthly_ta(today.year, today.month, store_id)
orders_stats['current_month_target'] = current_month_ta.value if current_month_ta else 'N/A'
sales_stats = User.get_all_sales_by_store_from_cache(long(store_id))
yesterday_receptions = Reception.find_all_by_date_in_store(yesterday, store_id)
today_appointments = Appointment.find_all_by_date_in_store(datetime.date.today(), store_id)
rx_stats = dict()
rx_stats['yesterday_incomplete_count'] = len(
[x for x in yesterday_receptions if x._last_status_changer == 'system'])
total_counts, sales_counts = calc_reception_counts(yesterday_receptions, sales_stats)
for sale in sales_stats:
sale.rx_count = sales_counts.get(sale.id, {'total': 0, 'new': 0, 'appt_new': 0, 'appt': 0, 'other': 0})
populate_appt_count_agg_by_sale_and_type(today_appointments, sale)
sales_stats.sort(key=lambda sale: sale.rx_count, reverse=True)
appts_count = generate_appt_count_agg_by_type(today_appointments)
recent_campaigns = Campaign.find_all_by_store_in_recent_days(store_id, 15)
current_endpoint = 'user.morning_call'
now = datetime.datetime.now()
yesterday_datetime = now - datetime.timedelta(days=1)
rx_base_url, rx_url_params = get_filter_link('receptions.receptions', yesterday_datetime, yesterday_datetime,
current_endpoint)
rx_incomplete_params = rx_url_params.copy()
rx_incomplete_params['incomplete'] = 'y'
appt_base_url, appt_url_params = get_filter_link('appointments.appts', now, now, current_endpoint)
order_base_url, order_url_params = get_filter_link('orders.orders', yesterday_datetime, yesterday_datetime,
current_endpoint)
monthly_order_url_params = order_url_params.copy()
monthly_order_url_params['start_date'] = datetime.date.today().replace(day=1).strftime(DATE_FORMAT)
monthly_order_url_params['end_date'] = now.strftime(DATE_FORMAT)
return render_template('user/salesmanager/morningcall.html', selected_menu=USER_MORNING_CALL,
orders_stats=orders_stats, sales_stats=sales_stats, appts_count=appts_count,
total_rx_count=total_counts, recent_campaigns=recent_campaigns,
recent_campaigns_count=len(recent_campaigns), current_month_ta=current_month_ta,
rx_base_url=rx_base_url, rx_url_params=rx_url_params, appt_base_url=appt_base_url,
appt_url_params=appt_url_params, rx_incomplete_params=rx_incomplete_params,
order_base_url=order_base_url, order_url_params=order_url_params,
monthly_order_url_params=monthly_order_url_params, rx_stats=rx_stats,
back_endpoint=request.args.get('back_endpoint', None))
def query_appointments_in_store(store_id):
query_criteria = request.args.get('q')
if query_criteria is None:
return abort(404,
description=gettext(u'query criteria can not be empty'))
return Appointment.find_all_by_q_in_store(query_criteria, store_id)
def get_appointment(uid):
result = Appointment.find(uid)
if result is None:
abort(404,
description=gettext(u'appointment with id %(id)s is not found',
id=uid))
return result
def sync_appointments_of_sales(sales_id):
last_sync_date = request.args.get('last_sync_date', None)
try:
last_sync_date = datetime.fromtimestamp(int(last_sync_date))
except:
last_sync_date = None
bulk_size = request.args.get('bulk_size', None)
return Appointment.find_all_by_sales_before_sync_in_bulk(
sales_id, last_sync_date, bulk_size)
def transfer_sales_customers(from_sales_id, to_sales_id):
passcode = request.args.get('passcode', None)
status = request.args.getlist('status')
if not passcode or not valid_passcode(passcode):
abort(401)
from_sales = User.find(from_sales_id)
if not from_sales or from_sales.is_active():
abort(400, description=gettext(u'sales with id (%id)s is not found', id=from_sales_id))
to_sales = User.find(to_sales_id)
if not to_sales:
abort(400, description=gettext(u'sales with id (%id)s is not found', id=to_sales_id))
Appointment.cancel_all_for_sales(from_sales_id, u'重新分配客户')
processed_count = Customer.reassign_all_of_sales_to_sales(from_sales_id, to_sales_id, status)
return {'from_sales_id': from_sales_id, 'to_sales_id': to_sales_id, 'processed_count': processed_count}
def close_appointment_before(reception):
if not reception.customer_id:
return
if reception.rx_type == 'other':
appt_type = 'deliver'
else:
appt_type = 'instore'
today_appts = Appointment.find_all_opened_by_type_and_date_of_sales_customer(
appt_type,
datetime.today().date(), reception.sales_id, reception.customer_id)
for appt in today_appts:
appt.status = 'closed'
def view_details(cid):
current_user = g.user
store_id = get_or_set_store_id()
customer = Customer.find_by_id_and_store(cid, store_id)
if not customer:
abort(404)
orders = Order.find_all_by_customer_sales(customer.id)
appts = Appointment.find_all_by_customer_sales(customer.id)
receptions = Reception.find_all_by_customer_sales(customer.id)
calllogs = Calllog.find_all_by_customer_id(customer.id)
form = CustomerReassignForm()
form.saleses_list.choices = get_sales_selection(store_id)
if current_user.is_receptionist() or (
current_user.is_sales()
and current_user.is_role_in_store_id(store_id, 'manager') == False
and customer.sales_id != current_user.id):
abort(401)
if request.method == 'GET':
form.saleses_list.data = customer.sales_id
if request.method == 'POST' and (
form.saleses_list.data not in ('None', customer.sales_id)
and current_user.is_role_in_store_id(store_id, 'manager')):
customer.reassign(int(form.saleses_list.data))
customer.save_and_flush()
flash_success(u'重新分配成功')
return redirect(url_for('customers.view_details',
cid=cid,
back_url=back_url(
url_for('customers.customers'))),
code=303)
return render_template('customers/detail.html',
selected_menu=CUSTOMER_MGMT,
customer=customer,
orders=orders,
appts=appts,
receptions=receptions,
calllogs=calllogs,
form=form,
back_url=back_url(url_for('customers.customers')))
def reset_status(self):
from application.models.appointment import Appointment
if self.status == 'defeated':
return
elif len(Order.find_all_by_customer_sales(self.id, self.sales_id)):
self.status = 'ordered'
return
elif Appointment.exist_opened_of_sales_customer(self.sales_id, self.id):
self.status = 'enlist'
return
elif self.has_required_fields_filled():
self.status = 'formal'
return
else:
self.status = 'draft'
return
def merge_stores(from_store_id, to_store_id):
passcode = request.args.get('passcode', None)
if not passcode or not valid_passcode(passcode):
abort(401)
result = dict()
result['receptions'] = Reception.migrate_store(from_store_id, to_store_id)
result['customers'] = Customer.migrate_store(from_store_id, to_store_id)
result['appointments'] = Appointment.migrate_store(from_store_id, to_store_id)
from application.models.order import Order
result['orders'] = Order.migrate_store(from_store_id, to_store_id)
from application.models.calllog import Calllog
result['calllogs'] = Calllog.migrate_store(from_store_id, to_store_id)
from application.models.campaign import Campaign
result['campaigns'] = Campaign.migrate_store(from_store_id, to_store_id)
from application.models.driverecord import DriveRecord
result['driverecords'] = DriveRecord.migrate_store(from_store_id, to_store_id)
return result
def appts():
current_user = g.user
store_id = get_or_set_store_id()
from application.forms.appt import ApptSearchForm
search_form = ApptSearchForm(request.args)
search_form.type_filter.choices = get_type_selection()
search_form.status_filter.choices = get_status_selection()
search_form.sales_filter.choices = get_sales_selection(store_id)
query = dict()
if search_form.start_date.data and search_form.start_date.data != '':
query['start_date'] = search_form.start_date.data
if search_form.end_date.data and search_form.end_date.data != '':
query['end_date'] = search_form.end_date.data
if search_form.type_filter.data and search_form.type_filter.data not in (
'None', 'all'):
query['type_filter'] = search_form.type_filter.data
if search_form.status_filter.data and search_form.status_filter.data not in (
'None', 'all'):
query['status'] = search_form.status_filter.data
if search_form.sales_filter.data and search_form.sales_filter.data not in (
'None', 'all'):
query['sales_filter'] = search_form.sales_filter.data
sort_params = SortMixin.get_order_query(search_form)
if sort_params:
query.update(sort_params)
query.update(get_page_info(request))
appts = Appointment.find_all_by_query_params_in_store(store_id, **query)
return render_template('appts/appts.html',
selected_menu=APPTS_VIEW,
form=search_form,
back_endpoint=request.args.get(
'back_endpoint', None),
appts=appts)
def create_appointment():
data = request.json
if data is None:
abort(400, description=gettext('invalid json request'))
# validate appointment time
if data.get('appt_datetime', None) is None:
abort(400,
description=gettext('appointment datetime can not be empty'))
appt_time = parse(data.get('appt_datetime'))
now_time = datetime.now()
if appt_time < now_time:
abort(400,
description=gettext('appointment datetime must later than now'))
latest_time = now_time + timedelta(days=30)
if appt_time > latest_time:
abort(400,
description=gettext(
'appointment datetime can not be later than 30 days'))
populate_customer_from_request(data, data.get('store_id'),
data.get('sales_id'))
data.pop('id', None)
validator = get_appt_validator(data.get('store_id'))
if validator:
validator.validate(data)
if data.get('customer', None) and data['customer'].id:
Appointment.cancel_all_for_sales_customer(data['sales_id'],
data['customer'].id,
"new appointment created")
appt = Appointment(**data)
appt.customer.enlist()
appt.save_and_flush()
return appt, 201, add_location_header(
dict(), url_for('api.get_appointment', uid=appt.id))
gettext(
u'the customer belongs to %(sales_name)s, force assign to %(new_sales)s',
sales_name=npe.customer.sales.username,
new_sales=User.find(data.get('sales_id')).username))
reception = Reception(**data)
# default receptionist_id if not passed from client
if convert_int(reception.receptionist_id) <= 0:
reception.receptionist_id = get_user_id()
reception.customer.enlist()
reception.created_on = datetime.now()
reception.customer.last_reception_date = reception.created_on
if reception.appointment_id is not None:
appt = Appointment.find(reception.appointment_id)
if not appt:
reception.appointment_id = None
else:
if appt.type == 'deliver':
reception.rx_type = 'other'
elif not Reception.has_reception_before(appt.customer.id):
reception.rx_type = 'appt_new'
else:
reception.rx_type = 'appt'
appt.status = 'closed'
reception.save_and_flush()
new_reception_created.send(new_reception=reception)
def evening_call():
current_user = g.user
store_id = get_or_set_store_id()
today = datetime.date.today()
orders_stats = dict()
orders_stats['today_orders_count'] = Order.count_orders_by_date_and_store(datetime.date.today(), store_id)
orders_stats['current_month_orders_count'] = Order.count_orders_from_date_and_store(
datetime.date.today().replace(day=1),
store_id)
current_month_ta = TaSetting.find_active_monthly_ta(today.year, today.month, store_id)
orders_stats['current_month_target'] = current_month_ta.value if current_month_ta else 'N/A'
sales_stats = User.get_all_sales_by_store_from_cache(long(store_id))
today_receptions = Reception.find_all_of_today_in_store(store_id)
today_appointments = Appointment.find_all_by_date_in_store(datetime.date.today(), store_id)
tomorrow_appointments = Appointment.find_all_by_date_in_store(datetime.date.today() + datetime.timedelta(days=1),
store_id)
total_counts, sales_counts = calc_reception_counts(today_receptions, sales_stats)
for sale in sales_stats:
populate_appt_count_agg_by_sale_and_type(today_appointments, sale, include_closed=True)
populate_appt_count_agg_by_sale_and_type(tomorrow_appointments, sale, attr_prefix='tomorrow_')
sale.rx_count = sales_counts.get(sale.id, {'total': 0, 'new': 0, 'appt_new': 0, 'appt': 0, 'other': 0})
appts_count = generate_appt_count_agg_by_type(today_appointments, include_closed=True)
tomorrow_appts_count = generate_appt_count_agg_by_type(tomorrow_appointments)
sales_stats.sort(key=lambda sale: sale.rx_count, reverse=True)
rx_stats = {'today_incomplete_count': len([x for x in today_receptions if x.status != 'completed'])}
appt_stats = dict()
appt_stats['instore'] = len([x for x in today_appointments if x.status != 'cancelled' and x.type == 'instore'])
appt_stats['open_instore'] = len([x for x in today_appointments if x.status == 'opened' and x.type == 'instore'])
appt_stats['followup'] = len([x for x in today_appointments if x.type == 'followup'])
appt_stats['open_followup'] = len([x for x in today_appointments if x.status == 'opened' and x.type == 'followup'])
now = datetime.datetime.now()
tomorrow_datetime = now + datetime.timedelta(days=1)
current_endpoint = 'user.evening_call'
rx_base_url, rx_url_params = get_filter_link('receptions.receptions', now, now, current_endpoint)
rx_incomplete_params = rx_url_params.copy()
rx_incomplete_params['status_filter'] = 'in-store'
appt_base_url, appt_url_params = get_filter_link('appointments.appts', now, now, current_endpoint)
tomorrow_appt_base_url, tomorrow_appt_url_params = get_filter_link('appointments.appts', tomorrow_datetime,
tomorrow_datetime,
current_endpoint)
recent_campaigns = Campaign.find_all_by_store_in_recent_days(store_id, 15)
order_base_url, order_url_params = get_filter_link('orders.orders', now, now, current_endpoint)
monthly_order_url_params = order_url_params.copy()
monthly_order_url_params['start_date'] = datetime.date.today().replace(day=1).strftime(DATE_FORMAT)
monthly_order_url_params['end_date'] = now.strftime(DATE_FORMAT)
return render_template('user/salesmanager/eveningcall.html', selected_menu=USER_EVENING_CALL, rx_stats=rx_stats,
orders_stats=orders_stats, today_receptions_count=len(today_receptions),
rx_incomplete_params=rx_incomplete_params,
sales_stats=sales_stats, appts_count=appts_count, total_rx_count=total_counts,
tomorrow_appts_count=tomorrow_appts_count, recent_campaigns=recent_campaigns,
recent_campaigns_count=len(recent_campaigns), rx_base_url=rx_base_url,
rx_url_params=rx_url_params, order_base_url=order_base_url,
tomorrow_appt_base_url=tomorrow_appt_base_url,
tomorrow_appt_url_params=tomorrow_appt_url_params,
order_url_params=order_url_params, appt_stats=appt_stats, appt_base_url=appt_base_url,
appt_url_params=appt_url_params,
monthly_order_url_params=monthly_order_url_params,
back_endpoint=request.args.get('back_endpoint', None))
def get_appointments_by_sales(sales_id):
return Appointment.find_all_of_sales(sales_id, **get_page_info(request))
def dashboard():
current_user = g.user
now = datetime.datetime.now()
store_id = get_or_set_store_id()
orders_stats = dict()
orders_stats['today_orders_count'] = Order.count_orders_by_date_and_store(datetime.date.today(), store_id)
orders_with_status = Order.find_orders_status_from_date_and_store(datetime.date.today().replace(day=1), store_id)
orders_stats['current_month_new_count'] = len(
[x for x in orders_with_status if x.status == 'new'])
orders_stats['current_month_delivered_count'] = Order.count_delivered_orders_between_date_and_store(store_id,
get_first_day_of_month(
now).date(),
now.date())
customer_stats = dict()
today_receptions = Reception.find_all_of_today_in_store(store_id)
completed_reception = filter(lambda rx: rx.status == 'completed', today_receptions)
customer_stats['total'] = len(today_receptions) if today_receptions else 0
customer_stats['complete'] = len(completed_reception) if completed_reception else 0
customer_stats['instore'] = customer_stats['total'] - customer_stats['complete']
customer_stats['new'] = len([x for x in today_receptions if x.rx_type == 'new'])
customer_stats['appt_new'] = len([x for x in today_receptions if x.rx_type == 'appt_new'])
customer_stats['appt'] = len([x for x in today_receptions if x.rx_type == 'appt'])
customer_stats['other'] = len([x for x in today_receptions if x.rx_type == 'other'])
today_appointments = Appointment.find_all_by_date_in_store(datetime.date.today(), store_id)
appt_stats = dict()
appt_stats['instore'] = len([x for x in today_appointments if x.status != 'cancelled' and x.type == 'instore'])
appt_stats['open_instore'] = len([x for x in today_appointments if x.status == 'opened' and x.type == 'instore'])
appt_stats['followup'] = len([x for x in today_appointments if x.type == 'followup'])
appt_stats['open_followup'] = len([x for x in today_appointments if x.status == 'opened' and x.type == 'followup'])
sales = User.get_all_sales_by_store_from_cache(long(store_id))
# make sure the status is correct
SalesStatus.reset_all_sales_status(store_id)
sales_status = SalesStatus.get_all_sales_status(store_id)
total_counts, reception_counts = calc_reception_counts(today_receptions, sales)
for sale in sales:
sale.status = sales_status.get(str(sale.id), 'free')
set_status_label_and_style(sale)
sale.rx_count = reception_counts.get(sale.id, {'total': 0, 'new': 0, 'appt_new': 0, 'appt': 0, 'other': 0})
# receptions_per_sale = filter(lambda rx: rx.sales_id == sale.id, today_receptions)
# sale.rx_count = len(receptions_per_sale) if receptions_per_sale else 0
# total_rx_count += sale.rx_count
sales.sort(key=lambda sale: sale.status)
today_orders = Order.find_all_created_today_by_store(store_id)
today_orders_count = len(today_orders) if today_orders else 0
current_endpoint = 'user.dashboard'
rx_base_url, rx_url_params = get_filter_link('receptions.receptions', now, now, current_endpoint)
order_base_url, order_url_params = get_filter_link('orders.orders', now, now, current_endpoint)
monthly_order_url_params = order_url_params.copy()
monthly_order_url_params.update({'start_date': datetime.date.today().replace(day=1).strftime(DATE_FORMAT)})
monthly_delivered_order_url_params = monthly_order_url_params.copy()
monthly_delivered_order_url_params['status_filter'] = 'delivered'
monthly_delivered_order_url_params['history'] = 'y'
appt_base_url, appt_url_params = get_filter_link('appointments.appts', now, now, current_endpoint)
# tbc_orders = Order.find_all_in_status_by_store(store_id, confirmed=0, status='new')
return render_template('user/salesmanager/dashboard.html', selected_menu=USER_RT_DATA, orders_stats=orders_stats,
appt_stats=appt_stats,
customer_stats=customer_stats, sales=sales, today_orders=today_orders,
total_count=total_counts, today_orders_count=today_orders_count,
sales_receptions=reception_counts, rx_base_url=rx_base_url, rx_url_params=rx_url_params,
order_base_url=order_base_url, order_url_params=order_url_params,
monthly_order_url_params=monthly_order_url_params,
monthly_delivered_order_url_params=monthly_delivered_order_url_params,
appt_base_url=appt_base_url,
appt_url_params=appt_url_params)
def update_customer_status(customer, sales):
if customer.status == 'enlist' and not Appointment.exist_opened_of_sales_customer(
sales.id, customer.id):
customer.status = 'formal'
def get_all_customer_appointments(customer_id):
sales_id = request.args.get("sales_id", None)
return Appointment.find_all_by_customer_sales(customer_id, sales_id)
