This SDK library was generated using OpenApi Generator. The SDK can be used as a module in your code and the examples demonstrate how to connect to financial institutions integrated with Yapily.

To connect to the Yapily API, you will need to register your application at https://dashboard.yapily.com.

Specify the financial institutions you want to work with and save your application. You will then be prompted to download your application credentials. These application credentials can then be used to authorise your requests against the Yapily API.

The SDK is currently available in the Yapily maven repository and can be included in your project by adding it to your dependencies

Repository:

Dependency:

Repository:

repositories {
    // other repos
    maven {
        url "http://maven.yapily.com/"
    }
}

Dependency:

compile group: 'yapily', name: 'yapily-sdk', version: '2.13.1'

The JAR can also be downloaded from a tagged release, or this project can be cloned/downloaded and packaged into a library JAR to be included in your project.

Sample usages of the SDK can be seen in the examples folder.

• Configure the default api client

ApiClient defaultClient = Configuration.getDefaultApiClient();
// Configure the API authentication
HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
// Replace these demo constants with your application credentials
basicAuth.setUsername(APPLICATION_ID);
basicAuth.setPassword(APPLICATION_SECRET);

• Or configure a new one for multiple application cases

ApiClient applicationClient = new ApiClient();
// Configure the API authentication
HttpBasicAuth basicAuth = (HttpBasicAuth) applicationClient.getAuthentication("basicAuth");
// Replace these demo constants with your application credentials
basicAuth.setUsername(APPLICATION_ID);
basicAuth.setPassword(APPLICATION_SECRET);
InstitutionsApi institutionsApi = new InstitutionsApi();
institutionsApi.setApiClient(applicationClient);

• Retrieve a list of available financial institutions to connect to

InstitutionsApi institutionsApi = new InstitutionsApi();
List<Institution> institutions = institutionsApi.getInstitutionsUsingGET().getData();

• Creating users and retrieving users for your application registered in the Yapily Dashboard

final ApplicationUsersApi applicationUsersApi = new ApplicationUsersApi();
NewApplicationUser exampleUser = new NewApplicationUser();
exampleUser.setApplicationUserId("java-sdk@yapily.com");
applicationUsersApi.addUserUsingPOST(exampleUser);

List<ApplicationUser> users = applicationUsersApi.getUsersUsingGET();

• Create an authorization url in order for your users to give consent on accessing their account data.

final AccountsApi accountsApi = new AccountsApi();
AccountAuthorisationRequest accountAuthorisationRequest = new AccountAuthorisationRequest();
accountAuthorisationRequest.setApplicationUserId(applicationUserId);
accountAuthorisationRequest.setInstitutionId(institutionId);
/**
* Use the defaults
*/
accountAuthorisationRequest.setAccountRequest(new AccountRequest());
ApiResponseOfAuthorisationRequestResponse authorizationResponse = accountsApi.initiateAccountRequestUsingPOST(accountAuthorisationRequest, null, null, null);
String directUrl = authorizationResponse.getData().getAuthorisationUrl();

• Get the most resent Consent for the configured user and institution. Make sure to check that the Consent is AUTHORIZED otherwise fail the request

Consent consent = consentsApi.getConsentsUsingGET(
        Collections.singletonList(applicationUserId),
        Collections.emptyList(),
        Collections.singletonList(institutionId),
        Collections.emptyList(),
        null,
        null,
        1,
        null).getData().stream()
        .filter(c -> c.getStatus().equals(Consent.StatusEnum.AUTHORIZED))
        .findFirst()
        .orElseThrow(() -> new RuntimeException(String.format("No valid consent token present for application user %s", applicationUserId)));

• Providing that the user has given consent and you have an AUTHORIZED Consent, obtain the user account details using the consent token

String consentToken = consent.getConsentToken();
ApiListResponseOfAccount accountsResponse = accountsApi.getAccountsUsingGET(consentToken);
List<Account> accounts = accountsResponse.getData();

• Return user transaction details, using an account the user has given consent to.

String consentToken = consent.getConsentToken();
ApiListResponseOfTransaction transactionsResponse = transactionsApi.getTransactionsUsingGET(
                                        consentToken, 
                                        accountId, 
                                        Collections.emptyList(),
                                        "1980-01-01T00:00:00.000Z",
                                        "2020-01-01T00:00:00.000Z",
                                        10,
                                        null,
                                        0,
                                        null);
List<Transaction> transactions = transactionsResponse.getData();

• Check that the identity feature is provided for this institution.

Institution institution = institutionsApi.getInstitutionUsingGET(institutionId);
Boolean supportsIdentity = institution.getFeatures().stream()
        .anyMatch(featuresEnum -> featuresEnum != null && featuresEnum.equals(Institution.FeaturesEnum.IDENTITY));

• If the identity feature is supported return user identity details. This will fail if the identity feature is not supported.

String consentToken = consent.getConsentToken();
IdentityApi identityApi = new IdentityApi();
ApiResponseOfIdentity identityResp = identityApi.getIdentityUsingGET(consentToken); 
Identity identity = identityResp.getData();

• Create a new payment request detailing what type of payment you want to issue on behalf of your user e.g. a Domestic payment to send £1.00 to another account using an account number and sort code:

PaymentRequest paymentRequest = new PaymentRequest();

Amount amount = new Amount();
amount.setAmount(new BigDecimal(1));
amount.setCurrency("GBP");

Payee payee = new Payee();
payee.setName("John Doe");

List<AccountIdentification> payeeAccountIdentifications = new ArrayList<>();

AccountIdentification accountNumberIdentification = new AccountIdentification();
accountNumberIdentification.setType(AccountIdentification.TypeEnum.ACCOUNT_NUMBER);
accountNumberIdentification.setIdentification("70000005");
payeeAccountIdentifications.add(accountNumberIdentification);

AccountIdentification sortCodeIdentification = new AccountIdentification();
sortCodeIdentification.setType(AccountIdentification.TypeEnum.SORT_CODE);
sortCodeIdentification.setIdentification("700001");
payeeAccountIdentifications.add(sortCodeIdentification);

payee.setAccountIdentifications(payeeAccountIdentifications);

paymentRequest.setAmount(amount);
paymentRequest.setPayee(payee);
paymentRequest.setType(PaymentRequest.TypeEnum.DOMESTIC_PAYMENT);
paymentRequest.setReference("Sending £1.00 to John Doe via. Yapily");
paymentRequest.setPaymentIdempotencyId("anyUniqueStringOver18characters");

• Create a new payment authorisation request using the payment request to generate an authorization url that your users can use to authorize the payment:

PaymentsApi paymentsApi = new PaymentsApi();
PaymentAuthorisationRequest paymentAuthorisationRequest = new PaymentAuthorisationRequest();
paymentAuthorisationRequest.setApplicationUserId(applicationUserId);
paymentAuthorisationRequest.setInstitutionId(institutionId);
paymentAuthorisationRequest.setPaymentRequest(paymentRequest);
ApiResponseOfPaymentAuthorisationRequestResponse authorizationResponse = 
                        paymentsApi.createPaymentAuthorisationUsingPOST(paymentAuthorisationRequest, null, null, null);
String url = authorizationResponse.getData().getAuthorisationUrl();

• Submit a payment request using the same payment request object in the authorization request and the AUTHORIZED consent given by the user:

String consentToken = consent.getConsentToken();
ApiResponseOfPaymentResponse response = paymentsApi.createPaymentUsingPOST(consentToken, paymentRequest);

• Check the payment status:

String consentToken = consent.getConsentToken();
String paymentId =  paymentResponse.getData().getId();
ApiResponseOfPaymentResponse apiResponseOfPaymentResponse = paymentsApi.getPaymentStatusUsingGET(paymentId, consentToken);

For more information on how to get connected, visit the Yapily Knowledge Base.

This dataset contains images of the surface of Venus from Magellan’s spacecraft circa 1990. The dataset labels some images as having volcanoes and others as no volcano. The images that contain volcanoes are also given a label for the type of volcano, radius, and number of volcanoes in the image.

I chose this dataset, because when I started at the University of Colorado Boulder, I was an astrophysics major. I later switched majors to mathematics, but I find astronomy very interesting and it was fun to be able to combine that interest with my data science learning. I also chose this as a challenge as I have not worked with image data before.

I now realize that the reason I have not worked with image data is that I have not learned all of the tools to best model it. This project will remain a work in progress that I come back to and tweak as I learn new skills.

Here’s are my conclusions so far:

EDA:
For Exploratory Data Analysis, I had to fix the dataframes so that all of the pictures showed up and the image dataframes matched up with the labels. I found that there was class imbalance in the Volcanos? column that I was trying to predict. I created three different dataframes, one with the imbalanced, one with random undersampling, and one with SMOTE oversampling to compare in the different models.

Model Performance:
I found it counterintuitive that the Logistic Regression was more successful than Random Forest Classifier. I initially spent a lot of time trying to tune the Random Forest Classifier before even trying the Logistic Regression Classifier. This is a reminder not to just try my favorite model, or the one I’m most interested in practicing. I then tried to use GridSearchCV to find the best hyperparameters. The runtime on these was costly, which led to me not optimizing across all of the parameters. Still, I achieved nearly 100% recall and over 95% Accuracy, Precision, and F1.

Next Steps:
I would continue to try out different solvers and regularization algorithms to see if I can improve performance even more.

Takeaways:
I learned so much during this project. I learned a lot about class imbalance, including different sampling techniques, but also the problem of using accuracy as your only score for model performance. I was forced to go back to learning about different regularization techniques and their parameters. I started using cross_validate instead of cross_val_scores because of the problem of accuracy score. I started playing with GridSearchCV and will need to keep playing with it to find a way to reduce runtime to get the most out of it.

This project was created while learning the react js, rethinkdb, web socket integration from the plural site course : Building Real-time Apps with React, Socket.io, and RethinkDB.

The code has been modified to match the latest version of all components at the time of writing, also changed some behaviors like port number passing from env instead of arguments in server app., and many others.

This application let us collaborate on the drawing (simple black and white) in real time.

• RethinkDB change feed
• RxJS streaming capabilities
• Rx Sync buffering capabilities in time of network non-availability
• ReactJS for building UI using component model and also building state based UI.
• Socket.io for web sockets handling

• NodeJS v12.x
• Socket.io
• RethinkDB v2.4
• ReactJS v16.13.x
• RxJS v6.x
• Rx sync
• simple-react-canvas (just for learning, not a production one)

• add the following tables in the RethinkDB

  • drawings
    • used for storing the drawing names and id
  • lines
    • used to store lines, the actual drawing
  • timers

• Server

  • cd server from root directory of project
  • npm start
    • default port is 8000
    • with particular port HTTP_PORT=8001
    • one can also set different config using env. variables (check in config.js)

• Client

  • cd client from root directory of project
  • npm start
  • if one want to connect to another server on different port
    • passively (I mean by restarting the server)
      • change src/config.json
    • actively (without restarting the server)
      • in URL bar in browser, after the base url all ?PORT_NUMBER
      • example: if base url is http://localhost:3000 then to connect to 8001 change the url to http://localhost:3000?8001 and enter.

• Course: https://app.pluralsight.com/library/courses/react-socketio-rethinkdb-building-real-time-apps/table-of-contents
• Github: https://github.com/hendrikswan/realtime-rethink-lessons
• Instructor: @hendrikswan

This page covers advanced snippet techniques for javascript. Describes code snippets that can be used.
You can contribute anytime using Pull Request.

• Validation
• Data manipulation
• Performance utility

function checkiOS() {
    return /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
}

var entityMap = {
    '&': '&',
    '<': '&lt;',
    '>': '&gt;',
    '"': '&quot;',
    "'": '&#39;',
    "https://github.com/": '&#x2F;',
    '`': '&#x60;',
    '=': '&#x3D;'
};

function escapeHtml (string) {
    return String(string).replace(/[&<>"'`=\/]/g, function fromEntityMap (s) {
        return entityMap[s];
    });
}

import React from 'react';

function replaceLinebreak(text) {
    const lineArray = text.split('\n');
    const lineArrayLength = lineArray.length;
    return lineArray.map((line, index) => {
        return <span key={index}>{line}{index === lineArrayLength - 1? '' : <br/>}</span>;
    });
}

function escapeRegExp(string){
    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $&는 일치한 전체 문자열을 의미합니다.
}

// Closure
(function () {
    /**
     * Decimal adjustment of a number.
     *
     * @param {String}  type  The type of adjustment.
     * @param {Number}  value The number.
     * @param {Integer} exp   The exponent (the 10 logarithm of the adjustment base).
     * @returns {Number} The adjusted value.
     */
    function decimalAdjust(type, value, exp) {
        // If the exp is undefined or zero...
        if (typeof exp === 'undefined' || +exp === 0) {
            return Math[type](value);
        }
        value = +value;
        exp = +exp;
        // If the value is not a number or the exp is not an integer...
        if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
            return NaN;
        }
        // Shift
        value = value.toString().split('e');
        value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
        // Shift back
        value = value.toString().split('e');
        return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
    }

    // Decimal round
    if (!Math.round10) {
        Math.round10 = function (value, exp) {
            return decimalAdjust('round', value, exp);
        };
    }
    // Decimal floor
    if (!Math.floor10) {
        Math.floor10 = function (value, exp) {
            return decimalAdjust('floor', value, exp);
        };
    }
    // Decimal ceil
    if (!Math.ceil10) {
        Math.ceil10 = function (value, exp) {
            return decimalAdjust('ceil', value, exp);
        };
    }
})();

// Round
Math.round10(55.55, -1);   // 55.6
Math.round10(55.549, -1);  // 55.5
Math.round10(55, 1);       // 60
Math.round10(54.9, 1);     // 50
Math.round10(-55.55, -1);  // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1);      // -50
Math.round10(-55.1, 1);    // -60
// Floor
Math.floor10(55.59, -1);   // 55.5
Math.floor10(59, 1);       // 50
Math.floor10(-55.51, -1);  // -55.6
Math.floor10(-51, 1);      // -60
// Ceil
Math.ceil10(55.51, -1);    // 55.6
Math.ceil10(51, 1);        // 60
Math.ceil10(-55.59, -1);   // -55.5
Math.ceil10(-59, 1);       // -50

function ellipseStr(str, length) {
    if(!str || !length || str.length <= length){
        return str;
    }

    return `${str.slice(0, length - 3)}...`;
}

function numberWithComma(number) {
    return number.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}

function trim(string) {
    return string.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
}

function setLocalStorageItem(key, item) {
    localStorage.setItem(key, JSON.stringify(item));
}

function getLocalStorageItem(key) {
    return JSON.parse(localStorage.getItem(key));
}

// 'e' is touchEvent Object. (touchStart, touchMove, touchEnd)
function getTouchPositionX(e) {
    return e.changedTouches ? e.changedTouches[0].pageX : e.pageX;
}

function getTouchPositionY(e) {
    return e.changedTouches ? e.changedTouches[0].pageY : e.pageY;
}

function getAngle(deltaX, deltaY) {
    return Math.atan(deltaY / deltaX) * 180 / Math.PI;
}

function highlight(message, keyword) {
    return message && escapeHtml(message).replace(new RegExp(escapeRegExp(keyword), ['gi']), '<em>$&</em>');
}

// window
window.addEventListener('scroll', handleScrollEvent, false);

function handleScrollEvent() {
    if (window.scrollY + window.innerHeight >= document.body.scrollHeight) {
        // do something such as fetch.
        console.log('touch down');
    }
}

// element
const $el = documnet.getElementById('list');
$el.addEventListener('scroll', handleScrollEvent, false);

function handleScrollEvent() {
    if ($el.scrollTop + $el.offsetHeight >= $el.scrollHeight) {
        // do something such as fetch.
        console.log('touch down');
    }
}

TBD

TBD

const throttle = (func, limit) => {
  let lastFunc;
  let lastRan;
  return function() {;
    const context = this;
    const args = arguments;
    if (!lastRan) {
      func.apply(context, args);
      lastRan = Date.now();
    } else {
      clearTimeout(lastFunc)
      lastFunc = setTimeout(function() {
        if ((Date.now() - lastRan) >= limit) {
          func.apply(context, args);
          lastRan = Date.now();
        }
      }, limit - (Date.now() - lastRan));
    }
  }
}

const debounce = (func, delay) => {
  let inDebounce
  return function() {
    const context = this;
    const args = arguments;
    clearTimeout(inDebounce);
    inDebounce = setTimeout(() => func.apply(context, args), delay);
  }
}

diagram generates dynamic diagrams using DOT markup language
and exports images in pdf, png, jpeg, gif, and bmp format. For more information visit diagram homepage. It can also generate diagrams automatically from Stata data set.

E. F. Haghish
Center for Medical Biometry and Medical Informatics
University of Freiburg, Germany
haghish@imbi.uni-freiburg.de
http://www.haghish.com/dot
@Haghish

The diagram package relies on webimage package for exporting the graphs to various formats. For more information regarding the latter package, visit webimage on GitHub. Both packages are installable via GitHub.

The diagram package requires webimage__ Stata package for exporting the graphical files. The github package can be used to install diagram and its dependency, webimage, as shown below:

github install haghish/diagram

Moreover, for exporting graphical files, the webimage package requires phantomJS, which is an open-source freeware available for Windows, Mac, and Linux. The path to the executable phantomJS file is required in order to export the graphical files. However, if the executable file is installed in the default local directory (e.g. /usr/local/bin/ on Mac or c:\phantomJS\bin\phantomJS.exe on Windows), the phantomjs(str) can be ignored.

The examples directory includes several examples for generating dynamic diagrams from DOT markup and Stata data sets.

In the examples directory, there is a DOT file named PATH1.txt which draws a path diagram. The file is rendered by diagram command and exported to a PNG file directly from Stata:

diagram using "./examples/PATH1.txt", export(./examples/example1.png)

diagram generates dynamic diagrams using DOT markup language
and exports images in pdf, png, jpeg, gif, and bmp format. For more information visit diagram homepage. It can also generate diagrams automatically from Stata data set.

E. F. Haghish
Center for Medical Biometry and Medical Informatics
University of Freiburg, Germany
haghish@imbi.uni-freiburg.de
http://www.haghish.com/dot
@Haghish

The diagram package relies on webimage package for exporting the graphs to various formats. For more information regarding the latter package, visit webimage on GitHub. Both packages are installable via GitHub.

The diagram package requires webimage__ Stata package for exporting the graphical files. The github package can be used to install diagram and its dependency, webimage, as shown below:

github install haghish/diagram

Moreover, for exporting graphical files, the webimage package requires phantomJS, which is an open-source freeware available for Windows, Mac, and Linux. The path to the executable phantomJS file is required in order to export the graphical files. However, if the executable file is installed in the default local directory (e.g. /usr/local/bin/ on Mac or c:\phantomJS\bin\phantomJS.exe on Windows), the phantomjs(str) can be ignored.

The examples directory includes several examples for generating dynamic diagrams from DOT markup and Stata data sets.

In the examples directory, there is a DOT file named PATH1.txt which draws a path diagram. The file is rendered by diagram command and exported to a PNG file directly from Stata:

diagram using "./examples/PATH1.txt", export(./examples/example1.png)

UMKM (Usaha Mikro, Kecil, dan Menengah) memiliki peran penting dalam perekonomian Indonesia. Namun, banyak pelaku UMKM yang masih kurang memahami literasi digital dan pengelolaan keuangan secara modern. Kurangnya pemahaman ini membuat mereka kesulitan dalam mengembangkan bisnis, terutama dalam hal pencatatan transaksi, penggunaan dompet digital, dan pemasaran online.

Melihat permasalahan tersebut, tim kami mengembangkan SI LICIK (Sistem Literasi Cerdas, Inovatif dan Keuangan), sebuah platform edukasi yang membantu UMKM memahami dan menerapkan teknologi digital dalam bisnis mereka. Sistem ini akan menyediakan materi pembelajaran tentang pencatatan keuangan digital, transaksi online, serta cara mengelola keuangan dengan lebih efektif. Selain itu, platform ini juga dilengkapi dengan fitur pengelolaan keuangan praktis yang dapat langsung digunakan oleh pelaku UMKM untuk membuat laporan keuangan, dan merencanakan anggaran.

• Jalankan secara Localhost (web & backend berjalan pada komputer user)

git clone https://github.com/SkulZOnTheYT/Si_LiCIK.git
cd client
npm run dev
cd ~
cd server
npm run dev

• Jalankan secara Local + API (menggunakan localhost pada front-end dan api backend online)

git clone https://github.com/SkulZOnTheYT/Si_LiCIK.git
cd client
npm run dev

ubah kode pada client/src/utils/url.js untuk menggunakan url backend online Si LiCIK atau ubah .env pada folder client

const url = {
    apiUrl: import.meta.env.PROD 
+     ? 'https://silicik-api.up.railway.app'
-     : 'http://localhost:5000',
    clientUrl: import.meta.env.PROD
-     ? 'https://silicik.vercel.app'
+     : 'http://localhost:5173'
  };
  
  export default url;

• jalankan secara langsung dari web Si LiCIK

Kunjungi website Si LiCIK client & backend

webMethods API Gateway is the core run time component in webMethods API Management platform and it enables organizations to secure, manage and monitor their API programs. It allows providers to securely expose APIs to external developers, partners, and other consumers.  API Gateway provides a dedicated, web-based user interface to perform all the administration and API related tasks such as creating APIs, defining and activating policies, creating applications, and consuming APIs. API Gateway gives you rich dashboard capabilities for API Analytics. 

APIs created in API Gateway can also be published to API Portal for external facing developers’ consumption. 

webMethods API Gateway can be provisioned in multiple ways based on the users needs. Choose the one which works the best for you. 

• WEBMETHODS.io –  A 30 day free trial cloud account can be provisioned in less than 15 minutes. Visit SoftwareAG cloud and get your instance running in a region of your choice.
• Docker – A 90 day free trial version of API Gateway docker image can be pulled from the docker hub.                     

Hope, everything went well in product provisioning . Lets now get started to explore the product capabilities. 

• WEBMETHODS.io  – You would have received a mail from Software AG with a link to login to your cloud account. Login and start the free trial of the products. In few mins, your cloud instance would be up and running. 
• Docker – After the checkout, you would have landed in the “How to use” page which lists the detailed steps for spinning up a container with the docker image. Please follow the steps and get your instance started in few minutes.

Hurrah!!!!.. Now that the product is up and running and let’s get into the real action of using it. First let us create an API and add some enforcement to it.

1. Login to the webapp (http://localhost:9072/)) using the default credentials. If you are using API cloud, make sure to launch the “API Gateway” app. 

2. Create a “DateAPI” by importing the attached archive through the import option under the user menu. By default, this API is protected with the API Key security enforcement.

3. Also, enable the global “Transaction logging” policies present under  _Policies → Global Policie_s. This would capture the metrics of all runtime invocations.

         

Now, its all set for the runtime execution. If you have an API Portal instance available, you can publish this API to API Portal and try it out.

If not, no worries,we will just create an application in API Gateway itself. Under the Applications section,create a new application, provide a name, consume the API(add our DateAPI under the APIs subsection) and click save. This will create an application and automatically provision an API Key. Copy the API access key from the application details page for invoking the API. Using any REST client, you can invoke the gateway endpoint(can be obtained from the API details page in Gateway) and pass the access key with the header “x-Gateway-APIKey”.

With the transaction Logging policy enabled, the information about runtime requests done in the above steps would have been captured and the same is rendered in the API Gateway analytics page. You can have a look at the global analytics and also API level analytics for more insights.

API Gateway offers a wide range of capabilities. 

Read on topics related to deployment and architecture topics such as high availability, sizing, deployment best practices, 

Read on topics related to maintenance, upgrade and operations.

Read on topics related to different policies supported in API Gateway

Read on topics related to key features such as Teams support, SOAP to REST etc

Read on topics related to troubleshooting, diagnostics etc 

• API Management Home 
• API Gateway DevOps Repo
• DevOps Templates 
• Product Documentation 
• Tech community
• Software AG Devcast Videos 

These tools are provided as-is and without warranty or support. They do not constitute part of the webMethods product suite. Users are free to use, fork and modify them, subject to the license agreement. While we welcome contributions, we cannot guarantee to include every contribution in the master project.

Contact us at TECHcommunity if you have any questions.

webMethods API Gateway is the core run time component in webMethods API Management platform and it enables organizations to secure, manage and monitor their API programs. It allows providers to securely expose APIs to external developers, partners, and other consumers.  API Gateway provides a dedicated, web-based user interface to perform all the administration and API related tasks such as creating APIs, defining and activating policies, creating applications, and consuming APIs. API Gateway gives you rich dashboard capabilities for API Analytics. 

APIs created in API Gateway can also be published to API Portal for external facing developers’ consumption. 

webMethods API Gateway can be provisioned in multiple ways based on the users needs. Choose the one which works the best for you. 

• WEBMETHODS.io –  A 30 day free trial cloud account can be provisioned in less than 15 minutes. Visit SoftwareAG cloud and get your instance running in a region of your choice.
• Docker – A 90 day free trial version of API Gateway docker image can be pulled from the docker hub.                     

Hope, everything went well in product provisioning . Lets now get started to explore the product capabilities. 

• WEBMETHODS.io  – You would have received a mail from Software AG with a link to login to your cloud account. Login and start the free trial of the products. In few mins, your cloud instance would be up and running. 
• Docker – After the checkout, you would have landed in the “How to use” page which lists the detailed steps for spinning up a container with the docker image. Please follow the steps and get your instance started in few minutes.

Hurrah!!!!.. Now that the product is up and running and let’s get into the real action of using it. First let us create an API and add some enforcement to it.

1. Login to the webapp (http://localhost:9072/)) using the default credentials. If you are using API cloud, make sure to launch the “API Gateway” app. 

2. Create a “DateAPI” by importing the attached archive through the import option under the user menu. By default, this API is protected with the API Key security enforcement.

3. Also, enable the global “Transaction logging” policies present under  _Policies → Global Policie_s. This would capture the metrics of all runtime invocations.

         

Now, its all set for the runtime execution. If you have an API Portal instance available, you can publish this API to API Portal and try it out.

If not, no worries,we will just create an application in API Gateway itself. Under the Applications section,create a new application, provide a name, consume the API(add our DateAPI under the APIs subsection) and click save. This will create an application and automatically provision an API Key. Copy the API access key from the application details page for invoking the API. Using any REST client, you can invoke the gateway endpoint(can be obtained from the API details page in Gateway) and pass the access key with the header “x-Gateway-APIKey”.

With the transaction Logging policy enabled, the information about runtime requests done in the above steps would have been captured and the same is rendered in the API Gateway analytics page. You can have a look at the global analytics and also API level analytics for more insights.

API Gateway offers a wide range of capabilities. 

Read on topics related to deployment and architecture topics such as high availability, sizing, deployment best practices, 

Read on topics related to maintenance, upgrade and operations.

Read on topics related to different policies supported in API Gateway

Read on topics related to key features such as Teams support, SOAP to REST etc

Read on topics related to troubleshooting, diagnostics etc 

• API Management Home 
• API Gateway DevOps Repo
• DevOps Templates 
• Product Documentation 
• Tech community
• Software AG Devcast Videos 

These tools are provided as-is and without warranty or support. They do not constitute part of the webMethods product suite. Users are free to use, fork and modify them, subject to the license agreement. While we welcome contributions, we cannot guarantee to include every contribution in the master project.

Contact us at TECHcommunity if you have any questions.

This repository contains the analysis performed by Javier Gómez García for the 4th project of the Udacity Data Analyst Nanodegree.
It includes the following files:

• A Jupyter notebook containing the main program and the description of the work (Python version: 2.7):
  Project4_Identify_Fraud_from_Enron_Email.ipynb

• The following text files:

  • REFERENCES: text file containing the links to the websites and repositories I have used for my work.

• The following Python files, required to process the data and called by the main program (the .ipynb file), all written in Python 2.7:

  • poi_id.py: main program to build the POI identification algorithm
  • helper_functions.py: additional functions required for processing the data and doing the tuning and testing of the classifiers
  • tester.py: additional functions to test the classifier and write the output pickle files (provided by Udacity)
  • feature_format.py: additional functions to process the data (provided by Udacity)

• The following pickle files (.pkl):

  • final_project_dataset.pkl: input file containing the Enron dataset (provided by Udacity)
  • my_classifier.pkl: file containing the final classifier
  • my_dataset.pkl: file containing the dataset with the new features added
  • my_feature_list.pkl: file containing the names of the features used for the classifier