public async Task <IActionResult> Send(int receiverGroupId, string description)
        {
            AddMergeRequestDto dto = new AddMergeRequestDto {
                ReceiverGroupId = receiverGroupId, CreatedAt = DateTime.Now, Description = description
            };
            ServiceResponse <AddMergeRequestDto> response = await _mergeRequestService.SendMergeRequest(dto);

            if (response.Success)
            {
                return(Ok(response));
            }
            return(NotFound(response));
        }
Example #2
0
        public async Task <ServiceResponse <AddMergeRequestDto> > SendMergeRequest(AddMergeRequestDto newMergeRequest)
        {
            ServiceResponse <AddMergeRequestDto> response = new ServiceResponse <AddMergeRequestDto>();
            User user = await _context.Users.Include(u => u.ProjectGroups)
                        .ThenInclude(g => g.ProjectGroup)
                        .ThenInclude(g => g.AffiliatedSection)
                        .FirstOrDefaultAsync(u => u.Id == GetUserId());

            ProjectGroup receiverGroup = await _context.ProjectGroups.Include(g => g.AffiliatedSection)
                                         .Include(g => g.GroupMembers).Include(g => g.IncomingMergeRequest)
                                         .Include(g => g.OutgoingMergeRequest)
                                         .FirstOrDefaultAsync(rg => rg.Id == newMergeRequest.ReceiverGroupId);

            if (receiverGroup == null)
            {
                response.Data    = null;
                response.Message = "There is no group with receiverGroup's id";
                response.Success = false;
                return(response);
            }

            Section section = await _context.Sections.FirstOrDefaultAsync(s => (s.Id == receiverGroup.AffiliatedSection.Id));

            if (user == null)
            {
                response.Data    = null;
                response.Message = "There is no user with this Id";
                response.Success = false;
                return(response);
            }
            if (section == null)
            {
                response.Data    = null;
                response.Message = "There is no section with this Id ";
                response.Success = false;
                return(response);
            }


            ProjectGroup senderGroup = new ProjectGroup {
                AffiliatedSectionId = -1
            };

            foreach (ProjectGroupUser pgu in user.ProjectGroups)
            {
                if (pgu.ProjectGroup.AffiliatedCourseId == receiverGroup.AffiliatedCourseId && pgu.ProjectGroup.AffiliatedSectionId == receiverGroup.AffiliatedSectionId)
                {
                    senderGroup = pgu.ProjectGroup;
                    break;
                }
            }
            if (senderGroup.AffiliatedSectionId == -1)
            {
                response.Data    = null;
                response.Message = "You are not in the same section with this group";
                response.Success = false;
                return(response);
            }
            if (senderGroup.Id == receiverGroup.Id)
            {
                response.Data    = null;
                response.Message = "You are already in this group";
                response.Success = false;
                return(response);
            }

            if (senderGroup.ConfirmationState == true)
            {
                response.Data    = null;
                response.Message = "Your group is finalized.";
                response.Success = false;
                return(response);
            }
            if (receiverGroup.ConfirmationState == true)
            {
                response.Data    = null;
                response.Message = "The group you want to merge with is finalized.";
                response.Success = false;
                return(response);
            }
            ProjectGroup senderGroupOriginal = await _context.ProjectGroups
                                               .Include(g => g.GroupMembers)
                                               .FirstOrDefaultAsync(rg => rg.Id == senderGroup.Id);

            int maxSize = (await _context.Courses.FirstOrDefaultAsync(c => c.Id == senderGroup.AffiliatedCourseId)).MaxGroupSize;

            if (receiverGroup.GroupMembers.Count + senderGroupOriginal.GroupMembers.Count > maxSize)
            {
                response.Data    = null;
                response.Message = "You would exceed the max allowed group size if you merged.";
                response.Success = false;
                return(response);
            }
            if (receiverGroup.GroupMembers.Count == 0)
            {
                response.Data    = null;
                response.Message = "The group you want to merge with is empty";
                response.Success = false;
                return(response);
            }


            foreach (MergeRequest mr in receiverGroup.IncomingMergeRequest)
            {
                if (mr.SenderGroupId == senderGroup.Id && !mr.Resolved)
                {
                    response.Data    = null;
                    response.Message = "Your group has already sent a merge request to this group that is not resolved yet.";
                    response.Success = false;
                    return(response);
                }
            }

            foreach (MergeRequest mr in receiverGroup.OutgoingMergeRequest)
            {
                if (mr.ReceiverGroupId == senderGroup.Id && !mr.Resolved)
                {
                    response.Data    = null;
                    response.Message = "The group has already sent a merge request to your group that is not resolved yet.";
                    response.Success = false;
                    return(response);
                }
            }

            MergeRequest createdMergeRequest = new MergeRequest
            {
                SenderGroup     = senderGroup,
                SenderGroupId   = senderGroup.Id,
                ReceiverGroup   = receiverGroup,
                ReceiverGroupId = receiverGroup.Id,
                VotedStudents   = GetUserId().ToString(),
                CreatedAt       = newMergeRequest.CreatedAt,
                Accepted        = false,
                Resolved        = false,
                Description     = newMergeRequest.Description
            };

            receiverGroup.IncomingMergeRequest.Add(createdMergeRequest);
            senderGroup.OutgoingMergeRequest.Add(createdMergeRequest);

            _context.ProjectGroups.Update(receiverGroup);
            _context.ProjectGroups.Update(senderGroup);
            _context.MergeRequests.Add(createdMergeRequest);
            await _context.SaveChangesAsync();

            response.Data    = newMergeRequest;
            response.Message = "Merge request is successfully sent " + senderGroup.GroupMembers.Count + " " + receiverGroup.GroupMembers.Count;
            response.Success = true;

            return(response);
        }