def make_member_of(user, group, processor, during=UnboundedInterval):
"""
Makes a user member of a group in a given interval. If the given interval
overlaps with an existing membership, this method will join the overlapping
intervals together, so that there will be at most one membership for
particular user in particular group at any given point in time.
:param User user: the user
:param Group group: the group
:param User processor: User issuing the addition
:param Interval during:
"""
memberships = session.session.query(Membership).filter(
Membership.user == user, Membership.group == group,
Membership.active(during)).all()
intervals = IntervalSet(
closed(m.begins_at, m.ends_at) for m in memberships
).union(during)
for m in memberships:
session.session.delete(m)
session.session.add_all(
Membership(begins_at=i.begin, ends_at=i.end, user=user, group=group)
for i in intervals)
message = deferred_gettext(u"Added to group {group} during {during}.")
log_user_event(message=message.format(group=group.name,
during=during).to_json(),
user=user, author=processor)
def make_member_of(user, group, processor, during=UnboundedInterval):
"""
Makes a user member of a group in a given interval. If the given interval
overlaps with an existing membership, this method will join the overlapping
intervals together, so that there will be at most one membership for
particular user in particular group at any given point in time.
:param User user: the user
:param Group group: the group
:param User processor: User issuing the addition
:param Interval during:
"""
memberships = session.session.query(Membership).filter(
Membership.user == user, Membership.group == group,
Membership.active(during)).all()
intervals = IntervalSet(
closed(m.begins_at, m.ends_at) for m in memberships).union(during)
for m in memberships:
session.session.delete(m)
session.session.add_all(
Membership(begins_at=i.begin, ends_at=i.end, user=user, group=group)
for i in intervals)
message = deferred_gettext(u"Added to group {group} during {during}.")
log_user_event(message=message.format(group=group.name,
during=during).to_json(),
user=user,
author=processor)
def unblock(user, processor, when=None):
"""Unblocks a user.
This removes his membership of the ``config.violation`` group.
Note that for unblocking, no further asynchronous action has to be
triggered, as opposed to e.g. membership termination.
:param User user: The user to be unblocked.
:param User processor: The admin who unblocked the user.
:param datetime when: The time of membership termination. Note
that in comparison to :py:func:`suspend`, you don't provide an
_interval_, but a point in time, defaulting to the current
time. Will be converted to ``closedopen(when, None)``.
:return: The unblocked user.
"""
if when is None:
when = session.utcnow()
remove_member_of(user=user,
group=config.violation_group,
processor=processor,
during=closedopen(when, None))
message = deferred_gettext(u"User has been unblocked.")
log_user_event(message=message.to_json(), author=processor, user=user)
return user
def host_delete(host, processor):
message = deferred_gettext("Deleted host '{}'.".format(host.name))
log_user_event(author=processor,
user=host.owner,
message=message.to_json())
session.delete(host)\
def make_member_of(user, group, processor, during=UnboundedInterval):
"""
Makes a user member of a group in a given interval. If the given interval
overlaps with an existing membership, this method will join the overlapping
intervals together, so that there will be at most one membership for
particular user in particular group at any given point in time.
:param User user: the user
:param Group group: the group
:param User processor: User issuing the addition
:param Interval during:
"""
if group.permission_level > processor.permission_level:
raise PermissionError("cannot create a membership for a group with a"
" higher permission level")
memberships: list[Membership] = [
m for m in user.active_memberships(when=during) if m.group == group
]
intervals = IntervalSet(m.active_during.closure
for m in memberships).union(during)
for m in memberships:
session.session.delete(m)
session.session.flush()
session.session.add_all(
Membership(active_during=i, user=user, group=group) for i in intervals)
message = deferred_gettext("Added to group {group} during {during}.")
log_user_event(message=message.format(group=group.name,
during=during).to_json(),
user=user,
author=processor)
def migrate_user_host(host, new_room, processor):
"""
Migrate a UserHost to a new room and if necessary to a new subnet.
If the host changes subnet, it will get a new IP address.
:param Host host: Host to be migrated
:param Room new_room: new room of the host
:param User processor: User processing the migration
:return:
"""
old_room = host.room
host.room = new_room
subnets = [
subnet for p in new_room.connected_patch_ports
for vlan in p.switch_port.default_vlans for subnet in vlan.subnets
]
if old_room.building_id == new_room.building_id:
return
for interface in host.interfaces:
old_ips = tuple(ip for ip in interface.ips)
for old_ip in old_ips:
ip_address, subnet = get_free_ip(subnets)
new_ip = IP(interface=interface, address=ip_address, subnet=subnet)
session.session.add(new_ip)
old_address = old_ip.address
session.session.delete(old_ip)
message = deferred_gettext(
u"Changed IP from {old_ip} to {new_ip}.").format(
old_ip=str(old_address), new_ip=str(new_ip))
log_user_event(author=processor,
user=host.owner,
message=message.to_json())
def block(user, reason, processor, during=None, violation=True):
"""Suspend a user during a given interval.
The user is added to violation_group or blocked_group in a given
interval. A reason needs to be provided.
:param User user: The user to be suspended.
:param unicode reason: The reason for suspending.
:param User processor: The admin who suspended the user.
:param Interval|None during: The interval in which the user is
suspended. If None the user will be suspendeded from now on
without an upper bound.
:param Boolean violation: If the user should be added to the violation group
:return: The suspended user.
"""
if during is None:
during = closedopen(session.utcnow(), None)
if violation:
make_member_of(user, config.violation_group, processor, during)
else:
make_member_of(user, config.blocked_group, processor, during)
message = deferred_gettext(u"Suspended during {during}. Reason: {reason}.")
log_user_event(message=message.format(during=during, reason=reason)
.to_json(), author=processor, user=user)
return user
def remove_member_of(user, group, processor, during=UnboundedInterval):
"""Remove a user from a group in a given interval.
The interval defaults to the unbounded interval, so that the user
will be removed from the group at any point in time, **removing
all memberships** in this group retroactively.
However, a common use case is terminating a membership by setting
``during=closedopen(now, None)``.
:param User user: the user
:param Group group: the group
:param User processor: User issuing the removal
:param Interval during:
"""
memberships = session.session.query(Membership).filter(
Membership.user == user, Membership.group == group,
Membership.active(during)).all()
intervals = IntervalSet(
closed(m.begins_at, m.ends_at) for m in memberships
).difference(during)
for m in memberships:
session.session.delete(m)
session.session.add_all(
Membership(begins_at=i.begin, ends_at=i.end, user=user, group=group)
for i in intervals)
message = deferred_gettext(u"Removed from group {group} during {during}.")
log_user_event(message=message.format(group=group.name,
during=during).to_json(),
user=user, author=processor)
def interface_create(host, name, mac, ips, processor):
interface = Interface(host=host, mac=mac, name=name)
session.add(interface)
subnets = get_subnets_for_room(interface.host.room)
if ips is None:
ip, _ = get_free_ip(subnets)
ips = {ip}
# IP added
for ip in ips:
subnet = next(
iter([subnet for subnet in subnets if (ip in subnet.address)]),
None)
if subnet is not None:
session.add(IP(interface=interface, address=ip, subnet=subnet))
message = deferred_gettext(
u"Created interface ({}, {}) with name '{}' for host '{}'.".format(
interface.mac, ', '.join(str(ip.address) for ip in interface.ips),
interface.name, interface.host.name))
log_user_event(author=processor,
user=host.owner,
message=message.to_json())
return interface
def remove_member_of(user, group, processor, during=UnboundedInterval):
"""Remove a user from a group in a given interval.
The interval defaults to the unbounded interval, so that the user
will be removed from the group at any point in time, **removing
all memberships** in this group retroactively.
However, a common use case is terminating a membership by setting
``during=closedopen(now, None)``.
:param User user: the user
:param Group group: the group
:param User processor: User issuing the removal
:param Interval during:
"""
memberships = session.session.query(Membership).filter(
Membership.user == user, Membership.group == group,
Membership.active(during)).all()
intervals = IntervalSet(
closed(m.begins_at, m.ends_at) for m in memberships).difference(during)
for m in memberships:
session.session.delete(m)
session.session.add_all(
Membership(begins_at=i.begin, ends_at=i.end, user=user, group=group)
for i in intervals)
message = deferred_gettext(u"Removed from group {group} during {during}.")
log_user_event(message=message.format(group=group.name,
during=during).to_json(),
user=user,
author=processor)
def interface_delete(interface, processor):
message = deferred_gettext(u"Deleted interface {} of host {}.".format(
interface.mac, interface.host.name))
log_user_event(author=processor,
user=interface.host.owner,
message=message.to_json())
session.delete(interface)
def change_password(user, password):
# TODO: verify password complexity
user.password = password
message = deferred_gettext(u"Password was changed")
log_user_event(author=user,
user=user,
message=message.to_json())
def reset_password(user, processor):
plain_password = user_helper.generate_password(12)
user.password = plain_password
message = deferred_gettext(u"Password was reset")
log_user_event(author=processor, user=user, message=message.to_json())
return plain_password
def reset_wifi_password(user: User, processor: User) -> str:
plain_password = generate_wifi_password()
user.wifi_password = plain_password
message = deferred_gettext(u"WIFI-Password was reset")
log_user_event(author=processor, user=user, message=message.to_json())
return plain_password
def edit_email(user: User,
email: str | None,
email_forwarded: bool,
processor: User,
is_confirmed: bool = False):
"""
Changes the email address of a user and creates a log entry.
:param user: User object to change
:param email: New email address (empty interpreted as ``None``)
:param email_forwarded: Boolean if emails should be forwarded
:param processor: User object of the processor, which issues the change
:param is_confirmed: If the email address is already confirmed
:return:Changed user object
"""
if not can_target(user, processor):
raise PermissionError("cannot change email of a user with a"
" greater or equal permission level.")
if not email:
email = None
else:
email = email.lower()
if email_forwarded != user.email_forwarded:
user.email_forwarded = email_forwarded
log_user_event(
author=processor,
user=user,
message=deferred_gettext("Set e-mail forwarding to {}.").format(
email_forwarded).to_json())
if is_confirmed:
user.email_confirmed = True
user.email_confirmation_key = None
if email == user.email:
# email wasn't changed, do nothing
return user
old_email = user.email
user.email = email
if email is not None:
if not is_confirmed:
send_confirmation_email(user)
else:
user.email_confirmed = False
user.email_confirmation_key = None
message = deferred_gettext("Changed e-mail from {} to {}.")
log_user_event(author=processor,
user=user,
message=message.format(old_email, email).to_json())
return user
def reset_password(user, processor):
if not can_target(user, processor):
raise PermissionError("cannot reset password of a user with a"
" greater or equal permission level.")
plain_password = user_helper.generate_password(12)
user.password = plain_password
message = deferred_gettext(u"Password was reset")
log_user_event(author=processor, user=user, message=message.to_json())
return plain_password
def move(user, building_id, level, room_number, processor, when=None):
"""Moves the user into another room.
:param user: The user to be moved.
:param building_id: The id of the building.
:param level: The level of the new room.
:param room_number: The number of the new room.
:param processor: The user who is currently logged in.
:param when: The date at which the user should be moved
:return: The user object of the moved user.
:rtype: User
"""
if when and when > session.utcnow():
return schedule_user_task(task_type=TaskType.USER_MOVE,
due=when,
user=user,
parameters={
'building_id': building_id,
'level': level,
'room_number': room_number
},
processor=processor)
else:
old_room = user.room
had_custom_address = user.has_custom_address
new_room = Room.q.filter_by(number=room_number,
level=level,
building_id=building_id).one()
assert old_room != new_room,\
"A User is only allowed to move in a different room!"
user.room = new_room
if not had_custom_address:
user.address = new_room.address
message = deferred_gettext(u"Moved from {} to {}.")
log_user_event(author=processor,
message=message.format(str(old_room),
str(new_room)).to_json(),
user=user)
for user_host in user.hosts:
if user_host.room == old_room:
migrate_user_host(user_host, new_room, processor)
user_send_mail(user, UserMovedInTemplate(), True)
return user
def interface_edit(interface, name, mac, ips, processor):
message = u"Edited interface ({}, {}) of host '{}'." \
.format(interface.mac,
', '.join(str(ip.address) for ip in
interface.ips),
interface.host.name)
if interface.name != name:
interface.name = name
message += " New name: '{}'.".format(interface.name)
if interface.mac != mac:
interface.mac = mac
message += " New MAC: {}.".format(interface.mac)
ips_changed = False
current_ips = list(ip.address for ip in interface.ips)
subnets = get_subnets_for_room(interface.host.room)
new_ips = set(current_ips)
# IP removed
for ip in current_ips:
if ip not in ips:
session.delete(IP.q.filter_by(address=ip).first())
ips_changed = True
new_ips.remove(ip)
# IP added
for ip in ips:
if ip not in current_ips:
subnet = next(
iter([subnet for subnet in subnets if (ip in subnet.address)]),
None)
if subnet is not None:
session.add(IP(interface=interface, address=ip,
subnet=subnet))
ips_changed = True
new_ips.add(str(ip))
if ips_changed:
message += " New IPs: {}.".format(', '.join(str(ip) for ip in
new_ips))
log_user_event(author=processor,
user=interface.host.owner,
message=deferred_gettext(message).to_json())
def handle_payments_in_default():
processor = User.q.get(0)
# Add memberships and end "member" membership if threshold met
users = User.q.join(User.current_properties)\
.filter(CurrentProperty.property_name == 'membership_fee') \
.join(Account).filter(Account.balance > 0).all()
users_pid_membership = []
users_membership_terminated = []
ts_now = session.utcnow()
for user in users:
last_pid_membership = Membership.q.filter(Membership.user_id == user.id) \
.filter(Membership.group_id == config.payment_in_default_group.id) \
.order_by(Membership.ends_at.desc()) \
.first()
if last_pid_membership is not None:
if last_pid_membership.ends_at is not None and \
last_pid_membership.ends_at >= ts_now - timedelta(days=7):
continue
in_default_days = user.account.in_default_days
try:
fee = get_membership_fee_for_date(date.today() -
timedelta(days=in_default_days))
except NoResultFound:
fee = get_last_applied_membership_fee()
if not fee:
return [], []
if not user.has_property('payment_in_default'):
if in_default_days >= fee.payment_deadline.days:
make_member_of(user, config.payment_in_default_group,
processor, closed(ts_now, None))
users_pid_membership.append(user)
if in_default_days >= fee.payment_deadline_final.days:
remove_member_of(user, config.member_group, processor,
closedopen(ts_now, None))
log_user_event(
"Mitgliedschaftsende wegen Zahlungsrückstand ({})".format(
fee.name), processor, user)
users_membership_terminated.append(user)
return users_pid_membership, users_membership_terminated
def handle_payments_in_default():
processor = User.q.get(0)
# Add memberships and end "member" membership if threshold met
users = User.q.join(User.current_properties)\
.filter(CurrentProperty.property_name == 'membership_fee') \
.join(Account).filter(Account.balance > 0).all()
users_pid_membership = []
users_membership_terminated = []
ts_now = session.utcnow()
for user in users:
last_pid_membership = Membership.q.filter(Membership.user_id == user.id) \
.filter(Membership.group_id == config.payment_in_default_group.id) \
.order_by(Membership.ends_at.desc()) \
.first()
if last_pid_membership is not None:
if last_pid_membership.ends_at is not None and \
last_pid_membership.ends_at >= ts_now - timedelta(days=7):
continue
in_default_days = user.account.in_default_days
try:
fee = get_membership_fee_for_date(
date.today() - timedelta(days=in_default_days))
except NoResultFound:
fee = get_last_applied_membership_fee()
if not fee:
return [], []
if not user.has_property('payment_in_default'):
if in_default_days >= fee.payment_deadline.days:
make_member_of(user, config.payment_in_default_group,
processor, closed(ts_now, None))
users_pid_membership.append(user)
if in_default_days >= fee.payment_deadline_final.days:
remove_member_of(user, config.member_group, processor,
closedopen(ts_now, None))
log_user_event("Mitgliedschaftsende wegen Zahlungsrückstand ({})"
.format(fee.name),
processor, user)
users_membership_terminated.append(user)
return users_pid_membership, users_membership_terminated
def move_out(user, comment, processor, when, end_membership=True):
"""Move out a user and may terminate relevant memberships.
The user's room is set to ``None`` and all hosts are deleted.
Memberships in :py:obj:`config.member_group` and
:py:obj:`config.member_group` are terminated. A log message is
created including the number of deleted hosts.
:param User user: The user to move out.
:param unicode|None comment: An optional comment
:param User processor: The admin who is going to move out the
user.
:param datetime when: The time the user is going to move out.
:param bool end_membership: Ends membership if true
:return: The user that moved out.
"""
if when > session.utcnow():
raise NotImplementedError(
"Moving out in the future is not supported yet.")
if end_membership:
for group in ({
config.member_group, config.network_access_group,
config.external_group
}
| set(user.traffic_groups)):
remove_member_of(user, group, processor, closedopen(when, None))
user.birthdate = None
num_hosts = 0 # In case the chain is empty
for num_hosts, h in enumerate(user.hosts, 1):
session.session.delete(h)
user.room = None
if comment:
message = deferred_gettext(
u"Moved out: ({} hosts deleted). Comment: {}").format(
num_hosts, comment)
else:
message = deferred_gettext(u"Moved out: ({} hosts deleted).").format(
num_hosts)
log_user_event(message=message.to_json(), author=processor, user=user)
return user
def finish_member_request(prm: PreMember,
processor: User | None,
ignore_similar_name: bool = False):
if prm.room is None:
raise ValueError("Room is None")
if prm.move_in_date is not None and prm.move_in_date < session.utcnow(
).date():
prm.move_in_date = session.utcnow().date()
check_new_user_data(prm.login, prm.email, prm.name, prm.swdd_person_id,
prm.room, prm.move_in_date, ignore_similar_name)
user, _ = create_user(prm.name,
prm.login,
prm.email,
prm.birthdate,
groups=[],
processor=processor,
address=prm.room.address,
passwd_hash=prm.passwd_hash)
processor = processor if processor is not None else user
user.swdd_person_id = prm.swdd_person_id
user.email_confirmed = prm.email_confirmed
move_in_datetime = utc.with_min_time(prm.move_in_date)
move_in(user,
prm.room.building_id,
prm.room.level,
prm.room.number,
None,
processor if processor is not None else user,
when=move_in_datetime)
message = deferred_gettext("Created from registration {}.").format(
str(prm.id)).to_json()
log_user_event(message, processor, user)
if move_in_datetime > session.utcnow():
make_member_of(user, config.pre_member_group, processor,
closed(session.utcnow(), None))
session.session.delete(prm)
return user
def change_mac(interface, mac, processor):
"""
This method will change the mac address of the given interface to the new
mac address.
:param interface: the interface which should become a new mac address.
:param mac: the new mac address.
:param processor: the user who initiated the mac address change.
:return: the changed interface with the new mac address.
"""
old_mac = interface.mac
interface.mac = mac
message = deferred_gettext(u"Changed MAC address from {} to {}.").format(
old_mac, mac)
log_user_event(message.to_json(), processor, interface.host.owner)
return interface
def change_mac(interface, mac, processor):
"""
This method will change the mac address of the given interface to the new
mac address.
:param interface: the interface which should become a new mac address.
:param mac: the new mac address.
:param processor: the user who initiated the mac address change.
:return: the changed interface with the new mac address.
"""
old_mac = interface.mac
interface.mac = mac
message = deferred_gettext(u"Changed MAC address from {} to {}.").format(
old_mac, mac)
log_user_event(message.to_json(), processor, interface.host.owner)
return interface
def create_user(name, login, email, birthdate, groups, processor, address):
"""Create a new member
Create a new user with a generated password, finance- and unix account, and make him member
of the `config.member_group` and `config.network_access_group`.
:param str name: The full name of the user (e.g. Max Mustermann)
:param str login: The unix login for the user
:param str email: E-Mail address of the user
:param Date birthdate: Date of birth
:param PropertyGroup groups: The initial groups of the new user
:param User processor: The processor
:param Address address: Where the user lives. May or may not come from a room.
:return:
"""
now = session.utcnow()
plain_password = user_helper.generate_password(12)
# create a new user
new_user = User(
login=login,
name=name,
email=email,
registered_at=now,
account=Account(name="", type="USER_ASSET"),
password=plain_password,
birthdate=birthdate,
address=address
)
account = UnixAccount(home_directory="/home/{}".format(login))
new_user.unix_account = account
with session.session.begin(subtransactions=True):
session.session.add(new_user)
session.session.add(account)
new_user.account.name = deferred_gettext(u"User {id}").format(
id=new_user.id).to_json()
for group in groups:
make_member_of(new_user, group, processor, closed(now, None))
log_user_event(author=processor,
message=deferred_gettext(u"User created.").to_json(),
user=new_user)
return new_user, plain_password
def migrate_user_host(host, new_room, processor):
"""
Migrate a UserHost to a new room and if necessary to a new subnet.
If the host changes subnet, it will get a new IP address.
:param Host host: Host to be migrated
:param Room new_room: new room of the host
:param User processor: User processing the migration
:return:
"""
old_room = host.room
host.room = new_room
subnets_old = get_subnets_for_room(old_room)
subnets = get_subnets_for_room(new_room)
if subnets_old != subnets:
for interface in host.interfaces:
old_ips = tuple(ip for ip in interface.ips)
for old_ip in old_ips:
ip_address, subnet = get_free_ip(subnets)
new_ip = IP(interface=interface,
address=ip_address,
subnet=subnet)
session.session.add(new_ip)
old_address = old_ip.address
session.session.delete(old_ip)
message = deferred_gettext(
u"Changed IP of {mac} from {old_ip} to {new_ip}.").format(
old_ip=str(old_address),
new_ip=str(new_ip.address),
mac=interface.mac)
log_user_event(author=processor,
user=host.owner,
message=message.to_json())
message = deferred_gettext(
u"Moved host '{name}' from {room_old} to {room_new}.".format(
name=host.name,
room_old=old_room.short_name,
room_new=new_room.short_name))
log_user_event(author=processor,
user=host.owner,
message=message.to_json())
def edit_name(user, name, processor):
"""
Changes the name of the user and creates a log entry.
:param user: The user object.
:param name: The new full name.
:return: The changed user object.
"""
if not name:
raise ValueError()
old_name = user.name
user.name = name
message = deferred_gettext(u"Changed name from {} to {}.")
log_user_event(author=processor,
user=user,
message=message.format(old_name, name).to_json())
return user
def host_create(owner, room, name, processor):
host = Host(name=name, owner_id=owner.id, room=room)
session.add(host)
message = deferred_gettext(
u"Created host '{name}' in {dorm} {level}-{room}.".format(
name=host.name,
dorm=room.building.short_name,
level=room.level,
room=room.number))
log_user_event(author=processor,
user=owner,
message=message.to_json())\
return host
def take_actions_for_payment_in_default_users(users_pid_membership,
users_membership_terminated,
processor):
ts_now = session.utcnow()
for user in users_pid_membership:
if not user.member_of(config.payment_in_default_group):
make_member_of(user, config.payment_in_default_group,
processor, closed(ts_now, None))
from pycroft.lib.user import move_out
for user in users_membership_terminated:
if user.member_of(config.member_group):
move_out(user, "Zahlungsrückstand", processor, ts_now - timedelta(seconds=1), True)
log_user_event("Mitgliedschaftsende wegen Zahlungsrückstand.",
processor, user)
def edit_email(user, email, processor):
"""
Changes the email address of a user and creates a log entry.
:param user: User object to change
:param email: New email address, can be None
:param processor:User object of the processor, which issues the change
:return:Changed user object
"""
if not email:
email = None
old_email = user.email
user.email = email
message = deferred_gettext(u"Changed e-mail from {} to {}.")
log_user_event(author=processor,
user=user,
message=message.format(old_email, email).to_json())
return user
def edit_birthdate(user, birthdate, processor):
"""
Changes the birthdate of a user and creates a log entry.
:param user: User object to change
:param birthdate: New birthdate
:param processor:User object of the processor, which issues the change
:return:Changed user object
"""
if not birthdate:
birthdate = None
old_bd = user.birthdate
user.birthdate = birthdate
message = deferred_gettext(u"Changed birthdate from {} to {}.")
log_user_event(author=processor,
user=user,
message=message.format(old_bd, birthdate).to_json())
return user
def reset_credit(user, processor, target_amount=1*1024**3):
"""Compensate a user's traffic credit to a target amount
:param User user:
:param User processor:
:param int target_amount: The target amount to reach, in bytes.
Defaults to 1GiB.
:raises ValueError: if the user's current credit is greater than
or equal to the given target amount.
"""
now = session.utcnow()
difference = target_amount - user.current_credit
if difference <= 0:
raise ValueError("The current credit surpasses the target amount."
" Only an upwards correction is possible.")
session.session.add(TrafficCredit(user=user, timestamp=now, amount=difference))
log_user_event(deferred_gettext("Traffic has ben compensated to 1GiB").to_json(),
author=processor,
user=user)
def test_user_log_entry(self):
user_log_entry = log_user_event(message=self.message,
author=self.user,
user=self.user)
self.assert_log_entry(user_log_entry, self.user, session.utcnow(),
self.message)
assert user_log_entry.user == self.user
session.session.delete(user_log_entry)
session.session.commit()
assert LogEntry.get(user_log_entry.id) is None
def edit_person_id(user: User, person_id: int, processor: User):
"""
Changes the swdd_person_id of the user and creates a log entry.
:param user: The user object.
:param person_id: The new person_id.
:return: The changed user object.
"""
if person_id == user.swdd_person_id:
# name wasn't changed, do nothing
return user
old_person_id = user.swdd_person_id
user.swdd_person_id = person_id
message = deferred_gettext(u"Changed tenant number from {} to {}.")
log_user_event(author=processor,
user=user,
message=message.format(str(old_person_id),
str(person_id)).to_json())
return user
def edit_address(
user: User,
processor: User,
street: str,
number: str,
addition: Optional[str],
zip_code: str,
city: Optional[str],
state: Optional[str],
country: Optional[str],
):
"""Changes the address of a user and appends a log entry.
Should do nothing if the user already has an address.
"""
address = get_or_create_address(street, number, addition, zip_code, city,
state, country)
user.address = address
log_user_event(
deferred_gettext("Changed address to {address}").format(
address=str(address)).to_json(), processor, user)
def test_0010_create_user_log_entry(self):
user_log_entry = log_user_event(message=self.message,
author=self.user,
user=self.user)
self.assertEqual(user_log_entry.message, self.message)
self.assertAlmostEqual(user_log_entry.created_at, session.utcnow(),
delta=timedelta(seconds=5))
self.assertEqual(user_log_entry.author, self.user)
self.assertEqual(user_log_entry.user, self.user)
self.assertIsNotNone(LogEntry.q.get(user_log_entry.id))
session.session.delete(user_log_entry)
session.session.commit()
self.assertIsNone(LogEntry.q.get(user_log_entry.id))
