Fusion Middleware

Accelerated Mobile App Development with Oracle Mobile Cloud Service – Part 2

Part 2: Mobile App Development with MCS

In Part 1, we explored using Oracle’s Mobile Cloud Service as tool to provide the backend services needed to retrieve data from an Oracle EBS Pricing and Availability form. With our mobile backend and custom API’s created, the actual app development can now begin!

 

Creating a Native App

For the next step of my POC, I’ll be creating a simple iOS application that allows me to lookup a Pricing and Availability item and view its properties and warehouse locations. Before firing up Xcode, I need to click the “SDK Downloads” from the MCS Applications page and download the iOS SDK.

 

As I mentioned earlier, the SDK will allow me to make MCS API calls with one or two lines of code. In order to take advantage of it I need to add the static libraries and header files from the downloaded SDK to my project in Xcode and properly link them.

 

The SDK download also includes an “OMC.plist” file that will need to be added to my project. The OMC.plist will hold the settings that are needed to connect to our Pricing and Availability mobile backend. The Settings tab of the Pricing and Availability backend in MCS has several of the items we need. Since we’re using basic authentication, we need to get the Mobile Backend ID, Anonymous Key, and the Base URL of our MCS environment.

 

We’ll also need the application key we were provided earlier after creating our mobile client. After adding these items to the OCM.plist, the initial MCS setup of our project is complete.

 

When a user runs my app, the first thing they will need to do is login. I put together a basic login screen with username and password fields.

 

When a user taps the Login button I simply need to authenticate against my mobile backend with these three lines of code:

 

If no error is returned then the authentication is successful and I can dismiss my login screen. My user will then be presented with my search screen which simply contains a table view with a search bar at the top.

This is the point where we utilize the Pricing and Availability custom API that we previously configured. When a user enters a Pricing and Availability Item’s ID and taps the search button I’ll need to make a GET call to the /pricingandavailabilityitem/{id} endpoint in order to return the matching item. Once again, this can be handled with a few lines of code:

 

The response is then parsed and a result row is added to my table view.

 

Tapping on the result row will bring the user to my item details screen where the Pricing and Availability item’s properties are displayed. I also want to display the warehouse locations for my item on the details screen so I make a similar second call to the pricingandavailabilityitem/{id}/pricingandavailabilityitemlocation endpoint and populate the results in another table view.

 

At this point I have successfully achieved the goal of displaying EBS form information on a mobile device! As you can see, the amount of effort required to authenticate and retrieve the data was minimal, whereas without MCS those tasks would have consumed a large percentage of my time.

 

Creating a MAX App

While the iOS SDK may have made my app development seem fairly effortless, MCS actually provides an easier way for me to achieve my goal. On the MCS Applications page, there is a Mobile Apps section that takes you to the Mobile Application Accelerator (MAX) application.

 

With the MAX application, it is possible to quickly put together a mobile app with absolutely no coding involved. With its drag-and-drop web interface, non-technical business users can easily login and build their own mobile apps in minutes.

Let’s take a look at building the same POC as a MAX application. Clicking the “New Application” button will take you through a simple app creation wizard.

 

After providing your app name and choosing your screen layout you will be presented with a blank home screen where you can drag and drop UI elements onto various content areas. Just like the native app, my MAX app will first present the user with a search screen that will display Pricing and Availability Item search results. To handle this, I’ll be adding a list element onto my home screen and enabling its search option which will automatically add a search field to the top of it.

 

Next we’ll need to indicate what data will be populated in our list element. Clicking “Add Data” will allow you to map any UI element to a data source. Choosing a data source is as simple as selecting the Pricing and Availability Item resource from our custom API. Our MAX app will automatically use the appropriate API calls to retrieve our data. We can then drag and drop properties from our Pricing and Availability resource onto each of the four available search result row labels to be displayed. I chose to use the Item Description, Item Type, Unit Pricing, and Pricing currency fields.

 

Since our Pricing and Availability Item API call requires an ID parameter we indicate that the list element’s search field will be the source.

 

Our search page now has what it needs to lookup a Pricing and Availability Item.

 

In order to see the details of a Pricing and Availability item, we will need to provide an action on the list element’s action tab. After clicking the Actions tab, another drag and drop interface allows us to indicate that when a list item is tapped, we will be taken to a new Pricing and Availability item detail screen.

 

In addition to displaying the Pricing and Availability item properties, I also want the new Pricing Item Detail page to display the warehouse locations. To handle this, when creating my details screen I choose the “Screen with Top Tabs and Summary” page template and specify three separate tabs: Overview, Quantities, and Warehouses. For each of the tabs, I follow the same process of dragging UI elements onto the content areas and mapping a data source to them. My Overview tab gets a form UI element that displays my Pricing and Availability Item’s properties. The Warehouses tab gets a list element that displays a list of all warehouse locations for the pricing item.

For the Quantities tab, I wanted to demonstrate a nice feature of MCS with the use of a bar chart to easily view the item quantities at each warehouse. I simply drag a bar chart UI element onto the tab and map the data source to my Pricing and Availability Item Locations resource with the warehouses along the X-Axis and the quantities along the Y-axis.

 

With our app complete, testing it out is as easy as hitting the test button. An iOS or Android simulator will run right in your browser.

 

Testing on or publishing to a mobile device isn’t that much more complicated. Once you install Oracle’s Mobile Application Accelerator client app on your device, you can easily add your MAX apps as “apps within an app” via a QR code. Avoiding time consuming app publishing processes means business users can get the tools they need with a few clicks.

 

Compared to native app development, the MAX app was created in a fraction of the time, and as you can see, no coding was involved. As easy as it was to build my POC, MAX has its limitations. Screens can be easily setup to search, view, add, edit, and delete business objects, but beyond that, you might need to get creative. Developing the right custom API for my Pricing and Availability app could make it possible to submit an item purchase, but the overall user experience will be limited. For more flexibility, native and hybrid apps will still have their place.

 

Conclusion

Overall, my POC just scratches the surface of what MCS can do. With the platform API’s providing database & content storage capabilities, push notifications, offline syncing, and built-in analytics, most of the things mobile apps require are readily available without having to worry about backend hardware and software. Having the ability quickly to assemble these platform API calls into custom API’s that can be reused across many mobile backends means that MCS has the potential to easily bring many aspects of a business to mobile devices.

By utilizing the MCS SDK’s, many of the common tasks of mobile app development that had previously been significant technical hurdles now become minor steps handled with a few lines of code. Considering the amount of effort that some of these common tasks required in my previous mobile projects, I believe MCS could have cut my development time in half. Realistically, organizations could have a mobile app in production use within a matter of hours. Being able to realize such quick time to value with a mobile app is definitely a key value proposition of MCS, so if that is important to your organization I recommend you give MCS a try.

The post Accelerated Mobile App Development with Oracle Mobile Cloud Service – Part 2 appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Accelerated Mobile App Development with Oracle Mobile Cloud Service – Part 1

Part 1: MCS Mobile Backends

The past decade has seen a steady rise in the use of mobile applications across nearly all industries. At Fishbowl Solutions, we have played a part in this trend by developing a series of Android and iOS apps that allow users to easily access their Oracle WebCenter content from their phones and tablets.

In my experience with mobile app development, I have found that a vast majority of development effort is spent on the same common tasks:

  • Writing code involving interaction with the backend server such as authentication & authorization
  • Retrieving & storing data
  • Synching content locally to devices for offline use
  • Sending push notifications across multiple device platforms.

These tasks always take a lot more effort than expected and tend to feel like I am reinventing the wheel. Even after the initial development, periodic changes to the backend server often require updated versions of the apps to be pushed through time-consuming publishing processes.

Time spent on these basic tasks is time that could be better spent adding additional features and creating a better user experience. Because of this, I was excited to learn that Oracle’s Mobile Cloud Service could be the solution to these problems.

What is Oracle Mobile Cloud Service?

Oracle Mobile Cloud Service (MCS) is a cloud service that provides a set of tools to support enterprise-wide mobile development. It allows quick creation and deployment of the back-end services your apps require without the initial hardware and software setup. With a small amount of configuration, any of these back-end services can be made available to your apps via REST API calls.

To handle features required by most apps, MCS includes the following built-in “Platform API’s”:

  • Authentication & Authorization
  • Database Storage
  • Content Storage
  • Push Notifications
  • Analytics
  • Offline Data & Synching
  • Mobile User Management

Having to configure all of these features on your own server would be a daunting task and likely set you back days or even weeks, but MCS provides the capabilities out of the box within minutes.

In addition to these platform API’s, MCS allows custom API’s to be quickly developed in NodeJS to create additional back-end services. With a few lines of JavaScript, additional calls to any of the Platform API’s or external services can be made allowing you to provide the exact functionality required by your mobile apps.

After your API’s are configured, MCS provides downloadable SDK’s for Android, iOS, Cordova (JavaScript), and Windows. Embedding these SDK’s in your code allows MCS API’s to be called with one or two lines of code compared to the many lines of code that would be required to make the API call manually.

MCS Mobile Backend Setup

I decided to try out MCS by creating a small proof-of-concept or POC. One of the problems Fishbowl customers face is accessing forms from Oracle E-Business Suite (EBS) on mobile devices, so I decided that the end goal for my POC would be to view the Pricing and Availability form in EBS on a mobile device.

 

Here is a simplistic view of this business challenge:

 

As a legacy application, EBS has no API of its own. To get around this we decided to enlist the help of a tool called AuraPlayer. AuraPlayer has the ability provide web services that allow us to externally interact with EBS forms. I’m not going to cover the AuraPlayer details in this blog, but the important thing to know is that after setting up the AuraPlayer services, I can now make a request to <AuraPlayerBaseURL>/PricingAndAvailability_queryByLabel?Item=AS18947 and receive a JSON response containing a list of my AS18947 pricing and availability item’s form fields from EBS along with a list of warehouse locations where the item is in stock.

Once the AuraPlayer services to EBS are configured my Pricing and Availability data is one step closer to reaching my mobile app:

 

At this point we’re now ready to setup MCS in order to fill the gap in the process. Our final configuration will look like this:

 

Any mobile application connecting to MCS will first and foremost require a Mobile Backend. Mobile Backends are MCS objects that group together a specific set of API’s along with the client applications and the set of users who will utilize them. In this scenario, I need to create a “Pricing and Availability” mobile backend that exposes a custom “Pricing and Availability” API to my mobile app. Since my Pricing and Availability API needs to make calls to the AuraPlayer services which are outside of MCS, I will also need to create a Connector. Connectors are MCS objects that provide access to external REST and SOAP API’s. Next, in order for my mobile application to access the mobile backend I will need to register my mobile application by setting up a Mobile Application Client. The last item needed is a test user who will have access to the mobile backend and the API. To summarize – labeled above:

  1. Create a mobile backend for “Pricing and Availability”
  2. Create a Pricing and Availability custom API
  3. Create AuraPlayer connector
  4. Register my app by setting up Mobile Application Client
  5. Set up a test user

Let’s now walk through the setup process in MCS.

 

After logging into the MCS interface, we first need to click on “Mobile Backends” and create a new mobile backend called “PricingAndAvailabilityBackend”.

 

With our new mobile backend created, the first thing we need to do is create at least one user who can access the backend. This can be done by clicking on the Users tab. In MCS, all mobile backends are associated with one User Realm. User Realms are sets of users that can either be managed directly in MCS or configured to connect to your company’s SSO. In our case, we will just create a new user called “testuser” under the default realm. Now that we have our test user, we can create our new Pricing and Availability custom API. When clicking on the API’s tab we see the message indicating that we don’t have any API’s selected, but before we create one we first need to create our AuraPlayer connector.

 

A new connector can be created by going to Applications > Connectors and clicking “New Connector”. In the connector setup wizard, I named it “AuraPlayerConnector” and provided the base service URL where the AuraPlayer REST services are accessed.

 

The Rules page of the Connector wizard allows any default parameters to be specified. Since all of my service calls to AuraPlayer have several required parameters I added them here.

 

The last step in the Connector wizard allows the connector to be tested. I provided the /PricingAndAvailability_queryByLabel?Item=AS18947 service URL I mentioned earlier that should return a pricing & availability item from EBS.

 

Since a connector must run under a mobile backend as a specific user, I select my backend and enter my test user’s credentials. I then click “Test Endpoint” and after receiving my expected JSON response I conclude that my AuraPlayer connector is configured correctly!

 

Our next task is to create the custom Pricing and Availability API that will utilize the newly created AuraPlayer connector. Going back to the mobile backend’s API tab we can now click the “New API” button. After providing the name of the API, the first thing to do is specify our available endpoints via the Endpoints tab. Clicking “New Resource” lets you add an Endpoint. I initially add two endpoints. One returns a collection of all pricing and availability items with a resource path of:

/pricingandavailabilityitem

The other returns a specific pricing and availability item with a resource path of:

pricingandavailabilityitem/{id}

where {id} is the item number in EBS.

Since my AuraPlayer services can also return a pricing and availability item’s warehouse locations, I decided to create two more endpoints underneath the pricingandavailabilityitem/{id} endpoint. This is done by clicking that endpoint’s “Add Nested Resource” icon. I create one endpoint that returns all pricing and availability item locations for a given item with a resource path of:

pricingandavailabilityitem/{id}/pricingandavailabilityitemlocation

I then create another endpoint that returns a specific pricing and availability item location for a given item with a resource path of:

pricingandavailabilityitem/{id}/pricingandavailabilityitemlocation /{pricingandavailabilityitemlocation_id}

 

For each endpoint created, I specify display names, descriptions, and available methods. For my initial POC, I’ll really only need GET methods.

 

With our endpoints defined, we now need to implement their behavior. MCS custom API’s are written in NodeJS using the ExpressJS framework. By clicking on the Pricing and Availability API’s Implementation tab, you can see a “JavaScript Scaffold” button which allows you to download a pre-built NodeJS project with each of your API’s endpoints already stubbed out for you.

 

After downloading the scaffold package the main file needing to be edited is the pricingavailabilityapi.js file.

 

In this file, each route will need to be implemented. Since my Pricing and Availability API is simply calling my AuraPlayer connector there won’t be a whole lot of work to be done. For my /pricingandavailabilityitem/{id} route, I basically need to do three things:

  1. Get the Pricing and Availability item’s “{id}” parameter from the request object.
  2. Use my connector to make a GET call to AuraPlayer specifying the “PricingAndAvailability_queryByLabel” resource and the id parameter.
  3. Extract the required elements from the AuraPlayerConnector results and return them in the API response.

 

Aside from building out each of my routes, the other important change is to add my API and connector dependencies in the package.json file.

 

Once that is taken care of, simply package up the files and upload them on the API’s Implementation tab.

 

With our Pricing and Availability API finished, our mobile backend is almost complete. As I mentioned earlier, in order for our mobile application to access the mobile backend we will need to register it on the PricingAndAvailabilityBackend Clients tab by clicking “New Client”.

 

A client is easily created by specifying the client name, platform, app version, and the bundle ID. Once the client is created you will be presented with an application key that will be needed when we build our app.

 

That’s basically it for our MCS setup. Within a few hours, my mobile app has what it needs to access the Pricing and Availability forms in EBS.

 

While MCS will prove to be valuable at quickly providing your backend services, it also provides the tools to save time on our front-end app development. In part 2, I will continue my POC by creating the mobile app that will access the newly created MCS mobile backend.

 

Next: Accelerated Mobile App Development with Oracle Mobile Cloud Service – Part 2

The post Accelerated Mobile App Development with Oracle Mobile Cloud Service – Part 1 appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Using Cloud Foundry CUPS to inject Spring Security credentials into a Spring Boot Application

Pas Apicella - Thu, 2017-09-14 18:48
The following demo shows how to inject the Spring Security username/password credentials from a User Provided service on PCF, hence using the VCAP_SERVICES env variable to inject the values required to protect the application using HTTP Basic Authentication while running in PCF. Spring Boot automatically converts this data into a flat set of properties so you can easily get to the data as shown below.

The demo application can be found as follows

https://github.com/papicella/springsecurity-cf-cups

The application.yml would access the VCAP_SERVICES CF env variable using the the Spring Boot flat set of properties as shown below.

eg:

VCAP_SERVICES

System-Provided:
{
 "VCAP_SERVICES": {
  "user-provided": [
   {
    "credentials": {
     "password": "myadminpassword",
     "username": "myadminuser"
    },
    "label": "user-provided",
    "name": "my-cfcups-service",
    "syslog_drain_url": "",
    "tags": [],
    "volume_mounts": []
   }
  ]
 }
}
...

application.yml

spring:
  application:
    name: security-cf-cups-demo
security:
  user:
    name: ${vcap.services.my-cfcups-service.credentials.username:admin}
    password: ${vcap.services.my-cfcups-service.credentials.password:password}
Categories: Fusion Middleware

Oracle 12c Service Broker for Pivotal Cloud Foundry

Pas Apicella - Thu, 2017-09-14 00:21
The following example is a PCF 2.0 Service Broker written as a Spring Boot application. This is just an example and should be evolved to match a production type setup in terms oracle requirements. This service broker simple creates USERS and assigns then 20M of quota against a known TABLESPACE

It's all documented as follows

https://github.com/papicella/oracle-service-broker




Categories: Fusion Middleware

Digital Transformation Instead of Technology Evolution: Cox Enterprises’ Digital Workplace Success with Oracle WebCenter Portal

WebCenter portal devicesIn 2014, Fishbowl Solutions engaged with Cox Enterprises to build its employee digital workplace. Prior to that engagement, Fishbowl delivered numerous employee, customer, and partner portals/intranets, but this was our first project where the word portal wasn’t being used to describe what Cox Enterprises would be building and delivering to its employees. Instead, the phrase “digital workplace” detailed how Cox envisioned a consumer-like digital experience that promoted collaboration, sparked innovation, and helped employees get their jobs done – regardless of time, space, or device.

Now neither the term nor concept of a digital workplace was new in 2014. Tech vendors and analysts had been discussing such a workplace environment since around 2008, but you may may remember it being called Enterprise 2.0. What stands out to me regarding Enterprise 2.0 was how much collaboration or social capabilities in the workplace became the focus. Such collaboration capabilities as instant messaging, blogs, wikis, and document sharing were thought to be the catalyst for more information sharing, which would lead to more innovation and better employee engagement. However, the place where all this collaboration was supposed to take place – the employee portal or intranet – did not offer the experience or performance that users needed to get work done. Furthermore, the technology and associated features really drove conversations and platform decisions, and not what users needed from the portal or how they wanted to work.

Contrast the above with how Cox Enterprises decided which portal platform they would use for their employee digital workplace. For them, this started with a focus on the workplace they wanted to provide to their employees. A workplace where employees could collaborate and access relevant information from one system – regardless of device. They invested time and money to learn as much about their eventual portal users (personas) before they decided on the technology with the associated features that could support employee work streams and how they would use the portal.

This focus on the user was part of much larger “digital transformation” initiative the company was undertaking. This initiative really centered on making sure Cox’s 50,000 employees, which are scattered across several divisions and geographic locations, were engaged and informed. To enable this, Cox leaders wanted to provide them with a similar experience to access company, department, and personal information. After doing this persona analysis and user flow mapping, they decided that Oracle WebCenter Portal would be the system for their employee digital workplace. They based their decision on WebCenter Portal’s tight integration with WebCenter Content, which was key for their overall digital transformation initiative to consolidate as much content within one system. They also needed a system that could handle 1,500+ concurrent users, and WebCenter’s underlying architecture, including WebLogic Server and Oracle Database, exceeded their performance metrics.

I encourage you to learn more about Cox’s digital transformation initiative by attending the webinar they are partnering with Fishbowl on next Thursday, September 14th. Come hear from Dave Longacre, one of Cox’s project managers for the digital workplace project, detail the vision, steps, and resulting benefits for Cox’s employee digital workplace. Please click on the link below to register. Also, check out our employee digital workplace page on our website for more resources.

Webinar – How Cox Enterprises Built a Digital Workplace for 50,000 Employees using Oracle WebCenter Portal

The post Digital Transformation Instead of Technology Evolution: Cox Enterprises’ Digital Workplace Success with Oracle WebCenter Portal appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Introducing Pivotal MySQL*Web, Pivotal’s New Open Source Web-Based Administration UI for MySQL for Pivotal Cloud Foundry

Pas Apicella - Sun, 2017-09-03 20:13
Recently Pivotal announced "Pivotal MySQL*Web" on it's main blog page. You can read more about it here which was an Open Source project I created a while ago for Pivotal MySQL instances on Pivotal Cloud Foundry

https://content.pivotal.io/blog/introducing-pivotal-mysql-web-pivotal-s-new-open-source-web-based-administration-ui-for-mysql-for-pivotal-cloud-foundry


Categories: Fusion Middleware

Couchbase Service Broker for Pivotal Cloud Foundry

Pas Apicella - Sun, 2017-09-03 19:11
The following example is a PCF 2.0 Service Broker written as a Spring Boot application for Couchbase 4.6.x. This is just an example and should be evolved to match a production type setup in terms of bucket creation and access for created service instances.

It's all documented as follows

https://github.com/papicella/couchbase-service-broker




More Information

https://docs.pivotal.io/tiledev/service-brokers.html
Categories: Fusion Middleware

Upcoming Webinar, “WebCenter Search that Works!” highlights Oracle WebCenter integration with Mindbreeze InSpire

Earlier this month, Fishbowl announced the release of our Oracle WebCenter Content Connector for Mindbreeze InSpire. The Connector enables the Mindbreeze enterprise search appliance to securely index and serve content stored in WebCenter Content. The Connector also allows customers to leverage the Mindbreeze Search App Designer to embed modern search apps directly in WebCenter Content.

As the quantity of unstructured information continues to expand, content management success depends on the ability to find data in a growing information flood. Without search that works, managed content becomes lost content. By integrating Oracle WebCenter with Mindbreeze InSpire you can improve information discovery, increase user adoption, and encourage content reuse through better search.

In our upcoming webinar, we will provide an overview of the Mindbreeze InSpire enterprise search appliance and our integrations with both WebCenter Content and Portal. We’ll cover what a typical implementation looks like and why customers are making the switch. We’ll also discuss the migration path off deprecated Oracle Secure Enterprise Search and Google Search Appliance technologies, and options for adding other sources like SharePoint and network shares.

We hope you’ll join us.

The post Upcoming Webinar, “WebCenter Search that Works!” highlights Oracle WebCenter integration with Mindbreeze InSpire appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

A Fishbowl Success Story: The Benefits of Consolidating Disparate CAD Databases

A large medical device manufacturer wanted to fully integrate their R&D, engineering, and manufacturing organizations. This would allow a more efficient, capable and robust product development system that would help the flow of new, innovative products and never fall short on quality.

One key obstacle was the amount of data scattered across the globe in various PDM, PLM and network folders.  This data needed to be organized and consolidated into a unified system with quality processes that would achieve FDA certification.  This consolidation would enable individuals to access accurate data from any location at any time.  Just from a CAD data perspective, there were 100’s of thousands of Solidworks files across 7+ locations around the world in 4+ PDM/PLM systems plus random network file folders.

The company partnered with Fishbowl to migrate the Solidworks PDM, PLM, CAD systems into their single global Windchill PDMLink system.  A key criterion for them choosing Fishbowl was Fishbowl’s LinkExport and LinkLoader family of products.  LinkExport automates the data extraction from PDMWorks and Enterprise PDM and LinkLoader automates the bulk loading into Windchill.

THE PLAN

The migration plan was to have separate migrations for each location.  Each production migration would be able to be completed over a weekend to minimize business impact (e.g. users would check files into PDMWorks – or whatever – on Friday and then check them out of Windchill on Monday).  This approach spread out the work and lowered risk since each location also needed to comply with quality audits as part of their test and production migration passes.

RESULTS

Fishbowl successfully executed 7 migrations that consisted of 100,000+ files total.  60,000+ files came from five separate Enterprise PDM and PDMWorks systems and another 40,000+ files from network file folders.  All data was bulk loaded into a single Windchill PDMLink and each migration was completed over a weekend so minimal disruption occurred.  The project ROI was less than 6 months, and the increase efficiencies and innovation have resulted in huge corporate gains.

 

Contact     Rick Passolt for more information on LinkLoader and LinkExport
Webinar: Automate and Expedite PTC Windchill Bulk Loading

 

Date: August 17th, 2017

Time: 1:00-2:00pm CST

Speaker: Rick Passolt – Senior Account Executive

Register

The post A Fishbowl Success Story: The Benefits of Consolidating Disparate CAD Databases appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Global Financial Services Company Leverages Oracle WebCenter Content for Compound Document Management to Support Underwriting Memo Application

For this week’s case study, our featured customer, a global financial services company, came to Fishbowl looking to replace their current system they had for composing financial underwriting documents. The company’s existing system was 15 years old but had since been sold and left to languish among its customers. Additionally, as the tool had not been updated it was becoming vastly more difficult to use and maintain in a fast-paced environment. Then, our client looked into creating a custom underwriting memo application on Oracle WebCenter Content with Fishbowl.

Working together, our client and the Fishbowl Solutions product development team worked to build, test, and deploy a new solution to create a modern system with Oracle WebCenter Content. The collaboration between Fishbowl and our featured client proved its success as WebCenter’s content management capabilities and user interface elements reduced credit memo application processing time by 25%.

 

BUSINESS DRIVERS
  • Reduce underwriting process time to enable faster transactions
  • Replace inefficient and archaic system for composing financial underwriting documents
  • Integrate and assemble all content needed for underwriting process to users of current credit application software
  • Ensure content needed for underwriting memo application is securely managed yet highly available
SOLUTION SUMMARY
  • Fishbowl configured Oracle WebCenter Content to manage all content needed for underwriting memo application
  • Integrated Fishbowl’s Compound Document Assembly within company’s credit underwriting system
  • Underwriting memo presented as chapters which include risk factors, business description, operating risk, etc.
  • Compound Document Assembly collates documents and includes non-text elements such as spreadsheets
  • Users can check in/check out the documents and their sections directly from underwriting memo application
  • Users can edit a section of the underwriting memo while another user edits a different section
  • Document structures can be viewed as tabs allowing users to quickly and easily navigate from one report to another
  • Users receive notifications related to any work within system
  • All changes tracked within underwriting memo and versions stored in Oracle WebCenter
CUSTOMER BENEFITS
  • Content management capabilities and user interface elements reduced credit memo application processing time by 25%
  • Content publishing time greatly reduced providing quicker reviews and increased collaboration for underwriting team
  • Documents can be collated and printed for reporting purposes

The post Global Financial Services Company Leverages Oracle WebCenter Content for Compound Document Management to Support Underwriting Memo Application appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Upgrading to Oracle WebCenter Content or Portal 12c: If not now, when?

Fishbowl Solutions will be kicking off a webinar series starting next Thursday, August 3rd. Our first webinar topic will be “5 Key Reasons to Upgrade to Oracle WebCenter Content or Portal 12c”. Why did we pick this topic, and why is this topic relevant now? Those are both good questions, especially if you are a well-informed WebCenter customer and you know that 12c was released almost 2 years ago.

To answer those questions, please let me start by stating that Fishbowl Solutions has performed many WebCenter upgrades over the years. While each one may have been different in size and scope, we have seen some common reasons/themes emerge from what drove customers to start their upgrade when they did.

Why upgrade to WebCenter 12c Now?
  • Get Current with Support and Maintenance
    • Premier and Extended support for 10g customers has elapsed. Most of the customers we talk to know this, but they might not know that they can do an upgrade directly from 10g to 12c. When you consider that Premier support for WebCenter Content and Portal 11g elapses in December of 2018, it makes sense to go directly to 12c instead of 11g. You can review Oracle’s Support Policies for Fusion Middleware here.
  • Explore Cloud Options for Content Management
    • With the release of 12c, Oracle introduced ways to integrate and share content between Oracle WebCenter on premise and the Oracle Content and Experience Cloud. This provided an easy way for organizations to share and collaborate on documents. If your organization is still deciding on your roadmap for content management – on premise, hybrid, cloud first – 12c provides the capabilities to explore use cases for the cloud while maintaining your content on premise.
  • Content and System Consolidation
    • Some legacy WebCenter customers come to the realization that they have too many instances of the system in place, as well as disparate/duplicate content being managed. Instead of trying to audit each one of their individual systems and fix or change any metadata issues, security groups, etc., they decide that doing an upgrade rectifies a lot of these problems, and enables them to get rid of content no longer needing management or retention.
  • Growing List of Environment & Technology Dependencies
    • Perhaps your organization wants to move the latest version of Oracle Database, but you can’t because your legacy WebCenter system utilizes an older version. Unless you upgrade WebCenter, your organization as a whole may be impacted by not being able to utilize the newest version of associated or dependent technologies.
  • User Expectations – Better User Experience
    • WebCenter Content and Portal 12c provide a better user experience for users and administrators. Since organizations want everyone to experience these better interfaces, they start to consider who the actual users of the system are, and they build an experience designed for each of those user personas. So while the upgrade to 12c would have improved the overall experience, organizations use the upgrade to design the best experience possible to ensure widespread adoption and overall use.

We will discuss each of these in more detail during the webinar next Thursday. You can find more information and register for the webinar here.

We hope you can join us.

 

The post Upgrading to Oracle WebCenter Content or Portal 12c: If not now, when? appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Accessing Pivotal Cloud Foundry droplet file system when "cf ssh" isn't enabled

Pas Apicella - Thu, 2017-07-27 00:03
In order to view your application layout you can simply use "cf ssh" to log into the container and then view the files created as part of the droplet. The problem is "cf ssh" isn't always enabled bye the Ops team so what is your alternative in cloud foundry?

You can use "cf curl" to invoke an endpoint using the application GUID as shown in the steps below.

** cf ssh demo **

pasapicella@pas-macbook:~/temp/droplets$ cf ssh pas-swagger-demo
vcap@ef9e4e93-0df9-47a7-5351-dccf:~$ ls -lartF
total 16
-rw-r--r-- 1 vcap vcap  675 Apr  9  2014 .profile
-rw-r--r-- 1 vcap vcap 3637 Apr  9  2014 .bashrc
-rw-r--r-- 1 vcap vcap  220 Apr  9  2014 .bash_logout
drwxr-xr-x 2 vcap vcap    6 Jun 14 03:32 deps/
drwxr-xr-x 1 vcap root   72 Jun 14 03:32 app/
-rw-r--r-- 1 vcap vcap 1087 Jun 14 03:32 staging_info.yml
drwxr-xr-x 2 vcap vcap    6 Jun 14 03:32 logs/
drwx------ 1 vcap vcap   76 Jun 14 03:32 ./
drwxr-xr-x 1 root root   18 Jul 26 23:45 ../
drwxr-xr-x 4 vcap vcap   92 Jul 26 23:48 tmp/
vcap@ef9e4e93-0df9-47a7-5351-dccf:~$

** Steps **

1. Download droplet as follows

Format:

   cf curl /v2/apps/`cf app {appname} --guid`/droplet/download > droplet.tar.gz

Example:

pasapicella@pas-macbook:~/temp/droplets$ cf curl /v2/apps/`cf app pas-swagger-demo --guid`/droplet/download > droplet.tar.gz

To determine the app name you can either use Applications manager UI or use "cf apps" to get the app name


2. This will take some time due to the size of the droplet but when done verify you have this on the file system

pasapicella@pas-macbook:~/temp/droplets$ ls -la
total 150736
drwxr-xr-x   3 pasapicella  staff       102 Jul 27 14:20 .
drwxr-xr-x  23 pasapicella  staff       782 Jul 27 14:19 ..
-rw-r--r--   1 pasapicella  staff  77173173 Jul 27 14:23 droplet.tar.gz

3. Gunzip followed by tar -xvf and you will then have a file system replicator of what your application droplet looks like in CF

pasapicella@pas-macbook:~/temp/droplets$ d
total 313408
drwxr-xr-x   2 pasapicella  staff         68 Jun 14 13:32 deps/
drwxr-xr-x   6 pasapicella  staff        204 Jun 14 13:32 app/
drwxr-xr-x   2 pasapicella  staff         68 Jun 14 13:32 tmp/
-rw-r--r--   1 pasapicella  staff       1087 Jun 14 13:32 staging_info.yml
drwxr-xr-x   2 pasapicella  staff         68 Jun 14 13:32 logs/
drwxr-xr-x  23 pasapicella  staff        782 Jul 27 14:19 ../
-rw-r--r--   1 pasapicella  staff  160460800 Jul 27 14:23 droplet.tar
drwxr-xr-x   8 pasapicella  staff        272 Jul 27 14:25 ./


You really only want to do this to see how your application was staged on the file system as the buildpack may have changed some files or added files based on what you deployed. This is not how you would debug an application but rather view what the file system looks like for your application itself and what content exists in the files should the buildpack have changed file content for example.

Categories: Fusion Middleware

Pivotal Cloud Foundry Isolation Segments Applications demo

Pas Apicella - Mon, 2017-07-24 00:16
PCF Isolation Segments Tile allows operators to isolate deployment workloads into dedicated resource pools called isolation segments. You can read more about how to install the Tile at the following location.

https://docs.pivotal.io/pivotalcf/1-11/opsguide/installing-pcf-is.html

In this demo I will show how you can configure your ORGS/spaces to use an isolation segment and then finally show that it is indeed using the isolated Diego Cells assigned to the segment tile at install time.

1. Determine the isolation segment name as per the Ops Manager title



2. Ensure you have CF CLI version as 6.26 or higher as shown below

pasapicella@pas-macbook:~$ cf --version
cf version 6.28.0+9e024bdbd.2017-06-27

3. First, you need to register an Isolation Segment with the cloud controller.

Note: you will need a prividledged user such as admin to perform this task

$ pasapicella@pas-macbook:~$ cf create-isolation-segment segment1
Creating isolation segment segment1 as admin...
OK

4. After registering the Isolation Segment, you can associate it with an Org

pasapicella@pas-macbook:~$ cf enable-org-isolation pas-org segment1
Enabling isolation segment segment1 for org pas-org as admin...
OK

5. List isolation segments against targeted ORGS as follows

pasapicella@pas-macbook:~$ cf isolation-segments
Getting isolation segments as admin...
OK

name       orgs
shared
segment1   pas-org

6. After associating an Isolation Segments with an Org, you then set it on a Space

- First target the ORG you wish to use

pasapicella@pas-macbook:~$ cf target -o pas-org
api endpoint:   https://api.yyyy.pcfdemo.yyy
api version:    2.82.0
user:           admin
org:            pas-org
No space targeted, use 'cf target -s SPACE'

- Now set the isolation segment on your desired space

pasapicella@pas-macbook:~$ cf set-space-isolation-segment isolation-segment-space segment1
Updating isolation segment of space isolation-segment-space in org pas-org as admin...
OK

In order to move running applications to this isolation segment, they must be restarted.

7. Log in as a user of the ORG/SPACE now rather then ad admin user. We will be using a
non privileged user now to push our app who has access to the ORG/Space we targeted
above. Below just shows we have switched to a different user here.

pasapicella@pas-macbook:~$ cf target
api endpoint:   https://api.yyyy.pcfdemo.yyy
api version:    2.82.0
user:           pas
org:            pas-org
space:          isolation-segment-space

8. Push an application to the space "isolation-segment-space"

pasapicella@pas-macbook:~/piv-projects/PivotalSpringBootJPA$ cf push -f manifest-inmemory-db.yml
Using manifest file manifest-inmemory-db.yml

Creating app pas-albums in org pas-org / space isolation-segment-space as pas...
OK

....

0 of 1 instances running, 1 starting
0 of 1 instances running, 1 starting
1 of 1 instances running

App started


OK

...


     state     since                    cpu      memory           disk           details
#0   running   2017-07-24 02:33:38 PM   225.3%   330.1M of 512M   162.8M of 1G

9. Identify IP address of diego CELL the app is running in

pasapicella@pas-macbook:~/piv-projects/PivotalSpringBootJPA$ cf curl /v2/apps/$(cf app pas-albums --guid)/stats | jq '.[].stats.host'
"10.10.10.71"

With this information you can verify the IP address of the Diego Cells you have for the Isolation Segment as follows using Pivotal Ops Manager Tile tabs. From the images below it's clear 10.10.10.71 is a diego cell IP address of our isolation segment.





More Information


Categories: Fusion Middleware

Protecting Financial Data with Oracle WebCenter and Adobe LiveCycle

For over 15 years, Oracle WebCenter has been used by organizations to store, manage, and retain their high-value content. During that time, Fishbowl has helped customers leverage the system to solve many common and unique content management problems. We want to share some of those success stories with you, with the hope that they will help you form new ideas on how to further leverage WebCenter in your organization. Starting today, we will be publishing an “Oracle WebCenter case study of the week “. These case studies will highlight the ways customers are using WebCenter to solve their business problems and drive new process efficiencies.

This week’s customer case study details a global manufacturer of aluminum rolled products. This company came to Fishbowl in search of a solution to make access to payroll information much more available to employees and financial officers, as well as secure the information provided. Fishbowl utilized Oracle WebCenter Imaging & Capture and Adobe LiveCycle to satisfy this content management use case, and also help the customer save around $75,000.

Business Drivers
  • Reduce costly distribution processes involving printing and mailing over 30,000 pages of reports per year.
  • Make access to payroll information much more readily available to employees and financial auditors.
  • Ensure payroll data stored in Oracle WebCenter is highly secure.
Solution Summary
  • Fishbowl implemented WebCenter Capture and Imaging to scan and manage over a dozen types payroll-related reports including payroll closing, direct deposits, W-4s, and garnishments.
  • Imaged documents output to directory where security policies are applied using Adobe Live Cycle’s Information Rights module. This further ensures unauthorized document access.
  • Documents with security information uploaded and stored in existing Oracle WebCenter Content instance and available for viewing by authenticated users.
Oracle WebCenter and Adobe LiveCycle

Document flow from capture with WebCenter to securing content with Adobe Information Rights Mangement.

Customer Benefits
  • Reduced estimated yearly cost of $75,000 to print and mail over 30,000 payroll-related documents.
  • Ensured that sensitive employee data cannot be seen by unauthorized users.
  • Created a much more accessible and simple Payroll processing system to manage and retain the company’s 16,000+ documents.

 

The post Protecting Financial Data with Oracle WebCenter and Adobe LiveCycle appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

The Future of Content Management: Oracle Content & Experience Cloud

What is the Content and Experience Cloud?

Content and Experience Cloud (CEC) is Oracle’s cloud platform solution for content management and delivery. It brings together Oracle’s Documents Cloud Service (Content) and Oracle’s Sites Cloud Service (Experience) to make a centrally managed platform for your business to contribute, collaborate, and share its content. It sets out to solve many of the headaches associated with content management solutions of the past and present, including:

  • Poor user experience
  • Security concerns
  • Limited access to content and collaboration

This can be drawn as a parallel to Oracle’s motto throughout marketing their Documents Cloud Service: “Simple, Secure, Everywhere”.

In this post, I’m going to detail how Content and Experience Cloud meets each of these challenges, describing some of the features available. I’ll also give an overview of some of the custom development efforts I’ve achieved in the past few weeks, and what kind of enterprise applications could be developed using similar approaches.

Solving the Problems with Traditional Content Management Systems – Including Oracle WebCenter.

User Experience – Low user adoption and poor user experience have been major challenges facing legacy content management systems. Oracle Content & Experience Cloud aims to remedy some of these problems in a number of ways.

  • Mobile, tablet, and desktop access:
    • Oracle adopted a mobile-forward design pattern for CEC interfaces to adjust for devices that can be used anywhere.
    • View, edit, and manage files from any of these devices with the applications Oracle has provided. All desktop and mobile application downloads can be found together on the “Download Apps” page of your CEC service interface, while mobile apps can also be found on both major mobile app markets (Android App and iPhone App).
  • Share files or folders simply, with the ability to assign access levels to limit what can be done to the content.
  • Conversations can be started about folders, files, or a separate topic altogether.
    • Annotations can be made on specific parts of a document.
    • Documents can be attached to conversations.
    • Conversations can be accessed from the web, desktop, and mobile apps.
  • Integrations exist out of the box with programs like Microsoft Word and Excel for syncing documents or spreadsheets to the cloud. A UI overlay will appear on the program, visually confirming the document as it syncs to the cloud, and expands to provide users actions like viewing content access history and versions, starting or viewing the document’s conversation, or sharing the document with other members or with anyone by generating public links. Additional actions will also exist in the file menus, allowing users to manage nearly everything about their documents without needing to leave the editor.

Security – A concern of many businesses considering cloud content management is the safety of their files. Oracle secures files through a multi-layered approach.

  • Access to the CEC service requires a username and password managed by a service administrator.
  • Files are encrypted through SSL while in storage and transit to the cloud.
  • Content owners have access control to the content and folders, which can be customized for different tiers of access. Users who are given access to a file in a folder will not have access to the other files that exist within the folder.
  • Service admins have the option to configure virus scans on files upon upload to the cloud. Infected files will be quarantined from the system.
  • Passcodes can be set for mobile devices accessing the cloud. Any files downloaded from the cloud will additionally require authentication to the CEC app in order to be decrypted.
  • Websites can have security applied to control:
    • Individual user/group membership to the published site.
    • Who can see the site when it is (un)published.
    • Who can see or interact with secured content on the site.
  • CEC also include access to analytics, auditing and automatic backups.

Access to Content, and Collaboration – Productivity can suffer when content is difficult to access, or hard to find. Content and Experience Cloud provides availability to content anywhere, with streamlined methods of sharing and collaboration.

  • The CEC interface gives users the ability to rapidly collaborate internally or externally by sharing content with other members, or creating public links to folders or files.
  • Mobile, tablet, and desktop access out of the box allows users to view and manage content on the go.
  • Content can be worked on without internet access, and can be synced to the cloud once you regain connectivity.
  • Workflow and review processes allow content to easily and efficiently get published.
  • Conversations allow users to comment on files, folders, or digital assets (including the ability to highlight and annotate specific areas of text, and attach files to your comments).
Customizing Your Experience

Oracle provides several expanding development resources that can be used to customize sites on CEC. The modular structure of the site components, and use of modern web libraries and frameworks like RequireJS, KnockoutJS, and Mustache templating help streamline the process of site development, and create a more responsive and rich experience for the end user. I’ve developed a couple proof of concept examples which can serve as a stepping stone to custom enterprise components that are either static, or dynamically accessing files housed in the cloud service.

Custom Component #1: Update Static Content without Coding

Using some of Oracle’s development documentation as a base, the first component I created demonstrates the ability to update static page content through custom settings without touching the code. It utilizes the SitesSDK, which provides a set of functions to integrate custom components with the Content and Experience Cloud. These functions are particularly helpful in providing storage and retrieval of custom settings used to configure components on the page.

For example, when the component is first set on the page, it will load the default settings values, and render them to the template. While editing the site, you can access the settings in the dropdown menu located on the top right of the component.

Custom settings were defined for each of the titles and descriptions of the tile elements. By simply updating the input text for each of these fields in the form and pressing enter, the values update immediately on the component within the page. Moreover, when I am happy with the changes I can click “Save” and “Publish”, and those settings will be published to the site and persist for everyone until they need to be changed again. Anyone with permissions to edit the site would be able to update these values in a matter of seconds and publish the changes without any outages. You can see that updating the “Title 1” field to the value “My Title”, and the “Text 1” field to the value “My Description” will update the first tile within the component.

To demonstrate another use of custom settings, I’ve integrated a filepicker that allows the user to navigate files stored in the cloud, and select image to be displayed in the component on the page. Data returned by the SitesSDK can also give us some information on the image, which may be useful depending on the demands of your component. The image, and information about the image will also display immediately on the component so the editor of the site has a preview of the site with the updated component before publishing it to the site for everyone to see.

Custom settings provide a great way to manage elements of a page on your site that occasionally need manual changes, and don’t necessarily need to rely on pulling content dynamically from the cloud or another source. It gives site managers flexibility to make changes on the fly, and keep the site fresh and current for its audience.

Custom Component #2: Browser for Cloud Content

The second component I created utilizes Oracle’s Content Management API to build a content browser which displays previews, information, and actions on content living in the cloud. The API provides multiple endpoints to allow viewing, creating, modifying, and deleting folders and files. It can also retrieve information on users in the system. Oracle is working to extend the number and functionality of these endpoints in future releases.

In the above screenshot, you can see the documents view from the CEC interface, and the files that live in the “images” folder. Below is the screenshot of the custom component which grabs all of this information, and renders it to the site. The data returned in the responses make it possible to call for thumbnails of images and documents, as well as build actions like “View” and “Download” to open the full file on the CEC interface, or download the file respectively. This functionality can be used to create components that grab content dynamically and display it to your site as it is contributed to the cloud.

With an enterprise-level account, content administrators will have the ability to define their own structured content with access to Content Types, Content Items, Content Layouts, and Digital Assets. This allows the design of content specific to your business, and opens the door to develop components like a news feed which filters and displays only news content items in a widget on the page, or a search form which can return content filtered on any number of criteria.

Conclusion & Looking to the Future: Integrating with On-Premise and other Back-Office Applications

Content and Experience Cloud provides an ideal platform for content management in the cloud. It aggregates content, digital assets, conversations, and sites to a single location, where power users can delegate access to the people who need it, anywhere. Surface your content to sites on the cloud using custom components to build an interface that works for your business. Make updates quickly to provide always-current information without modifying site code, or taking the system offline. Oracle continues to improve and expand on the API endpoints and other development materials with future releases.

I will be working to integrate some of Fishbowl Solutions’ SPA taskflows into custom components for display on CEC Sites similar to what I’ve shown in the previous section, except the taskflow code will be hooked into an existing on-premise WebCenter Content instance to serve back content housed in a locally managed database rather than the Document Cloud Service. This will provide options to businesses looking to transition to the cloud service for benefits like site servers being hosted on the cloud, simple site/component management, and near-instant publishing, while still maintaining all the same content on-prem.

Another integration planned for future development is integration with the AuraPlayer service. AuraPlayer provides the ability to wrap existing Oracle Forms/EBS systems as web services which can eventually be surfaced on a Content and Experience Cloud site as a modern, mobile-friendly, responsive UI. With CEC already accessible by tablet and mobile devices, it stands out as a strong platform candidate.

The post The Future of Content Management: Oracle Content & Experience Cloud appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Dark Eyes

Greg Pavlik - Sat, 2017-07-08 12:06
Dark Eyes
(A traditional Russian folk song translated by Greg Pavlik)
The eyes so black, passionate eyes
Fiery eyes, so beautiful!
How I love you - how I fear you!
You know I saw your eyes at the witching hour!

I cannot explain your deep, deep darkness!
I see a mourning within you for my soul,
I see the flame of triumph within you:
it consumes my sorrowing heart.
It does not make me bitter, it does not make me sad,
This my fate, my consolation:
All that is good is a gift from God,
And I sacrifice it all for those fiery eyes!

Original Russian by the Ukrainian poet and writer Yevhen Hrebinka.
1.
Очи чёрные, очи страстные,
Очи жгучие и прекрасные!
Как люблю я вас, как боюсь я вас!
Знать, увидел вас я в недобрый час!
2.
Ох, недаром вы глубины темней!
Вижу траур в вас по душе моей,
Вижу пламя в вас я победное:
Сожжено на нём сердце бедное.
3.
Но не грустен я, не печален я,
Утешительна мне судьба моя:
Всё, что лучшего в жизни Бог дал нам,
В жертву отдал я огневым глазам!

The river floes break in spring... take 2

Greg Pavlik - Sun, 2017-06-18 16:19
Alexander Blok
The river floes break in spring...
March 1902
translation by Greg Pavlik 



The river floes break in spring,
And for the dead I feel no sorrow -
Toward new summits I am rising,
Forgetting crevasses of past striving,
I see the blue horizon of tomorrow.

What regret, in fire and smoke,
the lament of the cross,
With each hour, with each stroke -
Or instead - the heavens’ gift stoked,
from the bush burnt without loss!

Original:

Весна в реке ломает льдины,
И милых мертвых мне не жаль:
Преодолев мои вершины,
Забыл я зимние теснины
И вижу голубую даль.

Что сожалеть в дыму пожара,
Что сокрушаться у креста,
Когда всечасно жду удара
Или божественного дара
Из Моисеева куста!
 
Март 1902
Translators note: I updated this after some reflection. The original translation used the allegorical imagery that would have been common in patristic writing and hence Russian Orthodoxy. For example, I used the image of Aaron's rod in lieu of the word "cross", which appears in Russian (креста). The rod of Aaron was commonly understood to be a type of the cross in traditional readings of Old Testament Scriptures. Similarly, the final line of Blok's poem "Из Моисеева куста" literally translates to "from Moses's Bush". In my original translation, I rendered the final line "from the bush of Moses, the Mother of God". Since at least the 4th century, the burning bush was interpreted as a type of Mary, the Theotokos (or God-bearer) in the patristic literature (see for example, Gregory of Nyssa, The Life of Moses). In Russian iconography there is even an icon type of the Mother of God called the Unburnt Bush. While the use of "rod" and "Mother of God" allowed me to maintain the rhyme pattern (rod/God in place of креста/куста) of the original poem, it created a awkward rhythm to the poem, especially in the final line. It also added explicit allusions to patristic images that are not explicitly present in the original poem, perhaps fundamentally altering the author's intention. A neat experiment but also one that I think ultimately failed.

The new translation returns to a more literal translation without allegory: "
креста" means simply cross and that is how the poem now reads. The final line has been abbreviated from my original translation, though somewhat less literal - "Из Моисеева куста" is now rendered as "from the bush burnt without loss" rather than the literal "from Moses's bush" or the more awkward original translation "From the Bush of Moses, the Mother of God". The new translation I believe captures more closely the original meaning and manages to maintain at least the rhyme pattern of the original (now cross/loss in place of креста/куста). Overall, this is far from a perfect translation but I think it is an improvement.
One final comment about Blok himself that perhaps illustrates why I am still conflicted about the changes to final line: Blok was a master of the Symbolist movement in Russian poetry, wherein he worked unconventional rhythms and rhyming into his poetry. On that score, I feel somewhat more at liberty to ignore the meter of the original and attempt to express something of a musical quality in English. However, Blok was also deeply influenced by the great philosopher Vladimir Soloviev, a proponent of Sophiology in the Russian intellectual tradition. This led to him writing many of his early poetic compositions about the Fair Lady, Sophia the embodiment of Wisdom. It is with this in mind that I feel some regret at removing the reference to the Mother of God, a human embodiment/enhypostatization of Divine Wisdom.

Swagger UI with Spring Boot 1.5.x

Pas Apicella - Tue, 2017-06-13 23:00
I recently created this demo / blog entry on using HTTPIE with Spring Boot Rest Repositories as shown below.

http://theblasfrompas.blogspot.com.au/2017/05/using-httpie-with-spring-boot-rest.html

I decided to take that same example and add Swagger UI to the RESTful endpoints. The full source code is here.

https://github.com/papicella/httpie-springboot

In short what you need is the following maven dependancies and that will add all you need. I found it works much cleaner if you use the same version of both these dependancies for some reason
  
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.6.1</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.6.1</version>
</dependency>

Finally a Class file describing the config and enabling Swagger is required as follows
  
package pivotal.io.boot.httpie.demo;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

import static springfox.documentation.builders.PathSelectors.regex;

@Configuration
@EnableSwagger2
public class SwaggerConfig
{
@Bean
public Docket swaggerSpringMvcPlugin() {
return new Docket(DocumentationType.SWAGGER_2)
.select()
.apis(RequestHandlerSelectors.basePackage("pivotal.io.boot.httpie.demo"))
.paths(regex("/api/employee/emps.*"))
.build()
.apiInfo(metaData());
}

private ApiInfo metaData() {
ApiInfo apiInfo = new ApiInfo(
"Spring Boot Employee REST API",
"Spring Boot Employee REST API",
"1.0",
"Terms of service",
new Contact("Pas Apicella", "https://www.blogger.com/profile/09389663166398991762", "papicella@pivotal.io"),
"Apache License Version 2.0",
"https://www.apache.org/licenses/LICENSE-2.0");
return apiInfo;
}
}

The GitHub repo also included a Pivotal Cloud Foundry manifest.yml file to make it easy to deploy to Pivotal Cloud Foundry. The example uses a static hostname BUT can easily be changed to use a random-route or alter the hostname itself.

applications:
- name: pas-swagger-demo
  memory: 1G
  instances: 1
  hostname: pas-swagger-demo
  path: ./target/httpie-springboot-0.0.1-SNAPSHOT.jar
  env:
    JAVA_OPTS: -Djava.security.egd=file:///dev/urando

Then it's the simple "cf push"

$ cf push

pasapicella@pas-macbook:~/piv-projects/httpie-springboot$ cf push
Using manifest file /Users/pasapicella/piv-projects/httpie-springboot/manifest.yml

Creating app pas-swagger-demo in org apples-pivotal-org / space development as papicella@pivotal.io...
OK

Creating route pas-swagger-demo.cfapps.io...
OK

..

Showing health and status for app pas-swagger-demo in org apples-pivotal-org / space development as papicella@pivotal.io...
OK

requested state: started
instances: 1/1
usage: 1G x 1 instances
urls: pas-swagger-demo.cfapps.io
last uploaded: Wed Jun 14 03:32:31 UTC 2017
stack: cflinuxfs2
buildpack: container-certificate-trust-store=2.0.0_RELEASE java-buildpack=v3.15-offline-https://github.com/cloudfoundry/java-buildpack.git#a3a9e61 java-main java-opts open-jdk-like-jre=1.8.0_121 open-jdk-like-memory-calculator=2.0.2_RELEASE spring-auto-reconfigur...

     state     since                    cpu      memory         disk           details
#0   running   2017-06-14 01:33:40 PM   291.5%   510.9M of 1G   154.9M of 1G


The application is running on Pivotal Web Services as follows:

http://pas-swagger-demo.cfapps.io/swagger-ui.html



Categories: Fusion Middleware

Using HTTPIE with Spring Boot Rest Repositories

Pas Apicella - Sun, 2017-05-21 22:58
I recently got introduced to HTTPIE as a command line alternative to CURL for testing RESTful api endpoints created using @RestController annotated classes. For more information on httpie follow this link

Before we test this out lets create a very basic Spring Boot Application with classes/interfaces to verify HTTPIE. The following assumes you have a Spring Boot application already created and it has maven dependancies as follows to enable JPA, Rest Repositories, H2 and Web support

Note: We are using Spring Boot 1.5.3 here
  
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.3.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>

1. Create classes/interfaces as follows

Employee.java
  
package pivotal.io.boot.httpie.demo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Employee
{
@Id
@GeneratedValue (strategy = GenerationType.AUTO)
private Long id;

private String firstName;
private String lastName;
private String job;

public Employee()
{
}

public Employee(String firstName, String lastName, String job) {
this.firstName = firstName;
this.lastName = lastName;
this.job = job;
}

public Long getId() {
return id;
}

public void setId(Long id) {
this.id = id;
}

public String getFirstName() {
return firstName;
}

public void setFirstName(String firstName) {
this.firstName = firstName;
}

public String getLastName() {
return lastName;
}

public void setLastName(String lastName) {
this.lastName = lastName;
}

public String getJob() {
return job;
}

public void setJob(String job) {
this.job = job;
}

@Override
public String toString() {
return "Employee{" +
"id=" + id +
", firstName='" + firstName + '\'' +
", lastName='" + lastName + '\'' +
", job='" + job + '\'' +
'}';
}
}

EmployeeRepository.java
  
package pivotal.io.boot.httpie.demo;

import org.springframework.data.jpa.repository.JpaRepository;

public interface EmployeeRepository extends JpaRepository <Employee, Long> {
}

EmployeeRest.java
  
package pivotal.io.boot.httpie.demo;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping ("/api/employee")
public class EmployeeRest
{
private static Log logger = LogFactory.getLog(EmployeeRest.class);

@Autowired
private EmployeeRepository employeeRepository;

@GetMapping("/emps")
public List<Employee> allEmployees()
{
return employeeRepository.findAll();
}

@GetMapping("/emp/{employeeId}")
public Employee findEmployee (@PathVariable Long employeeId)
{
Employee emp = employeeRepository.findOne(employeeId);

return emp;
}

@PostMapping("/emps")
public Employee createEmployee(@RequestBody Employee employee)
{
return employeeRepository.save(employee);
}

@DeleteMapping("/emps/{employeeId}")
public void deleteEmployee(@PathVariable Long employeeId)
{
Employee emp = employeeRepository.findOne(employeeId);
employeeRepository.delete(emp);
logger.info("Employee with id " + employeeId + " deleted...");
}

}

2. Run the Spring Boot Application which will run on port localhost:8080


  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.5.3.RELEASE)

2017-05-22 13:39:22.910  INFO 8875 --- [           main] p.i.b.h.d.HttpieSpringbootApplication    : Starting HttpieSpringbootApplication on pas-macbook with PID 8875 (/Users/pasapicella/pivotal/DemoProjects/spring-starter/pivotal/httpie-springboot/target/classes started by pasapicella in /Users/pasapicella/pivotal/DemoProjects/spring-starter/pivotal/httpie-springboot)

...

2017-05-22 13:39:25.948  INFO 8875 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
2017-05-22 13:39:25.952  INFO 8875 --- [           main] p.i.b.h.d.HttpieSpringbootApplication    : Started HttpieSpringbootApplication in 3.282 seconds (JVM running for 3.676)

Now we can test HTTPIE and here are some endpoints

3. Here are some examples with output

** All Employees **

pasapicella@pas-macbook:~$ http http://localhost:8080/api/employee/emps
HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Date: Mon, 22 May 2017 01:26:43 GMT
Transfer-Encoding: chunked

[
    {
        "firstName": "pas",
        "id": 1,
        "job": "CEO",
        "lastName": "Apicella"
    },
    {
        "firstName": "lucia",
        "id": 2,
        "job": "CIO",
        "lastName": "Apicella"
    },
    {
        "firstName": "lucas",
        "id": 3,
        "job": "MANAGER",
        "lastName": "Apicella"
    },
    {
        "firstName": "siena",
        "id": 4,
        "job": "CLERK",
        "lastName": "Apicella"
    }
]

** Find Employee by {employeeId} **

pasapicella@pas-macbook:~$ http http://localhost:8080/api/employee/emp/1
HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Date: Mon, 22 May 2017 01:31:32 GMT
Transfer-Encoding: chunked

{
    "firstName": "pas",
    "id": 1,
    "job": "CEO",
    "lastName": "Apicella"
}

** POST new employee **

pasapicella@pas-macbook:~$ http POST http://localhost:8080/api/employee/emps firstName=john lastName=black job=CLERK
HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Date: Mon, 22 May 2017 02:32:34 GMT
Transfer-Encoding: chunked

{
    "firstName": "john",
    "id": 5,
    "job": "CLERK",
    "lastName": "black"
}

** POST with updated employee object **

pasapicella@pas-macbook:~$ http POST http://localhost:8080/api/employee/emps id:=5 firstName=john lastName=black job=CLEANER
HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Date: Mon, 22 May 2017 02:36:06 GMT
Transfer-Encoding: chunked

{
    "firstName": "john",
    "id": 5,
    "job": "CLEANER",
    "lastName": "black"
}

** Delete employee with {employeeId} 5 **

pasapicella@pas-macbook:~$ http DELETE http://localhost:8080/api/employee/emps/5
HTTP/1.1 200
Content-Length: 0
Date: Mon, 22 May 2017 02:36:56 GMT

Categories: Fusion Middleware

A Sneak Peek at Oracle’s Chatbot Cloud Service and 5 Key Factors Necessary for Bot ROI

In early May, I flew out to Oracle HQ in San Francisco for an early look at their yet-to-be released Oracle Intelligent Bots Service.  The training left me ecstatic that the technology to quickly build great chatbots is finally here. However, the question remains, can chatbots provide real value for your business?

What is a chatbot?

A chatbot is a program that simulates a conversation partner over a messaging app. It can integrate with any kind of messaging client, such as Facebook, WeChat, WhatsApp, Slack, Skype, or you could even build your own client. If you’ve been following our blog, you may have already seen the chatbot (Atlas) we built as part of our annual hackathon.

Here is an example conversation I had with Atlas recently:

Chatbot Conversations

Chatbots use Natural Language Processing and Machine Learning algorithms to take what the user said and match it up against pre-defined conversations. Understanding how chatbots recognize phrases can help determine what conversations a user could have with a bot. Here is some chatbot terminology:

  • An intent is something the users wants, and the bot maps this to an action. For example, the user might want to say some form of “Hi” to the bot, and we would want the bot to respond with a random greeting. A chatbot generally has up to 2,000 intents.
  • Utterances are examples of different phrases that represent an intent. An intent might have 10-15 utterances. The bot will be able to match statements similar to those utterances to the intent, but what a user says doesn’t have to exactly match an utterance. This is where the language processing algorithms are used.
  • Entities are key variables the bot can parse from the intent.

Suppose we are building an HR chatbot that can help users reset passwords. The goal is for our bot to understand that the user needs a password reset link, and then send the correct link to the user. Our intent could be called Password Reset. Since the user could have accounts for different services, we would need to create an entity called AccountType for our bot to parse from what the user said. AccountType could map to “Gitlab”, “WebCenter”, or “OpenAir”.

As a rough design, we could start with:

  • Intent: Password Reset
  • Utterances:
    • I’d like to reset my password.
    • How do I change my password for Gitlab?
    • I forgot my WebCenter pw, can you help?
    • Please assist me in receiving a new password.
    • Forgot my passcode for OpenAir.
    • Give me another password.
  • Entity: AccountType (Gitlab, WebCenter, OpenAir)

Intents like this one will need to be set up for a bot to know what to do when a user says something. If a user asks the bot a question it doesn’t have an intent for, it won’t know what to do and the user will get frustrated. Our bot still won’t know how to order a pizza, but it could help with password resets.

Key Factor #1: Chatbots should have a purpose

A chatbot can only answer questions it is designed to answer. If I was building an HR Help chatbot, it probably would not be able to order a pizza, rent a car for you, or check the weather. It could, for example, reset passwords, report harassment, set up a new hire, and search for policies. Once the requirements are set, developers can build, design, and test to ensure the bot has those capabilities.

This makes it important to set expectations with the user on what types of questions they can ask it, without giving the user a list of questions. Introducing a bot along with its purpose will help with this. For example, we could have the HR Help Bot, the Travel Planning bot, or the Sales Rep Info bot. If we introduced the Fishbowl Ask-Me-Anything bot, users will start asking it a lot of questions we didn’t plan for it to be able to answer.

Conversations can be more complicated than a simple back and forth, or question and answer. The capability is there (Oracle’s solution gives developers full control over a Conversational State Machine), but I have yet to explore the full capabilities.

Once a purpose and a set of intents are identified, a chatbot could be a useful tool to engage customers or employees.

Key Factor #2: Design Architecture

Bots are great for interacting with difference services. Oracle Intelligent Bot Service is designed to make it easy for developers to make REST API calls and database lookups in between parsing what the user says, and returning a response.

Here are a few things to think about when designing a bot’s architecture:

  • Integrations: What services will the bot interact with?
  • Security: Are users typing their bank account number over Facebook chat?
  • Human interaction: How will the bot flip users over to a human to help when they get frustrated?
  • Infrastructure: What will be on premise and what will be in the cloud?
  • Performance: How to minimize network requests?
Key Factor #3: Analytics

Analytics can be used to improve the bot’s capability over time and understand the impact on the company. Some companies may already have metrics around help desk call volume or customer conversion rates, and it would be interesting to compare that data from before and after a bot’s release.

Beyond that, bot analytics will be able to show the performance of the bot. Analytics could show the top questions a bot is asked but can’t answer, how many questions it answers successfully each day, and what questions it mistook for something else. Oracle’s chatbot solution will have some capabilities built in, and the platform is so flexible it will be possible to gather any data about a bot.

Key Factor #4: Bot Building Best Practices

There is a lot to do when it comes to building the bot. From setting up the infrastructure, connecting all the services, and filling out all the utterances. There are some best practices to keep in mind as well.

The bot should sound like a human. Personality can play a big role in giving users a better interaction.

As users become more familiar with chatbots, there will also be a set of questions they expect every bot to be able to answer. This list might start with:

  • Hi.
  • What do you do?
  • Are you human?
  • Help!
  • Tell me a joke.
  • How are you?

When the bot is going to run a query or API that may take a while, it is important to warn the user in advance and echo that the bot understood what the user wanted. Some apps will also support “is typing” statuses, which is another great way to show the bot is thinking.

Key Factor #5: Testing

Users have high expectations for the intelligence level of a chatbot. They expect the Machine Learning algorithms to work well, and the bot to seem smart. If the bot doesn’t meet their expectations on the first try, they are unlikely to use the bot in the future.

Testing and tuning utterances can make the difference for making a bot seem smart. The bot should be able to accurately map what a user says to the correct intent. Oracle’s chatbot solution has some nice testing capabilities around utterances and intents, and making sure what the users says maps correctly.

Chatbots are another piece of software, so it is important to do performance and user testing on it as well.

Conclusion

Chatbots are a great way to tie in a single user interface to a large variety of services, or automate repetitive conversations. There are plenty of business use cases that would benefit from a chatbot, but the ROI depends on thorough requirements gathering and using analytics to optimize the bot. That being said, companies that have already started down the path – like this Accounting Firm in Minneapolis – are seeing benefits from bots automating manual processes leading to a reduction in operating costs by 25 to 40%. Savings like this will vary across use case and industry, but overall the automation gains from a bot are there regardless of what the bot is being used for. We would love to discuss your ideas on how a chatbot could help your business. Leave a comment or contact us with any questions.

The post A Sneak Peek at Oracle’s Chatbot Cloud Service and 5 Key Factors Necessary for Bot ROI appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Pages

Subscribe to Oracle FAQ aggregator - Fusion Middleware