Revision 71c741dc
| b/snf-astakos-app/astakos/im/functions.py | ||
|---|---|---|
| 411 | 411 |
|
| 412 | 412 |
|
| 413 | 413 |
def accept_membership_checks(membership, request_user): |
| 414 |
if not membership.can_accept():
|
|
| 414 |
if not membership.check_action("accept"):
|
|
| 415 | 415 |
m = _(astakos_messages.NOT_MEMBERSHIP_REQUEST) |
| 416 | 416 |
raise ProjectConflict(m) |
| 417 | 417 |
|
| ... | ... | |
| 424 | 424 |
membership = get_membership_by_id(memb_id) |
| 425 | 425 |
accept_membership_checks(membership, request_user) |
| 426 | 426 |
user = membership.person |
| 427 |
membership.accept()
|
|
| 427 |
membership.perform_action("accept")
|
|
| 428 | 428 |
qh_sync_user(user) |
| 429 | 429 |
logger.info("User %s has been accepted in %s." %
|
| 430 | 430 |
(user.log_display, project)) |
| ... | ... | |
| 434 | 434 |
|
| 435 | 435 |
|
| 436 | 436 |
def reject_membership_checks(membership, request_user): |
| 437 |
if not membership.can_reject():
|
|
| 437 |
if not membership.check_action("reject"):
|
|
| 438 | 438 |
m = _(astakos_messages.NOT_MEMBERSHIP_REQUEST) |
| 439 | 439 |
raise ProjectConflict(m) |
| 440 | 440 |
|
| ... | ... | |
| 448 | 448 |
membership = get_membership_by_id(memb_id) |
| 449 | 449 |
reject_membership_checks(membership, request_user) |
| 450 | 450 |
user = membership.person |
| 451 |
membership.reject()
|
|
| 451 |
membership.perform_action("reject")
|
|
| 452 | 452 |
logger.info("Request of user %s for %s has been rejected." %
|
| 453 | 453 |
(user.log_display, project)) |
| 454 | 454 |
|
| ... | ... | |
| 457 | 457 |
|
| 458 | 458 |
|
| 459 | 459 |
def cancel_membership_checks(membership, request_user): |
| 460 |
if not membership.can_cancel():
|
|
| 460 |
if not membership.check_action("cancel"):
|
|
| 461 | 461 |
m = _(astakos_messages.NOT_MEMBERSHIP_REQUEST) |
| 462 | 462 |
raise ProjectConflict(m) |
| 463 | 463 |
|
| ... | ... | |
| 470 | 470 |
project = get_project_of_membership_for_update(memb_id) |
| 471 | 471 |
membership = get_membership_by_id(memb_id) |
| 472 | 472 |
cancel_membership_checks(membership, request_user) |
| 473 |
membership.cancel()
|
|
| 473 |
membership.perform_action("cancel")
|
|
| 474 | 474 |
logger.info("Request of user %s for %s has been cancelled." %
|
| 475 | 475 |
(membership.person.log_display, project)) |
| 476 | 476 |
|
| 477 | 477 |
|
| 478 | 478 |
def remove_membership_checks(membership, request_user=None): |
| 479 |
if not membership.can_remove():
|
|
| 479 |
if not membership.check_action("remove"):
|
|
| 480 | 480 |
m = _(astakos_messages.NOT_ACCEPTED_MEMBERSHIP) |
| 481 | 481 |
raise ProjectConflict(m) |
| 482 | 482 |
|
| ... | ... | |
| 495 | 495 |
membership = get_membership_by_id(memb_id) |
| 496 | 496 |
remove_membership_checks(membership, request_user) |
| 497 | 497 |
user = membership.person |
| 498 |
membership.remove()
|
|
| 498 |
membership.perform_action("remove")
|
|
| 499 | 499 |
qh_sync_user(user) |
| 500 | 500 |
logger.info("User %s has been removed from %s." %
|
| 501 | 501 |
(user.log_display, project)) |
| ... | ... | |
| 514 | 514 |
|
| 515 | 515 |
try: |
| 516 | 516 |
membership = get_membership(project_id, user.id) |
| 517 |
if not membership.can_enroll():
|
|
| 517 |
if not membership.check_action("enroll"):
|
|
| 518 | 518 |
m = _(astakos_messages.MEMBERSHIP_ACCEPTED) |
| 519 | 519 |
raise ProjectConflict(m) |
| 520 |
membership.join()
|
|
| 520 |
membership.perform_action("join")
|
|
| 521 | 521 |
except ProjectNotFound: |
| 522 | 522 |
membership = new_membership(project, user) |
| 523 | 523 |
|
| 524 |
membership.accept()
|
|
| 524 |
membership.perform_action("accept")
|
|
| 525 | 525 |
qh_sync_user(user) |
| 526 | 526 |
logger.info("User %s has been enrolled in %s." %
|
| 527 | 527 |
(membership.person.log_display, project)) |
| ... | ... | |
| 531 | 531 |
|
| 532 | 532 |
|
| 533 | 533 |
def leave_project_checks(membership, request_user): |
| 534 |
if not membership.can_leave():
|
|
| 534 |
if not membership.check_action("leave"):
|
|
| 535 | 535 |
m = _(astakos_messages.NOT_ACCEPTED_MEMBERSHIP) |
| 536 | 536 |
raise ProjectConflict(m) |
| 537 | 537 |
|
| ... | ... | |
| 564 | 564 |
auto_accepted = False |
| 565 | 565 |
leave_policy = project.application.member_leave_policy |
| 566 | 566 |
if leave_policy == AUTO_ACCEPT_POLICY: |
| 567 |
membership.remove()
|
|
| 567 |
membership.perform_action("remove")
|
|
| 568 | 568 |
qh_sync_user(request_user) |
| 569 | 569 |
logger.info("User %s has left %s." %
|
| 570 | 570 |
(request_user.log_display, project)) |
| 571 | 571 |
auto_accepted = True |
| 572 | 572 |
else: |
| 573 |
membership.leave_request()
|
|
| 573 |
membership.perform_action("leave_request")
|
|
| 574 | 574 |
logger.info("User %s requested to leave %s." %
|
| 575 | 575 |
(request_user.log_display, project)) |
| 576 | 576 |
membership_leave_request_notify(project, membership.person) |
| ... | ... | |
| 595 | 595 |
m = user.get_membership(project) |
| 596 | 596 |
if not m: |
| 597 | 597 |
return True |
| 598 |
return m.can_join()
|
|
| 598 |
return m.check_action("join")
|
|
| 599 | 599 |
|
| 600 | 600 |
|
| 601 | 601 |
def new_membership(project, user): |
| ... | ... | |
| 610 | 610 |
|
| 611 | 611 |
try: |
| 612 | 612 |
membership = get_membership(project.id, request_user.id) |
| 613 |
if not membership.can_join():
|
|
| 613 |
if not membership.check_action("join"):
|
|
| 614 | 614 |
msg = _(astakos_messages.MEMBERSHIP_ASSOCIATED) |
| 615 | 615 |
raise ProjectConflict(msg) |
| 616 |
membership.join()
|
|
| 616 |
membership.perform_action("join")
|
|
| 617 | 617 |
except ProjectNotFound: |
| 618 | 618 |
membership = new_membership(project, request_user) |
| 619 | 619 |
|
| 620 | 620 |
join_policy = project.application.member_join_policy |
| 621 | 621 |
if (join_policy == AUTO_ACCEPT_POLICY and ( |
| 622 | 622 |
not project.violates_members_limit(adding=1))): |
| 623 |
membership.accept()
|
|
| 623 |
membership.perform_action("accept")
|
|
| 624 | 624 |
qh_sync_user(request_user) |
| 625 | 625 |
logger.info("User %s joined %s." %
|
| 626 | 626 |
(request_user.log_display, project)) |
| b/snf-astakos-app/astakos/im/models.py | ||
|---|---|---|
| 1924 | 1924 |
self.state = to_state |
| 1925 | 1925 |
self.save() |
| 1926 | 1926 |
|
| 1927 |
def can_join(self): |
|
| 1928 |
return self.state not in self.ASSOCIATED_STATES |
|
| 1929 |
|
|
| 1930 |
def join(self): |
|
| 1931 |
if not self.can_join(): |
|
| 1932 |
m = _("%s: attempt to join in state '%s'") % (self, self.state)
|
|
| 1933 |
raise AssertionError(m) |
|
| 1934 |
|
|
| 1935 |
self.set_state(self.REQUESTED) |
|
| 1936 |
|
|
| 1937 |
def can_accept(self): |
|
| 1938 |
return self.state == self.REQUESTED |
|
| 1939 |
|
|
| 1940 |
def accept(self): |
|
| 1941 |
if not self.can_accept(): |
|
| 1942 |
m = _("%s: attempt to accept in state '%s'") % (self, self.state)
|
|
| 1943 |
raise AssertionError(m) |
|
| 1944 |
|
|
| 1945 |
self.set_state(self.ACCEPTED) |
|
| 1946 |
|
|
| 1947 |
def can_enroll(self): |
|
| 1948 |
return self.state not in self.ACCEPTED_STATES |
|
| 1949 |
|
|
| 1950 |
def can_leave(self): |
|
| 1951 |
return self.state in self.ACCEPTED_STATES |
|
| 1952 |
|
|
| 1953 |
def leave_request(self): |
|
| 1954 |
if not self.can_leave(): |
|
| 1955 |
m = _("%s: attempt to request to leave in state '%s'") % (
|
|
| 1956 |
self, self.state) |
|
| 1957 |
raise AssertionError(m) |
|
| 1958 |
|
|
| 1959 |
self.set_state(self.LEAVE_REQUESTED) |
|
| 1960 |
|
|
| 1961 |
def can_deny_leave(self): |
|
| 1962 |
return self.state == self.LEAVE_REQUESTED |
|
| 1963 |
|
|
| 1964 |
def leave_request_deny(self): |
|
| 1965 |
if not self.can_deny_leave(): |
|
| 1966 |
m = _("%s: attempt to deny leave request in state '%s'") % (
|
|
| 1967 |
self, self.state) |
|
| 1968 |
raise AssertionError(m) |
|
| 1969 |
|
|
| 1970 |
self.set_state(self.ACCEPTED) |
|
| 1971 |
|
|
| 1972 |
def can_cancel_leave(self): |
|
| 1973 |
return self.state == self.LEAVE_REQUESTED |
|
| 1974 |
|
|
| 1975 |
def leave_request_cancel(self): |
|
| 1976 |
if not self.can_cancel_leave(): |
|
| 1977 |
m = _("%s: attempt to cancel leave request in state '%s'") % (
|
|
| 1978 |
self, self.state) |
|
| 1979 |
raise AssertionError(m) |
|
| 1980 |
|
|
| 1981 |
self.set_state(self.ACCEPTED) |
|
| 1982 |
|
|
| 1983 |
def can_remove(self): |
|
| 1984 |
return self.state in self.ACCEPTED_STATES |
|
| 1985 |
|
|
| 1986 |
def remove(self): |
|
| 1987 |
if not self.can_remove(): |
|
| 1988 |
m = _("%s: attempt to remove in state '%s'") % (self, self.state)
|
|
| 1989 |
raise AssertionError(m) |
|
| 1990 |
|
|
| 1991 |
self.set_state(self.REMOVED) |
|
| 1992 |
|
|
| 1993 |
def can_reject(self): |
|
| 1994 |
return self.state == self.REQUESTED |
|
| 1995 |
|
|
| 1996 |
def reject(self): |
|
| 1997 |
if not self.can_reject(): |
|
| 1998 |
m = _("%s: attempt to reject in state '%s'") % (self, self.state)
|
|
| 1999 |
raise AssertionError(m) |
|
| 2000 |
|
|
| 2001 |
self.set_state(self.REJECTED) |
|
| 1927 |
ACTION_CHECKS = {
|
|
| 1928 |
"join": lambda m: m.state not in m.ASSOCIATED_STATES, |
|
| 1929 |
"accept": lambda m: m.state == m.REQUESTED, |
|
| 1930 |
"enroll": lambda m: m.state not in m.ACCEPTED_STATES, |
|
| 1931 |
"leave": lambda m: m.state in m.ACCEPTED_STATES, |
|
| 1932 |
"leave_request": lambda m: m.state in m.ACCEPTED_STATES, |
|
| 1933 |
"deny_leave": lambda m: m.state == m.LEAVE_REQUESTED, |
|
| 1934 |
"cancel_leave": lambda m: m.state == m.LEAVE_REQUESTED, |
|
| 1935 |
"remove": lambda m: m.state in m.ACCEPTED_STATES, |
|
| 1936 |
"reject": lambda m: m.state == m.REQUESTED, |
|
| 1937 |
"cancel": lambda m: m.state == m.REQUESTED, |
|
| 1938 |
} |
|
| 2002 | 1939 |
|
| 2003 |
def can_cancel(self): |
|
| 2004 |
return self.state == self.REQUESTED |
|
| 1940 |
ACTION_STATES = {
|
|
| 1941 |
"join": REQUESTED, |
|
| 1942 |
"accept": ACCEPTED, |
|
| 1943 |
"leave_request": LEAVE_REQUESTED, |
|
| 1944 |
"deny_leave": ACCEPTED, |
|
| 1945 |
"cancel_leave": ACCEPTED, |
|
| 1946 |
"remove": REMOVED, |
|
| 1947 |
"reject": REJECTED, |
|
| 1948 |
"cancel": CANCELLED, |
|
| 1949 |
} |
|
| 2005 | 1950 |
|
| 2006 |
def cancel(self): |
|
| 2007 |
if not self.can_cancel(): |
|
| 2008 |
m = _("%s: attempt to cancel in state '%s'") % (self, self.state)
|
|
| 1951 |
def check_action(self, action): |
|
| 1952 |
try: |
|
| 1953 |
check = self.ACTION_CHECKS[action] |
|
| 1954 |
except KeyError: |
|
| 1955 |
raise ValueError("No check found for action '%s'" % action)
|
|
| 1956 |
return check(self) |
|
| 1957 |
|
|
| 1958 |
def perform_action(self, action): |
|
| 1959 |
if not self.check_action(action): |
|
| 1960 |
m = _("%s: attempted action '%s' in state '%s'") % (
|
|
| 1961 |
self, action, self.state) |
|
| 2009 | 1962 |
raise AssertionError(m) |
| 2010 |
|
|
| 2011 |
self.set_state(self.CANCELLED) |
|
| 1963 |
try: |
|
| 1964 |
s = self.ACTION_STATES[action] |
|
| 1965 |
except KeyError: |
|
| 1966 |
raise ValueError("No such action '%s'" % action)
|
|
| 1967 |
return self.set_state(s) |
|
| 2012 | 1968 |
|
| 2013 | 1969 |
|
| 2014 | 1970 |
class Serial(models.Model): |
Also available in: Unified diff