def process(self):
email = self.managerInstance.unprocessed_db_obj.user.email # to create instance for target user
for filename in self.data:
if isinstance(
self.data[filename], dict
): # if data type is dict that it contains, error so updating it
self.managerInstance.details[filename] = self.data[
filename] # in details
continue
for data in self.data[filename]:
try:
self.managerInstance.details[filename] = {
"processing_class": "",
"status_ok": True
}
class_ = self.get_data_processing_class(
data, filename, self.managerInstance.original_filename)
self.managerInstance.details[filename][
"processing_class"] = class_.__name__
processing_class = class_(email=email, **data)
self.managerInstance.details[filename][
"processing_class_messages"] = processing_class.details
except Exception as ex:
logger.critical(f"Exception while processing: {str(ex)}")
self.managerInstance.details[filename]["error"] = str(ex)
self.managerInstance.details[filename]["status_ok"] = False
def set_seen(self):
self.is_seen = True
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
def user_permissions():
# get request data
try:
data = request.get_json()
# get company id
company_id = data.get('id')
if company_id is None:
current_app.logger.warning(
f'Payload does not contain company id. Payload: {data}')
raise Exception('Payload does not contain company id')
# update company
user = auth.current_user()
company_details = user.set_company(company_id=company_id)
return jsonify({
'permissions': permissions(user),
'company': company_details,
}), 200
except Exception as e:
print(e)
from polzyFunctions.GlobalConstants import logger
logger.critical(f"Error: {e}", stack_info=True)
return {'error': f'Failed to set company: {e}'}, 400
def set_language(self, language):
self.language = language
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
def set_seen(self):
self.seen_at = datetime.now()
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
def set_processed(cls, file, processed_obj=None, details=None, key=None):
if not details:
details = {}
filename, extension = os.path.splitext(file)
if not processed_obj: # getting File row object if not supplied
processed_obj = db.session.query(models.File).filter_by(id=filename).first()
if not key: # zip file has different name on storage and details dict. Key is name for details dict
key = os.path.basename(file)
if extension.lower() == ".zip":
if not os.path.exists(filename):
filename = os.path.join(GlobalConstants.filesPath, filename)
if not os.path.exists(filename):
processed_obj.set_processed(details=details.get(key, {}))
return
files = os.listdir(filename)
for extracted_file in files: # these files are already processed, now creating entry in db & updating
instance = cls.create_new(file=os.path.join(filename, extracted_file
).replace(GlobalConstants.filesPath, ""),
extension=os.path.splitext(extracted_file)[1],
parent_id=filename) # parent_id means this entry is child of a zip file
cls.set_processed(
instance.id + os.path.splitext(extracted_file)[1], instance, details=details, key=extracted_file
) # marking the zip extracted file processed with necessary details. Details key is original filename
try:
os.rmdir(filename) # after processing and moving all files delete zip directory
except Exception as ex: # if zip directory is not empty it will create error
logger.critical(f"Exception while removing directory {filename}: {str(ex)}")
details[key] = details.copy()
processed_obj.set_processed(details=details.get(key, {}))
cls.move_processed_file(os.path.basename(file)) # moving files to processed files directory
def set_company(self, company_id=None, company=None):
# check if company data is provided
if company_id is None and company is None:
raise Exception('Neither Company ID nor Company provided')
# check if company should be fetched
if company is None:
company = db.session.query(Company).filter_by(id=company_id).first()
# check if company exists
if company is None:
raise Exception('Company not found')
# get UserToCompany instance
user_company = db.session.query(UserToCompany).filter(and_(
UserToCompany.user_id == self.id,
UserToCompany.company_id == company.id,
)).first()
# check if association exists
if user_company is None:
raise Exception(f'User is not assigned to company ID {company_id}')
# set company
self.company_id = company.id
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
# return company json
return user_company.to_json()
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 activityWriter(inInstance):
"""
The usage of "Antrag" here is wrong, usually it's an AntragActivitiy that will be provided in the call.
It is anyway important to have this reference because otherwise the "where used" doesn't work for "setSearchString"
"""
from polzyFunctions.Dataclasses.Antrag import Antrag
lInstance = None
try:
lInstance = inInstance.antrag
except AttributeError:
pass
if not lInstance:
# this will work if the instance itself is an Antrag (happens so far only when the Tag is changed by
# frontend
lInstance: Antrag = inInstance
logger.debug(f"classname = {lInstance.__class__.__name__}")
# Update search string in this antrag instance. It is the main search criteria.
try:
lInstance.setSearchString()
except AttributeError:
logger.critical(
f"We have instance of Type {type(inInstance)}. We can't currently work with that."
)
return
record = AntragActivityRecords.new(lInstance)
logger.debug(f"Activity recorded with id: {record.id}")
return record.timestamp
def getConfigurationParameter(self, configurationEnvironmentKey: str, configKeyToSearchFor: str):
"""
Main method to retrieve a configuration setting. It will first try to read from the given
configurationEnvironment. If that is not successful it will fallback to "default.json".
If unsuccessful, we'll create a log message.
:param configurationEnvironmentKey: Environment key (e.g. sapClient)
:param configKeyToSearchFor: The key in either default Configuration or manually set configuration
:return: the value of the configuration entry.
"""
lEnvironmentExists = self.__checkAndReadConfigurations(configurationEnvironmentKey)
if not lEnvironmentExists:
lReturn = self.configsRead["default"].get(configKeyToSearchFor)
else:
lReturn = self.configsRead.get(configurationEnvironmentKey, {}).get(configKeyToSearchFor)
if not lReturn:
lReturn = self.configsRead["default"].get(configKeyToSearchFor)
if not lReturn:
logger.critical(f"Configuration key {configKeyToSearchFor} not found in "
f"current configuration {configurationEnvironmentKey} nor in default configuration.")
return False
return lReturn
def new(cls, antrag):
json_data = {}
for activities in antrag.Activities:
json_data[activities.__class__.__name__] = activities.toJsonForPersistence()
if activities.encrypt: # if activity needs to be encrypt then encrypt it and replace
encrypted_dic = dict()
for key, value in json_data[activities.__class__.__name__].items():
encrypted_dic[cls.encrypt(key)] = cls.encrypt(value)
encrypted_dic["encrypt"] = True # used for identifying that this activity needs to be decrypt
json_data[activities.__class__.__name__] = encrypted_dic
instance = cls(
antrag_id=str(antrag.id),
user_id=str(antrag.user.id),
company_id=str(antrag.user.company_id),
antragsnummer=antrag.antragsnummer,
status=antrag.status,
searchString=antrag.searchstring,
json_data=json.dumps(antrag.Fields.toJSON()),
json_data_activities=json.dumps(json_data),
class_name=antrag.__class__.__name__,
sapClient=antrag.sapClient,
tag=antrag.tag,
)
db.session.add(instance)
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
return instance
def __init__(self, fileNameAndPath, original_filename, unprocessed_db_obj,
classes: list):
self.unprocessed_db_obj = unprocessed_db_obj # used to set processed tag on failed files
self.details = {
os.path.basename(fileNameAndPath): {}
} # used to save necessary details in db
self.processor = None
self.classes = classes
try:
self.fileName, self.extension = self.sanitize_filename(
fileNameAndPath)
self.original_filename = original_filename
self.fileHandler = Handler(self.fileName, self.original_filename,
self.extension)
self.data = self.fileHandler.data
self.process_data()
except Exception as ex:
logger.critical(
f"Exception while processing {os.path.basename(fileNameAndPath)}: {str(ex)}"
)
self.details[os.path.basename(
fileNameAndPath)]["status_ok"] = False
self.details[os.path.basename(fileNameAndPath)]["error"] = str(ex)
DatabaseManager.set_processed(os.path.basename(fileNameAndPath),
self.unprocessed_db_obj,
self.details)
def setFieldValue(self, fieldName, newValue, optional=False):
"""
Write a new value into a field of this instance.
:param fieldName:
:param newValue:
:param optional: don't raise an error/write to log, if field does not exist
:return:
"""
try:
lFeld = self.Fields.getField(name=fieldName)
lFeld.value = newValue
except Exception as e:
if not optional:
logger.critical(
f"Should have written {newValue} into field {fieldName} "
f"and failed with error {e}. Most probably typo in Program."
)
raise AttributeError(
f"Should have written {newValue} into field {fieldName} "
f"and failed with error {e}. Most probably typo in Program."
)
else:
logger.debug(
f"Should have written {newValue} into field {fieldName} "
f"and failed with error {e}. Most probably typo in Program. Optional was set, so Ok!"
)
def returnDate(string):
# some fields need date object, so we are using dateutils here to get date object
try:
dt = parse(string).strftime(GlobalConstants.dateFormat)
except Exception as ex:
logger.critical(f"Unable to parse date: {string}. Error was {ex}")
dt = datetime.now().strftime(GlobalConstants.dateFormat)
return dt
def new(cls, activity_name, line_of_business, points=1):
instance = cls(activity_name=activity_name, line_of_business=line_of_business, points=points)
db.session.add(instance)
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
def update_count():
instance = db.session.query(AntragNummer).first()
instance.count += 100
db.session.add(instance)
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
def finish(self, status):
#
# sets is_finished to True
#
self.status = status
self.finished = datetime.utcnow()
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
def set_processed(self, details=None):
if not details:
details = {}
self.processed = True
self.status_ok = details.get("status_ok", True)
if isinstance(details, dict):
details = json.dumps(details)
self.details = details
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
def get_activity(self, activity_name, optional=False):
"""
Retrieve an activity from the list of Activities in this instance by class name or activity name
:param activity_name: class name or activity name of the desired activity
:param optional: Don't raise an error if the activity can't be found
:return: the activity or None
"""
for activity in self.Activities:
if activity_name == activity.__class__.__name__ or activity_name == activity.name:
return activity
if not optional:
logger.critical(f"Cannot find activity: {activity_name}",
stack_info=True)
def new(cls, user_id, company_id, type_id):
instance = cls(
user_id=user_id,
company_id=company_id,
type_id=type_id,
)
db.session.add(instance)
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
return instance
def _toggleFieldGroupOnOff(self, listOfFieldgroupNamesToToggle: list,
OnOffAsBoolean: bool):
"""
Toggle a list of fieldgroups (=Cards on the UI) on or off by setting the value of the field-group to True/False
:param listOfFieldgroupNamesToToggle: List of the names of the fieldgroups to be effected
:param OnOffAsBoolean: True = On, False = Off
:return:
"""
for fielgroup in listOfFieldgroupNamesToToggle:
try:
self.Fields.getField(name=fielgroup).value = OnOffAsBoolean
except AttributeError:
logger.critical(
f"Field {fielgroup} not found. Typo? Forgot to add .value?"
)
def set_processed(self, commit=True):
#
# set activity as processed
#
self.processed = datetime.utcnow()
self.is_processed = True
# save to db
if commit:
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
def update_badge(self):
level_id = self.get_level_id()
badge = db.session.query(GamificationBadge).filter_by(user_id=self.user_id).filter_by(
company_id=self.company_id).filter_by(type_id=self.type_id).filter_by(level_id=level_id).first()
if not badge:
badge = GamificationBadge(
user_id=self.user_id, company_id=self.company_id, type_id=self.type_id, level_id=level_id)
db.session.add(badge)
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
ToastNotifications.new(
message=badge.id, type="badge", company_ids=self.company_id, user_ids=self.user_id
)
def new(cls, message, type="default", duration=3000, horizontal="left", vertical="top", company_ids=None, user_ids=None):
companies = []
if company_ids:
if isinstance(company_ids, list):
for company_id in company_ids:
if db.session.query(Company).filter_by(id=company_id).first():
companies.append(company_id)
else:
print(f"Company id {company_id} is not correct. Please recheck.")
else:
if db.session.query(Company).filter_by(id=company_ids).first():
companies.append(company_ids)
else:
print(f"Company id {company_ids} is not correct. Please recheck.")
else:
companies = [company.id for company in db.session.query(Company).all()]
if not companies:
print("Supplied company ids are not valid. Hence no notification will be updated")
for company_id in companies:
users = []
if not user_ids:
users = [user.id for user in db.session.query(User).filter_by(company_id=company_id).all()]
else:
if isinstance(user_ids, list):
for user_id in user_ids:
if db.session.query(User).filter_by(id=user_id).first():
users.append(user_id)
else:
print(f"User id {user_id} is not correct. Please recheck.")
else:
if db.session.query(User).filter_by(id=user_ids).first():
users.append(user_ids)
else:
print(f"User id {user_ids} is not correct. Please recheck.")
for user_id in users:
if type == "badge":
instance = cls(company_id=company_id, user_id=user_id, message=message, type=type)
else:
instance = cls(company_id=company_id, user_id=user_id, message=message, type=type,
duration=duration, horizontal=horizontal, vertical=vertical)
db.session.add(instance)
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
def newbadge():
# get user
user = User.query.first()
if user is None:
return {'error': 'There are no user in DB'}, 400
# create random badge
# get possible types
badge_level = GamificationBadgeLevel.query.first()
all_types = GamificationBadgeType.query.all()
search_type = True
count = 0
while search_type:
badge_type = choice(all_types)
search_type = any(b.type == badge_type for b in user.badges)
if search_type:
current_badge = next(
filter(lambda b: b.type == badge_type, user.badges))
if current_badge.level.next_level:
badge_level = current_badge.level.next_level
new_badge = current_badge
new_badge.level = badge_level
new_badge.is_seen = False
search_type = False
else:
new_badge = GamificationBadge(
user=user,
company=user.company.company,
type=badge_type,
level=badge_level,
)
db.session.add(new_badge)
# break if all user badges of the highest level
if count > 100:
raise Exception('No new badge is available:(')
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
messenger.announce_badge(new_badge)
return {'success': 'OK'}, 200
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 get_rank_by_category(self, rank_category, stats):
# getting weighted points for every activity and adding them up per user
unadded_user_points = {}
for stat in stats: # first getting weighted points of each activity
try:
if not stat.user.email in unadded_user_points:
unadded_user_points[stat.user.email] = []
except AttributeError:
logger.critical(
f"User id {stat.user_id} doesn't exist. So ranking is skipping it."
)
continue
unadded_user_points[stat.user.email].append([
stat.get_user_statistics().get(rank_category, 0),
stat.user.email
])
added_points = []
for user_email in unadded_user_points: # adding activity points to one per user
score = 0
for points in unadded_user_points[user_email]:
score += points[0]
added_points.append([score, user_email])
last_score = -1
last_rank = 0
ranked_data = []
for dt in sorted(added_points,
reverse=True): # ranking user as per their points
dic = {}
if dt[0] != last_score: # give same rank number if last iteration has same score
last_rank += 1
last_score = dt[0]
dt.append(last_rank)
else:
dt.append(last_rank)
dic['name'] = dt[1]
dic['operations'] = dt[0]
dic['rank'] = dt[2]
ranked_data.append(dic)
return ranked_data
def create_or_update_row(cls, activity: GamificationActivity, commit=True):
type_id = cls.get_type_id(activity.event, activity.event_details)
weightage = cls.get_weight(activity.event, activity.event_details)
if not type_id:
return None
user_id = activity.user_id
company_id = activity.company_id
user_stats = db.session.query(GamificationUserStats).filter_by(user_id=user_id
).filter_by(company_id=company_id).filter_by(type_id=type_id).first()
if user_stats:
user_stats.add_points(weight=weightage)
if not user_stats:
user_stats = GamificationUserStats.new(user_id=user_id, company_id=company_id, type_id=type_id)
user_stats.add_points(weight=weightage)
if commit:
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
return user_id
def updateFieldDataName(data):
sanitized_data = dict()
for key, value in data.items():
if key not in valid_headers: # then most probably this key contains value of some other keys in it -
try:
sanitize = getattr(sys.modules[__name__], key.lower())(
value) # e.g. name is first_name and last_name
sanitized_data.update(sanitize)
except Exception as ex:
logger.critical(
f"Found new header: {key}. This shouldn't be the case. Error was {ex}"
)
elif key in dateObj: # if key is in date object category that means we need to convert value in datetime object
processed = returnDate(value)
sanitized_data[key] = processed
else:
if key not in skipped_headers: # if key in skipped headers, that means current we want to avoid those keys.
sanitized_data[key] = value
else:
logger.debug(f"{key} skipped.")
return sanitized_data
def new(cls, user, filename, id, parent_id=None, file_type=None):
#
# create new instance of File
#
instance = cls(
id=id,
filename=filename,
user_id=user.id,
company_id=user.company_id,
parent_id=parent_id,
type=file_type,
)
db.session.add(instance)
try:
db.session.commit()
except Exception as ex:
logger.critical(f"Exception while committing changes to db: {ex}")
db.session.rollback()
return instance
