text:
namespace Microsoft.Azure.Management.VideoAnalyzer
{
    using Microsoft.Rest;
    using Microsoft.Rest.Azure;
    using Models;
    using Newtonsoft.Json;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;
    using System.Net;
    using System.Net.Http;
    using System.Threading;
    using System.Threading.Tasks;

    /// <summary>
    /// PipelineTopologiesOperations operations.
    /// </summary>
    internal partial class PipelineTopologiesOperations : IServiceOperations<VideoAnalyzerClient>, IPipelineTopologiesOperations
    {
        /// <summary>
        /// Initializes a new instance of the PipelineTopologiesOperations class.
        /// </summary>
        /// <param name='client'>
        /// Reference to the service client.
        /// </param>
        /// <exception cref="System.ArgumentNullException">
        /// Thrown when a required parameter is null
        /// </exception>
        internal PipelineTopologiesOperations(VideoAnalyzerClient client)
        {
            if (client == null)
            {
                throw new System.ArgumentNullException("client");
            }
            Client = client;
        }

        /// <summary>
        /// Gets a reference to the VideoAnalyzerClient
        /// </summary>
        public VideoAnalyzerClient Client { get; private set; }

        /// <summary>
        /// Retrieves a list of pipeline topologies.
        /// </summary>
        /// <remarks>
        /// Retrieves a list of pipeline topologies that have been added to the
        /// account, if any, along with their JSON representation.
        /// </remarks>
        /// <param name='resourceGroupName'>
        /// The name of the resource group. The name is case insensitive.
        /// </param>
        /// <param name='accountName'>
        /// The Azure Video Analyzer account name.
        /// </param>
        /// <param name='filter'>
        /// Restricts the set of items returned.
        /// </param>
        /// <param name='top'>
        /// Specifies a non-negative integer n that limits the number of items returned
        /// from a collection. The service returns the number of available items up to
        /// but not greater than the specified value n.
        /// </param>
        /// <param name='customHeaders'>
        /// Headers that will be added to request.
        /// </param>
        /// <param name='cancellationToken'>
        /// The cancellation token.
        /// </param>
        /// <exception cref="ErrorResponseException">
        /// Thrown when the operation returned an invalid status code
        /// </exception>
        /// <exception cref="SerializationException">
        /// Thrown when unable to deserialize the response
        /// </exception>
        /// <exception cref="ValidationException">
        /// Thrown when a required parameter is null
        /// </exception>
        /// <exception cref="System.ArgumentNullException">
        /// Thrown when a required parameter is null
        /// </exception>
        /// <return>
        /// A response object containing the response body and response headers.
        /// </return>
        public async Task<AzureOperationResponse<IPage<PipelineTopology>>> ListWithHttpMessagesAsync(string resourceGroupName, string accountName, string filter = default(string), int? top = default(int?), Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (Client.SubscriptionId == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId");
            }
            if (Client.SubscriptionId != null)
            {
                if (Client.SubscriptionId.Length < 1)
                {
                    throw new ValidationException(ValidationRules.MinLength, "Client.SubscriptionId", 1);
                }
            }
            if (resourceGroupName == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "resourceGroupName");
            }
            if (resourceGroupName != null)
            {
                if (resourceGroupName.Length > 90)
                {
                    throw new ValidationException(ValidationRules.MaxLength, "resourceGroupName", 90);
                }
                if (resourceGroupName.Length < 1)
                {
                    throw new ValidationException(ValidationRules.MinLength, "resourceGroupName", 1);
                }
            }
            if (accountName == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "accountName");
            }
            if (Client.ApiVersion == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.ApiVersion");
            }
            if (Client.ApiVersion != null)
            {
                if (Client.ApiVersion.Length < 1)
                {
                    throw new ValidationException(ValidationRules.MinLength, "Client.ApiVersion", 1);
                }
            }
            // Tracing
            bool _shouldTrace = ServiceClientTracing.IsEnabled;
            string _invocationId = null;
            if (_shouldTrace)
            {
                _invocationId = ServiceClientTracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("resourceGroupName", resourceGroupName);
                tracingParameters.Add("accountName", accountName);
                tracingParameters.Add("filter", filter);
                tracingParameters.Add("top", top);
                tracingParameters.Add("cancellationToken", cancellationToken);
                ServiceClientTracing.Enter(_invocationId, this, "List", tracingParameters);
            }
            // Construct URL
            var _baseUrl = Client.BaseUri.AbsoluteUri;
            var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/videoAnalyzers/{accountName}/pipelineTopologies").ToString();
            _url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(Client.SubscriptionId));
            _url = _url.Replace("{resourceGroupName}", System.Uri.EscapeDataString(resourceGroupName));
            _url = _url.Replace("{accountName}", System.Uri.EscapeDataString(accountName));
            List<string> _queryParameters = new List<string>();
            if (Client.ApiVersion != null)
            {
                _queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(Client.ApiVersion)));
            }
            if (filter != null)
            {
                _queryParameters.Add(string.Format("$filter={0}", System.Uri.EscapeDataString(filter)));
            }
            if (top != null)
            {
                _queryParameters.Add(string.Format("$top={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeObject(top, Client.SerializationSettings).Trim('"'))));
            }
            if (_queryParameters.Count > 0)
            {
                _url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
            }
            // Create HTTP transport objects
            var _httpRequest = new HttpRequestMessage();
            HttpResponseMessage _httpResponse = null;
            _httpRequest.Method = new HttpMethod("GET");
            _httpRequest.RequestUri = new System.Uri(_url);
            // Set Headers
            if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value)
            {
                _httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
            }
            if (Client.AcceptLanguage != null)
            {
                if (_httpRequest.Headers.Contains("accept-language"))
                {
                    _httpRequest.Headers.Remove("accept-language");
                }
                _httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage);
            }

            if (customHeaders != null)
            {
                foreach(var _header in customHeaders)
                {
                    if (_httpRequest.Headers.Contains(_header.Key))
                    {
                        _httpRequest.Headers.Remove(_header.Key);
                    }
                    _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
                }
            }

            // Serialize Request
            string _requestContent = null;
            // Set Credentials
            if (Client.Credentials != null)
            {
                cancellationToken.ThrowIfCancellationRequested();
                await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
            }
            // Send Request
            if (_shouldTrace)
            {
                ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
            }
            cancellationToken.ThrowIfCancellationRequested();
            _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
            if (_shouldTrace)
            {
                ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
            }
            HttpStatusCode _statusCode = _httpResponse.StatusCode;
            cancellationToken.ThrowIfCancellationRequested();
            string _responseContent = null;
            if ((int)_statusCode != 200)
            {
                var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
                try
                {
                    _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                    ErrorResponse _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<ErrorResponse>(_responseContent, Client.DeserializationSettings);
                    if (_errorBody != null)
                    {
                        ex.Body = _errorBody;
                    }
                }
                catch (JsonException)
                {
                    // Ignore the exception
                }
                ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
                ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
                if (_shouldTrace)
                {
                    ServiceClientTracing.Error(_invocationId, ex);
                }
                _httpRequest.Dispose();
                if (_httpResponse != null)
                {
                    _httpResponse.Dispose();
                }
                throw ex;
            }
            // Create Result
            var _result = new AzureOperationResponse<IPage<PipelineTopology>>();
            _result.Request = _httpRequest;
            _result.Response = _httpResponse;
            if (_httpResponse.Headers.Contains("x-ms-request-id"))
            {
                _result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
            }
            // Deserialize Response
            if ((int)_statusCode == 200)
            {
                _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                try
                {
                    _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<Page<PipelineTopology>>(_responseContent, Client.DeserializationSettings);
                }
                catch (JsonException ex)
                {
                    _httpRequest.Dispose();
                    if (_httpResponse != null)
                    {
                        _httpResponse.Dispose();
                    }
                    throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
                }
            }
            if (_shouldTrace)
            {
                ServiceClientTracing.Exit(_invocationId, _result);
            }
            return _result;
        }

        /// <summary>
        /// Retrieves a specific pipeline topology by name.
        /// </summary>
        /// <remarks>
        /// Retrieves a specific pipeline topology by name. If a topology with that
        /// name has been previously created, the call will return the JSON
        /// representation of that topology.
        /// </remarks>
        /// <param name='resourceGroupName'>
        /// The name of the resource group. The name is case insensitive.
        /// </param>
        /// <param name='accountName'>
        /// The Azure Video Analyzer account name.
        /// </param>
        /// <param name='pipelineTopologyName'>
        /// Pipeline topology unique identifier.
        /// </param>
        /// <param name='customHeaders'>
        /// Headers that will be added to request.
        /// </param>
        /// <param name='cancellationToken'>
        /// The cancellation token.
        /// </param>
        /// <exception cref="ErrorResponseException">
        /// Thrown when the operation returned an invalid status code
        /// </exception>
        /// <exception cref="SerializationException">
        /// Thrown when unable to deserialize the response
        /// </exception>
        /// <exception cref="ValidationException">
        /// Thrown when a required parameter is null
        /// </exception>
        /// <exception cref="System.ArgumentNullException">
        /// Thrown when a required parameter is null
        /// </exception>
        /// <return>
        /// A response object containing the response body and response headers.
        /// </return>
        public async Task<AzureOperationResponse<PipelineTopology>> GetWithHttpMessagesAsync(string resourceGroupName, string accountName, string pipelineTopologyName, Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (Client.SubscriptionId == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId");
            }
            if (Client.SubscriptionId != null)
            {
                if (Client.SubscriptionId.Length < 1)
                {
                    throw new ValidationException(ValidationRules.MinLength, "Client.SubscriptionId", 1);
                }
            }
            if (resourceGroupName == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "resourceGroupName");
            }
            if (resourceGroupName != null)
            {
                if (resourceGroupName.Length > 90)
                {
                    throw new ValidationException(ValidationRules.MaxLength, "resourceGroupName", 90);
                }
                if (resourceGroupName.Length < 1)
                {
                    throw new ValidationException(ValidationRules.MinLength, "resourceGroupName", 1);
                }
            }
            if (accountName == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "accountName");
            }
            if (pipelineTopologyName == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "pipelineTopologyName");
            }
            if (Client.ApiVersion == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.ApiVersion");
            }
            if (Client.ApiVersion != null)
            {
                if (Client.ApiVersion.Length < 1)
                {
                    throw new ValidationException(ValidationRules.MinLength, "Client.ApiVersion", 1);
                }
            }
            // Tracing
            bool _shouldTrace = ServiceClientTracing.IsEnabled;
            string _invocationId = null;
            if (_shouldTrace)
            {
                _invocationId = ServiceClientTracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("resourceGroupName", resourceGroupName);
                tracingParameters.Add("accountName", accountName);
                tracingParameters.Add("pipelineTopologyName", pipelineTopologyName);
                tracingParameters.Add("cancellationToken", cancellationToken);
                ServiceClientTracing.Enter(_invocationId, this, "Get", tracingParameters);
            }
            // Construct URL
            var _baseUrl = Client.BaseUri.AbsoluteUri;
            var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/videoAnalyzers/{accountName}/pipelineTopologies/{pipelineTopologyName}").ToString();
            _url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(Client.SubscriptionId));
            _url = _url.Replace("{resourceGroupName}", System.Uri.EscapeDataString(resourceGroupName));
            _url = _url.Replace("{accountName}", System.Uri.EscapeDataString(accountName));
            _url = _url.Replace("{pipelineTopologyName}", System.Uri.EscapeDataString(pipelineTopologyName));
            List<string> _queryParameters = new List<string>();
            if (Client.ApiVersion != null)
            {
                _queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(Client.ApiVersion)));
            }
            if (_queryParameters.Count > 0)
            {
                _url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
            }
            // Create HTTP transport objects
            var _httpRequest = new HttpRequestMessage();
            HttpResponseMessage _httpResponse = null;
            _httpRequest.Method = new HttpMethod("GET");
            _httpRequest.RequestUri = new System.Uri(_url);
            // Set Headers
            if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value)
            {
                _httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
            }
            if (Client.AcceptLanguage != null)
            {
                if (_httpRequest.Headers.Contains("accept-language"))
                {
                    _httpRequest.Headers.Remove("accept-language");
                }
                _httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage);
            }

            if (customHeaders != null)
            {
                foreach(var _header in customHeaders)
                {
                    if (_httpRequest.Headers.Contains(_header.Key))
                    {
                        _httpRequest.Headers.Remove(_header.Key);
                    }
                    _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
                }
            }

            // Serialize Request
            string _requestContent = null;
            // Set Credentials
            if (Client.Credentials != null)
            {
                cancellationToken.ThrowIfCancellationRequested();
                await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
            }
            // Send Request
            if (_shouldTrace)
            {
                ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
            }
            cancellationToken.ThrowIfCancellationRequested();
            _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
            if (_shouldTrace)
            {
                ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
            }
            HttpStatusCode _statusCode = _httpResponse.StatusCode;
            cancellationToken.ThrowIfCancellationRequested();
            string _responseContent = null;
            if ((int)_statusCode != 200)
            {
                var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
                try
                {
                    _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                    ErrorResponse _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<ErrorResponse>(_responseContent, Client.DeserializationSettings);
                    if (_errorBody != null)
                    {
                        ex.Body = _errorBody;
                    }
                }
                catch (JsonException)
                {
                    // Ignore the exception
                }
                ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
                ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
                if (_shouldTrace)
                {
                    ServiceClientTracing.Error(_invocationId, ex);
                }
                _httpRequest.Dispose();
                if (_httpResponse != null)
                {
                    _httpResponse.Dispose();
                }
                throw ex;
            }
            // Create Result
            var _result = new AzureOperationResponse<PipelineTopology>();
            _result.Request = _httpRequest;
            _result.Response = _httpResponse;
            if (_httpResponse.Headers.Contains("x-ms-request-id"))
            {
                _result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
            }
            // Deserialize Response
            if ((int)_statusCode == 200)
            {
                _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                try
                {
                    _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<PipelineTopology>(_responseContent, Client.DeserializationSettings);
                }
                catch (JsonException ex)
                {
                    _httpRequest.Dispose();
                    if (_httpResponse != null)
                    {
                        _httpResponse.Dispose();
                    }
                    throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
                }
            }
            if (_shouldTrace)
            {
                ServiceClientTracing.Exit(_invocationId, _result);
            }
            return _result;
        }

        /// <summary>
        /// Creates or updates a pipeline topology.
        /// </summary>
        /// <remarks>
        /// Creates a new pipeline topology or updates an existing one, with the given
        /// name. A pipeline topology describes the processing steps to be applied when
        /// processing content for a particular outcome. The topology should be defined
        /// according to the scenario to be achieved and can be reused across many
        /// pipeline instances which share the same processing characteristics.
        /// </remarks>
        /// <param name='resourceGroupName'>
        /// The name of the resource group. The name is case insensitive.
        /// </param>
        /// <param name='accountName'>
        /// The Azure Video Analyzer account name.
        /// </param>
        /// <param name='pipelineTopologyName'>
        /// Pipeline topology unique identifier.
        /// </param>
        /// <param name='parameters'>
        /// The request parameters
        /// </param>
        /// <param name='customHeaders'>
        /// Headers that will be added to request.
        /// </param>
        /// <param name='cancellationToken'>
        /// The cancellation token.
        /// </param>
        /// <exception cref="ErrorResponseException">
        /// Thrown when the operation returned an invalid status code
        /// </exception>
        /// <exception cref="SerializationException">
        /// Thrown when unable to deserialize the response
        /// </exception>
        /// <exception cref="ValidationException">
        /// Thrown when a required parameter is null
        /// </exception>
        /// <exception cref="System.ArgumentNullException">
        /// Thrown when a required parameter is null
        /// </exception>
        /// <return>
        /// A response object containing the response body and response headers.
        /// </return>
        public async Task<AzureOperationResponse<PipelineTopology>> CreateOrUpdateWithHttpMessagesAsync(string resourceGroupName, string accountName, string pipelineTopologyName, PipelineTopology parameters, Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (Client.SubscriptionId == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId");
            }
            if (Client.SubscriptionId != null)
            {
                if (Client.SubscriptionId.Length < 1)
                {
                    throw new ValidationException(ValidationRules.MinLength, "Client.SubscriptionId", 1);
                }
            }
            if (resourceGroupName == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "resourceGroupName");
            }
            if (resourceGroupName != null)
            {
                if (resourceGroupName.Length > 90)
                {
                    throw new ValidationException(ValidationRules.MaxLength, "resourceGroupName", 90);
                }
                if (resourceGroupName.Length < 1)
                {
                    throw new ValidationException(ValidationRules.MinLength, "resourceGroupName", 1);
                }
            }
            if (accountName == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "accountName");
            }
            if (pipelineTopologyName == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "pipelineTopologyName");
            }
            if (parameters == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "parameters");
            }
            if (parameters != null)
            {
                parameters.Validate();
            }
            if (Client.ApiVersion == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.ApiVersion");
            }
            if (Client.ApiVersion != null)
            {
                if (Client.ApiVersion.Length < 1)
                {
                    throw new ValidationException(ValidationRules.MinLength, "Client.ApiVersion", 1);
                }
            }
            // Tracing
            bool _shouldTrace = ServiceClientTracing.IsEnabled;
            string _invocationId = null;
            if (_shouldTrace)
            {
                _invocationId = ServiceClientTracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("resourceGroupName", resourceGroupName);
                tracingParameters.Add("accountName", accountName);
                tracingParameters.Add("pipelineTopologyName", pipelineTopologyName);
                tracingParameters.Add("parameters", parameters);
                tracingParameters.Add("cancellationToken", cancellationToken);
                ServiceClientTracing.Enter(_invocationId, this, "CreateOrUpdate", tracingParameters);
            }
            // Construct URL
            var _baseUrl = Client.BaseUri.AbsoluteUri;
            var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/videoAnalyzers/{accountName}/pipelineTopologies/{pipelineTopologyName}").ToString();
            _url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(Client.SubscriptionId));
            _url = _url.Replace("{resourceGroupName}", System.Uri.EscapeDataString(resourceGroupName));
            _url = _url.Replace("{accountName}", System.Uri.EscapeDataString(accountName));
            _url = _url.Replace("{pipelineTopologyName}", System.Uri.EscapeDataString(pipelineTopologyName));
            List<string> _queryParameters = new List<string>();
            if (Client.ApiVersion != null)
            {
                _queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(Client.ApiVersion)));
            }
            if (_queryParameters.Count > 0)
            {
                _url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
            }
            // Create HTTP transport objects
            var _httpRequest = new HttpRequestMessage();
            HttpResponseMessage _httpResponse = null;
            _httpRequest.Method = new HttpMethod("PUT");
            _httpRequest.RequestUri = new System.Uri(_url);
            // Set Headers
            if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value)
            {
                _httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
            }
            if (Client.AcceptLanguage != null)
            {
                if (_httpRequest.Headers.Contains("accept-language"))
                {
                    _httpRequest.Headers.Remove("accept-language");
                }
                _httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage);
            }

            if (customHeaders != null)
            {
                foreach(var _header in customHeaders)
                {
                    if (_httpRequest.Headers.Contains(_header.Key))
                    {
                        _httpRequest.Headers.Remove(_header.Key);
                    }
                    _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
                }
            }

            // Serialize Request
            string _requestContent = null;
            if(parameters != null)
            {
                _requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(parameters, Client.SerializationSettings);
                _httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
                _httpRequest.Content.Headers.ContentType =System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
            }
            // Set Credentials
            if (Client.Credentials != null)
            {
                cancellationToken.ThrowIfCancellationRequested();
                await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
            }
            // Send Request
            if (_shouldTrace)
            {
                ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
            }
            cancellationToken.ThrowIfCancellationRequested();
            _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
            if (_shouldTrace)
            {
                ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
            }
            HttpStatusCode _statusCode = _httpResponse.StatusCode;
            cancellationToken.ThrowIfCancellationRequested();
            string _responseContent = null;
            if ((int)_statusCode != 200 && (int)_statusCode != 201)
            {
                var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
                try
                {
                    _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                    ErrorResponse _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<ErrorResponse>(_responseContent, Client.DeserializationSettings);
                    if (_errorBody != null)
                    {
                        ex.Body = _errorBody;
                    }
                }
                catch (JsonException)
                {
                    // Ignore the exception
                }
                ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
                ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
                if (_shouldTrace)
                {
                    ServiceClientTracing.Error(_invocationId, ex);
                }
                _httpRequest.Dispose();
                if (_httpResponse != null)
                {
                    _httpResponse.Dispose();
                }
                throw ex;
            }
            // Create Result
            var _result = new AzureOperationResponse<PipelineTopology>();
            _result.Request = _httpRequest;
            _result.Response = _httpResponse;
            if (_httpResponse.Headers.Contains("x-ms-request-id"))
            {
                _result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
            }
            // Deserialize Response
            if ((int)_statusCode == 200)
            {
                _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                try
                {
                    _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<PipelineTopology>(_responseContent, Client.DeserializationSettings);
                }
                catch (JsonException ex)
                {
                    _httpRequest.Dispose();
                    if (_httpResponse != null)
                    {
                        _httpResponse.Dispose();
                    }
                    throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
                }
            }
            // Deserialize Response
            if ((int)_statusCode == 201)
            {
                _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                try
                {
                    _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<PipelineTopology>(_responseContent, Client.DeserializationSettings);
                }
                catch (JsonException ex)
                {
                    _httpRequest.Dispose();
                    if (_httpResponse != null)
                    {
                        _httpResponse.Dispose();
                    }
                    throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
                }
            }
            if (_shouldTrace)
            {
                ServiceClientTracing.Exit(_invocationId, _result);
            }
            return _result;
        }

        /// <summary>
        /// Deletes a pipeline topology.
        /// </summary>
        /// <remarks>
        /// Deletes a pipeline topology with the given name. This method should be
        /// called after all instances of the topology have been stopped and deleted.
        /// </remarks>
        /// <param name='resourceGroupName'>
        /// The name of the resource group. The name is case insensitive.
        /// </param>
        /// <param name='accountName'>
        /// The Azure Video Analyzer account name.
        /// </param>
        /// <param name='pipelineTopologyName'>
        /// Pipeline topology unique identifier.
        /// </param>
        /// <param name='customHeaders'>
        /// Headers that will be added to request.
        /// </param>
        /// <param name='cancellationToken'>
        /// The cancellation token.
        /// </param>
        /// <exception cref="ErrorResponseException">
        /// Thrown when the operation returned an invalid status code
        /// </exception>
        /// <exception cref="ValidationException">
        /// Thrown when a required parameter is null
        /// </exception>
        /// <exception cref="System.ArgumentNullException">
        /// Thrown when a required parameter is null
        /// </exception>
        /// <return>
        /// A response object containing the response body and response headers.
        /// </return>
        public async Task<AzureOperationResponse> DeleteWithHttpMessagesAsync(string resourceGroupName, string accountName, string pipelineTopologyName, Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (Client.SubscriptionId == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId");
            }
            if (Client.SubscriptionId != null)
            {
                if (Client.SubscriptionId.Length < 1)
                {
                    throw new ValidationException(ValidationRules.MinLength, "Client.SubscriptionId", 1);
                }
            }
            if (resourceGroupName == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "resourceGroupName");
            }
            if (resourceGroupName != null)
            {
                if (resourceGroupName.Length > 90)
                {
                    throw new ValidationException(ValidationRules.MaxLength, "resourceGroupName", 90);
                }
                if (resourceGroupName.Length < 1)
                {
                    throw new ValidationException(ValidationRules.MinLength, "resourceGroupName", 1);
                }
            }
            if (accountName == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "accountName");
            }
            if (pipelineTopologyName == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "pipelineTopologyName");
            }
            if (Client.ApiVersion == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.ApiVersion");
            }
            if (Client.ApiVersion != null)
            {
                if (Client.ApiVersion.Length < 1)
                {
                    throw new ValidationException(ValidationRules.MinLength, "Client.ApiVersion", 1);
                }
            }
            // Tracing
            bool _shouldTrace = ServiceClientTracing.IsEnabled;
            string _invocationId = null;
            if (_shouldTrace)
            {
                _invocationId = ServiceClientTracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("resourceGroupName", resourceGroupName);
                tracingParameters.Add("accountName", accountName);
                tracingParameters.Add("pipelineTopologyName", pipelineTopologyName);
                tracingParameters.Add("cancellationToken", cancellationToken);
                ServiceClientTracing.Enter(_invocationId, this, "Delete", tracingParameters);
            }
            // Construct URL
            var _baseUrl = Client.BaseUri.AbsoluteUri;
            var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/videoAnalyzers/{accountName}/pipelineTopologies/{pipelineTopologyName}").ToString();
            _url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(Client.SubscriptionId));
            _url = _url.Replace("{resourceGroupName}", System.Uri.EscapeDataString(resourceGroupName));
            _url = _url.Replace("{accountName}", System.Uri.EscapeDataString(accountName));
            _url = _url.Replace("{pipelineTopologyName}", System.Uri.EscapeDataString(pipelineTopologyName));
            List<string> _queryParameters = new List<string>();
            if (Client.ApiVersion != null)
            {
                _queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(Client.ApiVersion)));
            }
            if (_queryParameters.Count > 0)
            {
                _url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
            }
            // Create HTTP transport objects
            var _httpRequest = new HttpRequestMessage();
            HttpResponseMessage _httpResponse = null;
            _httpRequest.Method = new HttpMethod("DELETE");
            _httpRequest.RequestUri = new System.Uri(_url);
            // Set Headers
            if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value)
            {
                _httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
            }
            if (Client.AcceptLanguage != null)
            {
                if (_httpRequest.Headers.Contains("accept-language"))
                {
                    _httpRequest.Headers.Remove("accept-language");
                }
                _httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage);
            }

            if (customHeaders != null)
            {
                foreach(var _header in customHeaders)
                {
                    if (_httpRequest.Headers.Contains(_header.Key))
                    {
                        _httpRequest.Headers.Remove(_header.Key);
                    }
                    _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
                }
            }

            // Serialize Request
            string _requestContent = null;
            // Set Credentials
            if (Client.Credentials != null)
            {
                cancellationToken.ThrowIfCancellationRequested();
                await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
            }
            // Send Request
            if (_shouldTrace)
            {
                ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
            }
            cancellationToken.ThrowIfCancellationRequested();
            _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
            if (_shouldTrace)
            {
                ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
            }
            HttpStatusCode _statusCode = _httpResponse.StatusCode;
            cancellationToken.ThrowIfCancellationRequested();
            string _responseContent = null;
            if ((int)_statusCode != 200 && (int)_statusCode != 204)
            {
                var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
                try
                {
                    _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                    ErrorResponse _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<ErrorResponse>(_responseContent, Client.DeserializationSettings);
                    if (_errorBody != null)
                    {
                        ex.Body = _errorBody;
                    }
                }
                catch (JsonException)
                {
                    // Ignore the exception
                }
                ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
                ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
                if (_shouldTrace)
                {
                    ServiceClientTracing.Error(_invocationId, ex);
                }
                _httpRequest.Dispose();
                if (_httpResponse != null)
                {
                    _httpResponse.Dispose();
                }
                throw ex;
            }
            // Create Result
            var _result = new AzureOperationResponse();
            _result.Request = _httpRequest;
            _result.Response = _httpResponse;
            if (_httpResponse.Headers.Contains("x-ms-request-id"))
            {
                _result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
            }
            if (_shouldTrace)
            {
                ServiceClientTracing.Exit(_invocationId, _result);
            }
            return _result;
        }

        /// <summary>
        /// Updates an existing pipeline topology.
        /// </summary>
        /// <remarks>
        /// Updates an existing pipeline topology with the given name. If the
        /// associated live pipelines or pipeline jobs are in active or processing
        /// state, respectively, then only the description can be updated. Else, the
        /// properties that can be updated include: description, parameter
        /// declarations, sources, processors, and sinks.
        /// </remarks>
        /// <param name='resourceGroupName'>
        /// The name of the resource group. The name is case insensitive.
        /// </param>
        /// <param name='accountName'>
        /// The Azure Video Analyzer account name.
        /// </param>
        /// <param name='pipelineTopologyName'>
        /// Pipeline topology unique identifier.
        /// </param>
        /// <param name='parameters'>
        /// The request parameters
        /// </param>
        /// <param name='customHeaders'>
        /// Headers that will be added to request.
        /// </param>
        /// <param name='cancellationToken'>
        /// The cancellation token.
        /// </param>
        /// <exception cref="ErrorResponseException">
        /// Thrown when the operation returned an invalid status code
        /// </exception>
        /// <exception cref="SerializationException">
        /// Thrown when unable to deserialize the response
        /// </exception>
        /// <exception cref="ValidationException">
        /// Thrown when a required parameter is null
        /// </exception>
        /// <exception cref="System.ArgumentNullException">
        /// Thrown when a required parameter is null
        /// </exception>
        /// <return>
        /// A response object containing the response body and response headers.
        /// </return>
        public async Task<AzureOperationResponse<PipelineTopology>> UpdateWithHttpMessagesAsync(string resourceGroupName, string accountName, string pipelineTopologyName, PipelineTopologyUpdate parameters, Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (Client.SubscriptionId == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId");
            }
            if (Client.SubscriptionId != null)
            {
                if (Client.SubscriptionId.Length < 1)
                {
                    throw new ValidationException(ValidationRules.MinLength, "Client.SubscriptionId", 1);
                }
            }
            if (resourceGroupName == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "resourceGroupName");
            }
            if (resourceGroupName != null)
            {
                if (resourceGroupName.Length > 90)
                {
                    throw new ValidationException(ValidationRules.MaxLength, "resourceGroupName", 90);
                }
                if (resourceGroupName.Length < 1)
                {
                    throw new ValidationException(ValidationRules.MinLength, "resourceGroupName", 1);
                }
            }
            if (accountName == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "accountName");
            }
            if (pipelineTopologyName == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "pipelineTopologyName");
            }
            if (parameters == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "parameters");
            }
            if (Client.ApiVersion == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.ApiVersion");
            }
            if (Client.ApiVersion != null)
            {
                if (Client.ApiVersion.Length < 1)
                {
                    throw new ValidationException(ValidationRules.MinLength, "Client.ApiVersion", 1);
                }
            }
            // Tracing
            bool _shouldTrace = ServiceClientTracing.IsEnabled;
            string _invocationId = null;
            if (_shouldTrace)
            {
                _invocationId = ServiceClientTracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("resourceGroupName", resourceGroupName);
                tracingParameters.Add("accountName", accountName);
                tracingParameters.Add("pipelineTopologyName", pipelineTopologyName);
                tracingParameters.Add("parameters", parameters);
                tracingParameters.Add("cancellationToken", cancellationToken);
                ServiceClientTracing.Enter(_invocationId, this, "Update", tracingParameters);
            }
            // Construct URL
            var _baseUrl = Client.BaseUri.AbsoluteUri;
            var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/videoAnalyzers/{accountName}/pipelineTopologies/{pipelineTopologyName}").ToString();
            _url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(Client.SubscriptionId));
            _url = _url.Replace("{resourceGroupName}", System.Uri.EscapeDataString(resourceGroupName));
            _url = _url.Replace("{accountName}", System.Uri.EscapeDataString(accountName));
            _url = _url.Replace("{pipelineTopologyName}", System.Uri.EscapeDataString(pipelineTopologyName));
            List<string> _queryParameters = new List<string>();
            if (Client.ApiVersion != null)
            {
                _queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(Client.ApiVersion)));
            }
            if (_queryParameters.Count > 0)
            {
                _url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
            }
            // Create HTTP transport objects
            var _httpRequest = new HttpRequestMessage();
            HttpResponseMessage _httpResponse = null;
            _httpRequest.Method = new HttpMethod("PATCH");
            _httpRequest.RequestUri = new System.Uri(_url);
            // Set Headers
            if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value)
            {
                _httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
            }
            if (Client.AcceptLanguage != null)
            {
                if (_httpRequest.Headers.Contains("accept-language"))
                {
                    _httpRequest.Headers.Remove("accept-language");
                }
                _httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage);
            }

            if (customHeaders != null)
            {
                foreach(var _header in customHeaders)
                {
                    if (_httpRequest.Headers.Contains(_header.Key))
                    {
                        _httpRequest.Headers.Remove(_header.Key);
                    }
                    _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
                }
            }

            // Serialize Request
            string _requestContent = null;
            if(parameters != null)
            {
                _requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(parameters, Client.SerializationSettings);
                _httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
                _httpRequest.Content.Headers.ContentType =System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
            }
            // Set Credentials
            if (Client.Credentials != null)
            {
                cancellationToken.ThrowIfCancellationRequested();
                await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
            }
            // Send Request
            if (_shouldTrace)
            {
                ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
            }
            cancellationToken.ThrowIfCancellationRequested();
            _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
            if (_shouldTrace)
            {
                ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
            }
            HttpStatusCode _statusCode = _httpResponse.StatusCode;
            cancellationToken.ThrowIfCancellationRequested();
            string _responseContent = null;
            if ((int)_statusCode != 200)
            {
                var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
                try
                {
                    _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                    ErrorResponse _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<ErrorResponse>(_responseContent, Client.DeserializationSettings);
                    if (_errorBody != null)
                    {
                        ex.Body = _errorBody;
                    }
                }
                catch (JsonException)
                {
                    // Ignore the exception
                }
                ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
                ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
                if (_shouldTrace)
                {
                    ServiceClientTracing.Error(_invocationId, ex);
                }
                _httpRequest.Dispose();
                if (_httpResponse != null)
                {
                    _httpResponse.Dispose();
                }
                throw ex;
            }
            // Create Result
            var _result = new AzureOperationResponse<PipelineTopology>();
            _result.Request = _httpRequest;
            _result.Response = _httpResponse;
            if (_httpResponse.Headers.Contains("x-ms-request-id"))
            {
                _result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
            }
            // Deserialize Response
            if ((int)_statusCode == 200)
            {
                _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                try
                {
                    _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<PipelineTopology>(_responseContent, Client.DeserializationSettings);
                }
                catch (JsonException ex)
                {
                    _httpRequest.Dispose();
                    if (_httpResponse != null)
                    {
                        _httpResponse.Dispose();
                    }
                    throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
                }
            }
            if (_shouldTrace)
            {
                ServiceClientTracing.Exit(_invocationId, _result);
            }
            return _result;
        }

        /// <summary>
        /// Retrieves a list of pipeline topologies.
        /// </summary>
        /// <remarks>
        /// Retrieves a list of pipeline topologies that have been added to the
        /// account, if any, along with their JSON representation.
        /// </remarks>
        /// <param name='nextPageLink'>
        /// The NextLink from the previous successful call to List operation.
        /// </param>
        /// <param name='customHeaders'>
        /// Headers that will be added to request.
        /// </param>
        /// <param name='cancellationToken'>
        /// The cancellation token.
        /// </param>
        /// <exception cref="ErrorResponseException">
        /// Thrown when the operation returned an invalid status code
        /// </exception>
        /// <exception cref="SerializationException">
        /// Thrown when unable to deserialize the response
        /// </exception>
        /// <exception cref="ValidationException">
        /// Thrown when a required parameter is null
        /// </exception>
        /// <exception cref="System.ArgumentNullException">
        /// Thrown when a required parameter is null
        /// </exception>
        /// <return>
        /// A response object containing the response body and response headers.
        /// </return>
        public async Task<AzureOperationResponse<IPage<PipelineTopology>>> ListNextWithHttpMessagesAsync(string nextPageLink, Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (nextPageLink == null)
            {
                throw new ValidationException(ValidationRules.CannotBeNull, "nextPageLink");
            }
            // Tracing
            bool _shouldTrace = ServiceClientTracing.IsEnabled;
            string _invocationId = null;
            if (_shouldTrace)
            {
                _invocationId = ServiceClientTracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("nextPageLink", nextPageLink);
                tracingParameters.Add("cancellationToken", cancellationToken);
                ServiceClientTracing.Enter(_invocationId, this, "ListNext", tracingParameters);
            }
            // Construct URL
            string _url = "{nextLink}";
            _url = _url.Replace("{nextLink}", nextPageLink);
            List<string> _queryParameters = new List<string>();
            if (_queryParameters.Count > 0)
            {
                _url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
            }
            // Create HTTP transport objects
            var _httpRequest = new HttpRequestMessage();
            HttpResponseMessage _httpResponse = null;
            _httpRequest.Method = new HttpMethod("GET");
            _httpRequest.RequestUri = new System.Uri(_url);
            // Set Headers
            if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value)
            {
                _httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
            }
            if (Client.AcceptLanguage != null)
            {
                if (_httpRequest.Headers.Contains("accept-language"))
                {
                    _httpRequest.Headers.Remove("accept-language");
                }
                _httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage);
            }

            if (customHeaders != null)
            {
                foreach(var _header in customHeaders)
                {
                    if (_httpRequest.Headers.Contains(_header.Key))
                    {
                        _httpRequest.Headers.Remove(_header.Key);
                    }
                    _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
                }
            }

            // Serialize Request
            string _requestContent = null;
            // Set Credentials
            if (Client.Credentials != null)
            {
                cancellationToken.ThrowIfCancellationRequested();
                await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
            }
            // Send Request
            if (_shouldTrace)
            {
                ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
            }
            cancellationToken.ThrowIfCancellationRequested();
            _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
            if (_shouldTrace)
            {
                ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
            }
            HttpStatusCode _statusCode = _httpResponse.StatusCode;
            cancellationToken.ThrowIfCancellationRequested();
            string _responseContent = null;
            if ((int)_statusCode != 200)
            {
                var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
                try
                {
                    _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                    ErrorResponse _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<ErrorResponse>(_responseContent, Client.DeserializationSettings);
                    if (_errorBody != null)
                    {
                        ex.Body = _errorBody;
                    }
                }
                catch (JsonException)
                {
                    // Ignore the exception
                }
                ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
                ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
                if (_shouldTrace)
                {
                    ServiceClientTracing.Error(_invocationId, ex);
                }
                _httpRequest.Dispose();
                if (_httpResponse != null)
                {
                    _httpResponse.Dispose();
                }
                throw ex;
            }
            // Create Result
            var _result = new AzureOperationResponse<IPage<PipelineTopology>>();
            _result.Request = _httpRequest;
            _result.Response = _httpResponse;
            if (_httpResponse.Headers.Contains("x-ms-request-id"))
            {
                _result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
            }
            // Deserialize Response
            if ((int)_statusCode == 200)
            {
                _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                try
                {
                    _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<Page<PipelineTopology>>(_responseContent, Client.DeserializationSettings);
                }
                catch (JsonException ex)
                {
                    _httpRequest.Dispose();
                    if (_httpResponse != null)
                    {
                        _httpResponse.Dispose();
                    }
                    throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
                }
            }
            if (_shouldTrace)
            {
                ServiceClientTracing.Exit(_invocationId, _result);
            }
            return _result;
        }

    }
}

redpajama_set_name: RedPajamaGithub


As far as menswear's concerned, it's not easy being short – and I speak from experience. When it comes to off-the-rack tailoring, coats, shirts and trousers, it can be a lottery just trying to find anything that fits.
The problem is that the majority of brands utilise the same 'average' body type when cutting their garments, which just so happens to be tall, slim and in perfect proportion. A shape that is actually pretty rare in real life.
Add to that the current trend for longline tees, cropped trousers and fitted bomber jackets – all items that can look out of proportion on shorter guys – and just pulling together a decent outfit in the morning can be tough.
But never fear – we're here to help. Below you will find who we consider to be the best retailers and brands for shorter gents, to make looking good that little bit easier.
As well as offering sizes down to XXXS, ASOS provides shorter length trousers as standard on most of their own-label tailoring, negating the need to get them taken up.
Add to that plenty of brands which cater for shorter guys (such as Carhartt and Cheap Monday) and a 'shop by size' feature, and this e-tail giant is better stocked than most high street stores for men on the slighter side.
This cult Newcastle-based menswear store has a strong focus on streetwear, offering a wealth of labels that are ideal for shorter men.
On the tailoring side they stock Thom Browne, whose suits might be a mortgage-level investment but are cut short and in proportion, and who also makes more affordable items like knitwear and shirts.
Other brands to look out for include Japanese labels such as Journal Standard, who produce premium basics like bomber jackets, sweats and tees in slightly shorter fits, as well as edgier brands like Sasquatchfabrix and Neighborhood.
They also have a strong selection of pieces from A.P.C. and YMC – two labels that we've found make good outerwear for smaller guys.
While it might not seem like an obvious choice, Sunspel's T-shirts and sweats are made from high quality cotton that practically shapes to your body – perfect for achieving a more custom fit, no matter what your size.
With a little wear, the brand's tees break in easily and after a couple of washes, look just right on shorter frames. It's also well worth checking out its selection of shorts and outerwear.
Available at sunspel.com and Mr Porter.
Vintage shops are a gift to smaller men. Back in the day, garments were often cut a little shorter and boxier, and there was a lot more custom-made clothing around – we're looking for 1950s-1970s pieces here, especially things like denim shirts, coats and workerwear.
Beyond Retro has a particularly impressive online store stocked with hundreds of vintage sweats, flannel shirts and jeans – though prices are around the £30 mark, quality is often much better than you'd find on the high street for the same outlay.
There's something about Oliver Spencer's outerwear and shirts that fit slighter frames just right.
The designer favours shorter, more pulled-together pieces such as chore jackets and bombers with straight hems (rather than ribbed), which look good whether you prefer them fitted or slightly oversized.
Available at oliverspencer.co.uk and Mr Porter.
The Japanese retailer isn't ideal for shirts when it comes to shorter gents, but for sweaters and knitwear it scores highly – great, considering you can pick up premium quality cashmere and merino wool pieces at unbelievably low price points.
Its range of chinos and jeans is also superb and each UNIQLO store offers free alterations, taking the hassle out of needing to get everything professionally tailored.
If you're not yet familiar with J.Crew's famous 'Ludlow' suit, it might be worth getting acquainted.
One of the cornerstones of the US brand's offering, it comes in a range of colours and materials, from Japanese cotton to Italian linen, as well as short and regular sizes – both of which are widely regarded as an excellent choice for men of below average height.


We are now working with one of the premier booking agents for African hunts. He has been been there and done that many times and continues to hunt and visit with African outfitters on an annual basis. Let us refer you to this African specialist who will help you choose the perfect trip for you and then help you with the associated pre-hunt and post-hunt details.
Hunts can be arranged in the following African countries: Cameroon, C.A.R. (Central Africa Republic), Tanzania, Mozambique, Zambia, Zimbabwe, Namibia, Botswana and South Africa.
If an African safari is on your bucket list, contact us and we will put you in contact with this African authority.


He begins to speak and we entertain his conversation. Satan desires destruction, confusion and for us to mistrust the Lord.
Just like in the beginning, in the Garden, he whispers his venom and the distraction brings disaster.
David living under the favor of the Lord was incited by Satan and he entertained the thought. Let's count the men! Let's see how great we are doing!
When life is going well and the opposition seems at rest, we must be careful!
So if sin has visited us and we welcomed it in, what do we do? Destruction is running free and bringing death to areas where life was once thriving.
I will call on the Mercy of the Lord!
We must admit our wrong like David did.
Shut down every avenue that brought the destruction.
Focus on the Lord and his Goodness!
Obey & Honor the Lord!
Worship the Lord! Pour out your heart before Him!
Exodus 20:12 "Honor your father and your mother, so that you may live long in the land the Lord your God is giving you."
With Mother's Day in just a few days, we are all thinking about those special ladies, women that love us and enrich our lives. My mom has been gone 6 years and to me it seems that she is just at home and any day I will speak with her again.
I do want to honor my mom today, but in addition I want to honor my sister Betty.
Today was a very, very difficult day for me. The Rheumatoid Arthritis beat me good. I woke up this morning, my family was already gone and the pain that ravished my body was acute! I could not lift my arms and barely walk. Drinking coffee this morning required a straw!
When I spoke to my sister (which is daily) I could not hold back my tears and groans. She quickly left her job in NJ and drove to me. 45 Minutes later my nurse Betty arrived!
Moms love us and also impart behaviors to us. My mom was a servant, compassionate and a caring lady. These traits have been passed to my sister. When I could not call my mom today, my sister was there in a heartbeat!
I love you sister! Happy Mother's Day. You are just like mom!
It's been fourteen hours since my ordeal started this morning. Even though its difficult to type, I wanted to honor the Lord and my sister.
For all the "Be Inspired" readers, please keep me in prayer. Medication was increased and a new medication plan is coming.
Lord impart your wisdom and healing to me.
To God be the Glory! Happy Mother's Day!


The TSS-95-ECA In-Ground Trapzilla Solids Separator is designed to be a compact solids separator capable of retaining high volumes of solids. Ideally, a TSS-95-ECA Trapzilla Solids Separator would be installed in conjunction with a TZ-600-ECA or TZ-1826-ECA Trapzilla Grease Interceptor, effectively removing solids and permitting the grease interceptor to operate at maximum efficiency. In-Ground Trapzilla Solids Separator Models come with an Extension Collar Adapter Ring lid, 18" long Single-Piece Extension Collar and a 22" Solid Top Cover that can be removed easily to clean out retained solids.
Thermaco Trapzilla Model No. TSS-95-ECA, rotationally molded poly- ethylene solids separator(s) for in-ground installation, rated at 150 gallons per minute (9.46 l/s) peak flow, 95 gallons (359.61 l) of solids storage capacity, fully removable cover for vacuum ac- cess by pump truck for solids removal, and including as an integral part of the unit a vessel vent. Includes one extension collar assembly, linear low-density rotationally molded polyethylene in two pieces for field adjustability to optimal installation depth.


text:
You Will Be Remembered
On my Sunday training runs for the Zion Half Marathon, I usually go for a run up Utah SR 9, heading towards Zion from the town of Virgin. A few miles up, I pass by this gravestone just off the highway, the only remaining thing of the ghost town called Duncan's retreat.
I have never seen anybody stop here. Most people are tourists going 70 along this lonely stretch of highway, hell bent for Springdale lodging, and if they were looking anywhere it would be the other way, towards the Virgin River. A rock quarry lies just behind it, and nothing that would draw your attention to it.
The history book has this to say about the long-gone town:
A man named Chapman Duncan settled here in 1861. Shortly after several other families moved here also. In 1862 the Virgin river flooded and destroyed most the town. A lot of the people moved away but new settlers came. By January of 1863 about 70 people lived here. In 1863 a post office was built, a school was built in 1864 along with a meeting house. In 1866 floods took its toll on this town also and over the next few years high water from the Virgin river destroyed the fields and killed the town. By 1891 the town was deserted. All that remains of the town today is a grave of a lady named Nancy Ferguson Ott who died here in town in 1863. Her grave is located on the north side of highway 9. (Submitted by Bob Bezzant.)
My understanding from other locals is that Duncan used to live in our town of Virgin (now population 600), but "retreated" to this place far from Virgin to get away from the bustling metropolis.
When Nancy Ferguson Ott died, Duncan's Retreat had 70 citizens, a post office, families, friends. It was a town, and they thought it would stick around long enough for there to be a cemetery with more than just Nancy, but Nature and circumstance had other ideas.
Now she is utterly alone, on a lonely stretch of anonymous highway, with no one around, no town, no post office, no friends no family.
I stopped to look at the grave marker. There are fresh flowers, stuffed animals, cards. They are replaced regularly by somebody somewhere. I do not know who.
I take some comfort in this, and I hope you do too. No matter who you are, or how alone you may feel in this world, Nancy Ferguson Ott is here, on State Route 9, miles from anywhere and anyone, to deliver this message to you: No one dies alone. You will be Loved, You will be Remembered.
Life in Zion Canyon

redpajama_set_name: RedPajamaCommonCrawl


This can be the worst auto repair store, I used to be towed by aaa towing and towed out.I proprietor ought to be arrested for thief..
At Terrace Auto Repair, you and your self-assurance are A very powerful piece of the puzzle. We offer a variety of automotive repair solutions for the advantage. And bear in mind, we want to continue to keep you in our faithful customer loved ones. When you don't begin to see the support you're on the lookout for, just talk to!
The brand name names, logos, pictures and texts are the residence of these 3rd parties and their respective owners. Should you have click to read more any queries or suggestions with regards to this matter, you happen to be welcome to contact our client aid group.
The brand names, logos, pictures and texts would be the home of these 3rd functions and their respective proprietors. When you have any concerns or ideas about this make any difference, that you are welcome to Get hold of our client assistance workforce.
Maaco's certified facilities are in this article to offer national or regional fleets services to keep you within the street. From rebranding expert services, incident administration, company oversight Gains, adaptable billing and repairs, Maaco Fleet services are backed by a nationwide guarantee anytime.


When it comes to selling your high-end, luxury, or custom car or motorcycle, no one wants to walk away with a huge headache - that's where we come in! At V Fine Motor Cars, we guarantee the finest representation of your vehicle to showcase why it's worth maximum market value. You can trust us with everything from professionally photographing your ride to handling the tedious and time consuming paperwork - all you have to worry about it picking up the check.
The process of selling your vehicle can often feel like more trouble than it's worth. Why not just leave the dirty work to our professionals? We'll take care of meticulously cleaning and detailing your ride, researching every element and professionally photographing it to capture each and every unique feature to show why your car or bike is worth top dollar. All you have to do is sit back and take comfort in knowing that our skilled sales professionals will be working tirelessly to negotiate the best possible deal for you!
V Fine Motor Cars respects the relationship between man and machine, and you know your car or bike better than anyone. We'll take the time to work with you and gather all of the details, so we can create the optimal description of your one-of-a-kind ride. We appreciate the art of automotive design and understand the passion behind the horsepower - that's why our customer service is unparalleled and we can ensure you'll get the most value for your car or motorcycle.
We take pride in our high caliber of customer service in Austin's luxury and exotic automotive and motorcycle industry. That's why our consignment fees are fair and competitive - we want you leaving V Fine Motor Cars knowing that you made the right decision in choosing to list with us. Contact us today by calling (512) 825-5778 to learn more about the process and how to get your car or motorcycle sold with V Fine Motor Cars.
We're ambitious, enthusiastic and share a passion for horsepower.
Thank you! Your consignment form has been submited. We'll get back to you soon!


text:
8 Ways to Accelerate Environmental Sustainability Progress
By Patti Soldavini
A few weeks ago, I read "Moving to Higher Ground: Rising Sea Level and the Path Forward," by John Englander, a renowned oceanographer, multi-book author, speaker, and expert on climate change and sea level rise. Unlike all the cold, hard facts about preserving our environment, one sentence in this book took my breath away, resonating deeply like nothing else.
Essentially, the author said that the shape of all the continents on earth will change—forever.
Coastal Cities Across the World Will Vanish
Coastal areas like Miami, New York, Boston, Hong Kong, Manila, Rotterdam, Tokyo, Venice and more, will vanish, submerged under water due to the impact of rising sea level. "SLR will profoundly affect more than 10,000 coastal communities as soon as 2050, both in the U.S. and around the world." This means that a child born in 2021 will be just 29 years old when they experience these profound impacts. Even more sobering, Englander claims that it's already too late for us—even if we significantly improved our efforts—to prevent such a catastrophe.
Let all that sink in for a minute. (No pun intended.)
Sadly, it's not a question of if, but when. Even if we dramatically reduce carbon emissions, this is still going to happen.
Go ahead. Take a medium-tipped magic marker and a map and on the inside of the map, follow the outline of any continent to produce a new version of the map that leaves current coastlines outside of the new line—submerged under ocean water. Are any of your favorite vacation destinations gone? What about the coastal towns where your families and friends currently live?
Its Insidious Process Masks Its Urgency
The worst part is that it's such an insidious process. Sea levels are already rising globally. Some sources claim that globally, sea levels have risen roughly eight inches since the beginning of the 20th century and more than two inches in the last 20 years alone. This makes it difficult for people to grasp rising sea levels as an urgent issue.
It's much easier for people to process natural disasters that are "temporary" in the sense that earthquakes, tornadoes, hurricanes, and wildfires have a clear and definite starting and stopping period. Homes and towns are destroyed, people die, it gets cleaned up and we move on, the imminent threat is no longer imminent.
On the other hand, the impact of rising sea levels is cumulative. We may not notice the two-inch rise every 20 years, but soon, the way of life as we know it will be impacted by smaller economic measures along to path to catastrophe. Flood insurance will rise in coastal areas, property values will sink, family estates won't be able to be passed down to future generations, tourism will decline, even accounting methods will change.
The Responsibility for Businesses and Consumers is Equal
Consumers and businesses share an equal measure in preserving our planet—consumers because their purchase behavior drives the production of consumer products, and businesses because their massive scale has a colossal impact on the volume of waste created and carbon emitted.
While it varies from region to region, for decades, most consumers have paid lip service to environmental sustainability; saying one thing ("Yes, in theory they support protecting the environment) but doing another ("Not if it costs me more money or a loss of convenience.") However, the proverbial tide is shifting among consumers; younger generations are walking the talk, willing to make sacrifices in this area that earlier generations have not.
Many businesses have worked hard to ensure that the products they develop are as sustainable as they can be—given all the complex variables associated with product development supply chains, regulations, and the expectations of investors. But the job is half done. Now it's time for all businesses to turn their attention to making the packaging of their products and their marketing of them, environmentally sustainable as well. Those who are ahead of the others will be on the right side of history—and more successful.
So, where can companies start or take the next step to accelerate their environmental sustainability actions?
1. Integrate Environmental Sustainability Into All Your Brand Thinking
Environmental sustainability must be part of every project brief. This ranges from defining a brand's purpose to creating its expression across media, producing its assets for printing or digital activation, and transforming the processes that bring them to life for the consumer. It's time to move beyond product and examine the workflows, materials and processes that deliver your products to market. Challenge obvious assumptions and rethink your brand's place in a more sustainable world. If you started from scratch without any legacy restrictions, would you define, package or market your brand differently in an increasingly eco-conscious world? Use this as an opportunity to energize your creative teams in sustainability innovation exercises.
2. Rethink Your Structural Packaging Forms & Materials
Take advantage of new advances in substrates and materials. Evaluate your brand's structural forms across regions. Is there an opportunity to rationalize the forms in the entire portfolio and standardize where possible? Go even further. Look outside your own industry. Form a cooperative group of engineers with expertise in many different sub-fields like pharmaceutical, agricultural, aerospace, energy, biomedical, thermal, industrial, optical, etc. to synthesize knowledge, insights, and creative thinking about how to solve very complex problems around packaging forms, materials, printing, and waste. Surely, if mankind is now capable of using 3D printing technology to print everything from tiny houses to human organs, we can find innovative new ways to create new packaging forms and materials.
3. Rethink Retail Spaces
Retailers also need to rethink their space—especially grocery stores which have relied on the same store format for 105 years since Piggly Wiggly opened in 1916. From rethinking store formats, arrangements and displays to reducing the use of unsustainable materials in the construction and operations of stores to conserving energy and donating leftover food to local charities, opportunities to act more sustainably abound. Consider finding new ways to spotlight products with the most environmentally friendly packaging. Test ideas like reserving a few parking spaces closest to store entrances for electric vehicles. Create new ways to reward consumers for eco-friendly behaviors, beyond plastic bag substitutes. Convert some cashiers to roam stores as "Sustainability Guides."
4. Create Sustainable Packaging Design
Ask the questions that seem crazy. What happens to a brand when the package design uses no ink? How can a completely tactile experience communicate your brand? Can packaging wrappers be turned into apparel? What's the best design strategy for a zero-plastic product?
Consider practical opportunities as well: Print packaging using extended color gamut practices to create fixed color sets across your brand(s) to eliminate the need for custom spot colors. Doing this across all regions, printers and SKUs can significantly reduce the use, impact, and cost of ink. Ask yourself where you can convert pack printing from gravure to flexo to reduce ink as well as carbon emissions. Re-design your labels to put environmental sustainability claims and recycling information on the principal display panel to help eco-conscious consumers make more informed choices.
5. Implement Digimarc Watermarking/Codes
This is an easy one. Whenever you re-design a package, implement Digimarc coding. Not only can it help revolutionize plastic sorting rates and accuracy during recycling, but it also adds a critical layer in anti-counterfeiting strategies and supports brand traceability. Make this too, part of every design brief for new product introductions and pack refreshes. Leverage the ability of coding to activate a digital connection between your brand and the consumer. Suddenly, your packaging, whose physical dimensionality restricts your communication opportunities opens a digital world, unrestricted in its ability to deepen communication and engagement with consumers. Drive consumers to digital content that informs, educates, and even inspires them to act more sustainably.
6. Reduce Digital Litter When Marketing Digitally
Many people—especially consumers—are pretty unaware of the concept of digital litter or digital pollution. It's a relatively new concept and one that does not yet benefit from the decades of exposure to and awareness of physical pollution and its impact on the environment, first spotlighted in April 1970 with the formation of Earth Day. According to an article authored by the Environmental Justice Coalition, "The world's digital carbon footprint is becoming increasingly difficult to ignore. Each internet search, song played, video streamed, message sent, route planned via GPS, cashless payment, and social media scroll contributes to growing energy consumption, global demand for electricity, and rising CO2 emissions." To make this more concrete, consider this: From emails alone, the average person in the developed world adds 136kg of CO2 emissions to their carbon footprint annually, the equivalent of driving 200 miles in a car. Globally, the world's email usage generates as much carbon dioxide as adding 7 million cars to the roads."
7. Streamline Packaging and Marketing Workflows
You can take the farm-to-table concept and apply it to the processes of how companies can go from packaging to marketing and beyond more sustainably. Both are essentially about "purity of process," and a streamlined process at that. By removing "junk steps" from processes, those that have been bolted on to packaging and marketing workflows over the years to address immediate issues, brands can reverse this sprawl to improve speed to market, quality, and sustainability. Examining your workflows more holistically today can help reduce your brand's carbon footprint, simplify the process of going to market and amplify your brand's purpose.
8. Engage in Strategic Partnerships to Accelerate Sustainability
Never has it been more important to reach out externally to other partners—even competitors—to leverage unique expertise to co-create mutually beneficial sustainable solutions to preserve the planet we all occupy. Take a parallel path—challenge your current vendors to challenge you—to strategically help you create a path forward, while exploring strategic relationships with experts outside your industry. Cross pollinate the thinking of people who have been faced with discovering solutions to seemingly impossible challenges in vastly different fields. What can biotechnology experts bring to the sustainable packaging conversation? What unique expertise can aerospace engineers add? What role could Urban Planners & Growers play in rethinking the packaging status quo? How can Human Factors Psychologists frame a new vision for sustainable packaging based on their understanding of human needs and changing behaviors?
There's no escaping that the bold challenges of environmental sustainability and of life as we know it today requires taking brave actions now. The impact of packaging waste and digital pollution is a rising tide all its own and must be addressed with courage, clarity, and deep collaboration across silos of all kinds starting now.
Lastly, while we're at it, let's stop using the phrase "boil the ocean," as a metaphor for undertaking an impossible task. Because, in reality, that's exactly what we're doing to the planet now.
You can purchase "Moving to Higher Ground: Rising Sea Level and the Path Forward" here or from other sources.
You can also find additional information at:
https://johnenglander.net/moving-to-higher-ground/
https://www.ipcc.ch
https://bit.ly/3lFRxD9
About Patti Soldavini
Patti Soldavini is a futurist who has pushed the boundaries of marketing and creativity to connect brands with consumers, using leading edge technology to drive results. For the past 25 years on both the agency and client sides of the business across the entertainment, retail and pharmaceutical industries, she has served in marketing leadership positions for the New York Cable Marketing Co-op and IQVIA (formerly IMS Health) and in creative leadership positions for Home Shopping Network and Anthem Worldwide prior to joining SGK. She is passionate about the intersection of creativity, technology and psychology.
More great thinking
4 Ways to Create a More Sustainable Pharma Brand
3 Ways Pharma Brands Can Tell a Sustainable Packaging Story


text:
GJF Around Town
The Guelph Jazz Festival was founded in 1994 by Ajay Heble and a group of friends who shared a love of jazz and a commitment to Guelph. The Festival has consistently been praised by local, national, and international critics for its programming. The festival has commissioned several large-scale works including Passages, a multimedia opera by Jesse Stewart and based on poetry by Paul Haines; Québécité, with music by D.D. Jackson and libretto by George Elliott Clarke; and In Place of Wishes written by Robert Pennee with music by a quintet of improvisers.
Winner, Premier's Award for Excellence in the Arts, 2010
Finalist, Premier's Award for Excellence in the Arts, 2009
Nominee, Festival of the Year, National Jazz Awards, 2009
Finalist, Events Producer of the Year, Jazz Journalists Association, 2008
Winner, Lieutenant Governor's Award for the Arts, 2001, 2000, 1997
Guelph Jazz Festival presents music that invites listeners to experience the world anew.
Guelph Jazz Festival invites listeners to be inspired by and engaged with creative music. The Festival strives to present music that reflects the world in which we live and to make it accessible to the broadest possible audience through concerts, educational initiatives, and free programs.
We actively cultivate a wide range of community partnerships
We encourage artistic collaboration, teamwork, and volunteerism
We provide access with affordable ticket prices and free events
We deliver educational programs for young people
We engage learners of all ages
We inspire lively discussion
We encourage bold artistic ventures
We commission new works
We consider creative music within a global context
We celebrate artistic variety and human diversity
6 Dublin Street South, #301
GJF presents Mercury (Lori Freedman & Nicolas Caloia), Silence, 28 April
Annual General Meeting, Tuesday 27 March 2018
Review of GJF Days 4-5 from the Free Jazz Collective
Thanks for being part of a wonderful Festival weekend!