Sep 4 - Add link relavant issues function
This commit is contained in:
@@ -43,6 +43,116 @@ class IssueFollower(db.Model):
|
||||
return f'<IssueFollower issue={self.issue_id} user={self.user_id}>'
|
||||
|
||||
|
||||
# ── Issue Link ────────────────────────────────────────────────────────────────
|
||||
# Connects two issues so staff can jump between a duplicate and the original, or
|
||||
# between issues that are simply about the same thing.
|
||||
|
||||
class IssueLink(db.Model):
|
||||
"""One directed link between two issues, displayed on BOTH of them.
|
||||
|
||||
Only one row is stored per pair. The stored direction carries meaning for
|
||||
'duplicate' — issue_id is a duplicate OF linked_issue_id — so the two issues
|
||||
read the same row differently:
|
||||
|
||||
on issue_id -> "Duplicate of #B"
|
||||
on linked_issue_id -> "Duplicated by #A"
|
||||
|
||||
'related' is symmetric and reads "Related to" from either side.
|
||||
|
||||
Storing one row rather than a mirrored pair is what keeps the direction
|
||||
unambiguous and makes unlinking a single delete. The cost is that uniqueness
|
||||
cannot be expressed by the UniqueConstraint alone: (A,B) and (B,A) are
|
||||
distinct rows to the database but the same link to a person, so the
|
||||
duplicate check has to look in both directions. exists_between() is that
|
||||
check, and it is the only thing callers should use.
|
||||
|
||||
A link is PURELY NAVIGATIONAL. Marking a duplicate does not touch either
|
||||
issue's status, SLA, assignee or followers — closing the duplicate stays a
|
||||
deliberate, separate action.
|
||||
"""
|
||||
__tablename__ = 'issue_links'
|
||||
|
||||
TYPE_DUPLICATE = 'duplicate'
|
||||
TYPE_RELATED = 'related'
|
||||
|
||||
# How each link type reads from the two sides, keyed by (type, is_source).
|
||||
LABELS = {
|
||||
('duplicate', True): 'Duplicate of',
|
||||
('duplicate', False): 'Duplicated by',
|
||||
('related', True): 'Related to',
|
||||
('related', False): 'Related to',
|
||||
}
|
||||
|
||||
# Offered in the "Link an issue" picker. The value is what gets stored; the
|
||||
# phrasing is from the point of view of the issue being viewed.
|
||||
TYPE_CHOICES = [
|
||||
('duplicate', 'Duplicate of'),
|
||||
('related', 'Related to'),
|
||||
]
|
||||
|
||||
id = db.Column(db.Integer, primary_key=True)
|
||||
issue_id = db.Column(db.Integer,
|
||||
db.ForeignKey('issues.id', ondelete='CASCADE'),
|
||||
nullable=False, index=True)
|
||||
linked_issue_id = db.Column(db.Integer,
|
||||
db.ForeignKey('issues.id', ondelete='CASCADE'),
|
||||
nullable=False, index=True)
|
||||
link_type = db.Column(db.Enum('duplicate', 'related'),
|
||||
nullable=False, default='related')
|
||||
created_by = db.Column(db.Integer,
|
||||
db.ForeignKey('users.id', ondelete='SET NULL'),
|
||||
nullable=True)
|
||||
created_at = db.Column(db.DateTime, default=now_eastern, nullable=False)
|
||||
|
||||
__table_args__ = (
|
||||
# Catches the exact-duplicate row at the database level. The REVERSE
|
||||
# direction is caught by exists_between() — see the class docstring.
|
||||
db.UniqueConstraint('issue_id', 'linked_issue_id', name='uq_issue_link'),
|
||||
)
|
||||
|
||||
# BOTH relationships must pin foreign_keys: two FKs from this table to
|
||||
# issues leave the join condition ambiguous otherwise, and the mapper raises
|
||||
# on first ORM USE rather than at import — the app starts cleanly and then
|
||||
# every request 500s (CLAUDE.md rule 86).
|
||||
issue = db.relationship('Issue', foreign_keys=[issue_id],
|
||||
back_populates='links_from')
|
||||
linked_issue = db.relationship('Issue', foreign_keys=[linked_issue_id],
|
||||
back_populates='links_to')
|
||||
creator = db.relationship('User', foreign_keys=[created_by])
|
||||
|
||||
def label_for(self, viewing_issue_id):
|
||||
"""How this link reads on the issue currently being viewed."""
|
||||
return self.LABELS[(self.link_type, self.issue_id == viewing_issue_id)]
|
||||
|
||||
def other_issue(self, viewing_issue_id):
|
||||
"""The issue at the far end of this link from the one being viewed."""
|
||||
return (self.linked_issue if self.issue_id == viewing_issue_id
|
||||
else self.issue)
|
||||
|
||||
@staticmethod
|
||||
def exists_between(issue_id, other_id):
|
||||
"""True when the two issues are already linked, in EITHER direction.
|
||||
|
||||
The UniqueConstraint only covers the stored direction, so this is what
|
||||
stops #A being linked to #B and then #B linked back to #A as a second,
|
||||
contradictory row.
|
||||
"""
|
||||
return db.session.query(
|
||||
IssueLink.query.filter(
|
||||
db.or_(
|
||||
db.and_(IssueLink.issue_id == issue_id,
|
||||
IssueLink.linked_issue_id == other_id),
|
||||
db.and_(IssueLink.issue_id == other_id,
|
||||
IssueLink.linked_issue_id == issue_id),
|
||||
)
|
||||
).exists()
|
||||
).scalar()
|
||||
|
||||
def __repr__(self):
|
||||
return (f'<IssueLink {self.issue_id} {self.link_type} '
|
||||
f'{self.linked_issue_id}>')
|
||||
|
||||
|
||||
class Issue(db.Model):
|
||||
__tablename__ = 'issues'
|
||||
|
||||
@@ -115,10 +225,36 @@ class Issue(db.Model):
|
||||
followers = db.relationship('IssueFollower', back_populates='issue',
|
||||
cascade='all, delete-orphan', lazy='dynamic')
|
||||
|
||||
# An issue link is stored once and shown on both issues, so each issue has
|
||||
# rows pointing OUT of it and rows pointing AT it. Deleting an issue must
|
||||
# take its links with it from BOTH sides, or the surviving issue keeps a row
|
||||
# referencing one that no longer exists.
|
||||
links_from = db.relationship('IssueLink', back_populates='issue',
|
||||
foreign_keys='IssueLink.issue_id',
|
||||
cascade='all, delete-orphan', lazy='dynamic')
|
||||
links_to = db.relationship('IssueLink', back_populates='linked_issue',
|
||||
foreign_keys='IssueLink.linked_issue_id',
|
||||
cascade='all, delete-orphan', lazy='dynamic')
|
||||
|
||||
def is_followed_by(self, user):
|
||||
"""Return True if the given user is currently following this issue."""
|
||||
return self.followers.filter_by(user_id=user.id).first() is not None
|
||||
|
||||
def all_links(self):
|
||||
"""Every link touching this issue, from both directions, newest first.
|
||||
|
||||
The two relationships are a storage detail — a link is one thing to the
|
||||
person reading it, so callers get a single list and ask each row how it
|
||||
reads via label_for() / other_issue().
|
||||
|
||||
Nothing here filters by permission. The caller MUST drop links whose far
|
||||
end the viewer cannot access, or a link becomes a way to read another
|
||||
customer's issue. See _readable_links() in routes/issues.py.
|
||||
"""
|
||||
links = list(self.links_from) + list(self.links_to)
|
||||
links.sort(key=lambda link: link.created_at, reverse=True)
|
||||
return links
|
||||
|
||||
# Human-readable label for the handler category (phase35).
|
||||
# Perspective-neutral wording so it reads the same for staff and customers.
|
||||
HANDLER_LABELS = {
|
||||
|
||||
Reference in New Issue
Block a user