import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
@Override
public LdapEntry mapFromRegisteredService(final String dn, final RegisteredService svc) {
    try {
        if (svc.getId() == RegisteredService.INITIAL_IDENTIFIER_VALUE) {
            ((AbstractRegisteredService) svc).setId(System.nanoTime());
        }
        final String newDn = getDnForRegisteredService(dn, svc);
        LOGGER.debug("Creating entry {}", newDn);

        final Collection<LdapAttribute> attrs = new ArrayList<>();
        attrs.add(new LdapAttribute(this.idAttribute, String.valueOf(svc.getId())));

        final StringWriter writer = new StringWriter();
        this.jsonSerializer.toJson(writer, svc);
        attrs.add(new LdapAttribute(this.serviceDefinitionAttribute, writer.toString()));
        attrs.add(new LdapAttribute(LdapUtils.OBJECTCLASS_ATTRIBUTE, "top", this.objectClass));

        return new LdapEntry(newDn, attrs);
    } catch (final Exception e) {
        throw new RuntimeException(e);
    }
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
@Test
public void verifyUpdatingServices() {
    this.dao.save(getRegisteredService());
    final List<RegisteredService> services = this.dao.load();

    final AbstractRegisteredService rs = (AbstractRegisteredService) this.dao.findServiceById(services.get(0).getId());
    assertNotNull(rs);
    rs.setEvaluationOrder(9999);
    rs.setUsernameAttributeProvider(new DefaultRegisteredServiceUsernameProvider());
    rs.setName("Another Test Service");
    rs.setDescription("The new description");
    rs.setServiceId("https://hello.world");
    rs.setProxyPolicy(new RegexMatchingRegisteredServiceProxyPolicy("https"));
    rs.setAttributeReleasePolicy(new ReturnAllowedAttributeReleasePolicy());
    assertNotNull(this.dao.save(rs));

    final RegisteredService rs3 = this.dao.findServiceById(rs.getId());
    assertEquals(rs3.getName(), rs.getName());
    assertEquals(rs3.getDescription(), rs.getDescription());
    assertEquals(rs3.getEvaluationOrder(), rs.getEvaluationOrder());
    assertEquals(rs3.getUsernameAttributeProvider(), rs.getUsernameAttributeProvider());
    assertEquals(rs3.getProxyPolicy(), rs.getProxyPolicy());
    assertEquals(rs3.getUsernameAttributeProvider(), rs.getUsernameAttributeProvider());
    assertEquals(rs3.getServiceId(), rs.getServiceId());
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
private static RegisteredService getRegisteredService() {
    final AbstractRegisteredService rs = new RegisteredServiceImpl();
    rs.setName("Service Name1");
    rs.setProxyPolicy(new RefuseRegisteredServiceProxyPolicy());
    rs.setUsernameAttributeProvider(new AnonymousRegisteredServiceUsernameAttributeProvider(
            new ShibbolethCompatiblePersistentIdGenerator("hello")
    ));
    rs.setDescription("Service description");
    rs.setServiceId("https://?.edu/**");
    rs.setTheme("the theme name");
    rs.setEvaluationOrder(123);
    rs.setAttributeReleasePolicy(new ReturnAllAttributeReleasePolicy());
    rs.setRequiredHandlers(new HashSet<>(Arrays.asList("handler8", "handle92")));

    final Map<String, RegisteredServiceProperty> propertyMap = new HashMap();
    final DefaultRegisteredServiceProperty property = new DefaultRegisteredServiceProperty();

    final Set<String> values = new HashSet<>();
    values.add("value1");
    values.add("value2");
    property.setValues(values);
    propertyMap.put("field1", property);
    rs.setProperties(propertyMap);
    return rs;
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
private static RegisteredService getRegexRegisteredService() {
    final AbstractRegisteredService rs  = new RegexRegisteredService();
    rs.setName("Service Name Regex");
    rs.setProxyPolicy(new RefuseRegisteredServiceProxyPolicy());
    rs.setUsernameAttributeProvider(new AnonymousRegisteredServiceUsernameAttributeProvider(
            new ShibbolethCompatiblePersistentIdGenerator("hello")
    ));
    rs.setDescription("Service description");
    rs.setServiceId("^http?://.+");
    rs.setTheme("the theme name");
    rs.setEvaluationOrder(123);
    rs.setDescription("Here is another description");
    rs.setRequiredHandlers(new HashSet<>(Arrays.asList("handler1", "handler2")));

    final Map<String, RegisteredServiceProperty> propertyMap = new HashMap();
    final DefaultRegisteredServiceProperty property = new DefaultRegisteredServiceProperty();

    final Set<String> values = new HashSet<>();
    values.add("value1");
    values.add("value2");
    property.setValues(values);
    propertyMap.put("field1", property);
    rs.setProperties(propertyMap);

    return rs;
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
@Test
public void checkAccessStrategyJson() throws Exception {

    final Map<String, Set<String>> attributes = new HashMap<>();
    final Set<String> v1 = new HashSet<>();
    v1.add("admin");
    attributes.put("memberOf", v1);

    final AbstractRegisteredService service = TestUtils.getRegisteredService("test");
    final GrouperRegisteredServiceAccessStrategy grouper = new GrouperRegisteredServiceAccessStrategy();
    grouper.setRequiredAttributes(attributes);
    service.setAccessStrategy(grouper);
    final JsonServiceRegistryDao dao = new JsonServiceRegistryDao(RESOURCE.getFile());
    dao.save(service);
    dao.load();
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
@Override
public RegisteredService read(final Kryo kryo, final Input input, final Class<RegisteredService> type) {
    final AbstractRegisteredService svc = new RegexRegisteredService();
    svc.setServiceId(kryo.readObject(input, String.class));
    svc.setName(kryo.readObject(input, String.class));
    svc.setDescription(kryo.readObject(input, String.class));
    svc.setId(kryo.readObject(input, Long.class));
    svc.setEvaluationOrder(kryo.readObject(input, Integer.class));
    svc.setLogo(kryo.readObject(input, URL.class));
    svc.setLogoutType(kryo.readObject(input, LogoutType.class));
    svc.setLogoutUrl(kryo.readObject(input, URL.class));
    svc.setRequiredHandlers(kryo.readObject(input, ImmutableSet.class));
    svc.setTheme(kryo.readObject(input, String.class));

    svc.setPublicKey(readObjectByReflection(kryo, input, RegisteredServicePublicKey.class));
    svc.setProxyPolicy(readObjectByReflection(kryo, input, RegisteredServiceProxyPolicy.class));
    svc.setAttributeReleasePolicy(readObjectByReflection(kryo, input, RegisteredServiceAttributeReleasePolicy.class));
    svc.setUsernameAttributeProvider(readObjectByReflection(kryo, input, RegisteredServiceUsernameAttributeProvider.class));
    svc.setAccessStrategy(readObjectByReflection(kryo, input, RegisteredServiceAccessStrategy.class));

    return svc;
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
@Override
public RegisteredService read(final Kryo kryo, final Input input, final Class<RegisteredService> type) {
    final AbstractRegisteredService svc = new RegexRegisteredService();
    svc.setServiceId(kryo.readObject(input, String.class));
    svc.setName(kryo.readObject(input, String.class));
    svc.setDescription(kryo.readObject(input, String.class));
    svc.setId(kryo.readObject(input, Long.class));
    svc.setEvaluationOrder(kryo.readObject(input, Integer.class));
    svc.setLogo(kryo.readObject(input, URL.class));
    svc.setLogoutType(kryo.readObject(input, LogoutType.class));
    svc.setLogoutUrl(kryo.readObject(input, URL.class));
    svc.setRequiredHandlers(kryo.readObject(input, ImmutableSet.class));
    svc.setTheme(kryo.readObject(input, String.class));

    svc.setPublicKey(readObjectByReflection(kryo, input, RegisteredServicePublicKey.class));
    svc.setProxyPolicy(readObjectByReflection(kryo, input, RegisteredServiceProxyPolicy.class));
    svc.setAttributeReleasePolicy(readObjectByReflection(kryo, input, AttributeReleasePolicy.class));
    svc.setUsernameAttributeProvider(readObjectByReflection(kryo, input, RegisteredServiceUsernameAttributeProvider.class));
    svc.setAccessStrategy(readObjectByReflection(kryo, input, RegisteredServiceAccessStrategy.class));

    return svc;
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
@Test
public void checkCloning() {
    final AbstractRegisteredService r = new OAuthRegisteredService();
    r.setName("checkCloning");
    r.setServiceId("testId");
    r.setTheme("theme");
    r.setDescription("description");

    final OAuthRegisteredService r2 = (OAuthRegisteredService) r.clone();
    assertEquals(r, r2);
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
/**
 * Gets the registered service by id that would either match an ant or regex pattern.
 *
 * @param id the id
 * @return the registered service
 */
private AbstractRegisteredService getRegisteredService(@NotNull final String id) {
    if (RegexUtils.isValidRegex(id)) {
        return new RegexRegisteredService();
    }

    if (new AntPathMatcher().isPattern(id)) {
        return new RegisteredServiceImpl();
    }
    return null;
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
@Test
public void verifySavingServiceChangesDn() {
    this.dao.save(getRegisteredService());
    final List<RegisteredService> services = this.dao.load();

    final AbstractRegisteredService rs = (AbstractRegisteredService) this.dao.findServiceById(services.get(0).getId());
    final long originalId = rs.getId();
    assertNotNull(rs);
    rs.setId(666);
    assertNotNull(this.dao.save(rs));
    assertNotEquals(rs.getId(), originalId);
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
@Override
public RegisteredService createRegisteredService(final ServiceData data) {
    final RegisteredService svc = registeredServiceMapper.toRegisteredService(data);

    if (svc instanceof AbstractRegisteredService) {
        final AbstractRegisteredService absSvc = (AbstractRegisteredService) svc;

        final RegisteredServiceAccessStrategy accessStrategy = accessStrategyMapper.toAccessStrategy(data);
        if (accessStrategy != null) {
            absSvc.setAccessStrategy(accessStrategy);
        }

        final RegisteredServiceUsernameAttributeProvider usernameAttributeProvider =
                usernameAttributeProviderMapper.toUsernameAttributeProvider(data);
        if (usernameAttributeProvider != null) {
            absSvc.setUsernameAttributeProvider(usernameAttributeProvider);
        }

        final RegisteredServiceProxyPolicy proxyPolicy = proxyPolicyMapper.toProxyPolicy(data);
        if (proxyPolicy != null) {
            absSvc.setProxyPolicy(proxyPolicy);
        }

        final RegisteredServiceAttributeReleasePolicy attrPolicy = attributeReleasePolicyMapper
                .toAttributeReleasePolicy(data);
        if (attrPolicy != null) {
            absSvc.setAttributeReleasePolicy(attrPolicy);
        }

        for (final Map.Entry<String, RegisteredServiceProperty> entry : data.getProperties().entrySet()) {
            svc.getProperties().put(entry.getKey(), entry.getValue());
        }
    }

    return svc;
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
/**
 * Determine service type by pattern.
 *
 * @param serviceId the service id
 * @return the abstract registered service
 */
private AbstractRegisteredService determineServiceTypeByPattern(final String serviceId) {
    try {
        Pattern.compile(serviceId);
        LOGGER.debug("Service id {} is a valid regex.", serviceId);
        return new RegexRegisteredService();
    } catch (final PatternSyntaxException exception) {
        LOGGER.debug("Service id {} is not a valid regex. Checking ant patterns...", serviceId);
        if (new AntPathMatcher().isPattern(serviceId)) {
            LOGGER.debug("Service id {} is a valid ant pattern.", serviceId);
            return new RegisteredServiceImpl();
        }
    }
    throw new RuntimeException("Service id " + serviceId + " cannot be resolve to a service type");
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
public static AbstractRegisteredService getRegisteredService(final String id) {
    try  {
        final RegexRegisteredService s = new RegexRegisteredService();
        s.setServiceId(id);
        s.setEvaluationOrder(1);
        s.setName("Test registered service");
        s.setDescription("Registered service description");
        s.setProxyPolicy(new RegexMatchingRegisteredServiceProxyPolicy("^https?://.+"));
        s.setId(new SecureRandom().nextInt(Math.abs(s.hashCode())));
        s.setTheme("exampleTheme");
        s.setUsernameAttributeProvider(new PrincipalAttributeRegisteredServiceUsernameProvider("uid"));
        final DefaultRegisteredServiceAccessStrategy accessStrategy =
                new DefaultRegisteredServiceAccessStrategy(true, true);
        accessStrategy.setRequireAllAttributes(true);
        accessStrategy.setRequiredAttributes(getTestAttributes());
        s.setAccessStrategy(accessStrategy);
        s.setLogo(new URL("https://logo.example.org/logo.png"));
        s.setLogoutType(LogoutType.BACK_CHANNEL);
        s.setLogoutUrl(new URL("https://sys.example.org/logout.png"));
        s.setProxyPolicy(new RegexMatchingRegisteredServiceProxyPolicy("^http.+"));

        s.setPublicKey(new RegisteredServicePublicKeyImpl("classpath:pub.key", "RSA"));

        final ReturnAllowedAttributeReleasePolicy policy = new ReturnAllowedAttributeReleasePolicy();
        policy.setAuthorizedToReleaseCredentialPassword(true);
        policy.setAuthorizedToReleaseProxyGrantingTicket(true);

        final CachingPrincipalAttributesRepository repo =
                new CachingPrincipalAttributesRepository(new StubPersonAttributeDao(), 10);
        repo.setMergingStrategy(new NoncollidingAttributeAdder());
        policy.setPrincipalAttributesRepository(repo);
        policy.setAttributeFilter(new RegisteredServiceRegexAttributeFilter("https://.+"));
        policy.setAllowedAttributes(new ArrayList(getTestAttributes().keySet()));
        s.setAttributeReleasePolicy(policy);

        return s;
    } catch (final Exception e) {
        throw new RuntimeException(e);
    }
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
/**
 * Gets the registered service by id that would either match an ant or regex pattern.
 *
 * @param id the id
 * @return the registered service
 */
private AbstractRegisteredService getRegisteredService(@NotNull final String id) {
    if (isValidRegexPattern(id)) {
        return new RegexRegisteredService();
    }

    if (new AntPathMatcher().isPattern(id)) {
        return new RegisteredServiceImpl();
    }
    return null;
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
private RegisteredService getRegisteredService() {
    final AbstractRegisteredService rs = new RegisteredServiceImpl();
    rs.setName("Service Name1");
    rs.setProxyPolicy(new RefuseRegisteredServiceProxyPolicy());
    rs.setUsernameAttributeProvider(new AnonymousRegisteredServiceUsernameAttributeProvider());
    rs.setDescription("Service description");
    rs.setServiceId("https://?.edu/**");
    rs.setTheme("the theme name");
    rs.setEvaluationOrder(123);
    rs.setAttributeReleasePolicy(new ReturnAllAttributeReleasePolicy());
    rs.setRequiredHandlers(new HashSet<String>(Arrays.asList("handler8", "handle92")));
    return rs;
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
private RegisteredService getRegexRegisteredService() {
    final AbstractRegisteredService rs  = new RegexRegisteredService();
    rs.setName("Service Name Regex");
    rs.setProxyPolicy(new RefuseRegisteredServiceProxyPolicy());
    rs.setUsernameAttributeProvider(new AnonymousRegisteredServiceUsernameAttributeProvider());
    rs.setDescription("Service description");
    rs.setServiceId("^http?://.+");
    rs.setTheme("the theme name");
    rs.setEvaluationOrder(123);
    rs.setDescription("Here is another description");
    rs.setRequiredHandlers(new HashSet<String>(Arrays.asList("handler1", "handler2")));
    return rs;
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
@Override
public RegisteredService read(final Kryo kryo, final Input input, final Class<RegisteredService> type) {
    final String id = kryo.readObject(input, String.class);
    final AbstractRegisteredService svc = new RegisteredServiceImpl();
    svc.setServiceId(id);
    return svc;
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
@Override
public LdapEntry mapFromRegisteredService(final String dn, final RegisteredService svc) {


    if (svc.getId() == RegisteredService.INITIAL_IDENTIFIER_VALUE) {
        ((AbstractRegisteredService) svc).setId(System.nanoTime());
    }
    final String newDn = getDnForRegisteredService(dn, svc);
    LOGGER.debug("Creating entry {}", newDn);

    final Collection<LdapAttribute> attrs = new ArrayList<LdapAttribute>();
    attrs.add(new LdapAttribute(this.idAttribute, String.valueOf(svc.getId())));
    attrs.add(new LdapAttribute(this.serviceIdAttribute, svc.getServiceId()));
    attrs.add(new LdapAttribute(this.serviceNameAttribute, svc.getName()));
    attrs.add(new LdapAttribute(this.serviceDescriptionAttribute, svc.getDescription()));
    attrs.add(new LdapAttribute(this.serviceEnabledAttribute, Boolean.toString(svc.isEnabled()).toUpperCase()));
    attrs.add(new LdapAttribute(this.serviceAllowedToProxyAttribute, Boolean.toString(svc.isAllowedToProxy()).toUpperCase()));
    attrs.add(new LdapAttribute(this.serviceAnonymousAccessAttribute, Boolean.toString(svc.isAnonymousAccess()).toUpperCase()));
    attrs.add(new LdapAttribute(this.serviceSsoEnabledAttribute, Boolean.toString(svc.isSsoEnabled()).toUpperCase()));
    attrs.add(new LdapAttribute(this.ignoreAttributesAttribute, Boolean.toString(svc.isAnonymousAccess()).toUpperCase()));
    attrs.add(new LdapAttribute(this.evaluationOrderAttribute, String.valueOf(svc.getEvaluationOrder())));
    attrs.add(new LdapAttribute(this.serviceThemeAttribute, svc.getTheme()));
    attrs.add(new LdapAttribute(this.usernameAttribute, svc.getUsernameAttribute()));

    if (svc.getAllowedAttributes().size() > 0) {
        attrs.add(new LdapAttribute(this.serviceAllowedAttributesAttribute, svc.getAllowedAttributes().toArray(new String[] {})));
    }

    if (svc.getRequiredHandlers().size() > 0) {
        attrs.add(new LdapAttribute(this.requiredHandlersAttribute, svc.getRequiredHandlers().toArray(new String[] {})));
    }

    attrs.add(new LdapAttribute(LdapUtils.OBJECTCLASS_ATTRIBUTE, this.objectClass));

    return new LdapEntry(newDn, attrs);
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
@Override
public RegisteredService mapToRegisteredService(final LdapEntry entry) {

    final LdapAttribute attr = entry.getAttribute(this.serviceIdAttribute);

    if (attr != null) {
        final AbstractRegisteredService s = getRegisteredService(attr.getStringValue());

        if (s != null) {
            s.setId(LdapUtils.getLong(entry, this.idAttribute, Long.valueOf(entry.getDn().hashCode())));

            s.setServiceId(LdapUtils.getString(entry, this.serviceIdAttribute));
            s.setName(LdapUtils.getString(entry, this.serviceNameAttribute));
            s.setDescription(LdapUtils.getString(entry, this.serviceDescriptionAttribute));
            s.setEnabled(LdapUtils.getBoolean(entry, this.serviceEnabledAttribute));
            s.setTheme(LdapUtils.getString(entry, this.serviceThemeAttribute));
            s.setEvaluationOrder(LdapUtils.getLong(entry, this.evaluationOrderAttribute).intValue());
            s.setUsernameAttribute(LdapUtils.getString(entry, this.usernameAttribute));
            s.setAllowedToProxy(LdapUtils.getBoolean(entry, this.serviceAllowedToProxyAttribute));
            s.setAnonymousAccess(LdapUtils.getBoolean(entry, this.serviceAnonymousAccessAttribute));
            s.setSsoEnabled(LdapUtils.getBoolean(entry, this.serviceSsoEnabledAttribute));
            s.setAllowedAttributes(new ArrayList<String>(getMultiValuedAttributeValues(entry, this.serviceAllowedAttributesAttribute)));
            s.setIgnoreAttributes(LdapUtils.getBoolean(entry, this.ignoreAttributesAttribute));
            s.setRequiredHandlers(new HashSet<String>(getMultiValuedAttributeValues(entry, this.requiredHandlersAttribute)));
        }
        return s;
    }
    return null;
}
 

import org.jasig.cas.services.AbstractRegisteredService; //导入依赖的package包/类
private AbstractRegisteredService getRegisteredService(@NotNull final String id) {
    if (isValidRegexPattern(id)) {
        return new RegexRegisteredService();
    }

    if (new AntPathMatcher().isPattern(id)) {
        return new RegisteredServiceImpl();
    }
    return null;
}