modulitiz-micro 2.26.0__py311-none-any.whl

modulitiz_micro/android/enums/AndroidSmsTypeEnum.py

@@ -0,0 +1,17 @@
+from enum import IntEnum
+from enum import auto
+from enum import unique
+
+
+@unique
+class AndroidSmsTypeEnum(IntEnum):
+	"""
+	Tipi di sms/mms
+	"""
+	ALL=0
+	RECEIVED=auto()
+	SENT=auto()
+	DRAFT=auto()
+	OUTBOX=auto()
+	FAILED_OUTGOING=auto()
+	QUEUED=auto()

modulitiz_micro/database/AbstractDatabaseService.py

@@ -0,0 +1,13 @@
+import threading
+from abc import ABC
+
+from modulitiz_micro.files.ModuloLogging import ModuloLogging
+
+
+class AbstractDatabaseService(ABC):
+	
+	def __init__(self,logger:ModuloLogging):
+		self._logger=logger
+		self.lock=threading.Lock()
+		
+		self.database=None

modulitiz_micro/database/AbstractSql.py

@@ -0,0 +1,49 @@
+import threading
+from abc import ABC
+
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+
+
+class AbstractSql(ABC):
+	def __init__(self):
+		self.connDb=None
+		self.lock=threading.Lock()
+	
+	def commit(self):
+		with self.lock:
+			self.commitNoLock()
+	
+	def commitNoLock(self):
+		"""
+		Da usare solo se il lock viene fatto esternamente
+		"""
+		self.connDb.commit()
+	
+	def rollback(self):
+		with self.lock:
+			self.connDb.rollback()
+	
+	def initCursore(self):
+		with self.lock:
+			cursoreDb=self.connDb.cursor()
+		return cursoreDb
+	
+	def count(self,cursoreDb)->int:
+		with cursoreDb:
+			with self.lock:
+				result=cursoreDb.fetchone()
+		if not result:
+			return 0
+		return result[0]
+	
+	def close(self):
+		with self.lock:
+			if self.connDb is not None:
+				self.connDb.close()
+				self.connDb=None
+	
+	@staticmethod
+	def ifEmptyThenNull(testo:str|None)->str|None:
+		if ModuloStringhe.isEmpty(testo) or testo=="NULL":
+			return None
+		return testo

modulitiz_micro/database/ModuloSqlOracle.py

@@ -0,0 +1,19 @@
+import oracledb
+
+from modulitiz_micro.database.ModuloSqlServer import ModuloSqlServer
+
+
+class ModuloSqlOracle(ModuloSqlServer):
+	DEFAULT_PORTA=1521
+	
+	def __init__(self,porta:int|None,*args,**kwargs):
+		super().__init__(*args,**kwargs)
+		if porta is None:
+			porta=self.DEFAULT_PORTA
+		self.porta=porta
+	
+	def connessione(self):
+		dsn="{}/{}@{}:{}/xe".format(self.username,self.password,self.host,self.porta)
+		self.connDb=oracledb.connect(dsn)
+		self.connDb=dsn
+	

modulitiz_micro/database/ModuloSqlServer.py

@@ -0,0 +1,50 @@
+import pypyodbc
+
+from modulitiz_micro.database.AbstractSql import AbstractSql
+
+
+class ModuloSqlServer(AbstractSql):
+	ERROR_CODE__UNIQUE_INDEX=23000
+	
+	def __init__(self,host:str,nome_db:str,username:str,password:str):
+		super().__init__()
+		self.host=host
+		self.nome_db=nome_db
+		self.username=username
+		self.password=password
+		
+	def connessione(self):
+		connDb=pypyodbc.connect("Driver={SQL Server};Server="+self.host+";Database="+self.nome_db+";uid="+self.username+";pwd="+self.password+";")
+		self.connDb=connDb
+	
+	def select(self,sql:str,params:list):
+		with self.initCursore() as cursoreDb:
+			cursoreDb.execute(sql,params)
+			results=list(cursoreDb)
+		return results
+	
+	@staticmethod
+	def selectOne(cursoreDb,sql:str,params:list)->list:
+		"""
+		Scarica la prima riga della query
+		"""
+		with cursoreDb:
+			cursoreDb.execute(sql,params)
+			element=cursoreDb.fetchone()
+		return list(element)
+	
+	def select_count(self,cursoreDb,sql:str,params:list)->int:
+		elemento=self.selectOne(cursoreDb,sql,params)
+		return int(elemento[0])
+	
+	#usare se si vogliono fare delle modifiche ai dati
+	#tipo: insert, update, delete
+	def modifica(self,cursoreDb,sql:str,params:list,ignore_unique_index:bool):
+		try:
+			cursoreDb.execute(sql,params)
+		except pypyodbc.IntegrityError as ie:
+			if ignore_unique_index:
+				error_code=int(ie.value[0])
+				if error_code!=self.ERROR_CODE__UNIQUE_INDEX:
+					raise ie
+	

modulitiz_micro/database/eccezioni/EccezioneDbNoData.py

@@ -0,0 +1,6 @@
+from modulitiz_micro.eccezioni.EccezioneBase import EccezioneBase
+
+class EccezioneDbNoData(EccezioneBase):
+	
+	def __init__(self,*args,**kwargs):
+		super().__init__(*args,**kwargs)

modulitiz_micro/database/mysql/AbstractBasicMysql.py

@@ -0,0 +1,114 @@
+from abc import abstractmethod
+
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+from modulitiz_micro.database.mysql.ModuloMysql import AbstractMysql
+
+
+class AbstractBasicMysql(AbstractMysql):
+	
+	def __init__(self,*args,**kwargs):
+		super().__init__(*args,**kwargs)
+	
+	def initDdlBasicTables(self):
+		if not self.isDbNew:
+			return
+		sqlStr=ModuloStringhe.normalizzaEol(self.schemaBasicTables())
+		for risultati in self.executeScript(sqlStr):
+			yield risultati
+		sqlInsertBasicTables=self.insertBasicTables()
+		if not ModuloStringhe.isEmpty(sqlInsertBasicTables):
+			sqlInsertBasicTables=ModuloStringhe.normalizzaEol(sqlInsertBasicTables)
+			for risultati in self.executeScript(sqlInsertBasicTables):
+				yield risultati
+		self.commit()
+	
+	def schemaBasicTables(self):
+		return """
+
+CREATE TABLE tb_params(
+	id						INT UNSIGNED AUTO_INCREMENT PRIMARY KEY NOT NULL,
+	type1					CHAR(30) NOT NULL,
+	key1					CHAR(30) NOT NULL,
+	desc1					CHAR(100) NOT NULL,
+	enabled					BOOLEAN NOT NULL,
+	lang_code				CHAR(2) NULL,
+	data_insert				DATETIME NOT NULL
+)"""+self.TABLE_OPTIONS+""";
+CREATE UNIQUE INDEX PARAMS__UK1 ON tb_params(type1,key1,lang_code);
+
+"""
+	
+	@abstractmethod
+	def insertBasicTables(self):
+		"""
+		Inserire le istruzioni sql che vanno eseguite alla fine di tutto
+		"""
+	
+	
+	
+	#############################################################################################################################
+	#############################################################################################################################
+	#############################################################################################################################
+	def selectParamDescByEntries(self,paramType:str,paramKey:str|None)->str|None:
+		cursoreDb=self.selectParamByEntries(paramType, paramKey, None, True)
+		results=self.fetchAll(cursoreDb)
+		if len(results)==0:
+			return None
+		result=results[0]
+		return result['desc1']
+	
+	def selectParamByEntries(self,paramType:str,paramKey:str|None,langCode:str|None,enabled:bool|None):
+		addParamKey=ModuloStringhe.isEmpty(paramKey) is False
+		addLangCode=ModuloStringhe.isEmpty(langCode) is False
+		addEnabled=enabled is not None
+		
+		sql="""
+SELECT *
+FROM tb_params
+WHERE type1=%(paramType)s
+"""+("AND key1=%(paramKey)s" if addParamKey is True else "")+"""
+"""+("AND langCode=%(langCode)s" if addLangCode is True else "")+"""
+"""+("AND enabled=%(enabled)s" if addEnabled is True else "")+"""
+;
+"""
+		params= {'paramType': paramType}
+		if addParamKey is True:
+			params['paramKey']=paramKey
+		if addLangCode is True:
+			params['langCode']=langCode
+		if addEnabled is True:
+			params['enabled']=enabled
+		
+		cursoreDb=self.initCursore()
+		with self.lock:
+			cursoreDb.execute(sql,params)
+		return cursoreDb
+	
+	
+	def updateParamDesc(self,paramType:str,paramKey:str|None,newDesc:str|None):
+		addParamKey=ModuloStringhe.isEmpty(paramKey) is False
+		addNewDesc=ModuloStringhe.isEmpty(newDesc) is False
+		
+		sqlSet=[]
+		if addNewDesc is True:
+			sqlSet.append("desc1=%(newDesc)s")
+		sqlSet=", ".join(sqlSet)
+		
+		sql="""
+UPDATE tb_params
+SET """+sqlSet+"""
+WHERE type1=%(paramType)s
+"""+("AND key1=%(paramKey)s" if addParamKey is True else "")+"""
+;
+"""
+		params={}
+		if addNewDesc is True:
+			params['newDesc']=newDesc
+		params['paramType']=paramType
+		if addParamKey is True:
+			params['paramKey']=paramKey
+		cursoreDb=self.initCursore()
+		with self.lock:
+			cursoreDb.execute(sql,params)
+		return cursoreDb
+	

modulitiz_micro/database/mysql/ModuloMysql.py

@@ -0,0 +1,151 @@
+from abc import abstractmethod
+
+import mysql.connector
+
+from modulitiz_micro.ModuloListe import ModuloListe
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+from modulitiz_micro.database.AbstractSql import AbstractSql
+from modulitiz_micro.database.eccezioni.EccezioneDbNoData import EccezioneDbNoData
+from modulitiz_micro.database.mysql.MysqlCommonConverter import MysqlCommonConverter
+from modulitiz_micro.eccezioni.EccezioneRuntime import EccezioneRuntime
+from modulitiz_micro.files.ModuloFiles import ModuloFiles
+from modulitiz_micro.files.ModuloLogging import ModuloLogging
+from modulitiz_micro.sistema.ModuloSystem import ModuloSystem
+
+
+class AbstractMysql(AbstractSql):
+	"""
+	select
+	count
+	insert
+	update
+	delete
+	"""
+	
+	DATE_TIME_NOW="NOW()"
+	
+	DEFAULT_PORT=3306
+	
+	
+	def __init__(self,host: str,porta: int|None,user: str,password: str,nomeDb: str,isDebug: bool):
+		super().__init__()
+		self.nomeDb=nomeDb
+		if porta is None:
+			porta=self.DEFAULT_PORT
+		# apro la connessione col server
+		self.connDb=mysql.connector.connect(user=user,password=password,host=host,port=porta,
+				converter_class=MysqlCommonConverter)
+		self.initCursore()
+		self.TABLE_OPTIONS=self.getTableOptions(isDebug)
+		self.isDbNew=None
+	
+	def initDdl(self):
+		#scelgo il db
+		try:
+			self.connDb.cmd_init_db(self.nomeDb)
+			self.isDbNew=False
+		except mysql.connector.ProgrammingError:
+			sqlCreaDb="CREATE DATABASE %s;"%(self.nomeDb,)
+			with self.initCursore() as cursoreDb:
+				with self.lock:
+					cursoreDb.execute(sqlCreaDb)
+			self.connDb.cmd_init_db(self.nomeDb)
+			self.isDbNew=True
+		#se il db non esisteva creo le tabelle
+		if self.isDbNew:
+			sqlStr=ModuloStringhe.normalizzaEol(self.schema())
+			for risultati in self.executeScript(sqlStr):
+				yield risultati
+	
+	@abstractmethod
+	def schema(self):
+		"""
+		Inserire le istruzioni sql contenenti la dichiarazione delle tabelle (DDL)
+		"""
+	
+	def getLastIdInserted(self,cursoreDb):
+		return cursoreDb.lastrowid
+	
+	def executeScript(self,sqlStr:str):
+		sqlCmds=sqlStr.split(";")
+		sqlCmds=ModuloListe.eliminaElementiVuoti(sqlCmds)
+		numCmds=len(sqlCmds)
+		cursoreDb=self.initCursore()
+		for index,sqlCmd in enumerate(sqlCmds):
+			sqlCmd=sqlCmd.strip()
+			try:
+				if sqlCmd!="":
+					with self.lock:
+						cursoreDb.execute(sqlCmd)
+				yield index,numCmds
+			except Exception as ex:
+				raise EccezioneRuntime(sqlCmd+"\n\n"+ModuloLogging.exceptionToString(ex))
+	
+	def fetchAll(self,cursoreDb)->list:
+		with cursoreDb:
+			if cursoreDb.description is None:
+				raise EccezioneDbNoData()
+			descriptions=cursoreDb.description
+			with self.lock:
+				rows=cursoreDb.fetchall()
+				self.commitNoLock()		# mysql mette in cache i risultati, lo risolvo così, è un bug loro...
+		columns = [col[0] for col in descriptions]
+		rows = [dict(zip(columns, row)) for row in rows]
+		return rows
+	
+	@classmethod
+	def backup(cls,percorsoCartella: str,user: str,password: str,dbName: str,
+			ignoreTables:list|tuple|None)->list:
+		output=[
+			cls.backupDdl(percorsoCartella,user,password,dbName,ignoreTables),
+			cls.backupData(percorsoCartella,user,password,dbName,ignoreTables)
+		]
+		return output
+	
+	@classmethod
+	def backupDdl(cls,percorsoCartella: str,user: str,password: str,dbName: str,
+			ignoreTables:list|tuple|None)->str:
+		return cls.__backup(percorsoCartella,user,password,dbName,ignoreTables,True,False)
+	@classmethod
+	def backupData(cls,percorsoCartella: str,user: str,password: str,dbName: str,
+			ignoreTables:list|tuple|None)->str:
+		return cls.__backup(percorsoCartella,user,password,dbName,ignoreTables,False,True)
+	
+	@staticmethod
+	def __backup(percorsoCartella:str,user:str,password:str,dbName:str,
+			ignoreTables:list|tuple|None,onlyDdl:bool,onlyData:bool)->str:
+		if onlyDdl and onlyData:
+			raise EccezioneRuntime("valorizzare solo un'opzione alla volta")
+		cmdIgnoreTables=""
+		if ignoreTables is not None:
+			cmdIgnoreTables=" ".join(["--ignore-table=%s.%s"%(dbName,x) for x in ignoreTables])
+		nomefileSuffix=""
+		cmdOptions=""
+		if onlyDdl:
+			nomefileSuffix="_ddl"
+			cmdOptions="--no-data "+cmdIgnoreTables
+		elif onlyData:
+			nomefileSuffix="_data"
+			cmdOptions="--order-by-primary --no-create-info --quick "+cmdIgnoreTables
+		nomefileOutput=dbName+nomefileSuffix+".sql"
+		percorsoFileBackup=ModuloFiles.pathJoin(percorsoCartella,nomefileOutput)
+		cmd=r'mysqldump -u {} -p{} --databases {} --skip-add-drop-table --skip-comments {} -r "{}"'.format(user,password,dbName,cmdOptions,percorsoFileBackup)
+		output=ModuloSystem.systemCallReturnOutput(cmd,None).strip()
+		if not ModuloStringhe.isEmpty(output):
+			raise EccezioneRuntime(output)
+		return percorsoFileBackup
+	
+	@staticmethod
+	def getTableOptions(isDebug: bool) -> str:
+		return "ENGINE=%s DEFAULT CHARSET=utf8"%("InnoDB" if not isDebug else "MEMORY",)
+
+def paginazione(firstResult:int,numResults:int)->str:
+	sql=("LIMIT "+str(numResults) if numResults is not None else "")+\
+			(" OFFSET "+str(firstResult) if firstResult is not None else "")
+	return sql
+
+def add_param_list(lista:list,prefix:str)->dict:
+	params={}
+	for index,elem in enumerate(lista):
+		params[prefix+str(index)]=elem
+	return params

modulitiz_micro/database/mysql/MysqlCommonConverter.py

@@ -0,0 +1,47 @@
+from typing import Optional
+
+from mysql.connector import FieldType
+from mysql.connector.conversion import MySQLConverter
+from mysql.connector.types import DescriptionType
+from mysql.connector.types import MySQLConvertibleType
+from mysql.connector.types import MySQLProducedType
+from mysql.connector.types import PythonProducedType
+
+
+class MysqlCommonConverter(MySQLConverter):
+	def __init__(self,charset: str|None = None,
+			use_unicode: bool = True,
+			str_fallback: bool = False):
+		super().__init__(charset,use_unicode,str_fallback)
+	
+	def to_mysql(self,value) -> MySQLProducedType:
+		value=self.__to_mysql(value)
+		# default behavior
+		return super().to_mysql(value)
+	
+	@staticmethod
+	def __to_mysql(value):
+		"""
+		Gestione custom, ad esempio per IntEnum e StrEnum
+		"""
+		if value.__class__ in MySQLConvertibleType.__args__:
+			return value
+		# inizio gestione custom
+		if isinstance(value,int):
+			typePrimitive=int
+		elif isinstance(value,str):
+			typePrimitive=str
+		else:
+			return value
+		value.__class__.__name__=typePrimitive.__name__
+		return value
+	
+	def to_python(
+			self,
+			vtype: DescriptionType,
+			value: Optional[bytes],
+	) -> PythonProducedType:
+		if vtype[1] == FieldType.BIT:
+			return value==b'\x01'
+		# default behavior
+		return super().to_python(vtype, value)

modulitiz_micro/database/mysql/eccezioni/EccezioneMysqlOffline.py

@@ -0,0 +1,6 @@
+import mysql.connector
+
+class EccezioneMysqlOffline(mysql.connector.InterfaceError):
+	
+	def __init__(self,*args,**kwargs):
+		super().__init__(*args,**kwargs)

modulitiz_micro/database/sqlite/AbstractBasicSQLite.py

@@ -0,0 +1,114 @@
+from abc import abstractmethod
+
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+from modulitiz_micro.database.sqlite.ModuloSQLite import AbstractSqlite
+
+
+class AbstractBasicSqlite(AbstractSqlite):
+	
+	def __init__(self,*args,**kwargs):
+		super().__init__(*args,**kwargs)
+		if not self.isDbNew:
+			return
+		sql_str=ModuloStringhe.normalizzaEol(self.schemaBasicTables())
+		with self.initCursore() as cursoreDb:
+			with self.lock:
+				cursoreDb.executescript(sql_str)
+			sql_insertBasicTables=self.insertBasicTables()
+			if not ModuloStringhe.isEmpty(sql_insertBasicTables):
+				sql_insertBasicTables=ModuloStringhe.normalizzaEol(sql_insertBasicTables)
+				with self.lock:
+					cursoreDb.executescript(sql_insertBasicTables)
+		self.commit()
+	
+	@abstractmethod
+	def insertBasicTables(self):
+		"""
+		Inserire le istruzioni sql che vanno eseguite alla fine di tutto
+		"""
+	
+	def schemaBasicTables(self):
+		return """
+
+CREATE TABLE tb_params(
+	id						INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+	type					TEXT NOT NULL,
+	key						TEXT NULL,
+	desc					TEXT NOT NULL,
+	enabled					INTEGER NOT NULL,
+	lang_code				TEXT NULL,
+	data_insert				TIMESTAMP NOT NULL
+);
+CREATE UNIQUE INDEX PARAMS__UK1 ON tb_params(
+	type,
+	IFNULL(key, 0),
+	IFNULL(lang_code, 0)
+);
+
+"""
+	
+	
+	#############################################################################################################################
+	#############################################################################################################################
+	#############################################################################################################################
+	def selectParamDescByEntries(self,paramType,paramKey)->str|None:
+		with self.selectParamByEntries(paramType, paramKey, None, True) as cursoreDb:
+			results=cursoreDb.fetchall()
+		if len(results)==0:
+			return None
+		return results[0]['desc']
+	
+	def selectParamByEntries(self,paramType,paramKey,langCode,enabled):
+		addParamKey=ModuloStringhe.isEmpty(paramKey) is False
+		addLangCode=ModuloStringhe.isEmpty(langCode) is False
+		addEnabled=ModuloStringhe.isEmpty(enabled) is False
+		
+		sql="""
+SELECT *
+FROM tb_params
+WHERE type=:paramType
+"""+("AND key=:paramKey" if addParamKey is True else "")+"""
+"""+("AND langCode=:langCode" if addLangCode is True else "")+"""
+"""+("AND enabled=:enabled" if addEnabled is True else "")+"""
+;
+"""
+		params={'paramType':paramType}
+		if addParamKey is True:
+			params['paramKey']=paramKey
+		if addLangCode is True:
+			params['langCode']=langCode
+		if addEnabled is True:
+			params['enabled']=enabled
+		cursoreDb=self.initCursore()
+		with self.lock:
+			cursoreDb.execute(sql,params)
+		return cursoreDb
+	
+	
+	def updateParamDesc(self,paramType,paramKey,newDesc):
+		addParamKey=ModuloStringhe.isEmpty(paramKey) is False
+		addNewDesc=ModuloStringhe.isEmpty(newDesc) is False
+		
+		sql_set=[]
+		if addNewDesc is True:
+			sql_set.append("desc=:newDesc")
+		sql_set=", ".join(sql_set)
+		
+		sql="""
+UPDATE tb_params
+SET """+sql_set+"""
+WHERE type=:paramType
+"""+("AND key=:paramKey" if addParamKey is True else "")+"""
+;
+"""
+		params={}
+		if addNewDesc is True:
+			params['newDesc']=newDesc
+		params['paramType']=paramType
+		if addParamKey is True:
+			params['paramKey']=paramKey
+		cursoreDb=self.initCursore()
+		with self.lock:
+			cursoreDb.execute(sql,params)
+		return cursoreDb
+	

modulitiz_micro/database/sqlite/ModuloSQLite.py

@@ -0,0 +1,82 @@
+"""
+esempio utilizzo per lista
+
+def __query_NOME_TABELLA(self,lista_status,is_count):
+	paramsStatus=ModuloSQLite.add_param_list(lista_status, "status")
+	
+	sql='''
+SELECT '''+("COUNT(*)" if is_count is True else "*")+'''
+FROM NOME_TABELLA
+WHERE 1=1
+AND status IN (:'''+",:".join(paramsStatus.keys())+''')
+;
+'''
+	cursoreDb.execute(sql,paramsStatus)
+"""
+import sqlite3
+from abc import abstractmethod
+
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+from modulitiz_micro.database.AbstractSql import AbstractSql
+from modulitiz_micro.files.ModuloFiles import ModuloFiles
+
+
+class AbstractSqlite(AbstractSql):
+	"""
+	select
+	count
+	insert
+	update
+	delete
+	"""
+	
+	DATE_TIME_NOW="datetime('now','localtime')"
+	DATE_TIME_NOW_MILLIS="strftime('%Y-%m-%d %H:%M:%f', 'now')"
+	
+	TIMEOUT_CONNECTION=10
+	
+	
+	def __init__(self,nomefile_db:str,show_sql:bool=False):
+		super().__init__()
+		self.isDbNew=ModuloFiles.getFileSize(nomefile_db)<=0
+		#apro la connessione col db
+		connDb=sqlite3.connect(nomefile_db, timeout=self.TIMEOUT_CONNECTION, detect_types=sqlite3.PARSE_DECLTYPES, check_same_thread=False)
+		#modifica row factory per usare Row
+		connDb.row_factory=sqlite3.Row
+		self.connDb=connDb
+		# creo il cursore, deve essere fatto dopo il row factory
+		with self.initCursore() as cursoreDb:
+			# setup iniziale
+			with self.lock:
+				# non puoi cancellare un record se e' referenziato da un'altra tabella
+				cursoreDb.executescript('PRAGMA foreign_keys=ON;')
+			self.commit()
+			# mostra i comandi sql eseguiti
+			if show_sql is True:
+				self.connDb.set_trace_callback(print)
+			# se il db non esisteva creo le tabelle
+			if self.isDbNew:
+				sql_str=ModuloStringhe.normalizzaEol(self.schema())
+				with self.lock:
+					cursoreDb.executescript(sql_str)
+				self.commit()
+	
+	@abstractmethod
+	def schema(self):
+		"""
+		Inserire le istruzioni sql contenenti la dichiarazione delle tabelle (DDL)
+		"""
+	
+	def getLastIdInserted(self,cursoreDb):
+		return cursoreDb.lastrowid
+
+def paginazione(first_result:int,num_results:int)->str:
+	sql=("LIMIT "+str(num_results) if num_results is not None else "")
+	sql+=(" OFFSET "+str(first_result) if first_result is not None else "")
+	return sql
+
+def add_param_list(lista,prefix):
+	params={}
+	for index,elem in enumerate(lista):
+		params[prefix+str(index)]=elem
+	return params

modulitiz_micro/eccezioni/EccezioneBase.py

@@ -0,0 +1,7 @@
+from modulitiz_micro.eccezioni.EccezioneRuntime import EccezioneRuntime
+
+
+class EccezioneBase(EccezioneRuntime):
+	
+	def __init__(self,*args,**kwargs):
+		super().__init__(*args,**kwargs)

modulitiz_micro/eccezioni/EccezioneCtrlC.py

@@ -0,0 +1,7 @@
+from modulitiz_micro.eccezioni.EccezioneBase import EccezioneBase
+
+
+class EccezioneCtrlC(EccezioneBase):
+	
+	def __init__(self,*args,**kwargs):
+		super().__init__(*args,**kwargs)