Are you the publisher? Claim or contact us about this channel


Embed this content in your HTML

Search

Report adult content:

click to rate:

Account: (login)

More Channels


Channel Catalog


Channel Description:

Welcome to Oracle Blogs

Welcome to the Oracle blogging community!

older | 1 | .... | 961 | 962 | (Page 963) | 964 | 965 | .... | 989 | newer

    0 0

    We are pleased to announce the general availability of the Oracle Container Registry. The Container Registry is designed to provide simple access to Oracle products for use in Docker containers.                                         

    The available products on the Oracle Container Registry include:

    • Oracle Linux 7, 6, and 5
    • Oracle JDK 8 (Server JRE)
    • Oracle WebLogic Server 12, Tuxedo, Coherence and the Fusion Middleware Web Tier
    • Oracle Database 12c Standard Edition 2 and Enterprise Edition
    • MySQL 5.7 Community Edition

    Oracle will be expanding this list with additional products in the future.

    Currently, access to the Oracle Container Registry is limited to customers in the United States, United Kingdom and Australia.

    How do I login to the Oracle Container Registry?

    Point your browser at https://container-registry.oracle.com. If this is the first time you’re visiting the Container Registry, you will need to associate your existing Oracle SSO credentials or create a new account. Click the “Register” button and select either: “I Already Have an Oracle Single Sign On Account” to associate your existing account or “I Don't Have an Oracle Single Sign On Account” to create a new account.

    Once you have an account, click the login button to log into the Container Registry. You will be prompted to read and accept the license agreement. Note that acceptance of the license agreement is required to download images using the Docker command-line tool and that acceptance only persists for eight (8) hours.

    After accepting the license, you can browse the available business areas and images to review which images you’d like to pull from the registry using the Docker client.

    How do I pull images using the Docker client?

    Once you’ve accepted the license via the web interface, you can login and pull images using the Docker client.

    First, login to the Container Registry using the docker login command:

    $ docker login container-registry.oracle.com

    You should provide the same Oracle SSO credentials that were used to login to the web interface and accept the license. Once you have successfully logged in, you can pull images:

    $ docker pull container-registry.oracle.com/java/serverjre:8

    Each image has its own documentation that can be reviewed via the Container Registry web interface.

    How do I store images locally?

    We recommend deploying a local Docker registry to store images both from the Oracle Container Registry as well as those created and extended locally. This also means you can deliver images to your servers locally without having to download them each time across the Internet.

    The Oracle Linux Docker User Guide includes instructions on how to setup a local registry.

    How do I adapt and extend these images?

    Oracle provides these images as a convenient method for customers and users to get started with Oracle products within Docker containers.

    However, we also provide the Oracle Docker Images GitHub repository which contains base product Dockerfiles as well as samples of how to extend these images to create custom containers for each product.

    The GitHub repository files can also be used to recreate or adapt the base images to suit on-premises requirements.

    Support

    Support for Docker is provided at no extra cost to customers with Oracle Linux Basic or Premier Support Subscriptions.

    If you do not have paid support, you can get peer support via the Oracle Community forums at https://community.oracle.com.


    0 0

    imageJanuary 2017 top tweets by soaCommunity

    Send your tweets @soacommunity#soaCommunity and follow us at http://twitter.com/soacommunity. Make sure you share your content with the community!

    SOA & BPM Partner Community

    For regular information on Oracle SOA Suite become a member in the SOA & BPM Partner Community for registration please visit www.oracle.com/goto/emea/soa (OPN account required) If you need support with your account please contact the Oracle Partner Business Center.

    BlogTwitterLinkedInimage[7][2][2][2]Facebookclip_image002[8][4][2][2][2]Wiki


    0 0

    MySQL Cluster helps you conquer the database challenges of next generation web, cloud, and communications services with uncompromising scalability, uptime and agility.

    With MySQL Cluster training, you'll gain valuable, hands-on experience installing and configuring a real-time database cluster at the core of your application.

    Using MySQL Cluster's open-source and enterprise components, this course gives you a chance to develop the skills to properly design and maintain your clusters for high availability and scalability.

    Need a MySQL Online Learning Resource that's Constantly Updated?

    The all new MySQL Learning Subscription includes all-digital content that's regularly updated as technology evolves. Access training content 24/7. 

    Administrators and developers: get 12 months of access to fresh training content to help you develop skills and knowledge you can apply to your job on a daily basis. 

    PREVIEW NOW!


    0 0

    Oracle Data Integrator (ODI) 12.2.1.2.6 now supports Git as an external Version Control System (VCS). Now you can use either Apache Subversion or Git for source controlling ODI objects. Regardless of which technology is used, the user experience for an ODI user will be the same for any versioning operation and the underlying differences between the two systems are transparent to ODI users. This is consistent with the ODI core benefits of keeping users shielded from learning underlying systems and providing a seamless experience across technologies.

    In addition, there are numerous new features added to increase productivity and address various use cases. Now you can have a consolidated view and manage all out-of-sync versioned objects from a single screen. The ODI Populate Repository option is also enhanced to allow populating a repository from a tag so that you can restore objects state from it. You can create version for all dependent object as well, along with versioning of the base object. There are options provided to regenerate scenarios during tag or deployment archive creation to ensure that the scenario corresponds to the current state of the corresponding object in VCS. The automatic merge process is made smarter to perform three way merge with change detection which reduces conflicts during branch merges.

    In this article we are going to explore the version control related features and capabilities. I will cover the smart merge capabilities in a later article so stay tuned for that.

    Configuring Git

    The administrator needs to first enable Git as version control system and configure the repository connectivity.


    Selecting Git as version control system will enable all the Git related configuration menu options. You can switch anytime between the version control systems so an ODI repository, previously configured with Subversion, can be switched to Git-based versioning. ODI however, does not migrate the version history during such switch so you need to migrate any such history directly though the tools provided by those systems.

    Selecting Git for versioning enables the VCS settings options in the studio menu.

    You need to perform all three settings configuration in the order of their appearance. The Edit Connection dialog configures Git connectivity details such as authentication type (protocol), URL, password etc. After connection setup, you can create and configure local Git repository through Clone Remote Repository operation. Then select the Git branch through the Configure menu option. Once successfully configured, you will notice that the Git indicator in the bottom right corner of ODI Studio turns green from grey indicating successful Git configuration. The indicator also displays the configured Git branch name – for example master branch in below screenshot.

    Managing Versions

    All the Lifecycle Management functionalities that existed in previous ODI releases for creating and managing versions in Subversion are now available for Git as well. Some of the operations are as follows

    1. Adding one or more objects to VCS
    2. Creating versions for modified objects that are out of sync from VCS
    3. Viewing version history – Hierarchical view and Tabular view
    4. Comparing difference between two object versions in VCS or comparing the VCS version with repository object
    5. Restoring an object version from VCS
    6. Restoring a deleted object from VCS

    Since these functionalities are the same as noted earlier, I am not going to cover their details here. Instead, I will focus here on the new options provided in the latest release to make these more user friendly. If you are interested in details on above-mentioned operations, please refer to my previous postOracle Data Integrator 12.2.1 - Managing Versions in Apache Subversion.

    New options while creating versions

    There are a couple of useful options available when adding a new object to VCS or creating new version of an already versioned object. These advanced options are available at the bottom of all the versioning dialogs. By default, they are not selected to give you the existing behavior from previous releases.

    1. Include Dependencies
    2. Regenerate and Version Scenarios

    Include Dependencies

    This option allows you to ensure that all the dependencies of an object are also versioned along with the object. For example if you are versioning a mapping which uses two data sources which in turn depends upon some technology or logical schema, then using this option you can version all these objects in a single operation along with the mapping itself.

    If a dependent object is not yet versioned then it adds it to Git or Subversion or if a dependent object is out-of-sync with VCS systems then it creates a new version. If the dependent object is already versioned then it will not do anything for that object.

    This option is particularly useful in keeping consistency in the versioned objects in VCS, which is key for continuous integration. It removes any chances of missing to create a version for a dependent object so that the current copies of all the relevant objects are present in VCS.

    Regenerate and Version Scenarios

    This option takes care of regenerating the scenario before creating a version for it in VCS. If you also select Include Dependencies then it regenerate a scenario for any of the selected objects and their dependent objects.

    This option will be useful when you want to ensure that the scenarios present in your VCS correspond to the current copy of the corresponding object in VCS. Such requirement could be crucial if you have an automated build and testing process, which takes the scenarios from VCS and validates them.

    Pending Changes

    The newly introduced Pending Changes dialog allows you to manage objects that are out-of-sync from a single place. You can access it from ODI Studio Team menu option.

    The Pending Changes dialog shows the list of all the versioned objects from the ODI repository that are out-of-sync. If you are looking for a particular object, you can directly reach to it through the search field. This dialog allows you to perform following operations on the selected objects.

    1. Create version for the selected object(s) here if the selected object is a deleted object from ODI Repository then you can push the deletion to VCS.
    2. Restore a deleted object from VCS. This option is applicable only when you select all the deleted objects.
    3. Compare the highlighted object with the VCS version.

    New options while creation Tag

    There are a couple of useful options provided during a Tag creation allowing you to control this:

    1. Option to add only the versioned objects to the tag. This provides flexibility of creating Full Tag with only versioned object is a very useful flexibility that allows you to push all the versioned objects along with dependencies to VCS in a single operation.
    2. Regenerate and version scenarios so that the scenarios referred by a Tag always corresponds to the relevant object in the Tag.

    New options while Populating Repository from VCS


    The enhanced Populate ODI repository from VCS dialog provides a number of flexibility.

    1. Populate from branch or Tag: Now not only you can populate ODI repository contents from the currently configured branch but you can also restore the objects from a particular Tag created on the current branch.
    2. It now gives you the flexibility to select either all the objects or a subset of objects to be populated from the selected Tag or branch. Such selective populating will be useful if you want to break down the process into smaller chunks or if you are interested only in a selected subset of objects from the branch or Tag. However, this flexibility comes with a pitfall that you may miss to import some of the dependent objects affecting the repository objects consistency. So this selective population process should be used with caution.
    3. Deleting existing work repository objects from ODI repository before populating objects from VCS. This will be useful in ensuring that there are no remnant of old work repository and after populate the ODI work repository objects are in sync with VCS contents.

    SDK APIs for Continuous Integration

    One of the needs for Continuous Integration is to automate the Tag Creation and Deployment Archive build process. There are a couple of services available in ODI SDK APIs that allows you to automate your entire build and testing process. VersionManagementService provides the necessary APIs to configure the VCS system, create Tags, and populate an ODI repository from the VCS contents from a Tag. DeploymentService provides APIs for creating Deployment Archive and applying it to target ODI Repository.

    Conclusion

    The enhancements added in Oracle Data Integrator (ODI) 12.2.1.2.6 around Lifecycle Management capabilities provides broader support for the leading Version Control Systems, improves developer’s productivity, and addresses the needs for automating Continuous Integration and build process. Yet again ODI differentiates itself by providing Lifecycle Management capabilities not available in any other competing products.


    0 0


     The January edition of the PaaS & Middleware Partner Update contains three key topics:

    • PaaS Partner Community Forum
    • Developer Gateway & Code Events
    • SOA & BPM Partner Community Webcasts January 31st 2017

    For regular updates please subscribe to our YouTube channel here. Thanks for your likes and sharing the video on YouTube and LinkedIn. For the latest SOA & BPM Partner Community information please visit our Community update wiki here (Community membership required).

    SOA & BPM Partner Community

    For regular information on Oracle SOA Suite become a member in the SOA & BPM Partner Community for registration please visit www.oracle.com/goto/emea/soa (OPN account required) If you need support with your account please contact the Oracle Partner Business Center.

    BlogTwitterLinkedInimage[7][2][2][2]Facebookclip_image002[8][4][2][2][2]Wiki

    Technorati Tags: PaaS,PaaS for SaaS,SaaS,YouTube,SOA Community,Oracle SOA,Oracle BPM,Jürgen Kress,Middleware Update,Partner Update

    0 0

    Today Oracle released a great new GitHub project - Oracle Database Programming Interface for C. It sits on top of OCI and offers an alternative programming experience. ODPI-C is a C library that simplifies the use of common Oracle Call Interface (OCI) features for Oracle Database drivers and user... [Read More]

    0 0

    Jdeveloper logoWhen you create extensions to Oracle E-Business Suite OA Framework pages, you must use the version of Oracle JDeveloper shipped by the Oracle E-Business Suite product team. 

    The version of Oracle JDeveloper is specific to the Oracle E-Business Suite Applications Technology patch level, so there is a new version of Oracle JDeveloper with each new release of the Oracle E-Business Suite Applications Technology patchset.

    The Oracle Applications (OA) Extensions for JDeveloper 10g for E-Business Suite Release 12.2.6 have recently been updated.  For details, see:

    The same Note also lists the latest OA Extension updates for EBS 11i, 12.0, 12.1, and 12.2.

    Related Articles


    0 0

    Introduction

    In parts IV and V of this series I covered the Composite Component API in terms of properties and events. This part will complete the story by looking at Composite Component methods.

    Methods, in this context, are functions that are exposed by the component that you are able to call on the composite once it is running. You can use these as a way to pass information into the Composite Compnent after it has been started, or manipulate the component as a whole in some other way. 

    A Note on Passing Data into A Running Composite Component

    As a side note it's worth reminding you of alternative ways of passing data into the Composite Component once it is up and running. Although methods can indeed be used for this, they are not the only way. You can leverage the binding syntax ([[...]] or {{...}}) combined with property change listeners as discussed in the previous article to achieve this as well. Likewise you can set the properties directly from JQuery without using bindings e.g. $('#cc1').prop('badge-name','Fred Flintstone'); or even directly on the DOM element $('#cc1')['badge-name'] = 'Fred Flintstone';. All of these will achieve the end of passing data changes in to the component when the relevant data endpoint for doing so is exposed as a writeable CCA property.  

    The one advantage of using a Composite Component method though is, of course, that the method call can encapsulate a potentially complex data structure to pass and maybe you also need to update the internals of the Composite Component that are not exposed through published properties. 

    Defining Custom Methods

    Just like properties and events, Composite Component Methods are declared in the Composite metadata. As an example, let's take our ongoing ccdemo-name-badge component and add a method called changeBackground that will update the background color of the badge. We'll have this take a single string parameter with the color name or code to assign. I'll also have it provide a return value to illustrate how that's done.

    Not surprisingly we do this by adding a top level property to the metadata object called methods to the ccdemo-name-badge.json file. This object then defines a sub-property for each method that the component needs to expose.

        {
          "name" : "ccdemo-name-badge",
          "version" : "1.0.0",
          "jetVersion" : ">=2.2.0",      
          "properties": {
            "badge-name": {
              "description" : "Full name to display on the badge",
              "type": "string"
            },
            "badge-image": {
              "description" : "URL for the avatar to use for this badge",
              "type": "string"
            }
          },
          "events" : {
            "badgeSelected" : {
              "description" : "The event that consuming views can use to recognize when this badge is selected",
              "bubbles" : true,
              "cancelable" : false,
              "detail" : {
                "nameOnBadge" : {"type" : "string"}
              }
            }
          },
          "methods" : {
            "changeBackground" : {
              "description" : "A function to update the background color of the badge",
              "internalName" : "_setBackgroundColor",
              "params" : [
                {
                  "description":"Color name or hex color code",
                  "name" : "colorToSet",
                  "type": "string"
                }
              ],
              "return" : "boolean"
            }
          }
        }
        
    Let's look at each of the properties of the changeBackground method

    The description

    As in the other cases within this metadata, the description property is simply there to help your consumers and provide information for design time tooling to display. As such it's optional but recommended.

    The internalName

    This is an optional property which allows you to define a name for the implementing function inside of your Composite Component viewModel which is different from the public name that you provide as the API. In this example, the public name that consumers will use is called changeBackground but the implementing function in the Composite is called _setBackgroundColor. The framework automatically manages the mapping for you. You don't have to set an internalName, if you don't then the framework will just map directly to a function within the Composite that matches the method name.

    The params

    As the name suggests, params is a place to declare any parameters that your public method may accept. The params property itself, if specified (it's optional), should define an array of sub-objects which are defined with a description, name and type property as shown here. The type definition matches the those you would use for defining properties although there is no type coercion in this case, the definition is purely informational, although design time tooling may take advantage of it.

    The return

    Should your method return a value you can declare this in the metadata. Again this is purely for informational purposes and no conversion or checking takes place.

    Implementing a Composite Component Method

    In order to implement your method, all you need to do is to define the appropriate function in the Composite Component View Model. The name of the function should match the name that your declared in the Metadata, or the supplied internalName if you supplied that. So, here's our running example where I've implemented the custom method by creating a function with my allocated internalName - _setBackgroundColor.

            define(
                ['ojs/ojcore','knockout','jquery'
                ], function (oj, ko, $) {
                'use strict';
                function CCDemoNameBadgeComponentModel(context) {
                    var self = this;
                    context.props.then(function(propertyMap){
                        //Save the resolved properties for later access
                        self.properties = propertyMap;
                        //Extract the badge-name value
                        var badgeNameAttr = propertyMap['badge-name'];
                        self._extractFirstName(badgeNameAttr);
                    });
    
                    self.composite = context.element;
                    $(self.composite).on('badge-name-changed',function(event){
                        if (event.detail.updatedFrom === 'external'){
                          self._extractFirstName(event.detail.value);
                        }
                    });
    
                    //Wire the custom event raise function into the click on
                    //the composite
                    $(self.composite).on('click keypress',function(event){
                        self._raiseBadgeSelection(event);
                    });
    
                };
    
                CCDemoNameBadgeComponentModel.prototype._extractFirstName = function (fullName) {
                    if (this.upperFirstName === undefined){
                        this.upperFirstName = ko.observable();
                    }
                    this.upperFirstName(fullName.split('')[0].toUpperCase());
                };
    
                //Generate and raise the custom event for Badge Selection
                CCDemoNameBadgeComponentModel.prototype._raiseBadgeSelection = function (sourceEvent) {
                    if (sourceEvent.type === 'click' ||
                        (sourceEvent.type === 'keypress'&& sourceEvent.keycode === 13)){
                        var eventParams = {
                            'bubbles' : true,
                            'cancelable' : false,
                            'detail' : {
                                'nameOnBadge' : this.properties['badge-name']
                            }
                        };
                        //Raise the custom event
                        this.composite.dispatchEvent(new CustomEvent('badgeSelected',eventParams));
                    }
                };
    
                //Internal implementation of the changeBackground Composite Method
                CCDemoNameBadgeComponentModel.prototype._setBackgroundColor = function (colorToSet) {
                    var wasChanged = true;
                    if (this.lastSetColor !== undefined && this.lastSetColor === colorToSet){
                        wasChanged = false;
                    }
                    else {
                        $(this.composite).children('.badge-face').css('background',colorToSet);
                        this.lastSetColor = colorToSet;
                    }
                    return wasChanged;
                };
    
    
                return CCDemoNameBadgeComponentModel;
            });
          
    The implementation as you can see trivially updates the background-color of the main badge div and then returns a boolean value based on if the incoming value is the same as or different from the last one set.

    Calling Composite Component Methods

    Once the implementation function and the associated metadata is defined, the named custom method is just exposed on the custom component element. Thus we could call it using syntax such as:

          var wasChanged =document.getElementById("cc1").changeBackground("red");
          
    or
          var wasChanged = $("#cc1")[0].changeBackground("red");
          
    The important thing here is that other methods within the Composite Component viewModel, that are not exposed through the metadata, are kept private.

    What's Next

    In the next article, I'll be taking a look at the lifecycle methods exposed by the Composite Component Architecture and how that might be affected by your component definition.


    Composite Component Article Series Index

    1. Introduction
    2. Your First Composite Component - A Tutorial
    3. Composite Conventions and Standards
    4. Attributes, Properties and Data
    5. Events
    6. Methods

    0 0

    The growth of low-cost storage platforms has allowed many companies to actively seeking out new external data sets and combine them with internal historical data that goes back over a very long time frame. Therefore, as both the type of data and the volume of data continue to grow the challenge for many businesses... [Read More]

    0 0

    image

    Attend our January edition of the SOA & BPM Partner Community Webcast live on January 31st 2017 at 16:00 CET.

    Oracle B2B and evolution to API Driven B2B

    This session will present an overview of Oracle B2B platform and show a demo of the current functionality. Oracle B2B is a highly available, high-performing B2B platform that is being used by major customers across different verticals such as retail, supply chain, and utilities. Hear from Product Management about the product overview, architecture, and best practices. Also hear about how B2B integration is evolving into an API driven B2B and hear about Oracle’s vision and roadimage map.

    Krishnaprem Bhatia
    Twitter: KrishnapremB

    Krishnaprem Bhatia is product manager in the Cloud Integration product management team focusing on B2B, Healthcare and API Management products. He has over 15 years of work experience in software development and product management. As a product manager at Oracle he has worked extensively with customers and partners worldwide in all industry verticals. He holds Computer Science & Engineering and MBA degrees and loves to read, travel and work out.

    Call ID: 6965489 Call Passcode: 333111

    UK: +44 (0) 208 118 1001 & United States: 140 877 440 73

    More Local Numbers


    Schedule:

    January 31st 2017 at 16:00-17:00 CET

    Visit the registration page here.

    Missed our SOA & BPM Partner Community Webcast? – watch the on-demand versions:

    ·SOA 12 & BPM Suite 12c Roadmap update November 29th 2016

    ·Microservices October 25th 2016

    ·Oracle OpenWorld 2016 update September 27th 2016

    ·API Cloud Platform Service August 30th 2016

    ·BPM Suite & PCS Update July 26th 2016

    ·Integration Cloud Service June 28th 2016

    ·Sales Plays Webcast June 9th 2016

    ·Real-Time Integration Business Insight May 31st 2016

    For the latest information please visit Community Updates Wiki page (SOA Community membership required).

    SOA & BPM Partner Community

    For regular information on Oracle SOA Suite become a member in the SOA & BPM Partner Community for registration please visit www.oracle.com/goto/emea/soa (OPN account required) If you need support with your account please contact the Oracle Partner Business Center.

    BlogTwitterLinkedInimage[7][2][2][2]Facebookclip_image002[8][4][2][2][2]Wiki

    Technorati Tags: SOA Community,Oracle SOA,Oracle BPM,OPN,Jürgen Kress,webcast


    0 0

    I’m out on vacation this week, but you’re in luck. I have to do the Southwest 24 hour check-in thing, so that means I’m stuck on my laptop for a few minutes. If you’re a command-line kind of guy or gal, then you know all about SQL*Plus. If you’ve spent any time here, then you also know all... [Read More]

    0 0

    The Oracle Mexico Payroll End of Year 2016 Phase 2 patches have been released and are now available on My Oracle Support!

    End of Year 2016 Phase 2 patches:

    R12.1 - Patch 25444692:R12.PAY.B
    R12.2 -
    Patch 25444692:R12.PAY.C


    Highlights

    - UMA (Unidad de Medida y Actualización – Unit of Measure and Update) will be the index to compute Mexico taxation and replaces the Minimum Wage.

    - New Tamaulipas state tax rate.

    UMA Support Implications

    • In December 2016, the IMSS government agency confirmed that the Minimum Wage should still serve as the index to compute the Social Security quotas for 2017 onwards.
    • On January 26th, 2017, IMSS disclaimed that UMA must be used to compute Social Security quotation effective February 1, 2017.
    • As result of this last minute change, we have had to revert back the source code updates to support Minimum Wage for Social Security and UMA for ISR and State Taxes (originally planned to be included in the End of Year 2016 Phase 2 patch) and implement a quick workaround solution to support UMA.
    • The definitive solution to support UMA and Minimum Wage will be included in the End of Year 2016 Phase 3 patch.

    Please note:

    • The Year End 2016 Phase 2 patch includes the 2017 Year Begin patch (25258590:R12.PAY.x) so you do not need to apply it separately if you are planning to install the End of Year 2016 Phase 2 patch.
    • Due to the simultaneous support of two CFDI versions (the old and the new) during the extension period given by SAT (January 1, 2017 to March 31 2017), the End of Year 2016 Phase 2 patch DOES NOT include End of Year 2016 Phase 1 so you must apply BOTH patches if you are planning to use version 1.2 of the CFDI Payroll Payslip.
    • A subsequent new patch, End of Year 2016 Phase 3, will soon be released to merge the two patch branches that were required to simultaneously support multiple CFDI versions. The End of Year 2016 Phase 3 patch will include all of the Year End patches as well as the latest statutory updates. Please review the 2016 Mexico Year End Patch Schedule available in My Oracle Support Knowledge Document 975677.1.
    End of Year 2016 Phase 2 Functional Readme's

    Note 2200278.1 - Release R12.1.x Year End 2016 Phase 2 Readme

    Note 2200279.1 - Release R12.2.x Year End 2016 Phase 2 Readme

    These patches are different from all other statutory updates (there are additional post installation steps), so please be sure to carefully read the entire patch readme before installing these patches to ensure successful processing.

    Mandatory Patch Information for Oracle Mexico Payroll:

    R12.1.X Payroll Mandatory Patch List, see My Oracle Support Knowledge Document 941743.1
    R12.2.X Payroll Mandatory Patch List, see My Oracle Support Knowledge
    Document 1677134.1

    If you encounter any issues with this Patch, please raise a Service Request via My Oracle Support, product Oracle HRMS (Mexico)


    0 0

    New Parameters in Oracle Database 12.1.0.2 with July 2016 PSU/BP By following an internal discussion and checking parameter changes between Patch Set Updates (PSU) and Proactive Bundle Patches (BP) I learned that we introduced two new SPFILE parameters in Oracle Database 12.1.0.2 with the July PSU and BP. One is... [Read More]

    0 0

    The February edition of the PaaS & Middleware Partner Update contains three key topics:

    • Apiary acquisition & API Cloud Service
    • Free on-demand training for SOA 12c, BPM 12c and WebLogic Suite 12c
    • SOA & BPM Partner Community Webcasts February 28th 2017

    Please like and share the video at LinkedIn and Twitter. For regular updates please subscribe to our YouTube channel here. Thanks for your likes and sharing the video on YouTube and LinkedIn. For the latest SOA & BPM Partner Community information please visit our Community update wiki here (Community membership required).

    SOA & BPM Partner Community

    For regular information on Oracle SOA Suite become a member in the SOA & BPM Partner Community for registration please visit www.oracle.com/goto/emea/soa (OPN account required) If you need support with your account please contact the Oracle Partner Business Center.

    BlogTwitterLinkedInimage[7][2][2][2]Facebookclip_image002[8][4][2][2][2]Wiki

    Technorati Tags: PaaS,PaaS for SaaS,SaaS,YouTube,SOA Community,Oracle SOA,Oracle BPM,Jürgen Kress,Middleware Update,Partner Update


    0 0


    On completion of this year's UK Early Adopter Program the following patch is now available to download and apply via My Oracle Support. 
    This patch provides the changes required for completing processing for the UK 2016/17 tax year, and the legislative updates effective from 6th April 2017.

    This patch also includes Real Time Information changes for the tax year beginning on 6th April 2017.



    R12.1 –Patch 25398061:R12.PAY.B

    This patch delivers the following changes:

    • Autumn Statement Changes
    • Student Loan Changes
    • Apprenticeship Levy Changes
    • Real Time Information Changes:
      • Employer Payment Summary (EPS)
      • Full Payment Summary (FPS)
      • Earlier Year Updates (EYU)
      • EYU Reconciliation Report
    • P60 Reports Changes
    • Replacement P60s
    • Scottish Rate of Income Tax Changes
    • NI Prefix Changes effective from Nov 2016
    • Payrolling of Benefits.

    Please refer to MOS Note for further details:

    Oracle Support Document 2175951.1 (UK legislative Changes for end of tax year 2016/17, the start of tax year 2017/18 and the Real Time Information changes effective from April 2017)

    Please note:

    • That this patch includes changes required as a result of the early adopter program and therefore supersedes the early adopter patch released near the beginning of January.
    • Post Install steps need to be run after patch installation. The patch Readme has important installation, setup instructions and guidelines.
    • The TYE patch delivers limited Payrolling of Benefits in Kind (BIK) functionality, it does not include the full functionality. An additional patch will be released with full details prior to the BIK EAP program which begins on 13th February 2017.  A further communication will be sent when this patch is available.


    The following My Oracle Support notes have been updated:

    Note 862407.1: UK Payroll Mandatory Patches (R12.1)

    If you encounter any questions or issues with this Patch, please visit the Payroll - EBS (MOSC) Community or raise a Service Request via My Oracle Support, product Oracle HRMS (UK)



    0 0

    Oracle currently plans to disable MD5 signed JARs in the upcoming Critical Patch Update slated for April 18, 2017.  JAR files signed with MD5 algorithms will be treated as unsigned JARs.

    MD5 JAR file signing screenshot

    Does this affect EBS environments?

    Yes. This applies to Java 6, 7, and 8 used in EBS 12.1 and 12.2.  Oracle E-Business Suite uses Java, notably for running Forms-based content via the Java Runtime Environment (JRE) browser plug-in.  Java-based content is delivered in JAR files.  Customers must sign E-Business Suite JAR files with a code signing certificate from a trusted Certificate Authority (CA). 

    A code signing certificate from a Trusted CA is required to sign your Java content securely. It allows you to deliver signed code from your server (e.g. JAR files) to users desktops and verifying you as the publisher and trusted provider of that code and also verifies that the code has not been altered. A single code signing certificate allows you to verify any amount of code across multiple EBS environments. This is a different type of certificate to the commonly used SSL certificate which is used to authorize a server on a per environment basis. You cannot use an SSL certificate for the purpose of signing jar files. 

    Instructions on how to sign EBS JARs are published here:

    Where can I get more information?

    Oracle's plans for changes to the security algorithms and associated policies/settings in the Oracle Java Runtime Environment (JRE) and Java SE Development Kit (JDK) are published here:

    More information about Java security is available here:

    Getting help

    If you have questions about Java Security, please log a Service Request with Java Support.

    If you need assistance with the steps for signing EBS JAR files, please log a Service Request against the "Oracle Applications Technology Stack (TXK)" > "Java."

    Disclaimer

    The preceding is intended to outline our general product direction.  It is intended for information purposes only, and may not be incorporated into any contract.   It is not a commitment to deliver any material, code, or functionality, and should not be relied upon in making purchasing decision.  The development, release, and timing of any features or functionality described for Oracle’s products remains at the sole discretion of Oracle.



    0 0

    Introduction

    Once you get into any serious usage of Composite Components it becomes useful to understand the lifecycle of any component in some detail, this is particularly true if, for example, your components UI needs to be dynamically adjusted at runtime. Fortunately the lifecycle is simple to understand and work with, so let's get on.

    The Complete Lifecycle

    In the following table I outline all of the events and lifecycle methods that can be called as a Composite Component is rendered in a view. Note that all of the methods mentioned are optional, you don't need to create them for the component to work (with the exception of the basic Constructor for the object of course).

    1 pending event raised If the consuming view has registered a listener on the Composite Component for the pending event it will be received as the first indication that the Composite Component is loading
    2 Component viewModel object constructed If the bootstrap script for the Composite Component was passed an object constructor as it's viewModel definition, an instance of the component viewModel will be physically created. The Constructor will be passed a context object (see below).
    or
    initialize lifecycle method executed In the case where an already constructed object (as opposed to a constructor) is passed as the viewModel then the framework will call this initialize method, passing a context object.
    3 activated lifecycle method executed The activated lifecycle method is called and passed the standard context object. At the point in time that this method executes, the base Composite Component element will exist in the HTML DOM, however it will not yet have any child nodes1 so you cannot manipulate the UI at this stage.
    4 attached lifecycle method executed The attached lifecycle method is called and passed the standard context object. At this phase, the view defined by the Composite Component bootstrap script will have been processed and the Composite Component element will now have child elements in the DOM that you can locate and manipulate if necessary. If you need to set up any viewModel values that will be used by knockout bindings in the generated view, this is your last chance to do so
    5 bindingsApplied lifecycle method executed The bindingsApplied lifecycle method is called and passed the standard context object. At this phase, the Knockout applyBindings has been called on the subtree and any data-bind or other Knockout directives will have been applied. Thus it would be too late to change a DOM element to add a data-bind at this stage.
    6 ready event raised If the consuming view has registered a listener on the Composite Component for the ready event it will be received as the indication that the Composite Component has completed its loading
    7 dispose lifecycle method executed As a module containing this Composite Component is being replaced, this dispose lifecycle method is called with a reference to the Composite element object. This gives you the opportunity to do clean up if required. Note that dispose does not get called if the user resets the page with a manual browser refresh or explicit navigation that does not first replace the current module. Therefore, you cannot rely on this method as the only way of releasing resources.

    As well as these lifecycle methods and events, you can also receive property-changed events throughout the lifetime of the Composite Component should you have listeners registered to do so.

    The context Object

    As shown above, most of the lifecycle objects, as well as the viewModel constructor are passed a common context object. This object contains the following properties:

    1. element - the DOM element that represents the Composite Component itself. Useful if you want to attach listeners (such as property-change listeners) or to manipulate the DOM subtree for the component.
    2. props - A promise that will return the property map for the Composite Component. See Part IV in this series for information on it's usage. Generally I'd recommend storing the resolved property map reference on the Composite Component viewModel as soon as you can2. This will ease later access.
    3. slotNodeCounts - Another promise which, when resolved, returns a list of the slots defined within the Composite Components and the number of nodes assigned to those slots. We cover the slotting feature in Parts VIII and IX of this series.
    4. unique - A string value generated by the framework which will return a unique "identity" for the Composite Component. This identity will take the form of _ojcomposite0 where the trailing number increments for each composite in the view. Note, although this composite identity will be unique within the parent view that embeds the composite component, the generation is not idempotent and the unique identity that is provided for a particular instance of a Composite Component might change from run to run of a view. For a more stable unique identity, you should consider assigning an id to the Composite Component instance in the consuming view. You can then access that id through the supplied element reference e.g. element.id.

    View-Model Constructor v's Object

    You will notice that in step 2 of the lifecycle table, as illustrated above, there are two paths. This specifically relates to what exactly was passed as the viewModel property during the registration phase. Let's explore that.

    If we start off with a conventional Composite Component viewModel definition, something like:

        define(['ojs/ojcore','knockout','jquery'],
          function (oj, ko, $) {
          'use strict';
          function CCDemoNameBadgeComponentModel(context) {
              var self = this;
              …
          };
    
          …
    
          return CCDemoNameBadgeComponentModel;
        });
        
    This defines a constructor function CCDemoNameBadgeComponentModel and then returns it.

    Contrast this with the subtly different variant which is more like what you might use with a standard Knockout view / ojModule:

        define(['ojs/ojcore','knockout','jquery'],
          function (oj, ko, $) {
          'use strict';
          function CCDemoNameBadgeComponentModel() {
              var self = this;
              …
          };
    
          …
    
          return new CCDemoNameBadgeComponentModel;
        });
        
    Note that there are two physical differences here, the first being the lack of a context argument to the constructor function and the second being the use of the new keyword in the return statement. The effect of this new statement, is that rather than just returning the constructor function, this second version returns a pre-created instance of the component viewModel.

    The Composite Component registration process only takes place once for a particular composite, no matter how many instances are being used in the view. During that registration call, if the object passed to the viewModel property is a constructor function then, as each new instance of the physical Composite Component is created on the view, the framework will use this constructor to create a corresponding viewModel. As noted above, the constructor is passed a context object as part of this. This viewModel is therefore dedicated to that instance of the Composite Component. in this normal variant of the lifecycle the initialize lifecycle method is never called.
    If the object passed to the viewModel is instead a instance, rather than a constructor, as in the second example, then all instances of the Composite Component created in that view will use this same pre-created viewModel object. In this case the alternate version of the lifecycle kicks in and the initialize function is called with a context that is appropriate for that instance of the Composite Component. It is, in fact, somewhat unusual to be using this second approach, if you do, it would generally be when you are leveraging a factory object that in turn would be creating a viewModel instance.

    Lifecycle Method Name Customization

    Just to finish off the basic coverage of lifecycle here, it's worth understanding that the lifecycle function names used by default (initialize, activate and so forth) can be overridden. This is accomplished by updating the defaults property of oj.Composite. I strongly recommend that you do not do this. Making such a change would, of course, mean that any Composite Components that you use or consume will need to use the new lifecycle method names and will therefore be incompatible with every other Application that does not.

    What I've Not Covered

    This article is covers the basic Composite Component lifecycle. There are two related further topics that will be discussed in later articles in this series:

    1. Custom Property Parsing
    2. The use of promises during registration
    These are both advanced topics that deserve independent coverage.

    What's Next?

    In this article we encountered the slotNodeCount property of the lifecycle context object. Therefore it makes sense to take a look next at very powerful feature of the Composite Component Architecture - slotting.


    Composite Component Article Series Index

    1. Introduction
    2. Your First Composite Component - A Tutorial
    3. Composite Conventions and Standards
    4. Attributes, Properties and Data
    5. Events
    6. Methods
    7. The Lifecycle

    1 This is not strictly true in the case where you are using slotting, something I cover in the next couple of articles. However, that's not to say that you therefore have free reign to go playing with the DOM nodes at this stage in the lifecycle, you probably shouldn't!

    2 This assumes you are defining a separate viewModel instance for each Composite Component instance. If you are using a shared viewModel for all instances then you would have to be careful to always use the props reference that you receive with each lifecycle method. This will ensure you are using the correct set of properties and other context information for the Composite Component instance in play.


    0 0

    Due to popular demand, Oracle University is happy to offer additional dates to give you a first look at the new features available within the upcoming Oracle Applications Cloud Release 12.

    Learn what this means for you and your organization by attending one of our FREE live training events!

    Join Oracle experts for a series of live webinars. Learn how to best leverage the benefits of the new features and capabilities for Release 12.

    Each live webinar will cover a specific Oracle Cloud application:

    • Human Capital Management (HCM) Cloud
    • Financials Cloud
    • Project Portfolio Management Cloud
    • Supply Chain Management (SCM) Cloud

    Each session will review:

    • New features and functionalities for Release 12
    • Implications and benefits of these new features for your organization

    View webinar schedule below & select title to register

    Topic, Date & Instructor                   Event Title

           Scheduled PST

    FIN - Feb 1, 2017
    Chris Rudd
    Oracle Financials Cloud New Features Preview for Rel 12         10:00am PST
    HCM - Feb 2, 2017
    Amy Kust
    Oracle HCM Cloud New Features Preview for Rel 12         10:00am PST
    PPM - Feb 7, 2017
    Deepak Seth
    Oracle Project Portfolio Management Cloud New Features Preview for Rel 12         08:00am PST
    SCM - Feb 8, 2017
    David Nelson
    Oracle SCM Cloud New Features Preview for Rel 12         08:00am PST


    0 0

    Database migration across platforms of different "endian" (byte ordering) formats using the Transportable Tablespaces (TTS) process has been certified for Oracle E-Business Suite Release R12.1 for several years. 

    This certification has recently been updated to cover the use of the incremental backup option with Database 11.2.0.4 as a source.

    Transportable Tablespaces

    Does it meet your requirements?

    Note that for migration across platforms of the same "endian" format, users are advised to use the Transportable Database (TDB) migration process instead for large databases. The "endian-ness" target platforms can be verified by querying the view V$DB_TRANSPORTABLE_PLATFORM using sqlplus (connected as sysdba) on the source platform:

    SQL> select platform_name from v$db_transportable_platform;
    If the intended target platform does not appear in the output, it means that it is of a different endian format from the source and Transportable Tablespaces (for large databases) or export/import should be used for database migration.

    The use of Transportable Tablespaces can greatly speed up the migration of the data portion of the database - it does not affect metadata which must still be migrated using export/import. We recommend that users initially perform a test migration with export/import on their database with the 'metrics=y' parameter to find out the relative size of data vs metadata in their database and to have a basis to compare any gains in timing. Generally speaking, the larger the relative size of data (as compared to metadata), the more likely it would be that XTTS is suitable to reduce downtime.


    0 0

    Introduction

    Not every Composite Component can be totally self contained. There are some use cases where as well as setting configuration attributes on the tag, you want the consumer to supply whole chunks of markup to embed within the component. An example of this might be a component which shows a collection as a table with a standard toolbar. If you want to be able to allow the consumer to add their own content to the toolbar how might you do it? Well, slotting is one way. Simply put, slotting is a way of naming reserved spots within the Composite Component into which consumer content can be injected. This allows you to make your Composite Components more extensible without having to dream up and code for every possible form of extension. For those of you familiar with the Java EE JavaServer Faces framework, slots are analogous to named facets in JSF components.

    Using a Composite Component with Slots

    First of all, let's look at the process of consuming a Composite Component which has one or more slots defined. To illustrate this, we'll go back to the ccdemo-name-badge component that we've been using throughout this series and imagine that the component has defined a slot called greetingArea for the consumer to use. The idea is that the user can add whatever they like into this area, be it a text or perhaps an image, or both as shown here:

    To place content in the new greetingArea slot the consumer of the component puts the required content as a child of the Composite Component tag and sets the slot attribute on the content root which names the slot to use.

    <ccdemo-name-badge id="cc1"  badge-name="{{personName}}" badge-image="[[personImageURL]]" compact-view="false">
              <div slot="greetingArea"><span>I &hearts;</span><img src="https://blogs.oracle.com/images/oracle_jet_icon.png" style="vertical-align:middle"/></div>
        </ccdemo-name-badge>
        
    Futhermore, you can define multiple references to a named slot and the Composite Component will gather them up and place them into the slot in the order that they are defined, thus:
    <ccdemo-name-badge id="cc1"  badge-name="{{personName}}" badge-image="[[personImageURL]]" compact-view="false">
              <span slot="greetingArea">Hello</span>
              <div slot="greetingArea"><span>I &hearts;</span><img src="https://blogs.oracle.com/images/oracle_jet_icon.png" style="vertical-align:middle"/></div>
        </ccdemo-name-badge>
        
    Results in:

    Note how the HTML nodes defined with the slot="greetingArea" can be of different types.   

    Defining Your Composite Slots

    So we've seen now simple it is to place content into slots, what about defining them? Well that's really just as simple and involves the use of the <oj-slot> tag in the Composite Component view along with some basic metadata for documentation purposes.

    First the Metadata

    As you would expect we define a little metadata to help document the slotting capabilities of the component. This uses a top level property called slots which is a peer of the properties, events and methods properties that we've already seen. The basic metadata for each slot is really just to declare it and provide some description of what it does, although you can, as ever, extend the metadata to include your own information should you desire, (see Part XI). Here's the completed metadata json for the ccdemo-name-badge Composite Component that includes the slot definition

          {
            "name" : "ccdemo-name-badge",
            "version" : "1.0.0",
            "jetVersion" : ">=2.2.0",
            "properties": {
              "badge-name": {
                "description" : "Full name to display on the badge",
                "type": "string"
              },
              "badge-image": {
                "description" : "URL for the avatar to use for this badge",
                "type": "string"
              }
            },
            "events" : {
              "badgeSelected" : {
                "description" : "The event that consuming views can use to recognize when this badge is selected",
                "bubbles" : true,
                "cancelable" : false,
                "detail" : {
                  "nameOnBadge" : {"type" : "string"}
                }
              }
            },
            "methods" : {
              "changeBackground" : {
                "description" : "A function to update the background color of the badge",
                "internalName" : "_setBackgroundColor",
                "params" : [
                  {
                    "description":"Color name or hex color code",
                    "name" : "colorToSet",
                    "type": "string"
                  }
                ],
                "return" : "boolean"
              }
            },
            "slots" : {
              "greetingArea":{
                "description" : "Put your customized greeting here",
              }
            }
          }
        

    X Marks the Slot

    The <oj-slot> tag takes an attribute called name. This name attribute is the official name of the slot that the consumer will use in the corresponding slot attribute in their injected content. This name is case sensitive.

    So here's the new version of the markup for the ccdemo-name-bage.html which defines a named slot called greetingArea for injected content:

    <div class="badge-face">
          <img class="badge-image" data-bind="attr:{src: $props['badge-image'], alt: $props['badge-name']}"/>
          <h2 data-bind="text: upperFirstName"/>
          <h3 data-bind="text: $props['badge-name']"/>
          <div class="greeting-area">
              <oj-slot name="greetingArea"/>
          </div>
        </div>
        
    You can define as many named slots like this within your Composite Component view template as you desire. You should not define more than one <oj-slot> with the same name attribute, however. Only one of the duplicates would be used and the others ignored.     

    Defaulting Slot Contents

    In some cases you might want to supply some default content for a particular slot, just in case the user does not supply their own content. To do this, all you need to do is to add the required elements to your Composite Component view template HTML as children of the relevant slot. For example, we might decide to default in a standard greeting of "Hi" into the greetingArea slot if the consumer does not specify something themselves.

    <div class="badge-face">
            <img class="badge-image" data-bind="attr:{src: $props['badge-image'], alt: $props['badge-name']}"/>
            <h2 data-bind="text: upperFirstName"/>
            <h3 data-bind="text: $props['badge-name']"/>
            <div class="greeting-area">
                <oj-slot name="greetingArea">
                  <!-- Default Content -->
                  <span>Hi</span>
                </oj-slot>
            </div>
          </div>
          
    If the consumer does not specify anything for the slot then this default will be used. However, if they supply any content for the slot then any default value is ignored and not displayed.
    Slots are not in any way compulsory and should the user not provide any content and the slot itself has no default content, then the slot is just ignored.

    Default Slot

    As well as supporting named slots to target specific child elements to specific places within the final DOM tree, Composite Components also support the concept of a default slot. The default slot is just defined using a plain <oj-slot> tag with no specified name attribute. Then, any content assigned as a child of the Composite Component that does not specify a slot="…" attribute, will be assigned to this default slot. As many nodes as are required can be placed into the default slot, and again they will appear in the order in which they were defined. If you do not define a default slot, then any children of the Composite Component that do not include the slot attribute will be ignored because there is nowhere to put them.

    Note that if you define a child node of the Composite Component with an invalid slot name, then it will also not appear. Importantly you should note that slot names are case sensitive, thus content defined as:

    <ccdemo-name-badge id="cc1"  badge-name="{{personName}}" badge-image="[[personImageURL]]" compact-view="false">
                <span slot="GreetingArea">Hello</span>
          </ccdemo-name-badge>
        
    Would not display the "Hello" content because the Composite Component slot name uses a lowercase leading "g" not the uppercase used by slot="GreetingArea".

    Scoping of Slotted Content

    We've seen that using the slotting capability of Composite Components, component consumers are able to inject their own markup into the midst of the Composite. An important question to ask, however, is what's the viewModel scope?.

    For example if I utilize a statement such as this:

    <ccdemo-name-badge id="cc1"  badge-name="{{personName}}" badge-image="[[personImageURL]]" compact-view="false">
              <span slot="greetingArea" data-bind="text:greetingMessage"/>
        </ccdemo-name-badge>
        
    Then where is greetingMessage coming from? The answer is not from the Composite Component. Any binding expressions that you use within slotted content are associated with the viewModel of the view that contains the reference to the Composite Component. Effectively, although it appears that slotted content is a child of the Composite Component, the reality is that it is its peer. When you think about it, this makes a lot of sense. As a consumer of a component you are not privy to the internal implementation of that component and its viewModel should be hidden from you.

    What's Next?

    In the next article, I'll be looking at some of the more advanced aspects of slotting, specifically how it integrates into the Composite Component lifecycle and how looped content is handled.


    Composite Component Article Series Index

    1. Introduction
    2. Your First Composite Component - A Tutorial
    3. Composite Conventions and Standards
    4. Attributes, Properties and Data
    5. Events
    6. Methods
    7. The Lifecycle
    8. Slotting Part 1

    Appendix

    Updated ccdemo-name-badge.css File

    Now the component supports slotting the CSS has changed a little to define the new greeting-area class and to increase the height of the component as a whole. Here's the full version of the CSS in case you want to update your copy of the code if you have been following along using the sample created in Part II of the series:

        ccdemo-name-badge:not(.oj-complete){
            visibility: hidden;
        }
    
        ccdemo-name-badge{
            display : block;
            width : 200px;
            height: 260px;
            margin : 10px;
            padding: 10px;
        }
    
        ccdemo-name-badge .badge-face {
            height : 100%;
            width : 100%;
            background-color : #80C3C8;
            border-radius: 5px;
            text-align: center;
            padding-top: 30px;
        }
    
        ccdemo-name-badge .badge-image {
            height : 100px;
            width : 100px;
            border-radius: 50%;
            border:3px solid white;
        }
    
        ccdemo-name-badge .greeting-area {
            max-height: 60px;
            min-height: 0px;
            border-style: solid;
            border-width: 1px;
            border-radius: 5px;
            background-color: #DCE3E4;
            padding:5px;
            margin : 10px;
            text-align: center;
            overflow : hidden;
        }
        

older | 1 | .... | 961 | 962 | (Page 963) | 964 | 965 | .... | 989 | newer