dashboard_service.go 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583
  1. package backend
  2. import (
  3. "context"
  4. "encoding/json"
  5. "fmt"
  6. "kpt-tmr-group/model"
  7. "kpt-tmr-group/pkg/logger/zaplog"
  8. "kpt-tmr-group/pkg/tool"
  9. "kpt-tmr-group/pkg/xerr"
  10. operationPb "kpt-tmr-group/proto/go/backend/operation"
  11. "net/http"
  12. "sort"
  13. "sync"
  14. "time"
  15. "go.uber.org/multierr"
  16. "go.uber.org/zap"
  17. )
  18. const compareTime = 10 * 60
  19. // PasturePrefAnalysisData PasturePrefExecTimeData PastureSprinkleFeedTime TODO 后期三个函数封装一下
  20. func (s *StoreEntry) PasturePrefAnalysisData(ctx context.Context, req *operationPb.SearchAnalysisAccuracyRequest) (map[int64]*model.PastureAnalysisAccuracyData, error) {
  21. res := make(map[int64]*model.PastureAnalysisAccuracyData, 0)
  22. wg := sync.WaitGroup{}
  23. wg.Add(len(req.PastureIds))
  24. for _, pastureId := range req.PastureIds {
  25. go func(pId int32) {
  26. defer wg.Done()
  27. response := &model.PastureAnalysisAccuracyResponse{}
  28. groupPasture, err := s.GetGroupPastureListById(ctx, int64(pId))
  29. if err != nil {
  30. zaplog.Error("PasturePrefAnalysisData",
  31. zap.Any("GetGroupPastureListById", err),
  32. zap.Any("pId", pId))
  33. return
  34. }
  35. body := &model.DashboardAccuracyRequest{
  36. PastureId: int32(groupPasture.PastureId),
  37. FeedFormulaId: req.FeedFormulaId,
  38. CattleParentCategoryId: int32(req.CattleParentCategoryId),
  39. StartDate: req.StartDate,
  40. EndDate: req.EndDate,
  41. }
  42. _, err = s.PastureHttpClient(ctx, model.DashboardAccuracyUrl, int64(pId), body, response)
  43. if err != nil {
  44. zaplog.Error("DistributeFeedFormula",
  45. zap.String("url", model.DashboardAccuracyUrl),
  46. zap.Any("pasture", groupPasture), zap.Any("body", body),
  47. zap.Any("err", err), zap.Any("response", response))
  48. b, _ := json.Marshal(body)
  49. resB, _ := json.Marshal(response)
  50. pastureDataLog := model.NewPastureDataLog(groupPasture.Id, PastureDataLogType["FeedFormula_Distribute"], model.DashboardAccuracyUrl, string(b), string(resB))
  51. s.DB.Create(pastureDataLog)
  52. return
  53. }
  54. if response.Code != http.StatusOK {
  55. zaplog.Error("DistributeFeedFormula-response",
  56. zap.String("url", model.DashboardAccuracyUrl),
  57. zap.Any("pasture", groupPasture), zap.Any("body", body),
  58. zap.Any("response", response), zap.Any("response", response))
  59. return
  60. }
  61. res[groupPasture.Id] = response.Data
  62. }(pastureId)
  63. }
  64. wg.Wait()
  65. return res, nil
  66. }
  67. func (s *StoreEntry) PasturePrefExecTimeData(ctx context.Context, req *operationPb.SearchAnalysisAccuracyRequest) (map[string]*model.ExecTimeData, error) {
  68. res := make(map[string]*model.ExecTimeData, 0)
  69. wg := sync.WaitGroup{}
  70. wg.Add(len(req.PastureIds))
  71. for _, pastureId := range req.PastureIds {
  72. go func(pId int32) {
  73. defer wg.Done()
  74. groupPasture, err := s.GetGroupPastureListById(ctx, int64(pId))
  75. if err != nil {
  76. return
  77. }
  78. response := &model.PastureExecTimeData{}
  79. body := &model.DashboardAccuracyRequest{
  80. PastureId: int32(groupPasture.PastureId),
  81. FeedFormulaId: req.FeedFormulaId,
  82. CattleParentCategoryId: int32(req.CattleParentCategoryId),
  83. StartDate: req.StartDate,
  84. EndDate: req.EndDate,
  85. }
  86. if _, err = s.PastureHttpClient(ctx, model.DashboardExecTimeUrl, int64(pId), body, response); err != nil {
  87. zaplog.Error("PasturePrefExecTimeData",
  88. zap.String("url", model.DashboardExecTimeUrl),
  89. zap.Any("pasture", groupPasture), zap.Any("body", body),
  90. zap.Any("err", err), zap.Any("response", response))
  91. b, _ := json.Marshal(body)
  92. resB, _ := json.Marshal(response)
  93. pastureDataLog := model.NewPastureDataLog(groupPasture.Id, PastureDataLogType["PasturePrefExecTimeData"], model.DashboardExecTimeUrl, string(b), string(resB))
  94. s.DB.Create(pastureDataLog)
  95. return
  96. }
  97. if response.Code != http.StatusOK {
  98. zaplog.Error("PasturePrefExecTimeData-response",
  99. zap.String("url", model.DashboardExecTimeUrl),
  100. zap.Any("pasture", groupPasture), zap.Any("body", body),
  101. zap.Any("err", err), zap.Any("response", response))
  102. return
  103. }
  104. res[groupPasture.Name] = response.Data
  105. }(pastureId)
  106. }
  107. wg.Wait()
  108. return res, nil
  109. }
  110. func (s *StoreEntry) PastureSprinkleFeedTime(ctx context.Context, req *operationPb.SprinkleFeedTimeRequest) (map[string][]*model.SprinkleStatisticsDataList, error) {
  111. res := make(map[string][]*model.SprinkleStatisticsDataList, 0)
  112. wg := sync.WaitGroup{}
  113. wg.Add(len(req.PastureIds))
  114. var muError error
  115. for _, pasture := range req.PastureIds {
  116. go func(pId int32) {
  117. defer wg.Done()
  118. groupPasture, err := s.GetGroupPastureListById(ctx, int64(pId))
  119. if err != nil {
  120. zaplog.Error("PastureSprinkleFeedTime", zap.Any("GetGroupPastureListById", err))
  121. return
  122. }
  123. response := &model.PastureSprinkleStatisticsDataList{}
  124. body := &model.DashboardAccuracyRequest{
  125. PastureId: int32(groupPasture.PastureId),
  126. FeedFormulaId: req.FeedFormulaId,
  127. StartDate: req.StartDate,
  128. EndDate: req.EndDate,
  129. }
  130. if _, err = s.PastureHttpClient(ctx, model.DashboardSprinkleFeedTimeUrl, int64(pId), body, response); err != nil {
  131. muError = multierr.Append(muError, err)
  132. zaplog.Error("PastureSprinkleFeedTime",
  133. zap.String("url", model.DashboardSprinkleFeedTimeUrl),
  134. zap.Any("pasture", groupPasture), zap.Any("body", body),
  135. zap.Any("err", err), zap.Any("response", response))
  136. b, _ := json.Marshal(body)
  137. resB, _ := json.Marshal(response)
  138. pastureDataLog := model.NewPastureDataLog(groupPasture.Id, PastureDataLogType["PasturePrefExecTimeData"], model.DashboardSprinkleFeedTimeUrl, string(b), string(resB))
  139. s.DB.Create(pastureDataLog)
  140. }
  141. if response.Code != http.StatusOK {
  142. muError = multierr.Append(muError, xerr.Custom(response.Msg))
  143. }
  144. res[groupPasture.Name] = response.Data
  145. }(pasture)
  146. }
  147. wg.Wait()
  148. return res, nil
  149. }
  150. func (s *StoreEntry) SearchAnalysisAccuracy(ctx context.Context, req *operationPb.SearchAnalysisAccuracyRequest) (*model.SearchAnalysisAccuracyResponse, error) {
  151. res := &model.SearchAnalysisAccuracyResponse{
  152. Code: http.StatusOK,
  153. Msg: "ok",
  154. Data: &model.AnalysisAccuracyData{
  155. Chart: &model.Chart{},
  156. Table: &model.Table{
  157. TitleList: make([]*model.TableList, 0),
  158. DataList: &model.DataList{},
  159. },
  160. },
  161. }
  162. res.Data.Table.TitleList = append(res.Data.Table.TitleList, &model.TableList{
  163. Name: "title",
  164. Value: "牧场",
  165. })
  166. pastureAnalysisAccuracy, err := s.PasturePrefAnalysisData(ctx, req)
  167. if err != nil {
  168. return nil, xerr.WithStack(err)
  169. }
  170. mixedFodderAccurateRatio, mixedFodderCorrectRatio, sprinkleFodderAccurateRatio, sprinkleFodderCorrectRatio :=
  171. &model.CommonValueRatio{}, &model.CommonValueRatio{}, &model.CommonValueRatio{}, &model.CommonValueRatio{}
  172. maTitleValueList, mcTitleValueList, saTitleValueList, scTitleValueList := make([]float64, 0), make([]float64, 0), make([]float64, 0), make([]float64, 0)
  173. mTopOneName := ""
  174. dayTimeList := tool.TimeBetween(req.StartDate, req.EndDate)
  175. for pastureId, data := range pastureAnalysisAccuracy {
  176. groupPasture, err := s.GetGroupPastureListById(ctx, pastureId)
  177. if err != nil {
  178. zaplog.Error("SearchAnalysisAccuracy GetGroupPastureListById",
  179. zap.Any("pastureId", pastureId), zap.Any("error", err))
  180. continue
  181. }
  182. if data == nil {
  183. continue
  184. }
  185. mixedFodderAccurateRatioDataList := make([]string, 0)
  186. for _, v := range data.MixedFodderAccurateRatio {
  187. mixedFodderAccurateRatioDataList = append(mixedFodderAccurateRatioDataList, fmt.Sprintf("%.2f", v.Ratio))
  188. if len(mixedFodderAccurateRatio.DateDay) < len(dayTimeList) {
  189. mixedFodderAccurateRatio.DateDay = append(mixedFodderAccurateRatio.DateDay, v.DayTime)
  190. }
  191. maTitleValueList = append(maTitleValueList, v.Ratio)
  192. }
  193. mixedFodderAccurateRatio.DataList = append(mixedFodderAccurateRatio.DataList, mixedFodderAccurateRatioDataList)
  194. mixedFodderAccurateRatio.PastureIds = append(mixedFodderAccurateRatio.PastureIds, int32(pastureId))
  195. mixedFodderAccurateRatio.PastureName = append(mixedFodderAccurateRatio.PastureName, groupPasture.Name)
  196. mixedFodderCorrectRatioDataList := make([]string, 0)
  197. for _, v := range data.MixedFodderCorrectRatio {
  198. mixedFodderCorrectRatioDataList = append(mixedFodderCorrectRatioDataList, fmt.Sprintf("%.2f", v.Ratio))
  199. if len(mixedFodderCorrectRatio.DateDay) < len(dayTimeList) {
  200. mixedFodderCorrectRatio.DateDay = append(mixedFodderCorrectRatio.DateDay, v.DayTime)
  201. }
  202. mcTitleValueList = append(mcTitleValueList, v.Ratio)
  203. }
  204. mixedFodderCorrectRatio.DataList = append(mixedFodderCorrectRatio.DataList, mixedFodderCorrectRatioDataList)
  205. mixedFodderCorrectRatio.PastureIds = append(mixedFodderCorrectRatio.PastureIds, int32(pastureId))
  206. mixedFodderCorrectRatio.PastureName = append(mixedFodderCorrectRatio.PastureName, groupPasture.Name)
  207. sprinkleFodderRatioDataList := make([]string, 0)
  208. for _, v := range data.SprinkleFodderAccurateRatio {
  209. sprinkleFodderRatioDataList = append(sprinkleFodderRatioDataList, fmt.Sprintf("%.2f", v.Ratio))
  210. if len(sprinkleFodderAccurateRatio.DateDay) < len(dayTimeList) {
  211. sprinkleFodderAccurateRatio.DateDay = append(sprinkleFodderAccurateRatio.DateDay, v.DayTime)
  212. }
  213. saTitleValueList = append(saTitleValueList, v.Ratio)
  214. }
  215. sprinkleFodderAccurateRatio.DataList = append(sprinkleFodderAccurateRatio.DataList, sprinkleFodderRatioDataList)
  216. sprinkleFodderAccurateRatio.PastureIds = append(sprinkleFodderAccurateRatio.PastureIds, int32(pastureId))
  217. sprinkleFodderAccurateRatio.PastureName = append(sprinkleFodderAccurateRatio.PastureName, groupPasture.Name)
  218. sprinkleFodderCorrectRatioDataList := make([]string, 0)
  219. for _, v := range data.SprinkleFodderCorrectRatio {
  220. sprinkleFodderCorrectRatioDataList = append(sprinkleFodderCorrectRatioDataList, fmt.Sprintf("%.2f", v.Ratio))
  221. if len(sprinkleFodderCorrectRatio.DateDay) < len(dayTimeList) {
  222. sprinkleFodderCorrectRatio.DateDay = append(sprinkleFodderCorrectRatio.DateDay, v.DayTime)
  223. }
  224. scTitleValueList = append(scTitleValueList, v.Ratio)
  225. }
  226. sprinkleFodderCorrectRatio.DataList = append(sprinkleFodderCorrectRatio.DataList, sprinkleFodderCorrectRatioDataList)
  227. sprinkleFodderCorrectRatio.PastureIds = append(sprinkleFodderCorrectRatio.PastureIds, int32(pastureId))
  228. sprinkleFodderCorrectRatio.PastureName = append(sprinkleFodderCorrectRatio.PastureName, groupPasture.Name)
  229. }
  230. sort.Float64s(maTitleValueList)
  231. mixedFodderAccurateRatio.MaxValue = fmt.Sprintf("%.2f", maTitleValueList[len(maTitleValueList)-1])
  232. mixedFodderAccurateRatio.MinValue = fmt.Sprintf("%.2f", maTitleValueList[0])
  233. mixedFodderAccurateRatio.MiddleValue = fmt.Sprintf("%.2f", tool.Median(maTitleValueList))
  234. mixedFodderAccurateRatio.TopOneName = mTopOneName
  235. sort.Float64s(mcTitleValueList)
  236. mixedFodderCorrectRatio.MaxValue = fmt.Sprintf("%.2f", mcTitleValueList[len(mcTitleValueList)-1])
  237. mixedFodderCorrectRatio.MinValue = fmt.Sprintf("%.2f", mcTitleValueList[0])
  238. mixedFodderCorrectRatio.MiddleValue = fmt.Sprintf("%.2f", tool.Median(mcTitleValueList))
  239. mixedFodderCorrectRatio.TopOneName = mTopOneName
  240. sort.Float64s(saTitleValueList)
  241. sprinkleFodderAccurateRatio.MaxValue = fmt.Sprintf("%.2f", saTitleValueList[len(saTitleValueList)-1])
  242. sprinkleFodderAccurateRatio.MinValue = fmt.Sprintf("%.2f", saTitleValueList[0])
  243. sprinkleFodderAccurateRatio.MiddleValue = fmt.Sprintf("%.2f", tool.Median(saTitleValueList))
  244. sprinkleFodderAccurateRatio.TopOneName = mTopOneName
  245. sort.Float64s(scTitleValueList)
  246. sprinkleFodderCorrectRatio.MaxValue = fmt.Sprintf("%.2f", scTitleValueList[len(scTitleValueList)-1])
  247. sprinkleFodderCorrectRatio.MinValue = fmt.Sprintf("%.2f", scTitleValueList[0])
  248. sprinkleFodderCorrectRatio.MiddleValue = fmt.Sprintf("%.2f", tool.Median(scTitleValueList))
  249. sprinkleFodderCorrectRatio.TopOneName = mTopOneName
  250. chart := &model.Chart{
  251. MixedFodderAccurateRatio: mixedFodderAccurateRatio,
  252. MixedFodderCorrectRatio: mixedFodderCorrectRatio,
  253. SprinkleFodderAccurateRatio: sprinkleFodderAccurateRatio,
  254. SprinkleFodderCorrectRatio: sprinkleFodderCorrectRatio,
  255. }
  256. res.Data.Chart = chart
  257. res.Data.Table = s.TitleList(ctx, pastureAnalysisAccuracy)
  258. return res, nil
  259. }
  260. // TopPasture 牧场排名
  261. func (s *StoreEntry) TopPasture(ctx context.Context, req *operationPb.SearchAnalysisAccuracyRequest) (*model.GetPastureTopResponse, error) {
  262. res := &model.GetPastureTopResponse{
  263. Code: http.StatusOK,
  264. Msg: "ok",
  265. Data: &model.PastureTop{
  266. MixedFodderAccurateRatio: make([]*model.PastureTopData, 0),
  267. MixedFodderCorrectRatio: make([]*model.PastureTopData, 0),
  268. SprinkleFodderAccurateRatio: make([]*model.PastureTopData, 0),
  269. SprinkleFodderCorrectRatio: make([]*model.PastureTopData, 0),
  270. },
  271. }
  272. analysisAccuracy, err := s.PasturePrefAnalysisData(ctx, req)
  273. if err != nil {
  274. return nil, xerr.WithStack(err)
  275. }
  276. mixedFodderAccurateRatio := make([]*model.PastureTopData, 0)
  277. mixedFodderCorrectRatio := make([]*model.PastureTopData, 0)
  278. sprinkleFodderAccurateRatio := make([]*model.PastureTopData, 0)
  279. sprinkleFodderCorrectRatio := make([]*model.PastureTopData, 0)
  280. for pastureId, data := range analysisAccuracy {
  281. groupPasture, err := s.GetGroupPastureListById(ctx, pastureId)
  282. if err != nil {
  283. zaplog.Error("TopPasture", zap.Any("GetGroupPastureListById", pastureId), zap.Any("err", err))
  284. continue
  285. }
  286. if data == nil {
  287. continue
  288. }
  289. allMaRatio, allMcRatio, allSaRatio, allScRatio := 0.0, 0.0, 0.0, 0.0
  290. for _, v := range data.MixedFodderAccurateRatio {
  291. allMaRatio += v.Ratio
  292. }
  293. mixedFodderAccurateRatio = append(mixedFodderAccurateRatio, &model.PastureTopData{
  294. PastureName: groupPasture.Name,
  295. Ratio: allMaRatio / float64(len(data.MixedFodderAccurateRatio)),
  296. })
  297. for _, v := range data.MixedFodderCorrectRatio {
  298. allMcRatio += v.Ratio
  299. }
  300. mixedFodderCorrectRatio = append(mixedFodderCorrectRatio, &model.PastureTopData{
  301. PastureName: groupPasture.Name,
  302. Ratio: allMaRatio / float64(len(data.MixedFodderCorrectRatio)),
  303. })
  304. for _, v := range data.SprinkleFodderAccurateRatio {
  305. allSaRatio += v.Ratio
  306. }
  307. sprinkleFodderAccurateRatio = append(sprinkleFodderAccurateRatio, &model.PastureTopData{
  308. PastureName: groupPasture.Name,
  309. Ratio: allSaRatio / float64(len(data.SprinkleFodderAccurateRatio)),
  310. })
  311. for _, v := range data.SprinkleFodderCorrectRatio {
  312. allScRatio += v.Ratio
  313. }
  314. sprinkleFodderCorrectRatio = append(sprinkleFodderCorrectRatio, &model.PastureTopData{
  315. PastureName: groupPasture.Name,
  316. Ratio: allScRatio / float64(len(data.SprinkleFodderCorrectRatio)),
  317. })
  318. }
  319. sort.Slice(mixedFodderAccurateRatio, func(i, j int) bool {
  320. return mixedFodderAccurateRatio[i].Ratio > mixedFodderAccurateRatio[j].Ratio
  321. })
  322. sort.Slice(mixedFodderCorrectRatio, func(i, j int) bool {
  323. return mixedFodderCorrectRatio[i].Ratio > mixedFodderCorrectRatio[j].Ratio
  324. })
  325. sort.Slice(sprinkleFodderAccurateRatio, func(i, j int) bool {
  326. return sprinkleFodderAccurateRatio[i].Ratio > sprinkleFodderAccurateRatio[j].Ratio
  327. })
  328. sort.Slice(sprinkleFodderCorrectRatio, func(i, j int) bool {
  329. return sprinkleFodderCorrectRatio[i].Ratio > sprinkleFodderCorrectRatio[j].Ratio
  330. })
  331. res.Data.MixedFodderAccurateRatio = mixedFodderAccurateRatio
  332. res.Data.MixedFodderCorrectRatio = mixedFodderCorrectRatio
  333. res.Data.SprinkleFodderAccurateRatio = sprinkleFodderAccurateRatio
  334. res.Data.SprinkleFodderCorrectRatio = sprinkleFodderCorrectRatio
  335. return res, nil
  336. }
  337. func (s *StoreEntry) TitleList(ctx context.Context, pastureAnalysisList map[int64]*model.PastureAnalysisAccuracyData) *model.Table {
  338. res := &model.Table{
  339. TitleList: make([]*model.TableList, 0),
  340. DataList: &model.DataList{
  341. MixedFodderAccurateRatio: make([]map[string]string, 0),
  342. MixedFodderCorrectRatio: make([]map[string]string, 0),
  343. SprinkleFodderAccurateRatio: make([]map[string]string, 0),
  344. SprinkleFodderCorrectRatio: make([]map[string]string, 0),
  345. },
  346. }
  347. for pastureId, data := range pastureAnalysisList {
  348. groupPasture, err := s.GetGroupPastureListById(ctx, pastureId)
  349. if err != nil {
  350. zaplog.Info("TitleList", zap.Any("GetGroupPastureListById", pastureId), zap.Any("err", err))
  351. continue
  352. }
  353. if len(res.TitleList) <= len(data.MixedFodderAccurateRatio) {
  354. res.TitleList = append(res.TitleList, &model.TableList{
  355. Name: "title",
  356. Value: "牧场",
  357. })
  358. }
  359. maMap := map[string]string{
  360. "title": groupPasture.Name,
  361. }
  362. for i, v := range data.MixedFodderCorrectRatio {
  363. maMap[fmt.Sprintf("data%d", i+1)] = fmt.Sprintf("%.2f", v.Ratio)
  364. if len(res.TitleList) <= len(data.MixedFodderAccurateRatio) {
  365. res.TitleList = append(res.TitleList, &model.TableList{
  366. Name: fmt.Sprintf("data%d", i+1),
  367. Value: v.DayTime,
  368. })
  369. }
  370. }
  371. res.DataList.MixedFodderAccurateRatio = append(res.DataList.MixedFodderAccurateRatio, maMap)
  372. mcMap := map[string]string{
  373. "title": groupPasture.Name,
  374. }
  375. for i, v := range data.MixedFodderCorrectRatio {
  376. mcMap[fmt.Sprintf("data%d", i+1)] = fmt.Sprintf("%.2f", v.Ratio)
  377. }
  378. res.DataList.MixedFodderCorrectRatio = append(res.DataList.MixedFodderCorrectRatio, mcMap)
  379. saMap := map[string]string{
  380. "title": groupPasture.Name,
  381. }
  382. for i, v := range data.SprinkleFodderAccurateRatio {
  383. saMap[fmt.Sprintf("data%d", i+1)] = fmt.Sprintf("%.2f", v.Ratio)
  384. }
  385. res.DataList.SprinkleFodderAccurateRatio = append(res.DataList.SprinkleFodderAccurateRatio, saMap)
  386. scMap := map[string]string{
  387. "title": groupPasture.Name,
  388. }
  389. for i, v := range data.SprinkleFodderCorrectRatio {
  390. scMap[fmt.Sprintf("data%d", i+1)] = fmt.Sprintf("%.2f", v.Ratio)
  391. }
  392. res.DataList.SprinkleFodderCorrectRatio = append(res.DataList.SprinkleFodderCorrectRatio, scMap)
  393. }
  394. return res
  395. }
  396. func (s *StoreEntry) ExecutionTime(ctx context.Context, req *operationPb.SearchAnalysisAccuracyRequest) (*model.ExecTimeResponse, error) {
  397. res := &model.ExecTimeResponse{
  398. Code: http.StatusOK,
  399. Msg: "ok",
  400. Data: &model.ExecTimeDataList{
  401. Chart: &model.ExecTimeDataListChart{
  402. Title: make([]string, 0),
  403. AddFeedTime: make([][]string, 0),
  404. SprinkleTime: make([][]string, 0),
  405. StirTime: make([][]string, 0),
  406. },
  407. TableList: make([]map[string]string, 0),
  408. },
  409. }
  410. pastureExecTime, err := s.PasturePrefExecTimeData(ctx, req)
  411. if err != nil {
  412. return nil, xerr.WithStack(err)
  413. }
  414. for pastureName, execTime := range pastureExecTime {
  415. res.Data.Chart.Title = append(res.Data.Chart.Title, pastureName)
  416. addFeedTimeStr, sprinkleTimeStr, stirTimeStr := make([]string, 0), make([]string, 0), make([]string, 0)
  417. if execTime != nil {
  418. addFeedTimeStr = append(addFeedTimeStr, execTime.AddFeedTime.MaxValue, execTime.AddFeedTime.UpMiddleValue,
  419. execTime.AddFeedTime.MiddleValue, execTime.AddFeedTime.DownMiddleValue, execTime.AddFeedTime.MinValue)
  420. sprinkleTimeStr = append(sprinkleTimeStr, execTime.SprinkleTime.MaxValue, execTime.SprinkleTime.UpMiddleValue,
  421. execTime.SprinkleTime.MiddleValue, execTime.SprinkleTime.DownMiddleValue, execTime.SprinkleTime.MinValue)
  422. stirTimeStr = append(stirTimeStr, execTime.StirTime.MaxValue, execTime.StirTime.UpMiddleValue,
  423. execTime.StirTime.MiddleValue, execTime.StirTime.DownMiddleValue, execTime.StirTime.MinValue)
  424. }
  425. res.Data.Chart.AddFeedTime = append(res.Data.Chart.AddFeedTime, addFeedTimeStr)
  426. res.Data.Chart.SprinkleTime = append(res.Data.Chart.SprinkleTime, sprinkleTimeStr)
  427. res.Data.Chart.StirTime = append(res.Data.Chart.StirTime, stirTimeStr)
  428. if execTime == nil {
  429. continue
  430. }
  431. tableList := map[string]string{
  432. "title": pastureName,
  433. "add_feed_time": "加料时间",
  434. "add_feed_time_max_value": execTime.AddFeedTime.MaxValue,
  435. "add_feed_time_up_middle_value": execTime.AddFeedTime.UpMiddleValue,
  436. "add_feed_time_middle_value": execTime.AddFeedTime.MiddleValue,
  437. "add_feed_time_down_middle_value": execTime.AddFeedTime.DownMiddleValue,
  438. "add_feed_time_min_value": execTime.AddFeedTime.MinValue,
  439. "sprinkle_time": "撒料时间",
  440. "sprinkle_time_max_value": execTime.SprinkleTime.MaxValue,
  441. "sprinkle_time_up_middle_value": execTime.SprinkleTime.UpMiddleValue,
  442. "sprinkle_time_middle_value": execTime.SprinkleTime.MiddleValue,
  443. "sprinkle_time_down_middle_value": execTime.SprinkleTime.DownMiddleValue,
  444. "sprinkle_time_min_value": execTime.SprinkleTime.MinValue,
  445. "stir_time": "搅拌延迟时间",
  446. "stir_time_max_value": execTime.StirTime.MaxValue,
  447. "stir_time_up_middle_value": execTime.StirTime.UpMiddleValue,
  448. "stir_time_middle_value": execTime.StirTime.MiddleValue,
  449. "stir_time_down_middle_value": execTime.StirTime.DownMiddleValue,
  450. "stir_time_min_value": execTime.StirTime.MinValue,
  451. }
  452. res.Data.TableList = append(res.Data.TableList, tableList)
  453. }
  454. return res, nil
  455. }
  456. func (s *StoreEntry) SprinkleFeedTime(ctx context.Context, req *operationPb.SprinkleFeedTimeRequest) (*model.SprinkleFeedTimeResponse, error) {
  457. res := &model.SprinkleFeedTimeResponse{
  458. Code: http.StatusOK,
  459. Msg: "ok",
  460. Data: &model.SprinkleFeedTimeData{
  461. Chart: &model.SprinkleFeedTimeChart{
  462. Title: make([]string, 0),
  463. SprinkleNumberList: make([][]int32, 0),
  464. },
  465. TableList: make([]*model.SprinkleFeedTimeTable, 0),
  466. },
  467. }
  468. pastureSprinkleDataList, err := s.PastureSprinkleFeedTime(ctx, req)
  469. if err != nil {
  470. return nil, xerr.WithStack(err)
  471. }
  472. tableList := make([]*model.SprinkleFeedTimeTable, 0)
  473. infoSprinkleNumber, errorSprinkleNumber := make([]int32, 0), make([]int32, 0)
  474. for pastureName, data := range pastureSprinkleDataList {
  475. sprinkleFeedTimeList := make(map[int32]map[int32][]int64, 0)
  476. for _, v := range data {
  477. tableList = append(tableList, &model.SprinkleFeedTimeTable{
  478. PastureName: pastureName,
  479. BarnName: v.FName,
  480. ClassNumber: fmt.Sprintf("%d", v.Times),
  481. RealitySprinkleFeedTime: tool.TimeSub(v.InTime, v.ProcessTime),
  482. })
  483. realityTime := tool.TimeSub(v.InTime, v.ProcessTime)
  484. realityTimeUnix, _ := time.Parse(model.LayoutTime, realityTime)
  485. if sprinkleFeedTimeList[v.FBarId] == nil {
  486. sprinkleFeedTimeList[v.FBarId] = make(map[int32][]int64, 0)
  487. }
  488. sprinkleFeedTimeList[v.FBarId][v.Times] = append(sprinkleFeedTimeList[v.FBarId][v.Times], realityTimeUnix.Unix())
  489. }
  490. res.Data.Chart.Title = append(res.Data.Chart.Title, pastureName)
  491. infoNumber, errNumber := sprinkleExecTimeAnalysis(sprinkleFeedTimeList)
  492. infoSprinkleNumber = append(infoSprinkleNumber, infoNumber)
  493. errorSprinkleNumber = append(errorSprinkleNumber, errNumber)
  494. }
  495. res.Data.Chart.SprinkleNumberList = append(res.Data.Chart.SprinkleNumberList, infoSprinkleNumber, errorSprinkleNumber)
  496. res.Data.TableList = tableList
  497. return res, nil
  498. }
  499. func sprinkleExecTimeAnalysis(sprinkleFeedTimeList map[int32]map[int32][]int64) (int32, int32) {
  500. var infoSprinkleNumber, errorSprinkleNumber int32 = 0, 0
  501. if len(sprinkleFeedTimeList) <= 0 {
  502. return infoSprinkleNumber, errorSprinkleNumber
  503. } else {
  504. for _, value := range sprinkleFeedTimeList {
  505. for _, execTimeList := range value {
  506. middleValue := tool.MedianInt64(execTimeList)
  507. for _, v := range execTimeList {
  508. if v >= middleValue-int64(compareTime) && v <= middleValue+int64(compareTime) {
  509. infoSprinkleNumber += 1
  510. } else {
  511. errorSprinkleNumber += 1
  512. }
  513. }
  514. }
  515. }
  516. }
  517. return infoSprinkleNumber, errorSprinkleNumber
  518. }