canvas

Canvas 3 Released

canvas 3.png

Canvas 2 was already a big step forward by making Canvas way faster and bringing a lot of new features such as reports bursting. Thanks to feedback from all our customers, this new version brings Canvas much further by adding two desired components - a whole new Cube Viewer and Subset Editor.

Cube Viewer

The new Canvas Cube Viewer will offer greater flexibility to your users and fasten developments. It fully supports all IBM Planning Analytics features such as hierarchies and sandbox. What is more is that you are free to customize the look, the way you like.

Subset Editor

Canvas already had lots of different ways to facilitate user selections with dropdown, radio-buttons, date picker... now with the Subset Editor, your users will be able to use all common TM1 and Planning Analytics filter features such as filter by level, attributes, string. This Subset Editor is also highly customisable.

Sandbox

Canvas now supports sandbox. Creating, Publishing, Discarding and Deleting sandboxes is now very easy to do in your Canvas application. The DBRs support sandboxes as well so you can now compare different sandboxes by just referencing two different sandboxes to two different DBRs.

New samples

A whole new sample application has been added. This new application is a great way to learn how you can customize all Canvas look and feel following the standard practices.

Introducing Apliqo UX

If you are looking for Out-of-the-box solution,  check out Apliqo UX. The Apliqo team has built an App-Builder on top of Canvas with lots of ready-to-use components. With Apliqo UX you get the power and freedom of Canvas combined with the ease of drag-and-dropping.

READ MORE:

How Cubewise Code will shape the future of IBM TM1/Planning Analytics in 2018

2018 v2.png

A lot happened in the TM1/Planning Analytics world in 2017. Canvas has been endorsed by many customers as their new way to build modern web planning and reporting applications. TM1py brought together for the first time, the TM1 and Python communities in order to find new ways to integrate external systems with your TM1 application. 

In 2018, we continue mastering the TM1 REST API by introducing a brand new product:

Something that all TM1 developers have been asking for! A new way to build your TM1 models which takes advantage of all the new features of TM1 11 / Planning Analytics. More information to come on this blog or you can contact your local Cubewise office.

Pulse goes Big Data with Kibana and Elasticsearch

Buiding reports and analysing the core of your TM1 application such as your TM1 user sessions, TM1 process errors, TM1 process/chore runtime... will become even easier now with Kibana and Elastic Search.

Kibana is probably the most exciting new feature of Pulse since migration was added. With Pulse v5.7, Pulse can now send data to Elasticsearch, one of the best and most popular Big Data stores. Kibana provides dashboarding / reporting on top of the Pulse data stored in Elasticsearch enabling you to develop your own metrics and share them with your TM1 community.

Canvas Cube Viewer and Subset Editor

Canvas will continue revolutioning the way TM1 planning and dashboarding applications are built. Canvas has proven in 2017 that it is a mature, scalable and stable solution for many customers. In 2018, we will make Canvas even better by introducing a lot of new exciting features such as the brand new Cube Viewer, Subset Editor and new samples.

A new version of Bedrock and TM1py

In 2018, there will be a new version of Bedrock (v4) which will be designed for IBM Planning Analytics. This will support hierarchies and all the new functions introduced with Planning Analytics Local. We will continue improving TM1py as well, with a lot of new features and articles to inform the TM1 Community about what you can do with Python.

Exciting IBM TM1/Planning Analytics conferences coming close to you

This year TM1 and Planning Analytics conferences will be held in four locations:

  • London in April
  • Sydney and Melbourne in August
  • Las Vegas in September

We will also be at Think conference in March so if you are in Las Vegas drop by and say hello.

Read more:

 

 

How Cubewise CODE has revolutionized TM1 Planning Analytics in 2017

A lot happened in 2017 in the IBM Planning Analytics (TM1) world. Here is a quick recap from Cubewise CODE.

Pulse: Centralized Database Architecture

Pulse take up continues to grow beyond 150 customers globally allowing our customers to watch over a combined total of well over 50 million lines of TM1 code. Accordingly, the number of “large enterprise” TM1 implementations has increased necessitating support for MS SQL Server. The latest version,  Pulse v5.6,  incorporates a centralized database architecture which brings downstream benefits such as forensic TM1 server and user reporting via Big Data provider, Elasticsearch. This version is a big step forward for Pulse in the cloud.

Canvas v2 Released

Canvas v2 was a major milestone in the maturity, scalability and stability of the product. This new version introduced lots of new features such as:

A new way to integrate systems with your IBM TM1 Planning Analytics application

TM1py is a free Python package that wraps the TM1 REST API in a simple to use library. Making it easier to integrate systems more effectively with IBM Planning Analytics.

Speed up your IBM Planning Analytics development with our free products

Bedrock, TM1Kill, Hustle and many more other free products will save you lots of time as a TM1 developer:

Cubewise EDU Conferences and Training

In 2017, we hosted more than 500 paying delegates at our IBM Planning Analytics conferences in Sydney, London, NYC and Los Angeles. To learn more about our products, training is now available from the Cubewise EDU page.

conferencesflat.png

Looking forward to 2018

2017 was a great year for the TM1 community and Cubewise Code. We are looking forward to 2018 and making IBM Planning Analytics even better!

READ MORE:

The differences between IBM Planning Analytics Workspace and Canvas

The world has changed, user experience is now the most decisive factor in the success of any business application that is built for people, and TM1-based applications are no exception. Despite inferior modelling capability and performance, other (non-TM1) software solutions have become popular almost solely on the fact that they meet modern user expectations for user experience.

scaleJPEG.png

In other words, companies are choosing their budgeting and reporting solutions based on look and feel and not based on whether it gets the job done - and done well.

To address this, at the end of last year IBM released Planning Analytics Workspace (PAW). PAW is a completely new, modern, web-based self-service user interface for TM1.

With Cubewise Code’s Canvas for TM1 and IBM’s Planning Analytics Workspace, TM1 customers thankfully now have two options to offer users to give them a modern TM1 user experience.

But there has been some confusion about where customers should best use PAW and where best to use Canvas. Let’s dig into that.

Similarities

Canvas and Planning Analytics Workspace are both designed to build web applications natively on TM1 using the TM1 REST API. This means that both are very fast and require no other data layer (no “connector”, no flat file interface, etc.) to access TM1. They both are focused on TM1-specific functionality which means they feature the rich, high-performance write-back capabilities that underpin business planning applications.

Differences

SELF SERVICE vs Curated Apps

PAW has been designed as a powerful ad-hoc self-service data discovery tool with which business users can easily build and share their own reports and dashboards. The main advantage of such drag-and-drop tools is that any user with minimal to no training can create a report or dashboard quickly. The disadvantage is that the user is inherently limited to whatever the software allows them to drag and drop and corresponding “right click” options. If you want to do something you have been able to do in Excel or have seen in another application and it is not “in the box”, the best you can do is request the new feature from IBM and hope they prioritise it.

Canvas is not a drag-and-drop tool. Canvas was designed to finally bring the freedom and power of modern web application development to TM1 developers. The core benefit of Canvas is that for the very first time, a TM1 Developer can produce a modern web-based application and match the modern user experience “wow factor” expectations of end users.
Some people have shied away from Canvas because they do not know HTML. But Canvas has been designed with this in mind – we have seen that any TM1 Developer that can write rules and TI is able to easily learn enough HTML to be able to build rich, modern web applications for TM1 with Canvas. In short, it allows TM1 developers to embed DBR and SUBNM functions (among many other familiar TM1 pieces) into their web applications in a way they are already familiar with in Excel.

VIEWS VS CELLS

PAW and Canvas are built on fundamentally different concepts in regards to how a report is built

PAW is a view-based application. It allows a user to easily drag and drop a TM1 cube view onto a workspace and then display it as a range of charts. So whatever a user wants to have in the chart, they must have in the view – which may lead to design decisions regarding what you put in a cube in order to display it in PAW.

Canvas, on the other hand has adopted a cell-based approach to application building similar to Excel, and TM1 Perspectives.  This means each cell in Canvas has its own DBR formula to retrieve data and to update TM1, which is exactly how TM1 Developers are used to working with TM1. So with Canvas, you can easily combine data from two different cubes into one table or chart as you can in Excel and TM1 Perspectives.

 CONCLUSION

As it turns out it is not Canvas versus PAW - Canvas and PAW are complementary products. PAW is much better suited for ad-hoc TM1 reporting while Canvas is definitely the product of choice for those who want to build a sophisticated custom TM1 application for planning or reporting.

Canvas v2 Released

The unique IBM TM1/Planning Analytics REST API framework just got even better! Some of the highlights of the great new features of Canvas version 2 below.

Email Bursting

With Canvas v2, you can now burst PDF reports by email. There are 5 ways to drive your bursting either based on a Dimension Subset, Dimension MDX, Cubeview, CSV file or a path to a CSV file. 

Even more exciting is that you can schedule to run a TM1 process or TM1 chore just before the bursting via the Task Scheduler.

Alternate hierarchies are now supported

Canvas v2 also supports the exciting new alternate hierarchies feature found in IBM Planning Analytics. To get values using alternate hierarchies, you can now use the following syntax:

  • "Hierarchy1::Element1 && Hierarchy2::Element2"

For example, to get the value from 2010 Jan from the Time dimension, you will need to use the following:

  • "Year::2010 && Month::Jan"

As you can see in the following screenshot which is using the cell reference feature in Canvas:

A new way to upload Excel files into TM1

Canvas includes the SheetJS library which will help you read data from a spreadsheet and display it in your browser.

Once the data is in the browser and after clicking on the Save button. Canvas will batch the query and send the data into the TM1 cube using the TM1 REST API.

Canvas usage tracking is now available

With Canvas, you can track which pages your users are using. This data can be viewed in Pulse and/or stored in a file system.

Refresh only a specific group of DBRs

You can now make your page even more responsive by grouping your DBRs so they do not all refresh when you input a value into one DBR.

Upload data into TM1 from an Excel file

No matter which tool your company uses for planning, if finance users have to choose one tool to input lots of data, they will choose Excel.

With IBM TM1/Planning Analytics, you can give your users the freedom to do all their input into Excel and then upload the Excel file into the TM1 cubes. This article explains the different methods that you can implement in your TM1 application to upload data from an Excel file into your IBM TM1/Planning Analytics cubes.

Option 1: DBS or PAx

The most common way to send data from Excel to TM1 is to use the DBS formula. The DBS takes a value from a cell and sends it to the TM1 cube. With PAx, the new Excel Add-in, a simple copy paste can send the value into the TM1 cube. 

The advantage of this method is that it is straight forward, you just need to refresh Excel or press the commit button in PAx to upload the data into the TM1 cube. But the challenging part is that you rely on Excel and this is not the best option to upload lots of data. The other main challenge is that there is no governance or transparency. Any TM1 user could upload any data from any Excel spreadsheets.

Option 2: TM1 processes

The second option is to use a TM1 process. TM1 processes are very powerful, they can load data from many types of data sources, albeit Excel is unfortunately not one of them. In order to load data from an Excel file, you will need first to convert the file into a CSV or text format.

To upload data using this method you will need to follow these steps:

  1. User copy their Excel file into a specific folder.
  2. A script converts Excel file into CSV.
  3. TM1 process uploads the CSV file into TM1.

The advantage of this method is that users do not need to log in to TM1 and they can work offline. But this method is not straight forward, in theory it works, but in real life applications there are lots of moving parts.

Option 3: Canvas

The third option is to use the TM1 REST API, in just two steps you can load lots of data from your web browser into TM1:

1. Upload File into your web browser

Canvas includes the SheetJS library which helps working with spreadsheets on the web. With a simple button you can upload an Excel file and then display the data into your browser.

This step allows you to do validations before sending the data into TM1:

2. Send the data into TM1

Once the data is in the browser and after clicking on the Save button. Canvas will batch the query and send the data into the TM1 cube using the TM1 REST API.

This method gives you an extra step where you can validate automatically your users input and add greater governance, controls and transparency so you know who has updated which cells and when.

Once the Excel file is uploaded, all the work is happening on your web browser. You can then continue working on Excel while your data is uploading.

Find the biggest impact on your budget in an instant

Finding which cost center, product or project has the biggest impact on your budget can be time consuming if you have to drill down to the lowest level of a large dimension.

Have you already thought about using Treemaps?

Crossing two types of data will speed-up your analysis, for example while you analyse the % of margin, the Treemap can help you to analyse the impact as well. A product could have a high % of a margin but a low impact or a low margin but high impact.

    Why you should use it?

    A Treemap is a great way to display hierarchical data. It simultaneously shows the big picture, comparisons of related items, and allows easy navigation.

    In a Treemap, you analyse two types of data with one visualization. A quantity measure such as revenue which will determine the size of the boxes and a measure of performance such as % revenue compared to last year which will be represented by the colors.

    Dynamic Treemap with Canvas

    The Treemap in Canvas is dynamic, you can navigate intuitively through the hierarchy, starting from the top consolidation and then drilling down quickly to the lowest levels:

    Customize it the way you like

    With Canvas, you are not limited, you can customize colors, fonts of the Treemap the way you like:

    Meet the Cubewise Code team in Sydney

    The 2017 Sydney TM1 & Planning Analytics User Conference is coming very soon, the 15th of August. The Cubewise Code team will be there.

    For the first time this year, there will be two hands-on sessions where you will be able to try Pulse and Canvas.

    There will be plenty of opportunities to meet us:

    Pulse user group

    On Day 1, It is a customer feedback sessions where you will get the latest news on Pulse, learn a new way to access Pulse databases and Customer stories.

    Pulse Hands-On

    On Day 3, Try Pulse and learn in this session how to improve your Change Management process by using the change tracking, migration and user analytics features.

    Canvas Hands-On

    On Day 3, Try Canvas and learn how to build a TM1 data entry template using the modern web technology. Take the opportunity to learn the basics of HTML, Bootstrap and Angular.

    Booth for demo

    You can meet us at our demo booth where we can show you all our products.

    Book your ticket

    If you haven't booked your ticket yet, you can see the full agenda and book your ticket on the cubewise website: cubewise.com/conference/.

    Analyse your data with Google Map and IBM TM1/Planning Analytics

    Canvas for TM1 gives your company the freedom to easily create modern, sophisticated IBM TM1/Planning Analytics applications. There is almost no limit with the things you can do now, such as displaying your business data by locations with Google Map. For example we have seen sales field rep benefiting from this new type of visualization:

    Integrate Google Map into your application

    With Canvas for TM1, it is really easy to link Google Map with your IBM TM1/Planning Analytics data. All you need to do is query your cube using MDX Query and then use Canvas for TM1 to display it in Google Map:

    Create your own Google Map

    Even better, you can customize Google Map to the way you want it. Show/Hide roads, parks or monuments. There are lots of settings that you can play with! Google Map has a Google Maps APIs Styling Wizard which will help you create your own style:

    Canvas for TM1 at IBM Vision

    This year at IBM Vision in Orlando, there will be two great examples of Canvas applications presented by Jabil Circuit and Apliqo C3.

    Jabil Circuit

    Jabil Circuit is building a refreshed web-based user interface for its 2,500+ Cognos TM1 users leveraging Canvas for TM1. Jabil will be presenting on stage, the session code is FPM-1205.

    Apliqo C3

    Apliqo C3 provides a pre-built Performance Management Solution with unified reporting, analysis and planning in ten different modules. They have chosen Canvas to rebuild their existing Cognos TM1 Web application into a whole new modern interface. The Apliqo team will be presenting on stage, the session code is FPM-1281.

    Meet us at our booths 13 & 14

    You can meet the Cubewise and the Apliqo team at their booths 13 & 14. Swing past our booths and get a selfie with Manny Perez, Cubewise CTO and the inventor of TM1!

    Canvas examples

    Responsive design with Canvas and Bootstrap

    Excel vs HTML

    The first thing you notice when you start building a web page is that the layout is not defined. You literally start from a blank page. First you have to create the containers before adding some contents. 

    In Excel, when you create a new sheet, you can easily add some contents into the cells. The advantage is that you don't have to worry about defining the containers but the downside is that the layout is fixed. The size of the cells will always be the same no matter the screen-size. It is not responsive, on a small screen it is likely that you will have to use the scroll bar to see all the contents.

    Building a webpage takes a bit more time at the beginning because you have to define the layout. The advantage is that it offers you the freedom to set your layout as you want. To help you to define a responsive design for your TM1 applications, Canvas includes the Bootstrap framework.

    What is Bootstrap?

    Bootstrap is a pretty nice HTML and CSS framework for developing responsive web applications. In other words it helps to create a layout which will adjust depending on the screen size.

    The bootstrap grid system allows for up to 12 columns on the page. You can group multiple columns to create bigger containers:

    For example if you want to show 4 columns of the same size in the same row, you will need to create 4 containers with a width of "col-md-3", you define a container by using div tag:

      <div class="row">
        <div class="col-md-3">
             Column 1
        </div>
        <div class="col-md-3">
             Column 2
        </div>
        <div class="col-md-3">
            Column 3
        </div>
        <div class="col-md-3">
            Column 4
        </div>
      </div>

    This is what your page will look like, 4 columns with the same width:

    If you work on a smaller device where the 12 columns cannot fit, instead of staying on the same row and use the scroll bar to see them, the columns will be pushed to the next rows:

    Bootstrap allows you to manage the look and feel of your TM1 applications as you resize your web browser or switch from a tablet to a smart phone.

    Dashboard with responsive design in Canvas

    In the following video, you can see an example of dashboard with a responsive design:

    With Canvas and Bootstrap you have the freedom to define the look and feel of your TM1 applications. You do not need to know Bootstrap or HTML before starting to build Canvas pages. Canvas comes with a complete set of samples which will give you plenty of ideas on how to build out your own TM1 applications, and if you want to go even further there are plenty of contents online such as forum and training courses.

    What is the TM1 REST API?

    The TM1 REST API is a new way of accessing data and everything else in TM1. Rather than being a proprietary API like old TM1 interfaces it is based on web standards making it accessible to a wide range of developers.  

    REST stands for REpresentational State Transfer and is an architectural style (not a standard) that has become the common way of designing API for applications on the internet. The TM1 REST API does however support the OData standard (v4) which provides a common way for accessing data through queries and also updating data. OData is used by multiple vendors and is supported by companies like Microsoft, SAP and of course IBM

    If you want to become a true TM1 REST API guru you should read up the documentation on the odata.org website. TM1 supports v4 of the standard, you may find examples out on the web that are an earlier version of the standard that won't work with TM1.

    An important distinction to make about REST and OData is that neither of these are programming languages. The REST API is language agnostic, you can use the language of your choice: Java, JavaScript, Python, C#, Visual Basic, etc. All of these languages have HTTP libraries that will allow you to access the REST API.

    What is great about the REST API?

    • It is fast! The REST API is built in to the TM1 server, there is no external web servers or parts you need to install. Because of this the REST API has direct access to all of that data stored in memory in your TM1 server.
    • It is fast over slow networks! The REST API is optimized for access over the internet, it takes advantage of all of the goodness that is built into the HTTP protocol such as compression, streaming, etc.
    • Did I mention it is fast? In our applications, we are noticing no discernible difference in speed when accessing applications from a local server to one that is hosted on the other side of the world. Our application framework Canvas optimizes this further by batching requests so they are returned in milliseconds rather than seconds.
    • You can use any programming language. Whatever your favorite programming language is the chances are you can use it with the REST API. As long as there is a HTTP library for your language, you can use it. Examples of these are:
      • Java: Apache HTTP Client, okHttp, etc.
      • C# and VB.NET: Built into the .NET Framework: System.Net.WebClient and System.Net.HttpWebRequest
      • JavaScript: jquery, Angular $http.
      • Python: httpie.
      • Others: Search github.
    • It is very easy to get most information out of TM1, there is even a built-in document that describes the API called $metadata (more on that later).
    • It is cloud and big data enabled! I just added that to make the article sounds cooler.

    What ARE the hard bits ABOUT the REST API?

    If we are going to make an objective assessment of the REST API we also need to understand that it isn't all smooth sailing with the REST API. In fact, because of the points below Cubewise decided to build a framework on top of the REST API called Canvas to help TM1 developers build beautiful user interfaces without all of the scary bits.

    • It is low level. The REST API is built to access TM1 objects directly, this is easy for many queries but is more difficult for updating data, accessing application entries and a number of other things.
    • Difficult for the traditional Accountant who recently became a TM1 Developer. As stated before, the REST API can be complicated for people without an IT background.
    • Little cross-over from existing TM1 concepts and terminology. If you are a long time TM1 person you will be very familiar with functions such as DBRW and SUBNM as well as Active Forms and Slices. These concepts don't exist in the REST API but do in Canvas.

    What can you use the REST API for?

    Anything, the REST API is NOT a user interface however, it is a way to access objects/data in TM1. It could be used for pretty much anything:

    • As an ETL tool to move data into and out of TM1.
    • As a data source for a user interface.
    • To sync data between TM1 servers.
    • To backup data to another source or file. 
    • Create, update and delete TM1 objects.

    Where to next?

    Over the coming weeks we will be posting regular articles on how to use the REST API including examples. We will also provide a comparison and reasons why we developed Canvas to leverage the goodness of the REST API and provide something that is easy to work with for regular TM1 developers. 

    Stay tuned!

    Enabling the TM1 REST API

    The TM1 REST API is not enabled by default, you need to update your tm1s.cfg on your TM1 server with the following parameter:

    • HttpPortNumber=8881

    The port number can be anything but not be used by any other application. You must make sure you use a different port number for each TM1 instance (server). 

    You now need to restart the instance of TM1 for it to take effect using the Windows Services panel:

    To see if the REST API is working open your favourite browser (my recommendation is Chrome) and enter the following URL (replace the port number with your one). It is important that you enter the URL exactly as it is below. Note the https as the protocol, TM1 uses SSL by default.

    https://localhost:8881/api/v1/$metadata 

    Because the SSL certificate used by TM1 is for tm1server rather than localhost you will receive an error about your connection not being private (example of Chrome below). It is safe to ignore the error (in development only) so click on ADVANCED and then Process to localhost (unsafe)

    You will now see the content below, which is the TM1 REST API $metadata page that describes all of the objects / actions you can take against the REST API.

    Retrieving Information from the REST API (The GET Request)

    It is very simple to test out the functionality of the REST API using your browser. In the previous article I discussed how you both enable and connect to the REST API. Here I am are going to describe how you query the REST API to retrieve information about your TM1 model.

    Before we get into the detail we need to understand a couple concepts about REST APIs in general. In REST terminology TM1 has a number of resources that can be retrieved, created, updated and deleted. From a TM1 perspective these are just objects: cubes, dimensions, processes, chores, cells, etc. 

    Each resource has a unique URL that identifies what information is to be retrieved from TM1. For example if we want to retrieve information about a cube called General Ledger we would issue a GET request using the URL:

    https://localhost:8881/api/v1/Cubes('General Ledger')

    A GET request is called a HTTP method and TM1 REST API supports 4 different HTTP methods:

    • GET: Retrieves information about the resource specified in the URL.
    • POST: Creates a resource in the TM1 server.
    • PATCH: Updates an existing resource in the TM1 server.
    • DELETE: Deletes an existing resource from the TM1 server.

    The GET request is something that can be executed easily from your browser by typing the address into the Address Bar and pressing Enter. The other methods can only be executed in the browser with the assistance of an add-in like Postman (for Chrome), I will provide more information on how to do this in subsequent articles.

    FIRST EXAMPLE - RETRIEVING A LIST

    The first thing we are going to retrieve is a list of the cubes in our TM1 model. Go to your browser and type in the below URL and press ENTER:

    https://localhost:8881/api/v1/Cubes

    NOTE: If your TM1 model has SSL enabled (the default) you will receive a warning about it being an untrusted or insecure connection. It is ok to ignore this message and proceed. 

    You will be greeted by a pop-up dialog like the image below that will ask you for your TM1 credentials. This dialog uses what is called BASIC authentication and it is only supported when using traditional TM1 security, i.e. IntegratedSecurityMode 1 or 2. If you are using CAM security you should revert back to mode 1 or 2 on a dev/test environment so you can follow these examples.

    Enter your regular TM1 credentials in this box and press Log In, i.e. if you are using the Planning Sample model for testing it would be: admin and apple. You will then be presented with a full list of every cube in your model including the rules. It will also look like a jumbled mess like the screenshot below:

    This data is the JSON response from TM1, JSON is a text based format that is human readable, supported by nearly every programming language and is natively supported in web browsers. To help you understand what this information is I recommend installing a Chrome add-in called JSON Formatter, it will turn that previously ugly mess into this:

    SECOND EXAMPLE - RETRIEVING A SINGLE OBJECT

    We can see from the screenshot above that TM1 is returning a list of cubes in the TM1 model. In this next example we are going to retrieve just a single object, in this case the General Ledger cube:

    https://localhost:8881/api/v1/Cubes('General Ledger')

    Enter the above request into the browser address by appending ('General Ledger') and press Enter. Make sure you use single quotes, it is best to type these directly into the browser or use a text editor like Notepad or Notepad++. If you type the same single quotes into Microsoft Word or Outlook it will convert them to Smart Quotes which aren't supported.

    You will also note that any spaces are automatically converted by the browser to %20. This is called encoding the URL, for a full list how URLs should be encoded see this article.

    The response you retrieve should look like this:

    BREAKING DOWN THE URL

    Before we move on to the next article Using $expand and $select with the TM1 REST API we should review the parts of the URLs above and describe what they mean. Example:

    https://localhost:8881/api/v1/Cubes('General Ledger')

    Parts:

    • https: This the scheme to be used, in this case https, which means use the HTTP protocol using secure sockets. If we were to disable SSL in the tm1s.cfg (UseSSL=F) we would use http instead.
    • localhost: The location as a server name, IP address or domain name to access the REST API.
    • 8881: The port number the TM1 REST API is running on, this has to the same number that you have used for the HttpPortNumber setting in the tm1s.cfg file.
    • api/v1/: The version of the TM1 REST API that you are using, if for some reason breaking changes are made to the REST API the version will increment so no existing applications are broken.
    • Cubes: The collection of resources that we are querying, this can also be Dimensions, Processes, Chores, etc. For a full list see the $metadata document:

    https://localhost:8881/api/v1/$metadata

    A journey through the TM1 REST API

    The TM1 REST API is a way of accessing data and everything else in TM1. Since its first introduction with TM1 10.2, a number of fix packs have been released with additional improvements and extensions. All new products released by IBM such as CAFE (PAX) and Planning Analytics Workspace (PAW) are using it. It is the THE API for the TM1 server going forward.
    The TM1 REST API can be used to do pretty much anything you want with your TM1 server such as building cubes, dimensions, extracting or loading data...

    The TM1 REST API journey for a web application

    You don’t need any extra components to access your TM1 server with the TM1 REST API. You can follow the IBM official guide and try to tackle the TM1 REST API by yourself, but you need to understand that it isn't all smooth sailing:

    1. Access TM1 server. This is the challenging part, there are lots of things which can be difficult to set up and not well documented such as cellsets, cross domain scripting and SSL certificates.
    2. Request data. The TM1 REST API supports the OData standard (v4) which provides a common way for accessing data through queries and also updating data.
    3. Transform data. The MDX query will return you a set of cells that you’ll need to transform in a specific format to make it fit in your application.
    4. Visualization: Once your data is ready, you now need to build your web application using HTML.

    On the one hand, some things are very simple to do with the TM1 REST API, such as getting the list of cubes and dimensions. On the other hand some things which are trivial to do in TM1, can be very hard to do with the TM1 REST API. For example: getting a cell or updating a value.

    Because of these points Cubewise decided to build a development framework on top of the TM1 REST API called Canvas to help TM1 developers to build beautiful user interfaces without all of the scary bits.

    TM1 REST API with Canvas

    Canvas handles all the way from the server access to data transformation so you can focus on the visualization part. With a mix of HTML and Canvas directives you’ll be able to build a modern web planning and reporting application:

    With Canvas, you don’t need to know JavaScript or MDX, the assumption is that if you know how to write a rule or a TM1 process, you’ll quickly learn how to build a TM1 application with HTML. However if you do know JavaScript, you'll be able to build a more sophisticated application.

    Canvas is built with TM1 Developers in mind – it uses immediately recognizable TM1 concepts like DBRs, SUBNMs, Views, etc. and for the first time makes these easy to plug into any web application. DBR in Canvas looks like this:

    <tm1-ui-dbr tm1-instance="dev" 
                 tm1-cube="Regional Assumptions" 
                 tm1-elements="Actual,2012,Jan,13,Super Rate" 
                 >
     </tm1-ui-dbr>

    With Canvas, the TM1 REST API is now available to anyone who does not want to rely on limited drag and drop tools to develop sophisticated applications.

    TM1 Web vs Canvas - Timesheet application

    Here's an example of how your TM1 application would like if you replaced TM1 Web with Canvas. For this example the TM1 Web and Canvas user interface have been built on top of the same TM1 cubes:

    Moving to Canvas will give you many benefits such as:

    • Canvas is mobile ready: resize automatically to fit on any device.
    • Give your TM1 application WOW factor.
    • New kinds of applications that you didn’t think were possible: You can swap rows and columns in your table.
    • Columns are dynamic: hide/show as you like.

    Is Canvas the best reporting tool for TM1?

    TM1 has by far the most powerful calculation engine on the market, but it is also well known that it is missing a modern user interface. Lots of companies using TM1 for planning and reporting also use an extra Business Intelligence tool for management reporting.

    Most of the BI tools on the market do not take full advantage of TM1. Even if it is possible to build beautiful dashboards on top of TM1 data, they are not built for TM1. The main issue is that they do not have direct access to TM1. Indeed, they require either an extra component to connect to TM1 or you'll have to extract TM1 data into flat files in order to process them. By adding an extra step between TM1 and your reports, you're losing the beauty of TM1 which is its speed.

    CANVAS IS FAST

    Canvas uses the TM1 REST API to connect to TM1 which means that it has a direct access to TM1 with no extra ETL required. Canvas optimizes access to TM1 further by batching queries and updates so that TM1 can process multiple requests in one go.

    CANVAS LEVERAGES TM1

    Canvas is built for TM1 by people who have worked with TM1. Canvas gives you access to all TM1 features:

    • Cell orientation
    • Read/Write
    • Attributes
    • Subsets
    • Hierarchy
    • Cell Reference
    • Numeric or String data

    CANVAS IS MOBILE READY

    Canvas includes responsive design libraries that enable you to support all types of devices. This modern web technology is smart enough to manage how it should appear on your browser. You have full control and can optimize your interface for mobile, tablets, the desktop or support all three:

    SIMPLE CELL BASED DBR CONTROL TO RETRIEVE AND UPDATE TM1

    Similar to TM1 and Excel, Canvas is a cell based application, each cells has its own DBR formula to retrieve and update TM1. If you're used to build TM1 reports in Excel, you will quickly learn how to build reports or data entry template in Canvas.