MF-237 - Add support for storing messages in MongoDB (#307)

* Add mongodb-writer

Signed-off-by: Darko Draskovic <darko.draskovic@gmail.com>

* Add official mongodb driver

Signed-off-by: Darko Draskovic <darko.draskovic@gmail.com>

* Move Connect to main.go

Signed-off-by: Darko Draskovic <darko.draskovic@gmail.com>

* Remove bson.NewDoc and write msg directly in db

Signed-off-by: Darko Draskovic <darko.draskovic@gmail.com>

* Add MongoDB writer tests

Signed-off-by: Dušan Borovčanin <dusan.borovcanin@mainflux.com>

* Update README.md

Signed-off-by: Dušan Borovčanin <dusan.borovcanin@mainflux.com>

* Add mongodb services compose to addons dir

Signed-off-by: Dušan Borovčanin <dusan.borovcanin@mainflux.com>

* Update docs

Signed-off-by: Dušan Borovčanin <dusan.borovcanin@mainflux.com>

* Update docs and tests

Refactor code.

Signed-off-by: Dušan Borovčanin <dusan.borovcanin@mainflux.com>

* Expose MetricsMiddleware to align writers with other services

Signed-off-by: Dušan Borovčanin <dusan.borovcanin@mainflux.com>

* Add logging middleware

Signed-off-by: Dušan Borovčanin <dusan.borovcanin@mainflux.com>

* Update load tests version

Signed-off-by: Dušan Borovčanin <dusan.borovcanin@mainflux.com>

Gopkg.lock

@@ -32,13 +32,13 @@
   branch = "master"
   name = "github.com/beorn7/perks"
   packages = ["quantile"]
-  revision = "4c0e84591b9aa9e6dcfdf3e020114cd81f89d5f9"
+  revision = "3a771d992973f24aa725d07868b467d1ddfceafb"
 
 [[projects]]
   name = "github.com/cenkalti/backoff"
   packages = ["."]
-  revision = "61153c768f31ee5f130071d08fc82b85208528de"
-  version = "v1.1.0"
+  revision = "2ea60e5f094469f9e65adb9cd103795b73ae743e"
+  version = "v2.0.0"
 
 [[projects]]
   branch = "master"
@@ -50,7 +50,7 @@
   branch = "master"
   name = "github.com/containerd/continuity"
   packages = ["pathdriver"]
-  revision = "d8fb8589b0e8e85b8c8bbaa8840226d0dfeb7371"
+  revision = "c6cef34830231743494fe2969284df7b82cc0ad0"
 
 [[projects]]
   name = "github.com/davecgh/go-spew"
@@ -58,50 +58,12 @@
   revision = "346938d642f2ec3594ed81d874461961cd0faa76"
   version = "v1.1.0"
 
-[[projects]]
-  branch = "master"
-  name = "github.com/dereulenspiegel/coap-mux"
-  packages = ["."]
-  revision = "e137e310a99955be01d60b2237da89153ea40987"
-
 [[projects]]
   name = "github.com/dgrijalva/jwt-go"
   packages = ["."]
   revision = "06ea1031745cb8b3dab3f6a236daf2b0aa468b7e"
   version = "v3.2.0"
 
-[[projects]]
-  branch = "master"
-  name = "github.com/docker/docker"
-  packages = [
-    "api/types",
-    "api/types/blkiodev",
-    "api/types/container",
-    "api/types/filters",
-    "api/types/mount",
-    "api/types/network",
-    "api/types/registry",
-    "api/types/strslice",
-    "api/types/swarm",
-    "api/types/swarm/runtime",
-    "api/types/versions",
-    "opts",
-    "pkg/archive",
-    "pkg/fileutils",
-    "pkg/homedir",
-    "pkg/idtools",
-    "pkg/ioutils",
-    "pkg/jsonmessage",
-    "pkg/longpath",
-    "pkg/mount",
-    "pkg/pools",
-    "pkg/stdcopy",
-    "pkg/system",
-    "pkg/term",
-    "pkg/term/windows"
-  ]
-  revision = "72ba7f593fa4dbb628cf5ee83cd7daf955934cf5"
-
 [[projects]]
   name = "github.com/docker/go-connections"
   packages = ["nat"]
@@ -111,20 +73,8 @@
 [[projects]]
   name = "github.com/docker/go-units"
   packages = ["."]
-  revision = "0dadbb0345b35ec7ef35e228dabb8de89a65bf52"
-  version = "v0.3.2"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/dustin/go-coap"
-  packages = ["."]
-  revision = "ddcc80675fa42611359d91a6dfa5aa57fb90e72b"
-
-[[projects]]
-  name = "github.com/fsouza/go-dockerclient"
-  packages = ["."]
-  revision = "ca33ff277b527ce11b793e62f9ba244129b01caf"
-  version = "v1.2.0"
+  revision = "47565b4f722fb6ceae66b95f853feed578a4a51c"
+  version = "v0.3.3"
 
 [[projects]]
   name = "github.com/go-kit/kit"
@@ -134,6 +84,7 @@
     "metrics",
     "metrics/internal/lv",
     "metrics/prometheus",
+    "transport/grpc",
     "transport/http"
   ]
   revision = "4dc7be5d2d12881735283bcab7352178e190fc71"
@@ -165,9 +116,15 @@
 
 [[projects]]
   name = "github.com/golang/protobuf"
-  packages = ["proto"]
-  revision = "925541529c1fa6821df4e44ce2723319eb2be768"
-  version = "v1.0.0"
+  packages = [
+    "proto",
+    "ptypes",
+    "ptypes/any",
+    "ptypes/duration",
+    "ptypes/timestamp"
+  ]
+  revision = "b4deda0973fb4c70b50d226b1af49f3da59f5265"
+  version = "v1.1.0"
 
 [[projects]]
   name = "github.com/gorilla/websocket"
@@ -176,19 +133,14 @@
   version = "v1.2.0"
 
 [[projects]]
-  name = "github.com/jinzhu/gorm"
+  name = "github.com/influxdata/influxdb"
   packages = [
-    ".",
-    "dialects/postgres"
+    "client/v2",
+    "models",
+    "pkg/escape"
   ]
-  revision = "6ed508ec6a4ecb3531899a69cbc746ccf65a4166"
-  version = "v1.9.1"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/jinzhu/inflection"
-  packages = ["."]
-  revision = "04140366298a54a039076d798123ffa108fff46c"
+  revision = "02d7d4f043b34ecb4e9b2dbec298c6f9450c2a32"
+  version = "v1.5.2"
 
 [[projects]]
   branch = "master"
@@ -201,10 +153,9 @@
   name = "github.com/lib/pq"
   packages = [
     ".",
-    "hstore",
     "oid"
   ]
-  revision = "88edab0803230a3898347e77b474f8c1820a1f20"
+  revision = "d34b9ff171c21ad295489235aec8b6626023cd04"
 
 [[projects]]
   name = "github.com/matttproud/golang_protobuf_extensions"
@@ -212,6 +163,37 @@
   revision = "3247c84500bff8d9fb6d579d800f20b3e091582c"
   version = "v1.0.0"
 
+[[projects]]
+  name = "github.com/mongodb/mongo-go-driver"
+  packages = [
+    "bson",
+    "bson/builder",
+    "bson/decimal",
+    "bson/elements",
+    "bson/objectid",
+    "core/addr",
+    "core/auth",
+    "core/auth/internal/gssapi",
+    "core/command",
+    "core/connection",
+    "core/connstring",
+    "core/description",
+    "core/dispatch",
+    "core/options",
+    "core/readconcern",
+    "core/readpref",
+    "core/result",
+    "core/tag",
+    "core/topology",
+    "core/version",
+    "core/wiremessage",
+    "core/writeconcern",
+    "internal",
+    "mongo"
+  ]
+  revision = "29a4d7d5b648e5b0b60e03e3bd71c11703f0c203"
+  version = "v0.0.5"
+
 [[projects]]
   name = "github.com/nats-io/go-nats"
   packages = [
@@ -219,8 +201,8 @@
     "encoders/builtin",
     "util"
   ]
-  revision = "d66cb54e6b7bdd93f0b28afc8450d84c780dfb68"
-  version = "v1.4.0"
+  revision = "062418ea1c2181f52dc0f954f6204370519a868b"
+  version = "v1.5.0"
 
 [[projects]]
   name = "github.com/nats-io/nuid"
@@ -252,6 +234,37 @@
   revision = "baf6536d6259209c3edfa2b22237af82942d3dfa"
   version = "v0.1.1"
 
+[[projects]]
+  name = "github.com/ory/dockertest"
+  packages = [
+    "docker",
+    "docker/opts",
+    "docker/pkg/archive",
+    "docker/pkg/fileutils",
+    "docker/pkg/homedir",
+    "docker/pkg/idtools",
+    "docker/pkg/ioutils",
+    "docker/pkg/jsonmessage",
+    "docker/pkg/longpath",
+    "docker/pkg/mount",
+    "docker/pkg/pools",
+    "docker/pkg/stdcopy",
+    "docker/pkg/system",
+    "docker/pkg/term",
+    "docker/pkg/term/windows",
+    "docker/types",
+    "docker/types/blkiodev",
+    "docker/types/container",
+    "docker/types/filters",
+    "docker/types/mount",
+    "docker/types/network",
+    "docker/types/registry",
+    "docker/types/strslice",
+    "docker/types/versions"
+  ]
+  revision = "2e92e7784b6fb199fd168aa46269a2f1b34f299e"
+  version = "v3.3.0"
+
 [[projects]]
   name = "github.com/pkg/errors"
   packages = ["."]
@@ -287,7 +300,7 @@
     "internal/bitbucket.org/ww/goautoneg",
     "model"
   ]
-  revision = "e4aa40a9169a88835b849a6efb71e05dc04b88f0"
+  revision = "d811d2e9bf898806ecfb6ef6296774b13ffc314c"
 
 [[projects]]
   branch = "master"
@@ -298,7 +311,16 @@
     "nfs",
     "xfs"
   ]
-  revision = "54d17b57dd7d4a3aa092476596b3f8a933bde349"
+  revision = "8b1c2da0d56deffdbb9e48d4414b4e674bd8083e"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/rubenv/sql-migrate"
+  packages = [
+    ".",
+    "sqlparse"
+  ]
+  revision = "081fe17d19ff4e2dd9f5a0c1158e6bcf74da6906"
 
 [[projects]]
   name = "github.com/satori/go.uuid"
@@ -327,33 +349,8 @@
 [[projects]]
   name = "github.com/ugorji/go"
   packages = ["codec"]
-  revision = "9831f2c3ac1068a78f50999a30db84270f647af6"
-  version = "v1.1"
-
-[[projects]]
-  name = "go.uber.org/atomic"
-  packages = ["."]
-  revision = "8474b86a5a6f79c443ce4b2992817ff32cf208b8"
-  version = "v1.3.1"
-
-[[projects]]
-  name = "go.uber.org/multierr"
-  packages = ["."]
-  revision = "3c4937480c32f4c13a875a1829af76c98ca3d40a"
-  version = "v1.1.0"
-
-[[projects]]
-  name = "go.uber.org/zap"
-  packages = [
-    ".",
-    "buffer",
-    "internal/bufferpool",
-    "internal/color",
-    "internal/exit",
-    "zapcore"
-  ]
-  revision = "35aad584952c3e7020db7b839f6b102de6271f89"
-  version = "v1.7.1"
+  revision = "b4c50a2b199d93b13dc15e78929cfb23bfdf21ab"
+  version = "v1.1.1"
 
 [[projects]]
   branch = "master"
@@ -361,18 +358,30 @@
   packages = [
     "bcrypt",
     "blowfish",
+    "pbkdf2",
     "ssh/terminal"
   ]
-  revision = "374053ea96cb300f8671b8d3b07edeeb06e203b4"
+  revision = "2d027ae1dddd4694d54f7a8b6cbe78dca8720226"
 
 [[projects]]
   branch = "master"
   name = "golang.org/x/net"
   packages = [
     "context",
-    "context/ctxhttp"
+    "http/httpguts",
+    "http2",
+    "http2/hpack",
+    "idna",
+    "internal/timeseries",
+    "trace"
   ]
-  revision = "24dd3780ca4f75fed9f321890729414a4b5d3f13"
+  revision = "f73e4c9ed3b7ebdd5f699a16a880c2b1994e50dd"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/sync"
+  packages = ["semaphore"]
+  revision = "1d60e4601c6fd243af51cc01ddf169918a5407ca"
 
 [[projects]]
   branch = "master"
@@ -381,17 +390,81 @@
     "unix",
     "windows"
   ]
-  revision = "01acb38716e021ed1fc03a602bdb5838e1358c5e"
+  revision = "7dfd1290c7917b7ba22824b9d24954ab3002fe24"
+
+[[projects]]
+  name = "golang.org/x/text"
+  packages = [
+    "collate",
+    "collate/build",
+    "internal/colltab",
+    "internal/gen",
+    "internal/tag",
+    "internal/triegen",
+    "internal/ucd",
+    "language",
+    "secure/bidirule",
+    "transform",
+    "unicode/bidi",
+    "unicode/cldr",
+    "unicode/norm",
+    "unicode/rangetable"
+  ]
+  revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
+  version = "v0.3.0"
+
+[[projects]]
+  branch = "master"
+  name = "google.golang.org/genproto"
+  packages = ["googleapis/rpc/status"]
+  revision = "86e600f69ee4704c6efbf6a2a40a5c10700e76c2"
+
+[[projects]]
+  name = "google.golang.org/grpc"
+  packages = [
+    ".",
+    "balancer",
+    "balancer/base",
+    "balancer/roundrobin",
+    "channelz",
+    "codes",
+    "connectivity",
+    "credentials",
+    "encoding",
+    "encoding/proto",
+    "grpclb/grpc_lb_v1/messages",
+    "grpclog",
+    "internal",
+    "keepalive",
+    "metadata",
+    "naming",
+    "peer",
+    "resolver",
+    "resolver/dns",
+    "resolver/passthrough",
+    "stats",
+    "status",
+    "tap",
+    "transport"
+  ]
+  revision = "41344da2231b913fa3d983840a57a6b1b7b631a1"
+  version = "v1.12.0"
+
+[[projects]]
+  name = "gopkg.in/gorp.v1"
+  packages = ["."]
+  revision = "c87af80f3cc5036b55b83d77171e156791085e2e"
+  version = "v1.7.1"
 
 [[projects]]
   name = "gopkg.in/ory-am/dockertest.v3"
   packages = ["."]
-  revision = "15c8e8835bba04e0d7c2b57958ffe294d5e643dc"
-  version = "v3.1.6"
+  revision = "2e92e7784b6fb199fd168aa46269a2f1b34f299e"
+  version = "v3.3.0"
 
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "c1b28e90e21e838cec2d16c95d8eb414b5de9bbe9667acb01b5375db047cc6db"
+  inputs-digest = "6010ae4c4f91c30b3a63789cc280466ce56d50f387c1e4d11c49df1302f083da"
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -6,18 +6,10 @@
   branch = "master"
   name = "github.com/cisco/senml"
 
-[[constraint]]
-  branch = "master"
-  name = "github.com/dereulenspiegel/coap-mux"
-
 [[constraint]]
   name = "github.com/dgrijalva/jwt-go"
   version = "3.2.0"
 
-[[constraint]]
-  branch = "master"
-  name = "github.com/dustin/go-coap"
-
 [[constraint]]
   name = "github.com/go-kit/kit"
   version = "0.6.0"
@@ -28,11 +20,7 @@
 
 [[constraint]]
   name = "github.com/golang/protobuf"
-  version = "1.0.0"
-
-[[constraint]]
-  name = "github.com/jinzhu/gorm"
-  version = "1.9.1"
+  version = "1.1.0"
 
 [[constraint]]
   branch = "master"
@@ -58,10 +46,6 @@
   name = "github.com/stretchr/testify"
   version = "1.2.1"
 
-[[constraint]]
-  name = "go.uber.org/zap"
-  version = "1.7.1"
-
 [[constraint]]
   branch = "master"
   name = "golang.org/x/crypto"
@@ -74,6 +58,18 @@
   name = "github.com/gorilla/websocket"
   version = "1.2.0"
 
+[[constraint]]
+  branch = "master"
+  name = "github.com/rubenv/sql-migrate"
+
+[[constraint]]
+  name = "github.com/influxdata/influxdb"
+  version = "1.5.2"
+
+[[constraint]]
+  name = "github.com/mongodb/mongo-go-driver"
+  version = "0.0.5"
+
 [prune]
   go-tests = true
   unused-packages = true

Makefile

@@ -1,5 +1,5 @@
 BUILD_DIR = build
-SERVICES = manager http normalizer ws
+SERVICES = users things http normalizer ws influxdb mongodb
 DOCKERS = $(addprefix docker_,$(SERVICES))
 CGO_ENABLED ?= 0
 GOOS ?= linux
@@ -23,7 +23,7 @@ install:
 	cp ${BUILD_DIR}/* $(GOBIN)
 
 proto:
-	protoc --go_out=. *.proto
+	protoc --go_out=plugins=grpc:. *.proto
 
 $(SERVICES): proto
 	$(call compile_service,$(@))
@@ -32,11 +32,15 @@ $(DOCKERS):
 	$(call make_docker,$(@))
 
 dockers: $(DOCKERS)
+	docker build --tag=mainflux/dashflux -f dashflux/docker/Dockerfile dashflux
+	docker build --tag=mainflux/mqtt -f mqtt/Dockerfile .
 
 latest: dockers
 	for svc in $(SERVICES); do \
 		docker push mainflux/$$svc; \
 	done
+	docker push mainflux/dashflux
+	docker push mainflux/mqtt
 
 release:
 	$(eval version = $(shell git describe --abbrev=0 --tags))
@@ -46,3 +50,7 @@ release:
 		docker tag mainflux/$$svc mainflux/$$svc:$(version); \
 		docker push mainflux/$$svc:$(version); \
 	done
+	docker tag mainflux/dashflux mainflux/dashflux:$(version)
+	docker push mainflux/dashflux:$(version)
+	docker tag mainflux/mqtt mainflux/mqtt:$(version)
+	docker push mainflux/mqtt:$(version)

api.go

@@ -0,0 +1,13 @@
+package mainflux
+
+// Response contains HTTP response specific methods.
+type Response interface {
+	// Code returns HTTP response code.
+	Code() int
+
+	// Headers returns map of HTTP headers with their values.
+	Headers() map[string]string
+
+	// Empty indicates if HTTP response has content.
+	Empty() bool
+}

cmd/coap/main.go

@@ -1,83 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"os/signal"
-	"syscall"
-
-	"github.com/mainflux/mainflux/coap"
-	"github.com/mainflux/mainflux/coap/nats"
-
-	broker "github.com/nats-io/go-nats"
-	"go.uber.org/zap"
-)
-
-const (
-	port       int    = 5683
-	defNatsURL string = broker.DefaultURL
-	envNatsURL string = "COAP_ADAPTER_NATS_URL"
-)
-
-type config struct {
-	Port    int
-	NatsURL string
-}
-
-func main() {
-	cfg := loadConfig()
-
-	logger, _ := zap.NewProduction()
-	defer logger.Sync() // flushes buffer, if any
-
-	nc := connectToNats(cfg, logger)
-	defer nc.Close()
-
-	pub := nats.NewMessagePublisher(nc)
-	ca := adapter.NewCoAPAdapter(logger, pub)
-
-	nc.Subscribe("src.http", ca.BridgeHandler)
-	nc.Subscribe("src.mqtt", ca.BridgeHandler)
-
-	errs := make(chan error, 2)
-
-	go func() {
-		coapAddr := fmt.Sprintf(":%d", cfg.Port)
-		errs <- ca.Serve(coapAddr)
-	}()
-
-	go func() {
-		c := make(chan os.Signal)
-		signal.Notify(c, syscall.SIGINT)
-		errs <- fmt.Errorf("%s", <-c)
-	}()
-
-	c := <-errs
-	logger.Info("terminated", zap.String("error", c.Error()))
-}
-
-func loadConfig() *config {
-	return &config{
-		NatsURL: env(envNatsURL, defNatsURL),
-		Port:    port,
-	}
-}
-
-func env(key, fallback string) string {
-	value := os.Getenv(key)
-	if value == "" {
-		return fallback
-	}
-
-	return value
-}
-
-func connectToNats(cfg *config, logger *zap.Logger) *broker.Conn {
-	nc, err := broker.Connect(cfg.NatsURL)
-	if err != nil {
-		logger.Error("Failed to connect to NATS", zap.Error(err))
-		os.Exit(1)
-	}
-
-	return nc
-}

cmd/http/main.go

@@ -13,31 +13,32 @@ import (
 	"github.com/mainflux/mainflux/http/api"
 	"github.com/mainflux/mainflux/http/nats"
 	log "github.com/mainflux/mainflux/logger"
-	manager "github.com/mainflux/mainflux/manager/client"
+	thingsapi "github.com/mainflux/mainflux/things/api/grpc"
 	broker "github.com/nats-io/go-nats"
 	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	"google.golang.org/grpc"
 )
 
 const (
-	defPort       string = "8180"
-	defNatsURL    string = broker.DefaultURL
-	defManagerURL string = "http://localhost:8180"
-	envPort       string = "MF_HTTP_ADAPTER_PORT"
-	envNatsURL    string = "MF_NATS_URL"
-	envManagerURL string = "MF_MANAGER_URL"
+	defPort      string = "8180"
+	defNatsURL   string = broker.DefaultURL
+	defThingsURL string = "localhost:8181"
+	envPort      string = "MF_HTTP_ADAPTER_PORT"
+	envNatsURL   string = "MF_NATS_URL"
+	envThingsURL string = "MF_THINGS_URL"
 )
 
 type config struct {
-	ManagerURL string
-	NatsURL    string
-	Port       string
+	ThingsURL string
+	NatsURL   string
+	Port      string
 }
 
 func main() {
 	cfg := config{
-		ManagerURL: mainflux.Env(envManagerURL, defManagerURL),
-		NatsURL:    mainflux.Env(envNatsURL, defNatsURL),
-		Port:       mainflux.Env(envPort, defPort),
+		ThingsURL: mainflux.Env(envThingsURL, defThingsURL),
+		NatsURL:   mainflux.Env(envNatsURL, defNatsURL),
+		Port:      mainflux.Env(envPort, defPort),
 	}
 
 	logger := log.New(os.Stdout)
@@ -49,6 +50,14 @@ func main() {
 	}
 	defer nc.Close()
 
+	conn, err := grpc.Dial(cfg.ThingsURL, grpc.WithInsecure())
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to users service: %s", err))
+		os.Exit(1)
+	}
+	defer conn.Close()
+
+	cc := thingsapi.NewClient(conn)
 	pub := nats.NewMessagePublisher(nc)
 
 	svc := adapter.New(pub)
@@ -73,9 +82,8 @@ func main() {
 
 	go func() {
 		p := fmt.Sprintf(":%s", cfg.Port)
-		mc := manager.NewClient(cfg.ManagerURL)
 		logger.Info(fmt.Sprintf("HTTP adapter service started, exposed port %s", cfg.Port))
-		errs <- http.ListenAndServe(p, api.MakeHandler(svc, mc))
+		errs <- http.ListenAndServe(p, api.MakeHandler(svc, cc))
 	}()
 
 	go func() {

cmd/influxdb/main.go

@@ -0,0 +1,139 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+
+	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
+	influxdata "github.com/influxdata/influxdb/client/v2"
+	"github.com/mainflux/mainflux"
+	log "github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/writers"
+	"github.com/mainflux/mainflux/writers/influxdb"
+	nats "github.com/nats-io/go-nats"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+)
+
+const (
+	name         = "influxdb-writer"
+	senML        = "out.senml"
+	prefix       = "http://"
+	defNatsURL   = nats.DefaultURL
+	defPort      = "8180"
+	defPointName = "messages"
+	defDBName    = "mainflux"
+	defDBHost    = "localhost"
+	defDBPort    = "8086"
+	defDBUser    = "mainflux"
+	defDBPass    = "mainflux"
+
+	envNatsURL = "MF_NATS_URL"
+	envPort    = "MF_INFLUX_WRITER_PORT"
+	envDBName  = "MF_INFLUX_WRITER_DB_NAME"
+	envDBHost  = "MF_INFLUX_WRITER_DB_HOST"
+	envDBPort  = "MF_INFLUX_WRITER_DB_PORT"
+	envDBUser  = "MF_INFLUX_WRITER_DB_USER"
+	envDBPass  = "MF_INFLUX_WRITER_DB_PASS"
+)
+
+type config struct {
+	NatsURL string
+	Port    string
+	DBName  string
+	DBHost  string
+	DBPort  string
+	DBUser  string
+	DBPass  string
+}
+
+func main() {
+	cfg, clientCfg := loadConfigs()
+	logger := log.New(os.Stdout)
+
+	nc, err := nats.Connect(cfg.NatsURL)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to NATS: %s", err))
+		os.Exit(1)
+	}
+	defer nc.Close()
+
+	client, err := influxdata.NewHTTPClient(clientCfg)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to create InfluxDB client: %s", err))
+		os.Exit(1)
+	}
+	defer client.Close()
+
+	repo, err := influxdb.New(client, cfg.DBName)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to create InfluxDB writer: %s", err))
+		os.Exit(1)
+	}
+
+	counter, latency := makeMetrics()
+	repo = writers.LoggingMiddleware(repo, logger)
+	repo = writers.MetricsMiddleware(repo, counter, latency)
+	if err := writers.Start(name, nc, logger, repo); err != nil {
+		logger.Error(fmt.Sprintf("Failed to start message writer: %s", err))
+		os.Exit(1)
+	}
+
+	errs := make(chan error, 2)
+	go func() {
+		c := make(chan os.Signal)
+		signal.Notify(c, syscall.SIGINT)
+		errs <- fmt.Errorf("%s", <-c)
+	}()
+
+	go startHTTPService(cfg.Port, logger, errs)
+
+	err = <-errs
+	logger.Error(fmt.Sprintf("InfluxDB writer service terminated: %s", err))
+}
+
+func loadConfigs() (config, influxdata.HTTPConfig) {
+	cfg := config{
+		NatsURL: mainflux.Env(envNatsURL, defNatsURL),
+		Port:    mainflux.Env(envPort, defPort),
+		DBName:  mainflux.Env(envDBName, defDBName),
+		DBHost:  mainflux.Env(envDBHost, defDBHost),
+		DBPort:  mainflux.Env(envDBPort, defDBPort),
+		DBUser:  mainflux.Env(envDBUser, defDBUser),
+		DBPass:  mainflux.Env(envDBPass, defDBPass),
+	}
+
+	clientCfg := influxdata.HTTPConfig{
+		Addr:     fmt.Sprintf("%s%s:%s", prefix, cfg.DBHost, cfg.DBPort),
+		Username: cfg.DBUser,
+		Password: cfg.DBPass,
+	}
+
+	return cfg, clientCfg
+}
+
+func makeMetrics() (*kitprometheus.Counter, *kitprometheus.Summary) {
+	counter := kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
+		Namespace: "influxdb",
+		Subsystem: "message_writer",
+		Name:      "request_count",
+		Help:      "Number of database inserts.",
+	}, []string{"method"})
+
+	latency := kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+		Namespace: "influxdb",
+		Subsystem: "message_writer",
+		Name:      "request_latency_microseconds",
+		Help:      "Total duration of inserts in microseconds.",
+	}, []string{"method"})
+
+	return counter, latency
+}
+
+func startHTTPService(port string, logger log.Logger, errs chan error) {
+	p := fmt.Sprintf(":%s", port)
+	logger.Info(fmt.Sprintf("Influxdb writer service started, exposed port %s", p))
+	errs <- http.ListenAndServe(p, influxdb.MakeHandler())
+}

cmd/manager/main.go

@@ -1,108 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"net/http"
-	"os"
-	"os/signal"
-	"syscall"
-
-	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
-	"github.com/mainflux/mainflux"
-	log "github.com/mainflux/mainflux/logger"
-	"github.com/mainflux/mainflux/manager"
-	"github.com/mainflux/mainflux/manager/api"
-	"github.com/mainflux/mainflux/manager/bcrypt"
-	"github.com/mainflux/mainflux/manager/jwt"
-	"github.com/mainflux/mainflux/manager/postgres"
-	stdprometheus "github.com/prometheus/client_golang/prometheus"
-)
-
-const (
-	defDBHost string = "localhost"
-	defDBPort string = "5432"
-	defDBUser string = "mainflux"
-	defDBPass string = "mainflux"
-	defDBName string = "manager"
-	defPort   string = "8180"
-	defSecret string = "manager"
-	envDBHost string = "MF_DB_HOST"
-	envDBPort string = "MF_DB_PORT"
-	envDBUser string = "MF_DB_USER"
-	envDBPass string = "MF_DB_PASS"
-	envDBName string = "MF_MANAGER_DB"
-	envPort   string = "MF_MANAGER_PORT"
-	envSecret string = "MF_MANAGER_SECRET"
-)
-
-type config struct {
-	DBHost string
-	DBPort string
-	DBUser string
-	DBPass string
-	DBName string
-	Port   string
-	Secret string
-}
-
-func main() {
-	cfg := config{
-		DBHost: mainflux.Env(envDBHost, defDBHost),
-		DBPort: mainflux.Env(envDBPort, defDBPort),
-		DBUser: mainflux.Env(envDBUser, defDBUser),
-		DBPass: mainflux.Env(envDBPass, defDBPass),
-		DBName: mainflux.Env(envDBName, defDBName),
-		Port:   mainflux.Env(envPort, defPort),
-		Secret: mainflux.Env(envSecret, defSecret),
-	}
-
-	logger := log.New(os.Stdout)
-
-	db, err := postgres.Connect(cfg.DBHost, cfg.DBPort, cfg.DBName, cfg.DBUser, cfg.DBPass)
-	if err != nil {
-		logger.Error(fmt.Sprintf("Failed to connect to postgres: %s", err))
-		os.Exit(1)
-	}
-	defer db.Close()
-
-	users := postgres.NewUserRepository(db)
-	clients := postgres.NewClientRepository(db)
-	channels := postgres.NewChannelRepository(db)
-	hasher := bcrypt.New()
-	idp := jwt.New(cfg.Secret)
-
-	svc := manager.New(users, clients, channels, hasher, idp)
-	svc = api.LoggingMiddleware(svc, logger)
-	svc = api.MetricsMiddleware(
-		svc,
-		kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
-			Namespace: "manager",
-			Subsystem: "api",
-			Name:      "request_count",
-			Help:      "Number of requests received.",
-		}, []string{"method"}),
-		kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
-			Namespace: "manager",
-			Subsystem: "api",
-			Name:      "request_latency_microseconds",
-			Help:      "Total duration of requests in microseconds.",
-		}, []string{"method"}),
-	)
-
-	errs := make(chan error, 2)
-
-	go func() {
-		p := fmt.Sprintf(":%s", cfg.Port)
-		logger.Info(fmt.Sprintf("Manager service started, exposed port %s", cfg.Port))
-		errs <- http.ListenAndServe(p, api.MakeHandler(svc))
-	}()
-
-	go func() {
-		c := make(chan os.Signal)
-		signal.Notify(c, syscall.SIGINT)
-		errs <- fmt.Errorf("%s", <-c)
-	}()
-
-	err = <-errs
-	logger.Error(fmt.Sprintf("Manager service terminated: %s", err))
-}

cmd/mongodb/main.go

@@ -0,0 +1,121 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+
+	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
+	"github.com/mainflux/mainflux"
+	log "github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/writers"
+	mongodb "github.com/mainflux/mainflux/writers/mongodb"
+	"github.com/mongodb/mongo-go-driver/mongo"
+	nats "github.com/nats-io/go-nats"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+)
+
+const (
+	name       = "mongodb-writer"
+	defNatsURL = nats.DefaultURL
+	defPort    = "8180"
+	defDBName  = "mainflux"
+	defDBHost  = "localhost"
+	defDBPort  = "27017"
+
+	envNatsURL = "MF_NATS_URL"
+	envPort    = "MF_MONGO_WRITER_PORT"
+	envDBName  = "MF_MONGO_WRITER_DB_NAME"
+	envDBHost  = "MF_MONGO_WRITER_DB_HOST"
+	envDBPort  = "MF_MONGO_WRITER_DB_PORT"
+)
+
+type config struct {
+	NatsURL string
+	Port    string
+	DBName  string
+	DBHost  string
+	DBPort  string
+}
+
+func main() {
+	cfg := loadConfigs()
+	logger := log.New(os.Stdout)
+
+	nc, err := nats.Connect(cfg.NatsURL)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to NATS: %s", err))
+		os.Exit(1)
+	}
+	defer nc.Close()
+
+	client, err := mongo.Connect(context.Background(), fmt.Sprintf("mongodb://%s:%s", cfg.DBHost, cfg.DBPort), nil)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to database: %s", err))
+		os.Exit(1)
+	}
+
+	db := client.Database(cfg.DBName)
+	repo, err := mongodb.New(db)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to create MongoDB writer: %s", err))
+		os.Exit(1)
+	}
+
+	counter, latency := makeMetrics()
+	repo = writers.LoggingMiddleware(repo, logger)
+	repo = writers.MetricsMiddleware(repo, counter, latency)
+	if err := writers.Start(name, nc, logger, repo); err != nil {
+		logger.Error(fmt.Sprintf("Failed to start message writer: %s", err))
+		os.Exit(1)
+	}
+
+	errs := make(chan error, 2)
+	go func() {
+		c := make(chan os.Signal)
+		signal.Notify(c, syscall.SIGINT)
+		errs <- fmt.Errorf("%s", <-c)
+	}()
+
+	go startHTTPService(cfg.Port, logger, errs)
+
+	err = <-errs
+	logger.Error(fmt.Sprintf("MongoDB writer service terminated: %s", err))
+}
+
+func loadConfigs() config {
+	return config{
+		NatsURL: mainflux.Env(envNatsURL, defNatsURL),
+		Port:    mainflux.Env(envPort, defPort),
+		DBName:  mainflux.Env(envDBName, defDBName),
+		DBHost:  mainflux.Env(envDBHost, defDBHost),
+		DBPort:  mainflux.Env(envDBPort, defDBPort),
+	}
+}
+
+func makeMetrics() (*kitprometheus.Counter, *kitprometheus.Summary) {
+	counter := kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
+		Namespace: "mongodb",
+		Subsystem: "message_writer",
+		Name:      "request_count",
+		Help:      "Number of database inserts.",
+	}, []string{"method"})
+
+	latency := kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+		Namespace: "mongodb",
+		Subsystem: "message_writer",
+		Name:      "request_latency_microseconds",
+		Help:      "Total duration of inserts in microseconds.",
+	}, []string{"method"})
+
+	return counter, latency
+}
+
+func startHTTPService(port string, logger log.Logger, errs chan error) {
+	p := fmt.Sprintf(":%s", port)
+	logger.Info(fmt.Sprintf("Mongodb writer service started, exposed port %s", p))
+	errs <- http.ListenAndServe(p, mongodb.MakeHandler())
+}

cmd/things/main.go

@@ -0,0 +1,156 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+
+	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
+	"github.com/mainflux/mainflux"
+	log "github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/things"
+	"github.com/mainflux/mainflux/things/api"
+	grpcapi "github.com/mainflux/mainflux/things/api/grpc"
+	httpapi "github.com/mainflux/mainflux/things/api/http"
+	"github.com/mainflux/mainflux/things/postgres"
+	"github.com/mainflux/mainflux/things/uuid"
+	usersapi "github.com/mainflux/mainflux/users/api/grpc"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	"google.golang.org/grpc"
+)
+
+const (
+	defDBHost   = "localhost"
+	defDBPort   = "5432"
+	defDBUser   = "mainflux"
+	defDBPass   = "mainflux"
+	defDBName   = "things"
+	defHTTPPort = "8180"
+	defGRPCPort = "8181"
+	defUsersURL = "localhost:8181"
+	envDBHost   = "MF_THINGS_DB_HOST"
+	envDBPort   = "MF_THINGS_DB_PORT"
+	envDBUser   = "MF_THINGS_DB_USER"
+	envDBPass   = "MF_THINGS_DB_PASS"
+	envDBName   = "MF_THINGS_DB"
+	envHTTPPort = "MF_THINGS_HTTP_PORT"
+	envGRPCPort = "MF_THINGS_GRPC_PORT"
+	envUsersURL = "MF_USERS_URL"
+)
+
+type config struct {
+	DBHost   string
+	DBPort   string
+	DBUser   string
+	DBPass   string
+	DBName   string
+	HTTPPort string
+	GRPCPort string
+	UsersURL string
+}
+
+func main() {
+	cfg := loadConfig()
+
+	logger := log.New(os.Stdout)
+
+	db := connectToDB(cfg, logger)
+	defer db.Close()
+
+	conn := connectToUsersService(cfg.UsersURL, logger)
+	defer conn.Close()
+
+	svc := newService(conn, db, logger)
+	errs := make(chan error, 2)
+
+	go startHTTPServer(svc, cfg.HTTPPort, logger, errs)
+	go startGRPCServer(svc, cfg.GRPCPort, logger, errs)
+
+	go func() {
+		c := make(chan os.Signal)
+		signal.Notify(c, syscall.SIGINT)
+		errs <- fmt.Errorf("%s", <-c)
+	}()
+
+	err := <-errs
+	logger.Error(fmt.Sprintf("Things service terminated: %s", err))
+}
+
+func loadConfig() config {
+	return config{
+		DBHost:   mainflux.Env(envDBHost, defDBHost),
+		DBPort:   mainflux.Env(envDBPort, defDBPort),
+		DBUser:   mainflux.Env(envDBUser, defDBUser),
+		DBPass:   mainflux.Env(envDBPass, defDBPass),
+		DBName:   mainflux.Env(envDBName, defDBName),
+		HTTPPort: mainflux.Env(envHTTPPort, defHTTPPort),
+		GRPCPort: mainflux.Env(envGRPCPort, defGRPCPort),
+		UsersURL: mainflux.Env(envUsersURL, defUsersURL),
+	}
+}
+
+func connectToDB(cfg config, logger log.Logger) *sql.DB {
+	db, err := postgres.Connect(cfg.DBHost, cfg.DBPort, cfg.DBName, cfg.DBUser, cfg.DBPass)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to postgres: %s", err))
+		os.Exit(1)
+	}
+	return db
+}
+
+func connectToUsersService(usersAddr string, logger log.Logger) *grpc.ClientConn {
+	conn, err := grpc.Dial(usersAddr, grpc.WithInsecure())
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to users service: %s", err))
+		os.Exit(1)
+	}
+	return conn
+}
+
+func newService(conn *grpc.ClientConn, db *sql.DB, logger log.Logger) things.Service {
+	users := usersapi.NewClient(conn)
+	thingsRepo := postgres.NewThingRepository(db, logger)
+	channelsRepo := postgres.NewChannelRepository(db, logger)
+	idp := uuid.New()
+
+	svc := things.New(users, thingsRepo, channelsRepo, idp)
+	svc = api.LoggingMiddleware(svc, logger)
+	svc = api.MetricsMiddleware(
+		svc,
+		kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: "things",
+			Subsystem: "api",
+			Name:      "request_count",
+			Help:      "Number of requests received.",
+		}, []string{"method"}),
+		kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+			Namespace: "things",
+			Subsystem: "api",
+			Name:      "request_latency_microseconds",
+			Help:      "Total duration of requests in microseconds.",
+		}, []string{"method"}),
+	)
+	return svc
+}
+
+func startHTTPServer(svc things.Service, port string, logger log.Logger, errs chan error) {
+	p := fmt.Sprintf(":%s", port)
+	logger.Info(fmt.Sprintf("Things service started, exposed port %s", port))
+	errs <- http.ListenAndServe(p, httpapi.MakeHandler(svc))
+}
+
+func startGRPCServer(svc things.Service, port string, logger log.Logger, errs chan error) {
+	p := fmt.Sprintf(":%s", port)
+	listener, err := net.Listen("tcp", p)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to listen on port %s: %s", port, err))
+	}
+	server := grpc.NewServer()
+	mainflux.RegisterThingsServiceServer(server, grpcapi.NewServer(svc))
+	logger.Info(fmt.Sprintf("Things gRPC service started, exposed port %s", port))
+	errs <- server.Serve(listener)
+}

cmd/users/main.go

@@ -0,0 +1,143 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+
+	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
+	"github.com/mainflux/mainflux"
+	log "github.com/mainflux/mainflux/logger"
+	"github.com/mainflux/mainflux/users"
+	"github.com/mainflux/mainflux/users/api"
+	grpcapi "github.com/mainflux/mainflux/users/api/grpc"
+	httpapi "github.com/mainflux/mainflux/users/api/http"
+	"github.com/mainflux/mainflux/users/bcrypt"
+	"github.com/mainflux/mainflux/users/jwt"
+	"github.com/mainflux/mainflux/users/postgres"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	"google.golang.org/grpc"
+)
+
+const (
+	defDBHost   = "localhost"
+	defDBPort   = "5432"
+	defDBUser   = "mainflux"
+	defDBPass   = "mainflux"
+	defDBName   = "users"
+	defHTTPPort = "8180"
+	defGRPCPort = "8181"
+	defSecret   = "users"
+	envDBHost   = "MF_USERS_DB_HOST"
+	envDBPort   = "MF_USERS_DB_PORT"
+	envDBUser   = "MF_USERS_DB_USER"
+	envDBPass   = "MF_USERS_DB_PASS"
+	envDBName   = "MF_USERS_DB"
+	envHTTPPort = "MF_USERS_HTTP_PORT"
+	envGRPCPort = "MF_USERS_GRPC_PORT"
+	envSecret   = "MF_USERS_SECRET"
+)
+
+type config struct {
+	DBHost   string
+	DBPort   string
+	DBUser   string
+	DBPass   string
+	DBName   string
+	HTTPPort string
+	GRPCPort string
+	Secret   string
+}
+
+func main() {
+	cfg := loadConfig()
+
+	logger := log.New(os.Stdout)
+
+	db := connectToDB(cfg, logger)
+	defer db.Close()
+
+	svc := newService(db, cfg.Secret, logger)
+	errs := make(chan error, 2)
+
+	go startHTTPServer(svc, cfg.HTTPPort, logger, errs)
+	go startGRPCServer(svc, cfg.GRPCPort, logger, errs)
+
+	go func() {
+		c := make(chan os.Signal)
+		signal.Notify(c, syscall.SIGINT)
+		errs <- fmt.Errorf("%s", <-c)
+	}()
+
+	err := <-errs
+	logger.Error(fmt.Sprintf("Users service terminated: %s", err))
+}
+
+func loadConfig() config {
+	return config{
+		DBHost:   mainflux.Env(envDBHost, defDBHost),
+		DBPort:   mainflux.Env(envDBPort, defDBPort),
+		DBUser:   mainflux.Env(envDBUser, defDBUser),
+		DBPass:   mainflux.Env(envDBPass, defDBPass),
+		DBName:   mainflux.Env(envDBName, defDBName),
+		HTTPPort: mainflux.Env(envHTTPPort, defHTTPPort),
+		GRPCPort: mainflux.Env(envGRPCPort, defGRPCPort),
+		Secret:   mainflux.Env(envSecret, defSecret),
+	}
+}
+
+func connectToDB(cfg config, logger log.Logger) *sql.DB {
+	db, err := postgres.Connect(cfg.DBHost, cfg.DBPort, cfg.DBName, cfg.DBUser, cfg.DBPass)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to postgres: %s", err))
+		os.Exit(1)
+	}
+	return db
+}
+
+func newService(db *sql.DB, secret string, logger log.Logger) users.Service {
+	repo := postgres.New(db)
+	hasher := bcrypt.New()
+	idp := jwt.New(secret)
+
+	svc := users.New(repo, hasher, idp)
+	svc = api.LoggingMiddleware(svc, logger)
+	svc = api.MetricsMiddleware(
+		svc,
+		kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: "users",
+			Subsystem: "api",
+			Name:      "request_count",
+			Help:      "Number of requests received.",
+		}, []string{"method"}),
+		kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+			Namespace: "users",
+			Subsystem: "api",
+			Name:      "request_latency_microseconds",
+			Help:      "Total duration of requests in microseconds.",
+		}, []string{"method"}),
+	)
+	return svc
+}
+
+func startHTTPServer(svc users.Service, port string, logger log.Logger, errs chan error) {
+	p := fmt.Sprintf(":%s", port)
+	logger.Info(fmt.Sprintf("Users HTTP service started, exposed port %s", port))
+	errs <- http.ListenAndServe(p, httpapi.MakeHandler(svc, logger))
+}
+
+func startGRPCServer(svc users.Service, port string, logger log.Logger, errs chan error) {
+	p := fmt.Sprintf(":%s", port)
+	listener, err := net.Listen("tcp", p)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to listen on port %s: %s", port, err))
+	}
+	server := grpc.NewServer()
+	mainflux.RegisterUsersServiceServer(server, grpcapi.NewServer(svc))
+	logger.Info(fmt.Sprintf("Users gRPC service started, exposed port %s", port))
+	errs <- server.Serve(listener)
+}

cmd/ws/main.go

@@ -10,34 +10,35 @@ import (
 	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
 	"github.com/mainflux/mainflux"
 	log "github.com/mainflux/mainflux/logger"
-	manager "github.com/mainflux/mainflux/manager/client"
+	thingsapi "github.com/mainflux/mainflux/things/api/grpc"
 	adapter "github.com/mainflux/mainflux/ws"
 	"github.com/mainflux/mainflux/ws/api"
 	"github.com/mainflux/mainflux/ws/nats"
 	broker "github.com/nats-io/go-nats"
 	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	"google.golang.org/grpc"
 )
 
 const (
-	defPort       = "8180"
-	defNatsURL    = broker.DefaultURL
-	defManagerURL = "http://localhost:8180"
-	envPort       = "MF_WS_ADAPTER_PORT"
-	envNatsURL    = "MF_NATS_URL"
-	envManagerURL = "MF_MANAGER_URL"
+	defPort      = "8180"
+	defNatsURL   = broker.DefaultURL
+	defThingsURL = "localhost:8181"
+	envPort      = "MF_WS_ADAPTER_PORT"
+	envNatsURL   = "MF_NATS_URL"
+	envThingsURL = "MF_THINGS_URL"
 )
 
 type config struct {
-	ManagerURL string
-	NatsURL    string
-	Port       string
+	ThingsURL string
+	NatsURL   string
+	Port      string
 }
 
 func main() {
 	cfg := config{
-		ManagerURL: mainflux.Env(envManagerURL, defManagerURL),
-		NatsURL:    mainflux.Env(envNatsURL, defNatsURL),
-		Port:       mainflux.Env(envPort, defPort),
+		ThingsURL: mainflux.Env(envThingsURL, defThingsURL),
+		NatsURL:   mainflux.Env(envNatsURL, defNatsURL),
+		Port:      mainflux.Env(envPort, defPort),
 	}
 
 	logger := log.New(os.Stdout)
@@ -49,6 +50,14 @@ func main() {
 	}
 	defer nc.Close()
 
+	conn, err := grpc.Dial(cfg.ThingsURL, grpc.WithInsecure())
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to connect to users service: %s", err))
+		os.Exit(1)
+	}
+	defer conn.Close()
+
+	cc := thingsapi.NewClient(conn)
 	pubsub := nats.New(nc)
 	svc := adapter.New(pubsub)
 	svc = api.LoggingMiddleware(svc, logger)
@@ -72,9 +81,8 @@ func main() {
 
 	go func() {
 		p := fmt.Sprintf(":%s", cfg.Port)
-		mc := manager.NewClient(cfg.ManagerURL)
 		logger.Info(fmt.Sprintf("WebSocket adapter service started, exposed port %s", cfg.Port))
-		errs <- http.ListenAndServe(p, api.MakeHandler(svc, mc, logger))
+		errs <- http.ListenAndServe(p, api.MakeHandler(svc, cc, logger))
 	}()
 
 	go func() {

coap/README.md

@@ -1,52 +0,0 @@
-# Mainflux CoAP Adapter
-
-Mainflux CoAP adapter provides an [CoAP](http://coap.technology/) API for sending messages through the
-platform.
-
-## Configuration
-
-The service is configured using the environment variables presented in the
-following table. Note that any unset variables will be replaced with their
-default values.
-
-| Variable              | Description       | Default               |
-|-----------------------|-------------------|-----------------------|
-| COAP_ADAPTER_NATS_URL | NATS instance URL | nats://localhost:4222 |
-
-## Deployment
-
-The service is distributed as Docker container. The following snippet provides
-a compose file template that can be used to deploy the service container locally:
-
-```yaml
-version: "2"
-services:
-  adapter:
-    image: mainflux/coap-adapter:[version]
-    container_name: [instance name]
-    ports:
-      - [host machine port]:5683
-    environment:
-      COAP_ADAPTER_NATS_URL: [NATS instance URL]
-```
-
-To start the service outside of the container, execute the following shell script:
-
-```bash
-# download the latest version of the service
-go get github.com/mainflux/mainflux
-
-cd $GOPATH/src/github.com/mainflux/mainflux/cmd/coap
-
-# compile the app; make sure to set the proper GOOS value
-CGO_ENABLED=0 GOOS=[platform identifier] go build -ldflags "-s" -a -installsuffix cgo -o app
-
-# set the environment variables and run the service
-COAP_ADAPTER_NATS_URL=[NATS instance URL] app
-```
-
-## Usage
-
-For more information about service capabilities and its usage, please check out
-the [API documentation](swagger.yaml).
-

coap/adapter.go

@@ -1,61 +0,0 @@
-package adapter
-
-import (
-	"encoding/json"
-	"log"
-	"net"
-
-	"github.com/dustin/go-coap"
-	"github.com/mainflux/mainflux"
-	broker "github.com/nats-io/go-nats"
-	"go.uber.org/zap"
-)
-
-const protocol string = "coap"
-
-type Observer struct {
-	conn    *net.UDPConn
-	addr    *net.UDPAddr
-	message *coap.Message
-}
-
-type CoAPAdapter struct {
-	obsMap map[string][]Observer
-	logger *zap.Logger
-	pub    mainflux.MessagePublisher
-}
-
-// NewCoAPAdapter creates new CoAP adapter struct
-func NewCoAPAdapter(logger *zap.Logger, pub mainflux.MessagePublisher) *CoAPAdapter {
-	ca := &CoAPAdapter{
-		logger: logger,
-		pub:    pub,
-		obsMap: make(map[string][]Observer),
-	}
-
-	return ca
-}
-
-// Serve function starts CoAP server
-func (ca *CoAPAdapter) Serve(addr string) error {
-	ca.logger.Info("Starting CoAP server", zap.String("address", addr))
-	return coap.ListenAndServe("udp", addr, ca.COAPServer())
-}
-
-// BridgeHandler functions is a handler for messages received via NATS
-func (ca *CoAPAdapter) BridgeHandler(nm *broker.Msg) {
-	log.Printf("Received a message: %s\n", string(nm.Data))
-
-	// And write it into the database
-	m := mainflux.RawMessage{}
-	if len(nm.Data) > 0 {
-		if err := json.Unmarshal(nm.Data, &m); err != nil {
-			log.Println("Can not decode adapter msg")
-			return
-		}
-	}
-
-	log.Println("Calling obsTransmit()")
-	log.Println(m.Publisher, m.Protocol, m.Channel, m.Payload)
-	ca.obsTransmit(m)
-}

coap/messages.go

@@ -1,145 +0,0 @@
-package adapter
-
-import (
-	"bytes"
-	"log"
-	"net"
-
-	mux "github.com/dereulenspiegel/coap-mux"
-	coap "github.com/dustin/go-coap"
-	"github.com/mainflux/mainflux"
-)
-
-func (ca *CoAPAdapter) sendMessage(l *net.UDPConn, a *net.UDPAddr, m *coap.Message) *coap.Message {
-	log.Printf("Got message in sendMessage: path=%q: %#v from %v", m.Path(), m, a)
-	var res *coap.Message
-	if m.IsConfirmable() {
-		res = &coap.Message{
-			Type:      coap.Acknowledgement,
-			Code:      coap.Content,
-			MessageID: m.MessageID,
-			Token:     m.Token,
-			Payload:   []byte(""),
-		}
-		res.SetOption(coap.ContentFormat, coap.AppJSON)
-	}
-
-	if len(m.Payload) == 0 {
-		if m.IsConfirmable() {
-			res.Code = coap.BadRequest
-		}
-		return res
-	}
-
-	// Channel ID
-	cid := mux.Var(m, "channel_id")
-
-	n := mainflux.RawMessage{
-		Channel:   cid,
-		Publisher: "",
-		Protocol:  protocol,
-		Payload:   m.Payload,
-	}
-
-	if err := ca.pub.Publish(n); err != nil {
-		if m.IsConfirmable() {
-			res.Code = coap.InternalServerError
-		}
-		return res
-	}
-
-	if m.IsConfirmable() {
-		res.Code = coap.Changed
-	}
-	return res
-}
-
-func (ca *CoAPAdapter) registerObserver(o Observer, cid string) {
-	found := false
-	for _, v := range ca.obsMap[cid] {
-		if v.addr == o.addr && bytes.Compare(v.message.Token, o.message.Token) == 0 {
-			found = true
-			break
-		}
-	}
-	if !found {
-		log.Println("Register " + cid)
-		log.Printf("o.message = %v", o.message)
-		ca.obsMap[cid] = append(ca.obsMap[cid], o)
-	}
-}
-
-func (ca *CoAPAdapter) deregisterObserver(o Observer, cid string) {
-	for k, v := range ca.obsMap[cid] {
-		if bytes.Compare(v.message.Token, o.message.Token) == 0 {
-			// Observer found, remove it from array
-			log.Println("Deregister " + cid)
-			ca.obsMap[cid] = append((ca.obsMap[cid])[:k], (ca.obsMap[cid])[k+1:]...)
-		}
-	}
-}
-
-func (ca *CoAPAdapter) observeMessage(l *net.UDPConn, a *net.UDPAddr, m *coap.Message) *coap.Message {
-	log.Printf("Got message in observeMessage: path=%q: %#v from %v", m.Path(), m, a)
-	var res *coap.Message
-
-	if m.IsConfirmable() {
-		res = &coap.Message{
-			Type:      coap.Acknowledgement,
-			Code:      coap.Content,
-			MessageID: m.MessageID,
-			Token:     m.Token,
-			Payload:   []byte(""),
-		}
-		res.SetOption(coap.ContentFormat, coap.AppJSON)
-	}
-
-	// Channel ID
-	cid := mux.Var(m, "channel_id")
-
-	// Observer
-	o := Observer{
-		conn:    l,
-		addr:    a,
-		message: m,
-	}
-
-	if m.Option(coap.Observe) == nil {
-		if m.IsConfirmable() {
-			res.Code = coap.BadRequest
-		}
-		return res
-	}
-
-	if value, ok := m.Option(coap.Observe).(uint32); ok && value == 0 {
-		ca.registerObserver(o, cid)
-	} else {
-		ca.deregisterObserver(o, cid)
-	}
-
-	if m.IsConfirmable() {
-		res.Code = coap.Valid
-	}
-	return res
-}
-
-func (ca *CoAPAdapter) obsTransmit(n mainflux.RawMessage) {
-	for _, v := range ca.obsMap[n.Channel] {
-		msg := *(v.message)
-		msg.Payload = n.Payload
-
-		log.Printf("ca.obsMap[cid] = %v", v)
-		log.Printf("msg = %v", msg)
-
-		msg.SetOption(coap.ContentFormat, coap.AppJSON)
-		msg.SetOption(coap.LocationPath, msg.Path())
-
-		log.Printf("Transmitting %v", msg)
-		err := coap.Transmit(v.conn, v.addr, msg)
-		if err != nil {
-			log.Printf("Error on transmitter, stopping: %v", err)
-			return
-		}
-	}
-
-}

coap/nats/messages.go

@@ -1,30 +0,0 @@
-// Package nats contains NATS-specific message repository implementation.
-package nats
-
-import (
-	"github.com/golang/protobuf/proto"
-	"github.com/mainflux/mainflux"
-	broker "github.com/nats-io/go-nats"
-)
-
-const topic string = "src.coap"
-
-var _ mainflux.MessagePublisher = (*natsPublisher)(nil)
-
-type natsPublisher struct {
-	nc *broker.Conn
-}
-
-// NewMessagePublisher instantiates NATS message publisher.
-func NewMessagePublisher(nc *broker.Conn) mainflux.MessagePublisher {
-	return &natsPublisher{nc}
-}
-
-func (pub *natsPublisher) Publish(msg mainflux.RawMessage) error {
-	data, err := proto.Marshal(&msg)
-	if err != nil {
-		return err
-	}
-
-	return pub.nc.Publish(topic, data)
-}

coap/server.go

@@ -1,30 +0,0 @@
-package adapter
-
-import (
-	"log"
-	"net"
-
-	"github.com/dereulenspiegel/coap-mux"
-	"github.com/dustin/go-coap"
-)
-
-func notFoundHandler(l *net.UDPConn, a *net.UDPAddr, m *coap.Message) *coap.Message {
-	log.Printf("Got message in notFoundHandler: path=%q: %#v from %v", m.Path(), m, a)
-	if m.IsConfirmable() {
-		return &coap.Message{
-			Type: coap.Acknowledgement,
-			Code: coap.NotFound,
-		}
-	}
-	return nil
-}
-
-func (ca *CoAPAdapter) COAPServer() *mux.Router {
-	r := mux.NewRouter()
-	r.Handle("/channels/{channel_id}/messages", coap.FuncHandler(ca.sendMessage)).Methods(coap.POST)
-	r.Handle("/channels/{channel_id}/messages", coap.FuncHandler(ca.observeMessage)).Methods(coap.GET)
-
-	r.NotFoundHandler = coap.FuncHandler(notFoundHandler)
-
-	return r
-}

dashflux/.angular-cli.json

@@ -0,0 +1,60 @@
+{
+  "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
+  "project": {
+    "name": "mainflux-ui"
+  },
+  "apps": [
+    {
+      "root": "src",
+      "outDir": "dist",
+      "assets": [
+        "assets",
+        "favicon.ico"
+      ],
+      "index": "index.html",
+      "main": "main.ts",
+      "polyfills": "polyfills.ts",
+      "test": "test.ts",
+      "tsconfig": "tsconfig.app.json",
+      "testTsconfig": "tsconfig.spec.json",
+      "prefix": "app",
+      "styles": [
+        "styles.scss"
+      ],
+      "scripts": [],
+      "environmentSource": "environments/environment.ts",
+      "environments": {
+        "dev": "environments/environment.ts",
+        "prod": "environments/environment.prod.ts"
+      }
+    }
+  ],
+  "e2e": {
+    "protractor": {
+      "config": "./protractor.conf.js"
+    }
+  },
+  "lint": [
+    {
+      "project": "src/tsconfig.app.json",
+      "exclude": "**/node_modules/**"
+    },
+    {
+      "project": "src/tsconfig.spec.json",
+      "exclude": "**/node_modules/**"
+    },
+    {
+      "project": "e2e/tsconfig.e2e.json",
+      "exclude": "**/node_modules/**"
+    }
+  ],
+  "test": {
+    "karma": {
+      "config": "./karma.conf.js"
+    }
+  },
+  "defaults": {
+    "styleExt": "scss",
+    "component": {}
+  }
+}

dashflux/.editorconfig

@@ -0,0 +1,13 @@
+# Editor configuration, see http://editorconfig.org
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 2
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+max_line_length = off
+trim_trailing_whitespace = false

dashflux/.gitignore

@@ -0,0 +1,58 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+
+# compiled output
+/dist
+/tmp
+
+# dependencies
+/node_modules
+/bower_components
+
+# IDEs and editors
+/.idea
+/.vscode
+/out-tsc
+
+# dependencies
+/node_modules
+
+# IDEs and editors
+/.idea
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+# misc
+/.sass-cache
+/connect.lock
+/coverage/*
+/coverage
+/libpeerconnection.log
+npm-debug.log
+testem.log
+/typings
+
+# e2e
+/e2e/*.js
+/e2e/*.map
+
+#System Files
+.DS_Store
+Thumbs.db
+
+#json-server database
+db.json
+db.*
+# System Files
+.DS_Store
+Thumbs.db

dashflux/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

dashflux/README.md

@@ -0,0 +1,73 @@
+# Mainflux UI Dashboad
+
+Mainflux UI, dashboard for [Mainflux](https://github.com/mainflux/mainflux) Industrial IoT Messaging and Device Management Server.
+
+> **N.B.** Mainflux UI service is WIP and not suitable for deployment at this moment. You are welcome to contribute and improve it.
+> ## Development
+>- Follow angular-cli [documentation](https://github.com/angular/angular-cli)
+>- Follow [official angular style guide](https://angular.io/styleguide)
+
+## Requirements
+
+You'll need the following software installed to get started.
+
+- [Node](https://nodejs.org/en/) 6  or higher, we recommend current LTS version, together with NPM 3 or higher.
+- [Angular-cli](https://github.com/angular/angular-cli) Newest version with Webpack integration
+- - Depending on how Node is configured on your machine, you may need to run installation command with `sudo`
+- [Git](http://git-scm.com/downloads): Use the installer for your OS.
+  - Windows users can also try [Git for Windows](http://git-for-windows.github.io/).
+- For local Development with [Mainflux composition](https://github.com/mainflux/mainflux) running locally, [Chrome extension for Cross origin](https://chrome.google.com/webstore/detail/allow-control-allow-origi/nlfbmbojpeacfghkpbjhddihlkkiljbi?utm_source=chrome-app-launcher-info-dialog) is required. Because composition is running on different port then our Angular app, we have cross origin.
+
+## Configuration
+
+Change into the directory.
+
+```bash
+cd dashflux
+```
+
+Install the dependencies. If you're running Mac OS or Linux, you may need to run `sudo npm install` instead, depending on how your machine is configured.
+
+```bash
+npm install
+```
+
+Set appropriate endpoint URLs in **environment.ts** (for local development will probably be 0.0.0.0:<_port_>) or **environment.prod.ts** for production.
+
+To start the server, run:
+
+```bash
+ng serve
+```
+
+This will run and assemble our app.
+ **Now go to `localhost:4200` in your browser to see it in action.**
+
+## Deployment
+
+Dashflux is distributed as Docker container. We use nginx to serve dashflux from docker container, supporting environments using docker multi-stage builds.
+Dashflux docker image is available on [Dockerhub mainflux/dashflux](https://hub.docker.com/r/mainflux/dashflux/)
+
+If you want to build image locally, you can build image using the **development** environment:
+
+```bash
+docker build -f docker/Dockerfile  -t dashflux:dev --build-arg env=dev .
+```
+
+Build image using the **production** environment:
+
+```bash
+docker build -t dashflux:prod -f ./docker/Dockerfile .
+```
+
+**Note:** before running *docker build* command, please make sure appropriate endpoint URLs in *environment.ts* or *environment.prod.ts* are set up.
+
+You can test image running
+
+```bash
+docker run -p 80:80 dashflux:dev
+```
+
+This will run dashflux in docker container.
+
+Now go to `http://localhost` in your browser to see it in action.

dashflux/docker/.dockerignore

@@ -0,0 +1 @@
+node_modules

dashflux/docker/Dockerfile

@@ -0,0 +1,13 @@
+# Stage 0, based on Node.js, to build and compile Angular
+FROM node:9.5 as node
+WORKDIR /app
+COPY package.json /app/
+RUN npm install
+COPY ./ /app/
+ARG env=prod
+RUN npm run build -- --prod --environment $env
+
+# Stage 1, based on Nginx, to have only the compiled app, ready for production with Nginx
+FROM nginx:1.13-alpine
+COPY --from=node /app/dist/ /usr/share/nginx/html
+COPY docker/nginx.conf /etc/nginx/conf.d/default.conf

dashflux/docker/nginx.conf

@@ -0,0 +1,8 @@
+server {
+  listen 3000;
+  location / {
+    root /usr/share/nginx/html;
+    index index.html index.htm;
+    try_files $uri $uri/ /index.html =404;
+  }
+}

dashflux/e2e/app.e2e-spec.ts

@@ -0,0 +1,14 @@
+import { AppPage } from './app.po';
+
+describe('mainflux-ui App', () => {
+  let page: AppPage;
+
+  beforeEach(() => {
+    page = new AppPage();
+  });
+
+  it('should display welcome message', () => {
+    page.navigateTo();
+    expect(page.getParagraphText()).toEqual('Welcome to app!');
+  });
+});

dashflux/e2e/app.po.ts

@@ -0,0 +1,11 @@
+import { browser, by, element } from 'protractor';
+
+export class AppPage {
+  navigateTo() {
+    return browser.get('/');
+  }
+
+  getParagraphText() {
+    return element(by.css('app-root h1')).getText();
+  }
+}

dashflux/e2e/tsconfig.e2e.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../out-tsc/e2e",
+    "baseUrl": "./",
+    "module": "commonjs",
+    "target": "es5",
+    "types": [
+      "jasmine",
+      "jasminewd2",
+      "node"
+    ]
+  }
+}

dashflux/karma.conf.js

@@ -0,0 +1,33 @@
+// Karma configuration file, see link for more information
+// https://karma-runner.github.io/1.0/config/configuration-file.html
+
+module.exports = function (config) {
+  config.set({
+    basePath: '',
+    frameworks: ['jasmine', '@angular/cli'],
+    plugins: [
+      require('karma-jasmine'),
+      require('karma-chrome-launcher'),
+      require('karma-jasmine-html-reporter'),
+      require('karma-coverage-istanbul-reporter'),
+      require('@angular/cli/plugins/karma')
+    ],
+    client:{
+      clearContext: false // leave Jasmine Spec Runner output visible in browser
+    },
+    coverageIstanbulReporter: {
+      reports: [ 'html', 'lcovonly' ],
+      fixWebpackSourcePaths: true
+    },
+    angularCli: {
+      environment: 'dev'
+    },
+    reporters: ['progress', 'kjhtml'],
+    port: 9876,
+    colors: true,
+    logLevel: config.LOG_INFO,
+    autoWatch: true,
+    browsers: ['ChromeHeadless'],
+    singleRun: false
+  });
+};

dashflux/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "mainflux-ui",
+  "version": "0.1.0",
+  "license": "Apache License, version 2.0",
+  "scripts": {
+    "ng": "ng",
+    "start": "ng serve --proxy-config proxy-config.json",
+    "build": "ng build",
+    "test": "ng test",
+    "lint": "ng lint",
+    "e2e": "ng e2e"
+  },
+  "private": true,
+  "dependencies": {
+    "@angular/animations": "^5.2.4",
+    "@angular/common": "^5.2.4",
+    "@angular/compiler": "^5.2.4",
+    "@angular/core": "^5.2.4",
+    "@angular/flex-layout": "2.0.0-beta.10-4905443",
+    "@angular/forms": "^5.2.4",
+    "@angular/http": "^5.2.4",
+    "@angular/platform-browser": "^5.2.4",
+    "@angular/platform-browser-dynamic": "^5.2.4",
+    "@angular/router": "^5.2.4",
+    "core-js": "^2.4.1",
+    "mobx": "^3.5.1",
+    "mobx-angular": "^2.1.1",
+    "ngx-auth": "^2.2.0",
+    "rxjs": "^5.5.2",
+    "zone.js": "^0.8.14"
+  },
+  "devDependencies": {
+    "@angular/cdk": "^5.2.0",
+    "@angular/cli": "^1.7.3",
+    "@angular/compiler-cli": "^5.2.4",
+    "@angular/language-service": "^5.2.4",
+    "@angular/material": "^5.2.0",
+    "@types/jasmine": "~2.5.53",
+    "@types/jasminewd2": "~2.0.2",
+    "@types/node": "^6.0.100",
+    "codelyzer": "~3.2.0",
+    "hammerjs": "^2.0.8",
+    "jasmine-core": "~2.5.2",
+    "jasmine-spec-reporter": "~4.1.0",
+    "karma": "~1.7.0",
+    "karma-chrome-launcher": "~2.1.1",
+    "karma-cli": "~1.0.1",
+    "karma-coverage-istanbul-reporter": "^1.2.1",
+    "karma-jasmine": "~1.1.0",
+    "karma-jasmine-html-reporter": "^0.2.2",
+    "karma-phantomjs-launcher": "^1.0.4",
+    "protractor": "~5.1.2",
+    "ts-node": "~3.2.0",
+    "tslint": "~5.7.0",
+    "typescript": "~2.4.2"
+  }
+}

dashflux/protractor.conf.js

@@ -0,0 +1,28 @@
+// Protractor configuration file, see link for more information
+// https://github.com/angular/protractor/blob/master/lib/config.ts
+
+const { SpecReporter } = require('jasmine-spec-reporter');
+
+exports.config = {
+  allScriptsTimeout: 11000,
+  specs: [
+    './e2e/**/*.e2e-spec.ts'
+  ],
+  capabilities: {
+    'browserName': 'chrome'
+  },
+  directConnect: true,
+  baseUrl: 'http://localhost:4200/',
+  framework: 'jasmine',
+  jasmineNodeOpts: {
+    showColors: true,
+    defaultTimeoutInterval: 30000,
+    print: function() {}
+  },
+  onPrepare() {
+    require('ts-node').register({
+      project: 'e2e/tsconfig.e2e.json'
+    });
+    jasmine.getEnv().addReporter(new SpecReporter({ spec: { displayStacktrace: true } }));
+  }
+};

dashflux/proxy-config.json

@@ -0,0 +1,9 @@
+{
+    "/api/*": {
+       "target": "http://localhost:8180",
+       "secure":false,
+       "pathRewrite": {
+           "^/api": ""
+        }
+    }
+}

dashflux/src/app/app-routing.module.ts

@@ -0,0 +1,28 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { Route, RouterModule } from '@angular/router';
+import { ProtectedGuard, PublicGuard } from 'ngx-auth';
+
+import { LoginComponent } from './components/auth/login/login.component';
+import { SignupComponent } from './components/auth/signup/signup.component';
+import { ChannelsComponent } from './components/channels/channels.component';
+import { ThingsComponent } from './components/things/things.component';
+
+const routes: Route[] = [
+  { path: '', redirectTo: 'things', pathMatch: 'full'},
+  { path: 'login', component: LoginComponent, canActivate: [PublicGuard]},
+  { path: 'signup', component: SignupComponent, canActivate: [PublicGuard]},
+  { path: 'things', component: ThingsComponent, canActivate: [ProtectedGuard]},
+  { path: 'channels', component: ChannelsComponent, canActivate: [ProtectedGuard]}
+];
+
+@NgModule({
+  imports: [
+    CommonModule,
+    RouterModule.forRoot(routes)
+  ],
+  exports: [
+    RouterModule
+  ]
+})
+export class AppRoutingModule { }

dashflux/src/app/app.component.html

@@ -0,0 +1,15 @@
+<div *mobxAutorun>
+    <div class="loading" *ngIf="uiStore.loading" fxLayoutAlign="center center">
+        <mat-progress-spinner [mode]="'indeterminate'"></mat-progress-spinner>
+    </div>
+    <mat-toolbar color="primary" class="mat-elevation-z6">
+        <h1 fxFlex>Mainflux</h1>
+        <ng-container *ngIf="authStore.isAuthenticated">
+            <a [routerLink]="['/things']" mat-button>Things</a>
+            <a [routerLink]="['/channels']" mat-button>Channels</a>
+            <a (click)="logout()" mat-button>Logout</a>
+        </ng-container>
+
+    </mat-toolbar>
+    <router-outlet></router-outlet>
+</div>

dashflux/src/app/app.component.scss

@@ -0,0 +1,6 @@
+.loading {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    z-index: 999;
+}

dashflux/src/app/app.component.spec.ts

@@ -0,0 +1,40 @@
+import { HttpClientModule } from '@angular/common/http';
+import { async, TestBed } from '@angular/core/testing';
+import { RouterTestingModule } from '@angular/router/testing';
+
+import { AppComponent } from './app.component';
+import { MaterialModule } from './core/material/material.module';
+import { AuthenticationService } from './core/services/auth/authentication.service';
+import { TokenStorage } from './core/services/auth/token-storage.service';
+import { ChannelsService } from './core/services/channels/channels.service';
+import { ThingsService } from './core/services/things/things.service';
+import { UiStore } from './core/store/ui.store';
+import { AuthStore } from './core/store/auth.store';
+
+describe('AppComponent', () => {
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [
+        AppComponent
+      ],
+      imports: [
+        MaterialModule,
+        HttpClientModule,
+        RouterTestingModule
+      ],
+      providers: [
+        UiStore,
+        AuthStore,
+        AuthenticationService,
+        TokenStorage,
+        ThingsService,
+        ChannelsService,
+      ]
+    }).compileComponents();
+  }));
+  it('should create the app', async(() => {
+    const fixture = TestBed.createComponent(AppComponent);
+    const app = fixture.debugElement.componentInstance;
+    expect(app).toBeTruthy();
+  }));
+});

dashflux/src/app/app.component.ts

@@ -0,0 +1,33 @@
+import { Component, OnInit } from '@angular/core';
+import { MatSnackBar } from '@angular/material';
+import { reaction } from 'mobx';
+
+import { UiStore } from './core/store/ui.store';
+import { AuthStore } from './core/store/auth.store';
+
+@Component({
+  selector: 'app-root',
+  templateUrl: './app.component.html',
+  styleUrls: ['./app.component.scss']
+})
+export class AppComponent implements OnInit {
+  constructor(
+    private snackBar: MatSnackBar,
+    public uiStore: UiStore,
+    public authStore: AuthStore,
+  ) { }
+
+  ngOnInit() {
+    reaction(() => this.authStore.authError, (authError) => {
+      if (authError) {
+        this.snackBar.open(authError, '', {
+          duration: 3000
+        });
+      }
+    });
+  }
+
+  logout() {
+    this.authStore.logout();
+  }
+}

dashflux/src/app/app.module.ts

@@ -0,0 +1,92 @@
+import './rxjs-extensions.ts';
+import 'hammerjs';
+
+import { HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
+import { APP_BASE_HREF } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FlexLayoutModule } from '@angular/flex-layout';
+import { ReactiveFormsModule } from '@angular/forms';
+import { BrowserModule } from '@angular/platform-browser';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { MobxAngularModule } from 'mobx-angular';
+import { AUTH_SERVICE, AuthModule, PROTECTED_FALLBACK_PAGE_URI, PUBLIC_FALLBACK_PAGE_URI } from 'ngx-auth';
+
+import { AppRoutingModule } from './app-routing.module';
+import { AppComponent } from './app.component';
+import { LoginComponent } from './components/auth/login/login.component';
+import { SignupComponent } from './components/auth/signup/signup.component';
+import { ChannelDialogComponent } from './components/channels/channel-dialog/channel-dialog.component';
+import { ChannelsComponent } from './components/channels/channels.component';
+import { ThingDialogComponent } from './components/things/thing-dialog/thing-dialog.component';
+import { ThingsComponent } from './components/things/things.component';
+import { ConfirmationDialogComponent } from './components/shared/confirmation-dialog/confirmation-dialog.component';
+import { MaterialModule } from './core/material/material.module';
+import { AuthenticationService } from './core/services/auth/authentication.service';
+import { TokenStorage } from './core/services/auth/token-storage.service';
+import { ChannelsService } from './core/services/channels/channels.service';
+import { ThingsService } from './core/services/things/things.service';
+import { MockAuthService } from './core/services/mock-auth.service';
+import { MockChannelsService } from './core/services/mock-channels.service';
+import { MockThingsService } from './core/services/mock-things.service';
+import { ChannelsStore } from './core/store/channels.store';
+import { ThingsStore } from './core/store/things.store';
+import { UiStore } from './core/store/ui.store';
+import { AuthStore } from './core/store/auth.store';
+import { UnauthorizedInterceptor } from './core/services/auth/unauthorized.interceptor';
+
+export function factory(authenticationService: AuthenticationService) {
+  return authenticationService;
+}
+
+@NgModule({
+  declarations: [
+    AppComponent,
+    ThingsComponent,
+    ChannelsComponent,
+    SignupComponent,
+    LoginComponent,
+    ThingDialogComponent,
+    ConfirmationDialogComponent,
+    ChannelDialogComponent,
+  ],
+  imports: [
+    AuthModule,
+    BrowserModule,
+    BrowserAnimationsModule,
+    AppRoutingModule,
+    HttpClientModule,
+    MaterialModule,
+    FlexLayoutModule,
+    ReactiveFormsModule,
+    MobxAngularModule,
+  ],
+  providers: [
+    UiStore,
+    ThingsStore,
+    ChannelsStore,
+    AuthStore,
+    MockAuthService,
+    MockThingsService,
+    MockChannelsService,
+    ThingsService,
+    ChannelsService,
+    TokenStorage,
+    AuthenticationService,
+    { provide: PROTECTED_FALLBACK_PAGE_URI, useValue: '/' },
+    { provide: PUBLIC_FALLBACK_PAGE_URI, useValue: '/login' },
+    {
+      provide: AUTH_SERVICE,
+      deps: [AuthenticationService],
+      useFactory: factory
+    },
+    { provide: HTTP_INTERCEPTORS, useClass: UnauthorizedInterceptor, multi: true },
+    { provide: APP_BASE_HREF, useValue: '/app/' }
+  ],
+  bootstrap: [AppComponent],
+  entryComponents: [
+    ThingDialogComponent,
+    ChannelDialogComponent,
+    ConfirmationDialogComponent
+  ]
+})
+export class AppModule { }

dashflux/src/app/components/auth/login/login.component.html

@@ -0,0 +1,28 @@
+<div class="container" style="height: 80vh" fxLayoutAlign="center center">
+  <form fxLayout="column" [formGroup]="loginForm" (ngSubmit)="login()" fxFlex="30%" fxFlex.sm="70%" fxFlex.xs="90%">
+    <mat-card>
+      <mat-card-title>Login</mat-card-title>
+      <mat-card-content class="loginCard" fxLayout="column" fxLayoutAlign="space-evenly">
+        <mat-form-field fxFlex="40%">
+          <input type="text" class="emailInput" required matInput placeholder="Email" formControlName="email"/>
+          <mat-error *ngIf="loginForm.get('email').errors?.required">
+            Email is required
+          </mat-error>
+          <mat-error *ngIf="loginForm.get('email').errors?.email">
+            Email must be valid
+          </mat-error>
+        </mat-form-field>
+        <mat-form-field fxFlex="30%">
+          <input type="password" class="passwordInput" required matInput placeholder="Password" formControlName="password" />
+          <mat-error *ngIf="loginForm.get('password').errors?.required">
+            Password is required
+          </mat-error>
+        </mat-form-field>
+      </mat-card-content>
+      <mat-card-actions fxLayout="column">
+        <button type="submit" [disabled]="loginForm.invalid" mat-raised-button color="primary" class="loginButton">Login</button>
+        <button mat-button (click)="signup()" class="signupButton">Sign Up with Email</button>
+      </mat-card-actions>
+    </mat-card>
+  </form>
+</div>

dashflux/src/app/components/auth/login/login.component.scss

@@ -0,0 +1,3 @@
+::ng-deep mat-card-content.loginCard {
+    height: 200px;
+}

dashflux/src/app/components/auth/login/login.component.spec.ts

@@ -0,0 +1,59 @@
+import { HttpClientModule } from '@angular/common/http';
+import { async, ComponentFixture, inject, TestBed } from '@angular/core/testing';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { NoopAnimationsModule } from '@angular/platform-browser/animations';
+import { RouterTestingModule } from '@angular/router/testing';
+
+import { MaterialModule } from '../../../core/material/material.module';
+import { AuthenticationService } from '../../../core/services/auth/authentication.service';
+import { TokenStorage } from '../../../core/services/auth/token-storage.service';
+import { LoginComponent } from './login.component';
+import { UiStore } from '../../../core/store/ui.store';
+import { AuthStore } from '../../../core/store/auth.store';
+
+describe('LoginComponent', () => {
+  let component: LoginComponent;
+  let fixture: ComponentFixture<LoginComponent>;
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [ LoginComponent ],
+      imports: [
+        MaterialModule,
+        HttpClientModule,
+        RouterTestingModule,
+        FormsModule,
+        ReactiveFormsModule,
+        NoopAnimationsModule
+      ],
+      providers: [
+        UiStore,
+        AuthStore,
+        AuthenticationService,
+        TokenStorage,
+      ]
+    })
+    .compileComponents();
+  }));
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(LoginComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+
+  it('should call the store goToSignup when clicked on Sign Up with Email', inject([UiStore], (store: UiStore) => {
+    const signupButton = fixture.debugElement.nativeElement.querySelector('.signupButton');
+    const signupSpy = spyOn(store, 'goToSignup').and.stub();
+
+    signupButton.click();
+
+    fixture.detectChanges();
+
+    expect(signupSpy).toHaveBeenCalled();
+  }));
+});

dashflux/src/app/components/auth/login/login.component.ts

@@ -0,0 +1,42 @@
+import { Component, OnInit } from '@angular/core';
+import { FormBuilder, FormGroup, Validators } from '@angular/forms';
+
+import { UiStore } from '../../../core/store/ui.store';
+import { AuthStore } from '../../../core/store/auth.store';
+
+@Component({
+  selector: 'app-login',
+  templateUrl: './login.component.html',
+  styleUrls: ['./login.component.scss']
+})
+export class LoginComponent implements OnInit {
+  loginForm: FormGroup;
+
+  constructor(
+    private fb: FormBuilder,
+    private uiStore: UiStore,
+    private authStore: AuthStore,
+  ) { }
+
+  ngOnInit() {
+    this.loginForm = this.fb.group({
+      email: ['', [Validators.required, Validators.email]],
+      password: ['', [Validators.required]],
+    });
+  }
+
+  login() {
+    this.authStore.login(this.getUserDataFromForm());
+  }
+
+  signup() {
+    this.uiStore.goToSignup();
+  }
+
+  getUserDataFromForm() {
+    return {
+      email: this.loginForm.get('email').value,
+      password: this.loginForm.get('password').value
+    };
+  }
+}

dashflux/src/app/components/auth/signup/signup.component.html

@@ -0,0 +1,34 @@
+<div class="container" style="height: 80vh" fxLayoutAlign="center center">
+  <form fxLayout="column" [formGroup]="signupForm" (ngSubmit)="signup()" fxFlex="30%" fxFlex.sm="70%" fxFlex.xs="90%">
+    <mat-card>
+      <mat-card-title>Signup</mat-card-title>
+      <mat-card-content class="loginCard" fxLayout="column" fxLayoutAlign="space-evenly">
+        <mat-form-field fxFlex="40%">
+          <input type="text" required matInput placeholder="Email" formControlName="email"/>
+          <mat-error *ngIf="signupForm.get('email').errors?.required">
+            Email is required
+          </mat-error>
+          <mat-error *ngIf="signupForm.get('email').errors?.email">
+            Email must be valid
+          </mat-error>
+        </mat-form-field>
+        <mat-form-field fxFlex="30%" formGroupName="passwords">
+          <input type="password" required matInput placeholder="Password" formControlName="password" />
+          <mat-error *ngIf="signupForm.get('passwords.password').errors?.required">
+            Password is required
+          </mat-error>
+        </mat-form-field>
+        <mat-form-field fxFlex="30%" formGroupName="passwords">
+          <input type="password" required matInput placeholder="Repeat password" formControlName="repeatPassword" />
+          <mat-error *ngIf="signupForm.get('passwords.repeatPassword').errors?.required">
+            Repeat the password
+          </mat-error>
+        </mat-form-field>
+      </mat-card-content>
+      <mat-card-actions fxLayout="column">
+        <button type="submit" [disabled]="signupForm.invalid" mat-raised-button color="primary" class="large-button">Signup</button>
+        <a mat-button (click)="login()">Login</a>
+      </mat-card-actions>
+    </mat-card>
+  </form>
+</div>

dashflux/src/app/components/auth/signup/signup.component.scss

@@ -0,0 +1,3 @@
+::ng-deep mat-card-content.loginCard {
+    height: 200px;
+}

dashflux/src/app/components/auth/signup/signup.component.spec.ts

@@ -0,0 +1,48 @@
+import { HttpClientModule } from '@angular/common/http';
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { NoopAnimationsModule } from '@angular/platform-browser/animations';
+import { RouterTestingModule } from '@angular/router/testing';
+
+import { MaterialModule } from '../../../core/material/material.module';
+import { AuthenticationService } from '../../../core/services/auth/authentication.service';
+import { TokenStorage } from '../../../core/services/auth/token-storage.service';
+import { SignupComponent } from './signup.component';
+import { AuthStore } from '../../../core/store/auth.store';
+import { UiStore } from '../../../core/store/ui.store';
+
+describe('SignupComponent', () => {
+  let component: SignupComponent;
+  let fixture: ComponentFixture<SignupComponent>;
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [ SignupComponent ],
+      imports: [
+        MaterialModule,
+        HttpClientModule,
+        RouterTestingModule,
+        FormsModule,
+        ReactiveFormsModule,
+        NoopAnimationsModule
+      ],
+      providers: [
+        UiStore,
+        AuthStore,
+        AuthenticationService,
+        TokenStorage
+      ]
+    })
+    .compileComponents();
+  }));
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(SignupComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

dashflux/src/app/components/auth/signup/signup.component.ts

@@ -0,0 +1,55 @@
+import { Component, OnInit } from '@angular/core';
+import { AbstractControl, FormBuilder, FormGroup, Validators } from '@angular/forms';
+
+import { AuthStore } from '../../../core/store/auth.store';
+import { UiStore } from '../../../core/store/ui.store';
+
+@Component({
+  selector: 'app-signup',
+  templateUrl: './signup.component.html',
+  styleUrls: ['./signup.component.scss']
+})
+export class SignupComponent implements OnInit {
+  signupForm: FormGroup;
+
+  constructor(
+    private fb: FormBuilder,
+    private uiStore: UiStore,
+    private authStore: AuthStore,
+  ) { }
+
+  ngOnInit() {
+    this.signupForm = this.fb.group({
+      email: ['', [Validators.required, Validators.email]],
+      passwords: this.fb.group({
+        password: ['', [Validators.required]],
+        repeatPassword: ['', [Validators.required]]
+      }, { validator: this.comparePasswords })
+    });
+  }
+
+  comparePasswords(c: AbstractControl): { [key: string]: boolean } {
+    const pass = c.get('password');
+    const repeatPassword = c.get('repeatPassword');
+
+    if (pass.value !== repeatPassword.value) {
+      return { 'match': true };
+    }
+    return null;
+  }
+
+  signup() {
+    this.authStore.signup(this.getUserDataFromForm());
+  }
+
+  login() {
+    this.uiStore.goToLogin();
+  }
+
+  getUserDataFromForm() {
+    return {
+      email: this.signupForm.get('email').value,
+      password: this.signupForm.get('passwords.password').value
+    };
+  }
+}

dashflux/src/app/components/channels/channel-dialog/channel-dialog.component.html

@@ -0,0 +1,22 @@
+<form [formGroup]="addChannelForm" (ngSubmit)="onAddChannel()">
+    <h1 *ngIf="!editMode" mat-dialog-title>Add channel</h1>
+    <h1 *ngIf="editMode" mat-dialog-title>Edit channel</h1>
+    <div mat-dialog-content fxLayout="column">
+      <input type="hidden" formControlName="id">
+      <mat-form-field>
+        <input matInput tabindex="1" placeholder="Name" formControlName="name" />
+        <mat-error *ngIf="addChannelForm.get('name').errors?.required">
+          Name is required
+        </mat-error>
+      </mat-form-field>
+      <mat-form-field>
+          <mat-select placeholder="Connected things" formControlName="connected" [compareWith]="compareFunction" multiple>
+            <mat-option *ngFor="let thing of thingsStore.things" [value]="thing">{{thing.name}}</mat-option>
+          </mat-select>
+        </mat-form-field>
+    </div>
+    <div mat-dialog-actions>
+      <button mat-button mat-dialog-close>Cancel</button>
+      <button mat-button mat-raised-button color="primary" type="submit" [disabled]="addChannelForm.invalid">Ok</button>
+    </div>
+  </form>

dashflux/src/app/components/channels/channel-dialog/channel-dialog.component.spec.ts

@@ -0,0 +1,56 @@
+import { HttpClientModule } from '@angular/common/http';
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MAT_DIALOG_DATA, MatDialogModule, MatDialogRef } from '@angular/material';
+import { NoopAnimationsModule } from '@angular/platform-browser/animations';
+import { RouterTestingModule } from '@angular/router/testing';
+
+import { MaterialModule } from '../../../core/material/material.module';
+import { AuthenticationService } from '../../../core/services/auth/authentication.service';
+import { TokenStorage } from '../../../core/services/auth/token-storage.service';
+import { ChannelsService } from '../../../core/services/channels/channels.service';
+import { ThingsService } from '../../../core/services/things/things.service';
+import { ChannelDialogComponent } from './channel-dialog.component';
+import { ThingsStore } from '../../../core/store/things.store';
+import { UiStore } from '../../../core/store/ui.store';
+
+describe('ChannelDialogComponent', () => {
+  let component: ChannelDialogComponent;
+  let fixture: ComponentFixture<ChannelDialogComponent>;
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [ ChannelDialogComponent ],
+      imports: [
+        MaterialModule,
+        MatDialogModule,
+        HttpClientModule,
+        RouterTestingModule,
+        FormsModule,
+        ReactiveFormsModule,
+        NoopAnimationsModule
+      ],
+      providers: [
+        ThingsStore,
+        UiStore,
+        AuthenticationService,
+        TokenStorage,
+        ThingsService,
+        ChannelsService,
+        { provide: MatDialogRef, useValue: {} },
+        { provide: MAT_DIALOG_DATA, useValue: [] },
+      ]
+    })
+    .compileComponents();
+  }));
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(ChannelDialogComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

dashflux/src/app/components/channels/channel-dialog/channel-dialog.component.ts

@@ -0,0 +1,52 @@
+import { Component, EventEmitter, Inject, OnInit, Output } from '@angular/core';
+import { FormBuilder, FormGroup } from '@angular/forms';
+import { MAT_DIALOG_DATA, MatDialogRef } from '@angular/material';
+import { toJS } from 'mobx';
+
+import { ThingsStore } from '../../../core/store/things.store';
+import { Channel, Thing } from '../../../core/store/models';
+
+@Component({
+  selector: 'app-channel-dialog',
+  templateUrl: './channel-dialog.component.html',
+  styleUrls: ['./channel-dialog.component.scss']
+})
+export class ChannelDialogComponent implements OnInit {
+  addChannelForm: FormGroup;
+  @Output() submit: EventEmitter<Channel> = new EventEmitter<Channel>();
+  editMode: boolean;
+
+  constructor(
+    private fb: FormBuilder,
+    private dialogRef: MatDialogRef<ChannelDialogComponent>,
+    @Inject(MAT_DIALOG_DATA) public data: Channel,
+    public thingsStore: ThingsStore,
+  ) { }
+
+  ngOnInit() {
+    this.addChannelForm = this.fb.group(
+      {
+        id: [''],
+        name: [''],
+        connected: [[]]
+      }
+    );
+
+    if (this.data) {
+      this.editMode = true;
+      this.addChannelForm.patchValue(toJS(this.data));
+    } else {
+      this.editMode = false;
+    }
+  }
+
+  onAddChannel() {
+    const channel = this.addChannelForm.value;
+    this.submit.emit(channel);
+    this.dialogRef.close();
+  }
+
+  compareFunction(obj1: Thing, obj2: Thing) {
+    return obj1.id === obj2.id;
+  }
+}

dashflux/src/app/components/channels/channels.component.html

@@ -0,0 +1,49 @@
+<div class="channelsContainer" fxLayout="row" fxLayoutWrap>
+  <ng-container [ngSwitch]="channelsStore.channels?.length > 0">
+    <ng-container *ngSwitchCase="true">
+        <!-- List -->
+        <div class="channel-list-container">
+          <mat-table #table [dataSource]="channelsStore.channels.toJS()" matSort class="mat-cell">
+            <!-- Columns -->
+            <ng-container matColumnDef="id">
+              <mat-header-cell fxFlex="32%" *matHeaderCellDef mat-sort-header>Id</mat-header-cell>
+              <mat-cell fxFlex="32%" *matCellDef="let row" >{{row.id}}</mat-cell>
+            </ng-container>
+            <ng-container matColumnDef="name">
+              <mat-header-cell fxFlex="30%" *matHeaderCellDef mat-sort-header>Name</mat-header-cell>
+              <mat-cell fxFlex="30%" *matCellDef="let row"> {{row.name}}</mat-cell>
+            </ng-container>
+            <ng-container matColumnDef="connected">
+              <mat-header-cell fxFlex="30%" *matHeaderCellDef mat-sort-header>Connected</mat-header-cell>
+              <mat-cell fxFlex="30%" *matCellDef="let row">
+                <li *ngFor="let item of row.connected"> {{item.id}} </li>
+              </mat-cell>
+            </ng-container>
+            <!-- Actions -->
+            <ng-container matColumnDef="actions">
+              <mat-header-cell fxFlex="8%" *matHeaderCellDef mat-sort-header></mat-header-cell>
+              <mat-cell fxFlex="8%" *matCellDef="let row" >
+                <button mat-icon-button color="accent" (click)="editChannel(row)">
+                  <mat-icon aria-label="Delete">edit</mat-icon>
+                </button>
+                <button mat-icon-button color="accent" (click)="deleteChannel(row)">
+                  <mat-icon aria-label="Delete">delete</mat-icon>
+                </button>
+              </mat-cell>
+            </ng-container>
+
+            <mat-header-row *matHeaderRowDef="displayedColumns"></mat-header-row>
+            <mat-row *matRowDef="let row; columns: displayedColumns;"></mat-row>
+        </mat-table>
+      </div>
+    </ng-container>
+
+    <ng-container *ngSwitchDefault>
+      <h3>It looks like you don't have any channels in your account.</h3>
+    </ng-container>
+  </ng-container>
+</div>
+
+<button mat-mini-fab class="addButton" (click)="addChannel()">
+  <mat-icon>add</mat-icon>
+</button>

dashflux/src/app/components/channels/channels.component.scss

@@ -0,0 +1,10 @@
+.addButton {
+    position: fixed;
+    bottom: 12px;
+    right: 12px;
+}
+
+/* List container */
+.channel-list-container {
+  width: 100%;
+}

dashflux/src/app/components/channels/channels.component.spec.ts

@@ -0,0 +1,68 @@
+import { HttpClientModule } from '@angular/common/http';
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MAT_DIALOG_DATA, MatDialogModule, MatDialogRef } from '@angular/material';
+import { NoopAnimationsModule } from '@angular/platform-browser/animations';
+import { RouterTestingModule } from '@angular/router/testing';
+
+import { MaterialModule } from '../../core/material/material.module';
+import { AuthenticationService } from '../../core/services/auth/authentication.service';
+import { TokenStorage } from '../../core/services/auth/token-storage.service';
+import { ChannelsService } from '../../core/services/channels/channels.service';
+import { ThingsService } from '../../core/services/things/things.service';
+import { ChannelsComponent } from './channels.component';
+import { ThingsStore } from '../../core/store/things.store';
+import { UiStore } from '../../core/store/ui.store';
+import { ChannelsStore } from '../../core/store/channels.store';
+
+describe('ChannelsComponent', () => {
+  let component: ChannelsComponent;
+  let fixture: ComponentFixture<ChannelsComponent>;
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [ ChannelsComponent ],
+      imports: [
+        MaterialModule,
+        MatDialogModule,
+        HttpClientModule,
+        RouterTestingModule,
+        FormsModule,
+        ReactiveFormsModule,
+        NoopAnimationsModule,
+      ],
+      providers: [
+        {
+          provide: ThingsStore,
+          useClass: class {
+            getThings = jasmine.createSpy('getThings');
+          }
+        },
+        UiStore,
+        {
+          provide: ChannelsStore,
+          useClass: class {
+            getChannels = jasmine.createSpy('getChannels');
+          }
+        },
+        AuthenticationService,
+        TokenStorage,
+        ThingsService,
+        ChannelsService,
+        { provide: MatDialogRef, useValue: {} },
+        { provide: MAT_DIALOG_DATA, useValue: [] },
+      ]
+    })
+    .compileComponents();
+  }));
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(ChannelsComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

dashflux/src/app/components/channels/channels.component.ts

@@ -0,0 +1,62 @@
+import { Component, OnInit } from '@angular/core';
+import { MatDialog } from '@angular/material';
+import { Observable } from 'rxjs/Observable';
+
+import { ChannelsStore } from '../../core/store/channels.store';
+import { ThingsStore } from '../../core/store/things.store';
+import { Channel } from '../../core/store/models';
+import { ConfirmationDialogComponent } from '../shared/confirmation-dialog/confirmation-dialog.component';
+import { ChannelDialogComponent } from './channel-dialog/channel-dialog.component';
+
+@Component({
+  selector: 'app-channels',
+  templateUrl: './channels.component.html',
+  styleUrls: ['./channels.component.scss'],
+})
+export class ChannelsComponent implements OnInit {
+  channels: Observable<Channel[]>;
+  displayedColumns = ['id', 'name', 'connected', 'actions'];
+
+  constructor(
+    private dialog: MatDialog,
+    public thingsStore: ThingsStore,
+    public channelsStore: ChannelsStore,
+  ) { }
+
+  ngOnInit() {
+    this.channelsStore.getChannels();
+    this.thingsStore.getThings();
+  }
+
+  addChannel() {
+    const dialogRef = this.dialog.open(ChannelDialogComponent);
+
+    dialogRef.componentInstance.submit.subscribe((channel: Channel) => {
+      this.channelsStore.addChannel(channel);
+    });
+  }
+
+  editChannel(channel: Channel) {
+    const dialogRef = this.dialog.open(ChannelDialogComponent, {
+      data: channel
+    });
+
+    dialogRef.componentInstance.submit.subscribe((editedChannel: Channel) => {
+      this.channelsStore.editChannel(editedChannel);
+    });
+  }
+
+  deleteChannel(channel: Channel) {
+    const dialogRef = this.dialog.open(ConfirmationDialogComponent, {
+      data: {
+        question: 'Are you sure you want to delete the channel?'
+      }
+    });
+
+    dialogRef.afterClosed().subscribe((result) => {
+      if (result) {
+        this.channelsStore.deleteChannel(channel);
+      }
+    });
+  }
+}

dashflux/src/app/components/shared/confirmation-dialog/confirmation-dialog.component.html

@@ -0,0 +1,5 @@
+<h1 mat-dialog-title>{{data.question}}</h1>
+<div mat-dialog-actions fxLayoutAlign="end end">
+  <button mat-button mat-dialog-close>Cancel</button>
+  <button mat-button mat-raised-button color="primary" [mat-dialog-close]="true">Ok</button>
+</div>

dashflux/src/app/components/shared/confirmation-dialog/confirmation-dialog.component.spec.ts

@@ -0,0 +1,40 @@
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MAT_DIALOG_DATA, MatDialogModule, MatDialogRef } from '@angular/material';
+import { NoopAnimationsModule } from '@angular/platform-browser/animations';
+
+import { MaterialModule } from '../../../core/material/material.module';
+import { ConfirmationDialogComponent } from './confirmation-dialog.component';
+
+describe('ConfirmationDialogComponent', () => {
+  let component: ConfirmationDialogComponent;
+  let fixture: ComponentFixture<ConfirmationDialogComponent>;
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [ ConfirmationDialogComponent ],
+      imports: [
+        MaterialModule,
+        MatDialogModule,
+        FormsModule,
+        ReactiveFormsModule,
+        NoopAnimationsModule
+      ],
+      providers: [
+        { provide: MatDialogRef, useValue: {} },
+        { provide: MAT_DIALOG_DATA, useValue: [] },
+      ]
+    })
+    .compileComponents();
+  }));
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(ConfirmationDialogComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

dashflux/src/app/components/shared/confirmation-dialog/confirmation-dialog.component.ts

@@ -0,0 +1,16 @@
+import { Component, Inject, OnInit } from '@angular/core';
+import { MAT_DIALOG_DATA } from '@angular/material';
+
+@Component({
+  selector: 'app-confirmation-dialog',
+  templateUrl: './confirmation-dialog.component.html',
+  styleUrls: ['./confirmation-dialog.component.scss']
+})
+export class ConfirmationDialogComponent implements OnInit {
+
+  constructor(@Inject(MAT_DIALOG_DATA) public data: any) { }
+
+  ngOnInit() {
+  }
+
+}

dashflux/src/app/components/things/thing-dialog/thing-dialog.component.html

@@ -0,0 +1,34 @@
+<form [formGroup]="addThingForm" (ngSubmit)="onAddThing()">
+  <h1 mat-dialog-title>Add thing</h1>
+  <div mat-dialog-content fxLayout="column">
+    <input type="hidden" formControlName="id">
+    <mat-form-field *ngIf="!editMode">
+      <mat-select placeholder="Thing type" formControlName="type">
+        <mat-option value="app">
+          App
+        </mat-option>
+        <mat-option value="device">
+          Device
+        </mat-option>
+      </mat-select>
+      <mat-error *ngIf="addThingForm.get('type').errors?.required">
+        Type is required
+      </mat-error>
+    </mat-form-field>
+
+    <mat-form-field>
+      <input matInput tabindex="1" placeholder="Name" formControlName="name" />
+      <mat-error *ngIf="addThingForm.get('name').errors?.required">
+        Name is required
+      </mat-error>
+    </mat-form-field>
+    <mat-form-field>
+      <textarea formControlName="payload" matInput placeholder="Payload" matTextareaAutosize matAutosizeMinRows="2"
+                matAutosizeMaxRows="5"></textarea>
+    </mat-form-field>
+  </div>
+  <div mat-dialog-actions>
+    <button mat-button mat-dialog-close>Cancel</button>
+    <button mat-button mat-raised-button color="primary" type="submit" [disabled]="addThingForm.invalid">Ok</button>
+  </div>
+</form>

dashflux/src/app/components/things/thing-dialog/thing-dialog.component.spec.ts

@@ -0,0 +1,52 @@
+import { HttpClientModule } from '@angular/common/http';
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MAT_DIALOG_DATA, MatDialogModule, MatDialogRef } from '@angular/material';
+import { NoopAnimationsModule } from '@angular/platform-browser/animations';
+import { RouterTestingModule } from '@angular/router/testing';
+
+import { MaterialModule } from '../../../core/material/material.module';
+import { AuthenticationService } from '../../../core/services/auth/authentication.service';
+import { TokenStorage } from '../../../core/services/auth/token-storage.service';
+import { ChannelsService } from '../../../core/services/channels/channels.service';
+import { ThingsService } from '../../../core/services/things/things.service';
+import { ThingDialogComponent } from './thing-dialog.component';
+
+describe('ThingDialogComponent', () => {
+  let component: ThingDialogComponent;
+  let fixture: ComponentFixture<ThingDialogComponent>;
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [ ThingDialogComponent ],
+      imports: [
+        MaterialModule,
+        MatDialogModule,
+        HttpClientModule,
+        RouterTestingModule,
+        FormsModule,
+        ReactiveFormsModule,
+        NoopAnimationsModule
+      ],
+      providers: [
+        AuthenticationService,
+        TokenStorage,
+        ThingsService,
+        ChannelsService,
+        { provide: MatDialogRef, useValue: {} },
+        { provide: MAT_DIALOG_DATA, useValue: [] },
+      ]
+    })
+    .compileComponents();
+  }));
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(ThingDialogComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

dashflux/src/app/components/things/thing-dialog/thing-dialog.component.ts

@@ -0,0 +1,44 @@
+import { Component, EventEmitter, Inject, OnInit, Output } from '@angular/core';
+import { AbstractControl, FormBuilder, FormGroup, Validators } from '@angular/forms';
+import { MAT_DIALOG_DATA, MatDialogRef } from '@angular/material';
+
+import { Thing } from '../../../core/store/models';
+
+@Component({
+  selector: 'app-thing-dialog',
+  templateUrl: './thing-dialog.component.html',
+  styleUrls: ['./thing-dialog.component.scss']
+})
+export class ThingDialogComponent implements OnInit {
+  addThingForm: FormGroup;
+  @Output() submit: EventEmitter<Thing> = new EventEmitter<Thing>();
+  editMode: boolean;
+
+  constructor(
+    private fb: FormBuilder,
+    private dialogRef: MatDialogRef<ThingDialogComponent>,
+    @Inject(MAT_DIALOG_DATA) public data: Thing
+  ) { }
+
+  ngOnInit() {
+    this.addThingForm = this.fb.group(
+      {
+        id: null,
+        type: ['', [Validators.required]],
+        name: ['', [Validators.required, Validators.minLength(5)]],
+        payload: ['']
+      }
+    );
+
+    if (this.data) {
+      this.editMode = true;
+      this.addThingForm.patchValue(this.data);
+    }
+  }
+
+  onAddThing() {
+    const thing = this.addThingForm.value;
+    this.submit.emit(thing);
+    this.dialogRef.close();
+  }
+}

dashflux/src/app/components/things/things.component.html

@@ -0,0 +1,51 @@
+<div class="thingsContainer" fxLayout="row" fxLayoutWrap>
+  <ng-container [ngSwitch]="thingsStore.things?.length > 0">
+    <ng-container *ngSwitchCase="true">
+      <!-- List -->
+      <div class="things-list-container">
+        <mat-table #table [dataSource]="thingsStore.things.toJS()" matSort class="mat-cell">
+          <!-- Columns -->
+          <ng-container matColumnDef="id">
+            <mat-header-cell fxFlex="32%" *matHeaderCellDef mat-sort-header>Id</mat-header-cell>
+            <mat-cell fxFlex="32%" *matCellDef="let row" >{{row.id}}</mat-cell>
+          </ng-container>
+          <ng-container matColumnDef="name">
+            <mat-header-cell fxFlex="15%" *matHeaderCellDef mat-sort-header>Name</mat-header-cell>
+            <mat-cell fxFlex="15%" *matCellDef="let row"> {{row.name}}</mat-cell>
+          </ng-container>
+          <ng-container matColumnDef="type">
+            <mat-header-cell fxFlex="10%" *matHeaderCellDef mat-sort-header>Type</mat-header-cell>
+            <mat-cell fxFlex="10%" *matCellDef="let row"> {{row.type}}</mat-cell>
+          </ng-container>
+          <ng-container matColumnDef="payload">
+            <mat-header-cell fxFlex="35%" *matHeaderCellDef mat-sort-header>Payload</mat-header-cell>
+            <mat-cell fxFlex="35%" *matCellDef="let row"> {{row.payload | json}}</mat-cell>
+          </ng-container>
+          <!-- Actions -->
+          <ng-container matColumnDef="actions">
+            <mat-header-cell fxFlex="8%" *matHeaderCellDef mat-sort-header></mat-header-cell>
+            <mat-cell fxFlex="8%" *matCellDef="let row" >
+              <button mat-icon-button color="accent" (click)="editThing(row)">
+                <mat-icon aria-label="Delete">edit</mat-icon>
+              </button>
+              <button mat-icon-button color="accent" (click)="deleteThing(row)">
+                <mat-icon aria-label="Delete">delete</mat-icon>
+              </button>
+            </mat-cell>
+          </ng-container>
+
+          <mat-header-row *matHeaderRowDef="displayedColumns"></mat-header-row>
+          <mat-row *matRowDef="let row; columns: displayedColumns;"></mat-row>
+      </mat-table>
+    </div>
+
+    </ng-container>
+    <ng-container *ngSwitchDefault>
+      <h3 >It looks like you don't have any device in your account.</h3>
+    </ng-container>
+  </ng-container>
+</div>
+
+<button mat-mini-fab class="addButton" (click)="addThing()">
+  <mat-icon>add</mat-icon>
+</button>

dashflux/src/app/components/things/things.component.scss

@@ -0,0 +1,10 @@
+.addButton {
+    position: fixed;
+    bottom: 12px;
+    right: 12px;
+}
+
+/* List container */
+.things-list-container {
+  width: 100%;
+}

dashflux/src/app/components/things/things.component.spec.ts

@@ -0,0 +1,63 @@
+import { HttpClientModule } from '@angular/common/http';
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MAT_DIALOG_DATA, MatDialogModule, MatDialogRef } from '@angular/material';
+import { NoopAnimationsModule } from '@angular/platform-browser/animations';
+import { RouterTestingModule } from '@angular/router/testing';
+
+import { MaterialModule } from '../../core/material/material.module';
+import { AuthenticationService } from '../../core/services/auth/authentication.service';
+import { TokenStorage } from '../../core/services/auth/token-storage.service';
+import { ChannelsService } from '../../core/services/channels/channels.service';
+import { ThingsService } from '../../core/services/things/things.service';
+import { ThingsComponent } from './things.component';
+import { UiStore } from '../../core/store/ui.store';
+import { ThingsStore } from '../../core/store/things.store';
+import { ChannelsStore } from '../../core/store/channels.store';
+
+describe('ThingsComponent', () => {
+  let component: ThingsComponent;
+  let fixture: ComponentFixture<ThingsComponent>;
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [ ThingsComponent ],
+      imports: [
+        MaterialModule,
+        MatDialogModule,
+        HttpClientModule,
+        RouterTestingModule,
+        FormsModule,
+        ReactiveFormsModule,
+        NoopAnimationsModule,
+      ],
+      providers: [
+        UiStore,
+        {
+          provide: ThingsStore,
+          useClass: class {
+            getThings = jasmine.createSpy('getThings');
+          }
+        },
+        ChannelsStore,
+        AuthenticationService,
+        TokenStorage,
+        ThingsService,
+        ChannelsService,
+        { provide: MatDialogRef, useValue: {} },
+        { provide: MAT_DIALOG_DATA, useValue: [] },
+      ]
+    })
+    .compileComponents();
+  }));
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(ThingsComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

dashflux/src/app/components/things/things.component.ts

@@ -0,0 +1,63 @@
+import { Component, OnInit } from '@angular/core';
+import { MatDialog } from '@angular/material';
+import { toJS } from 'mobx';
+import { Observable } from 'rxjs/Observable';
+
+import { Thing } from '../../core/store/models';
+import { ConfirmationDialogComponent } from '../shared/confirmation-dialog/confirmation-dialog.component';
+import { ThingDialogComponent } from './thing-dialog/thing-dialog.component';
+import { ThingsStore } from '../../core/store/things.store';
+import { ChannelsStore } from '../../core/store/channels.store';
+
+@Component({
+  selector: 'app-things',
+  templateUrl: './things.component.html',
+  styleUrls: ['./things.component.scss']
+})
+export class ThingsComponent implements OnInit {
+  things: Observable<Thing[]>;
+  displayedColumns = ['id', 'name', 'type', 'payload', 'actions'];
+
+  constructor(
+    private dialog: MatDialog,
+    public thingsStore: ThingsStore,
+    public channelsStore: ChannelsStore,
+  ) { }
+
+  ngOnInit() {
+    this.thingsStore.getThings();
+    this.channelsStore.getChannels();
+  }
+
+  addThing() {
+    const dialogRef = this.dialog.open(ThingDialogComponent);
+
+    dialogRef.componentInstance.submit.subscribe((thing: Thing) => {
+      this.thingsStore.addThing(thing);
+    });
+  }
+
+  editThing(thing: Thing) {
+    const dialogRef = this.dialog.open(ThingDialogComponent, {
+      data: thing
+    });
+
+    dialogRef.componentInstance.submit.subscribe((editedThing: Thing) => {
+      this.thingsStore.editThing(toJS(editedThing));
+    });
+  }
+
+  deleteThing(thing: Thing) {
+    const dialogRef = this.dialog.open(ConfirmationDialogComponent, {
+      data: {
+        question: 'Are you sure you want to delete the thing?'
+      }
+    });
+
+    dialogRef.afterClosed().subscribe((result) => {
+      if (result) {
+        this.thingsStore.deleteThing(toJS(thing));
+      }
+    });
+  }
+}

dashflux/src/app/core/material/material.module.ts

@@ -0,0 +1,71 @@
+import { NgModule } from '@angular/core';
+import {
+  MatButtonModule,
+  MatButtonToggleModule,
+  MatCardModule,
+  MatCheckboxModule,
+  MatChipsModule,
+  MatDialogModule,
+  MatIconModule,
+  MatInputModule,
+  MatListModule,
+  MatMenuModule,
+  MatProgressSpinnerModule,
+  MatSelectModule,
+  MatSidenavModule,
+  MatSliderModule,
+  MatSlideToggleModule,
+  MatSnackBarModule,
+  MatTabsModule,
+  MatToolbarModule,
+  MatTooltipModule,
+  MatTableModule,
+} from '@angular/material';
+
+@NgModule({
+  imports: [
+    MatButtonModule,
+    MatButtonToggleModule,
+    MatCardModule,
+    MatDialogModule,
+    MatIconModule,
+    MatInputModule,
+    MatListModule,
+    MatMenuModule,
+    MatProgressSpinnerModule,
+    MatSelectModule,
+    MatSidenavModule,
+    MatSnackBarModule,
+    MatTabsModule,
+    MatToolbarModule,
+    MatTooltipModule,
+    MatCheckboxModule,
+    MatSliderModule,
+    MatSlideToggleModule,
+    MatChipsModule,
+    MatTableModule
+  ],
+  exports: [
+    MatButtonModule,
+    MatButtonToggleModule,
+    MatCardModule,
+    MatDialogModule,
+    MatIconModule,
+    MatInputModule,
+    MatListModule,
+    MatMenuModule,
+    MatProgressSpinnerModule,
+    MatSelectModule,
+    MatSidenavModule,
+    MatSnackBarModule,
+    MatTabsModule,
+    MatToolbarModule,
+    MatTooltipModule,
+    MatCheckboxModule,
+    MatSliderModule,
+    MatSlideToggleModule,
+    MatChipsModule,
+    MatTableModule
+  ],
+})
+export class MaterialModule { }

dashflux/src/app/core/services/auth/authentication.service.ts

@@ -0,0 +1,144 @@
+import '../../../rxjs-extensions';
+
+import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { AuthService } from 'ngx-auth';
+import { Observable } from 'rxjs/Observable';
+
+import { environment } from '../../../../environments/environment';
+import { TokenStorage } from './token-storage.service';
+
+
+interface AccessData {
+  token: string;
+}
+
+@Injectable()
+export class AuthenticationService implements AuthService {
+
+  constructor(
+    private http: HttpClient,
+    private tokenStorage: TokenStorage
+  ) { }
+
+  /**
+   * Check, if user already authorized.
+   * @description Should return Observable with true or false values
+   * @returns {Observable<boolean>}
+   * @memberOf AuthService
+   */
+  public isAuthorized(): Observable<boolean> {
+    return this.tokenStorage
+      .getAccessToken()
+      .map(token => !!token);
+  }
+
+  public getHeaders(token) {
+    return {
+      'Authorization': token
+    };
+  }
+
+  /**
+   * Get access token
+   * @description Should return access token in Observable from e.g.
+   * localStorage
+   * @returns {Observable<string>}
+   */
+  public getAccessToken(): Observable<string> {
+    return this.tokenStorage.getAccessToken();
+  }
+
+  /**
+   * Function, that should perform refresh token verifyTokenRequest
+   * @description Should be successfully completed so interceptor
+   * can execute pending requests or retry original one
+   * @returns {Observable<any>}
+   */
+  public refreshToken(): Observable<AccessData> {
+    return this.tokenStorage
+      .getRefreshToken()
+      .switchMap((refreshToken: string) => {
+        return this.http.post(`http://localhost:3000/refresh`, { refreshToken });
+      })
+      .do(this.saveAccessData.bind(this))
+      .catch((err) => {
+        this.logout();
+
+        return Observable.throw(err);
+      });
+  }
+
+  /**
+   * Function, checks response of failed request to determine,
+   * whether token be refreshed or not.
+   * @description Essentialy checks status
+   * @param {Response} response
+   * @returns {boolean}
+   */
+  public refreshShouldHappen(response: HttpErrorResponse): boolean {
+    return response.status === 401;
+  }
+
+  /**
+   * Verify that outgoing request is refresh-token,
+   * so interceptor won't intercept this request
+   * @param {string} url
+   * @returns {boolean}
+   */
+  public verifyTokenRequest(url: string): boolean {
+    return url.endsWith('/refresh');
+  }
+
+  /**
+   * EXTRA AUTH METHODS
+   */
+
+  public login(payload): Observable<any> {
+    return this.http.post(environment.loginUrl, payload)
+      .do((tokens: AccessData) => this.saveAccessData(tokens))
+      .catch((error) => {
+        let message = '';
+
+        if (error.status === 403) {
+          message = 'Wrong password or email';
+        } else {
+          message = 'Server side error';
+        }
+
+        return Observable.throw(message);
+      });
+  }
+
+  public signup(payload): Observable<any> {
+    return this.http.post(environment.signupUrl, payload)
+      .catch((error) => {
+        let message = '';
+        if (error.status === 409) {
+          message = 'Already existing email address';
+        } else {
+          message = 'Server side error';
+        }
+
+        return Observable.throw(message);
+      });
+  }
+
+  /**
+   * Logout
+   */
+  public logout(): void {
+    this.tokenStorage.clear();
+  }
+
+  /**
+   * Save access data in the storage
+   *
+   * @private
+   * @param {AccessData} data
+   */
+  private saveAccessData({ token }: AccessData) {
+    this.tokenStorage
+      .setAccessToken(token);
+  }
+}

dashflux/src/app/core/services/auth/token-storage.service.ts

@@ -0,0 +1,52 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs/Observable';
+
+@Injectable()
+export class TokenStorage {
+
+  /**
+   * Get access token
+   * @returns {Observable<string>}
+   */
+  public getAccessToken(): Observable<string> {
+    const token: string = <string>localStorage.getItem('accessToken');
+    return Observable.of(token);
+  }
+
+  /**
+   * Get refresh token
+   * @returns {Observable<string>}
+   */
+  public getRefreshToken(): Observable<string> {
+    const token: string = <string>localStorage.getItem('refreshToken');
+    return Observable.of(token);
+  }
+
+  /**
+   * Set access token
+   * @returns {TokenStorage}
+   */
+  public setAccessToken(token: string): TokenStorage {
+    localStorage.setItem('accessToken', token);
+
+    return this;
+  }
+
+   /**
+   * Set refresh token
+   * @returns {TokenStorage}
+   */
+  public setRefreshToken(token: string): TokenStorage {
+    localStorage.setItem('refreshToken', token);
+
+    return this;
+  }
+
+   /**
+   * Remove tokens
+   */
+  public clear() {
+    localStorage.removeItem('accessToken');
+    localStorage.removeItem('refreshToken');
+  }
+}

dashflux/src/app/core/services/auth/unauthorized.interceptor.ts

@@ -0,0 +1,21 @@
+import { Injectable } from '@angular/core';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpErrorResponse } from '@angular/common/http';
+import { Observable } from 'rxjs/Observable';
+import 'rxjs/add/operator/do';
+
+import { AuthStore } from '../../store/auth.store';
+
+@Injectable()
+export class UnauthorizedInterceptor implements HttpInterceptor {
+    constructor(
+        private authStore: AuthStore
+    ) {}
+
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+        return next.handle(req).do(event => {}, err => {
+            if (err instanceof HttpErrorResponse && err.status === 403) {
+                this.authStore.logout();
+            }
+        });
+    }
+}

dashflux/src/app/core/services/channels/channels.service.ts

@@ -0,0 +1,107 @@
+import { HttpClient, HttpResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs/Observable';
+import { forkJoin } from 'rxjs/observable/forkJoin';
+
+import { environment } from '../../../../environments/environment';
+import { Channel, Thing } from '../../store/models';
+
+interface ChannelsPayload {
+  channels: Channel[];
+}
+
+@Injectable()
+export class ChannelsService {
+
+  constructor(private http: HttpClient) { }
+
+  getChannels() {
+    return this.http.get(environment.channelsUrl).switchMap((payload: ChannelsPayload) => {
+      const allChannels = forkJoin(this.createChannelsRequests(payload.channels));
+      return allChannels;
+    }).switchMap((responses: Channel[]) => {
+      responses.forEach(channel => {
+        channel.connected = channel.connected ? channel.connected : [];
+      });
+      return Observable.of(responses);
+    });
+  }
+
+  createChannelsRequests(channels) {
+    return channels.map((channel => this.http.get(environment.channelsUrl + '/' + channel.id)));
+  }
+
+  addChannel(channel: Channel) {
+    const payload = {
+      name: channel.name
+    };
+
+    if (!channel.connected.length) {
+      console.log('send add ch');
+      return this.http.post(environment.channelsUrl, payload);
+    }
+    return this.http.post(environment.channelsUrl, payload, { observe: 'response' })
+      .switchMap((res) => {
+        const id = this.getChannelIdFrom(res);
+        return forkJoin(this.createThingsConnectRequests(id, channel.connected));
+      });
+  }
+
+  private getChannelIdFrom(res: HttpResponse<Object>) {
+    const location = res.headers.get('Location');
+    return location.replace('/channels/', '');
+  }
+
+  deleteChannel(channel: Channel) {
+    return this.http.delete(environment.channelsUrl + '/' + channel.id);
+  }
+
+  editChannel(channelFormData: Channel, channel: Channel) {
+    const payload = {
+      name: channelFormData.name
+    };
+
+    const editChannel = this.http.put(environment.channelsUrl + '/' + channel.id, payload);
+
+    return editChannel.switchMap(() => {
+      const thingsToAdd = this.getThingsToAdd(channelFormData, channel);
+      if (thingsToAdd.length) {
+        return forkJoin(this.createThingsConnectRequests(channel.id, thingsToAdd));
+      } else {
+        return Observable.of([]);
+      }
+    }).switchMap(() => {
+      const thingsToDelete = this.getThingsToDelete(channelFormData, channel);
+      console.log(thingsToDelete);
+      if (thingsToDelete.length) {
+        return forkJoin(this.createThingsDisconnectRequests(channel.id, thingsToDelete));
+      } else {
+        return Observable.of([]);
+      }
+    });
+  }
+
+  getThingsToDelete(channelFormData: Channel, channel: Channel) {
+    return channel.connected.filter(thing => {
+      return channelFormData.connected.find(th => th.id === thing.id) === undefined;
+    });
+  }
+
+  getThingsToAdd(channelFormData: Channel, channel: Channel) {
+    return channelFormData.connected.filter(thing => {
+      return channel.connected.find(th => th.id === thing.id) === undefined;
+    });
+  }
+
+  createThingsConnectRequests(channelId: string , connected: Thing[]) {
+    return connected.map((connection) => {
+      return this.http.put(environment.channelsUrl + '/' + channelId + '/things/' + connection.id, {});
+    });
+  }
+
+  createThingsDisconnectRequests(channelId: string , connected: Thing[]) {
+    return connected.map((connection) => {
+      return this.http.delete(environment.channelsUrl + '/' + channelId + '/things/' + connection.id, {});
+    });
+  }
+}

dashflux/src/app/core/services/mock-auth.service.ts

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs/Observable';
+
+import { User } from '../store/models';
+
+export const MOCK_USER = {
+  email: 'asdf@asdf.com',
+  password: 'asdf'
+};
+
+export const EXISTING_USER = {
+  email: '1234@1234.com',
+  password: '1234'
+};
+
+export const INVALID_CREDENTIALS_USER = {
+  email: 'pera@pera.com',
+  password: 'pera'
+};
+
+@Injectable()
+export class MockAuthService {
+  public signup(user: User): Observable<User> {
+    if (user.email === MOCK_USER.email) {
+      return Observable.of(user).delay(5000);
+    }
+
+    if (user.email === EXISTING_USER.email) {
+      return Observable.throw(new Error('User with email already exists.'));
+    }
+
+    return Observable.throw(new Error('Failed connecting to server.'));
+  }
+
+  public login(user: User): Observable<User> {
+    if (user.email === MOCK_USER.email) {
+      return Observable.of(user).delay(1000);
+    }
+
+    if (user.email === INVALID_CREDENTIALS_USER.email) {
+      return Observable.throw(new Error('Invalid credentials'));
+    }
+
+    return Observable.throw(new Error('Cannot connect to server'));
+  }
+}

dashflux/src/app/core/services/mock-channels.service.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs/Observable';
+
+import { Thing } from '../store/models';
+
+const MOCK_CHANNELS = {
+  channels: [
+    {
+      name: 'pera'
+    },
+    {
+      name: 'dzoni'
+    }
+  ]
+};
+
+@Injectable()
+export class MockChannelsService {
+  getChannels() {
+      return Observable.of(MOCK_CHANNELS).delay(1000);
+  }
+
+  addChannel(client: Thing) {
+    MOCK_CHANNELS.channels.push(client);
+    return Observable.of(1).delay(1000);
+  }
+}

dashflux/src/app/core/services/mock-things.service.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs/Observable';
+
+import { Thing } from '../store/models';
+
+const MOCK_THINGS = [
+];
+
+@Injectable()
+export class MockThingsService {
+  getThings() {
+      return Observable.of(MOCK_THINGS).delay(1000);
+  }
+
+  addThing(thing: Thing) {
+    MOCK_THINGS.push(thing);
+    return Observable.of(1).delay(1000);
+  }
+}

dashflux/src/app/core/services/things/things.service.ts

@@ -0,0 +1,27 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+
+import { environment } from '../../../../environments/environment';
+import { Thing } from '../../store/models';
+
+@Injectable()
+export class ThingsService {
+
+  constructor(private http: HttpClient) { }
+
+  getThings() {
+    return this.http.get(environment.thingsUrl);
+  }
+
+  addThing(thing: Thing) {
+    return this.http.post(environment.thingsUrl, thing);
+  }
+
+  deleteThing(thing: Thing) {
+    return this.http.delete(environment.thingsUrl + '/' + thing.id);
+  }
+
+  editThing(thing: Thing) {
+    return this.http.put(environment.thingsUrl + '/' + thing.id, thing);
+  }
+}

dashflux/src/app/core/store/auth.store.spec.ts

@@ -0,0 +1,178 @@
+import { HttpClientModule } from '@angular/common/http';
+import { inject, TestBed } from '@angular/core/testing';
+import { Router } from '@angular/router';
+import { RouterTestingModule } from '@angular/router/testing';
+import { Observable } from 'rxjs/Observable';
+
+import { AuthenticationService } from '../services/auth/authentication.service';
+import { TokenStorage } from '../services/auth/token-storage.service';
+import { ChannelsService } from '../services/channels/channels.service';
+import { ThingsService } from '../services/things/things.service';
+import { AuthStore } from './auth.store';
+import { UiStore } from './ui.store';
+
+describe('AuthStore', () => {
+    beforeEach(() => {
+        TestBed.configureTestingModule({
+            imports: [
+                HttpClientModule,
+                RouterTestingModule.withRoutes([])
+            ],
+            providers: [
+                AuthStore,
+                UiStore,
+                TokenStorage,
+                AuthenticationService,
+                ThingsService,
+                ChannelsService,
+            ]
+        });
+    });
+
+    it('should be created', inject([AuthStore], (authStore: AuthStore) => {
+        expect(authStore).toBeTruthy();
+    }));
+
+    describe('login', () => {
+        const user = {
+            email: 'user@user.com',
+            password: 'userPassword',
+        };
+
+        it('should set the loading flag to true before calling service', inject([AuthStore, UiStore, AuthenticationService],
+            (authStore: AuthStore, uiStore: UiStore, authService: AuthenticationService) => {
+                const spy = spyOn(authService, 'login').and.returnValue({ subscribe: () => { } });
+
+                authStore.login(user);
+
+                expect(uiStore.loading).toBeTruthy();
+            }));
+
+        it('should set the isAuthenticated flag to true when successfully authenticated', inject([AuthStore, AuthenticationService, Router],
+            (authStore: AuthStore, authService: AuthenticationService, router: Router) => {
+                const spy = spyOn(authService, 'login').and.returnValue(Observable.of(true));
+                const routerSpy = spyOn(router, 'navigate').and.stub();
+
+                authStore.login(user);
+
+                expect(authStore.isAuthenticated).toBeTruthy();
+            }));
+
+
+        it('should navigate to /things when successfully authenticated', inject([AuthStore, AuthenticationService, Router],
+            (authStore: AuthStore, authService: AuthenticationService, router: Router) => {
+                const spy = spyOn(authService, 'login').and.returnValue(Observable.of(true));
+                const routerSpy = spyOn(router, 'navigate').and.stub();
+
+                authStore.login(user);
+
+                expect(routerSpy).toHaveBeenCalledWith(['/things']);
+            }));
+
+        it('should set the loading flag to false when successfully authenticated',
+            inject([AuthStore, UiStore, AuthenticationService, Router],
+            (authStore: AuthStore, uiStore: UiStore, authService: AuthenticationService, router: Router) => {
+                const spy = spyOn(authService, 'login').and.returnValue(Observable.of(true));
+                const routerSpy = spyOn(router, 'navigate').and.stub();
+
+                authStore.login(user);
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+
+        it('should set the loading flag to false when authentication failed', inject([AuthStore, UiStore, AuthenticationService],
+            (authStore: AuthStore, uiStore: UiStore, authService: AuthenticationService) => {
+                const spy = spyOn(authService, 'login').and.returnValue(Observable.throw({ status: 403 }));
+
+                authStore.login(user);
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+
+        it('should set the authError to authentication error', inject([AuthStore, AuthenticationService],
+            (authStore: AuthStore, authService: AuthenticationService) => {
+                const spy = spyOn(authService, 'login').and.returnValue(Observable.throw('Auth failed'));
+
+                authStore.login(user);
+
+                expect(authStore.authError).toEqual('Auth failed');
+            }));
+    });
+
+    describe('signup', () => {
+        const user = {
+            email: 'user@user.com',
+            password: 'userPassword',
+        };
+
+        it('should set the loading flag to true before calling service', inject([AuthStore, UiStore, AuthenticationService],
+            (authStore: AuthStore, uiStore: UiStore, authService: AuthenticationService) => {
+                const spy = spyOn(authService, 'signup').and.returnValue({ subscribe: () => { } });
+
+                authStore.signup(user);
+
+                expect(uiStore.loading).toBeTruthy();
+            }));
+
+        it('should call the login when signup successfull', inject([AuthStore, AuthenticationService, Router],
+            (authStore: AuthStore, authService: AuthenticationService, router: Router) => {
+                const spy = spyOn(authService, 'signup').and.returnValue(Observable.of(true));
+                const routerSpy = spyOn(router, 'navigate').and.stub();
+                const loginSpy = spyOn(authStore, 'login').and.stub();
+
+                authStore.signup(user);
+
+                expect(loginSpy).toHaveBeenCalled();
+            }));
+
+        it('should set the loading flag to false when signup failed', inject([AuthStore, UiStore, AuthenticationService],
+            (authStore: AuthStore, uiStore: UiStore, authService: AuthenticationService) => {
+                const spy = spyOn(authService, 'signup').and.returnValue(Observable.throw('Signup failed'));
+
+                authStore.signup(user);
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+
+        it('should set the authError to signup error', inject([AuthStore, AuthenticationService],
+            (authStore: AuthStore, authService: AuthenticationService) => {
+                const spy = spyOn(authService, 'signup').and.returnValue(Observable.throw('Signup failed'));
+
+                authStore.signup(user);
+
+                expect(authStore.authError).toEqual('Signup failed');
+            }));
+    });
+
+    describe('logout', () => {
+        it('should call the authentication service logout', inject([AuthStore, AuthenticationService, Router],
+            (authStore: AuthStore, authService: AuthenticationService, router: Router) => {
+                const spy = spyOn(authService, 'logout');
+                const routerSpy = spyOn(router, 'navigate').and.stub();
+
+                authStore.logout();
+
+                expect(spy).toHaveBeenCalled();
+            }));
+
+        it('should set the isAuthenticated flag to false', inject([AuthStore, AuthenticationService, Router],
+            (authStore: AuthStore, authService: AuthenticationService, router: Router) => {
+                const spy = spyOn(authService, 'logout');
+                const routerSpy = spyOn(router, 'navigate').and.stub();
+
+                authStore.logout();
+
+                expect(authStore.isAuthenticated).toBeFalsy();
+            }));
+
+        it('should navigate to /login', inject([AuthStore, AuthenticationService, Router],
+            (authStore: AuthStore, authService: AuthenticationService, router: Router) => {
+                const spy = spyOn(authService, 'logout');
+                const routerSpy = spyOn(router, 'navigate').and.stub();
+
+                authStore.logout();
+
+                expect(routerSpy).toHaveBeenCalledWith(['/login']);
+            }));
+    });
+});

dashflux/src/app/core/store/auth.store.ts

@@ -0,0 +1,63 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { action, observable } from 'mobx';
+
+import { AuthenticationService } from '../services/auth/authentication.service';
+import { User } from './models';
+import { UiStore } from './ui.store';
+
+@Injectable()
+export class AuthStore {
+    @observable isAuthenticated = false;
+    @observable authError = '';
+
+    constructor(
+        private authenticationService: AuthenticationService,
+        private uiState: UiStore,
+        private router: Router,
+    ) {
+        this.authenticationService.isAuthorized().subscribe(
+            (isAuthenticated) => {
+                this.isAuthenticated = isAuthenticated;
+            }
+        );
+    }
+
+    @action
+    login(user: User) {
+        this.uiState.loading = true;
+
+        this.authenticationService.login(user)
+            .subscribe(() => {
+                this.uiState.loading = false;
+                this.isAuthenticated = true;
+                this.router.navigate(['/things']);
+            },
+            (error) => {
+                this.uiState.loading = false;
+                this.authError = error;
+            }
+            );
+    }
+
+    @action
+    signup(user: User) {
+        this.uiState.loading = true;
+
+        this.authenticationService.signup(user)
+            .subscribe(() => {
+                this.login(user);
+            },
+            (error) => {
+                this.uiState.loading = false;
+                this.authError = error;
+            });
+    }
+
+    @action
+    logout() {
+        this.authenticationService.logout();
+        this.isAuthenticated = false;
+        this.router.navigate(['/login']);
+    }
+}

dashflux/src/app/core/store/channels.store.spec.ts

@@ -0,0 +1,247 @@
+import { HttpClientModule } from '@angular/common/http';
+import { inject, TestBed } from '@angular/core/testing';
+import { RouterTestingModule } from '@angular/router/testing';
+import { toJS } from 'mobx';
+import { Observable } from 'rxjs/Observable';
+
+import { ChannelsService } from '../services/channels/channels.service';
+import { ChannelsStore } from './channels.store';
+import { Channel } from './models';
+import { UiStore } from './ui.store';
+
+describe('ChannelsStore', () => {
+    beforeEach(() => {
+        TestBed.configureTestingModule({
+            imports: [
+                HttpClientModule,
+                RouterTestingModule.withRoutes([])
+            ],
+            providers: [
+                ChannelsStore,
+                UiStore,
+                ChannelsService,
+            ]
+        });
+    });
+
+    it('should be created', inject([ChannelsStore], (channelsStore: ChannelsStore) => {
+        expect(channelsStore).toBeTruthy();
+    }));
+
+    describe('getChannels', () => {
+        it('should set the loading flag to true before service call', inject([ChannelsStore, UiStore, ChannelsService],
+            (channelsStore: ChannelsStore, uiStore: UiStore, channelsService: ChannelsService) => {
+                const getChannels = spyOn(channelsService, 'getChannels').and.returnValue({ subscribe: () => { } });
+
+                channelsStore.getChannels();
+
+                expect(uiStore.loading).toBeTruthy();
+            }));
+
+        it('should set the loading flag to false after successful get', inject([ChannelsStore, UiStore, ChannelsService],
+            (channelsStore: ChannelsStore, uiStore: UiStore, channelsService: ChannelsService) => {
+                const getChannels = spyOn(channelsService, 'getChannels').and.returnValue(Observable.of(true));
+
+                channelsStore.getChannels();
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+
+        it('should set the channels property to the returned channels from the service', inject([ChannelsStore, ChannelsService],
+            (channelsStore: ChannelsStore, channelsService: ChannelsService) => {
+                const serviceReturnValue = [];
+                const getChannels = spyOn(channelsService, 'getChannels').and.returnValue(Observable.of(serviceReturnValue));
+
+                channelsStore.getChannels();
+
+                expect(toJS(channelsStore.channels)).toEqual(serviceReturnValue);
+            }));
+
+        it('should set the loading flag to false after failed get', inject([ChannelsStore, UiStore, ChannelsService],
+            (channelsStore: ChannelsStore, uiStore: UiStore, channelsService: ChannelsService) => {
+                const getChannels = spyOn(channelsService, 'getChannels').and.returnValue(Observable.throw(''));
+
+                channelsStore.getChannels();
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+    });
+
+    describe('addChannel', () => {
+        it('should set the loading flag to true before service call', inject([ChannelsStore, UiStore, ChannelsService],
+            (channelsStore: ChannelsStore, uiStore: UiStore, channelsService: ChannelsService) => {
+                const addChannel = spyOn(channelsService, 'addChannel').and.returnValue({ subscribe: () => { } });
+                const newChannel: Channel = {
+                    name: 'new channel',
+                    connected: [],
+                };
+
+                channelsStore.addChannel(newChannel);
+
+                expect(uiStore.loading).toBeTruthy();
+            }));
+
+        it('should set the loading flag to false after successful service call', inject([ChannelsStore, UiStore, ChannelsService],
+            (channelsStore: ChannelsStore, uiStore: UiStore, channelsService: ChannelsService) => {
+                const addChannel = spyOn(channelsService, 'addChannel').and.returnValue(Observable.of(true));
+                const storeGetChannelsSpy = spyOn(channelsStore, 'getChannels').and.stub();
+                const newChannel: Channel = {
+                    name: 'new channel',
+                    connected: [],
+                };
+
+                channelsStore.addChannel(newChannel);
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+
+        it('should set the loading flag to false after failed service call', inject([ChannelsStore, UiStore, ChannelsService],
+            (channelsStore: ChannelsStore, uiStore: UiStore, channelsService: ChannelsService) => {
+                const addChannel = spyOn(channelsService, 'addChannel').and.returnValue(Observable.throw(''));
+                const storeGetChannelsSpy = spyOn(channelsStore, 'getChannels').and.stub();
+                const newChannel: Channel = {
+                    name: 'new channel',
+                    connected: [],
+                };
+
+                channelsStore.addChannel(newChannel);
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+
+        it('should call the channelsStore.getChannels after successful add', inject([ChannelsStore, ChannelsService],
+            (channelsStore: ChannelsStore, channelsService: ChannelsService) => {
+                const addChannel = spyOn(channelsService, 'addChannel').and.returnValue(Observable.of(true));
+                const storeGetChannelsSpy = spyOn(channelsStore, 'getChannels').and.stub();
+
+                const newChannel: Channel = {
+                    name: 'new channel',
+                    connected: [],
+                };
+
+                channelsStore.addChannel(newChannel);
+
+                expect(storeGetChannelsSpy).toHaveBeenCalled();
+            }));
+    });
+
+    describe('editChannel', () => {
+        it('should set the loading flag to true before service call', inject([ChannelsStore, UiStore, ChannelsService],
+            (channelsStore: ChannelsStore, uiStore: UiStore, channelsService: ChannelsService) => {
+                const addChannel = spyOn(channelsService, 'editChannel').and.returnValue({ subscribe: () => { } });
+                const editedChannel: Channel = {
+                    name: 'edited channel',
+                    connected: [],
+                };
+
+                channelsStore.editChannel(editedChannel);
+
+                expect(uiStore.loading).toBeTruthy();
+            }));
+
+        it('should set the loading flag to false after successful service call', inject([ChannelsStore, UiStore, ChannelsService],
+            (channelsStore: ChannelsStore, uiStore: UiStore, channelsService: ChannelsService) => {
+                const editChannel = spyOn(channelsService, 'editChannel').and.returnValue(Observable.of(true));
+                const storeGetChannelsSpy = spyOn(channelsStore, 'getChannels').and.stub();
+                const editedChannel: Channel = {
+                    name: 'edited channel',
+                    connected: [],
+                };
+
+
+                channelsStore.editChannel(editedChannel);
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+
+        it('should set the loading flag to false after failed service call', inject([ChannelsStore, UiStore, ChannelsService],
+            (channelsStore: ChannelsStore, uiStore: UiStore, channelsService: ChannelsService) => {
+                const editChannel = spyOn(channelsService, 'editChannel').and.returnValue(Observable.throw(''));
+                const storeGetChannelsSpy = spyOn(channelsStore, 'getChannels').and.stub();
+                const editedChannel: Channel = {
+                    name: 'edited channel',
+                    connected: [],
+                };
+
+
+                channelsStore.editChannel(editedChannel);
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+
+        it('should call the channelsStore.getChannels after successful add', inject([ChannelsStore, ChannelsService],
+            (channelsStore: ChannelsStore, channelsService: ChannelsService) => {
+                const editChannel = spyOn(channelsService, 'editChannel').and.returnValue(Observable.of(true));
+                const storeGetChannelsSpy = spyOn(channelsStore, 'getChannels').and.stub();
+
+                const editedChannel: Channel = {
+                    name: 'edited channel',
+                    connected: [],
+                };
+
+                channelsStore.editChannel(editedChannel);
+
+                expect(storeGetChannelsSpy).toHaveBeenCalled();
+            }));
+    });
+
+    describe('deleteChannel', () => {
+        it('should set the loading flag to true before service call', inject([ChannelsStore, UiStore, ChannelsService],
+            (channelsStore: ChannelsStore, uiStore: UiStore, channelsService: ChannelsService) => {
+                const deleteChannel = spyOn(channelsService, 'deleteChannel').and.returnValue({ subscribe: () => { } });
+                const channelToBeDeleted: Channel = {
+                    name: 'channelToBeDeleted',
+                    connected: [],
+                };
+
+                channelsStore.deleteChannel(channelToBeDeleted);
+
+                expect(uiStore.loading).toBeTruthy();
+            }));
+
+        it('should set the loading flag to false after successful service call', inject([ChannelsStore, UiStore, ChannelsService],
+            (channelsStore: ChannelsStore, uiStore: UiStore, channelsService: ChannelsService) => {
+                const deleteChannel = spyOn(channelsService, 'deleteChannel').and.returnValue(Observable.of(true));
+                const storeGetChannelsSpy = spyOn(channelsStore, 'getChannels').and.stub();
+                const channelToBeDeleted: Channel = {
+                    name: 'channelToBeDeleted',
+                    connected: [],
+                };
+
+
+                channelsStore.deleteChannel(channelToBeDeleted);
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+    
+        it('should set the loading flag to false after failed service call', inject([ChannelsStore, UiStore, ChannelsService],
+            (channelsStore: ChannelsStore, uiStore: UiStore, channelsService: ChannelsService) => {
+                const deleteChannel = spyOn(channelsService, 'deleteChannel').and.returnValue(Observable.throw(''));
+                const storeGetChannelsSpy = spyOn(channelsStore, 'getChannels').and.stub();
+                const channelToBeDeleted: Channel = {
+                    name: 'channelToBeDeleted',
+                    connected: [],
+                };
+
+
+                channelsStore.deleteChannel(channelToBeDeleted);
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+
+        it('should call the channelsStore.getChannels after successful add', inject([ChannelsStore, ChannelsService],
+            (channelsStore: ChannelsStore, channelsService: ChannelsService) => {
+                const deleteChannel = spyOn(channelsService, 'deleteChannel').and.returnValue(Observable.of(true));
+                const storeGetChannelsSpy = spyOn(channelsStore, 'getChannels').and.stub();
+
+                const channelToBeDeleted: Channel = {
+                    name: 'channelToBeDeleted',
+                    connected: [],
+                };
+
+                channelsStore.deleteChannel(channelToBeDeleted);
+
+                expect(storeGetChannelsSpy).toHaveBeenCalled();
+            }));
+    });
+});

dashflux/src/app/core/store/channels.store.ts

@@ -0,0 +1,70 @@
+import { Injectable } from '@angular/core';
+import { action, observable } from 'mobx';
+
+import { ChannelsService } from '../services/channels/channels.service';
+import { Channel } from './models';
+import { UiStore } from './ui.store';
+
+@Injectable()
+export class ChannelsStore {
+    @observable channels: Channel[] = [];
+
+    constructor(
+        private uiState: UiStore,
+        private channelsService: ChannelsService,
+    ) { }
+
+    @action
+    getChannels() {
+        this.uiState.loading = true;
+        this.channelsService.getChannels()
+            .subscribe((payload: any) => {
+                this.uiState.loading = false;
+                this.channels = payload;
+            }, () => {
+                this.uiState.loading = false;
+            });
+    }
+
+    @action
+    addChannel(channel: Channel) {
+        this.uiState.loading = true;
+        console.log('add ch');
+        this.channelsService.addChannel(channel)
+            .subscribe(resp => {
+                console.log(resp);
+                this.uiState.loading = false;
+                this.getChannels();
+            }, () => {
+                this.uiState.loading = false;
+            });
+    }
+
+    @action
+    editChannel(editedChannel: Channel) {
+        this.uiState.loading = true;
+        this.channelsService.editChannel(editedChannel, this.getChannelById(editedChannel.id))
+            .subscribe(() => {
+                this.uiState.loading = false;
+                this.getChannels();
+            }, () => {
+                this.uiState.loading = false;
+            });
+    }
+
+    private getChannelById(id: string) {
+        return this.channels.find(ch => ch.id === id);
+    }
+
+    @action
+    deleteChannel(channel: Channel) {
+        this.uiState.loading = true;
+        this.channelsService.deleteChannel(channel)
+            .subscribe(() => {
+                this.uiState.loading = false;
+                this.getChannels();
+            }, () => {
+                this.uiState.loading = false;
+            });
+    }
+}

dashflux/src/app/core/store/models.ts

@@ -0,0 +1,17 @@
+export interface Channel {
+    id?: '';
+    name: string;
+    connected: Thing[];
+}
+
+export interface Thing {
+    id?: '';
+    type: string;
+    name: string;
+    payload: string;
+}
+
+export interface User {
+    email: string;
+    password: string;
+}

dashflux/src/app/core/store/things.store.spec.ts

@@ -0,0 +1,256 @@
+import { HttpClientModule } from '@angular/common/http';
+import { inject, TestBed } from '@angular/core/testing';
+import { RouterTestingModule } from '@angular/router/testing';
+import { toJS } from 'mobx';
+import { Observable } from 'rxjs/Observable';
+
+import { ThingsService } from '../services/things/things.service';
+import { ThingsStore } from './things.store';
+import { Thing } from './models';
+import { UiStore } from './ui.store';
+
+describe('ThingsStore', () => {
+    beforeEach(() => {
+        TestBed.configureTestingModule({
+            imports: [
+                HttpClientModule,
+                RouterTestingModule.withRoutes([])
+            ],
+            providers: [
+                ThingsStore,
+                UiStore,
+                ThingsService,
+            ]
+        });
+    });
+
+    it('should be created', inject([ThingsStore], (thingsStore: ThingsStore) => {
+        expect(thingsStore).toBeTruthy();
+    }));
+
+    describe('getThings', () => {
+        it('should set the loading flag to true before service call', inject([ThingsStore, UiStore, ThingsService],
+            (thingsStore: ThingsStore, uiStore: UiStore, thingsService: ThingsService) => {
+                const getThings = spyOn(thingsService, 'getThings').and.returnValue({ subscribe: () => { } });
+
+                thingsStore.getThings();
+
+                expect(uiStore.loading).toBeTruthy();
+            }));
+
+        it('should set the loading flag to false after successful get', inject([ThingsStore, UiStore, ThingsService],
+            (thingsStore: ThingsStore, uiStore: UiStore, thingsService: ThingsService) => {
+                const getThings = spyOn(thingsService, 'getThings').and.returnValue(Observable.of(true));
+
+                thingsStore.getThings();
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+
+        it('should set the things property to the returned things from the service', inject([ThingsStore, ThingsService],
+            (thingsStore: ThingsStore, thingsService: ThingsService) => {
+                const serviceReturnValue = { things: [] };
+                const getChannels = spyOn(thingsService, 'getThings').and.returnValue(Observable.of(serviceReturnValue));
+
+                thingsStore.getThings();
+
+                expect(toJS(thingsStore.things)).toEqual(serviceReturnValue.things);
+            }));
+
+        it('should set the loading flag to false after failed get', inject([ThingsStore, UiStore, ThingsService],
+            (thingsStore: ThingsStore, uiStore: UiStore, thingsService: ThingsService) => {
+                const getThings = spyOn(thingsService, 'getThings').and.returnValue(Observable.throw(''));
+
+                thingsStore.getThings();
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+    });
+
+    describe('addThing', () => {
+        it('should set the loading flag to true before service call', inject([ThingsStore, UiStore, ThingsService],
+            (thingsStore: ThingsStore, uiStore: UiStore, thingsService: ThingsService) => {
+                const addThing = spyOn(thingsService, 'addThing').and.returnValue({ subscribe: () => { } });
+                const newThing: Thing = {
+                    name: 'new thing',
+                    type: 'app',
+                    payload: '',
+                };
+
+                thingsStore.addThing(newThing);
+
+                expect(uiStore.loading).toBeTruthy();
+            }));
+
+        it('should set the loading flag to false after successful service call', inject([ThingsStore, UiStore, ThingsService],
+            (thingsStore: ThingsStore, uiStore: UiStore, thingsService: ThingsService) => {
+                const addThing = spyOn(thingsService, 'addThing').and.returnValue(Observable.of(true));
+                const storeGetThingsSpy = spyOn(thingsStore, 'getThings').and.stub();
+                const newThing: Thing = {
+                    name: 'new thing',
+                    type: 'app',
+                    payload: '',
+                };
+
+                thingsStore.addThing(newThing);
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+
+        it('should call the thingsStore.getThings after successful add', inject([ThingsStore, ThingsService],
+            (thingsStore: ThingsStore, thingsService: ThingsService) => {
+                const addThing = spyOn(thingsService, 'addThing').and.returnValue(Observable.of(true));
+                const storeGetThingsSpy = spyOn(thingsStore, 'getThings').and.stub();
+                const newThing: Thing = {
+                    name: 'new thing',
+                    type: 'app',
+                    payload: '',
+                };
+
+                thingsStore.addThing(newThing);
+
+                expect(storeGetThingsSpy).toHaveBeenCalled();
+            }));
+
+        it('should set the loading flag to false after failed add', inject([ThingsStore, UiStore, ThingsService],
+            (thingsStore: ThingsStore, uiStore: UiStore, thingsService: ThingsService) => {
+                const addThing = spyOn(thingsService, 'addThing').and.returnValue(Observable.throw(''));
+                const storeGetThingsSpy = spyOn(thingsStore, 'getThings').and.stub();
+
+                const newThing: Thing = {
+                    name: 'new thing',
+                    type: 'app',
+                    payload: '',
+                };
+
+                thingsStore.addThing(newThing);
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+    });
+
+    describe('editThing', () => {
+        it('should set the loading flag to true before service call', inject([ThingsStore, UiStore, ThingsService],
+            (thingsStore: ThingsStore, uiStore: UiStore, thingsService: ThingsService) => {
+                const editThing = spyOn(thingsService, 'editThing').and.returnValue({ subscribe: () => { } });
+                const editedThing: Thing = {
+                    name: 'edited thing',
+                    type: 'app',
+                    payload: '',
+                };
+
+                thingsStore.editThing(editedThing);
+
+                expect(uiStore.loading).toBeTruthy();
+            }));
+
+        it('should set the loading flag to false after successful service call', inject([ThingsStore, UiStore, ThingsService],
+            (thingsStore: ThingsStore, uiStore: UiStore, thingsService: ThingsService) => {
+                const editThing = spyOn(thingsService, 'editThing').and.returnValue(Observable.of(true));
+                const storeGetThingsSpy = spyOn(thingsStore, 'getThings').and.stub();
+                const editedThing: Thing = {
+                    name: 'edited thing',
+                    type: 'app',
+                    payload: '',
+                };
+
+                thingsStore.editThing(editedThing);
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+
+        it('should call the thingsStore.getChannels after successful edit', inject([ThingsStore, UiStore, ThingsService],
+            (thingsStore: ThingsStore, uiStore: UiStore, thingsService: ThingsService) => {
+                const editThing = spyOn(thingsService, 'editThing').and.returnValue(Observable.of(true));
+                const storeGetThingsSpy = spyOn(thingsStore, 'getThings').and.stub();
+
+                const editedThing: Thing = {
+                    name: 'edited thing',
+                    type: 'app',
+                    payload: '',
+                };
+
+                thingsStore.editThing(editedThing);
+
+                expect(storeGetThingsSpy).toHaveBeenCalled();
+            }));
+
+        it('should set the loading flag to false after failed edit', inject([ThingsStore, UiStore, ThingsService],
+            (thingsStore: ThingsStore, uiStore: UiStore, thingsService: ThingsService) => {
+                const editThing = spyOn(thingsService, 'editThing').and.returnValue(Observable.throw(''));
+                const storeGetThingsSpy = spyOn(thingsStore, 'getThings').and.stub();
+                const editedThing: Thing = {
+                    name: 'edited thing',
+                    type: 'app',
+                    payload: '',
+                };
+
+                thingsStore.editThing(editedThing);
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+    });
+
+    describe('deleteThing', () => {
+        it('should set the loading flag to true before service call', inject([ThingsStore, UiStore, ThingsService],
+            (thingsStore: ThingsStore, uiStore: UiStore, thingsService: ThingsService) => {
+                const deleteThing = spyOn(thingsService, 'deleteThing').and.returnValue({ subscribe: () => { } });
+                const thingToBeDeleted: Thing = {
+                    name: 'thingToBeDeleted',
+                    type: 'app',
+                    payload: ''
+                };
+
+                thingsStore.deleteThing(thingToBeDeleted);
+
+                expect(uiStore.loading).toBeTruthy();
+            }));
+
+        it('should set the loading flag to false after successful service call', inject([ThingsStore, UiStore, ThingsService],
+            (thingsStore: ThingsStore, uiStore: UiStore, thingsService: ThingsService) => {
+                const deleteThing = spyOn(thingsService, 'deleteThing').and.returnValue(Observable.of(true));
+                const storeGetThingsSpy = spyOn(thingsStore, 'getThings').and.stub();
+                const thingToBeDeleted: Thing = {
+                    name: 'thingToBeDeleted',
+                    type: 'app',
+                    payload: ''
+                };
+
+
+                thingsStore.deleteThing(thingToBeDeleted);
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+
+        it('should call the thingsStore.getChannels after successful add', inject([ThingsStore, ThingsService],
+            (thingsStore: ThingsStore, thingsService: ThingsService) => {
+                const deleteThing = spyOn(thingsService, 'deleteThing').and.returnValue(Observable.of(true));
+                const storeGetThingsSpy = spyOn(thingsStore, 'getThings').and.stub();
+
+                const thingToBeDeleted: Thing = {
+                    name: 'thingToBeDeleted',
+                    type: 'app',
+                    payload: ''
+                };
+
+                thingsStore.deleteThing(thingToBeDeleted);
+
+                expect(storeGetThingsSpy).toHaveBeenCalled();
+            }));
+
+        it('should set the loading flag to false after failed delete', inject([ThingsStore, UiStore, ThingsService],
+            (thingsStore: ThingsStore, uiStore: UiStore, thingsService: ThingsService) => {
+                const deleteThing = spyOn(thingsService, 'deleteThing').and.returnValue(Observable.throw(''));
+                const storeGetThingsSpy = spyOn(thingsStore, 'getThings').and.stub();
+                const thingToBeDeleted: Thing = {
+                    name: 'thingToBeDeleted',
+                    type: 'app',
+                    payload: ''
+                };
+
+                thingsStore.deleteThing(thingToBeDeleted);
+
+                expect(uiStore.loading).toBeFalsy();
+            }));
+    });
+});

dashflux/src/app/core/store/things.store.ts

@@ -0,0 +1,64 @@
+import { Injectable } from '@angular/core';
+import { action, observable } from 'mobx';
+
+import { ThingsService } from '../services/things/things.service';
+import { Thing } from './models';
+import { UiStore } from './ui.store';
+
+@Injectable()
+export class ThingsStore {
+    @observable things: Thing[] = [];
+
+    constructor(
+        private uiState: UiStore,
+        private thingsService: ThingsService,
+    ) { }
+
+    @action
+    getThings() {
+        this.uiState.loading = true;
+        this.thingsService.getThings()
+            .subscribe((payload: any) => {
+                this.uiState.loading = false;
+                this.things = payload.things;
+            }, () => {
+                this.uiState.loading = false;
+            });
+    }
+
+    @action
+    addThing(thing: Thing) {
+        this.uiState.loading = true;
+        this.thingsService.addThing(thing)
+            .subscribe(() => {
+                this.uiState.loading = false;
+                this.getThings();
+            }, () => {
+                this.uiState.loading = false;
+            });
+    }
+
+    @action
+    editThing(thing: Thing) {
+        this.uiState.loading = true;
+        this.thingsService.editThing(thing)
+            .subscribe(() => {
+                this.uiState.loading = false;
+                this.getThings();
+            }, () => {
+                this.uiState.loading = false;
+            });
+    }
+
+    @action
+    deleteThing(thing: Thing) {
+        this.uiState.loading = true;
+        this.thingsService.deleteThing(thing)
+            .subscribe(() => {
+                this.uiState.loading = false;
+                this.getThings();
+            }, () => {
+                this.uiState.loading = false;
+            });
+    }
+}

dashflux/src/app/core/store/ui.store.spec.ts

@@ -0,0 +1,57 @@
+import { HttpClientModule } from '@angular/common/http';
+import { inject, TestBed } from '@angular/core/testing';
+import { Router } from '@angular/router';
+import { RouterTestingModule } from '@angular/router/testing';
+
+import { AuthenticationService } from '../services/auth/authentication.service';
+import { TokenStorage } from '../services/auth/token-storage.service';
+import { ChannelsService } from '../services/channels/channels.service';
+import { ThingsService } from '../services/things/things.service';
+import { UiStore } from './ui.store';
+
+describe('State', () => {
+    beforeEach(() => {
+        TestBed.configureTestingModule({
+            imports: [
+                HttpClientModule,
+                RouterTestingModule.withRoutes([])
+            ],
+            providers: [
+                UiStore,
+                UiStore,
+                TokenStorage,
+                AuthenticationService,
+                ThingsService,
+                ChannelsService,
+            ]
+        });
+    });
+
+    it('should be created', inject([UiStore], (uiStore: UiStore) => {
+        expect(uiStore).toBeTruthy();
+    }));
+
+    describe('goToSignup', () => {
+        it('should navigate to /signup', inject([UiStore, Router],
+            (uiStore: UiStore, router: Router) => {
+                const routerSpy = spyOn(router, 'navigate').and.stub();
+
+                uiStore.goToSignup();
+
+                expect(routerSpy).toHaveBeenCalledWith(['/signup']);
+            }));
+    });
+
+    describe('goToLogin', () => {
+        it('should navigate to /login', inject([UiStore, Router],
+            (uiStore: UiStore, router: Router) => {
+                const routerSpy = spyOn(router, 'navigate').and.stub();
+
+                uiStore.goToLogin();
+
+                expect(routerSpy).toHaveBeenCalledWith(['/login']);
+            }));
+    });
+});
+
+

dashflux/src/app/core/store/ui.store.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { action, observable } from 'mobx';
+
+@Injectable()
+export class UiStore {
+    @observable loading = false;
+
+    constructor(
+        private router: Router
+    ) { }
+
+
+    @action
+    goToSignup() {
+        this.router.navigate(['/signup']);
+    }
+
+    @action
+    goToLogin() {
+        this.router.navigate(['/login']);
+    }
+}

dashflux/src/app/rxjs-extensions.ts

@@ -0,0 +1,19 @@
+import 'rxjs/add/observable/combineLatest';
+import 'rxjs/add/observable/interval';
+import 'rxjs/add/observable/of';
+import 'rxjs/add/observable/from';
+import 'rxjs/add/observable/throw';
+import 'rxjs/add/operator/concatMap';
+import 'rxjs/add/operator/catch';
+import 'rxjs/add/operator/debounceTime';
+import 'rxjs/add/operator/delay';
+import 'rxjs/add/operator/do';
+import 'rxjs/add/operator/finally';
+import 'rxjs/add/operator/map';
+import 'rxjs/add/operator/mergeMap';
+import 'rxjs/add/operator/retry';
+import 'rxjs/add/operator/startWith';
+import 'rxjs/add/operator/switchMap';
+import 'rxjs/add/operator/take';
+import 'rxjs/add/operator/toPromise';
+import 'rxjs/add/operator/withLatestFrom';

dashflux/src/environments/environment.prod.ts

@@ -0,0 +1,7 @@
+export const environment = {
+  production: true,
+  signupUrl: '/users',
+  loginUrl: '/tokens',
+  thingsUrl: '/things',
+  channelsUrl: '/channels'
+};

dashflux/src/environments/environment.ts

@@ -0,0 +1,12 @@
+// The file contents for the current environment will overwrite these during build.
+// The build system defaults to the dev environment which uses `environment.ts`, but if you do
+// `ng build --env=prod` then `environment.prod.ts` will be used instead.
+// The list of which env maps to which file can be found in `.angular-cli.json`.
+
+export const environment = {
+  production: false,
+  signupUrl: '/users',
+  loginUrl: '/tokens',
+  thingsUrl: '/things',
+  channelsUrl: '/channels'
+};

dashflux/src/index.html

@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>Mainflux UI</title>
+  <base href="/">
+
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <link rel="icon" type="image/x-icon" href="favicon.ico">
+  <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet"> 
+</head>
+<body>
+  <app-root></app-root>
+</body>
+</html>

dashflux/src/main.ts

@@ -0,0 +1,12 @@
+import { enableProdMode } from '@angular/core';
+import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+
+import { AppModule } from './app/app.module';
+import { environment } from './environments/environment';
+
+if (environment.production) {
+  enableProdMode();
+}
+
+platformBrowserDynamic().bootstrapModule(AppModule)
+  .catch(err => console.log(err));

dashflux/src/polyfills.ts

@@ -0,0 +1,76 @@
+/**
+ * This file includes polyfills needed by Angular and is loaded before the app.
+ * You can add your own extra polyfills to this file.
+ *
+ * This file is divided into 2 sections:
+ *   1. Browser polyfills. These are applied before loading ZoneJS and are sorted by browsers.
+ *   2. Application imports. Files imported after ZoneJS that should be loaded before your main
+ *      file.
+ *
+ * The current setup is for so-called "evergreen" browsers; the last versions of browsers that
+ * automatically update themselves. This includes Safari >= 10, Chrome >= 55 (including Opera),
+ * Edge >= 13 on the desktop, and iOS 10 and Chrome on mobile.
+ *
+ * Learn more in https://angular.io/docs/ts/latest/guide/browser-support.html
+ */
+
+/***************************************************************************************************
+ * BROWSER POLYFILLS
+ */
+
+/** IE9, IE10 and IE11 requires all of the following polyfills. **/
+// import 'core-js/es6/symbol';
+// import 'core-js/es6/object';
+// import 'core-js/es6/function';
+// import 'core-js/es6/parse-int';
+// import 'core-js/es6/parse-float';
+// import 'core-js/es6/number';
+// import 'core-js/es6/math';
+// import 'core-js/es6/string';
+// import 'core-js/es6/date';
+// import 'core-js/es6/array';
+// import 'core-js/es6/regexp';
+// import 'core-js/es6/map';
+// import 'core-js/es6/weak-map';
+// import 'core-js/es6/set';
+
+/** IE10 and IE11 requires the following for NgClass support on SVG elements */
+// import 'classlist.js';  // Run `npm install --save classlist.js`.
+
+/** IE10 and IE11 requires the following for the Reflect API. */
+// import 'core-js/es6/reflect';
+
+
+/** Evergreen browsers require these. **/
+// Used for reflect-metadata in JIT. If you use AOT (and only Angular decorators), you can remove.
+import 'core-js/es7/reflect';
+
+
+/**
+ * Required to support Web Animations `@angular/platform-browser/animations`.
+ * Needed for: All but Chrome, Firefox and Opera. http://caniuse.com/#feat=web-animation
+ **/
+// import 'web-animations-js';  // Run `npm install --save web-animations-js`.
+
+
+
+/***************************************************************************************************
+ * Zone JS is required by Angular itself.
+ */
+import 'zone.js/dist/zone';  // Included with Angular CLI.
+
+
+
+/***************************************************************************************************
+ * APPLICATION IMPORTS
+ */
+
+/**
+ * Date, currency, decimal and percent pipes.
+ * Needed for: All but Chrome, Firefox, Edge, IE11 and Safari 10
+ */
+// import 'intl';  // Run `npm install --save intl`.
+/**
+ * Need to import at least one locale-data with intl.
+ */
+// import 'intl/locale-data/jsonp/en';

dashflux/src/styles.scss

@@ -0,0 +1 @@
+@import '~@angular/material/prebuilt-themes/indigo-pink.css';

dashflux/src/test.ts

@@ -0,0 +1,32 @@
+// This file is required by karma.conf.js and loads recursively all the .spec and framework files
+
+import 'zone.js/dist/long-stack-trace-zone';
+import 'zone.js/dist/proxy.js';
+import 'zone.js/dist/sync-test';
+import 'zone.js/dist/jasmine-patch';
+import 'zone.js/dist/async-test';
+import 'zone.js/dist/fake-async-test';
+import { getTestBed } from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting
+} from '@angular/platform-browser-dynamic/testing';
+
+// Unfortunately there's no typing for the `__karma__` variable. Just declare it as any.
+declare const __karma__: any;
+declare const require: any;
+
+// Prevent Karma from running prematurely.
+__karma__.loaded = function () {};
+
+// First, initialize the Angular testing environment.
+getTestBed().initTestEnvironment(
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting()
+);
+// Then we find all the tests.
+const context = require.context('./', true, /\.spec\.ts$/);
+// And load the modules.
+context.keys().map(context);
+// Finally, start Karma to run the tests.
+__karma__.start();

dashflux/src/tsconfig.app.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../out-tsc/app",
+    "baseUrl": "./",
+    "module": "es2015",
+    "types": []
+  },
+  "include": [ "../node_modules/ngx-auth/**/*", "**/*"],
+  "exclude": [
+    "test.ts",
+    "**/*.spec.ts"
+  ]
+}

dashflux/src/tsconfig.spec.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "sourceMap": true,
+    "declaration": false,
+    "moduleResolution": "node",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "lib": [
+      "es2017",
+      "dom"
+    ],
+    "outDir": "../out-tsc/spec",
+    "module": "commonjs",
+    "target": "es5",
+    "baseUrl": "",
+    "types": [
+      "jasmine",
+      "node"
+    ]
+  },
+  "files": [
+    "test.ts"
+  ],
+  "include": [
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}

dashflux/src/typings.d.ts

@@ -0,0 +1,5 @@
+/* SystemJS module definition */
+declare var module: NodeModule;
+interface NodeModule {
+  id: string;
+}

dashflux/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "outDir": "./dist/out-tsc",
+    "sourceMap": true,
+    "declaration": false,
+    "moduleResolution": "node",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "es5",
+    "typeRoots": [
+      "node_modules/@types"
+    ],
+    "lib": [
+      "es2017",
+      "dom"
+    ]
+  }
+}

dashflux/tslint.json

@@ -0,0 +1,141 @@
+{
+  "rulesDirectory": [
+    "node_modules/codelyzer"
+  ],
+  "rules": {
+    "arrow-return-shorthand": true,
+    "callable-types": true,
+    "class-name": true,
+    "comment-format": [
+      true,
+      "check-space"
+    ],
+    "curly": true,
+    "eofline": true,
+    "forin": true,
+    "import-blacklist": [
+      true,
+      "rxjs",
+      "rxjs/Rx"
+    ],
+    "import-spacing": true,
+    "indent": [
+      true,
+      "spaces"
+    ],
+    "interface-over-type-literal": true,
+    "label-position": true,
+    "max-line-length": [
+      true,
+      140
+    ],
+    "member-access": false,
+    "member-ordering": [
+      true,
+      {
+        "order": [
+          "static-field",
+          "instance-field",
+          "static-method",
+          "instance-method"
+        ]
+      }
+    ],
+    "no-arg": true,
+    "no-bitwise": true,
+    "no-console": [
+      true,
+      "debug",
+      "info",
+      "time",
+      "timeEnd",
+      "trace"
+    ],
+    "no-construct": true,
+    "no-debugger": true,
+    "no-duplicate-super": true,
+    "no-empty": false,
+    "no-empty-interface": true,
+    "no-eval": true,
+    "no-inferrable-types": [
+      true,
+      "ignore-params"
+    ],
+    "no-misused-new": true,
+    "no-non-null-assertion": true,
+    "no-shadowed-variable": true,
+    "no-string-literal": false,
+    "no-string-throw": true,
+    "no-switch-case-fall-through": true,
+    "no-trailing-whitespace": true,
+    "no-unnecessary-initializer": true,
+    "no-unused-expression": true,
+    "no-use-before-declare": true,
+    "no-var-keyword": true,
+    "object-literal-sort-keys": false,
+    "one-line": [
+      true,
+      "check-open-brace",
+      "check-catch",
+      "check-else",
+      "check-whitespace"
+    ],
+    "prefer-const": true,
+    "quotemark": [
+      true,
+      "single"
+    ],
+    "radix": true,
+    "semicolon": [
+      true,
+      "always"
+    ],
+    "triple-equals": [
+      true,
+      "allow-null-check"
+    ],
+    "typedef-whitespace": [
+      true,
+      {
+        "call-signature": "nospace",
+        "index-signature": "nospace",
+        "parameter": "nospace",
+        "property-declaration": "nospace",
+        "variable-declaration": "nospace"
+      }
+    ],
+    "typeof-compare": true,
+    "unified-signatures": true,
+    "variable-name": false,
+    "whitespace": [
+      true,
+      "check-branch",
+      "check-decl",
+      "check-operator",
+      "check-separator",
+      "check-type"
+    ],
+    "directive-selector": [
+      true,
+      "attribute",
+      "app",
+      "camelCase"
+    ],
+    "component-selector": [
+      true,
+      "element",
+      "app",
+      "kebab-case"
+    ],
+    "use-input-property-decorator": true,
+    "use-output-property-decorator": true,
+    "use-host-property-decorator": true,
+    "no-input-rename": true,
+    "no-output-rename": true,
+    "use-life-cycle-interface": true,
+    "use-pipe-transform-interface": true,
+    "component-class-suffix": true,
+    "directive-class-suffix": true,
+    "invoke-injectable": true
+  }
+}