api-response | Package for standardizing the responses from the API | REST library

If you want to use old Android Code into Kotlin-Multiplatofrm Project you need to do some steps

First Step : you should separate your code into business layer and presentation layer you can know about it by reading clean architecture Android

Second Step : we will put business layer into Shared Module then we will put presentation layer into ANDROID APP

Third Step : you should replace Retrofit Code with Ktor Code

Fourth Step : You should replace Room Code with SqlDlight Code

fifth Step : You Should Write your view in presentation layer with Compose not Xml

then application will be ready to use his business logic into ios

sixth Step : then you can write your swift code into IOS APP

you can look at this code this is not complete code but it will make it clear to you haw you can use my Kmm Repo at Github

note :

Presentation layer contain view , viewmodel and any Platform dependent tools like workmanger

business layer contain network and caching code like KTOR , SQLDELIGHT and any logic that may be shared between Android and Ios

You would need to enable CORS(Cross-Origin Resource Sharing) by sending appropriate response headers, one of them being Access-Control-Allow-Origin header, which tells the browser what all origins can access the resource.

CORS policy is something imposed by the browsers as a security measure, and not by REST clients such as Insomnia/Postman. Hence the HTTP request works in insomnia, but not in browser.

From MDN:

For security reasons, browsers restrict cross-origin HTTP requests initiated from scripts. For example, XMLHttpRequest and the Fetch API follow the same-origin policy. This means that a web application using those APIs can only request resources from the same origin the application was loaded from unless the response from other origins includes the right CORS headers.

HTTP request to subdomain doesn't fall under same-origin policy, and hence you would need to enable CORS.

Resources:

• https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
• https://developer.mozilla.org/en-US/docs/Glossary/Origin
• https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy#definition_of_an_origin

Well, I was having the same issue.

It is easier than expected. Just call the middleware in settings.py as the first in the list (as explained in your link):

You need to use the .get method of the Headers object:

I figured it out. The media type I wanted to use for "text/plain" required different handling, and the parameter in the signature of the endpoint caused issues. This article helped.

Updated endpoint:

You can do that:

As the read_xml()documentation says:

Note: The etree parser supports limited XPath expressions. For more complex XPath, use lxml which requires installation.

Unfortunately, it seems to me this is one of those situations where a "more complex" xpath is needed... So let's use lxml:

Never use runBlocking in an Android app unless you know exactly what you're doing. It's the wrong choice 99% of the time because it defeats the purpose of using coroutines. Blocking means the current thread waits for the coroutine to run its asynchronous code. But you cannot block the main thread because that freezes the UI.

Since your LoginHelper is an object or singleton, it needs its own CoroutineScope if it's going to launch coroutines.

You can make deleteSession() a suspend function so it can call the api.deleteSession() suspend function.

You can make logout() launch a coroutine to sequentially delete the session and subsequently perform other tasks. And you can make it return the launched Job so other classes can choose whether or not to simply start the logout, or to start and wait for the logout in a coroutine.

A couple of things to consider here.

1. The while loop is the wrong approach here - since we're working with asynchronous operations in JavaScript we need to keep in mind how the event loop works (here's a good talk if you need a primer). Your while loop will tie up the call stack and prevent the rest of the event loop (which includes the ES6 job queue, where Promises are dealt with, and the callback queue, where timeouts are dealt with) from occurring.
2. So without a while loop, is there a way in JavaScript that we can control when to resolve a function so we can move onto the next one? Of course - it's Promises! We'll wrap the job in a Promise and only resolve that Promise when we're ready to move forward or reject it if there's an error.
3. Since we're talking about a specific data structure, a queue, let's use some better terms to improve our mental model. We're not "processing" these jobs, we're "enqueuing" them. If we were processing them at the same time (i.e. "processing 1", "processing 2", etc.), we wouldn't be executing them sequentially.