def delete(request, body, *args, **kwargs):
"""
Delete Account
Method: Post
Request: accountId
"""
account_id = body.get('id')
try:
account = Account.objects.get(account_id=account_id,
status=Status.valid.key)
user = User.objects.get(account_id=account_id, status=Status.valid.key)
except ObjectDoesNotExist:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
timestamp = mills_timestamp()
try:
with transaction.atomic():
account.status = Status.invalid.key
account.update_date = timestamp
account.save()
user.status = Status.invalid.key
user.update_date = timestamp
user.save()
except Exception as e:
print(e)
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(resp=resp)
def atl_login(request, body, *args, **kwargs):
"""
Update atlassian login info
Method: Post
Request: first_name,last_name,old_password,password
"""
try:
user = request.session.get('user', {})
# if user['atl_login']:
# resp = init_http_response_my_enum(RespCode.success)
# return make_json_response(resp=resp)
user['atl_username'] = body['atl_username']
user['atl_password'] = body['atl_password']
# user['atl_login'] = True
request.session['user'] = user
confluence = Confluence(
url='https://confluence.cis.unimelb.edu.au:8443/',
username=request.session['user']['atl_username'],
password=request.session['user']['atl_password'])
conf_resp = confluence.get_all_groups()
# print("~~")
# print(request.session['user']['atl_username'])
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(resp=resp)
except requests.exceptions.HTTPError as e:
resp = init_http_response_my_enum(RespCode.server_error)
return make_json_response(resp=resp)
def invite_accept(request, body, *args, **kwargs):
"""
Accept Invitation and Create Account (WIP)
Method: Post
Request: key, username, password
"""
invite_accept_dto = InviteAcceptDTO()
body_extract(body, invite_accept_dto)
if not invite_accept_dto.not_empty():
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
if Account.objects.filter(username=invite_accept_dto.username).exists():
resp = init_http_response_my_enum(RespCode.account_existed)
return make_json_response(resp=resp)
try:
invitation = Invitation.objects.get(key=invite_accept_dto.key,
status=InvitationStatus.sent.key)
except Exception as e:
print(e)
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
timestamp = mills_timestamp()
data = dict()
try:
with transaction.atomic():
invite_accept_dto.encrypt()
account = Account(username=invite_accept_dto.username,
password=invite_accept_dto.md5,
email=invitation.email,
status=Status.valid.key,
create_date=timestamp,
update_date=timestamp)
account.save()
data['account_id'] = account.account_id
user = User(account_id=account.account_id,
username=invite_accept_dto.username,
first_name=invite_accept_dto.first_name,
last_name=invite_accept_dto.last_name,
role=Roles.supervisor.key,
status=Status.valid.key,
create_date=timestamp,
update_date=timestamp,
email=invitation.email)
user.save()
invitation.status = InvitationStatus.accepted.key
invitation.accept_reject_date = timestamp
invitation.save()
except Exception as e:
print(e)
resp = init_http_response_my_enum(RespCode.server_error)
return make_json_response(resp=resp)
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(resp=resp)
def get_account(request):
"""
Get Account
Method: Get
Request: accountId
"""
user = request.session.get('user')
user_id = user['id']
try:
user = User.objects.get(user_id=user_id, status=Status.valid.key)
except ObjectDoesNotExist:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
account_id = int(request.GET.get('id', user.account_id))
if not account_id:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
try:
account = Account.objects.get(account_id=account_id,
status=Status.valid.key)
except ObjectDoesNotExist:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
data = dict(
username=account.username,
email=account.email,
first_name=user.first_name,
last_name=user.last_name,
)
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(resp=resp)
def get_git_individual_commits(request, space_key):
data = []
if StudentCommitCounts.objects.filter(space_key=space_key).exists():
for item in StudentCommitCounts.objects.filter(space_key=space_key):
temp = {
"student": str(item.student_name),
"commit_count": int(item.commit_counts)
}
data.append(temp)
else:
if ProjectCoordinatorRelation.objects.filter(space_key=space_key).exists():
update_individual_commits()
temp = {}
for item in StudentCommitCounts.objects.filter(space_key=space_key):
temp = {
"student": str(item.student_name),
"commit_count": int(item.commit_counts)
}
data.append(temp)
else:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(resp=resp)
def team_configure(request, body, *args, **kwargs):
team_id = None
if isinstance(kwargs, dict):
team_id = kwargs.get('team_id', None)
if team_id:
try:
team_configuration = TeamConfiguration.objects.get(team_id=team_id)
except ObjectDoesNotExist as e:
logger.info(e)
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
else:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
if request.method == 'POST':
team_configuration_dto = TeamConfigurationDTO()
body_extract(body, team_configuration_dto)
team_configuration.slack_workspace = team_configuration_dto.slack_workspace
team_configuration.confluence_workspace = team_configuration_dto.confluence_workspace
team_configuration.jira_workspace = team_configuration_dto.jira_workspace
team_configuration.git_repository = team_configuration_dto.git_repository
team_configuration.save()
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(HttpResponse, resp)
elif request.method == 'GET':
data = dict()
data['slack_workspace'] = team_configuration.slack_workspace
data['confluence_workspace'] = team_configuration.confluence_workspace
data['jira_workspace'] = team_configuration.jira_workspace
data['git_repository'] = team_configuration.git_repository
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(HttpResponse, resp)
return HttpResponseNotAllowed(['POST', 'GET'])
def get_git_commits(request, body, *args, **kwargs):
git_dto = GitDTO()
body_extract(body, git_dto)
if not git_dto.valid_url:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
git_dto.url = git_dto.url.lstrip('$')
commits = get_commits(git_dto.url, git_dto.author, git_dto.branch,
git_dto.second_after, git_dto.second_before)
total = len(commits)
author = set()
file_changed = 0
insertion = 0
deletion = 0
for commit in commits:
file_changed += commit['file_changed']
insertion += commit['insertion']
deletion += commit['deletion']
author.add(commit['author'])
data = dict(
total=total,
author=list(author),
file_changed=file_changed,
insertion=insertion,
deletion=deletion,
commits=commits,
)
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(resp=resp)
def get_supervisor(request, supervisor_id, *args, **kwargs):
"""
:param request:
:param supervisor_id:
:param args:
:param kwargs:
:return:
"""
try:
supervisor = User.objects.get(
user_id=supervisor_id,
role__in=[Roles.supervisor.key, Roles.coordinator.key],
status=Status.valid.key)
except ObjectDoesNotExist as e:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
data = dict(
id=supervisor.user_id,
name=supervisor.get_name(),
email=supervisor.email,
)
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(resp=resp)
def update_account(request, body, *args, **kwargs):
"""
Update account
Method: Post
Request: first_name,last_name,old_password,password
"""
user = request.session.get('user')
user_id = user['id']
update_account_dto = UpdateAccountDTO()
body_extract(body, update_account_dto)
update_account_dto.encrypt()
try:
user = User.objects.get(user_id=user_id, status=Status.valid.key)
account = Account.objects.get(account_id=user.account_id,
status=Status.valid.key)
except ObjectDoesNotExist:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
if (update_account_dto.old_password and update_account_dto.old_md5 != account.password) \
or not update_account_dto.validate():
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
timestamp = mills_timestamp()
if update_account_dto.first_name:
user.first_name = update_account_dto.first_name
user.update_date = timestamp
if update_account_dto.role:
user.role = update_account_dto.role
user.update_date = timestamp
if update_account_dto.last_name:
user.last_name = update_account_dto.last_name
user.update_date = timestamp
if update_account_dto.atl_username:
user.atl_username = update_account_dto.atl_username
user.update_date = timestamp
if update_account_dto.atl_password:
update_account_dto.encrypt_aes()
user.atl_password = update_account_dto.aes
user.update_date = timestamp
if update_account_dto.old_password and update_account_dto.password \
and update_account_dto.old_md5 == account.password:
account.password = update_account_dto.md5
account.update_date = timestamp
try:
with transaction.atomic():
user.save()
account.save()
except Exception as e:
print(e)
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(resp=resp)
def get_team_members(request, *args, **kwargs):
"""
Get certain team members
:param request:
:param team_id:
:return:
"""
team_id = int(kwargs['id'])
members = []
data = dict()
try:
team = Team.objects.get(team_id=team_id)
team_members = TeamMember.objects.filter(team_id=team_id)
except ObjectDoesNotExist as e:
logger.info(e)
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
try:
supervisor = User.objects.get(account_id=team.supervisor_id)
if supervisor:
data['supervisor'] = supervisor_data = {
'supervisor_id': supervisor.account_id,
'supervisor_first_name': supervisor.first_name,
'supervisor_last_name': supervisor.last_name,
'email': supervisor.email
}
except ObjectDoesNotExist:
data['supervisor'] = "supervisor not exist"
try:
secondary_supervisor = User.objects.get(
account_id=team.secondary_supervisor_id)
if secondary_supervisor:
data['secondary_supervisor'] = secondary_supervisor_data = {
'secondary_supervisor_id': secondary_supervisor.account_id,
'secondary_supervisor_first_name':
secondary_supervisor.first_name,
'secondary_supervisor_last_name':
secondary_supervisor.last_name,
'email': secondary_supervisor.email,
}
except ObjectDoesNotExist:
data['secondary_supervisor'] = "secondary_supervisor not exist"
for member in team_members:
student = Student.objects.get(student_id=member.student_id)
member_data = {
'student_id': student.student_id,
'fullname': student.fullname,
'email': student.email
}
members.append(member_data)
data['team_members'] = members
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(HttpResponse, resp)
def add_account(request, body, *args, **kwargs):
"""
Create account and user
Method: Post
Request: username, email, password, role, first_name, last_name
"""
add_account_dto = AddAccountDTO()
body_extract(body, add_account_dto)
if not add_account_dto.not_empty() or not add_account_dto.validate():
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
if Account.objects.filter(
Q(username=add_account_dto.username)
| Q(email=add_account_dto.email)).exists():
resp = init_http_response_my_enum(RespCode.account_existed)
return make_json_response(resp=resp)
add_account_dto.encrypt()
timestamp = mills_timestamp()
try:
with transaction.atomic():
account = Account(username=add_account_dto.username,
email=add_account_dto.email,
password=add_account_dto.md5,
status=Status.valid.key,
create_date=timestamp,
update_date=timestamp)
account.save()
user = User(account_id=account.account_id,
username=add_account_dto.username,
first_name=add_account_dto.first_name,
last_name=add_account_dto.last_name,
role=add_account_dto.role,
status=Status.valid.key,
create_date=timestamp,
update_date=timestamp,
email=add_account_dto.email)
user.save()
except Exception as e:
print(e)
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(resp=resp)
def login(request, body, *args, **kwargs):
"""
Login
Method: Post
Request: username(can input username or email to this), password
"""
login_dto = LoginDTO()
body_extract(body, login_dto)
if not login_dto.validate():
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
login_dto.encrypt()
account = None
try:
if login_dto.username:
account = Account.objects.get(username=login_dto.username,
password=login_dto.md5,
status=Status.valid.key)
elif login_dto.email:
account = Account.objects.get(email=login_dto.email,
password=login_dto.md5,
status=Status.valid.key)
except ObjectDoesNotExist:
resp = init_http_response_my_enum(RespCode.login_fail)
return make_json_response(resp=resp)
user = User.objects.get(account_id=account.account_id)
session_data = dict(
id=user.user_id,
name=user.get_name(),
role=user.role,
is_login=True,
atl_login=False,
atl_username=None,
atl_password=None,
)
request.session['user'] = session_data
data = dict(user_id=user.user_id,
account_id=account.account_id,
role=user.role,
name=user.get_name())
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(resp=resp)
def multi_get_supervisor(request, *args, **kwargs):
"""
:param request:
:param args:
:param kwargs:
:return:
"""
offset = int(request.GET.get('offset', 0))
has_more = 0
supervisors = User.objects.filter(role__in=[Roles.supervisor.key, Roles.coordinator.key], status=Status.valid.key)\
.only('user_id')[offset: offset + SINGLE_PAGE_LIMIT + 1]
if len(supervisors) > SINGLE_PAGE_LIMIT:
supervisors = supervisors[:SINGLE_PAGE_LIMIT]
has_more = 1
offset += len(supervisors)
data = dict(
supervisors=[supervisor.user_id for supervisor in supervisors],
offset=offset,
has_more=has_more,
)
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(resp=resp)
def logout(request, *args, **kwargs):
"""
:param request:
:param args:
:param kwargs:
:return:
"""
user = request.session.get('user')
if user is None:
resp = init_http_response_my_enum(RespCode.not_logged)
return make_json_response(resp=resp)
request.session.flush()
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(resp=resp)
def get_metrics(relation):
data = {"url": relation.git_url}
# create GitDTO object
git_dto = GitDTO()
# extract body information and store them in GitDTO.
body_extract(data, git_dto)
if not git_dto.valid_url:
resp = init_http_response_my_enum(RespCode.no_repository)
return make_json_response(resp=resp)
git_dto.url = git_dto.url.lstrip('$')
metrics = get_und_metrics(git_dto.url, relation.space_key)
if metrics is None:
resp = init_http_response_my_enum(RespCode.invalid_authentication)
return make_json_response(resp=resp)
elif metrics == -1:
resp = init_http_response_my_enum(RespCode.user_not_found)
return make_json_response(resp=resp)
elif metrics == -2:
resp = init_http_response_my_enum(RespCode.git_config_not_found)
return make_json_response(resp=resp)
if GitMetrics.objects.filter(space_key=relation.space_key).exists():
GitMetrics.objects.filter(space_key=relation.space_key).update(
file_count=metrics['CountDeclFile'],
class_count=metrics['CountDeclClass'],
function_count=metrics['CountDeclFunction'],
code_lines_count=metrics['CountLineCode'],
declarative_lines_count=metrics['CountLineCodeDecl'],
executable_lines_count=metrics['CountLineCodeExe'],
comment_lines_count=metrics['CountLineComment'],
comment_to_code_ratio=metrics['RatioCommentToCode'],
)
else:
metrics_dto = GitMetrics(
space_key=relation.space_key,
file_count=metrics['CountDeclFile'],
class_count=metrics['CountDeclClass'],
function_count=metrics['CountDeclFunction'],
code_lines_count=metrics['CountLineCode'],
declarative_lines_count=metrics['CountLineCodeDecl'],
executable_lines_count=metrics['CountLineCodeExe'],
comment_lines_count=metrics['CountLineComment'],
comment_to_code_ratio=metrics['RatioCommentToCode'],
)
metrics_dto.save()
def update_individual_commits():
for relation in ProjectCoordinatorRelation.objects.all():
data = {"url": relation.git_url}
# create GitDTO object
git_dto = GitDTO()
# extract body information and store them in GitDTO.
body_extract(data, git_dto)
if not git_dto.valid_url:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
git_dto.url = git_dto.url.lstrip('$')
# request commits from github api
commits = get_commits(git_dto.url, relation.space_key, git_dto.author,
git_dto.branch, git_dto.second_after,
git_dto.second_before)
# commits = get_commits(git_dto.url, git_dto.author, git_dto.branch, git_dto.second_after, git_dto.second_before)
if commits is None:
resp = init_http_response_my_enum(RespCode.invalid_authentication)
return make_json_response(resp=resp)
if commits == -1:
resp = init_http_response_my_enum(RespCode.user_not_found)
return make_json_response(resp=resp)
if commits == -2:
resp = init_http_response_my_enum(RespCode.git_config_not_found)
return make_json_response(resp=resp)
CommitCount = defaultdict(lambda: 0)
for commit in commits:
CommitCount[commit['author']] += 1
for key, value in CommitCount.items():
if StudentCommitCounts.objects.filter(
student_name=str(key)).exists():
user = StudentCommitCounts.objects.get(student_name=str(key))
if str(value) != user.commit_counts:
StudentCommitCounts.objects.filter(
student_name=str(key)).update(commit_counts=str(value))
else:
user = StudentCommitCounts(student_name=str(key),
commit_counts=str(value),
space_key=relation.space_key)
user.save()
def team_member_configure(request, *args, **kwargs):
team_id = None
team_member_id = None
if isinstance(kwargs, dict):
team_id = kwargs.get('team_id', None)
team_member_id = kwargs.get('team_member_id', None)
print(team_id, team_member_id)
if team_id and team_member_id:
try:
team_member = TeamMember.objects.get(team_id=team_id,
member_id=team_member_id)
print(team_member)
except ObjectDoesNotExist as e:
logger.info(e)
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
try:
student = Student.objects.get(student_id=team_member.student_id)
print(student)
except ObjectDoesNotExist as e:
logger.info(e)
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
else:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
if request.method == 'POST':
body = dict(ujson.loads(request.body))
team_member_dto = TeamMemberDTO()
body_extract(body, team_member_dto)
student.git_name = team_member_dto.git_name
student.slack_email = team_member_dto.slack_email
student.atl_account = team_member_dto.atl_account
student.save()
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(HttpResponse, resp)
elif request.method == 'GET':
data = dict()
data['git_name'] = student.git_name
data['slack_email'] = student.slack_email
data['atl_account'] = student.atl_account
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(HttpResponse, resp)
return HttpResponseNotAllowed(['POST', 'GET'])
def update_team(request, body, *args, **kwargs):
team_id = kwargs.get('id')
update_team_dto = UpdateTeamDTO()
body_extract(body, update_team_dto)
try:
team = Team.objects.get(team_id=team_id)
except ObjectDoesNotExist as e:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
if update_team_dto.supervisor_id:
team.supervisor_id = update_team_dto.supervisor_id
if update_team_dto.secondary_supervisor_id:
team.secondary_supervisor_id = update_team_dto.secondary_supervisor_id
team.save()
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(resp=resp)
def get_git_pr(request, body, *args, **kwargs):
git_dto = GitDTO()
body_extract(body, git_dto)
if not git_dto.valid_url:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
git_dto.url = git_dto.url.lstrip('$')
commits = get_pull_request(git_dto.url, git_dto.author, git_dto.branch,
git_dto.second_after, git_dto.second_before)
total = len(commits)
author = set()
for commit in commits:
author.add(commit['author'])
data = dict(
total=total,
author=list(author),
commits=commits,
)
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(resp=resp)
def check_oauth(team_id):
# retrieve Slack configuration
try:
team_configuration = TeamConfiguration.objects.get(team_id=team_id)
except ObjectDoesNotExist as e:
resp = init_http_response_my_enum(RespCode.invalid_op)
resp['message'] = "Invalid team configuration"
return make_json_response(resp=resp)
# retrieve token by team_id from team Slack configuration
if team_configuration.slack_access:
token = team_configuration.slack_token
if token:
slack_client = WebClient(token=token)
return slack_client
else:
resp = init_http_response_my_enum(RespCode.invalid_op)
resp['message'] = "Need access to Slack workspace"
return make_json_response(resp=resp)
# Todo: Oauth v2
return None
def get_git_metrics(request, space_key):
# Case 1: if git_metrics table contains this space_key, get it directly from db
if GitMetrics.objects.filter(space_key=space_key).exists():
metrics_data = GitMetrics.objects.filter(space_key=space_key)[0]
# Case 2: if git_metrics table does not contain this space_key, get it using get_metrics()
else:
coordinator_id = request.session['coordinator_id']
if ProjectCoordinatorRelation.objects.filter(space_key=space_key, coordinator_id=coordinator_id).exists():
relation_data = ProjectCoordinatorRelation.objects.filter(space_key=space_key, coordinator_id=coordinator_id)[0]
get_metrics(relation_data)
if GitMetrics.objects.filter(space_key=space_key).exists():
metrics_data = GitMetrics.objects.filter(space_key=space_key)[0]
else:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
# Case 3: if space_key is invalid, return None
else:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
data = []
tmp = {
"file_count": int(metrics_data.file_count),
"class_count": int(metrics_data.class_count),
"function_count": int(metrics_data.function_count),
"code_lines_count": int(metrics_data.code_lines_count),
"declarative_lines_count": int(metrics_data.declarative_lines_count),
"executable_lines_count": int(metrics_data.executable_lines_count),
"comment_lines_count": int(metrics_data.comment_lines_count),
"comment_to_code_ratio": float(metrics_data.comment_to_code_ratio),
}
data.append(tmp)
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(resp=resp)
def get_team_data(request, *args, **kwargs):
team_id = kwargs['id']
try:
team = Team.objects.get(team_id=team_id)
except ObjectDoesNotExist as e:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
# call Slack api to get all Slack channels before the end of the sprint
client = check_oauth(team_id)
if not client:
resp = init_http_response_my_enum(RespCode.invalid_op)
return make_json_response(resp=resp)
elif isinstance(client, HttpResponse):
return client
channels = get_all_channels(client)
logger.info('channel: {}'.format(channels))
# get sprint number from request
sprint_num = request.GET.get("sprint_num", None)
sprint_num = int(sprint_num) if sprint_num is not None else -1
logger.info('sprint_num: {}'.format(sprint_num))
sprint_start = None
sprint_end = None
if sprint_num >= 0:
parameter_start = 'sprint_start_{}'.format(sprint_num)
parameter_end = 'sprint_end_{}'.format(sprint_num)
sprint_start = team.__getattribute__(parameter_start)
sprint_end = team.__getattribute__(parameter_end)
logger.info('sprint start {} end {}'.format(sprint_start, sprint_end))
result = dict()
temp_result = dict()
total_number = 0
if SlackTeam.objects.filter(team_id=team_id,
sprint_num=sprint_num).exists():
records = SlackTeam.objects.filter(
team_id=team_id, sprint_num=sprint_num).order_by('time')
start_time = records[0].time / 1000
if sprint_end and start_time > sprint_end:
for record in records:
result[record.channel_name] = record.message_num
total_number += record.message_num
result['total_number'] = total_number
if sprint_start:
result['sprint_start'] = sprint_start * 1000
if sprint_end:
result['sprint_end'] = sprint_end * 1000
logger.info('result: {}'.format(result))
resp = init_http_response_my_enum(RespCode.success, data=result)
return make_json_response(resp=resp)
else:
# call Slack api to get all channel messages in a specific sprint
for channel in channels:
messages = get_channel_messages(client, channel['id'],
start_time, sprint_end)
temp_result[channel['name']] = len(messages)
for record in records:
record.message_num += temp_result[record.channel_name]
temp_result.pop(record.channel_name)
result[record.channel_name] = record.message_num
total_number += result[record.channel_name]
record.time = mills_timestamp()
record.save()
# save new created channels
logger.info('temp result: {}'.format(temp_result))
for (channel, num) in temp_result.items():
print(channel, num)
result[channel] = num
total_number += num
slack_team = SlackTeam(team_id=team_id,
channel_name=channel,
message_num=num,
sprint_num=sprint_num,
time=mills_timestamp())
slack_team.save()
result["total_number"] = total_number
if sprint_start:
result['sprint_start'] = sprint_start * 1000
if sprint_end:
result['sprint_end'] = sprint_end * 1000
logger.info('result: {}'.format(result))
resp = init_http_response_my_enum(RespCode.success, data=result)
return make_json_response(resp=resp)
else:
# call Slack api to get all channel messages in a specific sprint
for channel in channels:
messages = get_channel_messages(client, channel['id'],
sprint_start, sprint_end)
logger.info("{}: {}".format(channel['name'], len(messages)))
result[channel['name']] = len(messages)
total_number += len(messages)
slack_team = SlackTeam(team_id=team_id,
channel_name=channel['name'],
message_num=result[channel['name']],
sprint_num=sprint_num,
time=mills_timestamp())
slack_team.save()
result['total_number'] = total_number
if sprint_start:
result['sprint_start'] = sprint_start * 1000
if sprint_end:
result['sprint_end'] = sprint_end * 1000
logger.info('result: {}'.format(result))
resp = init_http_response_my_enum(RespCode.success, data=result)
return make_json_response(resp=resp)
def get_member_data(request, *args, **kwargs):
team_id = kwargs['team_id']
student_id = int(kwargs['student_id'])
try:
team = Team.objects.get(team_id=team_id)
except ObjectDoesNotExist as e:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
client = check_oauth(team_id)
if not client:
resp = init_http_response_my_enum(RespCode.invalid_op)
return make_json_response(resp=resp)
elif isinstance(client, HttpResponse):
return client
channels = get_all_channels(client)
users, user_email = get_all_users(client)
email_id = dict()
for uid in user_email:
email_id[user_email[uid]] = uid
student = Student.objects.get(student_id=student_id)
student_uid = email_id[student.email]
student_info = dict(
email=student.email,
id=student_uid,
name=users[email_id[student.email]],
)
print(student_info)
# get sprint number from request
sprint_num = request.GET.get("sprint_num", None)
sprint_num = int(sprint_num) if sprint_num is not None else -1
logger.info('sprint_num: {}'.format(sprint_num))
sprint_start = None
sprint_end = None
if sprint_num >= 0:
parameter_start = 'sprint_start_{}'.format(sprint_num)
parameter_end = 'sprint_end_{}'.format(sprint_num)
sprint_start = team.__getattribute__(parameter_start)
sprint_end = team.__getattribute__(parameter_end)
logger.info('sprint start {} end {}'.format(sprint_start, sprint_end))
result = dict(total_number=0, name=student_info['name'], channel=dict())
for channel in channels:
result['channel'][channel['name']] = 0
temp_result = deepcopy(result)
if SlackMember.objects.filter(team_id=team_id,
student_id=student_id,
sprint_num=sprint_num).exists():
records = SlackMember.objects.filter(
team_id=team_id, student_id=student_id,
sprint_num=sprint_num).order_by('time')
start_time = records[0].time / 1000
if sprint_end and start_time > sprint_end:
for record in records:
result['total_number'] += record.message_num
result['channel'][record.channel_name] = record.message_num
logger.info('result: {}'.format(result))
if sprint_start:
result['sprint_start'] = sprint_start * 1000
if sprint_end:
result['sprint_end'] = sprint_end * 1000
resp = init_http_response_my_enum(RespCode.success, data=result)
return make_json_response(resp=resp)
else:
for channel in channels:
messages = get_channel_messages(client, channel['id'],
start_time, sprint_end)
for message in messages:
if message['user'] != student_info['id']:
continue
temp_result['total_number'] += 1
temp_result['channel'][channel['name']] += 1
for record in records:
record.message_num += temp_result['channel'][
record.channel_name]
temp_result['channel'].pop(record.channel_name)
result['channel'][record.channel_name] = record.message_num
result['total_number'] += record.message_num
record.time = mills_timestamp()
record.save()
# save new created channels
logger.info('temp result: {}'.format(temp_result))
for k, v in temp_result['channel'].items():
result['channel'][k] = v
result['total_number'] += v
slack_member = SlackMember(team_id=team_id,
student_id=student_id,
channel_name=k,
message_num=v,
sprint_num=sprint_num,
time=mills_timestamp())
slack_member.save()
logger.info('result: {}'.format(result))
if sprint_start:
result['sprint_start'] = sprint_start * 1000
if sprint_end:
result['sprint_end'] = sprint_end * 1000
resp = init_http_response_my_enum(RespCode.success, data=result)
return make_json_response(resp=resp)
else:
for channel in channels:
messages = get_channel_messages(client, channel['id'],
sprint_start, sprint_end)
for message in messages:
if message['user'] != student_info['id']:
continue
result['total_number'] += 1
result['channel'][channel['name']] += 1
for c in result['channel']:
slack_member = SlackMember(team_id=team_id,
student_id=student_id,
channel_name=c,
message_num=result['channel'][c],
sprint_num=sprint_num,
time=mills_timestamp())
slack_member.save()
logger.info('result: {}'.format(result))
if sprint_start:
result['sprint_start'] = sprint_start * 1000
if sprint_end:
result['sprint_end'] = sprint_end * 1000
resp = init_http_response_my_enum(RespCode.success, data=result)
return make_json_response(resp=resp)
def get_git_commits(request, space_key):
# Case 1: if git_commit table contains this space_key, get it directly from db
data = []
if GitCommitCounts.objects.filter(space_key=space_key).exists():
query_set = GitCommitCounts.objects.filter(space_key=space_key)
start = 0
if len(query_set) >= 30:
start = len(query_set) - 30
for i in query_set[start:]:
tmp = {
"time": int(i.query_date),
"commit_count": int(i.commit_counts)
}
data.append(tmp)
else:
# Case 2: if git_commit table doesn't contain while relation table contains,
# get it from git web (the first crawler)
coordinator_id = request.session['coordinator_id']
if ProjectCoordinatorRelation.objects.filter(space_key=space_key, coordinator_id=coordinator_id).exists():
relation_data = ProjectCoordinatorRelation.objects.filter(space_key=space_key, coordinator_id=coordinator_id)[0]
git_dto = construct_url(relation_data)
if not git_dto.valid_url:
resp = init_http_response_my_enum(RespCode.no_repository)
return make_json_response(resp=resp)
commits = get_commits(relation_data.git_url, space_key, None, None, None, None)
if commits is None:
resp = init_http_response_my_enum(RespCode.invalid_authentication)
return make_json_response(resp=resp)
if commits == -1:
resp = init_http_response_my_enum(RespCode.user_not_found)
return make_json_response(resp=resp)
if commits == -2:
resp = init_http_response_my_enum(RespCode.git_config_not_found)
return make_json_response(resp=resp)
delta_commit_count = {} # To store every day commit count
days = [] # For a month loop
today = transformTimestamp(time.time())
for i in range(30):
days.append(today - i * 24 * 60 * 60)
for commit in commits:
ts = commit['date']
for i in days:
if ts > i:
break
else:
if i in delta_commit_count:
delta_commit_count[i] += 1
else:
delta_commit_count[i] = 1
days = [i for i in reversed(days)] # sort days
for day in days:
count = 0
if day in delta_commit_count:
count = delta_commit_count[day]
# data which are returned to front end
tmp = {
"time": int(day),
"commit_count": int(count)
}
data.append(tmp)
# store data into db by date
git_data = GitCommitCounts(
space_key=space_key,
commit_counts=count,
query_date=day
)
git_data.save()
# for i in commits:
# ts = transformTimestamp(i['date'])
# if ts in delta_commit_count:
# delta_commit_count[ts] += 1
# else:
# delta_commit_count[ts] = 1
# days.append(ts)
# for day in days:
# count = 0
# for k, v in delta_commit_count.items():
# if k <= day:
# count += v
# # data which are returned to front end
# tmp = {
# "time": int(day),
# "commit_count": int(count)
#
# }
# data.append(tmp)
# # store data into db by date
# git_data = GitCommitCounts(
# space_key=space_key,
# commit_counts=count,
# query_date=day
# )
# git_data.save()
# Case 3: Neither contains, invalid space_key, return None
else:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(resp=resp)
def get_invitation(request):
"""
TODO: update expired status
:param request:
:param subject_id:
:return:
"""
user = request.session.get('user')
user_id = user['id']
finished = request.GET.get('finished', None)
offset = int(request.GET.get('offset', 0))
has_more = 0
kwargs = dict(operator=user_id, )
if finished is not None:
if int(finished) == 0:
kwargs['status__lt'] = InvitationStatus.accepted.key
else:
kwargs['status__gte'] = InvitationStatus.accepted.key
kwargs_update = dict(
expired=mills_timestamp(),
status=InvitationStatus.waiting.key,
)
Invitation.objects.filter(**kwargs_update).update(
status=InvitationStatus.expired.key)
invitations = Invitation.objects.filter(
**kwargs).order_by('invitation_id')[offset:offset + SINGLE_PAGE_LIMIT +
1]
if len(invitations) > SINGLE_PAGE_LIMIT:
invitations = invitations[:SINGLE_PAGE_LIMIT]
has_more = 1
offset += len(invitations)
if len(invitations) == 0:
data = dict(
invitations=[],
has_more=has_more,
offset=offset,
)
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(resp=resp)
data = dict(invitation=[
dict(
id=invitation.invitation_id,
email=invitation.email,
expired=invitation.expired,
status=get_message(InvitationStatus.__members__,
invitation.status),
) for invitation in invitations
],
offset=offset,
has_more=has_more)
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(resp=resp)
def add_invitation(request, body, *args, **kwargs):
"""
TODO: check email in account
TODO: send email
:param body:
:param request:
:return:
"""
print(body)
user = request.session.get('user')
user_id = user['id']
timestamp = mills_timestamp()
expired = timestamp + 1000 * 60 * 60 * 24 * 1
invite_emails = body['emails']
template = body['template']
failed_list = list()
invitations = list()
if PATTERN_COORDINATOR not in template or PATTERN_URL not in template:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
for email in invite_emails:
if Invitation.objects.filter(email=email, status__lte=InvitationStatus.accepted.key).exists() or \
Account.objects.filter(email=email, status=Status.valid.key).exists():
failed_list.append(
dict(
email=email,
status=InvitationRespCode.existed.key,
message=InvitationRespCode.existed.msg,
))
continue
key = ''.join([
''.join(random.sample(string.ascii_letters + string.digits, 8))
for i in range(4)
])
content = str(template).replace(PATTERN_COORDINATOR,
user['name']).replace(
PATTERN_URL,
get_invitation_link(key))
invitation = Invitation(key=key,
email=email,
operator=user_id,
create_date=timestamp,
expired=expired,
template=content,
status=InvitationStatus.waiting.key)
invitations.append(invitation)
try:
with transaction.atomic():
for invite in invitations:
invite.save()
for invite in invitations:
smtp_thread.put_task(invite.invitation_id, user['name'],
invite.email, invite.template)
except Exception as e:
print(e)
resp = init_http_response_my_enum(RespCode.server_error)
return make_json_response(resp=resp)
data = dict(
invitation=[
dict(
email=invite.email,
status=invite.status,
template=invite.template,
message=get_message(InvitationStatus.__members__,
invite.status),
expired=invite.expired,
) for invite in invitations
],
failed=failed_list,
)
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(resp=resp)
