def __init__(
self: object,
host: str,
port: int,
character_domain: CharacterManagementInterface,
dataset_domain: DatasetManagementInterface,
garment_domain: GarmentManagementInterface,
debug: bool = False,
) -> object:
logging.debug("FlaskApplication.__init__")
self.app = Flask(__name__)
self.api = Api(self.app)
self.host = host
self.port = port
self.debug = debug
self.character_domain = character_domain
self.dataset_domain = dataset_domain
self.garment_domain = garment_domain
# Character namespace
character_namespace = Namespace("character")
character_namespace.add_resource(
CharacterHandler,
"",
resource_class_kwargs={"domain": character_domain})
self.api.add_namespace(character_namespace,
path="/characters/<uuid:character_id>")
# Characters namespace
characters_namespace = Namespace("characters")
characters_namespace.add_resource(
CharactersHandler,
"",
resource_class_kwargs={"domain": character_domain})
self.api.add_namespace(characters_namespace, path="/characters")
# Datasets namespace
datasets_namespace = Namespace("datasets")
datasets_namespace.add_resource(
DatasetsHandler,
"",
resource_class_kwargs={"domain": dataset_domain})
self.api.add_namespace(datasets_namespace, path="/datasets")
# Garment namespace
garment_namespace = Namespace("garment")
garment_namespace.add_resource(
GarmentHandler,
"",
resource_class_kwargs={"domain": garment_domain})
self.api.add_namespace(garment_namespace,
path="/clothes/<uuid:garment_id>")
# Clothes namespace
clothes_namespace = Namespace("clothes")
clothes_namespace.add_resource(
ClothesHandler,
"",
resource_class_kwargs={"domain": garment_domain})
self.api.add_namespace(clothes_namespace, path="/clothes")
def initialize(graph):
api = Namespace('ingestor', description='Ingestor API')
api.add_resource(
Prometheus,
'/prometheus',
resource_class_args=[prometheus.AlertHandler.create(graph)])
api.add_resource(Falco,
'/falco',
resource_class_args=[falco.AlertHandler.create(graph)])
api.add_resource(
Elastalert,
'/elastalert',
resource_class_args=[elastalert.AlertHandler.create(graph)])
return api
"""get a ride(passenger)"""
response = rides.get_ride(ride_id=ride_id)
return response
class RequestRide(Resource):
"""Contain PATCH method"""
@api.expect(request_model)
@api.doc(security='apikey')
@token_required
def post(self, ride_id):
"""Request ride"""
parser = reqparse.RequestParser()
parser.add_argument('pickup_point',
required=True,
type=str,
help='Pickup_point is required',
location=['json'])
args = parser.parse_args()
pickup_point = args['pickup_point']
res = rides.request_ride(ride_id=ride_id, pickup_point=pickup_point)
return res
api.add_resource(RideList, '/rides', endpoint='ridelist')
api.add_resource(Ride, '/rides/<int:ride_id>')
api.add_resource(RequestRide, '/users/rides/<int:ride_id>/request')
all_repositories = github_repositories + bit_bucket_repositories
profile = self.aggregate_data(all_repositories)
# Retrieve user followers
followers = self.get_followers_count(username)
profile["followers"] = len(followers)
return jsonify(profile)
except Exception as e:
return jsonify({"message": "There is not network connetion"})
def get_followers_count(self, username=''):
"""
Retrieves user github followers
Parameters:
username (str): name of the user, organization or team
Returns:
followers(list): A list dict objects containing details of each
follower
"""
followers = requests.get(
'{}/{}/followers'.format(GITHUB_URL, username)).json()
return followers
api.add_resource(Profile, '/profile')
}).first()
if cur_parent_event: # if found update the deleted field of the sub_event
received_data = {'deleted': True}
result = update_sub_event(received_data, cur_parent_event,
objectid.ObjectId(event_id))
logging.debug("Edited sub_event deleted")
else:
abort(404)
elif rec_id: # if this is a sub_event of a recurring event that has not been created yet
sub_event_dummy = placeholder_recurring_creation(
rec_id, [], result, True)
sub_event_dummy['deleted'] = True
# create a sub_event with the deleted field set to true
create_sub_event(sub_event_dummy, result)
logging.debug("Deleted sub_event for the first time")
else: # if a normal event is to be deleted
received_data = request_to_dict(request)
logging.debug("Received DELETE data: %s", received_data)
result.delete()
return mongo_to_dict(result)
api.add_resource(EventApi, '/', methods=['GET', 'POST'], endpoint='event')
api.add_resource(EventApi,
'/<string:event_id>',
methods=['GET', 'PUT', 'PATCH', 'DELETE'],
endpoint='event_id')
# api.add_resource(EventApi, '/<string:event_id>/<string:rec_id>',
# methods=['GET', 'PUT', 'PATCH', 'DELETE'],
# endpoint='rec_id') # TODO: add route for string/gphycat links
if not is_localized(execution_date):
execution_date = execution_date.replace(tzinfo=timezone.utc)
except ValueError:
abort(
BAD_REQUEST_RESPONSE_CODE,
"Couldn't parse execution date: {execution_date}".format(
execution_date=api.payload[DAG_RUN_EXECUTION_DATE_KEY]
)
)
dag_id = api.payload[DAG_ID_KEY]
if check_for_dag_id(dag_id) is None:
abort(NOT_FOUND_RESPONSE_CODE, message=DAG_NOT_FOUND_MESSAGE)
try:
dr = trigger_dag(
dag_id=dag_id,
execution_date=execution_date
)
response_data = _process_dag_run_to_response_object(dr)
return Response(
json.dumps(response_data),
status=POST_RESPONSE_SUCCESS_CODE,
mimetype=JSON_MIME_TYPE
)
except DagRunAlreadyExists:
abort(CONFLICT_RESPONSE_CODE, DAG_RUN_CONFLICT_MESSAGE)
dag_runs.add_resource(PostDagRun, '')
dag_runs.add_resource(GetDagRun, '/<string:dag_run_id>')
@users_namespace.response(404, "User <user_id> does not exist")
def put(self, user_id):
"""Updates a user."""
post_data = request.get_json()
username = post_data.get("username")
email = post_data.get("email")
response_object = {}
user = get_user_by_id(user_id)
if not user:
users_namespace.abort(404, f"User {user_id} does not exist")
update_user(user, username, email)
response_object["message"] = f"{user.id} was updated!"
return response_object, 200
@users_namespace.response(200, "<user_id> was removed!")
@users_namespace.response(404, "User <user_id> does not exist")
def delete(self, user_id):
"""Updates a user."""
response_object = {}
user = get_user_by_id(user_id)
if not user:
users_namespace.abort(404, f"User {user_id} does not exist")
delete_user(user)
response_object["message"] = f"{user.email} was removed!"
return response_object, 200
users_namespace.add_resource(UsersList, "")
users_namespace.add_resource(Users, "/<int:user_id>")
from ..mine.resources.mine_type import MineTypeResource
from ..mine.resources.mine_type_detail import MineTypeDetailResource
from ..mine.resources.mine_tenure_type_code import MineTenureTypeCodeResource
from ..mine.resources.mine_disturbance_code import MineDisturbanceCodeResource
from ..mine.resources.mine_commodity_code import MineCommodityCodeResource
from ..location.resources.location import MineLocationResource
from ..status.resources.status import MineStatusResource
from ..region.resources.region import MineRegionResource
from ..tailings.resources.tailings import MineTailingsStorageFacilityResource
from ..compliance.resources.compliance import MineComplianceResource
from ..mine.resources.mine_basicinfo import MineBasicInfoResource
from app.api.mines.mine.resources.mine_verified_status import MineVerifiedStatusResource
api = Namespace('mines', description='Mine related operations')
api.add_resource(MineResource, '', '/<string:mine_no_or_guid>')
api.add_resource(MineListSearch, '/search')
api.add_resource(MineTenureTypeCodeResource, '/mine-tenure-type-codes')
api.add_resource(MineDisturbanceCodeResource, '/disturbance-codes')
api.add_resource(MineCommodityCodeResource, '/commodity-codes')
api.add_resource(MineLocationResource, '/location',
'/location/<string:mine_location_guid>')
api.add_resource(MineStatusResource, '/status',
'/status/<string:mine_status_guid>')
api.add_resource(MineRegionResource, '/region',
'/region/<string:mine_region_guid>')
api.add_resource(MineTailingsStorageFacilityResource, '/tailings',
'/tailings/<string:mine_tailings_storage_facility_guid>')
api.add_resource(MineComplianceResource, '/compliance',
'/compliance/<string:mine_no>')
api.add_resource(MineTypeResource, '/mine-types',
user_security = auth.get_current_user_security()
return user_security.is_restricted()
@requires_any_of([VIEW_ALL, MINESPACE_PROPONENT])
def delete(self):
user_security = auth.get_current_user_security()
return user_security.is_restricted()
@requires_any_of([VIEW_ALL, MINESPACE_PROPONENT])
def put(self):
user_security = auth.get_current_user_security()
return user_security.is_restricted()
api = Namespace('authtest')
api.add_resource(DummyAuthResource, '')
app_api.add_namespace(api)
@pytest.fixture(scope="function")
def setup_info(db_session):
User._test_mode = False
auth.clear_cache()
MinespaceUserFactory(email_or_username='******')
yield
User._test_mode = True
# Test no role
from flask_restplus import Namespace
from ..resources.document_manager import DocumentManagerResource
api = Namespace(
'document-manager',
description=
'Document Manager for uploading and keeping track of files and then serving them to users.'
)
api.add_resource(DocumentManagerResource, '', '/<string:document_guid>')
from flask_restplus import Namespace
from ..permit.resources.permit import PermitResource
from ..permit.resources.permit_status_code import PermitStatusCodeResource
from ..permit_amendment.resources.permit_amendment import PermitAmendmentResource
from ..permit_amendment.resources.permit_amendment_document import PermitAmendmentDocumentResource
api = Namespace('permits', description='Permit related operations')
api.add_resource(PermitResource, '', '/<string:permit_guid>')
api.add_resource(PermitStatusCodeResource, '/status-codes')
api.add_resource(PermitAmendmentResource, '/<string:permit_guid>/amendments',
'/amendments/<string:permit_amendment_guid>',
'/<string:permit_guid>/amendments/<string:permit_amendment_guid>')
api.add_resource(
PermitAmendmentDocumentResource,
'/amendments/documents',
'/amendments/documents/<string:document_guid>',
'/amendments/<string:permit_amendment_guid>/documents',
'/amendments/<string:permit_amendment_guid>/documents/<string:document_guid>',
'/<string:permit_guid>/amendments/<string:permit_amendment_guid>/documents/<string:document_guid>',
'/<string:permit_guid>/amendments/<string:permit_amendment_guid>/documents',
)
# services/src/api/app.py
from flask_restplus import Namespace, Resource
app_namespace = Namespace("app")
class App(Resource):
def get(self):
return {"status": "success", "message": "app started"}
app_namespace.add_resource(App, "")
from flask_restplus import Namespace
from app.speedtest.views import (SimpleList, PaginatedList, Aggregation, Count,
SelectList, Create, Update, Save,
HeavyCodeList)
api = Namespace('speedtest', description='speedtest related operations')
api.add_resource(SimpleList, '/simple')
api.add_resource(PaginatedList, '/paginated')
api.add_resource(Aggregation, '/aggregation')
api.add_resource(Count, '/count')
api.add_resource(SelectList, '/select')
api.add_resource(Create, '/create')
api.add_resource(Save, '/save')
api.add_resource(Update, '/update')
api.add_resource(HeavyCodeList, '/algo')
# /aggregation/
from flask_restplus import Namespace
from ..party.resources.party_resource import PartyResource
from ..party.resources.sub_division_code_resource import SubDivisionCodeResource
from ..party_appt.resources.mine_party_appt_resource import MinePartyApptResource
from ..party_appt.resources.mine_party_appt_type_resource import MinePartyApptTypeResource
from ..party.resources.party_list_resource import PartyListResource
api = Namespace('parties', description='Party related operations')
api.add_resource(PartyListResource, '')
api.add_resource(PartyResource, '/<string:party_guid>')
api.add_resource(SubDivisionCodeResource, '/sub-division-codes')
api.add_resource(MinePartyApptResource, '/mines',
'/mines/<string:mine_party_appt_guid>')
api.add_resource(
MinePartyApptTypeResource, '/mines/relationship-types',
'/mines/relationship-types/<string:mine_party_appt_type_code>')
error_msg = ''
event_msg = ''
error_code = -1
if not user:
error_msg = 'user not found'
event_msg = '[Not Found] Login attempt, user not found [{0}]'.format(
data['mail'])
error_code = 404
elif not user.check_password(data['password']):
error_msg = 'Invalid password'
event_msg = '[Login attempt] invalid password for user [{0}]'.format(
data['mail'])
error_code = 401
# Check for error and save
if error_code != -1:
save_new_event(event_msg)
return {'error': error_msg}, error_code
# Generate token to send
token = generate_auth_token_for_user(user)
save_new_event('[Login] user with id [{0}] logged in'.format(user.id))
return {'user': user.serialize(), 'auth_token': token}
auth_namespace.add_resource(AuthCollection, '/login', methods=['POST'])
from app.api.mines.variances.resources.variance_uploaded_documents import MineVarianceUploadedDocumentsResource
from app.api.mines.incidents.resources.mine_incidents import MineIncidentListResource, MineIncidentResource
from app.api.mines.incidents.resources.mine_incident_document import MineIncidentDocumentListResource, MineIncidentDocumentResource
from app.api.mines.reports.resources.mine_report_document import MineReportDocumentListResource
from app.api.mines.reports.resources.mine_reports import MineReportListResource, MineReportResource
from app.api.mines.reports.resources.mine_report_definition import MineReportDefinitionListResource
from app.api.mines.reports.resources.mine_report_comment import MineReportCommentResource, MineReportCommentListResource
from app.api.mines.permits.permit.resources.permit import PermitResource, PermitListResource
from app.api.mines.permits.permit.resources.permit_status_code import PermitStatusCodeResource
from app.api.mines.permits.permit_amendment.resources.permit_amendment import PermitAmendmentResource, PermitAmendmentListResource
from app.api.mines.permits.permit_amendment.resources.permit_amendment_document import PermitAmendmentDocumentListResource, PermitAmendmentDocumentResource
from app.api.mines.now_submissions.resources.application_resource import MineApplicationResource
api = Namespace('mines', description='Mine related operations')
api.add_resource(MineResource, '/<string:mine_no_or_guid>')
api.add_resource(MineListResource, '')
api.add_resource(MineMapResource, '/map-list')
api.add_resource(MineListSearch, '/search')
api.add_resource(MineTenureTypeCodeResource, '/mine-tenure-type-codes')
api.add_resource(MineDisturbanceCodeResource, '/disturbance-codes')
api.add_resource(MineCommodityCodeResource, '/commodity-codes')
api.add_resource(MineStatusResource, '/status/<string:mine_status_guid>')
api.add_resource(MineStatusListResource, '/status')
api.add_resource(MineRegionResource, '/region')
api.add_resource(MineTailingsStorageFacilityListResource,
'/<string:mine_guid>/tailings')
api.add_resource(MineDocumentListResource, '/<string:mine_guid>/documents')
def delete(self, pk):
ticket = Ticket.query.get_or_404(pk)
return ticket.delete(), 202
class TicketResourceList(Resource):
method_decorators = [
roles_required(['ADMIN', 'USER', 'CLIENT']), jwt_required
]
def get(self):
if current_user.role == 'CLIENT':
return pagination.paginate(
Ticket.query.filter(
Ticket.project.has(user_id=current_user.id)), schema, True)
return pagination.paginate(Ticket, schema, True)
def post(self):
parser.parse_args(strict=True)
ticket = Ticket()
obj = schema.load(data=request.json,
instance=ticket,
session=db.session,
unknown='exclude')
obj.save()
return schema.dump(obj), 201
ns_ticket.add_resource(TicketResource, '/<int:pk>', endpoint='ticket')
ns_ticket.add_resource(TicketResourceList, '/', endpoint='tickets')
comment.file = data.get('filename')
for team in comment.project.project_team:
rq_notify_team(
team.users, "Project Notification",
f"A new Project file has been uploaded on <a href='{request.url}'>Comment</a>"
)
return comment.save(filename=comment.file, id=comment.id), 201
# @roles_required(['ADMIN'])
# @jwt_required
def delete(self, uuid, pk):
# if current_user.role != 'ADMIN':
comment = current_user.project_comments.filter(
ProjectComment.id == pk,
ProjectComment.project.has(uuid=uuid)).first_or_404()
msg = delete_file(comment.file)
comment.file = ""
comment.save()
return msg, 202
ns_proj_comment.add_resource(ProjectCommentResource,
'/comment/<uuid>/<int:pk>',
endpoint='projects_comment')
ns_proj_comment.add_resource(ProjectCommentResourceFile,
'/comment/file/<uuid>/<int:pk>',
endpoint='projects_comment_file')
ns_proj_comment.add_resource(ProjectCommentResourceList,
'/comments/<uuid>',
endpoint='projects_comments')
# services/users/project/api/ping.py
from flask_restplus import Namespace, Resource
foo_namespace = Namespace("foo")
class Foo(Resource):
def get(self):
return {"status": "success", "message": "pong!"}
foo_namespace.add_resource(Foo, "")
if option == 'img':
profile_parser.add_argument(
'files',
required=True,
location='files',
type=werkzeug.datastructures.FileStorage)
args = profile_parser.parse_args(strict=True)
file = img_upload(args.file)
if file.get('message'):
return file, 400
current_user.img = file.get('filename')
file.get('upload').save(file.get('full_path'))
return current_user.save(filename=current_user.img), 201
return abort(404)
class MeResource(Resource):
method_decorators = [jwt_required]
@marshal_with(user_schema)
def get(self):
return current_user
ns_user.add_resource(UserResourceList, '/', endpoint='users')
ns_user.add_resource(MeResource, '/me', endpoint='me')
ns_user.add_resource(UserResource, '/<int:pk>', endpoint='user')
ns_user.add_resource(UserProfileResource,
'/profile/<string:option>',
endpoint='user_profile')
@token_required
def put(self, email):
"""modify username"""
parser = reqparse.RequestParser()
parser.add_argument('username',
required=False,
help="No username provided",
location=['json'])
parser.add_argument('password',
required=False,
help="No username provided",
location=['json'])
args = parser.parse_args(strict=True)
username = args['username']
password = args['password']
if username:
res = user.modify_username(email=email, username=args['username'])
return res
if password:
res = user.reset_password(email=email, password=password)
return res
api.add_resource(User, '/auth/user/<string:email>')
from flask_restplus import Namespace
from app.api.well.resources.well import WellListResource
api = Namespace('well', description='Well endpoints')
api.add_resource(WellListResource, '')
'Parâmetro opcional, caso queira a lista de colaboradores ativos e inativos com um cpf'
)
def get(self):
if 'cpf' in request.args:
return colaborador_service.getByCpf(request.args['cpf'])
return colaborador_service.getAll()
@colaborador_namespace.route('/<int:id>')
class ReadUpdateAndDelete(Resource):
def get(self, id):
return colaborador_service.getById(id)
@colaborador_namespace.expect(colaboradorPutFields)
def put(self, id):
return colaborador_service.update(id, request.json)
def delete(self, id):
return colaborador_service.delete(id)
@colaborador_namespace.route('/hard_delete/<int:id>')
class HardDelete(Resource):
def delete(self, id):
return colaborador_service.hard_delete(id)
colaborador_namespace.add_resource(CreateAndReadOptions)
colaborador_namespace.add_resource(ReadUpdateAndDelete)
colaborador_namespace.add_resource(HardDelete)
'pick_up_point': fields.String('pick_up_point'),
'destination': fields.String('destination')
})
class Request(Resource):
@request_api.expect(request)
def post(self, ride_id):
data = RequestParser.parser.parse_args()
new_ride = Ride_object.get_single_ride(ride_id)
if new_ride:
if Ride_object.rides[ride_id]["seats_available"] >= data[
'number_of_seats']:
Ride_object.join_request(ride_id, data['username'],
data['number_of_seats'],
data['pick_up_point'],
data['destination'])
return "Request made successfully", 201
return "This ride is only limited to {} seats".format(
Ride_object.rides[ride_id]['seats_available']), 400
return "Ride does not exists", 404
class Requests(Resource):
def get(self):
return Ride_object.requests
request_api.add_resource(Request, '/rides/<int:ride_id>/requests')
request_api.add_resource(Requests, '/requests')
method_decorators = [roles_required(['ADMIN', 'USER', 'CLIENT']), jwt_required]
def post(self, uuid, pk):
comment = TicketComment.query.filter(TicketComment.ticket.has(uuid=uuid),
TicketComment.id == pk,
TicketComment.user_id == current_user.id).first_or_404()
args = xparser.parse_args(strict=True)
data = file_upload(args.file)
if data.get('error'):
return data, 400
data.get('upload').save(data.get('full_path'))
delete_file(comment.file)
comment.file = data.get('filename')
comment.save()
return marshal(comment, ticket_comment_schema), 201
def delete(self, uuid, pk):
comment = TicketComment.query.filter(TicketComment.ticket.has(uuid=uuid),
TicketComment.id == pk,
TicketComment.user_id == current_user.id).first_or_404()
data = delete_file(comment.file)
if data.get('message'):
return data, 400
return data
ns_ticket_comments.add_resource(TicketCommentResource, '/comment/<uuid>/<pk>', endpoint='ticket_comment')
ns_ticket_comments.add_resource(TicketCommentResourceList, '/comments/<uuid>', endpoint='ticket_comments')
ns_ticket_comments.add_resource(TicketCommentResourceFile, '/comment/file/<uuid>/<int:pk>',
endpoint='ticket_comment_file')
from flask_restplus import Namespace
from ..party.resources.party_resource import PartyResource
from ..party.resources.sub_division_code_resource import SubDivisionCodeResource
from ..party_appt.resources.mine_party_appt_resource import MinePartyApptResource
from ..party_appt.resources.mine_party_appt_admin_resource import MinePartyApptAdminResource
from ..party_appt.resources.mine_party_appt_type_resource import MinePartyApptTypeResource
from ..party.resources.party_advance_search_resource import PartyAdvancedSearchResource
api = Namespace('parties', description='Party related operations')
api.add_resource(PartyResource, '', '/<string:party_guid>')
api.add_resource(SubDivisionCodeResource, '/sub-division-codes')
api.add_resource(MinePartyApptResource, '/mines',
'/mines/<string:mine_party_appt_guid>')
api.add_resource(
MinePartyApptTypeResource, '/mines/relationship-types',
'/mines/relationship-types/<string:mine_party_appt_type_code>')
api.add_resource(MinePartyApptAdminResource, '/mines/manager-history/csv')
api.add_resource(PartyAdvancedSearchResource, '/search')
from flask_restplus import Namespace
from ..resources.metabase import MetabaseDashboardResource
api = Namespace('reporting', description='Authenticated reports')
api.add_resource(MetabaseDashboardResource, '/dashboard/<int:id>')
return notification.save(**args), 201
class UserNotificationResource(Resource):
method_decorators = [
roles_required(['CLIENT', 'ADMIN', 'USER', 'CLIENT']), jwt_required
]
def get(self):
return pagination.paginate(current_user.notifications,
notification_schema)
def put(self):
xparser = RequestParser(trim=True, bundle_errors=True)
xparser.add_argument('id', type=int, location='json')
xparser.add_argument('read', type=inputs.boolean, location='json')
args = xparser.parse_args(strict=True)
notify = current_user.notifications.filter_by(
id=args.id).first_or_404()
notify.read = True
return notify.save(**args), 202
ns_notify.add_resource(NotificationResource,
'/<int:pk>',
endpoint='notification')
ns_notify.add_resource(NotificationResourceList, '/', endpoint='notifications')
ns_notify.add_resource(UserNotificationResource,
'/user',
endpoint='user_notify')
return book.trades
@book_ns.route('/book/active_bids')
class BookActiveBidsView(Resource):
@book_ns.marshal_list_with(order_model)
def get(self):
book = get_book()
# Returning a set() does not serialize properly with Flask-RESTFul
return list(book.active_bids)
@book_ns.route('/book/active_offers')
class BookActiveOffersView(Resource):
@book_ns.marshal_list_with(order_model)
def get(self):
book = get_book()
# Returning a set() does not serialize properly with Flask-RESTFul
return list(book.active_offers)
book_ns.add_resource(BookView, '/book', endpoint='book')
book_ns.add_resource(BookOrderView, '/book/orders', endpoint='book_orders')
book_ns.add_resource(BookTraderOrderView,
'/book/traders/<trader>/orders',
endpoint='book_orders_per_trader')
book_ns.add_resource(BookStatsView, '/book/stats', endpoint='book_stats')
book_ns.add_resource(BookTradeView, '/book/trades', endpoint='book_trades')
from flask_restplus import Namespace
from app.api.now_submissions.resources.application_resource import ApplicationResource
from app.api.now_submissions.resources.application_list_resource import ApplicationListResource
from app.api.now_submissions.resources.application_nda_resource import ApplicationNDAResource
from app.api.now_submissions.resources.application_nda_list_resource import ApplicationNDAListResource
from app.api.now_submissions.resources.application_document_resource import ApplicationDocumentResource, ApplicationDocumentTokenResource
from app.api.now_submissions.resources.application_status_resource import ApplicationStatusResource, ApplicationStatusListResource
api = Namespace('now-submissions',
description='NROS/VFCBC Notice of Work submission operations')
api.add_resource(ApplicationListResource, '/applications')
api.add_resource(ApplicationResource,
'/applications/<string:application_guid>')
api.add_resource(ApplicationNDAListResource, '/applications-nda')
api.add_resource(ApplicationNDAResource,
'/applications-nda/<int:application_nda_guid>')
api.add_resource(ApplicationDocumentResource,
'/applications/<string:application_guid>/document/<int:id>')
api.add_resource(
ApplicationDocumentTokenResource,
'/applications/<string:application_guid>/document/<int:id>/token')
api.add_resource(ApplicationStatusResource,
'/applications/<string:messageid>/status')
api.add_resource(ApplicationStatusListResource, '/applications/status')
