Wave + uProc Integrations

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

About Wave

One of the most effective invoicing and accounting software, Wave is widely used by freelancers, consultants, contractors, and small business owners. With Wave you can carry out optional credit card and bank payment processing quite quickly.

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
Connect Wave + uProc in easier way

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

  • New Customer

    Triggers when a new customer is added to a business you choose.

  • New Invoice

    Triggers when a new invoice is created.

  • Create Customer

    Creates a customer in a business that you choose.

  • Create Invoice

    Creates a new invoice.

  • Create Product or Service

    Creates a product or service in a business that you choose.

  • Record Transaction

    Records a transaction in a business.

  • Select Tool

    Select a tool to perform verification or enrichment

How Wave & uProc Integrations Work

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

    (30 seconds)

  2. Step 2: Authenticate Wave 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 Wave and uProc

Google Wave is a new project by Google which is intended to be a new form of communication. It is perceived as a way to make the Internet more social. The product is being developed for Chrome OS, Mac OS, and Linux platforms. However, it is not yet available on Microsoft Windows or mobile devices, but Google has announced that they are working on versions for these platforms.

UProc is a new language designed for building web applications. It was created by Google (in particular, by Nikita Johnson and Brian Leroux. UProc is a general purpose language which is used for creating Web applications. With this language you can create fast and highly scalable applications.

The aim of this article is to show how Google Wave and uProc can be combined in order to create faster and easier to use web applications.

  • Background
  • Google Wave?
  • Google Wave is a web application which allows users to cplaborate with each other. In addition, it facilitates real-time communication by using live text, images, videos and even links. Furthermore, it supports drag-and-drop functions, allows users to share URLs and highlights text which are added by other users. It also provides functionality to perform keyword searches on chat sessions, messages and attachments.

    Google Wave is an open platform which enables users to create new wavelets (a wavelet is a unit of conversation. Each wavelet represents a topic of discussion. You can add people to the wavelet and start chatting about the topic you have chosen. You can also add wavelets as participants in your current wavelet.

    The main advantages of Google Wave include instant notification of new messages, ability to discuss several people in one place, the possibility of sharing links and images, and real-time typing. Some of the disadvantages include the lack of offline support, limited keyboard shortcuts and absence of email addresses for contacts.


    UProc is a programming language which complies with the Python syntax and runs on top of Python’s standard library (it uses the Python interpreter as its runtime. One of the main goals of creating this language was that it should be run by Google’s Python-based infrastructure (including App Engine. without modification. Therefore, if you need to develop some application which provides real-time communication between users, you can use uProc instead of developing a full stack from scratch. By using uProc, you will be able to save time and money, because not only you will avoid having to write all the backend stuff from scratch but also you will have access to other libraries which help you handle communication between users.

    uProc consists of two parts – server and client side. The client side manages communication between users and the server side handles connections between clients. Both these sides interact with each other through messages received via the server side. There are three types of messages. query messages, update messages and event messages. These messages are easily transferable between the client side and server side (using JSON encoding.

    The client side of uProc consists of two major components. an engine and a shell. The engine creates data structures from conversations in a way similar to how an interpreter works with code – it simply takes lines from the input stream and executes them one by one until it runs out of them or encounters an error (it then returns an appropriate error message. The shell takes a sequence of commands from the user and sends them to the engine as strings (the engine then parses them into commands that make sense for it.

  • Integration of Google Wave into uProc
  • Integration of Wave into uProc
  • There are already some projects which allow integration of Google Wave into various systems. For example, if you want to integrate Wave into Django’s framework, you are advised to use django-wave [1]. The authors of this project have made it easy to integrate Wave into any platform based on Django or other frameworks (such as Pylons or Zope. Another project – mod_wave [2] – allows integration of Wave into Apache’s Web Server through mod_python script. This script allows you to communicate with wavelets which have been previously created via web pages. This way users can view content of wavelets in any web browser such as Google Chrome.

    However, I think that integrating uProc into Wave would be more beneficial than integrating Wave into existing platforms. For this reason I would like to present some ideas on what could be done in order to integrate both platforms into each other so that they would be able to work together properly. As I stated before, uProc operates at the level of command messages while Wave operates at the level of text messages. Therefore, we need some kind of middleware which will enable communication between the two levels. For example, we could create a special application which will act as a bridge between uProc and Wave by translating commands from uProc into text messages which can be understood by Wave’s system. Now let us take a look at what problems arise when we try to implement such spution.

    One of the main objectives when creating this spution should be to make it as customizable as possible so that developers would be able to use it in their projects without modifying any source code (they should still be allowed to modify their code in case they want to provide additional functionality. This means that we should create some kind of interface which will expose all functions provided by our application so that developers could use them programmatically (for example, through Python modules. We should also provide some kind of configuration file so that developers would be able to configure some aspects of our application (for example, they could specify database credentials.

    Another objective should be making our spution modular and extensible so that developers could easily add custom functionality without changing core code. Not only should they be able to use existing functions but also add their own ones which will make managing communication easier for them.

    Each message sent by uProc contains a “key” field which contains information about who sent it (in case we want to know who sent a message we just need to read this field. However this information is not enough for us because we need additional data such as sender’s name and email address. Therefore, we need some kind of database where data about each contact can be stored using his/her key as an identifier. When trying to set up such database we must consider two things. data storage format and how data will be accessed by our application. In terms of data storage format there are two possibilities. relational database management system (RDBMS. or non-relational database management system (N-RDBMS. [3]. If we choose RDBMS we need to decide whether we want it to be SQL or non-SQL based; similarly if we choose N-RDBMS we need to decide whether we want an object-oriented one (based on objects. or a document-oriented one (based on documents. Choosing N-RDBMS instead of RDBMS may help us reduce costs related to maintaining data storage but it may increase costs associated with accessing data because N-RDBMS require multiple queries in order to retrieve information whereas RDBMS require only one query[4].

    Another important aspect is security – defining a way for authenticating requests coming from clients in order to prevent unauthorized access from third parties. We should also decide how secure our connection between servers should be – whether we want it to be encrypted or not and if yes then how do we want it encrypted? One way would be adding SSL support but this may slow down our application because encryption/decryption algorithms are very computationally expensive; therefore we should choose an encryption algorithm which would require less computing power when encrypting/decrypting data [5].

    After we have decided what exactly our application should do we can start its implementation. It would probably be easiest if we use a non-relational database management system (N-RDBMS. instead of RDBMS because they do not require schema definition; therefore defining tables containing different fields should not cause any problems (note that non-SQL based N-RDBMS do not require tables at all. If we decide that N-RDBMS is the right choice for us then implementing our application should not cause any problems; however if we decide that RDBMS is better for us then defining tables might become a problem because schema definition might introduce a lot of overhead into our application (this might occur if we insist on having rich schemas. Another thing worth considering is whether objects or documents are better suited

    The process to integrate Wave 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.