dashboard_service.go 34 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852
  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[int64][]*model.SprinkleStatisticsDataList, map[int64]*model.GroupPasture, error) {
  110. res, pastureList := make(map[int64][]*model.SprinkleStatisticsDataList), make(map[int64]*model.GroupPasture, 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.Id] = response.Data
  144. pastureList[groupPasture.Id] = groupPasture
  145. }(pasture)
  146. }
  147. wg.Wait()
  148. return res, pastureList, nil
  149. }
  150. func (s *StoreEntry) SearchAnalysisAccuracy(ctx context.Context, req *operationPb.SearchAnalysisAccuracyRequest) (*model.SearchAnalysisAccuracyResponse1, error) {
  151. res := &model.SearchAnalysisAccuracyResponse1{
  152. Code: http.StatusOK,
  153. Msg: "ok",
  154. Data: &model.AnalysisAccuracyData1{
  155. Table: &model.Table{
  156. TitleList: make([]*model.TableList, 0),
  157. DataList: &model.DataList{},
  158. },
  159. Chart: nil,
  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. res.Data.Table = s.TitleList(ctx, pastureAnalysisAccuracy)
  171. dashboardTopData, err := s.DashboardTopPasture(ctx, req)
  172. if err != nil {
  173. return nil, xerr.WithStack(err)
  174. }
  175. dashboardTopData1 := &model.Chart1{
  176. MixedFodderAccurateRatio: &model.PastureTopData1{
  177. Title: make([]string, 0),
  178. Ratio: make([]float64, 0),
  179. },
  180. MixedFodderCorrectRatio: &model.PastureTopData1{
  181. Title: make([]string, 0),
  182. Ratio: make([]float64, 0),
  183. },
  184. SprinkleFodderAccurateRatio: &model.PastureTopData1{
  185. Title: make([]string, 0),
  186. Ratio: make([]float64, 0),
  187. },
  188. SprinkleFodderCorrectRatio: &model.PastureTopData1{
  189. Title: make([]string, 0),
  190. Ratio: make([]float64, 0),
  191. },
  192. }
  193. maTitleValueList, mcTitleValueList, saTitleValueList, scTitleValueList := make([]float64, 0), make([]float64, 0), make([]float64, 0), make([]float64, 0)
  194. for pastureId, data := range pastureAnalysisAccuracy {
  195. if _, err = s.GetGroupPastureListById(ctx, pastureId); err != nil {
  196. zaplog.Error("SearchAnalysisAccuracy GetGroupPastureListById",
  197. zap.Any("pastureId", pastureId), zap.Any("error", err))
  198. continue
  199. }
  200. if data == nil {
  201. continue
  202. }
  203. mixedFodderAccurateRatioDataList := make([]string, 0)
  204. for _, v := range data.MixedFodderAccurateRatio {
  205. mixedFodderAccurateRatioDataList = append(mixedFodderAccurateRatioDataList, fmt.Sprintf("%.2f", v.Ratio))
  206. maTitleValueList = append(maTitleValueList, v.Ratio)
  207. }
  208. mixedFodderCorrectRatioDataList := make([]string, 0)
  209. for _, v := range data.MixedFodderCorrectRatio {
  210. mixedFodderCorrectRatioDataList = append(mixedFodderCorrectRatioDataList, fmt.Sprintf("%.2f", v.Ratio))
  211. mcTitleValueList = append(mcTitleValueList, v.Ratio)
  212. }
  213. sprinkleFodderRatioDataList := make([]string, 0)
  214. for _, v := range data.SprinkleFodderAccurateRatio {
  215. sprinkleFodderRatioDataList = append(sprinkleFodderRatioDataList, fmt.Sprintf("%.2f", v.Ratio))
  216. saTitleValueList = append(saTitleValueList, v.Ratio)
  217. }
  218. sprinkleFodderCorrectRatioDataList := make([]string, 0)
  219. for _, v := range data.SprinkleFodderCorrectRatio {
  220. sprinkleFodderCorrectRatioDataList = append(sprinkleFodderCorrectRatioDataList, fmt.Sprintf("%.2f", v.Ratio))
  221. scTitleValueList = append(scTitleValueList, v.Ratio)
  222. }
  223. }
  224. pastureTopDataList, err := s.TopPasture(ctx, req)
  225. if err != nil {
  226. zaplog.Error("SearchAnalysisAccuracy", zap.Any("TopPasture", err), zap.Any("request", req))
  227. return nil, xerr.WithStack(err)
  228. }
  229. sort.Float64s(maTitleValueList)
  230. dashboardTopData1.MixedFodderAccurateRatio.MaxValue = fmt.Sprintf("%.2f", maTitleValueList[len(maTitleValueList)-1])
  231. dashboardTopData1.MixedFodderAccurateRatio.MinValue = fmt.Sprintf("%.2f", maTitleValueList[0])
  232. dashboardTopData1.MixedFodderAccurateRatio.MiddleValue = fmt.Sprintf("%.2f", tool.Median(maTitleValueList))
  233. dashboardTopData1.MixedFodderAccurateRatio.TopOneName = pastureTopDataList.Data.MixedFodderAccurateRatio[0].PastureName
  234. sort.Float64s(mcTitleValueList)
  235. dashboardTopData1.MixedFodderCorrectRatio.MaxValue = fmt.Sprintf("%.2f", mcTitleValueList[len(mcTitleValueList)-1])
  236. dashboardTopData1.MixedFodderCorrectRatio.MinValue = fmt.Sprintf("%.2f", mcTitleValueList[0])
  237. dashboardTopData1.MixedFodderCorrectRatio.MiddleValue = fmt.Sprintf("%.2f", tool.Median(mcTitleValueList))
  238. dashboardTopData1.MixedFodderCorrectRatio.TopOneName = pastureTopDataList.Data.MixedFodderCorrectRatio[0].PastureName
  239. sort.Float64s(saTitleValueList)
  240. dashboardTopData1.SprinkleFodderAccurateRatio.MaxValue = fmt.Sprintf("%.2f", saTitleValueList[len(saTitleValueList)-1])
  241. dashboardTopData1.SprinkleFodderAccurateRatio.MinValue = fmt.Sprintf("%.2f", saTitleValueList[0])
  242. dashboardTopData1.SprinkleFodderAccurateRatio.MiddleValue = fmt.Sprintf("%.2f", tool.Median(saTitleValueList))
  243. dashboardTopData1.SprinkleFodderAccurateRatio.TopOneName = pastureTopDataList.Data.SprinkleFodderAccurateRatio[0].PastureName
  244. sort.Float64s(scTitleValueList)
  245. dashboardTopData1.SprinkleFodderCorrectRatio.MaxValue = fmt.Sprintf("%.2f", scTitleValueList[len(scTitleValueList)-1])
  246. dashboardTopData1.SprinkleFodderCorrectRatio.MinValue = fmt.Sprintf("%.2f", scTitleValueList[0])
  247. dashboardTopData1.SprinkleFodderCorrectRatio.MiddleValue = fmt.Sprintf("%.2f", tool.Median(scTitleValueList))
  248. dashboardTopData1.SprinkleFodderCorrectRatio.TopOneName = pastureTopDataList.Data.SprinkleFodderCorrectRatio[0].PastureName
  249. for _, v := range dashboardTopData.MixedFodderCorrectRatio {
  250. dashboardTopData1.MixedFodderCorrectRatio.Title = append(dashboardTopData1.MixedFodderCorrectRatio.Title, v.PastureName)
  251. dashboardTopData1.MixedFodderCorrectRatio.Ratio = append(dashboardTopData1.MixedFodderCorrectRatio.Ratio, v.Ratio)
  252. }
  253. for _, v := range dashboardTopData.MixedFodderAccurateRatio {
  254. dashboardTopData1.MixedFodderAccurateRatio.Title = append(dashboardTopData1.MixedFodderAccurateRatio.Title, v.PastureName)
  255. dashboardTopData1.MixedFodderAccurateRatio.Ratio = append(dashboardTopData1.MixedFodderAccurateRatio.Ratio, v.Ratio)
  256. }
  257. for _, v := range dashboardTopData.SprinkleFodderAccurateRatio {
  258. dashboardTopData1.SprinkleFodderAccurateRatio.Title = append(dashboardTopData1.SprinkleFodderAccurateRatio.Title, v.PastureName)
  259. dashboardTopData1.SprinkleFodderAccurateRatio.Ratio = append(dashboardTopData1.SprinkleFodderAccurateRatio.Ratio, v.Ratio)
  260. }
  261. for _, v := range dashboardTopData.SprinkleFodderCorrectRatio {
  262. dashboardTopData1.SprinkleFodderCorrectRatio.Title = append(dashboardTopData1.SprinkleFodderCorrectRatio.Title, v.PastureName)
  263. dashboardTopData1.SprinkleFodderCorrectRatio.Ratio = append(dashboardTopData1.SprinkleFodderCorrectRatio.Ratio, v.Ratio)
  264. }
  265. res.Data.Chart = dashboardTopData1
  266. return res, nil
  267. }
  268. func (s *StoreEntry) SearchAnalysisAccuracyOld(ctx context.Context, req *operationPb.SearchAnalysisAccuracyRequest) (*model.SearchAnalysisAccuracyResponse, error) {
  269. res := &model.SearchAnalysisAccuracyResponse{
  270. Code: http.StatusOK,
  271. Msg: "ok",
  272. Data: &model.AnalysisAccuracyData{
  273. Chart: &model.Chart{},
  274. Table: &model.Table{
  275. TitleList: make([]*model.TableList, 0),
  276. DataList: &model.DataList{},
  277. },
  278. },
  279. }
  280. res.Data.Table.TitleList = append(res.Data.Table.TitleList, &model.TableList{
  281. Name: "title",
  282. Value: "牧场",
  283. })
  284. pastureAnalysisAccuracy, err := s.PasturePrefAnalysisData(ctx, req)
  285. if err != nil {
  286. return nil, xerr.WithStack(err)
  287. }
  288. mixedFodderAccurateRatio, mixedFodderCorrectRatio, sprinkleFodderAccurateRatio, sprinkleFodderCorrectRatio :=
  289. &model.CommonValueRatio{}, &model.CommonValueRatio{}, &model.CommonValueRatio{}, &model.CommonValueRatio{}
  290. maTitleValueList, mcTitleValueList, saTitleValueList, scTitleValueList := make([]float64, 0), make([]float64, 0), make([]float64, 0), make([]float64, 0)
  291. dayTimeList := tool.TimeBetween(req.StartDate, req.EndDate)
  292. for pastureId, data := range pastureAnalysisAccuracy {
  293. groupPasture, err := s.GetGroupPastureListById(ctx, pastureId)
  294. if err != nil {
  295. zaplog.Error("SearchAnalysisAccuracy GetGroupPastureListById",
  296. zap.Any("pastureId", pastureId), zap.Any("error", err))
  297. continue
  298. }
  299. if data == nil {
  300. continue
  301. }
  302. mixedFodderAccurateRatioDataList := make([]string, 0)
  303. for _, v := range data.MixedFodderAccurateRatio {
  304. mixedFodderAccurateRatioDataList = append(mixedFodderAccurateRatioDataList, fmt.Sprintf("%.2f", v.Ratio))
  305. if len(mixedFodderAccurateRatio.DateDay) < len(dayTimeList) {
  306. mixedFodderAccurateRatio.DateDay = append(mixedFodderAccurateRatio.DateDay, v.DayTime)
  307. }
  308. maTitleValueList = append(maTitleValueList, v.Ratio)
  309. }
  310. mixedFodderAccurateRatio.DataList = append(mixedFodderAccurateRatio.DataList, mixedFodderAccurateRatioDataList)
  311. mixedFodderAccurateRatio.PastureIds = append(mixedFodderAccurateRatio.PastureIds, int32(pastureId))
  312. mixedFodderAccurateRatio.PastureName = append(mixedFodderAccurateRatio.PastureName, groupPasture.Name)
  313. mixedFodderCorrectRatioDataList := make([]string, 0)
  314. for _, v := range data.MixedFodderCorrectRatio {
  315. mixedFodderCorrectRatioDataList = append(mixedFodderCorrectRatioDataList, fmt.Sprintf("%.2f", v.Ratio))
  316. if len(mixedFodderCorrectRatio.DateDay) < len(dayTimeList) {
  317. mixedFodderCorrectRatio.DateDay = append(mixedFodderCorrectRatio.DateDay, v.DayTime)
  318. }
  319. mcTitleValueList = append(mcTitleValueList, v.Ratio)
  320. }
  321. mixedFodderCorrectRatio.DataList = append(mixedFodderCorrectRatio.DataList, mixedFodderCorrectRatioDataList)
  322. mixedFodderCorrectRatio.PastureIds = append(mixedFodderCorrectRatio.PastureIds, int32(pastureId))
  323. mixedFodderCorrectRatio.PastureName = append(mixedFodderCorrectRatio.PastureName, groupPasture.Name)
  324. sprinkleFodderRatioDataList := make([]string, 0)
  325. for _, v := range data.SprinkleFodderAccurateRatio {
  326. sprinkleFodderRatioDataList = append(sprinkleFodderRatioDataList, fmt.Sprintf("%.2f", v.Ratio))
  327. if len(sprinkleFodderAccurateRatio.DateDay) < len(dayTimeList) {
  328. sprinkleFodderAccurateRatio.DateDay = append(sprinkleFodderAccurateRatio.DateDay, v.DayTime)
  329. }
  330. saTitleValueList = append(saTitleValueList, v.Ratio)
  331. }
  332. sprinkleFodderAccurateRatio.DataList = append(sprinkleFodderAccurateRatio.DataList, sprinkleFodderRatioDataList)
  333. sprinkleFodderAccurateRatio.PastureIds = append(sprinkleFodderAccurateRatio.PastureIds, int32(pastureId))
  334. sprinkleFodderAccurateRatio.PastureName = append(sprinkleFodderAccurateRatio.PastureName, groupPasture.Name)
  335. sprinkleFodderCorrectRatioDataList := make([]string, 0)
  336. for _, v := range data.SprinkleFodderCorrectRatio {
  337. sprinkleFodderCorrectRatioDataList = append(sprinkleFodderCorrectRatioDataList, fmt.Sprintf("%.2f", v.Ratio))
  338. if len(sprinkleFodderCorrectRatio.DateDay) < len(dayTimeList) {
  339. sprinkleFodderCorrectRatio.DateDay = append(sprinkleFodderCorrectRatio.DateDay, v.DayTime)
  340. }
  341. scTitleValueList = append(scTitleValueList, v.Ratio)
  342. }
  343. sprinkleFodderCorrectRatio.DataList = append(sprinkleFodderCorrectRatio.DataList, sprinkleFodderCorrectRatioDataList)
  344. sprinkleFodderCorrectRatio.PastureIds = append(sprinkleFodderCorrectRatio.PastureIds, int32(pastureId))
  345. sprinkleFodderCorrectRatio.PastureName = append(sprinkleFodderCorrectRatio.PastureName, groupPasture.Name)
  346. }
  347. pastureTopDataList, err := s.TopPasture(ctx, req)
  348. if err != nil {
  349. zaplog.Error("SearchAnalysisAccuracy", zap.Any("TopPasture", err), zap.Any("request", req))
  350. return nil, xerr.WithStack(err)
  351. }
  352. sort.Float64s(maTitleValueList)
  353. mixedFodderAccurateRatio.MaxValue = fmt.Sprintf("%.2f", maTitleValueList[len(maTitleValueList)-1])
  354. mixedFodderAccurateRatio.MinValue = fmt.Sprintf("%.2f", maTitleValueList[0])
  355. mixedFodderAccurateRatio.MiddleValue = fmt.Sprintf("%.2f", tool.Median(maTitleValueList))
  356. mixedFodderAccurateRatio.TopOneName = pastureTopDataList.Data.MixedFodderAccurateRatio[0].PastureName
  357. sort.Float64s(mcTitleValueList)
  358. mixedFodderCorrectRatio.MaxValue = fmt.Sprintf("%.2f", mcTitleValueList[len(mcTitleValueList)-1])
  359. mixedFodderCorrectRatio.MinValue = fmt.Sprintf("%.2f", mcTitleValueList[0])
  360. mixedFodderCorrectRatio.MiddleValue = fmt.Sprintf("%.2f", tool.Median(mcTitleValueList))
  361. mixedFodderCorrectRatio.TopOneName = pastureTopDataList.Data.MixedFodderCorrectRatio[0].PastureName
  362. sort.Float64s(saTitleValueList)
  363. sprinkleFodderAccurateRatio.MaxValue = fmt.Sprintf("%.2f", saTitleValueList[len(saTitleValueList)-1])
  364. sprinkleFodderAccurateRatio.MinValue = fmt.Sprintf("%.2f", saTitleValueList[0])
  365. sprinkleFodderAccurateRatio.MiddleValue = fmt.Sprintf("%.2f", tool.Median(saTitleValueList))
  366. sprinkleFodderAccurateRatio.TopOneName = pastureTopDataList.Data.SprinkleFodderAccurateRatio[0].PastureName
  367. sort.Float64s(scTitleValueList)
  368. sprinkleFodderCorrectRatio.MaxValue = fmt.Sprintf("%.2f", scTitleValueList[len(scTitleValueList)-1])
  369. sprinkleFodderCorrectRatio.MinValue = fmt.Sprintf("%.2f", scTitleValueList[0])
  370. sprinkleFodderCorrectRatio.MiddleValue = fmt.Sprintf("%.2f", tool.Median(scTitleValueList))
  371. sprinkleFodderCorrectRatio.TopOneName = pastureTopDataList.Data.SprinkleFodderCorrectRatio[0].PastureName
  372. chart := &model.Chart{
  373. MixedFodderAccurateRatio: mixedFodderAccurateRatio,
  374. MixedFodderCorrectRatio: mixedFodderCorrectRatio,
  375. SprinkleFodderAccurateRatio: sprinkleFodderAccurateRatio,
  376. SprinkleFodderCorrectRatio: sprinkleFodderCorrectRatio,
  377. }
  378. res.Data.Chart = chart
  379. res.Data.Table = s.TitleList(ctx, pastureAnalysisAccuracy)
  380. return res, nil
  381. }
  382. // TopPasture 牧场排名
  383. func (s *StoreEntry) TopPasture(ctx context.Context, req *operationPb.SearchAnalysisAccuracyRequest) (*model.GetPastureTopResponse, error) {
  384. res := &model.GetPastureTopResponse{
  385. Code: http.StatusOK,
  386. Msg: "ok",
  387. Data: nil,
  388. }
  389. dashboardTopData, err := s.DashboardTopPasture(ctx, req)
  390. if err != nil {
  391. return nil, xerr.WithStack(err)
  392. }
  393. res.Data = dashboardTopData
  394. return res, nil
  395. }
  396. func (s *StoreEntry) DashboardTopPasture(ctx context.Context, req *operationPb.SearchAnalysisAccuracyRequest) (*model.PastureTop, error) {
  397. dashboardTopData := &model.PastureTop{
  398. MixedFodderAccurateRatio: make([]*model.PastureTopData, 0),
  399. MixedFodderCorrectRatio: make([]*model.PastureTopData, 0),
  400. SprinkleFodderAccurateRatio: make([]*model.PastureTopData, 0),
  401. SprinkleFodderCorrectRatio: make([]*model.PastureTopData, 0),
  402. }
  403. analysisAccuracy, err := s.PasturePrefAnalysisData(ctx, req)
  404. if err != nil {
  405. return nil, xerr.WithStack(err)
  406. }
  407. for pastureId, data := range analysisAccuracy {
  408. groupPasture, err := s.GetGroupPastureListById(ctx, pastureId)
  409. if err != nil {
  410. zaplog.Error("TopPasture", zap.Any("GetGroupPastureListById", pastureId), zap.Any("err", err))
  411. continue
  412. }
  413. if data == nil {
  414. continue
  415. }
  416. allMaRatio, allMcRatio, allSaRatio, allScRatio := 0.0, 0.0, 0.0, 0.0
  417. for _, v := range data.MixedFodderAccurateRatio {
  418. allMaRatio += v.Ratio
  419. }
  420. dashboardTopData.MixedFodderAccurateRatio = append(dashboardTopData.MixedFodderAccurateRatio, &model.PastureTopData{
  421. PastureName: groupPasture.Name,
  422. Ratio: tool.Decimal(allMaRatio / float64(len(data.MixedFodderAccurateRatio))),
  423. })
  424. for _, v := range data.MixedFodderCorrectRatio {
  425. allMcRatio += v.Ratio
  426. }
  427. dashboardTopData.MixedFodderCorrectRatio = append(dashboardTopData.MixedFodderCorrectRatio, &model.PastureTopData{
  428. PastureName: groupPasture.Name,
  429. Ratio: tool.Decimal(allMaRatio / float64(len(data.MixedFodderCorrectRatio))),
  430. })
  431. for _, v := range data.SprinkleFodderAccurateRatio {
  432. allSaRatio += v.Ratio
  433. }
  434. dashboardTopData.SprinkleFodderAccurateRatio = append(dashboardTopData.SprinkleFodderAccurateRatio, &model.PastureTopData{
  435. PastureName: groupPasture.Name,
  436. Ratio: tool.Decimal(allSaRatio / float64(len(data.SprinkleFodderAccurateRatio))),
  437. })
  438. for _, v := range data.SprinkleFodderCorrectRatio {
  439. allScRatio += v.Ratio
  440. }
  441. dashboardTopData.SprinkleFodderCorrectRatio = append(dashboardTopData.SprinkleFodderCorrectRatio, &model.PastureTopData{
  442. PastureName: groupPasture.Name,
  443. Ratio: tool.Decimal(allScRatio / float64(len(data.SprinkleFodderCorrectRatio))),
  444. })
  445. }
  446. sort.Slice(dashboardTopData.MixedFodderAccurateRatio, func(i, j int) bool {
  447. return dashboardTopData.MixedFodderAccurateRatio[i].Ratio > dashboardTopData.MixedFodderAccurateRatio[j].Ratio
  448. })
  449. sort.Slice(dashboardTopData.MixedFodderCorrectRatio, func(i, j int) bool {
  450. return dashboardTopData.MixedFodderCorrectRatio[i].Ratio > dashboardTopData.MixedFodderCorrectRatio[j].Ratio
  451. })
  452. sort.Slice(dashboardTopData.SprinkleFodderAccurateRatio, func(i, j int) bool {
  453. return dashboardTopData.SprinkleFodderAccurateRatio[i].Ratio > dashboardTopData.SprinkleFodderAccurateRatio[j].Ratio
  454. })
  455. sort.Slice(dashboardTopData.SprinkleFodderCorrectRatio, func(i, j int) bool {
  456. return dashboardTopData.SprinkleFodderCorrectRatio[i].Ratio > dashboardTopData.SprinkleFodderCorrectRatio[j].Ratio
  457. })
  458. if req.DashboardTopType > 0 {
  459. switch req.DashboardTopType {
  460. case operationPb.DashboardTopType_MIXED_ACCURATE:
  461. dashboardTopData.MixedFodderAccurateRatio = dashboardTopRand(req, dashboardTopData.MixedFodderAccurateRatio)
  462. case operationPb.DashboardTopType_MIXED_CORRECT:
  463. dashboardTopData.MixedFodderCorrectRatio = dashboardTopRand(req, dashboardTopData.MixedFodderCorrectRatio)
  464. case operationPb.DashboardTopType_SPRINKLE_ACCURATE:
  465. dashboardTopData.SprinkleFodderAccurateRatio = dashboardTopRand(req, dashboardTopData.SprinkleFodderAccurateRatio)
  466. case operationPb.DashboardTopType_Sprinkle_CORRECT:
  467. dashboardTopData.SprinkleFodderCorrectRatio = dashboardTopRand(req, dashboardTopData.SprinkleFodderCorrectRatio)
  468. }
  469. }
  470. return dashboardTopData, nil
  471. }
  472. func (s *StoreEntry) TitleList(ctx context.Context, pastureAnalysisList map[int64]*model.PastureAnalysisAccuracyData) *model.Table {
  473. res := &model.Table{
  474. TitleList: make([]*model.TableList, 0),
  475. DataList: &model.DataList{
  476. MixedFodderAccurateRatio: make([]map[string]string, 0),
  477. MixedFodderCorrectRatio: make([]map[string]string, 0),
  478. SprinkleFodderAccurateRatio: make([]map[string]string, 0),
  479. SprinkleFodderCorrectRatio: make([]map[string]string, 0),
  480. },
  481. }
  482. for pastureId, data := range pastureAnalysisList {
  483. groupPasture, err := s.GetGroupPastureListById(ctx, pastureId)
  484. if err != nil {
  485. zaplog.Info("TitleList", zap.Any("GetGroupPastureListById", pastureId), zap.Any("err", err))
  486. continue
  487. }
  488. if len(res.TitleList) <= len(data.MixedFodderAccurateRatio) {
  489. res.TitleList = append(res.TitleList, &model.TableList{
  490. Name: "title",
  491. Value: "牧场",
  492. })
  493. }
  494. maMap := map[string]string{
  495. "title": groupPasture.Name,
  496. }
  497. for i, v := range data.MixedFodderCorrectRatio {
  498. maMap[fmt.Sprintf("data%d", i+1)] = fmt.Sprintf("%.2f", v.Ratio)
  499. if len(res.TitleList) <= len(data.MixedFodderAccurateRatio) {
  500. res.TitleList = append(res.TitleList, &model.TableList{
  501. Name: fmt.Sprintf("data%d", i+1),
  502. Value: v.DayTime,
  503. })
  504. }
  505. }
  506. res.DataList.MixedFodderAccurateRatio = append(res.DataList.MixedFodderAccurateRatio, maMap)
  507. mcMap := map[string]string{
  508. "title": groupPasture.Name,
  509. }
  510. for i, v := range data.MixedFodderCorrectRatio {
  511. mcMap[fmt.Sprintf("data%d", i+1)] = fmt.Sprintf("%.2f", v.Ratio)
  512. }
  513. res.DataList.MixedFodderCorrectRatio = append(res.DataList.MixedFodderCorrectRatio, mcMap)
  514. saMap := map[string]string{
  515. "title": groupPasture.Name,
  516. }
  517. for i, v := range data.SprinkleFodderAccurateRatio {
  518. saMap[fmt.Sprintf("data%d", i+1)] = fmt.Sprintf("%.2f", v.Ratio)
  519. }
  520. res.DataList.SprinkleFodderAccurateRatio = append(res.DataList.SprinkleFodderAccurateRatio, saMap)
  521. scMap := map[string]string{
  522. "title": groupPasture.Name,
  523. }
  524. for i, v := range data.SprinkleFodderCorrectRatio {
  525. scMap[fmt.Sprintf("data%d", i+1)] = fmt.Sprintf("%.2f", v.Ratio)
  526. }
  527. res.DataList.SprinkleFodderCorrectRatio = append(res.DataList.SprinkleFodderCorrectRatio, scMap)
  528. }
  529. return res
  530. }
  531. func (s *StoreEntry) ExecutionTime(ctx context.Context, req *operationPb.SearchAnalysisAccuracyRequest) (*model.ExecTimeResponse, error) {
  532. res := &model.ExecTimeResponse{
  533. Code: http.StatusOK,
  534. Msg: "ok",
  535. Data: &model.ExecTimeDataList{
  536. Chart: &model.ExecTimeDataListChart{
  537. Title: make([]string, 0),
  538. AddFeedTime: make([][]string, 0),
  539. SprinkleTime: make([][]string, 0),
  540. StirTime: make([][]string, 0),
  541. },
  542. TableList: make([]map[string]string, 0),
  543. },
  544. }
  545. pastureExecTime, err := s.PasturePrefExecTimeData(ctx, req)
  546. if err != nil {
  547. return nil, xerr.WithStack(err)
  548. }
  549. for pastureName, execTime := range pastureExecTime {
  550. res.Data.Chart.Title = append(res.Data.Chart.Title, pastureName)
  551. addFeedTimeStr, sprinkleTimeStr, stirTimeStr := make([]string, 0), make([]string, 0), make([]string, 0)
  552. if execTime != nil {
  553. addFeedTimeStr = append(addFeedTimeStr, execTime.AddFeedTime.MaxValue, execTime.AddFeedTime.UpMiddleValue,
  554. execTime.AddFeedTime.MiddleValue, execTime.AddFeedTime.DownMiddleValue, execTime.AddFeedTime.MinValue)
  555. sprinkleTimeStr = append(sprinkleTimeStr, execTime.SprinkleTime.MaxValue, execTime.SprinkleTime.UpMiddleValue,
  556. execTime.SprinkleTime.MiddleValue, execTime.SprinkleTime.DownMiddleValue, execTime.SprinkleTime.MinValue)
  557. stirTimeStr = append(stirTimeStr, execTime.StirTime.MaxValue, execTime.StirTime.UpMiddleValue,
  558. execTime.StirTime.MiddleValue, execTime.StirTime.DownMiddleValue, execTime.StirTime.MinValue)
  559. }
  560. res.Data.Chart.AddFeedTime = append(res.Data.Chart.AddFeedTime, addFeedTimeStr)
  561. res.Data.Chart.SprinkleTime = append(res.Data.Chart.SprinkleTime, sprinkleTimeStr)
  562. res.Data.Chart.StirTime = append(res.Data.Chart.StirTime, stirTimeStr)
  563. if execTime == nil {
  564. continue
  565. }
  566. tableList := map[string]string{
  567. "title": pastureName,
  568. "add_feed_time": "加料时间",
  569. "add_feed_time_max_value": execTime.AddFeedTime.MaxValue,
  570. "add_feed_time_up_middle_value": execTime.AddFeedTime.UpMiddleValue,
  571. "add_feed_time_middle_value": execTime.AddFeedTime.MiddleValue,
  572. "add_feed_time_down_middle_value": execTime.AddFeedTime.DownMiddleValue,
  573. "add_feed_time_min_value": execTime.AddFeedTime.MinValue,
  574. "sprinkle_time": "撒料时间",
  575. "sprinkle_time_max_value": execTime.SprinkleTime.MaxValue,
  576. "sprinkle_time_up_middle_value": execTime.SprinkleTime.UpMiddleValue,
  577. "sprinkle_time_middle_value": execTime.SprinkleTime.MiddleValue,
  578. "sprinkle_time_down_middle_value": execTime.SprinkleTime.DownMiddleValue,
  579. "sprinkle_time_min_value": execTime.SprinkleTime.MinValue,
  580. "stir_time": "搅拌延迟时间",
  581. "stir_time_max_value": execTime.StirTime.MaxValue,
  582. "stir_time_up_middle_value": execTime.StirTime.UpMiddleValue,
  583. "stir_time_middle_value": execTime.StirTime.MiddleValue,
  584. "stir_time_down_middle_value": execTime.StirTime.DownMiddleValue,
  585. "stir_time_min_value": execTime.StirTime.MinValue,
  586. }
  587. res.Data.TableList = append(res.Data.TableList, tableList)
  588. }
  589. return res, nil
  590. }
  591. func (s *StoreEntry) SprinkleFeedTime(ctx context.Context, req *operationPb.SprinkleFeedTimeRequest) (*model.SprinkleFeedTimeResponse, error) {
  592. res := &model.SprinkleFeedTimeResponse{
  593. Code: http.StatusOK,
  594. Msg: "ok",
  595. Data: &model.SprinkleFeedTimeData{
  596. Chart: &model.SprinkleFeedTimeChart{
  597. Title: make([]string, 0),
  598. SprinkleNumberList: make([][]int32, 0),
  599. },
  600. TableList: make([]*model.SprinkleFeedTimeTable, 0),
  601. },
  602. }
  603. pastureSprinkleDataList, pastureList, err := s.PastureSprinkleFeedTime(ctx, req)
  604. if err != nil {
  605. return nil, xerr.WithStack(err)
  606. }
  607. tableList := make([]*model.SprinkleFeedTimeTable, 0)
  608. infoSprinkleNumber, errorSprinkleNumber, pastureIds := make([]int32, 0), make([]int32, 0), make([]int, 0)
  609. for pastureId, _ := range pastureSprinkleDataList {
  610. pastureIds = append(pastureIds, int(pastureId))
  611. }
  612. sort.Ints(pastureIds)
  613. pastureInfo := &model.GroupPasture{}
  614. for _, pastureId := range pastureIds {
  615. if pastureData, ok := pastureList[int64(pastureId)]; ok {
  616. pastureInfo = pastureData
  617. }
  618. if data, ok := pastureSprinkleDataList[int64(pastureId)]; ok {
  619. sprinkleFeedTimeList := make(map[int32]map[int32][]int64, 0)
  620. for _, v := range data {
  621. tableList = append(tableList, &model.SprinkleFeedTimeTable{
  622. PastureName: pastureInfo.Name,
  623. BarnName: v.FName,
  624. ClassNumber: fmt.Sprintf("%d", v.Times),
  625. RealitySprinkleFeedTime: tool.TimeSub(v.InTime, v.ProcessTime),
  626. })
  627. realityTime := tool.TimeSub(v.InTime, v.ProcessTime)
  628. realityTimeUnix, _ := time.Parse(model.LayoutTime, realityTime)
  629. if sprinkleFeedTimeList[v.FBarId] == nil {
  630. sprinkleFeedTimeList[v.FBarId] = make(map[int32][]int64, 0)
  631. }
  632. sprinkleFeedTimeList[v.FBarId][v.Times] = append(sprinkleFeedTimeList[v.FBarId][v.Times], realityTimeUnix.Unix())
  633. }
  634. res.Data.Chart.Title = append(res.Data.Chart.Title, pastureInfo.Name)
  635. infoNumber, errNumber := sprinkleExecTimeAnalysis(sprinkleFeedTimeList)
  636. infoSprinkleNumber = append(infoSprinkleNumber, infoNumber)
  637. errorSprinkleNumber = append(errorSprinkleNumber, errNumber)
  638. }
  639. }
  640. res.Data.Chart.SprinkleNumberList = append(res.Data.Chart.SprinkleNumberList, infoSprinkleNumber, errorSprinkleNumber)
  641. res.Data.TableList = tableList
  642. return res, nil
  643. }
  644. func (s *StoreEntry) FeedMixedAndTmrName(ctx context.Context, req *operationPb.MixedCategoryTmrName) (*model.PastureCommonResponse, error) {
  645. groupPasture, err := s.GetGroupPastureListById(ctx, int64(req.PastureId))
  646. if err != nil {
  647. return nil, xerr.WithStack(err)
  648. }
  649. pastureId := req.PastureId
  650. if groupPasture.PastureId > 0 {
  651. pastureId = int32(groupPasture.PastureId)
  652. }
  653. body := &model.PastureCommonRequest{
  654. Name: req.ApiName,
  655. ReturnType: "Map",
  656. ParamMaps: &model.MixedCategoryTmrNameParams{
  657. PastureId: fmt.Sprintf("%d", pastureId),
  658. StartTime: req.StartTime,
  659. EndTime: req.EndTime,
  660. },
  661. }
  662. response := &model.PastureCommonResponse{Data: &model.PastureCommonData{}}
  663. if err = s.PastureHttpClient(ctx, model.UrlDataByName, int64(req.PastureId), body, response); err != nil {
  664. return nil, xerr.WithStack(err)
  665. }
  666. return response, nil
  667. }
  668. func (s *StoreEntry) FeedTemplateHistory(ctx context.Context, req *operationPb.FeedTemplateHistoryRequest) (*model.PastureFeedTemplateHistoryResponse, error) {
  669. groupPasture, err := s.GetGroupPastureListById(ctx, int64(req.PastureId))
  670. if err != nil {
  671. return nil, xerr.WithStack(err)
  672. }
  673. pastureId := req.PastureId
  674. if groupPasture.PastureId > 0 {
  675. pastureId = int32(groupPasture.PastureId)
  676. }
  677. body := &model.PastureFeedTemplateHistoryRequest{
  678. PastureId: fmt.Sprintf("%d", pastureId),
  679. FTid: int64(req.Ftid),
  680. StartDate: req.StartTime,
  681. EndDate: req.EndTime,
  682. }
  683. response := &model.PastureFeedTemplateHistoryResponse{}
  684. if err = s.PastureHttpClient(ctx, model.UrlFeedTemplateHistory, int64(req.PastureId), body, response); err != nil {
  685. return nil, xerr.WithStack(err)
  686. }
  687. return response, nil
  688. }
  689. func (s *StoreEntry) BarnHistory(ctx context.Context, req *operationPb.BarnHistoryRequest) (*model.PastureBarnHistoryResponse, error) {
  690. _, err := s.GetGroupPastureListById(ctx, int64(req.PastureId))
  691. if err != nil {
  692. return nil, xerr.WithStack(err)
  693. }
  694. body := &model.PastureBarnHistoryRequest{
  695. BarName: req.BarnName,
  696. StartDate: req.StartTime,
  697. EndDate: req.EndTime,
  698. }
  699. response := &model.PastureBarnHistoryResponse{}
  700. if err = s.PastureHttpClient(ctx, model.UrlBarnHistory, int64(req.PastureId), body, response); err != nil {
  701. return nil, xerr.WithStack(err)
  702. }
  703. return response, nil
  704. }
  705. func (s *StoreEntry) SpillageAllHistory(ctx context.Context, req *operationPb.BarnHistoryRequest) (*model.PastureBarnHistoryResponse, error) {
  706. groupPasture, err := s.GetGroupPastureListById(ctx, int64(req.PastureId))
  707. if err != nil {
  708. return nil, xerr.WithStack(err)
  709. }
  710. pastureId := req.PastureId
  711. if groupPasture.PastureId > 0 {
  712. pastureId = int32(groupPasture.PastureId)
  713. }
  714. body := &model.PastureBarnHistoryRequest{
  715. PastureId: fmt.Sprintf("%d", pastureId),
  716. BarName: req.BarnName,
  717. StartDate: req.StartTime,
  718. EndDate: req.EndTime,
  719. }
  720. response := &model.PastureBarnHistoryResponse{}
  721. if err = s.PastureHttpClient(ctx, model.UrlSpillageAllHistory, int64(req.PastureId), body, response); err != nil {
  722. return nil, xerr.WithStack(err)
  723. }
  724. return response, nil
  725. }
  726. func sprinkleExecTimeAnalysis(sprinkleFeedTimeList map[int32]map[int32][]int64) (int32, int32) {
  727. var infoSprinkleNumber, errorSprinkleNumber int32 = 0, 0
  728. if len(sprinkleFeedTimeList) <= 0 {
  729. return infoSprinkleNumber, errorSprinkleNumber
  730. } else {
  731. for _, value := range sprinkleFeedTimeList {
  732. for _, execTimeList := range value {
  733. middleValue := tool.MedianInt64(execTimeList)
  734. for _, v := range execTimeList {
  735. if v >= middleValue-int64(compareTime) && v <= middleValue+int64(compareTime) {
  736. infoSprinkleNumber += 1
  737. } else {
  738. errorSprinkleNumber += 1
  739. }
  740. }
  741. }
  742. }
  743. }
  744. return infoSprinkleNumber, errorSprinkleNumber
  745. }
  746. func dashboardTopRand(req *operationPb.SearchAnalysisAccuracyRequest, data []*model.PastureTopData) []*model.PastureTopData {
  747. if req.TopRandStart < 0 || req.TopRandEnd < 0 || req.TopRandStart > req.TopRandEnd {
  748. return data
  749. }
  750. res := make([]*model.PastureTopData, 0)
  751. for _, v := range data {
  752. if v.Ratio >= float64(req.TopRandStart) && v.Ratio <= float64(req.TopRandEnd) {
  753. res = append(res, v)
  754. }
  755. }
  756. return res
  757. }