def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
booking_id = self.get_argument('booking_id', '')
uid = self.get_argument('uid', '')
date = self.get_argument('date', dt.datetime.strftime(dt.datetime.now(), '%Y%m%d'))
time = self.get_argument('time', '08:00')
master_ids = self.get_argument('master_ids', [])
apply_to_all_behind = self.get_argument('apply_to_all_behind', 0)
by_manager = self.get_argument('by_manager', 0)
# convert parameters
apply_to_all_behind = int(apply_to_all_behind)
selected_date_str = date
time_str = time
selected_date = dt.datetime.strptime(date, '%Y%m%d')
master_ids = master_ids.split(',')
by_manager = int(by_manager)
# logging part
mix = get_mixpanel()
mongo_logger = get_mongo_logger()
print 'update schedule'
print selected_date_str, time_str, apply_to_all_behind
print '*' * 100
try:
session = Session()
booking_info = {}
userdao = UserDAO()
masterdao = MasterDAO()
holder = IntermediateValueHolder()
try:
row = session.query(Booking).filter(Booking.id == booking_id).one()
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_no_record'])
return
except MultipleResultsFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_multiple_record'])
return
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
user_id = self.get_argument('user_id', '')
store_key = self.get_argument('store_key', '')
search_keys = self.get_argument('search_keys', '')
print 'dismiss schedule *****'
print user_id
print store_key
print search_keys
# convert
search_keys = search_keys.split(',')
ret = {}
mix = get_mixpanel()
try:
holder = IntermediateValueHolder()
holder.remove(store_key)
for sk in search_keys:
holder.remove(sk)
if user_id != '':
mix.track(user_id, 'dismiss schedule',
{'time': dt.datetime.now()})
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
print 'recommendation was disappeared....'
except Exception, e:
print_err_detail(e)
self.set_status(Response.RESULT_SERVERERROR)
add_err_message_to_response(ret, err_dict['err_mysql'])
def post(self):
self.set_header("Content-Type", "application/json")
ret = {}
uid = self.get_argument('uid', '')
search_keys = self.get_argument('search_keys', '')
store_key = self.get_argument('store_key', '')
price = self.get_argument('price', 0)
price_with_task = self.get_argument('price_with_task', 0)
discounted_price = self.get_argument('discounted_price', 0)
promotion_code = self.get_argument('promotion_code', '')
laundry_apply_all = self.get_argument('laundry_apply_all', 0) # -1 - 없앰, 0 - one time, 1 - all time
# convert datetime
price = int(price)
price_with_task = int(price_with_task)
discounted_price = int(discounted_price)
laundry_apply_all = int(laundry_apply_all)
search_keys = search_keys.split(',')
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
masterdao = MasterDAO()
userdao = UserDAO()
promotiondao = PromotionDAO()
holder = IntermediateValueHolder()
# request id to group each individual bookings
request_id = str(uuid.uuid4())
obj = holder.retrieve(store_key)
print obj
if obj == None:
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_booking_timeout'])
mix.track(uid, 'request timeout', {'time' : dt.datetime.now()})
mongo_logger.error('%s got timed out' % uid)
return
# retrieve all stored values
uid = obj['user_id']
mid = obj['master_id']
dates = obj['dates']
time = obj['time']
appointment_type = obj['appointment_type']
additional_task = obj['additional_task']
taking_time = obj['taking_time']
first_added_time = obj['first_added_time']
additional_time = obj['additional_time']
total_time = obj['total_time']
master_gender = obj['master_gender']
have_pet = obj['have_pet']
isdirty = obj['isdirty']
# hasids to generate unique booking id
now = dt.datetime.strftime(dt.datetime.now(), '%Y%m%d%H%M%S')
hashids = Hashids(min_length = 16, salt = now + uid)
# set tool info
havetools = 1
if additional_task >= 64:
havetools = 0
card_idx = 0
addr_idx = 0
# get card and address idx
addr_idx = userdao.get_user_default_address_index(uid)
card_idx = userdao.get_user_default_card_index(uid)
i = 1
booking_ids = []
start_time_list = []
for date in dates: #
print date, time
booking_id = hashids.encode(int(date + time.replace(':', '')))
print 'key', booking_id
master_id = mid
date = dt.datetime.strptime(date, '%Y%m%d')
dow = date.date().weekday()
booking_time = dt.time(hour = int(time.split(':')[0]), minute = int(time.split(':')[1]))
start_time = dt.datetime.combine(date, booking_time)
estimated_end_time = start_time + dt.timedelta(minutes = total_time)
cleaning_duration = taking_time
actual_price = 0
if i == 1: # 1 번째 클리닝
actual_price = price_with_task - discounted_price # 할인은 1회만 적용됨
else: # 나머지
actual_price = price
if havetools == 1:
additional_task = 0
else:
additional_task = 64
if laundry_apply_all == 1:
additional_task += 4 # 빨래
isdirty = 0 # 첫째 이후에는 is dirty는 0
estimated_end_time = estimated_end_time - dt.timedelta(minutes = additional_time + first_added_time)
booking = Booking(id = booking_id,
request_id = request_id,
user_id = uid,
master_id = mid,
appointment_type = appointment_type,
appointment_index = i,
dow = dow,
booking_time = dt.datetime.now(),
org_start_time = start_time,
start_time = start_time,
estimated_end_time = estimated_end_time,
end_time = estimated_end_time, # update after homemaster finish their job
cleaning_duration = cleaning_duration,
additional_task = additional_task,
price = price,
price_with_task = actual_price,
charging_price = 0,
card_idx = card_idx,
addr_idx = addr_idx,
havetools = havetools,
havepet = have_pet,
laundry_apply_all = laundry_apply_all,
is_dirty = isdirty,
master_gender = master_gender,
status = BC.BOOKING_UPCOMMING,
cleaning_status = BC.BOOKING_UPCOMMING,
payment_status = BC.BOOKING_UNPAID_YET)
i += 1
session.add(booking)
booking_ids.append(booking_id)
start_time_list.append(start_time)
#print 'booking_id', booking_id, 'was added..'
# charge for first appointment date
user_name = userdao.get_user_name(uid)
if price_with_task - discounted_price <= 0:
ret_code = True
msg = ''
else:
ret_code = True
msg = ''
if ret_code:
session.commit()
# remove store_key and related_keys
holder.remove(store_key)
for sk in search_keys:
holder.remove(sk)
# promotion code 와 연결
if promotion_code != '':
promotiondao.set_promotion_code_status(promotion_code, 1, booking_ids[0], price_with_task)
session.commit()
mix.track(uid, 'confirm booking', {'time' : dt.datetime.now(), 'appointment_type' : appointment_type, 'additional_task' : additional_task})
mongo_logger.debug('confirm booking', extra = {'user_id' : uid, 'master_id' : mid, 'booking_id' : booking_ids[0], 'start_time' : start_time_list[0]})
#ret['response'] = {'booking_ids' : booking_ids} # victor 요청으로 첫번째
ret['response'] = booking_ids[0]
self.set_status(Response.RESULT_OK)
# notification to managers
send_booking_iphone(booking_ids[0])
appointment_type_text = ''
if appointment_type == BC.ONE_TIME or appointment_type == BC.ONE_TIME_BUT_CONSIDERING:
appointment_type_text = '1회'
elif appointment_type == BC.FOUR_TIME_A_MONTH:
appointment_type_text = '매주'
elif appointment_type == BC.TWO_TIME_A_MONTH:
appointment_type_text = '2주 1회'
elif appointment_type == BC.ONE_TIME_A_MONTH:
appointment_type_text = '4주 1회'
master_phone = masterdao.get_master_phone(mid)
send_alimtalk(master_phone, 'noti_manager_new', user_name, appointment_type_text)
try:
first_booking = session.query(Booking, User, MasterPushKey) \
.join(User, Booking.user_id == User.id) \
.outerjoin(MasterPushKey, Booking.master_id == MasterPushKey.master_id) \
.filter(Booking.id == booking_ids[0]) \
.one()
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
mongo_logger.debug('no first booking record', extra = { 'uid' : uid, 'mid' : mid,'appointment_type' : appointment_type, 'have_pet' : have_pet, 'master_gender' : master_gender, 'isdirty' : isdirty})
add_err_message_to_response(ret, err_dict['err_no_record'])
return
except MultipleResultsFound, e:
session.close()
self.set_status(Response.RESULT_OK)
mongo_logger.debug('multiple first booking record', extra = { 'uid' : uid, 'mid' : mid, 'appointment_type' : appointment_type, 'have_pet' : have_pet, 'master_gender' : master_gender, 'isdirty' : isdirty})
add_err_message_to_response(ret, err_dict['err_multiple_record'])
return
def add_booking(self, order_dict, user_id):
try:
session = Session()
holder = IntermediateValueHolder()
if not 'lnkKey' in order_dict:
print 'NO BOOKING ID - lnkKey'
print '*' * 100
return
store_key = order_dict['lnkKey']
obj = holder.retrieve(store_key)
if obj == None:
return [], False
master_id = obj['master_id']
dates = obj['dates']
time = obj['time']
cleaning_duration = obj['cleaning_duration']
additional_time = 0
if 'additional_time' in obj:
additional_time = obj['additional_time']
order_id = order_dict['ordNo']
product_no = order_dict['sellerPrdNo']
if '_' in product_no:
product_no = product_no.split('_')
appointment_type = int(product_no[2])
else:
appointment_type = 0
# field
request_id = str(uuid.uuid4())
#appointment_type = int(product_no[2])
message = order_dict[
'rsvEtcInfo5'] if 'rsvEtcInfo5' in order_dict else ''
trash_location = '%s %s' % (order_dict['rsvEtcInfo1'],
order_dict['rsvEtcInfo2'])
havepet = 0 if order_dict['rsvEtcInfo3'] == '아니오' else 1
card_idx = -1
addr_idx = 0
options = order_dict['RsvDtlsInfo']
print options
options_price = sum([int(opt['optAmt']) for opt in options[1:]])
options_name = [opt['optNm'] for opt in options[1:]]
additional_task = 0
if options_name != [None]:
for opt in options_name:
if '창문' in opt:
additional_task += 1
elif '베란다' in opt:
additional_task += 2
elif '빨래' in opt:
additional_task += 4
elif '옷장' in opt:
additional_task += 8
elif '단문형' in opt:
additional_task += 16
elif '양문형' in opt:
additional_task += 32
actual_price = int(order_dict['rsvAmt'])
price = actual_price - options_price
now = dt.datetime.strftime(dt.datetime.now(), '%Y%m%d%H%M%S')
hashids = Hashids(min_length=16, salt=now + user_id)
booking_ids = []
index = 1
for date in dates: #
print date, time
if index == 1:
booking_id = store_key
else:
booking_id = hashids.encode(
int(date + time.replace(':', '')))
print 'key', booking_id
date = dt.datetime.strptime(date, '%Y%m%d')
dow = date.date().weekday()
booking_time = dt.time(hour=int(time.split(':')[0]),
minute=int(time.split(':')[1]))
start_time = dt.datetime.combine(date, booking_time)
estimated_end_time = start_time + dt.timedelta(
minutes=cleaning_duration + additional_time)
if index != 1:
actual_price = price
additional_task = 0
estimated_end_time -= dt.timedelta(minutes=additional_time)
booking = Booking(
id=booking_id,
request_id=request_id,
user_id=user_id,
master_id=master_id,
appointment_type=appointment_type,
appointment_index=index,
dow=dow,
booking_time=dt.datetime.now(),
org_start_time=start_time,
start_time=start_time,
estimated_end_time=estimated_end_time,
end_time=
estimated_end_time, # update after homemaster finish their job
cleaning_duration=cleaning_duration,
additional_task=additional_task,
price=price,
price_with_task=actual_price,
charging_price=0,
card_idx=card_idx,
addr_idx=addr_idx,
message=message,
trash_location=trash_location,
havepet=havepet,
laundry_apply_all=0,
is_dirty=0,
master_gender=0,
source='11st',
status=BC.BOOKING_UPCOMMING,
cleaning_status=BC.BOOKING_UPCOMMING,
payment_status=BC.BOOKING_PAID)
session.add(booking)
index += 1
booking_ids.append(booking_id)
# remove store_key and related_keys
store_key = obj['store_key']
search_keys = obj['search_keys'].split(',')
holder.remove(store_key)
for sk in search_keys:
holder.remove(sk)
# order_11st에 order_id 추가 필요.
print order_id
order = Order11st(order_id=order_id)
session.add(order)
session.commit()
except Exception, e:
print_err_detail(e)
class EditBookingHandler(tornado.web.RequestHandler):
def post(self):
self.set_header("Content-Type", "application/json")
booking_id = self.get_argument('booking_id', '')
changed = self.get_argument('ischange', '')
date = self.get_argument('date', dt.datetime.now())
start_time_range_begin = self.get_argument('range_begin',
BC.START_TIME_RANGE_BEGIN)
start_time_range_begin_min = self.get_argument('range_begin_min', 0)
start_time_range_end = self.get_argument('range_end',
BC.START_TIME_RANGE_END)
start_time_range_end_min = self.get_argument('range_end_min', 0)
price = self.get_argument('price', 0)
taking_time = self.get_argument('taking_time', 25)
additional_task = self.get_argument('additional_task', 0)
message = self.get_argument('msg', '')
laundry_apply_all = self.get_argument(
'laundry_apply_all', 0) # -1 - 없앰, 0 - one time, 1 - all time
print 'edit booking params....'
print booking_id, changed, date, additional_task, taking_time, price
# convert datetime
price = int(price)
taking_time = int(taking_time)
additional_task = int(additional_task)
taking_time_in_minutes = taking_time * 6
laundry_apply_all = int(laundry_apply_all)
changed = "{0:03b}".format(int(changed))
mongo_logger = get_mongo_logger()
mongo_logger.debug('%s was called to updated' % booking_id,
extra={
'changed': changed,
'date': date,
'start_time_range_begin':
start_time_range_begin,
'start_time_range_end': start_time_range_end,
'price': price,
'taking_time': taking_time,
'additional_task': additional_task,
'user_message': message
})
ret = {}
mix = get_mixpanel()
try:
session = Session()
userdao = UserDAO()
addrdao = AddressDAO()
masterdao = MasterDAO()
try:
row = session.query(Booking).filter(
Booking.id == booking_id).one()
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_no_record'])
return
except MultipleResultsFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_multiple_record'])
return
uid = row.user_id
price_with_task = row.price_with_task
appointment_type = row.appointment_type
org_master_id = row.master_id
holder = IntermediateValueHolder()
org_date = dt.datetime.strftime(row.start_time, '%m월%d일')
time_changed = changed[2]
task_changed = changed[1]
msg_changed = changed[0]
# booking can not be updated within 24 hours ahead
appointment_time = row.start_time
current_time = dt.datetime.now()
diff_in_hours = (appointment_time -
current_time).total_seconds() / 3600
if diff_in_hours < 24: # 못바꾸도록 함
time_changed = 0
task_changed = 0
havetools = 1
if additional_task >= 64:
havetools = 0
# time이 변경되었다면 무조건 scheduling
if time_changed == '1':
date = dt.datetime.strptime(date, '%Y%m%d')
start_time_range_begin = int(start_time_range_begin)
start_time_range_begin_min = int(start_time_range_begin_min)
start_time_range_end = int(start_time_range_end)
start_time_range_end_min = int(start_time_range_end_min)
appointment_type = 0 # 여기서는 1회 청소로 한다. 편집이기 때문에
start_time = row.start_time
end_time = row.estimated_end_time
have_pet = row.havepet
master_gender = row.master_gender
price_with_task = row.price_with_task
addr_idx = row.addr_idx
org_taking_time_in_minutes = time_to_minutes(
timedelta_to_time(end_time - start_time))
new_taking_time_in_minutes = org_taking_time_in_minutes + taking_time_in_minutes
address, geohash5, geohash6 = userdao.get_user_address_by_index(
uid, addr_idx)
gu_id = addrdao.get_gu_id(address)
dates = [int(dt.datetime.strftime(date, '%Y%m%d'))]
schedule_by_date_list = masterdao.get_master_schedule_by_dates(
gu_id, have_pet, master_gender, dates)
success, msg, store_key, search_keys, result = masterdao.find_master_by_score(schedule_by_date_list, \
gu_id, \
uid, \
appointment_type, \
dates, \
start_time_range_begin, \
start_time_range_begin_min, \
start_time_range_end, \
start_time_range_end_min, \
new_taking_time_in_minutes, \
geohash6)
# if not successful
if success != 'SUCCESS':
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(
ret, err_dict['err_no_hm_at_that_time'])
self.write(json.dumps(ret))
return
else: # find matching homemaster
item = result[0]
master_id = item['mid']
dow = dt.datetime.strptime(item['date'],
'%Y%m%d').date().weekday()
start_time = dt.datetime.combine(
dt.datetime.strptime(item['date'], '%Y%m%d'),
item['start_time'])
estimated_end_time = dt.datetime.combine(
dt.datetime.strptime(item['date'], '%Y%m%d'),
item['end_time'])
status = row.payment_status
if status == BC.BOOKING_PAID: # 미리 지불한 경우는 취소 하고 다시 결제함
# 전거래 취소 및 재결제
cancel_ret_code, msg = cancel_payment(uid,
booking_id,
price_with_task,
partial='0')
if cancel_ret_code:
user_name = userdao.get_user_name(uid)
pay_ret_code, pay_msg = request_payment(
uid,
user_name,
booking_id,
price,
appointment_type,
status='UPDATED')
if pay_ret_code:
row.tid = pay_msg
row.payment_status = BC.BOOKING_PAID
else:
row.payment_status = BC.BOOKING_PAYMENT_FAILED
session.commit()
session.close()
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, pay_msg)
self.write(json.dumps(ret))
return
row.master_id = master_id
row.dow = dow
row.price_with_task = price
row.start_time = start_time
row.message = message
row.additional_task = additional_task
row.havetools = havetools
row.estimated_end_time = estimated_end_time
row.laundry_apply_all = laundry_apply_all
if org_master_id != master_id:
row.is_master_changed = 1
# about laundry
request_id = row.request_id
appointment_index = row.appointment_index
all_bookings = session.query(Booking) \
.filter(Booking.request_id == request_id) \
.filter(Booking.cleaning_status == BC.BOOKING_UPCOMMING) \
.filter(Booking.appointment_index > appointment_index) \
.all()
if laundry_apply_all == 1:
for booking in all_bookings:
booking.additional_task += 4 # 빨래
booking.laundry_apply_all = laundry_apply_all
else:
for booking in all_bookings:
bits = "{0:07b}".format(booking.additional_task)
if bits[4] == '1':
booking.additional_task -= 4 # 빨래 제거
booking.laundry_apply_all = laundry_apply_all
session.commit()
holder.remove(store_key)
for sk in search_keys:
holder.remove(sk)
else:
if task_changed == '1':
if taking_time_in_minutes > 0: # 실제 시간이 늘어났을 경우에만 뒷 스케쥴 확인
master_id, start_date_int = masterdao.get_masterid_and_starttime_from_booking(
booking_id)
search_key = '%s_%d' % (master_id, start_date_int)
new_estimated_end_time = masterdao.is_master_available_next_schedule(
booking_id, taking_time_in_minutes)
print new_estimated_end_time, '&&&&'
if new_estimated_end_time != None and holder.store(
search_key, 1): # 실제로 시간이 가능하면
status = row.payment_status
if status == BC.BOOKING_PAID: # 미리 지불한 경우는 취소 하고 다시 결제함
# 전거래 취소 및 재결제
cancel_ret_code, msg = cancel_payment(
uid,
booking_id,
price_with_task,
partial='0')
if cancel_ret_code:
user_name = userdao.get_user_name(uid)
pay_ret_code, pay_msg = request_payment(
uid,
user_name,
booking_id,
price,
appointment_type,
status='UPDATED')
if pay_ret_code:
row.tid = pay_msg
row.payment_status = BC.BOOKING_PAID
else:
row.payment_status = BC.BOOKING_PAYMENT_FAILED
session.commit()
session.close()
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(
ret, pay_msg)
self.write(json.dumps(ret))
return
row.estimated_end_time = new_estimated_end_time
row.additional_task = additional_task
row.message = message
row.price_with_task = price
row.havetools = havetools
row.laundry_apply_all = laundry_apply_all
# about laundry
request_id = row.request_id
appointment_index = row.appointment_index
all_bookings = session.query(Booking) \
.filter(Booking.request_id == request_id) \
.filter(Booking.cleaning_status == BC.BOOKING_UPCOMMING) \
.filter(Booking.appointment_index > appointment_index) \
.all()
if laundry_apply_all == 1:
for booking in all_bookings:
booking.additional_task += 4 # 빨래
booking.laundry_apply_all = laundry_apply_all
else:
for booking in all_bookings:
bits = "{0:07b}".format(
booking.additional_task)
if bits[4] == '1':
booking.additional_task -= 4 # 빨래 제거
booking.laundry_apply_all = laundry_apply_all
session.commit()
# 메모리에서 삭제
holder.remove(search_key)
else: # 스케쥴이 있어서 불가능 함
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(
ret, err_dict['err_hm_have_next_schedule'])
self.write(json.dumps(ret))
return
else: # 시간이 줄어들었거나, 그대로인경우에는 additional task 값만 바꾸면 됨
status = row.payment_status
if status == BC.BOOKING_PAID: # 미리 지불한 경우는 취소 하고 다시 결제함
# 전거래 취소 및 재결제
cancel_ret_code, msg = cancel_payment(
uid, booking_id, price_with_task, partial='0')
if cancel_ret_code:
user_name = userdao.get_user_name(uid)
pay_ret_code, pay_msg = request_payment(
uid,
user_name,
booking_id,
price,
appointment_type,
status='UPDATED')
if pay_ret_code:
row.tid = pay_msg
row.payment_status = BC.BOOKING_PAID
else:
row.payment_status = BC.BOOKING_PAYMENT_FAILED
session.commit()
session.close()
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(
ret, pay_msg)
self.write(json.dumps(ret))
return
print row.estimated_end_time, taking_time_in_minutes
row.estimated_end_time = row.estimated_end_time + dt.timedelta(
minutes=taking_time_in_minutes)
row.additional_task = additional_task
row.message = message
row.price_with_task = price
row.havetools = havetools
row.laundry_apply_all = laundry_apply_all
# about laundry
request_id = row.request_id
appointment_index = row.appointment_index
all_bookings = session.query(Booking) \
.filter(Booking.request_id == request_id) \
.filter(Booking.cleaning_status == BC.BOOKING_UPCOMMING) \
.filter(Booking.appointment_index > appointment_index) \
.all()
if laundry_apply_all == 1:
for booking in all_bookings:
booking.additional_task += 4 # 빨래
booking.laundry_apply_all = laundry_apply_all
else:
for booking in all_bookings:
bits = "{0:07b}".format(
booking.additional_task)
if bits[4] == '1':
booking.additional_task -= 4 # 빨래 제거
booking.laundry_apply_all = laundry_apply_all
session.commit()
else:
row.message = message
session.commit()
# 문자 전송
#send_updated_text(booking_id, org_date)
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
mix.track(
uid, 'update', {
'time': dt.datetime.now(),
'booking_id': booking_id,
'additional_task': additional_task
})
mongo_logger.debug('%s was updated' % booking_id,
extra={
'user_id': uid,
'booking_id': booking_id
})
print booking_id, 'successfully updated...'
def post(self):
self.set_header("Content-Type", "application/json")
ret = {}
booking_id = self.get_argument('booking_id', '')
additional_task = self.get_argument('additional_task', '')
new_price = self.get_argument('new_price', 0)
total_taking_time = self.get_argument('total_taking_time', '')
laundry_apply_all = self.get_argument(
'laundry_apply_all',
0) # -2 - 전체없앰 -1 - 하나 없앰, 0 - one time, 1 - all time
# convert parameter
new_price = int(new_price)
additional_task = int(additional_task)
total_taking_time = int(total_taking_time)
total_taking_time_in_minutes = total_taking_time * 6
laundry_apply_all = int(laundry_apply_all)
print 'update additional task params'
print booking_id
print additional_task
print new_price
print total_taking_time
print laundry_apply_all
mix = get_mixpanel()
mongo_logger = get_mongo_logger()
try:
print 'total_minutes :', total_taking_time_in_minutes
if total_taking_time_in_minutes >= 720:
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(
ret,
'클리닝 가능 시간을 초과하였습니다. (최대 12시간) 이전 화면으로 돌아가 추가사항을 2개이하로 줄여주세요.'
)
return
session = Session()
masterdao = MasterDAO()
userdao = UserDAO()
holder = IntermediateValueHolder()
row = session.query(Booking).filter(Booking.id == booking_id).one()
uid = row.user_id
start_time = row.start_time
end_time = row.estimated_end_time
request_id = row.request_id
appointment_index = row.appointment_index
appointment_type = row.appointment_type
payment_status = row.payment_status
price_with_task = row.price_with_task
isdirty = row.is_dirty
if isdirty == 1:
total_taking_time_in_minutes += 120
org_taking_time_in_minutes = time_to_minutes(
timedelta_to_time(end_time - start_time))
is_event = session.query(UserFreeEvent) \
.filter(UserFreeEvent.booking_request_id == request_id) \
.first()
is_event = True if is_event != None else False
user_name = userdao.get_user_name(uid)
# 추가 업무로 인해 소요된 시간이 더 크다면 앞 뒤 일정을 고려.
# 고려해서 이동이 가능하다면 추가 업무 할당함.
if total_taking_time_in_minutes > org_taking_time_in_minutes:
print '2'
master_id, time = masterdao.get_masterid_and_starttime_from_booking(
booking_id)
search_key = '%s_%d' % (master_id, time)
new_estimated_end_time = masterdao.is_schedule_extend_available(
booking_id, total_taking_time_in_minutes)
if new_estimated_end_time != None and holder.store(
search_key, 1): # 변경이 가능함.
if payment_status == BC.BOOKING_PAID: # 미리 지불한 경우는 취소 하고 다시 결제함
# 전거래 취소 및 재결제
if not (is_event and appointment_index == 1):
print 'in this case'
cancel_ret_code, msg = cancel_payment(
uid, booking_id, price_with_task, partial='0')
if cancel_ret_code:
pay_ret_code, pay_msg = request_payment(
uid,
user_name,
booking_id,
new_price,
appointment_type,
status='UPDATED')
if pay_ret_code:
row.tid = pay_msg
row.payment_status = BC.BOOKING_PAID
else:
row.payment_status = BC.BOOKING_PAYMENT_FAILED
session.commit()
session.close()
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(
ret, pay_msg)
return
else: # 정기 1회 이벤트 일 때
print 'hahaha'
charge_amount = new_price - row.price
print charge_amount
if row.price_with_task != row.price: # 다르면
charge_amount = new_price - row.price_with_task
pay_ret_code, pay_msg = request_payment(
uid,
user_name,
booking_id,
charge_amount,
appointment_type,
status='UPDATED')
if pay_ret_code:
row.tid = pay_msg
row.payment_status = BC.BOOKING_PAID
else:
row.payment_status = BC.BOOKING_PAYMENT_FAILED
session.commit()
session.close()
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, pay_msg)
return
row.estimated_end_time = new_estimated_end_time
row.additional_task = additional_task
row.price_with_task = new_price
row.laundry_apply_all = laundry_apply_all
session.commit()
holder.remove(search_key)
else:
print '3'
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(
ret, err_dict['err_hm_have_next_schedule'])
# 메모리에서 삭제
holder.remove(search_key)
return
else: # 같거나 작은 경우는 바로 변경
print '4'
if payment_status == BC.BOOKING_PAID: # 미리 지불한 경우는 취소 하고 다시 결제함
# 전거래 취소 및 재결제
if not (is_event and appointment_index == 1):
cancel_ret_code, msg = cancel_payment(uid,
booking_id,
price_with_task,
partial='0')
if cancel_ret_code:
user_name = userdao.get_user_name(uid)
pay_ret_code, pay_msg = request_payment(
uid,
user_name,
booking_id,
new_price,
appointment_type,
status='UPDATED')
if pay_ret_code:
row.tid = pay_msg
row.payment_status = BC.BOOKING_PAID
else:
row.payment_status = BC.BOOKING_PAYMENT_FAILED
session.commit()
session.close()
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, pay_msg)
return
else:
if row.price_with_task != row.price: # 다르면
charge_amount = row.price_with_task - new_price
cancel_payment(uid,
booking_id,
charge_amount,
partial='0')
row.additional_task = additional_task
row.estimated_end_time = end_time + dt.timedelta(
minutes=total_taking_time_in_minutes -
org_taking_time_in_minutes)
row.price_with_task = new_price
row.laundry_apply_all = laundry_apply_all
# 빨래의 경우는 시간 변경이 없으므로 마지막에 바로 적용
# about laundry
print '5'
all_upcoming_bookings = session.query(Booking) \
.filter(Booking.request_id == request_id) \
.filter(Booking.cleaning_status == BC.BOOKING_UPCOMMING) \
.filter(Booking.appointment_index >= appointment_index) \
.all()
if laundry_apply_all == 1: # 전체 선택
for booking in all_upcoming_bookings:
bits = "{0:07b}".format(booking.additional_task)
if bits[4] == '0': # 빨래가 세팅되어 있다면
booking.additional_task += 4 # 빨래
booking.laundry_apply_all = laundry_apply_all
elif laundry_apply_all == -2: # 선택 해제
for booking in all_upcoming_bookings:
bits = "{0:07b}".format(booking.additional_task)
if bits[4] == '1': # 빨래가 세팅되어 있다면
booking.additional_task -= 4 # 빨래 제거
booking.laundry_apply_all = laundry_apply_all
print '6'
session.commit()
# alim talk
user_name = userdao.get_user_name(uid)
additional_task_str = additional_task_string(additional_task)
#for manager_phone in MANAGERS_CALL.split(','):
# send_alimtalk(manager_phone, 'noti_manager_modify_task', user_name, additional_task_str)
# log to mixpanel
mix.track(
uid, 'update additional task', {
'time': dt.datetime.now(),
'booking_id': booking_id,
'additional_task': additional_task,
'new_price': new_price,
'total_taking_time': total_taking_time,
'laundry_apply_all': laundry_apply_all
})
# log to mongo
mongo_logger.debug('update additional task',
extra={
'user_id': uid,
'booking_id': booking_id,
'additional_task': additional_task,
'new_price': new_price,
'total_taking_time': total_taking_time,
'laundry_apply_all': laundry_apply_all
})
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
except NoResultFound, e:
print_err_detail(e)
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_no_record'])
return
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
uid = self.get_argument('uid', '')
appointment_type = self.get_argument('appointment_type', BC.ONE_TIME)
additional_task = self.get_argument('additional_task', 0)
date = self.get_argument('date', dt.datetime.strftime(dt.datetime.now(), '%Y%m%d'))
time = self.get_argument('time', '08:00')
taking_time = self.get_argument('taking_time', 25)
first_added_time = self.get_argument('first_added_time', 0)
additional_time = self.get_argument('additional_time', 10)
have_pet = self.get_argument('have_pet', 0)
master_gender = self.get_argument('master_gender', 0)
isdirty = self.get_argument('isdirty', 0)
master_ids = self.get_argument('master_ids', [])
# convert parameters
selected_date_str = date
selected_date = dt.datetime.strptime(date, '%Y%m%d')
master_ids = master_ids.split(',')
appointment_type = int(appointment_type)
additional_task = int(additional_task)
taking_time = int(taking_time)
first_added_time = int(first_added_time)
additional_time = int(additional_time)
have_pet = int(have_pet)
master_gender = int(master_gender) # 0 dont care 1 women
isdirty = int(isdirty)
print additional_task, type(additional_task)
if additional_task > 64: # ios typo bug temporary fix
additional_task = str(additional_task)
additional_task = int(additional_task, 2)
if additional_task >= 64:
additional_task -= 64
taking_time_in_minutes = taking_time
first_added_time_in_minutes = first_added_time
additional_time_in_minutes = additional_time
total_taking_time_in_minutes = taking_time_in_minutes + first_added_time_in_minutes + additional_time_in_minutes
print '*' * 50
print additional_task
print '*' * 50
if isdirty == 1:
total_taking_time_in_minutes += 120
# logging part
mix = get_mixpanel()
mongo_logger = get_mongo_logger()
try:
booking_info = {}
masterdao = MasterDAO()
holder = IntermediateValueHolder()
cal_appointment_type = appointment_type
if cal_appointment_type == BC.ONE_TIME_BUT_CONSIDERING:
cal_appointment_type = BC.ONE_TIME
count_of_iteration = cal_appointment_type * 2 + 1 # 2 months
date_list = []
if cal_appointment_type == BC.ONE_TIME:
week_const = 0
else:
week_const = 4 / cal_appointment_type
for i in xrange(count_of_iteration):
date = selected_date + dt.timedelta(weeks = week_const * i)
date = dt.datetime.strftime(date, '%Y%m%d')
date_list.append(date)
booking_info['dates'] = date_list
booking_info['time'] = time
booking_info['appointment_type'] = appointment_type
booking_info['additional_task'] = additional_task
booking_info['have_pet'] = have_pet
booking_info['master_gender'] = master_gender
booking_info['isdirty'] = isdirty
booking_info['user_id'] = uid
booking_info['taking_time'] = taking_time_in_minutes
booking_info['first_added_time'] = first_added_time_in_minutes
booking_info['additional_time'] = additional_time_in_minutes
booking_info['total_time'] = total_taking_time_in_minutes
# 각 마스터별로 예약이 가능한지 메모리에서 다시 한번 확인.
# 선택한 값을 메모리에 키로 저장하여 중복되는 예약 방지.
# 선택 했으면 선택된 정보를 가지고 있어야 함
master_num = len(master_ids)
i = 0
while i < master_num: # 랭킹이 높은 홈마스터별로 확인
mid = master_ids[i]
master_date_keys = []
name, img_url, avg_rating = masterdao.get_master_name_img_and_average_rating(mid)
booking_info['master_id'] = mid
booking_info['name'] = name
booking_info['img_url'] = img_url
booking_info['avg_rating'] = avg_rating
# 날짜별 키 생성
for date in date_list:
key = '%s_%s' % (mid, date)
master_date_keys.append(key)
# 저장할 키 생성
booking_item_key = '%s_%s_%d' % (uid, master_date_keys[0], appointment_type)
# 가능 일정을 미리 호출한 고객과, 그 바로 직후 휴무 신청을 한 홈마스터의 경우, 예약이 불가 하기 때문에 체크하도록 함
if holder.store_keys(master_date_keys) and not masterdao.is_master_off_date(mid, selected_date.date()): # 메모리에 키가 하나도 없을 때, 즉 예약이 가능할 때
holder.store(booking_item_key, booking_info)
master_date_keys = ','.join(master_date_keys)
booking_info['search_keys'] = master_date_keys
booking_info['store_key'] = booking_item_key
ret['response'] = booking_info
self.set_status(Response.RESULT_OK)
# log to mixpanel
mix.track(uid, 'select schedule', {'time' : dt.datetime.now(), 'user_id' : uid, 'master_id' : mid, 'sel_date' : selected_date_str, 'sel_time' : time, 'taking_time' : taking_time, 'additional_time' : additional_time, 'appointment_type' : appointment_type, 'have_pet' : have_pet, 'master_gender' : master_gender,'isdirty' : isdirty})
# log to mongo
mongo_logger.debug('select schedule', extra = {'user_id' : uid, 'master_id' : mid, 'sel_date' : selected_date_str, 'sel_time' : time, 'taking_time' : taking_time, 'additional_time' : additional_time, 'appointment_type' : appointment_type, 'have_pet' : have_pet, 'master_gender' : master_gender,'isdirty' : isdirty})
return
i += 1
# when not available
# log to mixpanel
mix.track(uid, 'cannot select schedule admin', {'time' : dt.datetime.now(), 'user_id' : uid, 'sel_date' : selected_date_str, 'sel_time' : time, 'taking_time' : taking_time, 'additional_time' : additional_time, 'appointment_type' : appointment_type, 'have_pet' : have_pet, 'master_gender' : master_gender,'isdirty' : isdirty})
# log to mongo
mongo_logger.debug('cannot select schedule admin', extra = {'log_time' : dt.datetime.now(), 'user_id' : uid, 'sel_date' : selected_date_str, 'sel_time' : time, 'taking_time' : taking_time, 'additional_time' : additional_time, 'appointment_type' : appointment_type, 'have_pet' : have_pet, 'master_gender' : master_gender,'isdirty' : isdirty})
# other users preempt homemasters, so no homemaster available
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_homemaster_occupied'])
return
except Exception, e:
add_err_message_to_response(ret, err_dict['err_mysql'])
self.set_status(Response.RESULT_SERVERERROR)
print_err_detail(e)
mongo_logger.error('error request select schedules', extra = {'user_id' : uid, 'err' : str(e)})
def post(self):
self.set_header("Content-Type", "application/json")
master_id = self.get_argument('master_id', '')
ret = {}
# 해당 마스터의 상태를 deactivate 시킨다.
# 남아있는 일정이 있다면 모든 일정을 다른 마스터에게 양도 한다.
try:
session = Session()
userdao = UserDAO()
addrdao = AddressDAO()
masterdao = MasterDAO()
holder = IntermediateValueHolder()
# deactivate master
row = session.query(Master).filter(Master.id == master_id).one()
row.active = 0
session.commit()
# automatically assign that master's remain jobs to other masters
masterdao = MasterDAO()
request_ids = masterdao.get_distinct_req_ids(master_id)
matched_booking_groups = []
unmatched_booking_groups = []
for req_id in request_ids:
reqs = session.query(Booking, User, UserAddress) \
.join(User, User.id == Booking.user_id) \
.join(UserAddress, and_(Booking.user_id == UserAddress.user_id, Booking.addr_idx == UserAddress.user_addr_index)) \
.filter(Booking.request_id == req_id).filter(Booking.cleaning_status == BC.BOOKING_UPCOMMING) \
.order_by(Booking.start_time) \
.all()
key = userdao.get_user_salt_by_id(reqs.User.id)[:16]
crypto = aes.MyCrypto(key)
dates = []
datetimes = []
max_taking_time_in_minutes = 0
for item in reqs:
appointment_type = item.Booking.appointment_type
address = crypto.decodeAES(item.UserAddress.address)
geohash5 = item.UserAddress.geohash5
geohash6 = item.UserAddress.geohash6
start_time = item.Booking.start_time
end_time = item.Booking.estimated_end_time
# 최대 시간 기준으로 할당을 잡음
taking_time_in_minutes = time_to_minutes(
timedelta_to_time(end_time - start_time))
if taking_time_in_minutes > max_taking_time_in_minutes:
max_taking_time_in_minutes = taking_time_in_minutes
gu_id = addrdao.get_gu_id(address)
dates.append(
int(dt.datetime.strftime(start_time, '%Y%m%d')))
datetimes.append(start_time)
uid = item.Booking.user_id
time_range_begin = datetimes[0].hour
time_range_begin_min = datetimes[0].minute
time_range_end = datetimes[0].hour
time_range_end_min = datetimes[0].minute
have_pet = item.Booking.havepet
master_gedner = item.Booking.master_gender
schedule_by_date_list = masterdao.get_master_schedule_by_dates(
gu_id, have_pet, master_gender, dates)
success, msg, store_key, search_keys, result = masterdao.find_master_by_score(schedule_by_date_list, \
gu_id, \
uid, \
appointment_type, \
dates, \
time_range_begin, \
time_range_begin_min, \
time_range_end, \
time_range_end_min, \
max_taking_time_in_minutes, \
geohash6)
if success == 'SUCCESS':
matched_booking_groups.append(req_id)
matched_list = session.query(Booking) \
.filter(Booking.request_id == req_id) \
.filter(Booking.cleaning_status == BC.BOOKING_UPCOMMING) \
.all()
for match in matched_list:
match.master_id = result[0]['mid']
session.commit()
holder.remove(store_key)
for sk in search_keys:
holder.remove(sk)
else:
unmatched_booking_groups.append(req_id)
unmatched_list = session.query(Booking) \
.filter(Booking.request_id == req_id) \
.filter(Booking.cleaning_status == BC.BOOKING_UPCOMMING) \
.all()
for unmatch in unmatched_list:
print unmatch
unmatch.master_id = None
session.commit()
ret['response'] = {
'matched_group': matched_booking_groups,
'unmatched_group': unmatched_booking_groups
}
self.set_status(Response.RESULT_OK)
except NoResultFound, e:
session.rollback()
print_err_detail(e)
self.set_status(Response.RESULT_SERVERERROR)
add_err_message_to_response(ret, err_dict['err_no_record'])
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
uid = self.get_argument('uid', '')
search_keys = self.get_argument('search_keys', '')
store_key = self.get_argument('store_key', '')
price = self.get_argument('price', 0)
price_with_task = self.get_argument('price_with_task', 0)
wage_per_hour = self.get_argument('wage_per_hour', 0)
address_index = self.get_argument('address_index', 0)
discounted_price = self.get_argument('discounted_price', 0)
promotion_code = self.get_argument('promotion_code', '')
coupon_id = self.get_argument('coupon_id', '')
coupon_discount_price = self.get_argument('coupon_discount_price', 0)
laundry_apply_all = self.get_argument(
'laundry_apply_all', 0) # -1 - 없앰, 0 - one time, 1 - all time
user_type = self.get_argument('user_type', 'unknown')
# convert datetime
# for ios fix
if discounted_price != 0:
discounted_price = discounted_price.replace('Optional(',
'').replace(')', '')
price = int(price)
price_with_task = int(price_with_task)
discounted_price = int(discounted_price)
coupon_discount_price = int(coupon_discount_price)
laundry_apply_all = int(laundry_apply_all)
wage_per_hour = int(wage_per_hour)
print 'price_with_task', price_with_task
print 'discounted_price', discounted_price
search_keys = search_keys.split(',')
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
userdao = UserDAO()
masterdao = MasterDAO()
promotiondao = PromotionDAO()
addressdao = AddressDAO()
coupondao = CouponDAO()
holder = IntermediateValueHolder()
# request id to group each individual bookings
request_id = str(uuid.uuid4())
obj = holder.retrieve(store_key)
print obj
if obj == None:
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_booking_timeout'])
mix.track(uid, 'request timeout', {'time': dt.datetime.now()})
mongo_logger.error('%s got timed out' % uid)
return
# retrieve all stored values
uid = obj['user_id']
mid = obj['master_id']
dates = obj['dates']
time = obj['time']
appointment_type = obj['appointment_type']
additional_task = obj['additional_task']
org_additional_task = additional_task
taking_time = obj['taking_time']
first_added_time = obj['first_added_time']
additional_time = obj['additional_time']
total_time = obj['total_time']
master_gender = obj['master_gender']
have_pet = obj['have_pet']
isdirty = obj['isdirty']
is_b2b = userdao.is_b2b(uid)
# hasids to generate unique booking id
now = dt.datetime.strftime(dt.datetime.now(), '%Y%m%d%H%M%S')
hashids = Hashids(min_length=16, salt=now + uid)
# set tool info
havetools = 1
if additional_task >= 64:
havetools = 0
card_idx = 0
addr_idx = 0
# get card and address idx
if is_b2b:
addr_idx = address_index
else:
addr_idx = userdao.get_user_default_address_index(uid)
card_idx = userdao.get_user_default_card_index(uid)
i = 1
booking_ids = []
start_time_list = []
for date in dates: #
print date, time
booking_id = hashids.encode(int(date + time.replace(':', '')))
print 'key', booking_id
master_id = mid
date = dt.datetime.strptime(date, '%Y%m%d')
dow = date.date().weekday()
booking_time = dt.time(hour=int(time.split(':')[0]),
minute=int(time.split(':')[1]))
start_time = dt.datetime.combine(date, booking_time)
estimated_end_time = start_time + dt.timedelta(
minutes=total_time)
cleaning_duration = taking_time
actual_price = 0
if i == 1: # 1 번째 클리닝
actual_price = price_with_task - (
discounted_price + coupon_discount_price
) # 할인은 1회만 적용됨
else: # 나머지
actual_price = price
if havetools == 1:
additional_task = 0
else:
additional_task = 64
if laundry_apply_all == 1:
additional_task += 4 # 빨래
isdirty = 0 # 첫째 이후에는 is dirty는 0
estimated_end_time = estimated_end_time - dt.timedelta(
minutes=additional_time + first_added_time)
booking = Booking(
id=booking_id,
request_id=request_id,
user_id=uid,
master_id=mid,
appointment_type=appointment_type,
appointment_index=i,
dow=dow,
booking_time=dt.datetime.now(),
org_start_time=start_time,
start_time=start_time,
estimated_end_time=estimated_end_time,
end_time=
estimated_end_time, # update after homemaster finish their job
cleaning_duration=cleaning_duration,
additional_task=additional_task,
price=price,
price_with_task=actual_price,
charging_price=0,
card_idx=card_idx,
addr_idx=addr_idx,
havetools=havetools,
havepet=have_pet,
laundry_apply_all=laundry_apply_all,
is_dirty=isdirty,
master_gender=master_gender,
user_type=user_type,
wage_per_hour=wage_per_hour,
status=BC.BOOKING_UPCOMMING,
cleaning_status=BC.BOOKING_UPCOMMING,
payment_status=BC.BOOKING_UNPAID_YET)
i += 1
session.add(booking)
booking_ids.append(booking_id)
start_time_list.append(start_time)
#print 'booking_id', booking_id, 'was added..'
# charge for first appointment date
user_name = userdao.get_user_name(uid)
if is_b2b:
session.commit()
# remove store_key and related_keys
holder.remove(store_key)
for sk in search_keys:
holder.remove(sk)
send_jandi('NEW_BOOKING', '[b2b]새 예약 알림', 'b2b 고객님 예약완료',
user_name)
# b2b용 알림톡 추가 필요
ret['response'] = booking_ids[0]
self.set_status(Response.RESULT_OK)
mongo_logger.debug('b2b confirm booking',
extra={
'user_id': uid,
'master_id': mid,
'booking_id': booking_ids[0]
})
return
charge_price = price_with_task - (discounted_price +
coupon_discount_price)
# 1주 1회면서, 이벤트 기간인 경우에는 결제 하지 않음
import redis
try:
from utils.secrets import REDIS_HOST, REDIS_PORT, REDIS_PWD
except ImportError:
REDIS_HOST = 'localhost'
REDIS_PORT = 6379
REDIS_PWD = ''
r = redis.Redis(host=REDIS_HOST,
port=REDIS_PORT,
password=REDIS_PWD)
event_on = r.get('free_event')
print event_on
if appointment_type == 4 and event_on:
charge_price = price_with_task - price
# 1회 이벤트 고객임을 명시해야함
# table 필요
free_event = UserFreeEvent(booking_request_id=request_id,
user_id=uid,
datetime=dt.datetime.now())
session.add(free_event)
if charge_price <= 0:
ret_code = True
msg = ''
else:
ret_code, msg = request_payment(uid, user_name, booking_ids[0],
charge_price, appointment_type)
# 결제 정보 출력
print user_name, ret_code, msg
if ret_code:
session.commit()
# remove store_key and related_keys
holder.remove(store_key)
for sk in search_keys:
holder.remove(sk)
# promotion code 와 연결
if promotion_code != '':
promotiondao.set_promotion_code_status(
promotion_code, 1, booking_ids[0], price_with_task)
if coupon_id != '':
coupondao.set_coupon_status(coupon_id, 1, booking_ids[0],
price_with_task)
# change status to paid
try:
first_booking = session.query(Booking, User, MasterPushKey) \
.join(User, Booking.user_id == User.id) \
.outerjoin(MasterPushKey, Booking.master_id == MasterPushKey.master_id) \
.filter(Booking.id == booking_ids[0]) \
.one()
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
mongo_logger.debug('no first booking record',
extra={
'uid': uid,
'mid': mid,
'appointment_type':
appointment_type,
'have_pet': have_pet,
'master_gender': master_gender,
'isdirty': isdirty
})
add_err_message_to_response(ret, err_dict['err_no_record'])
return
except MultipleResultsFound, e:
session.close()
self.set_status(Response.RESULT_OK)
mongo_logger.debug('multiple first booking record',
extra={
'uid': uid,
'mid': mid,
'appointment_type':
appointment_type,
'have_pet': have_pet,
'master_gender': master_gender,
'isdirty': isdirty
})
add_err_message_to_response(
ret, err_dict['err_multiple_record'])
return
def post(self):
self.set_header("Content-Type", "application/json")
ret = {}
date = self.get_argument('date', dt.datetime.strftime(dt.datetime.now(), '%Y%m%d'))
time = self.get_argument('start_time', '08:00')
master_ids = self.get_argument('master_ids', [])
comb_key = self.get_argument('comb_key', '')
# convert parameters
selected_date_str = date
selected_date = dt.datetime.strptime(date, '%Y%m%d')
master_ids = master_ids.split(',')
keys = comb_key.split('_')
# logging part
mix = get_mixpanel()
mongo_logger = get_mongo_logger()
try:
booking_info = {}
masterdao = MasterDAO()
holder = IntermediateValueHolder()
print comb_key
appointment_type = int(comb_key.split('_')[2])
date_list = []
if appointment_type == BC.ONE_TIME:
count_of_iteration = 1
week_const = 0
else:
count_of_iteration = appointment_type * 2 # 2 months
week_const = 4 / appointment_type
for i in xrange(count_of_iteration):
date = selected_date + dt.timedelta(weeks = week_const * i)
date = dt.datetime.strftime(date, '%Y%m%d')
date_list.append(date)
booking_info['dates'] = date_list
booking_info['time'] = time
booking_info['comb_key'] = comb_key
house_type = comb_key.split('_')[0]
if house_type == 'officetel':
house_type = 0
elif house_type == 'rowhouse':
house_type = 1
else:
house_type = 2
house_type = int(house_type)
house_size = int(comb_key.split('_')[1])
additional_task = int(comb_key.split('_')[3])
print comb_key
print appointment_type, house_type, house_size
_, cleaning_duration, _, _ = get_time_price(appointment_type, house_type, house_size)
booking_info['cleaning_duration'] = cleaning_duration
task_time, _ = get_additional_task_time_price(additional_task, house_type, house_size)
booking_info['additional_time'] = task_time
print task_time
# 각 마스터별로 예약이 가능한지 메모리에서 다시 한번 확인.
# 선택한 값을 메모리에 키로 저장하여 중복되는 예약 방지.
# 선택 했으면 선택된 정보를 가지고 있어야 함
master_num = len(master_ids)
i = 0
while i < master_num: # 랭킹이 높은 홈마스터별로 확인
mid = master_ids[i]
master_date_keys = []
name, img_url, avg_rating = masterdao.get_master_name_img_and_average_rating(mid)
booking_info['master_id'] = mid
booking_info['name'] = name
booking_info['img_url'] = img_url
booking_info['avg_rating'] = avg_rating
now = dt.datetime.strftime(dt.datetime.now(), '%Y%m%d%H%M%S')
hashids = Hashids(min_length = 16, salt = now + comb_key)
booking_id = hashids.encode(int(date + time.replace(':', '')))
booking_info['id'] = booking_id
# 날짜별 키 생성
for date in date_list:
key = '%s_%s' % (mid, date)
master_date_keys.append(key)
# 저장할 키 생성
#booking_item_key = '%s_%s' % (comb_key, master_date_keys[0])
if holder.store_keys(master_date_keys, source = '11st') and not masterdao.is_master_off_date(mid, selected_date.date()): # 메모리에 키가 하나도 없을 때, 즉 예약이 가능할 때
master_date_keys = ','.join(master_date_keys)
booking_info['search_keys'] = master_date_keys
booking_info['store_key'] = booking_id # 11번가의 경우는, 미리 생성한 아이디 키로 한다.
holder.store(booking_id, booking_info, source = '11st')
# for 11st response
ret['response'] = {'booking_available' : 'Y', 'booking_id' : booking_id}
self.set_status(Response.RESULT_OK)
# log to mixpanel
#mix.track(uid, '11 select schedule', {'time' : dt.datetime.now(), 'user_id' : uid, 'master_id' : mid, 'sel_date' : selected_date_str, 'sel_time' : time, 'taking_time' : taking_time, 'additional_time' : additional_time, 'appointment_type' : appointment_type, 'have_pet' : have_pet, 'master_gender' : master_gender,'isdirty' : isdirty})
# log to mongo
mongo_logger.debug('11 select schedule', extra = {'master_id' : mid, 'sel_date' : selected_date_str, 'sel_time' : time, 'comb_key' : comb_key})
return
i += 1
# when not available
# log to mongo
mongo_logger.debug('11 cannot select schedule', extra = {'sel_date' : selected_date_str, 'sel_time' : time, 'comb_key' : comb_key})
# other users preempt homemasters, so no homemaster available
self.set_status(Response.RESULT_OK)
ret['response'] = {'booking_available' : 'N'}
return
except Exception, e:
add_err_message_to_response(ret, err_dict['err_mysql'])
self.set_status(Response.RESULT_SERVERERROR)
print_err_detail(e)
mongo_logger.error('error 11 request select schedules', extra = {'err' : str(e)})
add_err_message_to_response(ret, err_dict['err_no_record'])
return
except MultipleResultsFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_multiple_record'])
return
uid = row.user_id
price_with_task = row.price_with_task
appointment_type = row.appointment_type
org_master_id = row.master_id
holder = IntermediateValueHolder()
org_date = dt.datetime.strftime(row.start_time, '%m월%d일')
time_changed = changed[2]
task_changed = changed[1]
msg_changed = changed[0]
print time_changed, task_changed, msg_changed
print type(time_changed)
# booking can not be updated within 24 hours ahead
appointment_time = row.start_time
current_time = dt.datetime.now()
diff_in_hours = (appointment_time -
current_time).total_seconds() / 3600
def post(self):
self.set_header("Content-Type", "application/json")
booking_id = self.get_argument('booking_id', '')
new_master_id = self.get_argument('new_master_id', '')
ret = {}
try:
session = Session()
userdao = UserDAO()
addrdao = AddressDAO()
masterdao = MasterDAO()
holder = IntermediateValueHolder()
row = session.query(Booking).filter(Booking.id == booking_id).one()
uid = row.user_id
master_id_to_change = row.master_id
org_start_time = row.start_time
org_end_time = row.estimated_end_time
appointment_type = 0 # 여기서는 1회 청소로 한다. 편집이기 때문에
have_pet = row.havepet
master_gender = row.master_gender
addr_idx = row.addr_idx
taking_time_in_minutes = time_to_minutes(timedelta_to_time(org_end_time - org_start_time))
address, geohash5, geohash6 = userdao.get_user_address_by_index(uid, addr_idx)
gu_id = addrdao.get_gu_id(address)
dates = [int(dt.datetime.strftime(org_start_time, '%Y%m%d'))]
time_range_begin = org_start_time.hour
time_range_begin_min = org_start_time.minute
time_range_end = org_start_time.hour
time_range_end_min = org_start_time.minute
print gu_id, dates
print time_range_begin
print time_range_begin_min
print time_range_end
print time_range_end_min
print taking_time_in_minutes
schedule_by_date_list = masterdao.get_master_schedule_by_dates(gu_id, have_pet, master_gender, dates, new_master_id)
print schedule_by_date_list
success, msg, store_key, search_keys, result = masterdao.find_master_by_score(schedule_by_date_list, \
gu_id, \
uid, \
appointment_type, \
dates, \
time_range_begin, \
time_range_begin_min, \
time_range_end, \
time_range_end_min, \
taking_time_in_minutes, \
geohash6)
if success != 'SUCCESS':
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_no_hm_at_that_time'])
#self.write(json.dumps(ret))
print booking_id, ' WAS NOT ... successfully updated to master_id : ', new_master_id
return
else:
row.master_id = result[0]['mid']
if master_id_to_change != row.master_id:
row.is_master_changed = 1
session.commit()
holder.remove(store_key)
for sk in search_keys:
holder.remove(sk)
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
print booking_id, ' was successfully updated to master_id : ', new_master_id
except Exception, e:
session.rollback()
print_err_detail(e)
self.set_status(Response.RESULT_SERVERERROR)
add_err_message_to_response(ret, err_dict['err_mysql'])
def post(self):
self.set_header("Content-Type", "application/json")
ret = {}
store_key = self.get_argument('store_key', '')
uid = self.get_argument('uid', '')
mid = self.get_argument('mid', '')
appointment_type = self.get_argument('appointment_type', BC.ONE_TIME)
additional_task = self.get_argument('additional_task', 0)
discounted_price = self.get_argument('discounted_price', 0)
price = self.get_argument('price', 0)
price_with_task = self.get_argument('price_with_task', 0)
promotion_code = self.get_argument('promotion_code', '')
have_pet = self.get_argument('have_pet', 0)
search_keys = self.get_argument('search_keys', '')
master_gender = self.get_argument('master_gender', 0)
isdirty = self.get_argument('isdirty', 0)
first_added_time = self.get_argument('first_added_time', 0)
additional_time = self.get_argument('additional_time', 10)
laundry_apply_all = self.get_argument('laundry_apply_all', 0) # -1 - 없앰, 0 - one time, 1 - all time
# convert datetime
appointment_type = int(appointment_type)
additional_task = int(additional_task)
price = int(price)
price_with_task = int(price_with_task)
discounted_price = int(discounted_price)
have_pet = int(have_pet)
master_gender = int(master_gender)
isdirty = int(isdirty)
laundry_apply_all = int(laundry_apply_all)
first_added_time = int(first_added_time)
additional_time = int(additional_time)
first_added_time_in_minutes = first_added_time * 6
additional_time_in_minutes = additional_time * 6
print first_added_time, additional_time
search_keys = search_keys.split(',')
havetools = 1
if additional_task >= 64:
havetools = 0
mongo_logger = get_mongo_logger()
mongo_logger.debug('%s request booking' % uid, extra = { 'uid' : uid, 'mid' : mid,
'appointment_type' : appointment_type,
'have_pet' : have_pet, 'master_gender' : master_gender,
'isdirty' : isdirty})
mix = get_mixpanel()
try:
session = Session()
userdao = UserDAO()
promotiondao = PromotionDAO()
holder = IntermediateValueHolder()
card_idx = 0
addr_idx = 0
# get card and address idx
addr_idx = userdao.get_user_default_address_index(uid)
card_idx = userdao.get_user_default_card_index(uid)
# hasids to generate unique booking id
now = dt.datetime.strftime(dt.datetime.now(), '%Y%m%d%H%M%S')
hashids = Hashids(min_length = 16, salt = now + uid)
print 'salt : ', now + uid
# request id to group each individual bookings
request_id = str(uuid.uuid4())
obj = holder.retrieve(store_key)
if obj == None:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_booking_timeout'])
mix.track(uid, 'request timeout', {'time' : dt.datetime.now()})
mongo_logger.error('%s got timed out' % uid)
self.write(json.dumps(ret))
return
i = 1
booking_ids = []
start_time_list = []
obj = sorted(obj, key = lambda x: x['date'])
for item in obj:
print item['date']
booking_id = hashids.encode(int(item['date'] + time_to_str(item['start_time'])))
master_id = item['mid']
dow = dt.datetime.strptime(item['date'], '%Y%m%d').date().weekday()
start_time = dt.datetime.combine(dt.datetime.strptime(item['date'], '%Y%m%d'), item['start_time'])
estimated_end_time = dt.datetime.combine(dt.datetime.strptime(item['date'], '%Y%m%d'), item['end_time'])
cleaning_duration = time_to_minutes(timedelta_to_time(estimated_end_time - dt.timedelta(minutes=additional_time_in_minutes + first_added_time_in_minutes) - start_time))
actual_price = 0
if i == 1: # 1 번째 클리닝
actual_price = price_with_task - discounted_price # 할인은 1회만 적용됨
else: # 나머지
actual_price = price
if havetools == 1:
additional_task = 0
else:
additional_task = 64
#actual_price += BC.VACCUM_CHARGE
if laundry_apply_all == 1:
additional_task += 4 # 빨래
isdirty = 0 # 첫째 이후에는 is dirty는 0
estimated_end_time = estimated_end_time - dt.timedelta(minutes=additional_time_in_minutes + first_added_time_in_minutes)
booking = Booking(id = booking_id,
request_id = request_id,
user_id = uid,
master_id = mid,
appointment_type = appointment_type,
appointment_index = i,
dow = dow,
booking_time = dt.datetime.now(),
org_start_time = start_time,
start_time = start_time,
estimated_end_time = estimated_end_time,
end_time = estimated_end_time, # update after homemaster finish their job
cleaning_duration = cleaning_duration,
additional_task = additional_task,
price = price,
price_with_task = actual_price,
charging_price = 0,
card_idx = card_idx,
addr_idx = addr_idx,
havetools = havetools,
havepet = have_pet,
laundry_apply_all = laundry_apply_all,
is_dirty = isdirty,
master_gender = master_gender,
status = BC.BOOKING_UPCOMMING,
cleaning_status = BC.BOOKING_UPCOMMING,
payment_status = BC.BOOKING_UNPAID_YET)
i += 1
session.add(booking)
booking_ids.append(booking_id)
start_time_list.append(start_time)
#print 'booking_id', booking_id, 'was added..'
# charge for first appointment date
user_name = userdao.get_user_name(uid)
if price_with_task - discounted_price <= 0:
ret_code = True
msg = ''
else:
ret_code, msg = request_payment(uid, user_name, booking_ids[0], price_with_task - discounted_price, appointment_type)
# 결제 정보 출력
print user_name, ret_code, msg
if ret_code:
session.commit()
# remove store_key and related_keys
holder.remove(store_key)
for sk in search_keys:
holder.remove(sk)
# promotion code 와 연결
if promotion_code != '':
promotiondao.set_promotion_code_status(promotion_code, 1, booking_ids[0], price_with_task)
# change status to paid
try:
first_booking = session.query(Booking).filter(Booking.id == booking_ids[0]).one()
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
mongo_logger.debug('no first booking record', extra = { 'uid' : uid, 'mid' : mid,'appointment_type' : appointment_type, 'have_pet' : have_pet, 'master_gender' : master_gender, 'isdirty' : isdirty})
add_err_message_to_response(ret, err_dict['err_no_record'])
return
except MultipleResultsFound, e:
session.close()
self.set_status(Response.RESULT_OK)
mongo_logger.debug('multiple first booking record', extra = { 'uid' : uid, 'mid' : mid, 'appointment_type' : appointment_type, 'have_pet' : have_pet, 'master_gender' : master_gender, 'isdirty' : isdirty})
add_err_message_to_response(ret, err_dict['err_multiple_record'])
return
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
uid = self.get_argument('uid', '')
search_keys = self.get_argument('search_keys', '')
store_key = self.get_argument('store_key', '')
#price = self.get_argument('price', 0)
#price_with_task = self.get_argument('price_with_task', 0)
#discounted_price = self.get_argument('discounted_price', 0)
promotion_code = self.get_argument('promotion_code', '')
laundry_apply_all = self.get_argument(
'laundry_apply_all', 0) # -1 - 없앰, 0 - one time, 1 - all time
has_card = self.get_argument('has_card', 0)
# ---------- card paremeters ------------
cno = self.get_argument('cno', '')
expy = self.get_argument('expy', '')
expm = self.get_argument('expm', '')
ssnf = self.get_argument('ssnf', '')
cpftd = self.get_argument('cpftd', '')
calias = self.get_argument('calias', '')
# register card
request_url = '%s:%d/homemaster_payment/register_card' % (PAYMENT_HOST,
PAYMENT_PORT)
params = {}
params['id'] = uid
params['cno'] = cno
params['expy'] = expy
params['expm'] = expm
params['ssnf'] = ssnf
params['cpftd'] = cpftd
params['calias'] = calias
has_card = int(has_card)
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
# 카드가 없는 경우에만 카드 등록하고 진행, 있다면 바로 진행
if has_card == 0:
response = requests.post(request_url, data=params)
result = json.loads(response.text)
if response.status_code != 200 or result['response'] == "":
print 'An error occurred while register card'
print result['err_code'], result['err_msg']
add_err_ko_message_to_response(ret, result['err_msg'])
mongo_logger.error('register card failed', extra={'uid': uid})
return
laundry_apply_all = int(laundry_apply_all)
search_keys = search_keys.split(',')
try:
session = Session()
userdao = UserDAO()
masterdao = MasterDAO()
promotiondao = PromotionDAO()
addressdao = AddressDAO()
holder = IntermediateValueHolder()
# request id to group each individual bookings
request_id = str(uuid.uuid4())
obj = holder.retrieve(store_key)
print obj
if obj == None:
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_booking_timeout'])
mix.track(uid, 'request timeout', {'time': dt.datetime.now()})
mongo_logger.error('%s got timed out' % uid)
return
# retrieve all stored values
uid = obj['user_id']
mid = obj['master_id']
dates = obj['dates']
time = obj['time']
appointment_type = obj['appointment_type']
additional_task = obj['additional_task']
org_additional_task = additional_task
taking_time = obj['taking_time']
first_added_time = obj['first_added_time']
additional_time = obj['additional_time']
total_time = obj['total_time']
master_gender = obj['master_gender']
have_pet = obj['have_pet']
isdirty = obj['isdirty']
# price
# price_with_task
# discounted_price
address, house_size, house_type = userdao.get_user_address_detail(
uid)
_, _, price, _ = get_time_price(appointment_type, house_type,
house_size)
_, additional_price = get_additional_task_time_price(
additional_task, house_type, house_size)
discounted_price = 0
if promotion_code != '':
discounted_price = promotiondao.get_discount_price(
promotion_code)
price_with_task = price + additional_price
if 0 < discounted_price <= 100:
price_with_task *= (float(100 - discounted_price) / 100)
else:
price_with_task -= discounted_price
price_with_task = int(price_with_task)
print '-' * 30
print price, additional_price
print promotion_code, price_with_task
print '##' * 20
# hasids to generate unique booking id
now = dt.datetime.strftime(dt.datetime.now(), '%Y%m%d%H%M%S')
hashids = Hashids(min_length=16, salt=now + uid)
# set tool info
havetools = 1
if additional_task >= 64:
havetools = 0
card_idx = 0
addr_idx = 0
# get card and address idx
addr_idx = userdao.get_user_default_address_index(uid)
card_idx = userdao.get_user_default_card_index(uid)
i = 1
booking_ids = []
start_time_list = []
for date in dates: #
print date, time
booking_id = hashids.encode(int(date + time.replace(':', '')))
print 'key', booking_id
master_id = mid
date = dt.datetime.strptime(date, '%Y%m%d')
dow = date.date().weekday()
booking_time = dt.time(hour=int(time.split(':')[0]),
minute=int(time.split(':')[1]))
start_time = dt.datetime.combine(date, booking_time)
estimated_end_time = start_time + dt.timedelta(
minutes=total_time)
cleaning_duration = taking_time
actual_price = 0
if i == 1: # 1 번째 클리닝
actual_price = price_with_task # 할인은 1회만 적용됨
else: # 나머지
actual_price = price
if havetools == 1:
additional_task = 0
else:
additional_task = 64
if laundry_apply_all == 1:
additional_task += 4 # 빨래
isdirty = 0 # 첫째 이후에는 is dirty는 0
estimated_end_time = estimated_end_time - dt.timedelta(
minutes=additional_time + first_added_time)
booking = Booking(
id=booking_id,
request_id=request_id,
user_id=uid,
master_id=mid,
appointment_type=appointment_type,
appointment_index=i,
dow=dow,
booking_time=dt.datetime.now(),
org_start_time=start_time,
start_time=start_time,
estimated_end_time=estimated_end_time,
end_time=
estimated_end_time, # update after homemaster finish their job
cleaning_duration=cleaning_duration,
additional_task=additional_task,
price=price,
price_with_task=actual_price,
charging_price=0,
card_idx=card_idx,
addr_idx=addr_idx,
havetools=havetools,
havepet=have_pet,
laundry_apply_all=laundry_apply_all,
is_dirty=isdirty,
master_gender=master_gender,
status=BC.BOOKING_UPCOMMING,
cleaning_status=BC.BOOKING_UPCOMMING,
payment_status=BC.BOOKING_UNPAID_YET)
i += 1
session.add(booking)
booking_ids.append(booking_id)
start_time_list.append(start_time)
#print 'booking_id', booking_id, 'was added..'
# charge for first appointment date
user_name = userdao.get_user_name(uid)
if price_with_task <= 0:
ret_code = True
msg = ''
else:
ret_code, msg = request_payment(uid, user_name, booking_ids[0],
price_with_task,
appointment_type)
# 결제 정보 출력
print user_name, ret_code, msg
if ret_code:
session.commit()
# remove store_key and related_keys
holder.remove(store_key)
for sk in search_keys:
holder.remove(sk)
# promotion code 와 연결
if promotion_code != '':
promotiondao.set_promotion_code_status(
promotion_code, 1, booking_ids[0], price_with_task)
# change status to paid
try:
first_booking = session.query(Booking, User, MasterPushKey) \
.join(User, Booking.user_id == User.id) \
.outerjoin(MasterPushKey, Booking.master_id == MasterPushKey.master_id) \
.filter(Booking.id == booking_ids[0]) \
.one()
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
mongo_logger.debug('no first booking record',
extra={
'uid': uid,
'mid': mid,
'appointment_type':
appointment_type,
'have_pet': have_pet,
'master_gender': master_gender,
'isdirty': isdirty
})
add_err_message_to_response(ret, err_dict['err_no_record'])
return
except MultipleResultsFound, e:
session.close()
self.set_status(Response.RESULT_OK)
mongo_logger.debug('multiple first booking record',
extra={
'uid': uid,
'mid': mid,
'appointment_type':
appointment_type,
'have_pet': have_pet,
'master_gender': master_gender,
'isdirty': isdirty
})
add_err_message_to_response(
ret, err_dict['err_multiple_record'])
return
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
master_id = self.get_argument('master_id', '')
off_date = self.get_argument('off_date', '') # 20160603
debug = self.get_argument('debug', 0) # debug = 1: true 0: false
master_date_key = '{0}_{1}'.format(master_id, off_date)
off_date = dt.datetime.strptime(off_date, '%Y%m%d')
ret = {}
mongo_logger = get_mongo_logger()
try:
print "day off request ------------------------------------------- start"
holder = IntermediateValueHolder()
session = Session()
masterdao = MasterDAO()
# check redis that the master is not held
is_held = holder.exists(master_date_key)
print is_held
if is_held:
self.set_status(Response.RESULT_OK)
mongo_logger.debug('doing booking',
extra={
'master_id': master_id,
'off_date': off_date
})
add_err_ko_message_to_response(
ret, '현재 예약이 진행 중 이라 휴무 신청이 불가능 합니다.')
return
# add request logs
# type : 1 - request, 0 - cancel
day_off_request = MasterDayoffRequest(
master_id=master_id,
date=off_date,
type=1,
request_time=dt.datetime.now())
session.add(day_off_request)
# master schedules by date active -> 0
row = session.query(MasterScheduleByDate) \
.filter(MasterScheduleByDate.master_id == master_id) \
.filter(MasterScheduleByDate.date == off_date) \
.one()
row.active = 0
mongo_logger.debug('set row.active = 0',
extra={
'master_id': master_id,
'off_date': off_date
})
# commit
session.commit()
mongo_logger.debug('session.commit()',
extra={
'master_id': master_id,
'off_date': off_date
})
if debug == 0:
master_name = masterdao.get_master_name(master_id)
send_jandi('HOMEMASTER_REST', "휴무 신청",
master_name + ' 홈마스터님 휴무 신청',
'휴무날짜 : {}'.format(off_date))
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
print 'master_id', master_id, 'request dayoff request', off_date
print "day off request ------------------------------------------- end"
except NoResultFound, e:
self.set_status(Response.RESULT_OK)
mongo_logger.debug('no result',
extra={
'master_id': master_id,
'off_date': off_date
})
add_err_ko_message_to_response(ret, '휴무 신청 가능 날짜가 아닙니다.')
return
def post(self):
self.set_header("Content-Type", "application/json")
ret = {}
uid = self.get_argument('uid', '')
date = self.get_argument('date', dt.datetime.now())
start_time_range_begin = self.get_argument('range_begin',
BC.START_TIME_RANGE_BEGIN)
start_time_range_begin_min = self.get_argument('range_begin_min', 0)
start_time_range_end = self.get_argument('range_end',
BC.START_TIME_RANGE_END)
start_time_range_end_min = self.get_argument('range_end_min', 0)
appointment_type = self.get_argument('appointment_type', BC.ONE_TIME)
taking_time = self.get_argument('taking_time', 25)
first_added_time = self.get_argument('first_added_time', 0)
additional_time = self.get_argument('additional_time', 10)
have_pet = self.get_argument('have_pet', 0)
master_gender = self.get_argument('master_gender', 0)
isdirty = self.get_argument('isdirty', 0)
# convert datetime
date = dt.datetime.strptime(date, '%Y%m%d')
start_time_range_begin = int(start_time_range_begin)
start_time_range_begin_min = int(start_time_range_begin_min)
start_time_range_end = int(start_time_range_end)
start_time_range_end_min = int(start_time_range_end_min)
appointment_type = int(appointment_type)
taking_time = int(taking_time)
first_added_time = int(first_added_time)
additional_time = int(additional_time)
taking_time_in_minutes = taking_time * 6
first_added_time_in_minutes = first_added_time * 6
additional_time_in_minutes = additional_time * 6
total_taking_time_in_minutes = taking_time_in_minutes + first_added_time_in_minutes + additional_time_in_minutes
have_pet = int(have_pet)
master_gender = int(master_gender) # 0 dont care 1 women 2 men
isdirty = int(isdirty)
print 'request schedule'
print 'taking time :', taking_time_in_minutes
mongo_logger = get_mongo_logger()
mongo_logger.debug('%s request schedule' % uid,
extra={
'date': dt.datetime.strftime(date, '%Y%m%d'),
'start_time_range_begin':
start_time_range_begin,
'start_time_range_end': start_time_range_end,
'taking_time': taking_time,
'additional_time': additional_time,
'appointment_type': appointment_type,
'have_pet': have_pet,
'master_gender': master_gender,
'isdirty': isdirty
})
mix = get_mixpanel()
try:
session = Session()
userdao = UserDAO()
addrdao = AddressDAO()
masterdao = MasterDAO()
holder = IntermediateValueHolder()
# request id to group each individual bookings
request_id = str(uuid.uuid4())
# get user's address and cover address to gu code
address, geohash5, geohash6 = userdao.get_user_address(uid)
gu_id = addrdao.get_gu_id(address)
# four consecutive appointment days to make booking if regular , otherwise just one day
dates = [int(dt.datetime.strftime(date, '%Y%m%d'))]
if appointment_type == BC.ONE_TIME_A_MONTH or appointment_type == BC.TWO_TIME_A_MONTH or appointment_type == BC.FOUR_TIME_A_MONTH:
dates = [
int(
dt.datetime.strftime(
date + dt.timedelta(days=i * BC.DAYS_IN_A_WEEK *
(4 / appointment_type)),
'%Y%m%d')) for i in xrange(4)
]
# 크리스마스 및 새해 임시로 막음.
if date.date() == dt.date(2016, 2, 7) or date.date() == dt.date(
2016, 2, 8) or date.date() == dt.date(
2016, 2, 9) or date.date() == dt.date(2016, 2, 10):
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, '설날 연휴동안은, 예약이 불가능합니다.')
self.write(json.dumps(ret))
return
# 스케쥴이 이미 해당 날짜에 있다면, 있다고 표시하고 리턴함
num_schedules_on_dates = userdao.get_user_schedule_on_dates(
uid,
[dt.datetime.strptime(str(d), '%Y%m%d').date() for d in dates])
if num_schedules_on_dates > 0:
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_schedules_on_dates'])
self.write(json.dumps(ret))
return
# 똥집인 경우 3시간 추가됨.
if isdirty == 1:
if appointment_type == BC.ONE_TIME or appointment_type == BC.ONE_TIME_BUT_CONSIDERING:
total_taking_time_in_minutes += 120
print 'gu_id', gu_id, have_pet, master_gender, dates
#get available homemaster's time table day by day
schedule_by_date_list = masterdao.get_master_schedule_by_dates(
gu_id, have_pet, master_gender, dates)
success, msg, store_key, search_keys, result = masterdao.find_master_by_score(schedule_by_date_list, \
gu_id, \
uid, \
appointment_type, \
dates, \
start_time_range_begin, \
start_time_range_begin_min, \
start_time_range_end, \
start_time_range_end_min, \
total_taking_time_in_minutes, \
geohash6)
# if not successful
if success != 'SUCCESS':
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_no_hm_at_that_time'])
mix.track(
uid, 'request schedule', {
'time': dt.datetime.now(),
'date': dt.datetime.strftime(date, '%Y%m%d'),
'start_time_range_begin': start_time_range_begin,
'start_time_range_begin_min':
start_time_range_begin_min,
'start_time_range_end': start_time_range_end,
'start_time_range_end_min': start_time_range_end_min,
'taking_time': taking_time,
'additional_time': additional_time,
'appointment_type': appointment_type,
'have_pet': have_pet,
'master_gender': master_gender,
'isdirty': isdirty,
'status': 'no homemaster'
})
print uid, 'was not able to find any homemasters....'
else:
schedules = []
for row in result:
s = {}
s['date'] = row['date']
s['start_time'] = time_to_str(row['start_time'])
s['end_time'] = time_to_str(row['end_time'])
schedules.append(s)
mid = row['mid']
name, img_url, avg_rating = masterdao.get_master_name_img_and_average_rating(
mid)
search_keys_str = ','.join(search_keys)
ret['response'] = {
'store_key': store_key,
'search_keys': search_keys_str,
'schedules': schedules,
'uid': uid,
'mid': row['mid'],
'name': name,
'img_url': img_url,
'avg_rating': str(float(avg_rating))
}
print uid, 'successfully made booking requests...'
mix.track(
uid, 'request schedule', {
'time': dt.datetime.now(),
'date': dt.datetime.strftime(date, '%Y%m%d'),
'start_time_range_begin': start_time_range_begin,
'start_time_range_begin_min':
start_time_range_begin_min,
'start_time_range_end': start_time_range_end,
'start_time_range_end_min': start_time_range_end_min,
'taking_time': taking_time,
'additional_time': additional_time,
'appointment_type': appointment_type,
'have_pet': have_pet,
'master_gender': master_gender,
'isdirty': isdirty,
'status': 'find homemaster'
})
mongo_logger.debug('%s made booking requests' % uid,
extra={'user_id': uid})
self.set_status(Response.RESULT_OK)
except Exception, e:
session.rollback()
add_err_message_to_response(ret, err_dict['err_mysql'])
self.set_status(Response.RESULT_SERVERERROR)
print_err_detail(e)
mongo_logger.error('error occurred when request schedule',
extra={'err': str(e)})
# if error occur, then remove all keys
holder.remove(store_key)
for sk in search_keys:
holder.remove(sk)
def post(self):
self.set_header("Content-Type", "application/json")
uid = self.get_argument('uid', '')
taking_time = self.get_argument('taking_time', 25)
additional_time = self.get_argument('additional_time', 10)
appointment_type = self.get_argument('appointment_type', 0)
have_pet = self.get_argument('have_pet', 0)
master_gender = self.get_argument('master_gender', 0)
isdirty = self.get_argument('isdirty', 0)
# convert
appointment_type = int(appointment_type)
have_pet = int(have_pet)
taking_time = int(taking_time)
additional_time = int(additional_time)
taking_time_in_minutes = taking_time * 6
additional_time_in_minutes = additional_time * 6
total_taking_time_in_minutes = taking_time_in_minutes + additional_time_in_minutes
master_gender = int(master_gender) # 0 dont care 1 women 2 men
isdirty = int(isdirty)
ret = {}
print 'recommend schedule'
print 'taking time :', taking_time_in_minutes
mongo_logger = get_mongo_logger()
mongo_logger.debug('%s request recommendation' % uid,
extra={
'taking_time': taking_time,
'additional_time': additional_time,
'appointment_type': appointment_type,
'have_pet': have_pet,
'master_gender': master_gender,
'isdirty': isdirty
})
mix = get_mixpanel()
try:
session = Session()
userdao = UserDAO()
addrdao = AddressDAO()
masterdao = MasterDAO()
holder = IntermediateValueHolder()
# request id to group each individual bookings
request_id = str(uuid.uuid4())
# get user's address and cover address to gu code
address, geohash5, geohash6 = userdao.get_user_address(uid)
gu_id = addrdao.get_gu_id(address)
start_time_range_begin = 8
start_time_range_end = 18
# 똥집인 경우 3시간 추가됨.
if isdirty == 1:
if appointment_type == BC.ONE_TIME or appointment_type == BC.ONE_TIME_BUT_CONSIDERING:
total_taking_time_in_minutes += 120
#get available homemaster's time table day by day
schedule_by_date_list = masterdao.get_recommended_schedule(
gu_id, have_pet, master_gender, appointment_type, geohash6,
dt.datetime.now().date())
success, msg, store_key, search_keys, result = masterdao.find_master_by_score(schedule_by_date_list, \
gu_id, \
uid, \
appointment_type, \
None, \
start_time_range_begin, \
0,
start_time_range_end, \
0,
total_taking_time_in_minutes, \
geohash6,
True)
# if not successful
if success != 'SUCCESS':
print 'haha no recommendation.....'
self.set_status(Response.RESULT_OK)
ret['response'] = 'NoRecommendation'
mongo_logger.error('have no recommendation',
extra={'err': msg})
#add_err_message_to_response(ret, err_dict['err_hm_no_recommendation'])
#self.write(json.dumps(ret))
return
else:
schedules = []
for row in result:
s = {}
s['date'] = row['date']
s['start_time'] = time_to_str(row['start_time'])
s['end_time'] = time_to_str(row['end_time'])
schedules.append(s)
# 스케쥴이 이미 해당 날짜에 있다면, 있다고 표시하고 리턴함
num_schedules_on_dates = userdao.get_user_schedule_on_dates(
uid, [
dt.datetime.strptime(str(s['date']), '%Y%m%d').date()
for s in schedules
])
if num_schedules_on_dates > 0:
print 'already have appointment on that days, no recommendation.....'
holder.remove(store_key)
for sk in search_keys:
holder.remove(sk)
self.set_status(Response.RESULT_OK)
ret['response'] = 'NoRecommendation'
mongo_logger.error(
'have no recommendation',
extra={'err': 'already have cleaning on that day'})
#add_err_message_to_response(ret, err_dict['err_hm_no_recommendation'])
#self.write(json.dumps(ret))
return
mid = row['mid']
name, img_url, avg_rating = masterdao.get_master_name_img_and_average_rating(
mid)
search_keys_str = ','.join(search_keys)
print 'search key string :', search_keys_str
ret['response'] = {
'store_key': store_key,
'search_keys': search_keys_str,
'schedules': schedules,
'uid': uid,
'mid': row['mid'],
'name': name,
'img_url': img_url,
'avg_rating': str(float(avg_rating))
}
mix.track(uid, 'recommend', {
'time': dt.datetime.now(),
'master_gender': master_gender
})
mongo_logger.debug('%s got recommendation' % uid,
extra={'user_id': uid})
self.set_status(Response.RESULT_OK)
print uid, 'got recommendation '
self.set_status(Response.RESULT_OK)
except Exception, e:
session.rollback()
print_err_detail(e)
self.set_status(Response.RESULT_SERVERERROR)
add_err_message_to_response(ret, err_dict['err_mysql'])
mongo_logger.error('error occurred when make recommendation',
extra={'err': str(e)})
# if error occur, then remove all keys
holder.remove(store_key)
for sk in search_keys:
holder.remove(sk)
class ChangeCircleHandler(tornado.web.RequestHandler):
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
print "call change_circle_handler"
ret = {}
org_booking_id = self.get_argument('booking_id', '')
new_booking_date = self.get_argument(
'date', dt.datetime.strftime(dt.datetime.now(), '%Y%m%d'))
new_booking_time = self.get_argument('time', '08:00')
master_ids = self.get_argument('master_ids', [])
new_appointment_type = self.get_argument('appointment_type', '')
# convert parameters
selected_date_str = new_booking_date
time_str = new_booking_time
new_booking_date = dt.datetime.strptime(new_booking_date, '%Y%m%d')
master_ids = master_ids.split(',')
new_appointment_type = int(new_appointment_type)
# logging part
mix = get_mixpanel()
mongo_logger = get_mongo_logger()
print 'change circle'
print selected_date_str, time_str
print '*' * 100
try:
session = Session()
try:
row = session.query(Booking).filter(
Booking.id == org_booking_id).one()
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_no_record'])
return
except MultipleResultsFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_multiple_record'])
return
org_request_id = row.request_id
org_appointment_index = row.appointment_index
org_additional_task = row.additional_task
org_master_id = row.master_id
org_start_time = row.start_time
org_estimated_end_time = row.estimated_end_time
user_id = row.user_id
card_idx = row.card_idx
addr_idx = row.addr_idx
havetools = row.havetools
have_pet = row.havepet
isdirty = row.is_dirty
master_gender = row.master_gender
cleaning_duration = row.cleaning_duration
#payment_status = BC.BOOKING_UNPAID_YET
# 원래 예약된 정보 불러오기
all_bookings = session.query(Booking) \
.filter(Booking.request_id == org_request_id) \
.filter(Booking.appointment_index >= org_appointment_index) \
.filter(Booking.cleaning_status > BC.BOOKING_CANCELED) \
.order_by(Booking.start_time) \
.all()
# 예약된 정보의 상태 변경
for booking in all_bookings:
print "change cleanning_status"
booking.cleaning_status = BC.BOOKING_CANCELED
# 결제 상태에 따른 상태 변경
session.commit()
# 주기에 따른 예약 생성
# request id to group each individual bookings
request_id = str(uuid.uuid4())
# hasids to generate unique booking id
now = dt.datetime.strftime(dt.datetime.now(), '%Y%m%d%H%M%S')
hashids = Hashids(min_length=16, salt=now + user_id)
userdao = UserDAO()
masterdao = MasterDAO()
holder = IntermediateValueHolder()
cal_appointment_type = new_appointment_type
count_of_iteration = cal_appointment_type * 2 + 1 # 2 months
date_list = []
week_const = 4 / cal_appointment_type
for i in xrange(count_of_iteration):
date = new_booking_date + dt.timedelta(weeks=week_const * i)
date = dt.datetime.strftime(date, '%Y%m%d')
date_list.append(date)
print "date_list : ", date_list
master_num = len(master_ids)
i = 0
booking_info = {}
time = new_booking_time
house_type, size = userdao.get_user_house_type_size(org_booking_id)
print "house_type : ", house_type
print "size : ", size
while i < master_num:
mid = master_ids[i]
master_date_keys = []
name, img_url, avg_rating = masterdao.get_master_name_img_and_average_rating(
mid)
print "master_name : ", name
print "img_url : ", img_url
print "avg_rating : ", avg_rating
for date in date_list:
key = '%s_%s' % (mid, date)
master_date_keys.append(key)
print "master_date_keys : ", master_date_keys
booking_item_key = '%s_%s_%d' % (user_id, master_date_keys[0],
new_appointment_type)
#if holder.store_keys(master_date_keys) and not masterdao.is_master_off_date(mid, new_booking_date.date()): # 메모리에 키가 하나도 없을 때, 즉 예약이 가능할 때
# holder.store(booking_item_key, booking_info)
new_appointment_idx = 1
for date in date_list:
print date, time
booking_id = hashids.encode(
int(date + time.replace(':', '')))
print 'new_booking_id : ', booking_id
date = dt.datetime.strptime(date, '%Y%m%d')
dow = date.date().weekday()
booking_time = dt.time(hour=int(time.split(':')[0]),
minute=int(time.split(':')[1]))
start_time = dt.datetime.combine(date, booking_time)
estimated_end_time = start_time # + dt.timedelta(minute = )
print "booking_time : ", booking_time
print "start_time : ", start_time
print "estimated_end_time : ", estimated_end_time
i += 1
'''while i < master_num:
mid = master_ids[i]
master_date_keys = []
name, img_url, avg_rating = masterdao.get_master_name_img_and_average_rating(mid)
for date in date_list:
key = '%s_%s' % (mid, date)
master_date_keys.append(key)
booking_item_key = '%s_%s_%d' % (uid, master_date_keys[0], appointment_type)
# 가능 일정을 미리 호출한 고객과, 그 바로 직후 휴무 신청을 한 홈마스터의 경우, 예약이 불가 하기 때문에 체크하도록 함
if holder.store_keys(master_date_keys) and not masterdao.is_master_off_date(mid, selected_date.date()): # 메모리에 키가 하나도 없을 때, 즉 예약이 가능할 때
holder.store(booking_item_key, booking_info)
new_appointment_idx = 1;
for date in date_list:
print date, time
booking_id = hashids.encode(int(date + time.replace(':', '')))
dow = date.date().weekday()
print 'key', booking_id
booking_time = dt.time(hour = int(time.split(':')[0]), minute = int(time.split(':')[1]))
start_time = dt.datetime.combine(date, booking_time)
estimated_end_time = estimated_end_time - dt.timedelta(minutes = additional_time + first_added_time)
booking = Booking(id = booking_id,
request_id = request_id,
user_id = uid,
master_id = mid,
appointment_type = new_appointment_type,
appointment_index = new_appointment_idx,
dow = dow,
booking_time = dt.datetime.now(),
org_start_time = start_time,
start_time = start_time,
estimated_end_time = estimated_end_time,
end_time = estimated_end_time, # update after homemaster finish their job
cleaning_duration = cleaning_duration,
additional_task = additional_task,
price = price,
price_with_task = actual_price,
charging_price = 0,
card_idx = card_idx,
addr_idx = addr_idx,
havetools = havetools,
havepet = have_pet,
laundry_apply_all = laundry_apply_all,
is_dirty = isdirty,
master_gender = master_gender,
status = BC.BOOKING_UPCOMMING,
cleaning_status = BC.BOOKING_UPCOMMING,
payment_status = BC.BOOKING_UNPAID_YET)
#booking_info['search_keys'] = master_date_keys
#booking_info['store_key'] = booking_item_key
return
i += 1'''
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
