import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
public List<Company> listAllCompanies() throws DeskComException {
	Set<Company> companies = new LinkedHashSet<Company>();
	try {
		Integer page = 1;
		SearchResponse<Company> results;
		do {
			results = companyApi.list(authProvider.genAuthorizationHeader(), page++);
			for(Company company: results.get_embedded().getEntries()) {
				companies.add(company);
			}
		} while (results.hasNextPage());
		return new LinkedList<Company>(companies);
	}catch(ClientResponseFailure t){
		throw new DeskComException(t);
	}
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
public List<Case> listAllCompanyCases(BigInteger companyId) throws DeskComException {
	Set<Case> cases = new LinkedHashSet<Case>();
	try {
		Integer page = 1;
		SearchResponse<Case> results;
		do {
			results = companyApi.listCases(authProvider.genAuthorizationHeader(), companyId, page++);
			for(Case _case : results.get_embedded().getEntries()) {
				cases.add(_case);
			}
		} while (results.hasNextPage());
		return new LinkedList<Case>(cases);
	}catch(ClientResponseFailure t){
		throw new DeskComException(t);
	}
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
/**
 * Test for registering permissions for resource
 */
@Test
public void testRegisterPermissionForInvalidResource() throws Exception {
    showTitle("testRegisterPermissionForInvalidResource");

    UmaPermission permission = new UmaPermission();
    permission.setResourceId(this.registerResourceTest.resourceId + "1");
    permission.setScopes(Arrays.asList("http://photoz.example.com/dev/scopes/view", "http://photoz.example.com/dev/scopes/all"));

    PermissionTicket ticket = null;
    try {
        ticket = getPermissionService().registerPermission(
                "Bearer " + this.registerResourceTest.pat.getAccessToken(), UmaPermissionList.instance(permission));
    } catch (ClientResponseFailure ex) {
        System.err.println(ex.getResponse().getEntity(String.class));
        assertTrue(ex.getResponse().getStatus() != Response.Status.CREATED.getStatusCode() &&
                ex.getResponse().getStatus() != Response.Status.OK.getStatusCode()
                , "Unexpected response status");
    }

    assertNull(ticket, "Resource permission is not null");
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
public String registerResource(List<String> scopes) throws Exception {
    try {
        UmaResource resource = new UmaResource();
        resource.setName("Photo Album");
        resource.setIconUri("http://www.example.com/icons/flower.png");
        resource.setScopes(scopes);
        resource.setType("myType");

        UmaResourceResponse resourceStatus = getResourceService().addResource("Bearer " + pat.getAccessToken(), resource);
        UmaTestUtil.assert_(resourceStatus);

        this.resourceId = resourceStatus.getId();
        return this.resourceId;
    } catch (ClientResponseFailure ex) {
        System.err.println(ex.getResponse().getEntity(String.class));
        throw ex;
    }
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
public String registerResourceWithScopeExpression(String scopeExpression) throws Exception {
    try {
        UmaResource resource = new UmaResource();
        resource.setName("Photo Album");
        resource.setIconUri("http://www.example.com/icons/flower.png");
        resource.setScopeExpression(scopeExpression);
        resource.setType("myType");

        UmaResourceResponse resourceStatus = getResourceService().addResource("Bearer " + pat.getAccessToken(), resource);
        UmaTestUtil.assert_(resourceStatus);

        this.resourceIdWithScopeExpression = resourceStatus.getId();
        return this.resourceIdWithScopeExpression;
    } catch (ClientResponseFailure ex) {
        System.err.println(ex.getResponse().getEntity(String.class));
        throw ex;
    }
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
/**
 * Test non existing UMA resource description modification
 */
@Test(dependsOnMethods = {"modifyResource"})
public void modifyNotExistingResource() throws Exception {
    showTitle("modifyNotExistingResource");

    try {
        UmaResource resource = new UmaResource();
        resource.setName("Photo Album 3");
        resource.setIconUri("http://www.example.com/icons/flower.png");
        resource.setScopes(Arrays.asList("http://photoz.example.com/dev/scopes/view", "http://photoz.example.com/dev/scopes/all"));

        getResourceService().updateResource("Bearer " + pat.getAccessToken(), "fake_resource_id", resource);
    } catch (ClientResponseFailure ex) {
        System.err.println(ex.getResponse().getEntity(String.class));
        int status = ex.getResponse().getStatus();
        assertTrue(status != Response.Status.OK.getStatusCode(), "Unexpected response status");
    }
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
/**
 * Test UMA resource description modification with invalid PAT
 */
@Test(dependsOnMethods = {"modifyResource"})
public void testModifyResourceWithInvalidPat() throws Exception {
    showTitle("testModifyResourceWithInvalidPat");

    UmaResourceResponse resourceStatus = null;
    try {
        UmaResource resource = new UmaResource();
        resource.setName("Photo Album 4");
        resource.setIconUri("http://www.example.com/icons/flower.png");
        resource.setScopes(Arrays.asList("http://photoz.example.com/dev/scopes/view", "http://photoz.example.com/dev/scopes/all"));

        resourceStatus = getResourceService().updateResource("Bearer " + pat.getAccessToken() + "_invalid", this.resourceId + "_invalid", resource);
    } catch (ClientResponseFailure ex) {
        System.err.println(ex.getResponse().getEntity(String.class));
        assertEquals(ex.getResponse().getStatus(), Response.Status.UNAUTHORIZED.getStatusCode(), "Unexpected response status");
    }

    assertNull(resourceStatus, "Resource status is not null");
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
/**
 * Get resource
 */
@Test(dependsOnMethods = {"modifyResource"})
public void getOneResource() throws Exception {
    showTitle("getOneResource");

    try {
        UmaResourceWithId resource = getResourceService().getResource("Bearer " + pat.getAccessToken(), this.resourceId);
        assertEquals(resource.getType(), "myType");

        UmaResourceWithId resourceWithExpression = getResourceService().getResource("Bearer " + pat.getAccessToken(), this.resourceIdWithScopeExpression);
        assertEquals(resourceWithExpression.getScopeExpression(), MODIFY_SCOPE_EXPRESSION);
    } catch (ClientResponseFailure ex) {
        System.err.println(ex.getResponse().getEntity(String.class));
        throw ex;
    }
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
/**
 * Get resources
 */
@Test(dependsOnMethods = {"getOneResource"})
public void getResources() throws Exception {
    showTitle("getResources");

    List<String> resources = null;
    try {
        resources = getResourceService().getResourceList("Bearer " + pat.getAccessToken(), "");
    } catch (ClientResponseFailure ex) {
        System.err.println(ex.getResponse().getEntity(String.class));
        throw ex;
    }

    assertNotNull(resources, "Resources is null");
    assertTrue(resources.contains(this.resourceId), "Resource list doesn't contain added resource");
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
/**
 * Test for getting meta data configuration
 */
@Test
@Parameters({"umaMetaDataUrl"})
public void testGetUmaMetaDataConfiguration(final String umaMetaDataUrl) throws Exception {
    showTitle("testGetUmaMetaDataConfiguration");

    UmaMetadataService metaDataConfigurationService = UmaClientFactory.instance().createMetadataService(umaMetaDataUrl, clientExecutor(true));

    // Get meta data
    UmaMetadata c = null;
    try {
        c = metaDataConfigurationService.getMetadata();
    } catch (ClientResponseFailure ex) {
        System.err.println(ex.getResponse().getEntity(String.class));
        throw ex;
    }

    UmaTestUtil.assert_(c);
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
public void configure() {

        //@formatter:off
        from("switchyard://GreetingCamelProxy")
            .routeId(getClass().getName())
            .log("********************************************************************************")
            .log("body = ${body}")
            .log("********************************************************************************")
            .doTry()
                .to("switchyard://GreetingService")
            .doCatch(ClientResponseFailure.class)
                .process(new FailureStatusProcessor())
            .end();
        //@formatter:on

    }
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
private String invoke(String operation, Object content) {
    int statusCode = 500;
    ClientResponse<?> response = null;

    ReferenceInvocation invocation = null;
    try {
        invocation = greeting.newInvocation(operation);
        Message message = invocation.invoke(content).getMessage();
        response = message.getContent(ClientResponse.class);
        statusCode = response.getStatus();
    } catch (Exception e) {
        LOGGER.error(e.getMessage(), e);
        // TODO this won't work due to SWITCHYARD-1890
        if (e.getCause() instanceof ClientResponseFailure) {
            response = ((ClientResponseFailure) e.getCause()).getResponse();
            statusCode = response.getStatus();
        }
    }

    String replyContent = response != null ? response.getEntity(String.class) : "";
    sendReply(statusCode, replyContent);
    return replyContent;
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
public static void handleException(String guid, Exception ex) throws ServiceException {
    if (ex instanceof ClientResponseFailure) {
        ClientResponseFailure e = (ClientResponseFailure) ex;
        ClientResponse response = e.getResponse();
        if (response.getResponseStatus().equals(Response.Status.FORBIDDEN)) {
            throw new ServiceException(guid, "Authentification failed", e);
        }
        throw new ServiceException(guid, "Error in the communication to the server " + response.getResponseStatus().getStatusCode(), e);
    } else {
        String msg = ex.getMessage();
        if (msg.startsWith(ClientProtocolException.class.getName())) {
            throw new ServiceException(guid, "The server is not valid address.", ex);
        }
        throw new ServiceException(guid, "Could not connect to the server", ex);
    }
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
public List<Customer> searchCustomer(Set<String> email, Set<String> externalId) throws DeskComException{
	try {
		SearchCustomerResponse<Customer> customer = customerApi.search(authProvider.genAuthorizationHeader(), null, null, email, externalId);
		return customer.get_embedded().getEntries();
	}catch(ClientResponseFailure t){
		throw new DeskComException(t);
	}
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
public Customer showCustomer(BigInteger id) throws DeskComException{
	try{
		return customerApi.show(authProvider.genAuthorizationHeader(), id.toString());
	}catch(ClientResponseFailure t){
		throw new DeskComException(t);
	}
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
public Customer newCustomer(Customer customer) throws DeskComException{
	try{
		return customerApi.create(authProvider.genAuthorizationHeader(), customer);
	}catch(ClientResponseFailure t){
		throw new DeskComException(t);
	}
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
/**
 * if caseId is present, case id. Other wise tries caseExternalId
 * @param caseId
 * @param caseExternalId
 * @param embeds (optional)
 * @return
 * @throws DeskComException
 */
public Case showCase(BigInteger caseId, String caseExternalId, Set<String> embeds) throws DeskComException {
	try {
		if(caseId != null){
			return caseApi.showCase(authProvider.genAuthorizationHeader(), caseId,embeds);
		} else {
			return caseApi.showCase(authProvider.genAuthorizationHeader(), caseExternalId, embeds);
		}
	}catch(ClientResponseFailure t){
		throw new DeskComException(t);
	}
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
public List<User> searchUser(Set<String> emails) throws DeskComException {
	Set<User> usuarios = new LinkedHashSet<User>();
	try{
		for(User us: userApi.users(authProvider.genAuthorizationHeader(), null, null).get_embedded().getEntries()) {
			if(emails.contains(us.getEmail())){
				usuarios.add(us);
			}
		}
		return new LinkedList(usuarios);
	}catch(ClientResponseFailure t){
		throw new DeskComException(t);
	}
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
public Message newMessage(BigInteger id, Message msg) throws DeskComException {
	try {
		return caseApi.createReplyCase(authProvider.genAuthorizationHeader(), id, msg);
	}catch(ClientResponseFailure t){
		throw new DeskComException(t);
	}
}
 

import org.jboss.resteasy.client.ClientResponseFailure; //导入依赖的package包/类
public List<Case> listCases(BigInteger customerId) throws DeskComException {
	Set<Case> cases = new LinkedHashSet<Case>();
	try {
		for(Case kase:caseApi.casesFromCustomer(authProvider.genAuthorizationHeader(), customerId,null,null).get_embedded().getEntries()){
			cases.add(kase);
		}
		return new LinkedList<Case>(cases);
	}catch(ClientResponseFailure t){
		throw new DeskComException(t);
	}
}