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 []