HYTOS

from app.api.controllers.ProjectController import api as project_ns

from app.api.controllers.ModelController import api as model_ns

from app.api.controllers.license_controller import api as license_ns

from app.api.controllers.license_controller import license_service

from app.api.controllers.TrainingController import api as training_ns

from app.api.controllers.RecognitionController import api as recognition_ns

api.add_namespace(project_ns, path='/projects')

api.add_namespace(model_ns, path='/models')

api.add_namespace(recognition_ns, path='/recognition')

from flask import request, Blueprint

from flask_restx import Resource

from ..models.ModelDTO import ModelDTO, api

resource_fields = ModelDTO.resource_fields

project_service = Blueprint('api', __name__, url_prefix='/models')

model_parser = api.parser()

model_parser.add_argument('project_no', type=str, required=True)

model_parser.add_argument('name', type=str, required=True)

@api.route('/list')

class ModelList(Resource):

    @api.doc('list_of_registered_model')

    @api.marshal_list_with(resource_fields, envelope='data')

    def get(self):

        """List all registered users"""

        model = ModelDTO()

        model.project_no = 'hello'

        model.name = 'open'

        models = [model.as_dict()]   # this is sample data

        return models

    @api.response(201, 'Model successfully created.')

    @api.doc('create a new model')

    @api.expect(model_parser)

    def post(self):

        """Creates a new model"""

        args = model_parser.parse_args()

        project_no = args['project_no']

        name = args['name']

        return ModelList.create_new_model_if_need(project_no, name)

    @staticmethod

    def exist(project_no: str, name: str) -> bool:

        return True

    @staticmethod

    def create_new_model_if_need(project_no: str, name: str) -> bool:

        return True

@api.route('/model')

@api.expect(model_parser)

class Model(Resource):

    @api.doc('get a model')

    @api.marshal_with(resource_fields)

    def get(self):

        """get a model given its identifier"""

        args = model_parser.parse_args()

        project_no = args['project_no']

        name = args['name']

        model = ModelDTO()

        model.project_no = project_no

        model.name = name

        return model

import os

from flask import request, Blueprint, make_response

from flask_restx import Resource

from ..models.ProjectDTO import ProjectDTO, api

resource_fields = ProjectDTO.resource_fields

project_service = Blueprint('api', __name__, url_prefix='/projects')

@api.route('/list')

class ProjectList(Resource):

    @api.doc('list_of_registered_project')

    @api.marshal_list_with(resource_fields, envelope='data')

    def get(self):

        """List all registered users"""

        project = ProjectDTO()

        project.name = 'hello'

        project.status.name = 'open'

        users = [project.as_dict(), {'no': 'hello'}]

        return users

    @api.response(201, 'User successfully created.')

    @api.doc('create a new project')

    @api.expect(resource_fields, validate=True)

    def post(self):

        """Creates a new User """

        data = request.json

        return None  # save_new_user(data=data)

@api.route('/<no>')

@api.doc(params={'no': 'The Project identifier'})

class Project(Resource):

    @api.doc('get a project')

    @api.marshal_with(resource_fields)

    def get(self, no):

        """get a project given its identifier"""

        pass

        """

        user = get_a_user(public_id)

        if not user:

            api.abort(404)

        else:

            return user

        """

        return ProjectDTO()

    @staticmethod

    def create_folder_if_need(project_no: str) -> bool:

        project_path = os.path.join(os.path.dirname(os.path.realpath(__file__)) + '\\..\\..\\symbol_training\\Data\\',

                                    project_no)

        try:

            if not os.path.isdir(project_path):

                os.mkdir(project_path)

                os.mkdir(os.path.join(project_path, 'training'))

                os.mkdir(os.path.join(project_path, 'training', 'xml'))

                os.mkdir(os.path.join(project_path, 'training', 'img'))

                os.mkdir(os.path.join(project_path, 'test'))

                os.mkdir(os.path.join(project_path, 'test', 'xml'))

                os.mkdir(os.path.join(project_path, 'test', 'img'))

                return True

        except Exception as ex:

            return False

        return False

import os

import zipfile

from flask import request, Blueprint, redirect, url_for, render_template, make_response, jsonify

from flask_restx import Namespace, Resource, reqparse

from werkzeug.datastructures import FileStorage

from .ModelController import ModelList

api = Namespace('training', description='file related operations')

upload_parser = api.parser()

upload_parser.add_argument('project_no', type=str, required=True)

upload_parser.add_argument('model_name', type=str, required=True)

upload_parser.add_argument('class_file', location='files', type=FileStorage, required=True)

upload_parser.add_argument('training_file', location='files', type=FileStorage, required=True)

training_parser = api.parser()

training_parser.add_argument('project_no', type=str, required=True)

training_parser.add_argument('model_name', type=str, required=True)

training_parser.add_argument('class_name_file', location='files', type=FileStorage, required=True)

def allowed_file(filename):

    return os.path.splitext(filename)[1].upper() == '.ZIP'

@api.route('/upload_files')

@api.expect(upload_parser)

class FileStorage(Resource):

    def post(self):

        args = upload_parser.parse_args()

        project_no = args['project_no']

        model_name = args['model_name']

        class_file = request.files['class_file']

        training_file = request.files['training_file']

        project_path = os.path.join(os.path.dirname(os.path.realpath(__file__)) + '\\..\\..\\symbol_training\\Data\\',

                                 project_no)

        try:

            if not os.path.isdir(project_path):

                os.mkdir(project_path)

                os.mkdir(os.path.join(project_path, 'training'))

                os.mkdir(os.path.join(project_path, 'training', 'xml'))

                os.mkdir(os.path.join(project_path, 'training', 'img'))

                os.mkdir(os.path.join(project_path, 'test'))

                os.mkdir(os.path.join(project_path, 'test', 'xml'))

                os.mkdir(os.path.join(project_path, 'test', 'img'))

        except FileNotFoundError:

            return make_response('File Not Found', 404)

        if ModelList.create_new_model_if_need(project_no, model_name):

            if class_file and allowed_file(class_file.filename):

                class_file.save(class_file.filename)

                with zipfile.ZipFile(class_file.filename) as zip_file:

                    zip_file.extractall(path=project_path)

            else:

                return False

            if training_file and allowed_file(training_file.filename):

                training_file.save(training_file.filename)

                with zipfile.ZipFile(training_file.filename) as zip_file:

                    zip_file.extractall(path=project_path)

            else:

                return False

            return True

        return False

@api.route('/training')

@api.expect(training_parser)

class TrainingModel(Resource):

    def post(self):

        args = training_parser.parse_args()

        project_no = args['project_no']

        model_name = args['model_name']

        class_name_file = request.files['class_name_file']

        project_path = os.path.join(os.path.dirname(os.path.realpath(__file__)) + '\\..\\..\\symbol_training\\Data\\',

                                    project_no)

        if ModelList.exist(project_no, model_name):

            if class_name_file:

                classes = class_name_file.read().decode('utf-8').splitlines()

            else:

                return False

        return jsonify({'count': 1})

# file name : license_controller.py

from flask import Flask, request, Blueprint

from flask_restx import Api, fields, marshal_with, Resource, reqparse

from ..models.LicenseDTO import LicenseDTO

api = LicenseDTO.api

_license = LicenseDTO.license

license_service = Blueprint('api', __name__, url_prefix='/api/license')

@api.route('/')

@api.doc(params={'authorization': 'authorization code', 'computer_name': 'your computer name'})

class License(Resource):

    @api.doc('generate license key')

    def get(self):

        """generate a license key with given authorization and computer name"""

        parser = reqparse.RequestParser()

        parser.add_argument('authorization', type=str, required=True, help='authorization can not be blank!')

        parser.add_argument('computer_name', type=str, required=True, help='computer name can not be blank!')

        args = parser.parse_args()

        code = self.generate_license_key(pw=args['authorization'], computer_name=args['computer_name'])

        return code

    def generate_license_key(self, pw: str, computer_name: str) -> str:

        import base64

        key = 'Image Drawing to Intelligent Drawing'

        if pw != 'admin':

            return 'Invalid Authorization'

        enc = []

        for i in range(len(computer_name)):

            key_c = key[i % len(key)]

            enc_c = (ord(computer_name[i]) + ord(key_c)) % 256

            enc.append(enc_c)

        new_key = base64.urlsafe_b64encode(bytes(enc))

        return new_key.decode('utf-8')

# coding: utf-8

"""This is license module"""

from flask_restx import Namespace, fields

class LicenseDTO:

    api = Namespace('license', description='license related operations')

    license = api.model('license', {

        'authorization': fields.String(requried=True, description='authorization'),

        'computer_name': fields.String(required=True, description='computer name'),

        'code': fields.String(description='code')

    })

from flask_restx import Namespace, fields

api = Namespace('model', description='model related operations')

class ModelDTO:

    resource_fields = api.model('model', {

        'uid': fields.String(required=True, description='project unit uid'),

        'project_no': fields.String(required=True, description='project no'),

        'name': fields.String(required=True, description='model name')

     })

    def __init__(self):

        self.uid = None

        self.project_no = None

        self.name = None

    def as_dict(self):

        obj_d = {

            'uid': self.uid,

            'project_no': self.project_no,

            'name': self.name

        }

        return obj_d

from flask_restx import Namespace, fields

api = Namespace('project', description='project related operations')

class ProjectUnitDTO:

    resource_fields = api.model('project_unit', {

        'uid': fields.String(required=True, description='project unit uid'),

        'name': fields.String(required=True, description='project unit name')

     })

    def __init__(self):

        self.uid = None

        self.name = None

    def as_dict(self):

        obj_d = {

            'uid': self.uid,

            'name': self.name,

        }

        return obj_d

class ProjectStatusDTO:

    resource_fields = api.model('status', {

        'uid': fields.String(required=True, description='project uid'),

        'name': fields.String(required=True, description='project status name')

     })

    def __init__(self):

        self.uid = None

        self.name = None

    def as_dict(self):

        obj_d = {

            'uid': self.uid,

            'name': self.name,

        }

        return obj_d

class ProjectDTO:

    resource_fields = api.model('project', {

        'no': fields.String(required=True, description='project id', default=0),

        'name': fields.String(required=True, description='project name'),

        'unit': fields.Nested(ProjectUnitDTO.resource_fields),

        'description': fields.String(description='project description'),

        'status': fields.Nested(ProjectStatusDTO.resource_fields)

    })

    def __init__(self):

        self.no = None

        self.name = None

        self.unit = ProjectUnitDTO()

        self.description = None

        self.status = ProjectStatusDTO()

    def as_dict(self):

        obj_d = {

            'no': self.no,

            'name': self.name,

            'unit': self.unit.as_dict(),

            'description': self.description,

            'status': self.status.as_dict()

        }

        return obj_d