private static bool CallDeleteActivity(string targetObjectID, IContainerOwner owner)
 {
     Activity activity = Activity.RetrieveFromOwnerContent(owner, targetObjectID);
     //Activity.RetrieveFromOwnerContent(owner, )
     DeleteInformationObject.Execute(new DeleteInformationObjectParameters { ObjectToDelete = activity });
     return false;
 }

 public static void EnsureMasterCollections(IContainerOwner owner)
 {
     {
             var masterCollection = ProductUsageCollection.GetMasterCollectionInstance(owner);
             if(masterCollection == null)
             {
                 masterCollection = ProductUsageCollection.CreateDefault();
                 masterCollection.RelativeLocation =
                     ProductUsageCollection.GetMasterCollectionLocation(owner);
                 StorageSupport.StoreInformation(masterCollection, owner);
             }
             IInformationCollection collection = masterCollection;
             collection.SubscribeToContentSource();
         }
         {
             var masterCollection = ProductCollection.GetMasterCollectionInstance(owner);
             if(masterCollection == null)
             {
                 masterCollection = ProductCollection.CreateDefault();
                 masterCollection.RelativeLocation =
                     ProductCollection.GetMasterCollectionLocation(owner);
                 StorageSupport.StoreInformation(masterCollection, owner);
             }
             IInformationCollection collection = masterCollection;
             collection.SubscribeToContentSource();
         }
 }

 public static IInformationObject GetTarget_ObjectToDelete(IContainerOwner owner, string objectDomainName, string objectName, string objectId)
 {
     IInformationObject objectToDelete =
         StorageSupport.RetrieveInformationObjectFromDefaultLocation(objectDomainName, objectName, objectId,
                                                                     owner);
     return objectToDelete;
 }

 public static void ExecuteMethod_InitializeGroupWithDefaultObjects(IContainerOwner groupAsOwner)
 {
     // Initialize nodesummarycontainer
     NodeSummaryContainer nodeSummaryContainer = NodeSummaryContainer.CreateDefault();
     nodeSummaryContainer.SetLocationAsOwnerContent(groupAsOwner, "default");
     nodeSummaryContainer.StoreInformationMasterFirst(groupAsOwner, true);
 }

 public static void PutQueryRequestToQueue(string storageContainerName, string indexName, IContainerOwner owner, string requestID)
 {
     var queueName = GetQueryRequestQueueName(indexName);
     string ownerstring = owner.ToParseableString();
     string messageText = storageContainerName + ":" +  ownerstring + ":" + requestID;
     QueueSupport.PutMessageToQueue(queueName, messageText);
 }

 public static void ExecuteMethod_PerformIndexing(IContainerOwner owner, IndexingRequest indexingRequest, string luceneIndexFolder)
 {
     string indexName = indexingRequest.IndexName;
     List<Document> documents = new List<Document>();
     List<string> removeDocumentIDs = new List<string>();
     foreach (var objLocation in indexingRequest.ObjectLocations)
     {
         IInformationObject iObj = StorageSupport.RetrieveInformation(objLocation, null, owner);
         if (iObj == null)
         {
             var lastSlashIX = objLocation.LastIndexOf('/');
             var objectID = objLocation.Substring(lastSlashIX + 1);
             removeDocumentIDs.Add(objectID);
             continue;
         }
         IIndexedDocument iDoc = iObj as IIndexedDocument;
         if (iDoc != null)
         {
             var luceneDoc = iDoc.GetLuceneDocument(indexName);
             if (luceneDoc == null)
                 continue;
             luceneDoc.RemoveFields("ObjectDomainName");
             luceneDoc.RemoveFields("ObjectName");
             luceneDoc.RemoveFields("ObjectID");
             luceneDoc.RemoveFields("ID");
             luceneDoc.Add(new Field("ObjectDomainName", iObj.SemanticDomainName, Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.NO));
             luceneDoc.Add(new Field("ObjectName", iObj.Name, Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.NO));
             luceneDoc.Add(new Field("ObjectID", iObj.ID, Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.NO));
             luceneDoc.Add(new Field("ID", iObj.ID, Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.NO));
             documents.Add(luceneDoc);
         }
     }
     FieldIndexSupport.AddAndRemoveDocuments(luceneIndexFolder, documents.ToArray(), removeDocumentIDs.ToArray());
 }

 private static bool CallDeleteAddressAndLocation(string addressAndLocationID, IContainerOwner owner)
 {
     AddressAndLocation addressAndLocation = AddressAndLocation.RetrieveFromOwnerContent(owner,
                                                                                         addressAndLocationID);
     addressAndLocation.DeleteInformationObject();
     return false;
 }

 public static bool ExecuteMethod_ExecuteActualOperation(string targetObjectID, string commandName, IContainerOwner owner, InformationSourceCollection informationSources, string[] formSourceNames, NameValueCollection formSubmitContent)
 {
     switch(commandName)
     {
         case "RemoveCollaborator":
             return CallRemoveGroupMember(targetObjectID, owner);
         case "PublishGroupPublicContent":
             return CallPublishGroupContentToPublicArea(owner);
         case "PublishGroupWwwContent":
             return CallPublishGroupContentToWww(owner);
         case "AssignCollaboratorRole":
             return CallAssignCollaboratorRole(targetObjectID, owner, informationSources.GetDefaultSource(typeof(GroupContainer).FullName) ,formSubmitContent);
         case "DeleteBlog":
             return CallDeleteBlog(targetObjectID, owner);
         case "DeleteActivity":
             return CallDeleteActivity(targetObjectID, owner);
         case "UnlinkEmailAddress":
             return CallUnlinkEmailAddress(targetObjectID, owner,
                                           informationSources.GetDefaultSource(typeof (AccountContainer).FullName));
         case "CreateHelloWorld":
             return CallCreateHelloWorld(owner, helloText: formSubmitContent["tHelloText"]);
         case "DeleteHelloWorld":
             return CallDeleteHelloWorld(owner, helloWorldId: formSubmitContent["HelloWorldID"]);
         default:
             throw new NotImplementedException("Operation mapping for command not implemented: " + commandName);
     }
 }

        public static object ExecuteOwnerWebPOST(IContainerOwner containerOwner, NameValueCollection form, HttpFileCollection fileContent)
        {
            bool reloadPageAfter = form["NORELOAD"] == null;

            bool isCancelButton = form["btnCancel"] != null;
            if (isCancelButton)
                return reloadPageAfter;

            string operationName = form["ExecuteOperation"];
            if (operationName != null)
            {
                var operationResult = executeOperationWithFormValues(containerOwner, operationName, form, fileContent);
                if(operationResult != null)
                    return operationResult;
                return reloadPageAfter;
            }

            string adminOperationName = form["ExecuteAdminOperation"];
            if (adminOperationName != null)
            {
                var adminResult = executeAdminOperationWithFormValues(containerOwner, adminOperationName, form, fileContent);
                if(adminResult != null)
                    return adminResult;
                return reloadPageAfter;
            }

            string contentSourceInfo = form["ContentSourceInfo"];
            var rootSourceAction = form["RootSourceAction"];
            if (rootSourceAction != null && rootSourceAction != "Save")
                return reloadPageAfter;
            var filterFields = new string[] { "ContentSourceInfo", "RootSourceAction", "NORELOAD" };
            string[] contentSourceInfos = contentSourceInfo.Split(',');
            var filteredForm = filterForm(form, filterFields);
            foreach (string sourceInfo in contentSourceInfos)
            {
                string relativeLocation;
                string oldETag;
                retrieveDataSourceInfo(sourceInfo, out relativeLocation, out oldETag);
                VirtualOwner verifyOwner = VirtualOwner.FigureOwner(relativeLocation);
                if (verifyOwner.IsSameOwner(containerOwner) == false)
                    throw new SecurityException("Mismatch in ownership of data submission");
                IInformationObject rootObject = StorageSupport.RetrieveInformation(relativeLocation, oldETag,
                                                                                   containerOwner);
                if (oldETag != rootObject.ETag)
                {
                    throw new InvalidDataException("Information under editing was modified during display and save");
                }
                // TODO: Proprely validate against only the object under the editing was changed (or its tree below)

                SetObjectTreeValues.Execute(new SetObjectTreeValuesParameters
                    {
                        RootObject = rootObject,
                        HttpFormData = filteredForm,
                        HttpFileData = fileContent
                    });
            }
            return reloadPageAfter;
        }

 public static IInformationObject GetTarget_CreatedObject(IContainerOwner owner, string objectDomainName, string objectName)
 {
     string objectTypeName = objectDomainName + "." + objectName;
     Type objectType = Type.GetType(objectTypeName);
     IInformationObject iObj = (IInformationObject) Activator.CreateInstance(objectType);
     var relativeLocation = StorageSupport.GetOwnerContentLocation(owner, objectDomainName + "/" + objectName + "/" + iObj.ID);
     iObj.RelativeLocation = relativeLocation;
     return iObj;
 }

 public static AuthenticatedAsActiveDevice GetTarget_AuthenticatedAsActiveDevice(IContainerOwner owner, string authenticationDeviceDescription, string negotiationUrl, string connectionUrl)
 {
     AuthenticatedAsActiveDevice activeDevice = new AuthenticatedAsActiveDevice();
     activeDevice.SetLocationAsOwnerContent(owner, activeDevice.ID);
     activeDevice.AuthenticationDescription = authenticationDeviceDescription;
     //activeDevice.SharedSecret = sharedSecret;
     activeDevice.NegotiationURL = negotiationUrl;
     activeDevice.ConnectionURL = connectionUrl;
     return activeDevice;
 }

 public static void RefreshMasterCollections(IContainerOwner owner)
 {
     {
             IInformationCollection masterCollection = HelloWorldCollection.GetMasterCollectionInstance(owner);
             if (masterCollection == null)
                 throw new InvalidDataException("Master collection HelloWorldCollection missing for owner");
             masterCollection.RefreshContent();
             StorageSupport.StoreInformation((IInformationObject) masterCollection, owner);
         }
 }

 public static InformationInput GetTarget_CreatedInformationInput(IContainerOwner owner, string inputDescription, string locationUrl, string localContentName, string authenticatedDeviceId)
 {
     InformationInput informationInput = new InformationInput();
     informationInput.SetLocationAsOwnerContent(owner, informationInput.ID);
     informationInput.InputDescription = inputDescription;
     informationInput.LocationURL = locationUrl;
     informationInput.LocalContentName = localContentName;
     informationInput.AuthenticatedDeviceID = authenticatedDeviceId;
     return informationInput;
 }

 public static void ExecuteMethod_RemoveExpiredEntries(IContainerOwner owner, string[] ensureUpdateOnStatusSummaryOutput)
 {
     foreach (string changeItemID in ensureUpdateOnStatusSummaryOutput)
     {
         string relativeLocationFromOwner = InformationChangeItem.GetRelativeLocationFromID(changeItemID);
         var blob = StorageSupport.GetOwnerBlobReference(owner, relativeLocationFromOwner);
         blob.DeleteWithoutFiringSubscriptions();
         var jsonBlob = StorageSupport.GetOwnerBlobReference(owner, relativeLocationFromOwner + ".json");
         jsonBlob.DeleteWithoutFiringSubscriptions();
     }
 }

 public static WebPublishInfo GetTarget_PublishInfo(IContainerOwner owner)
 {
     WebPublishInfo publishInfo = WebPublishInfo.RetrieveFromOwnerContent(owner, "default");
     if (publishInfo == null)
     {
         publishInfo = WebPublishInfo.CreateDefault();
         publishInfo.SetLocationAsOwnerContent(owner, "default");
         publishInfo.StoreInformation();
     }
     return publishInfo;
 }

 public static PackageOwnerContentParameters PackageOwnerContentToZip_GetParameters(IContainerOwner owner, string packageRootFolder, string[] includedFolders)
 {
     return new PackageOwnerContentParameters
         {
             Owner = owner,
             PackageName = "Full export",
             Description = "Full export done by ExportOwnerContentToZip",
             PackageType = "FULLEXPORT",
             IncludedFolders = includedFolders,
             PackageRootFolder = packageRootFolder
         };
 }

        public static void ExecuteMethod_EnsureUpdateOnStatusSummary(IContainerOwner owner, DateTime updateTime, string[] changedIdList, int removeExpiredEntriesSeconds)
        {
            int retryCount = 10;
            while (retryCount-- >= 0)
            {
                try
                {
                    var statusSummary = StatusSummary.RetrieveFromOwnerContent(owner, "default");
                    if (statusSummary == null)
                    {
                        statusSummary = new StatusSummary();
                        statusSummary.SetLocationAsOwnerContent(owner, "default");
                    }
                    string latestTimestampEntry = statusSummary.ChangeItemTrackingList.FirstOrDefault();
                    long currentTimestampTicks = updateTime.ToUniversalTime().Ticks;
                    if (latestTimestampEntry != null)
                    {
                        long latestTimestampTicks = Convert.ToInt64(latestTimestampEntry.Substring(2));
                        if (currentTimestampTicks <= latestTimestampTicks)
                            currentTimestampTicks = latestTimestampTicks + 1;
                    }
                    string currentTimestampEntry = "T:" + currentTimestampTicks;
                    var timestampedList = statusSummary.ChangeItemTrackingList;
                    // Remove possible older entries of new IDs
                    timestampedList.RemoveAll(changedIdList.Contains);
                    // Add Timestamp and new IDs
                    timestampedList.Insert(0, currentTimestampEntry);
                    timestampedList.InsertRange(1, changedIdList);
                    var removeOlderThanTicks = currentTimestampTicks -
                                               TimeSpan.FromSeconds(removeExpiredEntriesSeconds).Ticks;
                    int firstBlockToRemoveIX = timestampedList.FindIndex(candidate =>
                        {
                            if (candidate.StartsWith("T:"))
                            {
                                long candidateTicks = Convert.ToInt64(candidate.Substring(2));
                                return candidateTicks < removeOlderThanTicks;
                            }
                            return false;
                        });
                    if (firstBlockToRemoveIX > -1)
                    {
                        timestampedList.RemoveRange(firstBlockToRemoveIX, timestampedList.Count - firstBlockToRemoveIX);
                    }
                    statusSummary.StoreInformation();
                    return; // Break from while loop
                }
                catch (Exception ex)
                {

                }
            }
        }

        /// <summary>
        /// Creates default views and returns the one relative to the requester
        /// </summary>
        /// <param name="requesterLocation">Requester relative location</param>
        /// <param name="informationObject">Information object to create the view for</param>
        /// <param name="owner">Container owner</param>
        /// <returns></returns>
        public static CloudBlob CreateDefaultViewRelativeToRequester(string requesterLocation, IInformationObject informationObject, IContainerOwner owner)
        {
            bool isAccountOwner = owner.IsAccountContainer();
            bool isGroupOwner = owner.IsGroupContainer();
            bool isDeveloperView = owner.ContainerName == "dev";
            string[] viewLocations;
            if (isAccountOwner)
                viewLocations = FixedAccountSiteLocations;
            else if (isGroupOwner)
                viewLocations = FixedGroupSiteLocations;
            else throw new NotSupportedException("Invalid owner container type for default view (non acct, non group): " + owner.ContainerName);

            string requesterDirectory = StorageSupport.GetLocationParentDirectory(requesterLocation);
            FileInfo fileInfo = new FileInfo(requesterLocation);
            //string viewRoot = fileInfo.Directory.Parent != null
            //                      ? fileInfo.Directory.Parent.Name
            //                      : fileInfo.Directory.Name;
            CloudBlob relativeViewBlob = null;
            bool hasException = false;
            bool allException = true;
            foreach (string viewLocation in viewLocations)
            {
                try
                {
                    string viewRoot = isDeveloperView ? "developer-00000000000000000000000000" : GetViewRoot(viewLocation);
                    string viewItemDirectory = Path.Combine(viewRoot, viewLocation).Replace("\\", "/") + "/";
                    string viewName = GetDefaultStaticViewName(informationObject);
                    string viewTemplateName = GetDefaultStaticTemplateName(informationObject);
                    // TODO: Relative from xyzsite => xyztemplate; now we only have website - also acct/grp specific
                    //string viewTemplateLocation = "webtemplate/oip-viewtemplate/" + viewTemplateName;
                    string viewTemplateLocation = viewItemDirectory + viewTemplateName;
                    CloudBlob viewTemplate = StorageSupport.CurrActiveContainer.GetBlob(viewTemplateLocation, owner);
                    string renderedViewLocation = viewItemDirectory + viewName;
                    CloudBlob renderTarget = StorageSupport.CurrActiveContainer.GetBlob(renderedViewLocation, owner);
                    InformationSource defaultSource = InformationSource.GetAsDefaultSource(informationObject);
                    RenderWebSupport.RenderTemplateWithContentToBlob(viewTemplate, renderTarget, defaultSource);
                    if (viewItemDirectory == requesterDirectory)
                        relativeViewBlob = renderTarget;
                    allException = false;
                }
                catch (Exception ex)
                {
                    hasException = true;
                }

            }
            if (relativeViewBlob == null && hasException == false && false)
                throw new InvalidDataException(
                    String.Format("Default view with relative location {0} not found for owner type {1}",
                                  requesterLocation, owner.ContainerName));
            return relativeViewBlob;
        }

 public static QueueEnvelope GetTarget_RequestEnvelope(string processId, IContainerOwner owner, string activeContainerName)
 {
     var envelope = new QueueEnvelope
         {
             OwnerPrefix = owner.ToFolderName(),
             ActiveContainerName = activeContainerName,
             SingleOperation = new OperationRequest
                 {
                     ProcessIDToExecute = processId
                 }
         };
     return envelope;
 }

 public void SetMediaContent(IContainerOwner containerOwner, string contentObjectID, object mediaContent)
 {
     if(ID != contentObjectID)
         return;
     ClearCurrentContent(containerOwner);
     HttpPostedFile postedContent = (HttpPostedFile) mediaContent;
     FileExt = Path.GetExtension(postedContent.FileName);
     ContentLength = postedContent.ContentLength;
     string locationFileName = ID + FileExt;
     SetLocationAsOwnerContent(containerOwner, locationFileName);
     postedContent.InputStream.Seek(0, SeekOrigin.Begin);
     StorageSupport.CurrActiveContainer.UploadBlobStream(RelativeLocation, postedContent.InputStream, StorageSupport.InformationType_GenericContentValue);
     UpdateAdditionalMediaFormats();
 }