usergrid-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From snoopd...@apache.org
Subject [3/9] incubator-usergrid git commit: Continuing the conversion of Usegrid documentation to Markdown.
Date Wed, 29 Jul 2015 16:06:34 GMT
http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/data-storage/collections.md
----------------------------------------------------------------------
diff --git a/docs/data-storage/collections.md b/docs/data-storage/collections.md
new file mode 100644
index 0000000..97e7bc6
--- /dev/null
+++ b/docs/data-storage/collections.md
@@ -0,0 +1,254 @@
+# Collections
+
+## Creating Collections
+
+This article describes how to create collections in Advanced API Services. All entities are automatically associated with a corresponding collection based on the type property of the entity. You may create empty collections if you wish, but creating an entity of a new type will automatically create a corresponding collection for you. For example, creating a new custom "item" entity, creates an "items" collection.
+
+__Note__: Although not shown in the API examples below, you need to provide a valid access token with each API call. See Authenticating users and application clients for details.
+
+### Creating a collection
+
+The following example shows how to create an empty collection. Alternatively, you can create a collection simply by creating a new entity with a 'type' property that corresponds to the collection you wish to create. For more on creating entities, see Creating Custom Data Entities
+
+### Request Syntax
+
+curl -X POST https://api.usergrid.com/<org>/<app>/<collection_name>
+
+Parameters
+
+Parameter	    Description
+---------       -----------
+org	            Organization UUID or organization name
+app	            Application UUID or application name
+collection name	Name of the collection to create. 
+
+If the provided value is not a plural word, API Services will pluralize it. For example, providing 'item' will create a collection named 'items' but providing 'items' will not create 'itemses'.
+
+### Example Request/Response
+
+Request:
+
+    curl -X POST "https://api.usergrid.com/your-org/your-app/item"
+
+Response:
+
+    {
+      "action" : "post",
+      "application" : "f34f4222-a166-11e2-a7f7-02e81adcf3d0",
+      "params" : { },
+      "path" : "/items",
+      "uri" : "http://api.usergrid.com/your-org/your-app/items",
+      "entities" : [ ],
+      "timestamp" : 1378857079220,
+      "duration" : 31,
+      "organization" : "your-org",
+      "applicationName" : "your-app"
+    }
+  
+## Retrieving Collections
+
+This article describes how to retrieve all of the entities in a collection.
+
+By default, the API Services BaaS API returns 10 entities per request. For collections with more than 10 entities, use the returned 'cursor' property to retrieve the next 10 entities in the result set. You may also use the LIMIT parameter in a query string to increase the number of results returned. For more information on using cursors, see Managing large sets of results.
+
+__Note__: Although not shown in the API examples below, you need to provide a valid access token with each API call. See Authenticating users and application clients for details.
+
+### Retrieving sets of entities from a collection
+
+### Request Syntax
+
+    curl -X GET https://api.usergrid.com/<org>/<app>/<collection>
+    
+Parameters
+
+Parameter	Description
+---------   -----------
+org	        Organization UUID or organization name
+app	        Application UUID or application name
+collection	Collection UUID or collection name
+
+### Example Request/Response
+
+Request:
+
+    curl -X GET "https://api.usergrid.com/your-org/your-app/items"
+
+Response:
+
+    {
+          "action" : "get",
+          "application" : "f34f4222-a166-11e2-a7f7-02e81adcf3d0",
+          "params" : { },
+          "path" : "/items",
+          "uri" : "http://api.usergrid.com/your-org/your-app/items",
+          "entities" : [ {
+                "uuid" : "5bb76bca-1657-11e3-903f-9ff6c621a7a4",
+                "type" : "item",
+                "name" : "milk",
+                "created" : 1378405020796,
+                "modified" : 1378405020796,
+                "metadata" : {
+                      "path" : "/items/5bb76bca-1657-11e3-903f-9ff6c621a7a4"
+                },
+                "name" : "milk",
+                "price" : "3.25"
+          }, {
+            "uuid" : "1a9356ba-1682-11e3-a72a-81581bbaf055",
+            "type" : "item",
+            "name" : "bread",
+            "created" : 1378423379867,
+            "modified" : 1378423379867,
+            "metadata" : {
+                  "path" : "/items/1a9356ba-1682-11e3-a72a-81581bbaf055"
+            },
+            "name" : "bread",
+            "price" : "2.50"
+          } ],
+          "timestamp" : 1378426821261,
+          "duration" : 35,
+          "organization" : "your-org",
+          "applicationName" : "your-app",
+          "count" : 2
+    }   
+    
+## Updating Collections
+
+This article describes how to perform batch updates on all entities in a collection. Batch updates require the use of a query string in the request, which can either specify all entities in the collection or a subset of entities for the update to be performed on. For more information on queries, see Querying your data.
+
+__Note__: Although not shown in the API examples below, you need to provide a valid access token with each API call. See Authenticating users and application clients for details.
+
+### Batch updating entities in a collection
+
+### Request Syntax
+
+    curl -X PUT https://api.usergrid.com/<org>/<app>/<collection>/?ql= -d {<property>}
+
+Note the empty query string (ql=) appended to the URL.
+
+Parameters
+
+Parameter	Description
+---------   -----------
+org	        Organization UUID or organization name
+app	        Application UUID or application name
+collection	Collection UUID or collection name property	
+
+An entity property to be updated, formatted as a key-value pair. For example:
+
+    {"property_1":"value_1", "property_2":"value_2",...}
+
+### Example Request/Response
+
+Request:
+
+    curl -X PUT https://api.usergrid.com/your-org/your-app/items/?ql= -d '{"availability":"in-stock"}'
+
+Note the empty ?ql= query string.
+
+Response:
+
+    {
+      "action" : "put",
+      "application" : "f34f4222-a166-11e2-a7f7-02e81adcf3d0",
+      "params" : {
+        "ql" : [ "" ]
+      },
+      "path" : "/items",
+      "uri" : "http://api.usergrid.com/your-org/your-app/items",
+      "entities" : [ {
+        "uuid" : "31847b9a-1a62-11e3-be04-8d05e96f700d",
+        "type" : "item",
+        "name" : "milk",
+        "price" : "3.25",
+        "availability" : "in-stock"
+        "created" : 1378849479113,
+        "modified" : 1378849567301,
+        "name" : "milk",
+      }, {
+        "uuid" : "3192ac6a-1a62-11e3-a24f-496ca1d42ce7",
+        "type" : "item",
+        "name" : "bread",
+        "price" : "4.00",
+        "availability" : "in-stock"
+        "created" : 1378849479206,
+        "modified" : 1378849567351,
+        "name" : "bread",
+      } ],
+      "timestamp" : 1378849567280,
+      "duration" : 207,
+      "organization" : "your-org",
+      "applicationName" : "your-app"
+    }
+   
+## Deleting Collections
+This article describes how to batch delete entities in a collection. Batch deletes require the use of a query string in the request, which specifies a subset of entities to be deleted. For more information on queries, see Querying your data.
+
+Currently, collections cannot be deleted; however, you can delete all of the entities from a collection.
+
+__Note__: Although not shown in the API examples below, you need to provide a valid access token with each API call. See Authenticating users and application clients for details.
+
+### Batch deleting entities in a collection
+
+### Request Syntax
+
+    curl -X DELETE https://api.usergrid.com/<org>/<app>/<collection>/?ql=<query>
+    
+Parameters
+
+Parameter	Description
+---------   -----------
+org	        Organization UUID or organization name
+app	        Application UUID or application name
+collection	Collection UUID or collection name
+query	    A query string that specifies the subset of entities to delete 
+
+(for more information on queries, see Querying your data)
+
+### Example Request/Response
+
+The following example will delete the first 5 entities in a collection.
+
+Request:
+
+    curl -X DELETE https://api.usergrid.com/your-org/your-app/items/?ql="limit=5"
+    
+Response:
+
+    {
+      "action" : "delete",
+      "application" : "f34f4222-a166-11e2-a7f7-02e81adcf3d0",
+      "params" : {
+        "ql" : [ "" ]
+      },
+      "path" : "/items",
+      "uri" : "http://api.usergrid.com/your-org/your-app/items",
+      "entities" : [ {
+        "uuid" : "53fe3700-0abe-11e3-b1f7-1bd100b8059e",
+        "type" : "item",
+        "name" : "milk",
+        "price" : "3.25",
+        "created" : 1377129832047,
+        "modified" : 1377129832047,
+        "metadata" : {
+          "path" : "/items/53fe3700-0abe-11e3-b1f7-1bd100b8059e"
+        },
+        "name" : "milk"
+      }, {
+        "uuid" : "5ae1fa7a-0abe-11e3-89ab-6be0003c809b",
+        "type" : "item",
+        "name" : "bread",
+        "price" : "4.00",
+        "created" : 1377129843607,
+        "modified" : 1377129843607,
+        "metadata" : {
+          "path" : "/items/5ae1fa7a-0abe-11e3-89ab-6be0003c809b"
+        },
+        "name" : "bread"
+      } ],
+      "timestamp" : 1378848117272,
+      "duration" : 12275,
+      "organization" : "your-org",
+      "applicationName" : "your-app"
+    }
+    
+    
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/data-storage/data-store-dbms.md
----------------------------------------------------------------------
diff --git a/docs/data-storage/data-store-dbms.md b/docs/data-storage/data-store-dbms.md
new file mode 100644
index 0000000..5911b04
--- /dev/null
+++ b/docs/data-storage/data-store-dbms.md
@@ -0,0 +1,109 @@
+# The Usergrid Data Store
+
+The API BaaS data store is backed by Cassandra, an open source distributed DBMS. Cassandra isn’t a relational database system (RDBMS), and is sometimes placed in the category of “NoSQL” or “schema-less” databases. 
+
+.. note:: Usergrid is not a relational database
+ 
+Optimizing for performance on a DBMS like Cassandra differs a bit from relational databases. For more information, see Optimizing access to your API BaaS data store.
+
+Cassandra is specifically designed to support applications that need flexibility and high scalability, particularly web and mobile applications. API BaaS client applications write and read data formatted as JavaScript Object Notation (JSON). (Apigee provides SDKs through which client apps can do much of this work in their native language. For more information, see API BaaS SDKs.)
+
+With Cassandra as the underlying DBMS, apps benefit from:
+
+Fast writes to the data store.
+* A distributed architecture that means no single point of failure.
+* Flexibility in data model design. You aren't constrained by a schema.
+* Linear scalability.
+
+If you have experience with relational databases and are unfamiliar with "NoSQL" databases, the following table might be a helpful start. It maps the high-level concepts of an RDBMS’s data model both to Cassandra’s and to the API BaaS, which is backed by Cassandra.
+
+.. raw:: html
+    <table class="usergrid-table">
+    <tr>
+        <td></td>
+        <td>RDBMS</td>
+        <td>Cassandra</td>
+        <td>Usergrid</td>
+    </tr>
+    <tr>
+        <td>Each tuple is modeled as</td>
+        <td>A row.</td>
+        <td>A row.</td>
+        <td>An entity. Written and retrieved as JSON, an entity contains values for all of its properties in the way a row has values for columns.</td>
+    </tr>
+    <tr>
+        <td>Each data attribute is modeled as</td>
+        <td>A column.</td>
+        <td>A column. Many thousands of columns are supported.</td>
+        <td>A entity property. An entity has a default set of properties, including the entity’s UUID. You can add many more to support your application.</td>
+    </tr>
+    <tr>
+        <td>Each group of attributes is modeled as</td>
+        <td>A table.</td>
+        <td>A column family. Unlike rows in tables, rows in a column family can have differing numbers of columns. Because you’re not using a schema to define the model, you can update the column list for a row at any time.</td>
+        <td>An entity collection. As with its underlying Cassandra column family, a collection can have entities with differing numbers of properties. In other words, just because one entity has an authorId property doesn’t mean that other entities in its collection need to.</td>
+    </tr>
+    </table>
+
+The following examples from a product database provide simple illustrations of these differences.
+
+An RDBMS table has a schema-defined set of columns per row.
+
+.. image:: rdbms.png
+
+A Cassandra column family includes rows that can have differing column sets.
+
+.. image:: cassandra.png
+   
+In the JSON from the API BaaS application, the products are represented as entities. Note that each entity in the entities array below has a slightly different set of properties, like the columns in a Cassandra column family.
+
+    { 
+        "action" : "get", 
+        "application" : "<app_uuid>", 
+        "params" : {}, 
+        "path" : "/products", 
+        "uri" : "https://api.usergrid.com/my_org/my_app/products", 
+        "entities" : [ { 
+            "uuid" : "<product_uuid>", 
+            "type" : "product", 
+            "created" : 1395410098517, 
+            "modified" : 1395410098517, 
+            "image" : "http://path.jpg", 
+            "metadata" : { 
+                "path" : "/products/<product_uuid>" 
+            }, 
+            "name" : "Bouncy Castle", 
+            "sku" : "35450349822" 
+        }, 
+        {
+            "uuid" : "<product_uuid>", 
+            "type" : "product", 
+            "created" : 1395409669686, 
+            "modified" : 1395409669686, 
+            "image" : "http://path.jpg", 
+            "metadata" : { 
+                "path" : "/products/<product_uuid>" 
+            }, 
+            "description" : "It makes coffee.", 
+            "name" : "Coffee Maker", 
+            "sku" : "60723023589" 
+        }, 
+        { 
+            "uuid" : "<product_uuid>", 
+            "type" : "product",
+            "created" : 1395407700578, 
+            "modified" : 1395407700578, 
+            "metadata" : { 
+                "path" : "/products/<product_uuid>" 
+            }, 
+            "name" : "Air Mattress", 
+            "sku" : "53045985365" 
+        }],
+        "timestamp" : 1396290037640, 
+        "duration" : 91, 
+        "organization" : "my_org", 
+        "applicationName" : "my_app", 
+        "count" : 3 
+    }
+    
+    
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/data-storage/entities.md
----------------------------------------------------------------------
diff --git a/docs/data-storage/entities.md b/docs/data-storage/entities.md
new file mode 100644
index 0000000..22d8f18
--- /dev/null
+++ b/docs/data-storage/entities.md
@@ -0,0 +1,515 @@
+# Entities
+
+## Creating Custom Data Entities
+This article describes how to create custom data entities and entity properties. Entity types correspond to the name of collection to which they are posted. For example, if you create a new custom "dog" entity, a "dogs" collection will be created if one did not already exist. If a "dogs" collection already exists, the new "dog" entity will be saved in it. All user-defined properties are indexed, and strings that contain multiple words are keyword-indexed.
+
+The methods cited in this article should be used to create custom data entities. If you are using one of the API Services BaaS SDKs, use one of the entity type-specific SDK methods to create default data entities.
+
+__Note__: Although not shown in the API examples below, you need to provide a valid access token with each API call. See Authenticating users and application clients for details.
+
+### Creating a custom entity
+When a new entity is created, API Services will automatically create a corresponding collection if one does not already exist. The collection will automatically be named with the plural form of the entity type. For example, creating a custom entity of type 'item' will automatically create a collection named 'items' in which all future 'item' entities will be saved.
+
+### Request Syntax
+
+    curl -X POST https://api.usergrid.com/<org>/<app>/<entity_type> -d 'json_object'
+
+Parameters
+
+Parameter	Description
+---------   -----------
+org	        Organization UUID or organization name
+app	        Application UUID or application name
+entity_type	Entity type to create. 
+json_object JSON representation of entity properties
+
+(For a full list of default properties, see Default Data Entity Types)
+
+Usergrid will create a corresponding collection if one does not already exist. To add an entity to an existing collections, use the pluralized collection name for entity_type.
+
+### Example Request/Response
+
+Request:
+
+    curl -X POST "https://api.usergrid.com/your-org/your-app/item" -d '{"name":"milk", "price":"3.25"}'
+    
+Response:
+
+    { 
+        "action" : "post", 
+        "application" : "4a1edb70-d7a8-11e2-9ce3-f315e5aa568a", 
+        "params" : { }, 
+        "path" : "/items", "uri" : "http://api.usergrid.com/my-org/my-app/items", 
+        "entities" : [ { 
+            "uuid" : "83e9b7ea-e8f5-11e2-84df-e94123890c7a", 
+            "type" : "item", 
+            "name" : "milk", 
+            "created" : 1373415195230, 
+            "modified" : 1373415195230, 
+            "metadata" : { 
+
+                "path" : "/items/83e9b7ea-e8f5-11e2-84df-e94123890c7a" 
+            }, 
+            "name" : "milk", 
+            "price" : "3.25"
+        } ], 
+        "timestamp" : 1373415195225, 
+        "duration" : 635, 
+        "organization" : "my-org", 
+        "applicationName" : "my-app" 
+    }
+    
+## Creating multiple custom entities
+
+### Request Syntax
+
+    curl -X POST https://api.usergrid.com/<org>/<app>/<entity_type>/ -d 'json_array'
+    
+Parameters
+
+Parameter	Description
+---------   -----------
+org	        Organization UUID or name
+app	        Application UUID or name
+entity_type	Custom entity type to create. 
+json_array  JSON array of entities to be created.
+
+Usergrid will create a corresponding collection if one does not already exist. To add an entity to an existing collections, use the collection name or collection UUID in place of the entity type.
+
+### Example Request/Response
+
+Request:
+
+    curl -X POST "https://api.usergrid.com/your-org/your-app/item" -d '[{"name":"milk", "price":"3.25"}, {"name":"bread", "price":"2.50"}]'
+    
+Response:
+
+    {
+        "action" : "post",
+        "application" : "f34f4222-a166-11e2-a7f7-02e9sjwsf3d0",
+        "params" : { },
+        "path" : "/items",
+        "uri" : "http://api.usergrid.com/your-org/your-app/items",
+        "entities" : [ {
+            "uuid" : "f3a8061a-ef0b-11e2-9e92-5f4a65c16193",
+            "type" : "item",
+            "name" : "milk",
+            "price" : "3.25",
+            "created" : 1374084538609,
+            "modified" : 1374084538609,
+            "metadata" : {
+                "path" : "/multis/f3a8061a-ef0b-11e2-9e92-5f4a65c16193"
+            },
+            "name" : "milk"
+        }, {
+            "uuid" : "f3be262a-ef0b-11e2-a51b-6715d5ef47a6",
+            "type" : "item",
+            "name" : "bread",
+            "price" : "2.50",
+            "created" : 1374084538754,
+            "modified" : 1374084538754,
+            "metadata" : {
+                "path" : "/items/f3be262a-ef0b-11e2-a51b-6715d5ef47a6"
+            },
+            "name" : "bread"
+        } ],
+        "timestamp" : 1374084538584,
+        "duration" : 388,
+        "organization" : "your-org",
+        "applicationName" : "your-app"
+    }
+
+### Creating an entity with sub-properties
+
+Any valid JSON object can be stored in an entity, regardless of the level of complexity, including sub-properties. For example, suppose you have an 'items' collection that contains an entity named 'milk'. You might store the different varieties of milk as sub-properties of a 'varieties' property:
+
+    {
+        "type" : "item"
+        "name" : "milk"
+        "varieties" : [ {
+            "name" : "1%",
+            "price" : "3.25",
+            "sku" : "0393847575533445"
+        }, {
+            "name" : "whole",
+            "price" : "3.85",
+            "sku" : "0393394956788445"
+        }, {
+            "name" : "skim",
+            "price" : "4.00",
+            "sku" : "0390299933488445"		
+        } ]
+    }		
+	
+### Updating sub-properties
+
+An array of sub-properties is treated as a single object. This means that sub-properties cannot be updated atomically. All sub-properties of a given property must be updated as a set.
+For more on updating an existing sub-property, see Updating Data Entities.
+
+Example Request/Response
+
+    Request:
+    //Note the use of square brackets for specifying multiple nested objects
+    curl -X POST "https://api.usergrid.com/your-org/your-app/items" -d '{"varieties":[{"name":"1%","price" : "3.25", "sku" : "0393847575533445"},{"name" : "whole", "price" : "3.85", "sku" : "0393394956788445"}, {"name" : "skim", "price" : "4.00", "sku" : "0390299933488445"}]}'
+    Response:
+    { 
+        "action" : "post", 
+        "application" : "f34f4222-a166-11e2-a7f7-02e81adcf3d0", 
+        "params" : { }, 
+        "path" : "/items", 
+        "uri" : "http://api.usergrid.com/your-org/your-app/items", 
+        "entities" : [ { 
+            "uuid" : "0d7cf92a-effb-11e2-917d-c5e707256e71", 
+            "type" : "item", 
+            "name" : "milk", 
+            "created" : 1374187231666, 
+            "modified" : 1374187231666, 
+            "metadata" : { 
+                "path" : "/items/0d7cf92a-effb-11e2-917d-c5e707256e71" 
+            }, 
+            "name" : "milk", 
+            "varieties" : [ { 
+                "name" : "1%", 
+                "price" : "3.25", 
+                "SKU" : "0393847575533445" 
+            }, { 
+                "name" : "whole", 
+                "price" : "3.85", 
+                "SKU" : "0393394956788445" 
+            }, { 
+                "name" : "skim", 
+                "price" : "4.00", 
+                "SKU" : "0390299933488445" 
+            } ] 
+        } ], 
+        "timestamp" : 1374187450826, 
+        "duration" : 50, 
+        "organization" : "your-org", 
+        "applicationName" : "your-app" 
+    }
+
+.. -----------------------------------------------------------------------------
+
+## Retrieving Data Entities
+This article describes how to retrieve entities from your account.
+
+__Note__: Although not shown in the API examples below, you need to provide a valid access token with each API call. See Authenticating users and application clients for details.
+
+With the exception of the user entity, all data entities can be retrieved by using their UUID or a 'name' property. The user entity can be retrieved by UUID or the 'username' property. The value for the 'name' or 'username' property must be unique.
+
+### Retrieving an entity
+
+### Request Syntax
+
+    curl -X GET https://api.usergrid.com/<org>/<app>/<collection>/<entity>
+
+Parameters
+
+Parameter	Description
+---------   -----------
+org	        Organization UUID or organization name
+app	        Application UUID or application name
+collection	Collection UUID or collection name
+entity	    Entity UUID or entity name
+
+### Example Request/Response
+
+Request:
+
+Retrieve by UUID:
+
+    curl -X GET "https://api.usergrid.com/your-org/your-app/items/da4a50dc-38dc-11e2-b2e4-02e81adcf3d0"
+    
+Retrieve by 'name' property:
+
+    curl -X GET "https://api.usergrid.com/your-org/your-app/items/milk"
+    
+Response:
+
+    {
+        "action" : "get",
+        "application" : "f34f4222-a166-11e2-a7f7-02e81adcf3d0",
+        "params" : { },
+        "path" : "/items",
+        "uri" : "http://api.usergrid.com/amuramoto/sandbox/items",
+        "entities" : [ {
+            "uuid" : "5bb76bca-1657-11e3-903f-9ff6c621a7a4",
+            "type" : "item",
+            "name" : "milk",
+            "created" : 1378405020796,
+            "modified" : 1378405020796,
+            "metadata" : {
+                  "path" : "/items/5bb76bca-1657-11e3-903f-9ff6c621a7a4"
+            },
+            "name" : "milk",
+            "price" : "3.25"
+        } ],
+        "timestamp" : 1378405025763,
+        "duration" : 31,
+        "organization" : "amuramoto",
+        "applicationName" : "sandbox"
+    }
+
+
+### Retrieving multiple entities
+
+This example describes how to retrieve multiple entities by UUID. You can also retrieve a set of entities by using a query string. For more information on querying your data, see Querying your data.
+
+### Request Syntax
+
+    curl -X GET https://api.usergrid.com/<org_id>/<app_id>/<collection>?ql= uuid = <entity_uuid> OR uuid = <entity_uuid>; ...
+    
+Parameters
+
+Parameter	Description
+---------   -----------
+org_id	    Organization UUID or organization name
+app_id	    Application UUID or application name
+collection	Collection UUID or collection name
+query	    A url-encoded query string of entity properties to be matched.
+ 
+The query must be in Usergrid Query Language, for example:
+
+    ?ql=uuid="<entity_uuid>"" OR name="<entity_name>" OR...
+    
+You may also specify the following for certain entity types:
+
+User entities: username = <entity_username>
+
+All other entities except groups: name = <entity_name>
+
+### Example Request/Response
+
+Request:
+
+    //note the url-encoded query string
+    curl -X GET "https://api.usergrid.com/your-org/your-app/items?ql=name%3D'milk'%20OR%20UUID%3D1a9356ba-1682-11e3-a72a-81581bbaf055&limit="				
+
+Note: The query parameter of the request must be url encoded for curl requests
+
+Response:
+
+    {
+          "action" : "get",
+          "application" : "f34f4222-a166-11e2-a7f7-02e81adcf3d0",
+          "params" : {
+                "ql" : [ "name='milk' OR UUID=1a9356ba-1682-11e3-a72a-81581bbaf055" ]
+          },
+          "path" : "/items",
+          "uri" : "http://api.usergrid.com/your-org/your-app/items",
+          "entities" : [ {
+                "uuid" : "5bb76bca-1657-11e3-903f-9ff6c621a7a4",
+                "type" : "item",
+                "name" : "milk",
+                "created" : 1378405020796,
+                "modified" : 1378405020796,
+                "metadata" : {
+                      "path" : "/items/5bb76bca-1657-11e3-903f-9ff6c621a7a4"
+            },
+                "name" : "milk",
+                "price" : "3.25"
+          }, {
+            "uuid" : "1a9356ba-1682-11e3-a72a-81581bbaf055",
+            "type" : "item",
+            "name" : "bread",
+            "created" : 1378423379867,
+            "modified" : 1378423379867,
+            "metadata" : {
+                  "path" : "/items/1a9356ba-1682-11e3-a72a-81581bbaf055"
+            },
+                "name" : "bread",
+                "price" : "2.50"
+          } ],
+          "timestamp" : 1378423793729,
+          "duration" : 63,
+          "organization" : "your-org",
+          "applicationName" : "your-app",
+          "count" : 2
+    }
+ 
+ 
+.. --------------------------------------------------------------------------------
+
+## Updating Data Entities
+
+This article describes how to update entities in your account.
+
+__Note__: Although not shown in the API examples below, you need to provide a valid access token with each API call. See Authenticating users and application clients for details.
+
+### Updating an entity
+One or more properties can be updated with a single PUT request. For information on updating sub-properties, see Updating sub-properties below.
+
+### Request Syntax
+
+    curl -X PUT https://api.usergrid.com/<org>/<app>/<collection>/<entity> -d {<property>}
+    
+Parameters
+
+Parameter	Description
+---------   -----------
+org_id	    Organization UUID or organization name
+app_id	    Application UUID or application name
+collection	Name of the collection containing the entity to be updated
+uuid|name	UUID or name of the data entity to be updated
+json_object JSON object with a field for each property to be updated
+
+An entity property to be updated, formatted as a key-value pair. For example:
+
+    {"property_1":"value_1", "property_2":"value_2",...}
+
+### Example Request/Response
+
+Request:
+
+    curl -X PUT https://api.usergrid.com/your-org/your-app/items/milk -d '{"price":"4.00", "availability":"in-stock"}'
+
+Response:
+
+    {
+      "action" : "put",
+      "application" : "f34f4222-a166-11e2-a7f7-02e81adcf3d0",
+      "params" : { },
+      "path" : "/items",
+      "uri" : "http://api.usergrid.com/your-org/your-app/items",
+      "entities" : [ {
+        "uuid" : "5bb76bca-1657-11e3-903f-9ff6c621a7a4",
+        "type" : "item",
+        "name" : "milk",
+        "created" : 1378405020796,
+        "modified" : 1378505705077,
+        "availability" : "in-stock",
+        "metadata" : {
+          "path" : "/items/5bb76bca-1657-11e3-903f-9ff6c621a7a4"
+        },
+        "name" : "milk",
+        "price" : "4.00"
+      } ],
+      "timestamp" : 1378505705050,
+      "duration" : 87,
+      "organization" : "your-org",
+      "applicationName" : "your-app"
+    }
+
+
+### Updating a sub-property
+
+Data entities may contain sets of sub-properties as nested JSON objects. Unlike normal entity properties, however, sub-properties cannot be updated individually. Updating a nested object will cause all sub-properties within it to be overwritten.
+
+For example, if you have a data entity with the following nested object:
+
+### Request Syntax
+
+    curl -X PUT https://api.usergrid.com/<org_id>/<app_id>/<collection>/<uuid|name> -d '{<property> : [{<sub_property>}, {<sub_property>}...]}'
+
+Parameters
+
+Parameter	Description
+---------   -----------
+org_id	    Organization UUID or organization name
+app_id	    Application UUID or application name
+collection	Name of the collection containing the entity to be updated
+uuid|name	UUID or name of the data entity to be updated
+json_object JSON object with a field for each property to be updated
+
+### Example Request/Response
+
+Request:
+
+    curl -X PUT https://api.usergrid.com/your-org/your-app/items/milk -d '{"varieties":[{"name":"1%","price":"3.25"},{"name":"whole","price":"4.00"}]}'
+
+Response:
+
+    {
+      "action" : "put",
+      "application" : "f34f4222-a166-11e2-a7f7-02e81adcf3d0",
+      "params" : { },
+      "path" : "/items",
+      "uri" : "http://api.usergrid.com/your-org/your-app/items",
+      "entities" : [ {
+        "uuid" : "5bb76bca-1657-11e3-903f-9ff6c621a7a4",
+        "type" : "item",
+        "name" : "milk",
+        "created" : 1378405020796,
+        "modified" : 1378761459069,
+        "availability" : "in-stock",
+        "metadata" : {
+          "path" : "/items/5bb76bca-1657-11e3-903f-9ff6c621a7a4"
+        },
+        "name" : "milk",
+        "uri" : "http://api.usergrid.com/your-org/your-app/items/5bb76bca-1657-11e3-903f-9ff6c621a7a4",
+        "varieties" : [ {
+          "name" : "1%",
+          "price" : "3.25"
+        }, {
+          "name" : "whole",
+          "price" : "4.00"
+        } ]
+      } ],
+      "timestamp" : 1378761459047,
+      "duration" : 62,
+      "organization" : "your-org",
+      "applicationName" : "your-app"
+    }
+ 
+.. --------------------------------------------------------------------------------
+
+## Deleting Data Entities
+
+This article describes how to delete data entities.
+
+__Note__:Although not shown in the API examples below, you need to provide a valid access token with each API call. See Authenticating users and application clients for details.
+
+### Deleting an entity
+
+### Request Syntax
+
+    curl -X DELETE https://api.usergrid.com/<org>/<app>/<collection>/<entity>
+    
+Parameters
+
+Parameter	Description
+---------   -----------
+org	        Organization UUID or organization name
+app	        Application UUID or application name
+collection	Collection UUID or collection name
+entity	    Entity UUID or entity name
+
+### Example Request/Response
+ 
+Request:
+ 
+Delete by UUID:
+ 
+    curl -X DELETE "https://api.usergrid.com/your-org/your-app/items/da4a50dc-38dc-11e2-b2e4-02e81adcf3d0" 
+    
+Delete by 'name' property:
+ 
+     curl -X DELETE "https://api.usergrid.com/your-org/your-app/items/milk"
+ 
+Response:
+ 
+     {
+       "action" : "delete",
+       "application" : "f34f4222-a166-11e2-a7f7-02e81adcf3d0",
+       "params" : { },
+       "path" : "/items",
+       "uri" : "http://api.usergrid.com/your-org/your-app/items",
+       "entities" : [ {
+         "uuid" : "328fe64a-19a0-11e3-8a2a-ebc6f49d1fc4",
+         "type" : "item",
+         "name" : "milk",
+         "created" : 1378766158500,
+         "modified" : 1378766158500,
+         "metadata" : {
+           "path" : "/items/328fe64a-19a0-11e3-8a2a-ebc6f49d1fc4"
+         },
+         "name" : "milk",
+         "price" : "3.25"
+       } ],
+       "timestamp" : 1378766172016,
+       "duration" : 324,
+       "organization" : "your-org",
+       "applicationName" : "your-app"
+     }
+  
+ 
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/data-storage/optimizing-access.md
----------------------------------------------------------------------
diff --git a/docs/data-storage/optimizing-access.md b/docs/data-storage/optimizing-access.md
new file mode 100644
index 0000000..2e5c0b6
--- /dev/null
+++ b/docs/data-storage/optimizing-access.md
@@ -0,0 +1,185 @@
+# Data Store Best Practices
+The Usergrid data store is backed by Cassandra, an open source distributed DBMS. Cassandra is specifically designed to support applications that need flexibility and high scalability, particularly web and mobile applications. To get the most out of your Usergrid application, you should optimize your data access with this kind of database in mind.
+
+## Put your data in as you'll want to get it out
+The best practices described here are all related to the theme of putting your data in the way you’ll want to get it out. You’ll model your data with your likely read requests in mind rather than by modeling around the structure of the data itself (as you might with a relational database). In many cases, you can avoid using queries that are inefficient for this kind of database.
+
+You can use the following techniques to optimize data store access:
+
+* __Denormalize and duplicate__. By creating a data model that strategically denormalizes and duplicates data, you can avoid costly queries. In other words, you model the data so that all of the data for a given request is all in one place rather than scattered in a way that a query must account for.
+
+* __Create direct paths to the data you’ll want__. You can optimize your app’s performance by connecting entities your code retrieves most often. With connections, you can avoid some queries that might add complexity and reduce performance.
+
+## Best practice: Denormalize for pre-computed query results
+If you’re familiar with designing relational databases, you’re probably used to normalizing the structure of your data as much as possible. When normalizing an RDBMS data model, you minimize redundancy by ensuring that a column from one table is duplicated only once in any other table, and only when necessary to create primary/secondary key relationships. You then retrieve data that spans tables by joining them with an SQL query.
+
+In contrast, with the Usergrid data store you’ll get better performance by strategically denormalizing and duplicating data. When you denormalize, you combine data from what might (in a relational model) have been separate tables. When duplicating, you intentionally maintain copies of certain entity properties across multiple entities. By denormalizing and duplicating, you can collect the results of requests into a single entity rather than relying on a query.
+
+Part of designing your data model should include identifying the queries your client will make. Then in your data model design, you capture the results of those queries in advance by writing that data into entities of one collection you can read from later.
+
+### Getting review data the relational way
+For example, take a closer look at the relational case through a product database. Imagine you want to present a list of all reviews for a product. When a user chooses a review from the list, you’ll show them a view that includes the review’s title, body, and rating; the product it describes; and who wrote the review. That way, your user will be able to click through to more information about the product or reviewing user.
+
+In a relational database, you’d likely have separate tables for the review-specific information and a rating; for the product; and for the user. Your reviews table would include secondary keys with which to join reviews to the users and products tables. Maybe something like this:
+
+.. image:: reviews.png
+
+To get the data you need, your query might look like the SQL query below. By getting UUIDs for the user and product into your client code, you’re able to give the user a way to get user and product information from the review.
+
+    SELECT review.title, review.body, review.rating, review.uuid, 
+        user.name, user.uuid, product.name, product.uuid 
+        FROM reviews 
+        INNER JOIN users 
+        ON users.uuid = reviews.authorId 
+        INNER JOIN products 
+        ON products.uuid = reviews.productId 
+        WHERE reviews.uuid = <uuid_for_selected_review> 
+        
+But due to Cassandra’s distributed, high-scale design, a join such as this wouldn’t work. So in the Usergrid, you’d get the data by first storing it all in one place.
+
+### Using a denormalized model to store (then retrieve) data
+In the Usergrid, a more efficient way to get the same result would start by including related user and product data with the review data. This would give you a single place to get all the data you'll show.
+
+The following shows how that model might look as entities in the Usergrid. (The users and products entities are included here to remind you that they exist, but they aren’t actually used in this denormalization example.)
+
+.. image:: reviews2.png
+
+This use case assumes that your user and product data are already in the data store. In the following API request code, you’re just adding a new review written by a user about a particular product. The JSON body is your new review entity (the JSON here is non-entitized to make it readable).
+
+    POST https://api.usergrid.com/my_org/my_app/reviews -d { 
+        "title" : "Tempted to climb in myself.", 
+        "body" : "I mean, who doesn't love a bouncy castle? The kids love it!",
+        "rating" : 3, 
+        "authorName" : "Jennie", 
+        "authorUUID" : <author_uuid>, 
+        "authorImage" : "http://<path_to_image>.png", 
+        "productUUID" : <product_uuid>,
+        "productImage" : "http://<path_to_image>.jpg", 
+        "productName" : "Magic Castle Bounce House Inflatable Bouncer" 
+    }
+    
+Notice that you’re adding user and product data (which your client code would have at hand when the user posts the review) when you’re adding the review-specific data.
+
+Retrieving all the data from one place
+You’d get the review, including the subset of product and user data you need right away, by making one API call such as the following (note there’s no SQL-like query string needed):
+
+    GET http://api.usergrid.com/my_org/my_app/reviews/<review_uuid> 
+
+Your result might look like this. The highlighted lines show data you'd present to the user.
+
+    { 
+        "action" : "get", 
+        "application" : "<app_uuid>", 
+        "params" : { }, 
+        "path" : "/reviews", 
+        "uri" : "https://api.usergrid.com/my_org/my_app/reviews", 
+        "entities" : [ {
+            "uuid" : "<review_uuid>", 
+            "type" : "review", 
+            "created" : 1395410364673, 
+            "modified" : 1395410364673, 
+            "authorName" : "Jennie", 
+            "authorImage" : "<path_to_image>.png", 
+            "authorUUID" : "<author_uuid>", 
+            "body" : "I mean, who doesn't love a bouncy castle? The kids love it!", 
+            "metadata" : { 
+                "path" : "/reviews/<review_uuid>" 
+            },
+            "productImage" : "http://<path_to_image>.jpg", 
+            "productName" : "Magic Castle Bounce House Inflatable Bouncer", 
+            "productUUID" : "<product_uuid>", 
+            "rating" : 3, 
+            "title" : "Tempted to climb in myself." 
+        } ], 
+        "timestamp" : 1395764951934, 
+        "duration" : 16, 
+        "organization" : "my_org", 
+        "applicationName" : "my_app" 
+    }
+
+This gives you, in one request, all the review information you’d planned on presenting to your app’s users for a single view. Your client code could retrieve the review entity in the result, along with the product and user data, then present it all as a review.
+
+Best practice: Connect entities to simplify scoped requests
+Another way to streamline your requests is to connect entities by using the built-in connections feature. In a sense, a connection can replace the WHERE clause of a query you might have written.
+
+Getting back to the review example, imagine you want to retrieve all of the reviews written by a particular user. In the relational example, you might have an SQL query such as this:
+
+    SELECT * FROM reviews WHERE authorId = <user_uuid>; 
+
+Even in the Usergrid, you could use a similar syntax in a query string appended to an API path. Working from the review entity model in the preceding example, that might look like this (though yours would likely entitize the spaces):
+
+    GET http://api.usergrid.com/my_org/my_app/reviews?ql=select * where
+            authorUUID=<user_uuid> 
+            
+But if this is an API call you’re going to be making often, there’s a better way. Instead, create a connection between the review and the user when your code creates the review. You can connect entities with a verb that describes their relationship to one another.
+
+The following creates Jennie’s review and at the same time connects her as the person who “wrote” it. (For easier reading, this example contains spaces you wouldn’t be able to include.)
+
+    POST http://api.usergrid.com/my_org/my_app/users/jennie/wrote/reviews { 
+        "title" : "Tempted to climb in myself.", 
+        "body" : "I mean, who doesn't love a bouncy castle? The kids love it!", 
+        "rating" : 3, 
+        "authorName" : "Jennie", 
+        "authorImage" : "http://<path_to_image>.png", 
+        "productName" : "Magic Castle Bounce House Inflatable Bouncer", 
+        "productImage" : "http://<path_to_image>.jpg" 
+    }
+
+When reading the data, you’d retrieve all of the reviews Jennie has written with a URL that’s nearly identical, minus the JSON:
+
+    GET http://api.usergrid.com/my_org/my_app/users/jennie/wrote/reviews 
+
+Your request result would look something like the following. Here, the entities array returned contains the reviews you connected with Jennie (though there’s only one in this example). The connection-specific metadata is highlighted.
+
+    {
+        "action" : "get", 
+        "application" : "<app_uuid>", 
+        "params" : { }, 
+        "path" : "/users/<user_uuid>/wrote", 
+        "uri" : "https://api.usergrid.com/my_org/my_app/users/<user_uuid>/wrote", 
+        "entities" : [ {
+            "uuid" : "<review_uuid>", 
+            "type" : "review", 
+            "created" : 1395410364673, 
+            "modified" : 1395410364673, 
+            "authorName" : "Jennie", 
+            "authorImage" : "http://<path_to_image>.png", 
+            "authorUUID" : "<user_uuid>", 
+            "body" : "I mean, who doesn't love a bouncy castle? Kids love it!", 
+            "metadata" : { 
+                "connecting" : {
+                    "wrote" : "/users/<user_uuid>/wrote/<review_uuid>/connecting/wrote" 
+                },
+                "path" : "/users/<user_uuid>/wrote/<review_uuid>", 
+            }, 
+            "productImage" : "http://<path_to_image>.jpg", 
+            "productName" : "Magic Castle Bounce House Inflatable Bouncer", 
+            "productUUID" : "<product_uuid>", 
+            "rating" : 3, 
+            "title" : "Tempted to climb in myself." 
+        } ], 
+        "timestamp" : 1395777037697, 
+        "duration" : 19, 
+        "organization" : "my_org", 
+        "applicationName" : "my_app" 
+    } 
+
+To retrieve a particular review written by Jennie, you could use something like the following:
+
+    GET http://api.usergrid.com/my_org/my_app/users/jennie/wrote/reviews/<review_uuid> 
+
+You can create connections to set up relationships you can use to later retrieve data quickly and with a simple syntax.
+
+For example, when creating a connected entity (such as the review entity here), you can at the same time create other connections to connect the product to the new review, then connect the product to its reviewer (paths are abbreviated in these examples):
+
+    POST /users/jennie/wrote/reviews {<review_entity_json>} 
+    POST /products/<reviewed_product_uuid>/reviewedIn/reviews/<new_review_uuid> 
+    POST /products/<reviewed_product_uuid>/reviewedBy/users/jennie 
+
+Having created these connections for each review you post, in addition to getting the review the user wrote, you could later also:
+
+Get the reviews for a product:
+
+    GET /products/<reviewed_product_uuid>/reviewedIn/reviews 
+    Get the users who reviewed the product:
+    GET /products/<reviewed_product_uuid>/reviewedBy/users 

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/data-storage/rdbms.png
----------------------------------------------------------------------
diff --git a/docs/data-storage/rdbms.png b/docs/data-storage/rdbms.png
new file mode 100644
index 0000000..ce9f2a7
Binary files /dev/null and b/docs/data-storage/rdbms.png differ

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/data-storage/reviews.png
----------------------------------------------------------------------
diff --git a/docs/data-storage/reviews.png b/docs/data-storage/reviews.png
new file mode 100644
index 0000000..3acb39d
Binary files /dev/null and b/docs/data-storage/reviews.png differ

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/data-storage/reviews2.png
----------------------------------------------------------------------
diff --git a/docs/data-storage/reviews2.png b/docs/data-storage/reviews2.png
new file mode 100644
index 0000000..85872f2
Binary files /dev/null and b/docs/data-storage/reviews2.png differ

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/deploy-local.md
----------------------------------------------------------------------
diff --git a/docs/deploy-local.md b/docs/deploy-local.md
deleted file mode 100644
index 0b417da..0000000
--- a/docs/deploy-local.md
+++ /dev/null
@@ -1,179 +0,0 @@
-# Deploying to local Tomcat & Cassandra
-
-This is a guide that explains how to install and run Usergrid using stock Tomcat and Cassandra on a single computer.
-
-NOTE: running Cassandra on a single computer is something you should do ONLY for testing purposes. You don't want to run one node in production even just to start out. To get the benefit of Cassandra's architecture, which is designed to support linear scalability. You should be running a Cassandra cluster with at least three nodes. 
-
-For more information:
-
-* [Cassandra FAQ: Can I Start With a Single Node?](http://planetcassandra.org/blog/post/cassandra-faq-can-i-start-with-a-single-node/)
-* [Why don't you start off with a “single & small” Cassandra server](http://stackoverflow.com/questions/18462530/why-dont-you-start-off-with-a-single-small-cassandra-server-as-you-usually)
-
-## Requirements
-
-* [JDK 1.7](http://www.oracle.com/technetwork/java/javase/downloads/index.html)
-* [Maven](http://maven.apache.org/)
-
-## Download
-
-Use GitHub to clone the [apache/incubator-usergrid](https://github.com/apache/incubator-usergrid) repo.
-
-Or you can start by [downloading our latest code](https://github.com/apache/incubator-usergrid/archive/master.zip) and extract it.
-
-## Building
-
-From the command line, navigate to `stack` directory and type the following:
-
-    mvn clean package -DskipTests=true
-
-Once you are done the Usergrid application will be package as a Java EE WAR file at the location __stack/rest/target/ROOT.war__.
-
-Install and configure Cassandra
----
-
-Install Cassandra, don't edit configuration files as we just want default values for this simple setup. Here are the [instructions for installing Cassandra](http://wiki.apache.org/cassandra/GettingStarted)
-
-Install and configure Tomcat
----
-
-Follow instructions, don't edit configuration files as we just want default values for this simple setup. Here are the [instructions for installing Tomcat 7](http://tomcat.apache.org/tomcat-7.0-doc/setup.html)
-
-Add Usergrid WAR to Tomcat
----
-
-Remove the existing `tomcat/webapps/ROOT` directory. 
-
-Place the Usergrid `ROOT.war` file into the `tomcat/webapps` directory
-
-Add Usergrid configuration file to Tomcat
----
-
-Create a ____usergrid-custom.properties____ file and place it in Tomcat's __lib__ directory. You can find an example properties file below  that should work well for a local Tomcat & Cassandra setup. You will probably only need to change the properties below to use your email address and preferred password for the install.
-
-
-    usergrid.sysadmin.login.allowed=true
-    usergrid.sysadmin.login.name=superuser
-    usergrid.sysadmin.login.password=pw123
-    usergrid.sysadmin.email=me@example.com
-    usergrid.sysadmin.login.email=myself@example.com
-    usergrid.management.mailer=Myself<myself@example.com>
-    usergrid.test-account.admin-user.email=myself@example.com
-    usergrid.test-account.admin-user.password=test
-
-Run Usergrid Database & Super User Setup
----
-
-Start Tomcat and use your web browser to visit the URLs below. While you do this you might want to watch the logs under tomcat/logs for clues, just in case anything goes wrong. 
-
-Database setup URL - [http://localhost:8080/system/database/setup](http://localhost:8080/system/database/setup)
-
-When prompted to login use the sysadmin credentials that you specified in your __usergrid-custom.properties__ file. Based on the example above that would be superuser and pw123. If the operation is successful you should a message like the one below in your browser. If not, check your logs for clues about what went wrong.
-
-    {
-      "action" : "cassandra setup",
-      "status" : "ok",
-      "timestamp" : 1379424622947,
-      "duration" : 76
-    }
-
-Superuser setup URL - [http://localhost:8080/system/superuser/setup](http://localhost:8080/system/superuser/setup)
-
-You should not be prompted for login because you already logged into for the Database Setup. If setup works, you should see a message like this:
-
-    {
-      "action" : "superuser setup",
-      "status" : "ok",
-      "timestamp" : 1379424667936,
-      "duration" : 2
-    }
-
-Build the Usergrid Console
----
-The Usergrid Console is an admin interface written in JavaScript that connects to your running Usergrid instance. For evaluation purposes, you can run it within Tomcat. Build it by following the steps [here](https://github.com/apache/incubator-usergrid/blob/master/portal/README.md). Once built, copy the directory _portal/build/usergrid-portal_ to _tomcat/webapps_.
-
-
-Login to the Usergrid Console & get started
----
-You should now be able to login to the Usergrid console and start configuring applications, users and more. 
-
-You can use an static version of the portal to get started:
-
-http://localhost:8080/usergrid-portal/(http://localhost:8080/usergrid-portal)
-
-
-Example __usergrid-custom.properties__ file
----
-Here's a complete example properties file to get you started.
-
-    # Minimal Usergrid configuration properties for local Tomcat and Cassandra 
-    #
-    # The cassandra configuration options. 
-
-    # The cassandra host to use
-    cassandra.url=localhost:9160
-
-    # if your cassandra instance requires username/password
-    cassandra.username=someuser
-    cassandra.password=somepassword
-    
-    # The strategy to use when creating the keyspace. This is the default. 
-    # We recommend creating the keyspace with this default, then editing it 
-    # via the cassandra CLI to meet the client's needs.
-    cassandra.keyspace.strategy=org.apache.cassandra.locator.SimpleStrategy
-     
-    # The default replication factor for the simple strategy. Again, leave the 
-    # default, create the app, then use the cassandra cli to set the replication 
-    # factor options. This can become complicated with different topologies and 
-    # is more a Cassandra administration issue than a UG issue.
-    cassandra.keyspace.strategy.options.replication_factor=1
-     
-    ######################################################
-    # Custom mail transport. Not usually used for local testing
-
-    #mail.transport.protocol=smtps
-    #mail.smtps.host=email-smtp.us-east-1.amazonaws.com
-    #mail.smtps.port=465
-    #mail.smtps.auth=true
-    #mail.smtps.quitwait=false
-    #mail.smtps.username=
-    #mail.smtps.password=
-
-    ######################################################
-    # Admin and test user setup (change these to be their super user
-
-    usergrid.sysadmin.login.name=superuser
-    usergrid.sysadmin.login.email=myself@example.com     <--- Change this
-    usergrid.sysadmin.login.password=pw123               <--- Change this
-    usergrid.sysadmin.login.allowed=true
-    usergrid.sysadmin.email=myself@example.com           <--- Change this
-    
-    # Enable or disable this to require superadmin approval of users
-    usergrid.sysadmin.approve.users=false
-
-    ######################################################
-    # Auto-confirm and sign-up notifications settings
-
-    usergrid.management.admin_users_require_confirmation=false
-    usergrid.management.admin_users_require_activation=false
-    usergrid.management.organizations_require_activation=false
-    usergrid.management.notify_sysadmin_of_new_organizations=false
-    usergrid.management.notify_sysadmin_of_new_admin_users=false
-
-    ######################################################
-    # URLs
-    # Redirect path when request come in for TLD
-
-    usergrid.redirect_root=https://localhost:8080/status
-    usergrid.view.management.organizations.organization.activate=https://localhost:8080/accounts/welcome
-    usergrid.view.management.organizations.organization.confirm=https://localhost:8080/accounts/welcome
-    usergrid.view.management.users.user.activate=https://localhost:8080/accounts/welcome
-    usergrid.view.management.users.user.confirm=https://localhost:8080/accounts/welcome
-    usergrid.organization.activation.url=https://localhost:8080/management/organizations/%s/activate
-    usergrid.admin.activation.url=https://localhost:8080/management/users/%s/activate
-    usergrid.admin.resetpw.url=https://localhost:8080/management/users/%s/resetpw
-    usergrid.admin.confirmation.url=https://localhost:8080/management/users/%s/confirm
-    usergrid.user.activation.url=https://localhost:8080%s/%s/users/%s/activate
-    usergrid.user.confirmation.url=https://localhost:8080/%s/%s/users/%s/confirm
-    usergrid.user.resetpw.url=https://localhost:8080/%s/%s/users/%s/resetpw
- 
- 
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/entity-connections/relationships.md
----------------------------------------------------------------------
diff --git a/docs/entity-connections/relationships.md b/docs/entity-connections/relationships.md
new file mode 100644
index 0000000..e039e09
--- /dev/null
+++ b/docs/entity-connections/relationships.md
@@ -0,0 +1,100 @@
+# Relationships
+
+Creating connections between entities
+-------------------------------------
+
+One of the most useful features of App services is the ability to create
+connections between entities. A simple example of this is the
+Twitter-like use of *following*, where one user forms a connection with
+another by subscribing to any tweets they post. [Messagee
+Example](/messagee-example) walks you through an example of following
+other users in our sample app, *Messagee*. Here is the basic format:
+
+    POST https://api.usergrid.com/my-org/my-app/users/fred/following/users/barney
+
+This API call results in two users, Fred and Barney, linked with a
+connection where Fred is following Barney.
+
+If you create a *following* connection between two users, Apache Usergrid
+automatically creates a virtual connection called *followers* that
+mirrors the *following* connection. In other words, if you create a
+connection where Fred is following Barney, Apache Usergrid automatically
+creates a virtual connection where Fred is a follower of Barney.
+
+Note that there is no mirror connection established. Apache Usergrid only
+creates a mirror connection when you create a *following* connection. It
+does not create a mirror connection for other verbs such as likes.
+
+You can see all the users that Fred is following, in this case only
+Barney, by making the following API call:
+
+    GET https://api.usergrid.com/my-org/my-app/users/fred/following
+
+You can see all of barney’s followers, in this case only Fred, by making
+the following API call:
+
+    GET https://api.usergrid.com/my-org/my-app/users/barney/followers
+
+The *followers* connection is a virtual connection because you can’t use
+it to link two entities. In other words, you can’t make fred a follower
+of barney by using a *followers* connection.  **This is wrong:**
+
+    POST https://api.usergrid.com/my-org/my-app/users/barney/followers/users/fred
+
+To create a *following* connection with the users switched, so that
+Barney is following Fred, do this:
+
+    POST https://api.usergrid.com/my-org/my-app/users/barney/following/users/fred
+
+You can now see Fred’s followers (only Barney) by making the following
+call:
+
+    GET https://api.usergrid.com/my-org/my-app/users/fred/followers
+
+Creating other connections
+--------------------------
+
+You can extend this connection structure to create connections using any
+"verb" that can link two entities. For example, you could use likes to
+denote a connection between a user and his dog. First, create a dogs
+collection:
+
+    POST https://api.usergrid.com/my-org/my-app/dogs
+
+Then populate this collection with a new dog named Dino:
+
+    POST https://api.usergrid.com/my-org/my-app/dogs {"name" : "dino"}
+
+Then create a likes connection between Fred and his dog Dino:
+
+    POST https://api.usergrid.com/my-org/my-app/users/fred/likes/dogs/dino
+
+Getting connections
+-------------------
+
+### Get all connections for an entity
+
+To get a list that only contains the connections, do a GET on the
+connections sub-property of the entity:
+
+    GET https://api.usergrid.com/my-org/my-app/users/fred/connections
+
+### Get information on a specific connection type
+
+To get a list of users who like Fred:
+
+    GET https://api.usergrid.com/my-org/my-app/users/fred/connecting/likes
+
+To get a list of all dogs that Fred likes:
+
+    GET https://api.usergrid.com/my-org/my-app/users/fred/likes/dog
+
+Deleting a connection
+---------------------
+
+You can delete a connection in a way similar to creating one. Just
+replace the POST method with the DELETE method. For example, you can
+delete the connection between fred and barney with the following API
+call:
+
+    DELETE https://api.usergrid.com/my-org/my-app/users/fred/following/barney

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/file-storage-configuration.md
----------------------------------------------------------------------
diff --git a/docs/file-storage-configuration.md b/docs/file-storage-configuration.md
deleted file mode 100644
index c56265a..0000000
--- a/docs/file-storage-configuration.md
+++ /dev/null
@@ -1,39 +0,0 @@
-# File storage configuration
-
-Usergrid can store your assets either on your hard drive or in the Amazon S3 cloud.
-
-Local storage configuration
----
-
-By default assets are stored in the temporary folder /tmp/usergrid
-This can be changed by editing this file /stack/rest/src/main/resources/usergrid-rest-context.xml and replacing {usergrid.temp.files} by the wanted destination
-```xml
-<bean id="binaryStore" class="org.apache.usergrid.services.assets.data.LocalFileBinaryStore">
-  <property name="reposLocation" value="${usergrid.temp.files}"/>
-</bean>
-```
-
-AwS S3 configuration
----
-
-To use your AWS S3 storage you need to change the binaryStore classpath and add several constructor arguments in /stack/rest/src/main/resources/usergrid-rest-context.xml
-
-Some examples :
-```xml
-<bean id="binaryStore" class="org.apache.usergrid.services.assets.data.AwsSdkS3BinaryStore">
-  <constructor-arg name="accessId" value="x" />
-  <constructor-arg name="secretKey" value="xx" />
-  <constructor-arg name="bucketName" value="x" />
-  <constructor-arg name="regionName" value="eu-central-1" />
-</bean>
-```
-the regionName field is not mandatory, this code is also valid
-```xml
-<bean id="binaryStore" class="org.apache.usergrid.services.assets.data.AwsSdkS3BinaryStore">
-  <constructor-arg name="accessId" value="x" />
-  <constructor-arg name="secretKey" value="xx" />
-  <constructor-arg name="bucketName" value="x" />
-</bean>
-```
-
-The filesize is limited to 50GB but you need to keep in mind that the file has to be stored on the hard drive before being sended to Amazon.

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/get_2.0_running_locally.md
----------------------------------------------------------------------
diff --git a/docs/get_2.0_running_locally.md b/docs/get_2.0_running_locally.md
deleted file mode 100644
index f1ff71c..0000000
--- a/docs/get_2.0_running_locally.md
+++ /dev/null
@@ -1,165 +0,0 @@
-# Get 2.0 Running Locally
-
-## Requirements
-
-* [JDK 1.8](http://www.oracle.com/technetwork/java/javase/downloads/index.html)
-* [Maven 3.2+](http://maven.apache.org/)
-* [Tomcat 7+](https://tomcat.apache.org/download-70.cgi)
-* [Cassandra 1.2.1*](http://cassandra.apache.org/download/)
-* [ElasticSearch 1.4+](https://www.elastic.co/downloads/elasticsearch) 
-* [Usergrid 2.0](https://github.com/apache/incubator-usergrid/tree/two-dot-o)
-
-##Running
-
-
-1. Start up Cassandra [^1]
-	a. To do this you can navigate to the cassandra folder and run ```./bin/cassandra ```
-2. Start up Elasticsearch
-	a. To do this you can navigate to the folder where you extracted elasticsearch and run ```/bin/elasticsearch``` 	
-
-###Running Usergrid	
-
-####Build The Java Sdk
-
-1. Navigate to where you cloned the usergrid repo
-2. Navigate to the ```sdks/java``` directory
-3. Run ```mvn clean install```
-
-####Build The Stack Itself
-
-1. Navigate to the ```stack``` directory.
-2. Run ```mvn clean install -DskipTests```
-3. This will generate a war at ```rest/target/ROOT.war```
-
-####Deploying the Stack Locally
-1. Take this war and deploy it on downloaded tomcat.
-1. In the lib directory of the tomcat you must also put usergrid-deployment.properties. ( An example file is provided below)
-1. Start up Tomcat
-	a. To do this you can navigate to folder where Tomcat is install and run ```./bin/catalina.sh start```
-1. Go to a web browser and input the following to initilizing the database ```localhost:8080/system/database/setup```. 
-	a. The credentials it asks for are the admin credentialls and password as defined in the usergrid-deployment.properties. 
-	b. You can also do a curl call with basic auth to automatically authenticate the call instead of using the web browser.
-1. Then using the same steps as before call ```localhost:8080/system/superuser/setup```
-
-The stack is now ready to be queried against, but to get the most out of it you'll need to initilize and use our portal!
-
-####Running The Portal Locally
-#####Requirments 
-[nodejs 0.10+](https://nodejs.org/download/) 
-
-1. Make sure you've installed node.js above. Any version above .10 or .10 should work fine.
-2. Navigate to ```incubator-usergrid/portal```.
-3. Open config.js and make sure the override URL is pointing to your local tomcat.
-4. Now in the portal folder run the following command ```./build.sh dev``` 
-5. The portal should automatically open ready for use!
-
-Now usergrid is fully ready to use! Feel free to query against it or use it however you like!
-
-
-
-Example __usergrid-deployment.properties__ file
----
-```
-# core persistence properties
-
-cassandra.embedded=false
-cassandra.version=1.2.18
-cassandra.timeout=2000
-
-collections.keyspace=Usergrid_Applications
-collections.keyspace.strategy.options=replication_factor:1
-collections.keyspace.strategy.class=org.apache.cassandra.locator.SimpleStrategy
-
-collection.stage.transient.timeout=60
-
-hystrix.threadpool.graph_user.coreSize=40
-hystrix.threadpool.graph_async.coreSize=40
-
-elasticsearch.embedded=false
-elasticsearch.cluster_name=elasticsearch
-elasticsearch.index_prefix=usergrid
-elasticsearch.hosts=127.0.0.1
-elasticsearch.port=9300
-
-elasticsearch.force_refresh=true
-
-index.query.limit.default=100
-
-# Max Cassandra connections, applies to both CP and EM
-cassandra.connections=600
-
-######################################################
-# Minimal Usergrid configuration properties for local Tomcat and Cassandra 
-#
-
-cassandra.url=127.0.0.1:9160
-
-cassandra.keyspace.strategy=org.apache.cassandra.locator.SimpleStrategy
-cassandra.keyspace.strategy.options.replication_factor=1
-
-######################################################
-# Custom mail transport 
-
-mail.transport.protocol=smtps
-mail.smtps.host=smtp.gmail.com
-mail.smtps.port=465
-mail.smtps.auth=true
-mail.smtps.username=
-mail.smtps.password=
-mail.smtps.quitwait=false
-
-
-######################################################
-# Admin and test user setup
-
-usergrid.sysadmin.login.name=superuser
-usergrid.sysadmin.login.email=myself@example.com     <--- Change this
-usergrid.sysadmin.login.password=pwHERE               <--- Change this
-usergrid.sysadmin.login.allowed=true
-usergrid.sysadmin.email=myself@example.com           <--- Change this
-
-usergrid.sysadmin.approve.users=false
-usergrid.sysadmin.approve.organizations=false
-
-# Base mailer account - default for all outgoing messages
-usergrid.management.mailer=User <myself@example.com>    <--- Change this
-
-usergrid.setup-test-account=true
-
-usergrid.test-account.app=test-app
-usergrid.test-account.organization=test-organization
-usergrid.test-account.admin-user.username=test
-usergrid.test-account.admin-user.name=Test User
-usergrid.test-account.admin-user.email=myself@example.com    <---Change this
-usergrid.test-account.admin-user.password=test
-
-######################################################
-# Auto-confirm and sign-up notifications settings
-
-usergrid.management.admin_users_require_confirmation=false
-usergrid.management.admin_users_require_activation=false
-
-usergrid.management.organizations_require_activation=false
-usergrid.management.notify_sysadmin_of_new_organizations=true
-usergrid.management.notify_sysadmin_of_new_admin_users=true
-######################################################
-# URLs
-
-# Redirect path when request come in for TLD
-usergrid.redirect_root=http://localhost:8080/status
-
-usergrid.view.management.organizations.organization.activate=http://localhost:8080/accounts/welcome
-usergrid.view.management.organizations.organization.confirm=http://localhost:8080/accounts/welcome
-usergrid.view.management.users.user.activate=http://localhost:8080/accounts/welcome
-usergrid.view.management.users.user.confirm=http://localhost:8080/accounts/welcome
-
-usergrid.organization.activation.url=http://localhost:8080/management/organizations/%s/activate
-usergrid.admin.activation.url=http://localhost:8080/management/users/%s/activate
-usergrid.admin.resetpw.url=http://localhost:8080/management/users/%s/resetpw
-usergrid.admin.confirmation.url=http://localhost:8080/management/users/%s/confirm
-usergrid.user.activation.url=http://localhost:8080%s/%s/users/%s/activate
-usergrid.user.confirmation.url=http://localhost:8080/%s/%s/users/%s/confirm
-usergrid.user.resetpw.url=http://localhost:8080/%s/%s/users/%s/resetpw
-``` 
-
-[^1]: You can start up cassandra and elasticsearch in any order but for the sake of ordered lists I put Cassandra first. 
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/getting-started/creating-a-new-application.md
----------------------------------------------------------------------
diff --git a/docs/getting-started/creating-a-new-application.md b/docs/getting-started/creating-a-new-application.md
new file mode 100644
index 0000000..cc5f577
--- /dev/null
+++ b/docs/getting-started/creating-a-new-application.md
@@ -0,0 +1,14 @@
+# Creating a new application
+
+## Creating an application
+You can use the admin portal to create applications. An application represents the data associated with your app. Through an application, you handle the entities associated with your app, including users, devices, events, and so on.
+
+To create a new application with the admin portal:
+
+1. In the admin portal, from the dropdown menu at the far top left, select the organization to which you will add the new application.
+1. Click the ADD NEW APP button, located at the top of the screen, next to the application drop-down.
+1. In the dialog box, enter a new application name, then click the Create button. Your new application will automatically be selected in the applications drop-down menu.
+Applications can also be created programmatically with a POST request to the API. For more, see Application.
+
+## Securing an application
+If this is going to be a production application, be sure to configure security roles that provide only the level of access your users will need. For more on security, see Security best practices.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/getting-started/creating-account.md
----------------------------------------------------------------------
diff --git a/docs/getting-started/creating-account.md b/docs/getting-started/creating-account.md
new file mode 100644
index 0000000..d8ec8f4
--- /dev/null
+++ b/docs/getting-started/creating-account.md
@@ -0,0 +1,21 @@
+# Creating an Usergrid Account
+To get started using the API Services BaaS, you'll need an Usergrid account. (Before reading this, you should already be familiar with what Usergrid can do to support your apps. If you're still curious about that, you might want to read API BaaS features first.)
+
+With an account, you get the following useful things:
+
+* A sandbox application you can try things with (we automatically create one for you with your new account). The sandbox is a partitioned area of the data store where you can add example data and try out API calls. The sandbox isn't secure, but it's handy to play in. For more about the sandbox, see "Using Your Application Sandbox".
+* The ability to create more applications (in addition to the sandbox). You can (and should!) make these as secure as you need to. These are the applications that you'll have behind the apps you make available to your users.
+* Access to the Admin Portal. In the portal, you can do the following:
+** Create and manage applications.
+** Manage your app's users, including access levels.
+** Manage the data in your app.
+** Manage app features, including push notifications, activities, analytics, and so on.
+** Try out API calls with a shell command window.
+** To create an Usergrid account and see a very short tutorial to get started with, go to the get started page.
+
+## Next steps
+Ready to learn and do more?
+
+* Install an SDK that will be most useful for your application environment. For more about Usergrid's SDKs, see SDKs.
+* Review API BaaS features for information on concepts and features.
+* Consult the API Reference for usage details.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/getting-started/using-a-sandbox-app.md
----------------------------------------------------------------------
diff --git a/docs/getting-started/using-a-sandbox-app.md b/docs/getting-started/using-a-sandbox-app.md
new file mode 100644
index 0000000..47c9eb1
--- /dev/null
+++ b/docs/getting-started/using-a-sandbox-app.md
@@ -0,0 +1,34 @@
+# Using a Sandbox Application
+
+## What is the sandbox application?
+
+When you create a new Usergrid account (see Creating an Usergrid Account) to use services for developers, Usergrid creates a new application for you on its servers. With the new application, called "sandbox," you can add your own example data and try out API calls that do things with the data. Be sure to see Using the API for suggestions.
+
+## Is the sandbox secure?
+
+To keep things simple and make it easier for you to try things out, the sandbox application has all authentication disabled. That way, it doesn’t require an access token for application-level calls to the API. Permissions are so open on the sandbox application because its "guest" role offers full permissions for all access paths -- that is, GET, POST, PUT, and DELETE for /**. Learn more about roles and permissions in Managing access by defining permission rules.
+
+.. warning:: Never use a Sandbox Application for a production 
+
+Keep in mind that the lack of authentication means that a sandbox application is not secure enough for important or sensitive data. A sandbox is just for experimentation while you learn how the services work, and should never be used for a production application. As with other Usergrid applications you create, a sandbox application is an area of the data store where you can put your own data. You can create as many other applications as you like, including more sandbox applications. When it comes to production (secured) applications, a good rule of thumb is to create one application for each mobile app you develop.
+
+## Creating a New Sandbox Application
+
+You may want to create (or re-create) a sandbox application. For example, you may want to create a sandbox application for another organization or you may want to create another application for testing purposes.
+
+.. warning:: Guest Role should never be given full permissions
+    
+Giving the guest role full permissions should be used only for testing and should not be used in production. Before you make your app “live”, you should remove the guest permissions for /**.
+
+Use the following steps to create a sandbox app:
+
+1. Create a new application using the admin portal. You can name the application whatever you like (including "sandbox").
+2. Set full access permissions for the guest role, as follows:
+    1. In the admin portal, click Users, then click Roles.
+    2. On the Roles page, in the list of roles, click Guest.
+    3. For the Guest role, under Permissions, click Add Permission.
+    4. In the New Permission dialog, enter the following in the Path box: ``/**``
+    5. Select the following check boxes: get, post, put, and delete.
+    6. Click the Add button.
+    7. If there are other permissions listed, delete them.
+

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/getting-started/using-the-api.md
----------------------------------------------------------------------
diff --git a/docs/getting-started/using-the-api.md b/docs/getting-started/using-the-api.md
new file mode 100644
index 0000000..9a7ba2d
--- /dev/null
+++ b/docs/getting-started/using-the-api.md
@@ -0,0 +1,150 @@
+# Using the API
+Usergrid uses a pure REST (Representational State Transfer) API built as a collection of resources. Resource locations are described by paths that are related intrinsically to collections and entities in collections.
+
+This section gives several examples of how to construct API requests. To focus on what's important, the examples use an abbreviated path that starts after the application UUID, or application name. For example, instead of giving a fully qualified path name as in:
+
+    https://api.usergrid.com/your-org/your-app/users
+   
+the example simply lists this:
+
+    /users
+    
+## Supported HTTP methods
+When building a REST API, the challenge is to represent the data and the action upon the data as a path to a resource that can be created, retrieved, updated, or deleted. The HTTP methods POST, GET, PUT, and DELETE correspond to the actions that are applied to resources.
+
+## Base URL
+The base url for all requests made to Usergrid depends on where you have Usergrid installed. If you are using Apigee's trial Usergrid service, the base URL is ``https://api.usergrid.com.``
+
+## Request construction
+Usergrid interprets the URL resource path as a list of names, UUIDs, or queries. The basic path format is:
+
+    https://api.usergrid.com/<org-uuid|org-name>/<app-uuid|app-name>/<collection-name>/<entity-uuid|entity-name>
+    
+Note: You cannot mix UUIDs and names in the URL resource path. For example, the following is incorrect:
+
+    https://api.usergrid.com/your-org/62de5d97-d28c-11e1-8d5c-12313b01d5c1/users/john.doe
+    
+## Accessing collections
+To access all entities in a collection, specify the path as follows:
+
+    /users
+    
+Such a request retrieves the first 10 entities in the collection /users sorted by their entity UUID.
+
+## Accessing entities
+To access an entity in a collection, specify the path as follows:
+
+    /<collection>/<uuid|name>
+
+where ``<collection>`` is the collection name, and <uuid|name> is the entity’s uuid or name.
+
+To access a user in the users collection, specify the path as follows:
+
+    /users/<uuid|username|email_address>
+    
+where ``<uuid|username|email_address>`` is the user’s uuid, username, or email address.
+
+For example, the following request retrieves the entity named dino from the dogs collection:
+
+    /dogs/dino
+
+## Issuing queries
+You can issue a query in an API request that retrieves items from a collection. Here is the typical format for queries:
+
+    /<collection>?ql=<query>
+
+where <query> is a query in the query language.
+
+For example, this request retrieves users whose Facebook first name is john:
+
+    /users?ql=select * where facebook.first_name ='john'
+
+For further information about queries, see Queries and parameters.
+
+## Authentication (OAuth)
+Usergrid implements the OAuth 2.0 standard for authenticating users, clients and API requests.
+
+Generally, you will generate a token for every user of your app by providing the user's username and password. The token can then be sent with all API requests to ensure each user is only able to access and modify the resources you have granted them rights to.
+
+Note that by default access tokens are not needed to make requests to the default sandbox application in an organization.
+
+For more information on generating and using access tokens, see Authenticating users and application clients and Authenticating API requests.
+
+## Response format
+All API methods return a response object that typically contains an array of entities:
+
+    {
+      "entities" : [
+        ...
+      ]
+    }
+
+Not everything can be included inside the entity, and some of the data that gets associated with specific entities isn't part of their persistent representation. This is metadata, and it can be part of the response as well as associated with a specific entity. Metadata is just an arbitrary key/value JSON structure.
+
+For example:
+
+    {
+      "entities" : {
+        {
+          "name" : "ed",
+          "metadata" : {
+            "collections" : ["activities", "groups", "followers"]
+          }
+        }
+      },
+      "metadata" : {
+        "foo" : ["bar", "baz"]
+      }
+    }
+
+For example, here is the response to a basic GET for a user entity:
+
+    {
+      "action" : "get",
+      "application" : "f34f4222-a166-11e2-a7f7-02e81adcf3d0",
+      "params" : { },
+      "path" : "/users",
+      "uri" : "https://api.usergrid.com/your-org/your-app/users",
+      "entities" : [ {
+        "uuid" : "503f17da-ec39-11e3-a0dd-a554b7fbd57a",
+        "type" : "user",
+        "created" : 1401921665485,
+        "modified" : 1401921665485,
+        "username" : "someUser",
+        "email" : "someUser@yourdomain.com",
+        "activated" : true,
+        "picture" : "http://www.gravatar.com/avatar/dc5d478e9c029853fbd025bed0dc51f8",
+        "metadata" : {
+          "path" : "/users/503f17da-ec39-11e3-a0dd-a554b7fbd57a",
+          "sets" : {
+            "rolenames" : "/users/503f17da-ec39-11e3-a0dd-a554b7fbd57a/roles",
+            "permissions" : "/users/503f17da-ec39-11e3-a0dd-a554b7fbd57a/permissions"
+          },
+          "collections" : {
+            "activities" : "/users/503f17da-ec39-11e3-a0dd-a554b7fbd57a/activities",
+            "devices" : "/users/503f17da-ec39-11e3-a0dd-a554b7fbd57a/devices",
+            "feed" : "/users/503f17da-ec39-11e3-a0dd-a554b7fbd57a/feed",
+            "groups" : "/users/503f17da-ec39-11e3-a0dd-a554b7fbd57a/groups",
+            "roles" : "/users/503f17da-ec39-11e3-a0dd-a554b7fbd57a/roles",
+            "following" : "/users/503f17da-ec39-11e3-a0dd-a554b7fbd57a/following",
+            "followers" : "/users/503f17da-ec39-11e3-a0dd-a554b7fbd57a/followers"
+          }
+        }
+      } ],
+      "timestamp" : 1401921673597,
+      "duration" : 12,
+      "organization" : "your-org",
+      "applicationName" : "your-app"
+    }
+
+## SDKs
+To make the integration of Usergrid features into your application code quicker and easier, Usegrid offers SDKs in a variety of languages. The SDKs contain language-specific methods that allow you to issue API requests from your application code in your preferred language. SDKs are available for the following languages:
+
+* iOS
+* Android
+* JavaScript/HTML5
+* Node.js
+* Ruby
+* .NET
+
+For more information, see SDKs.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/getting-up-and-running-locally.md
----------------------------------------------------------------------
diff --git a/docs/getting-up-and-running-locally.md b/docs/getting-up-and-running-locally.md
deleted file mode 100644
index ba7ffcc..0000000
--- a/docs/getting-up-and-running-locally.md
+++ /dev/null
@@ -1,72 +0,0 @@
-# Getting Up & Running Locally
-
-## Requirements
-
-* [JDK 1.7](http://www.oracle.com/technetwork/java/javase/downloads/index.html)
-* [Maven](http://maven.apache.org/)
-
-## Download
-
-### Download2
-
-Start by [downloading our latest code](https://github.com/apache/incubator-usergrid/archive/master.zip) and extract it.
-
-#### Building 3
-
-From the command line, navigate to stack directory and type the following:
-
-    mvn clean install -DskipTests=true
-
-## Running
-
-Usergrid-core contains the persistence layer and shared utilities for powering the Usergrid service. The services layer is contained in usergrid-services and exposes a higher-level API that's used by the usergrid-rest web services tier.
-
-You can run Usergrid from the command-line from the
-jar in the usergrid/standalone project:
-
-    cd launcher; java -jar target/usergrid-launcher-*.jar
-
-After startup, your instance will be available on localhost, port 8080.
-To check it’s running properly, you can try loading our status page:
-
-    curl http://localhost:8080/status
-
-You can also run it as a webapp in Tomcat, by deploying the ROOT.war file generated in the usergrid/rest project.
-
-## Getting Started with the HTTP API
-
-Start by creating an Organization. It’s the top-level structure in Usergrid:
-all Apps and Administrators must belong to an Organization. Here’s how you create one:
-
-    curl -X POST  \
-         -d 'organization=myfirstorg&username=myadmin&name=Admin&email=admin@example.com&password=password' \
-         http://localhost:8080/management/organizations
-
-You can see that creating an Organization creates an Administrator in the process. Let’s authenticate as him:
-
-    curl 'http://localhost:8080/management/token?grant_type=password&username=myadmin&password=password'
-
-This will return an access\_token. We’ll use this to authenticate the next two calls.
-Next, let’s create an Application:
-
-    curl -H "Authorization: Bearer [the management token from above]" \
-         -H "Content-Type: application/json" \
-         -X POST -d '{ "name":"myapp" }' \
-         http://localhost:8080/management/orgs/myfirstorg/apps
-
-… And a User for the Application:
-
-    curl -H "Authorization: Bearer [the management token from above]" \
-         -X POST "http://localhost:8080/myfirstorg/myapp/users" \
-         -d '{ "username":"myuser", "password":"mypassword", "email":"user@example.com" }'
-
-Let’s now generate an access token for this Application User:
-
-    curl 'http://localhost:8080/myfirstorg/myapp/token?grant_type=password&username=myuser&password=mypassword'
-
-This will also send back an access\_token, but limited in scope.
-Let’s use it to create a collection with some data in it:
-
-    curl -H "Authorization: Bearer [the user token]" \
-         -X POST -d '[ { "cat":"fluffy" }, { "fish": { "gold":2, "oscar":1 } } ]' \
-         http://localhost:8080/myfirstorg/myapp/pets

http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/07d14c88/docs/index.md
----------------------------------------------------------------------
diff --git a/docs/index.md b/docs/index.md
index d351a0f..dc35ba8 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,13 +1,142 @@
-***************
-Apache Usergrid Documents
-***************
-
-.. toctree::
-   deploy-local
-   getting-up-and-running-locally
-   get_2.0_running_locally
-   organizations-admins
-   usage
-   presentations-and-videos
-   upgrading
-   contribute-code
+*****************************
+Apache Usergrid Documentation
+*****************************
+
+.. _intro::
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Introduction
+
+   introduction/usergrid-features
+   introduction/data-model
+   introduction/async-vs-sync
+   
+.. _getting-started:
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Getting Started
+
+   getting-started/creating-a-new-application
+   getting-started/creating-account
+   getting-started/using-a-sandbox-app
+   getting-started/using-the-api.md
+     
+.. _data-storage:
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Data Storage
+   
+   data-storage/data-store-dbms
+   data-storage/optimizing-access
+   data-storage/collections
+   data-storage/entities
+
+.. _data-queries:
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Data Queries 
+  
+   data-queries/querying-your-data
+   data-queries/query-parameters
+   data-queries/operators-and-types
+   data-queries/advanced-query-usage
+
+.. _entity-connections:
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Entity Connections 
+  
+   entity-connections/relationships
+   
+.. _push-notifications:
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Push Notifications
+  
+   push-notifications/users-devices
+   
+.. _security-and-authentication:
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Security and Authentication
+  
+   security-and-auth/roles-and-permissions
+   
+.. _user-management-and-social-graph:
+
+.. toctree::
+   :maxdepth: 2
+   :caption: User Management and Social Graph
+  
+   user-management/activity
+   user-management/groups
+   
+.. _geolocation:
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Geolocation
+   
+   geolocation
+   
+.. _asset-and-file-management:
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Assets and Files
+  
+   asset-and-files/assets
+   asset-and-files/file-storage-configuration
+   
+.. _counters-and-events:
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Counters and Events
+  
+   counters-and-events/events-and-counters
+   
+.. _organization-and-application-management:
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Organizations and Applications
+   
+   orgs-and-apps/applications
+   orgs-and-apps/organizations-admins
+    
+.. _sdks:
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Software Development Kits (SDKs)
+
+   sdks/ios
+   sdks/java
+   sdks/javascript
+   sdks/usage
+   
+.. _references:
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Reference and other docs
+
+   reference/presentations
+   reference/videos
+    
+.. _installation:
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Installing the Usergrid stack
+
+   installation
+       


Mime
View raw message