import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
@Override
public AccountInfo getAccountInfo(String hostUrl, String accountName)
{
    UserService userService = new UserService(githubClientProvider.createClient(hostUrl));
    try
    {
        userService.getUser(accountName);
        return new AccountInfo(GithubCommunicator.GITHUB);

    }
    catch (IOException e)
    {
        log.debug("Unable to retrieve account information. hostUrl: {}, account: {} " + e.getMessage(), hostUrl,
                accountName);
    }
    return null;
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
public boolean isUsernameCorrect(String hostUrl, String accountName)
{
    UserService userService = userServiceFactory.createUserService(githubClientProvider.createClient(hostUrl));
    User user = null;
    try
    {
        user = userService.getUser(accountName);
    }
    catch (IOException e)
    {
        log.warn("Unable to retrieve account information. hostUrl: {}, account: {} " + e.getMessage(), hostUrl,
                accountName);
    }
    if (user != null)
    {
        return true;
    }
    else
    {
        // if we have blown the rate limit, we give them the benefit of the doubt
        return hasExceededRateLimit(userService.getClient());
    }
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
@Override
public DvcsUser getUser(Repository repository, String username)
{
    try
    {
        UserService userService = githubClientProvider.getUserService(repository);
        User ghUser = userService.getUser(username);
        String login = ghUser.getLogin();
        String name = ghUser.getName();
        String displayName = StringUtils.isNotBlank(name) ? name : login;
        String gravatarUrl = ghUser.getAvatarUrl();

        return new DvcsUser(login, displayName, null, gravatarUrl, repository.getOrgHostUrl() + "/" + login);
    }
    catch (IOException e)
    {
        throw new RuntimeException(e);
    }
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
@Override
public DvcsUser getTokenOwner(Organization organization)
{
    try
    {
        UserService userService = githubClientProvider.getUserService(organization);
        User ghUser = userService.getUser();
        String login = ghUser.getLogin();
        String name = ghUser.getName();
        String displayName = StringUtils.isNotBlank(name) ? name : login;
        String gravatarUrl = ghUser.getAvatarUrl();

        return new DvcsUser(login, displayName, null, gravatarUrl, organization.getHostUrl() + "/" + login);
    }
    catch (IOException e)
    {
        throw new RuntimeException(e);
    }
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
/**
 * Blindly accepts user credentials, no validation with github.
 *
 * @param user
 * @param password
 * @return primary github email for the user
 * @throws se.kth.karamel.common.exception.KaramelException
 */
public synchronized static GithubUser registerCredentials(String user, String password) throws KaramelException {
  try {
    GithubApi.user = user;
    GithubApi.password = password;
    client.setCredentials(user, password);
    client.getUser();
    Confs confs = Confs.loadKaramelConfs();
    confs.put(Settings.GITHUB_USER_KEY, user);
    confs.put(Settings.GITHUB_PASSWORD_KEY, password);
    confs.writeKaramelConfs();
    UserService us = new UserService(client);
    if (us == null) {
      throw new KaramelException("Could not find user or password incorret: " + user);
    }
    User u = us.getUser();
    if (u == null) {
      throw new KaramelException("Could not find user or password incorret: " + user);
    }
    GithubApi.email = u.getEmail();
  } catch (IOException ex) {
    logger.warn("Problem connecting to GitHub: " + ex.getMessage());
  }
  return new GithubUser(GithubApi.user, GithubApi.password, GithubApi.email);
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
/**
 * Create a repository in a given github user's local account.
 *
 * @param repoName
 * @param description
 * @throws KaramelException
 */
public synchronized static void createRepoForUser(String repoName, String description) throws KaramelException {
  try {
    UserService us = new UserService(client);
    RepositoryService rs = new RepositoryService(client);
    Repository r = new Repository();
    r.setName(repoName);
    r.setOwner(us.getUser());
    r.setDescription(description);
    rs.createRepository(r);
    cloneRepo(getUser(), repoName);
    cachedRepos.remove(GithubApi.getUser());
  } catch (IOException ex) {
    throw new KaramelException("Problem creating " + repoName + " for user " + ex.getMessage());
  }
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
public boolean connect(String username, String password){

		this.username=username;
		client = new GitHubClient();
		client.setCredentials(username, password);
		
		repoService = new MyRepositoriesService(client);
		userService = new UserService(client);
		issueService = new IssueService(client);
		milestoneService = new MilestoneService(client);
		labelService = new LabelService(client);
		commitService = new CommitService(client);
		markdownService = new MarkdownService(client);
		colaboratorService = new CollaboratorService(client);
		contentsService = new ContentsService(client);
		
		
		
		try {
			loadInformations();
			return true;
		} catch (IOException e) {
			mainApp.writeNotification(e.getMessage());
			return false;
		}
	}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
private void createReviewRequestIssue(Label reviewRequestLabel, Review review, IssueService issueService, UserService userService) throws IOException {
    Issue issue = new Issue();
    issue.setTitle("Reviewer - " + review.reviewer.login);
    List<Label> labels = new ArrayList<>();
    labels.add(reviewRequestLabel);
    issue.setLabels(labels);
    issue.setAssignee(userService.getUser(review.reviewer.login));
    
    String downloadLink = "https://github.com/" + review.repo.repoOwner + '/' + review.repo.repoName + "/raw/master/" + review.pathToPaperInRepo;
    
    issue.setBody("@" + review.reviewer.login + " has been requested to review this paper by @"+review.requester.login+".\n" +
    			  "Click [here](" + downloadLink + ") to download the paper\n" +
    			  "Click [here](" + review.linkToReviewPaper + ") to upload your review.");
    
    issueService.createIssue(review.repo.repoOwner, review.repo.repoName, issue);
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
	UserService userService = new UserService();
	userService.getClient().setOAuth2Token(req.getParameter("access_token"));
	User user = userService.getUser();
	
	String avatarUrl = user.getAvatarUrl();
	String login = user.getLogin();
	
	JSONObject json = new JSONObject();
	try {
		json.put("avatar", avatarUrl);
		json.put("login", login);
	} catch(JSONException e) {}
	
	resp.setContentType("application/json");
	resp.getWriter().write(json.toString());
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
	GitHubClient client = new GitHubClient();
	client.setOAuth2Token(req.getParameter("access_token"));
	UserService userService = new UserService(client);
	
	String login = req.getParameter("user");
	
	User user = userService.getUser(login);
	
	JSONObject userJ = new JSONObject();

	try {
		userJ.put("login", user.getLogin());
		userJ.put("email", user.getEmail());
		userJ.put("name", user.getName());
		
		resp.setContentType("application/json");
		resp.getWriter().write(userJ.toString());
	} catch(JSONException e) {
		e.printStackTrace();
	}
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
	GitHubClient client = new GitHubClient();
	client.setOAuth2Token(req.getParameter("access_token"));
	
	UserService userService = new UserService(client);
	User user = userService.getUser();
	OrganizationService orgService = new OrganizationService(client);
	List<User> users = orgService.getOrganizations(user.getLogin());
	
	JSONArray logins = new JSONArray();
	logins.put(user.getLogin());
	for(User u : users) {
		logins.put(u.getLogin());
	}
	
	resp.setContentType("application/json");
	resp.getWriter().write(logins.toString());
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
@Override
public void run() {
		try {
			GitHubClient client = new GitHubClient();
			client.setOAuth2Token(accessToken);
			
			DBAbstraction database = DatabaseFactory.getDatabase();
			UserService userService = new UserService(client);
			User reviewer = userService.getUser();
			List<Label> customLabels = createCustomLabels(client);
			
			createIssues(client, customLabels);
			
			String closeComment = "@" + reviewer.getLogin() + " has reviewed this paper.";
			
                  closeReviewIssue(client, repo, reviewer.getLogin(), closeComment);
			
			database.removeReviewFromDatastore(reviewer.getLogin(), repo);
			
		} catch(IOException e) {
		    e.printStackTrace();
			System.err.println("Error processing Pdf.");
		}
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
public GitHubBuilder(String token) {
    this.githubClient = new GitHubClient();
    githubClient.setOAuth2Token(token);

    uService = new UserService(githubClient);
    oService = new OrganizationService(githubClient);
    service = new RepositoryService(githubClient);
    cService = new ContentsService(githubClient);
    dService = new DataService(githubClient);
    commitService = new CommitService(githubClient);
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
/**
 * Must be called after #{createGitRepository()}
 */
public void pushAllChangesToGit() throws IOException {
    if (localRepository == null) {
        throw new IOException("Git has not been created, call createGitRepositoryFirst");
    }
    try {
        UserService userService = new UserService();
        userService.getClient().setOAuth2Token(oAuthToken);
        User user = userService.getUser();
        String name = user.getLogin();
        String email = user.getEmail();
        if (email == null) {
            // This is the e-mail addressed used by GitHub on web commits where the users mail is private. See:
            // https://github.com/settings/emails
            email = name + "@users.noreply.github.com";
        }

        localRepository.add().addFilepattern(".").call();
        localRepository.commit()
                .setMessage("Initial commit")
                .setCommitter(name, email)
                .call();
        PushCommand pushCommand = localRepository.push();
        addAuth(pushCommand);
        pushCommand.call();
    } catch (GitAPIException e) {
        throw new IOException("Error pushing changes to GitHub", e);
    }
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
@Test
public void testGitHubRepositoryCreation() throws Exception {
    String oAuthToken = System.getProperty("gitHubOauth");
    assumeTrue(oAuthToken != null && !oAuthToken.isEmpty());
    String name = "TestAppAcceleratorProject";
    String port = System.getProperty("liberty.test.port");
    URI baseUri = new URI("http://localhost:" + port + "/start");
    ServiceConnector serviceConnector = new MockServiceConnector(baseUri);
    Services services = new Services();
    Service service = new Service();
    service.setId("wibble");
    List<Service> serviceList = Collections.singletonList(service);
    services.setServices(serviceList);
    ProjectConstructionInputData inputData = new ProjectConstructionInputData(services, serviceConnector, name, ProjectConstructor.DeployType.LOCAL, ProjectConstructor.BuildType.MAVEN, null, null, null, null, null, false);

    ProjectConstructor constructor = new ProjectConstructor(inputData);
    GitHubConnector connector = new GitHubConnector(oAuthToken);
    GitHubWriter writer = new GitHubWriter(constructor.buildFileMap(), inputData.appName, connector);
    writer.createProjectOnGitHub();

    RepositoryService repositoryService = new RepositoryService();
    repositoryService.getClient().setOAuth2Token(oAuthToken);
    UserService userService = new UserService();
    userService.getClient().setOAuth2Token(oAuthToken);
    ContentsService contentsService = new ContentsService();
    contentsService.getClient().setOAuth2Token(oAuthToken);
    Repository repository = repositoryService.getRepository(userService.getUser().getLogin(), name);
    checkFileExists(contentsService, repository, "pom.xml");
    checkFileExists(contentsService, repository, "README.md");
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
/**
 * Gets the complete data for every user since most of GitHub APIs do not return users' complete data
 */
public static List<User> getCompleteUserData(List<User> users) {
    UserService service = new UserService();
    return users.stream()
            .map(user -> {
                try {
                    return service.getUser(user.getLogin());
                } catch (IOException e) {
                    logger.warn("Unable to get full details for user " + user.getLogin());
                    return user;
                }
            }).collect(Collectors.toList());
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
private List<Review> createNewReviews(String body, UserService userService) throws JSONException, IOException { 
    JSONObject data = new JSONObject(body);
    JSONArray reviewersJson = data.getJSONArray("reviewers");
    String repoOwner = data.getString("owner");
    String repoName = data.getString("repo");
    String pathToPaper = data.getString("pathToPaper");
    String paper = data.getString("paper");
    String requesterLogin = data.getString("login");
    String customLabels = data.getString("customLabels");
    
    List<String> parsedCustomLabels = parseCustomLabels(customLabels); //all reviews will have the same labels
    
    String pathToPaperInRepo = pathToPaper + "/" + paper;
    String linkToRespondToReview = "/?repoName=" + repoName + "&writer=" + repoOwner + "&paper=" + pathToPaperInRepo;

    
    List<Review> newReviews = new ArrayList<>();
    
    for(int i=0; i<reviewersJson.length(); i++) {
        String reviewerLogin = reviewersJson.getString(i);
        Review newReview = new Review(requesterLogin, repoOwner, reviewerLogin, repoName, pathToPaperInRepo, linkToRespondToReview, userService);
        newReview.setCustomLabels(parsedCustomLabels);
        newReviews.add(newReview);
        
    }
    return newReviews;
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
@Cacheable(value = "github",key="#accessToken + 'userInfo'")
public User getBasicUserInfo(String accessToken) throws Exception
{
	UserService uService=new UserService();
	uService.getClient().setOAuth2Token(accessToken);
	return uService.getUser();
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
public void bonusAuthor(String accessToken) 
{
	try
	{
		UserService uService=new UserService();
		uService.getClient().setOAuth2Token(accessToken);
		uService.follow(GitHubConstants.AUTHORUSER);
	}
	catch(Exception e)
	{
		
	}
}
 

import org.eclipse.egit.github.core.service.UserService; //导入依赖的package包/类
public UserService getUserService(Organization organization)
{
    return new UserService(createClient(organization));
}