Technical Articles / Blogs / Perficient

Create an RSS Feed using HTL

Raviteja Gunda — Fri, 03 May 2024 17:15:39 +0000

Did you know you can create an RSS feed in AEM (Adobe Experience Manager) for external applications like Eloqua? While AEM provides out-of-the-box functionality for RSS feeds, customizing them may require additional steps. Below you’ll find several options for creating RSS feeds in AEM along with steps for creating one using HTL.

3 Options to Create an RSS Feed in AEM

Override Default JSP Functionality (JSP Approach)
- Customize the JSP code to tailor the RSS feed according to your requirements
- This approach requires writing backend logic in Java and JSP
Create a Servlet for RSS Feed
- Implement the logic within the servlet to fetch and format the necessary data into RSS feed XML
- Configure the servlet to respond to specific requests for the RSS feed endpoint
- This approach allows more control and flexibility over the RSS feed generation process
Use HTL with Sling Model (HTL Approach)
- Write HTL templates combined with a Sling Model to generate the RSS feed
- Leverage Sling Models to retrieve data from AEM and format it within the HTL template
- This approach utilizes AEM’s modern templating language and component models
- HTL is preferred for templating tasks due to its simplicity and readability

Expected RSS Feed

Below is the feed response for an external source to integrate and send emails accordingly. Here the feed results can be filtered by category tag names (category) using query parameters in the feed URL.

https://www.demoproject.com/products/aem.rss
https://www.demoproject.com/products/aem.rss?category=web



    
        
        https://www.demoproject.com/products/aem
        AEM
        
        Fri, 29 Sep 2023 02:08:26 +0000
        
            https://www.demoproject.com/products/aem/one.rss.xml
            
            https://www.demoproject.com/products/aem/sites
            Aem Sites
            
            Tue, 31 Oct 2023 02:23:04 +0000
        
        
            https://www.demoproject.com/products/aem/two.rss.xml
            
            https://www.demoproject.com/products/aem/assets
            Aem Assets
            
            Thu, 26 Oct 2023 02:21:19 +0000
            pdf,doc,image,web

Steps for Creating RSS Feed Using HTL

Create a HTML file under the page component
Create a PageFeed Sling Model that returns data for the RSS feed
Add a rewrite rule in the dispatcher rewrite rules file
Update the ignoreUrlParams for the required params

Page Component – RSS html

Create an HTML file with the name “rss.xml.html” under page component. Both ‘rss.html’ or ‘rss.xml.html’ work fine for this. Here, ‘rss.xml.html’ naming convention indicates that it is generating XML data. PageFeedModel provides the page JSON data for the expected feed.

Category tag is rendered only when page properties are authored with tag values
CDATA (character data) is a section of element content to render as only character data instead of markup




    
        
        ${model.linkTag @ context='unsafe'}
        ${model.title}
        ${model.subTitle}
        ${model.publishedDate}
        
            
                ${childPage.feedUrl}
                
                ${childPage.linkTag @ context='unsafe'}
                ${childPage.title}
                
                ${childPage.publishedDate}
                
                    ${childPage.tags}

Page Feed Model

This is a component model that takes the currentPage as the root and retrieves a list of its child pages. Subsequently, it dynamically constructs properties such as publish date and categories based on the page’s tag field. These properties enable filtering of results based on query parameters. Once implemented, you can seamlessly integrate this model into your component to render the RSS feed.

Using currentPage get the current page properties as a value map
Retrieve title, description, pubDate, link for current page
Retrieve title, description, pubDate, link, tags (categories) for child pages
Filter the child pages list based on the query param value (category)

//PageFeedModel sample code 
package com.demoproject.aem.core.models;

import com.adobe.cq.export.json.ExporterConstants;
import com.day.cq.commons.Externalizer;
import com.day.cq.commons.jcr.JcrConstants;
import com.day.cq.wcm.api.Page;
import com.day.cq.wcm.api.PageFilter;
import com.demoproject.aem.core.utility.RssFeedUtils;
import lombok.Getter;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.sling.api.SlingException;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ValueMap;
import org.apache.sling.models.annotations.DefaultInjectionStrategy;
import org.apache.sling.models.annotations.Exporter;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.SlingObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.annotation.PostConstruct;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

@Model(adaptables = {
    Resource.class,
    SlingHttpServletRequest.class
}, resourceType = PageFeedModel.RESOURCE_TYPE, defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
@Exporter(name = ExporterConstants.SLING_MODEL_EXPORTER_NAME, extensions = ExporterConstants.SLING_MODEL_EXTENSION)
public class PageFeedModel {

    protected static final String RESOURCE_TYPE = "demoproject/components/page";
    private static final Logger logger = LoggerFactory.getLogger(PageFeedModel.class);
    @SlingObject
    ResourceResolver resourceResolver;
    @SlingObject
    SlingHttpServletRequest request;
    @Inject
    private Page currentPage;
    @Getter
    private String title;
    @Getter
    private String link;
    @Getter
    private String linkTag;
    @Getter
    private String description;
    @Getter
    private List < ChildPageModel > entries;
    @Inject
    private Externalizer externalizer;
    @Getter
    private String feedUrl;
    @Getter
    private String publishedDate;


    @PostConstruct
    protected void init() {
        try {
            ValueMap properties = currentPage.getContentResource().adaptTo(ValueMap.class);
            title = StringEscapeUtils.escapeXml(null != currentPage.getTitle() ? currentPage.getTitle() : properties.get(JcrConstants.JCR_TITLE, String.class));
            description = StringEscapeUtils.escapeXml(properties.get(JcrConstants.JCR_DESCRIPTION, String.class));

            link = RssFeedUtils.getExternaliseUrl(currentPage.getPath(), externalizer, resourceResolver);
            feedUrl = link + ".rss.xml";
            linkTag = RssFeedUtils.setLinkElements(link);

            String category = request.getParameter("category") != null ? request.getParameter("category").toLowerCase().replaceAll("\\s", "") : StringUtils.EMPTY;
            entries = new ArrayList < > ();
            Iterator < Page > childPages = currentPage.listChildren(new PageFilter(false, false));
            while (childPages.hasNext()) {
                Page childPage = childPages.next();
                ChildPageModel childPageModel = resourceResolver.getResource(childPage.getPath()).adaptTo(ChildPageModel.class);
                if (null != childPageModel) {
                    if (StringUtils.isBlank(category)) entries.add(childPageModel);
                    else {
                        String tags = childPageModel.getTags();
                        if (StringUtils.isNotBlank(tags)) {
                            tags = tags.toLowerCase().replaceAll("\\s", "");
                            List tagsList = Arrays.asList(tags.split(","));
                            String[] categoryList = category.split(",");
                            boolean flag = true;
                            for (String categoryStr: categoryList) {
                                if (tagsList.contains(StringEscapeUtils.escapeXml(categoryStr)) && flag) {
                                    entries.add(childPageModel);
                                    flag = false;
                                }
                            }
                        }
                    }
                }
            }
            publishedDate = RssFeedUtils.getPublishedDate(properties);

        } catch (SlingException e) {
            logger.error("Repository Exception {}", e);
        }
    }
}

//ChildPageModel 
package com.demoproject.aem.core.models;

import com.adobe.cq.export.json.ExporterConstants;
import com.day.cq.commons.Externalizer;
import com.day.cq.commons.jcr.JcrConstants;
import com.demoproject.aem.core.utility.RssFeedUtils;
import lombok.Getter;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.sling.api.SlingException;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ValueMap;
import org.apache.sling.models.annotations.DefaultInjectionStrategy;
import org.apache.sling.models.annotations.Exporter;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.SlingObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.annotation.PostConstruct;
import javax.inject.Inject;

@Model(adaptables = {
    Resource.class
}, defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
@Exporter(name = ExporterConstants.SLING_MODEL_EXPORTER_NAME, extensions = ExporterConstants.SLING_MODEL_EXTENSION)
public class ChildPageModel {
    private static final Logger logger = LoggerFactory.getLogger(ChildPageModel.class);

    @SlingObject
    Resource resource;

    @Getter
    private String title;

    @Getter
    private String link;

    @Getter
    private String linkTag;

    @Getter
    private String feedUrl;

    @Getter
    private String description;

    @Getter
    private String publishedDate;

    @Getter
    private String tags;

    @Inject
    private Externalizer externalizer;

    @PostConstruct
    protected void init() {
        try {
            if (null != resource) {
                String url = resource.getPath();

                ResourceResolver resourceResolver = resource.getResourceResolver();
                link = RssFeedUtils.getExternaliseUrl(url, externalizer, resourceResolver);
                feedUrl = link + ".rss.xml";
                linkTag = RssFeedUtils.setLinkElements(link);

                ValueMap properties = resource.getChild(JcrConstants.JCR_CONTENT).adaptTo(ValueMap.class);
                title = StringEscapeUtils.escapeXml(properties.get(JcrConstants.JCR_TITLE, String.class));
                description = StringEscapeUtils.escapeXml(properties.get(JcrConstants.JCR_DESCRIPTION, String.class));
                publishedDate = RssFeedUtils.getPublishedDate(properties);
                tags = StringEscapeUtils.escapeXml(RssFeedUtils.getPageTags(properties, resourceResolver));

            }
        } catch (SlingException e) {
            logger.error("Error: " + e.getMessage());
        }
    }
}

//RSS Feed Utils 

package com.demoproject.aem.core.utility;

import com.day.cq.commons.Externalizer;
import com.day.cq.commons.jcr.JcrConstants;
import com.day.cq.tagging.Tag;
import com.day.cq.tagging.TagManager;
import com.day.cq.wcm.api.NameConstants;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ValueMap;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/** 
 * @desc RSS Feed Utils 
 */
@Slf4j
public class RssFeedUtils {

    public static final String FORMAT_DATE = "E, dd MMM yyyy hh:mm:ss Z";
    public static final String CONTENT_PATH = "/content/demoproject/us/en";

    public static String getPublishedDate(ValueMap pageProperties) {
        String publishedDate = StringUtils.EMPTY;
        SimpleDateFormat dateFormat = new SimpleDateFormat(FORMAT_DATE);
        Date updatedDateVal = pageProperties.get(JcrConstants.JCR_LASTMODIFIED, pageProperties.get(JcrConstants.JCR_CREATED, Date.class));
        if (null != updatedDateVal) {
            Date replicatedDate = pageProperties.get(NameConstants.PN_PAGE_LAST_REPLICATED, updatedDateVal);
            publishedDate = dateFormat.format(replicatedDate);
        }
        return publishedDate;
    }

    public static String getExternaliseUrl(String pagePath, Externalizer externalizer, ResourceResolver resourceResolver) {
        String url = StringUtils.EMPTY;
        if (StringUtils.isNotBlank(pagePath) && null != externalizer && null != resourceResolver)
            url = externalizer.publishLink(resourceResolver, resourceResolver.map(pagePath)).replace(CONTENT_PATH, "");

        return url;
    }

    public static String setLinkElements(String link) {
        String url = StringUtils.EMPTY;
        if (StringUtils.isNotBlank(link)) {
            url = "" + link + "";
        }
        return url;
    }

    public static String getPageTags(ValueMap properties, ResourceResolver resourceResolver) {
        String tags = StringUtils.EMPTY;
        String[] pageTags = properties.get(NameConstants.PN_TAGS, String[].class);
        if (pageTags != null) {
            List < String > tagList = new ArrayList < > ();
            TagManager tagManager = resourceResolver.adaptTo(TagManager.class);
            for (String tagStr: pageTags) {
                Tag tag = tagManager.resolve(tagStr);
                if (tag != null) {
                    tagList.add(tag.getName());
                }
            }
            if (!tagList.isEmpty()) tags = String.join(",", tagList);
        }
        return tags;
    }
}

Dispatcher Changes

demoproject_rewrites.rules

In the client project rewrites.rules (/src/conf.d/rewrites) file add a rewrite rule for .rss extension. This rewrite rule takes a URL ending with .rss and rewrites it to point to a corresponding rss.xml file in the page component, effectively changing the file extension from .rss to .rss.xml

#feed rewrite rule
RewriteRule ^/(.*).rss$ /content/demoproject/us/en/$1.rss.xml [PT,L]

100_demoproject_dispatcher_farm.any

Set the URL parameters that should not be cached for the rss feed. It is recommended that you configure the ignoreUrlParams setting in an allowlist manner. As such, all query parameters are ignored and only known or expected query parameters are exempt (denied) from being ignored.

When a parameter is ignored for a page, the page is cached upon its initial request. As a result, the system subsequently serves requests for the page using the cached version, irrespective of the parameter’s value in the request. Here, we add URL parameters below to serve the content live as required by an external application.

/ignoreUrlParams {
    /0001 { /glob "*" /type "allow" }
    /0002 { /glob "category" /type "deny" }
    /0003 { /glob "pubdate_gt" /type "deny" }
    /0004 { /glob "pubdate_lt" /type "deny" }
}

Why is HTL Better?

We can utilize this approach to produce any XML feed, extending beyond RSS feeds. We have the flexibility to add custom properties to tailor the feed to our specific needs. Plus, we can easily apply filters using query parameters.

Big thanks to my director, Grace Siwicki, for her invaluable assistance in brainstorming the implementation and completing this blog work.

How to Create and Use Paginated Reports in Power BI

Seema Borhade — Tue, 12 Jul 2022 16:06:29 +0000

Paginated Reports are the same as SSRS, which have come to Power BI with advanced features for better reports. Paginated Reports are well designed & formatted reports which are perfectly sized so we can print and share the reports effectively. We can also load images and charts on these reports. We can create highly formatted reports for PDF generation purposes.

Power BI Report Builder is a tool used to create Paginated Reports and have them published on Power BI Service. We need Power BI Premium Capacity for Power BI Paginated Reports.

How to Create the Paginated Report

Following are the simple steps to create a Paginated Report using Power BI Report Builder:

1. Open Power BI Report Builder:

First, we need to open Power BI Report Builder; you will see the below window. In this one, we can select Table Wizard/ Chart wizard/ Map Wizard / Blank Report. Here we will select Blank Report.

2. Create and Configure Data Source:

After selecting the Blank report, Create the Data source to connect with Dataset you have already created and published in the workspace: Select the Power BI dataset available and create the Data source connection (Select the highlighted one Dataset):

3. Create a Dataset for the Report:

After creating the Data source, we need to make the Dataset for the report. When you click on Add Dataset, the below Dataset Properties Window appears; here, we will give the appropriate name to the Dataset and select the Data source we have already created.

Now we need to select the columns for the design view and also get the parameters in the parameters pane:

Now Click on Ok, and you will see the query created in the Query Designer. Again, click on Ok, and we can go ahead to make the table on the Report Page.

4. Create the Paginated Report:

Lets’ create the table from the Table Wizard:

After clicking on Table Wizard, you will see the window to choose the Dataset which already exists or the one you have already created before this step. After selecting the existing Dataset, the next step will be the Arrange Fields. In this, we need to drag the columns for Value, Row group, and Column Group pane as below. Also, we need to summarize the metrics as shown in the below image:

Click on Next and Finish, and the table will be created on the Report Page. Then you can do some formatting as per the Client’s Requirement to get the final Report. We can use Properties for formatting purposes.

5. Output of the Paginated Report:

To see the output of the report, we need to “Run” the Report from the “Home Tab.”

Paginated Report is always saved in .rdl file format.

After publishing the report on the Workspace/Power BI Service, the user can view the report on the Power BI Service. Users can view or download the Report from the Power BI Service also.

Why Use Paginated Reports?

Paginated reports help create tabular reports, purchases, sales invoices, etc.
Paginated Reports are more customized and cascading parametrization.
Includes graphic Query Designer to write the queries and test for the same.
Optimized for printing or PDF generation.

Learning How to Use the MuleSoft MongoDB Connector

Wubalem Derbe — Tue, 07 Dec 2021 16:27:31 +0000

MuleSoft has various pre-built connectors to connect Mule to different databases and third-party software. The Anypoint Connector for MongoDB (MongoDB Connector) is a closed-source connector that provides a connection between the Mule runtime engine and third-party software on a MongoDB server.

MongoDB is similar to the MuleSoft Database Connector, which uses a single interface for every case and allows developers to run SQL operations on their database. By leveraging the MongoDB Connector, we can import, export, backup, analyze, transform, and connect to MongoDB. This connector provides the easiest way to connect with MongoDB from the MuleSoft workflow by utilizing a connection string or connectivity details in the MongoDB Connector.

Below are supported operations within the MongoDB Connector, as shown in the screenshot from the Anypoint Studio Mule palette. I will talk about some of the operations later in a use case discussion.

Getting Started With the MongoDB Connector

To familiarize yourself with the MongoDB Connector, you can sign up for a free trial, cloud-hosted MongoDB service.

Create a free trial account below from Atlas with the following steps:

Go to https://account.mongodb.com/
Sign up for a trial account or sign in if you already have one
After verifying your email, you will be prompted to log in and taken to the below page:

Click on “create a new project” and name your project:

Once a project is created, create a database:

Click on “build database” and choose the shared cluster for your free trial account with your choice of cloud provider and region:

Then your cluster will be created:

After the cluster is created, click on “connect to create a DB user detail” and make sure to choose “allow connection from anywhere:”

Then click on “create a DB user:”

Next, choose the connection method using Native app and select “Java as a driver” from the drop-down. From here, you will get the connection string to be used in MuleSoft to connect to Mongo DB.

Configuring Mongo DB Connector in AnyPoint Studio

In the global config for MongoDB, select “connection string” from the connection drop-down. Then select the “recommended library” option as in the below screenshot for a MongoDB driver. Finally, use the connection string by updating it with your details (username, password, and the collection name to be created) in the above step to connect to MongoDB.

For example: mongodb+srv://admin1:admin1@cluster0.ahzus.mongodb.net/customers?retryWrites=true&w=majority

Test the connectivity. It is successful if the correct connection string is provided:

Now that we’ve walked through how to get started with the MongoDB Connector and configure it in Anypoint Studio, let’s take a look at a use case.

Use Case: Importing Data from CSV to MongoDB

In this use case, we are polling a CSV file from one location using a file connector and then transforming it as per the mapping to be stored in MongoDB.

First, we check to see if the collection where we need to store data already exists or not. If the collection isn’t present within MongoDB, we create the collection first. If the collection is present, we store the transformed data using Insert Documents.

To check if the collection doesn’t exist:

If we need to insert multiple records into our collection:

Sample input.csv:

Triggering the flow:

Data imported from CSV to MongoDB:

To learn more about the MongoDB Connector, click here.

Perficient + MuleSoft

At Perficient, we excel in tactical MuleSoft implementations by helping you address the full spectrum of challenges with lasting solutions, rather than relying on band-aid fixes. The end result is an intelligent, multifunctional resource that reduces the costs over time and equips your organization to proactively prepare for future integration demands.

We’re a Premier MuleSoft partner with more than 15 years of integration expertise across industries including financial services, healthcare, retail, and more. After MuleSoft’s acquisition by Salesforce, our continued innovation in the integration space offers more customized experiences on software developed by MuleSoft. We combine the MuleSoft product suite with our connectivity expertise to provide comprehensive solutions both on-premises and in the cloud.

An Intro to Caching in MuleSoft 4

Wubalem Derbe — Wed, 28 Jul 2021 15:45:14 +0000

Caching is a concept harnessed to store frequently used data in the memory, file system, or database that helps to improve processing times. This strategy is most useful when data does not change frequently or is static in nature. In general, some benefits of caching include improved responsiveness, increased performance, and decreased network costs.

The Cache scope in MuleSoft is used to store reusable and frequently used data. There are different types of caching available, which will be discussed later. We can use the caching mechanism to improve performance by speeding up processing times and easing the load on Mule instances.

Here is a snippet that shows where data from a database call is stored in an internal in-memory cache via a caching strategy. When we retrieve the same data multiple times from a database, it gets it from the cache rather than calling it from the database for subsequent calls. This alleviates the load on the end systems and achieves the desired output.

The Caching Process

How precisely does the Cache scope in MuleSoft 4 work?

A flow is enclosed in a Cache scope, so whenever a request comes, it will perform the following actions:

Checks if the request is repeatable or not. A repeatable payload means it’s a repeatable stream. If it is repeatable, only then it will come inside the Cache scope, or if it is not repeatable, it will go through the normal flow processing.
Creates the key so the default mechanism generates a Sha- 256 key generator and combines it with Sha- 256 digest; then the key is created.
Checks if the key is present in the cache. It could be a local cache, which means it is local in memory or the Object Store (could be a persistent Object Store, or it could be Object-Store V2). If the key is not found, it is considered a cache miss and will call the flow.

If the key is found, it will be called a Cache hit and will return a value from the cache that will be used by another processor. So, the processor inside the Cache scope will not be executed in case of a Cache hit. Before coming out of the Cache scope, it will store the value in the form of key-value pair in the cache.

Caching Configurations

To use a caching strategy, you will need to have a Cache scope property panel or Global Elements configuration in Anypoint Studio. Mainly, there are two strategies of caching in Mule:

Default Caching: If you do not specify a caching strategy, it uses a default caching strategy. This strategy provides a basic caching mechanism. Everything will be cached in memory, which is a volatile ram and is non-persistent i.e., if you restart your application, the cached data will be lost. If you want to store a huge static payload, you must use a custom caching strategy.

Reference to a Strategy: You can create a custom cache strategy using this option. In this, you can use Object Store and then define the cache size, time to live, and other configurations as per your requirement.

There are a few steps to configure a Cache Strategy:

Open the Caching Strategy Configuration window.
Define the name of the caching strategy.
Define the Object Store by selecting between Edit Inline and Global Reference.
Select a component for producing a key utilized for storing events inside the caching strategy.
Open the Advanced tab in the property window to configure the advanced setting.

There are two different strategies for storing data in cache. The first one is non-persistent, while the alternative can be used for both options i.e., in-memory Object Store and persistent Object Store that will store in the same file system.

Also, to access the object store externally by another system/application as a REST API, we can enable Object Store V2 during cloud hub deployment. It can also be used if we want consistency or synchronization of cache across a cluster of nodes.

In conclusion, caching in MuleSoft helps process data faster. It’s effective for two types of tasks: 1) processing repeated requests for the same information; and 2) processing requests for information that include large repeatable streams. For example, the next time the Cache scope receives a duplicate message payload, it can send the cached response instead of starting the previously time-consuming process.

To learn more, review MuleSoft’s Cache scope documentation or contact us to discuss your enterprise’s integration strategy.

Perficient + MuleSoft

At Perficient, we excel in tactical MuleSoft implementations by helping you address the full spectrum of challenges with lasting solutions, rather than relying on band-aid fixes. The end result is an intelligent, multifunctional resource that reduces costs over time and equips your organization to proactively prepare for future integration demands.

References

https://docs.mulesoft.com/mule-runtime/4.3/cache-scope

API Security: Common Threats and Considerations

Susheel Kumar — Wed, 17 Jun 2015 14:36:25 +0000

Common API Threats: spoofing, tampering, repudiation, denial of service, unauthorized access, confidentiality violation

API Security Considerations:

Identification – Know Your Consumer
The common approach to implementing this is using API keys, which are nothing but randomly generated values that will vary for each consumer.

Authentication – is Consumer Authentic

User-Password over SSl/TSL: the API consumer will be providing a user password to ensure their authenticity.

OAuth – Additional Security by providing token-based access, and the token can have attributes like expiration, which means
any user can perform certain activity for certain period of time and then later on they need to renew or get a new token
depending on what strategy is being implemented.

SAML – Another mechanism for Authentication. Security Assertion Markup Language (SAML) is an XML standard for injecting
Assertions. Typically, the identity provider will validate the user’s identity and insert appropriate assertions to describe things like what application, resource users have access, roles etc.

OpenID is another solution that gives funcationality similar to OAuth and SAML

Authorization – Is consumer authorized to perform a certain action?

Apart from these basic things, one might also want to consider following:

Json Attack: Since most of the API accept or return JSON response, the response can be intercepted in middle. We can have API Gateway taking care of this for all request responses.

Data Protection : Depending on the information being sent or received, we might need to encrypt certain data elements or mask data so that it will be difficult to guess or figure out what they are and what they really mean. For example, PHI or PCI information.

Richer, More Personalized Customer Experiences for an API Economy

Mark Polly — Tue, 02 Jun 2015 20:14:34 +0000

Open API Economy Source: Point.io

At the IBM Digital Experience 2015 Conference, Ajay Kadakia with IBM talked about how the API economy is affecting legacy IT companies versus the newer cloud-based companies. The challenge is how to provide more agile, market reactive content off the legacy systems when competing against seemingly more agile, cloud based systems.

Ajay talked about the digital disruption that is already underway:

90% of data has been created in the last 2 years
4x increase in cloud investment vs 2013 (just 2 years)
100% of LOB apps will be mobile first by 2017
75B internet connected devices by 2020

Customer centricity is the only differentiator in today’s world, so experience really matters. But customer choice has exploded in the ways they can experience our brand. Previously a website was the key method for customer self service. Now we have devices such as mobile apps, kiosks, internet TV, connected appliances, connected cars, etc.

The only way to reach out to all these channels is to build robust APIs. To succeed, you must include a strategy for API creation and consumption in your overall business strategy. And this requires support at every level of the organization.

So what is an API in the context of an API economy. An API is like a Lego building block that can be combined with other APIs to build more sophisticated services. APIs are the fast path to new business opportunities. At the end of 2014, over 75% of Fortune 1000 had public APIs. Almost every bank or financial services companies have APIs for their partners.

A successful API initiative requires end-to-end capabilities. APIs need to know who is using the API, you need to figure out how to charge or not charge for use of the API, and of course you need to manage the use of the API, which can require some IT infrastructure.

Entry points into the API Economy include:

Build – API Design and Implementation
Manage – API Lifecycle Management
Secure – Security, Metering and Control
Monetize – Analytics and Monetization

So how do you get started? First accelerate your agility. If you can’t be agile, you won’t be fast enough to meet customer and market demand. Second you need a strategy to identify business goals, assets and revenue strategies. Finally you need to monetize the API.

What can be API’s? Here are some examples of business assets that could be exposed through APIs:

Product catalogs
Customer records
ATM/Retail Locations
Payment Services
Shipping and fulfillment
Job Openings
Risk Profiles
Transaction data

You need to do a thorough asset inventory to identify the potential assets that you have that can become APIs. Some APIs could be monetized, while others may be more useful to create brand loyalty. For each API you need to determine the business goals and success criteria.

There are several monetization models to consider:

For Free – can drive adoption for typically low valued assets or brand loyalty
Developer pays – high value assets (like Amazon Web Services) could get paid by developers
Developer gets paid – provides incentives for developers to use your API for things like Ad Placement, etc
Indirect – includes other models

For IBM, they were late to the API Economy, but have quickly caught up through various acquisitions over the past few years. IBM Watson and the new IBM/Apple apps are built on the IBM API platforms.

How to Implement Lighter Weight Portals, Part 3: Knockout Portlet

Mark Polly — Thu, 18 Sep 2014 22:25:50 +0000

In this series, I’m showing how Portals don’t have to be heavyweight. In Part 1, I wrote about how to make the infrastructure lighter by using cloud or IBM’s Pure System. In Part 2, I introduced the concept of using IBM’s Web Content Manager system to build very simple portlets.

Now in this final installment, I am going to extend the concepts introduced in Part 2 to show how we can build more complex portlets, but still keep everything lightweight. To review quickly, in Part 2, I avoided the build and deploy cycle of building Java portlets by using the built-in content management system – WCM. In that example, I used WCM to display a Reuter’s news feed from a simple Javascript widget supplied by Reuters.

Final Appointments Portlet

In this blog, I want to implement a more complex portlet using Knockout, which is a popular Javascript framework. My example is to display in a portlet a list of my Doctor Appointments pulled from a REST service. Our goal is still to keep this lightweight, so I shouldn’t see a lot of code. The first screen shot shows you what the final version looks like in Portal 8.

A typical web page or application consists of several sections:

CSS
Links to external files
HTML body
Javascript

In WCM, we can create an authoring template that contains four HTML fields, one for each of the sections described above. The authoring template also has a workflow associated with it so we can control the publishing of our code.

Presentation Template

We also need a corresponding presentation template to display the page. In the second screen shot I show the presentation template I built. The template includes the four fields (Element tags). And to help the author out, I included the