PyAutomationIO 0.0.0__py3-none-any.whl

automation/dbmodels/events.py

@@ -0,0 +1,153 @@
+import pytz
+from peewee import CharField, TimestampField, ForeignKeyField, IntegerField, fn
+from ..dbmodels.core import BaseModel
+from datetime import datetime
+from .users import Users
+from ..modules.users.users import User
+
+DATETIME_FORMAT = "%m/%d/%Y, %H:%M:%S.%f"
+
+
+class Events(BaseModel):
+    
+    timestamp = TimestampField(utc=True)
+    message = CharField(max_length=256)
+    description = CharField(max_length=256, null=True)
+    classification = CharField(max_length=128, null=True)
+    priority = IntegerField(null=True)
+    criticity = IntegerField(null=True)
+    user = ForeignKeyField(Users, backref='events')
+
+    @classmethod
+    def create(
+        cls, 
+        message:str, 
+        user:User, 
+        description:str=None, 
+        classification:str=None,
+        priority:int=None,
+        criticity:int=None,
+        timestamp:datetime=None
+        )->tuple:
+
+        if not isinstance(user, User):
+
+            return None, f"User {user} - {type(user)} must be an User Object"
+        
+        user = Users.read_by_username(username=user.username) 
+
+        if not timestamp:
+
+            timestamp = datetime.now(pytz.UTC)
+        
+        if not isinstance(timestamp, datetime):
+
+            return None, f"Timestamp must be a datetime Object"
+
+        query = cls(
+            message=message,
+            user=user,
+            description=description,
+            classification=classification,
+            priority=priority,
+            criticity=criticity,
+            timestamp=timestamp
+        )
+        query.save()
+
+        return query, f"Event creation successful"
+    
+    @classmethod
+    def read_lasts(cls, lasts:int=1):
+        r"""
+        Documentation here
+        """
+        events = cls.select().order_by(cls.id.desc()).limit(lasts)
+
+        return [event.serialize() for event in events]
+    
+    @classmethod
+    def filter_by(
+        cls, 
+        usernames:list[str]=None,
+        priorities:list[int]=None,
+        criticities:list[int]=None,
+        greater_than_timestamp:datetime=None,
+        less_than_timestamp:datetime=None,
+        description:str="",
+        message:str="",
+        classification:str="",
+        timezone:str='UTC'):
+        r"""
+        Documentation here
+        """
+        _timezone = pytz.timezone(timezone)
+        query = cls.select()
+        
+        if usernames:
+            subquery = Users.select(Users.id).where(Users.username.in_(usernames))
+            query = query.join(Users).where(Users.id.in_(subquery))
+        
+        if priorities:
+            query = query.where(cls.priority.in_(priorities))
+            
+        if criticities:
+            query = query.where(cls.criticity.in_(criticities))
+            
+        if description:
+            query = query.where(fn.LOWER(cls.description).contains(description.lower()))
+            
+        if message:
+            query = query.where(fn.LOWER(cls.message).contains(message.lower()))
+            
+        if classification:
+            query = query.where(fn.LOWER(cls.classification).contains(classification.lower()))
+            
+        if greater_than_timestamp:
+            greater_than_timestamp = _timezone.localize(datetime.strptime(greater_than_timestamp, '%Y-%m-%d %H:%M:%S.%f')).astimezone(pytz.UTC)
+            query = query.where(cls.timestamp > greater_than_timestamp)
+            
+        if less_than_timestamp:
+            less_than_timestamp = _timezone.localize(datetime.strptime(less_than_timestamp, '%Y-%m-%d %H:%M:%S.%f')).astimezone(pytz.UTC)
+            query = query.where(cls.timestamp < less_than_timestamp)
+            
+        query = query.order_by(cls.id.desc())
+
+        if not query.exists():
+            
+            return []
+        
+        return [event.serialize() for event in query]
+    
+    @classmethod
+    def get_comments(cls, id:int):
+        r"""
+        Documentation here
+        """
+        query = cls.read(id=id)
+
+        return [comment.serialize() for comment in query.logs]
+
+    def serialize(self)-> dict:
+        from .. import TIMEZONE, MANUFACTURER, SEGMENT
+        timestamp = self.timestamp
+        if timestamp:
+
+            timestamp = timestamp.astimezone(TIMEZONE)
+            timestamp = timestamp.strftime(DATETIME_FORMAT)
+
+        return {
+            "id": self.id,
+            "timestamp": timestamp,
+            "user": self.user.serialize(),
+            "message": self.message,
+            "description": self.description,
+            "classification": self.classification,
+            "priority": self.priority,
+            "criticity": self.criticity,
+            "segment": SEGMENT,
+            "manufacturer": MANUFACTURER,
+            "has_comments": True if self.logs else False
+        }
+    
+

automation/dbmodels/logs.py

@@ -0,0 +1,155 @@
+import pytz
+from peewee import CharField, TimestampField, ForeignKeyField, fn
+from ..dbmodels.core import BaseModel
+from datetime import datetime
+from .users import Users
+from .events import Events
+from .alarms import AlarmSummary, Alarms
+from ..modules.users.users import User
+
+DATETIME_FORMAT = "%m/%d/%Y, %H:%M:%S.%f"
+
+
+class Logs(BaseModel):
+    
+    timestamp = TimestampField(utc=True)
+    message = CharField(max_length=256)
+    description = CharField(max_length=256, null=True)
+    classification = CharField(max_length=128, null=True)
+    user = ForeignKeyField(Users, backref='logs', on_delete='CASCADE')
+    alarm = ForeignKeyField(AlarmSummary, null=True, backref='logs', on_delete='CASCADE')
+    event = ForeignKeyField(Events, null=True, backref='logs', on_delete='CASCADE')
+
+    @classmethod
+    def create(
+        cls, 
+        message:str, 
+        user:User, 
+        description:str=None, 
+        classification:str=None,
+        alarm_summary_id:int=None,
+        event_id:int=None,
+        timestamp:datetime=None
+        )->tuple:
+        if not isinstance(user, User):
+
+            return None, f"User {user} - {type(user)} must be an User Object"
+        
+        _user = Users.read_by_username(username=user.username) 
+
+        if not timestamp:
+
+            timestamp = datetime.now()
+        
+        if not isinstance(timestamp, datetime):
+
+            return None, f"Timestamp must be a datetime Object"
+        
+        query = cls(
+            message=message,
+            user=_user,
+            description=description,
+            classification=classification,
+            timestamp=timestamp,
+            event=Events.get_or_none(id=event_id),
+            alarm=AlarmSummary.get_or_none(id=alarm_summary_id)
+        )
+        query.save()
+
+        return query, f"Event creation successful"
+    
+    @classmethod
+    def read_lasts(cls, lasts:int=1):
+        r"""
+        Documentation here
+        """
+        logs = cls.select().order_by(cls.id.desc()).limit(lasts)
+
+        return [log.serialize() for log in logs]
+    
+    @classmethod
+    def filter_by(
+        cls, 
+        usernames:list[str]=None,
+        alarm_names:list[str]=None,
+        event_ids:list[int]=None,
+        description:str="",
+        message:str="",
+        classification:str="",
+        greater_than_timestamp:datetime=None,
+        less_than_timestamp:datetime=None,
+        timezone:str='UTC'
+        ):
+        r"""
+        Documentation here
+        """
+        _timezone = pytz.timezone(timezone)
+        query = cls.select()
+        
+        if usernames:
+            subquery = Users.select(Users.id).where(Users.username.in_(usernames))
+            query = query.join(Users).where(Users.id.in_(subquery))
+        
+        if event_ids:
+            subquery = Events.select(Events.id).where(Events.id.in_(event_ids))
+            query = query.join(Events).where(Events.id.in_(subquery))
+        
+        if alarm_names:
+            subquery = Alarms.select(Alarms.id).where(Alarms.name.in_(alarm_names))
+            alarm_subquery = AlarmSummary.select(AlarmSummary.id).join(Alarms).where(Alarms.id.in_(subquery))
+            query = query.join(AlarmSummary).where(AlarmSummary.id.in_(alarm_subquery))
+        
+        if description:
+            query = query.where(fn.LOWER(cls.description).contains(description.lower()))
+        
+        if message:
+            query = query.where(fn.LOWER(cls.message).contains(message.lower()))
+        
+        if classification:
+            query = query.where(fn.LOWER(cls.classification).contains(classification.lower()))
+        
+        if greater_than_timestamp:
+            greater_than_timestamp = _timezone.localize(datetime.strptime(greater_than_timestamp, '%Y-%m-%d %H:%M:%S.%f')).astimezone(pytz.UTC)
+            query = query.where(cls.timestamp > greater_than_timestamp)
+        
+        if less_than_timestamp:
+            less_than_timestamp = _timezone.localize(datetime.strptime(less_than_timestamp, '%Y-%m-%d %H:%M:%S.%f')).astimezone(pytz.UTC)
+            query = query.where(cls.timestamp < less_than_timestamp)
+        
+        query = query.order_by(cls.id.desc())
+
+        if not query.exists():
+            
+            return []
+        
+        return [log.serialize() for log in query]
+
+    def serialize(self)-> dict:
+        from .. import MANUFACTURER, SEGMENT, TIMEZONE
+        timestamp = self.timestamp
+        if timestamp:
+            timestamp = pytz.UTC.localize(timestamp).astimezone(TIMEZONE)
+            timestamp = timestamp.strftime(DATETIME_FORMAT)
+
+        _event = None
+        if self.event:
+
+            _event = self.event.serialize()
+
+        _alarm = None
+        if self.alarm:
+
+            _alarm = self.alarm.serialize()
+
+        return {
+            "id": self.id,
+            "timestamp": timestamp,
+            "user": self.user.serialize(),
+            "message": self.message,
+            "description": self.description,
+            "classification": self.classification,
+            "event": _event,
+            "alarm": _alarm,
+            "segment": SEGMENT,
+            "manufacturer": MANUFACTURER
+        }

automation/dbmodels/machines.py

@@ -0,0 +1,181 @@
+from peewee import CharField, IntegerField, ForeignKeyField, FloatField
+from .core import BaseModel
+from .tags import Tags
+
+
+class Machines(BaseModel):
+    
+    identifier = CharField(unique=True)
+    name = CharField(unique=True)
+    interval = FloatField()
+    threshold = FloatField(null=True)
+    on_delay = IntegerField(null=True)
+    description = CharField(max_length=128)
+    classification = CharField(max_length=128)
+    buffer_size = IntegerField()
+    buffer_roll_type = CharField(max_length=16)
+    criticity = IntegerField()
+    priority = IntegerField()
+
+    @classmethod
+    def create(
+        cls, 
+        identifier:str,
+        name:str,
+        interval:int,
+        description:str,
+        classification:str,
+        buffer_size:int,
+        buffer_roll_type:str,
+        criticity:int,
+        priority:int,
+        threshold:float=None,
+        on_delay:int=None
+        )-> dict:
+
+        result = dict()
+        data = dict()
+
+        if not cls.name_exist(name):
+
+            query = cls(
+                identifier=identifier,
+                name=name,
+                interval=interval,
+                description=description,
+                classification=classification,
+                buffer_size=buffer_size,
+                buffer_roll_type=buffer_roll_type,
+                criticity=criticity,
+                priority=priority,
+                threshold=threshold,
+                on_delay=on_delay
+                )
+            query.save()
+            
+            message = f"Machine {name} created successfully"
+            data.update(query.serialize())
+
+            result.update(
+                {
+                    'message': message, 
+                    'data': data
+                }
+            )
+            return result
+
+        message = f"Machine {name} is already into database"
+        result.update(
+            {
+                'message': message, 
+                'data': data
+            }
+        )
+        return result
+
+    @classmethod
+    def read_by_name(cls, name:str)->bool:
+        query = cls.get_or_none(name=name)
+        
+        if query is not None:
+
+            return query
+        
+        return None
+
+    @classmethod
+    def read_config(cls):
+        r"""
+        Select all records
+
+        You can use this method to retrieve all instances matching in the database. 
+
+        This method is a shortcut that calls Model.select() with the given query.
+
+        **Parameters**
+
+        **Returns**
+
+        * **result:** (dict) --> {'message': (str), 'data': (list) row serialized}
+        """
+        return {f"{query.name}": query.serialize() for query in cls.select()}
+
+    @classmethod
+    def name_exist(cls, name:str)->bool:
+        r"""
+        Verify is a name exist into database
+
+        **Parameters**
+
+        * **name:** (str) Variable name
+
+        **Returns**
+
+        * **bool:** If True, name exist into database 
+        """
+        query = cls.get_or_none(name=name)
+        
+        if query is not None:
+
+            return True
+        
+        return False
+    
+    def get_tags(self):
+
+        return self.tags
+
+    def serialize(self)-> dict:
+        r"""
+        Serialize database record to a jsonable object
+        """
+
+        return {
+            "id": self.id,
+            "identifier": self.identifier,
+            "name": self.name,
+            "interval": self.interval,
+            "description": self.description,
+            "classification": self.classification,
+            "buffer_size": self.buffer_size,
+            "buffer_roll_type": self.buffer_roll_type,
+            "criticity": self.criticity,
+            "priority": self.priority,
+            "threshold": self.threshold,
+            "on_delay": self.on_delay
+        }
+
+
+class TagsMachines(BaseModel):
+    
+    tag = ForeignKeyField(Tags, backref="machines")
+    machine = ForeignKeyField(Machines, backref="tags")
+    default_tag_name = CharField(max_length=64, null=True)
+
+    @classmethod
+    def create(
+        cls, 
+        tag_name:str,
+        machine_name:str,
+        default_tag_name:str=None
+        )-> dict:
+
+        tag = Tags.get_or_none(name=tag_name)
+        machine = Machines.get_or_none(name=machine_name)
+
+        if not cls.get_or_none(tag=tag, machine=machine):
+
+            query = cls(
+                tag=tag,
+                machine=machine,
+                default_tag_name=default_tag_name
+                )
+            query.save()
+
+    def serialize(self):
+
+        return {
+            "machine": self.machine.serialize(),
+            "tag": self.tag.serialize(),
+            "default_tag_name": self.default_tag_name
+        }

automation/dbmodels/opcua.py

@@ -0,0 +1,81 @@
+from peewee import CharField, IntegerField
+from ..dbmodels.core import BaseModel
+
+class OPCUA(BaseModel):
+    
+    client_name = CharField(unique=True)
+    host = CharField()
+    port = IntegerField()
+
+    @classmethod
+    def create(cls, client_name:str, host:str, port:int):
+        r"""
+        You can use Model.create() to create a new model instance. This method accepts keyword arguments, where the keys correspond 
+        to the names of the model's fields. A new instance is returned and a row is added to the table.
+
+        ```python
+        >>> AlarmsType.create(name='High-High')
+        {
+            'message': (str)
+            'data': (dict) {
+                'name': 'HIGH-HIGH'
+            }
+        }
+        ```
+        
+        This will INSERT a new row into the database. The primary key will automatically be retrieved and stored on the model instance.
+
+        **Parameters**
+
+        * **name:** (str), Industrial protocol name
+
+        **Returns**
+
+        * **result:** (dict) --> {'message': (str), 'data': (dict) row serialized}
+
+        """
+
+        if not cls.client_name_exist(client_name):
+
+            query = cls(client_name=client_name, host=host, port=port)
+            query.save()
+
+            return query
+        
+    @classmethod
+    def get_by_client_name(cls, client_name:str):
+        r"""
+        Documentation here
+        """
+        return cls.get_or_none(client_name=client_name)
+    
+    @classmethod
+    def client_name_exist(cls, client_name:str):
+        r"""
+        Verify is a name exist into database
+
+        **Parameters**
+
+        * **name:** (str) Variable name
+
+        **Returns**
+
+        * **bool:** If True, name exist into database 
+        """
+        query = cls.get_or_none(client_name=client_name)
+        
+        if query is not None:
+
+            return True
+        
+        return False
+    
+    def serialize(self):
+        r"""
+        Documentation here
+        """
+        return {
+            "client_name": self.client_name,
+            "host": self.host,
+            "port": self.port
+        }