def startCameraWatcher(self):
Logger().debug("Start camera watcher thread")
self.__fsWatcherThread = QThread()
self.__fsWatcherThread.setObjectName("FSWatcherThread")
self.__fsWatcher = FSWatcher(
path=self.__settingsBean.getCameraRemotePath(),
intervalMs=self.__settingsBean.getCameraPollingTimeMs())
self.__fsWatcher.moveToThread(self.__fsWatcherThread)
self.__fsWatcherThread.started.connect(self.__fsWatcher.startProcess)
self.__fsWatcher.itemsPathUpdatedSignal.connect(
lambda items: self.__processBean.setCameraFolderItems(items))
self.__fsWatcher.isConnectedSignal.connect(
lambda isConnected: self.__processBean.setCameraConnectionUp(
isConnected))
self.__fsWatcher.startedSignal.connect(
lambda: self.__processBean.setCameraWatcherRunning(True))
self.__fsWatcher.stoppedSignal.connect(
lambda: self.__processBean.setCameraWatcherRunning(False))
self.__fsWatcher.stoppedSignal.connect(self.__fsWatcherThread.quit)
self.__fsWatcherThread.finished.connect(
self.__fsWatcherThread.deleteLater)
self.__fsWatcherThread.finished.connect(self.__fsWatcher.deleteLater)
Logger().debug("Camera watcher thread avviato")
self.__fsWatcherThread.start()
def startLaserWatcher(self):
Logger().debug("Start laser watcher thread")
self.__ftpWatcherThread = QThread()
self.__ftpWatcherThread.setObjectName("CSVWatcherThread")
self.__ftpWatcher = FTPWatcher(
remotePath=self.__settingsBean.getLaserRemotePath(),
ftpAddress=self.__settingsBean.getLaserIp(),
intervalMs=self.__settingsBean.getLaserPollingTimeMs(),
ftpPort=self.__settingsBean.getLaserPort())
self.__ftpWatcher.moveToThread(self.__ftpWatcherThread)
self.__ftpWatcherThread.started.connect(self.__ftpWatcher.startProcess)
self.__ftpWatcher.itemsPathUpdatedSignal.connect(
lambda items: (self.__processBean.setLaserFolderItems(items),
self.analizeFolderItems()))
# self.__csvWatcher.isConnectedSignal.connect(self.laserFolderWatcherConnectedSignal)
self.__ftpWatcher.isConnectedSignal.connect(
lambda isConnected: self.__processBean.setLaserConnectionUp(
isConnected))
self.__ftpWatcher.startedSignal.connect(
lambda: self.__processBean.setLaserWatcherRunning(True))
self.__ftpWatcher.stoppedSignal.connect(
lambda: self.__processBean.setLaserWatcherRunning(False))
self.__ftpWatcher.stoppedSignal.connect(self.__ftpWatcherThread.quit)
self.__ftpWatcherThread.finished.connect(
self.__ftpWatcherThread.deleteLater)
self.__ftpWatcherThread.finished.connect(self.__ftpWatcher.deleteLater)
Logger().debug("Laser watcher thread avviato")
self.__ftpWatcherThread.start()
def freeResources(self):
if isinstance(self.__ftpWatcherThread, QThread):
if self.__processBean.isLaserWatcherRunning():
Logger().debug("Stop laser watcher thread")
QMetaObject.invokeMethod(self.__ftpWatcher, "stopProcess")
if isinstance(self.__fsWatcherThread, QThread):
if self.__processBean.isCameraWatcherRunning():
Logger().debug("Stop camera watcher thread")
QMetaObject.invokeMethod(self.__fsWatcher, "stopProcess")
def connectFtp(self, ftpController) -> bool:
isConnected: bool = False
try:
Logger().info("Connessione al laser in FTP")
ftpController.connect()
ftpController.login()
isConnected = True
except ftplib.all_errors as ftpErr:
Logger().error("Errore connessione FTP: " + str(ftpErr))
ftpController.close()
isConnected = False
return isConnected
def fetch(self):
if self.valid(): return 1
url = self.url % (self.lat, self.lng,
datetime.utcnow().strftime("%Y-%m-%d"))
Logger().logger.info("SunAPI REQ: %s" % url)
r = requests.get(url=url)
self.data = r.json()['results']
self.cacheKey = datetime.utcnow().strftime("%Y-%m-%d")
Logger().logger.info("SunAPI: %s" % self.data)
return 1
def __init__(self):
super(V, self).__init__()
self.p2p = P2P()
self.p2p.clientConfig('192.168.1.102', 9001)
self.p2p.serverConfig('192.168.1.102', 9000)
#Interface
loadUi('ui/V.ui', self)
self.setWindowTitle('Votante')
#threads
self.tread = Thread(target=self.p2p.listening)
self.tread.start()
self.treadV = Thread(target=self.verify)
self.treadV.start()
#Logger
self.logger = Logger('data/votos.txt', 'data/eleitores.txt')
if self.logger.compare() is not True:
self.logger.repair()
self.btVotar.clicked.connect(self.btVotar_click)
if self.p2p.msgListen:
self.btVotar.setEnabled(True)
self.lbAguardando.setText('Votação Liberada')
self.txtVoto.setEnabled(True)
def sendMessageToAll(self):
chats = list(DB().chats.find({}))
for chat in chats:
self.bot.sendMessage(chat["chat_id"], "sup")
Logger().logger.info("sendMessageToAll()")
def main():
banner()
'''
command line option parser
'''
option_parser = optparse.OptionParser()
option_parser.usage = \
"""
search_register.py -e [email] [options]
search_register.py -c [cellphone] [options]"""
option_parser.add_option('-e', '--email', dest='email', action='store',default=None)
option_parser.add_option('-c', '--cellphone', dest='cellphone', action='store',default=None)
option_parser.add_option('-t', '--thread', dest='thread', action='store', default=1,help="")
"""
parse options
"""
(options, args) = option_parser.parse_args()
"""
new logger object
"""
logger = Logger(5)
"""
specific the search type (email or cellphone)
"""
email = options.email
cellphone = options.cellphone
if email:
task_list = Tasktable('email').tasklist
target = email
query_method = "email"
else:
if cellphone:
task_list = Tasktable('cellphone').tasklist
target = cellphone
query_method = "cellphone"
else:
option_parser.error("must specify email OR cellphone")
return
logger.info("search websites registered using "+query_method
+":"+target)
spider = Spider(task_list,target,query_method,logger)
spider.controller()
def main():
# no args provided
if len(sys.argv) == 1:
parser.print_help()
sys.exit(1)
logsDir = os.path.join(os.getcwd(), 'logs')
#resultsDir = os.path.join(os.getcwd(), 'results')
if not os.path.exists(logsDir):
os.mkdir(logsDir)
#if not os.path.exists(resultsDir):
# os.mkdir(resultsDir)
logger = Logger(args.nolog, args.verbose)
#single target or multiple targets
if(args.target and args.tlist):
logger.PrintError("You can request Geolocation information either for a single target(-t) or a list of targets(-T). Not both!", args.nolog)
sys.exit(2)
#my ip address or single target
if(args.target and args.myip):
logger.PrintError("You can request Geolocation information either for a single target(-t) or your own IP address. Not both!", args.nolog)
sys.exit(3)
#multiple targets or my ip address
if(args.tlist and args.myip):
logger.PrintError("You can request Geolocation information either for a list of targets(-T) or your own IP address. Not both!", args.nolog)
sys.exit(4)
#single target and google maps only allowed
if(args.tlist and args.g):
logger.PrintError("Google maps location is working only with single targets.", args.nolog)
sys.exit(5)
#specify user-agent or random
if(args.uagent and args.ulist):
logger.PrintError("You can either specify a user-agent string or let IPGeolocation pick random user-agent strings for you from a file.", args.nolog)
sys.exit(6)
#specify proxy or random
if(args.proxy and args.xlist):
logger.PrintError("You can either specify a proxy or let IPGeolocation pick random proxy connections for you from a file.", args.nolog)
sys.exit(7)
#init lib
ipGeoLocRequest = IpGeoLocationLib(args.target, logger, args.noprint)
print(banner)
#retrieve information
if not ipGeoLocRequest.GetInfo(args.uagent, args.tlist,
args.ulist, args.proxy, args.xlist,
args.csv, args.xml, args.txt, args.g):
logger.PrintError("Retrieving IP Geolocation information failed.")
sys.exit(8)
def sendLatest(self, chat_id):
latest = self.Capture()
path = '%s%s_c%s_02%s' % (
Config().get()["MotionDetector"]["Folder"], "latest", 0,
Config().get()["MotionDetector"]["Extension"])
Logger().logger.info(path)
cv2.imwrite(path, latest)
FeroxBot().sendImage(path, chat_id)
def isDay(self):
self.fetch()
now = datetime.now(timezone.utc).astimezone(tz.tzlocal())
Logger().logger.info("%s < %s and %s > %s" %
(self.UTCDateToLocal(self.data['sunrise']), now,
self.UTCDateToLocal(self.data['sunset']), now))
return self.UTCDateToLocal(
self.data['sunrise']) < now and self.UTCDateToLocal(
self.data['sunset']) > now
def sendImageToAll(self, path):
chats = list(DB().chats.find({}))
for chat in chats:
self.bot.send_photo(chat["chat_id"], open(path, 'rb'))
Logger().logger.info("sendImageToAll()")
os.remove(path)
def process(self):
res = None
try:
res = self.ftpController.nlst(self.remotePath)
self.itemsPathUpdatedSignal.emit(res)
except ftplib.all_errors as ftpErr:
Logger().error("FTPWatcher error: " + str(ftpErr))
self.isConnectedSignal.emit(False)
self.ftpController.close()
self.restartProcess()
def process(self):
res = None
try:
res = os.listdir(self.__path)
self.setConnected(True)
self.itemsPathUpdatedSignal.emit(res)
except OSError as err:
Logger().error("FSWatcher error:" + str(err))
self.pathUnreachableSignal.emit()
self.setConnected(False)
self.restartProcess()
def sendCsvFileToDevices(self):
localloadingPath = self.__settingsBean.getLocalLoadingPath()
csvFilename = self.__settingsBean.getLocalCsvFilename()
csvLocalPath = localloadingPath + "\\" + csvFilename
cameraPath = self.__settingsBean.getCameraRemotePath()
csvCameraPath = cameraPath + "\\" + csvFilename
if not os.path.exists(csvLocalPath):
Logger().error("File " + csvLocalPath + " non trovato")
self.showDialogSignal.emit(
"Nessun file trovato nella cartella locale")
return
# invio file csv al laser
Logger().info("Invio file " + csvFilename + " al laser")
ftpController = FTP()
ftpController.host = self.__settingsBean.getLaserIp()
ftpController.port = self.__settingsBean.getLaserPort()
laserFTPRemotePath = self.__settingsBean.getLaserRemotePath()
try:
ftpController.connect()
ftpController.login()
ftpController.cwd(laserFTPRemotePath)
cmd = "STOR " + csvFilename
Logger().debug("Comando: " + cmd)
fp = open(csvLocalPath, "rb")
ftpController.storbinary(cmd, fp)
except ftplib.all_errors as ftpErr:
Logger().error("Error on FTP:" + str(ftpErr))
ftpController.close()
self.showDialogSignal.emit("Errore invio file csv al laser")
return
if self.__settingsBean.getCameraSendCSV():
# invio il file csv alla camera
Logger().info("Invio file " + csvFilename + " alla camera")
try:
shutil.copy(csvLocalPath, csvCameraPath)
except:
Logger().error("Impossibile copiare il file csv in camera")
self.showDialogSignal.emit("Errore invio file csv alla camera")
return
self.showDialogSignal.emit("Invio OK al laser e camera")
else:
Logger().info("Invio file " + csvFilename +
" alla camera non richiesto")
self.showDialogSignal.emit("Invio OK al laser")
self.__processBean.setCsvRegThreadCsvNewEmpty(False)
def startProcess(self):
try:
# self.ftpController.connect(host="192.168.1.1")
self.startedSignal.emit()
self.ftpController.connect()
self.ftpController.login()
# self.nlst()
self.timer.start()
self.isConnectedSignal.emit(True)
except ftplib.all_errors as ftpErr:
Logger().error("FTPWatcher error:" + str(ftpErr))
self.ftpController.close()
self.restartProcess()
def start(self):
Logger().logger.info("MotionDetector started")
while True:
if self.handler.stop: break
time_string = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S')
name = '%s' % time_string
img1 = self.cam.Capture()
img2 = self.cam.Capture()
if (self.handler.sendLatest):
self.handler.sendLatest = False
path = '%s%s_c%s_02%s' % (self.folder, name, nonZero,
self.extension)
cv2.imwrite(path, img1)
FeroxBot().sendImageToAll(path)
dm = DetectMotion(img1, img2)
(motion_found, img1_1, img2_1, contourCount, img2_processed,
nonZero) = dm.detect_motion()
if not motion_found:
continue
Logger().logger.info("Motion detected: %s", contourCount)
path = '%s%s_c%s_02%s' % (self.folder, name, nonZero,
self.extension)
#cv2.imwrite('%s%s_c%s_01%s' % (self.folder, name, nonZero, self.extension), img1_1)
cv2.imwrite(path, img2_1)
FeroxBot().sendImageToAll(path)
def removeErrorFileFromLaser(self):
Logger().info("Rimozione file error dal laser")
ftpController = FTP()
ftpController.host = self.__settingsBean.getLaserIp()
ftpController.port = self.__settingsBean.getLaserPort()
laserFTPRemotePath = self.__settingsBean.getLaserRemotePath()
errorFilename = self.__settingsBean.getLocalLaserErrorFilename()
try:
ftpController.connect()
ftpController.login()
ftpController.cwd(laserFTPRemotePath)
Logger().info("Rimozione file: " + errorFilename)
ftpController.delete(errorFilename)
except ftplib.all_errors as ftpErr:
Logger().error("Errore rimozione file: " + str(ftpErr))
self.showDialogSignal.emit(
"Errore cancellazione file csv dal laser - " + str(ftpErr))
finally:
ftpController.close()
Logger().info("Rimozione file error dal laser")
def __init__(self):
super(M, self).__init__()
'''
Classe Peer to Peer com os metodos
ClientConfig, ServerConfig, Listening, Reading
O ip client deve ser o ip config da outra ponta
e o ip server dessa ponta deve ser o ip client da outra
'''
self.p2p = P2P()
self.p2p.clientConfig('192.168.1.102', 9000)
self.p2p.serverConfig('192.168.1.102', 9001)
'''
Para boas praticas, a UI está separada em uma pasta
'''
loadUi('ui/M.ui', self)
self.setWindowTitle('mesario')
'''
O sistema comporta-se de duas threads,
1° é para ficar ouvindo o socket
2° para verificar se pode ou não habilitar os botoes
tem uma variavel no P2P que é responsavel por essa função
'''
self.tread = Thread(target=self.p2p.listening)
self.tread.start()
self.treadV = Thread(target=self.verify)
self.treadV.start()
'''
Classe Logger, já ajusta arquivos
'''
self.logger = Logger('data/eleitores.txt', 'data/votos.txt')
if self.logger.compare() is not True:
#Aparecer mensagem de texto
self.logger.repair()
self.lbAguardando.hide()
self.btLiberar.clicked.connect(self.btLiberar_click)
def removeCsvFileFromDevices(self):
Logger().info("Rimozione file cartella laser")
ftpController = FTP()
ftpController.host = self.__settingsBean.getLaserIp()
ftpController.port = self.__settingsBean.getLaserPort()
laserFTPRemotePath = self.__settingsBean.getLaserRemotePath()
cameraPath = self.__settingsBean.getCameraRemotePath()
csvFilename = self.__settingsBean.getLocalCsvFilename()
csvCameraPath = cameraPath + "\\" + csvFilename
try:
ftpController.connect()
ftpController.login()
ftpController.cwd(laserFTPRemotePath)
Logger().info("Rimozione file: " + csvFilename)
ftpController.delete(csvFilename)
except ftplib.all_errors as ftpErr:
Logger().error("Errore rimozione file: " + str(ftpErr))
self.showDialogSignal.emit(
"Errore cancellazione file csv dal laser - " + str(ftpErr))
finally:
ftpController.close()
try:
if os.path.exists(csvCameraPath):
Logger().debug("Rimozione file .csv dalla camera")
os.remove(csvCameraPath)
except OSError as err:
if err != errno.ENOENT:
Logger().error("Errore rimozione file dalla camera")
self.showDialogSignal.emit(
"Errore cancellazione file csv dalla camera")
Logger().info("Rimozione file cartella laser OK")
logsDir = os.path.join(os.getcwd(), 'logs')
#resultsDir = os.path.join(os.getcwd(), 'results')
if not os.path.exists(logsDir):
os.mkdir(logsDir)
#if not os.path.exists(resultsDir):
# os.mkdir(resultsDir)
logger = Logger(args.nolog, args.verbose)
#single target or multiple targets
if(args.target and args.tlist):
logger.PrintError("You can request Geolocation information either for a single target(-t) or a list of targets(-T). Not both!", args.nolog)
sys.exit(2)
#my ip address or single target
import pkgutil
import importlib
from core import pyperclip
from core.configobj import ConfigObj
from core.Hash_ID_v1_1 import *
from core.Logger import Logger
#### static variable ####
config_file = os.path.join(os.getenv('HOME'), ".Slx7hS3ns3onLinux.cfg")
config = ConfigObj(config_file)
if 'GLOBAL' not in config.keys():
config['GLOBAL'] = {}
config['GLOBAL']['DEBUG'] = 1
config.write()
logger = Logger('main').__new__()
dictOfNotifiers = {}
dictOfParsers = {}
dictOfTransltors = {}
dictOfDecrypter = {}
#### global variable ####
DEBUG = int(config['GLOBAL']['DEBUG'])
expectedLang = []
def log(m):
if DEBUG:
logger.info(m)
def __init__(self, nolog=False, verbose=False):
self.Logger = Logger(nolog, verbose)
except TypeError as err:
message = 'TypeError in this data: ' + str(err)
Logger.error(os.path.basename(__file__), message)
return render_template('home.html', topicsList = ErrorMessage)
except ValueError as err:
message = 'ValueError in this data: ' + str(err)
Logger.error(os.path.basename(__file__), message)
return render_template('home.html', topicsList = ErrorMessage)
except AttributeError as err:
message = 'AttributeError in this data: ' + str(err)
loggerObj.error(os.path.basename(__file__), message)
return render_template('home.html', topicsList = ErrorMessage)
except:
message = 'Error encountered for this data: ' + str(sys.exc_info()[0])
Logger.error(os.path.basename(__file__), message)
return render_template('home.html', topicsList = ErrorMessage)
@app.route('/about')
def about():
return render_template('about.html', topicsList = [])
@app.route('/contact')
def contact():
return render_template('contact.html', topicsList = [])
if __name__ == '__main__':
loggerObj = Logger()
processObj = Processing()
app.run(debug = True)
import json
import os
from core import core
from core.Logger import Logger
logger = Logger(__name__)
def merge_todo_lists(*todo_lists):
"""Merge todo lists keeping only unique values."""
logger.log.info("Merging todo lists")
new_lists = {}
for list_entry in todo_lists:
for k in list_entry:
new_lists[k] = list_entry[k]
return new_lists
def read_json_data(fn=core.lists_fn):
"""Read in todo lists from a JSON file."""
if not os.path.exists(fn):
msg = f"JSON file {fn} does not exist"
logger.log.warning(msg)
return False, msg
logger.log.info(f"Reading JSON file {fn}")
try:
with open(fn, "r", encoding="utf-8") as f:
# Merge lists
def __init__(self, config):
self.logger = Logger()
self.dataRouter = DataRouter(self)
self.serviceManager = ServiceManager(self, config)
self.configManager = ConfigManager(config,
self.serviceManager.services)
def main():
# no args provided
if len(sys.argv) == 1:
parser.print_help()
sys.exit(1)
logsDir = os.path.join(os.getcwd(), 'logs')
#resultsDir = os.path.join(os.getcwd(), 'results')
if not os.path.exists(logsDir):
os.mkdir(logsDir)
#if not os.path.exists(resultsDir):
# os.mkdir(resultsDir)
logger = Logger(args.nolog, args.verbose)
#single target or multiple targets
if (args.target and args.tlist):
logger.PrintError(
"Вы можете запросить геолокационную информацию либо для одной цели (- t), либо для списка целей(-T). Только не оба!",
args.nolog)
sys.exit(2)
#my ip address or single target
if (args.target and args.myip):
logger.PrintError(
"Вы можете запросить геолокационную информацию либо для одной цели (- t), либо для вашего собственного IP-адреса. Только не оба!",
args.nolog)
sys.exit(3)
#multiple targets or my ip address
if (args.tlist and args.myip):
logger.PrintError(
"Вы можете запросить геолокационную информацию либо для списка целей (- T), либо для вашего собственного IP-адреса. Только не оба!!",
args.nolog)
sys.exit(4)
#single target and google maps only allowed
if (args.tlist and args.g):
logger.PrintError(
"Google maps location работает только с одиночными целями.",
args.nolog)
sys.exit(5)
#specify user-agent or random
if (args.uagent and args.ulist):
logger.PrintError(
"Вы можете либо указать строку агента пользователя, либо позволить IPGeolocation выбрать случайные строки агента пользователя для вас из файла.",
args.nolog)
sys.exit(6)
#specify proxy or random
if (args.proxy and args.xlist):
logger.PrintError(
"Вы можете либо указать прокси-сервер, либо позволить IPGeolocation выбрать случайные прокси-соединения для вас из файла.",
args.nolog)
sys.exit(7)
#init lib
ipGeoLocRequest = IpGeoLocationLib(args.target, logger, args.noprint)
print(banner)
#retrieve information
if not ipGeoLocRequest.GetInfo(args.uagent, args.tlist, args.ulist,
args.proxy, args.xlist, args.csv, args.xml,
args.txt, args.g):
logger.PrintError(
"Не удалось получить информацию о геолокации IP-адресов.")
sys.exit(8)
def start_polling(self):
Logger().logger.info("Started polling")
self.updater.start_polling()
from core.Logger import Logger """ This module returns instance of logger """ logger = Logger().getLogger()
from controller.ProcessController import ProcessController
from core.Logger import Logger
import resources
if __name__ == "__main__":
# Set up the application window
app = QGuiApplication(sys.argv)
version = "1.0.2"
app.setOrganizationName("DV")
app.setApplicationName("CSV-Synchronizer")
app.setApplicationVersion(version)
Logger().info("Start applicazione CSV-Synchronizer")
Logger().info("Versione: " + version)
# qmlFile = QFile(":/ui/main.qml")
# qmlFile.open(QFile.ReadOnly | QFile.Text)
# Load the QML file
# qmlFile = os.path.join(os.path.dirname(__file__), "./ui/main.qml")
qmlRegisterType(SettingsController, "SettingsController", 1, 0, "QMLSettingsController")
qmlRegisterType(ProcessController, "ProcessController", 1, 0, "QMLProcessController")
qmlRegisterType(ProcessBean, "ProcessBean", 1, 0, "QMLProcessBean")
qmlRegisterType(SettingsBean, "SettingsBean", 1, 0, "QMLSettingsBean")
engine = QQmlApplicationEngine()
engine.load(":/ui/main.qml")