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 = {}
try:
addresses = []
session = Session()
userdao = UserDAO()
addresses = userdao.get_all_user_addresses(user_id)
name = userdao.get_user_name(user_id)
default_index = userdao.get_user_default_address_index(user_id)
ret['response'] = {
'name': name,
'addresses': addresses,
'user_id': user_id,
'default_index': default_index
}
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 notify_10mins_ahead(self):
try:
userdao = UserDAO()
current_time = dt.datetime.now()
print '-' * 40
print 'push before 10 minutes'
print 'current_time :', current_time
hour = current_time.hour
if current_time.minute >= 20 and current_time.minute <= 29:
minute = 30
elif current_time.minute >= 50 and current_time.minute <= 59:
hour += 1
minute = 0
else:
minute = 0
cron_time = current_time.replace(hour=hour,
minute=minute,
second=0,
microsecond=0)
print 'cron_time :', cron_time
print '-' * 40
session = Session()
result = session.query(Booking, Master, User, UserPushKey) \
.join(Master, Booking.master_id == Master.id) \
.join(User, Booking.user_id == User.id) \
.outerjoin(UserPushKey, User.id == UserPushKey.user_id) \
.filter(or_(Booking.cleaning_status == BC.BOOKING_UPCOMMING, Booking.cleaning_status == BC.BOOKING_STARTED)) \
.filter(func.date(Booking.start_time) == cron_time.date()) \
.filter(func.HOUR(Booking.start_time) == cron_time.time().hour) \
.filter(func.MINUTE(Booking.start_time) == cron_time.time().minute) \
.all()
for row in result:
key = userdao.get_user_salt_by_id(row.User.id)[:16]
crypto = aes.MyCrypto(key)
booking_id = row.Booking.id
pushkey = row.UserPushKey.pushkey if row.UserPushKey != None else ''
user_name = crypto.decodeAES(row.User.name)
phone = crypto.decodeAES(row.User.phone)
master_name = row.Master.name
devicetype = row.User.devicetype
print 'push to', user_name, master_name, booking_id
print pushkey
if devicetype != 'android':
pushkey = crypto.decodeAES(row.User.phone)
send_10mins_ahead_notification(devicetype, [pushkey],
booking_id)
send_alimtalk(phone, 'noti_10', user_name, master_name)
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 = {}
user_id = self.get_argument('user_id', '')
new_pwd = self.get_argument('new_pwd', 'hm123')
try:
userdao = UserDAO()
session = Session()
user_row = session.query(User).filter(User.id == user_id).one()
salt = userdao.get_user_salt_by_id(user_id)
hash_obj = hashlib.sha256(salt + new_pwd)
user_row.password = hash_obj.hexdigest()
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 get(self):
ret = {}
user_id = self.get_argument('user_id', '')
address_index = self.get_argument('address_index', '')
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
try:
userdao = UserDAO()
address, size, kind, rooms, baths = userdao.get_user_address_full_detail_by_index(user_id, address_index)
address_info = {}
address_info['rooms'] = rooms
address_info['size'] = size
address_info['kind'] = kind
address_info['baths'] = baths
address_info['address'] = address
ret['response'] = address_info
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)
def get(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
user_id = self.get_argument('user_id', '')
havepet = self.get_argument('havepet', '')
master_gender = self.get_argument('master_gender', '')
havepet = int(havepet)
master_gender = int(master_gender)
ret = {}
try:
session = Session()
userdao = UserDAO()
addressdao = AddressDAO()
masters = []
row = session.query(UserDefaultAddress) \
.filter(UserDefaultAddress.user_id == user_id) \
.one()
address, _, _ = userdao.get_user_address_by_index(
user_id, row.address_idx)
gu_id = addressdao.get_gu_id(address)
pet_filter = 2
if havepet == 1:
pet_filter = 1
gender_filter = 2
if master_gender == 1:
gender_filter = 0
result = session.query(Master, MasterPreferedArea) \
.join(MasterPreferedArea, Master.id == MasterPreferedArea.master_id) \
.filter(Master.active == 1) \
.filter(Master.pet_alergy != pet_filter) \
.filter(Master.gender != gender_filter) \
.filter(MasterPreferedArea.prefered_gu == gu_id) \
.order_by(Master.name) \
.all()
for row in result:
masters.append({'id': row.Master.id, 'name': row.Master.name})
ret['response'] = masters
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 notify(self):
try:
userdao = UserDAO()
current_time = dt.datetime.now()
print '-' * 40
print 'push before 2 hours'
print 'current_time :', current_time
hour = current_time.hour
minute = 30 if current_time.minute >= 30 else 0
#current_time = current_time + dt.timedelta(hours=2)
cron_time = current_time.replace(hour=hour+2, minute=minute, second = 0, microsecond=0)
print 'cron_time :', cron_time
print '-' * 40
session = Session()
result = session.query(Booking, Master, MasterPushKey, User) \
.join(Master, Booking.master_id == Master.id) \
.join(MasterPushKey, Master.id == MasterPushKey.master_id) \
.join(User, Booking.user_id == User.id) \
.filter(Booking.cleaning_status == BC.BOOKING_UPCOMMING) \
.filter(func.date(Booking.start_time) == cron_time.date()) \
.filter(func.HOUR(Booking.start_time) == cron_time.time().hour) \
.filter(func.MINUTE(Booking.start_time) == cron_time.time().minute) \
.all()
for row in result:
key = userdao.get_user_salt_by_id(row.User.id)[:16]
crypto = aes.MyCrypto(key)
if row.Master.id == 'da2a1f50-fd36-40bf-8460-55b3e1b2c459':
continue
booking_id = row.Booking.id
pushkey = row.MasterPushKey.pushkey if row.MasterPushKey != None else ''
master_name = row.Master.name
start_time = row.Booking.start_time
time_str = convert_datetime_format4(start_time)
print 'push to', master_name, booking_id
print pushkey
send_master_ahead_notification('android', [pushkey], booking_id, master_name, time_str)
except Exception, e:
print_err_detail(e)
def get(self):
self.set_header("Content-Type", "application/json")
ret = {}
try:
session = Session()
ratings = []
userdao = UserDAO()
result = session.query(Rating, Booking, User, Master) \
.join(Booking, Rating.booking_id == Booking.id) \
.join(Master, Rating.master_id == Master.id) \
.join(User, Booking.user_id == User.id) \
.order_by(desc(Rating.review_time)) \
.all()
for row in result:
key = userdao.get_user_salt(row.User.email)[:16]
crypto = aes.MyCrypto(key)
rating = {}
rating['user_name'] = crypto.decodeAES(row.User.name)
rating['master_name'] = row.Master.name
rating['appointment_type'] = row.Booking.appointment_type
rating['start_time'] = dt.datetime.strftime(
row.Booking.start_time, '%Y-%m-%d %H:%M')
rating['estimated_end_time'] = dt.datetime.strftime(
row.Booking.estimated_end_time, '%Y-%m-%d %H:%M')
rating['end_time'] = dt.datetime.strftime(
row.Booking.end_time, '%Y-%m-%d %H:%M')
rating['clean_rating'] = float(row.Rating.rate_clean)
rating['clean_review'] = row.Rating.review_clean
rating['master_rating'] = float(row.Rating.rate_master)
rating['master_review'] = row.Rating.review_master
rating['review_time'] = dt.datetime.strftime(
row.Rating.review_time, '%Y-%m-%d %H:%M')
ratings.append(rating)
ret['response'] = ratings
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 get(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
print "test-intro"
try:
session = Session()
result = session.query(UserClaim, Booking, User, Master) \
.join(Booking, UserClaim.booking_id == Booking.id) \
.join(Master, Master.id == Booking.master_id) \
.join(User, User.id == Booking.user_id) \
.all()
claims = []
Userdao = UserDAO()
print result
for record in result:
key = Userdao.get_user_salt(record.User.email)[:16]
if key == None or key == '':
continue
crypto = aes.MyCrypto(key)
claim_info = {}
claim_info['cleanning_date'] = dt.datetime.strftime(
record.Booking.start_time, '%Y-%m-%d %H:%M')
claim_info['user_name'] = crypto.decodeAES(record.User.name)
claim_info['user_phone'] = crypto.decodeAES(record.User.phone)
claim_info['master_name'] = record.Master.name
claim_info['claim_comment'] = record.UserClaim.comment
claim_info['claim_reg_time'] = dt.datetime.strftime(
record.UserClaim.register_time, '%Y-%m-%d %H:%M')
claims.append(claim_info)
ret['response'] = claims
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 get(self):
self.set_header("Content-Type", "application/json")
ret = {}
master_id = self.get_argument('master_id', '')
try:
session = Session()
userdao = UserDAO()
result = session.query(Master, Booking, User) \
.join(Booking, Master.id == Booking.master_id) \
.join(User, Booking.user_id == User.id) \
.filter(Booking.master_id == master_id) \
.filter(or_(Booking.cleaning_status == BC.BOOKING_UPCOMMING, Booking.cleaning_status == BC.BOOKING_STARTED, Booking.cleaning_status == BC.BOOKING_COMPLETED)) \
.order_by(desc(Booking.start_time)) \
.all()
booking_list = []
for row in result:
key = userdao.get_user_salt_by_id(row.Booking.user_id)[:16]
crypto = aes.MyCrypto(key)
booking = {}
booking['booking_id'] = row.Booking.id
booking['name'] = crypto.decodeAES(row.User.name)
booking['start_time'] = convert_datetime_format2(
row.Booking.start_time)
booking['additional_task'] = row.Booking.additional_task
booking['price'] = row.Booking.price_with_task
booking['status'] = row.Booking.status
booking['cleaning_status'] = row.Booking.cleaning_status
booking['payment_status'] = row.Booking.payment_status
booking_list.append(booking)
ret['response'] = booking_list
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 get(self):
self.set_header("Content-Type", "application/json")
ret = {}
try:
session = Session()
userdao = UserDAO()
bookingdao = BookingDAO()
# get last saturday
now = dt.datetime.now()
if week != 0:
offset = ((now.weekday() - FRIDAY) % 7) + (week - 1) * 7
now -= dt.timedelta(days=offset)
offset = (now.weekday() - SATURDAY) % 7
last_saturday = (now - dt.timedelta(days=offset)).date()
now = now.date()
# rating
#
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")
booking_id = self.get_argument('booking_id', '')
ret = {}
try:
session = Session()
userdao = UserDAO()
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")
manager_id = self.get_argument('manager_id', '')
ret = {}
try:
session = Session()
userdao = UserDAO()
payment_records = []
result = session.query(UserPaymentRecord, User) \
.join(User, UserPaymentRecord.user_id == User.id) \
.order_by(UserPaymentRecord.user_id, desc(UserPaymentRecord.auth_date)) \
.all()
for row in result:
payment = {}
key = userdao.get_user_salt_by_id(row.User.id)[:16]
crypto = aes.MyCrypto(key)
payment['tid'] = row.UserPaymentRecord.tid
payment['booking_id'] = row.UserPaymentRecord.booking_id
payment['user_id'] = row.UserPaymentRecord.user_id
payment['price'] = row.UserPaymentRecord.price
payment['auth_date'] = row.UserPaymentRecord.auth_date
payment[
'canceled_amount'] = row.UserPaymentRecord.canceled_amount
payment['canceled_date'] = row.UserPaymentRecord.canceled_date
payment['status'] = row.UserPaymentRecord.status
payment['user_name'] = crypto.decodeAES(row.User.name)
payment['user_phone'] = crypto.decodeAES(row.User.phone)
payment_records.append(payment)
ret['response'] = payment_records
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', '*')
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 get(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
user_id = self.get_argument('user_id', '')
ret = {}
try:
session = Session()
userdao = UserDAO()
payment_histories = []
result = session.query(UserChargeRecord, User) \
.join(User, UserChargeRecord.user_id == User.id) \
.filter(UserChargeRecord.user_id == user_id) \
.order_by(desc(UserChargeRecord.auth_date)) \
.all()
for row in result:
try:
auth_date = '20' + row.UserChargeRecord.auth_date
auth_date = dt.datetime.strptime(auth_date, '%Y%m%d%H%M%S')
except Exception, e:
auth_date = None
payment_info = {}
payment_info['tid'] = row.UserChargeRecord.tid
payment_info['amount'] = row.UserChargeRecord.amount
payment_info['auth_date'] = convert_datetime_format2(
auth_date) if auth_date != None else ''
payment_histories.append(payment_info)
user_name = userdao.get_user_name(user_id)
user_phone = userdao.get_user_phone(user_id)
ret['response'] = {
'user_id': user_id,
'name': user_name,
'phone': user_phone,
'payment_histories': payment_histories
}
self.set_status(Response.RESULT_OK)
def get(self):
self.set_header("Content-Type", "application/json")
ret = {}
try:
session = Session()
users = []
userdao = UserDAO()
for row in session.query(User, UserAddress) \
.outerjoin(UserDefaultAddress, UserDefaultAddress.user_id == User.id) \
.outerjoin(UserAddress, and_(UserDefaultAddress.user_id == UserAddress.user_id, UserDefaultAddress.address_idx == UserAddress.user_addr_index)) \
.order_by(desc(User.dateofreg)) \
.all():
key = userdao.get_user_salt(row.User.email)[:16]
crypto = aes.MyCrypto(key)
user_info = {}
user_info['user_id'] = row.User.id
user_info['dateofreg'] = dt.datetime.strftime(row.User.dateofreg, '%Y-%m-%d %H:%M')
user_info['devicetype'] = row.User.devicetype
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['birthdate'] = crypto.decodeAES(row.User.dateofbirth)
user_info['default_address'] = crypto.decodeAES(row.UserAddress.address) if row.UserAddress != None else ''
user_info['default_address_size'] = row.UserAddress.size if row.UserAddress != None else ''
user_info['default_address_kind'] = row.UserAddress.kind if row.UserAddress != None else ''
users.append(user_info)
ret['response'] = users
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'])
class ManualChargeHandler(tornado.web.RequestHandler):
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
booking_id = self.get_argument('booking_id', '')
price = self.get_argument('price', '')
product_name = self.get_argument('product_name', '')
price = int(price)
ret = {}
try:
session = Session()
try:
row = session.query(Booking, User) \
.join(User, Booking.user_id == User.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_login_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
userdao = UserDAO()
user_id = row.User.id
key = userdao.get_user_salt_by_id(user_id)[:16]
crypto = aes.MyCrypto(key)
user_name = crypto.decodeAES(row.User.name)
appointment_type = row.Booking.appointment_type
if row.User.devicetype == 'None':
try:
record = UserPaymentRecordForIOS(booking_id, user_id,
price, dt.datetime.now())
session.add(record)
session.commit()
ret_code = True
except Exception, e:
ret_code = False
value = 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 = {}
uid = self.get_argument('user_id', '')
master_gender = self.get_argument('master_gender', 1)
mongo_logger = get_mongo_logger()
master_gender = int(master_gender)
if master_gender == 2: # 남자일 경우 남자코드인 0으로 변경
master_gender = 0
try:
session = Session()
userdao = UserDAO()
addressdao = AddressDAO()
address = userdao.get_user_address(uid)[0]
gu_id = addressdao.get_gu_id(address)
master_count_by_gender = session.query(MasterPreferedArea, Master) \
.join(Master, MasterPreferedArea.master_id == Master.id) \
.filter(MasterPreferedArea.prefered_gu == gu_id) \
.filter(Master.gender == master_gender) \
.filter(Master.active == 1) \
.count()
ret['response'] = {'master_count_by_gender' : master_count_by_gender}
self.set_status(Response.RESULT_OK)
print uid, 'request master gender, value of ', master_gender, master_count_by_gender
mongo_logger.debug('%s request master gender count' % uid, extra={'user_id' : uid, 'master_gender' : master_gender})
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 login(self, name, phone):
session = Session()
userdao = UserDAO()
result = session.query(User) \
.filter(User.email == name + phone + '@11st.co.kr') \
.filter(User.authsource == '11st') \
.all()
for row in result:
key = userdao.get_user_salt_by_id(row.id)[:16]
crypto = aes.MyCrypto(key)
decrypted_name = crypto.decodeAES(row.name)
decrypted_phone = crypto.decodeAES(row.phone)
if name == decrypted_name and phone == decrypted_phone: # 동명이인 고려, 일치하게 된다면 id 반환
return row.id, True
return '', False
def get(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
try:
session = Session()
result = session.query(Booking, User) \
.join(User, and_(Booking.user_id == User.id, and_(or_(Booking.cleaning_status == 1, Booking.cleaning_status == 2), or_(Booking.payment_status == 0, Booking.payment_status == -3)))) \
.filter(not_(User.email.like('*****@*****.**'))) \
.all()
unpaid_datas = []
Userdao = UserDAO()
for record in result:
key = Userdao.get_user_salt(record.User.email)[:16]
if key == None or key == '':
continue
crypto = aes.MyCrypto(key)
unpaid_info = {}
unpaid_info['booking_id'] = record.Booking.id
unpaid_info[
'appointment_type'] = record.Booking.appointment_type
unpaid_info['cleanning_date'] = dt.datetime.strftime(
record.Booking.start_time, '%Y-%m-%d %H:%M')
unpaid_info['user_name'] = crypto.decodeAES(record.User.name)
unpaid_info['user_phone'] = crypto.decodeAES(record.User.phone)
unpaid_info['price_with_task'] = record.Booking.price_with_task
unpaid_datas.append(unpaid_info)
ret['response'] = unpaid_datas
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")
uid = self.get_argument('uid', '')
price = self.get_argument('price', '')
ret = {}
try:
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
userdao = UserDAO()
request_url = '%s:%d/homemaster_payment/request_payment' % (PAYMENT_HOST, PAYMENT_PORT)
params = {}
params['id'] = uid
params['name'] = userdao.get_user_name(uid)
params['price'] = price
params['product_name'] = 'moving'
response = requests.post(request_url, data = params)
result = json.loads(response.text)
if response.status_code == 200 and result['response'] == "SUCCESS":
mix.track(uid, 'request mc payment', {'time' : dt.datetime.now(), 'tid' : result['tid'], 'authdate' : result['authdate']})
mongo_logger.debug('%s request mc payment' % uid, extra = {'user_id' : uid, 'tid' : result['tid'], 'authdate' : result['authdate']})
ret['response'] = result['response']
self.set_status(Response.RESULT_OK)
else:
print 'An error occurred when paying moving clean'
print result['err_code'], result['err_msg']
add_err_ko_message_to_response(ret, result['err_msg'])
mix.track(uid, 'cannot request mc payment', {'time' : dt.datetime.now(), 'code' : result['err_code']})
mongo_logger.error('%s failed to request mc payment' % uid, extra = {'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")
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 post(self):
ret = {}
guid = self.get_argument('id', '')
address = self.get_argument('address', '')
size = self.get_argument('size', 0)
kind = self.get_argument('kind', 1)
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()
default_addr_index = userdao.get_user_default_address_index(guid)
try:
row = session.query(UserAddress) \
.filter(and_(UserAddress.user_id == guid, UserAddress.user_addr_index == default_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 is_user_block(self, ret, uid):
try:
mongo_logger = get_mongo_logger()
userdao = UserDAO()
session = Session()
result = session.query(User) \
.filter(User.id == uid) \
.one()
key = userdao.get_user_salt_by_id(result.id)[:16]
crypto = aes.MyCrypto(key)
phone = crypto.decodeAES(result.phone)
row = session.query(BlockUser, User) \
.join(User, User.id == BlockUser.user_id) \
.filter(func.aes_decrypt(func.from_base64(User.phone), func.substring(User.salt, 1, 16)) == phone) \
.all()
print row
session.close()
if len(row) > 0:
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(
ret,
'현재 주문량이 많아 신규 예약이 불가능 합니다. 확실한 서비스 품질을 보증을 위해 바로 서비스를 제공해 드릴 수 없는 점 양해 부탁드립니다.'
)
mongo_logger.debug('block user', extra={'user_id': uid})
ret['err_code'] = '4037' # 임시 처리
return True
return False
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'])
return True
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 get(self):
self.set_header("Content-Type", "application/json")
ret = {}
try:
session = Session()
userdao = UserDAO()
none_ios_users = []
for row in session.query(User, Booking) \
.join(Booking, User.id == Booking.user_id) \
.filter(Booking.cleaning_status == 0) \
.filter(User.devicetype == 'None') \
.group_by(User.id) \
.all():
user_dict = {}
user_id = row.User.id
key = userdao.get_user_salt_by_id(user_id)[:16]
crypto = aes.MyCrypto(key)
user_dict['name'] = crypto.decodeAES(row.User.name)
user_dict['email'] = row.User.email
user_dict['phone'] = crypto.decodeAES(row.User.phone)
user_dict['gender'] = row.User.gender
none_ios_users.append(user_dict)
print len(none_ios_users)
ret['response'] = none_ios_users
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 get(self):
self.set_header("Content-Type", "application/json")
ret = {}
try:
userdao = UserDAO()
session = Session()
result = session.query(MasterClaim, Master, User) \
.join(Master, MasterClaim.master_id == Master.id) \
.join(User, MasterClaim.user_id == User.id) \
.order_by(desc(MasterClaim.register_time)) \
.all()
claims = []
for row in result:
key = userdao.get_user_salt_by_id(row.User.id)[:16]
crypto = aes.MyCrypto(key)
claim = {}
claim['user_name'] = crypto.decodeAES(row.User.name)
claim['user_phone'] = crypto.decodeAES(row.User.phone)
claim['master_name'] = row.Master.name
claim['text'] = row.MasterClaim.claim_text
claim['datetime'] = convert_datetime_format2(
row.MasterClaim.register_time)
claims.append(claim)
ret['response'] = claims
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 notify(self):
try:
userdao = UserDAO()
current_date = dt.datetime.now().date()
print current_date
session = Session()
result = session.query(Booking, User, UserPushKey) \
.join(User, Booking.user_id == User.id) \
.join(UserPushKey, User.id == UserPushKey.user_id) \
.filter(func.date(Booking.start_time) == current_date) \
.filter(Booking.cleaning_status == BC.BOOKING_COMPLETED) \
.all()
for row in result:
key = userdao.get_user_salt_by_id(row.User.id)[:16]
crypto = aes.MyCrypto(key)
booking_id = row.Booking.id
user_name = crypto.decodeAES(row.User.name)
pushkey = row.UserPushKey.pushkey
devicetype = row.User.devicetype
if row.Booking.havereview == 0: # review 하지 않은 사용자에게만 보냄
print 'rating push to ', user_name, booking_id
if devicetype != 'android':
pushkey = crypto.decodeAES(row.User.phone)
send_rating_notification(devicetype, [pushkey], booking_id, user_name)
print 'notified to users for rating successfully...', dt.datetime.now()
except Exception, e:
print_err_detail(e)
def get(self):
self.set_header("Content-Type", "application/json")
ret = {}
try:
session = Session()
userdao = UserDAO()
users = []
for row in session.query(User, UserAddress, UserDefaultAddress, Booking) \
.outerjoin(UserAddress, User.id == UserAddress.user_id) \
.outerjoin(UserDefaultAddress, User.id == UserDefaultAddress.user_id) \
.outerjoin(Booking, and_(User.id == Booking.user_id)) \
.all():
if row.UserAddress != None and row.Booking == None:
user_id = row.User.id
key = userdao.get_user_salt_by_id(user_id)[:16]
crypto = aes.MyCrypto(key)
user_info = {}
user_info['name'] = crypto.decodeAES(row.User.name)
user_info['phone'] = crypto.decodeAES(row.User.phone)
users.append(user_info)
ret['response'] = users
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 get(self):
self.set_header("Content-Type", "application/json")
ret = {}
try:
session = Session()
userdao = UserDAO()
memos = []
result = session.query(UserMemo, User) \
.join(User, UserMemo.user_id == User.id) \
.order_by(desc(UserMemo.requested_datetime)) \
.all()
for row in result:
key = userdao.get_user_salt_by_id(row.User.id)[:16]
crypto = aes.MyCrypto(key)
memo = {}
memo['time'] = dt.datetime.strftime(
row.UserMemo.requested_datetime, '%Y-%m-%d %H:%M')
memo['memo'] = row.UserMemo.memo
memo['user_name'] = crypto.decodeAES(row.User.name)
memos.append(memo)
ret['response'] = memos
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'])
