fielder.go 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289
  1. package rest
  2. import (
  3. "errors"
  4. "fmt"
  5. "reflect"
  6. "strings"
  7. "git.ali33.ru/fcg-xvii/go-tools/json"
  8. )
  9. type IRestFielder interface {
  10. RestFields(fieldName string, names ...any) (any, IErrorArgs)
  11. }
  12. // Field реализует ...
  13. type Field struct {
  14. Name string
  15. Names []any
  16. }
  17. type FieldList []*Field
  18. func (s FieldList) Field(name string) (*Field, bool) {
  19. for _, f := range s {
  20. if f.Name == name {
  21. return f, true
  22. }
  23. }
  24. return nil, false
  25. }
  26. // IFielder реализует интерфейс завершения формирования полей объекта в "ручном" режиме.
  27. // RestFields будет вызван после завершения автматического формирования полей объекта
  28. // result - массив с полями, сформированными автоматически, в него можно вносить правки
  29. // files - глобальный массив файловых дескрипторов, который будет передан в ответе клиенту
  30. type IFielderPost interface {
  31. RestFieldsPost(result json.Map, files map[string]IReadCloserLen, names FieldList)
  32. }
  33. func fieldsDefault(t reflect.Type) (res []any) {
  34. for i := 0; i < t.NumField(); i++ {
  35. fType := t.Field(i)
  36. // проверяем тег, если он есть
  37. tag := fType.Tag.Get("rest")
  38. if len(tag) > 0 && (strings.Contains(tag, "default") || strings.Contains(tag, "fixed")) {
  39. res = append(res, fType.Name)
  40. }
  41. }
  42. return
  43. }
  44. func fieldsFixed(t reflect.Type) (res []any) {
  45. for i := 0; i < t.NumField(); i++ {
  46. fType := t.Field(i)
  47. // проверяем тег, если он есть
  48. tag := fType.Tag.Get("rest")
  49. if len(tag) > 0 && strings.Contains(tag, "fixed") {
  50. res = append(res, fType.Name)
  51. }
  52. }
  53. return
  54. }
  55. func parseName(val reflect.Value) (res *Field, err error) {
  56. switch val.Kind() {
  57. case reflect.String:
  58. return &Field{
  59. Name: val.String(),
  60. }, nil
  61. case reflect.Map:
  62. jm := make(json.Map)
  63. jmVal := reflect.ValueOf(jm)
  64. if !val.CanConvert(jmVal.Type()) {
  65. err = fmt.Errorf("expected map[string]any")
  66. }
  67. jm = val.Convert(jmVal.Type()).Interface().(json.Map)
  68. name := jm.String("name", "")
  69. if len(name) == 0 {
  70. err = fmt.Errorf("name is empty")
  71. return
  72. }
  73. fields := jm.Slice("fields", nil)
  74. res = &Field{
  75. Name: name,
  76. Names: fields,
  77. }
  78. return
  79. default:
  80. err = fmt.Errorf("invalid request %s", val.Kind())
  81. }
  82. return
  83. }
  84. func fieldVal(val reflect.Value, fieldName string, files RequestFiles, names ...any) (res reflect.Value, err IErrorArgs) {
  85. switch val.Kind() {
  86. case reflect.Ptr, reflect.Interface:
  87. return fieldVal(val.Elem(), fieldName, files, names...)
  88. case reflect.Struct:
  89. // check fielder interface
  90. if f, check := val.Interface().(IRestFielder); check {
  91. rVal, err := f.RestFields(fieldName, names...)
  92. if err != nil {
  93. return reflect.Value{}, err
  94. }
  95. return reflect.ValueOf(rVal), nil
  96. }
  97. // check fieler addr
  98. if val.CanAddr() {
  99. // check fielder interface
  100. if f, check := val.Addr().Interface().(IRestFielder); check {
  101. rVal, err := f.RestFields(fieldName, names...)
  102. if err != nil {
  103. return reflect.Value{}, err
  104. }
  105. return reflect.ValueOf(rVal), nil
  106. }
  107. }
  108. // parse struct public fields
  109. if len(names) == 0 {
  110. names = fieldsDefault(val.Type())
  111. }
  112. jm := json.Map{}
  113. var fields FieldList
  114. addFieldVal := func(name any) bool {
  115. rField, rErr := parseName(reflect.ValueOf(name))
  116. if rErr != nil {
  117. message := fmt.Sprintf("%v: %v", name, err)
  118. err = ErrorFiled(fieldName, message)
  119. return false
  120. }
  121. fields = append(fields, rField)
  122. var field reflect.Value
  123. for i := 0; i < val.NumField(); i++ {
  124. f := val.Type().Field(i)
  125. if f.Name == rField.Name {
  126. tag := f.Tag.Get("rest")
  127. if len(tag) > 0 && strings.Contains(tag, "ignore") {
  128. return true
  129. }
  130. field = val.Field(i)
  131. break
  132. }
  133. }
  134. if !field.IsValid() {
  135. err = ErrorFiled(rField.Name, "field is not found")
  136. return false
  137. }
  138. var fVal reflect.Value
  139. if fVal, err = fieldVal(
  140. field,
  141. fmt.Sprintf("%v.%v", fieldName, rField.Name),
  142. files,
  143. rField.Names...,
  144. ); err != nil {
  145. return false
  146. }
  147. jm[rField.Name] = fVal.Interface()
  148. return true
  149. }
  150. for _, name := range names {
  151. if !addFieldVal(name) {
  152. return
  153. }
  154. }
  155. // fields fixed
  156. fFixed := fieldsFixed(val.Type())
  157. for _, fixed := range fFixed {
  158. if !jm.KeyExists(fixed.(string)) {
  159. addFieldVal(fixed)
  160. }
  161. }
  162. // post (когда результирующий объект уже сформирован)
  163. if fielder, check := val.Interface().(IFielderPost); check {
  164. fielder.RestFieldsPost(jm, files, fields)
  165. } else if val.CanAddr() {
  166. if fielder, check := val.Addr().Interface().(IFielderPost); check {
  167. fielder.RestFieldsPost(jm, files, fields)
  168. }
  169. }
  170. res = reflect.ValueOf(jm)
  171. return
  172. case reflect.Slice:
  173. sl := make([]any, val.Len())
  174. for i := 0; i < val.Len(); i++ {
  175. fName := fmt.Sprintf("%v[%v]", fieldName, i)
  176. var rVal reflect.Value
  177. rVal, err = fieldVal(
  178. val.Index(i),
  179. fName,
  180. files,
  181. names...,
  182. )
  183. if err != nil {
  184. return
  185. }
  186. sl[i] = rVal.Interface()
  187. }
  188. res = reflect.ValueOf(sl)
  189. return
  190. case reflect.Map:
  191. res = reflect.MakeMap(val.Type())
  192. for _, key := range val.MapKeys() {
  193. fName := fmt.Sprintf("%v[%v]", fieldName, key.String())
  194. var rVal reflect.Value
  195. iVal := val.MapIndex(key)
  196. rVal, err = fieldVal(iVal, fName, files)
  197. if err != nil {
  198. return
  199. }
  200. res.SetMapIndex(key, rVal)
  201. }
  202. return
  203. default:
  204. res = val
  205. return
  206. }
  207. }
  208. func FieldsAny(obj any, files RequestFiles, names ...any) (any, IErrorArgs) {
  209. sVal := reflect.ValueOf(obj)
  210. rVal, err := fieldVal(sVal.Elem(), "", files, names...)
  211. if err != nil {
  212. return nil, err
  213. }
  214. return rVal.Interface(), nil
  215. }
  216. // Fields позволяет получить значения объекта в json
  217. func Fields(obj any, files RequestFiles, names ...any) (json.Map, IErrorArgs) {
  218. sVal := reflect.ValueOf(obj)
  219. rVal, err := fieldVal(sVal.Elem(), "", files, names...)
  220. if err != nil {
  221. return nil, err
  222. }
  223. res, check := rVal.Interface().(json.Map)
  224. if !check {
  225. return nil, ErrorMessage("ErrFields", "Empty object")
  226. }
  227. return res, nil
  228. }
  229. type FieldNamesList []string
  230. func (s FieldNamesList) Exists(name string) bool {
  231. for _, fName := range s {
  232. if fName == name {
  233. return true
  234. }
  235. }
  236. return false
  237. }
  238. // GetStructFields возвращает список полей структуры
  239. func FieldNames(s any) (FieldNamesList, error) {
  240. // Получаем тип и проверяем, что это структура
  241. t := reflect.TypeOf(s)
  242. if t.Kind() == reflect.Ptr || t.Kind() == reflect.Interface {
  243. return FieldNames(reflect.ValueOf(s).Elem().Interface())
  244. } else if t.Kind() != reflect.Struct {
  245. return nil, errors.New("expected struct last type")
  246. }
  247. // Создаем срез для хранения имен полей
  248. var fields []string
  249. // Перебираем поля структуры
  250. for i := 0; i < t.NumField(); i++ {
  251. field := t.Field(i)
  252. fields = append(fields, field.Name)
  253. }
  254. return fields, nil
  255. }
  256. /////////////////////////////////////////////
  257. func OutFileds(req IRequestIn, obj any, files RequestFiles, names ...any) IRequestOut {
  258. m, err := Fields(obj, files, names...)
  259. if err != nil {
  260. return req.OutError(err)
  261. }
  262. return req.OutSuccess(m, files)
  263. }
  264. func OutFieldsReq(req IRequestIn, obj any, files RequestFiles, names ...any) IRequestOut {
  265. if len(names) == 0 {
  266. names = req.RData().Slice("fields", nil)
  267. }
  268. return OutFileds(req, obj, files, names...)
  269. }