from app.services.nqueen_services import QueenService
from app.services.challenge_services import add_challenge
from app.services.challenge_services import get_challenge
from app.services.challenge_services import add_solution
from app.services.challenge_services import list_challenges
from app.services.challenge_services import list_solutions_by_challenge
from app.services.challenge_services import get_solution_by_challenge
from app.resources.serializers import solution_model_serializer
from app.resources.serializers import challenge_model_serializer
from app.resources.serializers import add_challenge_serializer
from app.resources.serializers import list_of_challenges_serializer
from app.resources.serializers import list_of_solutions_serializer
log = logging.getLogger(__name__)
ns = api.namespace("nqueen", description="API to solve N-Queens Challenge")
@ns.route("/challenges", doc={"description": "List all challenges solved"})
class ListChallenges(Resource):
@auth.login_required
@api.marshal_with(list_of_challenges_serializer)
def get(self):
return list_challenges()
@auth.login_required
@api.expect(add_challenge_serializer)
@api.marshal_with(challenge_model_serializer)
def post(self):
data = request.json
challenge_number = int(data.get("challenge_number"))
import logging
from flask_restplus import Resource
from app.restplus import api
log = logging.getLogger(__name__)
ns = api.namespace('test', description='Tests')
@ns.route('/')
class Test(Resource):
@staticmethod
def get():
response_dict = {"test": "test_string", "test_2": "test_string"}
return response_dict
from app.restplus import api
#from app.blockchain import Blockchain
from flask_restplus import Resource, marshal_with, marshal
from app.serializers import node, blockList, block, blockchain, balances
from app.parsers import registerPeer_args, transaction_arguments
from app.blockchain import Block, Blockchain, Accounts, Account
from app.node import Node
import logging
from flask import request
ns_operations = api.namespace('', description='Node operations')
@ns_operations.route('/nodeInfo')
class NodeInfo(Resource):
@api.marshal_with(node)
def get(self):
return Node.instance, 200
@ns_operations.route('/registerPeer/')
class RegisterPeer(Resource):
@api.expect(registerPeer_args)
def post(self):
args = registerPeer_args.parse_args()
Node.instance.registerPeer(args['peer'])
import logging
from flask import request, jsonify, redirect, url_for
from app.restplus import api
from flask_restplus import Resource, cors
from app.utils.serializers import email_args
from app.utils.tools import send_email
log = logging.getLogger(__name__)
ns = api.namespace('email', description='manage clients emails')
@ns.route('/')
class InboxEmail(Resource):
@api.expect(email_args)
@cors.crossdomain(origin='*')
def post(self):
'''
return 200 if en email was sent to user
'''
args = request.args
client_username = args.get('name')
client_message = args.get('message')
client_email = args.get('email')
try:
status = send_email(client_username, client_email, client_message)
response_message = "Email was sending successfully" if status else "Email wasn't sending correctly :("
from flask_restplus import Resource
from app.handlers.health_handler import HealthHandler
from app.restplus import api
from app.schemas.routes.health_schema import HealthSchema
ns = api.namespace(path="/health", name="Health", description="Check service life")
schema = HealthSchema()
@ns.route("")
@api.doc(security=None)
@api.response(code=500, description="internal_error")
@api.response(code=404, description="not_found")
class Health(Resource):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.health = HealthHandler()
@api.response(code=200, model=schema.response_health, description="success")
def get(self):
"""
Check if everything is ok with the service
"""
return self.health.verify()
from flask import request
from flask_restplus import Resource
from app.restplus import api
from app.config import db
from app.models.author import Author
from app.serializers.author import author_serializer
from app.schemas.author import AuthorSchema
ns_author = api.namespace('author')
@ns_author.route('/')
class AuthorView(Resource):
def get(self):
authors = Author.query.all()
result = AuthorSchema(many=True).dump(authors)
return result, 200
@ns_author.expect(author_serializer)
def post(self):
name = request.json['name']
author = Author(name)
db.session.add(author)
db.session.commit()
result = AuthorSchema().dump(author)
return result, 201
@ns_author.route('/<id>')
from flask_restplus import Resource, fields
from app.schemas.routes.job_schema import JobSchema, JobGetSchema
from app.schemas.models.job_schema import JobModel
from app.utils.format_response_api import Response
model = api.model(
'Job', {
'description_job': fields.String,
'maximum_date_finish': fields.DateTime,
'expected_time_in_hours_to_finish': fields.Integer(max=8),
})
schema = JobModel()
ns = api.namespace(path="/jobs",
name="Jobs",
description="Create and get jobs")
@ns.route("")
@api.doc(security=None)
@api.response(code=500, description="internal_error")
@api.response(code=404, description="not_found")
@api.response(code=400, description="bad_request")
class Job(Resource):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.job = JobHandler()
@api.expect(model)
@api.response(code=201, description="created", model=schema.response_job)