Desenvolvendo serviços do WebSphere Commerce para comércio entre canais

Este tutorial traz instruções sobre como desenvolver serviços que serão usados por aplicativos da web, remotos e de terceiros. O tutorial também aborda o modelo de programação baseado em SOA do WebSphere® e como desenvolver lógica de negócios que possa ser reutilizada em diferentes canais.

N Krishnan, IT Specialist, IBM

N Krishnan é IT Specialist e trabalha no IBM India Software Labs, Índia. Ele fez parte da equipe de desenvolvimento do WebSphere Commerce e também desenvolveu soluções de varejo para a equipe Retail EBO. Atualmente, é Consultor do WebSphere Commerce em IBM Software Services para soluções de segmento de mercado.



22/Mar/2012

Sobre este tutorial

Este tutorial traz instruções sobre como desenvolver serviços que serão usados por aplicativos da web, remotos e de terceiros. O tutorial também aborda o modelo de programação baseado em SOA do WebSphere Commerce e como desenvolver lógica de negócios que possa ser reutilizada em diferentes canais. Este tutorial é voltado para arquitetos, consultores e desenvolvedores que implementarão soluções WebSphere Commerce.

Objetivos

Neste tutorial, iremos customizar o serviço Catalog para suportar informações estendidas de entrada de catálogo e usar serviços de diversos canais. Essa customização inclui:

  • Atualizar o esquema do WebSphere Commerce para armazenar novas informações.
  • Customizar o serviço Catalog para incluir novas informações como dados de usuário no substantivo CatalogEntry.
  • Reutilizar o mesmo código de serviço independente da origem do cliente.

Pré-requisitos

Esse tutorial foi escrito para desenvolvedores de WebSphere Commerce cujas qualificações e experiências sejam de nível intermediário. Além disso, é necessário estar familiarizado com conceitos de arquitetura orientada a serviços.

Requisitos do Sistema

Para criar o exemplo neste tutorial, é necessário ter o WebSphere Commerce Developer V7 instalado e configurado. Também é necessária a loja de início de sites Madison Extended publicada com o catálogo Furniture.

Antes de iniciar o tutorial:

  1. Faça download e instalação do aplicativo soapUI para trabalhar com o serviço da web.
  2. Descompacte o arquivo code sample.zip que é fornecido com o tutorial para um local temporário, como por exemplo C:\Lab_Instructions.
  3. <WCDev_Dir> representa o diretório no qual o ambiente de desenvolvimento do WebSphere Commerce está instalado, por exemplo: C:\WebSphere\WCToolkit.

Duração

3 a 4 horas


Customizando o serviço do WebSphere Commerce

Customizando o esquema do WebSphere Commerce

Nesta seção, incluiremos novas tabelas no esquema do WebSphere Commerce para armazenar as informações adicionais do produto. A Figura 1 mostra as alterações no esquema.

Figura 1. Extensões do esquema
Extensões do esquema

O esquema mostra as novas tabelas e seu relacionamento com as tabelas existentes. As novas tabelas são XPRODUCT, XPRODUCT_KIOSK e XCAREINSTRUCTION:

  • Tabela XPRODUCT: Essa tabela possui uma chave estrangeira para a tabela CATENTRY. Para fins de demonstração, essa tabela contém os dados sobre importação para uma dada entrada no catálogo. Isso permite que o Data Service Layer (DSL) grave dados da tabela XPRODUCT no elemento USERDATA do substantivo CatalogEntry.

    Observação: USERDATA é um ponto de extensão pronto para uso que permite aos clientes incluir pares simples de valores de nome ao substantivo ou resposta de serviço. Esses dados vêm de tabelas customizadas que possuem uma chave estrangeira para a tabela base do substantivo. Esse relacionamento deve ser um para um. Relacionamentos um para muitos não são suportadas para dados de usuário.

  • Tabela XPRODUCT_KIOSK: Essa tabela também possui uma chave estrangeira para a tabela CATENTRY. Para fins de demonstração, essa tabela contém os dados específicos do canal Kiosk. Isso permite que o Data Service Layer (DSL) grave dados da tabela XPRODUCT_KIOSK no elemento USERDATA do substantivo CatalogEntry.
  • Tabela XCAREINSTRUCTION: Essa tabela possui uma chave estrangeira para a tabela CATENTDESC, para permitir que o DSL insira dados no elemento ATTRIBUTE da parte de substantivo CatalogEntryDescription.

A tabela XCAREINSTRUCTION possui uma chave estrangeira para a tabela CATENTRY, para fornecer suporte à função de procura do DSL. Essa tabela contém informações sobre manuseio, por exemplo, "Frágil, manuseie com cuidado" para uma dada entrada de catálogo.

Para incluir as novas tabelas:

  1. Conecte-se ao banco de dados de desenvolvimento e execute as seguintes instruções SQL:
    1. Clique em Start > Run e digite db2cmd.
    2. Altere o diretório para C:\Lab_Instructions.
    3. Conecte-se ao banco de dados usando db2 connect to <DB_Name>.
    4. Execute o SQL para criar as tabelas, mostrado abaixo:
      	db2 -tvf CustomTablesDefinitions.sql
      
      	CREATE TABLE XPRODUCT
      	(
      	CATENTRY_ID BIGINT NOT NULL,
      	IMPORTED VARCHAR(1),
      	IMPORTED_COUNTRY VARCHAR(30),
      	OPTCOUNTER SMALLINT,
      	CONSTRAINT XPRODUCT_PK PRIMARY KEY (CATENTRY_ID),
      	CONSTRAINT XPRODUCT_FK FOREIGN KEY (CATENTRY_ID) REFERENCES CATENTRY 
           (CATENTRY_ID) on delete cascade
      	);
      	
      	CREATE TABLE XPRODUCT_KIOSK
      	(
      	CATENTRY_ID BIGINT NOT NULL,
      	AISLE_NUMBER VARCHAR(5),
      	AISLE_Information VARCHAR(100),
      	OPTCOUNTER SMALLINT,
      	CONSTRAINT XPRODUCT_KIOSK_PK PRIMARY KEY (CATENTRY_ID),
      	CONSTRAINT XPRODUCT_KIOSK_FK FOREIGN KEY (CATENTRY_ID) REFERENCES 
           CATENTRY (CATENTRY_ID) on delete cascade
      	);
      	
      	CREATE TABLE XCAREINSTRUCTION
      	(
      	CATENTRY_ID BIGINT NOT NULL,
      	LANGUAGE_ID INTEGER NOT NULL,
      	CAREINSTRUCTION VARCHAR(254),
      	OPTCOUNTER SMALLINT,
      	CONSTRAINT XCAREINST_PK PRIMARY KEY (CATENTRY_ID, LANGUAGE_ID),
      	CONSTRAINT XCAREINST_FK1 FOREIGN KEY (CATENTRY_ID,LANGUAGE_ID) 
           REFERENCES CATENTDESC(CATENTRY_ID,LANGUAGE_ID) on delete cascade,
      	CONSTRAINT XCAREINST_FK2 FOREIGN KEY (CATENTRY_ID)REFERENCES CATENTRY 
           (CATENTRY_ID) on delete cascade
      	);
  2. Preencha as tabelas customizadas com alguns dados de amostra executando as instruções SQL a seguir. Não se esqueça de substituir o CatalogEntry_id no SQL abaixo. No prompt de comandos do DB2® aberto na Etapa 1a acima, insira o seguinte comando para inserir os dados de amostra nas tabelas customizadas:
    db2 -tvf SampleData.sql
    
    INSERT INTO XPRODUCT (CATENTRY_ID, IMPORTED, IMPORTED_COUNTRY) VALUES 
     (10001,'Y', 'Japan, The Land of Rising Sun');
    INSERT INTO XPRODUCT (CATENTRY_ID, IMPORTED, IMPORTED_COUNTRY) VALUES 
     (10002,'Y', 'India, The subcontinent');
    		
    INSERT INTO XCAREINSTRUCTION (CATENTRY_ID, LANGUAGE_ID, CAREINSTRUCTION) VALUES 
     (10001, -1, 'Never use an abrasive cleaner or material on any finished product');
    INSERT INTO XCAREINSTRUCTION (CATENTRY_ID, LANGUAGE_ID, CAREINSTRUCTION) VALUES 
     (10002, -1, 'Never use an abrasive cleaner or material on any finished product');
    		
    INSERT INTO XPRODUCT_KIOSK (CATENTRY_ID, AISLE_NUMBER, AISLE_Information) VALUES 
     (10001, '10', 'Available in aisle');
    INSERT INTO XPRODUCT_KIOSK (CATENTRY_ID, AISLE_NUMBER, AISLE_Information) VALUES 
     (10002, '12', 'Available near checkout counter');

Customizando a camada física para incluir novas informações

Nesta seção, iremos customizar a camada física gerando metadados relacionais de objeto e gerando Objetos de Dados de Serviço físicos. Para isso, usaremos uma ferramenta chamada de assistente "Data Service Layer".

SDOs físicos são objetos de dados que representam tabelas no esquema do WebSphere Commerce. Cada tipo do objeto de dados corresponde a uma definição de tabela no esquema, e cada propriedade do objeto de dados corresponde a uma coluna da tabela ou a uma referência a outro tipo de objeto de dados. Essas referências correspondem aos relacionamentos de chave estrangeira entre as tabelas do banco de dados. O assistente de Data Service Layer é usado para gerar metadados relacionais de objeto e objetos de dados físicos para a customização do esquema.

Para cada módulo de serviço, há metadados relacionais de objeto que contêm as informações para relacionar o objeto de dados físico a uma tabela do banco de dados. Os metadados relacionais de objeto customizados estão armazenados nos diretórios de extensão de configuração de componente e os SDOs físicos customizados estão armazenados dentro do projeto WebSphereCommerceServerExtensionsLogic.

Esse assistente realiza as seguintes funções:

  • Cria uma pasta de configuração de extensão para o módulo do serviço Catalog, se não existir. O caminho do diretório é WC_eardir\xml\config\com.ibm.commerce.catalog-ext.
  • Gera um arquivo de metadados relacionais de objeto customizado. Esse arquivo se localiza em WC_eardir\xml\config\com.ibm.commerce.catalog-ext\wc-object-relational-metadata.xml.
  • Gera classes Java do SDO e as coloca no projeto WebSphereCommerceServerExtensionsLogic.

    Observação: Os objetos CatalogEntry fornecidos pela IBM® estão estendidos para incluir os novos getters.

  • Cria uma classe Java™ utilitária para retornar a classe raiz do SDO físico (e seu pacote) ao módulo de serviço. Essa classe raiz garante que todos os SDOs físicos do WebSphere Commerce para o módulo de serviço e qualquer SDO físico adicional para a customização estejam disponíveis no tempo de execução.

    Observação: Essa configuração informa ao sistema para instanciar o novo SDO CatalogEntry em vez do SDO CatalogEntry fornecido pela IBM, para que agora tenha acesso aos novos dados.

  • Cria um arquivo de configuração de módulo de serviço que instrui o WebSphere Commerce a usar a classe de SDO física de catálogo recém-criada em WC_eardir\xml\config\com.ibm.commerce.catalog-ext\wc-component.xml.
  • Cria um arquivo de configuração que configura um mediador de objeto de negócios para que inclua dados das tabelas XPRODUCT, XPRODUCT_KIOSK e XCAREINSTRUCTION nos dados do usuário de um substantivo CatalogEntry. Esse arquivo se localiza em WC_eardir\xml\config\com.ibm.commerce.catalog-ext\wc-business-object-mediator.xml.

Para executar o assistente de Data Service Layer:

  1. Selecione File > New > Other > WebSphere Commerce > Data Service Layer.
  2. Clique em Next.
  3. Selecione Extend a default WebSphere Commerce service module.

    Observação: Neste tutorial, o módulo de serviço de catálogo será estendido. Portanto, essa opção precisa ser selecionada. Ao criar um novo serviço, é preciso selecionar a outra opção, "Work with a custom service module".

  4. Clique em Next.
  5. Insira as informações a seguir:
    1. Módulo de serviço: Selecione com.ibm.commerce.catalog
    2. Prefixo de classe de extensão: MyCompany
    3. Nome do pacote Java de extensão: com.mycompany.commerce.catalog
  6. Clique em Next.
  7. Selecione as tabelas XPRODUCT, XPRODUCT_KIOSK e XCAREINSTRUCTION.
  8. Expanda as tabelas XPRODUCT, XPRODUCT_KIOSK e XCAREINSTRUCTION para garantir que todas as colunas tenham sido selecionadas.
  9. Clique em Next.
  10. Em UserData, certifique-se de que as colunas IMPORTED, IMPORTED_COUNTRY, AISLE_NUMBER, AISLE_INFORMATION e CAREINSTRUCTION do banco de dados estejam com o valor "True", como mostra a Figura 2. Configure as demais colunas com o valor "False" se estiverem definidas como "True" por padrão.

    Observação: Esta etapa garante que as colunas desejadas sejam incluídas na área UserData do esquema lógico.

    Figura 2. Tabela de extensão usando Edição de Metadados no assistente de DSL
    Tabela de extensão usando Edição de Metadados no assistente de DSL
  11. Clique em Finish.
  12. Verifique se os arquivos a seguir foram criados no projeto WebSphereCommerceServerExtensionsLogic, conforme mostra a Figura 3.
    Figura 3. Arquivos gerados pelo assistente de DSL
    Arquivos gerados pelo assistente de DSL

    Observação: Os SDOs físicos são gerados no projeto WebSphereCommerceServerExtensionsLogic em com.mycompany.commerce.catalog.facade.server.entity.datatypes. Esses SDOs proporcionam uma visualização Java do banco de dados para o serviço de catálogo customizado.

Incluindo modelos de consulta para incluir as novas informações

Nesta seção, nós incluiremos arquivos de modelo de consulta que recuperam informações adicionais do produto. Arquivos de modelo de consulta armazenam o SQL e as definições de perfil de acesso para um módulo de serviço, isolando-o completamente da camada de lógica de negócios.

O arquivo de modelo de consulta consiste no seguinte:

  • Uma seção de definição de símbolos que define as tabelas que serão usadas pelo modelo de consulta: CATENTRY, CATENTDESC, XPRODUCT, XPRODUCT_KIOSK e XCAREINSTRUCTION.
  • Instruções SQL associadas para definir consultas SQL. Essas consultas podem ser reutilizadas para desenvolver diferentes perfis definidos na seção PROFILE.

    Observação: Os perfis de acesso determinam quanta informação é retornada. Por exemplo, um "Resumo" pode retornar apenas uma descrição do produto, enquanto um perfil "Detalhes" pode retornar a descrição, preço, atributos e mais. Como estamos incluindo mais dados, é preciso criar um novo perfil de acesso.

  • Um novo perfil de acesso, MyCompany_All, é usado junto com a chave XPath para identificar a consulta de modelo SQL.
  • Muitos outros perfis de acesso são definidos no modelo de consulta, que serão usados em diferentes canais.

Para criar um arquivo de modelo de consulta Get do cliente:

  1. Clique com o botão direito na pasta WC\xml\config\com.ibm.commerce.catalog-ext. (Se a pasta com.ibm.commerce.catalog-ext não estiver visível, selecione a pasta WC\config e selecione File > Refresh.)

    Observação: Os arquivos TPL customizados devem ser criados na pasta <component name>-ext.

  2. Clique em New > File.
  3. Dê ao arquivo o nome de wc-query-MyCompanyCatalogEntry-get.tpl.

    Observação: O nome deve começar com wc-query- e terminar com o sufixo .tpl.

  4. Clique em Finish.
  5. Copie e cole o seguinte modelo de consulta no arquivo:
    BEGIN_SYMBOL_DEFINITIONS
    <!-- WebSphere Commerce tables -->
    COLS:CATENTRY=CATENTRY:*
    COLS:CATENTDESC=CATENTDESC:*
    
    <!-- MyCompany extension tables -->
    COLS:XPRODUCT =XPRODUCT:*
    COLS:XCAREINSTRUCTION=XCAREINSTRUCTION:*
    COLS:XPRODUCT_KIOSK=XPRODUCT_KIOSK:*
    
    END_SYMBOL_DEFINITIONS
    
    BEGIN_ASSOCIATION_SQL_STATEMENT
      name=MyCompanyImportgetCatalogEntryDetails
      base_table=CATENTRY
      additional_entity_objects=true
       sql=
    	SELECT
    	   CATENTRY.$COLS:CATENTRY$,
    	   CATENTDESC.$COLS:CATENTDESC$,
               XPRODUCT.$COLS:XPRODUCT$,	
               XCAREINSTRUCTION.$COLS:XCAREINSTRUCTION$
    	FROM
    	   CATENTRY
    		LEFT OUTER JOIN XPRODUCT ON (CATENTRY.CATENTRY_ID = 
             XPRODUCT.CATENTRY_ID)
    		LEFT OUTER JOIN CATENTDESC ON (CATENTDESC.CATENTRY_ID = 
             CATENTRY.CATENTRY_ID AND CATENTDESC.LANGUAGE_ID in ($CONTROL:LANGUAGES$))
    		LEFT OUTER JOIN XCAREINSTRUCTION ON (CATENTRY.CATENTRY_ID = 
             XCAREINSTRUCTION.CATENTRY_ID AND XCAREINSTRUCTION.LANGUAGE_ID in 
             ($CONTROL:LANGUAGES$))
    	WHERE
    	   CATENTRY.CATENTRY_ID IN ($ENTITY_PKS$) AND
    	   CATENTRY.MARKFORDELETE = 0
    END_ASSOCIATION_SQL_STATEMENT
    
    BEGIN_ASSOCIATION_SQL_STATEMENT
      name=MyCompanyImportgetCatalogEntryWithKioskDetails
      base_table=CATENTRY
      additional_entity_objects=true
       sql=
    	SELECT
    	   CATENTRY.$COLS:CATENTRY$,
           XPRODUCT_KIOSK.$COLS:XPRODUCT_KIOSK$
    	FROM
    	   CATENTRY
    		LEFT OUTER JOIN XPRODUCT_KIOSK ON (CATENTRY.CATENTRY_ID = 
             XPRODUCT_KIOSK.CATENTRY_ID)
    	WHERE
    	   CATENTRY.CATENTRY_ID IN ($ENTITY_PKS$) AND
    	   CATENTRY.MARKFORDELETE = 0
    END_ASSOCIATION_SQL_STATEMENT
    
    
    BEGIN_PROFILE
      name=MyCompany_All
      extends=IBM_Admin_All
      BEGIN_ENTITY
    	associated_sql_statement=MyCompanyImportgetCatalogEntryDetails
      END_ENTITY
    END_PROFILE
    
    BEGIN_PROFILE
      name=MyCompany_Admin_All
      extends=IBM_Admin_All
      BEGIN_ENTITY
    	associated_sql_statement=MyCompanyImportgetCatalogEntryDetails
      END_ENTITY
    END_PROFILE
    
    BEGIN_PROFILE
      name=MyCompany_Mobile_Description
      extends=IBM_Admin_CatalogEntryDescription
      BEGIN_ENTITY
    	associated_sql_statement=MyCompanyImportgetCatalogEntryDetails
      END_ENTITY
    END_PROFILE
    
    BEGIN_PROFILE
      name=MyCompany_Store_CatalogEntryAllDescriptions
      extends=IBM_Admin_CatalogEntryAllDescriptions
      BEGIN_ENTITY
    	associated_sql_statement=MyCompanyImportgetCatalogEntryDetails
      END_ENTITY
    END_PROFILE
    
    BEGIN_PROFILE
      name=MyCompany_Store_CatalogEntryDetailsWithKioskInfo
      extends=IBM_Admin_Details
      BEGIN_ENTITY
        associated_sql_statement=MyCompanyImportgetCatalogEntryDetails
    	associated_sql_statement=MyCompanyImportgetCatalogEntryWithKioskDetails
      END_ENTITY
    END_PROFILE
  6. Salve o arquivo.

Criando uma política de acesso de controle para proteger as novas informações

A seção anterior criou um novo perfil de acesso, MyCompany_All. Por padrão, apenas os usuários com função de administrador do site têm acesso a esses novos dados. Nesta seção, iremos atualizar a política de controle de acesso do serviço Catalog para declarar que todos os usuários podem visualizar esses dados.

A nova política define uma nova ação do perfil de acesso MyCompany_All e inclui a nova ação no grupo de usuário CatalogEntry All.

  1. Crie o arquivo a seguir: <WCDev_Dir>\xml\policies\xml\MyCompanyCatalogAccessControlPolicies.xml.
  2. Copie e cole o seguinte XML de política de controle de acesso nesse arquivo:
    	<?xml version="1.0" encoding="ISO-8859-1" standalone="no" ?>
    	<!DOCTYPE Policies SYSTEM "../dtd/accesscontrolpolicies.dtd">
    	<Policies>
    		<Action Name="GetCatalogEntry.MyCompany_All" CommandName=
             "GetCatalogEntry.MyCompany_All"/>
    	
    		<ActionGroup Name="Catalog-CatalogEntry-AllUsers-
             AccessProfileActionGroup" OwnerID="RootOrganization">
    			<ActionGroupAction Name="GetCatalogEntry.MyCompany_All"/>
    		</ActionGroup>
    	
    	        <!-- === Following entries are for mobile access profile which 
                 will be used in Section 5 of the lab === -->
    		<Action Name="GetCatalogEntry.MyCompany_Mobile_Description" 
             CommandName="GetCatalogEntry.MyCompany_Mobile_Description"/>
    	
    		<ActionGroup Name="Catalog-CatalogEntry-AllUsers-
             AccessProfileActionGroup" OwnerID="RootOrganization">
    			<ActionGroupAction Name="GetCatalogEntry.
                 MyCompany_Mobile_Description"/>
    		</ActionGroup>	
    	</Policies>
  3. Execute o comando acpload para carregar a política de controle de acesso:
    1. Abra um prompt de comandos e navegue para <WCDev_Dir>\bin.
    2. Execute o seguinte comando:
      acpload inst1db db2admin passw0rd MyCompanyCatalogAccessControlPolicies.xml 
       db2admin
    3. Navegue até o diretório <WCDev_Dir>\logs.

Inspecione os arquivos acpload.log e messages.txt para garantir que a política de controle de acesso tenha sido carregada com sucesso. O arquivo messages.txt pode não estar presente se tudo tiver sido carregado com sucesso.

Validando a customização de Catalog com JUnit

Esta seção mostra como testar a customização usando JUnit. JUnit é um programa Java independente que usará a biblioteca IBM Client (um conjunto de APIs Java) para acessar o serviço do WebSphere Commerce. Para isso, ele envia solicitações de HTTP ao serviço. Este teste de unidade supõe que uma loja de início com o ID de loja 10152 (MadisonsESite) e o ID de catálogo 10001 (Extended Sites Catalog Asset Store) tenha sido publicada no ambiente de desenvolvimento do WebSphere Commerce.

Para fins de demonstração, esse é considerado o primeiro canal para chamar os serviços.

  1. Importe o projeto JUnit Test para o serviço Catalog para a sua área de trabalho. O arquivo zip de troca de projeto, CatalogExtensions-UnitTest.zip, é fornecido na pasta C:\Lab_Instructions.
  2. Na visualização Enterprise Explorer, abra:
    CatalogExtensions-UnitTest\src\com.mycompany.commerce.catalog.facade.client\
     CatalogFacadeExtensionClientTest.java

    Observação: Analise este caso de teste JUnit para entender como ele foi desenvolvido.

    Há dois métodos importantes:

    • setUp(): Inicializa os objetos businesscontext e callbackhandler. Esses objetos são usados para criar o cliente CatalogEntry.
    • testCatalogEntryCustomization(): É nesse método que ocorre a chamada efetiva ao serviço. Forme a expressão Get usando a classe SelectionCriteriaHelper, e crie o verbo Get usando o método createGetVerb do cliente de fachada da entrada no catálogo. Realize a solicitação get usando o cliente CatalogEntry criado anteriormente no método setUp. Navegue e imprima (ou declare) o elemento UserData no objeto de resposta (neste caso, é do tipo ShowCatalogEntryDataAreaType).
  3. Observe as constantes a seguir com os valores específicos da máquina que já estão configuradas:
    • USER_ID = wcsadmin
    • PASSWORD = passw0rd
    • STORE_ID = 10152 (Como estamos usando um eSite para este tutorial, definimos o ID de loja da loja MadisonESite.)
    • CATALOG_ID = 10001 (Como o eSite que está configurado para este tutorial usa loja de ativos de catálogo, definimos o ID de catálogo da loja de ativos de catálogo.)
    • catEntryId = 10002 (Esse é o catentryId com relação ao qual os dados de amostra foram preenchidos.)
  4. Na página Server, clique com o botão direito em WebSphere Commerce Test Server e selecione Start.
  5. Se o projeto do WebSphere Commerce (WC) não tiver sido publicado no Servidor de Teste do WebSphere Commerce, publique-o:
    1. Na página Server, clique com o botão direito em WebSphere Commerce Test Server e selecione Add and Remove Projects.
    2. Selecione o projeto WC.
    3. Clique em Add.
    4. Clique em Finish.

    Se o projeto do WC já tiver sido publicado, clique com o botão direito em WebSphere Commerce Test Server e selecione Publish.

  6. Configure um monitor de TCP/IP no WebSphere Commerce Developer. Usaremos esse monitor de TCP/IP para observar os documentos de solicitação e resposta saindo e entrando do serviço do WebSphere Commerce criado. Para criar um monitor TCP/IP que irá encaminhar solicitações ao WebSphere Commerce:
    1. Selecione Window > Preferences.
    2. Na página Preferences, clique em Run/Debug > TCP/IP Monitor.
    3. Clique em Add.
    4. Digite as informações a seguir:
      • Porta de monitoramento local: 81
      • Nome do host: localhost - o nome do host do WebSphere Commerce Server no qual o serviço do catálogo está sendo executado.
      • Porta: 80 para WebSphere Commerce Developer
      • Marque a caixa de seleção Start monitor automatically.
    5. Clique em OK.
    6. Selecione o monitor TCP/IP criado.
    7. Clique em Start. (Isso já deve ter sido iniciado; nesse caso, ignore a próxima etapa.)
    8. Clique em OK.
  7. Clique com o botão direito na classe CatalogExtensionFacadeClientTest.java e selecione Run As > JUnit Test. Podemos ver que os documentos XML de solicitação e resposta são transmitidos entre o cliente e o servidor no monitor TCP/IP.

    Verifique os resultados:

    • Esse teste realiza uma solicitação Get para recuperar um substantivo CatalogEntry, incluindo a extensão do produto e dados de instrução de cuidado.
    • A solicitação Get usa a chave XPath /CatalogEntry[CatalogEntryIdentifier[(UniqueID=)]] e o perfil de acesso MyCompany_All definido na Etapa 3 acima.
    • A camada de serviço de dados usa a chave XPath e o perfil de acesso para identificar o modelo de consulta SQL para executar contra o banco de dados e preenche os objetos de dados físicos com os resultados.
    • O mediador de objeto de negócios transforma os objetos de dados físicos em substantivos lógicos. Esse processo insere informações adicionais do produto no elemento UserData do substantivo CatalogEntry e insere instruções de cuidado no elemento de atributos da parte do substantivo da descrição de Catalog.

Chamando o serviço da web modificado a partir da loja Madisons

Nesta seção, criaremos um arquivo JSP que exibe informações estendidas da entrada de catálogo usando a tag getData. Atualizamos o ProductDisplay.jsp para vincular a este arquivo JSP para as informações estendidas de entrada de catálogo. Após concluir a customização, os compradores veem um link para "Import information" na página Product Display. Quando os compradores clicam nesse link, a página JSP de entrada de catálogo estendida é exibida. Para fins de demonstração, esse é considerado o segundo canal para chamar o serviço do WebSphere Commerce a partir do canal da web. A IBM fornece um conjunto de tags JSTL que simplificam o acesso aos serviços.

  1. Crie o arquivo get-data-config da fachada de loja. O país das informações de importação é incluído no elemento UserData do substantivo CatalogEntry. Para recuperar as informações de importação de catalogEntry, crie um arquivo get-data-config de fachada de loja que sobrescreve o arquivo de configuração do componente de catálogo. As páginas JSP fazem referência à tag getData usando o construtor de expressões e nomes do perfil de acesso. A tag <wcf:getData> recupera os objetos de dados de serviço dos serviços WebSphere Commerce e os associa com uma variável de script declarada com um ID.
    1. Na visualização Enterprise Explorer, expanda Stores > WebContent > WEB-INF > config.
    2. Clique com o botão direito em config e, em seguida, clique em New > Folder.
    3. No campo Folder name, insira com.ibm.commerce.catalog-ext.
    4. Clique em Finish. A pasta com.ibm.commerce.catalog-ext é criada no diretório de configuração.
    5. Clique com o botão direito em com.ibm.commerce.catalog-ext e selecione New > File.
    6. No campo File name, insira get-data-config.xml.
    7. Clique em Finish. Insira o código a seguir no arquivo get-data-config.xml:
      <?xml version="1.0" encoding="UTF-8"?>
      <wcf:get-data-config
      xmlns:wcf="http://www.ibm.com/xmlns/prod/commerce/foundation"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.ibm.com/xmlns/prod/commerce/foundation ../../
       xsd/get-data-config.xsd ">
      		
      <expression-builder>
      <name>getCatalogEntryWithImport</name>
      <data-type-name>CatalogEntry</data-type-name>
      <expression-template>{_wcf.ap=$accessProfile$}/CatalogEntry
       [CatalogEntryIdentifier[(UniqueID='$catalogEntryId$')]]</expression-template>
      <param>
      <name>accessProfile</name>
      <value>MyCompany_All</value>
      </param>
      </expression-builder>
      		
      </wcf:get-data-config>

      Para <expression-builder>:

      name
      getCatalogEntryWithImport é usado pela tag getData e é referenciado pela página JSP, que é criada na próxima etapa.
      data-type-name
      O substantivo.
      expression-template
      A especificação XPath definida no arquivo wc-query-MyCompanyCatalogEntry-get.tpl.

      Para <param>:

      name
      O nome do perfil de acesso, accessProfile, definido no arquivo wc-query-MyCompanyCatalogEntry-get.tpl.
      value
      O valor, MyCompany_All, do perfil de acesso definido no arquivo wc-query-MyCompanyCatalogEntry-get.tpl.
    8. Salve o arquivo.
  2. Estenda o arquivo de propriedades:
    1. Na visualização Enterprise Explorer, expanda Stores > Java Resources: src > MadisonsStorefrontAssetStore > storetext.properties.
    2. Abra o arquivo storetext.properties.
    3. Inclua as propriedades de cabeçalho do novo título:
      #-------------------------------------------
      # Tutorial - START
      #-------------------------------------------
      productImportDisplayTitle=Import information
      #-------------------------------------------
      # Tutorial - END
      #-------------------------------------------

      Observação: O arquivo Properties contém os rótulos específicos de idioma que são exibidos na página.

  3. Crie o arquivo ImportDisplay.jsp para exibir as informações de importação na loja:
    1. Abra WebSphere Commerce Developer na perspectiva Java EE.
    2. Na visualização Enterprise Explorer, navegue até Stores > WebContent > MadisonsStorefrontAssetStore > ShoppingArea > CatalogSectio > CatalogEntrySubsection.
    3. Clique com o botão direito em CatalogEntrySubsection e selecione New > Web Page.
    4. No campo File name, insira ImportDisplay.jsp. Na seção Template, certifique-se de que JSP está selecionado em Basic Templates.
    5. Clique em Finish.
    6. Clique na guia Source e substitua o conteúdo do arquivo ImportDisplay.jsp com o seguinte código de amostra:
      	<%--
      	  *****
      	  * This JSP imports CachedProductItemDisplay or CachedProductOnlyDisplay 
            * based on the store configuration.
      	  * It also imports header, sidebar, and footer.
      	  *****
      	--%>
      	<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
      	<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
      	<%@ taglib uri="http://commerce.ibm.com/base" prefix="wcbase" %>
      	<%@ taglib uri="http://commerce.ibm.com/foundation" prefix="wcf" %>
      	<%@ taglib uri="flow.tld" prefix="flow" %>
      	
      	<%@ include file="../../../include/JSTLEnvironmentSetup.jspf"%>
      	<%@ include file="../../../include/nocache.jspf"%>
      	
      	<c:set var="productId" value="${WCParam.productId}" />
      	<c:set var="productPage" value="true" scope="request"/>
      	<c:set var="hasBreadCrumbTrail" value="true" scope="request"/>
      	<c:set var="useHomeRightSidebar" value="false" scope="request"/>
      	
      	
      	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
           "http://www.w3.org 
           TR/xhtml1/DTD/xhtml1-transitional.dtd">
      	<!-- BEGIN ProductDisplay.jsp -->
      	<html xmlns:wairole="http://www.w3.org/2005/01/wai-rdf/GUIRoleTaxonomy#"
      	xmlns:waistate="http://www.w3.org/2005/07/aaa" lang="${shortLocale}" 
           xml:lang="${shortLocale}">
      	<head>
      	<title>Import Display</title>
      	
      	<link rel="stylesheet" href="<c:out value="${jspStoreImgDir}$
           {vfileStylesheet}"/>" 
           type="text/css"/>
      	<!--[if lte IE 6]>
      	<link rel="stylesheet" href="<c:out value="${jspStoreImgDir}$
           {vfileStylesheetie}"/>" 
           type="text/css"/>
      	<![endif]-->
      	<script type="text/javascript" src="<c:out value="${dojoFile}"/>" 
           djConfig="${dojoConfigParams}"></script>
      	<%@ include file="../../../include/CommonJSToInclude.jspf"%>
      	<script type="text/javascript" src="<c:out value="${jsAssetsDir}
           javascript/MessageHelper.js"/>"></script>
      	
      	<style>
      	tr,td{
      	border:1px;
      	}
      	</style>
      	</head>
      	
      	<body>
      	<%@ include file="../../../include/StoreCommonUtilities.
           jspf"%>
      		<div id="page">
      			
      			<%@ include file="../../../include/LayoutContainerTop.
                   jspf"%>
      			
      			<div id="content_wrapper_box">
      	
      			<wcf:getData var="catentries" type="com.ibm.commerce.
                   catalog.facade.datatypes.CatalogEntryType[]" expressionBuilder=
                   "getCatalogEntryWithImport">
      				<wcf:contextData name="storeId" data=
                       "${WCParam.storeId}"/>
      				<wcf:contextData name="catalogId" data=
                       "${WCParam.catalogId}"/>
      				<wcf:contextData name="langId" data=
                       "${WCParam.langId}"/>
      				<wcf:param name="catalogEntryId" value=
                       "${WCParam.catalogEntryID}"/>
      				<wcf:param name="accessProfile" value=
                       "MyCompany_All"/>
      			</wcf:getData>
      			
      		<%-- Create a table to display the value for ProductID, Import & 
                Import Country --%>
      		 <div>
      			<table id="WC_CachedItemDisplay_Table_1">
      				<tbody align="center">
      					<tr align="left" cellpadding="2" 
                           cellspacing="2" >
      						<td align="left" cellpadding="2" 
                               cellspacing="2">
      						<p align="left"> <b><fmt:
                               message key="productImportDisplayTitle" 
                               bundle="${storeText}"/></b></p>
      						<br/>
      						</td>
      					</tr>
      					<tr cellpadding="2" cellspacing="2">
      						<td align="left" cellpadding="2" 
                               cellspacing="2">
      						<table border="1">
      						<tr style="border:1px" 
                               cellpadding="2"
                               cellspacing="2"> 
                                   <td cellpadding="2" cellspacing="2"
                                   ><u><b>ProductID</b></u></td>
                                   <td>|</td><td cellpadding="2" 
                                    cellspacing="2"><u>
                                    <b>Imported</b></u>
                                    </td><td>|</td><td 
                                    cellpadding="2" 
                                    cellspacing="2"><u><b>
                                    Imported From Country</b></u></td>
                                    <td>|</td>
      						</tr>
                              <c:forEach var="catalogEntry" items=
                               "${catentries}">
       
                                 <tr align="center" cellpadding="2" 
                                 cellspacing="2">
                               <td>${catalogEntry.catalogEntryIdentifier.
                                 uniqueID}</td>
                                   <td>|</td>
      	
      		<%-- Search the value for UserDataField & only output the value 
               for Imported & Imported From--%>
      			<c:forEach var="userDataField" items="${catalogEntry.
                    userData.userDataField}">
                    <c:if test="${userDataField.typedKey == 'imported' || 
                     userDataField.typedKey == 'imported_country'}">
      			<td>${userDataField.typedValue}</td><td>|</td>
      		  </c:if>
      		  </c:forEach>
      		</tr>
      		</c:forEach>
      		</table>
      		</td>
      	</tr>	
      	
      	</tbody>
       </table>
       </div>
       </div>		
       <%@ include file="../../../include/LayoutContainerBottom.jspf"%>
      	</div>
      </body>
      </html>

      A página recupera dados usando a tag getData.

    7. Salve o arquivo.
  4. AtualizeProductDisplay.jsp para que esteja vinculado ao arquivo ImportDisplay.jsp:
    1. Abra a perspectiva Java EE.
    2. Na visualização Enterprise Explorer, expanda Stores > WebContent > MadisonsStorefrontAssetStore > ShoppingArea > CatalogSection > CatalogEntrySubsection.
    3. Abra o arquivo ProductDisplay.jsp.
    4. Em ProductDisplay.jsp, localize as linhas a seguir, que estão localizadas na parte inferior do arquivo:
      <c:param name="productId" value="${productId}"/>
      	</c:import>
      	<%out.flush();%> </div>
    5. Inclua um link Import. Inclua o código a seguir após a tag </div>:
      <!-- Tutorial changes - BEGIN -->
       <div>
        <br/>
        <br/>
        <img src="<c:out value="${jspStoreImgDir}" />images/
         expand_icon_hover.gif" />
      
        <c:url var="ImportViewURL" value="ImportView">
      	<c:param name="langId" value="${langId}" />
          <c:param name="storeId" value="${WCParam.storeId}" />
      	<c:param name="catalogId" value="${WCParam.catalogId}" />
      	<c:param name="catalogEntryID" value="${productId}" />
        </c:url>
        <a href='<c:out value="${ImportViewURL}" />' id="">
         Import Information </a>
       </div>
      <!-- Tutorial changes - END -->
  5. Atualize o arquivo de configuração Struts para registrar a nova página JSP. Agora que criamos um modelo JSP para gerar a resposta do serviço da web, podemos registrar a página JSP no arquivo de configuração Struts para que possa ser usado pela estrutura de serviços da web do WebSphere Commerce. Como o WebSphere Commerce é compatível com Struts, é possível registrar as páginas JSP incluindo a configuração Struts apropriada para associar a visualização com uma página JSP física:
    1. Na visualização Enterprise Explorer, expanda Stores > WebContent > WEB-INF > struts-config-ext.xml.
    2. Abra o arquivo struts-config-ext.xml.
    3. Inclua o código a seguir na seção de encaminhamento global:
      <!-- Tutorial changes - BEGIN -->
      	
      <forward className="com.ibm.commerce.struts.ECActionForward" name=
        "ImportView/10651" path="/ShoppingArea/CatalogSection/CatalogEntrySubsection/
        ImportDisplay.jsp"/>
      	
      <!-- Tutorial changes - END -->
    4. Copie e cole o código de amostra a seguir antes da tag </actions-mapping> de fechamento na parte inferior do arquivo:
      <!-- Tutorial changes - BEGIN -->
      	
      <action path="/ImportView" type="com.ibm.commerce.struts.BaseAction">
      <set-property property="https" value="10651:1"/>
      </action>
      	
      <!-- Tutorial changes - END -->
    5. Salve o arquivo.
  6. Crie uma política de controle de acesso para garantir a nova visualização de importação. Por padrão, apenas os usuários com a função de Administrador do Site podem acessar a visualização criada na etapa anterior. Nesta etapa, atualizamos a política de controle de acesso do serviço Catalog para permitir que todos os usuários acessem a nova visualização.
    1. Crie um arquivo chamado ImportViewCommand.xml no diretório <WCDev_Dir>\xml\policies\xml.
    2. Copie e cole o seguinte XML de política de controle de acesso nesse arquivo:
      <?xml version="1.0" encoding="ISO-8859-1" standalone="no" ?>
      <!DOCTYPE Policies SYSTEM "../dtd/accesscontrolpolicies.dtd">
      		
      <Policies>
      		
      <Action Name="ImportView" CommandName="ImportView">
      </Action>
      <ActionGroup Name="AllSiteUsersViews" OwnerID="RootOrganization">
      <ActionGroupAction Name="ImportView"/>
      </ActionGroup>
      		
      </Policies>
    3. Salve o arquivo.
    4. Pare o ambiente de teste.
    5. Use o prompt de comandos para alternar para o diretório <WCDev_Dir>\bin.
    6. Carregue ImportviewCommand.xml executando o comando a seguir:
      acpload inst1db db2admin passw0rd ImportViewCommand.xml db2admin
    7. Navegue até o diretório <WCDev_Dir>\logs. Inspecione os arquivos acpload.log e messages.txt para garantir que a política de controle de acesso tenha sido carregada com sucesso. O arquivo messages.txt pode não estar presente se tudo tiver sido carregado com sucesso.
  7. Reinicie o servidor e publique as alterações.

Testando a customização na loja

Nesta seção, testaremos as alterações na fachada de loja.

  1. Certifique-se de que o WebSphere Commerce Server foi iniciado.
  2. Abra o navegador da web Mozilla® Firefox ® e insira a URL a seguir: http://localhost/webapp/wcs/stores/servlet/StoreView?storeId=10152.

    Observação: Altere storeId de acordo com seu ambiente.

  3. Clique em Furniture para entrar na página Category Display.
  4. Selecione Lounge Chairs.
  5. Clique em White Fabric Roll Arm Chaise. O link para as informações de importação é exibido, como mostra a Figura 4.
    Figura 4. Página Product Display com as novas informações de importação
    Página Product Display com as novas informações de importação
  6. Clique em Import information. Selecione Yes se a página de alerta de segurança for exibida. No Firefox, clique no botão I Understand the Risks e em seguida em Add Exception. Clique em Get Certificate e no botão Confirm Security Exception. A página Import information é exibida, como mostra a Figura 5.
    Figura 5. Novo JSP com informações de importação
    Novo JSP com informações de importação

Chamando o serviço da web modificado a partir da ferramenta de UI SOAP

É possível criar novas visualizações dos dados retornados pelo mesmo serviço definindo um novo perfil de acesso. Quatro perfis de acesso diferentes são criados para fins de demonstração. Esses quatro perfis de acesso retornam conjuntos diferentes de dados dependendo de qual canal é usado para chamar o serviço. A ferramenta de UI soap é usada neste tutorial para enviar a solicitação e analisar a resposta.

Para fins de demonstração, esse é considerado o terceiro canal. Neste caso, o cliente pode ser um barramento de serviço corporativo (ESB) que cria uma mensagem XML de acordo com nosso padrão e a envia diretamente para nosso serviço. Observe que não são usados cliente Java ou biblioteca de tags JSTL neste caso. O cliente cria e envia a mensagem por meio de algum outro mecanismo.

  1. Abra a ferramenta soapUI clicando duas vezes no ícone soapUI X.x no desktop.
  2. Importe o projeto de amostra de C:\Lab_Instructions\soapui-project.xml.
  3. Expanda Projects como mostra a Figura 6.
    Figura 6. soapUI com projeto de amostra carregado
    soapUI com projeto de amostra carregado

Chame usando o perfil de acesso à loja

  1. Clique duas vezes em StoreProfile Request. A Figura 7 representa a área de exibição de solicitação-resposta.
    Figura 7. Área de exibição de solicitação-resposta
    Área de exibição de solicitação-resposta

    Examine o conteúdo da solicitação no lado esquerdo da tela.

  2. Clique na seta verde para a direita no canto superior esquerdo para enviar a solicitação para o servidor do WebSphere Commerce.
  3. Examine o conteúdo da resposta no lado direito da tela.

Observação: Neste exemplo, o perfil de acesso MyCompany_Store_CatalogEntryAllDescriptions é usado para obter todas as descrições de uma dada entrada de catálogo, incluindo os dados adicionais nas tabelas customizadas.

Chamar usando o perfil de acesso de administrador

  1. Clique duas vezes em AdminProfile Request.
  2. Clique na seta verde para a direita no canto superior esquerdo para enviar a solicitação para o servidor do WebSphere Commerce.
  3. Examine o conteúdo da resposta no lado direito da tela.

Observação: Neste exemplo, o perfil de acesso MyCompany_Admin_All é usado para obter os dados a seguir, mais dados adicionais nas tabelas customizadas: Entrada de Catálogo com descrição, preço da Entrada de Catálogo, remessa da Entrada de Catálogo, filho da Entrada de Catálogo, grupo de catálogo do pai da Entrada de Catálogo, associações de comércio da Entrada de Catálogo, atributos da Entrada de Catálogo, entrada de catálogo pai da Entrada de Catálogo, item base da Entrada de Catálogo e especificação de item da Entrada de Catálogo.

Chamar usando o perfil de acesso Kiosk

  1. Clique duas vezes em KioskProfile Request.
  2. Clique na seta verde para a direita no canto superior esquerdo para enviar a solicitação para o servidor do WebSphere Commerce.
  3. Examine o conteúdo da resposta no lado direito da tela.

Observação: Neste exemplo, o perfil de acesso MyCompany_Store_CatalogEntryDetailsWithKioskInfo é usado para obter os dados a seguir, mais dados adicionais nas tabelas customizadas que incluem dados na tabela de quiosque: Entrada do Catálogo com descrição, preço da Entrada de Catálogo e grupo de catálogo pai da Entrada de Catálogo.

Chamar usando o perfil de acesso remoto

  1. Clique duas vezes em MobileProfile Request.
  2. Clique na seta verde para a direita no canto superior esquerdo para enviar a solicitação para o servidor do WebSphere Commerce.
  3. Examine o conteúdo da resposta no lado direito da tela.

Observação: Neste exemplo, o perfil de acesso MyCompany_Mobile_Description é usado para obter os dados a seguir, mais dados adicionais nas tabelas customizadas: Entrada do Catálogo com descrição.


Chamando o serviço da web modificado a partir da Loja Remota da Madison

Nesta seção, usamos a mesma tag de obtenção de dados usada na loja da web para recuperar as informações adicionais usando o perfil de acesso remoto. Atualizamos a loja remota CachedProductDisplay.jsp para incluir as informações estendidas. Após concluir a customização, os compradores podem ver "Import information" na página Product Display. Para fins de demonstração, esse é considerado o quarto canal. Essa é apenas uma extensão do canal da web e a mesma técnica de código é usada.

  1. Atualize o CachedProductDisplay.jsp da loja remota para incluir as informações estendidas:
    1. Abra a perspectiva Java EE.
    2. Na visualização Enterprise Explorer, expanda Stores > WebContent > MadisonsStorefrontAssetStore > mobile > Snippets > Catalog > CatalogEntryDisplay.
    3. Abra o arquivo CachedProductDisplay.jsp.
    4. Em CachedProductDisplay.jsp, localize as linhas a seguir, que estão na parte inferior do arquivo:
      <div id="product_description" class="description_container">
       <h3><fmt:message key="DESCRIPTION" bundle="${storeText}" />:</h3>
        <p><c:out value="${product.description.longDescription}" 
         escapeXml="false"/></p>
    5. Inclua o código a seguir após a tag </p>:
      <%-- Tutorial Changes – BEGIN --%>
      <%-- Create a table to display the value for ProductID, Import & 
       Import Country --%>
       <wcf:getData var="catentries" type="com.ibm.commerce.catalog.facade.  
        datatypes.CatalogEntryType[]" expressionBuilder="getCatalogEntryWithImport">
      	<wcf:contextData name="storeId" data="${WCParam.storeId}"/>
      	<wcf:contextData name="catalogId" data="${WCParam.catalogId}"/>
      	<wcf:contextData name="langId" data="${WCParam.langId}"/>
      	<wcf:param name="catalogEntryId" value="${catalogEntryID}"/>
      	<wcf:param name="accessProfile" value="MyCompany_Mobile_Description"/>
       </wcf:getData>	
      	<div>
      	 <table id="WC_CachedItemDisplay_Table_1">
      		<tbody align="center">
      			<tr align="left" cellpadding="2" cellspacing="2" >
      			 <td align="left" cellpadding="2" cellspacing="2">
      			 <p align="left"> <b>Import Information</b></p>
      			 </td>
      			</tr>
      			<tr cellpadding="2" cellspacing="2">
      			 <td align="left" cellpadding="2" cellspacing="2">
      			 <table border="1">
      			 <tr style="border:1px" cellpadding="2" cellspacing="2">
      			 <td cellpadding="2" cellspacing="2"><b>ProductID
                    </b></td><td cellpadding="2" cellspacing="2">
                    <b>Imported</b></td><td cellpadding="2" 
                    cellspacing="2"><b>Imported From Country</b></td>
      			 </tr>
      			 <c:forEach var="catalogEntry" items="${catentries}">
      		
      			 <tr align="center" cellpadding="2" cellspacing="2">
      			 <td>${catalogEntry.catalogEntryIdentifier.uniqueID}</td>
      		
      	<%-- Search the value for UserDataField & only output the value for 
            Imported & Imported From--%>
      	   <c:forEach var="userDataField" items="${catalogEntry.
              userData.userDataField}">
      	   <c:if test="${userDataField.typedKey == 'imported' || 
              userDataField.typedKey == 'imported_country'}">
      		<td>${userDataField.typedValue}</td>
      	   </c:if>
      	   </c:forEach>
      			</tr>
      			</c:forEach>
      			</table>
      			</td>
      			</tr>	
      		
      		</tbody>
      	</table>
      	</div>
      <%-- Tutorial Changes – END --%>
    6. Salve o arquivo.
  2. Abra o navegador Mozilla Firefox e configure o agente do usuário como iPhone 3.0. Acesse Tools > Default User Agent e selecione iPhone 3.0.

    Observação: Isso configura o navegador Mozilla Firefox para enviar as informações de agente de usuário iPhone® ao servidor WebSphere Commerce. O servidor WebSphere Commerce identifica solicitações móveis com base nas informações do agente do usuário.

  3. Insira a URL seguinte no navegador: http://localhost/webapp/wcs/stores/servlet/StoreView?storeId=10152.

    Observação: Altere storeId de acordo com seu ambiente.

  4. Clique em Furniture para entrar na página Category Display.
  5. Selecione Lounge Chairs.
  6. Clique em White Fabric Roll Arm Chaise.
  7. As informações de importação aparecem acima do link "Next Product", como mostra a Figura 8.
    Figura 8. Página Madisons Mobile
    Página Madisons Mobile

Como podemos ver no canal remoto, nós demonstramos a reutilização da mesma tag get-data com um perfil de acesso diferente.


Conclusão

Este tutorial mostrou como customizar o serviço Catalog para suportar informações estendidas de entrada de catálogo e usar serviços de diversos canais. Você aprendeu a realizar estas customizações:

  • Atualizar o esquema do WebSphere Commerce para armazenar novas informações.
  • Customizar o serviço Catalog para incluir novas informações como dados de usuário no substantivo CatalogEntry.
  • Usar o mesmo código de serviço independente do canal de origem do cliente.

Agradecimentos

O autor gostaria de agradecer Biswajit Dash e Scott Guminy por terem revisado este tutorial.


Download

DescriçãoNomeTamanho
Sample project filescode_sample.zip141KB

Recursos

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=WebSphere
ArticleID=806403
ArticleTitle=Desenvolvendo serviços do WebSphere Commerce para comércio entre canais
publish-date=03222012