@Override public void validateNameUniqueness(Map<CaseInsensitiveString, AbstractMaterialConfig> map) { if (CaseInsensitiveString.isBlank(getName())) { return; } CaseInsensitiveString currentMaterialName = getName(); AbstractMaterialConfig materialWithSameName = map.get(currentMaterialName); if (materialWithSameName != null) { materialWithSameName.addNameConflictError(); addNameConflictError(); return; } map.put(currentMaterialName, this); }
@Override public String getPipelineUniqueFingerprint() { if (pipelineUniqueFingerprint == null) { Map<String, Object> basicCriteria = new LinkedHashMap<>(getSqlCriteria()); appendPipelineUniqueCriteria(basicCriteria); pipelineUniqueFingerprint = generateFingerprintFromCriteria(basicCriteria); } return pipelineUniqueFingerprint; }
public void setConfigAttributes(Object attributes) { if (attributes == null) { return; } super.setConfigAttributes(attributes); Map map = (Map) attributes; this.packageId = (String) map.get(PACKAGE_ID); }
@Override public String getFingerprint() { if (fingerprint == null) { fingerprint = generateFingerprintFromCriteria(getSqlCriteria()); } return fingerprint; }
@Override public boolean validateTree(ValidationContext validationContext) { validate(validationContext); validateExtras(validationContext); return errors().isEmpty(); }
@Test public void shouldReturnTrueIfMaterialNameIsUsedInPipelineTemplate_caseInsensitive() { AbstractMaterialConfig material = new TestMaterialConfig(""); material.setName(new CaseInsensitiveString("funky_name")); PipelineConfig pipelineConfig = new PipelineConfig(new CaseInsensitiveString("blah"), "${COUNT}-${funky_Name}", "", false, null, new BaseCollection<>()); assertThat(material.isUsedInLabelTemplate(pipelineConfig), is(true)); }
@Test public void shouldNotSetMaterialNameIfItIsSetToEmptyAsItsAnOptionalField() { AbstractMaterialConfig materialConfig = new TestMaterialConfig(""); Map<String, String> map = new HashMap<>(); map.put(AbstractMaterialConfig.MATERIAL_NAME, ""); materialConfig.setConfigAttributes(map); assertThat(materialConfig.getName(), is(nullValue())); }
@Test public void shouldRecomputeSqlCriteriaAndXmlAttributeMap_whenAttributesChanged() { AbstractMaterialConfig testMaterialConfig = new TestMaterialConfig("foo"); Map<String, Object> sqlCriteria = testMaterialConfig.getSqlCriteria(); testMaterialConfig.setConfigAttributes(m("bar", "baz")); assertThat(testMaterialConfig.getSqlCriteria(), not(sameInstance(sqlCriteria))); assertThat(testMaterialConfig.getSqlCriteria().get("foo"), is("baz")); }
@Override public final void validate(ValidationContext validationContext) { if (name != null && !StringUtils.isBlank(CaseInsensitiveString.str(name)) && !new NameTypeValidator().isNameValid(name)) { errors().add(MATERIAL_NAME, NameTypeValidator.errorMessage("material", name)); } validateConcreteMaterial(validationContext); }
private void setCommonMaterialMembers(AbstractMaterialConfig materialConfig, CRMaterial crMaterial) { materialConfig.setName(toMaterialName(crMaterial.getName())); }
public String deserialize(String password, String encryptedPassword, AbstractMaterialConfig materialConfig) { if (isNotBlank(password) && isNotBlank(encryptedPassword)) { materialConfig.addError(PASSWORD, "You may only specify `password` or `encrypted_password`, not both!"); materialConfig.addError(ScmMaterialConfig.ENCRYPTED_PASSWORD, "You may only specify `password` or `encrypted_password`, not both!"); } if (isNotBlank(password)) { try { return goCipher.encrypt(password); } catch (CryptoException e) { materialConfig.addError(PASSWORD, "Could not encrypt the password. This usually happens when the cipher text is invalid"); } } else if (isNotBlank(encryptedPassword)) { try { goCipher.decrypt(encryptedPassword); } catch (Exception e) { materialConfig.addError(ENCRYPTED_PASSWORD, "Encrypted value for password is invalid. This usually happens when the cipher text is invalid."); } return goCipher.maybeReEncryptForPostConstructWithoutExceptions(encryptedPassword); } return null; } }
@Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } if (!super.equals(o)) { return false; } ScmMaterialConfig that = (ScmMaterialConfig) o; if (folder != null ? !folder.equals(that.folder) : that.folder != null) { return false; } return super.equals(that); }
@Override public final Map<String, Object> getSqlCriteria() { if (sqlCriteria == null) { Map<String, Object> map = new LinkedHashMap<>(); map.put("type", type); appendCriteria(map); sqlCriteria = Collections.unmodifiableMap(map); } return sqlCriteria; }
@Test public void shouldReturnFalseIfMaterialNameIsNotUsedInPipelineTemplate() { AbstractMaterialConfig material = new TestMaterialConfig(""); material.setName(new CaseInsensitiveString("funky_name")); assertThat(material.isUsedInLabelTemplate(new PipelineConfig(new CaseInsensitiveString("blah"), "${COUNT}-${test1}-test", "", false, null, new BaseCollection<>())), is(false)); }
@Override public boolean isUsedInLabelTemplate(PipelineConfig pipelineConfig) { CaseInsensitiveString materialName = getName(); return materialName != null && pipelineConfig.getLabelTemplate().toLowerCase().contains(String.format("${%s}", materialName.toLower())); }
@Override public void validateNameUniqueness(Map<CaseInsensitiveString, AbstractMaterialConfig> map) { if (StringUtils.isBlank(scmId)) { return; } if (map.containsKey(new CaseInsensitiveString(scmId))) { AbstractMaterialConfig material = map.get(new CaseInsensitiveString(scmId)); material.addError(SCM_ID, "Duplicate SCM material detected!"); addError(SCM_ID, "Duplicate SCM material detected!"); } else { map.put(new CaseInsensitiveString(scmId), this); } }
@Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } PackageMaterialConfig that = (PackageMaterialConfig) o; if (packageDefinition != null ? !packageDefinition.equals(that.packageDefinition) : that.packageDefinition != null) { return false; } return super.equals(that); }
@Test public void shouldReturnTrueIfMaterialNameIsUsedInPipelineTemplate() { AbstractMaterialConfig material = new TestMaterialConfig(""); material.setName(new CaseInsensitiveString("funky_name")); PipelineConfig pipelineConfig = new PipelineConfig(new CaseInsensitiveString("blah"), "${COUNT}-${funky_name}", "", false, null, new BaseCollection<>()); assertThat(material.isUsedInLabelTemplate(pipelineConfig), is(true)); }
public void setConfigAttributes(Object attributes) { if (attributes == null) { return; } super.setConfigAttributes(attributes); Map map = (Map) attributes; this.scmId = (String) map.get(SCM_ID); if (map.containsKey(FOLDER)) { String folder = (String) map.get(FOLDER); if (StringUtils.isBlank(folder)) { folder = null; } this.folder = folder; } if (map.containsKey(FILTER)) { String pattern = (String) map.get(FILTER); if (!StringUtils.isBlank(pattern)) { this.setFilter(Filter.fromDisplayString(pattern)); } else { this.setFilter(null); } } }