Door deze website te bezoeken maak je automatisch gebruik van cookies.

Als de browser instellingen niet veranderd, dan maak je gebruik van de cookies. Lees meer

Sluiten

2BA Cookie informatie

Deze tekst is van toepassing op de 2BA sites "Homepage", "Unifeed" en "Bestand & Beheer".

Wat is een Cookie

Wij maken op deze website gebruik van cookies. Een cookie is een eenvoudig klein bestandje dat met pagina’s van deze website wordt meegestuurd en door uw browser op uw harde schrijf van uw computer wordt opgeslagen.

Soort cookies

Wij gebruiken cookies om het gebruik van onze site faciliteren, het inloggen te onthouden en t.b.v. snelheidsverbeteringen. Daarnaast gebruiken wij (anonieme) gegevens voor het opbouwen van site statistieken zoals het aantal keer dat de sites bezocht worden, met welke browser etc. De 2BA site kan niet zonder cookies werken. 

2BA maakt geen gebruik van tracking cookies t.b.v. advertenties.

 

 

Documentatie

Description

Upload a catalog file to the 2BA database

Resource URL

json: https://api.2ba.nl/1/streaming/DeliveryUpload/UploadFile

The input is a MultipartFormDataContent with the parameter:
 file

required

 Stream with file. This file should be one of the accepted formats (bestandsformaten) compressed using zip, 7z or gzip. The maximum filesize is 2GB. For larger files see our alternative upload abilities (upload bestanden)

Response Object

The UploadFile service returns the normale HTTP Status as response.

 

c# sample code

       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;
            }
        }
    }