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 "" )