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 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 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 import_team(request, body, *args, **kwargs): """ Import team from confluence with supervisor_id :param request: :param body: :param args: :param kwargs: :return: """ add_team_dto = AddTeamDTO() body_extract(body, add_team_dto) # Check parameters if not add_team_dto.not_empty(): resp = init_http_response(RespCode.invalid_parameter.value.key, RespCode.invalid_parameter.value.msg) return make_json_response(HttpResponse, resp) team_members = get_members(request, add_team_dto.team) if not team_members: logger.info('Empty team member: %s', add_team_dto.team) resp = init_http_response(RespCode.invalid_parameter.value.key, RespCode.invalid_parameter.value.msg) return make_json_response(HttpResponse, resp) # If the team existed if Team.objects.filter(name=add_team_dto.team).exists(): resp = init_http_response(RespCode.team_existed.value.key, RespCode.team_existed.value.msg) return make_json_response(HttpResponse, resp) try: with transaction.atomic(): team = Team(name=add_team_dto.team, subject_code=add_team_dto.subject, year=add_team_dto.year, project_name=add_team_dto.project, create_date=mills_timestamp()) team.save() for member in team_members: try: student = Student.objects.get(email=member['email']) except ObjectDoesNotExist as e: student = Student(fullname=member['name'], email=member['email']) student.save() import_team_member(team.team_id, student.student_id) except Exception as e: logger.error(e) resp = init_http_response(RespCode.server_error.value.key, RespCode.server_error.value.msg) return make_json_response(HttpResponse, resp) resp = init_http_response(RespCode.success.value.key, RespCode.success.value.msg) 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 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 update_subject(request, body, *args, **kwargs): """ :param body: :param request: :param args: :param kwargs: :return: """ subject_id = kwargs.get('id') if not subject_id: resp = init_http_response(RespCode.invalid_parameter.value.key, RespCode.invalid_parameter.value.msg) return make_json_response(HttpResponse, resp) add_subject_dto = AddSubjectDTO() body_extract(body, add_subject_dto) try: subject = Subject.objects.get(subject_id=subject_id, status=Status.valid.value.key) if add_subject_dto.code is not None: subject.subject_code = add_subject_dto.code if add_subject_dto.name is not None: subject.name = add_subject_dto.name if add_subject_dto.coordinator_id is not None: subject.coordinator_id = add_subject_dto.coordinator_id subject.save() except ObjectDoesNotExist as e: resp = init_http_response(RespCode.invalid_parameter.value.key, RespCode.invalid_parameter.value.msg) return make_json_response(HttpResponse, resp) resp = init_http_response(RespCode.success.value.key, RespCode.success.value.msg) return make_json_response(HttpResponse, resp)
def add_subject(request, body, *args, **kwargs): """ :param request: :return: """ add_subject_dto = AddSubjectDTO() body_extract(body, add_subject_dto) # if the parameter is not sufficient if not add_subject_dto.not_empty(): resp = init_http_response(RespCode.invalid_parameter.value.key, RespCode.invalid_parameter.value.msg) return make_json_response(HttpResponseBadRequest, resp) # if the subject code existed if Subject.objects.filter(subject_code=add_subject_dto.code).exists(): resp = init_http_response(RespCode.subject_existed.value.key, RespCode.subject_existed.value.msg) return make_json_response(HttpResponseBadRequest, resp) if not User.objects.filter( user_id=add_subject_dto.coordinator_id).exists(): resp = init_http_response(RespCode.invalid_parameter.value.key, RespCode.invalid_parameter.value.msg) return make_json_response(HttpResponseBadRequest, resp) subject = Subject(subject_code=add_subject_dto.code, name=add_subject_dto.name, coordinator_id=add_subject_dto.coordinator_id, create_date=mills_timestamp(), status=Status.valid.value.key) subject.save() resp = init_http_response(RespCode.success.value.key, RespCode.success.value.msg) return make_json_response(HttpResponse, resp)
def construct_url(relation): data = {"url": relation.git_url} git_dto = GitDTO() body_extract(data, git_dto) git_dto.url = git_dto.url.lstrip('$') return git_dto