utils.go 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856
  1. package api
  2. import (
  3. "encoding/json"
  4. "fmt"
  5. "net/url"
  6. "regexp"
  7. "strconv"
  8. "strings"
  9. "time"
  10. "git.eugeniocarvalho.dev/eugeniucarvalho/apicodegen/api/errs"
  11. "github.com/davecgh/go-spew/spew"
  12. "github.com/eugeniucarvalho/validator"
  13. "github.com/kataras/iris/v12/context"
  14. "go.mongodb.org/mongo-driver/bson"
  15. "go.mongodb.org/mongo-driver/bson/primitive"
  16. "go.mongodb.org/mongo-driver/mongo"
  17. )
  18. var (
  19. AcceptJson = regexp.MustCompile("^application/json")
  20. Environment = map[string]interface{}{}
  21. ToReference = references{}
  22. )
  23. type references struct {
  24. }
  25. func (this *references) True() *bool {
  26. value := true
  27. return &value
  28. }
  29. func (this *references) False() *bool {
  30. value := false
  31. return &value
  32. }
  33. func (this *references) String(value string) *string {
  34. return &value
  35. }
  36. func (this *references) Bool(value bool) *bool {
  37. return &value
  38. }
  39. type ModeInterface interface {
  40. Mode() string
  41. }
  42. type PatchHistoryRegister struct {
  43. Id primitive.ObjectID `bson:"_id" json:"-"`
  44. CreatedAt int64 `bson:"createdAt" json:"-"`
  45. CreatedBy string `bson:"createdBy" json:"-"`
  46. Parent string `bson:"parent" json:"-"`
  47. ApiTags []string `bson:"apiTags" json:"-"`
  48. }
  49. type EntityModel struct {
  50. Mode string `bson:"-" json:"-"`
  51. ApplicationVersion *string `bson:"appVersion,omitempty" json:"-"`
  52. Deleted *bool `bson:"deleted,omitempty" json:"-"`
  53. DeletedIn *int64 `bson:"deletedIn,omitempty" json:"-"`
  54. }
  55. // type DotNotation struct {
  56. // Rules map[string]interface{} `bson:",inline" json:"-"`
  57. // }
  58. // func (model *DotNotation) DotNotation() map[string]interface{} {
  59. // if model.Rules == nil {
  60. // model.Rules = map[string]interface{}{}
  61. // }
  62. // return model.Rules
  63. // }
  64. func UserIDString(ctx context.Context) (id string, err *errs.Error) {
  65. if user, ok := ctx.Values().Get("$user.ref").(map[string]interface{}); ok {
  66. id = user["id"].(primitive.ObjectID).Hex()
  67. return
  68. }
  69. err = errs.Internal().Details(&errs.Detail{
  70. Message: "Invalid user instance",
  71. })
  72. return
  73. }
  74. func (model *EntityModel) SetMode(mode string) {
  75. model.Mode = mode
  76. switch mode {
  77. case "create":
  78. model.ApplicationVersion = &BuildVersion
  79. deleted := false
  80. model.Deleted = &deleted
  81. case "update":
  82. if model.Deleted == nil {
  83. deleted := false
  84. model.Deleted = &deleted
  85. }
  86. case "patch":
  87. // if model.Deleted == nil {
  88. // deleted := false
  89. // model.Deleted = &deleted
  90. // }
  91. // case "delete":
  92. // case "undelete":
  93. }
  94. }
  95. func GetIDString(input interface{}) (string, *errs.Error) {
  96. if value, converted := input.(string); converted {
  97. return value, nil
  98. }
  99. if value, converted := input.(*primitive.ObjectID); converted {
  100. return value.Hex(), nil
  101. }
  102. if value, converted := input.(primitive.ObjectID); converted {
  103. return value.Hex(), nil
  104. }
  105. return "", errs.Internal().Details(&errs.Detail{
  106. Reason: fmt.Sprintf("Can't convert ID into string. Invalid type '%T", input),
  107. })
  108. }
  109. func NowUnix() int64 {
  110. return time.Now().Unix()
  111. }
  112. func GetUser(ctx context.Context) interface{} {
  113. return ctx.Values().Get("$user.ref")
  114. }
  115. func (model *EntityModel) SetDeleted(deleted bool) {
  116. var deletedIn = int64(0)
  117. model.Deleted = &deleted
  118. if *model.Deleted {
  119. deletedIn = time.Now().Unix()
  120. }
  121. model.DeletedIn = &deletedIn
  122. }
  123. type CorsOptions struct {
  124. ExposeHeaders []string
  125. AllowHeaders []string
  126. AllowMethods []string
  127. AllowOrigin []string
  128. }
  129. type GetManyResponse struct {
  130. ResultSizeEstimate int `json:"resultSizeEstimate"` // Estimativa do numero total de itens.
  131. NextPageToken string `json:"nextPageToken"` // Referência para a proxima pagina de resultados.
  132. Itens interface{} `json:"itens"` // Lista contento os elementos da resposta.
  133. }
  134. var (
  135. // ParamsFlag map[string]*ParamFlag
  136. CorsDefaultOptions = CorsOptions{
  137. AllowOrigin: []string{"*"},
  138. // AllowOrigin: []string{"http://localhost:4200"},
  139. AllowMethods: []string{"OPTIONS", "GET", "POST", "PUT", "DELETE", "PATCH"},
  140. AllowHeaders: []string{"Authorization", "Content-Type", "Origin", "Host", "x-api-build"},
  141. ExposeHeaders: []string{"X-total-count"},
  142. }
  143. BuildVersion = "0"
  144. ApiVersion = "0"
  145. // Armazena os mimes dos arquivos consultados
  146. // MimeCache = xmap.NewMS2S()
  147. replaceEmpty = regexp.MustCompile(`\s+`)
  148. // pageTokenRegex = regexp.MustCompile(`(?P<ids>\w+):(?P<idc>\w+):(?P<page>\d{1,6})`)
  149. pageTokenRegex = regexp.MustCompile(`(?P<idc>[\w-]+):(?P<count>\d+)`)
  150. replaceIndex = regexp.MustCompile(`\.\d+\.`)
  151. )
  152. func init() {
  153. // fmt.Println("Register validation functions")
  154. // err := Validator.RegisterValidation("req", func(f validator.FieldLevel) bool {
  155. // fmt.Println("Running req validation")
  156. // spew.Dump(f)
  157. // return true
  158. // })
  159. validator.RegisterValidator("requiredOnCreate", func(i interface{}, o interface{}, v *validator.ValidatorOption) error {
  160. if schema, ok := o.(ModeInterface); ok {
  161. fmt.Println("requiredOnCreate ->", schema.Mode())
  162. switch schema.Mode() {
  163. case "create":
  164. if i == nil {
  165. return fmt.Errorf("")
  166. }
  167. case "update":
  168. }
  169. }
  170. return nil
  171. })
  172. // Validator.RegisterValidation("req",
  173. // func(fl validator.FieldLevel) bool {
  174. // // func(v *validator.Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
  175. // // func(v *validator.Validate, param string) bool {
  176. // // return passwordRegex.MatchString(field.String())
  177. // })
  178. // if err != nil {
  179. // panic(err)
  180. // }
  181. }
  182. func Panic() {
  183. if err := recover(); err != nil {
  184. LogError(0, err.(error).Error())
  185. }
  186. }
  187. func Validate(i interface{}) *errs.Error {
  188. // if err := Validator.Struct(i); err != nil {
  189. // fmt.Println("VALIDATE", result, err)
  190. // spew.Dump(i)
  191. if errors, valid := validator.Struct(i); !valid {
  192. err := errs.InvalidArgument()
  193. // er := Error(ERR_INVALID_PARAM, "Invalid params")
  194. for _, e := range errors {
  195. err.Details(&errs.Detail{
  196. Dominio: "global",
  197. Reason: "invalidParameter",
  198. Message: e.Message,
  199. // Message: fmt.Sprintf("%+v", e.Message),
  200. // LocationType:,
  201. // Location :,
  202. })
  203. }
  204. // if _, ok := err.(*validator.InvalidValidationError); ok {
  205. // fmt.Println("INvalid")
  206. // er.LastDescription().Message = err.Error()
  207. // } else {
  208. // for _, err := range err.(validator.ValidationErrors) {
  209. // switch err.Tag() {
  210. // case "required":
  211. // }
  212. // er.Add(&ErrDescription{
  213. // Dominio: "global",
  214. // Reason: "invalidParameter",
  215. // Message: fmt.Sprintf("%+v", err),
  216. // // LocationType:,
  217. // // Location :,
  218. // })
  219. // // fmt.Println("1", err.Namespace())
  220. // // fmt.Println("2", err.Field())
  221. // // fmt.Println("3", err.StructNamespace()) // can differ when a custom TagNameFunc is registered or
  222. // // fmt.Println("4", err.StructField()) // by passing alt name to ReportError like below
  223. // // fmt.Println("5", err.Tag())
  224. // // fmt.Println("6", err.ActualTag())
  225. // // fmt.Println("7", err.Kind())
  226. // // fmt.Println("8", err.Type())
  227. // // fmt.Println("9", err.Value())
  228. // // fmt.Println("10", err.Param())
  229. // // fmt.Println("-------------")
  230. // }
  231. // }
  232. return err
  233. // from here you can create your own error messages in whatever language you wish
  234. }
  235. return nil
  236. }
  237. // ApiResponse é a estrutura padrão de respostas
  238. // Apenas os campos preenchidos serão retornados
  239. type ApiResponse struct {
  240. Entity interface{} `json:"entity,omitempty"`
  241. List interface{} `json:"list,omitempty"`
  242. NextPageToken string `json:"nextPageToken,omitempty"`
  243. ResultSizeEstimate int `json:"resultSizeEstimate,omitempty"`
  244. }
  245. // func ErroCtxHandler(ctx context.Context, err *errs.Error) {
  246. // if accept := ctx.GetHeader("Accept"); AcceptJson.Match([]byte(accept)) {
  247. // ctx.JSON(err)
  248. // } else {
  249. // ctx.ViewData("", err)
  250. // }
  251. // }
  252. func finalizeRequest(ctx context.Context, resp interface{}, err *errs.Error) {
  253. var (
  254. status = 200
  255. accept = ctx.Request().Header.Get("accept")
  256. types = strings.Split(accept, ",")
  257. )
  258. defer func() {
  259. ctx.StopExecution()
  260. if err != nil {
  261. ctx.Application().Logger().Error(err.Error())
  262. if description := err.LastDescription(); description != nil {
  263. err.Stack.Print()
  264. // ctx.Application().Logger().Error(fmt.Printf("%s\n%s\n", description.Reason, description.Message))
  265. }
  266. // ctx.Application().Logger().Error()
  267. spew.Dump(err)
  268. }
  269. fmt.Println("defer of finalizeRequest")
  270. if r := recover(); r != nil {
  271. fmt.Println("Recovered in f", r)
  272. }
  273. fmt.Println(string(ctx.Values().Serialize()))
  274. }()
  275. if err != nil {
  276. status = err.HttpStatus
  277. // fmt.Println(status, err.Message, "------------------------------------------\n")
  278. // spew.Dump(err)
  279. // debbug
  280. // err.Stack.Print()
  281. resp = err
  282. abortTransaction(ctx)
  283. // fmt.Println("------------------------------------------\n", status)
  284. // spew.Dump(err)
  285. // fmt.Println("------------------------------------------\n", status)
  286. }
  287. ctx.Values().Set("res", resp)
  288. ctx.Header("x-api-build", BuildVersion)
  289. // fmt.Println("error")
  290. // spew.Dump(resp)
  291. // spew.Dump(types)
  292. // spew.Dump(ctx.Request().Header)
  293. ctx.StatusCode(status)
  294. for _, mime := range types {
  295. switch mime {
  296. case "application/json":
  297. ctx.JSON(resp)
  298. return
  299. }
  300. }
  301. // default response case
  302. ctx.WriteString("")
  303. }
  304. // Call encapsula e trata os erros para cada requisição.
  305. func CallAction(id string, fn func(context.Context) (interface{}, *errs.Error)) func(context.Context) {
  306. return func(ctx context.Context) {
  307. var (
  308. err *errs.Error
  309. resp interface{}
  310. finalize = true
  311. )
  312. defer func() {
  313. if !ctx.IsStopped() {
  314. if _err := recover(); _err != nil {
  315. err = errs.Internal().Details(&errs.Detail{
  316. Message: "",
  317. Location: fmt.Sprintf("call.action.%s", id),
  318. LocationType: "application.pipe.resource.stage",
  319. Reason: _err.(error).Error(),
  320. })
  321. }
  322. if finalize {
  323. finalizeRequest(ctx, resp, err)
  324. }
  325. }
  326. }()
  327. fmt.Println("apply -> ", id)
  328. if resp, err = fn(ctx); err != nil {
  329. return
  330. }
  331. if !ctx.IsStopped() {
  332. if resp != nil {
  333. err = commitTransaction(ctx)
  334. } else {
  335. ctx.Next()
  336. finalize = false
  337. }
  338. }
  339. return
  340. }
  341. }
  342. func abortTransaction(ctx context.Context) (err *errs.Error) {
  343. return transactionHandler(ctx, "abort")
  344. }
  345. func commitTransaction(ctx context.Context) (err *errs.Error) {
  346. return transactionHandler(ctx, "commit")
  347. }
  348. func transactionHandler(ctx context.Context, action string) (err *errs.Error) {
  349. var (
  350. localErr error
  351. operation func() error
  352. )
  353. contextSession := GetSessionContext(ctx)
  354. if contextSession == nil {
  355. return
  356. }
  357. switch action {
  358. case "abort":
  359. operation = func() error { return contextSession.AbortTransaction(contextSession) }
  360. case "commit":
  361. operation = func() error { return contextSession.CommitTransaction(contextSession) }
  362. }
  363. defer func () {
  364. if localErr != nil {
  365. err = errs.Internal().Details(&errs.Detail{
  366. Message: localErr.Error(),
  367. })
  368. }
  369. }()
  370. try := 4
  371. for {
  372. if localErr = operation(); localErr == nil {
  373. fmt.Println(action, "executed ")
  374. return
  375. }
  376. if try == 0 {
  377. return
  378. }
  379. try--
  380. fmt.Println(action, "transaction error loop ")
  381. // time.Sleep(4 * time.Second)
  382. // retry operation when command contains TransientTransactionError
  383. // if cmdErr, ok := localErr.(mongo.CommandError); ok && cmdErr.HasErrorLabel("TransientTransactionError") {
  384. if cmdErr, ok := localErr.(mongo.CommandError); ok {
  385. fmt.Println(action, cmdErr)
  386. if cmdErr.HasErrorLabel("TransientTransactionError") {
  387. continue
  388. }
  389. }
  390. }
  391. }
  392. func ReadJson(ctx context.Context, entity interface{}) (err *errs.Error) {
  393. if err := ctx.ReadJSON(entity); err != nil {
  394. err = errs.DataCaps().Details(&errs.Detail{
  395. Message: err.Error(),
  396. })
  397. }
  398. return
  399. }
  400. func MgoSortBson(fields []string) *bson.M {
  401. order := bson.M{}
  402. for _, field := range fields {
  403. n := 1
  404. if field != "" {
  405. fmt.Printf("sort '%c'\n", field[0])
  406. switch field[0] {
  407. case '+':
  408. field = field[1:]
  409. case '-':
  410. n = -1
  411. field = field[1:]
  412. default:
  413. panic(fmt.Sprintf("Invalid sort field %s.", field))
  414. }
  415. }
  416. if field == "" {
  417. panic("Sort: empty field name")
  418. }
  419. field = string(replaceIndex.ReplaceAll([]byte(field), []byte(".")))
  420. order[field] = n
  421. }
  422. return &order
  423. }
  424. func MgoSort(ctx context.Context, field string) []string {
  425. result := []string{}
  426. if fields := Q(ctx, field, ""); fields != "" {
  427. sort := string(replaceEmpty.ReplaceAll([]byte(fields), []byte("")))
  428. result = strings.Split(sort, ",")
  429. }
  430. // return nil
  431. return result
  432. }
  433. func MgoFieldsCtx(ctx context.Context, field string) *bson.M {
  434. return MgoFields(Q(ctx, field, ""))
  435. }
  436. func MgoFields(fields string) (projection *bson.M) {
  437. // fmt.Printf("MgoFields '%s'\n", fields)
  438. if fields != "" {
  439. projection = &bson.M{}
  440. for _, v := range strings.Split(fields, ",") {
  441. (*projection)[v] = 1
  442. }
  443. // spew.Dump(projection)
  444. }
  445. return
  446. }
  447. func MgoQuery(ctx context.Context, field string) (*bson.M, *errs.Error) {
  448. return MgoQueryString(ctx, Q(ctx, field, ""))
  449. }
  450. func MgoQueryString(ctx context.Context, query string) (*bson.M, *errs.Error) {
  451. var (
  452. selector = make(bson.M)
  453. // id = "_id"
  454. err error
  455. )
  456. // Unmarshal json query if any
  457. if query != "" {
  458. if err = bson.UnmarshalExtJSON([]byte(query), true, &selector); err != nil {
  459. // return nil, Error(ERR_GENERAL, err.Error())
  460. return nil, errs.Internal().Details(&errs.Detail{
  461. Message: err.Error(),
  462. })
  463. }
  464. if query, err = url.QueryUnescape(query); err != nil {
  465. return nil, errs.Internal().Details(&errs.Detail{
  466. Message: err.Error(),
  467. })
  468. // return nil, Error(ERR_GENERAL, err.Error())
  469. }
  470. if err = json.Unmarshal([]byte(query), &selector); err != nil {
  471. // return nil, Error(ERR_GENERAL, err.Error())
  472. return nil, errs.Internal().Details(&errs.Detail{
  473. Message: err.Error(),
  474. })
  475. }
  476. // if selector, err = mejson.Unmarshal(selector); err != nil {
  477. // return nil, Error(ERR_GENERAL, err.Error())
  478. // }
  479. }
  480. // Transform string HexId to ObjectIdHex
  481. // if selid, _ := selector[id].(string); selid != "" {
  482. // if bson.IsObjectIdHex(selid) {
  483. // selector[id] = bson.ObjectIdHex(selid)
  484. // }
  485. // // else {
  486. // // selector[id] = selid
  487. // // }
  488. // }
  489. return &selector, nil
  490. }
  491. func DefaultCorsHandler() func(ctx context.Context) {
  492. return Cors(CorsDefaultOptions)
  493. }
  494. func Cors(opt CorsOptions) func(ctx context.Context) {
  495. return func(ctx context.Context) {
  496. ctx.Header("Access-Control-Allow-Credentials", "true")
  497. if len(opt.AllowOrigin) > 0 {
  498. // ctx.Header("Access-Control-Allow-Origin", strings.Join(opt.AllowOrigin, ","))
  499. // ctx.Header("Access-Control-Allow-Origin", "*")
  500. // ctx.Header("Origin", "*")
  501. ctx.Header("Access-Control-Allow-Origin", ctx.GetHeader("Origin"))
  502. }
  503. if len(opt.AllowMethods) > 0 {
  504. ctx.Header("Access-Control-Allow-Methods", strings.Join(opt.AllowMethods, ","))
  505. }
  506. if len(opt.AllowHeaders) > 0 {
  507. ctx.Header("Access-Control-Allow-Headers", strings.Join(opt.AllowHeaders, ","))
  508. }
  509. if len(opt.ExposeHeaders) > 0 {
  510. ctx.Header("Access-Control-Expose-Headers", strings.Join(opt.ExposeHeaders, ","))
  511. }
  512. ctx.Next()
  513. }
  514. }
  515. // Retorna um valor de um parametro no path da url.
  516. func P(ctx context.Context, name string, def string) string {
  517. val := ctx.Params().Get(name)
  518. if val == "" {
  519. val = def
  520. }
  521. return val
  522. }
  523. //Retorna um valor de um parametro da query. Ex: ?x=1
  524. func Q(ctx context.Context, name string, def string) string {
  525. val := ctx.URLParam(name)
  526. if val == "" {
  527. val = def
  528. }
  529. return val
  530. }
  531. //Retorna um valor de um parametro da query
  532. func QInt(ctx context.Context, name string, def int) int {
  533. val, e := strconv.Atoi(Q(ctx, name, ""))
  534. if e != nil {
  535. val = def
  536. }
  537. return val
  538. }
  539. // Retorna um valor de um parametro do post.
  540. func F(ctx context.Context, name string, def interface{}) interface{} {
  541. var val interface{}
  542. val = ctx.FormValue(name)
  543. if val == "" {
  544. val = def
  545. }
  546. return val
  547. }
  548. func LogError(code int, m string) {
  549. log("31", fmt.Sprintf("[ERROR| %d] %s", code, m))
  550. }
  551. func LogInfo(code int, m string) {
  552. log("34", fmt.Sprintf("[INFO| %d] %s", code, m))
  553. }
  554. func LogWarning(code int, m string) {
  555. log("35", fmt.Sprintf("[WARNING| %d] %s", code, m))
  556. }
  557. func log(color string, m string) {
  558. fmt.Printf("\x1b[%s;1m%s\x1b[0m\n", color, m)
  559. }
  560. // func ParseRequestTest(ctx context.Context) {
  561. // var (
  562. // err error
  563. // filter = &Filter{
  564. // MaxResults: QInt(ctx, "maxResults", 10),
  565. // }
  566. // oid primitive.ObjectID
  567. // )
  568. // // parse parameter of path
  569. // id := P(ctx, "userId", "")
  570. // if oid, err = primitive.ObjectIDFromHex(id); err != nil {
  571. // filter.UserId = oid
  572. // }
  573. // id = P(ctx, "id", "")
  574. // if oid, err = primitive.ObjectIDFromHex(id); err != nil {
  575. // filter.Id = oid
  576. // }
  577. // // filter.PageToken.Parse(Q(ctx, "nextPageToken", ""))
  578. // if filter.Query, err = MgoQuery(ctx, "q"); err != nil {
  579. // goto Error
  580. // }
  581. // filter.Format = Q(ctx, "format", "full")
  582. // filter.Sort = MgoSortBson(MgoSort(ctx, "sort"))
  583. // filter.Fields = MgoFieldsCtx(ctx, "fields")
  584. // Error:
  585. // if err != nil {
  586. // ErroCtxHandler(
  587. // ctx,
  588. // // Error(ERR_INVALID_PARAM, err.Error()),
  589. // errs.Internal().Details(&errs.Detail{
  590. // Message: err.Error(),
  591. // }),
  592. // )
  593. // return
  594. // }
  595. // ctx.Values().Set("$filter", filter)
  596. // ctx.Next()
  597. // }
  598. // func MapError(erro *errs.Error) *errs.Error {
  599. // if strings.Contains(erro.Message, "E11000") {
  600. // return errs.AlreadyExists().Details(&errs.Detail{
  601. // Message: "DUPLICATED_ITEM",
  602. // })
  603. // } else if strings.Contains(erro.Message, "no documents in result") {
  604. // return errs.Internal().Details(&errs.Detail{
  605. // Message: "NOT_FOUND",
  606. // })
  607. // }
  608. // return erro
  609. // }
  610. // type PageToken struct {
  611. // // StartID string
  612. // // CurrentID string
  613. // Cursor string
  614. // NewCursor string
  615. // Page int
  616. // Count int
  617. // }
  618. // // Encode cria um novo token formatado
  619. // func (p *PageToken) Encode() string {
  620. // out := ""
  621. // if p.NewCursor != "" {
  622. // out = base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s:%d", p.NewCursor, p.Count)))
  623. // }
  624. // return out
  625. // // return string([]byte(fmt.Sprintf("%s:%d", p.NewCursor, p.Count)))
  626. // }
  627. // // HasToken determina se a requisição apresenta um token de paginacao
  628. // func (p *PageToken) HasToken() bool {
  629. // return p.Cursor != ""
  630. // }
  631. // // func (p *PageToken) GetBsonID() bson.ObjectId {
  632. // // if !bson.IsObjectIdHex(p.ID) {
  633. // // return nil
  634. // // }
  635. // // return bson.ObjectIdHex(p.ID)
  636. // // }
  637. // func (p *PageToken) Parse(s string) error {
  638. // var (
  639. // decoded []byte
  640. // err error
  641. // )
  642. // if decoded, err = base64.StdEncoding.DecodeString(s); err != nil {
  643. // return err
  644. // }
  645. // match := pageTokenRegex.FindStringSubmatch(string(decoded))
  646. // if len(match) != 3 {
  647. // return fmt.Errorf("Invalid Page Token")
  648. // }
  649. // p.Cursor = match[1]
  650. // // p.Page, err = strconv.Atoi(match[2])
  651. // p.Count, err = strconv.Atoi(match[2])
  652. // return err
  653. // }
  654. // Layout aplica o path do layout
  655. // func Layout(ctx context.Context) {
  656. // ctx.ViewLayout(ViewScript(ctx, "layout/layout.html"))
  657. // ctx.Next()
  658. // }
  659. // // ViewScript devolve o path do arquivo de script a ser renderizaco
  660. // func ViewScript(ctx context.Context, filename string) string {
  661. // var (
  662. // base string
  663. // ok bool
  664. // )
  665. // domain := strings.Split(ctx.Request().Host, ":")[0]
  666. // if base, ok = TemplateDomainMap[domain]; !ok {
  667. // base = "default"
  668. // }
  669. // return base + "/" + filename
  670. // }
  671. // defer func() {
  672. // var (
  673. // erro *errs.Error
  674. // // ok bool
  675. // err error
  676. // )
  677. // if err = recover(); err != nil {
  678. // if erro, ok = err.(*errs.Error); !ok {
  679. // erro = Error(ERR_GENERAL, err.Error())
  680. // }
  681. // ErroCtxHandler(ctx, erro)
  682. // }
  683. // // ctx.Header("Accept", "application/json")
  684. // // spew.Dump(err)
  685. // }()
  686. // func CallAction(f func(context.Context, *ApiResponse) *errs.Error) func(ctx context.Context) {
  687. // return func(ctx context.Context) {
  688. // var (
  689. // err *errs.Error
  690. // response = &ApiResponse{}
  691. // )
  692. // if err = f(ctx, response); err != nil {
  693. // ErroCtxHandler(ctx, err)
  694. // return
  695. // }
  696. // ctx.JSON(response)
  697. // }
  698. // }
  699. // Verifica se existe alguma pagina para ser carragada.
  700. // func UpdateCursorResponse(models *Mongo, f *Filter, resp interface{}) bool {
  701. // count := f.PageToken.Count
  702. // // Se não foi encontrado nenhum registro
  703. // if count > 0 {
  704. // resp.ResultSizeEstimate = count
  705. // resp.NextPageToken = f.PageToken.Encode()
  706. // return true
  707. // }
  708. // return false
  709. // }