def pre_update(new_data: dict, old_issue: Issue):
if 'status' in new_data and old_issue.status != new_data['status']:
new_data['status_date'] = datetime.now()
if new_data['status'] == 'in progress':
new_data['assignee_id'] = get_user_id()
if new_data['status'] == 'todo':
new_data['assignee_id'] = None
def start_time(project_id, issue_id=None): # pylint: disable=unused-variable
user_id = get_user_id()
with db.session_scope() as conn:
check_project(project_id, conn)
entry = TimeEntry(project_id=project_id,
issue_id=issue_id,
user_id=user_id)
conn.add(entry)
def check_project(project_id, conn):
user_id = get_user_id()
if conn.query(Project).join(projects_users).join(User).filter(
User.id == user_id).filter(
Project.id == project_id).count() != 1:
logger.error("check_project failed! project: %s, user: %s",
project_id, user_id)
abort(404)
def stop_time(): # pylint: disable=unused-variable
user_id = get_user_id()
with db.session_scope() as conn:
entry = conn.query(TimeEntry).filter(
TimeEntry.user_id == user_id).filter(
TimeEntry.end.is_(None)).first()
if entry:
entry.end = datetime.now()
return time_entry_to_dict(entry)
def leave_project(project_id: int): # pylint: disable=unused-variable
with db.session_scope() as conn:
check_project(project_id, conn)
user_id = get_user_id()
project = conn.query(Project).filter(
Project.id == project_id).first() # type: Project
user = conn.query(User).filter(User.id == user_id).first()
project.users.remove(user)
return True
def get_projects(id: int = None): # pylint: disable=unused-variable
user_id = get_user_id()
with db.session_scope() as conn:
qs = conn.query(Project).outerjoin(Payment).join(projects_users).join(User).filter(User.id == user_id) \
.outerjoin(Issue,Project.id == Issue.project_id)
if id:
qs = qs.filter(Project.id == id)
data = {r.id: project_to_dict(r) for r in qs.all()}
return data
def get_ticking_stat(): # pylint: disable=unused-variable
user_id = get_user_id()
with db.session_scope() as conn:
entry = conn.query(TimeEntry).filter(
TimeEntry.user_id == user_id, TimeEntry.end.is_(None)).first()
if entry:
return {'ticking': True, 'entry': time_entry_to_dict(entry)}
else:
return {'ticking': False}
return {}
def delete_issue(id: int): # pylint: disable=unused-variable
user_id = get_user_id()
with db.session_scope() as conn:
issue = conn.query(Issue).join(Project).join(projects_users).join(
User).filter(User.id == user_id).filter(
Issue.id == id).first()
if not issue:
abort(404)
conn.delete(issue)
return True
def delete_project_token(id: int): # pylint: disable=unused-variable
user_id = get_user_id()
with db.session_scope() as conn:
qs = conn.query(ProjectInvitationToken).join(Project).join(projects_users).join(User).filter(User.id == user_id) \
.filter(ProjectInvitationToken.id == id)
prj_token = qs.first()
if not prj_token:
abort(404)
conn.delete(prj_token)
return True
def delete_payment(id: int): # pylint: disable=unused-variable
user_id = get_user_id()
with db.session_scope() as conn:
qs = conn.query(Payment).join(Project).join(projects_users).join(
User).filter(User.id == user_id).filter(Payment.id == id)
payment = qs.first()
if not payment:
abort(404)
conn.delete(payment)
return True
def delete_time_entry(id: int): # pylint: disable=unused-variable
user_id = get_user_id()
with db.session_scope() as conn:
qs = conn.query(TimeEntry).join(Project).join(projects_users).join(
User).filter(User.id == user_id).filter(TimeEntry.id == id)
entry = qs.first()
if not entry:
abort(404)
conn.delete(entry)
return True
def join_to_project(token: str): # pylint: disable=unused-variable
with db.session_scope() as conn:
user_id = get_user_id()
prj_token = conn.query(ProjectInvitationToken).filter(
ProjectInvitationToken.token == token).first()
if not prj_token:
abort(404)
project = conn.query(Project).filter(
Project.id == prj_token.project_id).first() # type: Project
user = conn.query(User).filter(User.id == user_id).first()
if user not in project.users:
project.users.append(user)
return True
def add_time(project_id: int, amount: str, start: str, issue_id=None): # pylint: disable=unused-variable
user_id = get_user_id()
with db.session_scope() as conn:
check_project(project_id, conn)
seconds = parse(amount)
start = dateparser(start) if start else (
datetime.now() - timedelta(seconds=seconds))
end = start + timedelta(seconds=seconds)
entry = TimeEntry(project_id=project_id,
issue_id=issue_id,
start=start,
end=end,
user_id=user_id)
conn.add(entry)
def add_payment(project_id: int, amount: str, paid_user_id: int, time: str,
note: str): # pylint: disable=unused-variable
user_id = get_user_id()
with db.session_scope() as conn:
check_project(project_id, conn)
payment = Payment(
project_id=project_id,
amount=parse(amount),
paid_user_id=paid_user_id,
created_user_id=user_id,
note=note,
time=dateparser(time) if time else datetime.now())
conn.add(payment)
return True
def process_issues(issues): # pylint: disable=unused-variable
def pre_update(new_data: dict, old_issue: Issue):
if 'status' in new_data and old_issue.status != new_data['status']:
new_data['status_date'] = datetime.now()
if new_data['status'] == 'in progress':
new_data['assignee_id'] = get_user_id()
if new_data['status'] == 'todo':
new_data['assignee_id'] = None
with db.session_scope() as conn:
issues = process_resources(
issues, Issue, conn, {
'pre_process': lambda d: {
'reporter_id': get_user_id()
},
'pre_update': pre_update,
'checker': lambda i: check_project(i.project_id, conn),
'post_process': lambda d, i: None if 'id' in d else {
'rank': i.id
},
})
return {i.id: issue_to_dict(i) for i in issues}
def get_issues(project_id: int): # pylint: disable=unused-variable
user_id = get_user_id()
with db.session_scope() as conn:
rows = conn.query(Issue).join(Project).join(projects_users).join(User).filter(User.id == user_id) \
.filter(Project.id == project_id).all()
return {r.id: issue_to_dict(r) for r in rows}
def get_current_user(conn):
user_id = get_user_id()
return conn.query(User).filter(User.id == user_id).first()