Exemple #1
0
// GetMessagesByVisitID -
func GetMessagesByVisitID(e *config.Env, visitID string) ([]Message, int, error) {
	visitUUID, err := shortuuid.New().Decode(visitID)

	if err != nil {
		return nil, http.StatusBadRequest, err
	}

	messages := []Message{}
	err = e.MainDB.Select(&messages, "SELECT * FROM messages WHERE visit_id = ? ORDER BY updated_at ASC", visitUUID.Bytes())

	if err != nil {
		return nil, http.StatusNotFound, err
	}

	// parse all messages's UUID bytes into human readable IDs
	for key := range messages {
		statusCode, err := messages[key].convertUUIDToIDs()

		if err != nil {
			return nil, statusCode, err
		}

	}

	return messages, http.StatusOK, nil
}
Exemple #2
0
func (m *Message) createFieldsBuilder() {
	messageUUID := uuid.NewV4()
	m.ID = shortuuid.New().Encode(messageUUID)
	m.UUID = messageUUID.Bytes()

	m.CreatedAt = time.Now().String()
	m.UpdatedAt = m.CreatedAt
}
Exemple #3
0
func (v *Visit) createFieldsBuilder() {
	visitUUID := uuid.NewV4()
	v.ID = shortuuid.New().Encode(visitUUID)
	v.UUID = visitUUID.Bytes()

	v.CreatedAt = time.Now().String()
	v.UpdatedAt = v.CreatedAt
}
Exemple #4
0
func (m *Message) convertUUIDToIDs() (int, error) {
	messageUUID, err := uuid.FromBytes(m.UUID)

	if err != nil {
		return http.StatusBadRequest, err
	}

	visitUUID, err := uuid.FromBytes(m.VisitUUID)

	if err != nil {
		return http.StatusBadRequest, err
	}

	m.ID = shortuuid.New().Encode(messageUUID)
	m.VisitID = shortuuid.New().Encode(visitUUID)

	return http.StatusOK, nil
}
Exemple #5
0
func (m *Message) convertMessageIDtoUUID() (int, error) {
	messageUUID, err := shortuuid.New().Decode(m.ID)

	if err != nil {
		return http.StatusBadRequest, err
	}

	m.UUID = messageUUID.Bytes()

	return http.StatusOK, nil
}
Exemple #6
0
// Converts VisitID into a Byte UUIDs
//  Returns BadRequest if error occurs
func (m *Message) convertRefrencesIDtoUUID() (int, error) {
	visitUUID, err := shortuuid.New().Decode(m.VisitID)

	if err != nil {
		return http.StatusBadRequest, err
	}

	m.VisitUUID = visitUUID.Bytes()

	return http.StatusOK, nil
}
Exemple #7
0
// Converts VisitUUID into a Readable IDs
//  Returns BadRequest if error occurs
func (m *Message) convertRefrencesUUIDtoID() (int, error) {
	visitUUID, err := uuid.FromBytes(m.VisitUUID)

	if err != nil {
		return http.StatusBadRequest, err
	}

	m.VisitID = shortuuid.New().Encode(visitUUID)

	return http.StatusOK, nil
}
Exemple #8
0
func (b *Broker) TimerCallback(schedule string) *TimerCallback {
	callback := &TimerCallback{
		ID:       fmt.Sprintf("timer:%s", shortuuid.New()),
		Schedule: schedule,
		Chan:     make(chan time.Time),
	}
	if err := b.RegisterCallback(callback); err != nil {
		Logger.Debug("error registering callback ", callback.ID, ":: ", err)
		return nil
	}
	return callback
}
Exemple #9
0
func (v *Visit) convertVisitIDtoUUID() (int, error) {
	visitUUID, err := shortuuid.New().Decode(v.ID)

	if err != nil {
		fmt.Printf("convert visit err")

		return http.StatusBadRequest, err
	}

	v.UUID = visitUUID.Bytes()

	return http.StatusOK, nil
}
Exemple #10
0
func (b *Broker) QuestionCallback(user string, prompt string) *QuestionCallback {
	callback := &QuestionCallback{
		ID:       fmt.Sprintf("question:%s", shortuuid.New()),
		User:     user,
		Question: prompt,
		Answer:   make(chan string),
	}
	if err := b.RegisterCallback(callback); err != nil {
		Logger.Debug("error registering callback ", callback.ID, ":: ", err)
		return nil
	}
	return callback
}
Exemple #11
0
func (b *Broker) EventCallback(key string, val string) *EventCallback {
	callback := &EventCallback{
		ID:   fmt.Sprintf("event:%s", shortuuid.New()),
		Key:  key,
		Val:  val,
		Chan: make(chan map[string]interface{}),
	}

	if err := b.RegisterCallback(callback); err != nil {
		Logger.Debug("error registering callback ", callback.ID, ":: ", err)
		return nil
	}
	return callback
}
Exemple #12
0
// Delete -
func (m *Message) Delete(e *config.Env) (int, error) {
	messageUUID, err := shortuuid.New().Decode(m.ID)

	if err != nil {
		return http.StatusBadRequest, err
	}

	_, err = e.MainDB.Exec("DELETE FROM messages WHERE id=?", messageUUID.Bytes())

	if err != nil {
		return http.StatusBadRequest, err
	}

	return http.StatusOK, nil
}
Exemple #13
0
// GetByPhoneNumber -
func (v *Visit) GetByPhoneNumber(e *config.Env) (int, error) {
	err := e.MainDB.Get(v, "SELECT * FROM visits WHERE phone_number=? ORDER BY created_at DESC LIMIT 1", v.PhoneNumber)

	if err != nil {
		return http.StatusBadRequest, err
	}

	visitUUID, err := uuid.FromBytes(v.UUID)

	if err != nil {
		return http.StatusBadRequest, err
	}

	v.ID = shortuuid.New().Encode(visitUUID)

	return http.StatusOK, nil
}
Exemple #14
0
func (b *Broker) MessageCallback(pattern string, respond bool, channel ...string) *MessageCallback {
	callback := &MessageCallback{
		ID:      fmt.Sprintf("message:%s", shortuuid.New()),
		Pattern: pattern,
		Respond: respond,
		Chan:    make(chan PatternMatch),
	}

	if channel != nil {
		callback.SlackChan = channel[0] // todo: support an array of channels
	}

	if err := b.RegisterCallback(callback); err != nil {
		Logger.Debug("error registering callback ", callback.ID, ":: ", err)
		return nil
	}
	return callback
}
Exemple #15
0
func GetAll(e *config.Env) ([]*Visit, int, error) {
	var visits []*Visit

	err := e.MainDB.Select(&visits, "SELECT * FROM visits ORDER BY created_at DESC")

	if err != nil {
		return nil, http.StatusBadRequest, err
	}

	for _, v := range visits {
		visitUUID, err := uuid.FromBytes(v.UUID)

		if err != nil {
			return nil, http.StatusBadRequest, err
		}

		v.ID = shortuuid.New().Encode(visitUUID)
	}

	return visits, http.StatusOK, nil
}
Exemple #16
0
// Get -
func (v *Visit) Get(e *config.Env) (int, error) {
	statusCode, err := v.convertVisitIDtoUUID()

	if err != nil {
		return statusCode, err
	}

	err = e.MainDB.Get(v, "SELECT * FROM visits WHERE id = ?", v.UUID)

	if err != nil {
		return http.StatusBadRequest, err
	}

	visitUUID, err := uuid.FromBytes(v.UUID)

	if err != nil {
		return http.StatusBadRequest, err
	}

	v.ID = shortuuid.New().Encode(visitUUID)

	return http.StatusOK, nil
}
Exemple #17
0
// Create and initialize a new application. This is a front gate for
// the framework, since you should start by creating a new app struct.
// Every application should have a valid name (tag) and a version. So
// this function makes sure they have been passed and are all valid.
// Generally, you should not be creating more than one application.
func New(name, version string) *App {
	var room = make(map[string]interface{})
	const url = "https://github.com/ts33kr/boot"
	const ename = "name is not of correct format"
	const eversion = "version is not valid semver"
	pattern := regexp.MustCompile("^[a-zA-Z0-9-_]+$")
	var parsed semver.Version = semver.MustParse(version)
	if !pattern.MatchString(name) {
		panic(ename)
	}
	if parsed.Validate() != nil {
		panic(eversion)
	}
	application := &App{Name: name, Version: parsed}
	application.Storage = Storage{Container: room}
	application.CronEngine = cron.New() // create CRON
	application.Servers = make(map[string]*http.Server)
	application.Reference = shortuuid.New() // V4
	application.Providers = make([]*Provider, 0)
	application.Services = make([]*Service, 0)
	application.TimeLayout = time.RFC850
	application.Namespace = url // set
	return application          // prepared app
}
Exemple #18
0
package main

import (
	"fmt"
	"math/rand"
	"os"
	"time"

	"github.com/boltdb/bolt"
	"github.com/renstrom/shortuuid"
)

var (
	dbPath     = shortuuid.New() + ".db"
	bucketName = shortuuid.New()

	numKeys = 10
	keyLen  = 3
	valLen  = 7

	keys = make([][]byte, numKeys)
	vals = make([][]byte, numKeys)
)

func init() {
	fmt.Println("Starting writing random data...")
	for i := range keys {
		keys[i] = randBytes(keyLen)
		vals[i] = randBytes(valLen)
	}
	fmt.Println("Done with writing random data...")