func baseFind(o Option) r.Term { q := r.Table(resourceName) // slicing if o.Slice != "" { slice := strings.Split(o.Slice, ",") start, _ := strconv.Atoi(slice[0]) end, _ := strconv.Atoi(slice[1]) q = q.Slice(start, end) } // ordering if o.Order != "" { order := strings.Split(strings.ToLower(o.Order), ",") if len(order) == 2 && order[1] == "desc" { q = q.OrderBy(r.Desc(order[0])) } else { q = q.OrderBy(order[0]) } } // filtering q = q.Filter(o.Filter) return q }
func addOptions(q rdb.Term, value string, index string, opts *t.BrowseOpt) rdb.Term { var limit uint = 1024 // TODO(gene): pass into adapter as a config param var lower, upper interface{} if opts != nil { if opts.Since > 0 { lower = opts.Since } else { lower = rdb.MinVal } if opts.Before > 0 { upper = opts.Before } else { upper = rdb.MaxVal } if value != "" { lower = []interface{}{value, lower} upper = []interface{}{value, upper} } if opts.Limit > 0 && opts.Limit < limit { limit = opts.Limit } } else { lower = []interface{}{value, rdb.MinVal} upper = []interface{}{value, rdb.MaxVal} } return q.Between(lower, upper, rdb.BetweenOpts{Index: index}). OrderBy(rdb.OrderByOpts{Index: rdb.Desc(index)}).Limit(limit) }
func loadLatestSales(websocketConnection *websocket.Conn) { results, err := r.Table("analytics").Filter(M{ "type": "sale", }).OrderBy( r.Desc(r.Row.Field("data").Field("date")), ).Limit(10).Map(func(row r.Term) interface{} { return row.Field("data") }).Run(rethinkSession) if err != nil { log.Printf("error loadLatestSales: %q", err) } defer results.Close() var latestSales []interface{} err = results.All(&latestSales) if err != nil { log.Println(err) return } log.Printf("sending latest %d sales\n", len(latestSales)) socketOutgoingMessage := &SocketOutgoingMessage{ Function: "loadLatestSales", Data: M{ "type": "sale", "data": latestSales, }, } err = websocketConnection.WriteJSON(socketOutgoingMessage) if err != nil { log.Println(err) } }
func Slot(r Repository) (*db.Cursor, error) { return db.Table(r.Table()). Filter(db.Row.Field("slot").Gt(0)). OrderBy(db.Desc("slot")). Pluck("id", "name", "slot"). Run(r.Session()) }
func (r *repo) GetAllArticlesInBlog(blog *blogalert.Blog) ([]*blogalert.Article, error) { if blog == nil { return nil, nil } cursor, err := gorethink.DB(Database).Table(ArticleTable). OrderBy(gorethink.Desc("ts")). Filter(gorethink.Row.Field("blog").Eq(blog.URL.String())). Limit(100). Run(r.session) if err != nil { return nil, err } a := []*article{} err = cursor.All(&a) if err != nil { return nil, err } articles := make([]*blogalert.Article, 0, len(a)) for _, v := range a { if article, err := v.ToArticle(blog); err == nil { articles = append(articles, article) r.cache.SetArticle(article) } } return articles, nil }
func (r *repo) GetUserArticlesRead(UID string, blog *blogalert.Blog) ([]*blogalert.Article, error) { if blog == nil { return nil, nil } cursor, err := gorethink.DB(Database).Table(ArticleReadTable). OrderBy(gorethink.Desc("ts")). Filter(gorethink.Row.Field("uid").Eq(UID)). Filter(gorethink.Row.Field("blog").Eq(blog.URL.String())). Limit(100). Run(r.session) if err != nil { return nil, err } a := []*articleRead{} err = cursor.All(&a) if err != nil { return nil, err } articles := make([]*blogalert.Article, 0, len(a)) for _, v := range a { if article, err := r.GetArticle(v.ArticleURL); err == nil { articles = append(articles, article) } } return articles, nil }
func List(r Repository, nameField string, offset int, limit int) (*db.Cursor, error) { return db.Table(r.Table()). OrderBy(db.OrderByOpts{Index: db.Desc("id")}). Slice(offset, limit). Pluck("id", nameField). Run(r.Session()) }
func subscribeChannelMessage(client *Client, data interface{}) { go func() { eventData := data.(map[string]interface{}) val, ok := eventData["channelId"] if !ok { return } channelId, ok := val.(string) if !ok { return } stop := client.NewStopChannel(MessageStop) cursor, err := r.Table("message"). OrderBy(r.OrderByOpts{Index: r.Desc("createdAt")}). Filter(r.Row.Field("channelId").Eq(channelId)). Changes(r.ChangesOpts{IncludeInitial: true}). Run(client.session) if err != nil { client.send <- Message{"error", err.Error()} return } changeFeedHelper(cursor, "message", client.send, stop) }() }
func (m *Manager) Events(limit int) ([]*shipyard.Event, error) { res, err := r.Table(tblNameEvents).OrderBy(r.Desc("Time")).Limit(limit).Run(m.session) if err != nil { return nil, err } var events []*shipyard.Event if err := res.All(&events); err != nil { return nil, err } return events, nil }
func main() { log.Println("VERSION: ", VERSION) e := echo.New() e.Use(middleware.Logger()) e.Use(middleware.Recover()) e.Use(cors.Default().Handler) e.Index("public/index.html") e.Static("/", "public") if len(os.Args) < 2 { fmt.Println("\nPlease input callback url.\n Usage: app.exe [callback_url]") os.Exit(0) } callback_url = os.Args[1] //e.Favicon("public/favicon.ico") server, err := socketio.NewServer(nil) if err != nil { log.Fatal(err) } e.Get("/publish/photo", CallbackHandler) e.Post("/publish/photo", ReceiveHandler) e.Get("/socket.io/", server) server.On("connection", func(so socketio.Socket) { log.Println("====================== on connection ======================") result := make([]interface{}, 12) cur, err := r.Table("instacat").OrderBy(r.OrderByOpts{ Index: r.Desc("time"), }).Limit(12).Run(session) if err != nil { log.Println(err.Error()) } cur.All(&result) fmt.Println("Get result over. ") err = so.Emit("recent", result) if err != nil { log.Println(err.Error()) } so.On("disconnect", func() { log.Println("on disconnect") }) RealtimeChangefeed(so) }) //go SubscribeTag() go sub() port := ":3000" log.Printf("Starting HTTP service on %s ...", port) e.Run(port) }
func (m DefaultManager) Events(limit int) ([]*shipyard.Event, error) { t := r.Table(tblNameEvents).OrderBy(r.Desc("Time")) if limit > -1 { t.Limit(limit) } res, err := t.Run(m.session) if err != nil { return nil, err } events := []*shipyard.Event{} if err := res.All(&events); err != nil { return nil, err } return events, nil }
func (s *Storage) GetLatestQuote() Quote { rows, err := r.Table("quotes").OrderBy(r.Desc("timestamp")).Run(s.Session) if err != nil { fmt.Println(err) } defer rows.Close() var quote Quote err2 := rows.One("e) if err2 != nil { fmt.Println(err2) } fmt.Printf("Fetch one record %#v\n", quote) return quote }
func (c *rethinkClient) GetPipelineRunStatusLatest(id string) (*pps.PipelineRunStatus, error) { cursor, err := c.statuses. GetAllByIndex("pipeline_run_id", id). OrderBy(gorethink.Desc("timestamp")). Nth(0). ToJSON(). Run(c.session) if err != nil { return nil, err } data := "" if !cursor.Next(&data) { return nil, cursor.Err() } var pipelineRunStatus pps.PipelineRunStatus if err := jsonpb.UnmarshalString(data, &pipelineRunStatus); err != nil { return nil, err } return &pipelineRunStatus, nil }
func (a *rethinkAPIServer) ListPipelineInfos(ctx context.Context, request *google_protobuf.Empty) (response *persist.PipelineInfos, err error) { defer func(start time.Time) { a.Log(request, response, err, time.Since(start)) }(time.Now()) pipelineInfoObjs, err := a.getAllMessages( pipelineInfosTable, func() proto.Message { return &persist.PipelineInfo{} }, func(term gorethink.Term) gorethink.Term { return term.OrderBy(gorethink.Desc("created_at")) }, ) if err != nil { return nil, err } pipelineInfos := make([]*persist.PipelineInfo, len(pipelineInfoObjs)) for i, pipelineInfoObj := range pipelineInfoObjs { pipelineInfos[i] = pipelineInfoObj.(*persist.PipelineInfo) } return &persist.PipelineInfos{ PipelineInfo: pipelineInfos, }, nil }
func (c *Connection) GetBookmarks(userID string, page int64) ([]Bookmark, error) { var bookmarks []Bookmark cursor, err := r.DB("magnet"). Table("bookmarks"). OrderBy(r.OrderByOpts{r.Desc("Created")}). Filter(r.Row.Field("User").Eq(userID)). Skip(50 * page). Limit(50). Run(c.session) if err != nil { log.Print(err) return bookmarks, err } cursor.All(&bookmarks) cursor.Close() return bookmarks, err }
func (c *rethinkClient) GetAllPipelineRunStatuses(pipelineRunID string) ([]*pps.PipelineRunStatus, error) { cursor, err := c.pipelineRunStatuses. GetAllByIndex("pipeline_run_id", pipelineRunID). OrderBy(gorethink.Desc("timestamp")). Without("id"). Map(rethinkToJSON). Run(c.session) if err != nil { return nil, err } var pipelineRunStatuses []*pps.PipelineRunStatus data := "" for cursor.Next(&data) { var pipelineRunStatus pps.PipelineRunStatus if err := jsonpb.UnmarshalString(data, &pipelineRunStatus); err != nil { return nil, err } pipelineRunStatuses = append(pipelineRunStatuses, &pipelineRunStatus) } return pipelineRunStatuses, cursor.Err() }
func orders(w http.ResponseWriter, q *http.Request) { ctx, err := NewContext(q) if err != nil { log.Println(err) } rows, err := r.Db("goShop").Table("orders").OrderBy(r.Desc("Date")).Run(ctx.Db) if err != nil { log.Println(err) } var t []Order err = rows.All(&t) if err != nil { log.Println(err) } newmap := map[string]interface{}{"Orders": t} templatesA.ExecuteTemplate(w, "orders", newmap) }
func (a *rethinkAPIServer) GetJobInfosByPipeline(ctx context.Context, request *pps.Pipeline) (response *persist.JobInfos, err error) { defer func(start time.Time) { a.Log(request, response, err, time.Since(start)) }(time.Now()) jobInfoObjs, err := a.getMessagesByIndex( jobInfosTable, pipelineNameIndex, request.Name, func() proto.Message { return &persist.JobInfo{} }, func(term gorethink.Term) gorethink.Term { return term.OrderBy(gorethink.Desc("created_at")) }, ) if err != nil { return nil, err } jobInfos := make([]*persist.JobInfo, len(jobInfoObjs)) for i, jobInfoObj := range jobInfoObjs { jobInfos[i] = jobInfoObj.(*persist.JobInfo) } return &persist.JobInfos{ JobInfo: jobInfos, }, nil }
// ordered by time, latest to earliest func (a *rethinkAPIServer) GetJobLogs(ctx context.Context, request *pps.Job) (response *persist.JobLogs, err error) { defer func(start time.Time) { a.Log(request, response, err, time.Since(start)) }(time.Now()) jobLogObjs, err := a.getMessagesByIndex( jobLogsTable, jobIDIndex, request.Id, func() proto.Message { return &persist.JobLog{} }, func(term gorethink.Term) gorethink.Term { return term.OrderBy(gorethink.Desc("timestamp")) }, ) if err != nil { return nil, err } jobLogs := make([]*persist.JobLog, len(jobLogObjs)) for i, jobLogObj := range jobLogObjs { jobLogs[i] = jobLogObj.(*persist.JobLog) } return &persist.JobLogs{ JobLog: jobLogs, }, nil }
func (c *Connection) Search(userID string, params martini.Params, query string) ([]interface{}, error) { var response []interface{} page, _ := strconv.ParseInt(params["page"], 10, 16) cursor, err := r.DB("magnet"). Table("bookmarks"). OrderBy(r.OrderByOpts{r.Desc("Created")}). Filter(r.Row.Field("Title").Match("(?i)" + query). And(r.Row.Field("User").Eq(userID))). Skip(50 * page). Limit(50). Run(c.session) if err != nil { log.Print(err) return nil, err } cursor.All(&response) cursor.Close() return response, err }
func Get(session *gorethink.Session, w http.ResponseWriter, r *http.Request, render render.Render) { humidityPage := HumidityPage{} var offset int { strPage := r.URL.Query().Get("page") offset, _ = strconv.Atoi(strPage) if offset <= 0 { offset = 0 } } limit := 10 humidityPage.CurrentPage = offset * limit res, err := gorethink.Table("humidity").OrderBy(gorethink.Desc("date_created")).Skip(humidityPage.CurrentPage).Limit(limit).Run(session) if err != nil { render.HTML(404, "current_humidity", nil) return } humidityPage.Humidities = make([]*models.HumidityRecord, limit) for i := 0; i < limit; i++ { humidityPage.Humidities[i] = models.NewCleanRecord() } err = res.All(&humidityPage.Humidities) humidityPage.HasNext = false if len(humidityPage.Humidities) == limit { humidityPage.HasNext = true } if err != nil { render.HTML(404, "current_humidity", nil) return } humidityPage.NextPage = humidityPage.CurrentPage + 1 humidityPage.PreviousPage = humidityPage.CurrentPage - 1 render.HTML(200, "current_humidity", humidityPage) }
func (a *rethinkAPIServer) ListJobInfos(ctx context.Context, request *pps.ListJobRequest) (response *persist.JobInfos, err error) { defer func(start time.Time) { a.Log(request, response, err, time.Since(start)) }(time.Now()) query := a.getTerm(jobInfosTable) if request.Pipeline != nil && request.Input != nil { query = query.GetAllByIndex( pipelineNameAndInputIndex, gorethink.Expr([]string{request.Pipeline.Name, request.Input.Repo.Name, request.Input.Id}), ) } else if request.Pipeline != nil { query = query.GetAllByIndex( pipelineNameIndex, request.Pipeline.Name, ) } else if request.Input != nil { query = query.GetAllByIndex( inputIndex, gorethink.Expr([]string{request.Input.Repo.Name, request.Input.Id}), ) } jobInfoObjs, err := a.getAllMessages( jobInfosTable, func() proto.Message { return &persist.JobInfo{} }, func(term gorethink.Term) gorethink.Term { return term.OrderBy(gorethink.Desc("created_at")) }, ) if err != nil { return nil, err } jobInfos := make([]*persist.JobInfo, len(jobInfoObjs)) for i, jobInfoObj := range jobInfoObjs { jobInfos[i] = jobInfoObj.(*persist.JobInfo) } return &persist.JobInfos{ JobInfo: jobInfos, }, nil }
func (e *EmailsTable) List( owner string, sort []string, offset int, limit int, thread string, ) ([]*models.Email, error) { filter := map[string]interface{}{} if owner != "" { filter["owner"] = owner } if thread != "" { filter["thread"] = thread } term := e.GetTable().Filter(filter).Filter(gorethink.Not(gorethink.Row.Field("status").Eq(gorethink.Expr("queued")))) // If sort array has contents, parse them and add to the term if sort != nil && len(sort) > 0 { var conds []interface{} for _, cond := range sort { if cond[0] == '-' { conds = append(conds, gorethink.Desc(cond[1:])) } else if cond[0] == '+' || cond[0] == ' ' { conds = append(conds, gorethink.Asc(cond[1:])) } else { conds = append(conds, gorethink.Asc(cond)) } } term = term.OrderBy(conds...) } // Slice the result in 3 cases if offset != 0 && limit == 0 { term = term.Skip(offset) } if offset == 0 && limit != 0 { term = term.Limit(limit) } if offset != 0 && limit != 0 { term = term.Slice(offset, offset+limit) } // Run the query cursor, err := term.Run(e.GetSession()) if err != nil { return nil, err } defer cursor.Close() // Fetch the cursor var resp []*models.Email err = cursor.All(&resp) if err != nil { return nil, err } return resp, nil }
func StartQueue(config *shared.Flags) { // Initialize a new logger log := logrus.New() if config.LogFormatterType == "text" { log.Formatter = &logrus.TextFormatter{ ForceColors: config.ForceColors, } } else if config.LogFormatterType == "json" { log.Formatter = &logrus.JSONFormatter{} } log.Level = logrus.DebugLevel // Create a new header encoder he := quotedprintable.Q.NewHeaderEncoder("utf-8") // Initialize the database connection session, err := gorethink.Connect(gorethink.ConnectOpts{ Address: config.RethinkAddress, AuthKey: config.RethinkKey, MaxIdle: 10, Timeout: time.Second * 10, }) if err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to connect to RethinkDB") } // Create a new producer consumer, err := nsq.NewConsumer("send_email", "receive", nsq.NewConfig()) if err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to create a consumer") } // Connect to NSQ producer, err := nsq.NewProducer(config.NSQDAddress, nsq.NewConfig()) if err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to connect to NSQd") } // Load a DKIM signer var dkimSigner map[string]*dkim.DKIM if config.DKIMKey != "" { dkimSigner = map[string]*dkim.DKIM{} key, err := ioutil.ReadFile(config.DKIMKey) if err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to read DKIM private key") } for domain, _ := range domains { dkimConf, err := dkim.NewConf(domain, config.DKIMSelector) if err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to create a new DKIM conf object") } dk, err := dkim.New(dkimConf, key) if err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to create a new DKIM signer") } dkimSigner[domain] = dk } } consumer.AddConcurrentHandlers(nsq.HandlerFunc(func(msg *nsq.Message) error { var id string if err := json.Unmarshal(msg.Body, &id); err != nil { return err } // Get the email from the database cursor, err := gorethink.Db(config.RethinkDatabase).Table("emails").Get(id).Run(session) if err != nil { return err } defer cursor.Close() var email *models.Email if err := cursor.One(&email); err != nil { return err } // Get the thread cursor, err = gorethink.Db(config.RethinkDatabase).Table("threads").Get(email.Thread).Run(session) if err != nil { return err } defer cursor.Close() var thread *models.Thread if err := cursor.One(&thread); err != nil { return err } // Get the proper In-Reply-To hasInReplyTo := false inReplyTo := "" // Fetch received emails in the thread cursor, err = gorethink.Db(config.RethinkDatabase).Table("emails").GetAllByIndex("threadStatus", []interface{}{ thread.ID, "received", }).Pluck("date_created", "message_id", "from").OrderBy(gorethink.Desc(gorethink.Row.Field("date_created"))). Filter(func(row gorethink.Term) gorethink.Term { return gorethink.Expr(email.To).Contains(row.Field("from")) }).Limit(1).Run(session) if err != nil { return err } defer cursor.Close() var emid []*models.Email if err := cursor.All(&emid); err != nil { return err } if len(emid) == 1 { hasInReplyTo = true inReplyTo = emid[0].MessageID } // Fetch the files var files []*models.File if email.Files != nil && len(email.Files) > 0 { filesList := []interface{}{} for _, v := range email.Files { filesList = append(filesList, v) } cursor, err = gorethink.Db(config.RethinkDatabase).Table("files").GetAll(filesList...).Run(session) if err != nil { return err } defer cursor.Close() if err := cursor.All(&files); err != nil { return err } } else { files = []*models.File{} } // Fetch the owner cursor, err = gorethink.Db(config.RethinkDatabase).Table("accounts").Get(email.Owner).Run(session) if err != nil { return err } defer cursor.Close() var account *models.Account if err := cursor.One(&account); err != nil { return err } // Declare a contents variable contents := "" ctxFrom := email.From // Check if charset is set if !strings.Contains(email.ContentType, "; charset=") { email.ContentType += "; charset=utf-8" } if email.Kind == "raw" { // Encode the email if files == nil || len(files) == 0 { buffer := &bytes.Buffer{} context := &rawSingleContext{ From: ctxFrom, CombinedTo: strings.Join(email.To, ", "), MessageID: email.MessageID, HasInReplyTo: hasInReplyTo, InReplyTo: inReplyTo, Subject: he.Encode(email.Name), ContentType: email.ContentType, Body: quotedprintable.EncodeToString([]byte(email.Body)), Date: email.DateCreated.Format(time.RubyDate), } if email.CC != nil && len(email.CC) > 0 { context.HasCC = true context.CombinedCC = strings.Join(email.CC, ", ") } if email.ReplyTo != "" { context.HasReplyTo = true context.ReplyTo = email.ReplyTo } if err := rawSingleTemplate.Execute(buffer, context); err != nil { return err } contents = buffer.String() } else { buffer := &bytes.Buffer{} emailFiles := []*emailFile{} for _, file := range files { emailFiles = append(emailFiles, &emailFile{ Encoding: file.Encoding, Name: file.Name, Body: base64.StdEncoding.EncodeToString([]byte(file.Data)), }) } context := &rawMultiContext{ From: ctxFrom, CombinedTo: strings.Join(email.To, ", "), MessageID: email.MessageID, HasInReplyTo: hasInReplyTo, InReplyTo: inReplyTo, Boundary1: uniuri.NewLen(20), Subject: he.Encode(email.Name), ContentType: email.ContentType, Body: quotedprintable.EncodeToString([]byte(email.Body)), Files: emailFiles, Date: email.DateCreated.Format(time.RubyDate), } if email.CC != nil && len(email.CC) > 0 { context.HasCC = true context.CombinedCC = strings.Join(email.CC, ", ") } if email.ReplyTo != "" { context.HasReplyTo = true context.ReplyTo = email.ReplyTo } if err := rawMultiTemplate.Execute(buffer, context); err != nil { return err } contents = buffer.String() } // Fetch owner's account cursor, err = gorethink.Db(config.RethinkDatabase).Table("accounts").Get(email.Owner).Run(session) if err != nil { return err } defer cursor.Close() var account *models.Account if err := cursor.One(&account); err != nil { return err } // Get owner's key var key *models.Key if account.PublicKey != "" { cursor, err = gorethink.Db(config.RethinkDatabase).Table("keys").Get(account.PublicKey).Run(session) if err != nil { return err } defer cursor.Close() if err := cursor.One(&key); err != nil { return err } } else { cursor, err = gorethink.Db(config.RethinkDatabase).Table("keys").GetAllByIndex("owner", account.ID).Run(session) if err != nil { return err } defer cursor.Close() var keys []*models.Key if err := cursor.All(&keys); err != nil { return err } key = keys[0] } // Parse the key keyring, err := openpgp.ReadArmoredKeyRing(strings.NewReader(key.Key)) if err != nil { return err } // From, to and cc parsing fromAddr, err := mail.ParseAddress(email.From) if err != nil { fromAddr = &mail.Address{ Address: email.From, } } toAddr, err := mail.ParseAddressList(strings.Join(email.To, ", ")) if err != nil { toAddr = []*mail.Address{} for _, addr := range email.To { toAddr = append(toAddr, &mail.Address{ Address: addr, }) } } // Prepare a new manifest manifest := &man.Manifest{ Version: semver.Version{ Major: 1, }, From: fromAddr, To: toAddr, Subject: he.Encode(email.Name), Parts: []*man.Part{}, } if email.CC != nil && len(email.CC) > 0 { ccAddr, nil := mail.ParseAddressList(strings.Join(email.CC, ", ")) if err != nil { ccAddr = []*mail.Address{} for _, addr := range email.CC { ccAddr = append(ccAddr, &mail.Address{ Address: addr, }) } } manifest.CC = ccAddr } // Encrypt and hash the body encryptedBody, err := shared.EncryptAndArmor([]byte(email.Body), keyring) if err != nil { return err } hash := sha256.Sum256([]byte(email.Body)) // Append body to the parts manifest.Parts = append(manifest.Parts, &man.Part{ ID: "body", Hash: hex.EncodeToString(hash[:]), ContentType: email.ContentType, Size: len(email.Body), }) // Encrypt the attachments for _, file := range files { // Encrypt the attachment cipher, err := shared.EncryptAndArmor([]byte(file.Data), keyring) if err != nil { return err } // Hash it hash := sha256.Sum256([]byte(file.Data)) // Generate a random ID id := uniuri.NewLen(20) // Push the attachment into the manifest manifest.Parts = append(manifest.Parts, &man.Part{ ID: id, Hash: hex.EncodeToString(hash[:]), Filename: file.Name, ContentType: file.Encoding, Size: len(file.Data), }) // Replace the file in database err = gorethink.Db(config.RethinkDatabase).Table("files").Get(file.ID).Replace(&models.File{ Resource: models.Resource{ ID: file.ID, DateCreated: file.DateCreated, DateModified: time.Now(), Name: id + ".pgp", Owner: account.ID, }, Encrypted: models.Encrypted{ Encoding: "application/pgp-encrypted", Data: string(cipher), }, }).Exec(session) if err != nil { return err } } // Encrypt the manifest strManifest, err := man.Write(manifest) if err != nil { return err } encryptedManifest, err := shared.EncryptAndArmor(strManifest, keyring) if err != nil { return err } err = gorethink.Db(config.RethinkDatabase).Table("emails").Get(email.ID).Replace(&models.Email{ Resource: models.Resource{ ID: email.ID, DateCreated: email.DateCreated, DateModified: time.Now(), Name: "Encrypted message (" + email.ID + ")", Owner: account.ID, }, Kind: "manifest", From: email.From, To: email.To, CC: email.CC, BCC: email.BCC, Files: email.Files, Manifest: string(encryptedManifest), Body: string(encryptedBody), Thread: email.Thread, MessageID: email.MessageID, }).Exec(session) if err != nil { return err } } else if email.Kind == "pgpmime" { buffer := &bytes.Buffer{} context := &pgpContext{ From: ctxFrom, CombinedTo: strings.Join(email.To, ", "), MessageID: email.MessageID, HasInReplyTo: hasInReplyTo, InReplyTo: inReplyTo, Subject: email.Name, ContentType: email.ContentType, Body: email.Body, Date: email.DateCreated.Format(time.RubyDate), } if email.CC != nil && len(email.CC) > 0 { context.HasCC = true context.CombinedCC = strings.Join(email.CC, ", ") } if email.ReplyTo != "" { context.HasReplyTo = true context.ReplyTo = email.ReplyTo } if err := pgpTemplate.Execute(buffer, context); err != nil { return err } contents = buffer.String() } else if email.Kind == "manifest" { if files == nil || len(files) == 0 { buffer := &bytes.Buffer{} context := &manifestSingleContext{ From: ctxFrom, CombinedTo: strings.Join(email.To, ", "), MessageID: email.MessageID, HasInReplyTo: hasInReplyTo, InReplyTo: inReplyTo, Subject: he.Encode(email.Name), Boundary1: uniuri.NewLen(20), Boundary2: uniuri.NewLen(20), ID: email.ID, Body: email.Body, Manifest: email.Manifest, SubjectHash: thread.SubjectHash, Date: email.DateCreated.Format(time.RubyDate), } if email.CC != nil && len(email.CC) > 0 { context.HasCC = true context.CombinedCC = strings.Join(email.CC, ", ") } if email.ReplyTo != "" { context.HasReplyTo = true context.ReplyTo = email.ReplyTo } if err := manifestSingleTemplate.Execute(buffer, context); err != nil { return err } contents = buffer.String() } else { buffer := &bytes.Buffer{} emailFiles := []*emailFile{} for _, file := range files { emailFiles = append(emailFiles, &emailFile{ Encoding: file.Encoding, Name: file.Name, Body: file.Data, }) } context := &manifestMultiContext{ From: ctxFrom, CombinedTo: strings.Join(email.To, ", "), MessageID: email.MessageID, HasInReplyTo: hasInReplyTo, InReplyTo: inReplyTo, Subject: he.Encode(email.Name), Boundary1: uniuri.NewLen(20), Boundary2: uniuri.NewLen(20), ID: email.ID, Body: email.Body, Manifest: email.Manifest, SubjectHash: thread.SubjectHash, Files: emailFiles, Date: email.DateCreated.Format(time.RubyDate), } if email.CC != nil && len(email.CC) > 0 { context.HasCC = true context.CombinedCC = strings.Join(email.CC, ", ") } if email.ReplyTo != "" { context.HasReplyTo = true context.ReplyTo = email.ReplyTo } if err := manifestMultiTemplate.Execute(buffer, context); err != nil { return err } contents = buffer.String() } } recipients := email.To if email.CC != nil { recipients = append(recipients, email.CC...) } nsqmsg, _ := json.Marshal(map[string]interface{}{ "id": email.ID, "owner": email.Owner, }) // Sign the email if dkimSigner != nil { parts := strings.Split(email.From, "@") if len(parts) == 2 { if _, ok := dkimSigner[parts[1]]; ok { // Replace newlines with \r\n contents = strings.Replace(contents, "\n", "\r\n", -1) // Sign it data, err := dkimSigner[parts[1]].Sign([]byte(contents)) if err != nil { log.Print(err) return err } // Replace contents with signed contents = strings.Replace(string(data), "\r\n", "\n", -1) } } } if err := smtp.SendMail(config.SMTPAddress, nil, email.From, recipients, []byte(contents)); err != nil { err := producer.Publish("email_bounced", nsqmsg) if err != nil { log.WithFields(logrus.Fields{ "error": err, }).Error("Unable to publish a bounce msg") } } else { err := producer.Publish("email_delivery", nsqmsg) if err != nil { log.WithFields(logrus.Fields{ "error": err, }).Error("Unable to publish a bounce msg") } } err = gorethink.Db(config.RethinkDatabase).Table("emails").Get(email.ID).Update(map[string]interface{}{ "status": "sent", }).Exec(session) if err != nil { log.WithFields(logrus.Fields{ "error": err, }).Error("Unable to mark an email as sent") } msg.Finish() return nil }), 10) if err := consumer.ConnectToNSQLookupd(config.LookupdAddress); err != nil { log.WithFields(logrus.Fields{ "error": err, }).Fatal("Unable to connect to nsqlookupd") } log.Info("Connected to NSQ and awaiting data") }
func (c *AccountTransactions) ReadMany(ctx context.Context) (err error) { var transactions []models.Transaction accountId := ctx.PathValue("account_id") rows, err := r.Table("transactions").Filter(r.Row.Field("accountId").Eq(accountId)).OrderBy(r.Desc("createdAt")).Run(c.DbSession) for rows.Next() { var transaction models.Transaction err = rows.Scan(&transaction) if err != nil { return } transactions = append(transactions, transaction) } if err != nil { log.Fatal(err) return goweb.Respond.WithStatus(ctx, http.StatusNotFound) } return goweb.API.RespondWithData(ctx, transactions) }
func (t *ThreadsTable) List( owner string, sort []string, offset int, limit int, labels []string, ) ([]*models.Thread, error) { term := t.GetTable() if owner != "" { term = t.GetTable().GetAllByIndex("owner", owner) } // If sort array has contents, parse them and add to the term if sort != nil && len(sort) > 0 { var conds []interface{} for _, cond := range sort { if cond[0] == '-' { conds = append(conds, gorethink.Desc(cond[1:])) } else if cond[0] == '+' || cond[0] == ' ' { conds = append(conds, gorethink.Asc(cond[1:])) } else { conds = append(conds, gorethink.Asc(cond)) } } term = term.OrderBy(conds...) } // Parse labels hasLabels := []string{} excLabels := []string{} for _, label := range labels { if label[0] == '-' { excLabels = append(excLabels, label[1:]) } else { hasLabels = append(hasLabels, label) } } // Transform that into a term if len(hasLabels) > 0 || len(excLabels) > 0 { var hasTerm gorethink.Term if len(hasLabels) == 1 { hasTerm = gorethink.Row.Field("labels").Contains(hasLabels[0]) } else if len(hasLabels) > 0 { for i, label := range hasLabels { if i == 0 { hasTerm = gorethink.Row.Field("labels").Contains(label) } else { hasTerm = hasTerm.And(gorethink.Row.Field("labels").Contains(label)) } } } var excTerm gorethink.Term if len(excLabels) == 1 { excTerm = gorethink.Not(gorethink.Row.Field("labels").Contains(excLabels[0])) } else { for i, label := range excLabels { if i == 0 { excTerm = gorethink.Not(gorethink.Row.Field("labels").Contains(label)) } else { excTerm = excTerm.And(gorethink.Not(gorethink.Row.Field("labels").Contains(label))) } } } // Append them into the term if len(hasLabels) > 0 && len(excLabels) > 0 { term = term.Filter(hasTerm.And(excTerm)) } else if len(hasLabels) > 0 && len(excLabels) == 0 { term = term.Filter(hasTerm) } else if len(hasLabels) == 0 && len(excLabels) > 0 { term = term.Filter(excTerm) } } // Slice the result if offset != 0 || limit != 0 { term = term.Slice(offset, offset+limit) } // Add manifests term = term.Map(func(thread gorethink.Term) gorethink.Term { return thread.Merge(gorethink.Db(t.GetDBName()).Table("emails").Between([]interface{}{ thread.Field("id"), time.Date(1990, time.January, 1, 23, 0, 0, 0, time.UTC), }, []interface{}{ thread.Field("id"), time.Date(2090, time.January, 1, 23, 0, 0, 0, time.UTC), }, gorethink.BetweenOpts{ Index: "threadAndDate", }).OrderBy(gorethink.OrderByOpts{Index: "threadAndDate"}). Nth(0).Pluck("manifest")) }) // Run the query cursor, err := term.Run(t.GetSession()) if err != nil { return nil, err } defer cursor.Close() // Fetch the cursor var resp []*models.Thread err = cursor.All(&resp) if err != nil { return nil, err } return resp, nil }
func All(r Repository, offset int, limit int) (*db.Cursor, error) { return db.Table(r.Table()). OrderBy(db.OrderByOpts{Index: db.Desc("id")}). Slice(offset, limit). Run(r.Session()) }