class NewUserPasswordCsvExporter(ResultExporter):
"""
Export passwords of new users to a CSV file.
"""
field_names = ("username", "password", "role", "lastname", "firstname",
"schools", "classes")
def __init__(self, *arg, **kwargs):
super(NewUserPasswordCsvExporter, self).__init__(*arg, **kwargs)
self.factory = Factory()
self.a_user = self.factory.make_import_user([])
def get_iter(self, user_import):
"""
Return only the new users.
"""
li = list()
map(li.extend, user_import.added_users.values())
li.sort(key=lambda x: int(x['entry_count'])
if isinstance(x, dict) else int(x.entry_count))
return li
def get_writer(self):
"""
Use the user result csv writer.
"""
return self.factory.make_user_writer(field_names=self.field_names)
def serialize(self, user):
if isinstance(user, ImportUser):
pass
elif isinstance(user, dict):
user = self.a_user.from_dict(user)
else:
raise TypeError(
"Expected ImportUser or dict but got {}. Repr: {}".format(
type(user), repr(user)))
return dict(
username=user.name,
password=user.password,
role=user.role_sting,
lastname=user.lastname,
firstname=user.firstname,
schools=",".join(user.schools),
classes=user.school_classes_as_str,
)
class UserImportCsvResultExporter(ResultExporter):
"""
Export the results of the user import to a CSV file.
"""
field_names = ("line", "success", "error", "action", "role", "username", "schools", "firstname", "lastname", "birthday", "email", "disabled", "classes", "source_uid", "record_uid", "error_msg")
def __init__(self, *arg, **kwargs):
"""
:param arg: list: ignored
:param kwargs: dict: ignored
"""
super(UserImportCsvResultExporter, self).__init__(*arg, **kwargs)
self.factory = Factory()
self.a_user = self.factory.make_import_user([])
def get_iter(self, user_import):
"""
Iterator over all ImportUsers and errors of the user import.
First errors, then added, modified and deleted users.
:param user_import: UserImport object used for the import
:return: iterator: both ImportUsers and UcsSchoolImportError objects
"""
def exc_count(exc):
if exc.import_user:
entry_count = exc.import_user.entry_count
else:
entry_count = 0
return max(exc.entry_count, entry_count)
li = sorted(user_import.errors, key=exc_count)
for users in [user_import.added_users, user_import.modified_users, user_import.deleted_users]:
tmp = list()
map(tmp.extend, [u for u in users.values() if u])
li.extend(tmp)
li.sort(key=lambda x: int(x['entry_count']) if isinstance(x, dict) else int(x.entry_count))
return li
def get_writer(self):
"""
Object that will write the data to disk/network in the desired format.
:return: an object that knows how to write data
"""
return self.factory.make_user_writer(field_names=self.field_names)
def serialize(self, obj):
"""
Make a dict of attr_name->strings from an import object.
:param obj: object to serialize
:return: dict: attr_name->strings that will be used to write the
output file
"""
is_error = False
if isinstance(obj, ImportUser):
user = obj
elif isinstance(obj, UcsSchoolImportError):
user = obj.import_user
is_error = True
elif isinstance(obj, dict):
user = self.a_user.from_dict(obj)
else:
raise TypeError("Expected ImportUser, UcsSchoolImportError or dict but got {}. Repr: {}".format(type(obj), repr(obj)))
if not user:
# error during reading of input data
user = self.factory.make_import_user([role_pupil]) # set some role
user.roles = [] # remove role
return dict(
line=getattr(user, "entry_count", 0),
success=int(not is_error),
error=int(is_error),
action=user.action,
role=user.role_sting if user.roles else "",
username=user.name,
schools=" ".join(user.schools) if user.schools else user.school,
firstname=user.firstname,
lastname=user.lastname,
birthday=user.birthday,
email=user.email,
disabled="0" if user.disabled == "none" else "1",
classes=user.school_classes_as_str,
source_uid=user.source_uid,
record_uid=user.record_uid,
error_msg=str(obj) if is_error else ""
)