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)