def remove_parentheses(address):
try:
p = re.compile(r'\([^)]*\)')
return re.sub(p, '', address)
except Exception, e:
print_err_detail(e)
return address
def get(self):
self.set_header("Content-Type", "application/json")
manager_id = self.get_argument('manager_id', '')
ret = {}
try:
session = Session()
manager_info = {}
row = session.query(Manager).filter(
Manager.id == manager_id).scalar()
if row == None:
session.close()
add_err_message_to_response(ret,
err_dict['err_no_entry_to_cancel'])
self.write(json.dumps(ret))
return
manager_info['id'] = row.id
manager_info['name'] = row.name
manager_info['phone'] = row.phone
ret['response'] = manager_info
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', '')
routing_method = self.get_argument('routing_method', '')
ret = {}
try:
session = Session()
stmt = session.query(Booking.request_id).filter(Booking.id == booking_id).subquery()
result = session.query(Booking).filter(Booking.request_id == stmt) \
.order_by(Booking.start_time) \
.all()
for row in result:
row.routing_method = routing_method
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):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
area_code = self.get_argument('area_code', '')
ret = {}
if area_code == '':
self.set_status(Response.RESULT_BADREQUEST)
add_err_message_to_response(ret, u'Invalid parameter(' ')')
self.write(json.dumps(ret))
return
if area_code == 'state':
try:
cursor = self.db.find({'level': 'state'})
except Exception, e:
print_err_detail(e)
self.set_status(Response.RESULT_SERVERERROR)
add_err_message_to_response(ret, err_dict['err_mongodb'])
self.write(json.dumps(ret))
return
states = []
for state in cursor:
states.append({'name': state['name'], 'code': state['code']})
ret['requested_code'] = area_code
ret['requested_name'] = ''
ret['response'] = states
def timedelta_to_time(td):
try:
if td == None: return None
return (datetime.min + td).time()
except Exception, e:
print_err_detail(e)
return time(0, 0)
def send_jandi(channel_name, body, title, description, color='#FAC11B'):
try:
print JANDI_ON
if not JANDI_ON:
return
if channel_name in jandi_urls:
jandi_url = jandi_urls[channel_name]
else:
jandi_url = 'https://wh.jandi.com/connect-api/webhook/11415021/de317f9b090e8423b96c8054a4529714'
headers = {
'Accept': 'application/vnd.tosslab.jandi-v2+json',
'Content-Type': 'application/json'
}
data = {
"body": body,
"connectColor": color,
"connectInfo": [{
"title": title,
"description": description
}]
}
response = requests.post(jandi_url,
data=json.dumps(data),
headers=headers)
except Exception, e:
print_err_detail(e)
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
article_id = self.get_argument('id', '')
title = self.get_argument('title', '')
content = self.get_argument('content', '')
ret = {}
try:
session = Session()
row = session.query(MasterNotice).filter(
MasterNotice.id == article_id).one()
row.title = title
row.content = content
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', '*')
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 notify_24hours_ahead(self):
try:
print 'master notifier started...'
current_date = dt.datetime.now()
print current_date
tomorrow = current_date + dt.timedelta(days=1)
tomorrow = tomorrow.date()
print tomorrow
session = Session()
result = session.query(Booking.master_id, Master.phone, Master.name, func.count(Booking.master_id)) \
.join(Master, Booking.master_id == Master.id) \
.filter(func.date(Booking.start_time) == tomorrow) \
.group_by(Booking.master_id) \
.all()
for row in result:
master_phone = str(row[1])
master_name = str(row[2])
no_jobs = str(int(row[3]))
print master_phone, master_name, no_jobs
send_24hours_ahead_reminder(master_phone, master_name, no_jobs)
print 'notified to masters successfully...'
except Exception, e:
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', '')
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 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")
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_moving_time(geohash1, geohash2):
try:
if geohash1 == None or geohash2 == None: # 바로 나오는 경우, 들어가는 경우
return 0
if geohash1 == '' or geohash2 == '': # 모를 경우에는 1시간을 줌
return 60
geohash1_parent = geohash1[:5]
geohash2_parent = geohash2[:5]
expanded = geohash.expand(geohash1_parent)
expanded_depth2 = set()
for gh in expanded:
neighbors = geohash.neighbors(gh)
expanded_depth2 = expanded_depth2.union(neighbors)
expanded_depth2 = list(expanded_depth2)
if geohash1 == geohash2:
return 30
elif geohash2_parent in expanded:
return 60
elif geohash2_parent in expanded_depth2:
return 90
else:
return 120
except Exception, e:
print_err_detail(e)
return 60
def cancelall_coupon_usage(self, booking_id):
session = Session()
try:
booking_record = session.query(Booking).filter(
Booking.id == booking_id).one()
request_id = booking_record.request_id
records = session.query(Booking) \
.filter(Booking.request_id == request_id) \
.filter(Booking.cleaning_status == BC.BOOKING_UPCOMMING) \
.all()
for record in records:
bid = record.id
coupon_record = session.query(UserCoupon).filter(
UserCoupon.booking_id == bid).first()
if coupon_record:
coupon_record.used = 0
coupon_record.booking_id = None
coupon_record.service_price = 0
session.commit()
except Exception, e:
session.rollback()
print_err_detail(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', '')
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")
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 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 is_cancelled_all(self, booking_id):
canceled_all = True
try:
session = Session()
current_book_start_time = session.query(Booking) \
.filter(Booking.id == booking_id) \
.one() \
.start_time
stmt = session.query(Booking.request_id).filter(
Booking.id == booking_id).subquery()
booking_group = session.query(Booking) \
.filter(Booking.request_id == stmt) \
.filter(Booking.start_time > current_book_start_time) \
.order_by(Booking.start_time) \
.all()
for booking in booking_group:
if not booking.cleaning_status == BC.BOOKING_CANCELED:
canceled_all = False
break
except Exception, e:
print_err_detail(e)
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 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', '')
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', '*')
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 aes_encrypt(data, key):
try:
cipher = AES.new(key)
data = data + (u" " * (16 - (len(data) % 16)))
return binascii.hexlify(cipher.encrypt(data))
except Exception, e:
print_err_detail(e)
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 register(self, name, phone):
url = base_url + '/register'
authsource = '11st'
email = name + phone + '@11st.co.kr'
salt = self.create_salt()
password = self.create_password(salt) #123456
params = {
'name': name,
'email': email,
'salt': salt,
'password': password,
'phone': phone,
'authsource': authsource
}
try:
response = requests.post(url, data=params)
print response.text
result = json.loads(response.text)
except Exception, e:
print_err_detail(e)
self.logger.error('error register', extra={'err': str(e)})
return '', False
def get(self):
self.set_header("Content-Type", "application/json")
ret = {}
try:
session = Session()
managers = []
result = session.query(Manager).all()
for row in result:
manager_info = {}
manager_info['id'] = row.id
manager_info['name'] = row.name
manager_info['phone'] = row.phone
managers.append(manager_info)
ret['response'] = managers
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 = {}
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 get_moving_time_by_geos(origin, destinations, time = dt.datetime.now()):
try:
gmaps = googlemaps.Client(key = GOOGLE_API_KEY)
result = gmaps.distance_matrix(origin, destinations, language='ko', units='metric', mode='transit', departure_time=time)
print result
rows = result['rows']
if len(rows) == 0:
raise Exception('0 results')
if result['status'] != 'OK':
raise Exception('status not OK')
taking_times = []
for dest in rows[0]['elements']:
if dest['status'] == 'OK':
mins = int(math.ceil(dest['duration']['value'] / 60.0))
mins = int(mins / 30 + 1) * 30
else:
mins = 60
taking_times.append(mins)
return taking_times
except Exception, e:
print_err_detail(e)
return []
