Esempio n. 1
0
func (talk *Talk) GetTalkByUsersId() bool {
	talk1 := new(Talk)
	talk2 := new(Talk)

	curs, _ := r.Table("talks").
		Filter(r.Row.Field("UserIdX").Eq(talk.UserIdX)).
		Filter(r.Row.Field("UserIdY").Eq(talk.UserIdY)).
		Run(api.Sess)

	curs2, _ := r.Table("talks").
		Filter(r.Row.Field("UserIdX").Eq(talk.UserIdY)).
		Filter(r.Row.Field("UserIdY").Eq(talk.UserIdX)).
		Run(api.Sess)

	curs.One(&talk1)
	curs2.One(&talk2)
	if len(talk1.Id) == 0 && len(talk2.Id) == 0 {
		return false
	}
	if talk1.Id != "" {
		talk.copyTalk(talk1)
	} else {
		talk.copyTalk(talk2)
	}
	return true
}
Esempio n. 2
0
func (place *Place) getListPlace(getList GetListPlace) ListPlace {
	list := ListPlace{}
	var curs *r.Cursor

	if strings.Compare(getList.Filter, "") == 0 && strings.Compare(getList.Venue, "") == 0 {

		curs, _ = r.Table("places").Filter(r.Row.Field("Validated").Eq(true)).Slice(getList.Offset, getList.Offset+getList.Limit).OrderBy("-PostNb").Run(api.Sess)

	} else if strings.Compare(getList.Filter, "") != 0 && strings.Compare(getList.Venue, "") == 0 {

		curs, _ = r.Table("places").Filter(r.Row.Field("Validated").Eq(true)).Filter(func(customer r.Term) interface{} {
			return customer.Field(getList.Filter).Downcase().Match("^" + strings.ToLower(getList.FilterValue))
		}).Slice(getList.Offset, getList.Offset+getList.Limit).OrderBy("-PostNb").Run(api.Sess)

	} else if strings.Compare(getList.Filter, "") == 0 && strings.Compare(getList.Venue, "") != 0 {

		curs, _ = r.Table("places").Filter(r.Row.Field("Validated").Eq(true)).Filter(r.Row.Field("Type").Eq(getList.Venue)).Slice(getList.Offset, getList.Offset+getList.Limit).OrderBy("-PostNb").Run(api.Sess)

	} else if strings.Compare(getList.Filter, "") != 0 && strings.Compare(getList.Venue, "") != 0 {

		curs, _ = r.Table("places").Filter(r.Row.Field("Validated").Eq(true)).Filter(func(customer r.Term) interface{} {
			return customer.Field(getList.Filter).Downcase().Match("^" + strings.ToLower(getList.FilterValue))
		}).Filter(r.Row.Field("Type").Eq(getList.Venue)).Slice(getList.Offset, getList.Offset+getList.Limit).OrderBy("-PostNb").Run(api.Sess)

	}
	curs.All(&list.Places)
	return list
}
Esempio n. 3
0
func TestMain(m *testing.M) {
	var session *r.Session
	var err error

	c, err := dockertest.ConnectToRethinkDB(20, time.Millisecond*500, func(url string) bool {
		if session, err = r.Connect(r.ConnectOpts{Address: url, Database: "hydra"}); err != nil {
			return false
		} else if _, err = r.DBCreate("hydra").RunWrite(session); err != nil {
			logrus.Printf("Database exists: %s", err)
			return false
		} else if _, err = r.TableCreate("hydra_authorize_code").RunWrite(session); err != nil {
			logrus.Printf("Could not create table: %s", err)
			return false
		} else if _, err = r.TableCreate("hydra_id_sessions").RunWrite(session); err != nil {
			logrus.Printf("Could not create table: %s", err)
			return false
		} else if _, err = r.TableCreate("hydra_access_token").RunWrite(session); err != nil {
			logrus.Printf("Could not create table: %s", err)
			return false
		} else if _, err = r.TableCreate("hydra_implicit").RunWrite(session); err != nil {
			logrus.Printf("Could not create table: %s", err)
			return false
		} else if _, err = r.TableCreate("hydra_refresh_token").RunWrite(session); err != nil {
			logrus.Printf("Could not create table: %s", err)
			return false
		}

		rethinkManager = &FositeRehinkDBStore{
			Session:             session,
			AuthorizeCodesTable: r.Table("hydra_authorize_code"),
			IDSessionsTable:     r.Table("hydra_id_sessions"),
			AccessTokensTable:   r.Table("hydra_access_token"),
			ImplicitTable:       r.Table("hydra_implicit"),
			RefreshTokensTable:  r.Table("hydra_refresh_token"),
			AuthorizeCodes:      make(RDBItems),
			IDSessions:          make(RDBItems),
			AccessTokens:        make(RDBItems),
			Implicit:            make(RDBItems),
			RefreshTokens:       make(RDBItems),
		}
		rethinkManager.Watch(context.Background())
		time.Sleep(500 * time.Millisecond)
		return true
	})
	if session != nil {
		defer session.Close()
	}
	if err != nil {
		logrus.Fatalf("Could not connect to database: %s", err)
	}
	clientManagers["rethink"] = rethinkManager

	retCode := m.Run()
	c.KillRemove()
	os.Exit(retCode)
}
Esempio n. 4
0
func (user *User) createUserFacebook(request *restful.Request, response *restful.Response) {
	if user.getUserFacebookWithAccessToken(request.HeaderParameter("facebooktoken")) == false {
		response.InternalServerError()
		helpers.PrintLog(request, response, user.Name)
		return
	}
	newUser := new(User)

	//Facebook's data
	newUser.FacebookId = user.FacebookId
	newUser.UrlPicture = user.UrlPicture
	newUser.Name = user.Name

	isUserExist := newUser.getUserByFacebookId()

	if isUserExist == false {
		//user
		newUser.Group = 0
		newUser.CreateDate = time.Now()
		newUser.Email = ""
		newUser.Banish = false
	}

	//Session
	newUser.CreateDateToken = time.Now()
	newUser.ExpireDateToken = time.Now().AddDate(0, 0, 15)
	newUser.Token = uuid.New()

	var resp r.WriteResponse
	var err error

	//insert
	if isUserExist == false {
		resp, err = r.Table("users").Insert(newUser).RunWrite(api.Sess)
		//update
	} else {
		_, err = r.Table("users").Get(newUser.Id).Update(newUser).RunWrite(api.Sess)
	}
	if err != nil {
		response.WriteHeaderAndEntity(http.StatusConflict, err.Error())
		helpers.PrintLog(request, response, user.Name)
		return
	}
	//if user has been insert, we got ID
	if isUserExist == false {
		newUser.Id = resp.GeneratedKeys[0]
	}
	response.WriteHeaderAndEntity(http.StatusCreated, newUser)
	helpers.PrintLog(request, response, user.Name)
	return
}
Esempio n. 5
0
func (m DefaultManager) SaveAccount(account *auth.Account) error {
	var (
		hash      string
		eventType string
	)
	if account.Password != "" {
		h, err := auth.Hash(account.Password)
		if err != nil {
			return err
		}

		hash = h
	}
	// check if exists; if so, update
	acct, err := m.Account(account.Username)
	if err != nil && err != ErrAccountDoesNotExist {
		return err
	}

	// update
	if acct != nil {
		updates := map[string]interface{}{
			"first_name": account.FirstName,
			"last_name":  account.LastName,
			"roles":      account.Roles,
		}
		if account.Password != "" {
			updates["password"] = hash
		}

		if _, err := r.Table(tblNameAccounts).Filter(map[string]string{"username": account.Username}).Update(updates).RunWrite(m.session); err != nil {
			return err
		}

		eventType = "update-account"
	} else {
		account.Password = hash
		if _, err := r.Table(tblNameAccounts).Insert(account).RunWrite(m.session); err != nil {
			return err
		}

		eventType = "add-account"
	}

	m.logEvent(eventType, fmt.Sprintf("username=%s", account.Username), []string{"security"})

	return nil
}
Esempio n. 6
0
func handleChangeNotification(socket *websocket.Conn, userID string, err chan string) {
	res, errr := r.Table("notifications").
		Filter(r.Row.Field("UserId").
			Eq(userID)).
		Changes().
		Run(api.Sess)

	var value HandleChange
	if errr != nil {
		err <- errr.Error()
	}
	for res.Next(&value) {
		var notif api.Notification
		var simpleNotif api.WebSocketNotification

		mapstructure.Decode(value.NewVal, &notif)
		if notif.Id == "" {
			mapstructure.Decode(value.OldVal, &notif)
			simpleNotif.OldVal = true
		} else {
			simpleNotif.OldVal = false
		}
		simpleNotif.Title = "notification"
		simpleNotif.Type = notif.Type
		simpleNotif.Name = notif.Name
		simpleNotif.UserIdFrom = notif.UserIdFrom
		simpleNotif.IdLink = notif.IdLink
		simpleNotif.CreatedAt = notif.CreatedAt
		errr := socket.WriteJSON(simpleNotif)
		if errr != nil {
			err <- errr.Error()
		}
	}
}
Esempio n. 7
0
func (user *User) createUser(request *restful.Request, response *restful.Response) {
	newUser := new(User)

	//user
	newUser.Email = user.Email
	newUser.Name = user.Name
	newUser.CreateDate = time.Now()
	newUser.Group = 100
	newUser.FacebookId = ""
	newUser.UrlPicture = ""
	newUser.Banish = false

	//encrypt password
	newUser.Password = helpers.NewCryptPasswd([]byte(user.Password))

	//session
	newUser.CreateDateToken = time.Now()
	newUser.ExpireDateToken = time.Now().AddDate(0, 0, 15)
	newUser.Token = uuid.New()

	resp, err := r.Table("users").Insert(newUser).RunWrite(api.Sess)
	if err != nil {
		response.WriteHeaderAndEntity(http.StatusConflict, err.Error())
		helpers.PrintLog(request, response, user.Name)
		return
	}
	newUser.Id = resp.GeneratedKeys[0]
	newUser.Password = ""
	response.WriteHeaderAndEntity(http.StatusCreated, newUser)
}
Esempio n. 8
0
func (like *Like) getLikesByUserId(searchWithPost bool, limit int, offset int) interface{} {
	var list []Like
	var likelist LikeList

	curs, err := r.Table("likes").
		Filter(r.Row.Field("UserId").Eq(like.user.Id)).
		Slice(offset, offset+limit).
		Run(api.Sess)

	if err != nil && searchWithPost == true {
		return LikeAndPostList{}
	}
	if err != nil && searchWithPost == false {
		return likelist
	}

	curs.All(&list)
	defer curs.Close()

	if searchWithPost == true {
		likeAndPostList := LikeAndPostList{}
		var liste []LikeAndPost
		for _, aLike := range list {
			post := post.Post{Id: aLike.PostId}
			post.GetPostById()
			likeAndPost := LikeAndPost{Like: aLike, Post: post}
			liste = append(liste, likeAndPost)
		}
		likeAndPostList.List = liste
		return likeAndPostList
	}
	likelist.List = list
	return likelist
}
Esempio n. 9
0
func (match *Match) createMatch(request *restful.Request, response *restful.Response) {
	newMatch := new(Match)

	newMatch.CreateAt = time.Now()
	newMatch.PlaceId = match.post.PlaceId
	newMatch.PostId = match.post.Id
	newMatch.UserIdX = match.user.Id
	newMatch.UserImageX = match.user.UrlPicture
	newMatch.UserNameX = match.user.Name
	newMatch.UserIdY = match.post.UserId
	newMatch.UserNameY = match.post.UserName
	newMatch.Validated = false

	resp, err := r.Table("matchs").Insert(newMatch).RunWrite(api.Sess)
	if err != nil {
		response.WriteHeaderAndEntity(http.StatusConflict, err.Error())
		helpers.PrintLog(request, response, match.user.Name)
		return
	}
	go func() {
		notif := notification.SetMatchReceive()
		notif.UserId = match.post.UserId
		notif.UserIdFrom = match.user.Id
		notif.IdThing = resp.GeneratedKeys[0]
		notif.Name = match.user.Name
		notif.IdLink = match.post.Id
		notif.CreateNotification()
	}()

	newMatch.Id = resp.GeneratedKeys[0]
	response.WriteHeaderAndEntity(http.StatusCreated, newMatch)

	helpers.PrintLog(request, response, match.user.Name)
}
Esempio n. 10
0
func (message *Message) createMessageWithContent(request *restful.Request, response *restful.Response) {
	msg := new(Message)

	msg.Content = message.Content
	msg.CreatedAt = time.Now()
	msg.FromUserId = message.user.Id
	msg.TalkId = message.talk.Id
	msg.Read = false

	if message.talk.UserIdX == message.user.Id {
		msg.ToUserId = message.talk.UserIdY
	} else {
		msg.ToUserId = message.talk.UserIdX
	}
	resp, err := r.Table("messages").Insert(msg).RunWrite(api.Sess)
	if err != nil {
		helpers.PrintLog(request, response, message.user.Name)
		response.WriteHeaderAndEntity(http.StatusConflict, err.Error())
		return
	}
	msg.Id = resp.GeneratedKeys[0]
	message.talk.UpdateLastMessageDate(message.user.Id, message.Content)
	response.WriteHeaderAndEntity(http.StatusCreated, msg)
	helpers.PrintLog(request, response, message.user.Name)
}
Esempio n. 11
0
func (place *Place) createPlace(request *restful.Request, response *restful.Response) {
	place.Lat = 0
	place.Lng = 0
	place.PostNb = 0
	place.ValidatedAt = *new(time.Time)
	place.Validated = false
	place.CreateAt = time.Now()
	place.UserId = place.user.Id
	place.Id = *new(string)

	request.Request.ParseMultipartForm(32 << 20)
	mpf, hdr, _ := request.Request.FormFile("image")
	ext := filepath.Ext(hdr.Filename)

	if helpers.CheckFileExtension(ext) == false {
		errors := api.Error{}
		errors.ListErrors = append(errors.ListErrors, "Only .jpg, .jpeg or .png are authorized.")
		response.WriteHeaderAndEntity(406, errors)
		helpers.PrintLog(request, response, place.user.Name)
		return
	}
	place.Image = helpers.GenerateHash(50) + ext
	go helpers.PutFile("assets/Images/"+place.Image, mpf)

	resp, err := r.Table("places").Insert(place).RunWrite(api.Sess)
	if err != nil {
		response.WriteHeaderAndEntity(http.StatusConflict, err.Error())
		return
	}
	place.Id = resp.GeneratedKeys[0]
	response.WriteHeaderAndEntity(http.StatusCreated, place)

	helpers.PrintLog(request, response, place.user.Name)
}
Esempio n. 12
0
func (talk *Talk) RemoveTalk() error {
	if talk.GetTalkByUsersId() == true {
		_, err := r.Table("talks").Get(talk.Id).Delete().Run(api.Sess)
		return err
	}
	return nil
}
Esempio n. 13
0
func (place *Place) IncrementPostNb() error {
	place.PostNb += 1

	_, err := r.Table("places").Get(place.Id).Update(place).RunWrite(api.Sess)

	return err
}
Esempio n. 14
0
func (post *Post) acceptPost(request *restful.Request, response *restful.Response) {
	post.Validated = true
	post.ValidatedAt = time.Now()

	if err := post.place.IncrementPostNb(); err != nil {
		response.WriteHeaderAndEntity(http.StatusInternalServerError, err.Error())
		helpers.PrintLog(request, response, post.user.Name)
		return
	}
	post.IdByPlace = post.place.PostNb

	_, err := r.Table("posts").Get(post.Id).Update(post).RunWrite(api.Sess)
	if err != nil {
		response.WriteHeaderAndEntity(http.StatusInternalServerError, err.Error())
		helpers.PrintLog(request, response, post.user.Name)
		return
	}
	go func() {
		notif := notification.SetPostAccepted()
		notif.UserId = post.UserId
		notif.UserIdFrom = post.user.Id
		notif.IdThing = post.Id
		notif.Name = post.PlaceName
		notif.IdLink = post.Id
		notif.CreateNotification()
	}()
	response.WriteHeaderAndEntity(http.StatusOK, post)
	helpers.PrintLog(request, response, post.user.Name)
}
Esempio n. 15
0
func (post *Post) refusePost(request *restful.Request, response *restful.Response) {

	_, err := r.Table("posts").Get(post.Id).Delete().Run(api.Sess)
	if err != nil {
		response.WriteHeaderAndEntity(http.StatusInternalServerError, err.Error())
		helpers.PrintLog(request, response, post.user.Name)
		return
	}
	if post.Image != "" {
		helpers.RemoveFile("./assets/Images/" + post.Image)
	}
	if post.user.IsUserIsAdmin() == true {
		go func() {
			notif := notification.SetPostRefused()
			notif.UserId = post.UserId
			notif.UserIdFrom = post.user.Id
			notif.IdThing = post.Id
			notif.Name = post.PlaceName
			notif.IdLink = post.Id
			notif.CreateNotification()
		}()
	}
	response.WriteHeader(http.StatusOK)
	helpers.PrintLog(request, response, post.user.Name)
}
Esempio n. 16
0
func (place *Place) acceptPlace(request *restful.Request, response *restful.Response) {

	if place.getGeolocation() == false {
		errors := api.Error{}
		errors.ListErrors = append(errors.ListErrors, "We were unable to geolocate your plate")
		response.WriteHeaderAndEntity(500, errors)
		return
	}

	place.ValidatedAt = time.Now()
	place.Validated = true

	_, err := r.Table("places").Get(place.Id).Update(place).RunWrite(api.Sess)
	if err != nil {
		response.WriteHeaderAndEntity(http.StatusConflict, err.Error())
		return
	}

	go func() {
		notif := notification.SetPlaceAccepted()
		notif.UserId = place.UserId
		notif.UserIdFrom = place.user.Id
		notif.IdThing = place.Id
		notif.Name = place.Name
		notif.IdLink = place.Id
		notif.CreateNotification()
	}()

	response.WriteHeaderAndEntity(http.StatusOK, place)
	helpers.PrintLog(request, response, place.user.Name)
}
Esempio n. 17
0
func (post *Post) UpdateLikeNb(nb int) error {

	post.LikeNb += nb
	_, err := r.Table("posts").Get(post.Id).Update(post).RunWrite(api.Sess)

	return err
}
Esempio n. 18
0
func (place *Place) handleImage(request *restful.Request, response *restful.Response) {
	errors := api.Error{}

	request.Request.ParseMultipartForm(32 << 20)
	mpf, hdr, _ := request.Request.FormFile("image")

	ext := filepath.Ext(hdr.Filename)
	if helpers.CheckFileExtension(ext) == false {
		errors.ListErrors = append(errors.ListErrors, "Only .jpg, .jpeg or .png are authorized.")
		response.WriteHeaderAndEntity(406, errors)
		return
	}
	if strings.Compare(place.Image, "") != 0 {
		helpers.RemoveFile("./assets/Images/" + place.Image)
	}
	place.Image = helpers.GenerateHash(50) + ext
	go helpers.PutFile("assets/Images/"+place.Image, mpf)

	_, err := r.Table("places").Get(place.Id).Update(place).RunWrite(api.Sess)
	if err != nil {
		response.WriteHeaderAndEntity(http.StatusConflict, err.Error())
		return
	}
	response.WriteHeaderAndEntity(http.StatusOK, place)

	helpers.PrintLog(request, response, place.user.Name)
}
Esempio n. 19
0
func newConnectionHandler(c *config.Config, router *httprouter.Router) *connection.Handler {
	ctx := c.Context()

	h := &connection.Handler{}
	h.H = &herodot.JSON{}
	h.W = ctx.Warden
	h.SetRoutes(router)

	switch con := ctx.Connection.(type) {
	case *config.MemoryConnection:
		h.Manager = connection.NewMemoryManager()
		break
	case *config.RethinkDBConnection:
		con.CreateTableIfNotExists("hydra_policies")
		m := &connection.RethinkManager{
			Session: con.GetSession(),
			Table:   r.Table("hydra_policies"),
		}
		if err := m.ColdStart(); err != nil {
			logrus.Fatalf("Could not fetch initial state: %s", err)
		}
		m.Watch(context.Background())
		h.Manager = m
		break
	default:
		panic("Unknown connection type.")
	}

	return h
}
Esempio n. 20
0
func newClientManager(c *config.Config) client.Manager {
	ctx := c.Context()

	switch con := ctx.Connection.(type) {
	case *config.MemoryConnection:
		return &client.MemoryManager{
			Clients: map[string]*fosite.DefaultClient{},
			Hasher:  ctx.Hasher,
		}
	case *config.RethinkDBConnection:
		con.CreateTableIfNotExists("hydra_clients")
		m := &client.RethinkManager{
			Session: con.GetSession(),
			Table:   r.Table("hydra_clients"),
			Hasher:  ctx.Hasher,
		}
		if err := m.ColdStart(); err != nil {
			logrus.Fatalf("Could not fetch initial state: %s", err)
		}
		m.Watch(context.Background())
		return m
	default:
		panic("Unknown connection type.")
	}
}
Esempio n. 21
0
func newJWKHandler(c *config.Config, router *httprouter.Router) *jwk.Handler {
	ctx := c.Context()
	h := &jwk.Handler{
		H: &herodot.JSON{},
		W: ctx.Warden,
	}
	h.SetRoutes(router)

	switch con := ctx.Connection.(type) {
	case *config.MemoryConnection:
		ctx.KeyManager = &jwk.MemoryManager{}
		break
	case *config.RethinkDBConnection:
		con.CreateTableIfNotExists("hydra_json_web_keys")
		m := &jwk.RethinkManager{
			Session: con.GetSession(),
			Keys:    map[string]jose.JsonWebKeySet{},
			Table:   r.Table("hydra_json_web_keys"),
			Cipher: &jwk.AEAD{
				Key: c.GetSystemSecret(),
			},
		}
		if err := m.ColdStart(); err != nil {
			logrus.Fatalf("Could not fetch initial state: %s", err)
		}
		m.Watch(context.Background())
		ctx.KeyManager = m
		break
	default:
		logrus.Fatalf("Unknown connection type.")
	}

	h.Manager = ctx.KeyManager
	return h
}
Esempio n. 22
0
func (like *Like) createLike(request *restful.Request, response *restful.Response) {
	newLike := new(Like)

	newLike.PostId = like.post.Id
	newLike.UserId = like.user.Id
	newLike.Created = time.Now()
	if err := like.post.UpdateLikeNb(1); err != nil {
		response.WriteHeaderAndEntity(http.StatusConflict, err.Error())
		return
	}
	resp, err := r.Table("likes").Insert(newLike).RunWrite(api.Sess)
	if err != nil {
		like.post.UpdateLikeNb(-1)
		response.WriteHeaderAndEntity(http.StatusConflict, err.Error())
		helpers.PrintLog(request, response, like.user.Name)
		return
	}

	if like.post.UserId != like.user.Id {
		go func() {
			notif := notification.SetLikeReceive()
			notif.UserId = like.post.UserId
			notif.UserIdFrom = like.user.Id
			notif.IdThing = resp.GeneratedKeys[0]
			notif.Name = like.user.Name
			notif.IdLink = like.post.Id
			notif.CreateNotification()
		}()
	}

	newLike.Id = resp.GeneratedKeys[0]
	response.WriteHeaderAndEntity(http.StatusCreated, newLike)

	helpers.PrintLog(request, response, like.user.Name)
}
Esempio n. 23
0
func (like *Like) deleteLike(request *restful.Request, response *restful.Response) {

	like.post.Id = like.PostId
	if like.post.GetPostById() == false {
		response.WriteHeader(http.StatusInternalServerError)
		helpers.PrintLog(request, response, like.user.Name)
		return
	}
	if err := like.post.UpdateLikeNb(-1); err != nil {
		response.WriteHeaderAndEntity(http.StatusConflict, err.Error())
		helpers.PrintLog(request, response, like.user.Name)
		return
	}
	_, err := r.Table("likes").Get(like.Id).Delete().Run(api.Sess)
	if err != nil {
		response.WriteHeaderAndEntity(http.StatusConflict, err.Error())
		helpers.PrintLog(request, response, like.user.Name)
		return
	}
	go func() {
		notif := notification.SetLikeReceive()
		notif.IdThing = like.Id
		notif.UserIdFrom = like.user.Id
		notif.RemoveNotification()
	}()

	response.WriteHeader(http.StatusOK)
	helpers.PrintLog(request, response, like.user.Name)
}
Esempio n. 24
0
func (m DefaultManager) SaveEvent(event *shipyard.Event) error {
	if _, err := r.Table(tblNameEvents).Insert(event).RunWrite(m.session); err != nil {
		return err
	}

	return nil
}
Esempio n. 25
0
func connectRDB() {
	var err error
	var session *r.Session

	c, err := dockertest.ConnectToRethinkDB(20, time.Second, func(url string) bool {
		if session, err = r.Connect(r.ConnectOpts{Address: url, Database: "hydra"}); err != nil {
			return false
		} else if _, err = r.DBCreate("hydra").RunWrite(session); err != nil {
			log.Printf("Database exists: %s", err)
			return false
		} else if _, err = r.TableCreate("hydra_policies").RunWrite(session); err != nil {
			log.Printf("Could not create table: %s", err)
			return false
		}

		rethinkManager = &RethinkManager{
			Session:  session,
			Table:    r.Table("hydra_policies"),
			Policies: make(map[string]Policy),
		}

		rethinkManager.Watch(context.Background())
		time.Sleep(time.Second)
		return true
	})
	if err != nil {
		log.Fatalf("Could not connect to database: %s", err)
	}

	containers = append(containers, c)
	managers["rethink"] = rethinkManager
}
Esempio n. 26
0
func (talk *Talk) UpdateLastMessageDate(userID, lastMessage string) error {
	talk.LastMessageDate = time.Now()
	talk.LastMessageUserId = userID
	talk.LastMessage = lastMessage
	talk.MsgNb += 1
	_, err := r.Table("talks").Get(talk.Id).Update(talk).RunWrite(api.Sess)
	return err
}
Esempio n. 27
0
func (m DefaultManager) CreateConsoleSession(c *shipyard.ConsoleSession) error {
	if _, err := r.Table(tblNameConsole).Insert(c).RunWrite(m.session); err != nil {
		return err
	}

	m.logEvent("create-console-session", fmt.Sprintf("container=%s", c.ContainerID), []string{"console"})

	return nil
}
Esempio n. 28
0
func (m DefaultManager) RemoveServiceKey(key string) error {
	if _, err := r.Table(tblNameServiceKeys).Filter(map[string]string{"key": key}).Delete().RunWrite(m.session); err != nil {
		return err
	}

	m.logEvent("delete-service-key", fmt.Sprintf("key=%s", key), []string{"security"})

	return nil
}
Esempio n. 29
0
func (m DefaultManager) SaveServiceKey(key *auth.ServiceKey) error {
	if _, err := r.Table(tblNameServiceKeys).Insert(key).RunWrite(m.session); err != nil {
		return err
	}

	m.logEvent("add-service-key", fmt.Sprintf("description=%s", key.Description), []string{"security"})

	return nil
}
Esempio n. 30
0
func (todo *Todo) clearTodosTable(request *restful.Request, response *restful.Response) {
	//On clear la table donc on supprime tout dans la table Todos
	_, err := r.Table("Todos").Delete().Run(session)
	if err != nil {
		response.WriteHeaderAndEntity(http.StatusInternalServerError, err.Error())
		return
	}
	response.WriteHeader(http.StatusOK)
}