server
/
new-api
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
293 Commits
2 Branches
106 MiB
 
 
 
Tree: c67d8c409e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c67d8c409e'
${ noResults }
new-api/service/asset_chinamobile.go

740 lines
24 KiB
Raw Blame History 

  1. package service

  2. 

  3. import (

  4. 	"context"

  5. 	"errors"

  6. 	"fmt"

  7. 	"net/http"

  8. 	"net/url"

  9. 	"os"

  10. 	"strings"

  11. 

  12. 	"github.com/QuantumNous/new-api/common"

  13. 	"github.com/QuantumNous/new-api/model"

  14. 	cmerrs "gitlab.ecloud.com/ecloud/ecloudsdkcore/errs"

  15. 	cmmodel "gitlab.ecloud.com/ecloud/ecloudsdkmaas/model"

  16. )

  17. 

  18. const defaultChinaMobileAssetBaseURL = "https://ecloud.10086.cn"

  19. const defaultChinaMobileAssetPoolID = "CIDC-CORE-00"

  20. const chinaMobileAssetAKEnv = "CHINAMOBILE_ASSET_AK"

  21. const chinaMobileAssetSKEnv = "CHINAMOBILE_ASSET_SK"

  22. const chinaMobileAssetPoolIDEnv = "CHINAMOBILE_ASSET_POOL_ID"

  23. 

  24. type ChinaMobileAssetAdapter struct {

  25. 	newClient func(credential chinaMobileAssetCredential) chinaMobileAssetSDKClient

  26. }

  27. 

  28. func NewChinaMobileAssetAdapter() AssetAdapter {

  29. 	return &ChinaMobileAssetAdapter{newClient: newChinaMobileAssetSDKClient}

  30. }

  31. 

  32. func (a *ChinaMobileAssetAdapter) Name() string {

  33. 	return "chinamobile_asset"

  34. }

  35. 

  36. func (a *ChinaMobileAssetAdapter) Supports(operation AssetOperation) bool {

  37. 	switch operation {

  38. 	case AssetOperationAssetCreate,

  39. 		AssetOperationAssetList,

  40. 		AssetOperationAssetGet,

  41. 		AssetOperationAssetUpdate,

  42. 		AssetOperationAssetDelete,

  43. 		AssetOperationAssetGroupCreate,

  44. 		AssetOperationAssetGroupList,

  45. 		AssetOperationAssetGroupGet,

  46. 		AssetOperationAssetGroupUpdate,

  47. 		AssetOperationAssetGroupDelete:

  48. 		return true

  49. 	default:

  50. 		return false

  51. 	}

  52. }

  53. 

  54. func (a *ChinaMobileAssetAdapter) DoAssetRequest(ctx context.Context, channel *model.Channel, req AssetRequest) (*AssetUpstreamResponse, *AssetError) {

  55. 	if !a.Supports(req.Action.Operation) {

  56. 		return nil, newAssetError(AssetErrorOperationNotSupported, fmt.Sprintf("asset operation %s is not supported", req.Action.Operation), http.StatusBadRequest)

  57. 	}

  58. 	if err := validateChinaMobileCompatibility(req.Body); err != nil {

  59. 		return nil, err

  60. 	}

  61. 	if err := validateChinaMobileAssetRequest(req); err != nil {

  62. 		return nil, err

  63. 	}

  64. 

  65. 	credential, err := chinaMobileAssetCredentialFromEnv()

  66. 	if err != nil {

  67. 		return nil, newAssetError(AssetErrorInvalidRequest, err.Error(), http.StatusBadRequest)

  68. 	}

  69. 	newClient := a.newClient

  70. 	if newClient == nil {

  71. 		newClient = newChinaMobileAssetSDKClient

  72. 	}

  73. 	result, err := callChinaMobileAssetSDK(ctx, newClient(credential), req)

  74. 	if err != nil {

  75. 		if assetErr := classifyChinaMobileAssetSDKError(err); assetErr != nil {

  76. 			return nil, assetErr

  77. 		}

  78. 		return nil, newAssetError(AssetErrorUpstream, err.Error(), http.StatusBadGateway)

  79. 	}

  80. 	normalized, assetErr := normalizeChinaMobileAssetSDKResponse(req.Action, req.Version, result)

  81. 	if assetErr != nil {

  82. 		return nil, assetErr

  83. 	}

  84. 	return &AssetUpstreamResponse{StatusCode: http.StatusOK, Header: http.Header{}, Body: normalized}, nil

  85. }

  86. 

  87. func joinChinaMobileAssetURL(baseURL string, path string) (string, error) {

  88. 	u, err := url.Parse(baseURL)

  89. 	if err != nil {

  90. 		return "", err

  91. 	}

  92. 	u.Path = strings.TrimRight(u.Path, "/") + path

  93. 	u.RawQuery = ""

  94. 	u.Fragment = ""

  95. 	return u.String(), nil

  96. }

  97. 

  98. type chinaMobileAssetCredential struct {

  99. 	AK     string `json:"ak"`

  100. 	SK     string `json:"sk"`

  101. 	PoolID string `json:"pool_id"`

  102. }

  103. 

  104. func chinaMobileAssetCredentialFromEnv() (chinaMobileAssetCredential, error) {

  105. 	return normalizeChinaMobileAssetCredential(chinaMobileAssetCredential{

  106. 		AK:     os.Getenv(chinaMobileAssetAKEnv),

  107. 		SK:     os.Getenv(chinaMobileAssetSKEnv),

  108. 		PoolID: os.Getenv(chinaMobileAssetPoolIDEnv),

  109. 	})

  110. }

  111. 

  112. func normalizeChinaMobileAssetCredential(credential chinaMobileAssetCredential) (chinaMobileAssetCredential, error) {

  113. 	credential.AK = strings.TrimSpace(credential.AK)

  114. 	credential.SK = strings.TrimSpace(credential.SK)

  115. 	credential.PoolID = strings.TrimSpace(credential.PoolID)

  116. 	if credential.AK == "" || credential.SK == "" {

  117. 		return chinaMobileAssetCredential{}, fmt.Errorf("%s and %s are required for China Mobile asset library", chinaMobileAssetAKEnv, chinaMobileAssetSKEnv)

  118. 	}

  119. 	if credential.PoolID == "" {

  120. 		credential.PoolID = defaultChinaMobileAssetPoolID

  121. 	}

  122. 	return credential, nil

  123. }

  124. 

  125. func callChinaMobileAssetSDK(ctx context.Context, client chinaMobileAssetSDKClient, req AssetRequest) (any, error) {

  126. 	type sdkResult struct {

  127. 		value any

  128. 		err   error

  129. 	}

  130. 	resultCh := make(chan sdkResult, 1)

  131. 	go func() {

  132. 		value, err := executeChinaMobileAssetSDK(client, req)

  133. 		resultCh <- sdkResult{value: value, err: err}

  134. 	}()

  135. 	select {

  136. 	case <-ctx.Done():

  137. 		return nil, ctx.Err()

  138. 	case result := <-resultCh:

  139. 		return result.value, result.err

  140. 	}

  141. }

  142. 

  143. func executeChinaMobileAssetSDK(client chinaMobileAssetSDKClient, req AssetRequest) (any, error) {

  144. 	switch req.Action.Operation {

  145. 	case AssetOperationAssetCreate:

  146. 		return client.CreateAsset(&cmmodel.CreateAssetRequest{CreateAssetBody: newChinaMobileCreateAssetBody(req.Body)})

  147. 	case AssetOperationAssetList:

  148. 		return client.ListAssets(&cmmodel.ListAssetsRequest{ListAssetsBody: newChinaMobileListAssetsBody(req.Body)})

  149. 	case AssetOperationAssetGet:

  150. 		id, err := requiredAssetString(req.Body, "Id")

  151. 		if err != nil {

  152. 			return nil, err

  153. 		}

  154. 		return client.GetAsset(&cmmodel.GetAssetRequest{GetAssetPath: (&cmmodel.GetAssetPath{}).SetAssetId(id)})

  155. 	case AssetOperationAssetUpdate:

  156. 		id, err := requiredAssetString(req.Body, "Id")

  157. 		if err != nil {

  158. 			return nil, err

  159. 		}

  160. 		return client.UpdateAsset(&cmmodel.UpdateAssetRequest{

  161. 			UpdateAssetPath: (&cmmodel.UpdateAssetPath{}).SetAssetId(id),

  162. 			UpdateAssetBody: newChinaMobileUpdateAssetBody(req.Body),

  163. 		})

  164. 	case AssetOperationAssetDelete:

  165. 		id, err := requiredAssetString(req.Body, "Id")

  166. 		if err != nil {

  167. 			return nil, err

  168. 		}

  169. 		return client.DeleteAsset(&cmmodel.DeleteAssetRequest{DeleteAssetPath: (&cmmodel.DeleteAssetPath{}).SetAssetId(id)})

  170. 	case AssetOperationAssetGroupCreate:

  171. 		return client.CreateAssetGroup(&cmmodel.CreateAssetGroupRequest{CreateAssetGroupBody: newChinaMobileCreateAssetGroupBody(req.Body)})

  172. 	case AssetOperationAssetGroupList:

  173. 		return client.ListAssetGroups(&cmmodel.ListAssetGroupsRequest{ListAssetGroupsBody: newChinaMobileListAssetGroupsBody(req.Body)})

  174. 	case AssetOperationAssetGroupGet:

  175. 		id, err := requiredAssetString(req.Body, "Id")

  176. 		if err != nil {

  177. 			return nil, err

  178. 		}

  179. 		return client.GetAssetGroup(&cmmodel.GetAssetGroupRequest{GetAssetGroupPath: (&cmmodel.GetAssetGroupPath{}).SetGroupId(id)})

  180. 	case AssetOperationAssetGroupUpdate:

  181. 		id, err := requiredAssetString(req.Body, "Id")

  182. 		if err != nil {

  183. 			return nil, err

  184. 		}

  185. 		return client.UpdateAssetGroup(&cmmodel.UpdateAssetGroupRequest{

  186. 			UpdateAssetGroupPath: (&cmmodel.UpdateAssetGroupPath{}).SetGroupId(id),

  187. 			UpdateAssetGroupBody: newChinaMobileUpdateAssetGroupBody(req.Body),

  188. 		})

  189. 	case AssetOperationAssetGroupDelete:

  190. 		id, err := requiredAssetString(req.Body, "Id")

  191. 		if err != nil {

  192. 			return nil, err

  193. 		}

  194. 		return client.DeleteAssetGroup(&cmmodel.DeleteAssetGroupRequest{DeleteAssetGroupPath: (&cmmodel.DeleteAssetGroupPath{}).SetGroupId(id)})

  195. 	default:

  196. 		return nil, fmt.Errorf("unsupported asset operation %s", req.Action.Operation)

  197. 	}

  198. }

  199. 

  200. func isChinaMobileAssetLocalValidationError(err error) bool {

  201. 	return err != nil && strings.Contains(err.Error(), " is required")

  202. }

  203. 

  204. func classifyChinaMobileAssetSDKError(err error) *AssetError {

  205. 	if err == nil {

  206. 		return nil

  207. 	}

  208. 	if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {

  209. 		return newAssetError(AssetErrorUpstream, err.Error(), http.StatusGatewayTimeout)

  210. 	}

  211. 	if isChinaMobileAssetLocalValidationError(err) {

  212. 		return newAssetError(AssetErrorInvalidRequest, err.Error(), http.StatusBadRequest)

  213. 	}

  214. 	var responseErr *cmerrs.ServerResponseError

  215. 	if errors.As(err, &responseErr) && responseErr.Code == http.StatusBadRequest {

  216. 		message := strings.TrimSpace(responseErr.Body)

  217. 		if message == "" {

  218. 			message = responseErr.Error()

  219. 		}

  220. 		return newAssetError(AssetErrorInvalidRequest, message, http.StatusBadRequest)

  221. 	}

  222. 	return nil

  223. }

  224. 

  225. func validateChinaMobileAssetRequest(req AssetRequest) *AssetError {

  226. 	invalid := func(message string) *AssetError {

  227. 		return newAssetError(AssetErrorInvalidRequest, message, http.StatusBadRequest)

  228. 	}

  229. 	requireString := func(key string) *AssetError {

  230. 		if strings.TrimSpace(stringValue(req.Body, key)) == "" {

  231. 			return invalid(key + " is required")

  232. 		}

  233. 		return nil

  234. 	}

  235. 	validatePage := func() *AssetError {

  236. 		pageNumber := intValue(req.Body, "PageNumber", 1)

  237. 		pageSize := intValue(req.Body, "PageSize", 10)

  238. 		if pageNumber < 1 {

  239. 			return invalid("PageNumber must be greater than or equal to 1")

  240. 		}

  241. 		if pageSize < 1 || pageSize > 999999 {

  242. 			return invalid("PageSize must be between 1 and 999999")

  243. 		}

  244. 		return nil

  245. 	}

  246. 

  247. 	switch req.Action.Operation {

  248. 	case AssetOperationAssetCreate:

  249. 		for _, key := range []string{"GroupId", "Name", "URL", "AssetType"} {

  250. 			if err := requireString(key); err != nil {

  251. 				return err

  252. 			}

  253. 		}

  254. 		if len([]rune(stringValue(req.Body, "Name"))) > 64 {

  255. 			return invalid("Name must not exceed 64 characters")

  256. 		}

  257. 		assetURL, err := url.ParseRequestURI(strings.TrimSpace(stringValue(req.Body, "URL")))

  258. 		if err != nil || (assetURL.Scheme != "http" && assetURL.Scheme != "https") || assetURL.Host == "" {

  259. 			return invalid("URL must be a valid public HTTP or HTTPS URL")

  260. 		}

  261. 		switch stringValue(req.Body, "AssetType") {

  262. 		case "Image", "Video", "Audio":

  263. 		default:

  264. 			return invalid("AssetType must be one of Image, Video, Audio")

  265. 		}

  266. 	case AssetOperationAssetList:

  267. 		if err := validatePage(); err != nil {

  268. 			return err

  269. 		}

  270. 		groupType := strings.TrimSpace(stringValue(mapValue(req.Body, "Filter"), "GroupType"))

  271. 		if groupType == "" {

  272. 			return invalid("Filter.GroupType is required")

  273. 		}

  274. 		if groupType != "AIGC" && groupType != "LivenessFace" {

  275. 			return invalid("Filter.GroupType must be AIGC or LivenessFace")

  276. 		}

  277. 	case AssetOperationAssetGroupCreate:

  278. 		if stringValue(req.Body, "GroupType") != "AIGC" {

  279. 			return invalid("GroupType must be AIGC")

  280. 		}

  281. 		if len([]rune(stringValue(req.Body, "Name"))) > 64 {

  282. 			return invalid("Name must not exceed 64 characters")

  283. 		}

  284. 		if len([]rune(stringValue(req.Body, "Description"))) > 300 {

  285. 			return invalid("Description must not exceed 300 characters")

  286. 		}

  287. 	case AssetOperationAssetGroupList:

  288. 		return validatePage()

  289. 	case AssetOperationAssetUpdate:

  290. 		if err := requireString("Id"); err != nil {

  291. 			return err

  292. 		}

  293. 		if len([]rune(stringValue(req.Body, "Name"))) > 64 {

  294. 			return invalid("Name must not exceed 64 characters")

  295. 		}

  296. 	case AssetOperationAssetGroupUpdate:

  297. 		if err := requireString("Id"); err != nil {

  298. 			return err

  299. 		}

  300. 		if len([]rune(stringValue(req.Body, "Name"))) > 64 {

  301. 			return invalid("Name must not exceed 64 characters")

  302. 		}

  303. 		if len([]rune(stringValue(req.Body, "Description"))) > 300 {

  304. 			return invalid("Description must not exceed 300 characters")

  305. 		}

  306. 	case AssetOperationAssetGet, AssetOperationAssetDelete, AssetOperationAssetGroupGet, AssetOperationAssetGroupDelete:

  307. 		return requireString("Id")

  308. 	}

  309. 	return nil

  310. }

  311. 

  312. func newChinaMobileCreateAssetBody(body map[string]any) *cmmodel.CreateAssetBody {

  313. 	assetType := cmmodel.CreateAssetBodyAssetTypeEnum(stringValue(body, "AssetType"))

  314. 	result := &cmmodel.CreateAssetBody{}

  315. 	result.SetGroupId(stringValue(body, "GroupId"))

  316. 	result.SetAssetName(stringValue(body, "Name"))

  317. 	result.SetAssetUrl(stringValue(body, "URL"))

  318. 	if strings.TrimSpace(string(assetType)) != "" {

  319. 		result.SetAssetType(assetType)

  320. 	}

  321. 	return result

  322. }

  323. 

  324. func newChinaMobileListAssetsBody(body map[string]any) *cmmodel.ListAssetsBody {

  325. 	mapped := mapChinaMobileListAssets(body)

  326. 	result := &cmmodel.ListAssetsBody{}

  327. 	result.SetPageNo(int32(intValue(mapped, "pageNo", 1)))

  328. 	result.SetPageSize(int32(intValue(mapped, "pageSize", 10)))

  329. 	if value := stringValue(mapped, "groupType"); value != "" {

  330. 		result.SetGroupType(value)

  331. 	}

  332. 	if value := stringValue(mapped, "assetName"); value != "" {

  333. 		result.SetAssetName(value)

  334. 	}

  335. 	if values := stringArrayValue(mapped, "groupIds"); len(values) > 0 {

  336. 		result.SetGroupIds(values)

  337. 	}

  338. 	if values := stringArrayValue(mapped, "statuses"); len(values) > 0 {

  339. 		result.SetStatuses(values)

  340. 	}

  341. 	return result

  342. }

  343. 

  344. func newChinaMobileUpdateAssetBody(body map[string]any) *cmmodel.UpdateAssetBody {

  345. 	result := &cmmodel.UpdateAssetBody{}

  346. 	if value := stringValue(body, "Name"); value != "" {

  347. 		result.SetAssetName(value)

  348. 	}

  349. 	return result

  350. }

  351. 

  352. func newChinaMobileCreateAssetGroupBody(body map[string]any) *cmmodel.CreateAssetGroupBody {

  353. 	result := &cmmodel.CreateAssetGroupBody{}

  354. 	if value := stringValue(body, "GroupType"); value != "" {

  355. 		result.SetGroupType(value)

  356. 	}

  357. 	if value := stringValue(body, "Name"); value != "" {

  358. 		result.SetGroupName(value)

  359. 	}

  360. 	if value := stringValue(body, "Description"); value != "" {

  361. 		result.SetDescription(value)

  362. 	}

  363. 	return result

  364. }

  365. 

  366. func newChinaMobileListAssetGroupsBody(body map[string]any) *cmmodel.ListAssetGroupsBody {

  367. 	mapped := mapChinaMobileListAssetGroups(body)

  368. 	result := &cmmodel.ListAssetGroupsBody{}

  369. 	result.SetPageNo(int32(intValue(mapped, "pageNo", 1)))

  370. 	result.SetPageSize(int32(intValue(mapped, "pageSize", 10)))

  371. 	if value := stringValue(mapped, "groupType"); value != "" {

  372. 		result.SetGroupType(value)

  373. 	}

  374. 	if value := stringValue(mapped, "groupName"); value != "" {

  375. 		result.SetGroupName(value)

  376. 	}

  377. 	if values := stringArrayValue(mapped, "groupIds"); len(values) > 0 {

  378. 		result.SetGroupIds(values)

  379. 	}

  380. 	return result

  381. }

  382. 

  383. func newChinaMobileUpdateAssetGroupBody(body map[string]any) *cmmodel.UpdateAssetGroupBody {

  384. 	result := &cmmodel.UpdateAssetGroupBody{}

  385. 	if value := stringValue(body, "Name"); value != "" {

  386. 		result.SetGroupName(value)

  387. 	}

  388. 	if value := stringValue(body, "Description"); value != "" {

  389. 		result.SetDescription(value)

  390. 	}

  391. 	return result

  392. }

  393. 

  394. func buildChinaMobileAssetRequest(req AssetRequest) (string, string, map[string]any, error) {

  395. 	switch req.Action.Operation {

  396. 	case AssetOperationAssetCreate:

  397. 		return http.MethodPost, "/api/openapi-maas/exp/aicc/v2/asset", mapChinaMobileCreateAsset(req.Body), nil

  398. 	case AssetOperationAssetList:

  399. 		return http.MethodPost, "/api/openapi-maas/exp/aicc/v2/asset/query", mapChinaMobileListAssets(req.Body), nil

  400. 	case AssetOperationAssetGet:

  401. 		id, err := requiredAssetString(req.Body, "Id")

  402. 		return http.MethodGet, "/api/openapi-maas/exp/aicc/v2/asset/" + url.PathEscape(id), nil, err

  403. 	case AssetOperationAssetUpdate:

  404. 		id, err := requiredAssetString(req.Body, "Id")

  405. 		return http.MethodPut, "/api/openapi-maas/exp/aicc/v2/asset/" + url.PathEscape(id), mapChinaMobileUpdateAsset(req.Body), err

  406. 	case AssetOperationAssetDelete:

  407. 		id, err := requiredAssetString(req.Body, "Id")

  408. 		return http.MethodDelete, "/api/openapi-maas/exp/aicc/v2/asset/" + url.PathEscape(id), nil, err

  409. 	case AssetOperationAssetGroupCreate:

  410. 		return http.MethodPost, "/api/openapi-maas/exp/aicc/v2/asset-group", mapChinaMobileCreateAssetGroup(req.Body), nil

  411. 	case AssetOperationAssetGroupList:

  412. 		return http.MethodPost, "/api/openapi-maas/exp/aicc/v2/asset-group/query", mapChinaMobileListAssetGroups(req.Body), nil

  413. 	case AssetOperationAssetGroupGet:

  414. 		id, err := requiredAssetString(req.Body, "Id")

  415. 		return http.MethodGet, "/api/openapi-maas/exp/aicc/v2/asset-group/" + url.PathEscape(id), nil, err

  416. 	case AssetOperationAssetGroupUpdate:

  417. 		id, err := requiredAssetString(req.Body, "Id")

  418. 		return http.MethodPut, "/api/openapi-maas/exp/aicc/v2/asset-group/" + url.PathEscape(id), mapChinaMobileUpdateAssetGroup(req.Body), err

  419. 	case AssetOperationAssetGroupDelete:

  420. 		id, err := requiredAssetString(req.Body, "Id")

  421. 		return http.MethodDelete, "/api/openapi-maas/exp/aicc/v2/asset-group/" + url.PathEscape(id), nil, err

  422. 	default:

  423. 		return "", "", nil, fmt.Errorf("unsupported asset operation %s", req.Action.Operation)

  424. 	}

  425. }

  426. 

  427. func mapChinaMobileCreateAsset(body map[string]any) map[string]any {

  428. 	return compactAssetMap(map[string]any{

  429. 		"groupId":   stringValue(body, "GroupId"),

  430. 		"assetName": stringValue(body, "Name"),

  431. 		"assetUrl":  stringValue(body, "URL"),

  432. 		"assetType": stringValue(body, "AssetType"),

  433. 	})

  434. }

  435. 

  436. func mapChinaMobileListAssets(body map[string]any) map[string]any {

  437. 	filter := mapValue(body, "Filter")

  438. 	mapped := map[string]any{

  439. 		"pageNo":   intValue(body, "PageNumber", 1),

  440. 		"pageSize": intValue(body, "PageSize", 10),

  441. 	}

  442. 	copyStringArray(mapped, "groupIds", filter, "GroupIds")

  443. 	copyString(mapped, "groupType", filter, "GroupType")

  444. 	copyString(mapped, "assetName", filter, "Name")

  445. 	copyStatusArray(mapped, "statuses", filter, "Statuses")

  446. 	return compactAssetMap(mapped)

  447. }

  448. 

  449. func mapChinaMobileUpdateAsset(body map[string]any) map[string]any {

  450. 	return compactAssetMap(map[string]any{"assetName": stringValue(body, "Name")})

  451. }

  452. 

  453. func mapChinaMobileCreateAssetGroup(body map[string]any) map[string]any {

  454. 	return compactAssetMap(map[string]any{

  455. 		"groupType":   stringValue(body, "GroupType"),

  456. 		"groupName":   stringValue(body, "Name"),

  457. 		"description": stringValue(body, "Description"),

  458. 	})

  459. }

  460. 

  461. func mapChinaMobileListAssetGroups(body map[string]any) map[string]any {

  462. 	filter := mapValue(body, "Filter")

  463. 	mapped := map[string]any{

  464. 		"pageNo":   intValue(body, "PageNumber", 1),

  465. 		"pageSize": intValue(body, "PageSize", 10),

  466. 	}

  467. 	copyString(mapped, "groupType", filter, "GroupType")

  468. 	copyString(mapped, "groupName", filter, "Name")

  469. 	copyStringArray(mapped, "groupIds", filter, "GroupIds")

  470. 	return compactAssetMap(mapped)

  471. }

  472. 

  473. func mapChinaMobileUpdateAssetGroup(body map[string]any) map[string]any {

  474. 	return compactAssetMap(map[string]any{

  475. 		"groupName":   stringValue(body, "Name"),

  476. 		"description": stringValue(body, "Description"),

  477. 	})

  478. }

  479. 

  480. func normalizeChinaMobileAssetResponse(spec AssetActionSpec, version string, data []byte) ([]byte, *AssetError) {

  481. 	var payload struct {

  482. 		RequestID    string `json:"requestId"`

  483. 		State        string `json:"state"`

  484. 		ErrorCode    string `json:"errorCode"`

  485. 		ErrorMessage string `json:"errorMessage"`

  486. 		Body         any    `json:"body"`

  487. 	}

  488. 	if err := common.Unmarshal(data, &payload); err != nil {

  489. 		return nil, newAssetError(AssetErrorUpstream, err.Error(), http.StatusBadGateway)

  490. 	}

  491. 	if strings.EqualFold(payload.State, "ERROR") {

  492. 		message := strings.TrimSpace(payload.ErrorMessage)

  493. 		if message == "" {

  494. 			message = payload.ErrorCode

  495. 		}

  496. 		return nil, newAssetError(AssetErrorUpstream, message, http.StatusBadGateway)

  497. 	}

  498. 	if !strings.EqualFold(payload.State, "OK") {

  499. 		return nil, newAssetError(AssetErrorUpstream, "China Mobile asset response has invalid state", http.StatusBadGateway)

  500. 	}

  501. 	if spec.Delete {

  502. 		deleted, ok := payload.Body.(bool)

  503. 		if !ok || !deleted {

  504. 			return nil, newAssetError(AssetErrorUpstream, "China Mobile asset delete was not confirmed", http.StatusBadGateway)

  505. 		}

  506. 	}

  507. 	var result any

  508. 	if !spec.Delete {

  509. 		result = normalizeChinaMobileResult(spec.Operation, payload.Body)

  510. 	}

  511. 	body, err := buildAssetSuccessResponseWithRequestID(spec.Action, version, payload.RequestID, result)

  512. 	if err != nil {

  513. 		return nil, newAssetError(AssetErrorServer, err.Error(), http.StatusInternalServerError)

  514. 	}

  515. 	return body, nil

  516. }

  517. 

  518. func normalizeChinaMobileAssetSDKResponse(spec AssetActionSpec, version string, response any) ([]byte, *AssetError) {

  519. 	data, err := common.Marshal(response)

  520. 	if err != nil {

  521. 		return nil, newAssetError(AssetErrorServer, err.Error(), http.StatusInternalServerError)

  522. 	}

  523. 	return normalizeChinaMobileAssetResponse(spec, version, data)

  524. }

  525. 

  526. func normalizeChinaMobileResult(operation AssetOperation, body any) any {

  527. 	raw, ok := body.(map[string]any)

  528. 	if !ok {

  529. 		return body

  530. 	}

  531. 	switch operation {

  532. 	case AssetOperationAssetList:

  533. 		return map[string]any{

  534. 			"Items":      normalizeChinaMobileItems(raw["data"], false),

  535. 			"TotalCount": raw["total"],

  536. 		}

  537. 	case AssetOperationAssetGroupList:

  538. 		return map[string]any{

  539. 			"Items":      normalizeChinaMobileItems(raw["data"], true),

  540. 			"TotalCount": raw["total"],

  541. 		}

  542. 	case AssetOperationAssetGroupCreate, AssetOperationAssetGroupGet, AssetOperationAssetGroupUpdate:

  543. 		return normalizeChinaMobileAssetGroup(raw)

  544. 	default:

  545. 		return normalizeChinaMobileAsset(raw)

  546. 	}

  547. }

  548. 

  549. func normalizeChinaMobileItems(value any, group bool) []any {

  550. 	items, ok := value.([]any)

  551. 	if !ok {

  552. 		return nil

  553. 	}

  554. 	normalized := make([]any, 0, len(items))

  555. 	for _, item := range items {

  556. 		raw, ok := item.(map[string]any)

  557. 		if !ok {

  558. 			continue

  559. 		}

  560. 		if group {

  561. 			normalized = append(normalized, normalizeChinaMobileAssetGroup(raw))

  562. 		} else {

  563. 			normalized = append(normalized, normalizeChinaMobileAsset(raw))

  564. 		}

  565. 	}

  566. 	return normalized

  567. }

  568. 

  569. func normalizeChinaMobileAsset(raw map[string]any) map[string]any {

  570. 	return compactAssetMap(map[string]any{

  571. 		"Id":           raw["assetId"],

  572. 		"GroupId":      raw["groupId"],

  573. 		"Name":         raw["assetName"],

  574. 		"AssetType":    raw["assetType"],

  575. 		"URL":          raw["assetUrl"],

  576. 		"Status":       chinaMobileStatusToOfficial(fmt.Sprint(raw["status"])),

  577. 		"ErrorMessage": raw["errorMessage"],

  578. 		"CreatedAt":    raw["createdTime"],

  579. 		"UpdatedAt":    raw["updatedTime"],

  580. 	})

  581. }

  582. 

  583. func normalizeChinaMobileAssetGroup(raw map[string]any) map[string]any {

  584. 	return compactAssetMap(map[string]any{

  585. 		"Id":          raw["groupId"],

  586. 		"GroupId":     raw["groupId"],

  587. 		"GroupType":   raw["groupType"],

  588. 		"Name":        raw["groupName"],

  589. 		"Description": raw["description"],

  590. 		"CreatedAt":   raw["createdTime"],

  591. 		"UpdatedAt":   raw["updatedTime"],

  592. 	})

  593. }

  594. 

  595. func validateChinaMobileCompatibility(body map[string]any) *AssetError {

  596. 	if projectName := strings.TrimSpace(stringValue(body, "ProjectName")); projectName != "" && projectName != "default" {

  597. 		return newAssetError(AssetErrorOperationNotSupported, "China Mobile asset API does not support non-default ProjectName", http.StatusBadRequest)

  598. 	}

  599. 	if sortBy := strings.TrimSpace(stringValue(body, "SortBy")); sortBy != "" && sortBy != "CreateTime" {

  600. 		return newAssetError(AssetErrorOperationNotSupported, "China Mobile asset API does not support custom SortBy", http.StatusBadRequest)

  601. 	}

  602. 	if sortOrder := strings.TrimSpace(stringValue(body, "SortOrder")); sortOrder != "" && !strings.EqualFold(sortOrder, "Desc") {

  603. 		return newAssetError(AssetErrorOperationNotSupported, "China Mobile asset API does not support custom SortOrder", http.StatusBadRequest)

  604. 	}

  605. 	return nil

  606. }

  607. 

  608. func chinaMobileStatusToOfficial(status string) string {

  609. 	switch strings.ToUpper(strings.TrimSpace(status)) {

  610. 	case "PROCESSING":

  611. 		return "Processing"

  612. 	case "ACTIVE":

  613. 		return "Active"

  614. 	case "FAILED":

  615. 		return "Failed"

  616. 	default:

  617. 		return status

  618. 	}

  619. }

  620. 

  621. func officialStatusToChinaMobile(status string) string {

  622. 	switch strings.ToLower(strings.TrimSpace(status)) {

  623. 	case "processing":

  624. 		return "PROCESSING"

  625. 	case "active":

  626. 		return "ACTIVE"

  627. 	case "failed":

  628. 		return "FAILED"

  629. 	default:

  630. 		return status

  631. 	}

  632. }

  633. 

  634. func requiredAssetString(body map[string]any, key string) (string, error) {

  635. 	value := strings.TrimSpace(stringValue(body, key))

  636. 	if value == "" {

  637. 		return "", fmt.Errorf("%s is required", key)

  638. 	}

  639. 	return value, nil

  640. }

  641. 

  642. func stringValue(body map[string]any, key string) string {

  643. 	if body == nil {

  644. 		return ""

  645. 	}

  646. 	value, _ := body[key].(string)

  647. 	return value

  648. }

  649. 

  650. func mapValue(body map[string]any, key string) map[string]any {

  651. 	if body == nil {

  652. 		return nil

  653. 	}

  654. 	value, _ := body[key].(map[string]any)

  655. 	return value

  656. }

  657. 

  658. func intValue(body map[string]any, key string, fallback int) int {

  659. 	if body == nil {

  660. 		return fallback

  661. 	}

  662. 	switch value := body[key].(type) {

  663. 	case int:

  664. 		return value

  665. 	case int32:

  666. 		return int(value)

  667. 	case int64:

  668. 		return int(value)

  669. 	case float64:

  670. 		return int(value)

  671. 	case float32:

  672. 		return int(value)

  673. 	default:

  674. 		return fallback

  675. 	}

  676. }

  677. 

  678. func copyString(dst map[string]any, dstKey string, src map[string]any, srcKey string) {

  679. 	value := stringValue(src, srcKey)

  680. 	if strings.TrimSpace(value) != "" {

  681. 		dst[dstKey] = value

  682. 	}

  683. }

  684. 

  685. func copyStringArray(dst map[string]any, dstKey string, src map[string]any, srcKey string) {

  686. 	values := stringArrayValue(src, srcKey)

  687. 	if len(values) > 0 {

  688. 		dst[dstKey] = values

  689. 	}

  690. }

  691. 

  692. func copyStatusArray(dst map[string]any, dstKey string, src map[string]any, srcKey string) {

  693. 	values := stringArrayValue(src, srcKey)

  694. 	if len(values) == 0 {

  695. 		return

  696. 	}

  697. 	mapped := make([]string, 0, len(values))

  698. 	for _, value := range values {

  699. 		mapped = append(mapped, officialStatusToChinaMobile(value))

  700. 	}

  701. 	dst[dstKey] = mapped

  702. }

  703. 

  704. func stringArrayValue(body map[string]any, key string) []string {

  705. 	if body == nil {

  706. 		return nil

  707. 	}

  708. 	switch value := body[key].(type) {

  709. 	case []string:

  710. 		return value

  711. 	case []any:

  712. 		values := make([]string, 0, len(value))

  713. 		for _, item := range value {

  714. 			if s, ok := item.(string); ok && strings.TrimSpace(s) != "" {

  715. 				values = append(values, s)

  716. 			}

  717. 		}

  718. 		return values

  719. 	default:

  720. 		return nil

  721. 	}

  722. }

  723. 

  724. func compactAssetMap(input map[string]any) map[string]any {

  725. 	output := make(map[string]any, len(input))

  726. 	for key, value := range input {

  727. 		switch v := value.(type) {

  728. 		case string:

  729. 			if strings.TrimSpace(v) != "" {

  730. 				output[key] = v

  731. 			}

  732. 		case nil:

  733. 			continue

  734. 		default:

  735. 			output[key] = value

  736. 		}

  737. 	}

  738. 	return output

  739. }