def send_survey_link():
update_time = dt.datetime(2016, 9, 27)
session = Session()
result = session.query(User) \
.filter(func.length(func.aes_decrypt(func.from_base64(User.phone), func.substring(User.salt, 1, 16))) < 12) \
.filter(User.phone != 'out') \
.filter(User.active == 1) \
.filter(not_(User.email.op('regexp')(r'._$'))) \
.all()
sms_sender = Message_Sender()
for row in result:
key = row.salt[:16]
crypto = aes.MyCrypto(key)
name = crypto.decodeAES(row.name)
phone = crypto.decodeAES(row.phone)
print name, phone
text = '''(광고) 홈마스터 설문조사참여하고 신세계 상품권 받으세요^^
https://goo.gl/kYNti3
~12.31'''
print sms_sender.send(sender=MAIN_CALL,
mtype='lms',
to=str(phone),
text=str(text))
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 find(**kwargs):
address_key = current_app.config.get('ADDRESS_KEY')
engine = current_app.config.get('SQLALCHEMY_DATABASE_URI')
metadata = MetaData(bind=engine)
user_address_c = Table('user_address', metadata, autoload=True)
zipcode_ = func.aes_decrypt(func.from_base64(user_address_c.c.zipcode),
address_key).label('zipcode')
phone_ = func.aes_decrypt(func.from_base64(user_address_c.c.phone),
address_key).label('phone')
pref_ = func.aes_decrypt(func.from_base64(user_address_c.c.pref),
address_key).label('pref')
town_ = func.aes_decrypt(func.from_base64(user_address_c.c.town),
address_key).label('town')
address_ = func.aes_decrypt(func.from_base64(user_address_c.c.address),
address_key).label('address')
building_ = func.aes_decrypt(
func.from_base64(user_address_c.c.building),
address_key).label('building')
full_name_ = func.aes_decrypt(
func.from_base64(user_address_c.c.full_name),
address_key).label('full_name')
columns = [
user_address_c.c.id, user_address_c.c.user_id, zipcode_, phone_,
pref_, town_, address_, building_, full_name_,
user_address_c.c.is_delete
]
query = select().select_from(user_address_c)
if ('user_id' in kwargs):
query = query.where(user_address_c.c.user_id == kwargs['user_id'])
user_address_ = query.with_only_columns(columns)
results = db.session.execute(user_address_)
addresses = []
if results.rowcount > 0:
for result in results:
address = {}
address['zipcode'] = str(result.zipcode,
'utf-8') if result.zipcode else ''
address['phone'] = str(result.phone,
'utf-8') if result.phone else ''
address['pref'] = str(result.pref,
'utf-8') if result.pref else ''
address['town'] = str(result.town,
'utf-8') if result.town else ''
address['address'] = str(result.address,
'utf-8') if result.address else ''
address['building'] = str(result.building,
'utf-8') if result.building else ''
address['full_name'] = str(result.full_name,
'utf-8') if result.full_name else ''
address['id'] = result.id
address['user_id'] = result.user_id
address['is_delete'] = result.is_delete
addresses.append(address)
return addresses
def get(self):
self.set_header("Content-Type", "application/json")
email = self.get_argument('email', '')
ret = {}
if email == '':
self.set_status(Response.RESULT_BADREQUEST)
add_err_message_to_response(ret, err_dict['invalid_param'])
self.write(json.dumps(ret))
return
mongo_logger = get_mongo_logger()
try:
session = Session()
try:
row = session.query(User).filter(User.email == email).one()
except NoResultFound, e:
try:
if len(email) == 11 and email.startswith('010'):
row = session.query(User) \
.filter(func.aes_decrypt(func.from_base64(User.phone), \
func.substr(User.salt, 1, 16)) == email, \
User.active == 1) \
.one()
else:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(
ret, err_dict['err_salt_no_match'])
mongo_logger.error('failed to get salt',
extra={'err': str(e)})
return
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_salt_no_match'])
mongo_logger.error('failed to get salt',
extra={'err': str(e)})
return
except MultipleResultsFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret,
err_dict['err_dup_phone2'])
mongo_logger.error('failed to get salt',
extra={'err': str(e)})
return
def 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 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")
ret = {}
name = self.get_argument('name', '')
gender = self.get_argument('gender', 1)
authsource = self.get_argument('authsource', 'None')
devicetype = self.get_argument('devicetype', 'None')
email = self.get_argument('email', '')
password = self.get_argument('password', '')
salt = self.get_argument('salt', '')
phone = self.get_argument('phone', '')
birthdate = self.get_argument('birthdate', '')
registerdate = self.get_argument('regdate', '')
if gender == '':
gender = 1
gender = int(gender)
err_msg = ''
if name == '':
err_msg = 'name is invalid'
elif email == '':
err_msg = 'email is invalid'
elif password == '':
err_msg = 'password is invalid'
if err_msg != '': # invalid argument situation
ret['response'] = err_msg
self.set_status(Response.RESULT_BADREQUEST)
add_err_message_to_response(ret, err_dict['invalid_param'])
return
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
guid = str(uuid.uuid4())
registerdate_str = registerdate
#registerdate = dt.datetime.strptime(registerdate, '%Y-%m-%d').date()
registerdate = dt.datetime.now()
count = session.query(User).filter(User.email == email, User.active == 1).count()
if count > 0:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_dup_email'])
mongo_logger.debug('%s is already existed' % email, extra = {'err' : 'duplicate email'})
return
# phone duplicacy check
count = session.query(User) \
.filter(func.aes_decrypt(func.from_base64(User.phone), \
func.substr(User.salt, 1, 16)) == phone, \
User.active == 1) \
.count()
if count > 0:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_dup_phone'])
mongo_logger.debug('phone already existed', extra = {'err' : 'duplicate phone'})
return
key = salt[:16]
print key
crypto = aes.MyCrypto(key)
encrypted_name = crypto.encodeAES(str(name))
encrypted_phone = crypto.encodeAES(str(phone))
encrypted_birthdate = crypto.encodeAES(str(birthdate))
print encrypted_name, name
print encrypted_phone, phone
print encrypted_birthdate, birthdate
new_user = User(id = guid, name = encrypted_name, gender = gender, authsource = authsource,
devicetype = devicetype, email = email, password = password, salt = salt,
phone = encrypted_phone, dateofbirth = encrypted_birthdate,
dateofreg = registerdate, dateoflastlogin= registerdate)
session.add(new_user)
session.commit()
now = dt.datetime.now()
expire_date = dt.datetime(2016, 12, 31, 23, 59)
if now <= expire_date:
user_id = guid
discount_price = 10000
title = '크리스마스는 깨끗한 집에서!'
description = '1만원 할인쿠폰'
hashids = Hashids(min_length = 8, salt = user_id)
coupon_id = hashids.encode(int(dt.datetime.strftime(now, '%Y%m%d%H%M%S')))
user_coupon = UserCoupon(id = coupon_id, user_id = user_id, discount_price = discount_price,
expire_date = expire_date, title = title, description = description,
issue_date = now)
session.add(user_coupon)
session.commit()
sender = SMS_Sender()
if devicetype == 'ios':
# send lms
row = session.query(Promotion) \
.filter(Promotion.discount_price == 10000) \
.filter(Promotion.used == 0) \
.first()
code = row.promotion_code
row.used = 2
session.commit()
sender.send2(mtype = 'lms', to = phone, subject = '홈마스터 12월 회원가입 이벤트!',
text = '홈마스터 앱에서 클리닝 예약 시, 아래 코드를 입력 해주세요 (10,000원 할인코드): \n' + code)
elif devicetype == 'android':
sender.send2(mtype = 'lms', to = phone, subject = '홈마스터 12월 회원가입 이벤트!',
text = '홈마스터 10,000 할인 쿠폰이 도착했습니다. 앱의 쿠폰함에서 확인해주세요~')
ret['response'] = guid
self.set_status(Response.RESULT_OK)
print email, 'has successfully registered..!!'
print dt.datetime.now()
mix.track(guid, 'register', {'time' : dt.datetime.now()})
mix.people_set(guid, {'$name' : name, '$email' : email, '$gender' : gender,
'$authsource' : authsource, '$phone' : phone, '$devicetype' : devicetype,
'$brithdate' : birthdate, '$registerdate' : registerdate_str,
'$time' : dt.datetime.now()},
{'$ip' : '121.134.224.40'})
mongo_logger.debug('register', extra = {'log_time' : dt.datetime.now(), 'user_id': guid, 'user_name' : name, 'gender' : gender, 'authsource' : authsource, 'devicetype' : devicetype, 'email' : email, 'phone' : phone})
except Exception, e:
session.rollback()
add_err_message_to_response(ret, err_dict['err_mysql'])
self.set_status(Response.RESULT_SERVERERROR)
print_err_detail(e)
mongo_logger.error('failed to register', extra = {'log_time' : dt.datetime.now(), 'user_name' : name, 'gender' : gender, 'authsource' : authsource, 'devicetype' : devicetype, 'email' : email, 'phone' : phone, 'err' : str(e)})
def post(self):
self.set_header("Content-Type", "application/json")
mode = self.get_argument('mode', 'week') # today, week, all
search_term = self.get_argument('search_term', '')
ret = {}
now = dt.datetime.now().date()
week_ago = now - dt.timedelta(days = 7)
try:
session = Session()
users = []
userdao = UserDAO()
total_cnt = session.query(User).count()
query = session.query(User, UserAddress, UserMemo) \
.outerjoin(UserDefaultAddress, UserDefaultAddress.user_id == User.id) \
.outerjoin(UserAddress, and_(UserDefaultAddress.user_id == UserAddress.user_id, UserDefaultAddress.address_idx == UserAddress.user_addr_index)) \
.outerjoin(UserMemo, User.id == UserMemo.user_id)
if mode == 'week':
query = query.filter(func.date(User.dateofreg) >= week_ago)
elif mode == 'today':
query = query.filter(func.date(User.dateofreg) == now)
if search_term != '':
print 'searching term : ' + search_term
#search_term = search_term.lower()
query = query.filter(or_(func.aes_decrypt(func.from_base64(User.name), func.substring(User.salt, 1, 16)).like('%' + search_term + '%'),
func.aes_decrypt(func.from_base64(User.phone), func.substring(User.salt, 1, 16)).like(search_term + '%'),
User.email.like(search_term + '%'),
User.id == search_term))
result = query.order_by(desc(User.dateofreg)).all()
for row in result:
key = userdao.get_user_salt(row.User.email)[:16]
if key == None or key == '':
print row.User.email
continue
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 ''
user_info['memo'] = row.UserMemo.memo if row.UserMemo != None else ''
#if search_term != '':
# if search_term.lower() in user_info['name'].lower() or user_info['phone'] == search_term or user_info['email'] == search_term:
users.append(user_info)
#if search_term != '':
# users = filter(lambda x : search_term.lower() in x['name'].lower() or x['phone'] == search_term or x['email'] == search_term, users)
ret['response'] = {'count' : total_cnt, 'users' : 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 post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
ret = {}
name = self.get_argument('name', '')
authsource = self.get_argument('authsource', 'None')
devicetype = self.get_argument('devicetype', 'web')
email = self.get_argument('email', '')
password = self.get_argument('password', '')
phone = self.get_argument('phone', '')
is_b2b = self.get_argument('is_b2b', 0)
phone = phone.replace('-', '')
phone = phone.replace(' ', '')
gender = 2 # neither male or female
birthdate = ''
is_b2b = int(is_b2b)
err_msg = ''
if name == '':
err_msg = 'name is invalid'
elif email == '':
err_msg = 'email is invalid'
elif password == '':
err_msg = 'password is invalid'
if err_msg != '': # invalid argument situation
ret['response'] = err_msg
self.set_status(Response.RESULT_BADREQUEST)
add_err_message_to_response(ret, err_dict['invalid_param'])
return
mongo_logger = get_mongo_logger()
mix = get_mixpanel()
try:
session = Session()
guid = str(uuid.uuid4())
registerdate = dt.datetime.now()
registerdate_str = dt.datetime.strftime(registerdate, '%Y%m%d')
count = session.query(User).filter(User.email == email, User.active == 1).count()
if count > 0:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_dup_email'])
mongo_logger.debug('%s is already existed' % email, extra = {'err' : 'duplicate email'})
return
# phone duplicacy check
count = session.query(User) \
.filter(func.aes_decrypt(func.from_base64(User.phone), \
func.substr(User.salt, 1, 16)) == phone, \
User.active == 1) \
.count()
if count > 0:
session.close()
self.set_status(Response.RESULT_OK)
add_err_message_to_response(ret, err_dict['err_dup_phone'])
mongo_logger.debug('phone already existed', extra = {'err' : 'duplicate phone'})
return
salt = uuid.uuid4().hex
encrypted_password = hashlib.sha256(salt + password).hexdigest()
key = salt[:16]
print key
crypto = aes.MyCrypto(key)
encrypted_name = crypto.encodeAES(str(name))
encrypted_phone = crypto.encodeAES(str(phone))
encrypted_birthdate = crypto.encodeAES(str(birthdate))
print encrypted_name, name
print encrypted_phone, phone
print encrypted_birthdate, birthdate
new_user = User(id = guid, name = encrypted_name, gender = gender, authsource = authsource,
devicetype = devicetype, email = email, password = encrypted_password, salt = salt,
phone = encrypted_phone, dateofbirth = encrypted_birthdate,
dateofreg = registerdate, dateoflastlogin= registerdate, is_b2b = is_b2b)
session.add(new_user)
session.commit()
ret['response'] = guid
self.set_status(Response.RESULT_OK)
print email, 'has successfully registered..!!'
print dt.datetime.now()
mix.track(guid, 'register', {'time' : dt.datetime.now()})
mix.people_set(guid, {'$name' : name, '$email' : email, '$gender' : gender,
'$authsource' : authsource, '$phone' : phone, '$devicetype' : devicetype,
'$brithdate' : birthdate, '$registerdate' : registerdate_str,
'$time' : dt.datetime.now()},
{'$ip' : '121.134.224.40'})
mongo_logger.debug('register', extra = {'log_time' : dt.datetime.now(), 'user_id': guid, 'user_name' : name, 'gender' : gender, 'authsource' : authsource, 'devicetype' : devicetype, 'email' : email, 'phone' : phone})
except Exception, e:
session.rollback()
add_err_message_to_response(ret, err_dict['err_mysql'])
self.set_status(Response.RESULT_SERVERERROR)
print_err_detail(e)
mongo_logger.error('failed to register', extra = {'log_time' : dt.datetime.now(), 'user_name' : name, 'gender' : gender, 'authsource' : authsource, 'devicetype' : devicetype, 'email' : email, 'phone' : phone, 'err' : str(e)})
def find(**kwargs):
address_key = current_app.config.get('ADDRESS_KEY')
engine = current_app.config.get('SQLALCHEMY_DATABASE_URI')
matadata = MetaData(bind=engine)
item_shipping_c = Table('item_shipping', matadata, autoload=True)
item_shipping_name_ = func.aes_decrypt(
func.from_base64(item_shipping_c.c.item_shipping_name),
address_key).label('user_name')
item_shipping_name_kana_ = func.aes_decrypt(
func.from_base64(item_shipping_c.c.item_shipping_name_kana),
address_key).label('user_name_kana')
phone_ = func.aes_decrypt(
func.from_base64(item_shipping_c.c.item_shipping_phone),
address_key).label('phone')
zipcode_ = func.aes_decrypt(
func.from_base64(item_shipping_c.c.item_shipping_zipcode),
address_key).label('zipcode')
pref_ = func.aes_decrypt(
func.from_base64(item_shipping_c.c.item_shipping_pref),
address_key).label('pref')
town_ = func.aes_decrypt(
func.from_base64(item_shipping_c.c.item_shipping_town),
address_key).label('town')
address_ = func.aes_decrypt(
func.from_base64(item_shipping_c.c.item_shipping_address),
address_key).label('address')
building_ = func.aes_decrypt(
func.from_base64(item_shipping_c.c.item_shipping_building),
address_key).label('building')
columns = [
item_shipping_c.c.item_shipping_id,
item_shipping_c.c.project_item_id, item_shipping_c.c.project_id,
item_shipping_c.c.user_support_id, item_shipping_c.c.user_id,
item_shipping_name_, item_shipping_name_kana_, phone_, zipcode_,
pref_, town_, address_, building_,
item_shipping_c.c.item_shipping_tax,
item_shipping_c.c.item_shipping_date,
item_shipping_c.c.item_shipping_status
]
where_ = None
if ('user_id' in kwargs) and ('user_support_id' in kwargs):
where_ = and_(
item_shipping_c.c.user_id == kwargs['user_id'],
item_shipping_c.c.user_support_id == kwargs['user_support_id'])
elif ('user_id' in kwargs):
where_ = item_shipping_c.c.user_id == kwargs['user_id']
elif ('user_support_id' in kwargs):
where_ = item_shipping_c.c.user_support_id == kwargs[
'user_support_id']
query = select().select_from(item_shipping_c).where(where_)
user_shipping_ = query.with_only_columns(columns)
results = db.session.execute(user_shipping_)
shippings = []
if results.rowcount > 0:
for result in results:
shipping = {}
shipping['user_name'] = str(
result.user_name, 'utf-8') if result.user_name else ''
shipping['user_name_kana'] = str(
result.user_name_kana,
'utf-8') if result.user_name_kana else ''
shipping['phone'] = str(result.phone,
'utf-8') if result.phone else ''
shipping['zipcode'] = str(result.zipcode,
'utf-8') if result.zipcode else ''
shipping['pref'] = str(result.pref,
'utf-8') if result.pref else ''
shipping['town'] = str(result.town,
'utf-8') if result.town else ''
shipping['address'] = str(result.address,
'utf-8') if result.address else ''
shipping['building'] = str(result.building,
'utf-8') if result.building else ''
shipping['id'] = result.item_shipping_id
shipping['project_item_id'] = result.project_item_id
shipping['project_id'] = result.project_id
shipping['user_support_id'] = result.user_support_id
shipping['user_id'] = result.user_id
shipping['tax'] = result.item_shipping_tax
shipping['date'] = result.item_shipping_date.strftime(
'%Y-%m-%d') if result.item_shipping_date else ''
shipping['status'] = result.item_shipping_status
shippings.append(shipping)
return shippings
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
search_term = self.get_argument('search_term', '')
ret = {}
try:
session = Session()
users = []
userdao = UserDAO()
if search_term == None or search_term == '' or len(
search_term) == 1 or search_term == '010':
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, '잘못된 파라미터 입니다.')
return
total_cnt = session.query(User).count()
now = dt.datetime.now()
query = session.query(User, UserAddress, UserMemo) \
.outerjoin(UserDefaultAddress, UserDefaultAddress.user_id == User.id) \
.outerjoin(UserAddress, and_(UserDefaultAddress.user_id == UserAddress.user_id, UserDefaultAddress.address_idx == UserAddress.user_addr_index)) \
.outerjoin(UserMemo, User.id == UserMemo.user_id)
if search_term != '':
print 'searching term : ' + search_term
#search_term = search_term.lower()
query = query.filter(
or_(
func.aes_decrypt(
func.from_base64(User.name),
func.substring(User.salt, 1,
16)).like('%' + search_term + '%'),
func.aes_decrypt(func.from_base64(User.phone),
func.substring(User.salt, 1,
16)).like(search_term +
'%'),
User.email.like(search_term + '%'),
User.id == search_term))
result = query.order_by(desc(User.dateofreg)).all()
for row in result:
key = userdao.get_user_salt(row.User.email)[:16]
if key == None or key == '':
continue
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['authsource'] = row.User.authsource
user_info['phone'] = crypto.decodeAES(row.User.phone)
user_info['gender'] = row.User.gender
user_info['active'] = row.User.active
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 ''
user_info[
'memo'] = row.UserMemo.memo if row.UserMemo != None else ''
user_info['is_b2b'] = row.User.is_b2b
#user_info['all_addresses'] = userdao.get_all_user_addresses(row.User.id)
users.append(user_info)
ret['response'] = {'count': total_cnt, 'users': 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 post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
subject = self.get_argument('subject', '')
content = self.get_argument('content', '')
content_type = self.get_argument('content_type', '')
print "subject : " + subject
print "content : " + content
print "content_type : " + content_type
ret = {}
phone_numbers = ""
sms_sender = SMS_Sender()
try:
session = Session()
if content_type == 'all_masters':
print 'into masters'
masters = session.query(Master) \
.filter(Master.phone != 'out') \
.filter(Master.active == 1) \
.filter(func.length(Master.phone) < 12) \
.all()
for master in masters:
phone_numbers += master.phone + ","
elif content_type == 'all_users':
print 'into users'
result = session.query(func.group_concat(func.aes_decrypt(func.from_base64(User.phone), func.substring(User.salt, 1, 16)))) \
.filter(func.length(func.aes_decrypt(func.from_base64(User.phone), func.substring(User.salt, 1, 16))) < 12) \
.filter(User.phone != 'out') \
.filter(User.active == 1) \
.filter(not_(User.email.op('regexp')(r'._$'))) \
.all()
phone_numbers = result[0][0]
elif content_type == 'booking_users':
print 'into booking_users'
result = session.query(func.aes_decrypt(func.from_base64(User.phone), func.substring(User.salt, 1, 16))) \
.join(Booking, Booking.user_id == User.id) \
.filter(Booking.cleaning_status == 0) \
.distinct() \
.all()
for row in result:
phone_numbers += row[0] + ","
print phone_numbers
sms_sender.send2(mtype='lms',
to=phone_numbers,
subject=subject,
text=content)
ret['response'] = Response.SUCCESS
self.set_status(Response.RESULT_OK)
except NoResultFound, e:
session.close()
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, '조건에 만족하는 결과가 존재하지 않습니다.')
return
def post(self):
self.set_header("Content-Type", "application/json")
self.set_header('Access-Control-Allow-Origin', '*')
dates = self.get_argument('dates', '')
time = self.get_argument('time', '')
period = self.get_argument('period', '')
tasks = self.get_argument('tasks', '')
total_duration = self.get_argument('total_duration', 180)
total_price = self.get_argument('total_price', '')
basic_duration = self.get_argument('basic_duration', 180)
basic_price = self.get_argument('basic_price', '')
dirty = self.get_argument('dirty', 0)
name = self.get_argument('name', '')
phone = self.get_argument('phone', '')
address = self.get_argument('address', '')
size = self.get_argument('size', '')
rooms = self.get_argument('rooms', '')
baths = self.get_argument('baths', '')
message = self.get_argument('message', '')
password = self.get_argument('password', '')
# convert parameters
dates = dates.split(',')
start_date = dates[0]
if len(dates) > 1:
dates = dates[1:]
total_duration = int(total_duration)
total_price = int(total_price)
basic_duration = int(basic_duration)
basic_price = int(basic_price)
rooms = int(rooms)
baths = int(baths)
size = int(size)
dirty = int(dirty)
if dirty == 1:
dirty = '더러워요'
else:
dirty = '보통이에요'
cleaning_id = str(uuid.uuid4())
ret = {}
userdao = UserDAO()
mongo_logger = get_mongo_logger()
try:
# 전화번호나 이메일이 없는 경우에는 회원가입을 시키고 진행
# 있는 경우에는 가입 시키지 않고 그대로 진행
session = Session()
user_query = session.query(User) \
.filter(func.aes_decrypt(func.from_base64(User.phone), \
func.substr(User.salt, 1, 16)) == phone, \
User.active == 1) \
if user_query.count() <= 0:
user_id = str(uuid.uuid4())
salt = uuid.uuid4().hex
encrypted_password = hashlib.sha256(salt + password).hexdigest()
key = salt[:16]
crypto = aes.MyCrypto(key)
encrypted_name = crypto.encodeAES(str(name))
encrypted_phone = crypto.encodeAES(str(phone))
email = '{}@webuser.co.kr'.format(phone)
new_user = User(id = user_id, name = encrypted_name,
gender = 2, authsource = 'web',
devicetype = 'web', email = email,
password = encrypted_password, salt = salt,
phone = encrypted_phone,
dateofreg = dt.datetime.now(),
dateoflastlogin = dt.datetime.now())
session.add(new_user)
session.commit()
else:
user = user_query.order_by(desc(User.dateoflastlogin)).first()
user_id = user.id
email = user.email
if user_id == None or user_id == '':
self.set_status(Response.RESULT_OK)
add_err_ko_message_to_response(ret, '잘못된 사용자 아이디 입니다.')
return
# size : 0, kind : 3
# 일단 입력한 그대로 주소 추가. 주소 형식이 자유 형식이기 때문에
# 관리자가 판단하여 주소를 수정하거나, 예약을 취소할 수 있음
address_index = userdao.add_new_address(user_id, address, size, 3, rooms, baths)
booking = {}
booking['user_id'] = user_id
booking['cleaning_id'] = cleaning_id
booking['dates'] = dates
booking['start_date'] = start_date
booking['time'] = time
booking['period'] = period
booking['total_duration'] = total_duration
booking['total_price'] = total_price
booking['basic_duration'] = basic_duration
booking['basic_price'] = basic_price
booking['dirty'] = dirty
booking['tasks'] = tasks
booking['name'] = name
booking['phone'] = phone
booking['address'] = address
booking['address_index'] = address_index
booking['rooms'] = rooms
booking['baths'] = baths
booking['message'] = message
booking['email'] = email
booking['size'] = size
booking['password'] = password
booking['count'] = 0
booking['booking_ids'] = []
booking['request_time'] = dt.datetime.now()
self.db.insert(booking)
ret['response'] = cleaning_id
self.set_status(Response.RESULT_OK)
mongo_logger.debug('web request booking', extra = {'user_id': user_id,
'cleaning_id' : cleaning_id,
'dates' : dates,
'sel_time' : time,
'sel_period' : period,
'total_duration' : total_duration,
'toatl_price' : total_price,
'basic_duration' : basic_duration,
'basic_price' : basic_price,
'tasks' : tasks,
'rooms' : rooms,
'baths' : baths,
'user_name' : name,
'user_phone' : phone,
'user_address' : address})
except Exception, e:
session.rollback()
add_err_message_to_response(ret, err_dict['err_mysql'])
self.set_status(Response.RESULT_SERVERERROR)
print_err_detail(e)
mongo_logger.error('failed to web request booking',
extra = {'user_id': user_id,
'cleaning_id' : cleaning_id,
'dates' : dates,
'sel_time' : time,
'sel_period' : period,
'total_duration' : total_duration,
'toatl_price' : total_price,
'basic_duration' : basic_duration,
'basic_price' : basic_price,
'tasks' : tasks,
'rooms' : rooms,
'baths' : baths,
'user_name' : name,
'user_phone' : phone,
'user_address' : address})
