Cloud Connected



"I have been searching for a product like Cloud CMS for over 10 years.

After false starts with some typical content management solutions, we were finally able to design the content repository that our business required."
James Baddiley
James Baddiley, CEO
ChilliSauce

Easy Forms with Cloud CMS

Cloud CMS lets you easily design and deploy forms for your web applications and content contributors.  In this blog entry, we’ll walk through how you can do this within the Cloud CMS Administration Console.

In this example, we’ll create a form that allows parents to register a child for a summer camp.

Add a Definition

We begin by telling Cloud CMS what a registration is.  This is a bit like defining a word in the dictionary.  We will define a “registration” and tell Cloud CMS what schema it should have.  The schema describes the properties, types, constraints and structure of the content.

When someone fills out the form, Cloud CMS can then capture the content and store it in a way that is searchable and reusable.

Within the Console, we go to our branch’s definitions and click New Definition.

image

We provide a few properties for our new definition including a qname which defines a unique key (kind of like a dictionary “word”) which is ours.

Now we define the schema of this definition.  Cloud CMS uses JSON Schema for content modeling.  The console provides a good JSON editor to make things easier.

image

This schema has 5 properties (event, name, birthday, phone and notes).  Some properties are required.  Others are not.  The event property is allowed to take on one of three values (“wobegon”, “music” or “arts”).

Now we save our definition.  Cloud CMS instantly compiles the definition with no server restarts and no downtime.  The console shows us that our definition is loaded up and ready to go.

image

Add a Form

So far, we’ve defined what a camp registration is.  That is to say, we’ve defined the model for a camp registration.  We now want to add a form that can be used to create new camp registration content instances.

Cloud CMS lets you have many forms for a single definition.  You might choose have one form for administration that shows all fields and gets down and dirty.  You might have another form that simplifies things, has a simple layout and is intended for parents to use on a web site.

Let’s create a simple form.  All we have to do is click on New Form.

image

We now provide some configuration for our form.  We can do many things here such as modify the layout, the placement of fields, plug in custom templates and configure different kinds of fields (or controls) for our field elements.

Let’s use the following configuration to customize the fields for our form:

image

As you can see, each field has been given a label and a type.  The type identifies which field control to use.  The Cloud CMS forms engine provides 31 out-of-the-box fields.  Here we use “select”, “text”, “date”, “phone” and “textarea”.

We now save our form.  Cloud CMS automatically compiles the form and brings it online.  The console tells us that our camp registration form is ready to go.

image

Create Content using our Form

Now we can create content using our form.  We can do this from within the console or from our own web applications.

In the console, we click Create Node and we pick our form.  The form is presented to us and we can begin using it.  Here is an example of our Camp Registration form partially filled out.  

image

Notice that Cloud CMS automatically fires validation logic for things like required files.  The Cloud CMS forms engine is very configurable and provides drop downs for selectors, date pickers, custom formatters and much more.

Learn More

In additional to content entry forms, Cloud CMS provides storage and reporting facilities for analyzing form submissions.  It provides the ideal low-cost, cloud-based backend for your business.

Interested in learning more?  

We invite you to sign up for a Cloud CMS free trial account.  It’s instant and without any pressure.  We’re ready to help you to build great apps.

Adaptive Content in Practice - a Hands On Session!

We’re really excited at Cloud CMS to be able to attend and present at CMS Expo on May 15.  Michael Uzquiano from Cloud CMS will be giving a talk on Adaptive Content in Practice.

This will be a hands-on session aimed at content strategists and business types who want to gain a better understanding of what adaptive content is all about in practice.  The session will involve walking through the implementation of content-oriented web and mobile sites that reuse and repurpose well-structured content with rich metadata.

We’re hoping to keep things light and fun without getting too heavy into the technical details.  That said, we want to show how it really does all work and so we’ll dive into:

  • Content modeling
  • Content properties, types, validation and constraints
  • Forms
  • jQuery Mobile Framework
  • Cloud Deployment and Content Delivery

Adaptive Content is a term that was popularized by Karen McGrane in her book Content Strategy for Mobile.  It’s a term that encapsulates structured content, metadata and, in our view, decoupled delivery.  

When put into practice, an adaptive content approach offers your organization the promise of delivering better end-user experiences more quickly and with less cost by:

  • Building content for re-use with rich metadata
  • Leveraging automation for decoupled deployment
  • Empowering the device to make decision on how to render

CMS Expo is a wonderful event that brings open-source and proprietary vendors together to collaborate around innovations in content technology, content strategy, the cloud and mobile/web frameworks.

We’re excited to be a part of it and encourage everyone to attend our session!

Content Previews and Thumbnails with Cloud CMS

Cloud CMS lets you generate preview images (often called thumbnails) for any content item stored in your repository. This generation can be performed ahead of time via content modeling or it can be done in real-time using a simple URL call.

Content Nodes

In Cloud CMS, everyone content item you create is referred to as a node. A node is a JSON document that can have any structure you’d like.

That is to say, you can drop any valid JSON document you’d like into Cloud CMS and the product will automatically capture it, version it, index it and so forth. It’ll also give your node a unique ID (provided by the _doc field).

Every node lives on a repository branch. You might be working on repository repo1 and branch master. You might use the Cloud CMS Console to create a simple JSON node:

image

When we create this node, Cloud CMS automatically gives us a Node ID.  

image

In this case, it gives us d9cfc0491de1a63b6e8e. It is available in our JSON document and we can use this ID to reference our node anytime we want to. 

Note: Fans of the 80’s will no doubt identify the absurdity of a document promoting a movie that should not be made.  Still, we’re here to have some fun, so let’s go with it!

REST API

The Cloud CMS REST API lets us work with Cloud CMS content via HTTP commands. If we’re authenticated against our Cloud CMS platform or if our platform offers guest-mode access, we can reference our node like this:

This will give us back our JSON document. It’ll also give us a few additional and interesting properties.

{
   "_doc":"d9cfc0491de1a63b6e8e",
   "_features":{
      "f:audit":{},
      "f:titled":{},
      "f:filename":{
         "filename":"Back to the Future part IV"
      },
      "f:geolocation":{},
      "f:indexable":{}
   },
   "_qname":"o:d9cfc0491de1a63b6e8e",
   "_type":"n:node",
   "description":"Yes, they're back.  In Time.",
   "destination":1985,
   "title":"Back to the Future part IV",
   "year":2015
}

We won’t delve into this too deeply. But it suffices to say that our new node has automatically been given a dictionary type n:node and a definition qname o:d9cfc0491de1a63b6e8e. This allows us to use Cloud CMS’ content modeling facilities (if we choose to) to provide validation logic and behaviors on top of our content.

We also see that it has been outfitted with a number of features such as f:audit, f:geolocation and f:indexable. These features inform the behavior of our content and tell Cloud CMS that:

  • access to this content object should be recorded in the audit logs for our platform
  • a geolocation index should be maintained for this content so we can look it up by latitude and longitude (if desired)
  • this content should be indexed for search

Each feature can be configured. By default, no configuration is provided which allows Cloud CMS to fall back to its default way of handling each feature.

Attachments

Now on to preview images.

Every node in Cloud CMS supports zero or more attachments. An attachment is a binary object that is associated with the node.

You can think of attachments kind of like you think of attachments for an email. Every email can have many attachments. And the same is true for nodes. A node might have zero attachments. If so, we think of this as “content-less” content. Nothing wrong with that. However, other nodes might have a single attachment.

For example, a Word document would be stored in a node (with some JSON) and have a single default attachment which contains the Word document itself.

Suppose we upload a Word document as an attachment for our node. The word document might provide a movie description along with some images.

image

We can then reference this Word document via HTTP:

This will stream the Word document back to us.  Very useful!

Previews

Now let’s suppose that we have a web site. And on our web site, we’d like to provide a link to this Word document along with a thumbnail for purposes of preview. It’s easy. We just let Cloud CMS do the thumbnail generation for us.

This will generate a thumbnail image of the default attachment with a max width of 320 in image/jpeg format. Cloud CMS will produce a preview image of the first page of the Word document.

The preview image will be saved as a new attachment on the node. The new attachment will be called thumb320. The thumbnail will only be generated on the first call. Subsequent calls will re-use the previously generated attachment.

Options

The URL-based preview generator provides all kinds of neat options. Using request parameters, you can adjust how your preview attachments are generated and maintained. Here are some of the options:

  • mimetype - specifies the preview mimetype to be generated. If not specified, assumed to be image/jpeg. However, you could specify other image formats or even other document formats such as application/pdf.
  • size - specifies the maximum width of the resulting image (when mimetype is an image format).
  • attachment - specifies the attachment on the node to be previewed. If not specified, assumed to be default.
  • force - specifies whether the preview attachment should be re-generated in the event it already exists. If not specified, assumed to be false.
  • save - specifies whether the generated preview attachment should be saved as a new attachment on the node. If not specified, assumed to be true. If you set this to false, each request will generate the preview anew.
  • fallback - specifies a fallback URL that should be 301 redirected to in case the preview does not exist or cannot be generated.

Examples

Cloud CMS uses preview generation in many places. Fundamentally, we use this quite extensively in all of our HTML5 front-end applications as a means for generating intuitive user interfaces. Here are a couple of really neat places where it shows up: 

Real-time Document Transformations

Suppose we wanted to offer the default attachment (Word document) as a PDF. After all, PDF is a much preferred format for consumption. Businesses tend to prefer Word for the back-office and PDF for the consumer. We can do this by using a link like this:

Multi-Device / Multiple Form Factors

Suppose we want to support lots of form factors. We might want to have a hi-res preview for large form factors (like a kiosk) and much smaller images for devices like an iPhone. We may even want different mimetypes based on bandwidth. We can adjust our URLs accordingly.

Here are a few examples:

imageimageimageimage

Fallback

Sometimes we may not know whether a preview can/could be generated for content. Suppose, for example, that we want to produce a list of nodes. For content-less nodes, we might provide a stock image that use as a placeholder. The preview generation code lets you fallback to a URL of your choosing. You can do it like this:

Conclusion

As Cloud CMS grows and evolves, we’re pushing further into services and capabilities that support live applications.  The platform’s document management and transformation services are powerful capabilities that stand ready to service your web and mobile apps!

Are you new to Cloud CMS?  If so, consider giving us a try by signing up for a free trial today.