def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
cleaning_id = self.get_argument('cleaning_id', '')
booking_id = self.get_argument('booking_id', '')
mongo_logger = get_mongo_logger()
ret = {}
try:
doc = self.db.find_one_and_update({'cleaning_id': cleaning_id}, {
'$push': {
'booking_ids': booking_id
},
'$inc': {
'count': 1
}
})
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
mongo_logger.debug('web process booking')
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('failed to web process booking')
def get(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
mongo_logger = get_mongo_logger()
try:
now = dt.datetime.now()
r = redis.Redis(host = REDIS_HOST, port = REDIS_PORT, password = REDIS_PWD)
event_on = r.get('free_event')
event = True
if event_on == None or event_on != 'on':
event = False
ret['response'] = event
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', '*')
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")
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', '*')
cleaning_id = self.get_argument('cleaning_id', '')
contact_cnt = self.get_argument('contact_cnt', '1회')
contact_memo = self.get_argument('contact_memo', '')
ret = {}
mongo_logger = get_mongo_logger()
try:
doc = self.db.find_one_and_update({'cleaning_id' : cleaning_id},
{'$set' : {'contact_cnt' : contact_cnt,
'contact_memo' : contact_memo}},
return_document = ReturnDocument.AFTER)
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
mongo_logger.debug('web update web cleaning status',
extra = {'cleaning_id' : cleaning_id,
'contact_cnt' : contact_cnt,
'contact_memo' : contact_memo})
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('failed to web update web cleaning status',
extra = {'cleaning_id' : cleaning_id,
'contact_cnt' : contact_cnt,
'contact_memo' : contact_memo})
def post(self):
self.set_header("Content-Type", "application/json")
ret = {}
email = self.get_argument('email', '')
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
try:
row = session.query(User).filter(User.email == email,
User.active == 1).one()
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_login_no_record'])
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_multiple_record'])
mongo_logger.error('%s failed to logined' % email,
extra={'err': str(e)})
return
def get(self, **params):
self.set_header("Content-Type", "application/json")
user_id = self.get_argument('id', '')
mode = params['mode']
ret = {}
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
bookings = self.get_mybookings(session, user_id, mode)
ret['response'] = bookings
self.set_status(Response.RESULT_OK)
mix.track(user_id, 'got booking info', {
'time': dt.datetime.now(),
'mode': mode
})
mongo_logger.debug('got booking info', extra={'uid': user_id})
print user_id, 'successfully retrieved upcomming events...', dt.datetime.now(
)
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 get(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
mongo_logger = get_mongo_logger()
ret = {}
web_bookings = []
try:
docs = self.db.find({'$where' : 'this.dates.length > this.count',
'payment' : {'$exists' : True},
'removed' : {'$exists' : False}}) \
.sort('request_time', pymongo.DESCENDING)
for doc in docs:
booking = {}
booking['name'] = doc['name']
booking['phone'] = doc['phone']
booking['address'] = doc['address']
booking['address_index'] = doc['address_index']
booking['dates'] = doc['dates']
booking['start_date'] = doc[
'start_date'] if 'start_date' in doc else ''
booking['time'] = doc['time']
booking['user_id'] = doc['user_id']
booking['cleaning_id'] = doc['cleaning_id']
booking['tasks'] = doc['tasks']
booking['rooms'] = doc['rooms']
booking['baths'] = doc['baths']
booking['size'] = doc['size'] if 'size' in doc else 0
booking['total_price'] = doc['total_price']
booking['total_duration'] = doc['total_duration']
booking['basic_price'] = doc['basic_price']
booking['basic_duration'] = doc['basic_duration']
booking['period'] = doc['period']
booking['email'] = doc['email']
booking['dirty'] = doc['dirty']
booking['payment'] = doc['payment']
booking['count'] = doc['count']
booking['message'] = doc['message']
booking['request_time'] = dt.datetime.strftime(
doc['request_time'], '%Y-%m-%d %H:%M')
booking['contact_cnt'] = doc[
'contact_cnt'] if 'contact_cnt' in doc else '0회'
booking['contact_memo'] = doc[
'contact_memo'] if 'contact_memo' in doc else ''
web_bookings.append(booking)
ret['response'] = web_bookings
self.set_status(Response.RESULT_OK)
mongo_logger.debug('web booking')
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('failed to web booking')
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 = {}
mongo_logger = get_mongo_logger()
try:
now = dt.datetime.now()
session = Session()
row = session.query(Booking, UserCard) \
.outerjoin(UserCard, and_(Booking.user_id == UserCard.user_id, Booking.card_idx == UserCard.user_card_index)) \
.filter(Booking.user_id == user_id) \
.filter(Booking.start_time < now) \
.filter(Booking.cleaning_status == BC.BOOKING_COMPLETED) \
.filter(Booking.payment_status != BC.BOOKING_PAID) \
.order_by(desc(Booking.start_time)) \
.first()
if row:
booking_id = row.Booking.id
cleaning_price = row.Booking.price_with_task
cleaning_time = convert_datetime_format2(row.Booking.start_time)
card_alias = row.UserCard.card_alias if row.UserCard != None else ''
ret['response'] = {'unpaid_booking' : True,
'card_alias' : card_alias,
'booking_id' : booking_id,
'cleaning_price' : cleaning_price,
'cleaning_time' : cleaning_time}
mongo_logger.debug('check unpaid booking', extra = {'user_id' : user_id,
'dt' : now,
'unpaid_booking' : True,
'booking_id' : booking_id,
'cleaning_price' : cleaning_price,
'cleaning_time' : cleaning_time})
else:
ret['response'] = {'unpaid_booking' : False}
mongo_logger.debug('check unpaid booking', extra = {'user_id' : user_id,
'dt' : now,
'unpaid_booking' : False})
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('failed to check unpaid booking', extra = {'err' : str(e)})
def post(self):
self.set_header("Content-Type", "application/json")
ret = {}
email = self.get_argument('email', '')
pwd = self.get_argument('pwd', '')
print 'login', email, pwd
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
userdao = UserDAO()
try:
row = session.query(User) \
.filter(User.email == email, User.password == pwd, 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.password == pwd, \
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")
ret = {}
booking_id = self.get_argument('booking_id', '')
caller_mdn = self.get_argument('caller_mdn', '')
callee_mdn = self.get_argument('callee_mdn', '')
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
row = session.query(Booking).filter(Booking.id == booking_id).one()
data = {}
data_header = {}
data_body = {}
text = convert_datetime_format3(row.start_time)
if row.cleaning_status == 0:
text += ' 예정'
# data header
data_header['VERSION'] = '1.0.0'
data_header['CALLER_ID'] = PKG_MASTER
# data body
data_body['SERVICE_KEY'] = T_SERVICE_KEY
data_body['SERVICE_NAME'] = "홈마스터"
data_body['CALLER_MDN'] = caller_mdn
data_body['CALLEE_MDN'] = callee_mdn
data_body['TITLE'] = '[홈마스터] 담당 홈마스터입니다'
data_body['TEXT'] = text
data_body['APP_URL'] = 'homemaster://HMBookingList'
data_body['WEB_URL'] = 'https://homemaster.co.kr'
data_body['REQUEST_TYPE'] = '1'
data_body['API_TYPE'] = '1'
# post data
data['HEADER'] = data_header
data['BODY'] = data_body
http_headers = {'Content-Type' : 'application/json; charset=utf-8', 'CPID' : CPID}
response = requests.post(T_BETA_SERVER, data=json.dumps(data), headers=http_headers)
print response.text
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 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 get(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
user_id = self.get_argument('user_id', '')
mongo_logger = get_mongo_logger()
now = dt.datetime.now()
try:
session = Session()
results = session.query(UserCoupon) \
.filter(UserCoupon.user_id == user_id) \
.filter(func.date(UserCoupon.expire_date) >= now.date()) \
.filter(UserCoupon.used == 0) \
.order_by(UserCoupon.expire_date) \
.all()
print "request user coupon sql query"
user_coupons = []
for result in results:
user_coupon = {}
user_coupon['id'] = result.id
user_coupon['issue_date'] = dt.datetime.strftime(
result.issue_date, '%Y.%m.%d')
user_coupon['expire_date'] = dt.datetime.strftime(
result.expire_date, '%Y.%m.%d')
user_coupon['discount_price'] = result.discount_price
user_coupon['description'] = result.description
user_coupon['title'] = result.title
user_coupons.append(user_coupon)
ret['response'] = user_coupons
self.set_status(Response.RESULT_OK)
mongo_logger.debug('request user coupon',
extra={'user_id': user_id})
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 request user coupon',
extra={
'user_id': user_id,
'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('id', '')
tid = self.get_argument('tid', '')
amount = self.get_argument('amount', 0)
partial = self.get_argument('partial', 1)
cancel_msg = self.get_argument('cancel_msg', '')
amount = int(amount)
if cancel_msg == '':
cancel_msg = '취소'
ret = {}
try:
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
userdao = UserDAO()
request_url = '%s:%d/homemaster_payment/cancel_payment' % (
PAYMENT_HOST, PAYMENT_PORT)
params = {}
params['id'] = user_id
params['tid'] = tid
params['amount'] = amount
params['partial'] = partial
params['cancel_msg'] = cancel_msg
response = requests.post(request_url, data=params)
result = json.loads(response.text)
if response.status_code == 200 and result['response'] != "":
mix.track(user_id, 'cancel payment',
{'time': dt.datetime.now()})
mongo_logger.debug('cancel payment',
extra={'user_id': user_id})
ret['response'] = result['response']
self.set_status(Response.RESULT_OK)
else:
print 'An error occurred while register card'
print result['err_msg']
add_err_ko_message_to_response(ret, result['err_msg'])
mix.track(user_id, 'cannot cancel payment',
{'time': dt.datetime.now()})
mongo_logger.error('failed to cancel payment',
extra={'user_id': user_id})
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")
email = self.get_argument('email', '')
ret = {}
if email == '':
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()
try:
session = Session()
try:
row = session.query(User).filter(User.email == email).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()
else:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(
ret, err_dict['err_salt_no_match'])
mongo_logger.error('failed to get salt',
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_salt_no_match'])
mongo_logger.error('failed to get salt',
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('failed to get salt',
extra={'err': str(e)})
return
def send(self, reg_ids, push_data):
mongo_logger = get_mongo_logger()
try:
self.gcm.json_request(registration_ids=reg_ids, data=push_data)
mongo_logger.debug('push notification was sent', extra=push_data)
return True
except Exception, e:
print_err_detail(e)
mongo_logger.error('push notification was failed to send',
extra={'err': str(e)})
return False
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
user_id = self.get_argument('user_id', '')
booking_id = self.get_argument('booking_id', '')
coupon_id = self.get_argument('coupon_id', '')
mongo_logger = get_mongo_logger()
now = dt.datetime.now()
try:
session = Session()
count = session.query(UserCoupon) \
.filter(UserCoupon.booking_id == booking_id) \
.count()
if count > 0:
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, '이미 쿠폰이 적용된 예약 입니다.')
return
row = session.query(UserCoupon) \
.filter(UserCoupon.user_id == user_id) \
.filter(UserCoupon.id == coupon_id) \
.one()
if row.expire_date <= now:
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, '사용 기한이 만료된 쿠폰 입니다.')
return
if row.used != 0:
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, '이미 사용한 쿠폰 입니다.')
return
ret['response'] = row.discount_price
self.set_status(Response.RESULT_OK)
mongo_logger.debug('apply user coupon', extra = {'user_id' : user_id, 'booking_id' : booking_id })
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 apply user coupon', extra = {'user_id' : user_id, 'booking_id' : booking_id, 'err' : str(e)})
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
booking_id = self.get_argument('booking_id', '')
uid = self.get_argument('uid', '')
date = self.get_argument('date', dt.datetime.strftime(dt.datetime.now(), '%Y%m%d'))
time = self.get_argument('time', '08:00')
master_ids = self.get_argument('master_ids', [])
apply_to_all_behind = self.get_argument('apply_to_all_behind', 0)
by_manager = self.get_argument('by_manager', 0)
# convert parameters
apply_to_all_behind = int(apply_to_all_behind)
selected_date_str = date
time_str = time
selected_date = dt.datetime.strptime(date, '%Y%m%d')
master_ids = master_ids.split(',')
by_manager = int(by_manager)
# logging part
mix = get_mixpanel()
mongo_logger = get_mongo_logger()
print 'update schedule'
print selected_date_str, time_str, apply_to_all_behind
print '*' * 100
try:
session = Session()
booking_info = {}
userdao = UserDAO()
masterdao = MasterDAO()
holder = IntermediateValueHolder()
try:
row = session.query(Booking).filter(Booking.id == booking_id).one()
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_no_record'])
return
except MultipleResultsFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_multiple_record'])
return
def 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', '')
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")
self.set_header('Access-Control-Allow-Origin', '*')
print "call change_circle_handler"
ret = {}
org_booking_id = self.get_argument('booking_id', '')
new_booking_date = self.get_argument(
'date', dt.datetime.strftime(dt.datetime.now(), '%Y%m%d'))
new_booking_time = self.get_argument('time', '08:00')
master_ids = self.get_argument('master_ids', [])
new_appointment_type = self.get_argument('appointment_type', '')
# convert parameters
selected_date_str = new_booking_date
time_str = new_booking_time
new_booking_date = dt.datetime.strptime(new_booking_date, '%Y%m%d')
master_ids = master_ids.split(',')
new_appointment_type = int(new_appointment_type)
# logging part
mix = get_mixpanel()
mongo_logger = get_mongo_logger()
print 'change circle'
print selected_date_str, time_str
print '*' * 100
try:
session = Session()
try:
row = session.query(Booking).filter(
Booking.id == org_booking_id).one()
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_no_record'])
return
except MultipleResultsFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_multiple_record'])
return
def post(self):
ret = {}
guid = self.get_argument('id', '')
address = self.get_argument('address', '')
index = self.get_argument('index', 0)
size = self.get_argument('size', 0)
kind = self.get_argument('kind', 1)
rooms = self.get_argument('rooms', 1)
baths = self.get_argument('baths', 1)
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
index = int(index)
print address, index
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
userdao = UserDAO()
try:
row = session.query(UserAddress) \
.filter(and_(UserAddress.user_id == guid,
UserAddress.user_addr_index == 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', '*')
cleaning_id = self.get_argument('cleaning_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 = {}
try:
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
userdao = UserDAO()
doc = self.db.find_one_and_update(
{'cleaning_id': cleaning_id}, {'$set': {
'payment': '선결제'
}},
return_document=ReturnDocument.AFTER)
if doc == None:
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_no_cleaning_id'])
return
print cno
try:
uid = doc['user_id']
except Exception, e:
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_no_user_id'])
return
try:
amount = int(doc['total_price'])
except Exception, e:
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_invalid_amount'])
return
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
user_id = self.get_argument('user_id', '')
email = self.get_argument('email', '')
name = self.get_argument('name', '')
phone = self.get_argument('phone', '')
devicetype = self.get_argument('devicetype', 'None')
gender = self.get_argument('gender', 0)
birthdate = self.get_argument('birthdate', '')
self.set_header("Content-Type", "application/json")
gender = int(gender)
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
userdao = UserDAO()
try:
row = session.query(User) \
.filter(User.id == user_id) \
.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 user, no record' %
user_id,
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 user, multiple record' %
user_id,
extra={'err': str(e)})
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', '')
additional_task = self.get_argument('additional_task', '')
# convert parameters
additional_task = int(additional_task)
# logging part
mix = get_mixpanel()
mongo_logger = get_mongo_logger()
print 'modify additional task'
print '*' * 100
try:
session = Session()
booking_info = {}
userdao = UserDAO()
masterdao = MasterDAO()
try:
row = session.query(Booking, UserAddress) \
.join(UserAddress, Booking.user_id == UserAddress.user_id) \
.filter(Booking.addr_idx == UserAddress.user_addr_index) \
.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', '*')
phone = self.get_argument('phone', '')
print 'phone', phone
mongo_logger = get_mongo_logger()
ret = {}
try:
session = Session()
userdao = UserDAO()
try:
result = session.query(User) \
.filter(func.aes_decrypt(func.from_base64(User.phone), \
func.substr(User.salt, 1, 16)) == phone, \
User.active == 1) \
.all()
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 get registerinfo' % phone,
extra={'err': str(e)})
return
usersinfo = []
for row in result:
userinfo = {}
userinfo['id'] = row.id
userinfo['name'] = userdao.get_user_name(row.id)
userinfo['phone'] = userdao.get_user_phone(row.id)
userinfo['email'] = row.email
usersinfo.append(userinfo)
mongo_logger.debug('user registered info')
ret['response'] = usersinfo
self.set_status(Response.RESULT_OK)
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 post(self):
ret = {}
user_id = self.get_argument('user_id', '')
index = self.get_argument('index', 0)
index = int(index)
print user_id, index
self.set_header("Content-Type", "application/json")
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
try:
default_index = session.query(UserDefaultAddress) \
.filter(UserDefaultAddress.user_id == user_id) \
.one()
# 기본 주소이면 삭제 안되도록 함
if default_index.address_idx == index:
print 'default index'
session.close()
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, '기본 주소는 삭제 하실 수 없습니다.')
return
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_no_record'])
print_err_detail(e)
return
except MultipleResultsFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_multiple_record'])
print_err_detail(e)
return
def get(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
master_id = self.get_argument('master_id', '')
ret = {}
panalties = []
mongo_logger = get_mongo_logger()
try:
session = Session()
result = session.query(MasterPenalty) \
.filter(MasterPenalty.master_id == master_id) \
.order_by(desc(MasterPenalty.penalty_date)) \
.all()
for row in result:
panalties.append({
'master_id':
master_id,
'category_idx':
row.category_idx,
'penalty_idx':
row.penalty_idx,
'penalty':
row.penalty,
'datetime':
convert_datetime_format2(row.penalty_date)
})
mongo_logger.debug('get penalty', extra={'master_id': master_id})
ret['response'] = panalties
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('get penalty error',
extra={'master_id': master_id})
