def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
master_id = self.get_argument('master_id', '')
remove_status = self.get_argument('remove_status', 2)
print master_id, remove_status
# 0 - remove completely, 2 - cannot get works, but still showed up in list
remove_status = int(remove_status)
if remove_status != 0 and remove_status != 2:
remove_status = 2
ret = {}
try:
session = Session()
row = session.query(Master).filter(Master.id == master_id).one()
row.active = remove_status # about to remove, removig but not all work are reassigned to another homemaster yet
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 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 post(self):
self.set_header("Content-Type", "application/json")
ret = {}
master_id = self.get_argument('master_id', '')
pwd = self.get_argument('pw', '')
try:
session = Session()
try:
row = session.query(Master).filter(Master.id == master_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', '*')
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")
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('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', '*')
user_id = self.get_argument('user_id', '')
ret = {}
try:
session = Session()
result = session.query(RejectRelation, Master) \
.join(Master, RejectRelation.master_id == Master.id) \
.filter(RejectRelation.user_id == user_id) \
.group_by(RejectRelation.master_id) \
.order_by(Master.name) \
.all()
master_names = []
for row in result:
master_names.append(row.Master.name)
ret['response'] = master_names
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):
ret = {}
try:
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
size = self.get_argument('size', '')
_type = self.get_argument('type', '')
size = int(size)
_type = int(_type)
time_price_list = get_basic_time_price(_type, size)
window_price, window_time = get_window_time_price(_type, size)
ret['response'] = {
'basic': time_price_list,
'window_price': window_price,
'window_time': window_time
}
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")
manager_id = self.get_argument('manager_id', '')
name = self.get_argument('name', '')
phone = self.get_argument('phone', '')
ret = {}
try:
session = Session()
row = session.query(Manager).filter(
Manager.id == manager_id).scalar()
if row == None: # no entry
session.close()
add_err_message_to_response(ret,
err_dict['err_no_entry_to_cancel'])
self.write(json.dumps(ret))
return
row.name = name
row.phone = phone
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', '*')
user_id = self.get_argument('user_id', '')
ret = {}
try:
session = Session()
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_salt_no_match'])
return
except NoResultFound, 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()
unmatched = []
result = session.query(Booking).filter(
Booking.master_id == None).order_by(Booking.id,
Booking.start_time).all()
for row in result:
unmatched.append(row.id)
ret['response'] = unmatched
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 get(self):
self.set_header("Content-Type", "application/json")
ret = {}
try:
session = Session()
descriptions = []
result = session.query(MasterPointDescription) \
.filter(MasterPointDescription.index >= 10) \
.all()
for row in result:
descriptions.append({'index' : row.index, 'description' : row.description})
ret['response'] = descriptions
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")
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', '*')
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 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")
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 post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
booking_id = self.get_argument('booking_id', '')
cleaning_status = self.get_argument('cleaning_status', '')
change_all = self.get_argument('change_all', 'false')
change_all = False if (change_all.strip() == 'false') else True
try:
session = Session()
payment_status = int(cleaning_status)
bookingrow = session.query(Booking)\
.filter(Booking.id == booking_id)\
.first()
org_start = bookingrow.start_time
bookingrow.cleaning_status = payment_status
if change_all:
booking_data = session.query(Booking)\
.filter((Booking.request_id == bookingrow.request_id)
&(Booking.start_time > org_start))\
.update({'cleaning_status':cleaning_status})
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', '*')
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 post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
account_no = self.get_argument('account_no', '')
bank_name = self.get_argument('bank_name', '')
account_no = account_no.replace('-', '')
bank_dict = BC.bank_dict
bank_code = bank_dict[bank_name]
try:
status, message = salary_helper.check_account(
account_no, bank_code)
ret['response'] = {'status': status, 'message': message}
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', '')
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")
memo_id = self.get_argument('memo_id', 0)
response = self.get_argument('response', '')
memo_id = int(memo_id)
ret = {}
try:
session = Session()
try:
row = session.query(UserMemo).filter(
UserMemo.id == memo_id).one()
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_login_no_match'])
return
except MultipleResultsFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_multiple_record'])
return
def post(self):
self.set_header("Content-Type", "application/json")
ret = {}
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 post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
booking_id = self.get_argument('booking_id', '')
end_time = self.get_argument('end_time', '')
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")
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 get(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
master_id = self.get_argument('master_id', '')
month = self.get_argument('month', 0)
print master_id, month
month = int(month)
if month == 0:
month = dt.datetime.now().month
ret = {}
try:
session = Session()
row = session.query(func.count(MasterBookingModifyRequest)) \
.filter(MasterBookingModifyRequest.master_id == master_id) \
.filter(func.month(MasterBookingModifyRequest.request_time) == month ) \
.one()
count = row[0]
ret['response'] = count
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', '*')
booking_id = self.get_argument('booking_id', '')
price = self.get_argument('price', '')
# price int
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
def get(self):
self.set_header("Content-Type", "application/json")
ret = {}
try:
mix = Mixpanel(MX_KEY, MX_SECRET)
params = {}
params[
'selector'] = 'properties["$predict_grade"]=="A"orproperties["$predict_grade"]=="B"'
prediction_group = mix.request(['engage'], params)
users = []
for item in prediction_group['results']:
print item['$properties']['$name'], item['$properties'][
'$phone']
user_info = {}
user_info['name'] = item['$properties']['$name']
user_info['phone'] = item['$properties']['$phone']
users.append(user_info)
ret['response'] = users
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', '*')
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, **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'])
