statping/dev/README.md

This readme is automatically generated from the Golang documentation. [![GoDoc](https://godoc.org/github.com/golang/gddo?status.svg)](https://godoc.org/github.com/hunterlong/statping)

# statping
--
    import "github.com/hunterlong/statping"

Package statping is a server monitoring application that includs a status page
server. Visit the Statping repo at https://github.com/hunterlong/statping to get
a full understanding of what this application can do.


### Install Statping

Statping is available for Mac, Linux and Windows 64x. You can download the
tar.gz file or use a couple other methods. Download the latest release at
https://github.com/hunterlong/statping/releases/latest or view below. If you're
on windows, download the zip file from the latest releases link.

    // MacOS using homebrew
    brew tap hunterlong/statping
    brew install statping

    // Linux installation
    bash <(curl -s https://assets.statping.com/install.sh)
    statping version


### Docker

Statping can be built in many way, the best way is to use Docker!

    docker run -it -p 8080:8080 hunterlong/statping

Enjoy Statping and tell me any issues you might be having on Github.
https://github.com/hunterlong

## Usage
# cmd
--
Package main for building the Statping CLI binary application. This package
connects to all the other packages to make a runnable binary for multiple
operating system.


### Compile Assets

Before building, you must compile the Statping Assets with Rice, to install rice
run the command below:

    go get github.com/GeertJohan/go.rice
    go get github.com/GeertJohan/go.rice/rice

Once you have rice install, you can run the following command to build all
assets inside the source directory.

    cd source && rice embed-go


### Build Statping Binary

To build the statup binary for your local environment, run the command below:

    go build -o statup ./cmd


Build All Binary Arch's

To build Statping for Mac, Windows, Linux, and ARM devices, you can run xgo to
build for all. xgo is an awesome golang package that requires Docker.
https://github.com/karalabe/xgo

    docker pull karalabe/xgo-latest
    build-all

More info on: https://github.com/hunterlong/statping
# core
--
    import "github.com/hunterlong/statping/core"

Package core contains the main functionality of Statping. This includes
everything for Services, Hits, Failures, Users, service checking mechanisms,
databases, and notifiers in the notifier package

More info on: https://github.com/hunterlong/statping

## Usage

```go
var (
	Configs   *DbConfig // Configs holds all of the config.yml and database info
	CoreApp   *Core     // CoreApp is a global variable that contains many elements
	SetupMode bool      // SetupMode will be true if Statping does not have a database connection
	VERSION   string    // VERSION is set on build automatically by setting a -ldflag
)
```

```go
var (
	// DbSession stores the Statping database session
	DbSession *gorm.DB
	DbModels  []interface{}
)
```

#### func  CheckHash

```go
func CheckHash(password, hash string) bool
```
CheckHash returns true if the password matches with a hashed bcrypt password

#### func  CloseDB

```go
func CloseDB()
```
CloseDB will close the database connection if available

#### func  CountFailures

```go
func CountFailures() uint64
```
CountFailures returns the total count of failures for all services

#### func  CountUsers

```go
func CountUsers() int64
```
CountUsers returns the amount of users

#### func  DatabaseMaintence

```go
func DatabaseMaintence()
```
DatabaseMaintence will automatically delete old records from 'failures' and
'hits' this function is currently set to delete records 7+ days old every 60
minutes

#### func  Dbtimestamp

```go
func Dbtimestamp(group string, column string) string
```
Dbtimestamp will return a SQL query for grouping by date

#### func  DefaultPort

```go
func DefaultPort(db string) int64
```
DefaultPort accepts a database type and returns its default port

#### func  DeleteAllSince

```go
func DeleteAllSince(table string, date time.Time)
```
DeleteAllSince will delete a specific table's records based on a time.

#### func  DeleteConfig

```go
func DeleteConfig() error
```
DeleteConfig will delete the 'config.yml' file

#### func  ExportChartsJs

```go
func ExportChartsJs() string
```
ExportChartsJs renders the charts for the index page

#### func  ExportSettings

```go
func ExportSettings() ([]byte, error)
```
ExportSettings will export a JSON file containing all of the settings below: -
Core - Notifiers - Checkins - Users - Services - Groups - Messages

#### func  GetLocalIP

```go
func GetLocalIP() string
```
GetLocalIP returns the non loopback local IP of the host

#### func  InitApp

```go
func InitApp()
```
InitApp will initialize Statping

#### func  InsertLargeSampleData

```go
func InsertLargeSampleData() error
```
InsertLargeSampleData will create the example/dummy services for testing the
Statping server

#### func  InsertNotifierDB

```go
func InsertNotifierDB() error
```
InsertNotifierDB inject the Statping database instance to the Notifier package

#### func  InsertSampleData

```go
func InsertSampleData() error
```
InsertSampleData will create the example/dummy services for a brand new Statping
installation

#### func  InsertSampleHits

```go
func InsertSampleHits() error
```
InsertSampleHits will create a couple new hits for the sample services

#### func  SampleData

```go
func SampleData() error
```
SampleData runs all the sample data for a new Statping installation

#### func  Services

```go
func Services() []types.ServiceInterface
```

#### type Checkin

```go
type Checkin struct {
	*types.Checkin
}
```


#### func  AllCheckins

```go
func AllCheckins() []*Checkin
```
AllCheckins returns all checkin in system

#### func  ReturnCheckin

```go
func ReturnCheckin(c *types.Checkin) *Checkin
```
ReturnCheckin converts *types.Checking to *core.Checkin

#### func  SelectCheckin

```go
func SelectCheckin(api string) *Checkin
```
SelectCheckin will find a Checkin based on the API supplied

#### func (*Checkin) AfterFind

```go
func (c *Checkin) AfterFind() (err error)
```
AfterFind for Checkin will set the timezone

#### func (*Checkin) AllFailures

```go
func (c *Checkin) AllFailures() []*types.Failure
```
Hits returns all of the CheckinHits for a given Checkin

#### func (*Checkin) AllHits

```go
func (c *Checkin) AllHits() []*types.CheckinHit
```
AllHits returns all of the CheckinHits for a given Checkin

#### func (*Checkin) Create

```go
func (c *Checkin) Create() (int64, error)
```
Create will create a new Checkin

#### func (*Checkin) CreateFailure

```go
func (c *Checkin) CreateFailure() (int64, error)
```

#### func (*Checkin) Delete

```go
func (c *Checkin) Delete() error
```
Create will create a new Checkin

#### func (*Checkin) Expected

```go
func (c *Checkin) Expected() time.Duration
```
Expected returns the duration of when the serviec should receive a Checkin

#### func (*Checkin) Grace

```go
func (c *Checkin) Grace() time.Duration
```
Grace will return the duration of the Checkin Grace Period (after service hasn't
responded, wait a bit for a response)

#### func (*Checkin) Last

```go
func (c *Checkin) Last() *CheckinHit
```
Last returns the last checkinHit for a Checkin

#### func (*Checkin) LimitedFailures

```go
func (c *Checkin) LimitedFailures(amount int64) []types.FailureInterface
```
Hits returns all of the CheckinHits for a given Checkin

#### func (*Checkin) LimitedHits

```go
func (c *Checkin) LimitedHits(amount int64) []*types.CheckinHit
```
LimitedHits will return the last amount of successful hits from a checkin

#### func (*Checkin) Link

```go
func (c *Checkin) Link() string
```

#### func (*Checkin) Period

```go
func (c *Checkin) Period() time.Duration
```
Period will return the duration of the Checkin interval

#### func (*Checkin) RecheckCheckinFailure

```go
func (c *Checkin) RecheckCheckinFailure(guard chan struct{})
```
RecheckCheckinFailure will check if a Service Checkin has been reported yet

#### func (*Checkin) Routine

```go
func (c *Checkin) Routine()
```
Routine for checking if the last Checkin was within its interval

#### func (*Checkin) Select

```go
func (c *Checkin) Select() *types.Checkin
```
Select returns a *types.Checkin

#### func (*Checkin) Service

```go
func (c *Checkin) Service() *Service
```

#### func (*Checkin) String

```go
func (c *Checkin) String() string
```
String will return a Checkin API string

#### func (*Checkin) Update

```go
func (c *Checkin) Update() (int64, error)
```
Update will update a Checkin

#### type CheckinHit

```go
type CheckinHit struct {
	*types.CheckinHit
}
```


#### func  ReturnCheckinHit

```go
func ReturnCheckinHit(c *types.CheckinHit) *CheckinHit
```
ReturnCheckinHit converts *types.checkinHit to *core.checkinHit

#### func (*CheckinHit) AfterFind

```go
func (c *CheckinHit) AfterFind() (err error)
```
AfterFind for checkinHit will set the timezone

#### func (*CheckinHit) Ago

```go
func (c *CheckinHit) Ago() string
```
Ago returns the duration of time between now and the last successful checkinHit

#### func (*CheckinHit) Create

```go
func (c *CheckinHit) Create() (int64, error)
```
Create will create a new successful checkinHit

#### type Core

```go
type Core struct {
	*types.Core
}
```


#### func  NewCore

```go
func NewCore() *Core
```
NewCore return a new *core.Core struct

#### func  SelectCore

```go
func SelectCore() (*Core, error)
```
SelectCore will return the CoreApp global variable and the settings/configs for
Statping

#### func  UpdateCore

```go
func UpdateCore(c *Core) (*Core, error)
```
UpdateCore will update the CoreApp variable inside of the 'core' table in
database

#### func (*Core) AfterFind

```go
func (c *Core) AfterFind() (err error)
```
AfterFind for Core will set the timezone

#### func (Core) AllOnline

```go
func (c Core) AllOnline() bool
```
AllOnline will be true if all services are online

#### func (Core) BaseSASS

```go
func (c Core) BaseSASS() string
```
BaseSASS is the base design , this opens the file /assets/scss/base.scss to be
edited in Theme

#### func (*Core) Count24HFailures

```go
func (c *Core) Count24HFailures() uint64
```
Count24HFailures returns the amount of failures for a service within the last 24
hours

#### func (*Core) CountOnline

```go
func (c *Core) CountOnline() int
```
CountOnline returns the amount of services online

#### func (Core) CurrentTime

```go
func (c Core) CurrentTime() string
```
CurrentTime will return the current local time

#### func (Core) Messages

```go
func (c Core) Messages() []*Message
```
Messages will return the current local time

#### func (Core) MobileSASS

```go
func (c Core) MobileSASS() string
```
MobileSASS is the -webkit responsive custom css designs. This opens the file
/assets/scss/mobile.scss to be edited in Theme

#### func (Core) SassVars

```go
func (c Core) SassVars() string
```
SassVars opens the file /assets/scss/variables.scss to be edited in Theme

#### func (*Core) SelectAllServices

```go
func (c *Core) SelectAllServices(start bool) ([]*Service, error)
```
SelectAllServices returns a slice of *core.Service to be store on
[]*core.Services, should only be called once on startup.

#### func (*Core) ToCore

```go
func (c *Core) ToCore() *types.Core
```
ToCore will convert *core.Core to *types.Core

#### func (Core) UsingAssets

```go
func (c Core) UsingAssets() bool
```
UsingAssets will return true if /assets folder is present

#### type DateScan

```go
type DateScan struct {
	CreatedAt string `json:"x,omitempty"`
	Value     int64  `json:"y"`
}
```

DateScan struct is for creating the charts.js graph JSON array

#### type DateScanObj

```go
type DateScanObj struct {
	Array []DateScan `json:"data"`
}
```

DateScanObj struct is for creating the charts.js graph JSON array

#### func  GraphDataRaw

```go
func GraphDataRaw(service types.ServiceInterface, start, end time.Time, group string, column string) *DateScanObj
```
GraphDataRaw will return all the hits between 2 times for a Service

#### func (*DateScanObj) ToString

```go
func (d *DateScanObj) ToString() string
```
ToString will convert the DateScanObj into a JSON string for the charts to
render

#### type DbConfig

```go
type DbConfig types.DbConfig
```

DbConfig stores the config.yml file for the statup configuration

#### func  EnvToConfig

```go
func EnvToConfig() *DbConfig
```
EnvToConfig converts environment variables to a DbConfig variable

#### func  LoadConfigFile

```go
func LoadConfigFile(directory string) (*DbConfig, error)
```
LoadConfigFile will attempt to load the 'config.yml' file in a specific
directory

#### func  LoadUsingEnv

```go
func LoadUsingEnv() (*DbConfig, error)
```
LoadUsingEnv will attempt to load database configs based on environment
variables. If DB_CONN is set if will force this function.

#### func (*DbConfig) Connect

```go
func (db *DbConfig) Connect(retry bool, location string) error
```
Connect will attempt to connect to the sqlite, postgres, or mysql database

#### func (*DbConfig) CreateCore

```go
func (c *DbConfig) CreateCore() *Core
```
CreateCore will initialize the global variable 'CoreApp". This global variable
contains most of Statping app.

#### func (*DbConfig) CreateDatabase

```go
func (db *DbConfig) CreateDatabase() error
```
CreateDatabase will CREATE TABLES for each of the Statping elements

#### func (*DbConfig) DropDatabase

```go
func (db *DbConfig) DropDatabase() error
```
DropDatabase will DROP each table Statping created

#### func (*DbConfig) InsertCore

```go
func (db *DbConfig) InsertCore() (*Core, error)
```
InsertCore create the single row for the Core settings in Statping

#### func (*DbConfig) MigrateDatabase

```go
func (db *DbConfig) MigrateDatabase() error
```
MigrateDatabase will migrate the database structure to current version. This
function will NOT remove previous records, tables or columns from the database.
If this function has an issue, it will ROLLBACK to the previous state.

#### func (*DbConfig) Save

```go
func (db *DbConfig) Save() (*DbConfig, error)
```
Save will initially create the config.yml file

#### func (*DbConfig) Update

```go
func (db *DbConfig) Update() error
```
Update will save the config.yml file

#### type ErrorResponse

```go
type ErrorResponse struct {
	Error string
}
```

ErrorResponse is used for HTTP errors to show to User

#### type ExportData

```go
type ExportData struct {
	Core      *types.Core              `json:"core"`
	Services  []types.ServiceInterface `json:"services"`
	Messages  []*Message               `json:"messages"`
	Checkins  []*Checkin               `json:"checkins"`
	Users     []*User                  `json:"users"`
	Groups    []*Group                 `json:"groups"`
	Notifiers []types.AllNotifiers     `json:"notifiers"`
}
```


#### type Failure

```go
type Failure struct {
	*types.Failure
}
```


#### func (*Failure) AfterFind

```go
func (f *Failure) AfterFind() (err error)
```
AfterFind for Failure will set the timezone

#### func (*Failure) Ago

```go
func (f *Failure) Ago() string
```
Ago returns a human readable timestamp for a Failure

#### func (*Failure) Delete

```go
func (f *Failure) Delete() error
```
Delete will remove a Failure record from the database

#### func (*Failure) ParseError

```go
func (f *Failure) ParseError() string
```
ParseError returns a human readable error for a Failure

#### func (*Failure) Select

```go
func (f *Failure) Select() *types.Failure
```
Select returns a *types.Failure

#### type Group

```go
type Group struct {
	*types.Group
}
```


#### func  SelectGroup

```go
func SelectGroup(id int64) *Group
```
SelectGroup returns a *core.Group

#### func  SelectGroups

```go
func SelectGroups(includeAll bool, auth bool) []*Group
```
SelectGroups returns all groups

#### func (*Group) Create

```go
func (g *Group) Create() (int64, error)
```
Create will create a group and insert it into the database

#### func (*Group) Delete

```go
func (g *Group) Delete() error
```
Delete will remove a group

#### func (*Group) Services

```go
func (g *Group) Services() []*Service
```
Services returns all services belonging to a group

#### type Hit

```go
type Hit struct {
	*types.Hit
}
```


#### func (*Hit) AfterFind

```go
func (h *Hit) AfterFind() (err error)
```
AfterFind for Hit will set the timezone

#### type Message

```go
type Message struct {
	*types.Message
}
```


#### func  ReturnMessage

```go
func ReturnMessage(m *types.Message) *Message
```
ReturnMessage will convert *types.Message to *core.Message

#### func  SelectMessage

```go
func SelectMessage(id int64) (*Message, error)
```
SelectMessage returns a Message based on the ID passed

#### func  SelectMessages

```go
func SelectMessages() ([]*Message, error)
```
SelectMessages returns all messages

#### func  SelectServiceMessages

```go
func SelectServiceMessages(id int64) []*Message
```
SelectServiceMessages returns all messages for a service

#### func (*Message) AfterFind

```go
func (u *Message) AfterFind() (err error)
```
AfterFind for Message will set the timezone

#### func (*Message) Create

```go
func (m *Message) Create() (int64, error)
```
Create will create a Message and insert it into the database

#### func (*Message) Delete

```go
func (m *Message) Delete() error
```
Delete will delete a Message from database

#### func (*Message) Service

```go
func (m *Message) Service() *Service
```

#### func (*Message) Update

```go
func (m *Message) Update() (*Message, error)
```
Update will update a Message in the database

#### type PluginJSON

```go
type PluginJSON types.PluginJSON
```


#### type PluginRepos

```go
type PluginRepos types.PluginRepos
```


#### type Service

```go
type Service struct {
	*types.Service
}
```


#### func  ReturnService

```go
func ReturnService(s *types.Service) *Service
```
ReturnService will convert *types.Service to *core.Service

#### func  SelectService

```go
func SelectService(id int64) *Service
```
SelectService returns a *core.Service from in memory

#### func  SelectServiceLink

```go
func SelectServiceLink(permalink string) *Service
```
SelectServiceLink returns a *core.Service from the service permalink

#### func (*Service) ActiveMessages

```go
func (s *Service) ActiveMessages() []*Message
```
ActiveMessages returns all service messages that are available based on the
current time

#### func (*Service) AfterFind

```go
func (s *Service) AfterFind() (err error)
```
AfterFind for Service will set the timezone

#### func (*Service) AllCheckins

```go
func (s *Service) AllCheckins() []*Checkin
```
AllCheckins will return a slice of AllCheckins for a Service

#### func (*Service) AllFailures

```go
func (s *Service) AllFailures() []*Failure
```
AllFailures will return all failures attached to a service

#### func (*Service) AvgTime

```go
func (s *Service) AvgTime() string
```
AvgTime will return the average amount of time for a service to response back
successfully

#### func (*Service) AvgUptime

```go
func (s *Service) AvgUptime(ago time.Time) string
```
AvgUptime returns average online status for last 24 hours

#### func (*Service) AvgUptime24

```go
func (s *Service) AvgUptime24() string
```
AvgUptime24 returns a service's average online status for last 24 hours

#### func (*Service) Check

```go
func (s *Service) Check(record bool)
```
Check will run checkHttp for HTTP services and checkTcp for TCP services

#### func (*Service) CheckQueue

```go
func (s *Service) CheckQueue(record bool)
```
CheckQueue is the main go routine for checking a service

#### func (*Service) CheckinProcess

```go
func (s *Service) CheckinProcess()
```
CheckinProcess runs the checkin routine for each checkin attached to service

#### func (*Service) CountHits

```go
func (s *Service) CountHits() (int64, error)
```
CountHits returns a int64 for all hits for a service

#### func (*Service) Create

```go
func (s *Service) Create(check bool) (int64, error)
```
Create will create a service and insert it into the database

#### func (*Service) CreateFailure

```go
func (s *Service) CreateFailure(fail types.FailureInterface) (int64, error)
```
CreateFailure will create a new Failure record for a service

#### func (*Service) CreateHit

```go
func (s *Service) CreateHit(h *types.Hit) (int64, error)
```
CreateHit will create a new 'hit' record in the database for a successful/online
service

#### func (*Service) Delete

```go
func (s *Service) Delete() error
```
Delete will remove a service from the database, it will also end the service
checking go routine

#### func (*Service) DeleteFailures

```go
func (s *Service) DeleteFailures()
```
DeleteFailures will delete all failures for a service

#### func (*Service) Downtime

```go
func (s *Service) Downtime() time.Duration
```
Downtime returns the amount of time of a offline service

#### func (*Service) DowntimeText

```go
func (s *Service) DowntimeText() string
```
DowntimeText will return the amount of downtime for a service based on the
duration

    service.DowntimeText()
    // Service has been offline for 15 minutes

#### func (*Service) FailuresDaysAgo

```go
func (s *Service) FailuresDaysAgo(days int) uint64
```
FailuresDaysAgo returns the amount of failures since days ago

#### func (*Service) Hits

```go
func (s *Service) Hits() ([]*types.Hit, error)
```
Hits returns all successful hits for a service

#### func (*Service) HitsBetween

```go
func (s *Service) HitsBetween(t1, t2 time.Time, group string, column string) *gorm.DB
```
HitsBetween returns the gorm database query for a collection of service hits
between a time range

#### func (*Service) LimitedCheckinFailures

```go
func (s *Service) LimitedCheckinFailures(amount int64) []*Failure
```
LimitedFailures will return the last amount of failures from a service

#### func (*Service) LimitedFailures

```go
func (s *Service) LimitedFailures(amount int64) []*Failure
```
LimitedFailures will return the last amount of failures from a service

#### func (*Service) LimitedHits

```go
func (s *Service) LimitedHits(amount int64) ([]*types.Hit, error)
```
LimitedHits returns the last 1024 successful/online 'hit' records for a service

#### func (*Service) Messages

```go
func (s *Service) Messages() []*Message
```
Messages returns all Messages for a Service

#### func (*Service) OnlineDaysPercent

```go
func (s *Service) OnlineDaysPercent(days int) float32
```
OnlineDaysPercent returns the service's uptime percent within last 24 hours

#### func (*Service) OnlineSince

```go
func (s *Service) OnlineSince(ago time.Time) float32
```
OnlineSince accepts a time since parameter to return the percent of a service's
uptime.

#### func (*Service) Select

```go
func (s *Service) Select() *types.Service
```
Select will return the *types.Service struct for Service

#### func (*Service) SmallText

```go
func (s *Service) SmallText() string
```
SmallText returns a short description about a services status

    service.SmallText()
    // Online since Monday 3:04:05PM, Jan _2 2006

#### func (*Service) SparklineDayFailures

```go
func (s *Service) SparklineDayFailures(days int) string
```
SparklineDayFailures returns a string array of daily service failures

#### func (*Service) SparklineHourResponse

```go
func (s *Service) SparklineHourResponse(hours int, method string) string
```
SparklineHourResponse returns a string array for the average response or ping
time for a service

#### func (*Service) Sum

```go
func (s *Service) Sum() float64
```
Sum returns the added value Latency for all of the services successful hits.

#### func (*Service) ToJSON

```go
func (s *Service) ToJSON() string
```
ToJSON will convert a service to a JSON string

#### func (*Service) TotalFailures

```go
func (s *Service) TotalFailures() (uint64, error)
```
TotalFailures returns the total amount of failures for a service

#### func (*Service) TotalFailures24

```go
func (s *Service) TotalFailures24() (uint64, error)
```
TotalFailures24 returns the amount of failures for a service within the last 24
hours

#### func (*Service) TotalFailuresOnDate

```go
func (s *Service) TotalFailuresOnDate(ago time.Time) (uint64, error)
```
TotalFailuresOnDate returns the total amount of failures for a service on a
specific time/date

#### func (*Service) TotalFailuresSince

```go
func (s *Service) TotalFailuresSince(ago time.Time) (uint64, error)
```
TotalFailuresSince returns the total amount of failures for a service since a
specific time/date

#### func (*Service) TotalHits

```go
func (s *Service) TotalHits() (uint64, error)
```
TotalHits returns the total amount of successful hits a service has

#### func (*Service) TotalHitsSince

```go
func (s *Service) TotalHitsSince(ago time.Time) (uint64, error)
```
TotalHitsSince returns the total amount of hits based on a specific time/date

#### func (*Service) TotalUptime

```go
func (s *Service) TotalUptime() string
```
TotalUptime returns the total uptime percent of a service

#### func (*Service) Update

```go
func (s *Service) Update(restart bool) error
```
Update will update a service in the database, the service's checking routine can
be restarted by passing true

#### type ServiceOrder

```go
type ServiceOrder []types.ServiceInterface
```

ServiceOrder will reorder the services based on 'order_id' (Order)

#### func (ServiceOrder) Len

```go
func (c ServiceOrder) Len() int
```
Sort interface for resroting the Services in order

#### func (ServiceOrder) Less

```go
func (c ServiceOrder) Less(i, j int) bool
```

#### func (ServiceOrder) Swap

```go
func (c ServiceOrder) Swap(i, j int)
```

#### type User

```go
type User struct {
	*types.User
}
```


#### func  AuthUser

```go
func AuthUser(username, password string) (*User, bool)
```
AuthUser will return the User and a boolean if authentication was correct.
AuthUser accepts username, and password as a string

#### func  ReturnUser

```go
func ReturnUser(u *types.User) *User
```
ReturnUser returns *core.User based off a *types.User

#### func  SelectAllUsers

```go
func SelectAllUsers() ([]*User, error)
```
SelectAllUsers returns all users

#### func  SelectUser

```go
func SelectUser(id int64) (*User, error)
```
SelectUser returns the User based on the User's ID.

#### func  SelectUsername

```go
func SelectUsername(username string) (*User, error)
```
SelectUsername returns the User based on the User's username

#### func (*User) AfterFind

```go
func (u *User) AfterFind() (err error)
```
AfterFind for USer will set the timezone

#### func (*User) Create

```go
func (u *User) Create() (int64, error)
```
Create will insert a new User into the database

#### func (*User) Delete

```go
func (u *User) Delete() error
```
Delete will remove the User record from the database

#### func (*User) Update

```go
func (u *User) Update() error
```
Update will update the User's record in database
# handlers
--
    import "github.com/hunterlong/statping/handlers"

Package handlers contains the HTTP server along with the requests and routes.
All HTTP related functions are in this package.

More info on: https://github.com/hunterlong/statping

## Usage

#### func  ExecuteResponse

```go
func ExecuteResponse(w http.ResponseWriter, r *http.Request, file string, data interface{}, redirect interface{})
```
ExecuteResponse will render a HTTP response for the front end user

#### func  IsAdmin

```go
func IsAdmin(r *http.Request) bool
```
IsAdmin returns true if the user session is an administrator

#### func  IsFullAuthenticated

```go
func IsFullAuthenticated(r *http.Request) bool
```
IsFullAuthenticated returns true if the HTTP request is authenticated. You can
set the environment variable GO_ENV=test to bypass the admin authenticate to the
dashboard features.

#### func  IsReadAuthenticated

```go
func IsReadAuthenticated(r *http.Request) bool
```
IsReadAuthenticated will allow Read Only authentication for some routes

#### func  IsUser

```go
func IsUser(r *http.Request) bool
```
IsUser returns true if the user is registered

#### func  Router

```go
func Router() *mux.Router
```
Router returns all of the routes used in Statping. Server will use static assets
if the 'assets' directory is found in the root directory.

#### func  RunHTTPServer

```go
func RunHTTPServer(ip string, port int) error
```
RunHTTPServer will start a HTTP server on a specific IP and port

#### type Cacher

```go
type Cacher interface {
	Get(key string) []byte
	Delete(key string)
	Set(key string, content []byte, duration time.Duration)
	List() map[string]Item
}
```


```go
var CacheStorage Cacher
```

#### type Item

```go
type Item struct {
	Content    []byte
	Expiration int64
}
```

Item is a cached reference

#### func (Item) Expired

```go
func (item Item) Expired() bool
```
Expired returns true if the item has expired.

#### type PluginSelect

```go
type PluginSelect struct {
	Plugin string
	Form   string
	Params map[string]interface{}
}
```


#### type Storage

```go
type Storage struct {
}
```

Storage mecanism for caching strings in memory

#### func  NewStorage

```go
func NewStorage() *Storage
```
NewStorage creates a new in memory CacheStorage

#### func (Storage) Delete

```go
func (s Storage) Delete(key string)
```

#### func (Storage) Get

```go
func (s Storage) Get(key string) []byte
```
Get a cached content by key

#### func (Storage) List

```go
func (s Storage) List() map[string]Item
```

#### func (Storage) Set

```go
func (s Storage) Set(key string, content []byte, duration time.Duration)
```
Set a cached content by key
# notifiers
--
    import "github.com/hunterlong/statping/notifiers"

Package notifiers holds all the notifiers for Statping, which also includes user
created notifiers that have been accepted in a Push Request. Read the wiki to
see a full example of a notifier with all events, visit Statping's notifier
example code: https://github.com/hunterlong/statping/wiki/Notifier-Example

This package shouldn't contain any exports, to see how notifiers work visit the
core/notifier package at:
https://godoc.org/github.com/hunterlong/statping/core/notifier and learn how to
create your own custom notifier.

## Usage

#### type MobileResponse

```go
type MobileResponse struct {
	Counts  int                   `json:"counts"`
	Logs    []*MobileResponseLogs `json:"logs"`
	Success string                `json:"success"`
}
```


#### type MobileResponseLogs

```go
type MobileResponseLogs struct {
	Type     string `json:"type"`
	Platform string `json:"platform"`
	Token    string `json:"token"`
	Message  string `json:"message"`
	Error    string `json:"error"`
}
```


#### type PushArray

```go
type PushArray struct {
	Tokens   []string               `json:"tokens"`
	Platform int64                  `json:"platform"`
	Message  string                 `json:"message"`
	Topic    string                 `json:"topic"`
	Title    string                 `json:"title,omitempty"`
	Data     map[string]interface{} `json:"data,omitempty"`
}
```


#### type PushNotification

```go
type PushNotification struct {
	Array []*PushArray `json:"notifications"`
}
```
# plugin
--
    import "github.com/hunterlong/statping/plugin"

Package plugin contains the interfaces to build your own Golang Plugin that will
receive triggers on Statping events.

## Usage

```go
var (
	AllPlugins []*types.PluginObject
)
```

#### func  LoadPlugin

```go
func LoadPlugin(file string) error
```

#### func  LoadPlugins

```go
func LoadPlugins()
```
# source
--
    import "github.com/hunterlong/statping/source"

Package source holds all the assets for Statping. This includes CSS, JS, SCSS,
HTML and other website related content. This package uses Rice to compile all
assets into a single 'rice-box.go' file.


### Required Dependencies

- rice -> https://github.com/GeertJohan/go.rice - sass ->
https://sass-lang.com/install


### Compile Assets

To compile all the HTML, JS, SCSS, CSS and image assets you'll need to have rice
and sass installed on your local system.

    sass source/scss/base.scss source/css/base.css
    cd source && rice embed-go

More info on: https://github.com/hunterlong/statping

Code generated by go generate; DO NOT EDIT. This file was generated by robots at
2019-02-06 12:42:08.202468 -0800 PST m=+0.598756678

This contains the most recently Markdown source for the Statping Wiki.

## Usage

```go
var (
	CssBox  *rice.Box // CSS files from the 'source/css' directory, this will be loaded into '/assets/css'
	ScssBox *rice.Box // SCSS files from the 'source/scss' directory, this will be loaded into '/assets/scss'
	JsBox   *rice.Box // JS files from the 'source/js' directory, this will be loaded into '/assets/js'
	TmplBox *rice.Box // HTML and other small files from the 'source/tmpl' directory, this will be loaded into '/assets'
	FontBox *rice.Box // HTML and other small files from the 'source/tmpl' directory, this will be loaded into '/assets'
)
```

```go
var CompiledWiki = []byte("<a class=\"scrollclick\" href=\"#\" data-id=\"page_0\">Types of Monitoring</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_1\">Features</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_2\">Start Statping</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_3\">Linux</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_4\">Mac</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_5\">Windows</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_6\">AWS EC2</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_7\">Docker</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_8\">Mobile App</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_9\">Heroku</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_10\">API</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_11\">Makefile</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_12\">Notifiers</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_13\">Notifier Events</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_14\">Notifier Example</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_15\">Prometheus Exporter</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_16\">SSL</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_17\">Config with .env File</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_18\">Static Export</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_19\">Statping Plugins</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_20\">Statuper</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_21\">Build and Test</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_22\">Contributing</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_23\">PGP Signature</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_24\">Testing</a><br><a class=\"scrollclick\" href=\"#\" data-id=\"page_25\">Deployment</a><br>\n\n<div class=\"mt-5\" id=\"page_0\"><h1>Types of Monitoring</h1></div>\nYou can monitor your application by using a simple HTTP GET to the endpoint to return back a response and status code. Normally you want a 200 status code on an HTTP request. You might want to require a 404 or 500 error as a response code though. With each service you can include a Timeout in seconds to work with your long running services.\n\n# HTTP Endpoints with Custom POST\nFor more advanced monitoring you can add a data as a HTTP POST request. This is useful for automatically submitting JSON, or making sure your signup form is working correctly.\n\n<p align=\"center\">\n<img width=\"100%\" src=\"https://img.cjx.io/statup-httpservice.png\">\n</p>\n\nWith a HTTP service, you can POST a JSON string to your endpoint to retrieve any type of response back. You can then use Regex in the Expected Response field to parse a custom response that exactly matches your status requirements. \n\n# TCP Services\nFor other services that don't use HTTP, you can monitor any type of service by using the PORT of the service. If you're Ethereum Blockchain server is running on 8545, you can use TCP to monitor your server. With a TCP service, you can monitor your Docker containers, or remove service running on a custom port. You don't need to include `http` in the endpoint field, just IP or Hostname.\n\n<p align=\"center\">\n<img width=\"100%\" src=\"https://img.cjx.io/statup-tcpservice.png\">\n</p>\n\n\n<div class=\"mt-5\" id=\"page_1\"><h1>Features</h1></div>\nStatping is a great Status Page that can be deployed with 0 effort.\n\n# 3 Different Databases\nYou can use MySQL, Postgres, or SQLite as a database for your Statping status page. The server will automatically upgrade your database tables depending on which database you have.\n\n# Easy to Startup\nStatping is an extremely easy to setup website monitoring tool without fussing with dependencies or packages. Simply download and install the precompile binary for your operating system. Statping works on Windows, Mac, Linux, Docker, and even the Raspberry Pi.\n\n# Plugins\nStatping is an awesome Stat
```
CompiledWiki contains all of the Statping Wiki pages from the Github Wiki repo.

#### func  Assets

```go
func Assets()
```
Assets will load the Rice boxes containing the CSS, SCSS, JS, and HTML files.

#### func  CompileSASS

```go
func CompileSASS(folder string) error
```
CompileSASS will attempt to compile the SASS files into CSS

#### func  CopyAllToPublic

```go
func CopyAllToPublic(box *rice.Box, folder string) error
```
CopyAllToPublic will copy all the files in a rice box into a local folder

#### func  CopyToPublic

```go
func CopyToPublic(box *rice.Box, folder, file string) error
```
CopyToPublic will create a file from a rice Box to the '/assets' directory

#### func  CreateAllAssets

```go
func CreateAllAssets(folder string) error
```
CreateAllAssets will dump HTML, CSS, SCSS, and JS assets into the '/assets'
directory

#### func  DeleteAllAssets

```go
func DeleteAllAssets(folder string) error
```
DeleteAllAssets will delete the '/assets' folder

#### func  HelpMarkdown

```go
func HelpMarkdown() string
```
HelpMarkdown will return the Markdown of help.md into HTML

#### func  MakePublicFolder

```go
func MakePublicFolder(folder string) error
```
MakePublicFolder will create a new folder

#### func  OpenAsset

```go
func OpenAsset(folder, file string) string
```
OpenAsset returns a file's contents as a string

#### func  SaveAsset

```go
func SaveAsset(data []byte, folder, file string) error
```
SaveAsset will save an asset to the '/assets/' folder.

#### func  UsingAssets

```go
func UsingAssets(folder string) bool
```
UsingAssets returns true if the '/assets' folder is found in the directory
# types
--
    import "github.com/hunterlong/statping/types"

Package types contains all of the structs for objects in Statping including
services, hits, failures, Core, and others.

More info on: https://github.com/hunterlong/statping

## Usage

```go
const (
	TIME_NANO     = "2006-01-02T15:04:05Z"
	TIME          = "2006-01-02 15:04:05"
	POSTGRES_TIME = "2006-01-02 15:04"
	CHART_TIME    = "2006-01-02T15:04:05.999999-07:00"
	TIME_DAY      = "2006-01-02"
)
```

```go
var (
	NOW = func() time.Time { return time.Now() }()
)
```

#### type AllNotifiers

```go
type AllNotifiers interface{}
```

AllNotifiers contains all the Notifiers loaded

#### type Asseter

```go
type Asseter interface {
	Asset(string) ([]byte, error)
}
```


#### type Checkin

```go
type Checkin struct {
	Id          int64              `gorm:"primary_key;column:id" json:"id"`
	ServiceId   int64              `gorm:"index;column:service" json:"service_id"`
	Name        string             `gorm:"column:name" json:"name"`
	Interval    int64              `gorm:"column:check_interval" json:"interval"`
	GracePeriod int64              `gorm:"column:grace_period"  json:"grace"`
	ApiKey      string             `gorm:"column:api_key"  json:"api_key"`
	CreatedAt   time.Time          `gorm:"column:created_at" json:"created_at"`
	UpdatedAt   time.Time          `gorm:"column:updated_at" json:"updated_at"`
	Running     chan bool          `gorm:"-" json:"-"`
	Failing     bool               `gorm:"-" json:"failing"`
	LastHit     time.Time          `gorm:"-" json:"last_hit"`
	Hits        []*CheckinHit      `gorm:"-" json:"hits"`
	Failures    []FailureInterface `gorm:"-" json:"failures"`
}
```

Checkin struct will allow an application to send a recurring HTTP GET to confirm
a service is online

#### func (*Checkin) BeforeCreate

```go
func (c *Checkin) BeforeCreate() (err error)
```
BeforeCreate for Checkin will set CreatedAt to UTC

#### func (*Checkin) Close

```go
func (s *Checkin) Close()
```
Close will stop the checkin routine

#### func (*Checkin) IsRunning

```go
func (s *Checkin) IsRunning() bool
```
IsRunning returns true if the checkin go routine is running

#### func (*Checkin) Start

```go
func (s *Checkin) Start()
```
Start will create a channel for the checkin checking go routine

#### type CheckinHit

```go
type CheckinHit struct {
	Id        int64     `gorm:"primary_key;column:id" json:"id"`
	Checkin   int64     `gorm:"index;column:checkin" json:"-"`
	From      string    `gorm:"column:from_location" json:"from"`
	CreatedAt time.Time `gorm:"column:created_at" json:"created_at"`
}
```

CheckinHit is a successful response from a Checkin

#### func (*CheckinHit) BeforeCreate

```go
func (c *CheckinHit) BeforeCreate() (err error)
```
BeforeCreate for checkinHit will set CreatedAt to UTC

#### type CheckinInterface

```go
type CheckinInterface interface {
	Select() *Checkin
}
```


#### type Core

```go
type Core struct {
	Name          string             `gorm:"not null;column:name" json:"name"`
	Description   string             `gorm:"not null;column:description" json:"description,omitempty"`
	Config        string             `gorm:"column:config" json:"-"`
	ApiKey        string             `gorm:"column:api_key" json:"-"`
	ApiSecret     string             `gorm:"column:api_secret" json:"-"`
	Style         string             `gorm:"not null;column:style" json:"style,omitempty"`
	Footer        NullString         `gorm:"column:footer" json:"footer"`
	Domain        string             `gorm:"not null;column:domain" json:"domain"`
	Version       string             `gorm:"column:version" json:"version"`
	MigrationId   int64              `gorm:"column:migration_id" json:"migration_id,omitempty"`
	UseCdn        NullBool           `gorm:"column:use_cdn;default:false" json:"using_cdn,omitempty"`
	Timezone      float32            `gorm:"column:timezone;default:-8.0" json:"timezone,omitempty"`
	CreatedAt     time.Time          `gorm:"column:created_at" json:"created_at"`
	UpdatedAt     time.Time          `gorm:"column:updated_at" json:"updated_at"`
	DbConnection  string             `gorm:"-" json:"database"`
	Started       time.Time          `gorm:"-" json:"started_on"`
	Services      []ServiceInterface `gorm:"-" json:"-"`
	Plugins       []*Info            `gorm:"-" json:"-"`
	Repos         []PluginJSON       `gorm:"-" json:"-"`
	AllPlugins    []PluginActions    `gorm:"-" json:"-"`
	Notifications []AllNotifiers     `gorm:"-" json:"-"`
}
```

Core struct contains all the required fields for Statping. All application
settings will be saved into 1 row in the 'core' table. You can use the
core.CoreApp global variable to interact with the attributes to the application,
such as services.

#### type Databaser

```go
type Databaser interface {
	StatpingDatabase(*gorm.DB)
}
```


#### type DbConfig

```go
type DbConfig struct {
	DbConn      string `yaml:"connection"`
	DbHost      string `yaml:"host"`
	DbUser      string `yaml:"user"`
	DbPass      string `yaml:"password"`
	DbData      string `yaml:"database"`
	DbPort      int64  `yaml:"port"`
	ApiKey      string `yaml:"api_key"`
	ApiSecret   string `yaml:"api_secret"`
	Project     string `yaml:"-"`
	Description string `yaml:"-"`
	Domain      string `yaml:"-"`
	Username    string `yaml:"-"`
	Password    string `yaml:"-"`
	Email       string `yaml:"-"`
	Error       error  `yaml:"-"`
	Location    string `yaml:"location"`
	LocalIP     string `yaml:"-"`
}
```

DbConfig struct is used for the database connection and creates the 'config.yml'
file

#### type FailSort

```go
type FailSort []FailureInterface
```


#### func (FailSort) Len

```go
func (s FailSort) Len() int
```

#### func (FailSort) Less

```go
func (s FailSort) Less(i, j int) bool
```

#### func (FailSort) Swap

```go
func (s FailSort) Swap(i, j int)
```

#### type Failure

```go
type Failure struct {
	Id        int64     `gorm:"primary_key;column:id" json:"id"`
	Issue     string    `gorm:"column:issue" json:"issue"`
	Method    string    `gorm:"column:method" json:"method,omitempty"`
	MethodId  int64     `gorm:"column:method_id" json:"method_id,omitempty"`
	ErrorCode int       `gorm:"column:error_code" json:"error_code"`
	Service   int64     `gorm:"index;column:service" json:"-"`
	Checkin   int64     `gorm:"index;column:checkin" json:"-"`
	PingTime  float64   `gorm:"column:ping_time"  json:"ping"`
	CreatedAt time.Time `gorm:"column:created_at" json:"created_at"`
}
```

Failure is a failed attempt to check a service. Any a service does not meet the
expected requirements, a new Failure will be inserted into database.

#### func (*Failure) BeforeCreate

```go
func (f *Failure) BeforeCreate() (err error)
```
BeforeCreate for Failure will set CreatedAt to UTC

#### type FailureInterface

```go
type FailureInterface interface {
	Select() *Failure
	Ago() string        // Ago returns a human readable timestamp
	ParseError() string // ParseError returns a human readable error for a service failure
}
```


#### type Group

```go
type Group struct {
	Id        int64     `gorm:"primary_key;column:id" json:"id"`
	Name      string    `gorm:"column:name" json:"name"`
	Public    NullBool  `gorm:"default:true;column:public" json:"public"`
	CreatedAt time.Time `gorm:"column:created_at" json:"created_at"`
	UpdatedAt time.Time `gorm:"column:updated_at" json:"updated_at"`
}
```

Group is the main struct for Groups

#### type Hit

```go
type Hit struct {
	Id        int64     `gorm:"primary_key;column:id" json:"id"`
	Service   int64     `gorm:"column:service" json:"-"`
	Latency   float64   `gorm:"column:latency" json:"latency"`
	PingTime  float64   `gorm:"column:ping_time" json:"ping_time"`
	CreatedAt time.Time `gorm:"column:created_at" json:"created_at"`
}
```

Hit struct is a 'successful' ping or web response entry for a service.

#### func (*Hit) BeforeCreate

```go
func (h *Hit) BeforeCreate() (err error)
```
BeforeCreate for Hit will set CreatedAt to UTC

#### type Info

```go
type Info struct {
	Name        string
	Description string
	Form        string
}
```


#### type Message

```go
type Message struct {
	Id                int64     `gorm:"primary_key;column:id" json:"id"`
	Title             string    `gorm:"column:title" json:"title"`
	Description       string    `gorm:"column:description" json:"description"`
	StartOn           time.Time `gorm:"column:start_on" json:"start_on"`
	EndOn             time.Time `gorm:"column:end_on" json:"end_on"`
	ServiceId         int64     `gorm:"index;column:service" json:"service"`
	NotifyUsers       NullBool  `gorm:"column:notify_users" json:"notify_users"`
	NotifyMethod      string    `gorm:"column:notify_method" json:"notify_method"`
	NotifyBefore      NullInt64 `gorm:"column:notify_before" json:"notify_before"`
	NotifyBeforeScale string    `gorm:"column:notify_before_scale" json:"notify_before_scale"`
	CreatedAt         time.Time `gorm:"column:created_at" json:"created_at" json:"created_at"`
	UpdatedAt         time.Time `gorm:"column:updated_at" json:"updated_at" json:"updated_at"`
}
```

Message is for creating Announcements, Alerts and other messages for the end
users

#### func (*Message) BeforeCreate

```go
func (u *Message) BeforeCreate() (err error)
```
BeforeCreate for Message will set CreatedAt to UTC

#### type NullBool

```go
type NullBool struct {
	sql.NullBool
}
```

NullBool is an alias for sql.NullBool data type

#### func  NewNullBool

```go
func NewNullBool(s bool) NullBool
```
NewNullBool returns a sql.NullBool for JSON parsing

#### func (*NullBool) MarshalJSON

```go
func (nb *NullBool) MarshalJSON() ([]byte, error)
```
MarshalJSON for NullBool

#### func (*NullBool) UnmarshalJSON

```go
func (nf *NullBool) UnmarshalJSON(b []byte) error
```
Unmarshaler for NullBool

#### type NullFloat64

```go
type NullFloat64 struct {
	sql.NullFloat64
}
```

NullFloat64 is an alias for sql.NullFloat64 data type

#### func  NewNullFloat64

```go
func NewNullFloat64(s float64) NullFloat64
```
NewNullFloat64 returns a sql.NullFloat64 for JSON parsing

#### func (*NullFloat64) MarshalJSON

```go
func (ni *NullFloat64) MarshalJSON() ([]byte, error)
```
MarshalJSON for NullFloat64

#### func (*NullFloat64) UnmarshalJSON

```go
func (nf *NullFloat64) UnmarshalJSON(b []byte) error
```
Unmarshaler for NullFloat64

#### type NullInt64

```go
type NullInt64 struct {
	sql.NullInt64
}
```

NullInt64 is an alias for sql.NullInt64 data type

#### func  NewNullInt64

```go
func NewNullInt64(s int64) NullInt64
```
NewNullInt64 returns a sql.NullInt64 for JSON parsing

#### func (*NullInt64) MarshalJSON

```go
func (ni *NullInt64) MarshalJSON() ([]byte, error)
```
MarshalJSON for NullInt64

#### func (*NullInt64) UnmarshalJSON

```go
func (nf *NullInt64) UnmarshalJSON(b []byte) error
```
Unmarshaler for NullInt64

#### type NullString

```go
type NullString struct {
	sql.NullString
}
```

NullString is an alias for sql.NullString data type

#### func  NewNullString

```go
func NewNullString(s string) NullString
```
NewNullString returns a sql.NullString for JSON parsing

#### func (*NullString) MarshalJSON

```go
func (ns *NullString) MarshalJSON() ([]byte, error)
```
MarshalJSON for NullString

#### func (*NullString) UnmarshalJSON

```go
func (nf *NullString) UnmarshalJSON(b []byte) error
```
Unmarshaler for NullString

#### type Plugin

```go
type Plugin struct {
	Name        string
	Description string
}
```


#### type PluginActions

```go
type PluginActions interface {
	GetInfo() *Info
	OnLoad() error
}
```


#### type PluginInfo

```go
type PluginInfo struct {
	Info   *Info
	Routes []*PluginRoute
}
```


#### type PluginJSON

```go
type PluginJSON struct {
	Name        string `json:"name"`
	Description string `json:"description"`
	Repo        string `json:"repo"`
	Author      string `json:"author"`
	Namespace   string `json:"namespace"`
}
```


#### type PluginObject

```go
type PluginObject struct {
	Pluginer
}
```


#### type PluginRepos

```go
type PluginRepos struct {
	Plugins []PluginJSON
}
```


#### type PluginRoute

```go
type PluginRoute struct {
	Url    string
	Method string
	Func   http.HandlerFunc
}
```


#### type PluginRouting

```go
type PluginRouting struct {
	URL     string
	Method  string
	Handler func(http.ResponseWriter, *http.Request)
}
```


#### type Pluginer

```go
type Pluginer interface {
	Select() *Plugin
}
```


#### type Router

```go
type Router interface {
	Routes() []*PluginRoute
	AddRoute(string, string, http.HandlerFunc) error
}
```


#### type Service

```go
type Service struct {
	Id                 int64              `gorm:"primary_key;column:id" json:"id"`
	Name               string             `gorm:"column:name" json:"name"`
	Domain             string             `gorm:"column:domain" json:"domain"`
	Expected           NullString         `gorm:"column:expected" json:"expected"`
	ExpectedStatus     int                `gorm:"default:200;column:expected_status" json:"expected_status"`
	Interval           int                `gorm:"default:30;column:check_interval" json:"check_interval"`
	Type               string             `gorm:"column:check_type" json:"type"`
	Method             string             `gorm:"column:method" json:"method"`
	PostData           NullString         `gorm:"column:post_data" json:"post_data"`
	Port               int                `gorm:"not null;column:port" json:"port"`
	Timeout            int                `gorm:"default:30;column:timeout" json:"timeout"`
	Order              int                `gorm:"default:0;column:order_id" json:"order_id"`
	AllowNotifications NullBool           `gorm:"default:true;column:allow_notifications" json:"allow_notifications"`
	Public             NullBool           `gorm:"default:true;column:public" json:"public"`
	GroupId            int                `gorm:"default:0;column:group_id" json:"group_id"`
	Permalink          NullString         `gorm:"column:permalink" json:"permalink"`
	CreatedAt          time.Time          `gorm:"column:created_at" json:"created_at"`
	UpdatedAt          time.Time          `gorm:"column:updated_at" json:"updated_at"`
	Online             bool               `gorm:"-" json:"online"`
	Latency            float64            `gorm:"-" json:"latency"`
	PingTime           float64            `gorm:"-" json:"ping_time"`
	Online24Hours      float32            `gorm:"-" json:"online_24_hours"`
	AvgResponse        string             `gorm:"-" json:"avg_response"`
	Running            chan bool          `gorm:"-" json:"-"`
	Checkpoint         time.Time          `gorm:"-" json:"-"`
	SleepDuration      time.Duration      `gorm:"-" json:"-"`
	LastResponse       string             `gorm:"-" json:"-"`
	LastStatusCode     int                `gorm:"-" json:"status_code"`
	LastOnline         time.Time          `gorm:"-" json:"last_success"`
	Failures           []FailureInterface `gorm:"-" json:"failures,omitempty"`
	Checkins           []CheckinInterface `gorm:"-" json:"checkins,omitempty"`
}
```

Service is the main struct for Services

#### func (*Service) BeforeCreate

```go
func (s *Service) BeforeCreate() (err error)
```
BeforeCreate for Service will set CreatedAt to UTC

#### func (*Service) Close

```go
func (s *Service) Close()
```
Close will stop the go routine that is checking if service is online or not

#### func (*Service) IsRunning

```go
func (s *Service) IsRunning() bool
```
IsRunning returns true if the service go routine is running

#### func (*Service) Start

```go
func (s *Service) Start()
```
Start will create a channel for the service checking go routine

#### type ServiceInterface

```go
type ServiceInterface interface {
	Select() *Service
	CheckQueue(bool)
	Check(bool)
	Create(bool) (int64, error)
	Update(bool) error
	Delete() error
}
```


#### type User

```go
type User struct {
	Id            int64     `gorm:"primary_key;column:id" json:"id"`
	Username      string    `gorm:"type:varchar(100);unique;column:username;" json:"username,omitempty"`
	Password      string    `gorm:"column:password" json:"password,omitempty"`
	Email         string    `gorm:"type:varchar(100);unique;column:email" json:"email,omitempty"`
	ApiKey        string    `gorm:"column:api_key" json:"api_key,omitempty"`
	ApiSecret     string    `gorm:"column:api_secret" json:"api_secret,omitempty"`
	Admin         NullBool  `gorm:"column:administrator" json:"admin,omitempty"`
	CreatedAt     time.Time `gorm:"column:created_at" json:"created_at"`
	UpdatedAt     time.Time `gorm:"column:updated_at" json:"updated_at"`
	UserInterface `gorm:"-" json:"-"`
}
```

User is the main struct for Users

#### func (*User) BeforeCreate

```go
func (u *User) BeforeCreate() (err error)
```
BeforeCreate for User will set CreatedAt to UTC

#### type UserInterface

```go
type UserInterface interface {
	Create() (int64, error)
	Update() error
	Delete() error
}
```

UserInterface interfaces the database functions
# utils
--
    import "github.com/hunterlong/statping/utils"

Package utils contains common methods used in most packages in Statping. This
package contains multiple function like: Logging, encryption, type conversions,
setting utils.Directory as the current directory, running local CMD commands,
and creating/deleting files/folder.

You can overwrite the utils.Directory global variable by including STATPING_DIR
environment variable to be an absolute path.

More info on: https://github.com/hunterlong/statping

## Usage

```go
const (
	FlatpickrTime     = "2006-01-02 15:04"
	FlatpickrDay      = "2006-01-02"
	FlatpickrReadable = "Mon, 02 Jan 2006"
)
```

```go
var (
	LastLines []*LogRow
	LockLines sync.Mutex
)
```

```go
var (
	// Directory returns the current path or the STATPING_DIR environment variable
	Directory string
)
```

#### func  Command

```go
func Command(cmd string) (string, string, error)
```
Command will run a terminal command with 'sh -c COMMAND' and return stdout and
errOut as strings

    in, out, err := Command("sass assets/scss assets/css/base.css")

#### func  DeleteDirectory

```go
func DeleteDirectory(directory string) error
```
DeleteDirectory will attempt to delete a directory and all contents inside

    DeleteDirectory("assets")

#### func  DeleteFile

```go
func DeleteFile(file string) error
```
DeleteFile will attempt to delete a file

    DeleteFile("newfile.json")

#### func  DurationReadable

```go
func DurationReadable(d time.Duration) string
```
DurationReadable will return a time.Duration into a human readable string // t
:= time.Duration(5 * time.Minute) // DurationReadable(t) // returns: 5 minutes

#### func  FileExists

```go
func FileExists(name string) bool
```
FileExists returns true if a file exists

    exists := FileExists("assets/css/base.css")

#### func  FormatDuration

```go
func FormatDuration(d time.Duration) string
```
FormatDuration converts a time.Duration into a string

#### func  HashPassword

```go
func HashPassword(password string) string
```
HashPassword returns the bcrypt hash of a password string

#### func  Http

```go
func Http(r *http.Request) string
```
Http returns a log for a HTTP request

#### func  HttpRequest

```go
func HttpRequest(url, method string, content interface{}, headers []string, body io.Reader, timeout time.Duration) ([]byte, *http.Response, error)
```
HttpRequest is a global function to send a HTTP request // url - The URL for
HTTP request // method - GET, POST, DELETE, PATCH // content - The HTTP request
content type (text/plain, application/json, or nil) // headers - An array of
Headers to be sent (KEY=VALUE) []string{"Authentication=12345", ...} // body -
The body or form data to send with HTTP request // timeout - Specific duration
to timeout on. time.Duration(30 * time.Seconds) // You can use a HTTP Proxy if
you HTTP_PROXY environment variable

#### func  InitLogs

```go
func InitLogs() error
```
InitLogs will create the '/logs' directory and creates a file '/logs/statup.log'
for application logging

#### func  Log

```go
func Log(level int, err interface{}) error
```
Log creates a new entry in the utils.Log. Log has 1-5 levels depending on how
critical the log/error is

#### func  NewSHA1Hash

```go
func NewSHA1Hash(n ...int) string
```
NewSHA1Hash returns a random SHA1 hash based on a specific length

#### func  RandomString

```go
func RandomString(n int) string
```
RandomString generates a random string of n length

#### func  SaveFile

```go
func SaveFile(filename string, data []byte) error
```
SaveFile will create a new file with data inside it

    SaveFile("newfile.json", []byte('{"data": "success"}')

#### func  Timezoner

```go
func Timezoner(t time.Time, zone float32) time.Time
```
Timezoner returns the time.Time with the user set timezone

#### func  ToInt

```go
func ToInt(s interface{}) int64
```
ToInt converts a int to a string

#### func  ToString

```go
func ToString(s interface{}) string
```
ToString converts a int to a string

#### func  UnderScoreString

```go
func UnderScoreString(str string) string
```
UnderScoreString will return a string that replaces spaces and other characters
to underscores

    UnderScoreString("Example String")
    // example_string

#### type LogRow

```go
type LogRow struct {
	Date time.Time
	Line interface{}
}
```


#### func  GetLastLine

```go
func GetLastLine() *LogRow
```
GetLastLine returns 1 line for a recent log entry

#### func (*LogRow) FormatForHtml

```go
func (o *LogRow) FormatForHtml() string
```

#### type Timestamp

```go
type Timestamp time.Time
```


#### func (Timestamp) Ago

```go
func (t Timestamp) Ago() string
```
Ago returns a human readable timestamp based on the Timestamp (time.Time)
interface

#### type Timestamper

```go
type Timestamper interface {
	Ago() string
}
```