PyAutomationIO 0.0.0__py3-none-any.whl

automation/modules/events/resources/logs.py

@@ -0,0 +1,109 @@
+import pytz
+from datetime import datetime, timedelta
+from flask_restx import Namespace, Resource, fields
+from .... import PyAutomation
+from ....extensions.api import api
+from ....extensions import _api as Api
+from .... import _TIMEZONE, TIMEZONE
+
+ns = Namespace('Operation Logs', description='Operation Logs')
+app = PyAutomation()
+
+
+logs_filter_model = api.model("logs_filter_model",{
+    'usernames': fields.List(fields.String(), required=False),
+    'alarm_names': fields.List(fields.String(), required=False),
+    'event_ids': fields.List(fields.Integer(), required=False),
+    'classification': fields.String(required=False),
+    'message': fields.String(required=False),
+    'description': fields.String(required=False),
+    'greater_than_timestamp': fields.DateTime(required=False, default=datetime.now(pytz.utc).astimezone(TIMEZONE) - timedelta(minutes=30), description=f'Greater than timestamp - DateTime Format: {app.cvt.DATETIME_FORMAT}'),
+    'less_than_timestamp': fields.DateTime(required=False, default=datetime.now(pytz.utc).astimezone(TIMEZONE), description=f'Less than timestamp - DateTime Format: {app.cvt.DATETIME_FORMAT}',),
+    'timezone': fields.String(required=False, default=_TIMEZONE)
+})
+
+logs_model = api.model("logs_model",{
+    'message': fields.String(required=True, description="Log message"),
+    'alarm_summary_id': fields.Integer(required=False, description="Alarm summary id comment"),
+    'event_id': fields.Integer(required=False, description="Event id comment"),
+    'description': fields.String(required=False, description="Log description")
+})
+
+@ns.route('/add')
+class AddLogsByResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    @ns.expect(logs_model)
+    def post(self):
+        r"""
+        Create Log
+        """
+        user = Api.get_current_user()
+        api.payload.update({
+            "user": user
+        })
+        if "event_id" in api.payload:
+            api.payload.update({
+                "classification": "Event"
+            })
+        elif "alarm_summary_id" in api.payload:
+            api.payload.update({
+                "classification": "Alarm"
+            })
+        else:
+            api.payload.update({
+                "classification": "General"
+            })
+
+        log, message = app.create_log(**api.payload)
+        if log:
+            
+            return log.serialize(), 200
+        
+        return message, 400
+
+    
+@ns.route('/filter_by')
+class LogsFilterByResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    @ns.expect(logs_filter_model)
+    def post(self):
+        r"""
+        Logs Filter By
+        """
+        timezone = _TIMEZONE
+        if "timezone" in api.payload:
+
+            timezone = api.payload["timezone"]
+
+        if timezone not in pytz.all_timezones:
+
+            return f"Invalid Timezone", 400
+        
+        separator = '.'
+        if 'greater_than_timestamp' in api.payload:
+            
+            greater_than_timestamp = api.payload['greater_than_timestamp']
+            api.payload['greater_than_timestamp'] = greater_than_timestamp.replace("T", " ").split(separator, 1)[0] + '.00'
+        
+        if "less_than_timestamp" in api.payload:
+
+            less_than_timestamp = api.payload['less_than_timestamp']
+            api.payload['less_than_timestamp'] = less_than_timestamp.replace("T", " ").split(separator, 1)[0] + '.00'
+        return app.filter_logs_by(**api.payload), 200
+    
+
+@ns.route('/lasts/<lasts>')
+class LastsEventsResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def get(self, lasts:int=10):
+        r"""
+        Get lasts events
+        """
+        
+        return app.get_lasts_logs(lasts=int(lasts)), 200

automation/modules/tags/resources/__init__.py

@@ -0,0 +1,8 @@
+from ....extensions.api import api
+
+
+def init_app():
+
+    from .tags import ns as ns_tags
+
+    api.add_namespace(ns_tags, path="/tags")

automation/modules/tags/resources/tags.py

@@ -0,0 +1,201 @@
+import pytz
+from datetime import datetime, timedelta
+from flask_restx import Namespace, Resource, fields, reqparse
+from .... import PyAutomation
+from ....extensions.api import api
+from ....extensions import _api as Api
+from .... import _TIMEZONE, TIMEZONE
+
+ns = Namespace('Tags', description='Tags')
+app = PyAutomation()
+
+query_trends_model = api.model("query_trends_model",{
+    'tags':  fields.List(fields.String(), required=True),
+    'greater_than_timestamp': fields.DateTime(required=True, default=datetime.now(pytz.utc).astimezone(TIMEZONE) - timedelta(minutes=30), description='Greater than DateTime'),
+    'less_than_timestamp': fields.DateTime(required=True, default=datetime.now(pytz.utc).astimezone(TIMEZONE), description='Less than DateTime'),
+    'timezone': fields.String(required=True, default=_TIMEZONE)
+})
+
+query_table_model = api.model("query_table_model",{
+    'tags':  fields.List(fields.String(), required=True),
+    'greater_than_timestamp': fields.DateTime(required=True, default=datetime.now(pytz.utc).astimezone(TIMEZONE) - timedelta(minutes=30), description='Greater than DateTime'),
+    'less_than_timestamp': fields.DateTime(required=True, default=datetime.now(pytz.utc).astimezone(TIMEZONE), description='Less than DateTime'),
+    'timezone': fields.String(required=True, default=_TIMEZONE),
+    'page': fields.Integer(required=False, default=1, description='Page number'),
+    'limit': fields.Integer(required=False, default=20, description='Items per page')
+})
+
+write_value_model = api.model("write_value_model", {
+    'tag_name': fields.String(required=True, description='Nombre del tag'),
+    'value': fields.Raw(required=True, description='Valor a escribir (float, int, bool, str)')
+})
+
+
+@ns.route('/')
+class TagsCollection(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def get(self):
+        """
+        Get Tags
+        """
+        return app.get_tags(), 200
+
+@ns.route('/names')
+class TagsNamesCollection(Resource):
+
+    parser = reqparse.RequestParser()
+    parser.add_argument('names', type=str, action='append', location='args', help='Tags names to get')
+
+    @api.doc(security='apikey', parser=parser)
+    @Api.token_required(auth=True)
+    def get(self):
+        """
+        Get Tags Names
+        """
+        args = self.parser.parse_args()
+        names = args.get('names')
+        return app.get_tags_by_names(names=names or []), 200
+    
+@ns.route('/query_trends')
+class QueryTrendsResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    @ns.expect(query_trends_model)
+    def post(self):
+        """
+        Query tag value filtering by timestamp
+
+        Authorized Roles: {0}
+        """
+        timezone = _TIMEZONE
+        tags = api.payload['tags']
+        if "timezone" in api.payload:
+
+            timezone = api.payload["timezone"]
+
+        if timezone not in pytz.all_timezones:
+
+            return f"Invalid Timezone", 400
+        
+        for tag in tags:
+
+            if not app.get_tag_by_name(name=tag):
+
+                return f"{tag} not exist into db", 404
+        
+        separator = '.'
+        greater_than_timestamp = api.payload['greater_than_timestamp']
+        start = greater_than_timestamp.replace("T", " ").split(separator, 1)[0] + '.00'
+        less_than_timestamp = api.payload['less_than_timestamp']
+        stop = less_than_timestamp.replace("T", " ").split(separator, 1)[0] + '.00'
+        result = app.get_trends(start, stop, timezone, *tags)
+        
+        return result, 200
+
+@ns.route('/query_table')
+class QueryTableResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    @ns.expect(query_table_model)
+    def post(self):
+        """
+        Query tag values in table format with pagination
+
+        Authorized Roles: {0}
+        """
+        timezone = _TIMEZONE
+        tags = api.payload['tags']
+        page = api.payload.get('page', 1)
+        limit = api.payload.get('limit', 20)
+
+        if "timezone" in api.payload:
+            timezone = api.payload["timezone"]
+
+        if timezone not in pytz.all_timezones:
+            return f"Invalid Timezone", 400
+        
+        for tag in tags:
+            if not app.get_tag_by_name(name=tag):
+                return f"{tag} not exist into db", 404
+        
+        separator = '.'
+        greater_than_timestamp = api.payload['greater_than_timestamp']
+        # Ensure timestamp format is consistent
+        start = greater_than_timestamp.replace("T", " ").split(separator, 1)[0] + '.00'
+        
+        less_than_timestamp = api.payload['less_than_timestamp']
+        stop = less_than_timestamp.replace("T", " ").split(separator, 1)[0] + '.00'
+        
+        result = app.get_tags_tables(start, stop, timezone, tags, page, limit)
+        
+        return result, 200
+    
+@ns.route('/write_value')
+class WriteValueResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    @ns.expect(write_value_model)
+    def post(self):
+        """
+        Escribe un valor a un tag en CVT y en el servidor OPC UA si está configurado
+        
+        Authorized Roles: {0}
+        """
+        tag_name = api.payload['tag_name']
+        value = api.payload['value']
+        
+        # Buscar el tag en CVT
+        tag = app.cvt.get_tag_by_name(name=tag_name)
+        if not tag:
+            return {'message': f'Tag {tag_name} no existe', 'success': False}, 404
+        
+        # Escribir en CVT
+        try:
+            timestamp = datetime.now(pytz.utc).astimezone(TIMEZONE)
+            app.cvt.set_value(id=tag.id, value=value, timestamp=timestamp)
+        except Exception as err:
+            return {
+                'message': f'Error escribiendo en CVT: {str(err)}',
+                'tag': tag_name,
+                'success': False
+            }, 500
+        
+        # Si tiene node_namespace, escribir en OPC UA Server usando el método de core
+        opcua_result = None
+        opcua_status = None
+        if tag.node_namespace and tag.opcua_address:
+            opcua_result, opcua_status = app.write_opcua_value(
+                opcua_address=tag.opcua_address,
+                node_namespace=tag.node_namespace,
+                value=value
+            )
+        
+        # Resultado consolidado
+        result = {
+            'message': 'Valor escrito en CVT' + (' y OPC UA' if opcua_status == 200 else ''),
+            'tag': tag_name,
+            'value': value,
+            'cvt_success': True,
+            'opcua_success': opcua_status == 200 if opcua_status else None,
+            'opcua_detail': opcua_result if opcua_result else None
+        }
+        
+        # Status: 200 si CVT OK, aunque OPC UA falle (parcial success)
+        final_status = 200 if opcua_status in (200, None) else 207  # 207 = Multi-Status
+        return result, final_status
+
+@ns.route('/timezones')
+class TimezonesCollection(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def get(self):
+        """
+        Get Available Timezones
+        """
+        return pytz.all_timezones, 200

automation/modules/users/__init__.py

@@ -0,0 +1,2 @@
+from .roles import Roles, Role
+from .users import Users

automation/modules/users/resources/__init__.py

@@ -0,0 +1,10 @@
+from ....extensions.api import api
+
+
+def init_app():
+
+    from .users import ns as ns_users
+    from .roles import ns as ns_roles
+
+    api.add_namespace(ns_users, path="/users")
+    api.add_namespace(ns_roles, path="/users/roles")

automation/modules/users/resources/models/__init__.py

@@ -0,0 +1,2 @@
+from .roles import create_role_parser
+from .users import login_parser, signup_parser

automation/modules/users/resources/models/roles.py

@@ -0,0 +1,5 @@
+from flask_restx import reqparse
+
+create_role_parser = reqparse.RequestParser(bundle_errors=True)
+create_role_parser.add_argument("name", type=str, required=True, help='Role name')
+create_role_parser.add_argument("level", type=int, required=True, help='Role level, 0 maximum level', default=0)

automation/modules/users/resources/models/users.py

@@ -0,0 +1,14 @@
+from flask_restx import reqparse
+
+login_parser = reqparse.RequestParser(bundle_errors=True)
+login_parser.add_argument("username", type=str, required=False, help='Username')
+login_parser.add_argument("email", type=str, required=False, help='User email')
+login_parser.add_argument("password", type=str, required=True, help='User passqord')
+
+signup_parser = reqparse.RequestParser(bundle_errors=True)
+signup_parser.add_argument("username", type=str, required=True, help='Username')
+signup_parser.add_argument("role_name", type=str, required=True, help='Role Name')
+signup_parser.add_argument("email", type=str, required=True, help="Email address")
+signup_parser.add_argument("password", type=str, required=True, help="Password")
+signup_parser.add_argument("name", type=str, required=False, help="User's name")
+signup_parser.add_argument("lastname", type=str, required=False, help="User's lastname")

automation/modules/users/resources/roles.py

@@ -0,0 +1,38 @@
+from flask_restx import Namespace, Resource
+from .... import PyAutomation
+from ....modules.users.roles import roles
+from ....extensions.api import api
+from ....extensions import _api as Api
+from .models.roles import create_role_parser
+
+
+ns = Namespace('Roles', description='Roles')
+app = PyAutomation()
+
+@ns.route('/')
+class UsersByRoleResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def get(self):
+        """View all tecnogiros's role"""
+
+        return roles.serialize(), 200
+
+@ns.route('/add')
+class CreateRoleResource(Resource):
+    
+    @Api.validate_reqparser(reqparser=create_role_parser)
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    @ns.expect(create_role_parser)
+    def post(self):
+        """Add Role"""  
+        args = create_role_parser.parse_args()
+        role, message = app.set_role(**args)
+        
+        if role:
+
+            return role.serialize(), 200
+        
+        return message, 400

automation/modules/users/resources/users.py

@@ -0,0 +1,113 @@
+from flask import request
+from datetime import datetime
+from flask_restx import Namespace, Resource
+from .models.users import signup_parser, login_parser
+from .... import PyAutomation, TIMEZONE, _TIMEZONE
+from ....extensions.api import api
+from ....extensions import _api as Api
+from ....modules.users.users import Users as CVTUsers
+from ....dbmodels.users import Users
+
+DATETIME_FORMAT = "%m/%d/%Y, %H:%M:%S"
+ns = Namespace('Users', description='Users')
+app = PyAutomation()
+users = CVTUsers()
+
+@ns.route('/')
+class UsersResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def get(self):
+        """Get all usernames"""
+
+        return users.serialize(), 200
+
+@ns.route('/signup')
+class SignUpResource(Resource):
+    
+    @Api.validate_reqparser(reqparser=signup_parser)
+    @ns.expect(signup_parser)
+    def post(self):
+        """User signup"""
+        args = signup_parser.parse_args()
+        user, message = app.signup(**args)
+        
+        if user:
+
+            return user.serialize(), 200
+        
+        return message, 400
+
+
+@ns.route('/login')
+class LoginResource(Resource):
+
+    @Api.validate_reqparser(reqparser=login_parser)
+    @ns.expect(login_parser)
+    def post(self):
+        """User login"""
+        args = login_parser.parse_args()
+        user, message = app.login(**args)
+
+        if user:
+
+            return {
+                "apiKey": user.token,
+                "role": user.role.name,
+                "role_level": user.role.level,
+                "datetime": datetime.now(TIMEZONE).strftime(DATETIME_FORMAT),
+                "timezone": _TIMEZONE
+                }, 200
+
+        return message, 403
+    
+
+@ns.route('/credentials_are_valid')
+class VerifyCredentialsResource(Resource):
+    
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    @Api.validate_reqparser(reqparser=login_parser)
+    @ns.expect(login_parser)
+    def post(self):
+        """Verify user credentials"""
+        args = login_parser.parse_args()
+        credentials_valid, _ = users.verify_credentials(**args)
+        return credentials_valid, 200
+    
+@ns.route('/<username>')
+class UserResource(Resource):
+    
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def get(self, username):
+        """Get user information"""
+        
+        user = users.get_by_username(username=username)
+
+        if user:
+
+            return user.serialize(), 200
+
+        return f"{username} is not a valid username", 400
+
+
+@ns.route('/logout')
+class LogoutResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def post(self):
+        """User logout"""
+        if 'X-API-KEY' in request.headers:
+                            
+            token = request.headers['X-API-KEY']
+
+        elif 'Authorization' in request.headers:
+            
+            token = request.headers['Authorization'].split('Token ')[-1]
+        
+        _, message = Users.logout(token=token)
+
+        return message, 200

automation/modules/users/roles.py

@@ -0,0 +1,121 @@
+import secrets
+from ...singleton import Singleton
+
+
+class Role:
+    r"""
+    Documentation here
+    """
+
+    def __init__(self, name:str, level:int, identifier:str=None):
+        
+        _identifier = secrets.token_hex(4)
+        
+        if identifier:
+
+            _identifier = identifier
+
+        self.identifier = _identifier
+        self.name:str = name
+        self.level:int = level
+
+    def serialize(self):
+        r"""
+        Documentation here
+        """
+        return {
+            "identifier": self.identifier,
+            "name": self.name,
+            "level": self.level
+        }
+    
+
+class Roles(Singleton):
+    r"""
+    Documentation here
+    """
+
+    def __init__(self):
+
+        self.roles = dict()
+
+    def add(self, role:Role)->str:
+        r"""
+        Documentation here
+        """
+        if isinstance(role, Role):
+
+            if not self.check_role_name(name=role.name):
+
+                self.roles[role.identifier] = role
+
+                return role.identifier, f"role creation successful"
+            
+            return None, f"role {role.name} is already used"
+
+        else:
+
+            raise TypeError(f"{role} must be a Role instale")
+        
+    def get(self, id:str)->Role:
+        r"""
+        Documentation here
+        """
+        if id in self.roles:
+
+            return self.roles[id]
+        
+    def get_by_name(self, name:str)->Role:
+        r"""
+        Documentation here
+        """
+        for _, role in self.roles.items():
+
+            if name.lower()==role.name.lower():
+
+                return role
+            
+    def get_names(self)->list:
+        r"""
+        Documentation here
+        """
+        return [role.name for _, role in self.roles.items()]
+    
+    def put(self, id:str, **kwargs):
+        r"""
+        Documentation here
+        """
+        if id in self.roles:
+            role = self.roles[id]
+            fields = {key: value for key, value in kwargs.items() if key in role.serialize()}
+            self.roles[id].__dict__.update(fields)
+
+    def delete(self, id:str)->dict:
+        r"""
+        Documentation here
+        """
+        if id in self.roles:
+            
+            return self.roles.pop(id)
+        
+    def _delete_all(self):
+
+        self.roles = dict()
+    
+    def check_role_name(self, name:str):
+        r"""
+        Documentation here
+        """
+        if self.get_by_name(name=name):
+
+            return True
+        
+        return False
+    
+    def serialize(self):
+        r"""
+        Documentation here
+        """
+        return [role.serialize() for _, role in self.roles.items() if role.name.lower()!="sudo"]
+    
+roles = Roles()