mongo.go 35 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499
  1. package api
  2. import (
  3. "bytes"
  4. "context"
  5. "encoding/base64"
  6. "fmt" // "html/template"
  7. "reflect"
  8. "regexp"
  9. "strconv"
  10. "strings"
  11. "text/template"
  12. "time"
  13. "git.eugeniocarvalho.dev/eugeniucarvalho/apicodegen/api/errs"
  14. iriscontext "github.com/kataras/iris/v12/context"
  15. "go.mongodb.org/mongo-driver/bson"
  16. "go.mongodb.org/mongo-driver/bson/primitive"
  17. "go.mongodb.org/mongo-driver/mongo"
  18. "go.mongodb.org/mongo-driver/mongo/options"
  19. "go.mongodb.org/mongo-driver/mongo/readconcern"
  20. "go.mongodb.org/mongo-driver/mongo/readpref"
  21. "go.mongodb.org/mongo-driver/mongo/writeconcern"
  22. )
  23. const (
  24. DefaultAddrConnect = "mongodb://localhost:27017"
  25. InsertOne = iota + 1
  26. InsertMany
  27. Patch
  28. )
  29. var (
  30. QueriesMap = map[string]*template.Template{}
  31. EMPTYQUERY_REGEX = regexp.MustCompile(`{\s*}`)
  32. )
  33. func GetSessionContext(ctx iriscontext.Context) mongo.SessionContext {
  34. context := ctx.Values().Get("$SessionContext")
  35. if context != nil {
  36. return context.(mongo.SessionContext)
  37. }
  38. return nil
  39. }
  40. func init() {
  41. errs.RegisterMapErrorFunction("MONGO_ERROS", func(source error) (err *errs.Error) {
  42. message := source.Error()
  43. switch {
  44. case strings.Contains(message, "E11000"):
  45. err = errs.AlreadyExists().Details(&errs.Detail{
  46. Message: "DUPLICATED_ITEM",
  47. })
  48. case strings.Contains(message, "cannot decode"):
  49. err = errs.DataCaps().Details(&errs.Detail{
  50. Message: message,
  51. })
  52. case strings.Contains(message, "no documents in result"):
  53. errs.NotFound().Details(&errs.Detail{
  54. Message: "NOT_FOUND",
  55. })
  56. }
  57. return
  58. })
  59. }
  60. type Mongo struct {
  61. // Sessions map[string]*mgo.Session
  62. // Session *mgo.Session
  63. // Uri string
  64. // Configs
  65. //DefaultDB string
  66. // User string `json:"user"`
  67. // Password string `json:"password"`
  68. // DataBase string `json:"database"`
  69. // Addrs string `json:"addrs"`
  70. subject *BehaviorSubjectStruct
  71. client *mongo.Client
  72. Config string `json:"config"`
  73. Clients map[string]*mongo.Client
  74. }
  75. type execfn func(context.Context, *mongo.Collection)
  76. type EntityInterface interface {
  77. Patch() *bson.A
  78. }
  79. // Modelo de comunicação entre o controle da API e a camada de persistencia.
  80. type Filter struct {
  81. Id primitive.ObjectID
  82. UserId primitive.ObjectID
  83. // NextPageToken primitive.ObjectID
  84. // PageToken PageToken
  85. Fields *bson.M
  86. Query *bson.M
  87. Patchs *bson.A
  88. Sort *bson.M
  89. // Sort []string
  90. Collection string
  91. QueryType string
  92. DB string
  93. Format string
  94. Insertion int
  95. CheckQuery bool
  96. IgnoreNoEntityFound bool
  97. MaxResults int
  98. Entity interface{}
  99. Entities interface{}
  100. SessionContext mongo.SessionContext
  101. // Aggregate interface{}
  102. Pipeline primitive.A
  103. Options interface{}
  104. }
  105. func (f *Filter) Aggregate(ctx context.Context, collection *mongo.Collection, opts *options.AggregateOptions) (cursor *mongo.Cursor, err *errs.Error) {
  106. var errl error
  107. if opts == nil {
  108. opts = options.Aggregate().SetBatchSize(int32(f.MaxResults))
  109. }
  110. // cmd := command.Aggregate{
  111. // NS: ns,
  112. // Pipeline: pipeline,
  113. // ReadPref: rp,
  114. // }
  115. if cursor, errl = collection.Aggregate(ctx, f.Pipeline, opts); errl != nil {
  116. err = errs.FromError(errl)
  117. }
  118. return
  119. }
  120. func (t *Filter) Check() (err *errs.Error) {
  121. if t.CheckQuery {
  122. if t.Query == nil {
  123. if !t.Id.IsZero() {
  124. t.Query = &bson.M{"_id": t.Id}
  125. } else {
  126. err = errs.InvalidArgument().Details(&errs.Detail{
  127. LocationType: "query",
  128. Location: "q",
  129. Message: "emptyValue",
  130. })
  131. return
  132. }
  133. }
  134. }
  135. if t.Query == nil {
  136. t.Query = &bson.M{}
  137. }
  138. return
  139. }
  140. func (t *Mongo) Ready() *BehaviorSubjectStruct {
  141. if t.subject == nil {
  142. t.subject = BehaviorSubject()
  143. }
  144. return t.subject
  145. }
  146. func (t *Mongo) Init() (err error) {
  147. var ()
  148. fmt.Printf("Connection string '%s'", t.Config)
  149. if t.client, err = mongo.NewClient(options.Client().ApplyURI(t.Config)); err != nil {
  150. return
  151. }
  152. ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
  153. defer cancel()
  154. if err = t.client.Connect(ctx); err != nil {
  155. return
  156. }
  157. t.Ready().Next(true)
  158. return nil
  159. }
  160. func (t *Mongo) CommitTransaction(opts *options.SessionOptions) {
  161. }
  162. func (t *Mongo) StartTransaction(
  163. sessionOptions *options.SessionOptions,
  164. transactionOptions *options.TransactionOptions,
  165. ) (
  166. sessionContext mongo.SessionContext,
  167. err *errs.Error,
  168. ) {
  169. var (
  170. session mongo.Session
  171. localError error
  172. )
  173. defer func() {
  174. if localError != nil {
  175. err = errs.Internal().Details(&errs.Detail{
  176. Message: localError.Error(),
  177. })
  178. }
  179. }()
  180. if session, localError = t.client.StartSession(sessionOptions); localError == nil {
  181. ctx, _ := context.WithTimeout(context.Background(), 60*time.Second)
  182. mongo.WithSession(ctx, session, func(sctx mongo.SessionContext) error {
  183. if localError = session.StartTransaction(transactionOptions); localError == nil {
  184. sessionContext = sctx
  185. }
  186. return nil
  187. })
  188. }
  189. return
  190. }
  191. func (t *Mongo) Dispatch(f *Filter) {
  192. }
  193. func (t *Mongo) InsertOne(f *Filter) (res *mongo.InsertOneResult, err *errs.Error) {
  194. f.Insertion = InsertOne
  195. t.exec(f, func(ctx context.Context, collection *mongo.Collection) {
  196. var lerr error
  197. if res, lerr = collection.InsertOne(ctx, f.Entity); lerr != nil {
  198. err = errs.FromError(lerr)
  199. }
  200. }, func(e *errs.Error) { err = e })
  201. return
  202. }
  203. func (t *Mongo) InsertMany(f *Filter) (res *mongo.InsertManyResult, err *errs.Error) {
  204. f.Insertion = InsertMany
  205. t.exec(f, func(ctx context.Context, collection *mongo.Collection) {
  206. var (
  207. lerr error
  208. entities []interface{}
  209. value = reflect.ValueOf(f.Entities)
  210. )
  211. for index := 0; index < value.Len(); index++ {
  212. entities = append(entities, value.Index(index).Interface())
  213. }
  214. if res, lerr = collection.InsertMany(ctx, entities); lerr != nil {
  215. err = errs.FromError(lerr)
  216. }
  217. }, func(e *errs.Error) { err = e })
  218. return
  219. }
  220. //Remove os elementos da colecao, selecionados pela query
  221. func (t *Mongo) RemoveOne(f *Filter) (res *mongo.DeleteResult, err *errs.Error) {
  222. f.CheckQuery = true
  223. t.exec(f, func(ctx context.Context, collection *mongo.Collection) {
  224. var lerr error
  225. if res, lerr = collection.DeleteOne(ctx, f.Query); lerr != nil {
  226. err = errs.FromError(lerr)
  227. } else if res.DeletedCount == 0 {
  228. err = errs.NotFound().Details(&errs.Detail{
  229. Message: "No entity has been deleted",
  230. })
  231. }
  232. }, func(e *errs.Error) { err = e })
  233. return
  234. }
  235. //Remove os elementos da colecao, selecionados pela query
  236. func (t *Mongo) RemoveMany(f *Filter) (res *mongo.DeleteResult, err *errs.Error) {
  237. var lerr error
  238. f.CheckQuery = true
  239. t.exec(f, func(ctx context.Context, collection *mongo.Collection) {
  240. if res, lerr = collection.DeleteMany(ctx, f.Entities); lerr != nil {
  241. err = errs.FromError(lerr)
  242. } else if res.DeletedCount == 0 {
  243. err = errs.NotFound().Details(&errs.Detail{
  244. Message: "No entity has been deleted",
  245. })
  246. }
  247. }, func(e *errs.Error) { err = e })
  248. return
  249. }
  250. func (t *Mongo) UpdateOne(f *Filter) (res *mongo.UpdateResult, err *errs.Error) {
  251. var lerr error
  252. f.Insertion = InsertOne
  253. f.CheckQuery = true
  254. t.exec(f, func(ctx context.Context, collection *mongo.Collection) {
  255. if res, lerr = collection.ReplaceOne(ctx, f.Query, f.Entity); lerr != nil {
  256. err = errs.FromError(lerr)
  257. } else if !f.IgnoreNoEntityFound && (res.ModifiedCount+res.UpsertedCount) == 0 {
  258. err = errs.NotFound().Details(&errs.Detail{
  259. Message: "No entity has been updated",
  260. })
  261. }
  262. }, func(e *errs.Error) { err = e })
  263. return
  264. }
  265. func (t *Mongo) UpdateMany(f *Filter) (res *mongo.UpdateResult, err *errs.Error) {
  266. var (
  267. lerr error
  268. entity interface{}
  269. entities []interface{}
  270. value = reflect.ValueOf(f.Entities)
  271. )
  272. f.Insertion = InsertMany
  273. f.CheckQuery = true
  274. t.exec(f, func(ctx context.Context, collection *mongo.Collection) {
  275. for index := 0; index < value.Len(); index++ {
  276. entity = value.Index(index).Interface()
  277. entities = append(entities, entity)
  278. }
  279. if res, lerr = collection.UpdateMany(ctx, f.Query, entities); lerr != nil {
  280. err = errs.FromError(lerr)
  281. } else if !f.IgnoreNoEntityFound && (res.ModifiedCount+res.UpsertedCount) == 0 {
  282. err = errs.NotFound().Details(&errs.Detail{
  283. Message: "No entity has been updated ",
  284. })
  285. }
  286. }, func(e *errs.Error) { err = e })
  287. return
  288. }
  289. func RegisterQuery(id, query string) {
  290. QueriesMap[id] = template.Must(template.New(id).Parse(query))
  291. }
  292. func ParseQuery(ctx iriscontext.Context, filter *Filter, basequery string, data map[string]interface{}) (err *errs.Error) {
  293. var (
  294. found bool
  295. templateErr error
  296. buf bytes.Buffer
  297. baseQueryTemplate *template.Template
  298. // baseQeuryDocument *bson.M
  299. // errbq *errs.Error
  300. queryDecodedString []byte
  301. userQueryString = Q(ctx, "q", "e30=") // default base64 encoded from "{}"
  302. includeInTrash, _ = strconv.ParseBool(Q(ctx, "includeInTrash", "false")) // default base64 encoded from "{}"
  303. )
  304. // defer func() {
  305. // spew.Dump(filter.Query)
  306. // }()
  307. // Faz o parse da userQueryString enviada pelo usuario que deve ser um base64
  308. if queryDecodedString, templateErr = base64.StdEncoding.DecodeString(userQueryString); templateErr != nil {
  309. err = errs.InvalidArgument().Details(&errs.Detail{
  310. Message: "Query param isn't a base64 json",
  311. })
  312. return
  313. }
  314. if baseQueryTemplate, found = QueriesMap[basequery]; !found {
  315. err = errs.Internal().Details(&errs.Detail{
  316. Message: "Invalid query input",
  317. })
  318. return
  319. }
  320. // transclude the query to base query
  321. data["_transclude_"] = string(queryDecodedString)
  322. data["_deleted_"] = includeInTrash
  323. fmt.Println(
  324. basequery,
  325. string(queryDecodedString),
  326. data,
  327. )
  328. if templateErr = baseQueryTemplate.Execute(&buf, data); templateErr != nil {
  329. err = errs.InvalidArgument().Details(&errs.Detail{
  330. Message: "Failed on interpolate data with template query",
  331. })
  332. return
  333. }
  334. x := buf.Bytes()
  335. fmt.Println("buf.Bytes()", string(x))
  336. if templateErr = bson.UnmarshalExtJSON(x, false, &filter.Query); templateErr != nil {
  337. err = errs.InvalidArgument().Details(&errs.Detail{
  338. Message: "Failed on interpolate data with template query",
  339. })
  340. return
  341. }
  342. return
  343. }
  344. func (t *Mongo) PatchOne(f *Filter) (res *mongo.UpdateResult, err *errs.Error) {
  345. f.Insertion = Patch
  346. f.CheckQuery = true
  347. // out, _ := json.Marshal()
  348. // fmt.Println(string(out))
  349. // spew.Dump(f.Patchs)
  350. t.exec(f, func(ctx context.Context, collection *mongo.Collection) {
  351. var (
  352. lerr error
  353. // client *mongo.Client
  354. )
  355. // if client, err = t.GetClient(f.DB); err != nil {
  356. // return
  357. // }
  358. // spew.Dump(f.Query)
  359. // spew.Dump(f.Patchs)
  360. // id := primitive.NewObjectID()
  361. t.client.UseSessionWithOptions(
  362. ctx,
  363. options.Session().SetDefaultReadPreference(readpref.Primary()),
  364. func(sctx mongo.SessionContext) error {
  365. defer func() {
  366. if err != nil {
  367. // fmt.Println("abort patch ", id.Hex())
  368. sctx.AbortTransaction(sctx)
  369. } else {
  370. // fmt.Println("commit patch ", id.Hex())
  371. sctx.CommitTransaction(sctx)
  372. }
  373. sctx.EndSession(sctx)
  374. }()
  375. sctx.StartTransaction(options.Transaction().
  376. SetReadConcern(readconcern.Snapshot()).
  377. SetWriteConcern(writeconcern.New(writeconcern.WMajority())))
  378. for _, p := range *f.Patchs {
  379. if f.Options == nil {
  380. f.Options = options.Update()
  381. }
  382. if res, lerr = collection.UpdateOne(ctx, f.Query, p, f.Options.(*options.UpdateOptions)); lerr != nil {
  383. err = errs.FromError(lerr)
  384. return lerr
  385. }
  386. if !f.IgnoreNoEntityFound && (res.ModifiedCount+res.UpsertedCount) == 0 {
  387. err = errs.NotFound().Details(&errs.Detail{
  388. Message: "No entity has been updated",
  389. })
  390. return fmt.Errorf("No entity has been updated")
  391. }
  392. }
  393. return nil
  394. },
  395. )
  396. }, func(e *errs.Error) { err = e })
  397. return
  398. }
  399. func (t *Mongo) PatchMany(f *Filter) (res *mongo.UpdateResult, err *errs.Error) {
  400. f.Insertion = Patch
  401. f.CheckQuery = true
  402. t.exec(f, func(ctx context.Context, collection *mongo.Collection) {
  403. var (
  404. lerr error
  405. // client *mongo.Client
  406. )
  407. // if client, err = t.GetClient(f.DB); err != nil {
  408. // return
  409. // }
  410. // o, _ := json.MarshalIndent(f.Query, "", " ")
  411. // fmt.Println("query", o)
  412. // o, _ = json.MarshalIndent(f.Patchs, "", " ")
  413. // fmt.Println("patch", o)
  414. t.client.UseSessionWithOptions(
  415. ctx,
  416. options.Session().SetDefaultReadPreference(readpref.Primary()),
  417. func(sctx mongo.SessionContext) error {
  418. defer func() {
  419. if err != nil {
  420. sctx.AbortTransaction(sctx)
  421. } else {
  422. sctx.CommitTransaction(sctx)
  423. }
  424. sctx.EndSession(sctx)
  425. }()
  426. sctx.StartTransaction(
  427. options.Transaction().
  428. SetReadConcern(readconcern.Snapshot()).
  429. SetWriteConcern(writeconcern.New(writeconcern.WMajority())),
  430. )
  431. for _, p := range *f.Patchs {
  432. if res, lerr = collection.UpdateMany(ctx, f.Query, p); lerr != nil {
  433. err = errs.FromError(lerr)
  434. return lerr
  435. }
  436. if !f.IgnoreNoEntityFound && (res.ModifiedCount+res.UpsertedCount) == 0 {
  437. err = errs.NotFound().Details(&errs.Detail{
  438. Message: "No entity has been updated",
  439. })
  440. err.CodeText = "noEntityUpdated"
  441. return fmt.Errorf("No entity has been updated")
  442. }
  443. }
  444. return nil
  445. },
  446. )
  447. }, func(e *errs.Error) { err = e })
  448. return
  449. }
  450. func (mongo *Mongo) CreateIndex(database, collectionString string, index mongo.IndexModel) *errs.Error {
  451. collection := mongo.client.Database(database).Collection(collectionString)
  452. opts := options.CreateIndexes().SetMaxTime(10 * time.Second)
  453. if _, err := collection.Indexes().CreateOne(context.Background(), index, opts); err != nil {
  454. return errs.FromError(err)
  455. }
  456. return nil
  457. }
  458. func (mongo *Mongo) FindOneRx(options *Filter) *ObservableStruct {
  459. return Observable(func(observer *Subscriber) {
  460. if res, err := mongo.FindOne(options); err != nil {
  461. observer.Err(err)
  462. } else {
  463. observer.Next(res)
  464. }
  465. })
  466. }
  467. func (t *Mongo) FindOne(f *Filter) (res *mongo.SingleResult, err *errs.Error) {
  468. f.CheckQuery = (f.QueryType != "aggregate")
  469. t.exec(f, func(ctx context.Context, collection *mongo.Collection) {
  470. var (
  471. lerr error
  472. cursor *mongo.Cursor
  473. )
  474. if f.QueryType == "aggregate" {
  475. if cursor, err = f.Aggregate(ctx, collection, nil); err != nil {
  476. return
  477. }
  478. if cursor.Next(ctx) {
  479. if lerr = cursor.Decode(f.Entity); lerr == nil {
  480. return
  481. }
  482. } else {
  483. lerr = fmt.Errorf("No document found")
  484. }
  485. } else {
  486. res = collection.FindOne(ctx, f.Query)
  487. if lerr = res.Err(); lerr == nil {
  488. if lerr = res.Decode(f.Entity); lerr == nil {
  489. return
  490. }
  491. }
  492. }
  493. err = errs.FromError(lerr)
  494. }, func(e *errs.Error) {
  495. err = e
  496. })
  497. return
  498. }
  499. func findIds(filter *Filter) (ids []primitive.ObjectID) {
  500. ids = []primitive.ObjectID{}
  501. // findIdsFilter = &Filter{}
  502. // cursor, err := executeFind(findIdsFilter)
  503. return
  504. }
  505. func (t *Mongo) FindMany(f *Filter) (cursor *mongo.Cursor, err *errs.Error) {
  506. // f.CheckQuery = true
  507. t.exec(f, func(ctx context.Context, collection *mongo.Collection) {
  508. var (
  509. lerr error
  510. elemp reflect.Value
  511. // ids = []primitive.ObjectID{}
  512. // limit = int64(f.MaxResults)
  513. // fields = f.Fields
  514. )
  515. // defer func() {
  516. // if errd := recover(); errd != nil {
  517. // // fmt.Println(errd)
  518. // // spew.Dump(Trace())
  519. // // fmt.Println(errors.WithStack(errd.(error)) )
  520. // LogError(0, fmt.Sprintf("FindMany - %v", errd))
  521. // }
  522. // }()
  523. // Carrega os ids e verifica o intervalo de paginacao da consulta.
  524. // f.Fields = &bson.M{"_id": 1}
  525. // ids = findIds(f)
  526. // Atualiza a consulta para o conjunto de ids da paginacao
  527. // f.Fields = fields
  528. // f.Query = &bson.M{"_id": bson.M{"$in": ids}}
  529. // fmt.Println("Query Type ", f.QueryType)
  530. if f.QueryType == "aggregate" {
  531. cursor, lerr = f.Aggregate(ctx, collection, nil)
  532. } else {
  533. findOptions := options.Find()
  534. findOptions.SetLimit(int64(f.MaxResults))
  535. // fmt.Printf("sort of query '%s'\n", f.Format)
  536. // spew.Dump(f.Sort)
  537. // spew.Dump(f.Fields)
  538. // spew.Dump(f.Query)
  539. if f.Sort != nil {
  540. findOptions.SetSort(f.Sort)
  541. }
  542. if f.Fields != nil {
  543. findOptions.SetProjection(f.Fields)
  544. }
  545. cursor, lerr = collection.Find(ctx, f.Query, findOptions)
  546. }
  547. if lerr == nil {
  548. defer cursor.Close(ctx)
  549. // spew.Dump(cursor)
  550. if f.Entities == nil {
  551. lerr = fmt.Errorf("Entities can't be nil")
  552. goto FindManyError
  553. }
  554. entitiesValue := reflect.ValueOf(f.Entities)
  555. if entitiesValue.Kind() != reflect.Ptr || entitiesValue.Elem().Kind() != reflect.Slice {
  556. lerr = fmt.Errorf("Entities argument must be a slice address")
  557. goto FindManyError
  558. }
  559. slicev := entitiesValue.Elem()
  560. // fmt.Println("aaaaaaa000000000000001")
  561. slicev = slicev.Slice(0, slicev.Cap())
  562. // fmt.Println("aaaaaaa000000000000002")
  563. typ := slicev.Type().Elem()
  564. // fmt.Println("aaaaaaa000000000000003")
  565. for cursor.Next(ctx) {
  566. elemp = reflect.New(typ)
  567. // fmt.Println("aqui")
  568. if lerr = cursor.Decode(elemp.Interface()); lerr != nil {
  569. // spew.Dump(elemp)
  570. goto FindManyError
  571. }
  572. slicev = reflect.Append(slicev, elemp.Elem())
  573. }
  574. // spew.Dump(slicev)
  575. entitiesValue.Elem().Set(slicev)
  576. return
  577. }
  578. FindManyError:
  579. err = errs.FromError(lerr)
  580. }, func(e *errs.Error) { err = e })
  581. return
  582. }
  583. func (models *Mongo) Exists(options *Filter) (exists bool, err *errs.Error) {
  584. options.Fields = &bson.M{"_id": 1}
  585. if _, err = models.FindOne(options); err != nil {
  586. return
  587. }
  588. exists = true
  589. return
  590. }
  591. func (driver *Mongo) GetContext(options *Filter) (context.Context, *mongo.Collection) {
  592. var ctx context.Context
  593. if options.SessionContext != nil {
  594. ctx = options.SessionContext
  595. } else {
  596. ctx, _ = context.WithTimeout(context.Background(), 40*time.Second)
  597. }
  598. collection := driver.client.Database(options.DB).Collection(options.Collection)
  599. return ctx, collection
  600. }
  601. func (t *Mongo) exec(f *Filter, execAction execfn, errorAction func(*errs.Error)) {
  602. var (
  603. err *errs.Error
  604. errl error
  605. ctx context.Context
  606. // client *mongo.Client
  607. )
  608. defer func() {
  609. if err == nil {
  610. if errl == nil {
  611. return
  612. }
  613. err = errs.FromError(errl)
  614. }
  615. // spew.Dump(err)
  616. errorAction(err)
  617. }()
  618. if err = f.Check(); err != nil {
  619. return
  620. }
  621. switch f.Insertion {
  622. case InsertOne:
  623. if f.Entity == nil {
  624. errl = fmt.Errorf("Entity can't be nil")
  625. return
  626. }
  627. case InsertMany:
  628. if f.Entities == nil {
  629. errl = fmt.Errorf("Entities can't be nil")
  630. return
  631. }
  632. case Patch:
  633. if f.Patchs == nil {
  634. errl = fmt.Errorf("Patchs can't be nil")
  635. return
  636. }
  637. }
  638. // fmt.Println("passei do exec")
  639. if f.SessionContext != nil {
  640. ctx = f.SessionContext
  641. } else {
  642. ctx, _ = context.WithTimeout(context.Background(), time.Minute)
  643. }
  644. collection := t.client.Database(f.DB).Collection(f.Collection)
  645. execAction(ctx, collection)
  646. return
  647. }
  648. func DeletedPatch() *bson.A {
  649. return &bson.A{
  650. bson.M{
  651. "$set": bson.M{
  652. "deleted": true,
  653. "deletedIn": time.Now().Unix(),
  654. },
  655. },
  656. }
  657. }
  658. // func mergeQueries(filter *Filter) *bson.M {
  659. // if baseQeuryDocument != nil {
  660. // if filter.Query == nil {
  661. // filter.Query = baseQeuryDocument
  662. // } else {
  663. // filter.Query = &bson.M{
  664. // "$and": bson.A{baseQeuryDocument, filter.Query},
  665. // }
  666. // }
  667. // } else if filter.Query == nil {
  668. // filter.Query = &bson.M{}
  669. // }
  670. // }
  671. // func yieldIndexModel() mongo.IndexModel {
  672. // keys := bsonx.Doc{{Key: *key, Value: bsonx.Int32(int32(*value))}}
  673. // index := mongo.IndexModel{}
  674. // index.Keys = keys
  675. // if *unique {
  676. // index.Options = bsonx.Doc{{Key: "unique", Value: bsonx.Boolean(true)}}
  677. // }
  678. // return index
  679. // }
  680. // func (t *Mongo) GetClient() (*mgo.Session, *errs.Error) {
  681. // func (t *Mongo) GetClient(id string) (*mongo.Client, *errs.Error) {
  682. // var (
  683. // client *mongo.Client
  684. // found bool
  685. // )
  686. // if id == "" {
  687. // panic("Client id not defined!")
  688. // }
  689. // if client, found = t.Clients[id]; !found {
  690. // return nil, FullError(ERR_SERVICE_UNAVAILABLE, &errs.Detail{
  691. // Message: fmt.Sprintf("Client %s not exists!", id),
  692. // })
  693. // }
  694. // return client, nil
  695. // }
  696. // func errorcheck(err error) *errs.Error {
  697. // if err != nil {
  698. // return FullError(ERR_GENERAL, &errs.Detail{
  699. // Message: err.Error(),
  700. // })
  701. // }
  702. // return nil
  703. // }
  704. // func Paginate(collection *mongo.Collection, startValue primitive.ObjectID, nPerPage int64) ([]bson.D, *bson.Value, error) {
  705. // // Query range filter using the default indexed _id field.
  706. // filter := bson.VC.DocumentFromElements(
  707. // bson.EC.SubDocumentFromElements(
  708. // "_id",
  709. // bson.EC.ObjectID("$gt", startValue),
  710. // ),
  711. // )
  712. // var opts []findopt.Find
  713. // opts = append(opts, findopt.Sort(bson.NewDocument(bson.EC.Int32("_id", -1))))
  714. // opts = append(opts, findopt.Limit(nPerPage))
  715. // cursor, _ := collection.Find(context.Background(), filter, opts...)
  716. // var lastValue *bson.Value
  717. // var results []bson.Document
  718. // for cursor.Next(context.Background()) {
  719. // elem := bson.NewDocument()
  720. // err := cursor.Decode(elem)
  721. // if err != nil {
  722. // return results, lastValue, err
  723. // }
  724. // results = append(results, *elem)
  725. // lastValue = elem.Lookup("_id")
  726. // }
  727. // return results, lastValue, nil
  728. // }
  729. // func (t *Mongo) Patch(f *Filter) *errs.Error {
  730. // var (
  731. // entityinterface EntityInterface
  732. // col *mongo.Collection
  733. // entity interface{}
  734. // ok bool
  735. // session *mgo.Session
  736. // err error
  737. // x *bson.M
  738. // )
  739. // if session, err = t.GetClient(f.DB); err == nil {
  740. // if !f.Id.IsZero() {
  741. // f.Query = &bson.M{"_id": f.Id}
  742. // } else if f.Query == nil {
  743. // err = fmt.Errorf("Query not defined!")
  744. // goto ErrorPatch
  745. // }
  746. // defer session.Close()
  747. // if entityinterface, ok = f.Entity.(EntityInterface); ok {
  748. // entity = entityinterface.Update()
  749. // x = entity.(*bson.M)
  750. // // delete(*x, "$set")
  751. // } else {
  752. // entity = bson.M{"$set": f.Entity}
  753. // }
  754. // col = session.DB(f.DB).C(f.Collection)
  755. // // entity["$set"]
  756. // spew.Dump(entity)
  757. // _, err = col.Upsert(f.Query, entity)
  758. // }
  759. // ErrorPatch:
  760. // if err != nil {
  761. // return Error(ERR_PERSIST, err.Error())
  762. // }
  763. // return nil
  764. // }
  765. // func (t *Mongo) Upsert(f *Filter) *errs.Error {
  766. // var (
  767. // entityinterface EntityInterface
  768. // col *mongo.Collection
  769. // entity interface{}
  770. // ok bool
  771. // )
  772. // session, err := t.GetClient(f.DB)
  773. // if err == nil {
  774. // if !f.Id.IsZero() {
  775. // f.Query = &bson.M{"_id": f.Id}
  776. // } else if f.Query == nil {
  777. // err = fmt.Errorf("Query not defined!")
  778. // goto ErrorUp
  779. // }
  780. // defer session.Close()
  781. // col = session.DB(f.DB).C(f.Collection)
  782. // // update = bson.M{"$set": f.Entity}
  783. // // if data, ok = f.Entity.Push(); ok {
  784. // // update["$push"] = data
  785. // // }
  786. // // if data, ok = f.Entity.Pull(); ok {
  787. // // update["$pull"] = data
  788. // // }
  789. // // spew.Dump(f.Entity)
  790. // if entityinterface, ok = f.Entity.(EntityInterface); ok {
  791. // // fmt.Println("Implement interface")
  792. // entity = entityinterface.Update()
  793. // } else {
  794. // entity = f.Entity
  795. // }
  796. // // spew.Dump(entity)
  797. // // _, err = col.Upsert(f.Query, entity)
  798. // err = col.Update(f.Query, entity)
  799. // }
  800. // ErrorUp:
  801. // if err != nil {
  802. // return Error(ERR_PERSIST, err.Error())
  803. // }
  804. // return nil
  805. // }
  806. //-----------------------------------------------------------------------
  807. // func (t *Mongo) Find(f *Filter, one bool) (*errs.Error, int) {
  808. // var cursor string
  809. // pageToken := &f.PageToken
  810. // session, err := t.GetClient(f.DB)
  811. // if err == nil {
  812. // defer session.Close()
  813. // if f.Query == nil {
  814. // if one {
  815. // if !f.Id.IsZero() {
  816. // f.Query = &bson.M{"_id": f.Id}
  817. // } else {
  818. // return Error(ERR_INVALID_PARAM_VALUE, "Param id not valid."), 0
  819. // }
  820. // } else if f.Query == nil {
  821. // f.Query = &bson.M{}
  822. // }
  823. // }
  824. // query := minquery.New(session.DB(f.DB), f.Collection, f.Query)
  825. // // Se tem um token de paginacao
  826. // hasToken := pageToken.HasToken()
  827. // if hasToken {
  828. // fmt.Println("consultando com token", pageToken.Cursor)
  829. // query = query.Cursor(pageToken.Cursor)
  830. // }
  831. // // cursorFields := []string{"_id"}
  832. // cursorFields := []string{}
  833. // if len(f.Sort) > 0 {
  834. // query.Sort(f.Sort...)
  835. // for _, key := range f.Sort {
  836. // if !strings.Contains(key, ".") {
  837. // cursorFields = append(cursorFields, key)
  838. // }
  839. // }
  840. // } else {
  841. // cursorFields = append(cursorFields, "_id")
  842. // }
  843. // // Seleciona os campos se forem especificados
  844. // if f.Fields != nil {
  845. // query.Select(f.Fields)
  846. // }
  847. // // Determina o numero de itens a ser retornado
  848. // if f.MaxResults > 0 {
  849. // query.Limit(f.MaxResults)
  850. // }
  851. // if one {
  852. // err = query.One(f.Entity)
  853. // pageToken.Count = 1 // Filter one
  854. // } else {
  855. // // spew.Dump(f.Entity, cursorFields)
  856. // if cursor, err = query.All(f.Entity, cursorFields...); err != nil {
  857. // goto ErroFind
  858. // }
  859. // // Numero total de documentos
  860. // // Se tem um token de paginacao o valor total esta no token
  861. // // Caso contrario consulta no banco
  862. // if !hasToken {
  863. // c := session.DB(f.DB).C(f.Collection)
  864. // if pageToken.Count, err = c.Find(f.Query).Select(&bson.M{"_id": 1}).Count(); err != nil {
  865. // goto ErroFind
  866. // }
  867. // }
  868. // // if ()
  869. // fmt.Println("Cursor return", cursor, "-")
  870. // pageToken.NewCursor = cursor
  871. // }
  872. // }
  873. // ErroFind:
  874. // if err != nil {
  875. // return Error(ERR_PERSIST, err.Error()), 0
  876. // }
  877. // return nil, pageToken.Count
  878. // }
  879. // func (t *Mongo) FindOne(f *Filter) (*errs.Error, int) {
  880. // return t.Find(f, true)
  881. // }
  882. // func (t *Mongo) FindAll(f *Filter) (*errs.Error, int) {
  883. // return t.Find(f, false)
  884. // }
  885. // func (t *Mongo) Count(f *Filter) (*errs.Error, int) {
  886. // session, err := t.GetClient(f.DB)
  887. // if err == nil {
  888. // defer session.Close()
  889. // if f.Query == nil {
  890. // f.Query = &bson.M{}
  891. // }
  892. // query := session.DB(f.DB).C(f.Collection).Find(f.Query)
  893. // // Seleciona os campos se forem especificados
  894. // f.PageToken.Count, err = query.Select(&bson.M{"_id": 1}).Count()
  895. // }
  896. // if err != nil {
  897. // return Error(ERR_PERSIST, err.Error()), 0
  898. // }
  899. // return nil, f.PageToken.Count
  900. // }
  901. // func (t *Mongo) Update(f *Filter) *errs.Error {
  902. // var (
  903. // entityinterface EntityInterface
  904. // entity interface{}
  905. // )
  906. // one := false
  907. // ok := false
  908. // session, err := t.GetClient(f.DB)
  909. // if err == nil {
  910. // defer session.Close()
  911. // if !f.Id.IsZero() {
  912. // one = true
  913. // f.Query = &bson.M{"_id": f.Id}
  914. // } else if f.Query == nil {
  915. // err = fmt.Errorf("Query not defined!")
  916. // }
  917. // if entityinterface, ok = f.Entity.(EntityInterface); ok {
  918. // entity = entityinterface.Update()
  919. // } else {
  920. // entity = f.Entity
  921. // }
  922. // col := session.DB(f.DB).C(f.Collection)
  923. // if one {
  924. // err = col.Update(f.Query, entity)
  925. // } else {
  926. // _, err = col.UpdateAll(f.Query, entity)
  927. // }
  928. // }
  929. // if err != nil {
  930. // return Error(ERR_PERSIST, err.Error())
  931. // }
  932. // return nil
  933. // }
  934. //-----------------------------------------------------------------------
  935. // func (t *Mongo) Aggregation(f *Filter, q []bson.M, one bool) *errs.Error {
  936. // session, err := t.GetClient(f.DB)
  937. // if err == nil {
  938. // defer session.Close()
  939. // pipe := session.DB(f.DB).C(f.Collection).Pipe(q)
  940. // if one {
  941. // err = pipe.One(&f.Entity)
  942. // } else {
  943. // err = pipe.All(&f.Entity)
  944. // }
  945. // }
  946. // if err != nil {
  947. // return Error(ERR_PERSIST, err.Error())
  948. // }
  949. // return nil
  950. // }
  951. // all := true
  952. // session, err := t.GetClient(f.DB)
  953. // if err == nil {
  954. // defer session.Close()
  955. // if !f.Id.IsZero() {
  956. // all = false
  957. // f.Query = &bson.M{"_id": f.Id}
  958. // } else if f.Query == nil {
  959. // err = fmt.Errorf("Query not defined!")
  960. // }
  961. // C := session.DB(f.DB).C(f.Collection)
  962. // if all {
  963. // _, err = C.RemoveAll(f.Query)
  964. // } else {
  965. // err = C.Remove(f.Query)
  966. // }
  967. // }
  968. // if err != nil {
  969. // return Error(ERR_PERSIST, err.Error())
  970. // }
  971. // return nil
  972. // VERIFICAR A NECESSIDADE E CORRIGIR O ERRO
  973. // func (t *Mongo) GetArrayById(f *Filter, ids []primitive.ObjectID) error {
  974. // session, err := t.GetClient(f.DB)
  975. // if err != nil {
  976. // return err
  977. // }
  978. // defer session.Close()
  979. // q := bson.M{"_id": bson.M{"$in": ids}}
  980. // err = session.DB(f.DB).C(f.Collection).Find(q).One(f.Entity)
  981. // return err
  982. // }
  983. // func (t *Mongo) GetEmbedFromArray(f *Filter, embed string, id primitive.ObjectID, sid primitive.ObjectID) (errs error) {
  984. // session, err := t.GetClient(f.DB)
  985. // if err != nil {
  986. // return err
  987. // }
  988. // defer session.Close()
  989. // field := "$" + embed
  990. // match := bson.M{"_id": id}
  991. // match[embed] = bson.M{"$exists": true}
  992. // aggregations := []bson.M{
  993. // bson.M{"$unwind": field},
  994. // bson.M{"$match": match},
  995. // bson.M{"$replaceRoot": bson.M{"newRoot": field}},
  996. // bson.M{"$match": bson.M{"_id": sid}},
  997. // }
  998. // C := session.DB(f.DB).C(f.Collection)
  999. // return C.Pipe(aggregations).One(&f.Entity)
  1000. // }
  1001. // func (t *Mongo) UpdateEmbedFromArray(f *Filter, embed string, id primitive.ObjectID, sid primitive.ObjectID) error {
  1002. // session, err := t.GetClient(f.DB)
  1003. // if err != nil {
  1004. // return err
  1005. // }
  1006. // defer session.Close()
  1007. // col := session.DB(f.DB).C(f.Collection)
  1008. // //Define o elemento que sera atualizado
  1009. // element := bson.M{}
  1010. // element[embed+".$"] = &f.Entity
  1011. // //Define o seletor do elemento que sera atualizado
  1012. // selector := bson.M{"_id": id}
  1013. // selector[embed+"._id"] = sid
  1014. // return col.Update(selector, bson.M{"$set": element})
  1015. // }
  1016. // func (t *Mongo) AddEmbedFromArray(f *Filter, embed string, id primitive.ObjectID) error {
  1017. // session, errs := t.GetClient(f.DB)
  1018. // if errs != nil {
  1019. // return errs
  1020. // }
  1021. // defer session.Close()
  1022. // col := session.DB(f.DB).C(f.Collection)
  1023. // //Define o elemento que sera atualizado
  1024. // element := bson.M{}
  1025. // element[embed] = &f.Entity
  1026. // //Define o seletor do elemento que sera atualizado
  1027. // selector := bson.M{"_id": id}
  1028. // return col.Update(selector, bson.M{"$push": element})
  1029. // }
  1030. // 0000000000000000000000000000000000000000000000000000000000000000
  1031. // func (t *Mongo) NewTransaction(dbname string) (*Transaction, error) {
  1032. // session, e := t.GetClient(dbname)
  1033. // if e != nil {
  1034. // return nil, e
  1035. // }
  1036. // collection := session.DB(dbname).C("txns")
  1037. // return &Transaction{R: txn.NewRunner(collection)}, nil
  1038. // }
  1039. // Transactions
  1040. // type Transaction struct {
  1041. // R *txn.Runner
  1042. // Ops []txn.Op
  1043. // }
  1044. // func (t *Transaction) Insert(collection string, id primitive.ObjectID, entity interface{}) *Transaction {
  1045. // t.Ops = append(t.Ops, txn.Op{
  1046. // C: collection,
  1047. // Id: id,
  1048. // Insert: entity,
  1049. // })
  1050. // return t
  1051. // }
  1052. // func (t *Transaction) Update(collection string, id primitive.ObjectID, assert *bson.M, entity interface{}) *Transaction {
  1053. // op := txn.Op{
  1054. // C: collection,
  1055. // Id: id,
  1056. // Update: entity,
  1057. // }
  1058. // if assert != nil {
  1059. // op.Assert = assert
  1060. // }
  1061. // t.Ops = append(t.Ops, op)
  1062. // return t
  1063. // }
  1064. // func (t *Transaction) Remove(collection string, id primitive.ObjectID) *Transaction {
  1065. // t.Ops = append(t.Ops, txn.Op{
  1066. // C: collection,
  1067. // Id: id,
  1068. // Remove: true,
  1069. // })
  1070. // return t
  1071. // }
  1072. // func (t *Transaction) Run() error {
  1073. // return t.R.Run(t.Ops, primitive.NewObjectID(), nil)
  1074. // }
  1075. // func (t *Mongo) Find(f *Filter, one bool) (*errs.Error, int) {
  1076. // session, err := t.GetClient()
  1077. // if err == nil {
  1078. // defer session.Close()
  1079. // if !f.Id.IsZero() {
  1080. // f.Query = &bson.M{"_id": f.Id}
  1081. // } else if f.Query == nil {
  1082. // f.Query = &bson.M{}
  1083. // }
  1084. // pageToken := &f.PageToken
  1085. // aggregations := []*bson.M{}
  1086. // // Se tem um token de paginacao
  1087. // hasToken := pageToken.HasToken()
  1088. // if hasToken {
  1089. // fmt.Println("consultando com token", pageToken.CurrentID)
  1090. // // {$or:
  1091. // // [
  1092. // // {$and :
  1093. // // [
  1094. // // {<sort key>:{$gte: <last sort key value of previous page>}},
  1095. // // {"_id" : {$gt : <last result id of previous page>}}
  1096. // // ]
  1097. // // },
  1098. // // ou
  1099. // // {<sort key> :{$gt: <last sort key value>}}
  1100. // // ]
  1101. // // }.
  1102. // // f.Query = &bson.M{"$and": []bson.M{
  1103. // // *f.Query,
  1104. // // bson.M{"_id": bson.M{"$gt": f.NextPageToken}},
  1105. // // }}
  1106. // f.Query = &bson.M{"_id": bson.M{
  1107. // // "$gt": primitive.ObjectIDHex(pageToken.CurrentID),
  1108. // "$gt": pageToken.CurrentID,
  1109. // }}
  1110. // } else {
  1111. // }
  1112. // // Adiciona o primeiro estagio da agregacao
  1113. // aggregations = append(aggregations, &bson.M{"$match": f.Query})
  1114. // if len(f.Sort) > 0 {
  1115. // f.Sort = append(f.Sort, "_id")
  1116. // aggregations = append(aggregations, MgoSortBson(f.Sort))
  1117. // // query.Sort(f.Sort...)
  1118. // }
  1119. // // aggregations = append(aggregations, &bson.M{
  1120. // // "$addFields": bson.M{"position":},
  1121. // // })
  1122. // // Seleciona os campos se forem especificados
  1123. // if f.Fields != nil {
  1124. // // aggregations = append(aggregations, bson.M{"$limit": f.MaxResults})
  1125. // }
  1126. // // countQuery := session.DB(f.DB).C(f.Collection).Pipe(aggregations)
  1127. // // Determina o numero de itens a ser retornado
  1128. // if f.MaxResults > 0 {
  1129. // aggregations = append(aggregations, &bson.M{"$limit": f.MaxResults})
  1130. // }
  1131. // spew.Dump(aggregations)
  1132. // // query := session.DB(f.DB).C(f.Collection).Find(f.Query)
  1133. // collection := session.DB(f.DB).C(f.Collection)
  1134. // query := collection.Pipe(aggregations)
  1135. // if one {
  1136. // err = query.One(f.Entity)
  1137. // f.Count = 1 // Filter one
  1138. // } else {
  1139. // err = query.All(f.Entity)
  1140. // // Numero total de documentos
  1141. // // Se tem um token de paginacao o valor total esta no token
  1142. // // Caso contrario consulta no banco
  1143. // if hasToken {
  1144. // f.Count = pageToken.Count
  1145. // } else {
  1146. // f.Count, _ = collection.Find(f.Query).Select(&bson.M{"_id": 1}).Count()
  1147. // }
  1148. // }
  1149. // }
  1150. // if err != nil {
  1151. // return Error(ERR_PERSIST, err.Error()), 0
  1152. // }
  1153. // return nil, f.Count
  1154. // }
  1155. // v := reflect.ValueOf(f.Entity)
  1156. // fmt.Println("UpdateCursorResponse")
  1157. // // spew.Dump(f.PageToken)
  1158. // // fmt.Println(v.Kind())
  1159. // if v.Kind() == reflect.Ptr {
  1160. // // Atualiza v para o elemento apontado
  1161. // v = v.Elem()
  1162. // if v.Kind() == reflect.Slice || v.Kind() == reflect.Array {
  1163. // // Acessa o atributo ID da ultima entidade do array
  1164. // field := v.Index(v.Len() - 1).Elem().FieldByName("ID")
  1165. // // Converte o atributo ID para objectId
  1166. // last := field.Interface().(primitive.ObjectID)
  1167. // // Cria a consulta que verifica se existe outros registros alem do ultimo
  1168. // filter := &Filter{
  1169. // Collection: f.Collection,
  1170. // Query: &bson.M{"_id": bson.M{
  1171. // "$lt": last,
  1172. // }},
  1173. // }
  1174. // // Se existirem elementos adiciona o nextTOKEN
  1175. // if _, count := models.Count(filter); count > 0 {
  1176. // // atualiza os valores do token
  1177. // f.PageToken.StartID = last.Hex()
  1178. // f.PageToken.Count = f.Count
  1179. // resp.NextPageToken = f.PageToken.Encode()
  1180. // }
  1181. // }
  1182. // }
  1183. // func NewMongo() (*Mongo, error) {
  1184. // // session, err := mgo.Dial(addrs)
  1185. // // session, err := mgo.Dial("mongodb://localhost:27017")
  1186. // session, err := mgo.Dial("mongodb://localhost:27017")
  1187. // if err != nil {
  1188. // return nil, err
  1189. // }
  1190. // session.SetMode(mgo.Monotonic, true)
  1191. // // "addrs": "mongodb://localhost:27017",
  1192. // // "user": "guest",
  1193. // // "password": "welcome",
  1194. // // "database": "financeiro"
  1195. // m := &Mongo{
  1196. // Session: session,
  1197. // DataBase: "accounts",
  1198. // Addrs: ,
  1199. // // Config: cfg,
  1200. // }
  1201. // return m, err
  1202. // }