298 lines
9.0 KiB
Elm
298 lines
9.0 KiB
Elm
module Entry exposing (main)
|
|
|
|
import Browser
|
|
import Http
|
|
|
|
import Json.Decode as D
|
|
import Json.Decode.Pipeline as P
|
|
|
|
import Html exposing (..)
|
|
import Html.Attributes exposing (..)
|
|
import Html.Events exposing (..)
|
|
|
|
import NumberInput
|
|
import Select
|
|
|
|
main = Browser.element
|
|
{ init = \globals ->
|
|
( Context globals <| ItemSearch { searchTerm = "", searchResults = [] }
|
|
, Cmd.none
|
|
)
|
|
, subscriptions = \_ -> Sub.none
|
|
, update = update
|
|
, view = view
|
|
}
|
|
|
|
-- Data types
|
|
|
|
type alias SearchResult =
|
|
{ barcode : String
|
|
, name : String
|
|
, netUnitPrice : Float
|
|
, bought : String
|
|
, salesUnits : Int
|
|
, available : Bool
|
|
, locationName : String
|
|
, locationId : Int
|
|
, groupName : String
|
|
, groupId : Int
|
|
, taxGroupId : Int
|
|
}
|
|
|
|
searchResultDecoder =
|
|
D.succeed SearchResult
|
|
|> P.required "item_barcode" D.string
|
|
|> P.required "name" D.string
|
|
|> P.required "unit_price" D.float
|
|
|> P.required "bought" D.string
|
|
|> P.required "sales_units" D.int
|
|
|> P.required "available" D.bool
|
|
|> P.required "location_name" D.string
|
|
|> P.required "location_id" D.int
|
|
|> P.required "group_name" D.string
|
|
|> P.required "group_id" D.int
|
|
|> P.required "tax_group_id" D.int
|
|
|
|
type alias Location =
|
|
{ id : Int
|
|
, name : String
|
|
}
|
|
|
|
type alias Group =
|
|
{ id : Int
|
|
, name : String
|
|
}
|
|
|
|
type alias TaxGroup =
|
|
{ id : Int
|
|
, description : String
|
|
, percentage : Float
|
|
}
|
|
|
|
type alias Context =
|
|
{ globals : Globals
|
|
, state : State
|
|
}
|
|
|
|
type alias Globals =
|
|
{ locations : List Location
|
|
, groups : List Group
|
|
, taxGroups : List TaxGroup
|
|
}
|
|
|
|
type State
|
|
= ItemSearch
|
|
{ searchTerm : String
|
|
, searchResults : List SearchResult
|
|
}
|
|
| ItemEditor
|
|
{ barcode : String
|
|
, name : String
|
|
, salesUnits : NumberInput.Model Int
|
|
, netUnitPrice : NumberInput.Model Float
|
|
, grossUnitPrice : NumberInput.Model Float
|
|
, group : Select.Model Group
|
|
, location : Select.Model Location
|
|
, taxGroup : Select.Model TaxGroup
|
|
}
|
|
|
|
type Msg
|
|
= SetSearchTerm String
|
|
| SubmitSearch
|
|
| ReceiveSearchResults (Result Http.Error (List SearchResult))
|
|
| GotoItemEditor SearchResult
|
|
| SetBarcode String
|
|
| SetName String
|
|
| SetSalesUnits String
|
|
| SetNetUnitPrice String
|
|
| SetGrossUnitPrice String
|
|
| SetGroup String
|
|
| SetLocation String
|
|
| SetTaxGroup String
|
|
|
|
-- Update logic: State machine etc.
|
|
|
|
update msg { globals, state } =
|
|
let
|
|
(state_, cmd) = updateState msg globals state
|
|
in
|
|
({ globals = globals, state = state_ }, cmd)
|
|
|
|
updateState msg globals state = case state of
|
|
ItemSearch model -> case msg of
|
|
SetSearchTerm searchTerm ->
|
|
(ItemSearch { model | searchTerm = searchTerm }, Cmd.none)
|
|
SubmitSearch ->
|
|
( state
|
|
, Http.get
|
|
{ url = "/entry/api/search-items?search-term=" ++ model.searchTerm
|
|
, expect = Http.expectJson ReceiveSearchResults <| D.list searchResultDecoder
|
|
}
|
|
)
|
|
ReceiveSearchResults (Ok searchResults) ->
|
|
(ItemSearch { model | searchResults = searchResults }, Cmd.none)
|
|
GotoItemEditor searchResult ->
|
|
case find (\tg -> tg.id == searchResult.taxGroupId) globals.taxGroups of
|
|
Nothing -> (state, Cmd.none)
|
|
Just taxGroup ->
|
|
( ItemEditor <| updateGrossUnitPrice
|
|
{ barcode = searchResult.barcode
|
|
, name = searchResult.name
|
|
, netUnitPrice = NumberInput.fromFloat searchResult.netUnitPrice
|
|
, grossUnitPrice = NumberInput.fromFloat 0
|
|
, salesUnits = NumberInput.fromInt searchResult.salesUnits
|
|
, group = Select.init (.id >> String.fromInt) (.name) { id = searchResult.groupId, name = searchResult.groupName } globals.groups
|
|
, location = Select.init (.id >> String.fromInt) (.name) { id = searchResult.locationId, name = searchResult.locationName } globals.locations
|
|
, taxGroup = Select.init (.id >> String.fromInt) (.description) taxGroup globals.taxGroups
|
|
}
|
|
, Cmd.none
|
|
)
|
|
_ ->
|
|
(state, Cmd.none)
|
|
ItemEditor model -> case msg of
|
|
SetBarcode barcode ->
|
|
(ItemEditor { model | barcode = barcode }, Cmd.none)
|
|
SetName name ->
|
|
(ItemEditor { model | name = name }, Cmd.none)
|
|
SetSalesUnits str ->
|
|
(ItemEditor { model | salesUnits = NumberInput.update str model.salesUnits }, Cmd.none)
|
|
SetNetUnitPrice str ->
|
|
( ItemEditor <| updateGrossUnitPrice { model | netUnitPrice = NumberInput.update str model.netUnitPrice }
|
|
, Cmd.none
|
|
)
|
|
SetGrossUnitPrice str ->
|
|
(ItemEditor { model | grossUnitPrice = NumberInput.update str model.grossUnitPrice }, Cmd.none)
|
|
SetGroup key ->
|
|
(ItemEditor { model | group = Select.update key model.group }, Cmd.none)
|
|
SetLocation key ->
|
|
(ItemEditor { model | location = Select.update key model.location }, Cmd.none)
|
|
SetTaxGroup key ->
|
|
( ItemEditor <| updateGrossUnitPrice { model | taxGroup = Select.update key model.taxGroup }
|
|
, Cmd.none
|
|
)
|
|
_ ->
|
|
(state, Cmd.none)
|
|
|
|
updateGrossUnitPrice model =
|
|
{ model
|
|
| grossUnitPrice = Maybe.withDefault model.grossUnitPrice <| Maybe.map NumberInput.fromFloat <| calculateGarfieldPrice model
|
|
}
|
|
|
|
-- View stuff
|
|
|
|
view { globals, state } = case state of
|
|
ItemSearch model ->
|
|
fieldset []
|
|
[ legend [] [ text "Vorlage für neuen Inventareintrag" ]
|
|
, Html.form [ onSubmit SubmitSearch ]
|
|
[ div [ class "form-input" ]
|
|
[ label [ for "search-term", title "Barcode oder Name" ] [ text "Suchbegriff" ]
|
|
, input [ onInput SetSearchTerm, value model.searchTerm, id "search-term" ] []
|
|
]
|
|
, table [] <| searchResultHeaders :: List.map viewSearchResult model.searchResults
|
|
]
|
|
]
|
|
ItemEditor model ->
|
|
Html.form []
|
|
[ fieldset []
|
|
[ legend [] [ text "Neuer Inventareintrag" ]
|
|
, div [ class "form-input" ]
|
|
[ label [ for "barcode" ] [ text "Barcode" ]
|
|
, input [ onInput SetBarcode, value model.barcode, disabled True, id "barcode" ] []
|
|
]
|
|
, div [ class "form-input" ]
|
|
[ label [ for "name" ] [ text "Name" ]
|
|
, input [ onInput SetName, value model.name, id "name" ] []
|
|
]
|
|
, div [ class "form-input" ]
|
|
[ label [ for "sales-units" ] [ text "Stückzahl" ]
|
|
, input [ onInput SetSalesUnits, value <| NumberInput.show model.salesUnits, id "sales-units", type_ "number" ] []
|
|
]
|
|
, div [ class "form-input" ]
|
|
[ label [ for "group" ] [ text "Gruppe" ]
|
|
, Select.view SetGroup model.group
|
|
]
|
|
, div [ class "form-input" ]
|
|
[ label [ for "location" ] [ text "Raum" ]
|
|
, Select.view SetLocation model.location
|
|
]
|
|
, div [ class "form-input" ]
|
|
[ label [ for "net-unit-price" ] [ text "Stückpreis (Netto)" ]
|
|
, input
|
|
[ value <| NumberInput.show model.netUnitPrice
|
|
, onInput SetNetUnitPrice
|
|
, type_ "number"
|
|
, id "net-unit-price"
|
|
, step "0.01"
|
|
]
|
|
[]
|
|
]
|
|
, div [ class "form-input" ]
|
|
[ label [ for "tax-group" ] [ text "Steuergruppe" ]
|
|
, Select.view SetTaxGroup model.taxGroup
|
|
]
|
|
]
|
|
, fieldset []
|
|
[ legend [] [ text "Neuer Snackeintrag" ]
|
|
, div [ class "form-input" ]
|
|
[ label [ for "snack-name" ] [ text "Name" ]
|
|
, input [ value model.name, disabled True, id "snack-name" ] []
|
|
]
|
|
, viewGrossUnitPriceInput model
|
|
]
|
|
]
|
|
|
|
viewGrossUnitPriceInput model =
|
|
let
|
|
suggestedPriceStr = case calculateGarfieldPrice model of
|
|
Nothing -> "?"
|
|
Just suggestedPrice -> String.fromFloat suggestedPrice
|
|
in
|
|
div [ class "form-input" ]
|
|
[ label [ for "gross-unit-price" ]
|
|
[ text <| "Stückpreis (Brutto), Vorschlag: " ++ suggestedPriceStr
|
|
]
|
|
, input [ onInput SetGrossUnitPrice, value <| NumberInput.show model.grossUnitPrice, id "gross-unit-price", type_ "number", step "0.01" ] []
|
|
]
|
|
|
|
searchResultHeaders =
|
|
tr []
|
|
[ th [] [ text "Barcode" ]
|
|
, th [] [ text "Name" ]
|
|
, th [] [ text "Gruppe" ]
|
|
, th [] [ text "Stückpreis (Netto)" ]
|
|
, th [] [ text "Eingekauft" ]
|
|
, th [] [ text "Kaufdatum" ]
|
|
, th [] [ text "Raum" ]
|
|
, th [] [ text "Aktiv?" ]
|
|
, th [] []
|
|
]
|
|
|
|
viewSearchResult model =
|
|
tr []
|
|
[ td [] [ code [] [ text model.barcode ] ]
|
|
, td [] [ text model.name ]
|
|
, td [] [ text model.groupName ]
|
|
, td [] [ text <| String.fromFloat model.netUnitPrice ]
|
|
, td [] [ text <| String.fromInt model.salesUnits ]
|
|
, td [] [ text model.bought ]
|
|
, td [] [ text model.locationName ]
|
|
, td [] [ text <| showBool model.available ]
|
|
, td []
|
|
[ button [ onClick <| GotoItemEditor model ] [ text "Als Vorlage verwenden" ]
|
|
]
|
|
]
|
|
|
|
calculateGarfieldPrice model =
|
|
NumberInput.get model.netUnitPrice |> Maybe.map (\netUnitPrice ->
|
|
roundTo 2 <| netUnitPrice * (1 + (Select.get model.taxGroup).percentage) + 0.01
|
|
)
|
|
|
|
roundTo places x = toFloat (round <| x * 10 ^ places) / 10 ^ places
|
|
|
|
showBool b = case b of
|
|
True -> "✅"
|
|
False -> "❌"
|
|
|
|
find pred xs = List.head <| List.filter pred xs
|