/// <summary>
 /// The Add Virtual IP operation adds a logical Virtual IP to the
 /// deployment.
 /// </summary>
 /// <param name='operations'>
 /// Reference to the
 /// Microsoft.WindowsAzure.Management.Network.IVirtualIPOperations.
 /// </param>
 /// <param name='serviceName'>
 /// Required. The name of the hosted service that contains the given
 /// deployment.
 /// </param>
 /// <param name='deploymentName'>
 /// Required. The name of the deployment where the logical Virtual IP
 /// is to be added.
 /// </param>
 /// <param name='virtualIPName'>
 /// Required. The name of the logical Virtual IP to be added.
 /// </param>
 /// <returns>
 /// The response body contains the status of the specified asynchronous
 /// operation, indicating whether it has succeeded, is inprogress, or
 /// has failed. Note that this status is distinct from the HTTP status
 /// code returned for the Get Operation Status operation itself. If
 /// the asynchronous operation succeeded, the response body includes
 /// the HTTP status code for the successful request. If the
 /// asynchronous operation failed, the response body includes the HTTP
 /// status code for the failed request, and also includes error
 /// information regarding the failure.
 /// </returns>
 public static Task<OperationStatusResponse> AddAsync(this IVirtualIPOperations operations, string serviceName, string deploymentName, string virtualIPName)
 {
     return operations.AddAsync(serviceName, deploymentName, virtualIPName, CancellationToken.None);
 }
 /// <summary>
 /// A synchronous version of <see cref="INfieldLanguagesService.AddAsync"/>
 /// </summary>
 public static Language Add(this INfieldLanguagesService languagesService, string surveyId, Language language)
 {
     return languagesService.AddAsync(surveyId, language).Result;
 }
 /// <summary>
 /// A synchronous version of <see cref="INfieldInterviewersService.AddAsync"/>
 /// </summary>
 public static Interviewer Add(this INfieldInterviewersService interviewersService, Interviewer interviewer)
 {
     return interviewersService.AddAsync(interviewer).Result;
 }
 /// <summary>
 /// Adds a list of principals to the given collection.
 /// </summary>
 /// <param name='operations'>
 /// Reference to the
 /// Microsoft.WindowsAzure.Management.RemoteApp.IPrincipalOperations.
 /// </param>
 /// <param name='collectionName'>
 /// Required. The RemoteApp collection name.
 /// </param>
 /// <param name='securityPrincipalList'>
 /// Required. A list of RemoteApp principals to add.
 /// </param>
 /// <returns>
 /// The response for the collection user operation.
 /// </returns>
 public static Task<SecurityPrincipalOperationsResult> AddAsync(this IPrincipalOperations operations, string collectionName, SecurityPrincipalList securityPrincipalList)
 {
     return operations.AddAsync(collectionName, securityPrincipalList, CancellationToken.None);
 }
 /// <summary>
 /// Include existing user to existing group.
 /// </summary>
 /// <param name='operations'>
 /// Reference to the
 /// Microsoft.Azure.Management.ApiManagement.IGroupUsersOperations.
 /// </param>
 /// <param name='resourceGroupName'>
 /// Required. The name of the resource group.
 /// </param>
 /// <param name='serviceName'>
 /// Required. The name of the Api Management service.
 /// </param>
 /// <param name='gid'>
 /// Required. Identifier of the group.
 /// </param>
 /// <param name='uid'>
 /// Required. Identifier of the user.
 /// </param>
 /// <returns>
 /// A standard service response including an HTTP status code and
 /// request ID.
 /// </returns>
 public static Task<AzureOperationResponse> AddAsync(this IGroupUsersOperations operations, string resourceGroupName, string serviceName, string gid, string uid)
 {
     return operations.AddAsync(resourceGroupName, serviceName, gid, uid, CancellationToken.None);
 }
 /// <summary>
 /// Adds existing API to the Product.
 /// </summary>
 /// <param name='operations'>
 /// Reference to the
 /// Microsoft.Azure.Management.ApiManagement.IProductApisOperations.
 /// </param>
 /// <param name='resourceGroupName'>
 /// Required. The name of the resource group.
 /// </param>
 /// <param name='serviceName'>
 /// Required. The name of the Api Management service.
 /// </param>
 /// <param name='pid'>
 /// Required. Identifier of the product.
 /// </param>
 /// <param name='aid'>
 /// Required. Identifier of the API.
 /// </param>
 /// <returns>
 /// A standard service response including an HTTP status code and
 /// request ID.
 /// </returns>
 public static Task<AzureOperationResponse> AddAsync(this IProductApisOperations operations, string resourceGroupName, string serviceName, string pid, string aid)
 {
     return operations.AddAsync(resourceGroupName, serviceName, pid, aid, CancellationToken.None);
 }
 /// <summary>
 /// Create new Protection Policy.
 /// </summary>
 /// <param name='operations'>
 /// Reference to the
 /// Microsoft.Azure.Management.BackupServices.ICSMProtectionPolicyOperations.
 /// </param>
 /// <param name='resourceGroupName'>
 /// Required.
 /// </param>
 /// <param name='resourceName'>
 /// Required.
 /// </param>
 /// <param name='policyName'>
 /// Required. The protection policy Name to be updated.
 /// </param>
 /// <param name='cSMAddProtectionPolicyRequest'>
 /// Required. The protection policy creation request.
 /// </param>
 /// <param name='customRequestHeaders'>
 /// Optional. Request header parameters.
 /// </param>
 /// <returns>
 /// A standard service response including an HTTP status code and
 /// request ID.
 /// </returns>
 public static Task<AzureOperationResponse> AddAsync(this ICSMProtectionPolicyOperations operations, string resourceGroupName, string resourceName, string policyName, CSMAddProtectionPolicyRequest cSMAddProtectionPolicyRequest, CustomRequestHeaders customRequestHeaders)
 {
     return operations.AddAsync(resourceGroupName, resourceName, policyName, cSMAddProtectionPolicyRequest, customRequestHeaders, CancellationToken.None);
 }
        private static void PopulateAssetPairsRepository(this IAssetPairsRepository assetsRepository)
        {
            assetsRepository.AddAsync(new AssetPair
            {
                Id = "AUDNZD",
                BaseAssetId = "AUD",
                QuotingAssetId = "NZD",
                Accuracy = 5
            });




            assetsRepository.AddAsync(new AssetPair
            {
                Id = "AUDCAD",
                BaseAssetId = "AUD",
                QuotingAssetId = "CAD",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "AUDCHF",
                BaseAssetId = "AUD",
                QuotingAssetId = "CHF",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "AUDJPY",
                BaseAssetId = "AUD",
                QuotingAssetId = "JPY",
                Accuracy = 3
            });


            assetsRepository.AddAsync(new AssetPair
            {
                Id = "AUDUSD",
                BaseAssetId = "AUD",
                QuotingAssetId = "USD",
                Accuracy = 5
            });


            assetsRepository.AddAsync(new AssetPair
            {
                Id = "CADCHF",
                BaseAssetId = "CAD",
                QuotingAssetId = "CHF",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "CADJPY",
                BaseAssetId = "CAD",
                QuotingAssetId = "JPY",
                Accuracy = 3
            });


            assetsRepository.AddAsync(new AssetPair
            {
                Id = "CHFJPY",
                BaseAssetId = "CHF",
                QuotingAssetId = "JPY",
                Accuracy = 3
            });


            assetsRepository.AddAsync(new AssetPair
            {
                Id = "EURAUD",
                BaseAssetId = "EUR",
                QuotingAssetId = "AUD",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "EURCAD",
                BaseAssetId = "EUR",
                QuotingAssetId = "CAD",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "EURCHF",
                BaseAssetId = "EUR",
                QuotingAssetId = "CHF",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "EURGBP",
                BaseAssetId = "EUR",
                QuotingAssetId = "GBP",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "EURJPY",
                BaseAssetId = "EUR",
                QuotingAssetId = "JPY",
                Accuracy = 3
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "EURNZD",
                BaseAssetId = "EUR",
                QuotingAssetId = "NZD",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "EURUSD",
                BaseAssetId = "EUR",
                QuotingAssetId = "USD",
                Accuracy = 5
            });


            assetsRepository.AddAsync(new AssetPair
            {
                Id = "GBPAUD",
                BaseAssetId = "GBP",
                QuotingAssetId = "AUD",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "GBPCAD",
                BaseAssetId = "GBP",
                QuotingAssetId = "CAD",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "GBPCHF",
                BaseAssetId = "GBP",
                QuotingAssetId = "CHF",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "GBPJPY",
                BaseAssetId = "GBP",
                QuotingAssetId = "JPY",
                Accuracy = 3
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "GBPNZD",
                BaseAssetId = "GBP",
                QuotingAssetId = "NZD",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "GBPUSD",
                BaseAssetId = "GBP",
                QuotingAssetId = "USD",
                Accuracy = 5
            });


            assetsRepository.AddAsync(new AssetPair
            {
                Id = "NZDCAD",
                BaseAssetId = "NZD",
                QuotingAssetId = "CAD",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "NZDCHF",
                BaseAssetId = "NZD",
                QuotingAssetId = "CHF",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "NZDJPY",
                BaseAssetId = "NZD",
                QuotingAssetId = "JPY",
                Accuracy = 3
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "NZDUSD",
                BaseAssetId = "NZD",
                QuotingAssetId = "USD",
                Accuracy = 5
            });


            assetsRepository.AddAsync(new AssetPair
            {
                Id = "USDCAD",
                BaseAssetId = "USD",
                QuotingAssetId = "CAD",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "USDCHF",
                BaseAssetId = "USD",
                QuotingAssetId = "CHF",
                Accuracy = 5
            });

            assetsRepository.AddAsync(new AssetPair
            {
                Id = "USDJPY",
                BaseAssetId = "USD",
                QuotingAssetId = "JPY",
                Accuracy = 3
            });

        }
 public static Task UserIdAddAsync(this IConnectionMapping map, string userId, string connectionId)
 {
     return map.AddAsync(UserIdPrefix + userId, connectionId);
 }
 public static Task GroupAddAsync(this IConnectionMapping map, string group, string connectionId)
 {
     return map.AddAsync(GroupPrefix + group, connectionId);
 }
 /// <summary>
 /// A synchronous version of <see cref="INfieldLanguagesService.AddAsync"/>
 /// </summary>
 public static Translation Add(this INfieldTranslationsService translationsService, string surveyId, int languageId, Translation translation)
 {
     return translationsService.AddAsync(surveyId, languageId, translation).Result;
 }