from flask import Blueprint, abort
from flask_restful import Api
from flasgger import swag_from
from app.views import BaseResource
from app.models.facility import FacilityModel
from app.models.account import CareWorkerModel
from app.docs.daughter.info import *
api = Api(Blueprint(__name__, __name__))
api.prefix = '/daughter/info'
@api.resource('/facility/<facility_code>')
class ShowParticularFacility(BaseResource):
@swag_from(DAUGHTER_SHOW_FACILITY_INFO_GET)
def get(self, facility_code):
fac_info = FacilityModel.objects(facility_code=facility_code).first()
if not fac_info:
abort(400)
def get_average_value(val):
return round(val / fac_info.evaluation_count,
1) if fac_info.evaluation_cost != 0 else 0
one_line_e = [e for e in fac_info.one_line_evaluation]
return {
from datetime import datetime
from bson import ObjectId
from flask import Blueprint, Response, request
from flask_restful import Api
from app.views.v1 import BaseResource
from app.views.v1 import admin_only
from app.models.account import StudentModel
from app.models.point import PointHistoryModel
api = Api(Blueprint('admin-student-point-api', __name__))
api.prefix = '/admin/managing'
@api.resource('/student')
class StudentManaging(BaseResource):
@admin_only
def get(self):
"""
학생 목록 조회
"""
response = [{
'id':
student.id,
'name':
student.name,
'number':
student.number,
'good_point':
from binascii import hexlify
from hashlib import pbkdf2_hmac
from uuid import UUID
from flask import Blueprint, current_app, request
from flask_jwt_extended import get_jwt_identity, jwt_refresh_token_required
from flask_restful import Api, abort
from app.views.v1 import BaseResource
from app.models.account import AdminModel
from app.models.token import AccessTokenModelV2, RefreshTokenModelV2
api = Api(Blueprint('admin-auth-api', __name__))
api.prefix = '/admin'
@api.resource('/auth')
class Auth(BaseResource):
def post(self):
"""
관리자 로그인
"""
id = request.form['id']
pw = request.form['pw']
pw = hexlify(pbkdf2_hmac(
hash_name='sha256',
password=pw.encode(),
salt=current_app.secret_key.encode(),
def register_endpoints(
app: Flask,
db: Database,
user_manager: UserManager,
project_manager: ProjectManager,
notification_manager: NotificationManager,
):
api = Api(app)
# Inject resource dependencies with the `resource_class_args` kwarg.
api.prefix = "/api"
api.add_resource(AccountResource, "/user/account")
api.add_resource(ProfileResource, "/user/profile")
api.add_resource(UserInvite, "/user/<string:uid>/invite")
api.add_resource(UserInviteList, "/user/invite/list")
api.add_resource(OtherProfile,
"/user/<string:uid>/profile",
resource_class_args=[user_manager])
api.add_resource(FavouriteProjects,
"/user/favourites",
resource_class_args=[db])
api.add_resource(ProgrammingLanguages,
"/programming_languages",
resource_class_args=[db])
api.add_resource(Auth, "/auth", resource_class_args=[user_manager])
api.add_resource(LogOut,
"/auth/logout",
resource_class_args=[user_manager])
api.add_resource(ForgotPassword,
"/forgot_password",
resource_class_args=[db])
api.add_resource(ResetPassword,
"/reset_password/<string:token>",
resource_class_args=[db])
api.add_resource(NewProject, "/project")
api.add_resource(ProjectResource,
"/project/<string:project_id>",
resource_class_args=[project_manager])
api.add_resource(ProjectJoin,
"/project/<string:project_id>/join",
resource_class_args=[project_manager])
api.add_resource(ProjectLeave,
"/project/<string:project_id>/leave",
resource_class_args=[project_manager])
api.add_resource(ProjectKick,
"/project/<string:project_id>/kick",
resource_class_args=[project_manager])
api.add_resource(ProjectList,
"/project/list",
resource_class_args=[project_manager])
api.add_resource(ProjectRequest,
"/project/<string:project_id>/request",
resource_class_args=[project_manager])
api.add_resource(ProjectRequestList,
"/project/requests",
resource_class_args=[project_manager])
api.add_resource(SearchProjects,
"/project/search",
resource_class_args=[project_manager])
api.add_resource(CourseList, "/course_list", resource_class_args=[db])
api.add_resource(UserList, "/user_list", resource_class_args=[db])
api.add_resource(NotificationResource,
"/notify",
resource_class_args=[notification_manager])
return api
from flask import Blueprint
from flask_restful import Api
blueprint = Blueprint('post', __name__)
api = Api(blueprint)
api.prefix = '/post'
from .post import ShowAllPostView, WritePostView, OnePostView
api.add_resource(ShowAllPostView, '')
api.add_resource(WritePostView, '/write')
api.add_resource(OnePostView, '/<obj_id>')
from .comment import CommentView
api.add_resource(CommentView, '/comment/<obj_id>')
from flask import Blueprint, Response, request
from flask_restful import Api
from flasgger import swag_from
from app.docs.v2.admin.post.preview import *
from app.models.account import AdminModel
from app.views.v2 import BaseResource, auth_required, json_required
from app.views.v2.admin.post import CATEGORY_MODEL_MAPPING
api = Api(Blueprint(__name__, __name__))
api.prefix = '/admin/post-preview/<category>'
@api.resource('')
class Preview(BaseResource):
@auth_required(AdminModel)
@json_required({'id': str})
@swag_from(PREVIEW_PATCH)
def patch(self, category):
"""
게시글 프리뷰 설정
"""
payload = request.json
id = payload['id']
if category.upper() not in CATEGORY_MODEL_MAPPING:
raise self.ValidationError('Invalid category')
if len(id) != 24:
return Response('', 204)
code = e.code
return jsonify(error=str(e)), code
for ex in default_exceptions:
app.register_error_handler(ex, handle_error)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
"SQLALCHEMY_DATABASE_URI")
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = os.environ.get(
"SQLALCHEMY_TRACK_MODIFICATIONS")
app.config['BUNDLE_ERRORS'] = os.environ.get("BUNDLE_ERRORS")
db = SQLAlchemy(app)
api_app = Api(app)
api_app.prefix = '/api'
from api.docs.resource import DocsResource
api_app.add_resource(DocsResource, '/docs', '/docs/<int:docs>')
if __name__ == '__main__':
app.run()
# путь к папке где лежат наши шаблоны
# FORMS_FOLDER = os.path.join(app.root_path, "forms")
# DEBUG = os.environ.get("DEBUG")
# # вовзвращает список шаблонов
# @app.route('/api/form')
# def forms():
from flask import Blueprint
from flask_restful import Api
from flasgger import swag_from
from app.docs.v2.mixed.metadata.developers import *
from app.views.v2 import BaseResource
api = Api(Blueprint(__name__, __name__))
api.prefix = '/metadata'
@api.resource('/developer-info')
class DeveloperInfo(BaseResource):
@swag_from(DEVELOPER_INFO_GET)
def get(self):
"""
개발자 정보 조회
"""
return self.unicode_safe_json_dumps({
'app': ['조성빈', '이병찬', '윤정현', '이성현'],
'server': ['김성래', '조민규', '인상민'],
'webFrontend': ['김지수', '김건', '서윤호', '김형규', '오인서', '윤효상'],
'desktop': ['김경식', '정원태', '김동현', '이종현', '류근찬'],
'design': ['윤여환', '김동규']
})
from flasgger import swag_from
from flask import Blueprint, Response, request
from flask_restful import Api
from app.docs.sample import *
from app.views import BaseResource
from app.models import db
from app.models.model import UserModel, BeforeMenstruationSymptom, SymptomData
api = Api(Blueprint('sample_module', __name__))
api.prefix = '/sample'
@api.resource('')
class Sample(BaseResource):
@swag_from(SAMPLE_GET)
def get(self):
return Response('', 200)
def post(self):
id = request.form['id']
password = request.form['password']
menstruation_period = request.form['mp']
row = UserModel(id=str(id), password=str(password), menstruation_period=int(menstruation_period),
is_rhythm_contraception=True,
is_standard_contraception=False)
db.session.add(row)
db.session.commit()
from datetime import datetime
from flask import Blueprint, Response, abort, g, request, current_app
from flask_restful import Api
from flasgger import swag_from
from app.docs.v2.student.apply.extension import *
from app.models.account import StudentModel
from app.models.apply import ExtensionApply11Model, ExtensionApply12Model
from app.views.v2 import BaseResource, auth_required, json_required
from utils.extension_meta import APPLY_START, APPLY_END_11, APPLY_END_12, MAPS
api = Api(Blueprint(__name__, __name__))
api.prefix = '/student/apply/extension'
def can_apply(end_time):
return APPLY_START < datetime.now().time() < end_time
def can_apply_11():
return can_apply(APPLY_END_11)
def can_apply_12():
return can_apply(APPLY_END_12)
def apply_extension(model, class_num, seat_num) -> bool:
if model.objects(class_=class_num, seat=seat_num):
# -*- coding: utf-8 -*-
from flask import Flask
from flask_restful import Api
from app.models import create_tables
from app.views import TestView, AlbumListView, AlbumView, ClassificationListView
app = Flask(__name__)
app.config.from_object('config')
api = Api(app)
api.prefix = '/api/v1'
api.add_resource(TestView, '/test')
api.add_resource(AlbumListView, '/album')
api.add_resource(AlbumView, '/album/<album_id>')
api.add_resource(ClassificationListView, '/classification')
if __name__ == '__main__':
create_tables()
app.run(host='0.0.0.0', port=6999, use_reloader=False)
import random
import time
from flask import Blueprint, request, abort
from flask_restful import Api, Resource
from flask_jwt_extended import jwt_required, get_jwt_identity
from models.service.market import Market_Model
from models.service.order import Orderlist_Model
from models.user.user_model import User_Model
api = Api(Blueprint(__name__, __name__))
api.prefix = '/service'
@api.resource('/reservation')
class RegisterMarket(Resource):
@jwt_required
def get(self):
res = []
order_list = Orderlist_Model.objects(
customer_id=get_jwt_identity()).all()
for order in order_list:
res.append({
"order_id":
order['order_uuid'],
"order_time":
order['order_time'],
"market_name":
import socketio
from flask import Blueprint, request, abort
from flask_restful import Api, Resource
from flask_jwt_extended import jwt_required, get_jwt_identity
from stuffs import skin
from models.mirror import MirrorModel
api = Api(Blueprint(__name__, __name__))
api.prefix = '/mirror'
@api.resource('/stuff')
class RegisterCharManagement(Resource):
@jwt_required
def get(self):
mirror = MirrorModel.objects(mirror_key=get_jwt_identity()).first()
try:
now_skin = mirror['skin']
except:
now_skin = None
return {
'name': mirror['name'],
'stuff': mirror['stuff'],
'exp': mirror['exp'],
'level': mirror['level'],
'money': mirror['money'],
'now_skin': now_skin
from flask import Blueprint, request, Response, abort
from flask_restful import Api
from werkzeug.security import generate_password_hash
from flasgger import swag_from
from app.views import BaseResource, json_required
from app.models.account import DaughterModel
from app.docs.daughter.signup import DAUGHTER_SIGNUP_POST
api = Api(Blueprint(__name__, __name__))
api.prefix = '/daughter'
@api.resource('/signup')
class DaughterSignup(BaseResource):
@swag_from(DAUGHTER_SIGNUP_POST)
@json_required({
'id': str,
'pw': str,
'phoneNumber': str,
'name': str,
'age': int,
})
def post(self):
req = request.json
id = req['id']
if DaughterModel.objects(id=id).first():
abort(409)
from flask import Blueprint, request, Response, abort, current_app
from flask_restful import Api
from flasgger import swag_from
from flask_jwt_extended import get_jwt_identity
from werkzeug.security import check_password_hash
from app.views import BaseResource, json_required, auth_required
from app.models.account import DaughterModel
from app.models.patient import *
from app.docs.daughter.my_page import *
api = Api(Blueprint(__name__, __name__))
api.prefix = '/daughter/my_page'
# @api.resource('')
# class MyPage(BaseResource):
# @auth_required(DaughterModel)
# def get(self):
# daughter = DaughterModel.objects(id=get_jwt_identity()).first()
#
# return self.unicode_safe_json_dumps({
# 'name': daughter.name
# }, 200)
@api.resource('/account_info')
class ViewAccountInfo(BaseResource):
@swag_from(DAUGHTER_VIEW_ACCOUNT_INFO_GET)
import time
from flask import Blueprint, request
from flask_restful import Api, Resource
from sqlalchemy import and_
from tenderloin.app.models.homework import HomeworkModel
from tenderloin.app.models.singlefiles import SinglefileModel
from tenderloin.app.models.user import UserModel
from tenderloin.app.services import jwt_checker, user_type_checker
api = Api(Blueprint(__name__, __name__))
api.prefix = "/tenderloin"
@api.resource("/admin/homework/personal")
class personal_homework(Resource):
def get(self):
type = user_type_checker(jwt_checker(request.headers["Authorization"][7:]))
if not (type == 1 or type == 2):
return {"message": "your not admin"}
personal_homeworks = HomeworkModel.query.filter_by(homework_type=0).all()
res = []
for personal_homework in personal_homeworks:
c_1, c_2, c_3, c_4 = [], [], [], []
from flask import Blueprint, request, Response, abort
from flask_restful import Api
from flask_jwt_extended import get_jwt_identity
from flasgger import swag_from
from app.views import BaseResource, json_required, auth_required
from app.models.account import CareWorkerModel, DaughterModel
from app.models.connect import RequestModel
from app.models.patient import PatientModel
from app.docs.careworker.patients import *
api = Api(Blueprint(__name__, __name__))
api.prefix = '/care'
@api.resource('/patients')
class ViewPatientsList(BaseResource):
@swag_from(CARE_VIEW_PATIENTS_LIST_GET)
@auth_required(CareWorkerModel)
def get(self):
c = CareWorkerModel.objects(id=get_jwt_identity()).first()
reqs = RequestModel.objects(care_worker=c)
patients = PatientModel.objects(care_worker=c)
data = {
'connectionRequests': [{
'req_id': req.req_id,
'requester_id': req.requester_id,
'r_name': req.requester_name,
try:
from secrets import token_hex
except ImportError:
from os import urandom
def token_hex(nbytes=None):
return urandom(nbytes).hex()
# This is the rest controller, it controls every query/update done trough rest (everything in the /api/* site section)
# sqlalchemy session used to make query and updates
session = db.session # type: Session
api = Api()
api.prefix = "/api"
secret_key = token_hex(32)
passw_serializer = JSONWebSignatureSerializer(secret_key)
site_image = image.ImageManager()
# ---------------- Utility methods ----------------
# Utility methods used to automate the creation and query of resources
# Every GET, POST and PUT can use an utility method that discovers which
# field to use/update, also checking foreign key constraints (that some databases
# could not check).
# These methods already handle cases such as resource not found and missing field
# and handle them accordingly (ex: source not found -> throw 404)
from flask import Response, abort, request
from flask_restful import Api
from flask_jwt_extended import create_access_token, create_refresh_token
from werkzeug.security import check_password_hash
from app.views import BaseResource, api_blueprint
from app.models.account import UserModel as User
api = Api(api_blueprint)
api.prefix = ''
@api.resource('/login')
class Login(BaseResource):
def post(self):
"""
로그인
"""
payload = request.json
id = payload['id']
pw = payload['pw']
users = User.select().where(User.id == id)
user = users[0]
if not user:
abort(401)
if not check_password_hash(user.pw_hashed, pw):
from flask import Blueprint, request, abort
from flask_restful import Api, Resource
from flask_jwt_extended import jwt_required, get_jwt_identity
from models.user.user_model import User_Model
api = Api(Blueprint(__name__, __name__))
api.prefix = '/user'
@api.resource('/point')
class PointManagement(Resource):
@jwt_required
def put(self):
change_point = request.json['point']
finder = User_Model.objects(id=get_jwt_identity()).first()
finder.update(point=finder['point'] + change_point)
return '', 201
from flask import Blueprint, Response
from flask_restful import Api
from flasgger import swag_from
from app.docs.v2.mixed.post.post import *
from app.views.v2 import BaseResource
from app.views.v2.admin.post import CATEGORY_MODEL_MAPPING
api = Api(Blueprint(__name__, __name__))
api.prefix = '/post/<category>'
@api.resource('')
class PostList(BaseResource):
@swag_from(POST_LIST_GET)
def get(self, category):
"""
게시글 목록 조회
"""
if category.upper() not in CATEGORY_MODEL_MAPPING:
raise self.ValidationError('Invalid category')
return [{
'id': str(post.id),
'writeTime': post.write_time.strftime('%Y-%m-%d'),
'author': post.author,
'title': post.title,
'pinned': post.pinned
} for post in CATEGORY_MODEL_MAPPING[category.upper()].objects]
from flask import Blueprint, Response, request
from flask_restful import Api
from flasgger import swag_from
from app.docs.v2.student.account.auth import *
from app.models.account import StudentModel
from app.models.token import AccessTokenModelV2, RefreshTokenModelV2
from app.views.v2 import BaseResource, json_required
api = Api(Blueprint(__name__, __name__))
api.prefix = '/student'
@api.resource('/auth')
class Auth(BaseResource):
@json_required({'id': str, 'password': str})
@swag_from(AUTH_POST)
def post(self):
"""
학생 로그인
"""
payload = request.json
student = StudentModel.objects(id=payload['id'], pw=self.encrypt_password(payload['password'])).first()
return ({
'accessToken': AccessTokenModelV2.create_access_token(student, request.headers['USER-AGENT']),
'refreshToken': RefreshTokenModelV2.create_refresh_token(student, request.headers['USER-AGENT'])
}, 201) if student else Response('', 401)
from uuid import UUID
from flask import Blueprint, Response, abort, request
from flask_jwt_extended import create_access_token, get_jwt_identity, jwt_refresh_token_required
from flask_restful import Api
from flasgger import swag_from
from app.docs.jwt.refresh import *
from app.models.account import TokenModel, AccessTokenModel, RefreshTokenModel
from app.views import BaseResource
api = Api(Blueprint(__name__, __name__))
api.prefix = '/jwt'
@api.resource('/refresh')
class Refresh(BaseResource):
@jwt_refresh_token_required
@swag_from(REFRESH_GET)
def get(self):
try:
token = RefreshTokenModel.objects(
identity=UUID(get_jwt_identity())).first()
if not token:
abort(401)
return {
'accessToken':
create_access_token(
TokenModel.generate_token(AccessTokenModel, token.owner,
from flask import Blueprint, Response, request
from flask_restful import Api
from app.views.v1 import BaseResource
from app.views.v1 import admin_only
from app.models.post import FAQModel, NoticeModel, RuleModel
api = Api(Blueprint('admin-preview-api', __name__))
api.prefix = '/admin/preview'
@api.resource('/faq')
class FAQPreviewManaging(BaseResource):
@admin_only
def post(self):
"""
FAQ 프리뷰 설정
"""
id = request.form.get('id')
if len(id) != 24:
return Response('', 204)
faq = FAQModel.objects(id=id).first()
if not faq:
return Response('', 204)
pinned_faq = FAQModel.objects(pinned=True).first()
if pinned_faq:
pinned_faq.update(pinned=False)
return jsonify(error=str(e)), code
for ex in default_exceptions:
app.register_error_handler(ex, handle_error)
app.config['SQLALCHEMY_DATABASE_URI'] = settings.SQLALCHEMY_DATABASE_URI
app.config[
'SQLALCHEMY_TRACK_MODIFICATIONS'] = settings.SQLALCHEMY_TRACK_MODIFICATIONS
app.config['BUNDLE_ERRORS'] = settings.BUNDLE_ERRORS
db = SQLAlchemy(app)
# this import must be after db (cyclic imports)
#from endpoints.cure.resource import errors as CureErrors
api = Api(app) #,errors=CureErrors)
api.prefix = '/api'
from endpoints.users.resource import UsersResource
from endpoints.todos.resource import TodosResource
from endpoints.bu.resource import BUResource
from endpoints.comp.resource import CompoundResource
from endpoints.cure.resource import CuredbResource
api.add_resource(UsersResource, '/users', '/users/<int:user_id>')
api.add_resource(TodosResource, '/todos', '/todos/<int:todo_id>')
api.add_resource(CompoundResource, '/compounds', '/compounds/<int:comp_id>')
api.add_resource(BUResource, '/bu', '/bu/<int:bu_id>')
api.add_resource(CuredbResource, '/cures', '/cures/<int:cure_id>')
if __name__ == '__main__':
app.run()
from flask import Blueprint, g
from flask_restful import Api
from flasgger import swag_from
from app.docs.v2.student.account.info import *
from app.models.account import StudentModel
from app.models.apply import ExtensionApply11Model, ExtensionApply12Model, GoingoutApplyModel, StayApplyModel
from app.views.v2 import BaseResource, auth_required
api = Api(Blueprint(__name__, __name__))
api.prefix = '/student/info'
@api.resource('/apply')
class ApplyInfo(BaseResource):
@swag_from(APPLY_INFO_GET)
@auth_required(StudentModel)
def get(self):
"""
학생 신청 정보 확인
"""
extension11 = ExtensionApply11Model.objects(student=g.user).first()
extension12 = ExtensionApply12Model.objects(student=g.user).first()
goingout = GoingoutApplyModel.objects(student=g.user).first()
stay = StayApplyModel.objects(student=g.user).first()
return {
'extension11': {
'classNum': extension11.class_,
'seatNum': extension11.seat
} if extension11 else None,
from flask import Blueprint, request
from flask_restful import Api, Resource
from app.views import json_required
api = Api(Blueprint('sample_api', __name__))
api.prefix = '/prefix'
@api.resource('/sample')
class Sample(Resource):
@json_required('name', 'age')
def post(self):
return request.json
from flask import Blueprint
from flask_restful import Api
account_blueprint = Blueprint('account', __name__)
api = Api(account_blueprint)
api.prefix = '/account'
from .account import ShowMyProfileView
api.add_resource(ShowMyProfileView, '/profile')
from .auth import RegisterView, LoginView, GetRefreshTokenView
api.add_resource(RegisterView, '/register')
api.add_resource(LoginView, '/login')
api.add_resource(GetRefreshTokenView, '/refresh')
from .inform import ChangePWView, ChangeNicknameView
api.add_resource(ChangePWView, '/pw')
api.add_resource(ChangeNicknameView)
from .follow import FollowView
api.add_resource(FollowView, '/follow/<nickname>')
from datetime import datetime
from slacker import Slacker
from flask import Blueprint, Response, g, request, current_app
from flask_restful import Api
from flasgger import swag_from
from app.docs.v2.student.report.bug_report import *
from app.models.account import StudentModel
from app.views.v2 import BaseResource, auth_required, json_required
api = Api(Blueprint(__name__, __name__))
api.prefix = '/student/report'
@api.resource('/bug')
class BugReport(BaseResource):
def __init__(self):
self.slack_bot = Slacker(current_app.config['SLACK_BOT_TOKEN'])
self.PLATFORM_TYPES = {
1: 'Web',
2: 'Android',
3: 'iOS'
}
super(BugReport, self).__init__()
@swag_from(BUG_REPORT_POST)
@json_required({'platform': int, 'content': str})
@auth_required(StudentModel)
from flask import Blueprint, request, Response, abort
from flask_restful import Api
from flasgger import swag_from
from app.views import BaseResource, json_required, auth_required
from app.models.account import CareWorkerModel, DaughterModel
from app.models.facility import FacilityModel
from app.docs.daughter.evaluate import *
api = Api(Blueprint(__name__, __name__))
api.prefix = '/daughter/evaluate'
@api.resource('/facility/<facility_code>')
class EvaluateMyFacility(BaseResource):
@swag_from(DAUGHTER_EVALUATE_FACILITY_PATCH)
@auth_required(DaughterModel)
@json_required({
'equipment': int,
'meal': int,
'schedule': int,
'cost': int,
'service': int,
'overall': float
})
def patch(self, facility_code):
target = FacilityModel.objects(facility_code=facility_code).first()
if not target:
