dashboard_service.go 28 KB

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