def create_app(test_config=None):
app = Flask(__name__)
app.config['JSON_AS_ASCII'] = False
CORS(app)
if test_config is None:
app.config.from_pyfile("config.py")
else:
app.config.update(test_config)
database = create_engine(app.config['DB_URL'],
encoding='utf-8',
max_overflow=0)
## Persistenace Layer
user_dao = UserDao(database)
status_dao = StatusDao(database)
## Business Layer
services = Services
services.user_service = UserService(user_dao, config)
services.status_service = StatusService(status_dao)
## 엔드포인트들을 생성
create_endpoints(app, services)
return app
def create_app(test_config=None):
app = Flask(__name__)
CORS(app)
if test_config is None:
app.config.from_pyfile("config.py")
else:
app.config.update(test_config)
database = create_engine(app.config['DB_URL'],
encoding='utf-8',
max_overflow=0)
# Persistenace Layer
user_dao = UserDao(database)
tweet_dao = TweetDao(database)
# Business Layer
s3_client = boto3.client("s3",
aws_access_key_id=app.config['S3_ACCESS_KEY'],
aws_secret_access_key=app.config['S3_SECRET_KEY'])
services = Services
services.user_service = UserService(user_dao, app.config, s3_client)
services.tweet_service = TweetService(tweet_dao)
# 엔드포인트들을 생성
create_endpoints(app, services)
return app
def create_app(test_config=None):
'''
총 3개의 layer로 이루어 짐
레이어드 패턴 (layered pattern)을 이용하였습니다.
model, service, view
'''
app = Flask(__name__)
if test_config is None:
app.config.from_pyfile("config.py")
else:
app.config.update(test_config)
database = create_engine(app.config['DB_URL'],
encoding='utf-8',
max_overflow=0)
## model
movie_dao = MovieDao(database)
## service
services = Services
services.movie_service = MovieService(movie_dao, config)
## end point 생성
create_endpoints(app, services)
return app
def create_app(test_config = None):
app = Flask(__name__)
CORS(app)
if test_config is None:
app.config.from_pyfile("config.py")
else:
app.config.update(test_config)
database =create_engine(app.config['DB_URL'], encoding='utf-8', max_overflow =0 )
## Persistence layer
user_dao = UserDao(database)
tweet_dao = TweetDao(database)
## Business layer
services =Services
services.user_service = UserService(user_dao, app.config)
services.tweet_service = TweetService(tweet_dao)
## 엔드포인트 생성
create_endpoints(app, services)
# persistence, business, presentation layer 모두 연결된 flask application 생성
return app
def create_app(test_config=None):
app = Flask(__name__)
if test_config is None:
app.config.from_pyfile('config.py')
else:
app.config.update(test_config)
database = create_engine(app.config['DB_URL'],
encoding='utf-8',
max_overflow=0)
user_dao = UserDao(database)
tweet_dao = TweetDao(database)
s3_client = boto3.client('s3',
aws_access_key_id=app.config['S3_ACCESS_KEY'],
aws_secret_access_key=app.config['S3_SECRET_KEY'])
services = Services
services.user_service = UserService(user_dao, app.config, s3_client)
services.tweet_service = TweetService(tweet_dao)
create_endpoints(app, services)
return app
def create_app(test_config=None):
app = Flask(__name__)
app.config['JSON_AS_ASCII'] = False
CORS(app)
if test_config is None:
app.config.from_pyfile("config.py")
else:
app.config.update(test_config)
product_dao = ProductDao()
seller_dao = SellerDao()
order_dao = OrderDao()
user_dao = UserDao()
coupon_dao = CouponDao()
event_dao = EventDao()
services = Services
services.product_service = ProductService(product_dao, app.config)
services.seller_service = SellerService(seller_dao, app.config)
services.order_service = OrderService(order_dao, app.config)
services.user_service = UserService(user_dao, app.config)
services.coupon_service = CouponService(coupon_dao, app.config)
services.event_service = EventService(event_dao, app.config)
create_endpoints(app, services)
return app
def create_app(test_config=None):
app = Flask(__name__)
app.debug = True
# By default, submission of cookies across domains is disabled due to the security implications.
CORS(app, resources={r'*': {'origins': '*'}})
if test_config is None:
app.config.from_pyfile("config.py")
else:
app.config.update(test_config)
database = app.config['DB']
# persistence Layer
sample_user_dao = SampleUserDao()
# business Layer
services = Services
services.sample_user_service = SampleUserService(sample_user_dao)
# presentation Layer
create_endpoints(app, services, database)
return app
def create_app(test_config=None):
app = Flask(__name__)
CORS(app)
if test_config is None:
# app.config.from_pyfile("config.py")
app.config.update({
'DB': config.db,
'DB_URL': config.db_url,
'JWT_SECRET_KEY': config.jwt_secret_key
})
else:
app.config.update(test_config)
database = create_engine(app.config['DB_URL'],
encoding='utf-8',
max_overflow=0)
user_dao = UserDao(database)
tweet_dao = TweetDao(database)
services = Services
services.user_service = UserService(user_dao, app.config)
services.tweet_service = TweetService(tweet_dao)
create_endpoints(app, services)
return app
def create_app(test_config=None):
app = Flask(__name__)
#SetUp config
if test_config is None:
app.config.from_pyfile('config.py')
else:
app.config.update(test_config)
# database engin와 연동된 session maker 생성, connection 필요시마다 session instance 생성
database = create_engine(DB_URL,
encoding='utf-8',
pool_size=10,
max_overflow=5,
poolclass=QueuePool)
Session = sessionmaker(bind=database)
session = Session()
#SetUp CORS
CORS(app)
#SetUp Persistence Layer
user_dao = UserDao()
#SetUp Business Layer
services = Services
services.user_service = UserService(user_dao)
#SetUp Presentation Layer
create_endpoints(app, services, session)
return app
def create_app():
app = Flask(__name__)
services = Services
services.team_service = TeamService()
create_endpoints(app, services)
return app
def create_app(test_config=None):
app = Flask(__name__)
CORS(app)
if test_config is None:
app.config.from_pyfile("config.py")
else:
app.config.update(test_config)
database = create_engine(app.config['DB_URL'],
encoding='utf-8',
max_overflow=0)
## Persistenace Layer
user_dao = UserDao(database)
tweet_dao = TweetDao(database)
## Business Layer
services = Services
services.user_service = UserService(user_dao, config)
services.tweet_service = TweetService(tweet_dao)
## Create Endpoints
create_endpoints(app, services)
return app
def create_app(test_config=None):
app = Flask(__name__)
CORS(app)
app.config['CORS_HEADERS'] = 'Content-Type'
if test_config is None:
app.config.from_pyfile("config.py")
else:
app.config.update(test_config)
app.config['SQLALCHEMY_DATABASE_URI'] = config.DB_URL
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db.init_app(app)
app.app_context().push()
## Persistenace Layer
user_dao = UserDAO(db)
tag_dao = TagDAO(db)
image_dao = ImageDAO(db)
model_dao = ModelDAO(db)
test_dao = testDAO(db)
model_controller = ModelController(model_dao)
print("APP실행중")
# ## Threading_Timer
print("쓰레드 실행 뒤")
## Business Layer
s3_client = boto3.client(
"s3",
aws_access_key_id = app.config['S3_ACCESS_KEY'],
aws_secret_access_key = app.config['S3_SECRET_KEY']
)
services = Services
services.user_service = UserService(user_dao, app.config)
services.tag_service = TagService(tag_dao)
services.image_service = ImageService(image_dao, app.config, s3_client, test_dao)
services.model_service = ModelService(model_controller)
## 엔드포인트들을 생성
create_endpoints(app, services)
return app
def create_app(test_config=None):
"""
Returns :
생성된 플라스크 앱 객체
Authors :
[email protected](김기욱)
[email protected](김태하)
History :
2020-10-11 : Caching 구현
2020-10-02 : ASCCI형식 False로 변경(김기욱)
2020-09-17 : 초기 생성(김기욱 김태하)
"""
app = Flask(__name__)
app.config['JSON_AS_ASCII'] = False
app.config['CACHE_TYPE'] = 'simple'
cache.init_app(app)
#SetUp CORS
CORS(app)
#SetUp config
if test_config is None:
app.config.from_pyfile('config.py')
else:
app.config.update(test_config)
#SetUp Persistence Layer
product_dao = ProductDao()
search_dao = SearchDao()
user_dao = UserDao()
question_dao = QuestionDao()
coupon_dao = CouponDao()
purchase_dao = PurchaseDao()
#SetUp Business Layer
services = Services
services.product_service = ProductService(product_dao)
services.user_service = UserService(user_dao)
services.question_service = QuestionService(question_dao)
services.coupon_service = CouponService(coupon_dao)
services.search_service = SearchService(search_dao)
services.purchase_service = PurchaseService(purchase_dao)
#SetUp Presentation Layer
create_endpoints(app, services)
return app
def create_app():
app = Flask(__name__)
app.json_encoder = CustomJSONEncoder
CORS(app, resources={r"*": {"origins": "*"}})
create_endpoints(app)
@app.errorhandler(CustomError)
def handle_errors(e):
return jsonify({'message': e.message}), e.status_code
@app.errorhandler(InvalidRequestError)
def handle_data_errors(e):
return jsonify(demo_error_formatter(e)), 400
@app.errorhandler(Exception)
def handle_exceptions(e):
traceback.print_exc()
return jsonify({'message': UNKNOWN_ERROR}), 500
return app
def create_app(test_config = None):
#import한 Flask 클래스 객체화시켜서 app에 저
app = Flask(__name__)
#CORS 문제 해결 위함
CORS(app)
if test_config is None:
app.config.from_pyfile("config.py")
else:
app.config.update(test_config)
database = create_engine(app.config['DB_URL'], encoding= 'utf-8', max_overflow = 0)
user_dao = UserDao(database)
tweet_dao = TweetDao(database)
services = Services
services.user_service = UserService(user_dao, app.config)
services.tweet_service = TweetService(tweet_dao)
create_endpoints(app, services)
return app
def create_app(test_config=None):
app = Flask(__name__)
CORS(app)
if test_config is None:
app.config.from_pyfile("config.py")
else:
app.config.update(test_config)
database = create_engine(
app.config['DB_URL'], encoding='UTF-8', max_overflow=0)
userDao = UserDao(database)
tweetDao = TweetDao(database)
service = Service()
service.tweet_service = TweetService(tweetDao)
service.user_service = UserService(userDao, app.config)
create_endpoints(app, service)
return app
def create_app(test_config=None):
app = Flask(__name__)
cors = CORS(app, resources={r"/*": {"origins": "*"}})
if test_config is None:
app.config.from_pyfile("config.py")
else:
app.config.update(test_config)
database = create_engine(app.config['DB_URL'],
encoding='utf-8',
max_overflow=0)
## Persistenace Layer
user_dao = UserDao(database)
store_dao = StoreDao(database)
category_dao = CategoryDao(database)
menu_dao = MenuDao(database)
order_dao = OrderDao(database)
## Business Layer
s3_client = boto3.client("s3",
aws_access_key_id=app.config['S3_ACCESS_KEY'],
aws_secret_access_key=app.config['S3_SECRET_KEY'],
region_name='ap-northeast-2')
services = Services
services.user_service = UserService(user_dao, app.config, s3_client)
services.store_service = StoreService(store_dao, app.config, s3_client)
services.menu_service = MenuService(menu_dao, app.config, s3_client)
services.order_service = OrderService(order_dao)
services.category_service = CategoryService(category_dao)
socket_io = SocketIO(app, cors_allowed_origins="*")
## 엔드포인트들을 생성
create_endpoints(app, services, socket_io)
return app, socket_io
def create_app(test_config = None):
app = Flask(__name__)
#SetUp CORS
CORS(app)
#SetUp config
if test_config is None:
app.config.from_pyfile('config.py')
else:
app.config.update(test_config)
#SetUp Persistence Layer
user_dao = UserDao()
#SetUp Business Layer
services = Services
services.user_service = UserService(user_dao)
#SetUp Presentation Layer
create_endpoints(app, services)
return app
import config
from flask import Flask
from sqlalchemy import create_engine
from flask_cors import CORS
from model import WestaDao
from service import WestaService
from view import create_endpoints
def create_app(test_config - None):
app = Flask(__name__)
CORS(app)
if test_config is None:
app.config.from_pyfile("config.py")
else:
app.config.update(test_config)
database = create_engine(app.config['DB_URL'], encoding = 'utf-8', max_overflow = 0)
## WestaDao Layer
westa_dao = WestaDao(database)
service = WestaService
service.westa_service = WestaService(westa_dao, app.config)
create_endpoints(app, service)
return app
def create_app(test_config=None):
app = Flask(__name__)
CORS(app)
if test_config is None:
app.config.from_pyfile("config.py")
else:
app.config.update(test_config)
database = create_engine(app.config['DB_URL'],
encoding='utf-8',
max_overflow=0)
## Persistenace Layer
user_dao = UserDao(database)
tweet_dao = TweetDao(database)
## Business Layer
services = Services
services.user_service = UserService(user_dao, config)
services.tweet_service = TweetService(tweet_dao)
## 엔드포인트들을 생성
create_endpoints(app, services)
return app
# import jwt
# import bcrypt
#
# from flask import Flask, request, jsonify, current_app, Response, g
# from flask.json import JSONEncoder
# from sqlalchemy import create_engine, text
# from datetime import datetime, timedelta
# from functools import wraps
# from flask_cors import CORS
#
#
# ## Default JSON encoder는 set를 JSON으로 변환할 수 없다.
# ## 그럼으로 커스텀 엔코더를 작성해서 set을 list로 변환하여
# ## JSON으로 변환 가능하게 해주어야 한다.
# class CustomJSONEncoder(JSONEncoder):
# def default(self, obj):
# if isinstance(obj, set):
# return list(obj)
#
# return JSONEncoder.default(self, obj)
#
#
# def get_user(user_id):
# user = current_app.database.execute(text("""
# SELECT
# id,
# name,
# email,
# profile
# FROM users
# WHERE id = :user_id
# """), {
# 'user_id': user_id
# }).fetchone()
#
# return {
# 'id': user['id'],
# 'name': user['name'],
# 'email': user['email'],
# 'profile': user['profile']
# } if user else None
#
#
# def insert_user(user):
# return current_app.database.execute(text("""
# INSERT INTO users (
# name,
# email,
# profile,
# hashed_password
# ) VALUES (
# :name,
# :email,
# :profile,
# :password
# )
# """), user).lastrowid
#
#
# def insert_tweet(user_tweet):
# return current_app.database.execute(text("""
# INSERT INTO tweets (
# user_id,
# tweet
# ) VALUES (
# :id,
# :tweet
# )
# """), user_tweet).rowcount
#
#
# def insert_follow(user_follow):
# return current_app.database.execute(text("""
# INSERT INTO users_follow_list (
# user_id,
# follow_user_id
# ) VALUES (
# :id,
# :follow
# )
# """), user_follow).rowcount
#
#
# def insert_unfollow(user_unfollow):
# return current_app.database.execute(text("""
# DELETE FROM users_follow_list
# WHERE user_id = :id
# AND follow_user_id = :unfollow
# """), user_unfollow).rowcount
#
#
# def get_timeline(user_id):
# timeline = current_app.database.execute(text("""
# SELECT
# t.user_id,
# t.tweet
# FROM tweets t
# LEFT JOIN users_follow_list ufl ON ufl.user_id = :user_id
# WHERE t.user_id = :user_id
# OR t.user_id = ufl.follow_user_id
# """), {
# 'user_id': user_id
# }).fetchall()
#
# return [{
# 'user_id': tweet['user_id'],
# 'tweet': tweet['tweet']
# } for tweet in timeline]
#
#
# def get_user_id_and_password(email):
# row = current_app.database.execute(text("""
# SELECT
# id,
# hashed_password
# FROM users
# WHERE email = :email
# """), {'email': email}).fetchone()
#
# return {
# 'id': row['id'],
# 'hashed_password': row['hashed_password']
# } if row else None
#
#
# #########################################################
# # Decorators
# #########################################################
# def login_required(f):
# @wraps(f)
# def decorated_function(*args, **kwargs):
# access_token = request.headers.get('Authorization')
# if access_token is not None:
# try:
# payload = jwt.decode(access_token, current_app.config['JWT_SECRET_KEY'], 'HS256')
# except jwt.InvalidTokenError:
# payload = None
#
# if payload is None: return Response(status=401)
#
# user_id = payload['user_id']
# g.user_id = user_id
# g.user = get_user(user_id) if user_id else None
# else:
# return Response(status=401)
#
# return f(*args, **kwargs)
#
# return decorated_function
#
#
# def create_app(test_config=None):
# app = Flask(__name__)
#
# CORS(app)
#
# app.json_encoder = CustomJSONEncoder
#
# if test_config is None:
# app.config.from_pyfile("config.py")
# else:
# app.config.update(test_config)
#
# database = create_engine(app.config['DB_URL'], encoding='utf-8', max_overflow=0)
# app.database = database
#
# @app.route("/ping", methods=['GET'])
# def ping():
# return "pong"
#
# @app.route("/sign-up", methods=['POST'])
# def sign_up():
# new_user = request.json
# new_user['password'] = bcrypt.hashpw(
# new_user['password'].encode('UTF-8'),
# bcrypt.gensalt()
# )
#
# new_user_id = insert_user(new_user)
# new_user = get_user(new_user_id)
#
# return jsonify(new_user)
#
# @app.route('/login', methods=['POST'])
# def login():
# credential = request.json
# email = credential['email']
# password = credential['password']
# user_credential = get_user_id_and_password(email)
#
# if user_credential and bcrypt.checkpw(password.encode('UTF-8'),
# user_credential['hashed_password'].encode('UTF-8')):
# user_id = user_credential['id']
# payload = {
# 'user_id': user_id,
# 'exp': datetime.utcnow() + timedelta(seconds=60 * 60 * 24)
# }
# token = jwt.encode(payload, app.config['JWT_SECRET_KEY'], 'HS256')
#
# return jsonify({
# 'user_id': user_id,
# 'access_token': token.decode('UTF-8')
# })
# else:
# return '', 401
#
# @app.route('/tweet', methods=['POST'])
# @login_required
# def tweet():
# user_tweet = request.json
# user_tweet['id'] = g.user_id
# tweet = user_tweet['tweet']
#
# if len(tweet) > 300:
# return '300자를 초과했습니다', 400
#
# insert_tweet(user_tweet)
#
# return '', 200
#
# @app.route('/follow', methods=['POST'])
# @login_required
# def follow():
# payload = request.json
# payload['id'] = g.user_id
#
# insert_follow(payload)
#
# return '', 200
#
# @app.route('/unfollow', methods=['POST'])
# @login_required
# def unfollow():
# payload = request.json
# payload['id'] = g.user_id
#
# insert_unfollow(payload)
#
# return '', 200
#
# @app.route('/timeline/<int:user_id>', methods=['GET'])
# def timeline(user_id):
# return jsonify({
# 'user_id': user_id,
# 'timeline': get_timeline(user_id)
# })
#
# @app.route('/timeline', methods=['GET'])
# @login_required
# def user_timeline():
# user_id = g.user_id
#
# return jsonify({
# 'user_id': user_id,
# 'timeline': get_timeline(user_id)
# })
#
# return app
def create_app(test_config=None):
class Services:
pass
app = Flask(__name__)
CORS(app)
app.config.from_pyfile("config.py")
# 테스트 데이터 베이스 업데이트
if test_config:
app.config.update(test_config)
database = create_engine(app.config['DB_URL'],
encoding='utf-8',
max_overflow=0)
app.database = database
# 에러 처리
app.register_error_handler(KeyError, handle_key_error)
app.register_error_handler(ValidationError, handle_validation_error)
app.register_error_handler(LoginError, handle_login_error)
## Persistenace Layer
user_dao = UserDao(database)
company_dao = CompanyDao(database)
request_dao = RequestDao(database)
car_dao = CarDao(database)
suggestion_dao = SuggestionDao(database)
## Business Layer
services = Services
services.user_service = UserService(user_dao, company_dao, config,
database)
services.company_service = CompanyService(company_dao)
services.request_service = RequestService(request_dao, database)
services.suggestion_service = SuggestionService(suggestion_dao,
request_dao, database)
## 엔드포인트들을 생성
create_endpoints(app, services)
## 채팅을 위한 socket생성
socketio = SocketIO(app, cors_allowed_origins='*')
@socketio.on('connect')
def connect():
print('Client connected')
messages = database.execute("""
SELECT *
FROM chats
""").fetchall()
messages = [dict(message) for message in messages]
for message in messages:
message['created_at'] = str(message['created_at'])
socketio.emit('message', messages)
@socketio.on('send_message')
def handle_message(message):
request_id = message['request_id']
name = message['name']
text = message['text']
try:
connection = database.connect()
trans = connection.begin()
connection.execute(
"""
INSERT INTO chats (
request_id,
name,
text
) VALUES (
%s,
%s,
%s
)
""", (request_id, name, text))
trans.commit()
except:
trans.rollback()
chat_messages = database.execute("""
SELECT *
FROM chats
""").fetchall()
messages = [dict(chat_message) for chat_message in chat_messages]
for msg in messages:
msg['created_at'] = str(msg['created_at'])
socketio.emit('message', messages)
return app
def create_app(test_config=None):
app = Flask(__name__)
app.debug = True
app.json_encoder = CustomJSONEncoder
app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024
# By default, submission of cookies across domains is disabled due to the security implications.
CORS(app, resources={r'*': {'origins': '*'}})
if test_config is None:
app.config.from_pyfile("config.py")
else:
app.config.update(test_config)
database = app.config['DB']
# persistence Layer
destination_dao = DestinationDao()
cart_item_dao = CartItemDao()
sender_dao = SenderDao()
event_dao = EventDao()
store_order_dao = StoreOrderDao()
order_dao = OrderDao()
enquiry_dao = EnquiryDao()
seller_shop_dao = SellerShopDao()
# admin2
order_detail_dao = OrderDetailDao()
seller_info_dao = SellerInfoDao()
# service
services = Services
services.user_service = UserService(app.config)
services.destination_service = DestinationService(destination_dao)
services.cart_item_service = CartItemService(cart_item_dao)
services.store_order_service = StoreOrderService(store_order_dao)
services.product_list_service = ProductListService()
services.category_list_service = CategoryListService()
services.event_list_service = EventListService()
services.sender_service = SenderService(sender_dao)
services.event_service = EventService(event_dao)
services.seller_service = SellerService(app.config)
services.bookmark_service = BookmarkService()
services.product_enquiry_list_service = ProductEnquiryService()
services.seller_shop_service = SellerShopService(seller_shop_dao)
services.seller_info_service = SellerInfoService(seller_info_dao)
#admin1
services.event_service = EventService(event_dao)
services.order_service = OrderService(order_dao)
services.order_detail_service = OrderService(order_detail_dao)
services.enquiry_service = EnquiryService(enquiry_dao)
#admin2
services.seller_service = SellerService(app.config)
services.seller_info_service = SellerInfoService(seller_info_dao)
services.product_manage_service = ProductManageService()
# presentation Layer
create_endpoints(app, services, database)
return app
