scotty | Helper scripts for GitHub Enterprise admins | Frontend Framework library

But names is an array and not == 0

You might mean

Don’t do regularLine.remove(input) do regularLine.remove(chosenNames) and the same for fastTrack but with append. You can put this in an if statement which checks if “chosenNames in regularLine” and if you want to remove multiple names then I would do this code:

Truly understanding monads takes time, practice, and patience, but it shouldn't be too hard to understand the need for liftIO by examining your types.

First off, the type of liftIO is MonadIO m => IO a -> m a. This means that the function can convert any IO action into an action in the monad m so long as m has an instance of MonadIO. In theory, this can only be implemented if m has some way of processing IO actions, so this function is embedding the given action into the m monad.

You're definitely in the right sort of place to use liftIO, so why isn't it working? That is, you have a value getAllFilePaths2 path of type IO [String], and you'd like it to be a value of type ScottyM [String] — this indeed seems like a good place to use liftIO. However, ScottyM is not an instance of MonadIO, as that error message you saw is trying to tell you, so you can't use liftIO.

This may seem crazy—can you really not embed IO actions into ScottyM?—but there's actually a good reason for this. What happens if the IO action throws an error? Does your whole web app crash? It would if you naively used liftIO. Instead, scotty provides the function liftAndCatchIO, which, as the docs describe, is "Like liftIO, but catch any IO exceptions and turn them into Scotty exceptions." This is the preferred way to embed IO actions into Scotty.

And here comes the final gotcha: Note that liftAndCatchIO actually produces values of type ActionM a, not ScottyM a. Additionally, there's no way to take a value in the ActionM monad and get it into the ScottyM monad. Instead, you need to use that value as an action. So, I'm not sure what pathsToScotty does, but it's very likely that you'll need to rewrite it.

You can use the authIsProtected field of the AuthSettings to define a function Request -> IO Bool that determines if a particular (Wai) Request is subject to authorization by basic authentication. In particular, you can inspect the URL path components and make a determination that way.

Unfortunately, this means that the check for authorization is completely separated from the Scotty routing. This works fine in your case but can make fine-grained control of authorization by Scotty route difficult.

Anyway, the AuthSettings are the overloaded "My Realm" string in your source, and according to the documentation, the recommended way of defining the settings is to use the overloaded string to write something like:

As you're inserting orderIntentItemsSlugs, you need a ToField instance for orderIntentItemsSlug (which is a [Text]). This is what your error tells you.

I recommend looking at the sources of other ToField instances to figure out how you want to do that (one hacky way would be to turn your field into a Text first, which already gas a ToField instance).

You could also write an orders table that relates an orderID to one item at a time, then you wouldn't have to write any instances at all.

Actually, the errors are related. In Main.hs, change the import of Home to:

What you're trying to do may be impossible, at least with the current assumptions, but I would be happy to be proven wrong.

Lets start by saying that this error:

There are two forms of exceptions in a scotty action (of type ActionT Text IO). There are native exceptions in IO, and another form added by the ActionT transformer. These exceptions are handled separately. The interface is given by the instances of ActionT:

• (MonadCatch m, ScottyError e) => MonadCatch (ActionT e m) (and similarly the MonadThrow instance). This shows that when you use catch from MonadCatch (or throwString from MonadThrow, and other variants from the safe-exceptions library), you are using the error handling mechanism of the transformed monad m, which in Scotty is usually IO (it defines ActionM = ActionT Text IO).

• (Monad m, ScottyError e) => MonadFail (ActionT e m). MonadFail is the constraint used for partial pattern-matches in do blocks. It does not require a MonadFail from the underlying monad m, which indicates that, unlike MonadThrow/MonadCatch, it uses the exception mechanism provided by the ActionT transformer itself. To catch this exception you must look for a combinator in Scotty rather than an auxiliary library, such as rescue.

BigQuery doesn't have the concept of a schema registry itself, so you're likely going to want to use schema to either create a table, or load data into bigquery.

In the table creation case, you'd want to convert the avro schema to a bigquery schema. BigQuery doesn't use avro schema representations directly. Here's an example in java of creating tables with explicit schema: https://cloud.google.com/bigquery/docs/samples/bigquery-create-table#bigquery_create_table-java

In the load case, there's no need to transmit the schema independently of the data. The Avro OCF structure typically includes the schema as part of the header, plus a set of data blocks. Just specify the URI for the avro files: https://cloud.google.com/bigquery/docs/samples/bigquery-load-table-gcs-avro#bigquery_load_table_gcs_avro-java