def on_apply_clicked(self, _widget):
"""Apply the changes on the user."""
username = self.user.name
self.user.name = self.username.get_text()
self.user.rname = self.gc_name.get_text()
self.user.uid = int(self.uid_entry.get_text())
self.user.office = self.gc_office.get_text()
self.user.wphone = self.gc_office_phone.get_text()
self.user.hphone = self.gc_home_phone.get_text()
self.user.other = self.gc_other.get_text()
self.user.directory = self.homedir.get_text()
self.user.shell = self.shells_entry.get_text()
self.user.lstchg = int(self.last_change.get_value())
self.user.min = int(self.minimum.get_value())
self.user.max = int(self.maximum.get_value())
self.user.warn = int(self.warn.get_value())
self.user.inact = int(self.inactive.get_value())
self.user.expire = int(self.expire.get_value())
if not '\n' in self.password.get_text():
self.user.password = self.system.encrypt(self.password.get_text())
self.user.groups = [g[1] for g in self.groups_store if g[2]]
self.user.gid = int(self.pgid.get_text())
self.user.primary_group = self.pgroup.get_text()
if self.system.gid_is_free(self.user.gid):
self.system.add_group(
libuser.Group(self.user.primary_group, self.user.gid, {}))
self.system.update_user(username, self.user)
if self.builder.get_object('locked_account_check').get_active():
self.system.lock_user(self.user)
self.dialog.destroy()
def parse(self, pwd, spwd=None, grp=None):
new_set = libuser.Set()
with open(pwd) as f:
reader = csv.reader(f, delimiter=':', quoting=csv.QUOTE_NONE)
for row in reader:
u = libuser.User()
u.name = row[0]
u.password = row[1]
u.uid = int(row[2])
u.gid = int(row[3])
gecos = row[4].split(',', 4)
gecos += [''] * (5 - len(gecos)) # Pad with empty strings so we have exactly 5 items
u.rname, u.office, u.wphone, u.hphone, u.other = gecos
u.directory = row[5]
u.shell = row[6]
new_set.add_user(u)
if spwd:
with open(spwd) as f:
reader = csv.reader(f, delimiter=':', quoting=csv.QUOTE_NONE)
for row in reader:
name = row[0]
u = new_set.users[name] # The user must exist in passwd
u.password = row[1]
nums = ['lstchg', 'min', 'max', 'warn', 'inact', 'expire']
for i, att in enumerate(nums, 2):
try:
u.__dict__[att] = int(row[i])
except:
pass
if grp:
with open(grp) as f:
reader = csv.reader(f, delimiter=':', quoting=csv.QUOTE_NONE)
gids_map = {} # This is only used to set the primary_group User attribute
for row in reader:
g = libuser.Group()
g.name = row[0]
g.gid = int(row[2])
members = row[3].split(',')
if members == ['']:
members = []
g.members = {}
for name in members:
g.members[name] = new_set.users[name]
new_set.users[name].groups.append(g.name)
new_set.add_group(g)
gids_map[g.gid] = g.name
for u in new_set.users.values():
u.primary_group = gids_map[u.gid]
if u.primary_group in u.groups:
u.groups.remove(u.primary_group)
#u.groups.append(u.primary_group)
return new_set
def on_apply_clicked(self, widget):
name = self.groupname.get_text()
gid = int(self.gid_entry.get_text())
members = {u[0].name : u[0] for u in self.users_store if u[1]}
g = libuser.Group(name, gid, members)
self.system.add_group(g)
if self.has_shared.get_active():
self.sf.add([g.name])
self.dialog.destroy()
def parse(self, fname):
# Open the CSV as dictionary
with open(fname) as f:
users_dict = csv.DictReader(f)
users = {}
groups = {}
for user_d in users_dict:
# convert the user dictionary to a user object.
user = libuser.User()
for key, value in user_d.items():
try:
user.__dict__[self.fields_map[key]] = value # FIXME: Here we lose the datatype
except:
pass
# Try to convert the numbers from string to int
int_attributes = ['lstchg', 'gid', 'uid', 'expire', 'max', 'warn', 'min', 'inact']
for attr in int_attributes:
try:
user.__dict__[attr] = int(user.__dict__[attr])
except ValueError:
user.__dict__[attr] = None
# If plainpw is set, override and update password
if user.plainpw:
user.password = libuser.get_system().encrypt(user.plainpw)
# Convert groups string to groups object
if user.name:
users[user.name] = user
user_groups_string = user.groups
user.groups = []
for g in user_groups_string.split(','):
pair = g.split(':')
if len(pair) == 2:
gname, gid = pair
try:
gid = int(gid)
except ValueError:
gid = None
else: # There is no GID specified for this group
gname = g
gid = None
if gname != '':
user.groups.append(gname)
# Create Group instances from memberships
if gname not in groups:
groups[gname] = libuser.Group(gname, gid)
groups[gname].members[user.name] = user
if user.groups == '':
user.groups = None
return libuser.Set(users, groups)
def on_apply_clicked(self, _widget):
"""Apply the changes for the new group, then close the dialog."""
name = self.groupname.get_text()
gid = int(self.gid_entry.get_text())
members = {u[0].name: u[0] for u in self.users_store if u[1]}
grp = libuser.Group(name, gid, members)
self.system.add_group(grp)
if self.has_shared.get_active():
self.oneself.add([grp.name])
self.dialog.destroy()
def apply(self, _widget):
"""Apply the changes in order to create a new group and add users in it."""
text = "Να δημιουργηθούν οι νέοι χρήστες;"
response = dialogs.AskDialog(text, "Confirm").showup()
if response == Gtk.ResponseType.YES:
new_groups = {}
new_gids = [usr.gid for usr in self.set.users.values()]
sys_gids = [grp.gid for grp in libuser.system.groups.values()]
for usr in self.set.users.values():
if usr.primary_group not in libuser.system.groups:
if usr.primary_group not in new_groups:
g_obj = libuser.Group(usr.primary_group, usr.gid)
new_groups[usr.primary_group] = g_obj
new_groups[usr.primary_group].members[usr.name] = usr
for usr in self.set.users.values():
for grp in usr.groups:
if grp not in libuser.system.groups:
if grp not in new_groups:
g_obj = libuser.Group(grp)
if grp in self.set.groups:
g_obj.gid = self.set.groups[grp].gid
if g_obj.gid in new_gids + sys_gids or g_obj.gid is None:
g_obj.gid = libuser.system.get_free_gid(
exclude=new_gids)
new_gids.append(g_obj.gid)
new_groups[grp] = g_obj
new_groups[grp].members[usr.name] = usr
for group in new_groups.values():
gr_tmp = libuser.Group(group.name, group.gid)
libuser.system.add_group(gr_tmp)
for usr in self.set.users.values():
libuser.system.add_user(usr)
for group in new_groups.values():
for usr in group.members.values():
libuser.system.add_user_to_groups(usr, [group])
else:
return False
self.dialog.destroy()
def resolve_conflicts(self, _widget=None):
"""If there are any conflicts found they are resolved."""
# All the system users
sys_users = {'uids': [], 'gids': [], 'dirs': []}
sys_users['uids'] = [
user.uid for user in libuser.system.users.values()
]
sys_users['gids'] = [
user.gid for user in libuser.system.users.values()
]
sys_users['dirs'] = [
user.directory for user in libuser.system.users.values()
]
# All the users in the new Set
new_users = {'uids': [], 'gids': [], 'dirs': []}
new_users['uids'] = [user.uid for user in self.set.users.values()]
new_users['gids'] = [user.gid for user in self.set.users.values()]
new_users['dirs'] = [
user.directory for user in self.set.users.values()
]
log = []
def log_msg(item, user, attr1, attr2):
"""Show a message with the change applied on a user."""
txt = "Αλλάχθηκε το %s του χρήστη '%s' από %s σε %s." % (
item, user, attr1, attr2)
log.append(txt)
return txt
def log_uid(usr, field1, field2):
return log_msg('UID', usr, field1, field2)
def log_gid(usr, field1, field2):
return log_msg('GID', usr, field1, field2)
def _log_home(usr, field1, field2):
return log_msg('Home', usr, field1, field2)
def log_group(usr, field1, field2):
return log_msg('όνομα του primary group', usr, field1, field2)
for row in self.list:
if row[60] != self.states['error']:
continue
usr = self.set.users[row[0]]
ofs = 40
if row[1 + ofs] in ['dup', 'con']:
new_uid = libuser.system.get_free_uid(
exclude=new_users['uids'])
new_users['uids'].append(new_uid)
log_uid(usr.name, usr.uid, new_uid)
usr.uid = new_uid
self.set_row_props(row, 1, '')
elif row[1 + ofs] == 'hijack':
dir_uid = os.stat(usr.directory).st_uid
new_users['uids'].append(dir_uid)
log_uid(usr.name, usr.uid, dir_uid)
usr.uid = dir_uid
self.set_row_props(row, 1, '')
#if row[2+ofs] in ['dup', 'con']:
# new_gid = libuser.system.get_free_gid(exclude=new_users['gids'])
# new_users['gids'].append(new_gid)
# log_gid(usr.name, usr.gid, new_gid)
# usr.uid = new_uid
# self.set_row_props(row, 2, '')
if 'mismatch' in row[2 + ofs]:
new_gid = int(row[2 + ofs].split()[1])
new_users['gids'].append(new_gid)
log_gid(usr.name, usr.gid, new_gid)
if usr.primary_group in self.set.groups:
self.set.groups[usr.primary_group].gid = new_gid
usr.gid = new_gid
self.set_row_props(row, 2, '')
if row[2 + ofs] == 'hijack':
dir_gid = os.stat(usr.directory).st_gid
new_users['gids'].append(dir_gid)
log_gid(usr.name, usr.gid, dir_gid)
usr.gid = dir_gid
self.set_row_props(row, 2, '')
if 'mismatch' in row[3 + ofs]:
new_gname = row[3 + ofs].split()[1]
log_group(usr.name, usr.primary_group, new_gname)
if new_gname in self.set.groups:
if usr.name not in self.set.groups[new_gname].members:
self.set.groups[new_gname].members[usr.name] = usr
else:
self.set.groups[new_gname] = libuser.Group(
new_gname, usr.gid)
self.set.groups[new_gname].members[usr.name] = usr
if usr.primary_group in self.set.groups:
if self.set.groups[usr.primary_group].members.keys() == [
usr.name
]:
del self.set.groups[usr.primary_group]
else:
del self.set.groups[usr.primary_group].members[
usr.name]
usr.primary_group = new_gname
self.set_row_props(row, 3, '')
self.set_row_from_object(row)
num = len(log)
if num > 0:
log_dlg = self.builder.get_object('log_dialog')
buf = self.builder.get_object('logbuffer')
buf.set_text('\n'.join(log))
log_dlg.run()
log_dlg.hide()
self.detect_conflicts()
else:
dialogs.WarningDialog(
'Δεν ήταν δυνατή η αυτόματη επίλυση κάποιου προβλήματος'
).showup()
def Apply(self, widget):
text = _("Create the following users?\n\n" +
', '.join([u.name for u in self.set.users.values()]))
response = dialogs.AskDialog(text, "Confirm",
parent=self.dialog).showup()
if response == Gtk.ResponseType.YES:
new_groups = {}
new_gids = [u.gid for u in self.set.users.values()]
sys_gids = [g.gid for g in libuser.get_system().groups.values()]
for u in self.set.users.values():
if u.primary_group not in libuser.get_system().groups:
if u.primary_group not in new_groups:
g_obj = libuser.Group(u.primary_group, u.gid)
new_groups[u.primary_group] = g_obj
new_groups[u.primary_group].members[u.name] = u
for u in self.set.users.values():
for g in u.groups:
if g not in libuser.get_system().groups:
if g not in new_groups:
g_obj = libuser.Group(g)
if g in self.set.groups:
g_obj.gid = self.set.groups[g].gid
if g_obj.gid in new_gids + sys_gids or g_obj.gid is None:
g_obj.gid = libuser.get_system().get_free_gid(
exclude=new_gids)
new_gids.append(g_obj.gid)
new_groups[g] = g_obj
new_groups[g].members[u.name] = u
operations = len(new_groups) + len(self.set.users)
for gr in new_groups.values():
operations += len(gr.members)
progress = dialogs.ProgressDialog(_("Creating all users"),
operations, self.dialog)
def wait_gtk():
while Gtk.events_pending():
Gtk.main_iteration()
for gr in new_groups.values():
wait_gtk()
progress.set_message(
_("Adding group {group}").format(group=gr.name))
gr_tmp = libuser.Group(gr.name, gr.gid)
libuser.get_system().add_group(gr_tmp)
progress.inc()
for u in self.set.users.values():
wait_gtk()
progress.set_message(
_("Adding user {user}").format(user=u.name))
libuser.get_system().add_user(u)
progress.inc()
for gr in new_groups.values():
for u in gr.members.values():
wait_gtk()
progress.set_message(
_("Adding user {user} to group {group}").format(
user=u.name, group=gr.name))
libuser.get_system().add_user_to_groups(u, [gr])
progress.inc()
else:
return False
self.dialog.destroy()
def ResolveConflicts(self, widget=None):
# All the system users
sys_users = {'uids': [], 'gids': [], 'dirs': []}
sys_users['uids'] = [
user.uid for user in libuser.get_system().users.values()
]
sys_users['gids'] = [
user.gid for user in libuser.get_system().users.values()
]
sys_users['dirs'] = [
user.directory for user in libuser.get_system().users.values()
]
# All the users in the new Set
new_users = {'uids': [], 'gids': [], 'dirs': []}
new_users['uids'] = [user.uid for user in self.set.users.values()]
new_users['gids'] = [user.gid for user in self.set.users.values()]
new_users['dirs'] = [
user.directory for user in self.set.users.values()
]
log = []
def log_msg(txt):
log.append(txt)
return txt
def log_uid(u, f, t):
return log_msg(
_("The UID of user \"%(user)s\" was changed from %(old)s to %(new)s."
) % {
"user": u,
"old": f,
"new": t
})
def log_gid(u, f, t):
return log_msg(
_("The GID of user \"%(user)s\" was changed from %(old)s to %(new)s."
) % {
"user": u,
"old": f,
"new": t
})
def log_home(u, f, t):
return log_msg(
_("The home directory of user \"%(user)s\" was changed from %(old)s to %(new)s."
) % {
"user": u,
"old": f,
"new": t
})
def log_group(u, f, t):
return log_msg(
_("The primary group name of user \"%(user)s\" was changed from %(old)s to %(new)s."
) % {
"user": u,
"old": f,
"new": t
})
for row in self.list:
if row[60] != self.states['error']:
continue
u = self.set.users[row[0]]
ofs = 40
if row[1 + ofs] in ['dup', 'con']:
new_uid = libuser.get_system().get_free_uid(
exclude=new_users['uids'])
new_users['uids'].append(new_uid)
log_uid(u.name, u.uid, new_uid)
u.uid = new_uid
self.SetRowProps(row, 1, '')
elif row[1 + ofs] == 'hijack':
dir_uid = os.stat(u.directory).st_uid
new_users['uids'].append(dir_uid)
log_uid(u.name, u.uid, dir_uid)
u.uid = dir_uid
self.SetRowProps(row, 1, '')
#if row[2+ofs] in ['dup', 'con']:
# new_gid = libuser.get_system().get_free_gid(exclude=new_users['gids'])
# new_users['gids'].append(new_gid)
# log_gid(u.name, u.gid, new_gid)
# u.uid = new_uid
# self.SetRowProps(row, 2, '')
if 'missmatch' in row[2 + ofs] and 'missmatch' in row[3 + ofs]:
new_gid = libuser.get_system().get_free_gid(
exclude=new_users['gids'])
new_gname = row[3 + ofs].split()[1] + '_imported'
log_gid(u.name, u.gid, new_gid)
log_group(u.name, u.group, new_gname)
self.SetRowProps(row, 2, '')
self.SetRowProps(row, 3, '')
if 'mismatch' in row[2 + ofs]:
# conflict in gid
new_gid = int(row[2 + ofs].split()[1])
new_users['gids'].append(new_gid)
log_gid(u.name, u.gid, new_gid)
if u.primary_group in self.set.groups:
self.set.groups[u.primary_group].gid = new_gid
u.gid = new_gid
self.SetRowProps(row, 2, '')
if row[2 + ofs] == 'hijack':
dir_gid = os.stat(u.directory).st_gid
new_users['gids'].append(dir_gid)
log_gid(u.name, u.gid, dir_gid)
u.gid = dir_gid
self.SetRowProps(row, 2, '')
if 'mismatch' in row[3 + ofs]:
# conflict in groupname
new_gname = row[3 + ofs].split()[1]
log_group(u.name, u.primary_group, new_gname)
if new_gname in self.set.groups:
if u.name not in self.set.groups[new_gname].members:
self.set.groups[new_gname].members[u.name] = u
else:
self.set.groups[new_gname] = libuser.Group(
new_gname, u.gid)
self.set.groups[new_gname].members[u.name] = u
if u.primary_group in self.set.groups:
if self.set.groups[u.primary_group].members.keys() == [
u.name
]:
del self.set.groups[u.primary_group]
else:
del self.set.groups[u.primary_group].members[u.name]
u.primary_group = new_gname
self.SetRowProps(row, 3, '')
self.SetRowFromObject(row)
print(log)
num = len(log)
if num > 0:
log_dlg = self.builder.get_object('log_dialog')
buf = self.builder.get_object('logbuffer')
buf.set_text('\n'.join(log))
log_dlg.run()
log_dlg.hide()
self.DetectConflicts()
else:
issues = False
problemusers = []
for row in self.list:
if any(row[40:60]):
print(row[40:60])
print(list(row))
problemusers.append(row[0])
issues = True
if issues:
dialogs.WarningDialog(_(
"Some issues remain that could not be resolved automatically\n\t"
+ "\n\t".join(problemusers)),
parent=self.dialog).showup()
else:
dialogs.InfoDialog(_("No issues detected"),
parent=self.dialog).showup()
def on_button_apply_clicked(self, widget):
self.computers = self.glade.get_object('computers_number_spin').\
get_value_as_int()
self.groups_tmpl = self.glade.get_object('groups_template_entry').\
get_text()
button_close = self.glade.get_object('button_close')
total_users = self.computers * len(self.classes)
total_groups = len(self.classes)
progress = dialogs.ProgressDialog(
_("Creating all users"),
total_users + total_groups,
self.dialog,
on_close=self.on_button_cancel_clicked)
users_created = 0
groups_created = 0
set_gids = []
set_uids = []
# Create groups for all the listed classes
if self.classes != ['']:
for classn in self.classes:
dialogs.wait_gtk()
if classn not in self.system.groups:
tmp_gid = self.system.get_free_gid(exclude=set_gids)
set_gids.append(tmp_gid)
cmd_error = self.system.add_group(
libuser.Group(classn, tmp_gid, {}))
progress.set_message(
_("Creating group %(current)d of %(total)d...") % {
"current": groups_created + 1,
"total": total_groups
})
if cmd_error[0] and cmd_error[1] != "":
self.glade.get_object('error_label').set_text(
cmd_error[1])
self.glade.get_object('error_hbox').show()
button_close.set_sensitive(True)
return
groups_created += 1
progress.set_progress(groups_created)
else:
tmp_gid = self.system.groups[classn].gid
groups_created += 1
# Add teachers to group
if self.glade.get_object('teachers_checkbutton').get_active():
progress.set_message(
_("Adding teachers to group {group}").format(
group=classn))
for user in self.system.users.values():
dialogs.wait_gtk()
if 'teachers' in user.groups and classn not in user.groups:
user.groups.append(classn)
self.system.update_user(user.name, user)
# Create shared folders
if self.glade.get_object('shared_checkbutton').get_active():
for classn in self.classes:
progress.set_message(
_("Adding shares for {group}").format(group=classn))
dialogs.wait_gtk()
self.sf.add([classn])
# And finally, create the users
cmd_error = (False, '')
for classn in self.classes:
for compn in range(1, self.computers + 1):
dialogs.wait_gtk()
progress.set_message(
_("Creating user %(current)d of %(total)d...") % {
"current": users_created + 1,
"total": total_users
})
ev = lambda x: x.replace('{c}', classn.strip()).replace(
'{i}', str(compn)).replace('{0i}', '%02d' % compn)
epoch = datetime.datetime.utcfromtimestamp(0)
uname = ev(self.username_tmpl)
tmp_uid = self.system.get_free_uid(exclude=set_uids)
set_uids.append(tmp_uid)
tmp_gid = self.system.get_free_gid(exclude=set_gids)
tmp_password = ev(self.password_tmpl)
# Create the UPG
g = libuser.Group(uname, tmp_gid)
self.system.add_group(g)
u = libuser.User(
name=uname,
uid=tmp_uid,
gid=tmp_gid,
rname=ev(self.name_tmpl),
directory=(self.home + ev(self.username_tmpl)),
lstchg=(datetime.datetime.today() - epoch).days,
groups=[classn],
password=self.system.encrypt(tmp_password))
cmd_error = self.system.add_user(u)
self.system.load()
users_created += 1
progress.set_progress(groups_created + users_created)
if cmd_error[0] and cmd_error[1] != "":
self.progress.set_error(cmd_error.strip())
return
def on_button_apply_clicked(self, _widget):
"""On click apply changes.
Create groups for all the listed classes, adds teachers to group,
create shared folders and finally, create the users.
"""
self.computers = self.glade.get_object('computers_number_spin').\
get_value_as_int()
self.groups_tmpl = self.glade.get_object('groups_template_entry').\
get_text()
button_close = self.glade.get_object('button_close')
progress_dialog = self.glade.get_object('progress_dialog')
progress_dialog.set_transient_for(self.dialog)
progress_dialog.show()
progressbar = self.glade.get_object('users_progressbar')
total_users = self.computers * len(self.classes)
total_groups = len(self.classes)
users_created = 0
groups_created = 0
set_gids = []
set_uids = []
while Gtk.events_pending():
Gtk.main_iteration()
# Create groups for all the listed classes
if self.classes != ['']:
for classn in self.classes:
while Gtk.events_pending():
Gtk.main_iteration()
if classn not in self.system.groups:
tmp_gid = self.system.get_free_gid(exclude=set_gids)
set_gids.append(tmp_gid)
cmd_error = self.system.add_group(
libuser.Group(classn, tmp_gid, {}))
progressbar.set_text('Δημιουργία ομάδας %d από %d' %
(groups_created + 1, total_groups))
#TODO expect returned value from add_group
if False and cmd_error != "":
self.glade.get_object('error_label').set_text(
cmd_error)
self.glade.get_object('error_hbox').show()
button_close.set_sensitive(True)
return
groups_created += 1
progressbar.set_fraction(
float(groups_created) / float(total_groups))
else:
tmp_gid = self.system.groups[classn].gid
# Add teachers to group
if self.glade.get_object('teachers_checkbutton').get_active():
for user in self.system.users.values():
if 'teachers' in user.groups and classn not in user.groups:
user.groups.append(classn)
self.system.update_user(user.name, user)
# Create shared folders
if self.glade.get_object('shared_checkbutton').get_active():
for classn in self.classes:
while Gtk.events_pending():
Gtk.main_iteration()
self.oneself.add([classn])
# And finally, create the users
cmd_error = str()
for classn in self.classes:
for compn in range(1, self.computers + 1):
while Gtk.events_pending():
Gtk.main_iteration()
progressbar.set_text('Δημιουργία χρήστη %d από %d...' %
(users_created + 1, total_users))
evaluate_user_template = lambda x: x.replace(
'{c}', classn.strip()).replace('{i}', str(compn)).replace(
'{0i}', '%02d' % compn)
epoch = datetime.datetime.utcfromtimestamp(0)
uname = evaluate_user_template(self.username_tmpl)
tmp_uid = self.system.get_free_uid(exclude=set_uids)
set_uids.append(tmp_uid)
tmp_gid = self.system.get_free_gid(exclude=set_gids)
tmp_password = evaluate_user_template(self.password_tmpl)
# Create the UPG
grp = libuser.Group(uname, tmp_gid)
self.system.add_group(grp)
usr = libuser.User(
name=uname,
uid=tmp_uid,
gid=tmp_gid,
rname=evaluate_user_template(self.name_tmpl),
directory=('/home/' +
evaluate_user_template(self.username_tmpl)),
lstchg=(datetime.datetime.today() - epoch).days,
groups=[classn],
password=self.system.encrypt(tmp_password))
self.system.add_user(usr)
self.system.load()
users_created += 1
progressbar.set_fraction(
float(users_created) / float(total_users))
#TODO expect returned value from add_user
if False and cmd_error != "":
self.glade.get_object('error_label').set_text(cmd_error.strip())
self.glade.get_object('error_hbox').show()
button_close.set_sensitive(True)
return
# Display a success message and make the Close button sensitive
#TODO self.glade.get_object('success_hbox').show()
progressbar.set_text("Η διαδικασία ολοκληρώθηκε.")
button_close.set_sensitive(True)
