(define-module (tiedote-md-package)
  #:use-module (guix)
  #:use-module (guix build-system haskell)
  #:use-module (guix download)
  #:use-module (guix git-download)
  #:use-module ((guix licenses) #:prefix license:)
  #:use-module (guix packages)
  #:use-module (gnu packages haskell)
  #:use-module (gnu packages haskell-xyz)
  #:use-module (gnu packages haskell-crypto)
  #:use-module (gnu packages haskell-check)
  #:use-module (gnu packages haskell-web)
  #:use-module (gnu packages golang-web)
  #:use-module (gnu packages version-control))

(define vcs-file?
  (or (git-predicate (string-append (current-source-directory) "/../.."))
      (const #t)))

(define-public tiedote-md
  (package
    (name "tiedote-md")
    (version "0.0.1-git")
    (source (local-file "../.." "tiedote-md-checkout"
                        #:recursive? #t
                        #:select? vcs-file?))
    (build-system haskell-build-system)
    (inputs (list ghc-acid-state
                  ghc-cryptonite
                  ghc-case-insensitive
                  ghc-purebred-email
                  ghc-optparse-applicative
                  ghc-filestore
                  ghc-hostname
                  ghc-pandoc
                  ghc-file-embed
                  ghc-safecopy
                  ghc-scotty
                  ghc-exit-codes
                  git
                  go-github-com-aymerick-douceur))
    (arguments
      (list
       #:phases
       #~(modify-phases %standard-phases
           (add-after 'install 'wrap-binaries
             (lambda _
               (wrap-program
                 (string-append #$output "/bin/tiedote.md")
                 `("PATH" prefix (,(string-append #$(this-package-input "git") "/bin")
                                  ,(string-append #$(this-package-input "go-github-com-aymerick-douceur")
                                                  "/bin")))))))))
    (home-page "https://git.olarinmaensamoojat.fi/OMS/tiedote.md")
    (synopsis "Git- ja markdown-pohjainen masssasähköpostijärjestelmä OMS:lle")
    (description
      "Tiedote.md on massasähköpostijärjestelmä, joka käyttää
massasähköpostien hallintaan git-tietovarastossa olevia markdown-tiedostoja ja
sähköpostipohjaista käyttöliittymää. Toistaiseksi tiedote.md on kovakoodattu
käyttämään OMS:n tiedotepohjia.")
    (license license:agpl3+)))

(define ghc-scotty
  (package
    (name "ghc-scotty")
    (version "0.12")
    (source (origin
              (method url-fetch)
              (uri (hackage-uri "scotty" version))
              (sha256
               (base32
                "1lpggpdzgjk23mq7aa64yylds5dbm4ynhcvbarqihjxabvh7xmz1"))))
    (build-system haskell-build-system)
    (inputs (list ghc-aeson
                  ghc-base-compat-batteries
                  ghc-blaze-builder
                  ghc-case-insensitive
                  ghc-data-default-class
                  ghc-fail
                  ghc-http-types
                  ghc-monad-control
                  ghc-nats
                  ghc-network
                  ghc-regex-compat
                  ghc-transformers-base
                  ghc-transformers-compat
                  ghc-wai
                  ghc-wai-extra
                  ghc-warp))
    (native-inputs (list ghc-async ghc-hspec ghc-hspec-wai ghc-lifted-base hspec-discover))
    (arguments
     `(#:cabal-revision ("7"
                         "1i8icc612w4dbmqmnf99drqpmjvhjnkmqgk9xr63amj8jkz5lp4m")))
    (home-page "https://github.com/scotty-web/scotty")
    (synopsis
     "Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp")
    (description
     "This package provides a Haskell web framework inspired by Ruby's Sinatra, using
WAI and Warp. . @ {-# LANGUAGE OverloadedStrings #-} .  import
Web.Scotty .  import Data.Monoid (mconcat) .  main = scotty 3000 $   get
&#34;/:word&#34; $ do &#32;&#32;&#32;&#32;beam <- param &#34;word&#34;
&#32;&#32;&#32;&#32;html $ mconcat [&#34;&#60;h1&#62;Scotty, &#34;, beam, &#34;
me up!&#60;/h1&#62;&#34;] @ . .  Scotty is the cheap and cheerful way to write
RESTful, declarative web applications. . * A page is as simple as defining the
verb, url pattern, and Text content. . * It is template-language agnostic.
Anything that returns a Text value will do. . * Conforms to WAI Application
interface. . * Uses very fast Warp webserver by default. .  As for the name:
Sinatra + Warp = Scotty. . [WAI] <http://hackage.haskell.org/package/wai> .
[Warp] <http://hackage.haskell.org/package/warp>")
    (license license:bsd-3)))

(define ghc-hspec-wai
  (package
    (name "ghc-hspec-wai")
    (version "0.11.1")
    (source (origin
              (method url-fetch)
              (uri (hackage-uri "hspec-wai" version))
              (sha256
               (base32
                "03wiksic5y9a2g6a86nsxrnajdgdvpv17w02h5qla0zp9zs6pa1j"))))
    (build-system haskell-build-system)
    (inputs (list ghc-quickcheck
                  ghc-base-compat
                  ghc-case-insensitive
                  ghc-hspec-core
                  ghc-hspec-expectations
                  ghc-http-types
                  ghc-wai
                  ghc-wai-extra))
    (native-inputs (list ghc-hspec hspec-discover))
    (home-page "https://github.com/hspec/hspec-wai#readme")
    (synopsis "Experimental Hspec support for testing WAI applications")
    (description "Experimental Hspec support for testing WAI applications")
    (license license:expat)))

(define ghc-acid-state
  (package
   (name "ghc-acid-state")
   (version "0.16.1.2")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "acid-state" version))
             (sha256
              (base32
               "1ixg62liif1g18ggxap8zdhzy261fj5d24pmb0n36gfhz18b38bx"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "acid-state")))
   (inputs (list ghc-cereal
                 ghc-safecopy
                 ghc-filelock
                 ghc-network
                 ghc-network-bsd
                 ghc-th-expand-syns))
   (native-inputs (list ghc-hspec ghc-hspec-discover ghc-hedgehog))
   (home-page "https://github.com/acid-state/acid-state")
   (synopsis "Add ACID guarantees to any serializable Haskell data structure.")
   (description
    "Use regular Haskell data structures as your database and get stronger ACID
guarantees than most RDBMS offer.")
   (license license:public-domain)))

(define ghc-safecopy
  (package
   (name "ghc-safecopy")
   (version "0.10.4.2")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "safecopy" version))
             (sha256
              (base32
               "0r2mf0p82gf8vnldx477b5ykrj1x7hyg13nqfn6gzb50japs6h3i"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "safecopy")))
   (inputs (list ghc-cereal
                 ghc-generic-data
                 ghc-old-time
                 ghc-vector))
   (native-inputs (list ghc-lens
                        ghc-lens-action
                        ghc-tasty
                        ghc-tasty-quickcheck
                        ghc-quickcheck-instances
                        ghc-quickcheck
                        ghc-hunit))
   (arguments
    `(#:cabal-revision ("6"
                        "0ii5cdg4l4ww81p7gd5m3z2jdqrs2hvqhwzrlz267nzxbws00x0b")))
   (home-page "https://github.com/acid-state/safecopy")
   (synopsis "Binary serialization with version control.")
   (description "An extension to Data.Serialize with built-in version control.")
   (license license:public-domain)))

(define ghc-generic-data
  (package
   (name "ghc-generic-data")
   (version "1.0.0.1")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "generic-data" version))
             (sha256
              (base32
               "0fz65k4sxn9c23rg5iv0vij2mksl5rkn6dl2f3i9d9d60b5wca9y"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "generic-data")))
   (inputs (list ghc-ap-normalize
                 ghc-contravariant
                 ghc-show-combinators))
   (native-inputs (list ghc-tasty
                        ghc-tasty-hunit
                        ghc-tasty
                        ghc-tasty-hunit
                        ghc-tasty
                        ghc-tasty-hunit
                        ghc-generic-lens
                        ghc-tasty
                        ghc-tasty-hunit
                        ghc-generic-lens
                        ghc-one-liner))
   (home-page "https://github.com/Lysxia/generic-data#readme")
   (synopsis "Deriving instances with GHC.Generics and related utilities")
   (description
    "Generic implementations of standard type classes.  Operations on generic
representations to help using \"GHC.Generics\".  See README.")
   (license license:expat)))

(define ghc-lens-action
  (package
   (name "ghc-lens-action")
   (version "0.2.6")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "lens-action" version))
             (sha256
              (base32
               "0cdprc5j6r976dmrga2zwvcr7qsv7nqy3nvncp66yyy0dk2qlwm3"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "lens-action")))
   (inputs (list ghc-lens ghc-comonad ghc-contravariant ghc-profunctors
                 ghc-semigroupoids))
   (arguments
    `(#:cabal-revision ("2"
                        "0rrrv7k0fz98j99a6gzw858v5w3i378g0b7ijj30dz2am6p6rfnm")))
   (home-page "http://github.com/ekmett/lens-action/")
   (synopsis "Monadic Getters and Folds")
   (description
    "This package contains combinators and types for working with monadic getters and
folds as split off from the original lens package.")
   (license license:bsd-3)))

(define ghc-ap-normalize
  (package
   (name "ghc-ap-normalize")
   (version "0.1.0.1")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "ap-normalize" version))
             (sha256
              (base32
               "1212zxc4qn6msk0w13yhrza2qjs79h78misllb4chng75jqi61l2"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "ap-normalize")))
   (native-inputs (list ghc-inspection-testing ghc-inspection-testing))
   (home-page "http://hackage.haskell.org/package/ap-normalize")
   (synopsis "Self-normalizing applicative expressions")
   (description
    "An applicative functor transformer to normalize expressions using @@(\\<$>)@@,
@@(\\<*>)@@, and @@pure@@ into a linear list of actions.  See \"ApNormalize\" to
get started.")
   (license license:expat)))

(define ghc-show-combinators
  (package
   (name "ghc-show-combinators")
   (version "0.2.0.0")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "show-combinators" version))
             (sha256
              (base32
               "07ds87ldl9165hj3k5h84iawc6vqlbggni3dg1nhbxww1spxn0n9"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "show-combinators")))
   (arguments
    `(#:cabal-revision ("2"
                        "0n3xlpm41wpw1ybmacg9s7150nx00qrdlw2rq4fzz7iw7333cyjx")))
   (home-page "https://github.com/Lysxia/show-combinators#readme")
   (synopsis "Combinators to write Show instances")
   (description
    "This package provides a minimal pretty-printing library for Show instances in
Haskell.")
   (license license:expat)))

(define ghc-generic-lens
  (package
   (name "ghc-generic-lens")
   (version "2.2.2.0")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "generic-lens" version))
             (sha256
              (base32
               "0s4b51s11ssmndmx9m9zbwgv9rb27ajwihsrk10hn582rp4ck3c6"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "generic-lens")))
   (inputs (list ghc-generic-lens-core ghc-profunctors))
   (native-inputs (list ghc-lens
                        ghc-inspection-testing
                        ghc-hunit
                        ghc-lens
                        ghc-hunit
                        ghc-lens
                        ghc-hunit
                        ghc-doctest
                        ghc-lens))
   (home-page "https://github.com/kcsongor/generic-lens")
   (synopsis "Generically derive traversals, lenses and prisms.")
   (description
    "This library uses GHC.Generics to derive efficient optics (traversals, lenses
and prisms) for algebraic data types in a type-directed way, with a focus on
good type inference and error messages when possible.  The library exposes a
van Laarhoven interface.  For an alternative interface, supporting an opaque
optic type, see @@<https://hackage.haskell.org/package/generic-optics
generic-optics>@@.")
   (license license:bsd-3)))

(define ghc-one-liner
  (package
   (name "ghc-one-liner")
   (version "2.1")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "one-liner" version))
             (sha256
              (base32
               "09gdivd38disddxs42179vmgca0yzk5dfm6ygicgl5l25qbizrfh"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "one-liner")))
   (inputs (list ghc-contravariant ghc-bifunctors ghc-profunctors ghc-tagged
                 ghc-linear-base))
   (native-inputs (list ghc-hunit))
   (arguments
    `(#:cabal-revision ("1"
                        "1n6d74s0x91qi4fi6wv5yggjb1nvwk0ir580mkf67bca2x6f1cqn")))
   (home-page "https://github.com/sjoerdvisscher/one-liner")
   (synopsis "Constraint-based generics")
   (description
    "Write short and concise generic instances of type classes.  one-liner is
particularly useful for writing default implementations of type class methods.")
   (license license:bsd-3)))

(define ghc-generic-lens-core
  (package
   (name "ghc-generic-lens-core")
   (version "2.2.1.0")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "generic-lens-core" version))
             (sha256
              (base32
               "08i4c9yb6z84iknrnl9f3f343121j7ilp0a679v81nsjm9xz3rlf"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "generic-lens-core")))
   (inputs (list ghc-indexed-profunctors))
   (arguments
    `(#:cabal-revision ("1"
                        "1dbjhd6k7ypqa9f4h9v2xndgb4mjhfli3n1vjm8r8ga0kfndbqfn")))
   (home-page "https://github.com/kcsongor/generic-lens")
   (synopsis "Generically derive traversals, lenses and prisms.")
   (description
    "This library uses GHC.Generics to derive efficient optics (traversals, lenses
and prisms) for algebraic data types in a type-directed way, with a focus on
good type inference and error messages when possible.  This package is the
shared internal logic of the @@<https://hackage.haskell.org/package/generic-lens
generic-lens>@@ and @@<https://hackage.haskell.org/package/generic-optics
generic-optics>@@ libraries.")
   (license license:bsd-3)))

(define ghc-indexed-profunctors
  (package
   (name "ghc-indexed-profunctors")
   (version "0.1.1")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "indexed-profunctors" version))
             (sha256
              (base32
               "1cbccbvrx73drr1jf3yyw0rp1mcfv3jc1rvdcby5xxx4ja543fjs"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "indexed-profunctors")))
   (home-page "http://hackage.haskell.org/package/indexed-profunctors")
   (synopsis "Utilities for indexed profunctors")
   (description
    "This package contains basic definitions related to indexed profunctors.  These
are primarily intended as internal utilities to support the @@optics@@ and
@@generic-lens@@ package families.")
   (license license:bsd-3)))

(define ghc-linear-base
  (package
   (name "ghc-linear-base")
   (version "0.3.1")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "linear-base" version))
             (sha256
              (base32
               "1gm8bwyi39x5x29xb6nq13x9x9p30vm29s11k4pkcql70sj4pv0h"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "linear-base")))
   (inputs (list ghc-hashable ghc-linear-generics ghc-storable-tuple ghc-vector
                 ghc-primitive))
   (native-inputs (list ghc-inspection-testing
                        ghc-tasty-inspection-testing
                        ghc-hedgehog
                        ghc-tasty
                        ghc-tasty-hedgehog
                        ghc-mmorph
                        ghc-tasty
                        ghc-tasty-hedgehog
                        ghc-hedgehog))
   (arguments
    `(#:cabal-revision ("1"
                        "153nkw2i7n22xzfj8q2xmzsh77pr7pay8v3gc1xli491qmsc0fcd")))
   (home-page "https://github.com/tweag/linear-base#README")
   (synopsis "Standard library for linear types.")
   (description "Please see README.md.")
   (license license:expat)))

(define ghc-linear-generics
  (package
   (name "ghc-linear-generics")
   (version "0.2.2")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "linear-generics" version))
             (sha256
              (base32
               "0ls571qzayky0dax9d209lw9wv344z3969daqcsncv0r5rlvlps9"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "linear-generics")))
   (inputs (list ghc-th-abstraction-0.5))
   (native-inputs (list ghc-hspec hspec-discover))
   (home-page "https://github.com/linear-generics/linear-generics")
   (synopsis "Generic programming library for generalised deriving.")
   (description
    "This package offers a version of
<https://hackage.haskell.org/package/base/docs/GHC-Generics.html GHC.Generics>
with two important improvements:  1. The @@to@@, @@from@@, @@to1@@, and
@@from1@@ methods have multiplicity-polymorphic types, allowing them to be used
with either traditional Haskell code or linearly typed code.  2. The
representations used for @@Generic1@@ are modified slightly.")
   (license license:bsd-3)))

(define ghc-th-abstraction-0.5
  (package
   (inherit ghc-th-abstraction)
   (version "0.5.0.0")
   (source (origin
            (method url-fetch)
            (uri (hackage-uri "th-abstraction" version))
            (sha256
             (base32
              "0r4ri85283i1jjhd94wa9nps6cd9a8mh6rr4ds1gb2hqnwxdqn42"))))))

(define ghc-filestore
  (package
   (name "ghc-filestore")
   (version "0.6.5")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "filestore" version))
             (sha256
              (base32
               "0z29273vdqjsrj4vby0gp7d12wg9nkzq9zgqg18db0p5948jw1dh"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "filestore")))
   (inputs (list ghc-utf8-string ghc-xml ghc-split ghc-diff ghc-old-locale git mercurial))
   (native-inputs (list ghc-hunit))
   (arguments
    `(#:cabal-revision ("1"
                        "1v9xqm0112knv6za05qf310ldndrc0h3xhajgwjaycbzkrknz4n7")))
   (home-page "http://hackage.haskell.org/package/filestore")
   (synopsis "Interface for versioning file stores.")
   (description
    "The filestore library provides an abstract interface for a versioning file
store, and modules that instantiate this interface.  Currently Git, Darcs, and
Mercurial modules are provided, and other VCSs or databases could be added.")
   (license license:bsd-3)))

(define ghc-purebred-email
  (package
   (name "ghc-purebred-email")
   (version "0.6.0.1")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "purebred-email" version))
             (sha256
               (base32
                 "0gdzdbxgsyps8hqd903bsyja0cr6kbklkicvma62q48wv0y7230j"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "purebred-email")))
   (inputs (list ghc-attoparsec
                 ghc-case-insensitive
                 ghc-lens
                 ghc-base64-bytestring
                 ghc-concise
                 ghc-random
                 ghc-semigroupoids
                 ghc-stringsearch))
   (native-inputs (list ghc-tasty
                        ghc-tasty-hedgehog
                        ghc-tasty-quickcheck
                        ghc-tasty-hunit
                        ghc-tasty-golden
                        ghc-hedgehog
                        ghc-quickcheck-instances))
   (home-page "https://github.com/purebred-mua/purebred-email")
   (synopsis "types and parser for email messages (including MIME)")
   (description
     "The purebred email library.  RFC 5322, MIME, etc.  See \"Data.MIME\" for usage,
examples and API documentation. .  This is a general-purpose library for
processing and constructing email messages, originally written to meet the needs
of <https://github.com/purebred-mua/purebred purebred MUA>.  Transmission and
delivery of mail are not part of this library, but /purebred-email/ could be a
useful building block for such systems. .  Features and implemented
specifications include: . - <https://tools.ietf.org/html/rfc5322 RFC 5322>
message parsing and serialisation - MIME multipart messages
(<https://tools.ietf.org/html/rfc2046 RFC 2046>) - Convenient APIs for replying
and forward/bounce - Content transfer and charset decoding/encoding - MIME
message header extensions for non-ASCII text
(<https://tools.ietf.org/html/rfc2047 RFC 2047>) - MIME parameter value and
encoded word extensions (<https://tools.ietf.org/html/rfc2231 RFC 2231>) -
@@Content-Disposition@@ header field (<https://tools.ietf.org/html/rfc2183 RFC 2183>) - Address syntax in @@From@@ and @@Sender@@ fields
     (<https://tools.ietf.org/html/rfc6854 RFC 6854>)")
     (license license:agpl3+)))

(define ghc-concise
  (package
   (name "ghc-concise")
   (version "0.1.0.1")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "concise" version))
             (sha256
               (base32
                 "09crgc6gjfidlad6263253xx1di6wfhc9awhira21s0z7rddy9sw"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "concise")))
   (inputs (list ghc-lens))
   (native-inputs (list ghc-tasty ghc-tasty-quickcheck ghc-quickcheck
                        ghc-quickcheck-instances))
   (home-page "https://github.com/frasertweedale/hs-concise")
   (synopsis "Utilities for Control.Lens.Cons")
   (description
     "concise provides a handful of functions to extend what you can do with
 Control.Lens.Cons.")
     (license license:bsd-3)))

(define ghc-exit-codes
  (package
   (name "ghc-exit-codes")
   (version "1.0.0")
   (source (origin
             (method url-fetch)
             (uri (hackage-uri "exit-codes" version))
             (sha256
               (base32
                 "00cyli96zkyqhjr3lqzrislqyk72xwm2dcqvjagklidh32d4k8ja"))))
   (build-system haskell-build-system)
   (properties '((upstream-name . "exit-codes")))
   (home-page "http://github.com/JustusAdam/exit-codes")
   (synopsis "Exit codes as defined by BSD")
   (description
     "Expose the exit codes defined by BSD in sysexits.h to the Haskell world.")
   (license license:bsd-3)))

tiedote-md