def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
booking_id = self.get_argument('booking_id', '')
div_no = self.get_argument('div_no', '')
ret = {}
mongo_logger = get_mongo_logger()
try:
session = Session()
order_11st = OrderID11st(booking_id = booking_id, div_no = div_no,
datetime = dt.datetime.now())
session.add(order_11st)
session.commit()
ret['response'] = Response.SUCCESS
mongo_logger.debug('link hm 11st', extra = {'div_no' : div_no, 'booking_id' : booking_id})
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('failed tolink hm 11st',
extra = {'div_no' : div_no, 'booking_id' : booking_id})
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
user_id = self.get_argument('user_id', '')
master_id = self.get_argument('master_id', '')
ret = {}
try:
session = Session()
reject_relation = RejectRelation(user_id=user_id,
master_id=master_id)
session.add(reject_relation)
session.commit()
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 = {}
uid = self.get_argument('id', '')
pushkey = self.get_argument('pushkey', '')
try:
session = Session()
count = session.query(UserPushKey).filter(UserPushKey.user_id == uid).count()
if count == 0: # insert
new_user_pushkey = UserPushKey(user_id=uid, pushkey = pushkey)
session.add(new_user_pushkey)
else: # update
row = session.query(UserPushKey).filter(UserPushKey.user_id == uid).one()
row.pushkey = pushkey
session.commit()
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
print uid, 'modified pushkey successfully'
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")
self.set_header('Access-Control-Allow-Origin', '*')
booking_id = self.get_argument('booking_id', '')
comment = self.get_argument('comment', '')
print "booking_id : " + booking_id
print "comment : " + comment
ret = {}
try:
session = Session()
user_claim = UserClaim(booking_id = booking_id, comment = comment, register_time = dt.datetime.now())
session.add(user_claim)
session.commit()
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 = {}
uid = self.get_argument('user_id', '')
mid = self.get_argument('master_id', '')
memo = self.get_argument('memo', '')
mongo_logger = get_mongo_logger()
try:
session = Session()
memo = MasterMemo(user_id=uid,
master_id=mid,
memo=memo,
datetime=dt.datetime.now())
session.add(memo)
session.commit()
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
print mid, 'posted memo successfully'
mongo_logger.debug('%s posted memo' % mid)
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('%s failed to posted memo' % mid,
extra={'err': str(e)})
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
user_id = self.get_argument('user_id', '')
memo = self.get_argument('memo', '')
print 'user_id : ' + user_id
print 'memo : ' + memo
ret = {}
try:
session = Session()
admin_memo = AdminMemo(user_id=user_id,
memo=memo,
register_time=dt.datetime.now())
session.add(admin_memo)
session.commit()
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
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 = {}
master_id = self.get_argument('master_id', '')
user_id = self.get_argument('user_id', '')
claim_text = self.get_argument('claim_text', '')
try:
session = Session()
claim = MasterClaim(master_id=master_id,
user_id=user_id,
claim_text=claim_text,
register_time=dt.datetime.now())
session.add(claim)
session.commit()
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")
self.set_header('Access-Control-Allow-Origin', '*')
master_id = self.get_argument('master_id', '')
prize = self.get_argument('prize', 0)
prize_description = self.get_argument('prize_description', '')
prize = int(prize)
ret = {}
mongo_logger = get_mongo_logger()
try:
session = Session()
master_prize = MasterPrize(master_id = master_id, prize = prize, prize_description = prize_description, earn_date = dt.datetime.now())
session.add(master_prize)
session.commit()
mongo_logger.debug('add point', extra = {'master_id' : master_id, 'prize' : prize, 'prize_description' : prize_description})
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'])
mongo_logger.error('add point error', extra = {'master_id' : master_id, 'prize' : prize, 'prize_description' : prize_description})
def post(self):
self.set_header("Content-Type", "application/json")
name = self.get_argument('name', '')
phone = self.get_argument('phone', '')
ret = {}
try:
session = Session()
manager_id = str(uuid.uuid4())
new_manager = Manager(id=manager_id, name=name, phone=phone)
session.add(new_manager)
session.commit()
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
print 'manager named', name, 'was successfully added..'
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")
self.set_header('Access-Control-Allow-Origin', '*')
title = self.get_argument('title', '')
content = self.get_argument('content', '')
print 'title : ' + title
print 'content : ' + content
ret = {}
try:
session = Session()
master_notice = MasterNotice(title=title,
content=content,
reg_time=dt.datetime.now())
session.add(master_notice)
session.commit()
notify_all_active_homemaster()
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 request_charge(user_id, user_name, amount):
try:
request_url = '%s:%d/homemaster_payment/request_payment_new' % (
PAYMENT_HOST, PAYMENT_PORT)
params = {
'id': user_id,
'name': user_name,
'price': amount,
'product_name': 'charge_for_cancel'
}
response = requests.post(request_url, data=params)
result = json.loads(response.text)
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
if result['response'] == Response.SUCCESS:
# upate request payment record
tid = result['tid']
authdate = result['authdate']
session = Session()
charge_record = UserChargeRecord(user_id=user_id,
tid=tid,
amount=amount,
auth_date=authdate)
session.add(charge_record)
session.commit()
session.close()
mix.people_track_charge(user_id, amount,
{'time': dt.datetime.now()})
mongo_logger.debug(
'%s charged for canceling before passing 2 months' % user_id,
extra={'amount': amount})
return True, tid
else:
print 'An error occurred while charging processing...'
print result['err_code'], result['err_msg']
mongo_logger.error(
'%s failed to charged for canceling before passing 2 months' %
user_id,
extra={'err': result['err_msg']})
return False, result['err_msg']
except Exception, e:
print_err_detail(e)
mongo_logger.error(
'%s failed to charged for canceling before passing 2 months' %
user_id,
extra={'err': str(e)})
return False, str(e)
def request_unpaid_charge(user_id, user_name, amount, interest, quota):
try:
request_url = '%s:%d/homemaster_payment/request_payment_quota' % (
PAYMENT_HOST, PAYMENT_PORT)
params = {
'id': user_id,
'name': user_name,
'price': amount,
'product_name': '미납결제',
'interest': interest,
'quota': quota
}
response = requests.post(request_url, data=params)
result = json.loads(response.text)
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
if result['response'] == Response.SUCCESS:
# upate request payment record
tid = result['tid']
authdate = result['authdate']
session = Session()
payment_record = ManualPaymentRecord(user_id=user_id,
amount=amount,
auth_date=authdate,
interest=interest,
quota=quota)
session.add(payment_record)
session.commit()
session.close()
mix.people_track_charge(user_id, amount,
{'$time': dt.datetime.now()})
mongo_logger.debug('%s paid for unpaid ' % user_id,
extra={'price': amount})
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 unpaid' % user_id,
extra={'err': result['err_msg']})
return False, result['err_msg']
except Exception, e:
print_err_detail(e)
mongo_logger.error('%s failed to paid for unpaid' % user_id,
extra={'err': str(e)})
return False, str(e)
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
master_id = self.get_argument('master_id', '')
off_date = self.get_argument('off_date', '') # 20160603
master_date_key = '{0}_{1}'.format(master_id, off_date)
off_date = dt.datetime.strptime(off_date, '%Y%m%d')
ret = {}
try:
session = Session()
masterdao = MasterDAO()
# add request logs
# type : 1 - request, 0 - cancel
day_off_request = MasterDayoffRequest(
master_id=master_id,
date=off_date,
type=0,
request_time=dt.datetime.now())
session.add(day_off_request)
# master schedules by date active -> 0
row = session.query(MasterScheduleByDate) \
.filter(MasterScheduleByDate.master_id == master_id) \
.filter(MasterScheduleByDate.date == off_date) \
.one()
row.active = 1
# commit
session.commit()
master_name = masterdao.get_master_name(master_id)
send_jandi('HOMEMASTER_REST', "휴무 신청 취소",
master_name + ' 홈마스터님 휴무 신청 취소',
'휴무 취소 날짜 : {}'.format(off_date))
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
print 'master_id', master_id, 'cancel dayoff request', off_date
except NoResultFound, e:
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, '휴무 신청 취소 가능 날짜가 아닙니다.')
return
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
master_id = self.get_argument('master_id', '')
category_idx = self.get_argument('category_idx', '')
penalty_idx = self.get_argument('penalty_idx', '')
penalty = self.get_argument('penalty', '')
category_idx = int(category_idx)
penalty_idx = int(penalty_idx)
ret = {}
mongo_logger = get_mongo_logger()
try:
session = Session()
master_penalty = MasterPenalty(master_id=master_id,
category_idx=category_idx,
penalty_idx=penalty_idx,
penalty=penalty,
penalty_date=dt.datetime.now())
session.add(master_penalty)
session.commit()
mongo_logger.debug('charge penalty',
extra={
'master_id': master_id,
'category_idx': category_idx,
'penalty_idx': penalty_idx,
'penalty': penalty
})
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'])
mongo_logger.error('charge penalty error',
extra={
'master_id': master_id,
'category_idx': category_idx,
'penalty_idx': penalty_idx,
'penalty': penalty
})
def post(self):
self.set_header("Content-Type", "application/json")
user_id = self.get_argument('user_id', '')
ret = {}
try:
session = Session()
userdao = UserDAO()
addr_idx = userdao.get_user_default_address_index(user_id)
booking = MovingCleaningBooking(user_id=user_id,
addr_idx=addr_idx,
datetime=dt.datetime.now())
session.add(booking)
session.commit()
# send sms
sms_sender = SMS_Sender()
name = str(userdao.get_user_name(user_id))
phone = str(userdao.get_user_phone(user_id))
address, size, kind = userdao.get_user_address_detail(user_id)
address = str(address)
if kind == 0:
kind = '오피스텔'
elif kind == 1:
kind = '주택'
elif kind == 2:
kind = '아파트'
text = '입주청소 예약 문의\n이름: %s\n번호: %s\n주소: %s\n종류: %s\n평수:%d' % (
name, phone, address, kind, size)
#print sms_sender.send_for_manager(sender = MAIN_CALL, mtype = 'lms', to = JAMES_CALL, text = str(text))
# jandi notification
send_jandi('MOVING_IN_CLEANING', "이사청소 문의", name + ' 고객님 이사청소 문의',
text)
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 generate_promotion_codes(discount_price, start_num, end_num):
try:
session = Session()
for i in xrange(start_num, end_num):
hashids = Hashids(min_length=6, salt='show' + str(i))
code = hashids.encode(i)
print code
p = Promotion(promotion_code=code,
used=0,
discount_price=discount_price,
source='hm')
session.add(p)
session.commit()
except Exception, e:
print_err_detail(e)
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
master_id = self.get_argument('master_id', '')
ret = {}
mongo_logger = get_mongo_logger()
try:
session = Session()
row = session.query(func.sum(MasterPrize.prize)) \
.filter(MasterPrize.master_id == master_id) \
.one()
if int(row[0]) <= 0:
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_no_zero_point'])
mongo_logger.debug('reset failed', extra = {'master_id' : master_id})
return
prize = -1 * int(row[0])
prize_description = 'reset'
print prize, prize_description
master_prize = MasterPrize(master_id = master_id, prize = prize, prize_description = prize_description, earn_date = dt.datetime.now())
session.add(master_prize)
session.commit()
mongo_logger.debug('reset point', extra = {'master_id' : master_id, 'prize' : prize, 'prize_description' : prize_description})
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'])
mongo_logger.error('reset point error', extra = {'master_id' : master_id, 'prize' : prize, 'prize_description' : prize_description})
def update_new_master_schedule_with_active(self, master_id,
non_active_dates):
try:
session = Session()
masterdao = MasterDAO()
max_date = masterdao.get_master_schedule_max_date()
free_times_by_date = masterdao.get_available_time_by_date(
master_id)
print free_times_by_date
current_date = dt.datetime.now().date() + dt.timedelta(days=1)
print current_date, max_date
while current_date <= max_date:
free_times = free_times_by_date[current_date.weekday(
)] if current_date.weekday() in free_times_by_date else None
if free_times != None:
free_from = free_times[0]
free_to = free_times[1]
active = 1
if current_date in non_active_dates:
active = 0
schedule_by_date = MasterScheduleByDate(
master_id=master_id,
date=current_date,
free_from=free_from,
free_to=free_to,
active=active)
session.add(schedule_by_date)
current_date += dt.timedelta(days=1)
session.commit()
print 'build schedule successfully performed its task for master', master_id, 'in', dt.datetime.now(
)
except Exception, e:
session.rollback()
print_err_detail(e)
def post(self):
self.set_header("Content-Type", "application/json")
ret = {}
uid = self.get_argument('user_id', '')
memo = self.get_argument('memo', '')
mongo_logger = get_mongo_logger()
try:
session = Session()
query = session.query(UserMemo).filter(UserMemo.user_id == uid)
if query.count() == 0:
memo = UserMemo(user_id=uid,
memo=memo,
requested_datetime=dt.datetime.now())
session.add(memo)
else:
row = query.one()
row.requested_datetime = dt.datetime.now()
row.memo = memo
session.commit()
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
# notification to managers
#send_memo_requested(uid)
print uid, 'posted memo successfully'
mongo_logger.debug('%s posted memo' % uid)
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('%s failed to posted memo' % uid,
extra={'err': str(e)})
def post(self):
self.set_header("Content-Type", "application/json")
ret = {}
master_id = self.get_argument('master_id', '')
account_no = self.get_argument('account_no', '')
bank_name = self.get_argument('bank_name', '')
try:
session = Session()
if not bank_name in bank_dict.keys():
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(
ret, bank_name + '은(는) 지원하지 않는 은행입니다.')
return
bank_dict = BC.bank_dict
account_no = account_no.replace('-', '')
account = MasterAccount(master_id=master_id,
account_no=account_no,
bank_code=bank_dict[bank_name],
bank_name=bank_name,
datetime=dt.datetime.now())
session.add(account)
session.commit()
print master_id, ' has successfully add account!'
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
except NoResultFound, 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', '*')
booking_id = self.get_argument('booking_id', '')
try1 = self.get_argument('try1', '')
try2 = self.get_argument('try2', '')
try3 = self.get_argument('try3', '')
memo = self.get_argument('memo', '')
ret = {}
try:
session = Session()
row = session.query(RegularBasisManagement) \
.filter(RegularBasisManagement.booking_id == booking_id) \
.first()
if row == None:
rbm = RegularBasisManagement(booking_id=booking_id,
try_1st=try1,
try_2nd=try2,
try_3rd=try3,
memo=memo)
session.add(rbm)
else:
row.try_1st = try1
row.try_2nd = try2
row.try_3rd = try3
row.memo = memo
session.commit()
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
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', '*')
booking_id = self.get_argument('booking_id', '')
extra_mins = self.get_argument('extra_mins', 30)
extra_mins = int(extra_mins)
ret = {}
try:
session = Session()
userdao = UserDAO()
addressdao = AddressDAO()
extra_time = ExtraTime(booking_id = booking_id,
extended_mins = extra_mins,
request_time = dt.datetime.now())
session.add(extra_time)
session.commit()
# 고객 push
# 마스터 급여
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 set_promotion_code_status(self, code, new_status, booking_id, price):
UNUSED = 0
USED = 1
OCCUPIED = 2
try:
session = Session()
if code in PROMOTION_CODES:
booking = session.query(EventPromotion).filter(
EventPromotion.code == code).one()
discount_price = booking.amount
if discount_price <= 100: # 100 이하면 퍼센트로 간주
discount_price = price * discount_price
eventpromotion_booking = EventPromotionBooking(
booking_id=booking_id,
event_name=code,
discount_price=discount_price)
session.add(eventpromotion_booking)
else:
try:
row = session.query(Promotion).filter(
Promotion.promotion_code == code).one()
except NoResultFound, e:
session.close()
print_err_detail(e)
return
if new_status == USED:
row.used = new_status
row.booking_id = booking_id
row.service_price = price
row.used_datetime = dt.datetime.now()
elif new_status == UNUSED:
row.used = new_status
session.commit()
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
master_id = self.get_argument('master_id', '')
region_ids = self.get_argument('region_ids', '')
# convert date type
region_ids = region_ids.split(',')
ret = {}
try:
session = Session()
# master prefered area
session.query(MasterPreferedArea).filter(
MasterPreferedArea.master_id == master_id).delete()
session.commit()
for rid in region_ids:
try:
rid = int(rid)
except Exception, e:
print e
continue
new_master_area = MasterPreferedArea(master_id=master_id,
prefered_gu=rid)
session.add(new_master_area)
session.commit()
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
print master_id, 'successfully updated regions ids...'
def build_schedule_weekly(self):
try:
DAYS_IN_A_WEEK = 7
session = Session()
masterdao = MasterDAO()
max_date = masterdao.get_master_schedule_max_date()
master_ids = masterdao.get_all_master_ids()
for mid in master_ids:
free_times_by_date = masterdao.get_available_time_by_date(mid)
for i in xrange(DAYS_IN_A_WEEK):
date = max_date + dt.timedelta(days=i + 1)
free_times = free_times_by_date[date.weekday(
)] if date.weekday() in free_times_by_date else None
if free_times != None:
free_from = free_times[0]
free_to = free_times[1]
schedule_by_date = MasterScheduleByDate(
master_id=mid,
date=date,
free_from=free_from,
free_to=free_to)
session.add(schedule_by_date)
session.commit()
print 'build schedule weekly successfully performed its task in', dt.datetime.now(
)
except Exception, e:
session.rollback()
print_err_detail(e)
def initial_build_schedule(self):
try:
# 모든 홈마스터에 대해, 오늘 이후 20주 데이터 빌드 (140 days)
NUM_DAYS = 140
session = Session()
masterdao = MasterDAO()
master_ids = masterdao.get_all_master_ids()
for mid in master_ids:
today = dt.datetime.now()
free_times_by_date = masterdao.get_available_time_by_date(mid)
for i in xrange(NUM_DAYS):
date = today + dt.timedelta(days=(i + 1))
free_times = free_times_by_date[date.weekday(
)] if date.weekday() in free_times_by_date else None
if free_times != None:
free_from = free_times[0]
free_to = free_times[1]
schedule_by_date = MasterScheduleByDate(
master_id=mid,
date=date.date(),
free_from=free_from,
free_to=free_to)
session.add(schedule_by_date)
session.commit()
except Exception, e:
session.rollback()
print_err_detail(e)
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 add_booking(self, order_dict, user_id):
try:
session = Session()
holder = IntermediateValueHolder()
if not 'lnkKey' in order_dict:
print 'NO BOOKING ID - lnkKey'
print '*' * 100
return
store_key = order_dict['lnkKey']
obj = holder.retrieve(store_key)
if obj == None:
return [], False
master_id = obj['master_id']
dates = obj['dates']
time = obj['time']
cleaning_duration = obj['cleaning_duration']
additional_time = 0
if 'additional_time' in obj:
additional_time = obj['additional_time']
order_id = order_dict['ordNo']
product_no = order_dict['sellerPrdNo']
if '_' in product_no:
product_no = product_no.split('_')
appointment_type = int(product_no[2])
else:
appointment_type = 0
# field
request_id = str(uuid.uuid4())
#appointment_type = int(product_no[2])
message = order_dict[
'rsvEtcInfo5'] if 'rsvEtcInfo5' in order_dict else ''
trash_location = '%s %s' % (order_dict['rsvEtcInfo1'],
order_dict['rsvEtcInfo2'])
havepet = 0 if order_dict['rsvEtcInfo3'] == '아니오' else 1
card_idx = -1
addr_idx = 0
options = order_dict['RsvDtlsInfo']
print options
options_price = sum([int(opt['optAmt']) for opt in options[1:]])
options_name = [opt['optNm'] for opt in options[1:]]
additional_task = 0
if options_name != [None]:
for opt in options_name:
if '창문' in opt:
additional_task += 1
elif '베란다' in opt:
additional_task += 2
elif '빨래' in opt:
additional_task += 4
elif '옷장' in opt:
additional_task += 8
elif '단문형' in opt:
additional_task += 16
elif '양문형' in opt:
additional_task += 32
actual_price = int(order_dict['rsvAmt'])
price = actual_price - options_price
now = dt.datetime.strftime(dt.datetime.now(), '%Y%m%d%H%M%S')
hashids = Hashids(min_length=16, salt=now + user_id)
booking_ids = []
index = 1
for date in dates: #
print date, time
if index == 1:
booking_id = store_key
else:
booking_id = hashids.encode(
int(date + time.replace(':', '')))
print 'key', booking_id
date = dt.datetime.strptime(date, '%Y%m%d')
dow = date.date().weekday()
booking_time = dt.time(hour=int(time.split(':')[0]),
minute=int(time.split(':')[1]))
start_time = dt.datetime.combine(date, booking_time)
estimated_end_time = start_time + dt.timedelta(
minutes=cleaning_duration + additional_time)
if index != 1:
actual_price = price
additional_task = 0
estimated_end_time -= dt.timedelta(minutes=additional_time)
booking = Booking(
id=booking_id,
request_id=request_id,
user_id=user_id,
master_id=master_id,
appointment_type=appointment_type,
appointment_index=index,
dow=dow,
booking_time=dt.datetime.now(),
org_start_time=start_time,
start_time=start_time,
estimated_end_time=estimated_end_time,
end_time=
estimated_end_time, # update after homemaster finish their job
cleaning_duration=cleaning_duration,
additional_task=additional_task,
price=price,
price_with_task=actual_price,
charging_price=0,
card_idx=card_idx,
addr_idx=addr_idx,
message=message,
trash_location=trash_location,
havepet=havepet,
laundry_apply_all=0,
is_dirty=0,
master_gender=0,
source='11st',
status=BC.BOOKING_UPCOMMING,
cleaning_status=BC.BOOKING_UPCOMMING,
payment_status=BC.BOOKING_PAID)
session.add(booking)
index += 1
booking_ids.append(booking_id)
# remove store_key and related_keys
store_key = obj['store_key']
search_keys = obj['search_keys'].split(',')
holder.remove(store_key)
for sk in search_keys:
holder.remove(sk)
# order_11st에 order_id 추가 필요.
print order_id
order = Order11st(order_id=order_id)
session.add(order)
session.commit()
except Exception, e:
print_err_detail(e)
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)})
