module Faktory.JobState
  ( JobState(..)
  ) where

import Faktory.Prelude

import Control.Arrow ((&&&))
import Control.Error.Util (note)
import Data.Aeson
import Data.HashMap.Strict (HashMap)
import qualified Data.HashMap.Strict as HashMap
import qualified Data.Text as T

data JobState
  = JobStateUnknown
  | JobStateEnqueued
  | JobStateWorking
  | JobStateSuccess
  | JobStateFailed
  | JobStateDead
  deriving stock (JobState -> JobState -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JobState -> JobState -> Bool
$c/= :: JobState -> JobState -> Bool
== :: JobState -> JobState -> Bool
$c== :: JobState -> JobState -> Bool
Eq, Int -> JobState -> ShowS
[JobState] -> ShowS
JobState -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JobState] -> ShowS
$cshowList :: [JobState] -> ShowS
show :: JobState -> String
$cshow :: JobState -> String
showsPrec :: Int -> JobState -> ShowS
$cshowsPrec :: Int -> JobState -> ShowS
Show, JobState
forall a. a -> a -> Bounded a
maxBound :: JobState
$cmaxBound :: JobState
minBound :: JobState
$cminBound :: JobState
Bounded, Int -> JobState
JobState -> Int
JobState -> [JobState]
JobState -> JobState
JobState -> JobState -> [JobState]
JobState -> JobState -> JobState -> [JobState]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: JobState -> JobState -> JobState -> [JobState]
$cenumFromThenTo :: JobState -> JobState -> JobState -> [JobState]
enumFromTo :: JobState -> JobState -> [JobState]
$cenumFromTo :: JobState -> JobState -> [JobState]
enumFromThen :: JobState -> JobState -> [JobState]
$cenumFromThen :: JobState -> JobState -> [JobState]
enumFrom :: JobState -> [JobState]
$cenumFrom :: JobState -> [JobState]
fromEnum :: JobState -> Int
$cfromEnum :: JobState -> Int
toEnum :: Int -> JobState
$ctoEnum :: Int -> JobState
pred :: JobState -> JobState
$cpred :: JobState -> JobState
succ :: JobState -> JobState
$csucc :: JobState -> JobState
Enum)

instance ToJSON JobState where
  toJSON :: JobState -> Value
toJSON = forall a. ToJSON a => a -> Value
toJSON forall b c a. (b -> c) -> (a -> b) -> a -> c
. JobState -> Text
jobStateToText
  toEncoding :: JobState -> Encoding
toEncoding = forall a. ToJSON a => a -> Encoding
toEncoding forall b c a. (b -> c) -> (a -> b) -> a -> c
. JobState -> Text
jobStateToText

instance FromJSON JobState where
  parseJSON :: Value -> Parser JobState
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"JobState" forall a b. (a -> b) -> a -> b
$ forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Either String JobState
jobStateFromText

jobStateToText :: JobState -> Text
jobStateToText :: JobState -> Text
jobStateToText = \case
  JobState
JobStateUnknown -> Text
"unknown"
  JobState
JobStateEnqueued -> Text
"enqueued"
  JobState
JobStateWorking -> Text
"working"
  JobState
JobStateSuccess -> Text
"success"
  JobState
JobStateFailed -> Text
"failed"
  JobState
JobStateDead -> Text
"dead"

jobStateFromText :: Text -> Either String JobState
jobStateFromText :: Text -> Either String JobState
jobStateFromText Text
x =
  forall a b. a -> Maybe b -> Either a b
note
      (Text -> String
unpack
      forall a b. (a -> b) -> a -> b
$ Text
"Invalid JobState: "
      forall a. Semigroup a => a -> a -> a
<> Text
x
      forall a. Semigroup a => a -> a -> a
<> Text
", must be one of "
      forall a. Semigroup a => a -> a -> a
<> Text -> [Text] -> Text
T.intercalate Text
", " (forall k v. HashMap k v -> [k]
HashMap.keys HashMap Text JobState
jobStateMap)
      )
    forall a b. (a -> b) -> a -> b
$ forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HashMap.lookup Text
x HashMap Text JobState
jobStateMap

jobStateMap :: HashMap Text JobState
jobStateMap :: HashMap Text JobState
jobStateMap =
  forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HashMap.fromList forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (JobState -> Text
jobStateToText forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& forall a. a -> a
id) [forall a. Bounded a => a
minBound .. forall a. Bounded a => a
maxBound]
{-# NOINLINE jobStateMap #-}