fmconsult-utils-python-sdk 2.0.0__py3-none-any.whl

fmconsult/auth/decorator.py

@@ -0,0 +1,37 @@
+import sys, logging, jwt, mongoengine, bottle
+from bottle import request, response
+from .token_manager import TokenManager
+from fmconsult.utils.configs import ConfigPropertiesHelper
+from fmconsult.database.models.application import Application
+from fmconsult.database.connection import DatabaseConnector
+
+class AuthDecorator(object):
+    def requires_auth(self, f):
+        def decorated(*args, **kwargs):
+            token = None
+            token_manager = TokenManager()
+
+            try:
+                idx_localhost = bottle.request.url.index('127.0.0.1')
+            except:
+                try:
+                    token = token_manager.get_jwt_token_from_header()
+                except AuthorizationError as reason:
+                    response.status = 401
+                    response.headers['Content-Type'] = 'application/json'
+                    return {'status': reason.code, 'message': reason.description}
+                
+                try:
+                    token_decoded = token_manager.get_jwt_credetials()
+                except jwt.ExpiredSignature:
+                    response.status = 401
+                    response.headers['Content-Type'] = 'application/json'
+                    return {'status': 'ExpiredToken', 'message': 'Token is expired'}
+                except jwt.DecodeError as message:
+                    response.status = 401
+                    response.headers['Content-Type'] = 'application/json'
+                    return {'status': 'InvalidToken', 'message': str(message)}
+            
+            return f(*args, **kwargs)
+
+        return decorated

fmconsult/auth/profile_builder.py

@@ -0,0 +1,12 @@
+import time
+from fmconsult.utils.configs import ConfigPropertiesHelper
+
+class ProfileBuilder(object):
+    def __init__(self):
+        self.cph = ConfigPropertiesHelper()
+
+    def build_profile(self, credentials):
+        return {
+            'user': credentials,
+            'exp': time.time() + float(self.cph.get_property_value('JWT', 'jwt.expireoffset'))
+        }

fmconsult/auth/token_manager.py

@@ -0,0 +1,41 @@
+import bottle, jwt
+from bottle import request
+from fmconsult.utils.configs import ConfigPropertiesHelper
+from fmconsult.exceptions.authorization import AuthorizationError
+from .profile_builder import ProfileBuilder
+
+class TokenManager(object):
+    def __init__(self):
+        self.cph = ConfigPropertiesHelper()
+
+    def get_jwt_token_from_header(self):
+        auth = bottle.request.headers.get('Authorization', None)
+        if not auth:
+            raise AuthorizationError(code='authorization_header_missing', description='Authorization header is expected')
+
+        parts = auth.split()
+
+        if parts[0].lower() != 'bearer':
+            raise AuthorizationError(code='invalid_header', description='Authorization header must start with Bearer')
+        elif len(parts) == 1:
+            raise AuthorizationError(code='invalid_header', description='Token not found')
+        elif len(parts) > 2:
+            raise AuthorizationError(code='invalid_header', description='Authorization header must be Bearer token')
+        
+        return parts[1]
+
+
+    def get_jwt_credetials(self):
+        token       = self.get_jwt_token_from_header()
+        secret_key  = self.cph.get_property_value('JWT', 'jwt.secret')
+        algorithm   = self.cph.get_property_value('JWT', 'jwt.algorithm')
+
+        return jwt.decode(token, secret_key, algorithms=[algorithm])
+
+    def get_access_token(self, credentials):
+        builder = ProfileBuilder()
+        profile     = builder.build_profile(credentials)
+        secret_key  = self.cph.get_property_value('JWT', 'jwt.secret')
+        algorithm   = self.cph.get_property_value('JWT', 'jwt.algorithm')
+
+        return jwt.encode(profile, secret_key, algorithm=algorithm)

fmconsult/database/connection.py

@@ -0,0 +1,34 @@
+import logging, mongoengine
+from fmconsult.utils.configs import ConfigPropertiesHelper
+
+class DatabaseConnector:
+  def __init__(self, db_section='MONGODB'):
+    self.cph = ConfigPropertiesHelper()
+
+    self.mongodb_environment = self.cph.get_property_value(db_section, 'mongodb.environment')
+    self.mongodb_host = self.cph.get_property_value(db_section, f'mongodb.host.{self.mongodb_environment}')
+    self.mongodb_user = self.cph.get_property_value(db_section, 'mongodb.user')
+    self.mongodb_pass = self.cph.get_property_value(db_section, 'mongodb.pass')
+    self.mongodb_name = self.cph.get_property_value(db_section, 'mongodb.database.name')
+
+  def connect(self, db_alias='default'):
+    try:
+      if self.mongodb_host == 'localhost':
+        mongoengine.connect(self.mongodb_name, alias=db_alias)
+        logging.info(f"successful connection to local database '{self.mongodb_name}'.")
+      else:
+        dbqs = f'mongodb+srv://{self.mongodb_user}:{self.mongodb_pass}@{self.mongodb_host}/{self.mongodb_name}?retryWrites=true&w=majority'
+        mongoengine.connect(host=dbqs, alias=db_alias)
+        logging.info(f"successful connection to remote database '{self.mongodb_name}' in '{self.mongodb_host}'")
+    except Exception as e:
+      error_message = str(e)
+      logging.info(f"error connecting to database: {error_message}")
+      raise e
+      
+  def disconnect(self, db_alias='default'):
+    try:
+      mongoengine.disconnect(alias=db_alias)
+      logging.info(f"disconnected from mongodb with alias {db_alias}.")
+    except Exception as e:
+      logging.error('error disconnecting from mongodb.')
+      logging.error(e)

fmconsult/database/models/application.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+import json
+from mongoengine import *
+from mongoengine.fields import StringField, ListField
+from .base import CustomBaseDocument
+
+class Application(CustomBaseDocument):
+	meta = {
+		'collection': 'applications',
+		'db_alias': 'security'
+	}
+	
+	name = StringField()
+	token = StringField()
+	client_ids = ListField(default=[])
+	api_name = StringField()
+	
+	def to_dict(self):
+		json_string = {
+			"name": self.name,
+			"token": self.token,
+			"client_ids": self.client_ids,
+			"api_name": self.api_name,
+		}
+
+		return json.dumps(json_string, default=str)

fmconsult/database/models/base.py

@@ -0,0 +1,25 @@
+from datetime import datetime
+from mongoengine.queryset import QuerySet
+from mongoengine.document import Document
+from mongoengine.fields import BooleanField, DateTimeField
+
+class CustomQuerySet(QuerySet):
+	def to_json(self):
+		return "[%s]" % (",".join([doc.to_json() for doc in self]))
+	def to_json_all(self):
+		return "[%s]" % (",".join([doc.to_json_all() for doc in self]))
+
+class CustomBaseDocument(Document):
+    meta = { 'queryset_class': CustomQuerySet, 'abstract': True }
+
+    created_at  = DateTimeField(default=datetime.now)
+    updated_at  = DateTimeField()
+    deleted_at  = DateTimeField()
+    deleted     = BooleanField(default=False)
+    active      = BooleanField(default=True)
+    inactive_at = DateTimeField()
+
+    def set_all_values(self, data):
+        for attr in data:
+            if hasattr(self, attr):
+                setattr(self, attr, data[attr])

fmconsult/database/models/city.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+import json
+from mongoengine import *
+from mongoengine.fields import StringField, EmbeddedDocumentListField
+from .base import CustomBaseDocument
+
+class City(CustomBaseDocument):
+    meta = { 'collection': 'cities' }
+
+    name = StringField()
+    code = StringField()
+    country_code = StringField()
+    state_code = StringField()
+
+    def to_dict(self):
+        json_string = {
+            'id': str(self.id),
+            'name': self.name,
+            'code': self.code,
+            'country_code': self.country_code,
+            'state_code': self.state_code,
+            'created_at': self.created_at.strftime("%Y-%m-%d %H:%M:%S"),
+            'updated_at': self.updated_at.strftime("%Y-%m-%d %H:%M:%S") if self.updated_at is not None else None,
+            'deleted_at': self.deleted_at.strftime("%Y-%m-%d %H:%M:%S") if self.deleted_at is not None else None,
+            'deleted': self.deleted
+        }
+        return json.dumps(json_string, default=str)

fmconsult/database/models/country.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+import json
+from mongoengine import *
+from mongoengine.fields import StringField, EmbeddedDocumentListField
+from .base import CustomBaseDocument
+
+class Country(CustomBaseDocument):
+    meta = { 'collection': 'countries' }
+
+    name = StringField()
+    code = StringField()
+
+    def to_dict(self):
+        json_string = {
+            'id': str(self.id),
+            'name': self.name,
+            'code': self.code,
+            'created_at': self.created_at.strftime("%Y-%m-%d %H:%M:%S"),
+            'updated_at': self.updated_at.strftime("%Y-%m-%d %H:%M:%S") if self.updated_at is not None else None,
+            'deleted_at': self.deleted_at.strftime("%Y-%m-%d %H:%M:%S") if self.deleted_at is not None else None,
+            'deleted': self.deleted
+        }
+        return json.dumps(json_string, default=str)

fmconsult/database/models/state.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+import json
+from mongoengine import *
+from mongoengine.fields import StringField, EmbeddedDocumentListField
+from .base import CustomBaseDocument
+
+class State(CustomBaseDocument):
+    meta = { 'collection': 'states' }
+
+    name = StringField()
+    code = StringField()
+    country_code = StringField()
+
+    def to_dict(self):
+        json_string = {
+            'id': str(self.id),
+            'name': self.name,
+            'code': self.code,
+            'country_code': self.country_code,
+            'created_at': self.created_at.strftime("%Y-%m-%d %H:%M:%S"),
+            'updated_at': self.updated_at.strftime("%Y-%m-%d %H:%M:%S") if self.updated_at is not None else None,
+            'deleted_at': self.deleted_at.strftime("%Y-%m-%d %H:%M:%S") if self.deleted_at is not None else None,
+            'deleted': self.deleted
+        }
+        return json.dumps(json_string, default=str)

fmconsult/decorators/auth.py

@@ -0,0 +1,116 @@
+import sys, logging
+import mongoengine
+from bottle import request, response
+from fmconsult.utils.configs import ConfigPropertiesHelper
+from fmconsult.database.models.application import Application
+from fmconsult.database.connection import DatabaseConnector
+
+class AuthDecorator(object):
+	required_headers = {
+		'x-api-token': {
+			'type': 'str'
+		}
+	}
+
+	def __init__(self, additional_required_headers=None):
+		if not additional_required_headers is None:
+			for header in additional_required_headers:
+				self.required_headers[header] = additional_required_headers[header]
+
+	def require_auth(self, func):
+		def decorated(*args, **kwargs):
+			db_connector = None
+			try:
+				logging.info('getting headers from request...')
+				for header in self.required_headers:
+					value = request.headers.get(header, None)
+
+					if not value:
+						raise Application.DoesNotExist(f"{header} not found in headers")
+				
+					self.required_headers[header]['value'] = value
+				
+				logging.info(self.required_headers)
+
+				token = self.required_headers['x-api-token']['value']
+ 
+				logging.info('iniatlizing database connector...')
+				db_connector = DatabaseConnector('API-SECURITY')
+				try:
+					logging.info('try getting connection to security database...')
+					mongoengine.get_connection(alias='security')
+				except mongoengine.ConnectionFailure:
+					logging.info('failed to connect to security database. creating new connection...')
+					db_connector.connect(db_alias='security')
+
+				cph = ConfigPropertiesHelper()
+				api_name = cph.get_property_value('SELF', 'self.api.name')
+
+				logging.info(f'find exists token: {token} from application: {api_name}')
+
+				application = None
+ 
+				try:
+					logging.info('try getting application from database...')
+					application = Application.objects.get(token=token, api_name=api_name)
+
+				except Exception as e:
+					try:
+						logging.info('try getting connection to security database again...')
+						mongoengine.get_connection(alias='security')
+					except mongoengine.ConnectionFailure:
+						logging.info('failed to connect to security database. creating new connection again...')
+						db_connector.connect(db_alias='security')
+
+						logging.info('try getting application from database again...')
+						application = Application.objects.get(token=token, api_name=api_name)
+				
+				if application is None:
+					apps = Application.objects.filter()
+					logging.info(f'found {len(apps)} applications in database \o/...')
+					raise Application.DoesNotExist(f"{token} not found in database or error in connection to database...")
+
+				for header in self.required_headers:
+					if not (header == 'x-api-token'):
+						header_type = self.required_headers[header]['type']
+						header_field = self.required_headers[header]['field']
+						header_value = self.required_headers[header]['value']
+
+						logging.info(f'find exists header: {header_field} in database')
+						
+						db_field_value = getattr(application, header_field)
+						
+						logging.info(f'validating db value: {db_field_value} with header value: {header_value}')
+
+						if header_type == 'str':
+							if not (str(header_value) == str(db_field_value)):
+								raise Application.DoesNotExist(f"{header}:{header_value} does not match to the provided token {token}")
+
+						if header_type == 'list':
+							db_items = set(str(item) for item in db_field_value)
+							header_values_list = [str(value.strip()) for value in header_value.split(',')]
+       
+							for header_value in header_values_list:
+								if header_value not in db_items:
+									raise Application.DoesNotExist(f"{header}:{header_value} does not match any of the provided tokens")
+
+					logging.info('api protection process successfully!')
+			except Application.DoesNotExist as e:
+				response.status = 401
+				response.headers['Content-Type'] = 'application/json'
+				logging.error(e)
+				message = 'Error ocurred: {msg} on {line}'.format(msg=str(e), line=sys.exc_info()[-1].tb_lineno)
+				logging.error(message)
+				return {'status': 'Unauthorized', 'message': str(message)}
+			
+			except Exception as e:
+				response.status = 500
+				response.headers['Content-Type'] = 'application/json'
+				logging.error(e)
+				message = 'Error ocurred: {msg} on {line}'.format(msg=str(e), line=sys.exc_info()[-1].tb_lineno)
+				logging.error(message)
+				return {'status': 'Error', 'message': str(message)}
+		
+			return func(*args, **kwargs)
+		
+		return decorated

fmconsult/exceptions/authorization.py

@@ -0,0 +1,5 @@
+class AuthorizationError(Exception):
+    
+  def __init__(self, code, description):
+    self.code = code
+    self.description = description

fmconsult/exceptions/bad_request_exception.py

@@ -0,0 +1,7 @@
+class BadRequestException(Exception):
+
+    def __init__(self, message="he request is malformed or missing required parameters"):
+        self.message = message
+        self.status_code = 400
+        self.status = 'bad request'
+        super().__init__(self.message)

fmconsult/exceptions/conflict_exception.py

@@ -0,0 +1,7 @@
+class ConflictException(Exception):
+
+    def __init__(self, message="A conflict occurred with the current state of the resource."):
+        self.message = message
+        self.status_code = 409
+        self.status = 'Conflict'
+        super().__init__(self.message)

fmconsult/exceptions/forbidden_exception.py

@@ -0,0 +1,7 @@
+class ForbiddenException(Exception):
+  
+    def __init__(self, message="The server understood the request, but refuses to authorize it."):
+        self.message = message
+        self.status_code = 403
+        self.status = 'forbidden'
+        super().__init__(self.message)

fmconsult/exceptions/not_found_exception.py

@@ -0,0 +1,7 @@
+class NotFoundException(Exception):
+
+    def __init__(self, message='The requested resource was not found.'):
+        self.message = message
+        self.status_code = 404
+        self.status = 'Not Found'
+        super().__init__(self.message)

fmconsult/exceptions/not_implemented_exception.py

@@ -0,0 +1,7 @@
+class NotImplementedException(Exception):
+
+    def __init__(self, message='This functionality is not yet available.'):
+        self.message = message
+        self.status_code = 501
+        self.status = 'Not Implemented'
+        super().__init__(self.message)

fmconsult/exceptions/unauthorized_exception.py

@@ -0,0 +1,6 @@
+class UnauthorizedException(Exception):
+    def __init__(self, message="Unauthorized access"):
+        self.message = message
+        self.status_code = 401
+        self.status = 'unauthorized'
+        super().__init__(self.message)

fmconsult/exceptions/unavailable_exception.py

@@ -0,0 +1,7 @@
+class UnavailableException(Exception):
+    
+    def __init__(self, message="Service Temporarily Unavailable"):
+        self.message = message
+        self.status_code = 503
+        self.status = 'unavailable'
+        super().__init__(self.message)

fmconsult/http/api.py

@@ -0,0 +1,108 @@
+import logging, jsonpickle, requests
+from enum import Enum
+from http import HTTPMethod
+from requests.exceptions import ConnectionError, ChunkedEncodingError
+from fmconsult.exceptions.bad_request_exception import BadRequestException
+from fmconsult.exceptions.unavailable_exception import UnavailableException
+from fmconsult.exceptions.not_found_exception import NotFoundException
+from fmconsult.exceptions.unauthorized_exception import UnauthorizedException
+from fmconsult.exceptions.conflict_exception import ConflictException
+
+class ContentType(Enum):
+  APPLICATION_JSON = 'application/json'
+  TEXT_PLAIN = 'text/plain'
+
+class ApiBase(object):
+  def __init__(self, additional_headers=None):
+    self.headers = { 
+      'x-api-token': self.api_token
+    }
+
+    if not(additional_headers is None):
+      for header in additional_headers:
+        self.headers[header] = additional_headers[header]
+
+  def __make_request(self, req_args):
+    max_retries = 3
+    for attempt in range(max_retries):
+        try:
+            # Define o timeout, ajustável conforme a necessidade
+            res = requests.request(**req_args, timeout=60)
+            res.raise_for_status() # Verifica se ocorreu algum erro HTTP
+            return res
+        except (ConnectionError, ChunkedEncodingError) as e:
+            logging.error(f"Connection error occurred: {e}. Retrying {attempt + 1}/{max_retries}...")
+            if attempt == max_retries - 1:
+                raise # Lança a exceção se o limite de tentativas for atingido
+        except requests.exceptions.RequestException as e:
+            logging.error(f"An error occurred: {e}")
+            raise # Lança qualquer outra exceção que não for de conexão
+
+  def call_request(self, http_method:HTTPMethod, request_url, params=None, payload=None, content_type:ContentType=ContentType.APPLICATION_JSON):
+    try:
+      logging.info(f'{str(http_method).upper()} url:')
+      logging.info(request_url)
+
+      self.headers['Content-Type'] = content_type.value
+      logging.info(f'{str(http_method).upper()} headers:')
+      logging.info(jsonpickle.encode(self.headers))
+
+      # Verifica se há parâmetros a serem enviados na URL
+      if not params is None:
+        logging.info(f'{str(http_method).upper()} params:')
+        logging.info(jsonpickle.encode(params))
+
+      # Log do payload (apenas se for POST ou PUT)
+      if not payload is None:
+        logging.info(f'{str(http_method).upper()} payload:')
+        if content_type == ContentType.APPLICATION_JSON:
+          logging.info(jsonpickle.encode(payload))
+        else:
+          logging.info(payload)
+
+      # Configuração dos parâmetros para requisição
+      req_args = {
+        'method': http_method,
+        'url': request_url,
+        'headers': self.headers
+      }
+
+      if params:
+        req_args['params'] = params
+
+      if payload:
+        if content_type == ContentType.APPLICATION_JSON:
+          req_args['json'] = payload
+        else:
+          req_args['data'] = payload
+      
+      logging.info(f'request args:')
+      logging.info(req_args)
+
+      res = self.__make_request(req_args)
+      
+      if res.status_code == 503:
+        raise UnavailableException()
+      elif res.status_code == 404:
+        raise  NotFoundException(res.content)
+      elif res.status_code == 409:
+        raise ConflictException(res.content)
+      elif res.status_code == 401:
+        raise UnauthorizedException(res.content)
+      elif res.status_code == 400:
+        raise BadRequestException(res.content)
+      elif res.status_code != 200:
+        raise Exception(res.content)
+        
+      res = res.content.decode('utf-8')
+      logging.info(f'{str(http_method).upper()} response:')
+      logging.info(jsonpickle.encode(res))
+      return res
+    except UnavailableException as e:
+      raise e
+    except BadRequestException as e:
+        raise e
+    except NotFoundException as e:
+        raise e
+    except Exception as e:
+        raise e

fmconsult/utils/cast.py

@@ -0,0 +1,21 @@
+from enum import Enum
+
+class DataCastUtil:
+	
+	def parse_to_string(self, _object, _field):
+		if _field in _object:
+			_object[_field] = str(_object[_field])
+		return _object
+
+	def parse_fields_to_string(self, _object, _fields):
+		for _field in _fields:
+			_object = self.parse_to_string(_object, _field)
+		return _object
+
+class JSONCastUtil:
+
+	@staticmethod
+	def serialize_enum(obj):
+		if isinstance(obj, Enum):
+			return obj.value
+		raise TypeError(f"Object of type {obj.__class__.__name__} is not JSON serializable")

fmconsult/utils/cnpj.py

@@ -0,0 +1,29 @@
+import re
+
+class CNPJUtil:
+	def __init__( self ):
+		pass
+
+	def validate(self, cnpj):
+		cnpj = ''.join(re.findall('\d', str(cnpj)))
+
+		if (not cnpj) or (len(cnpj) < 14):
+			return False
+
+		inteiros = map(int, cnpj)
+		novo = inteiros[:12]
+		prod = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
+
+		while len(novo) < 14:
+			r = sum([x*y for (x, y) in zip(novo, prod)]) % 11
+			if r > 1:
+				f = 11 - r
+			else:
+				f = 0
+				novo.append(f)
+				prod.insert(0, 6)
+
+		if novo == inteiros:
+			return cnpj
+
+		return False

fmconsult/utils/configs.py

@@ -0,0 +1,11 @@
+import configparser
+
+class ConfigPropertiesHelper(object):
+	config = None
+	
+	def __init__(self, config_path='config/configs.ini'):
+		self.config = configparser.ConfigParser()
+		self.config.read(config_path)
+	
+	def get_property_value(self, section, property):
+		return self.config.get(section, property)

fmconsult/utils/cpf.py

@@ -0,0 +1,27 @@
+class CPFUtil:
+
+	def format( self, cpf ):
+		return "%s.%s.%s-%s" % ( cpf[0:3], cpf[3:6], cpf[6:9], cpf[9:11] )
+
+	def validate(self,cpf):
+		cpf_invalidos = [11*str(i) for i in range(10)]
+		if cpf in cpf_invalidos:
+			return False
+		if not cpf.isdigit():
+			cpf = cpf.replace(".", "")
+			cpf = cpf.replace("-", "")
+		if len(cpf) < 11:
+			return False
+		if len(cpf) > 11:
+			return False
+		selfcpf = [int(x) for x in cpf]
+		cpf = selfcpf[:9]
+		while len(cpf) < 11:
+			r =  sum([(len(cpf)+1-i)*v for i, v in [(x, cpf[x]) for x in range(len(cpf))]]) % 11
+			if r > 1:
+				f = 11 - r
+			else:
+				f = 0
+			cpf.append(f)
+			
+		return bool(cpf == selfcpf)

fmconsult/utils/date.py

@@ -0,0 +1,46 @@
+import re
+from dateutil import parser
+from datetime import datetime, date
+
+class DateUtils:
+	def is_date(self, string):
+		try:
+			parser.parse(string)
+			return True
+		except ValueError:
+			return False
+
+	def calculate_age(self, born):
+		today = date.today()
+		return today.year - born.year - ((today.month, today.day) < (born.month, born.day))
+	
+	def validate_date_format(date_string):
+		return re.match(r'^\d{4}-\d{2}-\d{2}$', date_string) is not None
+	
+	def calculate_hour_difference_from_iso_dates(self, start_date_iso, end_date_iso):
+		if start_date_iso is None or end_date_iso is None:
+				return 0
+		
+		time_difference = abs(end_date_iso - start_date_iso)
+		duration_in_seconds = time_difference.total_seconds()
+		duration_in_minutes = duration_in_seconds / 60
+		
+		return duration_in_minutes
+	
+	def convert_minute_in_hours(self, minutes):
+		hours = minutes // 60
+		minutes_remaining = minutes % 60
+		
+		return f"{int(hours):02d}:{int(minutes_remaining):02d}"
+		
+		
+	def calculate_hour_difference(self, hour_start_str, hour_end_str):
+		if hour_start_str is None or hour_end_str is None:
+			return 0
+		
+		hour_start = datetime.strptime(hour_start_str, "%H:%M")
+		hour_end = datetime.strptime(hour_end_str, "%H:%M")
+		hour_diff = hour_end - hour_start
+		hours_in_minutes = (hour_diff.seconds // 60) % 60
+
+		return hours_in_minutes

fmconsult/utils/enum.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class CustomEnum(Enum):
+  @classmethod
+  def from_value(cls, value):
+    for item in cls:
+      if item.value == value:
+        return item
+    raise ValueError(f"{value} is not a valid value for {cls.__name__}")

fmconsult/utils/haversine.py

@@ -0,0 +1,34 @@
+from math import atan2, cos, radians, sin, sqrt
+
+class HaversineUtil:
+
+    @staticmethod
+    def calculate_distance(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+            """
+            Calculate the distance in kilometers between two GPS coordinates using the Haversine formula.
+
+            Parameters:
+            lat1 (float): Latitude of the first point.
+            lon1 (float): Longitude of the first point.
+            lat2 (float): Latitude of the second point.
+            lon2 (float): Longitude of the second point.
+
+            Returns:
+            float: Distance in kilometers between the two points.
+            """
+            R = 6371.0  # Radius of the Earth in kilometers
+
+            lat1_rad = radians(lat1)
+            lon1_rad = radians(lon1)
+            lat2_rad = radians(lat2)
+            lon2_rad = radians(lon2)
+
+            dlon = lon2_rad - lon1_rad
+            dlat = lat2_rad - lat1_rad
+
+            a = sin(dlat / 2)**2 + cos(lat1_rad) * cos(lat2_rad) * sin(dlon / 2)**2
+            c = 2 * atan2(sqrt(a), sqrt(1 - a))
+
+            distance = R * c
+
+            return round(distance, 2)

fmconsult/utils/object.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass, asdict
+
+@dataclass
+class CustomObject(object):
+  def to_dict(self):
+    return asdict(self)

fmconsult/utils/pagination.py

@@ -0,0 +1,19 @@
+class PaginationUtil:
+    @staticmethod
+    def paginate(queryset, page, limit):
+        try:
+            offset = (page - 1) * limit
+            paginated_items = queryset[offset:offset + limit]
+            total_items = len(queryset)
+
+            return {
+                'items': paginated_items,
+                'total': total_items,
+                'page': page,
+                'limit': limit,
+                'pages': (total_items // limit) + (1 if total_items % limit != 0 else 0),
+                'prev': page - 1 if page > 1 else None,
+                'next': page + 1 if page < (total_items // limit) + (1 if total_items % limit != 0 else 0) else None
+            }
+        except Exception as e:
+            raise Exception(f"Pagination error: {str(e)}")

fmconsult/utils/string.py

@@ -0,0 +1,58 @@
+class StringUtil(object):
+  
+	def id_generator(self, size=6, chars=string.ascii_uppercase + string.digits):
+		return ''.join(random.choice(chars) for _ in range(size))
+
+	def get_encoded_value(self, value):
+		return str(value).decode('cp1252').encode('utf-8')
+
+	def custom_serializer(self, obj):
+		if isinstance(obj, ImportModel):
+			return obj.__dict__
+		else:
+			return None
+
+	def to_dict(self, input_ordered_dict):
+		return loads(dumps(input_ordered_dict, default=self.custom_serializer))
+	
+	def str2bool(self, value):
+		return str(value).lower() in ("yes", "true", "t", "1")
+	
+	def isBoolValue(self, value):
+		return str(value).lower() in ("yes", "false", "true", "t", "f", "1", "0")
+
+	def convert_aba_track_to_serial(self, aba_track_code):
+		return hex(aba_track_code)
+
+	def convert_serial_to_wiegand(self, serial_code):
+		# separando os bytes
+		_p1 = serial_code[-4:]
+		_p2 = serial_code[:(len(serial_code)-4)][-4:]
+		# convertendo os bytes p/ decimal
+		_p1int = int(_p1, 16)
+		_p2int = int(_p2, 16)    
+		# formatando a saida
+		_p2str = f'{_p2int:03}'
+		wiegand_code = '{b2}-{b1}'.format(b1=_p1int, b2=_p2str)
+		return wiegand_code
+
+	def convert_wiegand_to_serial(self, wiegand_code):
+		_wiegand_code = str(wiegand_code).split('-')
+		
+		_b1_hex = hex(int(_wiegand_code[0]))
+		_b2_hex = hex(int(_wiegand_code[1]))[-4:]
+
+		return '{b1}{b2}'.format(b1=_b1_hex, b2=_b2_hex)
+
+	def convert_decimal_to_wiegand(self, decimal_code):
+		return self.convert_serial_to_wiegand(hex(decimal_code))
+
+	def reverse_decimal_from_hexcode(self, decimal_code):
+		hex_code = hex(int(decimal_code)).replace('0x', '')
+		p1 = hex_code[0:2]
+		p2 = hex_code[2:4]
+		p3 = hex_code[4:6]
+		p4 = hex_code[6:8]
+		inverse_hex_code = '{p4}{p3}{p2}{p1}'.format(p4=p4, p3=p3, p2=p2, p1=p1)
+		inverse_dec_code = int(inverse_hex_code, 16)
+		return inverse_dec_code

fmconsult/utils/url.py

@@ -0,0 +1,30 @@
+from urllib.parse import parse_qs
+
+class UrlUtil(object):
+	def make_url(self, base_url, paths):
+		url = base_url
+		for path in paths:
+			url = url +'/'+ str(path)
+		return url
+
+	def url_parse(self, query_string):
+		url_params = {}
+		url_params['params'] = parse_qs(query_string)
+
+		params = url_params.copy()
+
+		for key, value in url_params['params'].items():
+			if key == 'offset':
+				params['offset'] = int(value[0])
+			elif key == 'limit':
+				params['limit'] = int(value[0])
+			else:
+				params['params'][key] = value[0]
+
+		if 'offset' in params['params']:
+			del params['params']['offset']
+		
+		if 'limit' in params['params']:
+			del params['params']['limit']
+
+		return params

fmconsult_utils_python_sdk-2.0.0.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: fmconsult-utils-python-sdk
+Version: 2.0.0
+Summary: Canivete suiço da FMConsult
+Author-email: Filipe Coelho <filipe@fmconsult.com.br>
+License: MIT License
+        
+        Copyright (c) 2025 Seu Nome
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy...
+        
+Project-URL: Homepage, https://github.com/seuuser/minha-biblioteca
+Project-URL: Bug Tracker, https://github.com/seuuser/minha-biblioteca/issues
+Keywords: sdk,api,fmconsult
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

fmconsult_utils_python_sdk-2.0.0.dist-info/RECORD

@@ -0,0 +1,44 @@
+__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmconsult/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmconsult/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmconsult/auth/decorator.py,sha256=gwKeN0BP9uWbFJ31g8HckTp8gQBJHFAiv5WsPdBd6JI,1601
+fmconsult/auth/profile_builder.py,sha256=fpKzRGHUft2VqVq1qHc9aOGdika5ZUwp_WHTVRaqD0o,367
+fmconsult/auth/token_manager.py,sha256=9sn-ZFPxeF9_SGwI3jHWQ_auqmYxWgABQ-Mv11JQo4Y,1710
+fmconsult/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmconsult/database/connection.py,sha256=qCvSWHrv_2xLauKwTcmN-Sux0yOnwSZ0Hj4WjuCmFp4,1637
+fmconsult/database/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmconsult/database/models/application.py,sha256=G1ltnMMitKc0RutEZK2RkW6fQr3IrHjeG26o321jyrU,572
+fmconsult/database/models/base.py,sha256=_V-Q8kFIX1GGNnEYcHfoLnkIeknPKhtTW2edc_LcZkw,875
+fmconsult/database/models/city.py,sha256=S5IzSMzuEqabLHeWlr-4iZf1RS73kiRtTii-qwmU5FU,985
+fmconsult/database/models/country.py,sha256=SR3eD3AwR263EvofKnxvLaMMFcIWtu4ZrKk0ZWMG1U0,837
+fmconsult/database/models/state.py,sha256=EI2OAEZbCh41wkRkY_UHXjAo62EBzqCImuokULuXgAE,912
+fmconsult/decorators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmconsult/decorators/auth.py,sha256=ad_D5_MeTE04TUS_ttD1v1d4br_pVvGOBu4UvzrVjds,4428
+fmconsult/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmconsult/exceptions/authorization.py,sha256=u1ZAnEsiTtBA3HODYwRq7yTq3eaHHrmMhx09rQrBbKU,138
+fmconsult/exceptions/bad_request_exception.py,sha256=EPEuRRl38Cujm3XSy1kAghji_WzOjqdwncBTWJskzCQ,265
+fmconsult/exceptions/conflict_exception.py,sha256=UroQfYRy4kNDRzd_S1lZk9D51HpKdS-ubemSvnEBiEs,265
+fmconsult/exceptions/forbidden_exception.py,sha256=End5OlVPXJjn9LsSxkIpsgfwmO1GibCNDDo8AiGGIGM,273
+fmconsult/exceptions/not_found_exception.py,sha256=AkOljUsBY4gOWjxNQFHr5LY3PKiNH9OwDb0ybr5YEmE,244
+fmconsult/exceptions/not_implemented_exception.py,sha256=c4X7j_fJrj-vGFYvgtBHBHGhqxAQc2dN2R0rFZW23Vo,259
+fmconsult/exceptions/unauthorized_exception.py,sha256=yYAcrB_krgTMw8Qpq3fjG4AkWk-keZCxQ_jVWE815i4,232
+fmconsult/exceptions/unavailable_exception.py,sha256=IJMPr8B9cb4csvKPGEBP0B06w2_xDKCzUyBb6e2BgkI,247
+fmconsult/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmconsult/http/api.py,sha256=_Q5TvWbAHEbE9yLo4G5_1duUsAlff67HxpoDCpuMQFQ,3961
+fmconsult/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmconsult/utils/cast.py,sha256=DF0dsghqlGVO_5QkHzcxMZ7ZrRCTN3oYOFIaRXL_Hi4,517
+fmconsult/utils/cnpj.py,sha256=2b4WMQh-rBrGWdHk_Q1PjRqQ51_71efttBF2_IPmf5E,503
+fmconsult/utils/configs.py,sha256=69cNAuCa3GgmoI7prc4-jENmw8un84ll6CTqMHjboIg,302
+fmconsult/utils/cpf.py,sha256=HtW8D2nEyFS8OSNJAf_T6DJ_lEreN7z5sIi0cd59FUw,647
+fmconsult/utils/date.py,sha256=wRBxYUJx5kzvKGYFNDbGAGW5SNKV34WdM13mwy78tyE,1335
+fmconsult/utils/enum.py,sha256=K7WjriWIx-iRzjDH3snFwPrAoVcZ7DJaXNmPUPoA4jE,235
+fmconsult/utils/haversine.py,sha256=0RlGI10MJDJP4mLVFcX9Q3wW_iIc6FDfyCbvl8D-RsQ,1142
+fmconsult/utils/object.py,sha256=1i0SS36TDQOZTvNvBI8wZ1ZJ2ug0l5Mw4GeKkcWqp2k,126
+fmconsult/utils/pagination.py,sha256=LHUhyMuzyCkKBOcmPLW1O4sZ6Mv2v6d7qMpRBqZSzeI,766
+fmconsult/utils/string.py,sha256=3GvU2T_2kTd9uZR-nNr-L22RKUlJ3BytpINZmuuFg6I,1830
+fmconsult/utils/url.py,sha256=Mz2_Af2PAZHRazqgVjkK3Odm5pQwgBQwivP1ZDgbFXU,682
+fmconsult_utils_python_sdk-2.0.0.dist-info/licenses/LICENSE,sha256=YZjQnFjzXGFa0D3iCQkNDwGBNuTGJREkRmItGX1B3YM,122
+fmconsult_utils_python_sdk-2.0.0.dist-info/METADATA,sha256=JJNRcxF8VbHWiXAJvDMURPDM3UN4DvzDNo2x8RlmUQ4,760
+fmconsult_utils_python_sdk-2.0.0.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+fmconsult_utils_python_sdk-2.0.0.dist-info/top_level.txt,sha256=q7f6ezwPmpsLq0feZx3vFnNAMRFM88R5IMcMK0YIyUo,19
+fmconsult_utils_python_sdk-2.0.0.dist-info/RECORD,,

fmconsult_utils_python_sdk-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.4.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fmconsult_utils_python_sdk-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,5 @@
+MIT License
+
+Copyright (c) 2025 Seu Nome
+
+Permission is hereby granted, free of charge, to any person obtaining a copy...

fmconsult_utils_python_sdk-2.0.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+__init__
+fmconsult