errs.go 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551
  1. package errs
  2. import (
  3. "fmt"
  4. "runtime"
  5. )
  6. type ErroNil *Error
  7. type Map map[string]interface{}
  8. type Error struct {
  9. HttpStatus int `json:"httpStatus"`
  10. CodeText string `json:"codetext"`
  11. Message string `json:"message"`
  12. Stack *ErrorStack `json:"stack,omitempty"`
  13. Errors []*Detail `json:"erros,omitempty"`
  14. }
  15. type Detail struct {
  16. Dominio string `json:"dominio,omitempty"`
  17. Reason string `json:"reason,omitempty"`
  18. Message string `json:"message,omitempty"`
  19. LocationType string `json:"locationType,omitempty"`
  20. Location string `json:"location,omitempty"`
  21. }
  22. type ErrorMapFunction func(error) (err *Error)
  23. // type ErrorMapFunction func(error) (err error, replaced bool)
  24. var (
  25. errorMapFunction = map[string]ErrorMapFunction{}
  26. )
  27. func RegisterMapErrorFunction(id string, fn ErrorMapFunction) {
  28. errorMapFunction[id] = fn
  29. }
  30. // Adiciona uma descricao ao erro
  31. // func (e *Erro) Add(desc *Detail) *Erro {
  32. // e.Errors = append(e.Errors, desc)
  33. // return e
  34. // }
  35. func (e *Error) Details(desc *Detail) *Error {
  36. e.Errors = append(e.Errors, desc)
  37. return e
  38. }
  39. // Retorna a ultima descricao adicionada
  40. func (e *Error) LastDescription() *Detail {
  41. size := len(e.Errors)
  42. if size > 0 {
  43. return e.Errors[size-1]
  44. }
  45. return nil
  46. }
  47. // Error retorna a mensagem de erro principal
  48. func (e *Error) Error() string {
  49. return e.Message
  50. }
  51. // The operation was cancelled, typically by the caller.
  52. //
  53. // HTTP Mapping: 499 Client Closed Request
  54. func Cancelled() *Error {
  55. return errorHandler(&Error{
  56. HttpStatus: 499,
  57. CodeText: "client_closed_request",
  58. Message: `Solicitação cancelada pelo cliente.`,
  59. })
  60. }
  61. // Unknown error. For example, this error may be returned when
  62. // a `Status` value received from another address space belongs to
  63. // an error space that is not known in this address space. Also
  64. // errors raised by APIs that do not return enough error information
  65. // may be converted to this error.
  66. //
  67. // HTTP Mapping: 500 Internal Server Error
  68. func Unknown() *Error {
  69. return errorHandler(&Error{
  70. HttpStatus: 500,
  71. CodeText: "internal_server_error",
  72. Message: "",
  73. })
  74. }
  75. // The client specified an invalid argument. Note that this differs
  76. // from `FAILED_PRECONDITION`. `INVALID_ARGUMENT` indicates arguments
  77. // that are problematic regardless of the state of the system
  78. // (e.g., a malformed file name).
  79. //
  80. // HTTP Mapping: 400 Bad Request
  81. func InvalidArgument() *Error {
  82. return errorHandler(&Error{
  83. HttpStatus: 400,
  84. CodeText: "bad_request",
  85. Message: "O campo de solicitação xyz é xxx, mas o esperado é [yyy, zzz].",
  86. })
  87. }
  88. // The deadline expired before the operation could complete. For operations
  89. // that change the state of the system, this error may be returned
  90. // even if the operation has completed successfully. For example, a
  91. // successful response from a server could have been delayed long
  92. // enough for the deadline to expire.
  93. //
  94. // HTTP Mapping: 504 Gateway Timeout
  95. func DeadlineExceeded() *Error {
  96. return errorHandler(&Error{
  97. HttpStatus: 504,
  98. CodeText: "gateway_timeout",
  99. Message: "",
  100. })
  101. }
  102. // Some requested entity (e.g., file or directory) was not found.
  103. //
  104. // Note to server developers: if a request is denied for an entire class
  105. // of users, such as gradual feature rollout or undocumented whitelist,
  106. // `NOT_FOUND` may be used. If a request is denied for some users within
  107. // a class of users, such as user-based access control, `PERMISSION_DENIED`
  108. // must be used.
  109. //
  110. // HTTP Mapping: 404 Not Found
  111. func NotFound() *Error {
  112. return errorHandler(&Error{
  113. HttpStatus: 404,
  114. CodeText: "not_found",
  115. Message: `O recurso "xxx" não foi encontrado.`,
  116. })
  117. }
  118. // The entity that a client attempted to create (e.g., file or directory)
  119. // already exists.
  120. //
  121. // HTTP Mapping: 409 Conflict
  122. func AlreadyExists() *Error {
  123. return errorHandler(&Error{
  124. HttpStatus: 409,
  125. CodeText: "conflict",
  126. Message: `O recurso já existe.`,
  127. })
  128. }
  129. // The caller does not have permission to execute the specified
  130. // operation. `PERMISSION_DENIED` must not be used for rejections
  131. // caused by exhausting some resource (use `RESOURCE_EXHAUSTED`
  132. // instead for those errors). `PERMISSION_DENIED` must not be
  133. // used if the caller can not be identified (use `UNAUTHENTICATED`
  134. // instead for those errors). This error code does not imply the
  135. // request is valid or the requested entity exists or satisfies
  136. // other pre-conditions.
  137. //
  138. // HTTP Mapping: 403 Forbidden
  139. func PermissionDenied() *Error {
  140. return errorHandler(&Error{
  141. HttpStatus: 403,
  142. CodeText: "forbidden",
  143. Message: `Permissão "xxx" negada no arquivo "yyy".`,
  144. })
  145. }
  146. // The request does not have valid authentication credentials for the
  147. // operation.
  148. //
  149. // HTTP Mapping: 401 Unauthorized
  150. func Unauthenticated() *Error {
  151. return errorHandler(&Error{
  152. HttpStatus: 401,
  153. CodeText: "unauthorized",
  154. Message: `Credenciais de autenticação inválidas.`,
  155. })
  156. }
  157. // Some resource has been exhausted, perhaps a per-user quota, or
  158. // perhaps the entire file system is out of space.
  159. //
  160. // HTTP Mapping: 429 Too Many Requests
  161. func ResourceExhausted() *Error {
  162. return errorHandler(&Error{
  163. HttpStatus: 429,
  164. CodeText: "too_many_requests",
  165. Message: `Limite de cota "xxx" excedido.`,
  166. })
  167. }
  168. // The operation was rejected because the system is not in a state
  169. // required for the operation's execution. For example, the directory
  170. // to be deleted is non-empty, an rmdir operation is applied to
  171. // a non-directory, etc.
  172. //
  173. // Service implementors can use the following guidelines to decide
  174. // between `FAILED_PRECONDITION`, `ABORTED`, and `UNAVAILABLE`:
  175. // (a) Use `UNAVAILABLE` if the client can retry just the failing call.
  176. // (b) Use `ABORTED` if the client should retry at a higher level
  177. // (e.g., when a client-specified test-and-set fails, indicating the
  178. // client should restart a read-modify-write sequence).
  179. // (c) Use `FAILED_PRECONDITION` if the client should not retry until
  180. // the system state has been explicitly fixed. E.g., if an "rmdir"
  181. // fails because the directory is non-empty, `FAILED_PRECONDITION`
  182. // should be returned since the client should not retry unless
  183. // the files are deleted from the directory.
  184. //
  185. // HTTP Mapping: 400 Bad Request
  186. func FailedPrecondition() *Error {
  187. return errorHandler(&Error{
  188. HttpStatus: 400,
  189. CodeText: "bad_request",
  190. Message: `O recurso xxx é um diretório que não está vazio, portanto, não pode ser excluído.`,
  191. })
  192. }
  193. // The operation was aborted, typically due to a concurrency issue such as
  194. // a sequencer check failure or transaction abort.
  195. //
  196. // See the guidelines above for deciding between `FAILED_PRECONDITION`,
  197. // `ABORTED`, and `UNAVAILABLE`.
  198. //
  199. // HTTP Mapping: 409 Conflict
  200. func Aborted() *Error {
  201. return errorHandler(&Error{
  202. HttpStatus: 409,
  203. CodeText: "conflict",
  204. Message: `Não foi possível adquirir o bloqueio no recurso "xxx".`,
  205. })
  206. }
  207. // The operation was attempted past the valid range. E.g., seeking or
  208. // reading past end-of-file.
  209. //
  210. // Unlike `INVALID_ARGUMENT`, this error indicates a problem that may
  211. // be fixed if the system state changes. For example, a 32-bit file
  212. // system will generate `INVALID_ARGUMENT` if asked to read at an
  213. // offset that is not in the range [0,2^32-1], but it will generate
  214. // `OUT_OF_RANGE` if asked to read from an offset past the current
  215. // file size.
  216. //
  217. // There is a fair bit of overlap between `FAILED_PRECONDITION` and
  218. // `OUT_OF_RANGE`. We recommend using `OUT_OF_RANGE` (the more specific
  219. // error) when it applies so that callers who are iterating through
  220. // a space can easily look for an `OUT_OF_RANGE` error to detect when
  221. // they are done.
  222. //
  223. // HTTP Mapping: 400 Bad Request
  224. func OutOfRange() *Error {
  225. return errorHandler(&Error{
  226. HttpStatus: 400,
  227. CodeText: "bad_request",
  228. Message: `A "idade" do parâmetro está fora do intervalo [0, 125].`,
  229. })
  230. }
  231. func HTTPVersionNotSupported() *Error {
  232. return errorHandler(&Error{
  233. HttpStatus: 400,
  234. CodeText: "http_version_not_supported",
  235. Message: `The server doesn’t support the major HTTP version the client used to make the request.`,
  236. })
  237. }
  238. // The operation is not implemented or is not supported/enabled in this
  239. // service.
  240. //
  241. // HTTP Mapping: 501 Not Implemented
  242. func Unimplemented() *Error {
  243. return errorHandler(&Error{
  244. HttpStatus: 501,
  245. CodeText: "not_implemented",
  246. Message: `Método "xxx" não implementado.`,
  247. })
  248. }
  249. // Internal errors. This means that some invariants expected by the
  250. // underlying system have been broken. This error code is reserved
  251. // for serious errors.
  252. //
  253. // HTTP Mapping: 500 Internal Server Error
  254. func Internal() *Error {
  255. return errorHandler(&Error{
  256. HttpStatus: 500,
  257. CodeText: "internal_server_error",
  258. Message: `Error interno.`,
  259. })
  260. }
  261. // The service is currently unavailable. This is most likely a
  262. // transient condition, which can be corrected by retrying with
  263. // a backoff.
  264. //
  265. // See the guidelines above for deciding between `FAILED_PRECONDITION`,
  266. // `ABORTED`, and `UNAVAILABLE`.
  267. //
  268. // HTTP Mapping: 503 Service Unavailable
  269. func Unavaliable() *Error {
  270. return errorHandler(&Error{
  271. HttpStatus: 503,
  272. CodeText: "service_unavailable",
  273. Message: "Serviço indisponivel.",
  274. })
  275. }
  276. // Unrecoverable data loss or corruption.
  277. //
  278. // HTTP Mapping: 500 Internal Server Error
  279. func DataCaps() *Error {
  280. return errorHandler(&Error{
  281. HttpStatus: 500,
  282. CodeText: "internal_server_error",
  283. Message: `Error interno.`,
  284. })
  285. }
  286. func errorHandler(err *Error) *Error {
  287. err.Stack = Trace()
  288. return err
  289. }
  290. // }
  291. // func Error(code int, m string) *Error {
  292. // LogError(code, m)
  293. // e := ErrosList[code]
  294. // if m != "" {
  295. // e.Message = m
  296. // }
  297. // e.Details(&Detail{
  298. // Dominio: "global",
  299. // Message: m,
  300. // })
  301. // return &e
  302. // }
  303. // func FullError(code int, err *Detail) *Error {
  304. // // _, fn, line, _ := runtime.Caller(1
  305. // // LogError(code, fmt.Sprintf("%s:%d - %s", fn, line, err.Message))
  306. // e := ErrosList[code]
  307. // e.Message = err.Message
  308. // e.Stack = Trace()
  309. // e.Details(err)
  310. // return &e
  311. // }
  312. type ErrorStack struct {
  313. Frames []runtime.Frame
  314. }
  315. func (stack *ErrorStack) Print() {
  316. for _, f := range stack.Frames {
  317. fmt.Printf("%s\n\t%s:%d\n", f.Function, f.File, f.Line)
  318. }
  319. }
  320. func Trace() (stack *ErrorStack) {
  321. stack = &ErrorStack{}
  322. pc := make([]uintptr, 20)
  323. n := runtime.Callers(2, pc)
  324. if n == 0 {
  325. // No pcs available. Stop now.
  326. // This can happen if the first argument to runtime.Callers is large.
  327. return
  328. }
  329. pc = pc[:n] // pass only valid pcs to runtime.CallersFrames
  330. frames := runtime.CallersFrames(pc)
  331. // Loop to get frames.
  332. // A fixed number of pcs can expand to an indefinite number of Frames.
  333. for {
  334. frame, more := frames.Next()
  335. stack.Frames = append(stack.Frames, frame)
  336. // To keep this example's output stable
  337. // even if there are changes in the testing package,
  338. // stop unwinding when we leave package runtime.
  339. // if strings.Contains(frame.Function, "main.main") {
  340. // break
  341. // }
  342. // spew.Dump(frame)
  343. if !more {
  344. break
  345. }
  346. }
  347. return
  348. }
  349. func FromError(source error) (err *Error) {
  350. for _, fn := range errorMapFunction {
  351. if err = fn(source); err != nil {
  352. return
  353. }
  354. }
  355. err = Internal().Details(&Detail{
  356. Message: source.Error(),
  357. })
  358. return
  359. }
  360. // 400 invalidParameter Indica que um parâmetro de solicitação tem um valor inválido. Os campos locationType e location na resposta de erro fornecem informações sobre qual valor era inválido. Não tente novamente sem corrigir o problema. Você precisa fornecer um valor válido para o parâmetro especificado na resposta de erro.
  361. // 400 badRequest Indica que a consulta era inválida. Por exemplo, o ID pai estava ausente ou a combinação de dimensões ou métricas solicitada não era válida. Não tente novamente sem corrigir o problema. Você precisa fazer alterações na consulta da API para que ela funcione.
  362. // 401 invalidCredentials Indica que o token de autenticação é inválido ou expirou. Não tente novamente sem corrigir o problema. Você precisa receber um novo token de autenticação.
  363. // 403 insufficientPermissions Indica que o usuário não tem permissões suficientes para a entidade especificada na consulta. Não tente novamente sem corrigir o problema. Você precisa receber permissões suficientes para executar a operação na entidade especificada.
  364. // 403 dailyLimitExceeded Indica que o usuário ultrapassou a cota diária [por projeto ou vista da propriedade (perfil)]. Não tente novamente sem corrigir o problema. Você esgotou sua cota diária. Consulte Limites e cotas da API.
  365. // 403 usageLimits.userRateLimitExceededUnreg Indica que o aplicativo precisa ser registrado no console de APIs do Google. Não tente novamente sem corrigir o problema. Você precisa se registrar no console de APIs para receber a cota completa da API.
  366. // 403 userRateLimitExceeded Indica que o limite da taxa de usuário foi ultrapassado. O limite de taxa máximo é de 10 qps por endereço IP. O valor padrão definido no console de APIs do Google é 1 qps por endereço IP. Você pode aumentar esse limite no console de APIs do Google para no máximo 10 qps. Tente novamente usando backoff exponencial. Você precisa diminuir a taxa em que envia as solicitações.
  367. // 403 rateLimitExceeded Indica que os limites de taxa global ou geral do projeto foram excedidos. Tente novamente usando backoff exponencial. Você precisa diminuir a taxa em que envia as solicitações.
  368. // 403 quotaExceeded Indica que o limite de 10 solicitações simultâneas por vista da propriedade (perfil) na API de relatórios principais foi atingido. Tente novamente usando backoff exponencial. Você precisa aguardar até que pelo menos uma solicitação em andamento para essa Vista (perfil) seja concluída.
  369. // ERR_BAD_REQUEST: Erro{
  370. // HttpStatus: 400,
  371. // CodeText: "bad_request",
  372. // Message: "",
  373. // },
  374. // ERR_INVALID_PARAM: Erro{
  375. // HttpStatus: 400,
  376. // CodeText: "invalid_param",
  377. // Message: "",
  378. // },
  379. // ERR_INVALID_PARAM_VALUE: Erro{
  380. // HttpStatus: 400,
  381. // CodeText: "invalid_param_value",
  382. // Message: "",
  383. // },
  384. // ERR_INVALID_CREDENTIAL: Erro{
  385. // HttpStatus: 401,
  386. // CodeText: "invalid_credential",
  387. // Message: "Invalid Credentials",
  388. // },
  389. // ERR_NOT_FOUND: Erro{
  390. // HttpStatus: 404,
  391. // CodeText: "not_found",
  392. // Message: "Recurso não existe",
  393. // },
  394. // ERR_PERSIST: Erro{
  395. // HttpStatus: 500,
  396. // CodeText: "persist_error",
  397. // Message: "Não foi possivel salvar as alterações",
  398. // },
  399. // ERR_CONFLICT: Erro{
  400. // HttpStatus: 409,
  401. // CodeText: "conflict",
  402. // Message: "A operação falhou porque o item é referenciado por outras.",
  403. // },
  404. // ERR_GENERAL: Erro{
  405. // HttpStatus: 500,
  406. // CodeText: "general",
  407. // Message: "Parece que algo deu errado. Nós pedimos desculpas. Você pode voltar para a página principal",
  408. // },
  409. // ERR_EXPIRED: Erro{
  410. // HttpStatus: 500,
  411. // CodeText: "expired",
  412. // Message: "Parece que o recurso não esta mais disponível",
  413. // },
  414. // const (
  415. // ERR_NOT_FOUND int = iota
  416. // ERR_GENERAL
  417. // ERR_PERSIST
  418. // ERR_INVALID_CREDENTIAL
  419. // ERR_BAD_REQUEST
  420. // ERR_INVALID_PARAM
  421. // ERR_INVALID_PARAM_VALUE
  422. // ERR_EXPIRED
  423. // ERR_NOT_MODIFIED
  424. // ERR_TEMPORARY_REDIRECT
  425. // ERR_UNAUTHORIZED
  426. // ERR_PAYMENT_REQUIRED
  427. // ERR_FORBIDDEN
  428. // ERR_METHOD_NOT_ALLOWED
  429. // ERR_CONFLICT
  430. // ERR_TOO_MANY_REQUESTS
  431. // ERR_NOT_IMPLEMENTED
  432. // ERR_SERVICE_UNAVAILABLE
  433. // )
  434. // Error cria uma instancia de um erro
  435. // code int assume:
  436. // ERR_NOT_FOUND int = 0
  437. // ERR_GENERAL int = 1
  438. // ERR_PERSIST int = 2
  439. // ERR_INVALID_CREDENTIAL int = 3
  440. // ERR_BAD_REQUEST int = 4
  441. // ERR_INVALID_PARAM int = 5
  442. // ERR_EXPIRED int = 6
  443. // func Errorf(code int, m string, args ...interface{}) *Erro {
  444. // LogError(code, m)
  445. // m = fmt.Sprintf(m, args...)
  446. // e := ErrosList[code]
  447. // if m != "" {
  448. // e.Message = m
  449. // }
  450. // e.Add(&Detail{
  451. // Dominio: "global",
  452. // Message: m,
  453. // })
  454. // return &e
  455. // }
  456. // func Falha(ctx context.Context, code int, m string, dev Map) {
  457. // // fmt.Println("CodeText:[", code, "]", m, dev);
  458. // // ctx.StopExecution()
  459. // base := ErrosList[code]
  460. // base.Development = Map{}
  461. // if m != "" {
  462. // base.Message = m
  463. // }
  464. // if dev != nil {
  465. // base.Development = dev
  466. // }
  467. // accept := ctx.GetHeader("Accept")
  468. // ctx.StatusCode(base.Code)
  469. // //spew.Dump(base)
  470. // if base.Error == "not_found" {
  471. // url := ctx.Host() + ctx.RequestPath(true)
  472. // base.Development["url"] = fmt.Sprintf("A url '%s' não foi encontrada.", url)
  473. // }
  474. // if accept == "application/json" {
  475. // ctx.JSON(base)
  476. // } else {
  477. // ctx.ViewData("", base)
  478. // // ctx.View(ViewScript(ctx, "error.html"))
  479. // }
  480. // ctx.StopExecution()
  481. // }