import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
void renderRepoSettings(String projectKey, String repoSlug, String username, HttpServletResponse response) throws IOException {
  Repository repo = repoService.getBySlug(projectKey, repoSlug);
  if(repo == null) {
    logger.warn("Project/Repo [{}/{}] not found for user {}", projectKey, repoSlug, username);
    response.setStatus(HttpServletResponse.SC_NOT_FOUND);
    return;
  }

  ApplicationUser appUser = userUtils.getApplicationUserByName(username);
  if(permissionService.hasRepositoryPermission(appUser, repo, Permission.REPO_ADMIN)) {
    response.setStatus(HttpServletResponse.SC_OK);
    response.setContentType("text/html;charset=utf-8");
    renderer.render("repo-config.html", ImmutableMap.<String, Object>of(
        "projectKey", projectKey,
        "repositorySlug", repoSlug
                                                                       ), response.getWriter());
  } else {
    logger.debug("Permission denied for user [{}]", username);
    response.setStatus(HttpServletResponse.SC_FORBIDDEN);
  }
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
void renderProjectSettings(String projectKey, String username, HttpServletResponse response) throws IOException {
  Project project = projectService.getByKey(projectKey);
  if(project == null) {
    logger.warn("Project [{}] not found for user {}", projectKey, username);
    response.setStatus(HttpServletResponse.SC_NOT_FOUND);
    return;
  }

  ApplicationUser appUser = userUtils.getApplicationUserByName(username);
  if(permissionService.hasProjectPermission(appUser, project, Permission.PROJECT_ADMIN)) {
    response.setStatus(HttpServletResponse.SC_OK);
    response.setContentType("text/html;charset=utf-8");
    renderer.render("project-config.html", ImmutableMap.<String, Object>of(
        "projectKey", projectKey
                                                                          ), response.getWriter());
  } else {
    logger.debug("Permission denied for user [{}]", username);
    response.setStatus(HttpServletResponse.SC_FORBIDDEN);
  }
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
@Nullable
@Override
public ApplicationUser authenticate(HttpAuthenticationContext ctx) {
  HttpServletRequest request = ctx.getRequest();
  String username = request.getHeader(USER_HEADER);
  String token = request.getHeader(TOKEN_HEADER);
  String path = request.getRequestURI().replaceFirst(request.getContextPath(), "");

  if(isNotEmpty(username) && isNotEmpty(token) && path.startsWith("/rest/")) {
    if(isTokenValid(path, username, token)) {
      return userService.getUserByName(username);
    }
  }

  return null;
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
public void notifyUserOfExpiredKey(int userId) {
    ApplicationUser user = userService.getUserById(userId);
    String pageUrl = applicationPropertiesService.getBaseUrl() + KEY_GEN_CONTEXT;
    String subject = i18nService.getMessage("stash.ssh.reset.email.subject");
    int maxDays = pluginSettingsService.getDaysAllowedForUserKeys();
    String body = i18nService.getMessage("stash.ssh.reset.email.body",pageUrl,maxDays);
    String policyUrl = pluginSettingsService.getInternalKeyPolicyLink();
    if( null != policyUrl){
        body = body + "\n " + i18nService.getMessage("stash.ssh.reset.email.policy",policyUrl);
    }
    if (null != user) {
        if(log.isDebugEnabled()){
            log.debug("Sending email to: " + user.getEmailAddress());
        }
        MailMessage message = new MailMessage.Builder()
                .to(user.getEmailAddress())
                .subject(subject)
                .text(body).build();
        mailService.submit(message);
    } else {
        throw new UserNotFoundException();
    }
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
@Override
public SshKeyEntity createOrUpdateUserKey(ApplicationUser user, String text, String label) {
    return ao.executeInTransaction(new TransactionCallback<SshKeyEntity>() {

        @Override
        public SshKeyEntity doInTransaction() {
            SshKeyEntity key = findSingleUserKey(user);
            if (null != key) {
                key.setText(text);
                key.setLabel(label);
                key.setCreatedDate(new Date());
                key.save();
                log.debug("Updated existing key for user");
            } else {
                key = ao.create(SshKeyEntity.class, new DBParam("TYPE", SshKeyEntity.KeyType.USER), new DBParam("USERID", user.getId()), new DBParam("TEXT", text), new DBParam("LABEL", label), new DBParam("CREATED", new Date()));
                log.debug("created new key for user");
            }

            return key;
        }
    });
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
@GET
@Path("/user/{username}")
@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
public Response getAllKeysForUser(@PathParam("username") String username) {
    ApplicationUser user = userService.getUserBySlug(username);
    try {
        List<SshKeyEntity> keyEntities = enterpriseKeyService.getKeysForUser(username);
        List<KeyDetailsResourceModel> keyResources = new ArrayList<KeyDetailsResourceModel>();
        for (SshKeyEntity keyEntity : keyEntities) {
            keyResources.add(KeyDetailsResourceModel.from(keyEntity,user));
        }
        return Response.ok(keyResources).build();
    } catch (EnterpriseKeyGenerationException e) {
        return Response.serverError().build();
    }

}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
/**
 * If allowed user ID or Group exception this will add meta to our own records, and return true
 * returns boolean: attempt was valid and added
 */
private boolean addAllowedBypass(SshKey key, ApplicationUser stashUser) {
    String bambooUser =  pluginSettingsService.getAuthorizedUser();
    String userGroup = pluginSettingsService.getAuthorizedGroup();
    if( bambooUser != null && bambooUser.equals(stashUser.getName())){
        log.debug("Username matches configured 'bambooUser', adding record");
        log.info("Bamboo Key {} created by an authorized bamboo system ID {} ", key.getId(), stashUser.getSlug());
        enterpriseKeyRepository.saveExternallyGeneratedKeyDetails(key,stashUser,SshKeyEntity.KeyType.BAMBOO);
        return true;
    }else if( userGroup != null && userService.existsGroup(userGroup) && userService.isUserInGroup(stashUser, userGroup)){
        log.debug("Username matches configured 'authorizedGroup', adding record");
        log.info("Bypass Key {} created by an authorized user {} in authorized group", key.getId(), stashUser.getSlug());
        enterpriseKeyRepository.saveExternallyGeneratedKeyDetails(key,stashUser,SshKeyEntity.KeyType.BYPASS);
        return true;
    }
    log.debug("User not in excused roles, do not allow.");
    return false;
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
@Override
public void replaceExpiredKeysAndNotifyUsers() {
    DateTime dateTime = new DateTime();
    Date oldestAllowed = dateTime.minusDays(pluginSettingsService.getDaysAllowedForUserKeys()).toDate();
    //Date oldestAllowed = dateTime.minusMillis(100).toDate(); //for live demos
    List<SshKeyEntity> expiredStashKeys = enterpriseKeyRepository.listOfExpiredKeys( oldestAllowed, KeyType.USER);
   
    
    for (SshKeyEntity keyRecord : expiredStashKeys) {
        try{
            ApplicationUser user = userService.getUserById(keyRecord.getUserId());
            String username = ( null != user ? user.getSlug() : "UNKNOWN_ID:"+keyRecord.getUserId());
            log.info("Removing Key for user: {}. KeyId: {}" , username, keyRecord.getKeyId());
            sshKeyService.remove(keyRecord.getKeyId());
            enterpriseKeyRepository.removeRecord(keyRecord);
            notificationService.notifyUserOfExpiredKey(keyRecord.getUserId());
            log.info("Key Removed");
        }catch(Exception e){
            log.error("Key removal failed for user: " + keyRecord.getUserId());
            e.printStackTrace();
        }
    }
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
public List<String> dereferenceGroups(List<String> groups) {
  List<String> users = newArrayList();
  for(String group : groups) {
    List<ApplicationUser> results = newArrayList(userService.findUsersByGroup(group, new PageRequestImpl(0, RESULTS_PER_REQUEST)).getValues());
    for(int i = 1; results.size() > 0; i++) {
      users.addAll(results.stream()
          .map(ApplicationUser::getSlug)
          .collect(Collectors.toList()));
      results = newArrayList(userService.findUsersByGroup(group, new PageRequestImpl(i * RESULTS_PER_REQUEST, RESULTS_PER_REQUEST)).getValues());
    }
  }
  return users;
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
public static PullRequestParticipant mockParticipant(String name, boolean approved) {
  PullRequestParticipant p = mock(PullRequestParticipant.class);
  ApplicationUser user = mockApplicationUser(name);
  when(p.getUser()).thenReturn(user);
  when(p.isApproved()).thenReturn(approved);
  return p;
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
@Before
@SuppressWarnings("unchecked")
public void setup() throws Exception {
  MockitoAnnotations.initMocks(this);
  ApplicationUser userA = mockApplicationUser("userA");
  ApplicationUser userB = mockApplicationUser("userB");
  ApplicationUser user1 = mockApplicationUser("user1");
  ApplicationUser user2 = mockApplicationUser("user2");
  ApplicationUser user3 = mockApplicationUser("user3");
  ApplicationUser user4 = mockApplicationUser("user4");
  List<ApplicationUser> userList1 = newArrayList(user1, user2);
  List<ApplicationUser> userList2 = newArrayList(user3, user4);

  Page p1 = mock(Page.class);
  Page p2 = mock(Page.class);
  Page empty = mock(Page.class);
  when(p1.getValues()).thenReturn(userList1);
  when(p2.getValues()).thenReturn(userList2);
  when(empty.getValues()).thenReturn(emptyList());
  when(userService.findUsersByGroup(any(String.class), any(PageRequest.class))).then((Answer<Page>) invocation -> {
    String group = (String) invocation.getArguments()[0];
    PageRequest pageRequest = (PageRequest) invocation.getArguments()[1];

    if("group1".equals(group) && pageRequest.getStart() == 0) {
      return p1;
    } else if("group2".equals(group) && pageRequest.getStart() == 0) {
      return p2;
    } else {
      return empty;
    }
  });

  when(userService.getUserBySlug("userA")).thenReturn(userA);
  when(userService.getUserBySlug("userB")).thenReturn(userB);
  when(userService.getUserBySlug("user1")).thenReturn(user1);
  when(userService.getUserBySlug("user2")).thenReturn(user2);
  when(userService.getUserBySlug("user3")).thenReturn(user3);
  when(userService.getUserBySlug("user4")).thenReturn(user4);
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
@Override
public SshKeyEntity findSingleUserKey(ApplicationUser user) {
    SshKeyEntity[] keys = ao.find(SshKeyEntity.class, Query.select().where("USERID = ? AND TYPE = ?", user.getId(), KeyType.USER));
    if( null != keys && keys.length == 1 ){
        SshKeyEntity key = keys[0];
        return key;
    }else{
        return null;
    }
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
public static KeyDetailsResourceModel from(SshKeyEntity keyEntity,ApplicationUser user){
    KeyDetailsResourceModel result = new KeyDetailsResourceModel();
    result.keyType = keyEntity.getKeyType();
    result.publicKey = keyEntity.getText();
    result.label = keyEntity.getLabel();
    result.user = new UserDetails(user);
    result.stashKeyId = keyEntity.getKeyId();
    result.created = keyEntity.getCreatedDate();
    return result;
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
/**
 * Generate a new Key for this user per rules of service (1 active key, etc)
 */
@POST
@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
public Response generateNewPair() {

    ApplicationUser user = stashAuthenticationContext.getCurrentUser();
    KeyPairResourceModel keyPair;
    try {
        keyPair = enterpriseKeyService.generateNewKeyPairFor(user);
    } catch (EnterpriseKeyGenerationException e) {
        return Response.serverError().build();
    }

    return Response.ok(keyPair).build();
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
@Override
public void removeKeyIfNotLegal(SshKey key, ApplicationUser user) {
    log.debug(">>>removeKeyIfNotLegal");
    if ( pluginIsAwareOf(user,key) ||  addAllowedBypass(key,user)) {
        log.debug("No action required, valid key.");
    }else{
        sshKeyService.remove(key.getId());
        log.info("Invalid or illegal key removed for user {} ({})", user.getId(), user.getSlug());
        // TODO issue custom audit event
    }
    log.debug("<<<removeKeyIfNotLegal");
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
@Override
public KeyPairResourceModel generateNewKeyPairFor(ApplicationUser user) {
    //purge old key for this user
    removeExistingUserKeysFor(user);
    //create new one
    String keyComment = "SYSTEM GENERATED";
    KeyPairResourceModel result = sshKeyPairGenerator.generateKeyPair(keyComment);
    // must add to our repo before calling stash SSH service since audit
    // listener will otherwise revoke it.
    SshKeyEntity newRecord = enterpriseKeyRepository.createOrUpdateUserKey(user, result.getPublicKey(), keyComment);
    SshKey newKey = sshKeyService.addForUser(user, result.getPublicKey());
    enterpriseKeyRepository.updateRecordWithKeyId(newRecord, newKey);
    log.info("New managed key " + newKey.getId() +" of type USER created user {} ({})", user.getId(), user.getSlug());
    return result;
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
private void removeExistingUserKeysFor(ApplicationUser user) {
    List<SshKeyEntity> allKeys = enterpriseKeyRepository.keysForUser(user);
    for(SshKeyEntity key: allKeys){
        if(key.getKeyType() == KeyType.USER){
            //this call fires an event that #forgetDeletedKey() will handle
            sshKeyService.remove(key.getKeyId());
        }
    }
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
@Test
@NonTransactional
public void aKeyCanBeSaved() {
    ApplicationUser user = mock(ApplicationUser.class);
    when(user.getId()).thenReturn(ADHOC_USER_ID);
    String comment = "No Comment123";

    keyRepo.createOrUpdateUserKey(user, PUBLIC_KEY_ONE, comment);

    SshKeyEntity[] createdRecords = ao.find(SshKeyEntity.class, Query.select().where("USERID = ?", ADHOC_USER_ID));
    assertThat(createdRecords.length, is(1));
    assertThat(createdRecords[0].getLabel(), is(comment));
    assertThat(createdRecords[0].getText(), is(PUBLIC_KEY_ONE));
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
@Before
public void setup(){
    sshKey = mock(SshKeyEntity.class);
    when(sshKey.getCreatedDate()).thenReturn(STATIC_DATE);
    user = mock(ApplicationUser.class);
    when(user.getId()).thenReturn(USER_ID);
    when(user.getSlug()).thenReturn(USERNAME);
}
 

import com.atlassian.bitbucket.user.ApplicationUser; //导入依赖的package包/类
public static BitbucketServerRepositoryOwner createActor(ApplicationUser user)
{
    return new BitbucketServerRepositoryOwner(user.getName(), user.getDisplayName());
}