def update_files_in_db(self):
files = os.listdir(GlobalConstants.filesPath)
original_company_id = admin.company_id # to restore original company id on db
admin.company_id = sample_organiztion_id # using sample organization as default company id
updated_files = []
for file in files:
if os.path.isdir(os.path.join(GlobalConstants.filesPath, file)):
continue
filename, extension = os.path.splitext(file)
if filename[:2] == "~$": # these are temp excel files created by ms excel
os.remove(os.path.join(GlobalConstants.filesPath, file))
continue
try:
id_ = UUID(filename) # if file name is uuid that means this might already has entry in db
db_row = db.session.query(models.File).filter_by(id=filename).first()
if not db_row: # if row is not found then create a new File object with this file
db_row = self.create_new(file, extension)
if db_row.processed: # if file is already processed these means we haven't moved it in archived
logger.info(f"{file} is already processed! Skipping it")
self.move_processed_file(file)
except ValueError: # we get value error when filename is not uuid, so update that file in db & rename it
updated_files.append(self.create_new(file, extension))
admin.company_id = original_company_id
self.update_unprocessed_rows() # fill unprocessed data in unprocessed_rows
return updated_files
def notifications():
user = auth.current_user()
toast = db.session.query(ToastNotifications).filter_by(
seen_at=None).filter_by(user_id=user.id).filter_by(
company_id=user.company_id).first()
if toast:
if toast.type == "badge":
badge = db.session.query(GamificationBadge).filter_by(
id=toast.message).first()
if badge:
messenger.announce_badge(badge=badge, duration=5000)
else:
logger.info(f"Badge id {str(toast.message)} not found.")
else:
msg = json.dumps({
'text': toast.message,
'autoHideDuration': toast.duration,
'variant': toast.type,
'anchorOrigin': {
'horizontal': toast.horizontal,
'vertical': toast.vertical,
}
})
messenger.announce(f'data: {msg}\n\n')
toast.set_seen()
return Response(response=f"New Notifications found", status=200)
return Response(response=f"No Notification", status=200)
def _get_default_data(self):
stage = 'pqa'
output_dir = ''
offline = False
try:
config = configparser.ConfigParser()
# pathlib.Path resolves issue of lowercase path stored in __file__ which was creating issue in configparser
config.read(self.setting_file)
default = config["Default"]
except Exception as ex:
logger.critical(f"Exception while reading config file: {ex}")
return offline, output_dir, stage
stage = default.get("stage", stage)
unchecked_path = default.get("PDFOutput")
try:
if unchecked_path:
Path(unchecked_path).mkdir(parents=True, exist_ok=True)
output_dir = unchecked_path
except Exception as ex:
output_dir = ''
logger.info(f"Error during Path creation: {ex}")
if default.get("offline", "").lower().strip() == "true":
offline = True
return offline, output_dir, stage
def check_processable(cls,
data: dict,
filename: str,
original_filename=""):
"""
This is an important method which should be override in inherited class. Please define the logic here to
see if the data or filename has any hint which leads to believe that the data should be processed by this class.
Please refer the logic below for further knowledge.
:param data:
:param filename:
:param original_filename:
:return:
"""
# we try to find flags here which can determine if this class can process targetted data
for key in data.keys(
): # trying to see if data has as particular thing which only belongs to current antrag
if key.lower().strip() == "product" or key.lower().strip(
) == "produkt":
if data[key].lower() == "rs" or data[key].lower(
) == "rechtschutz":
logger.info(f"{cls.__class__.__name__} will process data")
return True
if "rs_" in filename.lower() or "rechtschutz" in filename.lower(
): # else try to determine it with classname
return True
elif "rs_" in original_filename.lower(
) or "rechtschutz" in original_filename.lower():
return True
logger.info("No class found to process data")
return False
def getInstance():
"""
Method to get the singleton instance into any calling class/form
"""
if not ConfigurationProvider.__instance__:
logger.info("ConfigurationProvider instance created")
ConfigurationProvider()
logger.debug("returning existing ConfigurationProvider")
return ConfigurationProvider.__instance__
def translate(self, word, language=None):
if not language:
language = self.default_language
language = language.lower()
if language == "en":
return word
translations = self.data.get(word)
if translations:
result = translations.get(language)
else:
result = word
logger.info(f'Translation of "{word}" for language "{language}" not found!')
return result
def __init__(self, setting_file=Path(os.path.abspath(__file__)).parent.parent.joinpath("run_setting.ini")):
logger.info("Executing __init__ in ConfigurationProvider")
self.configsRead = {}
self.badConfigs = {}
# pathToConfig can and should be overwritten if needed otherwise:
self.pathToConfig = Path(os.getcwd()).joinpath("Configurations")
self.basePath = Path(os.getcwd())
self.setting_file = setting_file
if not self.pathToConfig.exists():
self.pathToConfig = Path(os.path.abspath(__file__)).parent.parent.joinpath("Configurations")
self.basePath = Path(os.path.abspath(__file__)).parent.parent
result = self.__checkAndReadConfigurations("default")
if not result:
logger.critical("Default configuration was not found. Aborting.")
raise NotImplementedError("Default configuration not found. Aborting.")
self.language = "en" # default fallback language is english
self.offline, self.PDFOutput, self.defaultStage = self._get_default_data()
def __checkIfEmptyValue(
inValue) -> bool: # Will return true if empty, flase if not empty.
if not inValue:
return True
if isinstance(inValue, str):
if len(inValue.strip()) > 0:
return False
return True
if isinstance(inValue, (int, float)):
return False
if isinstance(inValue, (list, dict)):
return len(inValue) == 0
if isinstance(inValue, FieldVisibilityTypes):
return False
logger.info(
f"not sure how to handle this field value {inValue}, it's type {type(inValue)}. Will parse to FE"
)
return True
def updateFieldValues(self, updateValues):
"""
Frontend (or anything) sends new values for fields of antrag instance.
If the values are really new/changed, we execute follow up processes.
:param updateValues: dict of {<field>:<value>}
:return: Nothing
"""
logger.info(
f'New Values (most probably from Frontend):\n{updateValues}')
if not self.status: # return if status is empty # take a look sir
return
if AntragsStatus.getStatusNumberFromText(
self.status) >= AntragsStatus.getStatusNumberFromText(
AntragsStatus.s800_sent):
self.announceMessage(
"Antrag bereits gesendet. Leider keine Änderug mehr möglich.")
return
self._updateFieldValues(updateValues)
def _saveXMLorJSONResultAsPrettyPrinted(self,
resultToPrint,
operation: str = None):
"""
Used for debugging when we want to save requests/responses from XML or JSON to files.
:param resultToPrint:
:param operation:
:return:
"""
if not LogLevelUpdater().saveJson:
return
if not operation:
operation = self.__class__.__name__
try:
lFileNameResult = f"{self.configurationProvider.basePath}/JsonFilesDelete/{self.polizze.polizzenNummer}_" \
f"{operation}_" \
f"{datetime.now().strftime(GlobalConstants.dateFormatLong)}_reply.json"
except Exception:
if hasattr(self, "antrag"):
lFileNameResult = f"{self.configurationProvider.basePath}/JsonFilesDelete/" \
f"Antrag_{self.antrag.sapClient}_" \
f"{self.antrag.productName.replace('/', '_')}_" \
f"{operation}_{datetime.now().strftime(GlobalConstants.dateFormatLong)}_reply.json"
else:
lFileNameResult = f"{self.configurationProvider.basePath}/JsonFilesDelete/" \
f"UnknownRootObject_" \
f"{operation}_{datetime.now().strftime(GlobalConstants.dateFormatLong)}_reply.json"
if isinstance(resultToPrint, dict):
try:
with open(lFileNameResult, "w") as resultFile:
json.dump(resultToPrint, fp=resultFile, indent=4)
logger.debug(f"File written: {lFileNameResult}")
return
except Exception as e:
logger.critical(f"Fehler beim JSON-Dump {e}")
return
if not resultToPrint:
logger.info(
"Should have printed result of call, but there was nothing in it."
)
return
try:
lDOMString = xml.dom.minidom.parseString(resultToPrint)
with open(lFileNameResult, "w") as resultFile:
resultFile.write(lDOMString.toprettyxml())
logger.debug(f"File written: {lFileNameResult}")
return
except Exception as e:
logger.debug(
f"Error during XML-Dump: {e}, will fallback to text dump.")
# If we can't write it as XML nor JSON, maybe we can save a text at least:
try:
with open(lFileNameResult, "w") as resultFile:
resultFile.write(str(resultToPrint))
logger.debug(f"File written {lFileNameResult}")
except Exception as e:
logger.critical(
f"Error {e} during writing of interface file. Filename was {lFileNameResult}. "
f"resultToPrint was {resultToPrint}. Error as ")