?>

Paddle + uProc Integrations

Appy Pie Connect allows you to automate multiple workflows between Paddle and uProc

About Paddle

Helping B2B SaaS increase global conversions, reduce churn, stay compliant, and scale up fast.

About uProc

uProc is a multipurpose data platform: clean, verify or enrich any field in forms, databases, files or applications with multiple categories supported (persons, companies, products, communications, social...).

uProc Integrations

Best Paddle and uProc Integrations

  • Paddle Pipedrive

    uProc + Pipedrive

    Add persons in Pipedrive from new uProc people list entries Read More...
    When this happens...
    Paddle New Profile Added to List
     
    Then do this...
    Pipedrive Create Person
    Don't waste time entering data manually. Use this Appy Pie Connect integration and automatically creates people in your Pipedrive account from new profiles submitted to uProc. The integration allows leads submitted to uProc are sent directly to Pipedrive as leads.
    How This uProc – Pipedrive Integration Works
    • A new profile is added to the selected UProc's list
    • Appy Pie Connect creates a new person on Pipedrive.
    What You Need
    • uProc account
    • Pipedrive account
  • Paddle Pipedrive

    {{item.triggerAppName}} + {{item.actionAppName}}

    {{item.message}} Read More...
    When this happens...
    Paddle {{item.triggerTitle}}
     
    Then do this...
    {{item.actionAppImage}} {{item.actionTitle}}
Connect Paddle + uProc in easier way

It's easy to connect Paddle + uProc without coding knowledge. Start creating your own business flow.

    Triggers
  • New Payment

    Trigger when new payment made.

  • New Transaction

    Trigger when new transaction is coming.

  • New User

    Trigger when new user created.

    Actions
  • Create Coupon

    Create a new coupon for the given product or a checkout.

  • Create Subscription

    Create a new subscription billing plan with the supplied parameters.

  • Select Tool

    Select a tool to perform verification or enrichment

How Paddle & uProc Integrations Work

  1. Step 1: Choose Paddle as a trigger app and Select "Trigger" from the Triggers List.

    (30 seconds)

  2. Step 2: Authenticate Paddle with Appy Pie Connect.

    (10 seconds)

  3. Step 3: Select uProc as an action app.

    (30 seconds)

  4. Step 4: Pick desired action for the selected trigger.

    (10 seconds)

  5. Step 5: Authenticate uProc with Appy Pie Connect.

    (2 minutes)

  6. Your Connect is ready! It's time to start enjoying the benefits of workflow automation.

Integration of Paddle and uProc

Paddle?

Paddle is a simple web-based data processing system. It allows users to develop data processing applications for analytic purposes. The system provides a number of classes that can be used to easily implement various common data processing tasks, such as loading and managing data from databases, manipulating data using SQL queries, and aggregating data across multiple datasets.

uProc?

uProc is a library that allows data manipulation processes to be encapsulated as expressions in the Scala programming language. This enables the definition of data transformations that can be executed on demand in a safe and modular fashion.

Integration of Paddle and uProc

In this section, I will discuss how Paddle and uProc can be integrated. To do this, I will implement a sample application that combines the two systems. The application will load a set of historical stock price data from Yahoo Finance into Paddle and then calculate the daily return of each stock over the course of several years. Each stock’s daily return will be calculated using uProc. This application will provide us with an example of how Paddle and uProc can be integrated.

The first step in creating the application will be to create a new Paddle project. We will use the UDFs for SQL sample project created by Paddle as our starting point. The project is located at http://paddlepaddle.org/docs/scala/quickstart/sqludf_demo.html (you may need to sign up for an account if you don’t already have one. We will download the Paddle source code from this link and place it in a new fpder called “Paddle” on our local machine. Next we will run the fplowing commands from a terminal window to build and run the application:

$ cd Paddle $ sbt //This command compiles and runs the application $ ./run-main com.example.sqludfdemo start ../../resources/data/test_data_2b898d6d354b8ca1b7a9f0526e1e08ed_2012-02-01T00:00:00Z

We’ll use this sample project as the basis for our new application, but we are going to modify it slightly. First we need to download uProc from Paddle’s GitHub repository at https://github.com/PaddlePaddle/uproc/tree/master . To do this, you will need to install Git on your machine, which you can do by downloading the installer for your operating system from http://git-scm.com/downloads . Once Git is installed, you can clone the repository by running the fplowing command from a terminal window:

$ git clone https://github.com/PaddlePaddle/uproc Cloning into 'uproc'... remote. Counting objects. 1688, done. remote. Compressing objects. 100% (802/802), done. remote. Total 1688 (delta 741), reused 969 (delta 521. Receiving objects. 100% (1688/1688), 456.52 KiB | 209 KiB/s, done. Respving deltas. 100% (741/741), done. $ cd uproc $ sbt //This command compiles and runs the application $ ./run-main com.example.uproctest start ../../test_data/historical_stock_prices_yahoo_finance_2013-08-19T00:00:00Z

If this command runs successfully, you should see output looking something like this:

Computing daily returns Using time frame [2013-08-19 00:00:00+0000 to 2013-11-06 23:59:59+0000] Using time frame [2013-09-30 00:00:00+0000 to 2013-11-06 23:59:59+0000] Using time frame [2013-10-28 00:00:00+0000 to 2013-11-06 23:59:59+0000] Using time frame [2013-11-25 00:00:00+0000 to 2013-11-06 23:59:59+0000] Using time frame [2014-02-14 00:00:00+0000 to 2014-02-20 23:59:59+0000] Using time frame [2014-03-08 00:00:00+0000 to 2014-03-15 23:59:59+0000] Using time frame [2014-04-03 00:00:00+0000 to 2014-04-10 23:59:59+0000] ... Calculating daily returns --------------------------- | Stock | Time | Day | Return | Name | ----------------------------------------------------------- | AAPL | 2013-08-19 | 1 | 0.0004 | Apple Inc. ... | AAPL | 2014-10-29 | 1 | 0.0002 | Apple Inc. ... | AAPL | 2014-11-07 | 1 | -0.0001 | Apple Inc. ... ----------------------------------------------------------- Total number of stocks -------------------- 2

By default, this command loads all historical stock price data available from Yahoo Finance into Paddle and calculates daily returns for each stock over the course of five years (from August 19th, 2013 to November 6th, 2014. If you want to change the date range or number of stocks returned by this command, you can modify the last parameter passed into this line of code. For instance, to load only AAPL stock price data, you could change this parameter to “AAPL”. Another option would be to change this parameter to “3” so that only three stocks are returned (this option is useful if you don’t want to wait for all of the stocks to be loaded.

Next we are going to modify the code for the application we downloaded from Paddle’s website so that it uses uProc rather than SQL queries for calculating daily returns. To do this, we will create a list containing two items of information for each stock that we want to include in our output file. its name and its corresponding daily return (which will be calculated using uProc. We will also need to update the code that loops through all of these stocks and writes them out as an output file (the code for this loop is contained in the main(. function. Each stock will now simply be represented by its name, rather than by some arbitrary string that was generated by Paddle when it created its output file (this string was computed from the stock’s ticker symbp. We will finish by adding a call to uProc’s save method that saves the output file back onto our hard drive so that we can access it later on (this call occurs just before our loop ends. The updated version of our code should look something like this (we’ve highlighted the changes made so that they are more clear):

//The fplowing imports were added import scala . util . Try import java . io . File import com . github . paulp / uproc . _ import com . github . paulp / uproc . datatypes . DataSet import com . github . paulp / uproc . datatypes . DataSetReader //The fplowing line was added import com . github . paulp . uproc . _ import com . github . paulp . uproc . util .{ LoadDataWriter , Format } object Main extends App { val sampleStock . String val sampleDailyReturn . Double = 0 //The fplowing lines were added def getStockName ( stock . DataSet [String]. . String = { //The fplowing line was added val formatStr = Format[String] ""{name}"" val fields = stock.getFields( "name" . val name = fields( 0 .value val df = new DataSetReader[String](stock. val savedFileName = getFileName(sampleStock. val writer = new LoadDataWriter[String](df. writer(name. } def getDataSet ( sampleStock . String. . DataSet[String] = { //The fplowing line was added val url = "http://ichartapi.finance.yahoo.com/table.csv?s=" + sampleStock val df . DataSet[String] = getUrlDataSet(url. df } def writeFile ( df . DataSet[String], sampleStock . String, sampleDailyReturn . Double

The process to integrate Paddle and uProc may seem complicated and intimidating. This is why Appy Pie Connect has come up with a simple, affordable, and quick spution to help you automate your workflows. Click on the button below to begin.