DeliveryUpload UploadFile (Streaming)

       public async Task Upload(byte[] file, string filename)
        {
            string result;
            if (string.IsNullOrEmpty(_refreshToken))
            {
                // Only once during the application life time the GetTokenResourceOwnerPasswordCredentials is called
                await GetTokens();
            }
            if (_client == null) {
                // The HttpClient object is intended to live for as long as this application needs to make HTTP requests.
                InitializeClient();
            }

            var uri = new Uri(_baseUri, "Streaming/DeliveryUpload/UploadFile");

            using (var content = new MultipartFormDataContent())
            {
                // Add parameter process. Process file after upload?
                content.Add(new StringContent(((int)_settings.ProcessFile).ToString()), "process");
                
                // Add file as stream
                content.Add(new StreamContent(new MemoryStream(file)), filename, filename);

                try
                {
                    result = await PostFile(uri, content);

                    if (string.IsNullOrEmpty(result))
                    {
                        // Tokens refreshed. Retry once!
                        result = await PostFile(uri, content);
                        if (string.IsNullOrEmpty(result))
                        {
                            throw new FileWatchUploadException($"Retry upload failed. Stop retrying.");              
                        }
                    }
                }
                catch (TaskCanceledException ex)
                {
                    // Check ex.CancellationToken.IsCancellationRequested here.
                    // If false, it's pretty safe to assume it was a timeout.
                    if (ex.CancellationToken.IsCancellationRequested)
                    {
                        _logger.LogError($"Problem uploading file *** Timeout ***");
                    }
                    throw;
                }
                catch (Exception e)
                {
                    throw new FileWatchUploadException($"Problem uploading file to { _settings.RestServiceUrl }", e);
                }
            }

            return JsonConvert.DeserializeObject(result);
        }

        private void InitializeClient()
        {
            _client = new HttpClient();
            _client.MaxResponseContentBufferSize = 256000;
            _client.Timeout = TimeSpan.FromMinutes(30);
            _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _accessToken);
        }

        private async Task PostFile(Uri uri, MultipartFormDataContent content)
        {
            var result = string.Empty;

            using (var response = await _client.PostAsync(uri, content))
            {
                if (response.IsSuccessStatusCode)
                {
                    // return result
                    _logger.LogInformation("Upload OK: " + _baseUri);
                    result = await response.Content.ReadAsStringAsync();
                    return result;
                }
                else if (response.StatusCode == HttpStatusCode.Unauthorized)
                {
                    // return empty result
                    _logger.LogInformation($"Unauthorized at: { _baseUri }. Start refreshing tokens");
                    var tokens = await _authorizeServices.RefreshToken(_refreshToken);
                    _client.DefaultRequestHeaders.Remove("Bearer");
                    _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokens.access_token);
                    return result;
                }
                else
                {
                    // throw exception
                    throw new FileWatchUploadException($"Error uploading file. Statuscode: {response.StatusCode }. {response.ReasonPhrase} \n {uri}");
                }
            }
        }

        private async Task GetTokens()
        {
            try
            {
                var tokenResponse = await _authorizeServices.GetTokenResourceOwnerPasswordCredentials();
                _refreshToken = tokenResponse.refresh_token;
                _accessToken = tokenResponse.access_token;
            }
            catch (Exception)
            {
                _logger.LogError($"Unable to get tokens at { _settings.AuthServiceUrl }");
                throw;
            }
        }
    }
</string></importfilelist></importfilelist>