def post(self):
ret = {}
user_id = self.get_argument('user_id', '')
addr_index = self.get_argument('addr_index', '')
detail_address = self.get_argument('detail_address', '')
addr_index = int(addr_index)
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
userdao = UserDAO()
try:
row = session.query(UserAddress) \
.filter(and_(UserAddress.user_id == user_id, UserAddress.user_addr_index == addr_index)) \
.one()
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_no_record'])
mongo_logger.error('%s failed to find address, no record' %
email,
extra={'err': str(e)})
return
except MultipleResultsFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_multiple_record'])
mongo_logger.error(
'%s failed to find address, multiple record' % email,
extra={'err': str(e)})
return
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
bid = self.get_argument('booking_id', '')
msg = self.get_argument('msg', '')
enterhome = self.get_argument('enterhome', '')
enterbuilding = self.get_argument('enterbuilding', '')
trash_location = self.get_argument('trash_location', '')
print '%%%%'
print bid
print msg
print enterhome
print enterbuilding
print trash_location
print '%%%%'
ret = {}
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
try:
row = session.query(Booking).filter(Booking.id == bid).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 get(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
uid = self.get_argument('user_id', '')
ret = {}
print uid
print PAYMENT_HOST, PAYMENT_PORT
try:
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
userdao = UserDAO()
request_url = '%s:%d/homemaster_payment/get_cards' % (PAYMENT_HOST,
PAYMENT_PORT)
params = {}
params['id'] = uid
response = requests.get(request_url, params=params)
print response
result = json.loads(response.text)
print result
if response.status_code == 200 and result['response'] != "":
ret['response'] = result['response']
self.set_status(Response.RESULT_OK)
else:
print 'An error occurred while get card info'
add_err_ko_message_to_response(ret, '카드정보 읽기 실패')
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")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
booking_id = self.get_argument('booking_id', '')
c_rate = self.get_argument('clean_rate', 0.0)
c_review_msg = self.get_argument('clean_review', '')
m_rate = self.get_argument('master_rate', 0.0)
m_review_msg = self.get_argument('master_review', '')
c_rate = float(c_rate)
m_rate = float(m_rate)
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
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', '*')
ret = {}
booking_id = self.get_argument('booking_id', '')
appointment_type = self.get_argument('appointment_type', 0)
is_admin = self.get_argument('is_admin', 1)
appointment_type = int(appointment_type)
is_admin = int(is_admin)
print 'appointment_type', appointment_type
# logging part
mix = get_mixpanel()
mongo_logger = get_mongo_logger()
try:
session = Session()
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 get(self):
self.set_header("Content-Type", "application/json")
booking_id = self.get_argument('booking_id', '')
ret = {}
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
booking_detail = {}
session = Session()
print booking_id
try:
row = session.query(Booking, Master, UserAddress, Promotion, UserCoupon) \
.join(Master, Booking.master_id == Master.id) \
.join(UserAddress, and_(Booking.user_id == UserAddress.user_id, Booking.addr_idx == UserAddress.user_addr_index)) \
.outerjoin(Promotion, Booking.id == Promotion.booking_id) \
.outerjoin(UserCoupon, Booking.id == UserCoupon.booking_id) \
.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")
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")
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")
ret = {}
name = self.get_argument('name', '')
gender = self.get_argument('gender', 1)
authsource = self.get_argument('authsource', 'None')
devicetype = self.get_argument('devicetype', 'None')
email = self.get_argument('email', '')
password = self.get_argument('password', '')
salt = self.get_argument('salt', '')
phone = self.get_argument('phone', '')
birthdate = self.get_argument('birthdate', '')
registerdate = self.get_argument('regdate', '')
if gender == '':
gender = 1
gender = int(gender)
err_msg = ''
if name == '':
err_msg = 'name is invalid'
elif email == '':
err_msg = 'email is invalid'
elif password == '':
err_msg = 'password is invalid'
if err_msg != '': # invalid argument situation
ret['response'] = err_msg
self.set_status(Response.RESULT_BADREQUEST)
add_err_message_to_response(ret, err_dict['invalid_param'])
return
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
guid = str(uuid.uuid4())
registerdate_str = registerdate
#registerdate = dt.datetime.strptime(registerdate, '%Y-%m-%d').date()
registerdate = dt.datetime.now()
count = session.query(User).filter(User.email == email, User.active == 1).count()
if count > 0:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_dup_email'])
mongo_logger.debug('%s is already existed' % email, extra = {'err' : 'duplicate email'})
return
# phone duplicacy check
count = session.query(User) \
.filter(func.aes_decrypt(func.from_base64(User.phone), \
func.substr(User.salt, 1, 16)) == phone, \
User.active == 1) \
.count()
if count > 0:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_dup_phone'])
mongo_logger.debug('phone already existed', extra = {'err' : 'duplicate phone'})
return
key = salt[:16]
print key
crypto = aes.MyCrypto(key)
encrypted_name = crypto.encodeAES(str(name))
encrypted_phone = crypto.encodeAES(str(phone))
encrypted_birthdate = crypto.encodeAES(str(birthdate))
print encrypted_name, name
print encrypted_phone, phone
print encrypted_birthdate, birthdate
new_user = User(id = guid, name = encrypted_name, gender = gender, authsource = authsource,
devicetype = devicetype, email = email, password = password, salt = salt,
phone = encrypted_phone, dateofbirth = encrypted_birthdate,
dateofreg = registerdate, dateoflastlogin= registerdate)
session.add(new_user)
session.commit()
now = dt.datetime.now()
expire_date = dt.datetime(2016, 12, 31, 23, 59)
if now <= expire_date:
user_id = guid
discount_price = 10000
title = '크리스마스는 깨끗한 집에서!'
description = '1만원 할인쿠폰'
hashids = Hashids(min_length = 8, salt = user_id)
coupon_id = hashids.encode(int(dt.datetime.strftime(now, '%Y%m%d%H%M%S')))
user_coupon = UserCoupon(id = coupon_id, user_id = user_id, discount_price = discount_price,
expire_date = expire_date, title = title, description = description,
issue_date = now)
session.add(user_coupon)
session.commit()
sender = SMS_Sender()
if devicetype == 'ios':
# send lms
row = session.query(Promotion) \
.filter(Promotion.discount_price == 10000) \
.filter(Promotion.used == 0) \
.first()
code = row.promotion_code
row.used = 2
session.commit()
sender.send2(mtype = 'lms', to = phone, subject = '홈마스터 12월 회원가입 이벤트!',
text = '홈마스터 앱에서 클리닝 예약 시, 아래 코드를 입력 해주세요 (10,000원 할인코드): \n' + code)
elif devicetype == 'android':
sender.send2(mtype = 'lms', to = phone, subject = '홈마스터 12월 회원가입 이벤트!',
text = '홈마스터 10,000 할인 쿠폰이 도착했습니다. 앱의 쿠폰함에서 확인해주세요~')
ret['response'] = guid
self.set_status(Response.RESULT_OK)
print email, 'has successfully registered..!!'
print dt.datetime.now()
mix.track(guid, 'register', {'time' : dt.datetime.now()})
mix.people_set(guid, {'$name' : name, '$email' : email, '$gender' : gender,
'$authsource' : authsource, '$phone' : phone, '$devicetype' : devicetype,
'$brithdate' : birthdate, '$registerdate' : registerdate_str,
'$time' : dt.datetime.now()},
{'$ip' : '121.134.224.40'})
mongo_logger.debug('register', extra = {'log_time' : dt.datetime.now(), 'user_id': guid, 'user_name' : name, 'gender' : gender, 'authsource' : authsource, 'devicetype' : devicetype, 'email' : email, 'phone' : phone})
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('failed to register', extra = {'log_time' : dt.datetime.now(), 'user_name' : name, 'gender' : gender, 'authsource' : authsource, 'devicetype' : devicetype, 'email' : email, 'phone' : phone, 'err' : str(e)})
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 post(self):
self.set_header("Content-Type", "application/json")
booking_id = self.get_argument('booking_id', '')
reason_id = self.get_argument('reason_id', 0)
etc_reason = self.get_argument('etc_reason', '')
reason_id = int(reason_id)
ret = {}
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
try:
row = session.query(Booking, Master, User, UserAddress) \
.join(Master, Booking.master_id == Master.id) \
.join(User, Booking.user_id == User.id) \
.join(UserDefaultAddress, User.id == UserDefaultAddress.user_id) \
.join(UserAddress, and_(UserAddress.user_id == UserDefaultAddress.user_id, UserAddress.user_addr_index == UserDefaultAddress.address_idx)) \
.filter(Booking.id == booking_id) \
.filter(Booking.cleaning_status == BC.BOOKING_UPCOMMING) \
.one()
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_no_entry_to_cancel'])
self.write(json.dumps(ret))
return
charge = 0
new_status = BC.BOOKING_CANCELED_CHARGE
request_id = row.Booking.request_id
user_id = row.Booking.user_id
appointment_index = row.Booking.appointment_index
appointment_time = row.Booking.start_time
appointment_type = row.Booking.appointment_type
current_status = row.Booking.status
current_cleaning_status = row.Booking.cleaning_status
current_payment_status = row.Booking.payment_status
price = row.Booking.price_with_task
now = dt.datetime.now()
diff_in_hours = (appointment_time - now).total_seconds() / 3600
if diff_in_hours >= 24:
charge = price * BC.BOOKING_CHARGE_RATE_NO
elif 4 <= diff_in_hours < 24:
charge = price * BC.BOOKING_CHARGE_RATE_30
else:
charge = price * BC.BOOKING_CHARGE_RATE_50
if current_payment_status == BC.BOOKING_PAID:
new_status = BC.BOOKING_CANCELED_REFUND
'''
partial = '1'
if charge == 0:
partial = '0'
cancel_amount = int(price - charge)
if cancel_amount > 0:
ret_code, msg = cancel_payment(user_id, booking_id, cancel_amount, partial)
if ret_code == False:
session.close()
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, msg)
self.write(json.dumps(ret))
return'''
#row.Booking.modified_date = now
row.Booking.charging_price = int(charge)
row.Booking.status = new_status
row.Booking.cleaning_status = BC.BOOKING_CANCELED
row.Booking.payment_status = new_status
masterdao = MasterDAO()
userdao = UserDAO()
key = userdao.get_user_salt_by_id(user_id)[:16]
crypto = aes.MyCrypto(key)
# push to homemaster via sms
master_id = row.Master.id
master_phone = str(row.Master.phone)
master_name = str(row.Master.name)
username = str(crypto.decodeAES(row.User.name))
userphone = str(crypto.decodeAES(row.User.phone))
date = str(convert_datetime_format(row.Booking.start_time))
addr = str(crypto.decodeAES(row.UserAddress.address))
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회'
#sms_sender = SMS_Sender()
#text = BOOKING_CANCEL_TEXT % (username, userphone, master_name, date)
#print sms_sender.send_for_manager(sender = MAIN_CALL, mtype = 'sms', to = MANAGERS_CALL, subject = BOOKING_TEXT_SUBJECT, text = text)
for manager_phone in MANAGERS_CALL.split(','):
send_alimtalk(manager_phone, 'noti_manager_cancel', username,
date, appointment_type_text)
master_pushkey = masterdao.get_master_pushkey(master_id)
#send_booking_canceled('android', [master_pushkey], booking_id, date)
print 'master_pushkey', master_pushkey
print booking_id, date
#send_alimtalk(master_phone, 'noti_manager_cancel', username, date, appointment_type_text)
# adjust appointment index
index_result = session.query(Booking).filter(
Booking.request_id == request_id).filter(
Booking.appointment_index > appointment_index).all()
for index_row in index_result:
index_row.appointment_index -= 1
CANCEL = 0
cancel_reason = CancelReason(booking_id=booking_id,
user_id=user_id,
reason_id=reason_id,
etc_reason=etc_reason,
kind=CANCEL,
cancel_time=dt.datetime.now())
session.add(cancel_reason)
session.commit()
mix.track(
user_id, 'cancel', {
'time': dt.datetime.now(),
'reason_id': reason_id,
'etc_reason': etc_reason
})
mongo_logger.debug('%s was canceled' % booking_id,
extra={
'user_id': user_id,
'booking_id': booking_id
})
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
email = self.get_argument('email', '')
password = self.get_argument('password', '')
print 'login', email, password
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
userdao = UserDAO()
try:
row = session.query(User).filter(User.email == email, User.active == 1).one()
salt = row.salt
encrypted_password = hashlib.sha256(salt + password).hexdigest()
row = session.query(User).filter(User.email == email, User.password == encrypted_password, User.active == 1).one()
except NoResultFound, e:
try:
if len(email) == 11 and email.startswith('010'):
row = session.query(User) \
.filter(func.aes_decrypt(func.from_base64(User.phone), \
func.substr(User.salt, 1, 16)) == email, \
User.active == 1) \
.one()
print row.email
salt = row.salt
encrypted_password = hashlib.sha256(salt + password).hexdigest()
print salt, encrypted_password
row = session.query(User) \
.filter(func.aes_decrypt(func.from_base64(User.phone), \
func.substr(User.salt, 1, 16)) == email, \
User.password == encrypted_password, \
User.active == 1) \
.one()
else:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_login_no_match'])
mongo_logger.error('%s failed to logined' % email, extra = {'err' : str(e)})
return
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_login_no_match'])
mongo_logger.error('%s failed to logined' % email, extra = {'err' : str(e)})
return
except MultipleResultsFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_dup_phone2'])
mongo_logger.error('%s failed to logined' % email, extra = {'err' : str(e)})
return
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
booking_id = self.get_argument('booking_id', '')
reason_id = self.get_argument('reason_id', CANCEL_ADMIN)
etc_reason = self.get_argument('etc_reason', '')
no_fee = self.get_argument('no_fee', 0)
reason_id = int(reason_id)
print "reason_id : ", reason_id
no_fee = int(no_fee)
ret = {}
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
try:
row = session.query(Booking, Master, User, UserAddress) \
.join(Master, Booking.master_id == Master.id) \
.join(User, Booking.user_id == User.id) \
.join(UserDefaultAddress, User.id == UserDefaultAddress.user_id) \
.join(UserAddress, and_(UserAddress.user_id == UserDefaultAddress.user_id, UserAddress.user_addr_index == UserDefaultAddress.address_idx)) \
.filter(Booking.id == booking_id) \
.filter(Booking.cleaning_status == BC.BOOKING_UPCOMMING) \
.one()
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_no_entry_to_cancel'])
return
user_id = row.Booking.user_id
masterdao = MasterDAO()
userdao = UserDAO()
key = userdao.get_user_salt_by_id(user_id)[:16]
crypto = aes.MyCrypto(key)
# push to homemaster via sms
master_id = row.Master.id
master_phone = str(row.Master.phone)
master_name = str(row.Master.name)
username = str(crypto.decodeAES(row.User.name))
userphone = str(crypto.decodeAES(row.User.phone))
date = str(convert_datetime_format(row.Booking.start_time))
addr = str(crypto.decodeAES(row.UserAddress.address))
charge = 0
new_status = BC.BOOKING_CANCELED_CHARGE
request_id = row.Booking.request_id
appointment_index = row.Booking.appointment_index
appointment_time = row.Booking.start_time
appointment_type = row.Booking.appointment_type
current_status = row.Booking.status
current_cleaning_status = row.Booking.cleaning_status
current_payment_status = row.Booking.payment_status
price = row.Booking.price_with_task
source = row.Booking.source
device_type = row.Booking.user_type
now = dt.datetime.now()
cancel_amount = 0
diff_in_hours = (appointment_time - now).total_seconds() / 3600
if diff_in_hours >= 24:
charge = price * BC.BOOKING_CHARGE_RATE_NO
elif 4 <= diff_in_hours < 24:
charge = price * BC.BOOKING_CHARGE_RATE_30
else:
charge = price * BC.BOOKING_CHARGE_RATE_50
if current_payment_status == BC.BOOKING_PAID:
if no_fee == 1: # 관리자가 선택하여 fee를 지불 할 수 있게 하기 위해서
charge = 0
new_status = BC.BOOKING_CANCELED_REFUND
partial = '1'
if charge == 0:
partial = '0'
is_event = session.query(UserFreeEvent) \
.filter(UserFreeEvent.booking_request_id == request_id) \
.first()
is_event = True if is_event != None else False
cancel_amount = int(price - charge)
if cancel_amount > 0 and source == 'hm' and userdao.get_user_default_card_index(
user_id) != -1:
if not (is_event and appointment_index == 1):
ret_code, msg = cancel_payment(user_id, booking_id,
cancel_amount, partial)
if ret_code == False:
session.close()
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, msg)
#self.write(json.dumps(ret))
return
else:
# 결제 필요
# 취소에 대한 결제 필요
partial = '0'
cancel_amount = row.Booking.price_with_task - row.Booking.price
if cancel_amount > 0:
cancel_payment(user_id, booking_id, cancel_amount,
partial)
complete_count = session.query(Booking) \
.filter(Booking.request_id == request_id) \
.filter(Booking.cleaning_status == 2) \
.count()
print complete_count, row.Booking.cleaning_status
if complete_count < 9 and row.Booking.cleaning_status == 2:
ret_code, msg = request_payment(
user_id, username, booking_id, price,
appointment_type)
if ret_code == False:
row.Booking.payment_status = BC.BOOKING_PAYMENT_FAILED
else: # cancel charge price
print 'cancel charge'
charging_price = int(charge)
if charging_price > 0 and source == 'hm' and userdao.get_user_default_card_index(
user_id) != -1 and no_fee == 0:
print user_id, username, booking_id, charging_price, appointment_type
ret_code, msg = request_payment(user_id, username,
booking_id, charging_price,
appointment_type)
if ret_code == False:
new_status = BC.BOOKING_PAYMENT_FAILED
#row.Booking.modified_date = now
row.Booking.charging_price = int(charge)
row.Booking.status = new_status
row.Booking.cleaning_status = BC.BOOKING_CANCELED
row.Booking.payment_status = new_status
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회'
#sms_sender = SMS_Sender()
#text = BOOKING_CANCEL_TEXT % (username, userphone, master_name, date)
#print sms_sender.send_for_manager(sender = MAIN_CALL, mtype = 'sms', to = MANAGERS_CALL, subject = BOOKING_TEXT_SUBJECT, text = text)
#for manager_phone in MANAGERS_CALL.split(','):
# send_alimtalk(manager_phone, 'noti_manager_cancel', username, date, appointment_type_text)
cancel_reasons = []
cancel_reasons.append('지금은 서비스가 필요하지 않아요')
cancel_reasons.append('집에 없어서 문을 열어드릴 수가 없어요')
cancel_reasons.append('시간이 마음에 들지 않아요')
cancel_reasons.append('클리닝을 잊고 있었네요')
cancel_reasons.append('원하는 홈마스터가 아니에요')
cancel_reasons.append('기타')
cancel_reasons.append('이사가요')
cancel_reasons.append('기타')
cancel_reasons.append('관리자가 취소 했습니다')
cancel_reason = cancel_reasons[reason_id]
if cancel_reason == '기타':
cancel_reason += ' ' + etc_reason
elif reason_id == CANCEL_ADMIN:
cancel_reason += ', 관리자 메모 : ' + etc_reason
send_jandi(
'NEW_BOOKING', "취소 알림", username + ' 고객님 취소함',
'{}, {}, 사유 : {}'.format(date, appointment_type_text,
cancel_reason))
print 'jandi notification for cancel...'
master_pushkey = masterdao.get_master_pushkey(master_id)
#master_name = masterdao.get_master_name(master_id)
#master_phone = masterdao.get_master_phone(master_id)
send_booking_canceled('android', [master_pushkey], booking_id,
date, username)
content = '''{} 홈마스터님
예약이 1회 취소 되었습니다.
고객 : {}
주기 : {}
날짜 : {}'''.format(master_name, username, appointment_type_text, date)
message_sender = MessageSender()
message_sender.send([master_phone], '예약 1회 취소 알림', content)
print 'master_pushkey', master_pushkey
print booking_id, date
#send_alimtalk(master_phone, 'noti_manager_cancel', username, date, appointment_type_text)
# adjust appointment index
index_result = session.query(Booking).filter(
Booking.request_id == request_id).filter(
Booking.appointment_index > appointment_index).all()
for index_row in index_result:
index_row.appointment_index -= 1
coupondao = CouponDAO()
coupondao.cancel_coupon_usage(booking_id)
CANCEL = 0
cancel_reason = CancelReason(booking_id=booking_id,
user_id=user_id,
reason_id=reason_id,
etc_reason=etc_reason,
kind=CANCEL,
cancel_time=dt.datetime.now())
session.add(cancel_reason)
session.commit()
mix.track(
user_id, 'cancel', {
'time': dt.datetime.now(),
'reason_id': reason_id,
'etc_reason': etc_reason,
'cancel_amount': cancel_amount
})
mongo_logger.debug('%s was canceled' % booking_id,
extra={
'user_id': user_id,
'booking_id': booking_id,
'cancel_amount': cancel_amount
})
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
def post(self):
self.set_header("Content-Type", "application/json")
booking_id = self.get_argument('booking_id', '')
reason_id = self.get_argument('reason_id', 0)
etc_reason = self.get_argument('etc_reason', '')
charge_amount = self.get_argument('charge_amount', 0)
charge_amount = int(charge_amount)
reason_id = int(reason_id)
print 'cancel all charge amount : ', charge_amount
ret = {}
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
userdao = UserDAO()
masterdao = MasterDAO()
stmt = session.query(Booking.request_id).filter(
Booking.id == booking_id).subquery()
first_startime = session.query(Booking.start_time).filter(
Booking.request_id == stmt).order_by(
Booking.start_time).first()[0]
result = session.query(Booking, Master, User, UserAddress) \
.join(Master, Booking.master_id == Master.id) \
.join(User, Booking.user_id == User.id) \
.join(UserDefaultAddress, User.id == UserDefaultAddress.user_id) \
.join(UserAddress, and_(UserAddress.user_id == UserDefaultAddress.user_id, UserAddress.user_addr_index == UserDefaultAddress.address_idx)) \
.filter(Booking.request_id == stmt) \
.filter(or_(Booking.cleaning_status == BC.BOOKING_UPCOMMING, Booking.cleaning_status == BC.BOOKING_STARTED)) \
.all()
# 서비스를 처음 이용한지 2달이 넘었는지 아닌지 조사,
# 넘지 않았다면 이미 부과된 금액에 대해서도 1회 서비스 금액 과의 차액만큼 부과됨
current_time = dt.datetime.now()
completed_charge = 1
if current_time >= first_startime + dt.timedelta(days=57):
completed_charge = 0
cancel_all_charge = 0
# 그동안의 모든 예약에 대해서 처리함
for row in result:
charge = 0
new_status = BC.BOOKING_CANCELED_CHARGE
bid = row.Booking.id
user_id = row.Booking.user_id
appointment_time = row.Booking.start_time
current_status = row.Booking.status
current_cleaning_status = row.Booking.cleaning_status
current_payment_status = row.Booking.payment_status
price = row.Booking.price_with_task
diff_in_hours = (appointment_time -
current_time).total_seconds() / 3600
if diff_in_hours >= 24:
charge = price * BC.BOOKING_CHARGE_RATE_NO
elif 4 <= diff_in_hours < 24:
charge = price * BC.BOOKING_CHARGE_RATE_30
else:
charge = price * BC.BOOKING_CHARGE_RATE_50
# 이미 지불한 금액에 대해 1회 비용의 차액만큼 계산
if completed_charge == 1:
if current_cleaning_status == BC.BOOKING_COMPLETED:
# 차액만큼 계속 더함
cancel_all_charge += charge_amount
if current_payment_status == BC.BOOKING_PAID and current_cleaning_status == BC.BOOKING_UPCOMMING:
new_status = BC.BOOKING_CANCELED_REFUND
'''
partial = '1'
if charge == 0:
partial = '0'
cancel_amount = int(price - charge)
if cancel_amount > 0:
ret_code, msg = cancel_payment(user_id, bid, cancel_amount, partial)
if ret_code == False:
session.close()
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, msg)
self.write(json.dumps(ret))
return '''
#row.Booking.modified_date = current_time
row.Booking.charging_price = int(charge)
row.Booking.status = new_status
row.Booking.cleaning_status = BC.BOOKING_CANCELED
row.Booking.payment_status = new_status
# add cancel reason
CANCEL_ALL = 1
reason = session.query(CancelReason).filter(
CancelReason.booking_id == bid)
if reason.count() == 0:
cancel_reason = CancelReason(booking_id=bid,
user_id=user_id,
reason_id=reason_id,
etc_reason=etc_reason,
kind=CANCEL_ALL,
cancel_time=dt.datetime.now())
session.add(cancel_reason)
else:
reason_row = reason.one()
reason_row.kind = 1
'''if cancel_all_charge > 0:
user_name = userdao.get_user_name(user_id)
ret_code, msg = request_charge(user_id, user_name, cancel_all_charge)
if ret_code == False:
session.close()
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, msg)
self.write(json.dumps(ret))
return '''
key = userdao.get_user_salt_by_id(row.User.id)[:16]
crypto = aes.MyCrypto(key)
# push to homemaster via sms
master_id = row.Master.id
master_phone = str(row.Master.phone)
master_name = str(row.Master.name)
username = str(crypto.decodeAES(row.User.name))
userphone = str(crypto.decodeAES(row.User.phone))
date = str(convert_datetime_format(row.Booking.start_time))
addr = str(crypto.decodeAES(row.UserAddress.address))
appointment_type = str(row.Booking.appointment_type)
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회'
#sms_sender = SMS_Sender()
#text = BOOKING_CANCEL_ALL_TEXT % (appointment_type, username, userphone, master_name, date)
#send_result = sms_sender.send_for_manager(sender = MAIN_CALL, mtype = 'sms', to = MANAGERS_CALL, subject = BOOKING_TEXT_SUBJECT, text = text)
for manager_phone in MANAGERS_CALL.split(','):
send_alimtalk(manager_phone, 'noti_manager_cancel_all',
username, date, appointment_type_text)
master_pushkey = masterdao.get_master_pushkey(master_id)
#send_all_bookings_canceled('android', [master_pushkey], booking_id, date)
#send_alimtalk(master_phone, 'noti_manager_cancel_all', username, date, appointment_type_text)
session.commit()
mix.track(
user_id, 'cancel all', {
'time': dt.datetime.now(),
'reason_id': reason_id,
'etc_reason': etc_reason
})
mongo_logger.debug('%s was all canceled' % booking_id,
extra={
'user_id': user_id,
'booking_id': booking_id
})
ret['response'] = Response.SUCCESS
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'])
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 request_payment(user_id,
user_name,
booking_id,
price,
appointment_type,
status='PAID'):
try:
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
request_url = '%s:%d/homemaster_payment/request_payment_new' % (
PAYMENT_HOST, PAYMENT_PORT)
params = {
'id': user_id,
'name': user_name,
'price': price,
'product_name': appointment_type
}
print user_id, price, appointment_type
print request_url
response = requests.post(request_url, data=params)
print response.text
result = json.loads(response.text)
if result['response'] == Response.SUCCESS:
# upate request payment record
tid = result['tid']
authdate = result['authdate']
session = Session()
# done in java server
# status 'PAID', 'CANCELLED'
payment_record = UserPaymentRecord(tid=tid,
booking_id=booking_id,
user_id=user_id,
price=price,
auth_date=authdate,
status=status)
session.add(payment_record)
session.commit()
session.close()
mix.people_track_charge(user_id, price,
{'$time': dt.datetime.now()})
mongo_logger.debug('%s paid for credit card' % user_id,
extra={
'booking_id': booking_id,
'tid': tid,
'price': price
})
return True, tid
else:
print 'An error occurred while request processing...'
print result['err_code'], result['err_msg']
mongo_logger.error('%s failed to paid for credit card' % user_id,
extra={
'booking_id': booking_id,
'err': result['err_msg']
})
return False, result['err_msg']
except Exception, e:
print_err_detail(e)
mongo_logger.error('%s failed to paid for credit card' % user_id,
extra={
'booking_id': booking_id,
'err': str(e)
})
return False, str(e)
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
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
booking_id = self.get_argument('booking_id', '')
reason_id = self.get_argument('reason_id', CANCEL_ADMIN)
etc_reason = self.get_argument('etc_reason', '')
charge_amount = self.get_argument('charge_amount', 0)
no_fee = self.get_argument('no_fee', 0)
regular_cancel_charge = self.get_argument('regular_cancel_charge', 0)
charge_amount = int(charge_amount)
reason_id = int(reason_id)
no_fee = int(no_fee)
regular_cancel_charge = int(regular_cancel_charge)
print 'cancel all charge amount : ', charge_amount
print 'reason_id : ', reason_id
print 'etc_reason : ', etc_reason
ret = {}
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
userdao = UserDAO()
masterdao = MasterDAO()
stmt = session.query(Booking.request_id).filter(
Booking.id == booking_id).subquery()
first_startime = session.query(Booking.start_time).filter(
Booking.request_id == stmt).order_by(
Booking.start_time).first()[0]
result = session.query(Booking, Master, User, UserAddress) \
.join(Master, Booking.master_id == Master.id) \
.join(User, Booking.user_id == User.id) \
.join(UserDefaultAddress, User.id == UserDefaultAddress.user_id) \
.join(UserAddress, and_(UserAddress.user_id == UserDefaultAddress.user_id, UserAddress.user_addr_index == UserDefaultAddress.address_idx)) \
.filter(Booking.request_id == stmt) \
.filter(or_(Booking.cleaning_status == BC.BOOKING_UPCOMMING, Booking.cleaning_status == BC.BOOKING_STARTED, Booking.cleaning_status == BC.BOOKING_COMPLETED)) \
.all()
# 서비스를 처음 이용한지 2달이 넘었는지 아닌지 조사,
# 넘지 않았다면 이미 부과된 금액에 대해서도 1회 서비스 금액 과의 차액만큼 부과됨
current_time = dt.datetime.now()
completed_charge = 1
if current_time >= first_startime + dt.timedelta(days=57):
completed_charge = 0
cancel_all_charge = 0
# 그동안의 모든 예약에 대해서 처리함
for row in result:
charge = 0
new_status = BC.BOOKING_CANCELED_CHARGE
key = userdao.get_user_salt_by_id(row.User.id)[:16]
crypto = aes.MyCrypto(key)
username = str(crypto.decodeAES(row.User.name))
request_id = row.Booking.request_id
appointment_index = row.Booking.appointment_index
bid = row.Booking.id
user_id = row.Booking.user_id
appointment_time = row.Booking.start_time
current_status = row.Booking.status
current_cleaning_status = row.Booking.cleaning_status
current_payment_status = row.Booking.payment_status
price = row.Booking.price_with_task
source = row.Booking.source
appointment_type = row.Booking.appointment_type
diff_in_hours = (appointment_time -
current_time).total_seconds() / 3600
if diff_in_hours >= 24:
charge = price * BC.BOOKING_CHARGE_RATE_NO
elif 4 <= diff_in_hours < 24:
charge = price * BC.BOOKING_CHARGE_RATE_30
else:
charge = price * BC.BOOKING_CHARGE_RATE_50
# 이미 지불한 금액에 대해 1회 비용의 차액만큼 계산
if completed_charge == 1:
if current_cleaning_status == BC.BOOKING_COMPLETED:
# 차액만큼 계속 더함
_, house_size, house_type = userdao.get_user_address_detail_by_index(
user_id, row.Booking.addr_idx)
time_prices = get_basic_time_price(
house_type, house_size)
try:
print time_prices[0]['price']
print time_prices[appointment_type]['price']
charge_amount = int(
time_prices[0]['price'] -
time_prices[appointment_type]['price'])
except Exception:
charge_amount = 3000
cancel_all_charge += charge_amount
# event
is_event = session.query(UserFreeEvent) \
.filter(UserFreeEvent.booking_request_id == request_id) \
.first()
is_event = True if is_event != None else False
if is_event == True and appointment_index == 1:
partial = '0'
cancel_amount = row.Booking.price_with_task - row.Booking.price
cancel_payment(user_id, bid, cancel_amount, partial)
# 취소에 대한 결제 필요
# 8회 이상 썼다면(완료카운트 9회 미만일 경우 결제)
complete_count = session.query(Booking) \
.filter(Booking.request_id == request_id) \
.filter(Booking.cleaning_status == 2) \
.count()
if complete_count < 9 and row.Booking.cleaning_status == 2:
ret_code, msg = request_payment(
user_id, username, booking_id, price,
appointment_type)
if ret_code == False:
row.Booking.payment_status = BC.BOOKING_PAYMENT_FAILED
if current_payment_status == BC.BOOKING_PAID and current_cleaning_status == BC.BOOKING_UPCOMMING:
if no_fee == 1:
charge = 0
new_status = BC.BOOKING_CANCELED_REFUND
partial = '1'
if charge == 0:
partial = '0'
cancel_amount = int(price - charge)
if cancel_amount > 0 and source == 'hm' and userdao.get_user_default_card_index(
user_id) != -1:
if not (is_event and appointment_index == 1):
ret_code, msg = cancel_payment(
user_id, bid, cancel_amount, partial)
if ret_code == False:
session.close()
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, msg)
#self.write(json.dumps(ret))
return
elif current_payment_status == BC.BOOKING_UNPAID_YET and current_cleaning_status == BC.BOOKING_UPCOMMING:
print 'cancel charge'
charging_price = int(charge)
if charging_price > 0 and source == 'hm' and userdao.get_user_default_card_index(
user_id) != -1 and no_fee == 0:
print user_id, username, booking_id, charging_price, appointment_type
ret_code, msg = request_payment(
user_id, username, bid, charging_price,
appointment_type)
if ret_code == False:
new_status = BC.BOOKING_PAYMENT_FAILED
#row.Booking.modified_date = current_time
if current_cleaning_status == BC.BOOKING_UPCOMMING:
row.Booking.charging_price = int(charge)
row.Booking.status = new_status
row.Booking.cleaning_status = BC.BOOKING_CANCELED
row.Booking.payment_status = new_status
# add cancel reason
CANCEL_ALL = 1
reason = session.query(CancelReason).filter(
CancelReason.booking_id == bid)
if reason.count() == 0:
cancel_reason = CancelReason(booking_id=bid,
user_id=user_id,
reason_id=reason_id,
etc_reason=etc_reason,
kind=CANCEL_ALL,
cancel_time=dt.datetime.now())
session.add(cancel_reason)
else:
try:
reason_row = reason.one()
reason_row.kind = 1
except Exception, e:
print e
# 수수료 임시 처리 막기
#cancel_all_charge = 0
if cancel_all_charge > 0 and source == 'hm' and regular_cancel_charge == 0:
user_name = userdao.get_user_name(user_id)
ret_code, msg = request_charge(user_id, user_name,
cancel_all_charge)
if ret_code == False:
session.close()
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, msg)
self.write(json.dumps(ret))
return
if row != None:
key = userdao.get_user_salt_by_id(row.User.id)[:16]
crypto = aes.MyCrypto(key)
# push to homemaster via sms
master_id = row.Master.id
master_phone = str(row.Master.phone)
master_name = str(row.Master.name)
username = str(crypto.decodeAES(row.User.name))
userphone = str(crypto.decodeAES(row.User.phone))
date = str(convert_datetime_format(row.Booking.start_time))
addr = str(crypto.decodeAES(row.UserAddress.address))
appointment_type = str(row.Booking.appointment_type)
print 'app _type'
print appointment_type
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회'
#sms_sender = SMS_Sender()
#text = BOOKING_CANCEL_ALL_TEXT % (appointment_type, username, userphone, master_name, date)
#send_result = sms_sender.send_for_manager(sender = MAIN_CALL, mtype = 'sms', to = MANAGERS_CALL, subject = BOOKING_TEXT_SUBJECT, text = text)
#for manager_phone in MANAGERS_CALL.split(','):
# send_alimtalk(manager_phone, 'noti_manager_cancel_all', username, date, appointment_type_text)
cancel_all_reasons = []
cancel_all_reasons.append('너무 비싸요')
cancel_all_reasons.append('제가 여행을 가요')
cancel_all_reasons.append('청소품질이 마음에 들지 않아요')
cancel_all_reasons.append('필요할 때에만 서비스를 이용하고 싶어요')
cancel_all_reasons.append('다른 업체로 바꿀래요')
cancel_all_reasons.append('원하던 홈마스터가 오질 않아요')
cancel_all_reasons.append('저 이사가요')
cancel_all_reasons.append('기타')
cancel_all_reasons.append('관리자가 취소 했습니다')
cancel_reason = cancel_all_reasons[reason_id]
if cancel_reason == '기타':
cancel_reason += ' ' + etc_reason
elif reason_id == CANCEL_ADMIN:
cancel_reason += ', 관리자 메모 : ' + etc_reason
send_jandi(
'NEW_BOOKING', "전체 취소 알림", username + ' 고객님 전체 취소함',
'{}, {} 사유 : {}'.format(date, appointment_type_text,
cancel_reason))
print 'jandi notification for cancel all...'
master_pushkey = masterdao.get_master_pushkey(master_id)
send_all_bookings_canceled('android', [master_pushkey],
booking_id, date, username)
master_phone = masterdao.get_master_phone(master_id)
master_name = masterdao.get_master_name(master_id)
user_name = userdao.get_user_name(user_id)
content = '''{} 홈마스터님
정기 고객의 예약이 전체 취소 되었습니다.
고객 : {}
주기 : {}'''.format(master_name, user_name, appointment_type_text)
print 'text'
print appointment_type_text
message_sender = MessageSender()
message_sender.send([master_phone], '예약 전체 취소 알림', content)
#send_alimtalk(master_phone, 'noti_manager_cancel_all', username, date, appointment_type_text)
coupondao = CouponDAO()
coupondao.cancelall_coupon_usage(booking_id)
session.commit()
mix.track(
user_id, 'cancel all', {
'time': dt.datetime.now(),
'reason_id': reason_id,
'etc_reason': etc_reason
})
mongo_logger.debug('%s was all canceled' % booking_id,
extra={
'user_id': user_id,
'booking_id': booking_id
})
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
uid = self.get_argument('id', '')
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', '')
ret = {}
print uid
try:
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
userdao = UserDAO()
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
response = requests.post(request_url, data=params)
result = json.loads(response.text)
if response.status_code == 200 and result['response'] != "":
mix.track(uid, 'register card', {
'time': dt.datetime.now(),
'calias': calias
})
mongo_logger.debug('register card',
extra={
'log_time': dt.datetime.now(),
'user_id': uid
})
ret['response'] = result['response']
self.set_status(Response.RESULT_OK)
else:
print 'An error occurred while register card'
print result['err_code'], result['err_msg']
add_err_ko_message_to_response(ret, result['err_msg'])
mix.track(uid, 'cannot register card',
{'time': dt.datetime.now()})
mongo_logger.error('failed to register card',
extra={
'log_time': dt.datetime.now(),
'err': result['err_msg']
})
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 = {}
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)})
def get(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
user_id = self.get_argument('user_id', '')
ret = {}
if user_id == '':
self.set_status(Response.RESULT_BADREQUEST)
add_err_message_to_response(ret, err_dict['invalid_param'])
self.write(json.dumps(ret))
return
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
userdao = UserDAO()
key = userdao.get_user_salt_by_id(user_id)[:16]
crypto = aes.MyCrypto(key)
user_info = {}
addresses = []
for row in session.query(User, UserAddress, UserDefaultAddress) \
.outerjoin(UserAddress, User.id == UserAddress.user_id) \
.outerjoin(UserDefaultAddress, User.id == UserDefaultAddress.user_id).filter(User.id == user_id) \
.order_by(UserAddress.user_addr_index) \
.all():
if row.UserAddress != None:
kind = row.UserAddress.kind
if kind == 3:
kind = 0
addr = {'addr' : crypto.decodeAES(row.UserAddress.address), 'size' : row.UserAddress.size, 'kind' : kind, 'index' : row.UserAddress.user_addr_index}
addresses.append(addr)
default_idx = -1
if row.UserDefaultAddress != None:
default_idx = row.UserDefaultAddress.address_idx
user_info['name'] = crypto.decodeAES(row.User.name)
user_info['email'] = row.User.email
user_info['phone'] = crypto.decodeAES(row.User.phone)
user_info['gender'] = row.User.gender
user_info['auth_source'] = row.User.authsource
user_info['devicetype'] = row.User.devicetype
user_info['birthdate'] = crypto.decodeAES(row.User.dateofbirth)
user_info['default_addr_idx'] = default_idx
user_info['arr_address'] = addresses
ret['response'] = user_info
self.set_status(Response.RESULT_OK)
mix.track(user_id, 'got userinfo', {'time' : dt.datetime.now()})
mongo_logger.debug('got userinfo', extra = {'user_id' : user_id})
print 'userinfo was successfully retrieved to', user_info['name']
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'])
mix.track(user_id, 'failed to got userinfo', {'time' : dt.datetime.now()})
mongo_logger.debug('failed to got userinfo', extra = {'user_id' : user_id})
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)
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', 0)
have_pet = self.get_argument('have_pet', 0)
master_gender = self.get_argument('master_gender', 0)
isdirty = self.get_argument('isdirty', 0)
for_manager = self.get_argument('for_manager', '')
# for b2b appointment
user_address_idx = self.get_argument('user_address_idx', -1)
b2b = self.get_argument('b2b', '')
# convert parameters
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
isdirty = int(isdirty)
# logging part
mix = get_mixpanel()
mongo_logger = get_mongo_logger()
try:
if self.is_user_block(ret, uid) == True:
return
if appointment_type == BC.ONE_TIME_A_MONTH and b2b != 'b2b':
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, '4주 1회 서비스는 신규 예약을 지원하지 않습니다.')
mongo_logger.debug('not booking one time a month', extra = { 'user_id' : uid })
ret['err_code'] = '4038' # 임시 처리
return
if total_taking_time_in_minutes >= 600:
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, '클리닝 가능 시간을 초과하였습니다. (최대 10시간) 이전 화면으로 돌아가 추가사항을 2개이하로 줄여주세요.')
ret['err_code'] = '4036' # 임시 처리
return
scheduler = HMScheduler()
userdao = UserDAO()
addrdao = AddressDAO()
if user_address_idx == -1: # default_address
address, geohash5, geohash6 = userdao.get_user_address(uid)
_, size, kind = userdao.get_user_address_detail(uid)
else: # address selection
address, geohash5, geohash6 = userdao.get_user_address_by_index(uid, user_address_idx)
_, size, kind = userdao.get_user_address_detail_by_index(uid, user_address_idx)
gu_id = addrdao.get_gu_id(address)
if gu_id == '':
raise Exception('gu id is incorrect')
available_schedules = scheduler.get_available_slots(gu_id = gu_id, geohash = geohash6, appointment_type = appointment_type, taking_time = total_taking_time_in_minutes,
prefer_women = True if master_gender == 1 else False,
have_pet = True if have_pet == 1 else False,
isdirty = True if isdirty == 1 else False,
user_id = uid)
now = dt.datetime.now()
if now.hour >= 17: # 7시 이후 라면 -> 5시로 변경 2016.06.03
if for_manager == '': # 사용자 앱에서는 내일 예약 불가능
tomorrow = now + dt.timedelta(days=1)
tomorrow = dt.datetime.strftime(tomorrow, '%Y%m%d')
if tomorrow in available_schedules:
del available_schedules[tomorrow]
for day in available_schedules:
print '[', day, ']'
print available_schedules[day]['by_time']
# log to mixpanel
mix.track(uid, 'request available schedule', {'time' : dt.datetime.now(), '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('request available schedule', extra = {'log_time' : dt.datetime.now(), 'user_id' : uid, 'taking_time' : taking_time, 'additional_time' : additional_time, 'appointment_type' : appointment_type, 'have_pet' : have_pet, 'master_gender' : master_gender,'isdirty' : isdirty})
if len(available_schedules) > 0: # 가능한 날짜가 있다면
ret['response'] = {'schedule' : available_schedules, 'first_date' : available_schedules.keys()[0] }
else:
add_err_message_to_response(ret, err_dict['err_not_available'])
mongo_logger.debug('no masters', extra = {'log_time' : dt.datetime.now(), 'user_id' : uid, 'taking_time' : total_taking_time_in_minutes, 'gu_id' : gu_id, 'address' : address})
user_name = userdao.get_user_name(uid)
user_phone = userdao.get_user_phone(uid)
send_jandi('BOOKING_NOT_AVAILABE', '예약 불가능 알림', '고객 : {} 전번 : {}'.format(user_name, user_phone),
'주기 : {}, 주소 : {}'.format(appointment_type, address))
self.set_status(Response.RESULT_OK)
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 available schedules', extra = {'user_id' : uid, 'err' : str(e)})
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)
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)
for_manager = self.get_argument('for_manager', '')
# for address parameter
address = self.get_argument('address', '')
size = self.get_argument('size', 25)
kind = self.get_argument('kind', 0)
size = int(size)
kind = int(kind)
# convert parameters
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
isdirty = int(isdirty)
# logging part
mix = get_mixpanel()
mongo_logger = get_mongo_logger()
try:
print uid
if self.is_user_block(ret, uid) == True:
return
if appointment_type == BC.ONE_TIME_A_MONTH:
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, '4주 1회 서비스는 신규 예약을 지원하지 않습니다.')
mongo_logger.debug('not booking one time a month', extra = { 'user_id' : uid })
ret['err_code'] = '4038' # 임시 처리
return
if total_taking_time_in_minutes <= 0 or taking_time_in_minutes <= 0:
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, '클리닝 시간이 잘못 설정되었습니다.')
ret['err_code'] = '9999' # 임시 처리
return
if total_taking_time_in_minutes >= 600:
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, '클리닝 가능 시간을 초과하였습니다. (최대 10시간) 이전 화면으로 돌아가 추가사항을 2개이하로 줄여주세요.')
ret['err_code'] = '4036' # 임시 처리
return
scheduler = HMScheduler()
session = Session()
userdao = UserDAO()
addrdao = AddressDAO()
# add user address
latlng = get_latlng_from_address(address)
if len(latlng) > 1:
latitude = latlng[0]
longitude = latlng[1]
geohash5 = get_geohash(latitude, longitude, 5)
geohash6 = get_geohash(latitude, longitude, 6)
else:
latitude = 0.0
longitude = 0.0
geohash5 = ''
geohash6 = ''
key = userdao.get_user_salt_by_id(uid)[:16]
crypto = aes.MyCrypto(key)
encrypted_address = crypto.encodeAES(str(address))
count = session.query(UserAddress).filter(UserAddress.user_id == uid).count()
last_index = session.query(UserAddress).filter(UserAddress.user_id == uid).order_by(desc(UserAddress.user_addr_index)).first()
index = 0
if last_index != None:
index = last_index.user_addr_index + 1
new_address = UserAddress(user_id = uid, address = encrypted_address, size = size, kind = kind,
user_addr_index = index, latitude = latitude, longitude = longitude,
geohash5 = geohash5, geohash6 = geohash6)
session.add(new_address)
session.commit()
# set default address index
if count == 0:
new_default_address = UserDefaultAddress(user_id=uid, address_idx=index)
session.add(new_default_address)
else:
record = session.query(UserDefaultAddress).filter(UserDefaultAddress.user_id == uid).one()
record.address_idx = index
session.commit()
address, geohash5, geohash6 = userdao.get_user_address(uid)
_, size, kind = userdao.get_user_address_detail(uid)
gu_id = addrdao.get_gu_id(address)
if gu_id == '':
raise Exception('gu id is incorrect')
return
available_schedules = scheduler.get_available_slots(gu_id = gu_id, geohash = geohash6, appointment_type = appointment_type, taking_time = total_taking_time_in_minutes,
prefer_women = True if master_gender == 1 else False,
have_pet = True if have_pet == 1 else False,
isdirty = True if isdirty == 1 else False,
user_id = uid)
now = dt.datetime.now()
if now.hour >= 17: # 7시 이후 라면 -> 5시로 변경 2016.06.03
if for_manager == '': # 사용자 앱에서는 내일 예약 불가능
tomorrow = now + dt.timedelta(days=1)
tomorrow = dt.datetime.strftime(tomorrow, '%Y%m%d')
if tomorrow in available_schedules:
del available_schedules[tomorrow]
for day in available_schedules:
print '[', day, ']'
print available_schedules[day]['by_time']
# log to mixpanel
mix.track(uid, 'request available schedule', {'time' : dt.datetime.now(), '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('request available schedule', extra = {'log_time' : dt.datetime.now(), 'user_id' : uid, 'taking_time' : taking_time, 'additional_time' : additional_time, 'appointment_type' : appointment_type, 'have_pet' : have_pet, 'master_gender' : master_gender,'isdirty' : isdirty})
if len(available_schedules) > 0: # 가능한 날짜가 있다면
ret['response'] = {'schedule' : available_schedules, 'first_date' : available_schedules.keys()[0] }
else:
add_err_message_to_response(ret, err_dict['err_not_available'])
mongo_logger.debug('no masters', extra = {'log_time' : dt.datetime.now(), 'user_id' : uid, 'taking_time' : total_taking_time_in_minutes, 'gu_id' : gu_id, 'address' : address})
user_name = userdao.get_user_name(uid)
user_phone = userdao.get_user_phone(uid)
send_jandi('BOOKING_NOT_AVAILABE', '예약 불가능 알림', '고객 : {} 전번 : {}'.format(user_name, user_phone),
'주기 : {}, 주소 : {}'.format(appointment_type, address))
self.set_status(Response.RESULT_OK)
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 available schedules', extra = {'user_id' : uid, 'err' : str(e)})
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 = {}
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")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
name = self.get_argument('name', '')
authsource = self.get_argument('authsource', 'None')
devicetype = self.get_argument('devicetype', 'web')
email = self.get_argument('email', '')
password = self.get_argument('password', '')
phone = self.get_argument('phone', '')
is_b2b = self.get_argument('is_b2b', 0)
phone = phone.replace('-', '')
phone = phone.replace(' ', '')
gender = 2 # neither male or female
birthdate = ''
is_b2b = int(is_b2b)
err_msg = ''
if name == '':
err_msg = 'name is invalid'
elif email == '':
err_msg = 'email is invalid'
elif password == '':
err_msg = 'password is invalid'
if err_msg != '': # invalid argument situation
ret['response'] = err_msg
self.set_status(Response.RESULT_BADREQUEST)
add_err_message_to_response(ret, err_dict['invalid_param'])
return
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
guid = str(uuid.uuid4())
registerdate = dt.datetime.now()
registerdate_str = dt.datetime.strftime(registerdate, '%Y%m%d')
count = session.query(User).filter(User.email == email, User.active == 1).count()
if count > 0:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_dup_email'])
mongo_logger.debug('%s is already existed' % email, extra = {'err' : 'duplicate email'})
return
# phone duplicacy check
count = session.query(User) \
.filter(func.aes_decrypt(func.from_base64(User.phone), \
func.substr(User.salt, 1, 16)) == phone, \
User.active == 1) \
.count()
if count > 0:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_dup_phone'])
mongo_logger.debug('phone already existed', extra = {'err' : 'duplicate phone'})
return
salt = uuid.uuid4().hex
encrypted_password = hashlib.sha256(salt + password).hexdigest()
key = salt[:16]
print key
crypto = aes.MyCrypto(key)
encrypted_name = crypto.encodeAES(str(name))
encrypted_phone = crypto.encodeAES(str(phone))
encrypted_birthdate = crypto.encodeAES(str(birthdate))
print encrypted_name, name
print encrypted_phone, phone
print encrypted_birthdate, birthdate
new_user = User(id = guid, name = encrypted_name, gender = gender, authsource = authsource,
devicetype = devicetype, email = email, password = encrypted_password, salt = salt,
phone = encrypted_phone, dateofbirth = encrypted_birthdate,
dateofreg = registerdate, dateoflastlogin= registerdate, is_b2b = is_b2b)
session.add(new_user)
session.commit()
ret['response'] = guid
self.set_status(Response.RESULT_OK)
print email, 'has successfully registered..!!'
print dt.datetime.now()
mix.track(guid, 'register', {'time' : dt.datetime.now()})
mix.people_set(guid, {'$name' : name, '$email' : email, '$gender' : gender,
'$authsource' : authsource, '$phone' : phone, '$devicetype' : devicetype,
'$brithdate' : birthdate, '$registerdate' : registerdate_str,
'$time' : dt.datetime.now()},
{'$ip' : '121.134.224.40'})
mongo_logger.debug('register', extra = {'log_time' : dt.datetime.now(), 'user_id': guid, 'user_name' : name, 'gender' : gender, 'authsource' : authsource, 'devicetype' : devicetype, 'email' : email, 'phone' : phone})
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('failed to register', extra = {'log_time' : dt.datetime.now(), 'user_name' : name, 'gender' : gender, 'authsource' : authsource, 'devicetype' : devicetype, 'email' : email, 'phone' : phone, 'err' : str(e)})
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)
def cancel_payment_new(user_id,
booking_id,
amount,
partial,
appointment_type,
cancel_msg='refund'):
try:
request_url = '%s:%d/homemaster_payment/cancel_payment_new' % (
PAYMENT_HOST, PAYMENT_PORT)
session = Session()
# get tid from booking_id
row = session.query(Booking).filter(Booking.id == booking_id).one()
tid = row.tid
session.close()
params = {
'id': user_id,
'tid': tid,
'amount': int(amount),
'partial': partial,
'appointment_type': appointment_type,
'cancel_msg': cancel_msg
}
response = requests.post(request_url, data=params)
result = json.loads(response.text)
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
print result
if 'response' in result and result['response'] == Response.SUCCESS:
mix.people_track_charge(user_id, (-1 * amount),
{'time': dt.datetime.now()})
mongo_logger.debug('%s cancel charged for credit card' % user_id,
extra={
'booking_id': booking_id,
'tid': tid,
'amount': amount,
'partial': partial
})
return True, ''
else:
print 'An error occurred while cancel processing...'
print result['err_code'], result['err_msg']
mongo_logger.error('%s failed to cancel charged for credit card' %
user_id,
extra={
'booking_id': booking_id,
'err': result['err_msg']
})
return False, result['err_msg']
except Exception, e:
print_err_detail(e)
mongo_logger.error('%s failed to cancel charged for credit card' %
user_id,
extra={
'booking_id': booking_id,
'err': str(e)
})
return False, str(e)
