GithubGraphQLService.java

package edu.ucsb.cs156.frontiers.services;

import com.fasterxml.jackson.core.JsonProcessingException;

import com.fasterxml.jackson.databind.JsonNode;

import com.fasterxml.jackson.databind.ObjectMapper;

import edu.ucsb.cs156.frontiers.entities.Branch;

import edu.ucsb.cs156.frontiers.entities.BranchId;

import edu.ucsb.cs156.frontiers.entities.Commit;

import edu.ucsb.cs156.frontiers.entities.Course;

import edu.ucsb.cs156.frontiers.errors.NoLinkedOrganizationException;

import edu.ucsb.cs156.frontiers.repositories.BranchRepository;

import edu.ucsb.cs156.frontiers.repositories.CommitRepository;

import java.security.NoSuchAlgorithmException;

import java.security.spec.InvalidKeySpecException;

import java.time.Instant;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import lombok.extern.slf4j.Slf4j;

import org.springframework.data.auditing.DateTimeProvider;

import org.springframework.graphql.GraphQlResponse;

import org.springframework.graphql.client.HttpSyncGraphQlClient;

import org.springframework.http.HttpHeaders;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.web.client.RestClient;

@Service

public class GithubGraphQLService {

  private final HttpSyncGraphQlClient graphQlClient;

  private final JwtService jwtService;

  private final DateTimeProvider dateTimeProvider;

  private final ObjectMapper jacksonObjectMapper;

  private final CommitRepository commitRepository;

  private final BranchRepository branchRepository;

  private final RestClient client;

  public GithubGraphQLService(

      RestClient.Builder builder,

      JwtService jwtService,

      DateTimeProvider dateTimeProvider,

      ObjectMapper jacksonObjectMapper,

      CommitRepository commitRepository,

  /**

   * Retrieves the name of the default branch for a given GitHub repository.

   *

   * @param owner The owner (username or organization) of the repository.

   * @param repo The name of the repository.

   * @return A Mono emitting the default branch name, or an empty Mono if not found.

   */

  public String getDefaultBranchName(Course course, String owner, String repo)

      throws JsonProcessingException,

          NoSuchAlgorithmException,

          InvalidKeySpecException,

          NoLinkedOrganizationException {

        "getDefaultBranchName called with course.getId(): {} owner: {}, repo: {}",

        owner,

        repo);

        """

                                query getDefaultBranch($owner: String!, $repo: String!) {

                                  repository(owner: $owner, name: $repo) {

                                    defaultBranchRef {

                                      name

                                    }

                                  }

                                }

                                """;

  }

  public String getCommits(

      Course course, String owner, String repo, String branch, int first, String after)

      throws JsonProcessingException,

          NoSuchAlgorithmException,

          InvalidKeySpecException,

          NoLinkedOrganizationException {

        "getCommits called with course.getId(): {} owner: {}, repo: {}, branch: {}, first: {}, after: {}",

        owner,

        repo,

        branch,

        after);

        """

            query GetBranchCommits($owner: String!, $repo: String!, $branch: String!, $first: Int!, $after: String) {

              repository(owner: $owner, name: $repo) {

                ref(qualifiedName: $branch) {

                  target {

                    ... on Commit {

                      history(first: $first, after: $after) {

                        pageInfo {

                          hasNextPage

                          endCursor

                        }

                        edges {

                          node {

                            oid

                            url

                            messageHeadline

                            committedDate

                            author {

                              name

                              email

                              user {

                                login

                              }

                            }

                            parents {

                              totalCount

                            }

                            committer {

                              name

                              email

                              user {

                                login

                              }

                            }

                          }

                        }

                      }

                    }

                  }

                }

              }

            }

            """;

        graphQlClient

  }

  /**

   * Loads the commit history for a specified repository branch. The method retrieves information

   * about the branch from the database, determines if the branch information is up to date, and

   * updates the commit history if necessary by fetching data from GitHub. If the branch does not

   * exist in the database, it is created.

   *

   * @param course the course to be authenticated against

   * @param branch the identifier of the branch to load commit history for

   * @return the {@code Branch} object representing the branch with its latest commit history

   *     information

   * @throws Exception if an error occurs while loading or updating the commit history

   */

  @Transactional(propagation = Propagation.NESTED)

  public Branch loadCommitHistory(Course course, BranchId branch) throws Exception {

    Branch selectedBranch;

      } else {

      }

    }

    boolean hasNextPage;

    do {

          currentPage

          currentPage

        } else {

        }

  }

  public String getMostRecentCommitSha(Course course, BranchId branch) throws Exception {

        client

  }

  }

  // language=GraphQL

      """

      repo_%d: repository(owner: "%s", name: "%s") {

        ref(qualifiedName: "refs/heads/%s") {

          target {

            ... on Commit {

              oid

            }

          }

        }

      }

  """;

  query CompleteQuery {

    %s

  }

  """;

  public Map<BranchId, ValidationStatus> assertBranchesExist(Course course, List<BranchId> branches)

      throws Exception {

              individualBranchQuery,

    }

        graphQlClient

      }

      }

    }

  }

}

Mutations