[Creation] Store location of new objects

The creation service stores the location (the full path) to
the domain object as "model.location"

platform/commonUI/browse/src/creation/CreationService.js

@@ -112,12 +112,37 @@ define(
                 return $q.when(
                     uuid()
                 ).then(function (id) {
+                    model = addLocationToModel(id, model, parent);
                     return doPersist(persistence.getSpace(), id, model);
                 }).then(function (id) {
                     return addToComposition(id, parent, persistence);
                 });
             }
 
+            // Store the location of an object relative to it's parent.
+            function addLocationToModel(modelId, model, parent) {
+                var context = parent.getCapability("context"),
+                    pathObjects,
+                    pathIds;
+
+                if (!context) {
+                    $log.warn('No parent context, location will not be set.');
+                    return model;
+                }
+
+                pathObjects = context.getPath();
+                if (!pathObjects || !pathObjects.length) {
+                    pathObjects = [];
+                }
+                pathIds = pathObjects.map(function (object) {
+                    return object.getId();
+                });
+                pathIds.push(modelId);
+
+                model.location = pathIds.join('/');
+                return model;
+            }
+
             return {
                 /**
                  * Create a new domain object with the provided model, as

platform/commonUI/browse/test/creation/CreationServiceSpec.js

@@ -38,6 +38,7 @@ define(
                 mockMutationCapability,
                 mockPersistenceCapability,
                 mockCompositionCapability,
+                mockContextCapability,
                 mockCapabilities,
                 creationService;
 
@@ -87,16 +88,30 @@ define(
                     "composition",
                     ["invoke"]
                 );
+                mockContextCapability = jasmine.createSpyObj(
+                    "context",
+                    ["getPath"]
+                );
                 mockCapabilities = {
                     mutation: mockMutationCapability,
                     persistence: mockPersistenceCapability,
-                    composition: mockCompositionCapability
+                    composition: mockCompositionCapability,
+                    context: mockContextCapability
                 };
 
                 mockPersistenceService.createObject.andReturn(
                     mockPromise(true)
                 );
 
+                mockContextCapability.getPath.andReturn([
+                    {
+                        getId: function () { return 'root'; }
+                    },
+                    {
+                        getId: function () { return 'parent'; }
+                    }
+                ]);
+
                 mockParentObject.getCapability.andCallFake(function (key) {
                     return mockCapabilities[key];
                 });
@@ -194,6 +209,15 @@ define(
                 expect(mockLog.error).toHaveBeenCalled();
             });
 
+            it("stores location on new domainObjects", function() {
+                var model = { name: "my model" };
+                var objectPromise = creationService.createObject(
+                    model,
+                    mockParentObject
+                );
+                expect(model.location).toBeDefined();
+                expect(model.location.indexOf('root/parent')).toBe(0);
+            });
 
         });
     }