Dueto | Music sharing social media platform | Social Channel Utils library

I don't think there's an answer without more context. However, if you try to implement a "refresh-token adapter / retrier", the strategy is as follows:

You need a specialised adapter (a struct or class) which sets the Authorization header with the access token. Accessing a token MUST be thread-safe, and even getting a token may fail - for example, because there's none. In case of an error, the adapter tries NOT to get a new access token, this will be done in the retrier. The adapter may just not set the access token. The request will fail and will be handled in the retrier.

The adapter dispatches is functions on a dedicated queue, let's call it "process_queue". When finished setting the header it calls the completion handler.

You also need a specialised Retrier (a struct or class). It accesses a shared state which holds the result of a token request. This can be a Swift.Result for example.

This retrier's functions execute on a dedicated dispatch queue.

The specialised Retrier determines the response status and if the status code is a 401 (not authorised) AND if the Authorization header is a bearer token, it needs to make a refresh-token request.

When starting this refresh-token task, it suspenses the process_queue, so that no more request adaption take place with an expired access token.

Now, the token request completes and say it was successful. The retrier stores the access token (into the key chain), updates the original request with the new access token, then resumes the process_queue and then it calls its completion handler.

Proper Error handling makes this slightly more complex. The question is how to treat pending requests when the refresh-token request has failed. I have used an approach, which let fail all the pending requests that have been queued until the refresh-token request completed. They just fail with the error 401. Then a new cycle starts, beginning with attempting to get a new refresh-token.

This approach prevents that multiple failed requests call into the token endpoint at the same time. You can even extend the approach when the refresh token also expires. In that case you need to sign-in the user. All this may happen within the retrier. It completes only after sign-in is complete, after getting a new access token is complete, or when an error occurred.

Thanks for the Help, I got everything working by replacing the protocol Assignment, with an class Assignment:

Like @NetMage said,Since the data you want to take is Contest type data, if you put the take after the Select is to operate on the data after the Select,The data obtained will not be of Contest type, it will cause an exception.

You can change your code like below:

See here :

https://github.com/Alamofire/Alamofire/issues/2998

The function is not called because there is an ambiguity...

In the Interceptor :

Add this :

Both exceptions (unique constraint and value too large for column) are related. There are serveral processes executed in a single transaction. Those processes make calls to the methods save() or saveOrUpdate() stacking queries until the flush() of the Hibernate session or commit the transaction.

At some point a flush() of the session is invoked with the given scenario:

Entity A and B both contains the same reference of entity C. The first process tries to insert entity A, so first executes the insert of C without problem, later tries to insert A but fails due to a too large column exception. At this point C is in the database (not yet commited) but the hibernate session is in an incoherent state due to the previous fail and Hibernate doesnt know about C being inserted (a fail on session flush doesnt trigger a rollback, is responsability of the developer).

Then a second process is executed and tries to insert B into the database. If the previous process went ok, Hibernate only inserts the entity B because he knows C is already in the database. Due to the incoherent session state, Hibernate tries to save the C entity again in the database raising a unique constraint exception.

Your issue is with await. There is no need for await as .map does not return a Promise, and so it is not asynchronous.

If you want to edit your object in-place you can use .forEach which would loop through each object in your instalments array and add the order property to it.

See example below:

If you have a single hashmap it's going to be difficult to statically guarantee that tests are not mapped to suite-failures or vice versa. The ideas you already have are pretty much what you can do unless you want to have two different ID-types and require each lookup to specify if a test or suite is being queried for status.

If I may suggest a more drastic change: How about getting rid of the hashtable and storing the tests and statuses in the same structure?

Something like: