public static void Execute(DeleteConnectionWithStructuresParameters parameters)
 {
     PrepareParameters(parameters);
             Connection Connection = DeleteConnectionWithStructuresImplementation.GetTarget_Connection(parameters.ConnectionID);
         DeleteConnectionWithStructuresImplementation.ExecuteMethod_CallDeleteOnOtherEndAndDeleteOtherEndDevice(parameters.IsLaunchedByRemoteDelete, Connection);
         DeleteConnectionWithStructuresImplementation.ExecuteMethod_DeleteConnectionIntermediateContent(Connection);
         DeleteConnectionWithStructuresImplementation.ExecuteMethod_DeleteConnectionProcesses(Connection);
         DeleteConnectionWithStructuresImplementation.ExecuteMethod_DeleteConnectionObject(Connection);
 }
 private static void PrepareParameters(DeleteConnectionWithStructuresParameters parameters)
 {
 }
        private static object executeOperationWithFormValues(IContainerOwner containerOwner, string operationName, NameValueCollection form, HttpFileCollection fileContent)
        {
            var filterFields = new string[] {"ExecuteOperation", "ObjectDomainName", "ObjectName", "ObjectID", "NORELOAD"};
            switch (operationName)
            {
                case "SetGroupAsDefaultForAccount":
                {
                    SetGroupAsDefaultForAccountParameters parameters = new SetGroupAsDefaultForAccountParameters
                    {
                        GroupID = form["GroupID"]
                    };
                    SetGroupAsDefaultForAccount.Execute(parameters);
                    break;
                }
                case "ClearDefaultGroupFromAccount":
                {
                    ClearDefaultGroupFromAccount.Execute();
                    break;
                }

                case "PublishToConnection":
                    {
                        var parameters = new PublishCollaborationContentOverConnectionParameters
                            {
                                ConnectionID = form["ConnectionID"]
                            };
                        PublishCollaborationContentOverConnection.Execute(parameters);
                        break;
                    }
                case "FinalizeConnectionAfterGroupAuthorization":
                    {
                        var parameters = new FinalizeConnectionAfterGroupAuthorizationParameters
                            {
                                ConnectionID = form["ConnectionID"]
                            };
                        FinalizeConnectionAfterGroupAuthorization.Execute(parameters);
                        break;
                    }
                case "DeleteConnection":
                    {
                        var parameters = new DeleteConnectionWithStructuresParameters
                            {
                                ConnectionID = form["ConnectionID"],
                                IsLaunchedByRemoteDelete = false
                            };
                        DeleteConnectionWithStructures.Execute(parameters);
                        break;
                    }
                case "SynchronizeConnectionCategories":
                    {
                        var parameters = new SynchronizeConnectionCategoriesParameters
                        {
                            ConnectionID = form["ConnectionID"]
                        };
                        SynchronizeConnectionCategories.Execute(parameters);
                        break;
                    }

                case "UpdateConnectionThisSideCategories":
                    {
                        ExecuteConnectionProcess.Execute(new ExecuteConnectionProcessParameters
                            {
                                ConnectionID = form["ConnectionID"],
                                ConnectionProcessToExecute = "UpdateConnectionThisSideCategories"
                            });
                        break;
                    }
                case "InitiateIntegrationConnection":
                    {
                        InitiateIntegrationConnectionParameters parameters = new InitiateIntegrationConnectionParameters
                            {
                                Description = form["Description"],
                                TargetBallHostName = form["TargetBallHostName"],
                                TargetGroupID = form["TargetGroupID"]
                            };
                        InitiateIntegrationConnection.Execute(parameters);
                        break;
                    }
                case "DeleteCustomUI":
                    {
                        if (containerOwner.IsGroupContainer() == false)
                            throw new NotSupportedException("CreateOrUpdateCustomUI is only supported for groups");
                        DeleteCustomUIParameters parameters = new DeleteCustomUIParameters
                            {
                                CustomUIName = form["CustomUIName"],
                                Owner = containerOwner
                            };
                        DeleteCustomUI.Execute(parameters);
                        break;
                    }
                case "CreateOrUpdateCustomUI":
                    {
                        if(containerOwner.IsGroupContainer() == false)
                            throw new NotSupportedException("CreateOrUpdateCustomUI is only supported for groups");
                        var customUIContent = fileContent["CustomUIContents"];
                        if(customUIContent == null)
                            throw new ArgumentException("CustomUIContent field is required to contain the zip contents of custom UI.");
                        CreateOrUpdateCustomUIParameters parameters = new CreateOrUpdateCustomUIParameters
                            {
                                CustomUIName = form["CustomUIName"],
                                Owner = containerOwner,
                                ZipArchiveStream = customUIContent.InputStream,
                            };
                        CreateOrUpdateCustomUI.Execute(parameters);
                        break;
                    }
                case "AddCategories":
                    {
                        string categoryNames = form["CategoryList"];
                        string[] categoryList = categoryNames.Split(new string[] { Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries);
                        foreach (string categoryName in categoryList)
                        {
                            NameValueCollection values = new NameValueCollection();
                            values.Add("Title", categoryName);
                            CreateSpecifiedInformationObjectWithValuesParameters parameters = new CreateSpecifiedInformationObjectWithValuesParameters
                                {
                                    ObjectDomainName = "AaltoGlobalImpact.OIP",
                                    ObjectName = "Category",
                                    HttpFormData = values,
                                    Owner = containerOwner
                                };
                            CreateSpecifiedInformationObjectWithValues.Execute(parameters);
                        }
                        break;
                    }
                case "PublishGroupToWww":
                    {
                        PublishGroupToWwwParameters parameters = new PublishGroupToWwwParameters
                            {
                                Owner = containerOwner
                            };
                        PublishGroupToWww.Execute(parameters);
                        break;
                    }
                case "UpdateUsageMonitoringItems":
                    {
                        UpdateUsageMonitoringItemsParameters parameters = new UpdateUsageMonitoringItemsParameters
                            {
                                MonitoringIntervalInMinutes = 5,
                                MonitoringItemTimeSpanInMinutes = 60,
                                Owner = containerOwner
                            };
                        UpdateUsageMonitoringItems.Execute(parameters);
                        UpdateUsageMonitoringSummariesParameters summaryParameters = new UpdateUsageMonitoringSummariesParameters
                            {
                                AmountOfDays = 31,
                                Owner = containerOwner
                            };
                        UpdateUsageMonitoringSummaries.Execute(summaryParameters);
                        break;
                    }
                case "ProcessAllResourceUsagesToOwnerCollections":
                    {
                        ProcessAllResourceUsagesToOwnerCollectionsParameters parameters = new ProcessAllResourceUsagesToOwnerCollectionsParameters
                            {
                                ProcessBatchSize = 500
                            };
                        ProcessAllResourceUsagesToOwnerCollections.Execute(parameters);
                        break;
                    }
                case "CreateInformationOutput":
                    {
                        CreateInformationOutputParameters parameters = new CreateInformationOutputParameters
                            {
                                Owner = containerOwner,
                                AuthenticatedDeviceID = form["AuthenticatedDeviceID"],
                                DestinationContentName = form["DestinationContentName"],
                                DestinationURL = form["DestinationURL"],
                                LocalContentURL = form["LocalContentURL"],
                                OutputDescription = form["OutputDescription"]
                            };
                        var createdInformationOutput = CreateInformationOutput.Execute(parameters);
                        var owningAccount = containerOwner as TBAccount;
                        TBCollaboratingGroup owningGroup = null;
                        if (owningAccount == null)
                        {
                            TBRGroupRoot groupRoot =
                                TBRGroupRoot.RetrieveFromDefaultLocation(containerOwner.LocationPrefix);
                            owningGroup = groupRoot.Group;
                        }
                        CreateAndSendEmailValidationForInformationOutputConfirmationParameters emailParameters = new CreateAndSendEmailValidationForInformationOutputConfirmationParameters
                        {
                            OwningAccount = owningAccount,
                            OwningGroup = owningGroup,
                            InformationOutput = createdInformationOutput.InformationOutput
                        };
                        CreateAndSendEmailValidationForInformationOutputConfirmation.Execute(emailParameters);
                        break;
                    }
                case "DeleteInformationOutput":
                    {
                        DeleteInformationOutputParameters parameters = new DeleteInformationOutputParameters
                            {
                                Owner = containerOwner,
                                InformationOutputID = form["InformationOutputID"]
                            };
                        DeleteInformationOutput.Execute(parameters);
                        break;
                    }

                case "PushToInformationOutput":
                    {
                        PushToInformationOutputParameters parameters = new PushToInformationOutputParameters
                            {
                                Owner = containerOwner,
                                InformationOutputID = form["InformationOutputID"]
                            };
                        PushToInformationOutput.Execute(parameters);
                        break;
                    }
                case "DeleteInformationInput":
                    {
                        DeleteInformationInputParameters parameters = new DeleteInformationInputParameters
                            {
                                Owner = containerOwner,
                                InformationInputID = form["InformationInputID"]
                            };
                        DeleteInformationInput.Execute(parameters);
                        break;
                    }
                case "FetchInputInformation":
                    {
                        FetchInputInformationParameters parameters = new FetchInputInformationParameters
                            {
                                Owner = containerOwner,
                                InformationInputID = form["InformationInputID"],
                                QueryParameters = form["QueryParameters"]
                            };
                        FetchInputInformation.Execute(parameters);
                        break;
                    }
                case "DeleteDeviceMembership":
                    {
                        DeleteDeviceMembershipParameters parameters = new DeleteDeviceMembershipParameters
                            {
                                Owner = containerOwner,
                                DeviceMembershipID = form["DeviceMembershipID"]
                            };
                        DeleteDeviceMembership.Execute(parameters);
                        break;
                    }
                case "DeleteAuthenticatedAsActiveDevice":
                    {
                        DeleteAuthenticatedAsActiveDeviceParameters parameters = new DeleteAuthenticatedAsActiveDeviceParameters
                            {
                                Owner = containerOwner,
                                AuthenticatedAsActiveDeviceID = form["AuthenticatedAsActiveDeviceID"]
                            };
                        DeleteAuthenticatedAsActiveDevice.Execute(parameters);
                        break;
                    }
                case "PerformNegotiationAndValidateAuthenticationAsActiveDevice":
                    {
                        PerformNegotiationAndValidateAuthenticationAsActiveDeviceParameters parameters = new PerformNegotiationAndValidateAuthenticationAsActiveDeviceParameters
                            {
                                Owner = containerOwner,
                                AuthenticatedAsActiveDeviceID = form["AuthenticatedAsActiveDeviceID"],
                            };
                        PerformNegotiationAndValidateAuthenticationAsActiveDevice.Execute(parameters);
                        break;
                    }
                case "CreateAuthenticatedAsActiveDevice":
                    {
                        requireGroup(containerOwner, "Create as authenticated device only supported by group for now");
                        CreateAuthenticatedAsActiveDeviceParameters parameters = new CreateAuthenticatedAsActiveDeviceParameters
                            {
                                Owner = containerOwner,
                                AuthenticationDeviceDescription = form["AuthenticationDeviceDescription"],
                                // SharedSecret = form["SharedSecret"],
                                TargetBallHostName = form["TargetBallHostName"],
                                TargetGroupID = form["TargetGroupID"]
                            };
                        CreateAuthenticatedAsActiveDevice.Execute(parameters);
                        break;
                    }
                case "RemoveCollaboratorFromGroup":
                    {
                        if (containerOwner.IsGroupContainer() == false)
                            throw new InvalidOperationException("Collaborator removal is only supported in group context");
                        if(!TBCollaboratorRole.HasModeratorRights(InformationContext.Current.CurrentGroupRole))
                            throw new SecurityException("Collaborator removal is only doable by moderators/initiators");
                        string accountID = form["AccountID"];
                        RemoveMemberFromGroupParameters parameters = new RemoveMemberFromGroupParameters
                            {
                                AccountID = accountID,
                                GroupID = containerOwner.LocationPrefix
                            };
                        RemoveMemberFromGroup.Execute(parameters);
                        break;
                    }
                case "InviteMemberToGroup":
                    {
                        if (containerOwner.IsGroupContainer() == false)
                            throw new InvalidOperationException("Group invitation is only supported in group context");
                        string emailAddress = form["EmailAddress"];
                        string emailRootID = TBREmailRoot.GetIDFromEmailAddress(emailAddress);
                        TBREmailRoot emailRoot = TBREmailRoot.RetrieveFromDefaultLocation(emailRootID);
                        if(emailRoot == null)
                            throw new NotSupportedException("Email used for group invitation is not yet registered to the system");
                        string groupID = containerOwner.LocationPrefix;
                        InviteMemberToGroup.Execute(new InviteMemberToGroupParameters { GroupID = groupID, MemberEmailAddress = emailAddress });
                        break;
                    }

                case "CreateGroupWithTemplates":
                    {
                        var owningAccount = containerOwner as TBAccount;
                        if(owningAccount == null)
                            throw new NotSupportedException("Creating a group is only supported by account");
                        CreateGroupWithTemplatesParameters parameters = new CreateGroupWithTemplatesParameters
                            {
                                AccountID = owningAccount.ID,
                                GroupName = form["GroupName"],
                                RedirectUrlAfterCreation = form["RedirectUrlAfterCreation"],
                                TemplateNameList = form["TemplateNameList"]
                            };
                        CreateGroupWithTemplates.Execute(parameters);
                        break;
                    }
                case "InitiateAccountMergeFromEmail":
                    {
                        var owningAccount = containerOwner as TBAccount;
                        if(owningAccount == null)
                            throw new NotSupportedException("Email address based account merge is only supported for accounts");
                        InitiateAccountMergeFromEmailParameters parameters = new InitiateAccountMergeFromEmailParameters
                            {
                                CurrentAccountID = owningAccount.ID,
                                RedirectUrlAfterValidation = form["RedirectUrlAfterValidation"],
                                EmailAddress = form["EmailAddress"],
                            };
                        InitiateAccountMergeFromEmail.Execute(parameters);
                        break;
                    }

                case "UnregisterEmailAddress":
                    {
                        var owningAccount = containerOwner as TBAccount;
                        if(owningAccount == null)
                            throw new NotSupportedException("Unregistering email address is only supported for accounts");
                        UnregisterEmailAddressParameters parameters = new UnregisterEmailAddressParameters
                            {
                                AccountID = owningAccount.ID,
                                EmailAddress = form["EmailAddress"],
                            };
                        UnregisterEmailAddress.Execute(parameters);
                        break;
                    }
                case "BeginAccountEmailAddressRegistration":
                    {
                        var owningAccount = containerOwner as TBAccount;
                        if(owningAccount == null)
                            throw new NotSupportedException("Email address registration is only supported for accounts");
                        BeginAccountEmailAddressRegistrationParameters parameters = new BeginAccountEmailAddressRegistrationParameters
                            {
                                AccountID = owningAccount.ID,
                                RedirectUrlAfterValidation = form["RedirectUrlAfterValidation"],
                                EmailAddress = form["EmailAddress"],
                            };
                        BeginAccountEmailAddressRegistration.Execute(parameters);
                        break;
                    }
                case "CreateInformationInput":
                    {
                        CreateInformationInputParameters parameters = new CreateInformationInputParameters
                            {
                                InputDescription = form["InputDescription"],
                                LocationURL = form["LocationURL"],
                                LocalContentName = form["LocalContentName"],
                                AuthenticatedDeviceID = form["AuthenticatedDeviceID"],
                                Owner = containerOwner
                            };
                        var createdInformationInput = CreateInformationInput.Execute(parameters);
                        var owningAccount = containerOwner as TBAccount;
                        TBCollaboratingGroup owningGroup = null;
                        if (owningAccount == null)
                        {
                            TBRGroupRoot groupRoot =
                                TBRGroupRoot.RetrieveFromDefaultLocation(containerOwner.LocationPrefix);
                            owningGroup = groupRoot.Group;
                        }
                        CreateAndSendEmailValidationForInformationInputConfirmationParameters emailParameters = new CreateAndSendEmailValidationForInformationInputConfirmationParameters
                            {
                                OwningAccount = owningAccount,
                                OwningGroup = owningGroup,
                                InformationInput = createdInformationInput.InformationInput,
                            };
                        CreateAndSendEmailValidationForInformationInputConfirmation.Execute(emailParameters);
                        break;
                    }
                case "CreateSpecifiedInformationObjectWithValues":
                    {
                        CreateSpecifiedInformationObjectWithValuesParameters parameters = new CreateSpecifiedInformationObjectWithValuesParameters
                            {
                                Owner = containerOwner,
                                ObjectDomainName = form["ObjectDomainName"],
                                ObjectName = form["ObjectName"],
                                HttpFormData = filterForm(form, filterFields),
                                HttpFileData = fileContent,
                            };
                        var result = CreateSpecifiedInformationObjectWithValues.Execute(parameters);
                        return result.CreatedObjectResult;
                    }
                case "DeleteSpecifiedInformationObject":
                    {
                        DeleteSpecifiedInformationObjectParameters parameters = new DeleteSpecifiedInformationObjectParameters
                            {
                                Owner = containerOwner,
                                ObjectDomainName = form["ObjectDomainName"],
                                ObjectName = form["ObjectName"],
                                ObjectID = form["ObjectID"],
                            };
                        DeleteSpecifiedInformationObject.Execute(parameters);
                        break;
                    }
                default:
                    throw new NotSupportedException("Operation not (yet) supported: " + operationName);
            }
            return null;
        }