class ProjectIssueMessageModel():
def __init__(self, conn_tool):
self._db = conn_tool.db
self._uid = conn_tool.uid
self._userModel = UserModel(conn_tool)
def get_issues(self, pid):
project = self.__get_project(pid)
if project == None:
return {}
repositories_id = project['repositories']['Github']
token = self._userModel.get_user_githubToken()
requester = GithubApiRequester(token)
issues = []
for id in repositories_id:
repo = {}
rp = requester.get_rp_by_id(id)
repo['name'] = rp.name
if rp is not None:
issue = requester.get_issues(rp)
repo['issue'] = issue
issues.append(repo)
return issues
def __get_project(self, pid):
project = self._db.collection(u'projects').document(
pid).get().to_dict()
return project
class ProjectWeekCommitModel():
def __init__(self, conn_tool):
self._db = conn_tool.db
self._uid = conn_tool.uid
self._userModel = UserModel(conn_tool)
def get_weekcommit(self, pid):
project = self.__get_project(pid)
if project == None :
return {}
repositories_id = project['repositories']['Github']
token = self._userModel.get_user_githubToken()
requester = GithubApiRequester(token)
repos_commits = []
for id in repositories_id:
rp = requester.get_rp_by_id(id)
if rp is not None:
repos_commits.append(requester.get_weekcommit(rp))
all_repo_week_commit = self.__create_repo_week_dict()
for repo_commits in repos_commits:
if repo_commits['start_time'] < all_repo_week_commit['start_time']:
all_repo_week_commit['start_time'] = repo_commits['start_time']
if repo_commits['end_time'] > all_repo_week_commit['end_time']:
all_repo_week_commit['end_time'] = repo_commits['end_time']
for commit_info in repo_commits['commit_info']:
self.__calculate_commit_times(
all_repo_week_commit['commit_info'], commit_info)
#print(all_repo_week_commit)
return all_repo_week_commit
def get_compare_week_commit(self, pid1, pid2):
commit1 = self.get_weekcommit(pid1)
if commit1 == {}:
return {}
commit1_info = {'pid' : pid1, 'commit' : commit1['commit_info']}
commit2 = self.get_weekcommit(pid2)
if commit2 == {}:
return {}
commit2_info = {'pid' : pid2, 'commit' : commit2['commit_info']}
max = lambda m, n: m if m >= n else n
min = lambda m, n: m if m <= n else n
new_start_time = max(commit1['start_time'], commit2['start_time'])
new_end_time = max(commit1['end_time'], commit2['end_time'])
commit_info_list = [commit1_info, commit2_info]
compare_repo_week_commit = dict({
'commit_info' : commit_info_list,
'start_time' : new_start_time,
'end_time' : new_end_time
})
return compare_repo_week_commit
def __create_repo_week_dict(self):
week_dict = {}
commit_info_list = []
week_days = ('Monday', 'Tuesday', 'Wednesday',
'Thursday', 'Friday', 'Saturday', 'Sunday')
for week_day in week_days:
commit_info = {}
commit_info['week_day'] = week_day
for hours in range(24):
commit_info[str(hours).zfill(2)] = 0
commit_info_list.append(commit_info)
week_dict['start_time'] = str(datetime.date(2099, 12, 31)).replace('-', '/')
week_dict['end_time'] = str(datetime.date(1999, 1, 1)).replace('-', '/')
week_dict['commit_info'] = commit_info_list
return week_dict
def __calculate_commit_times(self, week_list: list, commit_info: dict):
for week_day in week_list:
if week_day['week_day'] == commit_info['week_day']:
week_day[commit_info['time']
] = week_day[commit_info['time']] + 1
break
def __get_project(self, pid):
project = self._db.collection(
u'projects').document(pid).get().to_dict()
return project
class ProjectModel():
def __init__(self, conn_tool):
self._db = conn_tool.db
self._uid = conn_tool.uid
self._userModel = UserModel(conn_tool)
def get_project_list(self):
proj_owner = self._db.collection('projects').where(
'owner', '==', self._uid).get()
proj_collab = self._db.collection('projects').where(
'collaborator', 'array_contains', self._uid).get()
proj_list = []
self.__build_project_list(proj_list, proj_owner)
self.__build_project_list(proj_list, proj_collab)
return {'projects': proj_list}, status_code.OK
def __build_project_list(self, proj_list, projects):
for project in projects:
tmpData = project.to_dict()
tmpData['owner'] = self._userModel.get_user_info_by_uid(
tmpData['owner'])[0]
proj_dic = Project.from_dict(tmpData).to_dict()
proj_dic.update({'id': project.id})
proj_list.append(proj_dic)
def get_avail_repos(self, pid):
token = self._userModel.get_user_githubToken()
if token != None:
requester = GithubApiRequester(token)
existRepos = self._db.collection('projects').document(
pid).get().to_dict()
userRepos = requester.get_user_repoList()['repos']
info = {'repos': []}
for repo in userRepos:
if repo['id'] not in existRepos['repositories']['Github']:
info['repos'].append(repo)
return jsonify(info)
else:
return {'message': '尚未連結Github'}, status_code.NOT_FOUND
def get_project_repos(self, pid):
project, token = self._db.collection('projects').document(
pid).get().to_dict(), None
if project['owner'] == self._uid:
token = self._userModel.get_user_githubToken()
else:
token = self._userModel.get_user_githubToken(project['owner'])
info = {'repos': []}
if token != None:
requester = GithubApiRequester(token)
for repo in requester.get_user_repoList()['repos']:
if repo['id'] in project['repositories']['Github']:
info['repos'].append(repo)
return info, status_code.OK
else:
None, status_code.NOT_FOUND
def get_project_setting(self, pid):
project = self._db.collection('projects').document(pid).get()
if project.exists:
proj_dic = project.to_dict()
setting = Setting(proj_dic['name'], proj_dic['collaborator'],
self._userModel)
return setting.to_dict(), status_code.OK
return None, status_code.NOT_FOUND
def add_project(self, name):
if self.__is_project_name_used(name):
return None, status_code.BAD_REQUEST
project = Project(name=name,
owner=self._uid,
updated=firestore.SERVER_TIMESTAMP)
project_dict = {
'name': project.name,
'owner': project.owner,
'collaborator': project.collaborator,
'repositories': project.repositories,
'updated': project.updated
}
self._db.collection('projects').document().set(project_dict)
return None, status_code.OK
def __is_project_name_used(self, name):
projects = self._db.collection('projects').where(
'name', '==', name).where('owner', '==', self._uid).get()
for project in projects:
if project.to_dict()['owner'] == self._uid:
return True
return False
def delete_project(self, pid):
project = self._db.collection('projects').document(pid)
if project.get().exists and project.get().to_dict(
)['owner'] == self._uid:
project.delete()
return None, status_code.OK
return None, status_code.NOT_FOUND
def update_repos(self, pid, data):
project = self._db.collection('projects').document(pid)
print(data)
if project.get().exists:
if not self.__is_project_owner(project.get().to_dict(), self._uid):
return None, status_code.OK
action = data['repositories']['action']
if action == 'update':
project.update({
'repositories.Github':
firestore.ArrayUnion(data['repositories']['Github']),
'updated':
firestore.SERVER_TIMESTAMP
})
elif action == 'remove':
project.update({
'repositories.Github':
firestore.ArrayRemove(data['repositories']['Github']),
'updated':
firestore.SERVER_TIMESTAMP
})
else:
return 'missing action', status_code.BAD_REQUEST
return None, status_code.OK
else:
return None, status_code.NOT_FOUND
def __is_project_owner(self, project, uid):
return project['owner'] == uid
def update_collaborator(self, pid, collaborator, action):
project = self._db.collection('projects').document(pid)
if project.get().exists:
if action == 'add':
info, code = self._userModel.get_user_info_by_email(
collaborator)
if code == status_code.NOT_FOUND:
return info, code
elif info['uid'] in project.get().to_dict()['collaborator']:
info, code = {'msg': '協作者已存在！'}, status_code.BAD_REQUEST
elif info['uid'] == self._uid:
info, code = {'msg': '您已是專案擁有者！'}, status_code.BAD_REQUEST
else:
project.update({
'collaborator':
firestore.ArrayUnion([info['uid']]),
'updated':
firestore.SERVER_TIMESTAMP
})
code = status_code.OK
return info, code
elif action == 'remove':
project.update({
'collaborator':
firestore.ArrayRemove([collaborator]),
'updated':
firestore.SERVER_TIMESTAMP
})
return {'msg': '移除成功！'}, status_code.OK
else:
return {'msg': 'miss action'}, status_code.BAD_REQUEST
else:
return {'msg': 'Project Not Found'}, status_code.NOT_FOUND
def update_name(self, pid, name):
project = self._db.collection('projects').document(pid)
if project.get().exists:
if name != '':
project.update({
'name': name,
'updated': firestore.SERVER_TIMESTAMP
})
return None, status_code.OK
else:
return 'name is require', status_code.BAD_REQUEST
else:
return None, status_code.NOT_FOUND
