Fusion Middleware

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

Unboxing the Future of Fishbowl’s On-premise Enterprise Search Offering: Mindbreeze InSpire

Back on April 3rd, Fishbowl announced that we had formed a partner relationship with Mindbreeze to bring their industry leading enterprise search solutions to Fishbowl customers. We will offer their Mindbreeze InSpire search appliance to customers looking for an on-premise solution to search internal file shares, databases, document management systems and other enterprise repositories.

Since that announcement, we have been busy learning more about Mindbreeze InSpire, including sending some members of our development team to their partner technical training in Linz, Austria. This also includes procuring our own InSpire search appliance  so that we can begin development of connectors for Oracle WebCenter Content and PTC Windchill. We will also begin using InSpire as the search system for our internal content as well.

Fishbowl’s Mindbreeze InSpire appliance arrived last week, and we wanted to share a few pics of the unboxing and racking process. We are very excited about the value that Mindbreeze InSpire will bring to customers, including the time savings of searching, and in many cases not finding, high-value information. Consider these stats:

  • 25% of employee’s time is spent looking for information – AIIM
  • 50% of people need to search 5 or more sources – AIIM
  • 38% of time is spent unsuccessfully searching and recreating content – IDC

Stay tuned for more information on Fishbowl’s software and services for Mindbreeze InSpire. Demos of the system are available today, so contact us below or leave a comment here if you would like to see it in action.

 

 

The post Unboxing the Future of Fishbowl’s On-premise Enterprise Search Offering: Mindbreeze InSpire appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

How to Configure Microsoft IIS with Oracle WebCenter

I was setting up a Oracle WebCenter 12c Suite in a local development environment utilizing a Windows Server 2012 R2 Operating System with a Microsoft SQL Server. Instead of using a OHS (Oracle HTTP Server), I wanted to try using Microsoft IIS (Internet Information Services) to handle the forwarding of sub-sites to the specified ports.  Since the Oracle applications run specified ports (ex. 16200 for Content Server), when a user requests the domain on the default ports (80 and 443) on browsers it won’t redirect to the content server – example: www.mydomain.com/cs vs. www.mydomain.com:16200/cs. The reason I chose to use IIS was because it is already a feature built-in to Windows Server, and thus is one less application to manage.

That being said, IIS and OHS perform in the same manner but are setup and configured differently based on requirements.  Oracle provides documentation about using the Oracle Plug-in for Microsoft IIS, but the content is pretty outdated on the Oracle site.  The page first references IIS 6.0, which was released with Windows Server 2003 in April 2003.  It has now ended its support as of July 14th, 2015. Lower on the page, they show steps for IIS on Windows Server 2012 R2, which got me started.  In the next part of this post, I will review the steps I took to get all functionality working, as well as the limitations/flaws I incurred.

Step 1: Install IIS on the Server

The first part was to install IIS on the server.  In Server 2012, open the Server Manager and select Add Roles and Features.  From there select the option to add the IIS components.

Step 2: Select Default Web Site

Once IIS has been installed, open it and select the Default Web Site.  If you right-click and select edit bindings, you can see the default site is binded to port 80, which is what we want since port 80 is the default port for all web applications.

Step 3: Select Application Pools

Following the instructions from Oracle, download the plug-in and put it in the system folder close to the root level on the desired drive.  For this blog, I have it in C:\IISProxy\.  For each server (Content Server, Portal, etc) you need to perform configurations in IIS.  Open IIS and navigate to the Application Pools section.  Select Add Application Pool and create a pool with a specific name for each server.  There needs to be separate application pools for specific port forwarding to work correctly.

Step 4: Configure Properties

Once created, open Windows Explorer and create a folder inside IISProxy called “CS.”  Copy all he plug-in files into the CS folder.  Now open the iisproxy.ini file and configure the properties to match your environment.  Make sure to configure the Debug parameter accordingly to tailor on your environment.

Step 5: Select the Created Application Pool

Open IIS and select the Default Web Site option.  Right-click and select Add Application.  Add the Alias name and select the Application Pool created above.  Set the physical path to the folder created above and make sure the connection is setup for pass-through authentication.

Step 6: Set Up Handler Mappings

Once OK has been selected, the application should now be displayed on the tree on the left.  The next step is to setup handler mappings for how IIS will handle requests coming in.  Click on the “cs” application you just created and on the main display there should be a Handler Mappings icon to click. Double click the icon.  This is where we will setup the routing of static files vs content server requests. On the right side, click the “Add Script Map” icon.  Add the request path of “*” and add the folder path to the iisproxy.dll.  Open the request restrictions and verify the “Invoke handler…” checkbox is unchecked.  Open the access tab and select the Script radio button.  Click OK and verify the mapping has been applied.

    

Step 7: Map Static Files

Next, we will setup the mapping for static files.  Click “Add Module Mapping” Add “*” for the request path, “StaticFileModule,DefaultDocumentModule,DirectoryListingModule” for the Module and give it a name.  Open request restrictions and select the file or folder radio option.  Navigate to the access tab and select the read radio button.  Click OK and verify the mapping was applied.

  

Step 8: Verify Mapping Execution

After the mappings have been setup, we need to verify they are executed in the correct order.  Do this by going to the back to the handler mappings screen and clicking “View Ordered List”

Step 9: Restart the IIS Server

After these steps are completed, restart the IIS server.  To do this, open command-prompt as an administrator and type “iisreset”.  Once restarted, you now should be able to view the content server on port 80.  If you have other redirects you would like to perform, you can perform the same steps above with a different name (ex. Portal, Inbound Refinery, Console, Enterprise Manager, etc).

With Oracle’s tutorial out-of-date and missing key steps, it was difficult to determine how to set everything up.  With some trial and error and investigation, I think I outlined in the 9 steps above how to help you quickly setup IIS with the WebCenter Suite on a Windows environment so specific port numbers are not needed.  Obviously with any technology decision, application evaluations should take place to determine if IIS or OHS is a better fit. Good luck, and leave a comment if you have any questions or need further clarification.

The post How to Configure Microsoft IIS with Oracle WebCenter appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Fishbowl Innovation: Cloud 2 Cloud Content Migrations for Oracle Content and Experience Cloud (Oracle Documents Cloud Service) and Other Cloud Storage Providers

Migrating content between systems takes a lot of time, and without methods to bulk load or schedule the process may proceed incrementally as users facilitate the process whenever they have time. But what if they don’t have time? What if they had been using an unauthorized cloud storage system, or the system they were using is being decommissioned by the company. How can they quickly move high value content to another system?

For example, let’s say a business division within a company is using Microsoft OneDrive as a collaboration and document sharing system. Then, that company decides that OneDrive is no longer an accepted or company preferred file sync and share system, and employees should use Oracle Documents Cloud Service. For the division using OneDrive, such a declaration could cause some delays in any of their processes that rely on that content. An example of this could be the inability to collaborate with 3rd-parties – such as a law firm – on documents being reviewed by both parties. The process of downloading copies of the content and uploading them to another system could take a significant amount of time, but until that content gets moved over to, in this case Oracle Documents Cloud Service, critical processes could be severely delayed.

The hackathon event team for this solution set out to provide a web-based interface to enable single item and batch migrations between systems to be migrated and removed from one system or the other or just copied. As more and more of these easy-to-use document sharing solutions enter an organization, such a tool could be quite beneficial to ensure content can be easily accessed and shared across systems.

One important point to note about such a solution, and the use of cloud storage systems across an organization, is that governance and acceptable use policies for cloud storage/enterprise file sync and share systems need to be clearly defined. Although the solution developed by Fishbowl could help an organization migrate content to the standardized cloud storage solution, companies need to be proactive with monitoring employee use as they may try and utilize other systems. This can pose security risks – both from a sharing of confidential information perspective and opening up new avenues for cyber attacks. To combat this, solutions like Oracle’s Cloud Access Security Broker (CASB) could be leveraged to provide visibility into the cloud systems being used, and provide security monitoring and threat detection across your entire cloud technology stack.

The screenshot below shows the simple user interface to select available systems and begin migrating content. Fishbowl has customers using this cloud migration tool today, so if you are interested in learning how it could help you expedite your cloud to cloud content migrations, contact us now – info@fishbowlsolutions.com or 952-465-3400.

Here are the technologies the team used to develop Cloud 2 Cloud. If you would like more information on the technical specifics of the solutions, please leave a comment and we will get back to you ASAP.

  • REST API
  • Mustache – web template system for mobile and web applications
  • Debugging tools Fiddler and Postman

 

Cloud 2 Cloud Migration.

The post Fishbowl Innovation: Cloud 2 Cloud Content Migrations for Oracle Content and Experience Cloud (Oracle Documents Cloud Service) and Other Cloud Storage Providers appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Fishbowl Innovation: ATLAS – Intelligent Chatbot and Virtual Assistant for Oracle Applications

If you haven’t heard about chatbots yet, you will soon. Today’s leading technology companies – Apple, Google, Amazon, Microsoft, Oracle – all have bot development strategies proceeding this year. Why? To answer that question, let’s first define the two types of bots being used today. The first is called a “virtual assistant”, which is effectively Apple’s Siri or Amazon’s Alexa. Virtual assistants can help you find or remember things, or even buy things (Dom the pizza bot). These bots are powered by machine learning, which means they will get smarter over time as more people use them and its artificial intelligence learns what people are asking it to do.

The other type of bot is a messaging bot, which have become pretty prevalent within Facebook Messenger. This type of bot can be used for customer service to answer simple questions such as “what are your store hours”? The responses returned by the bot have all been programmed, so if it gets asked a question outside of its pre-defined responses it won’t be able to interact with the user.

So, back to the question, why are bots so popular? Because bots, in many cases, can provide answers to questions or facilitate a purchase faster than a human can. Consider this stat by Deloitte – a minute of work for a bot is equal to 15 minutes of work for a human. Additionally, because messaging apps are ubiquitous (1.3 billion people use them), companies have developed bots to engage and market to users 24 x 7. To look at this from a business perspective, consider the following use cases:

  • Requesting pricing and availability of a product
    • During  a sales meeting, you could type the following into a messaging service on your phone or laptop “what is the pricing and availability of product widget ABC”? The bot would then perform a query for this product in the ERP system and return your answer – “product widget ABC is $299 and can ship today.”
  • Logging your billable hours into a project management system
  • Providing quick answers to simple questions such as “how many PTO days do I have left”?
  • Resetting your password
  • Asking for specific content to be delivered to you, such as a product brochure, price list, or instruction manual
  • Ordering new business cards, which was the example that Larry Ellison shared at Oracle OpenWorld 2016

With each of the examples above, the time savings of not having to log onto a system and perform multiple clicks to facilitate such requests could be huge – especially for employees on the go, such as sales staff, that need information quickly. All the examples above are also opportunities to reduce the amount of calls and service requests to your help desk. According to this press release from Kore Inc., about 20% of IT help desk calls are still related to password resets, an inefficiency that can cost businesses between $15 to $20 per call.

The chatbot that was developed during Fishbowls hackathon was positioned as a personal assistant in the cloud for document management. The team showed how Atlas could be used with a team collaboration system like Slack, and integrated with Oracle WebCenter to retrieve documents based on simple input from the user. For example, “find a document – invoice 123456”. Then filter by user jsim. Here are the technologies the team used to develop and integrate Atlas:

Here some screenshots of this use case and the bot also running within Fishbowl’s demo instance of Oracle WebCenter Portal to show an example of employee self-service. Contact us today for more information on ATLAS and intelligent chat bots – info@fishbowlsolutions.com or 952-465-3400. If you would like more technical information on how Atlas was built and our approach to developing intelligent chatbots for Oracle applications, leave us a comment and we will respond directly.

 

ATLAS returning results for document named Invoice 123456.

 

Atlas filtering results returned by author jsim.

 

ATLAS performing employee self-service actions in WebCenter Portal.

The post Fishbowl Innovation: ATLAS – Intelligent Chatbot and Virtual Assistant for Oracle Applications appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Fishbowl Innovation: Controlled Document Management in the Cloud

Fishbowl Solutions has been delivering enterprise content management (ECM) solutions based on Oracle WebCenter for over 17 years. WebCenter is the only ECM solution we’ve built a consulting practice around and have software solutions for. Its comprehensive capabilities have satisfied numerous customer use cases including employee portals, contract management, and quality control. That being said, we understand customers have other use cases for storing and managing their high value content, and more recently that includes document storage in the cloud.

To satisfy use cases where companies manage the majority of their content with on-premise solutions like WebCenter but may need simple, cloud-bases solutions to manage specific documents that are part of a controlled process – contracts, policies and procedures, etc., Fishbowl developed a proof of concept (POC) for lightweight ECM in the cloud. This solution would provide a low barrier to entry for customers wanting content management capabilities through a simplified user interface that includes a dashboard, document list, and profile driven metadata fields. The other obvious benefit this solution would provide is a much lower overall cost due to a cloud-based subscription model, and less need for development resources and system administrators.

From a development and technology perspective, the team working on this POC discussed how workflow, revisioning, security/permissions, would all need be included to make this a viable solution. Here are some of the technologies they leveraged to develop the solution:

The following are some screenshots of the solution as it appears running on the Google Cloud Platform, but the flexibility of the technologies used to develop the solution means it could integrate with other cloud platforms like Oracle Content and Experience Cloud. Contact us today if you would like more information – info@fishbowlsolutions.com or 952-465-3400. If you are interested in learning more and discussing the technologies involved in the development, please leave a comment and we will get some dialogue going there.

 

The post Fishbowl Innovation: Controlled Document Management in the Cloud appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Hackathon Weekend Recap: Oracle Chatbots, Cloud Content Migrations, and Controlled Document Management in the Cloud

Wow! It’s always amazing what can be accomplished in a weekend when you give people limitless supplies of calories and caffeine, as well as a hard deadline. Couple that with a lot of competitive fire and the drive to innovate, and you just might be able to produce THREE, new software solutions and spark new product ideas. That’s what transpired during the weekend of April 7th as Fishbowl Solutions held its annual hackathon event. Over 250 hours were spent across three teams as they architected, designed, and developed their solutions. Teams then had to present the business use case for the solution and show a demo to the Fishbowl employees that did not participate in the hackathon. The non-participants then voted for the winner. What follows is a recap of the solutions developed in order of where they placed after the voting.

Controlled Document Management in the Cloud

Team Members: Andy Weaver, Lauren Beatty, Nate Scharber, Brent Genereaux, Amy Mellinger
Solution Summary: The goal for this team was to develop a controlled document management solution in the cloud. Essentially, the team wanted to produce a lightweight, cloud-based version of Fishbowl’s flagship controlled document management solution called ControlCenter. Their demo showed how easy it would be to provision users for the cloud instance, and then the simple steps users would take to begin uploading, reviewing and managing documents in the cloud.

For more information on this solution including some business use cases and screenshots, read this blog post — Fishbowl Innovation: Controlled Document Management in the Cloud

Team Controlled Document Management in the Cloud

ATLAS – Intelligent Chatbot

Team Members: John Sim, Danny Lesage, Amanda Jovanovic, Matt Hornung, Sean Deal
Solution Summary: This team was all about bots. What’s a bot? Well, it’s software that can run automated tasks over an Internet connection. Fishbowl’s resident Oracle UX expert, John Sim, is from the United Kingdom and while John was visiting he shared how Dom the pizza bot enables customers to order pizzas from Domino’s using Facebook Messenger. Sadly, Dom can only facilitate such requests in the United Kingdom currently, but this provided a great example of a bot for personal use (and made everyone hungry for pizza). However, Fishbowl isn’t in the business of “chat commerce” for food, so the team set out to develop a chatbot that could help users find content stored in Oracle WebCenter.

For more information on this solution including some business use cases and screenshots, read this blog post — Fishbowl Innovation: ATLAS – Intelligent Chatbot and Virtual Assistant for Oracle Applications

Team ATLAS: Intelligent Chatbot

Cloud 2 Cloud Content Migrations

Team Members: Tim Gruidl, Jake Ferm, Dan Haugen, Tom Johnson
Solution Summary: The premise of this solution was based on the proliferation of cloud storage/file sync and share systems within an organization and how it would take many steps to migrate or copy content between them. For example, moving or copying content from Microsoft OneDrive to Oracle Documents Cloud Service.

For more information on this solution including some business use cases and screenshots, read this blog post — Fishbowl Innovation: Cloud to Cloud Content Migrations for Oracle Content and Experience Cloud (Oracle Documents Cloud Service) and Other Cloud Storage Providers

Team Cloud to Cloud Content Migrations

 

This was Fishbowl’s sixth annual hackathon event, and the bar raises every year with the innovative solutions that get created. Here are some more pictures from this year’s event.

 

The post Hackathon Weekend Recap: Oracle Chatbots, Cloud Content Migrations, and Controlled Document Management in the Cloud appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Binding a Spring Cloud Task to a Pivotal Cloud Foundry Database Service

Pas Apicella - Mon, 2017-05-01 22:54
I previously blogged about how to create and deploy a Spring Cloud Task to Pivotal Cloud Foundry (PCF) as shown below.

http://theblasfrompas.blogspot.com.au/2017/03/run-spring-cloud-task-from-pivotal.html

Taking that same example I have used the Spring Cloud Connectors to persist the log output to a database table to avoid looking through log files to view the output. Few things have to change to make this happen as detailed below.

1. We need to change the manifest.yml to include a MySQL service instance as shown below

applications:
- name: springcloudtask-date
  memory: 750M
  instances: 1
  no-route: true
  health-check-type: none
  path: ./target/springcloudtasktodaysdate-0.0.1-SNAPSHOT.jar
  services:
    - pmysql-test
  env:
    JAVA_OPTS: -Djava.security.egd=file:///dev/urando

2. Alter the project dependancies to include Spring Data JPA libraries to persist the log output to a table. Spring Cloud Connectors will automatically pick up the bound MySQL instance and connect for us when we push the application to PCF

https://github.com/papicella/SpringCloudTaskTodaysDate
  
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-task</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>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>

3. A Entity class, Spring JPA repository interface and a JPA task Configurer has been created for persisting the log output as shown in the code below.

TaskRunOutput.java
  
package pas.au.pivotal.pa.sct.demo;

import javax.persistence.*;

@Entity
@Table (name = "TASKRUNOUTPUT")
public class TaskRunOutput
{
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;

private String output;

public TaskRunOutput()
{
}

public TaskRunOutput(String output) {
this.output = output;
}

public Long getId() {
return id;
}

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

public String getOutput() {
return output;
}

public void setOutput(String output) {
this.output = output;
}

@Override
public String toString() {
return "TaskRunOutput{" +
"id=" + id +
", output='" + output + '\'' +
'}';
}
}

TaskRepository.java
  
package pas.au.pivotal.pa.sct.demo;

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

public interface TaskRepository extends JpaRepository <TaskRun, Long>
{
}

JpaTaskConfigurer.java
  
package pas.au.pivotal.pa.sct.demo.configuration;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import pas.au.pivotal.pa.sct.demo.TaskRunOutput;
import pas.au.pivotal.pa.sct.demo.TaskRunRepository;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.task.configuration.DefaultTaskConfigurer;
import org.springframework.cloud.task.listener.annotation.BeforeTask;
import org.springframework.cloud.task.repository.TaskExecution;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;

@Component
public class JpaTaskConfigurer extends DefaultTaskConfigurer {
private static final Log logger = LogFactory.getLog(JpaTaskConfigurer.class);

@Autowired
private PlatformTransactionManager transactionManager;

@Autowired
private TaskRunRepository taskRunRepository;

@Override
public PlatformTransactionManager getTransactionManager() {
if(this.transactionManager == null) {
this.transactionManager = new JpaTransactionManager();
}

return this.transactionManager;
}

@BeforeTask
public void init(TaskExecution taskExecution)
{
String execDate = new SimpleDateFormat().format(new Date());
taskRunRepository.save(new TaskRunOutput("Executed at " + execDate));
logger.info("Executed at : " + execDate);
}
}

4. Now as per the previous blog execute the task and verify it completes without error. The screen shot below shows how the "Tasks" tab shows this

Note: You would need to PUSH the application to Pivotal Cloud Foundry before you can execute it which is shown on the original blog entry


5. Now if you follow this blog entry below you can deploy a Web Based interface for Pivotal MySQL instance to view the table and it's output

http://theblasfrompas.blogspot.com.au/2017/04/accessing-pivotal-mysql-service.html

With Pivotal MySQL*Web installed the output can be viewed as shown below.



Categories: Fusion Middleware

Accessing a Pivotal MySQL service instance within Pivotal Cloud Foundry

Pas Apicella - Thu, 2017-04-27 00:18
Recently at a hackathon we used the Pivotal MySQL service rather then a ClearDB MySQL service. As a result we could not connect to our instance from a third party tool as the service instance is locked down. There are various way to access the MySQL service to me the best two options are as follows.

1. Cloud Foundry CLI MySQL Plugin

cf-mysql-plugin makes it easy to connect the mysql command line client to any MySQL-compatible database used by Cloud Foundry apps. Use it to

  • inspect databases for debugging purposes
  • manually adjust schema or contents in development environments
  • dump and restore databases

Install it as explained in the link below:

  https://github.com/andreasf/cf-mysql-plugin

** Using It ** 

1. First ensure you are logged into a Pivotal Cloud Foundry instance you can determine that as follows

pasapicella@pas-macbook:~$ cf target -o ben.farrelly-org -s hackathon
API endpoint:   https://api.run.pivotal.io
API version:    2.78.0
User:           papicella@pivotal.io
Org:            ben.farrelly-org
Space:          hackathon

2. Verify you have a MySQL instance provisioned

pasapicella@pas-macbook:~$ cf services
Getting services in org ben.farrelly-org / space hackathon as papicella@pivotal.io...
OK

name        service   plan    bound apps                                                     last operation
nab-mysql   p-mysql   100mb   nabhackathon-beacon, nabhackathon-merchant, pivotal-mysqlweb   create succeeded

3. Log in as shown below

pasapicella@pas-macbook:~$ cf mysql nab-mysql

...

Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> show databases;
+-----------------------------------------+
| Database                                |
+-----------------------------------------+
| cf_53318c9c_caec_49be_9e33_075fade26183 |
| information_schema                      |
+-----------------------------------------+
2 rows in set (0.30 sec)

mysql> use cf_53318c9c_caec_49be_9e33_075fade26183;
Database changed

mysql> show tables;
+---------------------------------------------------+
| Tables_in_cf_53318c9c_caec_49be_9e33_075fade26183 |
+---------------------------------------------------+
| beacon                                            |
| beacon_product                                    |
| customer                                          |
| customer_registration                             |
| merchant                                          |
| payment                                           |
| payment_product                                   |
| product                                           |
+---------------------------------------------------+
8 rows in set (0.29 sec)

2. Pivotal MySQL*Web

PivotalMySQL*Web is a browser based SQL tool rendered using Bootstrap UI for MySQL PCF service instances which allows you to run SQL commands and view schema objects from a browser based interface. Use it to

  • Multiple Command SQL worksheet for DDL and DML
  • Run Explain Plan across SQL Statements
  • View/Run DDL command against Tables/Views/Indexes/Constraints
  • Command History
  • Auto Bind to Pivotal MySQL Services bound to the Application within Pivotal Cloud Foundry 
  • Manage JDBC Connections
  • Load SQL File into SQL Worksheet from Local File System
  • SQL Worksheet with syntax highlighting support
  • HTTP GET request to auto login without a login form
  • Export SQL query results in JSON or CSV formats
  • Generate DDL for schema objects


It does this deployed within Pivotal Cloud Foundry as an application instance and auto binds to the MySQL service for you if you choose to bind it as part of the "cf push" and a manifest.yml which looks as follows

---
applications:
- name: pivotal-mysqlweb
  memory: 512M
  instances: 1
  host: pivotal-mysqlweb-${random-word}
  path: ./target/PivotalMySQLWeb-0.0.1-SNAPSHOT.jar
  services:
    - pas-mysql

Install it as explained in the link below:

  https://github.com/pivotal-cf/PivotalMySQLWeb


Categories: Fusion Middleware

Cross-origin resource sharing (CORS) from Spring Boot Rest Controllers

Pas Apicella - Tue, 2017-04-25 18:45
Was involved in a hackathon recently and after creating a few Spring boot API's for the UI team to consume and they run into errors around (Cross-origin resource sharing ). For security reasons, browsers prohibit AJAX calls to resources residing outside the current origin.

I have seen this before and Spring Boot has support to ensure you can control which resources can be accessed outside of the current origin. It's as simple as an annotation "@CrossOrigin", as shown below. In this example every request from this Rest Controller supports resource calls residing outside the current origin.
  
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@CrossOrigin
@RestController
@RequestMapping(value = "/beacon")
public class BeaconRest
{
private static Log logger = LogFactory.getLog(BeaconRest.class);

@Autowired
private BeaconRepository beaconRepository;

@RequestMapping(value = "/all",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public List<Beacon> allBeacons()
{
logger.info("Invoking /beacon/all RESTful method");
return beaconRepository.findAll();
}

Of course it's much more flexible then that adding the ability to add options, and you can read more about it here.

https://docs.spring.io/spring/docs/4.2.x/spring-framework-reference/html/cors.html
Categories: Fusion Middleware

Proactively Manage Contracts, Policies, Web Assets, and Sales Content stored in Oracle WebCenter with Fishbowl’s Subscription Notifier

Oracle WebCenter Content is a great tool for keeping your company’s content organized, but it can be difficult to proactively manage new, updated, and expiring content. For example:

  • Users check out content and forget to check it back in
  • Plans and policies require reviews at varying intervals
  • Managers change, and metadata needs to be changed for several content items

In 2005, Fishbowl launched the initial release of Subscription Notifier to help solve these problems and many more. It was also specifically designed to satisfy these content management use cases:

  • Web Content Management: Ensure proactive updates to web content for optimal SEO.
  • Contract Management: Enable contract management knowledge workers to get ahead of contract renewals with scheduled email notifications at 90, 60, and 30 days.
  • Policy and Procedure Management: Trigger a workflow process to alert users of content requiring review annually to ensure company policies and procedures are up to date.
  • Sales Enablement: Provide key stakeholders with better visibility into new or updated sales or marketing material.

Today, Subscription Notifier is sold as part of the Admin Suite and included in our controlled document management solution – ControlCenter. Due to its value-add content management capabilities, Subscription Notifier has become one of our most popular products. We continue to make enhancements to the product, and just last month, we released version 5.0, which brings some customer-requested capabilities.

Before I provide an overview of what’s new in version 5.0, I want to start with a brief introduction on what Subscription Notifier actually does. Subscription Notifier is a query-based email notification and scheduled job utility that enables proactive content management in WebCenter Content. With an easy-to-understand subscription builder, you can quickly create subscriptions based on any business rule in your content server – not just expiration. You can schedule the subscription to run on an hourly, daily, weekly, monthly, or yearly basis, or let it run without a schedule to notify users as soon as possible. It also enables you to specify users and/or aliases to be notified of content that matches the subscription query, either directly by username or by using a metadata field, email address, or Idocscript. Other options are available to further customize the subscription, but the core is that simple – specify a schedule, include the users to notify, build the query, and you’re done!

As I highlighted in the policy and procedure management use case above, subscriptions can be set up as periodic reviews, which will put content items into the specified user’s “Documents Under Review” queue as the item’s expiration date (or any other specified date) approaches. Content remains in the queue until one of three actions are taken: “No Change Necessary”, allowing the user to update the review date without updating the content item; “Check Out and Revise”, updating the content item and its review date; or “Approve Expiration”, which lets the content item become expired. The review queue appears in both the core WebCenter UI and ControlCenter. Periodic reviews are one of the most useful features of Subscription Notifier, enabling companies to stay on top of expiring content and ensure that content is always kept up to date.

Beyond notifications and reviews, Subscription Notifier can also empower data synchronization through Pre-query Actions and Side Effects. These are extra effects that are triggered either once before the query executes (Pre-query Actions) or once for every content item that matches the subscription query (Side Effects). Custom Pre-query Actions and Side Effects can be created, and Subscription Notifier comes packaged with some useful Side Effects. These include actions to update metadata, delete old revisions, check-out and check-in, update an external database, and resubmit a content item to Inbound Refinery for conversion. Subscriptions don’t need to send emails – you can set up subscriptions to only trigger these actions.

Now that I’ve gone over the core functionality of Subscription Notifier, I’d like to highlight our latest release, version 5.0, by discussing some of this release’s new features:

 

Simplified Subscriptions for End-Users

Simplified Subscription Builder Interface

By specifying a role in the component configuration, non-administrators can now create subscriptions in Subscription Notifier. Users with restricted access can create subscriptions in a restricted view, which both simplifies the view for the non-tech-savvy and ensures security so that end-users do not have access to more than they should. Administrators can still manage all subscriptions, but users with restricted access can only manage subscriptions they have created themselves. This has been a highly-requested feature, so we’re excited to finally bring the requests to fruition!

 

Type-ahead User Fields

Type-Ahead User Fields Screenshot

Taking a feature from ControlCenter, user and alias fields on the subscription creation page will now offer type-ahead suggestions based on both usernames and full names. No longer do you need to worry about the exact spelling of usernames – these validated fields will do the remembering for you! In addition to greatly improving the look and feel of the subscription creation page, these newly improved fields also enhance performance by cutting out the load time of populating option lists.

 

Job Run History Job Run History Report Screenshot

Administrators can view an audit history of subscription job executions, allowing them to view when subscriptions are evaluated. The table can be sorted and filtered to allow for detailed auditing of Subscription Notifier. By inspecting an individual job run, you can see which content items matched the query and who was notified. If a job run failed, you can easily view the error message without delving into the content server logs.

 

Resubmit for Conversion Side Effect

Sometimes Inbound Refinery hits a snag, and content items will fail conversion for no apparent reason. This new Side Effect will allow you to resubmit content items to Inbound Refinery to attempt conversion again. You can specify the maximum number of times to attempt the re-conversion, and the queue of items being added to the conversion queue is throttled, so you don’t need to worry about clogging up Inbound Refinery with conversion requests.

 

Enforce Security on a Per-Subscription Basis

Subscription Notifier has allowed you to specify whether to enforce content security when sending emails, making sure users only are notified on content they have permissions to read or letting users be notified of everything. Previously, this was a component configuration setting, but now this setting can be changed on each subscription individually.

That about wraps up this spotlight on Subscription Notifier. I hope I was able to share how a simple yet powerful notification and subscription solution for Oracle WebCenter supports multiple use cases for proactive content management. At its core, Subscription Notifier helps organizations keep their content up-to-date while providing visibility into the overall content creation process. Its powerful side-effects capabilities can be used to trigger workflows, update metadata, delete old revisions and more – providing more proactive methods for users to best manage high-value content in an organization. If you’re interested in purchasing Subscription Notifier or upgrading your existing copy, please contact us for more info.

The post Proactively Manage Contracts, Policies, Web Assets, and Sales Content stored in Oracle WebCenter with Fishbowl’s Subscription Notifier appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

We're All In This Thing Together

Greg Pavlik - Fri, 2017-04-14 17:26
This song pretty much summarizes everything I've learned to be true about life after nearly five decades of living...

Well my friend, well I see your face so clear
Little bit tired, a little worn through the years
You sound nervous, you seem alone
I hardly recognize your voice on the telephone

In between I remember
Just before we wound up broken down
We'd drive out to the edge of the highway
Follow that lonesome dead-end roadside sound

We're all in this thing together
Walkin' the line between faith and fear
This life don't last forever
When you cry I taste the salt in your tears

Well my friend let's put this thing together
And walk the path that worn out feet have trod
If you wanted we can go home forever
Give up your jaded ways, spell your name to God

We're all in this thing together
Walkin' the line between faith and fear
This life don't last forever
When you cry I taste the salt in your tears

All we are is a picture in a mirror
Fancy shoes to grace our feet
All that there is is a slow road to freedom
Heaven above and the devil beneath

We're all in this thing together
Walkin' the line between faith and fear
This life don't last forever
When you cry I taste the salt in your tears

Automate and expedite bulk loading into Windchill.

Data migration is the least attractive part of a PDM/PLM project.  Take a look at our latest infographic to learn how to speed up bulk loading data from Creo, Autodesk Inventor and AutoCAD, SolidWorks, Documents, WTParts and more into Windchill PDMLink and Pro/INTRALINK.

More information can also be found in our previous posts:

Approaches to Consider for Your Organization’s Windchill Consolidation Project

Consider Your Options for SolidWorks to Windchill Data Migrations

 

The post Automate and expedite bulk loading into Windchill. appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Spring Boot Application for Pivotal Cloud Cache Service

Pas Apicella - Thu, 2017-04-13 06:21
I previously blogged about the Pivotal Cloud Cache service in Pivotal Cloud Foundry as follows

http://theblasfrompas.blogspot.com.au/2017/04/getting-started-with-pivotal-cloud.html

During that post I promised it will follow with a Spring Boot application which would use the PCC service to show what the code would look like. That demo exists at the GitHub URL below.

https://github.com/papicella/SpringBootPCCDemo

The GitHub URL above shows how you can clone , package and then push this application to PCF using your own PCC service instance using the "Spring Cloud GemFire Connector"



More Information

Pivotal Cloud Cache Docs
http://docs.pivotal.io/p-cloud-cache/index.html



Categories: Fusion Middleware

Webinar Recording: Improve WebCenter Portal Performance by 30% and get out of Oracle ADF Development Hell

In this webinar Fishbowl’s Director of Solutions, Jerry Aber, shared how leveraging modern web development technologies like Oracle JET, instead of ADF taskflows, can dramatically improve the performance of a portal – including the overall time to load the home page, as well as making content or stylistic changes.

Jerry also shared how to architect a portal implementation to include a caching layer that further enhances performance. These topics were all be backed by real world customer metrics that Jerry and Fishbowl team have seen through numerous, successful customer deployments.

If you are a WebCenter Portal administrator and are frustrated with challenges of improving your ADF-centric portal, this webinar is for you. Watch to learn how to overhaul the ADF UI, which will lead to less development complexities and ensure more happy users.

 

The post Webinar Recording: Improve WebCenter Portal Performance by 30% and get out of Oracle ADF Development Hell appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Getting Started with Pivotal Cloud Cache on Pivotal Cloud Foundry

Pas Apicella - Sun, 2017-04-09 22:57
Recently we announced the new cache service Pivotal Cloud Cache (PCC) for Pivotal Cloud Foundry (PCC). In short Pivotal Cloud Cache (PCC) is a opinionated, distributed, highly available, high speed key/value caching service. PCC can be easily horizontally scaled for capacity and performance.

In this post we will show how you would provision a service, login to the Pulse UI dashboard, connect using GFSH etc. I won't create a spring boot application to use the service at this stage BUT that will follow in a post soon enough.

Steps

1. First you will need the PCC service and if it's been installed it will look like this


2. Now let's view the current plans we have in place as shown below

pasapicella@pas-macbook:~$ cf marketplace -s p-cloudcache
Getting service plan information for service p-cloudcache as papicella@pivotal.io...
OK

service plan   description          free or paid
extra-small    Plan 1 Description   free
extra-large    Plan 5 Description   free

3. Now let's create a service as shown below

pasapicella@pas-macbook:~$ cf create-service p-cloudcache extra-small pas-pcc
Creating service instance pas-pcc in org pivot-papicella / space development as papicella@pivotal.io...
OK

Create in progress. Use 'cf services' or 'cf service pas-pcc' to check operation status.

4. At this point it will asynchronously create the GemFire cluster which is essentially what PCC is. For more Information on GemFire see the docs link here.

You can check the progress one of two ways.

1. Using Pivotal Apps manager as shown below


2. Using a command as follows

pasapicella@pas-macbook:~$ cf service pas-pcc

Service instance: pas-pcc
Service: p-cloudcache
Bound apps:
Tags:
Plan: extra-small
Description: Pivotal CloudCache offers the ability to deploy a GemFire cluster as a service in Pivotal Cloud Foundry.
Documentation url: http://docs.pivotal.io/gemfire/index.html
Dashboard: http://gemfire-yyyyy.run.pez.pivotal.io/pulse

Last Operation
Status: create in progress
Message: Instance provisioning in progress
Started: 2017-04-10T01:34:58Z
Updated: 2017-04-10T01:36:59Z

5. Once complete it will look as follows


6. Now in order to log into both GFSH and Pulse we are going to need to create a service key for the service we just created, which we do as shown below.

pasapicella@pas-macbook:~/pivotal/PCF/services/PCC$ cf create-service-key pas-pcc pas-pcc-key
Creating service key pas-pcc-key for service instance pas-pcc as papicella@pivotal.io...
OK

7. Retrieve service keys as shown below

pasapicella@pas-macbook:~$ cf service-key pas-pcc pas-pcc-key
Getting key pas-pcc-key for service instance pas-pcc as papicella@pivotal.io...

{
 "locators": [
  "0.0.0.0[55221]",
  "0.0.0.0[55221]",
  "0.0.0.0[55221]"
 ],
 "urls": {
  "gfsh": "http://gemfire-yyyy.run.pez.pivotal.io/gemfire/v1",
  "pulse": "http://gemfire-yyyy.run.pez.pivotal.io/pulse"
 },
 "users": [
  {
   "password": "password",
   "username": "developer"
  },
  {
   "password": "password",
   "username": "operator"
  }
 ]
}

8. Now lets log into Pulse. The URL is available as part of the output above

Login Page


Pulse Dashboard : You can see from the dashboard page it shows how many locators and cache server members we have as part of this default cluster



9. Now lets log into GFSH. Once again the URL is as per the output above

- First we will need to download Pivotal GemFire so we have the GFSH client, download the zip at the link below and extract to your file system

  https://network.pivotal.io/products/pivotal-gemfire

- Invoke as follows using the path to the extracted ZIP file

$GEMFIRE_HOME/bin/gfsh

pasapicella@pas-macbook:~/pivotal/software/gemfire/pivotal-gemfire-9.0.3/bin$ ./gfsh
    _________________________     __
   / _____/ ______/ ______/ /____/ /
  / /  __/ /___  /_____  / _____  /
 / /__/ / ____/  _____/ / /    / /
/______/_/      /______/_/    /_/    9.0.3

Monitor and Manage Pivotal GemFire
gfsh>connect --use-http --url=http://gemfire-yyyy.run.pez.pivotal.io/gemfire/v1 --user=operator --password=password
Successfully connected to: GemFire Manager HTTP service @ http://gemfire-yyyy.run.pez.pivotal.io/gemfire/v1

gfsh>

10. Now lets create a region which will use to store some cache data

$ create region --name=demoregion --type=PARTITION_HEAP_LRU --redundant-copies=1
  
gfsh>create region --name=demoregion --type=PARTITION_HEAP_LRU --redundant-copies=1
Member | Status
----------------------------------- | ---------------------------------------------------------------------
cacheserver-PCF-PEZ-Heritage-RP04-1 | Region "/demoregion" created on "cacheserver-PCF-PEZ-Heritage-RP04-1"
cacheserver-PCF-PEZ-Heritage-RP04-0 | Region "/demoregion" created on "cacheserver-PCF-PEZ-Heritage-RP04-0"
cacheserver-PCF-PEZ-Heritage-RP04-2 | Region "/demoregion" created on "cacheserver-PCF-PEZ-Heritage-RP04-2"
cacheserver-PCF-PEZ-Heritage-RP04-3 | Region "/demoregion" created on "cacheserver-PCF-PEZ-Heritage-RP04-3"

Note: Understanding the region types you can create exist at the Pivotal GemFire docs but basically in the example above we create a partitioned region where primary and backup data is stored among the cache servers. As you can see we asked for a single backup copy of each region entry to be placed on a separate cache server itself for redundancy

http://gemfire.docs.pivotal.io/geode/developing/region_options/region_types.html#region_types

11. If we return to the Pulse Dashboard UI we will see from the "Data Browser" tab we have a region


12. Now lets just add some data , few entries which are simple String key/value pairs only
  
gfsh>put --region=/demoregion --key=1 --value="value 1"
Result : true
Key Class : java.lang.String
Key : 1
Value Class : java.lang.String
Old Value : <NULL>


gfsh>put --region=/demoregion --key=2 --value="value 2"
Result : true
Key Class : java.lang.String
Key : 2
Value Class : java.lang.String
Old Value : <NULL>


gfsh>put --region=/demoregion --key=3 --value="value 3"
Result : true
Key Class : java.lang.String
Key : 3
Value Class : java.lang.String
Old Value : <NULL>

13. Finally lets query the data we have in the cache
  
gfsh>query --query="select * from /demoregion"

Result : true
startCount : 0
endCount : 20
Rows : 3

Result
-------
value 3
value 1
value 2

NEXT_STEP_NAME : END

13. We can return to Pulse and invoke the same query from the "Data Browser" tab as shown below.



Of course storing data in a cache isn't useful unless we actually have an application on PCF that can use the Cache BUT that will come in a separate post. Basically we will BIND to this service, connect as a GemFire Client using the locators we are given as part of the service key and then extract the cache data we have just created above by invoking a query.

More Information

Download PCC for PCF
https://network.pivotal.io/products/cloud-cache

Data Sheet for PCC
https://content.pivotal.io/datasheets/pivotal-cloud-cache
Categories: Fusion Middleware

Hackathon Weekend at Fishbowl Solutions: Bots, Cloud Content Migrations, and Lightweight ECM Apps

Hackathon 2017 captains – from L to R: Andy Weaver, John Sim, and Jake Ferm.

It’s hackathon weeked at Fishbowl Solutions. This means our resident hackers (coders) will be working as teams to develop new solutions for Oracle WebCenter, enterprise search, and various cloud offerings. The theme overall this year is The Cloud, and each completed solution will integrate with a cloud offering from Oracle, Google, and perhaps even a few others if time allows.

This year three teams have formed, and they all began coding today at 1:00 PM. Teams have until 9:00 AM on Monday, April 10th to complete their innovative solutions. Each team will then present and demo their solution to everyone at Fishbowl Solutions during our quarterly meeting at 4 PM. The winning team will be decided by votes from employees that did NOT participate in the hackathon.

Here are the descriptions of the three solutions that will be developed over the weekend:

Team Captain: Andy Weaver
Team Name – for now: Cloud ECM Middleware
Overview: Lightweight ECM for The Cloud. Solution will provide content management capabilities (workflow, versioning, periodic review notifications, etc.) to Google’s cloud platform. Solution will also include a simple dashboard to notify users of documents awaiting their attention, and users will be able to use the solution on any device as well.

Team Captain: John Sim
Team Name: SkyNet – Rise of the Bots
Overview: This team has high aspirations as they will be working on a number of solutions. The first is a bot that they are calling Atlas that will essentially query Fishbowl’s Google Search Appliance and return documents, which are stored in Oracle WebCenter, based on what was asked. For example, “show me the standard work document on on ordering food for the hackathon”. The bot will use Facebook messenger as the input interface, and if time allows, a similar bot will be developed to support Siri, Slack, and Skype.

The next solution the team will try and code by Monday will be a self-service bot to query a human capital management/human resources system to return how many days of PTO the employee has.

The last solution will be a bot that integrates Alexa, which is the voice system that powers the Amazon Echo, with Oracle WebCenter. In this example, voice commands could be used to ask Alexa to tell the user the number of workflow items in their queue, or the last document checked in by their manager.

Team Captain: Jake Ferm
Team Name – for now: Cloud Content Migrator
Overview: Jake’s team will be working on an interface to enable users to select content to be migrated across Google Drive, Microsoft OneDrive, DropBox, and the Oracle Documents Cloud Service. The goal with this solution is to enable with as few clicks as possible the ability to, for example, migrate content from OneDrive to the Oracle Documents Cloud Service. They will also be working on ensuring that content with larger file sizes can be migrated in the background so that users can carry on with other computer tasks.

Please check back on Tuesday, April 11th for a recap of the event and details on the winning solution. Happy hacking!

Taco bar to fuel the hackers!

 

The post Hackathon Weekend at Fishbowl Solutions: Bots, Cloud Content Migrations, and Lightweight ECM Apps appeared first on Fishbowl Solutions.

Categories: Fusion Middleware, Other

Pivotal Cloud Foundry Cloud Service Brokers for AWS, Azure and GCP

Pas Apicella - Tue, 2017-04-04 00:10
Pivotal Cloud Foundry (PCF) has various cloud service brokers for all the public clouds we support which include AWS, Azure and GCP. You can download and install those service brokers on premise or off premise giving you the capability to use Cloud services where it makes sense for your on premise or off premise cloud native applications.

https://network.pivotal.io/

The three cloud service brokers are as follows:





In the example below we have a PCF install running on vSphere and it has the AWS service broker tile installed as shown by the Ops Manager UI


Once installed this PCF instance can then provision AWS services and you can do that one of two ways.

1. Using Apps Manager UI as shown below


2. Use the CF CLI tool and invoking "cf marketplace" to list the service and then "cf create-service" to actually create an instance of the service.



Once provisioned within a SPACE of PCF you can then bind and use the service from applications as you normally would to consume the service reading the VCAP_SERVICES ENV variable and essentially access AWS services from your on premise installation of PCF in the example above.

More Information

GCP service broker:
https://network.pivotal.io/products/gcp-service-broker

AWS service broker:
https://network.pivotal.io/products/pcf-service-broker-for-aws

Azure service broker:
https://network.pivotal.io/products/microsoft-azure-service-broker


Categories: Fusion Middleware

Pages

Subscribe to Oracle FAQ aggregator - Fusion Middleware