def update_photo(photolog_id):
""" 사진 업로드 화면에서 사용자가 수정한 내용을 DB에 업데이트 한다. """
form = PhotoUploadForm(request.form)
if form.validate():
#: 업데이트 대상 항목들
tag = form.tag.data
comment = form.comment.data
lat = form.lat.data
lng = form.lng.data
try:
#: 변경전 원래의 photo 테이블 값을 읽어 온다.
photo = dao.query(Photo).filter_by(id=photolog_id).first()
#: 업데이트 값 셋팅
photo.tag = tag
photo.comment = comment
photo.geotag_lat = lat
photo.geotag_lng = lng
dao.commit()
except Exception as e:
dao.rollback()
Log.error("Update DB error : " + str(e))
raise e
return redirect(url_for('.show_all'))
else:
return render_template('upload.html', photo=photo, form=form)
def close_db_session(exception=None):
"""요청이 완료된 후에 db연결에 사용된 세션을 종료함"""
try:
dao.remove()
except Exception as e:
Log.error(str(e))
def update_photo(photolog_id):
""" 사진 업로드 화면에서 사용자가 수정한 내용을 DB에 업데이트 한다. """
form = PhotoUploadForm(request.form)
if form.validate():
#: 업데이트 대상 항목들
tag = form.tag.data
comment = form.comment.data
lat = form.lat.data
lng = form.lng.data
try :
#: 변경전 원래의 photo 테이블 값을 읽어 온다.
photo = dao.query(Photo).filter_by(id=photolog_id).first()
#: 업데이트 값 셋팅
photo.tag = tag
photo.comment = comment
photo.geotag_lat = lat
photo.geotag_lng = lng
dao.commit()
except Exception as e:
dao.rollback()
Log.error("Update DB error : " + str(e))
raise e
return redirect(url_for('.show_all'))
else:
return render_template('upload.html', photo=photo, form=form)
def __oauth(photolog_id):
""" twitter로부터 인증토큰을 받기 위한 함수 """
try:
twitter = Twython(current_app.config['TWIT_APP_KEY'],
current_app.config['TWIT_APP_SECRET'])
callback_svr = current_app.config['TWIT_CALLBACK_SERVER']
auth = twitter.get_authentication_tokens(
callback_url= callback_svr + \
url_for('.callback', photolog_id=photolog_id))
# 중간단계로 받은 임시 인증토큰은 최종인증을 위해 필요하므로 세션에 저장한다.
session['OAUTH_TOKEN'] = auth['oauth_token']
session['OAUTH_TOKEN_SECRET'] = auth['oauth_token_secret']
except TwythonError as e:
Log.error("__oauth(): TwythonError , "+ str(e))
session['TWITTER_RESULT'] = str(e)
return redirect(url_for('.show_all'))
# 트위터의 사용자 권한 인증 URL로 페이지를 리다이렉트한다.
return redirect(auth['auth_url'])
def close_db_session(exception=None):
"""요청이 완료된 후에 db연결에 사용된 세션을 종료함"""
try:
dao.remove()
except Exception as e:
Log.error(str(e))
def callback(photolog_id):
""" twitter로부터 callback url이 요청되었을때
최종인증을 한 후 트위터로 해당 사진과 커멘트를 전송한다.
"""
Log.info("callback oauth_token:" + request.args['oauth_token']);
Log.info("callback oauth_verifier:" + request.args['oauth_verifier']);
# oauth에서 twiter로 부터 넘겨받은 인증토큰을 세션으로 부터 가져온다.
OAUTH_TOKEN = session['OAUTH_TOKEN']
OAUTH_TOKEN_SECRET = session['OAUTH_TOKEN_SECRET']
oauth_verifier = request.args['oauth_verifier']
# 임시로 받은 인증토큰을 이용하여 twitter 객체를 만들고 인증토큰을 검증한다.
twitter = Twython(current_app.config['TWIT_APP_KEY'],
current_app.config['TWIT_APP_SECRET'],
OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(oauth_verifier)
# oauth_verifier를 통해 얻은 최종 인증토큰을 이용하여 twitter 객체를 새로 생성한다.
twitter = Twython(current_app.config['TWIT_APP_KEY'],
current_app.config['TWIT_APP_SECRET'],
final_step['oauth_token'],
final_step['oauth_token_secret'])
session['TWITTER'] = twitter
# 파라미터로 받은 photolog_id를 이용하여 해당 사진과 커멘트를 트위터로 전송한다.
photo_info = get_photo_info(photolog_id)
download_filepath = photo_info[2]
photo_comment = photo_info[3]
photo = open(download_filepath, 'rb')
twitter.update_status_with_media(status=photo_comment,
media=photo)
return redirect(url_for('.show_all'))
def register_user():
form = RegisterForm(request.form)
if form.validate():
username = form.username.data
email = form.email.data
password = form.password.data
try:
user = User(username=username,
email=email,
password=generate_password_hash(password))
dao.add(user)
dao.commit()
Log.debug(user)
except Exception as e:
error = "DB error occurs: " + str(e)
Log.error(error)
dao.rollback()
raise e
else:
return redirect(url_for('.login', register_user=username))
else:
return render_template('../photolog/templates/regist.html', form=form)
def register_user():
"""포토로그 사용자 등록을 위한 함수"""
form = RegisterForm(request.form)
if form.validate():
username = form.username.data
email = form.email.data
password = form.password.data
try:
user = User(username,
email,
generate_password_hash(password))
dao.add(user)
dao.commit()
Log.debug(user)
except Exception as e:
error = "DB error occurs : " + str(e)
Log.error(error)
dao.rollback()
raise e
else:
# 성공적으로 사용자 등록이 되면, 로그인 화면으로 이동.
return redirect(url_for('.login',
regist_username=username))
else:
return render_template('regist.html', form=form)
def register_user():
"""포토로그 사용자 등록을 위한 함수"""
form = RegisterForm(request.form)
if form.validate():
username = form.username.data
email = form.email.data
password = form.password.data
try:
user = User(username,
email,
generate_password_hash(password))
dao.add(user)
dao.commit()
Log.debug(user)
except Exception as e:
error = "DB error occurs : " + str(e)
Log.error(error)
dao.rollback()
raise e
else:
# 성공적으로 사용자 등록이 되면, 로그인 화면으로 이동.
return redirect(url_for('.login',
regist_username=username))
else:
return render_template('regist.html', form=form)
def update_user(username):
"""포토로그 사용자 정보 수정을 위한 함수"""
current_user = __get_user(username)
form = UpdateForm(request.form)
if form.validate():
email = form.email.data
password = form.password.data
try:
current_user.email = email
current_user.password = generate_password_hash(password)
dao.commit()
except Exception as e:
dao.rollback()
Log.error(str(e))
raise e
else:
# 변경된 사용자 정보를 세션에 반영
session['user_info'].email = \
current_user.email
session['user_info'].password = \
current_user.password
session['user_info'].password_confirm = \
current_user.password
# 성공적으로 사용자 등록이 되면, 로그인 화면으로 이동.
return redirect(url_for('.login',
update_username=username))
else:
return render_template('regist.html',
user=current_user,
form=form)
def update_user(username):
"""포토로그 사용자 정보 수정을 위한 함수"""
current_user = __get_user(username)
form = UpdateForm(request.form)
if form.validate():
email = form.email.data
password = form.password.data
try:
current_user.email = email
current_user.password = generate_password_hash(password)
dao.commit()
except Exception as e:
dao.rollback()
Log.error(str(e))
raise e
else:
# 변경된 사용자 정보를 세션에 반영
session['user_info'].email = \
current_user.email
session['user_info'].password = \
current_user.password
session['user_info'].password_confirm = \
current_user.password
# 성공적으로 사용자 등록이 되면, 로그인 화면으로 이동.
return redirect(url_for('.login',
update_username=username))
else:
return render_template('regist.html',
user=current_user,
form=form)
def callback(photolog_id):
""" twitter로부터 callback url이 요청되었을때
최종인증을 한 후 트위터로 해당 사진과 커멘트를 전송한다.
"""
Log.info("callback oauth_token:" + request.args['oauth_token'])
Log.info("callback oauth_verifier:" + request.args['oauth_verifier'])
# oauth에서 twiter로 부터 넘겨받은 인증토큰을 세션으로 부터 가져온다.
OAUTH_TOKEN = session['OAUTH_TOKEN']
OAUTH_TOKEN_SECRET = session['OAUTH_TOKEN_SECRET']
oauth_verifier = request.args['oauth_verifier']
# 임시로 받은 인증토큰을 이용하여 twitter 객체를 만들고 인증토큰을 검증한다.
twitter = Twython(current_app.config['TWIT_APP_KEY'],
current_app.config['TWIT_APP_SECRET'], OAUTH_TOKEN,
OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(oauth_verifier)
# oauth_verifier를 통해 얻은 최종 인증토큰을 이용하여 twitter 객체를 새로 생성한다.
twitter = Twython(current_app.config['TWIT_APP_KEY'],
current_app.config['TWIT_APP_SECRET'],
final_step['oauth_token'],
final_step['oauth_token_secret'])
session['TWITTER'] = twitter
# 파라미터로 받은 photolog_id를 이용하여 해당 사진과 커멘트를 트위터로 전송한다.
photo_info = get_photo_info(photolog_id)
download_filepath = photo_info[2]
photo_comment = photo_info[3]
photo = open(download_filepath, 'rb')
twitter.update_status_with_media(status=photo_comment, media=photo)
return redirect(url_for('.show_all'))
def __get_user(username):
try:
current_user = dao.query(User).filter_by(username=username).first()
Log.debug(current_user)
return current_user
except Exception as e:
Log.error(str(e))
raise e
def create_app(config_filepath='resource/config.cfg'):
'''
포토로그 애플리케이션을 생성하는 함수.
Args:
config_filepath: 설정파일의 위치
Returns: Flask 객체
'''
photolog_app = Flask(__name__)
# 기본 설정은 PhotologConfig 객체에 정의되있고 운영 환경 또는 기본 설정을 변경을 하려면
# 실행 환경변수인 PHOTOLOG_SETTINGS에 변경할 설정을 담고 있는 파일 경로를 설정
from photolog.photolog_config import PhotologConfig
photolog_app.config.from_object(
PhotologConfig) # photolog_config.py로부터(기본설정)
photolog_app.config.from_pyfile(config_filepath,
silent=True) # config.cfg 로부터
print_settings(photolog_app.config.iteritems())
# 로그 초기화
from photolog.photolog_logger import Log
log_filepath = os.path.join(photolog_app.root_path,
photolog_app.config['LOG_FILE_PATH'])
Log.init(log_filepath=log_filepath)
# 데이터베이스 처리
from photolog.database import DBManager
db_filepath = os.path.join(photolog_app.root_path,
photolog_app.config['DB_FILE_PATH'])
db_url = photolog_app.config['DB_URL'] + db_filepath
DBManager.init(db_url, eval(photolog_app.config['DB_LOG_FLAG']))
DBManager.init_db()
# 뷰 함수 모듈은 어플리케이션 객체 생성하고 블루프린트 등록전에
# 뷰 함수가 있는 모듈을 임포트해야 해당 뷰 함수들을 인식할 수 있음
from photolog.controller import *
from photolog.photolog_blueprint import photolog
photolog_app.register_blueprint(photolog)
# SessionInterface 설정.
# Redis를 이용한 세션 구현은 cache_session.RedisCacheSessionInterface 임포트하고
# app.session_interface에 RedisCacheSessionInterface를 할당
from photolog.cache_session import SimpleCacheSessionInterface
photolog_app.session_interface = SimpleCacheSessionInterface()
# 공통으로 적용할 HTTP 404과 500 에러 핸들러를 설정
photolog_app.error_handler_spec[None][404] = not_found
photolog_app.error_handler_spec[None][500] = server_error
# 페이징 처리를 위한 템플릿 함수
photolog_app.jinja_env.globals['url_for_other_page'] = \
url_for_other_page
return photolog_app
def login_form():
"""아이디/패스워드 기반의 로그인 화면을 제공함 """
next_url = request.args.get('next', '')
Log.info("(%s)next_url is %s" % (request.method, next_url))
form = LoginForm(request.form)
return render_template('login.html',
next_url=next_url,
form=form)
def create_app(config_filepath='resource/config.cfg'):
photolog_app = Flask(__name__)
# 기본 설정은 PhotologConfig 객체에 정의되있고 운영 환경 또는 기본 설정을 변경을 하려면
# 실행 환경변수인 PHOTOLOG_SETTINGS에 변경할 설정을 담고 있는 파일 경로를 설정
from photolog.photolog_config import PhotologConfig
photolog_app.config.from_object(PhotologConfig)
# photolog_app.config.from_pyfile(config_filepath, silent=True)
print_settings(photolog_app.config.items())
# 로그 초기화
from photolog.photolog_logger import Log
log_filepath = os.path.join(photolog_app.root_path,
photolog_app.config['LOG_FILE_PATH'])
Log.init(log_filepath=log_filepath)
# 데이터베이스 처리
from photolog.database import DBManager
db_filepath = os.path.join(photolog_app.root_path,
photolog_app.config['DB_FILE_PATH'])
db_url = photolog_app.config['DB_URL'] + db_filepath
DBManager.__init__(db_url, eval(photolog_app.config['DB_LOG_FLAG']))
DBManager.init_db()
# 뷰 함수 모듈은 어플리케이션 객체 생성하고 블루프린트 등록전에 뷰 함수가 있는 모듈을 임포트해야 해당 뷰 함수들을 인식할 수 있음
from photolog.controller import login
from photolog.controller import register_user
from photolog.photolog_blueprint import photolog
photolog_app.register_blueprint(photolog)
# sessionInterface 설정
# Redis를 이용한 세션 구현은 cache_session.RedisCacheSessionInterface 임포트하고
# app.session_interface에 RedisCacheSessionInterface를 할당
from photolog.cache_session import SimpleCacheSessionInterface
photolog_app.session_interface = SimpleCacheSessionInterface()
# 공통으로 적용할 HTTP 404, 500 에러 핸들러를 설정
# error_handler_spec() 함수는 딕셔너리의 값으로 다시 딕셔너리가 사용된 중첩 딕셔너리
# 첫 번째 키는 블루프린트이고 'None'으로 설정하면 애플리케이션 단위로 에러 핸들러가 등록된다.
# photolog_app.error_handler_spec[None][404] = not_found
# photolog_app.error_handler_spec[None][500] = server_error
# 페이징 처리를 위한 템플릿 함수
photolog_app.jinja_env.globals['url_for_other_page'] = \
url_for_other_page
return photolog_app
def login_form():
next_url = request.args.get('next', '')
regist_username = request.args.get('regist_username', '')
update_username = request.args.get('update_username', '')
Log.info('(%s)next_url is %s' % (request.method, next_url))
form = LoginForm(request.form)
return render_template('../photolog/templates/login.html',
next_url=next_url,
form=form,
regist_username=regist_username,
update_username=update_username)
def unregist():
user_id = session['user_info'].id
try:
user = dao.query(User).filter_by(id=user_id).first()
Log.info("unregist:"+user.username)
if user.id == user_id:
dao.delete(user)
# 업로드된 사진 파일 삭제
try:
upload_folder = \
os.path.join(current_app.root_path,
current_app.config['UPLOAD_FOLDER'])
__delete_files(upload_folder, user.username)
except Exception as e:
Log.error("파일 삭제에 실패했습니다. : %s" + \
str(e))
dao.commit()
else:
Log.error("존재하지 않는 사용자의 탈퇴시도 : %d", user_id)
raise Exception
except Exception as e:
Log.error(str(e))
dao.rollback()
raise e
# else:
return redirect(url_for('.logout'))
def create_app(config_filepath='resource/config.cfg'):
photolog_app = Flask(__name__)
# 기본 설정은 PhotologConfig 객체에 정의되있고 운영 환경 또는 기본 설정을 변경을 하려면
# 실행 환경변수인 PHOTOLOG_SETTINGS에 변경할 설정을 담고 있는 파일 경로를 설정
from photolog.photolog_config import PhotologConfig
photolog_app.config.from_object(PhotologConfig)
photolog_app.config.from_pyfile(config_filepath, silent=True)
print_settings(photolog_app.config.items())
# 로그 초기화
from photolog.photolog_logger import Log
log_filepath = os.path.join(photolog_app.root_path,
photolog_app.config['LOG_FILE_PATH'])
Log.init(log_filepath=log_filepath)
# 데이터베이스 처리
from photolog.database import DBManager
db_filepath = os.path.join(photolog_app.root_path,
photolog_app.config['DB_FILE_PATH'])
db_url = photolog_app.config['DB_URL'] + db_filepath
DBManager.init(db_url, eval(photolog_app.config['DB_LOG_FLAG']))
DBManager.init_db()
# 뷰 함수 모듈은 어플리케이션 객체 생성하고 블루프린트 등록전에
# 뷰 함수가 있는 모듈을 임포트해야 해당 뷰 함수들을 인식할 수 있음
from photolog.controller import login
from photolog.controller import photo_show
from photolog.controller import photo_upload
from photolog.controller import register_user
from photolog.controller import twitter
from photolog.photolog_blueprint import photolog
photolog_app.register_blueprint(photolog)
# SessionInterface 설정.
# Redis를 이용한 세션 구현은 cache_session.RedisCacheSessionInterface 임포트하고
# app.session_interface에 RedisCacheSessionInterface를 할당
from photolog.cache_session import SimpleCacheSessionInterface
photolog_app.session_interface = SimpleCacheSessionInterface()
# 공통으로 적용할 HTTP 404과 500 에러 핸들러를 설정
photolog_app.error_handler_spec[None][404] = not_found
photolog_app.error_handler_spec[None][500] = server_error
# 페이징 처리를 위한 템플릿 함수
photolog_app.jinja_env.globals['url_for_other_page'] = \
url_for_other_page
return photolog_app
def unregist():
user_id = session['user_info'].id
try:
user = dao.query(User).filter_by(id=user_id).first()
Log.info("unregist:"+user.username)
if user.id == user_id:
dao.delete(user)
# 업로드된 사진 파일 삭제
try:
upload_folder = \
os.path.join(current_app.root_path,
current_app.config['UPLOAD_FOLDER'])
__delete_files(upload_folder, user.username)
except Exception as e:
Log.error("파일 삭제에 실패했습니다. : %s" + \
str(e))
dao.commit()
else:
Log.error("존재하지 않는 사용자의 탈퇴시도 : %d", user_id)
raise Exception
except Exception as e:
Log.error(str(e))
dao.rollback()
raise e
# else:
return redirect(url_for('.leave'))
def login():
"""아이디/비밀번호 기반의 로그인 기능을 제공함
로그인 성공 시 세션에 사용자 정보를 저장하여 사용함
"""
form = LoginForm(request.form)
next_url = form.next_url.data
login_error = None
if form.validate():
""" 세션 생성"""
session.permanent = True
username = form.username.data
password = form.password.data
next_url = form.next_url.data
Log.info('(%s)next_url is %s' % (request.method, next_url))
try:
user = dao.query(User). \
filter_by(username=username). \
first()
except Exception as e:
Log.error(str(e))
raise e
if user:
if not check_password_hash(user.password, password):
login_error = 'Invalid password'
else:
# 세션에 추가할 정보를 session 객체의 값으로 추가함
# 가령, User 클래스 같은 사용자 정보를 추가하는 객체 생성하고
# 사용자 정보를 구성하여 session 객체에 추가
session['user_info'] = user
if next_url != '':
return redirect(next_url)
else:
return redirect(url_for('.index'))
else:
login_error = 'User does not exist!'
return render_template('login.html',
next_url=next_url,
error=login_error,
form=form)
def login_form():
"""아이디/비밀번호 기반의 로그인 화면을 제공함 """
next_url = request.args.get('next', '')
regist_username = request.args.get('regist_username', '')
update_username = request.args.get('update_username', '')
Log.info('(%s)next_url is %s' % (request.method, next_url))
form = LoginForm(request.form)
return render_template('login.html',
next_url=next_url,
form=form,
regist_username=regist_username,
update_username=update_username)
def login():
"""아이디/비밀번호 기반의 로그인 기능을 제공함
로그인 성공 시 세션에 사용자 정보를 저장하여 사용함
"""
form = LoginForm(request.form)
next_url = form.next_url.data
login_error = None
if form.validate():
session.permanent = True
username = form.username.data
password = form.password.data
next_url = form.next_url.data
Log.info('(%s)next_url is %s' % (request.method, next_url))
try:
user = dao.query(User). \
filter_by(username=username). \
first()
except Exception as e:
Log.error(str(e))
raise e
if user:
if not check_password_hash(user.password, password):
login_error = 'Invalid password'
else:
# 세션에 추가할 정보를 session 객체의 값으로 추가함
# 가령, User 클래스 같은 사용자 정보를 추가하는 객체 생성하고
# 사용자 정보를 구성하여 session 객체에 추가
session['user_info'] = user
if next_url != '':
return redirect(next_url)
else:
return redirect(url_for('.index'))
else:
login_error = 'User does not exist!'
return render_template('login.html',
next_url=next_url,
error=login_error,
form=form)
def __delete_files(filepath, username):
import glob
#: 원본 이미지 파일 제거
del_filepath_rule = filepath + username + "_*"
files = glob.glob(del_filepath_rule)
for f in files:
Log.debug(f)
os.remove(f)
#: 썸네일 제거
del_filepath_rule = filepath + "thumb_" + username + "_*"
files = glob.glob(del_filepath_rule)
for f in files:
Log.debug(f)
os.remove(f)
def __delete_files(filepath, username):
import glob
#: 원본 이미지 파일 제거
del_filepath_rule = filepath + username + "_*"
files = glob.glob(del_filepath_rule)
for f in files:
Log.debug(f)
os.remove(f)
#: 썸네일 제거
del_filepath_rule = filepath + "thumb_" + username + "_*"
files = glob.glob(del_filepath_rule)
for f in files:
Log.debug(f)
os.remove(f)
def decorated_function(*args, **kwargs):
try:
session_key = \
request.cookies.get(current_app.config['SESSION_COOKIE_NAME'])
is_login = False
if session.sid == session_key and \
session.__contains__('user_info') :
is_login = True
if not is_login:
return redirect(url_for('.login_form', next=request.url))
return f(*args, **kwargs)
except Exception as e:
Log.error("while checking session, error occurs : %s" % str(e))
raise e
def decorated_function(*args, **kwargs):
try:
session_key = request.cookies.get(
current_app.config['SESSION_COOKIE_NAME'])
is_login = False
if session.sid == session_key and session.__contains__(
'user_info'):
is_login = True
if not is_login:
return redirect(url_for('.login_form', next=request.url))
return f(*args, **kwargs)
except Exception as e:
Log.error("Phtolog error occurs: %s" % str(e))
raise e
def make_thumbnails(filename):
""" 업로드된 파일은 사이즈가 크기때문에 preview등에 사용하기 위해
썸네일 이미지를 생성한다.
"""
upload_folder = os.path.join(current_app.root_path,
current_app.config['UPLOAD_FOLDER'])
original_file = upload_folder+filename
target_name = upload_folder+"thumb_"+filename
try:
#: PIL 라이브러리를 이용하여 썸네일 생성
im = Image.open(original_file)
im = im.convert('RGB')
im.thumbnail((300,300), Image.ANTIALIAS)
im.save(target_name)
except Exception as e:
Log.error("Thumbnails creation error : " + target_name+" , "+str(e))
raise e
def __send_twit(twitter, photolog_id):
""" 실제로, photolog_id에 해당하는 사진과 커멘트를 트위터로 전송하는 내부 함수 """
try:
photo_info = get_photo_info(photolog_id)
download_filepath = photo_info[2]
photo_comment = photo_info[3]
photo = open(download_filepath, 'rb')
twitter.update_status_with_media(status=photo_comment,
media=photo)
session['TWITTER_RESULT'] = 'ok'
except IOError as e:
Log.error("send(): IOError , " + str(e))
session['TWITTER_RESULT'] = str(e)
except TwythonError as e:
Log.error("send(): TwythonError , " + str(e))
session['TWITTER_RESULT'] = str(e)
def create_app(config_filepath='resource/config.cfg'):
# 기본 설정은 PhotologConfig 객체에 정의되있고 운영 환경 또는 기본 설정을 변경을 하려면
# 실행 환경변수인 PHOTOLOG_SETTINGS에 변경할 설정을 담고 있는 파일 경로를 설정
from photolog.photolog_config import PhotologConfig
photolog_app = Flask(__name__)
photolog_app.config.from_object(PhotologConfig)
photolog_app.config.from_pyfile(config_filepath, slient=True)
print_setting(photolog_app.config.items())
# 로그 초기화
from photolog.photolog_logger import Log
log_filepath = os.path.join(photolog_app.root_path,
photolog_app.config['LOG_FILE_PATH']))
Log.init(log_filepath=log_filepath)
# data base처리
from photolog.database import DBManager
db_filepath = os.path.join( photolog_app.root_path,
photolog_app.config['DB_FILE_PATH'])
def login():
form = LoginForm(request.form)
next_url = form.next_url.data
login_error = None
if form.validate():
session.permanent = True
username = form.username.data
password = form.password.data
next_url = form.next_url.data
Log.info('(%s)next_url is %s' % (request.method, next_url))
try:
user = dao.query(User).filter_by(username=username).first()
except Exception as e:
Log.error(str(e))
raise e
if user:
if not check_password_hash(user.password, password):
login_error = 'Invalid password'
else:
session['user_info'] = user
if next_url != '':
return redirect(next_url)
else:
return redirect(url_for('.index'))
else:
login_error = 'User does not exist!'
return render_template('../photolog/templates/login.html',
next_url=next_url,
error=login_error,
form=form)
def callback(photolog_id):
""" twitter로부터 callback url이 요청되었을때
최종인증을 한 후 트위터로 해당 사진과 커멘트를 전송한다.
"""
Log.info("callback oauth_token:" + request.args['oauth_token']);
Log.info("callback oauth_verifier:" + request.args['oauth_verifier']);
# oauth에서 twiter로 부터 넘겨받은 인증토큰을 세션으로 부터 가져온다.
OAUTH_TOKEN = session['OAUTH_TOKEN']
OAUTH_TOKEN_SECRET = session['OAUTH_TOKEN_SECRET']
oauth_verifier = request.args['oauth_verifier']
try:
# 임시로 받은 인증토큰을 이용하여 twitter 객체를 만들고 인증토큰을 검증한다.
twitter = Twython(current_app.config['TWIT_APP_KEY'],
current_app.config['TWIT_APP_SECRET'],
OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(oauth_verifier)
# oauth_verifier를 통해 얻은 최종 인증토큰을 이용하여 twitter 객체를 새로 생성한다.
twitter = Twython(current_app.config['TWIT_APP_KEY'],
current_app.config['TWIT_APP_SECRET'],
final_step['oauth_token'],
final_step['oauth_token_secret'])
session['TWITTER'] = twitter
# 파라미터로 받은 photolog_id를 이용하여 해당 사진과 커멘트를 트위터로 전송한다.
__send_twit(twitter, photolog_id)
except TwythonError as e:
Log.error("callback(): TwythonError , "+ str(e))
session['TWITTER_RESULT'] = str(e)
return redirect(url_for('.show_all'))
def remove(photolog_id):
""" DB에서 해당 데이터를 삭제하고 관련된 이미지파일을 함께 삭제한다."""
user_id = session['user_info'].id
try:
photo = dao.query(Photo).filter_by(id=str(photolog_id)).first()
dao.delete(photo)
dao.commit()
upload_folder = os.path.join(current_app.root_path,
current_app.config['UPLOAD_FOLDER'])
os.remove(upload_folder + str(photo.filename))
os.remove(upload_folder + "thumb_"+str(photo.filename))
except Exception as e:
dao.rollback()
Log.error("Photo remove error => " + photolog_id + ":" + user_id + \
", " + str(e))
raise e
return redirect(url_for('.show_all'))
def remove(photolog_id):
""" DB에서 해당 데이터를 삭제하고 관련된 이미지파일을 함께 삭제한다."""
user_id = session['user_info'].id
try:
photo = dao.query(Photo).filter_by(id=str(photolog_id)).first()
dao.delete(photo)
dao.commit()
upload_folder = os.path.join(current_app.root_path,
current_app.config['UPLOAD_FOLDER'])
os.remove(upload_folder + str(photo.filename))
os.remove(upload_folder + "thumb_" + str(photo.filename))
except Exception as e:
dao.rollback()
Log.error("Photo remove error => " + photolog_id + ":" + user_id + \
", " + str(e))
raise e
return redirect(url_for('.show_all'))
def create_app(config_filepath="resource/config.cfg"):
"""hi."""
photolog_app = Flask(__name__)
from photolog.photolog_config import PhotologConfig
from photolog.photolog_logger import Log
from photolog.database import DBManager
from photolog.controller import *
from photolog.cache_session import SimpleCacheSessionInterface
from photolog.photolog_blueprint import photolog
photolog_app.config.from_object(PhotologConfig)
photolog_app.config.from_pyfile(config_filepath, silent=True)
print_settings(photolog_app.config.iteritems())
log_filepath = os.path.join(photolog_app.root_path,
photolog_app.config["LOG_FILE_PATH"])
Log.init(log_filepath=log_filepath)
db_filepath = os.path.join(photolog_app.root_path,
photolog_app.config['DB_FILE_PATH'])
db_url = photolog_app.config['DB_URL'] + db_filepath
DBManager.init(db_url, eval(photolog_app.config['DB_LOG_FLAG']))
DBManager.init_db()
photolog_app.register_blueprint(photolog)
photolog_app.session_interface = SimpleCacheSessionInterface()
photolog_app.error_handler_spec[None][404] = not_found
photolog_app.error_handler_spec[None][500] = server_error
photolog_app.jinja_env.globals["url_for_other_page"] = \
url_for_other_page
return photolog_app
def __delete_files(filepath, username):
"""
:param filepath:
:param username:
:return:
"""
import glob
""" glob = 유닉스 셀 법칙을 사용해 패턴에 매칭하는 파일 이름을 찻는다."""
# 원본 이미지 파일 제거
del_filepath_rule = filepath + username + "_*"
files = glob.glob(del_filepath_rule)
for f in files:
Log.debug(f)
os.remove(f)
# 썸네일 제거
del_filepath_rule = filepath + "thumb_" + username + "_*"
files = glob.glob(del_filepath_rule)
for f in files:
Log.debug(f)
os.remove(f)
u"""blue_print?."""
# -*- coding: utf-8 -*-
from flask import Blueprint
from photolog.photolog_logger import Log
photolog = Blueprint("photolog",
__name__,
template_folder="../templates",
static_folder="../static")
Log.info("static folder : %s" % photolog.static_folder)
Log.info("template folder : %s" % photolog.template_folder)
# -*- coding: utf-8 -*-
"""
photolog.blueprint
~~~~~~~~~~~~~~~~~~
photolog 어플리케이션에 적용할 blueprint 모듈.
:copyright: (c) 2013 by 4mba.
:license: MIT LICENSE 2.0, see license for more details.
"""
from flask import Blueprint
from photolog.photolog_logger import Log
photolog = Blueprint('photolog', __name__,
template_folder='../templates', static_folder='../static')
Log.info('static folder : %s' % photolog.static_folder)
Log.info('template folder : %s' % photolog.template_folder)
def upload_photo():
""" Form으로 파일과 변수들을 DB에 저장하는 함수. """
form = PhotoUploadForm(request.form)
# HTTP POST로 요청이 오면 사용자 정보를 등록
if form.validate():
#: Session에 저장된 사용자 정보를 셋팅
user_id = session['user_info'].id
username = session['user_info'].username
#: Form으로 넘어온 변수들의 값을 셋팅함
tag = form.tag.data
comment =form.comment.data
lat = form.lat.data
lng = form.lng.data
upload_date = datetime.today()
try:
#: Exif에서 전달받은 data 형식을 파이썬 date 객체로 변환
taken_date = datetime.strptime(form.taken_date.data,
"%Y:%m:%d %H:%M:%S")
except :
#: date 포맷 예외 발생: exif가 없거나,
#: 사진찍은 시간이 없는 경우에는 현재시간으로 대체
taken_date = datetime.today()
#: 업로드되는 파일정보 값들을 셋팅한다.
upload_photo = request.files['photo']
filename = None
filesize = 0
filename_orig = upload_photo.filename
try:
#: 파일 확장자 검사 : 현재 jpg, jpeg만 가능
if upload_photo and __allowed_file(upload_photo.filename):
ext = (upload_photo.filename).rsplit('.', 1)[1]
#: 업로드 폴더 위치는 얻는다.
upload_folder = \
os.path.join(current_app.root_path,
current_app.config['UPLOAD_FOLDER'])
#: 유일하고 안전한 파일명을 얻는다.
filename = \
secure_filename(username +
'_' +
unicode(uuid.uuid4()) +
"." +
ext)
upload_photo.save(os.path.join(upload_folder, filename))
filesize = os.stat(upload_folder + filename).st_size
#: 썸네일을 만든다.
make_thumbnails(filename)
else:
raise Exception("File upload error : illegal file.")
except Exception as e:
Log.error(str(e))
raise e
try :
#: 사진에 대한 정보 DB에 저장
photo = Photo(user_id, tag, comment, filename_orig, filename,
filesize, lat, lng, upload_date, taken_date)
dao.add(photo)
dao.commit()
except Exception as e:
dao.rollback()
Log.error("Upload DB error : " + str(e))
raise e
return redirect(url_for('.show_all'))
else:
return render_template('upload.html', form=form)
# -*- coding: utf-8 -*-
import flask import Blueprint
from photolog.photolog_logger import Log
photolog = Blueprint('photolog', __name__,
template_folder='../templates',
static_folder='../static')
Log.info('static folder: %s' % photolog.static_folder)
Log.info('template folder: %s' % photolog.template_folder)
def upload_photo():
""" Form으로 파일과 변수들을 DB에 저장하는 함수. """
form = PhotoUploadForm(request.form)
# HTTP POST로 요청이 오면 사용자 정보를 등록
if form.validate():
#: Session에 저장된 사용자 정보를 셋팅
user_id = session['user_info'].id
username = session['user_info'].username
#: Form으로 넘어온 변수들의 값을 셋팅함
tag = form.tag.data
comment = form.comment.data
lat = form.lat.data
lng = form.lng.data
upload_date = datetime.today()
try:
#: Exif에서 전달받은 data 형식을 파이썬 date 객체로 변환
taken_date = datetime.strptime(form.taken_date.data,
"%Y:%m:%d %H:%M:%S")
except:
#: date 포맷 예외 발생: exif가 없거나,
#: 사진찍은 시간이 없는 경우에는 현재시간으로 대체
taken_date = datetime.today()
#: 업로드되는 파일정보 값들을 셋팅한다.
upload_photo = request.files['photo']
filename = None
filesize = 0
filename_orig = upload_photo.filename
try:
#: 파일 확장자 검사 : 현재 jpg, jpeg만 가능
if upload_photo and __allowed_file(upload_photo.filename):
ext = (upload_photo.filename).rsplit('.', 1)[1]
#: 업로드 폴더 위치는 얻는다.
upload_folder = \
os.path.join(current_app.root_path,
current_app.config['UPLOAD_FOLDER'])
#: 유일하고 안전한 파일명을 얻는다.
filename = \
secure_filename(username +
'_' +
unicode(uuid.uuid4()) +
"." +
ext)
upload_photo.save(os.path.join(upload_folder, filename))
filesize = \
os.stat(upload_folder + filename).st_size
#: 썸네일을 만든다.
make_thumbnails(filename)
else:
raise Exception("File upload error : illegal file.")
except Exception as e:
Log.error(str(e))
raise e
try:
#: 사진에 대한 정보 DB에 저장
photo = Photo(user_id, tag, comment, filename_orig, filename,
filesize, lat, lng, upload_date, taken_date)
dao.add(photo)
dao.commit()
except Exception as e:
dao.rollback()
Log.error("Upload DB error : " + str(e))
raise e
return redirect(url_for('.show_all'))
else:
return render_template('upload.html', form=form)
u"""blue_print?."""
# -*- coding: utf-8 -*-
from flask import Blueprint
from photolog.photolog_logger import Log
photolog = Blueprint("photolog", __name__,
template_folder="../templates", static_folder="../static")
Log.info("static folder : %s" % photolog.static_folder)
Log.info("template folder : %s" % photolog.template_folder)