From c4eede11145be76fae4ded04a697a79788b8e3ba Mon Sep 17 00:00:00 2001 From: zzw <1464003642@qq.com> Date: Tue, 27 Oct 2026 09:01:36 +0800 Subject: [PATCH] feat: analysis user status --- rpc/analysis/analysis.pb | Bin 17987 -> 20762 bytes rpc/analysis/analysis.proto | 200 ++++ rpc/analysis/pb/analysis.pb.go | 949 +++++++++++++++++- rpc/analysis/pb/analysis_grpc.pb.go | 722 +++++++++++++ services/analysis/client/analysis/analysis.go | 115 +++ .../client/analysisuser/analysisUser.go | 14 + services/analysis/internal/config/wechat.go | 6 + services/analysis/internal/dao/banner.go | 8 + services/analysis/internal/dao/facepp.go | 64 ++ services/analysis/internal/dao/graph.go | 39 + services/analysis/internal/dao/view.go | 41 + .../internal/logic/analysis/bannersLogic.go | 47 + .../logic/analysis/deviceUpdateLogic.go | 93 ++ .../internal/logic/analysis/facepp.go | 188 ++++ .../logic/analysis/faceppMapBoxDeleteLogic.go | 60 ++ .../logic/analysis/faceppMapBoxesLogic.go | 47 + .../logic/analysis/faceppMapsLogic.go | 43 + .../internal/logic/analysis/gallery.go | 146 +++ .../logic/analysis/graphDetailLogic.go | 80 ++ .../logic/analysis/imagesDateLogic.go | 50 + .../logic/analysis/imagesListLogic.go | 71 ++ .../internal/logic/analysis/logLogic.go | 35 + .../internal/logic/analysis/modeImageLogic.go | 70 ++ .../internal/logic/analysis/overviewLogic.go | 105 ++ .../internal/logic/analysis/params.go | 11 + .../logic/analysis/qrcodeShareLogic.go | 157 +++ .../internal/logic/analysis/support.go | 133 +++ .../logic/analysis/userDetailLogic.go | 62 ++ .../logic/analysis/userFaceppLogic.go | 55 + .../internal/logic/analysis/userLogLogic.go | 35 + .../internal/logic/analysis/userLogic.go | 181 ++++ .../internal/logic/analysis/userModeLogic.go | 32 + .../logic/analysisuser/userLogDeleteLogic.go | 88 ++ .../logic/analysisuser/userStatusLogic.go | 55 + .../internal/logic/common/authUser.go | 82 ++ services/analysis/internal/model/banner.go | 16 + services/analysis/internal/model/facepp.go | 49 + services/analysis/internal/model/graph.go | 29 + services/analysis/internal/model/image.go | 24 + .../server/analysis/analysisServer.go | 85 ++ .../server/analysisuser/analysisUserServer.go | 10 + services/analysis/validator/view.go | 152 +++ 42 files changed, 4401 insertions(+), 48 deletions(-) create mode 100644 services/analysis/internal/dao/banner.go create mode 100644 services/analysis/internal/dao/facepp.go create mode 100644 services/analysis/internal/dao/graph.go create mode 100644 services/analysis/internal/dao/view.go create mode 100644 services/analysis/internal/logic/analysis/bannersLogic.go create mode 100644 services/analysis/internal/logic/analysis/deviceUpdateLogic.go create mode 100644 services/analysis/internal/logic/analysis/facepp.go create mode 100644 services/analysis/internal/logic/analysis/faceppMapBoxDeleteLogic.go create mode 100644 services/analysis/internal/logic/analysis/faceppMapBoxesLogic.go create mode 100644 services/analysis/internal/logic/analysis/faceppMapsLogic.go create mode 100644 services/analysis/internal/logic/analysis/gallery.go create mode 100644 services/analysis/internal/logic/analysis/graphDetailLogic.go create mode 100644 services/analysis/internal/logic/analysis/imagesDateLogic.go create mode 100644 services/analysis/internal/logic/analysis/imagesListLogic.go create mode 100644 services/analysis/internal/logic/analysis/logLogic.go create mode 100644 services/analysis/internal/logic/analysis/modeImageLogic.go create mode 100644 services/analysis/internal/logic/analysis/overviewLogic.go create mode 100644 services/analysis/internal/logic/analysis/params.go create mode 100644 services/analysis/internal/logic/analysis/qrcodeShareLogic.go create mode 100644 services/analysis/internal/logic/analysis/support.go create mode 100644 services/analysis/internal/logic/analysis/userDetailLogic.go create mode 100644 services/analysis/internal/logic/analysis/userFaceppLogic.go create mode 100644 services/analysis/internal/logic/analysis/userLogLogic.go create mode 100644 services/analysis/internal/logic/analysis/userLogic.go create mode 100644 services/analysis/internal/logic/analysis/userModeLogic.go create mode 100644 services/analysis/internal/logic/analysisuser/userLogDeleteLogic.go create mode 100644 services/analysis/internal/logic/analysisuser/userStatusLogic.go create mode 100644 services/analysis/internal/logic/common/authUser.go create mode 100644 services/analysis/internal/model/banner.go create mode 100644 services/analysis/internal/model/facepp.go create mode 100644 services/analysis/internal/model/graph.go create mode 100644 services/analysis/validator/view.go diff --git a/rpc/analysis/analysis.pb b/rpc/analysis/analysis.pb index f25940de8591348b2da7a5e6e0411e1cefa7b761..c66c38e0397f12b3cfc634a901f2a3b752c4f447 100644 GIT binary patch delta 2036 zcmb7F&uBo&vFlP2giC@q0YqG7qyLdNg zLn|Tm+(Xs9^;oHwo+?G{sTahNQ-#D|fVd&`)=Lkad2j7qiv+^$?Yx<9zWLtF?9(3- zKmU^Wy*iV8abdSMV-GIzX&71aWM|pgsL7V}WnDgGBapJ1o{^YL6;pLO@?jVvuN7bT zTOPV_fXruY*WaP@B7A`1!P5M3U?Lnn2s=F>5Bi9=prp!o=-wOCfaQ*HN;V8R)CD_c$RNDwxJ<<->g6Tz}vE?`?FVJ zxF)x)b-Cs?h3R1`zYLN^K4l8mGPlcSw*oT;Xf{<# z60X#^x_j8+2si9g#9TfY<`=2~3G)GDi0d_cZpI=+HEJkHPeiKCq^6*tJ9=>TkUbQ! z6fYpu|1Jzxg>B1@w^t$~`0L}sY#7$iew3;Ox!Bw>Bcd3YgGy!mwyDHC&8PPh^Pw7F z)1&zfkz>;uM~<1PD{j6MdV{7u_E28}^hVs<`=K73SA5U$;(mOU;`*V?ws1Y-{2kG!W4}Km13UHyk81biSY3Nm>f4_0%C|+CX^=bR%R5<=?@JGG7 IT>UroKP=*%>i_@% delta 40 ycmV+@0N4MTq5;E<0kA?f0{@0Ru9s2eYb3sspnoP4ojm{ST7> diff --git a/rpc/analysis/analysis.proto b/rpc/analysis/analysis.proto index a7ca872..be2bbb7 100644 --- a/rpc/analysis/analysis.proto +++ b/rpc/analysis/analysis.proto @@ -29,6 +29,125 @@ service Analysis { body: "*" }; } + + rpc Log(LogReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/log" + body: "*" + }; + } + + rpc Overview(OverviewReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/overview" + body: "*" + }; + } + + rpc User(UserReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/user" + body: "*" + }; + } + + rpc UserDetail(UserDetailReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/user/detail" + body: "*" + }; + } + + rpc UserFacepp(TaskIdReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/user/facepp" + body: "*" + }; + } + + rpc UserMode(EmptyReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/user/mode" + body: "*" + }; + } + + rpc UserLog(LogReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/user/log" + body: "*" + }; + } + + rpc Banners(EmptyReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/banners" + body: "*" + }; + } + + rpc QrcodeShare(QrcodeShareReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/qrcode/share" + body: "*" + }; + } + + rpc GraphDetail(GraphDetailReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/graph/detail" + body: "*" + }; + } + + rpc FaceppMaps(TaskIdReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/user/facepp/maps" + body: "*" + }; + } + + rpc FaceppMapBoxes(FaceppMapBoxesReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/user/facepp/maps/boxes" + body: "*" + }; + } + + rpc FaceppMapBoxDelete(IdReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/user/facepp/maps/boxes/delete" + body: "*" + }; + } + + rpc ImagesDate(ImagesDateReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/user/images/date" + body: "*" + }; + } + + rpc ImagesList(ImagesListReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/user/images/list" + body: "*" + }; + } + + rpc ModeImage(TaskIdReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/common/user/mode/image" + body: "*" + }; + } + + rpc DeviceUpdate(DeviceUpdateReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/device/update" + body: "*" + }; + } } service AnalysisUser { @@ -94,6 +213,20 @@ service AnalysisUser { body: "*" }; } + + rpc UserLogDelete(UserLogDeleteReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/user/log/delete" + body: "*" + }; + } + + rpc UserStatus(UserStatusReq) returns (Response) { + option (google.api.http) = { + post: "/api/v2/analysis/user/status" + body: "*" + }; + } } service AnalysisStore { @@ -294,3 +427,70 @@ message OssCallbackReq { message OssCallbackResp { string Status = 1 [json_name = "Status"]; } + +message UserLogDeleteReq { + repeated int64 ids = 1; +} + +message UserStatusReq {} + +message EmptyReq {} + +message LogReq { + int64 user_id = 1; + int32 page = 2; + int32 size = 3; +} + +message OverviewReq { + int64 user_id = 1; + int64 id = 2; +} + +message UserReq { + int64 user_id = 1; +} + +message UserDetailReq { + int64 id = 1; +} + +message TaskIdReq { + string task_id = 1; +} + +message QrcodeShareReq { + repeated int64 ids = 1; +} + +message GraphDetailReq { + int32 type = 1; +} + +message FaceppMapBoxesReq { + int64 id = 1; + string boxes = 2; +} + +message IdReq { + int64 id = 1; +} + +message ImagesDateReq { + int64 user_id = 1; + string start_time = 2; + string end_time = 3; +} + +message ImagesListReq { + int64 user_id = 1; + string mode = 2; + string position = 3; + string start_time = 4; + string end_time = 5; +} + +message DeviceUpdateReq { + int64 id = 1; + string device_name = 2; +} diff --git a/rpc/analysis/pb/analysis.pb.go b/rpc/analysis/pb/analysis.pb.go index 460ad60..3195050 100644 --- a/rpc/analysis/pb/analysis.pb.go +++ b/rpc/analysis/pb/analysis.pb.go @@ -1454,6 +1454,738 @@ func (x *OssCallbackResp) GetStatus() string { return "" } +type UserLogDeleteReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + Ids []int64 `protobuf:"varint,1,rep,packed,name=ids,proto3" json:"ids,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UserLogDeleteReq) Reset() { + *x = UserLogDeleteReq{} + mi := &file_analysis_analysis_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UserLogDeleteReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UserLogDeleteReq) ProtoMessage() {} + +func (x *UserLogDeleteReq) ProtoReflect() protoreflect.Message { + mi := &file_analysis_analysis_proto_msgTypes[28] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UserLogDeleteReq.ProtoReflect.Descriptor instead. +func (*UserLogDeleteReq) Descriptor() ([]byte, []int) { + return file_analysis_analysis_proto_rawDescGZIP(), []int{28} +} + +func (x *UserLogDeleteReq) GetIds() []int64 { + if x != nil { + return x.Ids + } + return nil +} + +type UserStatusReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UserStatusReq) Reset() { + *x = UserStatusReq{} + mi := &file_analysis_analysis_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UserStatusReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UserStatusReq) ProtoMessage() {} + +func (x *UserStatusReq) ProtoReflect() protoreflect.Message { + mi := &file_analysis_analysis_proto_msgTypes[29] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UserStatusReq.ProtoReflect.Descriptor instead. +func (*UserStatusReq) Descriptor() ([]byte, []int) { + return file_analysis_analysis_proto_rawDescGZIP(), []int{29} +} + +type EmptyReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *EmptyReq) Reset() { + *x = EmptyReq{} + mi := &file_analysis_analysis_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *EmptyReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EmptyReq) ProtoMessage() {} + +func (x *EmptyReq) ProtoReflect() protoreflect.Message { + mi := &file_analysis_analysis_proto_msgTypes[30] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EmptyReq.ProtoReflect.Descriptor instead. +func (*EmptyReq) Descriptor() ([]byte, []int) { + return file_analysis_analysis_proto_rawDescGZIP(), []int{30} +} + +type LogReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + UserId int64 `protobuf:"varint,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"` + Page int32 `protobuf:"varint,2,opt,name=page,proto3" json:"page,omitempty"` + Size int32 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *LogReq) Reset() { + *x = LogReq{} + mi := &file_analysis_analysis_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *LogReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LogReq) ProtoMessage() {} + +func (x *LogReq) ProtoReflect() protoreflect.Message { + mi := &file_analysis_analysis_proto_msgTypes[31] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LogReq.ProtoReflect.Descriptor instead. +func (*LogReq) Descriptor() ([]byte, []int) { + return file_analysis_analysis_proto_rawDescGZIP(), []int{31} +} + +func (x *LogReq) GetUserId() int64 { + if x != nil { + return x.UserId + } + return 0 +} + +func (x *LogReq) GetPage() int32 { + if x != nil { + return x.Page + } + return 0 +} + +func (x *LogReq) GetSize() int32 { + if x != nil { + return x.Size + } + return 0 +} + +type OverviewReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + UserId int64 `protobuf:"varint,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"` + Id int64 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *OverviewReq) Reset() { + *x = OverviewReq{} + mi := &file_analysis_analysis_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *OverviewReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OverviewReq) ProtoMessage() {} + +func (x *OverviewReq) ProtoReflect() protoreflect.Message { + mi := &file_analysis_analysis_proto_msgTypes[32] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OverviewReq.ProtoReflect.Descriptor instead. +func (*OverviewReq) Descriptor() ([]byte, []int) { + return file_analysis_analysis_proto_rawDescGZIP(), []int{32} +} + +func (x *OverviewReq) GetUserId() int64 { + if x != nil { + return x.UserId + } + return 0 +} + +func (x *OverviewReq) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +type UserReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + UserId int64 `protobuf:"varint,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UserReq) Reset() { + *x = UserReq{} + mi := &file_analysis_analysis_proto_msgTypes[33] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UserReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UserReq) ProtoMessage() {} + +func (x *UserReq) ProtoReflect() protoreflect.Message { + mi := &file_analysis_analysis_proto_msgTypes[33] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UserReq.ProtoReflect.Descriptor instead. +func (*UserReq) Descriptor() ([]byte, []int) { + return file_analysis_analysis_proto_rawDescGZIP(), []int{33} +} + +func (x *UserReq) GetUserId() int64 { + if x != nil { + return x.UserId + } + return 0 +} + +type UserDetailReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UserDetailReq) Reset() { + *x = UserDetailReq{} + mi := &file_analysis_analysis_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UserDetailReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UserDetailReq) ProtoMessage() {} + +func (x *UserDetailReq) ProtoReflect() protoreflect.Message { + mi := &file_analysis_analysis_proto_msgTypes[34] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UserDetailReq.ProtoReflect.Descriptor instead. +func (*UserDetailReq) Descriptor() ([]byte, []int) { + return file_analysis_analysis_proto_rawDescGZIP(), []int{34} +} + +func (x *UserDetailReq) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +type TaskIdReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + TaskId string `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TaskIdReq) Reset() { + *x = TaskIdReq{} + mi := &file_analysis_analysis_proto_msgTypes[35] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TaskIdReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TaskIdReq) ProtoMessage() {} + +func (x *TaskIdReq) ProtoReflect() protoreflect.Message { + mi := &file_analysis_analysis_proto_msgTypes[35] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TaskIdReq.ProtoReflect.Descriptor instead. +func (*TaskIdReq) Descriptor() ([]byte, []int) { + return file_analysis_analysis_proto_rawDescGZIP(), []int{35} +} + +func (x *TaskIdReq) GetTaskId() string { + if x != nil { + return x.TaskId + } + return "" +} + +type QrcodeShareReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + Ids []int64 `protobuf:"varint,1,rep,packed,name=ids,proto3" json:"ids,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *QrcodeShareReq) Reset() { + *x = QrcodeShareReq{} + mi := &file_analysis_analysis_proto_msgTypes[36] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *QrcodeShareReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QrcodeShareReq) ProtoMessage() {} + +func (x *QrcodeShareReq) ProtoReflect() protoreflect.Message { + mi := &file_analysis_analysis_proto_msgTypes[36] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use QrcodeShareReq.ProtoReflect.Descriptor instead. +func (*QrcodeShareReq) Descriptor() ([]byte, []int) { + return file_analysis_analysis_proto_rawDescGZIP(), []int{36} +} + +func (x *QrcodeShareReq) GetIds() []int64 { + if x != nil { + return x.Ids + } + return nil +} + +type GraphDetailReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + Type int32 `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GraphDetailReq) Reset() { + *x = GraphDetailReq{} + mi := &file_analysis_analysis_proto_msgTypes[37] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GraphDetailReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GraphDetailReq) ProtoMessage() {} + +func (x *GraphDetailReq) ProtoReflect() protoreflect.Message { + mi := &file_analysis_analysis_proto_msgTypes[37] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GraphDetailReq.ProtoReflect.Descriptor instead. +func (*GraphDetailReq) Descriptor() ([]byte, []int) { + return file_analysis_analysis_proto_rawDescGZIP(), []int{37} +} + +func (x *GraphDetailReq) GetType() int32 { + if x != nil { + return x.Type + } + return 0 +} + +type FaceppMapBoxesReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Boxes string `protobuf:"bytes,2,opt,name=boxes,proto3" json:"boxes,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FaceppMapBoxesReq) Reset() { + *x = FaceppMapBoxesReq{} + mi := &file_analysis_analysis_proto_msgTypes[38] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FaceppMapBoxesReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FaceppMapBoxesReq) ProtoMessage() {} + +func (x *FaceppMapBoxesReq) ProtoReflect() protoreflect.Message { + mi := &file_analysis_analysis_proto_msgTypes[38] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FaceppMapBoxesReq.ProtoReflect.Descriptor instead. +func (*FaceppMapBoxesReq) Descriptor() ([]byte, []int) { + return file_analysis_analysis_proto_rawDescGZIP(), []int{38} +} + +func (x *FaceppMapBoxesReq) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *FaceppMapBoxesReq) GetBoxes() string { + if x != nil { + return x.Boxes + } + return "" +} + +type IdReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *IdReq) Reset() { + *x = IdReq{} + mi := &file_analysis_analysis_proto_msgTypes[39] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *IdReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IdReq) ProtoMessage() {} + +func (x *IdReq) ProtoReflect() protoreflect.Message { + mi := &file_analysis_analysis_proto_msgTypes[39] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use IdReq.ProtoReflect.Descriptor instead. +func (*IdReq) Descriptor() ([]byte, []int) { + return file_analysis_analysis_proto_rawDescGZIP(), []int{39} +} + +func (x *IdReq) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +type ImagesDateReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + UserId int64 `protobuf:"varint,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"` + StartTime string `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + EndTime string `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ImagesDateReq) Reset() { + *x = ImagesDateReq{} + mi := &file_analysis_analysis_proto_msgTypes[40] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ImagesDateReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ImagesDateReq) ProtoMessage() {} + +func (x *ImagesDateReq) ProtoReflect() protoreflect.Message { + mi := &file_analysis_analysis_proto_msgTypes[40] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ImagesDateReq.ProtoReflect.Descriptor instead. +func (*ImagesDateReq) Descriptor() ([]byte, []int) { + return file_analysis_analysis_proto_rawDescGZIP(), []int{40} +} + +func (x *ImagesDateReq) GetUserId() int64 { + if x != nil { + return x.UserId + } + return 0 +} + +func (x *ImagesDateReq) GetStartTime() string { + if x != nil { + return x.StartTime + } + return "" +} + +func (x *ImagesDateReq) GetEndTime() string { + if x != nil { + return x.EndTime + } + return "" +} + +type ImagesListReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + UserId int64 `protobuf:"varint,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"` + Mode string `protobuf:"bytes,2,opt,name=mode,proto3" json:"mode,omitempty"` + Position string `protobuf:"bytes,3,opt,name=position,proto3" json:"position,omitempty"` + StartTime string `protobuf:"bytes,4,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + EndTime string `protobuf:"bytes,5,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ImagesListReq) Reset() { + *x = ImagesListReq{} + mi := &file_analysis_analysis_proto_msgTypes[41] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ImagesListReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ImagesListReq) ProtoMessage() {} + +func (x *ImagesListReq) ProtoReflect() protoreflect.Message { + mi := &file_analysis_analysis_proto_msgTypes[41] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ImagesListReq.ProtoReflect.Descriptor instead. +func (*ImagesListReq) Descriptor() ([]byte, []int) { + return file_analysis_analysis_proto_rawDescGZIP(), []int{41} +} + +func (x *ImagesListReq) GetUserId() int64 { + if x != nil { + return x.UserId + } + return 0 +} + +func (x *ImagesListReq) GetMode() string { + if x != nil { + return x.Mode + } + return "" +} + +func (x *ImagesListReq) GetPosition() string { + if x != nil { + return x.Position + } + return "" +} + +func (x *ImagesListReq) GetStartTime() string { + if x != nil { + return x.StartTime + } + return "" +} + +func (x *ImagesListReq) GetEndTime() string { + if x != nil { + return x.EndTime + } + return "" +} + +type DeviceUpdateReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + DeviceName string `protobuf:"bytes,2,opt,name=device_name,json=deviceName,proto3" json:"device_name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeviceUpdateReq) Reset() { + *x = DeviceUpdateReq{} + mi := &file_analysis_analysis_proto_msgTypes[42] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeviceUpdateReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeviceUpdateReq) ProtoMessage() {} + +func (x *DeviceUpdateReq) ProtoReflect() protoreflect.Message { + mi := &file_analysis_analysis_proto_msgTypes[42] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeviceUpdateReq.ProtoReflect.Descriptor instead. +func (*DeviceUpdateReq) Descriptor() ([]byte, []int) { + return file_analysis_analysis_proto_rawDescGZIP(), []int{42} +} + +func (x *DeviceUpdateReq) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *DeviceUpdateReq) GetDeviceName() string { + if x != nil { + return x.DeviceName + } + return "" +} + var File_analysis_analysis_proto protoreflect.FileDescriptor const file_analysis_analysis_proto_rawDesc = "" + @@ -1542,14 +2274,79 @@ const file_analysis_analysis_proto_rawDesc = "" + "\bmimeType\x18\x05 \x01(\tR\bmimeType\x12\x17\n" + "\atask_id\x18\x06 \x01(\tR\x06taskId\")\n" + "\x0fOssCallbackResp\x12\x16\n" + - "\x06Status\x18\x01 \x01(\tR\x06Status2\xed\x03\n" + + "\x06Status\x18\x01 \x01(\tR\x06Status\"$\n" + + "\x10UserLogDeleteReq\x12\x10\n" + + "\x03ids\x18\x01 \x03(\x03R\x03ids\"\x0f\n" + + "\rUserStatusReq\"\n" + + "\n" + + "\bEmptyReq\"I\n" + + "\x06LogReq\x12\x17\n" + + "\auser_id\x18\x01 \x01(\x03R\x06userId\x12\x12\n" + + "\x04page\x18\x02 \x01(\x05R\x04page\x12\x12\n" + + "\x04size\x18\x03 \x01(\x05R\x04size\"6\n" + + "\vOverviewReq\x12\x17\n" + + "\auser_id\x18\x01 \x01(\x03R\x06userId\x12\x0e\n" + + "\x02id\x18\x02 \x01(\x03R\x02id\"\"\n" + + "\aUserReq\x12\x17\n" + + "\auser_id\x18\x01 \x01(\x03R\x06userId\"\x1f\n" + + "\rUserDetailReq\x12\x0e\n" + + "\x02id\x18\x01 \x01(\x03R\x02id\"$\n" + + "\tTaskIdReq\x12\x17\n" + + "\atask_id\x18\x01 \x01(\tR\x06taskId\"\"\n" + + "\x0eQrcodeShareReq\x12\x10\n" + + "\x03ids\x18\x01 \x03(\x03R\x03ids\"$\n" + + "\x0eGraphDetailReq\x12\x12\n" + + "\x04type\x18\x01 \x01(\x05R\x04type\"9\n" + + "\x11FaceppMapBoxesReq\x12\x0e\n" + + "\x02id\x18\x01 \x01(\x03R\x02id\x12\x14\n" + + "\x05boxes\x18\x02 \x01(\tR\x05boxes\"\x17\n" + + "\x05IdReq\x12\x0e\n" + + "\x02id\x18\x01 \x01(\x03R\x02id\"b\n" + + "\rImagesDateReq\x12\x17\n" + + "\auser_id\x18\x01 \x01(\x03R\x06userId\x12\x1d\n" + + "\n" + + "start_time\x18\x02 \x01(\tR\tstartTime\x12\x19\n" + + "\bend_time\x18\x03 \x01(\tR\aendTime\"\x92\x01\n" + + "\rImagesListReq\x12\x17\n" + + "\auser_id\x18\x01 \x01(\x03R\x06userId\x12\x12\n" + + "\x04mode\x18\x02 \x01(\tR\x04mode\x12\x1a\n" + + "\bposition\x18\x03 \x01(\tR\bposition\x12\x1d\n" + + "\n" + + "start_time\x18\x04 \x01(\tR\tstartTime\x12\x19\n" + + "\bend_time\x18\x05 \x01(\tR\aendTime\"B\n" + + "\x0fDeviceUpdateReq\x12\x0e\n" + + "\x02id\x18\x01 \x01(\x03R\x02id\x12\x1f\n" + + "\vdevice_name\x18\x02 \x01(\tR\n" + + "deviceName2\xe6\x11\n" + "\bAnalysis\x12W\n" + "\x12InternalCreateUser\x12\x1f.analysis.InternalCreateUserReq\x1a .analysis.InternalCreateUserData\x12`\n" + "\x15InternalSetRegistered\x12\".analysis.InternalSetRegisteredReq\x1a#.analysis.InternalSetRegisteredData\x12k\n" + "\rAgreementInfo\x12\x1a.analysis.AgreementInfoReq\x1a\x12.analysis.Response\"*\x82\xd3\xe4\x93\x02$:\x01*\"\x1f/api/v2/analysis/agreement/info\x12U\n" + "\x06Switch\x12\x13.analysis.SwitchReq\x1a\x12.analysis.Response\"\"\x82\xd3\xe4\x93\x02\x1c:\x01*\"\x17/api/v2/analysis/switch\x12b\n" + "\n" + - "QrcodeInfo\x12\x17.analysis.QrcodeInfoReq\x1a\x12.analysis.Response\"'\x82\xd3\xe4\x93\x02!:\x01*\"\x1c/api/v2/analysis/qrcode/info2\xaa\a\n" + + "QrcodeInfo\x12\x17.analysis.QrcodeInfoReq\x1a\x12.analysis.Response\"'\x82\xd3\xe4\x93\x02!:\x01*\"\x1c/api/v2/analysis/qrcode/info\x12S\n" + + "\x03Log\x12\x10.analysis.LogReq\x1a\x12.analysis.Response\"&\x82\xd3\xe4\x93\x02 :\x01*\"\x1b/api/v2/analysis/common/log\x12b\n" + + "\bOverview\x12\x15.analysis.OverviewReq\x1a\x12.analysis.Response\"+\x82\xd3\xe4\x93\x02%:\x01*\" /api/v2/analysis/common/overview\x12V\n" + + "\x04User\x12\x11.analysis.UserReq\x1a\x12.analysis.Response\"'\x82\xd3\xe4\x93\x02!:\x01*\"\x1c/api/v2/analysis/common/user\x12i\n" + + "\n" + + "UserDetail\x12\x17.analysis.UserDetailReq\x1a\x12.analysis.Response\".\x82\xd3\xe4\x93\x02(:\x01*\"#/api/v2/analysis/common/user/detail\x12e\n" + + "\n" + + "UserFacepp\x12\x13.analysis.TaskIdReq\x1a\x12.analysis.Response\".\x82\xd3\xe4\x93\x02(:\x01*\"#/api/v2/analysis/common/user/facepp\x12`\n" + + "\bUserMode\x12\x12.analysis.EmptyReq\x1a\x12.analysis.Response\",\x82\xd3\xe4\x93\x02&:\x01*\"!/api/v2/analysis/common/user/mode\x12\\\n" + + "\aUserLog\x12\x10.analysis.LogReq\x1a\x12.analysis.Response\"+\x82\xd3\xe4\x93\x02%:\x01*\" /api/v2/analysis/common/user/log\x12]\n" + + "\aBanners\x12\x12.analysis.EmptyReq\x1a\x12.analysis.Response\"*\x82\xd3\xe4\x93\x02$:\x01*\"\x1f/api/v2/analysis/common/banners\x12l\n" + + "\vQrcodeShare\x12\x18.analysis.QrcodeShareReq\x1a\x12.analysis.Response\"/\x82\xd3\xe4\x93\x02):\x01*\"$/api/v2/analysis/common/qrcode/share\x12l\n" + + "\vGraphDetail\x12\x18.analysis.GraphDetailReq\x1a\x12.analysis.Response\"/\x82\xd3\xe4\x93\x02):\x01*\"$/api/v2/analysis/common/graph/detail\x12j\n" + + "\n" + + "FaceppMaps\x12\x13.analysis.TaskIdReq\x1a\x12.analysis.Response\"3\x82\xd3\xe4\x93\x02-:\x01*\"(/api/v2/analysis/common/user/facepp/maps\x12|\n" + + "\x0eFaceppMapBoxes\x12\x1b.analysis.FaceppMapBoxesReq\x1a\x12.analysis.Response\"9\x82\xd3\xe4\x93\x023:\x01*\"./api/v2/analysis/common/user/facepp/maps/boxes\x12{\n" + + "\x12FaceppMapBoxDelete\x12\x0f.analysis.IdReq\x1a\x12.analysis.Response\"@\x82\xd3\xe4\x93\x02::\x01*\"5/api/v2/analysis/common/user/facepp/maps/boxes/delete\x12n\n" + + "\n" + + "ImagesDate\x12\x17.analysis.ImagesDateReq\x1a\x12.analysis.Response\"3\x82\xd3\xe4\x93\x02-:\x01*\"(/api/v2/analysis/common/user/images/date\x12n\n" + + "\n" + + "ImagesList\x12\x17.analysis.ImagesListReq\x1a\x12.analysis.Response\"3\x82\xd3\xe4\x93\x02-:\x01*\"(/api/v2/analysis/common/user/images/list\x12h\n" + + "\tModeImage\x12\x13.analysis.TaskIdReq\x1a\x12.analysis.Response\"2\x82\xd3\xe4\x93\x02,:\x01*\"'/api/v2/analysis/common/user/mode/image\x12h\n" + + "\fDeviceUpdate\x12\x19.analysis.DeviceUpdateReq\x1a\x12.analysis.Response\")\x82\xd3\xe4\x93\x02#:\x01*\"\x1e/api/v2/analysis/device/update2\xfc\b\n" + "\fAnalysisUser\x12\\\n" + "\bFaceBind\x12\x15.analysis.FaceBindReq\x1a\x12.analysis.Response\"%\x82\xd3\xe4\x93\x02\x1f:\x01*\"\x1a/api/v2/analysis/face/bind\x12e\n" + "\vUserImprove\x12\x18.analysis.UserImproveReq\x1a\x12.analysis.Response\"(\x82\xd3\xe4\x93\x02\":\x01*\"\x1d/api/v2/analysis/user/improve\x12b\n" + @@ -1562,7 +2359,10 @@ const file_analysis_analysis_proto_rawDesc = "" + "\n" + "DeviceBind\x12\x17.analysis.DeviceBindReq\x1a\x12.analysis.Response\"'\x82\xd3\xe4\x93\x02!:\x01*\"\x1c/api/v2/analysis/device/bind\x12b\n" + "\n" + - "DeviceInfo\x12\x17.analysis.DeviceInfoReq\x1a\x12.analysis.Response\"'\x82\xd3\xe4\x93\x02!:\x01*\"\x1c/api/v2/analysis/device/info2\x90\x05\n" + + "DeviceInfo\x12\x17.analysis.DeviceInfoReq\x1a\x12.analysis.Response\"'\x82\xd3\xe4\x93\x02!:\x01*\"\x1c/api/v2/analysis/device/info\x12l\n" + + "\rUserLogDelete\x12\x1a.analysis.UserLogDeleteReq\x1a\x12.analysis.Response\"+\x82\xd3\xe4\x93\x02%:\x01*\" /api/v2/analysis/user/log/delete\x12b\n" + + "\n" + + "UserStatus\x12\x17.analysis.UserStatusReq\x1a\x12.analysis.Response\"'\x82\xd3\xe4\x93\x02!:\x01*\"\x1c/api/v2/analysis/user/status2\x90\x05\n" + "\rAnalysisStore\x12_\n" + "\tStoreAuth\x12\x16.analysis.StoreAuthReq\x1a\x12.analysis.Response\"&\x82\xd3\xe4\x93\x02 :\x01*\"\x1b/api/v2/analysis/store/auth\x12r\n" + "\x0fStoreAuthQrcode\x12\x1c.analysis.StoreAuthQrcodeReq\x1a\x12.analysis.Response\"-\x82\xd3\xe4\x93\x02':\x01*\"\"/api/v2/analysis/store/auth/qrcode\x12_\n" + @@ -1587,7 +2387,7 @@ func file_analysis_analysis_proto_rawDescGZIP() []byte { return file_analysis_analysis_proto_rawDescData } -var file_analysis_analysis_proto_msgTypes = make([]protoimpl.MessageInfo, 28) +var file_analysis_analysis_proto_msgTypes = make([]protoimpl.MessageInfo, 43) var file_analysis_analysis_proto_goTypes = []any{ (*Response)(nil), // 0: analysis.Response (*InternalCreateUserReq)(nil), // 1: analysis.InternalCreateUserReq @@ -1617,6 +2417,21 @@ var file_analysis_analysis_proto_goTypes = []any{ (*DeviceDisplayReq)(nil), // 25: analysis.DeviceDisplayReq (*OssCallbackReq)(nil), // 26: analysis.OssCallbackReq (*OssCallbackResp)(nil), // 27: analysis.OssCallbackResp + (*UserLogDeleteReq)(nil), // 28: analysis.UserLogDeleteReq + (*UserStatusReq)(nil), // 29: analysis.UserStatusReq + (*EmptyReq)(nil), // 30: analysis.EmptyReq + (*LogReq)(nil), // 31: analysis.LogReq + (*OverviewReq)(nil), // 32: analysis.OverviewReq + (*UserReq)(nil), // 33: analysis.UserReq + (*UserDetailReq)(nil), // 34: analysis.UserDetailReq + (*TaskIdReq)(nil), // 35: analysis.TaskIdReq + (*QrcodeShareReq)(nil), // 36: analysis.QrcodeShareReq + (*GraphDetailReq)(nil), // 37: analysis.GraphDetailReq + (*FaceppMapBoxesReq)(nil), // 38: analysis.FaceppMapBoxesReq + (*IdReq)(nil), // 39: analysis.IdReq + (*ImagesDateReq)(nil), // 40: analysis.ImagesDateReq + (*ImagesListReq)(nil), // 41: analysis.ImagesListReq + (*DeviceUpdateReq)(nil), // 42: analysis.DeviceUpdateReq } var file_analysis_analysis_proto_depIdxs = []int32{ 1, // 0: analysis.Analysis.InternalCreateUser:input_type -> analysis.InternalCreateUserReq @@ -1624,49 +2439,87 @@ var file_analysis_analysis_proto_depIdxs = []int32{ 7, // 2: analysis.Analysis.AgreementInfo:input_type -> analysis.AgreementInfoReq 9, // 3: analysis.Analysis.Switch:input_type -> analysis.SwitchReq 10, // 4: analysis.Analysis.QrcodeInfo:input_type -> analysis.QrcodeInfoReq - 6, // 5: analysis.AnalysisUser.FaceBind:input_type -> analysis.FaceBindReq - 5, // 6: analysis.AnalysisUser.UserImprove:input_type -> analysis.UserImproveReq - 8, // 7: analysis.AnalysisUser.UserDelete:input_type -> analysis.UserDeleteReq - 18, // 8: analysis.AnalysisUser.UserAuth:input_type -> analysis.UserAuthReq - 19, // 9: analysis.AnalysisUser.UserAuthList:input_type -> analysis.UserAuthListReq - 20, // 10: analysis.AnalysisUser.UserAuthDelete:input_type -> analysis.UserAuthDeleteReq - 21, // 11: analysis.AnalysisUser.UserAuthUpdate:input_type -> analysis.UserAuthUpdateReq - 22, // 12: analysis.AnalysisUser.DeviceBind:input_type -> analysis.DeviceBindReq - 23, // 13: analysis.AnalysisUser.DeviceInfo:input_type -> analysis.DeviceInfoReq - 11, // 14: analysis.AnalysisStore.StoreAuth:input_type -> analysis.StoreAuthReq - 12, // 15: analysis.AnalysisStore.StoreAuthQrcode:input_type -> analysis.StoreAuthQrcodeReq - 13, // 16: analysis.AnalysisStore.StoreInfo:input_type -> analysis.StoreInfoReq - 15, // 17: analysis.AnalysisStore.StoreUserList:input_type -> analysis.StoreUserListReq - 16, // 18: analysis.AnalysisStore.StoreUserUpdate:input_type -> analysis.StoreUserUpdateReq - 17, // 19: analysis.AnalysisStore.StoreUserInfo:input_type -> analysis.StoreUserInfoReq - 24, // 20: analysis.AnalysisDevice.Policy:input_type -> analysis.DevicePolicyReq - 25, // 21: analysis.AnalysisDevice.Display:input_type -> analysis.DeviceDisplayReq - 26, // 22: analysis.AnalysisDevice.OssCallback:input_type -> analysis.OssCallbackReq - 2, // 23: analysis.Analysis.InternalCreateUser:output_type -> analysis.InternalCreateUserData - 4, // 24: analysis.Analysis.InternalSetRegistered:output_type -> analysis.InternalSetRegisteredData - 0, // 25: analysis.Analysis.AgreementInfo:output_type -> analysis.Response - 0, // 26: analysis.Analysis.Switch:output_type -> analysis.Response - 0, // 27: analysis.Analysis.QrcodeInfo:output_type -> analysis.Response - 0, // 28: analysis.AnalysisUser.FaceBind:output_type -> analysis.Response - 0, // 29: analysis.AnalysisUser.UserImprove:output_type -> analysis.Response - 0, // 30: analysis.AnalysisUser.UserDelete:output_type -> analysis.Response - 0, // 31: analysis.AnalysisUser.UserAuth:output_type -> analysis.Response - 0, // 32: analysis.AnalysisUser.UserAuthList:output_type -> analysis.Response - 0, // 33: analysis.AnalysisUser.UserAuthDelete:output_type -> analysis.Response - 0, // 34: analysis.AnalysisUser.UserAuthUpdate:output_type -> analysis.Response - 0, // 35: analysis.AnalysisUser.DeviceBind:output_type -> analysis.Response - 0, // 36: analysis.AnalysisUser.DeviceInfo:output_type -> analysis.Response - 0, // 37: analysis.AnalysisStore.StoreAuth:output_type -> analysis.Response - 0, // 38: analysis.AnalysisStore.StoreAuthQrcode:output_type -> analysis.Response - 0, // 39: analysis.AnalysisStore.StoreInfo:output_type -> analysis.Response - 0, // 40: analysis.AnalysisStore.StoreUserList:output_type -> analysis.Response - 0, // 41: analysis.AnalysisStore.StoreUserUpdate:output_type -> analysis.Response - 0, // 42: analysis.AnalysisStore.StoreUserInfo:output_type -> analysis.Response - 0, // 43: analysis.AnalysisDevice.Policy:output_type -> analysis.Response - 0, // 44: analysis.AnalysisDevice.Display:output_type -> analysis.Response - 27, // 45: analysis.AnalysisDevice.OssCallback:output_type -> analysis.OssCallbackResp - 23, // [23:46] is the sub-list for method output_type - 0, // [0:23] is the sub-list for method input_type + 31, // 5: analysis.Analysis.Log:input_type -> analysis.LogReq + 32, // 6: analysis.Analysis.Overview:input_type -> analysis.OverviewReq + 33, // 7: analysis.Analysis.User:input_type -> analysis.UserReq + 34, // 8: analysis.Analysis.UserDetail:input_type -> analysis.UserDetailReq + 35, // 9: analysis.Analysis.UserFacepp:input_type -> analysis.TaskIdReq + 30, // 10: analysis.Analysis.UserMode:input_type -> analysis.EmptyReq + 31, // 11: analysis.Analysis.UserLog:input_type -> analysis.LogReq + 30, // 12: analysis.Analysis.Banners:input_type -> analysis.EmptyReq + 36, // 13: analysis.Analysis.QrcodeShare:input_type -> analysis.QrcodeShareReq + 37, // 14: analysis.Analysis.GraphDetail:input_type -> analysis.GraphDetailReq + 35, // 15: analysis.Analysis.FaceppMaps:input_type -> analysis.TaskIdReq + 38, // 16: analysis.Analysis.FaceppMapBoxes:input_type -> analysis.FaceppMapBoxesReq + 39, // 17: analysis.Analysis.FaceppMapBoxDelete:input_type -> analysis.IdReq + 40, // 18: analysis.Analysis.ImagesDate:input_type -> analysis.ImagesDateReq + 41, // 19: analysis.Analysis.ImagesList:input_type -> analysis.ImagesListReq + 35, // 20: analysis.Analysis.ModeImage:input_type -> analysis.TaskIdReq + 42, // 21: analysis.Analysis.DeviceUpdate:input_type -> analysis.DeviceUpdateReq + 6, // 22: analysis.AnalysisUser.FaceBind:input_type -> analysis.FaceBindReq + 5, // 23: analysis.AnalysisUser.UserImprove:input_type -> analysis.UserImproveReq + 8, // 24: analysis.AnalysisUser.UserDelete:input_type -> analysis.UserDeleteReq + 18, // 25: analysis.AnalysisUser.UserAuth:input_type -> analysis.UserAuthReq + 19, // 26: analysis.AnalysisUser.UserAuthList:input_type -> analysis.UserAuthListReq + 20, // 27: analysis.AnalysisUser.UserAuthDelete:input_type -> analysis.UserAuthDeleteReq + 21, // 28: analysis.AnalysisUser.UserAuthUpdate:input_type -> analysis.UserAuthUpdateReq + 22, // 29: analysis.AnalysisUser.DeviceBind:input_type -> analysis.DeviceBindReq + 23, // 30: analysis.AnalysisUser.DeviceInfo:input_type -> analysis.DeviceInfoReq + 28, // 31: analysis.AnalysisUser.UserLogDelete:input_type -> analysis.UserLogDeleteReq + 29, // 32: analysis.AnalysisUser.UserStatus:input_type -> analysis.UserStatusReq + 11, // 33: analysis.AnalysisStore.StoreAuth:input_type -> analysis.StoreAuthReq + 12, // 34: analysis.AnalysisStore.StoreAuthQrcode:input_type -> analysis.StoreAuthQrcodeReq + 13, // 35: analysis.AnalysisStore.StoreInfo:input_type -> analysis.StoreInfoReq + 15, // 36: analysis.AnalysisStore.StoreUserList:input_type -> analysis.StoreUserListReq + 16, // 37: analysis.AnalysisStore.StoreUserUpdate:input_type -> analysis.StoreUserUpdateReq + 17, // 38: analysis.AnalysisStore.StoreUserInfo:input_type -> analysis.StoreUserInfoReq + 24, // 39: analysis.AnalysisDevice.Policy:input_type -> analysis.DevicePolicyReq + 25, // 40: analysis.AnalysisDevice.Display:input_type -> analysis.DeviceDisplayReq + 26, // 41: analysis.AnalysisDevice.OssCallback:input_type -> analysis.OssCallbackReq + 2, // 42: analysis.Analysis.InternalCreateUser:output_type -> analysis.InternalCreateUserData + 4, // 43: analysis.Analysis.InternalSetRegistered:output_type -> analysis.InternalSetRegisteredData + 0, // 44: analysis.Analysis.AgreementInfo:output_type -> analysis.Response + 0, // 45: analysis.Analysis.Switch:output_type -> analysis.Response + 0, // 46: analysis.Analysis.QrcodeInfo:output_type -> analysis.Response + 0, // 47: analysis.Analysis.Log:output_type -> analysis.Response + 0, // 48: analysis.Analysis.Overview:output_type -> analysis.Response + 0, // 49: analysis.Analysis.User:output_type -> analysis.Response + 0, // 50: analysis.Analysis.UserDetail:output_type -> analysis.Response + 0, // 51: analysis.Analysis.UserFacepp:output_type -> analysis.Response + 0, // 52: analysis.Analysis.UserMode:output_type -> analysis.Response + 0, // 53: analysis.Analysis.UserLog:output_type -> analysis.Response + 0, // 54: analysis.Analysis.Banners:output_type -> analysis.Response + 0, // 55: analysis.Analysis.QrcodeShare:output_type -> analysis.Response + 0, // 56: analysis.Analysis.GraphDetail:output_type -> analysis.Response + 0, // 57: analysis.Analysis.FaceppMaps:output_type -> analysis.Response + 0, // 58: analysis.Analysis.FaceppMapBoxes:output_type -> analysis.Response + 0, // 59: analysis.Analysis.FaceppMapBoxDelete:output_type -> analysis.Response + 0, // 60: analysis.Analysis.ImagesDate:output_type -> analysis.Response + 0, // 61: analysis.Analysis.ImagesList:output_type -> analysis.Response + 0, // 62: analysis.Analysis.ModeImage:output_type -> analysis.Response + 0, // 63: analysis.Analysis.DeviceUpdate:output_type -> analysis.Response + 0, // 64: analysis.AnalysisUser.FaceBind:output_type -> analysis.Response + 0, // 65: analysis.AnalysisUser.UserImprove:output_type -> analysis.Response + 0, // 66: analysis.AnalysisUser.UserDelete:output_type -> analysis.Response + 0, // 67: analysis.AnalysisUser.UserAuth:output_type -> analysis.Response + 0, // 68: analysis.AnalysisUser.UserAuthList:output_type -> analysis.Response + 0, // 69: analysis.AnalysisUser.UserAuthDelete:output_type -> analysis.Response + 0, // 70: analysis.AnalysisUser.UserAuthUpdate:output_type -> analysis.Response + 0, // 71: analysis.AnalysisUser.DeviceBind:output_type -> analysis.Response + 0, // 72: analysis.AnalysisUser.DeviceInfo:output_type -> analysis.Response + 0, // 73: analysis.AnalysisUser.UserLogDelete:output_type -> analysis.Response + 0, // 74: analysis.AnalysisUser.UserStatus:output_type -> analysis.Response + 0, // 75: analysis.AnalysisStore.StoreAuth:output_type -> analysis.Response + 0, // 76: analysis.AnalysisStore.StoreAuthQrcode:output_type -> analysis.Response + 0, // 77: analysis.AnalysisStore.StoreInfo:output_type -> analysis.Response + 0, // 78: analysis.AnalysisStore.StoreUserList:output_type -> analysis.Response + 0, // 79: analysis.AnalysisStore.StoreUserUpdate:output_type -> analysis.Response + 0, // 80: analysis.AnalysisStore.StoreUserInfo:output_type -> analysis.Response + 0, // 81: analysis.AnalysisDevice.Policy:output_type -> analysis.Response + 0, // 82: analysis.AnalysisDevice.Display:output_type -> analysis.Response + 27, // 83: analysis.AnalysisDevice.OssCallback:output_type -> analysis.OssCallbackResp + 42, // [42:84] is the sub-list for method output_type + 0, // [0:42] is the sub-list for method input_type 0, // [0:0] is the sub-list for extension type_name 0, // [0:0] is the sub-list for extension extendee 0, // [0:0] is the sub-list for field type_name @@ -1684,7 +2537,7 @@ func file_analysis_analysis_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_analysis_analysis_proto_rawDesc), len(file_analysis_analysis_proto_rawDesc)), NumEnums: 0, - NumMessages: 28, + NumMessages: 43, NumExtensions: 0, NumServices: 4, }, diff --git a/rpc/analysis/pb/analysis_grpc.pb.go b/rpc/analysis/pb/analysis_grpc.pb.go index 0642f9d..0651463 100644 --- a/rpc/analysis/pb/analysis_grpc.pb.go +++ b/rpc/analysis/pb/analysis_grpc.pb.go @@ -24,6 +24,23 @@ const ( Analysis_AgreementInfo_FullMethodName = "/analysis.Analysis/AgreementInfo" Analysis_Switch_FullMethodName = "/analysis.Analysis/Switch" Analysis_QrcodeInfo_FullMethodName = "/analysis.Analysis/QrcodeInfo" + Analysis_Log_FullMethodName = "/analysis.Analysis/Log" + Analysis_Overview_FullMethodName = "/analysis.Analysis/Overview" + Analysis_User_FullMethodName = "/analysis.Analysis/User" + Analysis_UserDetail_FullMethodName = "/analysis.Analysis/UserDetail" + Analysis_UserFacepp_FullMethodName = "/analysis.Analysis/UserFacepp" + Analysis_UserMode_FullMethodName = "/analysis.Analysis/UserMode" + Analysis_UserLog_FullMethodName = "/analysis.Analysis/UserLog" + Analysis_Banners_FullMethodName = "/analysis.Analysis/Banners" + Analysis_QrcodeShare_FullMethodName = "/analysis.Analysis/QrcodeShare" + Analysis_GraphDetail_FullMethodName = "/analysis.Analysis/GraphDetail" + Analysis_FaceppMaps_FullMethodName = "/analysis.Analysis/FaceppMaps" + Analysis_FaceppMapBoxes_FullMethodName = "/analysis.Analysis/FaceppMapBoxes" + Analysis_FaceppMapBoxDelete_FullMethodName = "/analysis.Analysis/FaceppMapBoxDelete" + Analysis_ImagesDate_FullMethodName = "/analysis.Analysis/ImagesDate" + Analysis_ImagesList_FullMethodName = "/analysis.Analysis/ImagesList" + Analysis_ModeImage_FullMethodName = "/analysis.Analysis/ModeImage" + Analysis_DeviceUpdate_FullMethodName = "/analysis.Analysis/DeviceUpdate" ) // AnalysisClient is the client API for Analysis service. @@ -35,6 +52,23 @@ type AnalysisClient interface { AgreementInfo(ctx context.Context, in *AgreementInfoReq, opts ...grpc.CallOption) (*Response, error) Switch(ctx context.Context, in *SwitchReq, opts ...grpc.CallOption) (*Response, error) QrcodeInfo(ctx context.Context, in *QrcodeInfoReq, opts ...grpc.CallOption) (*Response, error) + Log(ctx context.Context, in *LogReq, opts ...grpc.CallOption) (*Response, error) + Overview(ctx context.Context, in *OverviewReq, opts ...grpc.CallOption) (*Response, error) + User(ctx context.Context, in *UserReq, opts ...grpc.CallOption) (*Response, error) + UserDetail(ctx context.Context, in *UserDetailReq, opts ...grpc.CallOption) (*Response, error) + UserFacepp(ctx context.Context, in *TaskIdReq, opts ...grpc.CallOption) (*Response, error) + UserMode(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error) + UserLog(ctx context.Context, in *LogReq, opts ...grpc.CallOption) (*Response, error) + Banners(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error) + QrcodeShare(ctx context.Context, in *QrcodeShareReq, opts ...grpc.CallOption) (*Response, error) + GraphDetail(ctx context.Context, in *GraphDetailReq, opts ...grpc.CallOption) (*Response, error) + FaceppMaps(ctx context.Context, in *TaskIdReq, opts ...grpc.CallOption) (*Response, error) + FaceppMapBoxes(ctx context.Context, in *FaceppMapBoxesReq, opts ...grpc.CallOption) (*Response, error) + FaceppMapBoxDelete(ctx context.Context, in *IdReq, opts ...grpc.CallOption) (*Response, error) + ImagesDate(ctx context.Context, in *ImagesDateReq, opts ...grpc.CallOption) (*Response, error) + ImagesList(ctx context.Context, in *ImagesListReq, opts ...grpc.CallOption) (*Response, error) + ModeImage(ctx context.Context, in *TaskIdReq, opts ...grpc.CallOption) (*Response, error) + DeviceUpdate(ctx context.Context, in *DeviceUpdateReq, opts ...grpc.CallOption) (*Response, error) } type analysisClient struct { @@ -95,6 +129,176 @@ func (c *analysisClient) QrcodeInfo(ctx context.Context, in *QrcodeInfoReq, opts return out, nil } +func (c *analysisClient) Log(ctx context.Context, in *LogReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_Log_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) Overview(ctx context.Context, in *OverviewReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_Overview_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) User(ctx context.Context, in *UserReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_User_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) UserDetail(ctx context.Context, in *UserDetailReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_UserDetail_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) UserFacepp(ctx context.Context, in *TaskIdReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_UserFacepp_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) UserMode(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_UserMode_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) UserLog(ctx context.Context, in *LogReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_UserLog_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) Banners(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_Banners_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) QrcodeShare(ctx context.Context, in *QrcodeShareReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_QrcodeShare_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) GraphDetail(ctx context.Context, in *GraphDetailReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_GraphDetail_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) FaceppMaps(ctx context.Context, in *TaskIdReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_FaceppMaps_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) FaceppMapBoxes(ctx context.Context, in *FaceppMapBoxesReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_FaceppMapBoxes_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) FaceppMapBoxDelete(ctx context.Context, in *IdReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_FaceppMapBoxDelete_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) ImagesDate(ctx context.Context, in *ImagesDateReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_ImagesDate_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) ImagesList(ctx context.Context, in *ImagesListReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_ImagesList_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) ModeImage(ctx context.Context, in *TaskIdReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_ModeImage_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisClient) DeviceUpdate(ctx context.Context, in *DeviceUpdateReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Analysis_DeviceUpdate_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + // AnalysisServer is the server API for Analysis service. // All implementations must embed UnimplementedAnalysisServer // for forward compatibility. @@ -104,6 +308,23 @@ type AnalysisServer interface { AgreementInfo(context.Context, *AgreementInfoReq) (*Response, error) Switch(context.Context, *SwitchReq) (*Response, error) QrcodeInfo(context.Context, *QrcodeInfoReq) (*Response, error) + Log(context.Context, *LogReq) (*Response, error) + Overview(context.Context, *OverviewReq) (*Response, error) + User(context.Context, *UserReq) (*Response, error) + UserDetail(context.Context, *UserDetailReq) (*Response, error) + UserFacepp(context.Context, *TaskIdReq) (*Response, error) + UserMode(context.Context, *EmptyReq) (*Response, error) + UserLog(context.Context, *LogReq) (*Response, error) + Banners(context.Context, *EmptyReq) (*Response, error) + QrcodeShare(context.Context, *QrcodeShareReq) (*Response, error) + GraphDetail(context.Context, *GraphDetailReq) (*Response, error) + FaceppMaps(context.Context, *TaskIdReq) (*Response, error) + FaceppMapBoxes(context.Context, *FaceppMapBoxesReq) (*Response, error) + FaceppMapBoxDelete(context.Context, *IdReq) (*Response, error) + ImagesDate(context.Context, *ImagesDateReq) (*Response, error) + ImagesList(context.Context, *ImagesListReq) (*Response, error) + ModeImage(context.Context, *TaskIdReq) (*Response, error) + DeviceUpdate(context.Context, *DeviceUpdateReq) (*Response, error) mustEmbedUnimplementedAnalysisServer() } @@ -129,6 +350,57 @@ func (UnimplementedAnalysisServer) Switch(context.Context, *SwitchReq) (*Respons func (UnimplementedAnalysisServer) QrcodeInfo(context.Context, *QrcodeInfoReq) (*Response, error) { return nil, status.Error(codes.Unimplemented, "method QrcodeInfo not implemented") } +func (UnimplementedAnalysisServer) Log(context.Context, *LogReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method Log not implemented") +} +func (UnimplementedAnalysisServer) Overview(context.Context, *OverviewReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method Overview not implemented") +} +func (UnimplementedAnalysisServer) User(context.Context, *UserReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method User not implemented") +} +func (UnimplementedAnalysisServer) UserDetail(context.Context, *UserDetailReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method UserDetail not implemented") +} +func (UnimplementedAnalysisServer) UserFacepp(context.Context, *TaskIdReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method UserFacepp not implemented") +} +func (UnimplementedAnalysisServer) UserMode(context.Context, *EmptyReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method UserMode not implemented") +} +func (UnimplementedAnalysisServer) UserLog(context.Context, *LogReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method UserLog not implemented") +} +func (UnimplementedAnalysisServer) Banners(context.Context, *EmptyReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method Banners not implemented") +} +func (UnimplementedAnalysisServer) QrcodeShare(context.Context, *QrcodeShareReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method QrcodeShare not implemented") +} +func (UnimplementedAnalysisServer) GraphDetail(context.Context, *GraphDetailReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method GraphDetail not implemented") +} +func (UnimplementedAnalysisServer) FaceppMaps(context.Context, *TaskIdReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method FaceppMaps not implemented") +} +func (UnimplementedAnalysisServer) FaceppMapBoxes(context.Context, *FaceppMapBoxesReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method FaceppMapBoxes not implemented") +} +func (UnimplementedAnalysisServer) FaceppMapBoxDelete(context.Context, *IdReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method FaceppMapBoxDelete not implemented") +} +func (UnimplementedAnalysisServer) ImagesDate(context.Context, *ImagesDateReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method ImagesDate not implemented") +} +func (UnimplementedAnalysisServer) ImagesList(context.Context, *ImagesListReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method ImagesList not implemented") +} +func (UnimplementedAnalysisServer) ModeImage(context.Context, *TaskIdReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method ModeImage not implemented") +} +func (UnimplementedAnalysisServer) DeviceUpdate(context.Context, *DeviceUpdateReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method DeviceUpdate not implemented") +} func (UnimplementedAnalysisServer) mustEmbedUnimplementedAnalysisServer() {} func (UnimplementedAnalysisServer) testEmbeddedByValue() {} @@ -240,6 +512,312 @@ func _Analysis_QrcodeInfo_Handler(srv interface{}, ctx context.Context, dec func return interceptor(ctx, in, info, handler) } +func _Analysis_Log_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LogReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).Log(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_Log_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).Log(ctx, req.(*LogReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_Overview_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(OverviewReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).Overview(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_Overview_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).Overview(ctx, req.(*OverviewReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_User_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UserReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).User(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_User_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).User(ctx, req.(*UserReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_UserDetail_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UserDetailReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).UserDetail(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_UserDetail_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).UserDetail(ctx, req.(*UserDetailReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_UserFacepp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TaskIdReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).UserFacepp(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_UserFacepp_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).UserFacepp(ctx, req.(*TaskIdReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_UserMode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(EmptyReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).UserMode(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_UserMode_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).UserMode(ctx, req.(*EmptyReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_UserLog_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LogReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).UserLog(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_UserLog_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).UserLog(ctx, req.(*LogReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_Banners_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(EmptyReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).Banners(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_Banners_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).Banners(ctx, req.(*EmptyReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_QrcodeShare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QrcodeShareReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).QrcodeShare(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_QrcodeShare_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).QrcodeShare(ctx, req.(*QrcodeShareReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_GraphDetail_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GraphDetailReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).GraphDetail(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_GraphDetail_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).GraphDetail(ctx, req.(*GraphDetailReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_FaceppMaps_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TaskIdReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).FaceppMaps(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_FaceppMaps_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).FaceppMaps(ctx, req.(*TaskIdReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_FaceppMapBoxes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(FaceppMapBoxesReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).FaceppMapBoxes(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_FaceppMapBoxes_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).FaceppMapBoxes(ctx, req.(*FaceppMapBoxesReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_FaceppMapBoxDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(IdReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).FaceppMapBoxDelete(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_FaceppMapBoxDelete_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).FaceppMapBoxDelete(ctx, req.(*IdReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_ImagesDate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ImagesDateReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).ImagesDate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_ImagesDate_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).ImagesDate(ctx, req.(*ImagesDateReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_ImagesList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ImagesListReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).ImagesList(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_ImagesList_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).ImagesList(ctx, req.(*ImagesListReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_ModeImage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TaskIdReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).ModeImage(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_ModeImage_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).ModeImage(ctx, req.(*TaskIdReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Analysis_DeviceUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeviceUpdateReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisServer).DeviceUpdate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Analysis_DeviceUpdate_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisServer).DeviceUpdate(ctx, req.(*DeviceUpdateReq)) + } + return interceptor(ctx, in, info, handler) +} + // Analysis_ServiceDesc is the grpc.ServiceDesc for Analysis service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) @@ -267,6 +845,74 @@ var Analysis_ServiceDesc = grpc.ServiceDesc{ MethodName: "QrcodeInfo", Handler: _Analysis_QrcodeInfo_Handler, }, + { + MethodName: "Log", + Handler: _Analysis_Log_Handler, + }, + { + MethodName: "Overview", + Handler: _Analysis_Overview_Handler, + }, + { + MethodName: "User", + Handler: _Analysis_User_Handler, + }, + { + MethodName: "UserDetail", + Handler: _Analysis_UserDetail_Handler, + }, + { + MethodName: "UserFacepp", + Handler: _Analysis_UserFacepp_Handler, + }, + { + MethodName: "UserMode", + Handler: _Analysis_UserMode_Handler, + }, + { + MethodName: "UserLog", + Handler: _Analysis_UserLog_Handler, + }, + { + MethodName: "Banners", + Handler: _Analysis_Banners_Handler, + }, + { + MethodName: "QrcodeShare", + Handler: _Analysis_QrcodeShare_Handler, + }, + { + MethodName: "GraphDetail", + Handler: _Analysis_GraphDetail_Handler, + }, + { + MethodName: "FaceppMaps", + Handler: _Analysis_FaceppMaps_Handler, + }, + { + MethodName: "FaceppMapBoxes", + Handler: _Analysis_FaceppMapBoxes_Handler, + }, + { + MethodName: "FaceppMapBoxDelete", + Handler: _Analysis_FaceppMapBoxDelete_Handler, + }, + { + MethodName: "ImagesDate", + Handler: _Analysis_ImagesDate_Handler, + }, + { + MethodName: "ImagesList", + Handler: _Analysis_ImagesList_Handler, + }, + { + MethodName: "ModeImage", + Handler: _Analysis_ModeImage_Handler, + }, + { + MethodName: "DeviceUpdate", + Handler: _Analysis_DeviceUpdate_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "analysis/analysis.proto", @@ -282,6 +928,8 @@ const ( AnalysisUser_UserAuthUpdate_FullMethodName = "/analysis.AnalysisUser/UserAuthUpdate" AnalysisUser_DeviceBind_FullMethodName = "/analysis.AnalysisUser/DeviceBind" AnalysisUser_DeviceInfo_FullMethodName = "/analysis.AnalysisUser/DeviceInfo" + AnalysisUser_UserLogDelete_FullMethodName = "/analysis.AnalysisUser/UserLogDelete" + AnalysisUser_UserStatus_FullMethodName = "/analysis.AnalysisUser/UserStatus" ) // AnalysisUserClient is the client API for AnalysisUser service. @@ -297,6 +945,8 @@ type AnalysisUserClient interface { UserAuthUpdate(ctx context.Context, in *UserAuthUpdateReq, opts ...grpc.CallOption) (*Response, error) DeviceBind(ctx context.Context, in *DeviceBindReq, opts ...grpc.CallOption) (*Response, error) DeviceInfo(ctx context.Context, in *DeviceInfoReq, opts ...grpc.CallOption) (*Response, error) + UserLogDelete(ctx context.Context, in *UserLogDeleteReq, opts ...grpc.CallOption) (*Response, error) + UserStatus(ctx context.Context, in *UserStatusReq, opts ...grpc.CallOption) (*Response, error) } type analysisUserClient struct { @@ -397,6 +1047,26 @@ func (c *analysisUserClient) DeviceInfo(ctx context.Context, in *DeviceInfoReq, return out, nil } +func (c *analysisUserClient) UserLogDelete(ctx context.Context, in *UserLogDeleteReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, AnalysisUser_UserLogDelete_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *analysisUserClient) UserStatus(ctx context.Context, in *UserStatusReq, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, AnalysisUser_UserStatus_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + // AnalysisUserServer is the server API for AnalysisUser service. // All implementations must embed UnimplementedAnalysisUserServer // for forward compatibility. @@ -410,6 +1080,8 @@ type AnalysisUserServer interface { UserAuthUpdate(context.Context, *UserAuthUpdateReq) (*Response, error) DeviceBind(context.Context, *DeviceBindReq) (*Response, error) DeviceInfo(context.Context, *DeviceInfoReq) (*Response, error) + UserLogDelete(context.Context, *UserLogDeleteReq) (*Response, error) + UserStatus(context.Context, *UserStatusReq) (*Response, error) mustEmbedUnimplementedAnalysisUserServer() } @@ -447,6 +1119,12 @@ func (UnimplementedAnalysisUserServer) DeviceBind(context.Context, *DeviceBindRe func (UnimplementedAnalysisUserServer) DeviceInfo(context.Context, *DeviceInfoReq) (*Response, error) { return nil, status.Error(codes.Unimplemented, "method DeviceInfo not implemented") } +func (UnimplementedAnalysisUserServer) UserLogDelete(context.Context, *UserLogDeleteReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method UserLogDelete not implemented") +} +func (UnimplementedAnalysisUserServer) UserStatus(context.Context, *UserStatusReq) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method UserStatus not implemented") +} func (UnimplementedAnalysisUserServer) mustEmbedUnimplementedAnalysisUserServer() {} func (UnimplementedAnalysisUserServer) testEmbeddedByValue() {} @@ -630,6 +1308,42 @@ func _AnalysisUser_DeviceInfo_Handler(srv interface{}, ctx context.Context, dec return interceptor(ctx, in, info, handler) } +func _AnalysisUser_UserLogDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UserLogDeleteReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisUserServer).UserLogDelete(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AnalysisUser_UserLogDelete_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisUserServer).UserLogDelete(ctx, req.(*UserLogDeleteReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _AnalysisUser_UserStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UserStatusReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AnalysisUserServer).UserStatus(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AnalysisUser_UserStatus_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AnalysisUserServer).UserStatus(ctx, req.(*UserStatusReq)) + } + return interceptor(ctx, in, info, handler) +} + // AnalysisUser_ServiceDesc is the grpc.ServiceDesc for AnalysisUser service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) @@ -673,6 +1387,14 @@ var AnalysisUser_ServiceDesc = grpc.ServiceDesc{ MethodName: "DeviceInfo", Handler: _AnalysisUser_DeviceInfo_Handler, }, + { + MethodName: "UserLogDelete", + Handler: _AnalysisUser_UserLogDelete_Handler, + }, + { + MethodName: "UserStatus", + Handler: _AnalysisUser_UserStatus_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "analysis/analysis.proto", diff --git a/services/analysis/client/analysis/analysis.go b/services/analysis/client/analysis/analysis.go index 2f6514c..308b6e6 100644 --- a/services/analysis/client/analysis/analysis.go +++ b/services/analysis/client/analysis/analysis.go @@ -15,13 +15,26 @@ import ( type ( AgreementInfoReq = analysis.AgreementInfoReq + DeviceUpdateReq = analysis.DeviceUpdateReq + EmptyReq = analysis.EmptyReq + FaceppMapBoxesReq = analysis.FaceppMapBoxesReq + GraphDetailReq = analysis.GraphDetailReq + IdReq = analysis.IdReq + ImagesDateReq = analysis.ImagesDateReq + ImagesListReq = analysis.ImagesListReq InternalCreateUserData = analysis.InternalCreateUserData InternalCreateUserReq = analysis.InternalCreateUserReq InternalSetRegisteredData = analysis.InternalSetRegisteredData InternalSetRegisteredReq = analysis.InternalSetRegisteredReq + LogReq = analysis.LogReq + OverviewReq = analysis.OverviewReq QrcodeInfoReq = analysis.QrcodeInfoReq + QrcodeShareReq = analysis.QrcodeShareReq Response = analysis.Response SwitchReq = analysis.SwitchReq + TaskIdReq = analysis.TaskIdReq + UserDetailReq = analysis.UserDetailReq + UserReq = analysis.UserReq Analysis interface { InternalCreateUser(ctx context.Context, in *InternalCreateUserReq, opts ...grpc.CallOption) (*InternalCreateUserData, error) @@ -29,6 +42,23 @@ type ( AgreementInfo(ctx context.Context, in *AgreementInfoReq, opts ...grpc.CallOption) (*Response, error) Switch(ctx context.Context, in *SwitchReq, opts ...grpc.CallOption) (*Response, error) QrcodeInfo(ctx context.Context, in *QrcodeInfoReq, opts ...grpc.CallOption) (*Response, error) + Log(ctx context.Context, in *LogReq, opts ...grpc.CallOption) (*Response, error) + Overview(ctx context.Context, in *OverviewReq, opts ...grpc.CallOption) (*Response, error) + User(ctx context.Context, in *UserReq, opts ...grpc.CallOption) (*Response, error) + UserDetail(ctx context.Context, in *UserDetailReq, opts ...grpc.CallOption) (*Response, error) + UserFacepp(ctx context.Context, in *TaskIdReq, opts ...grpc.CallOption) (*Response, error) + UserMode(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error) + UserLog(ctx context.Context, in *LogReq, opts ...grpc.CallOption) (*Response, error) + Banners(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error) + QrcodeShare(ctx context.Context, in *QrcodeShareReq, opts ...grpc.CallOption) (*Response, error) + GraphDetail(ctx context.Context, in *GraphDetailReq, opts ...grpc.CallOption) (*Response, error) + FaceppMaps(ctx context.Context, in *TaskIdReq, opts ...grpc.CallOption) (*Response, error) + FaceppMapBoxes(ctx context.Context, in *FaceppMapBoxesReq, opts ...grpc.CallOption) (*Response, error) + FaceppMapBoxDelete(ctx context.Context, in *IdReq, opts ...grpc.CallOption) (*Response, error) + ImagesDate(ctx context.Context, in *ImagesDateReq, opts ...grpc.CallOption) (*Response, error) + ImagesList(ctx context.Context, in *ImagesListReq, opts ...grpc.CallOption) (*Response, error) + ModeImage(ctx context.Context, in *TaskIdReq, opts ...grpc.CallOption) (*Response, error) + DeviceUpdate(ctx context.Context, in *DeviceUpdateReq, opts ...grpc.CallOption) (*Response, error) } defaultAnalysis struct { @@ -66,3 +96,88 @@ func (m *defaultAnalysis) QrcodeInfo(ctx context.Context, in *QrcodeInfoReq, opt client := analysis.NewAnalysisClient(m.cli.Conn()) return client.QrcodeInfo(ctx, in, opts...) } + +func (m *defaultAnalysis) Log(ctx context.Context, in *LogReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.Log(ctx, in, opts...) +} + +func (m *defaultAnalysis) Overview(ctx context.Context, in *OverviewReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.Overview(ctx, in, opts...) +} + +func (m *defaultAnalysis) User(ctx context.Context, in *UserReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.User(ctx, in, opts...) +} + +func (m *defaultAnalysis) UserDetail(ctx context.Context, in *UserDetailReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.UserDetail(ctx, in, opts...) +} + +func (m *defaultAnalysis) UserFacepp(ctx context.Context, in *TaskIdReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.UserFacepp(ctx, in, opts...) +} + +func (m *defaultAnalysis) UserMode(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.UserMode(ctx, in, opts...) +} + +func (m *defaultAnalysis) UserLog(ctx context.Context, in *LogReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.UserLog(ctx, in, opts...) +} + +func (m *defaultAnalysis) Banners(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.Banners(ctx, in, opts...) +} + +func (m *defaultAnalysis) QrcodeShare(ctx context.Context, in *QrcodeShareReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.QrcodeShare(ctx, in, opts...) +} + +func (m *defaultAnalysis) GraphDetail(ctx context.Context, in *GraphDetailReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.GraphDetail(ctx, in, opts...) +} + +func (m *defaultAnalysis) FaceppMaps(ctx context.Context, in *TaskIdReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.FaceppMaps(ctx, in, opts...) +} + +func (m *defaultAnalysis) FaceppMapBoxes(ctx context.Context, in *FaceppMapBoxesReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.FaceppMapBoxes(ctx, in, opts...) +} + +func (m *defaultAnalysis) FaceppMapBoxDelete(ctx context.Context, in *IdReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.FaceppMapBoxDelete(ctx, in, opts...) +} + +func (m *defaultAnalysis) ImagesDate(ctx context.Context, in *ImagesDateReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.ImagesDate(ctx, in, opts...) +} + +func (m *defaultAnalysis) ImagesList(ctx context.Context, in *ImagesListReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.ImagesList(ctx, in, opts...) +} + +func (m *defaultAnalysis) ModeImage(ctx context.Context, in *TaskIdReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.ModeImage(ctx, in, opts...) +} + +func (m *defaultAnalysis) DeviceUpdate(ctx context.Context, in *DeviceUpdateReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisClient(m.cli.Conn()) + return client.DeviceUpdate(ctx, in, opts...) +} diff --git a/services/analysis/client/analysisuser/analysisUser.go b/services/analysis/client/analysisuser/analysisUser.go index 60d87f9..5e24d43 100644 --- a/services/analysis/client/analysisuser/analysisUser.go +++ b/services/analysis/client/analysisuser/analysisUser.go @@ -24,6 +24,8 @@ type ( UserAuthUpdateReq = analysis.UserAuthUpdateReq UserDeleteReq = analysis.UserDeleteReq UserImproveReq = analysis.UserImproveReq + UserLogDeleteReq = analysis.UserLogDeleteReq + UserStatusReq = analysis.UserStatusReq AnalysisUser interface { FaceBind(ctx context.Context, in *FaceBindReq, opts ...grpc.CallOption) (*Response, error) @@ -35,6 +37,8 @@ type ( UserAuthUpdate(ctx context.Context, in *UserAuthUpdateReq, opts ...grpc.CallOption) (*Response, error) DeviceBind(ctx context.Context, in *DeviceBindReq, opts ...grpc.CallOption) (*Response, error) DeviceInfo(ctx context.Context, in *DeviceInfoReq, opts ...grpc.CallOption) (*Response, error) + UserLogDelete(ctx context.Context, in *UserLogDeleteReq, opts ...grpc.CallOption) (*Response, error) + UserStatus(ctx context.Context, in *UserStatusReq, opts ...grpc.CallOption) (*Response, error) } defaultAnalysisUser struct { @@ -92,3 +96,13 @@ func (m *defaultAnalysisUser) DeviceInfo(ctx context.Context, in *DeviceInfoReq, client := analysis.NewAnalysisUserClient(m.cli.Conn()) return client.DeviceInfo(ctx, in, opts...) } + +func (m *defaultAnalysisUser) UserLogDelete(ctx context.Context, in *UserLogDeleteReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisUserClient(m.cli.Conn()) + return client.UserLogDelete(ctx, in, opts...) +} + +func (m *defaultAnalysisUser) UserStatus(ctx context.Context, in *UserStatusReq, opts ...grpc.CallOption) (*Response, error) { + client := analysis.NewAnalysisUserClient(m.cli.Conn()) + return client.UserStatus(ctx, in, opts...) +} diff --git a/services/analysis/internal/config/wechat.go b/services/analysis/internal/config/wechat.go index ba200e9..f4f306c 100644 --- a/services/analysis/internal/config/wechat.go +++ b/services/analysis/internal/config/wechat.go @@ -13,6 +13,7 @@ type WechatConfig struct { Secret string Page string AuthPage string + ReportPage string Width int EnvVersion string } @@ -32,6 +33,10 @@ func LoadWechatConfig() (*WechatConfig, error) { if authPage == utils.StringEmpty { authPage = "pagesB/authorize/scan" } + reportPage := utils.GetConfigString("wechat.report_page") + if reportPage == utils.StringEmpty { + reportPage = "pagesB/details/index" + } width := utils.GetConfigInt("wechat.width") if width <= 0 { width = 430 @@ -46,6 +51,7 @@ func LoadWechatConfig() (*WechatConfig, error) { Secret: secret, Page: page, AuthPage: authPage, + ReportPage: reportPage, Width: width, EnvVersion: envVersion, }, nil diff --git a/services/analysis/internal/dao/banner.go b/services/analysis/internal/dao/banner.go new file mode 100644 index 0000000..a7ed7b4 --- /dev/null +++ b/services/analysis/internal/dao/banner.go @@ -0,0 +1,8 @@ +package dao + +type BannerItem struct { + Id int64 `gorm:"column:id" json:"id"` + Title string `gorm:"column:title" json:"title"` + ImageUrl string `gorm:"column:image_url" json:"image_url"` + LinkUrl string `gorm:"column:link_url" json:"link_url"` +} diff --git a/services/analysis/internal/dao/facepp.go b/services/analysis/internal/dao/facepp.go new file mode 100644 index 0000000..04143ab --- /dev/null +++ b/services/analysis/internal/dao/facepp.go @@ -0,0 +1,64 @@ +package dao + +import "lone-services/pkg/utils" + +const ( + FaceppMapTypeAcne = "acne" + FaceppMapTypeClosedComedones = "closed_comedones" + FaceppMapTypeBrownSpot = "brown_spot" + FaceppMapTypeMole = "mole" +) + +type FaceppMapMeta struct { + Type string + NameCN string + NameEN string +} + +var FaceppMapTypeMeta = []FaceppMapMeta{ + {Type: FaceppMapTypeAcne, NameCN: "痤疮", NameEN: "acne"}, + {Type: FaceppMapTypeClosedComedones, NameCN: "粉刺", NameEN: "comedones"}, + {Type: FaceppMapTypeBrownSpot, NameCN: "色斑", NameEN: "spot"}, + {Type: FaceppMapTypeMole, NameCN: "痣", NameEN: "mole"}, +} + +type FaceppAnalysis struct { + Id int64 `gorm:"column:id;primaryKey" json:"id"` + TaskId string `gorm:"column:task_id" json:"task_id"` + ResultOssPath string `gorm:"column:result_oss_path" json:"result_oss_path"` +} + +type FaceppMap struct { + Id int64 `gorm:"column:id;primaryKey" json:"id"` + TaskId string `gorm:"column:task_id" json:"task_id"` + Type string `gorm:"column:type" json:"type"` + Path string `gorm:"column:path" json:"path"` + ImageWidth int `gorm:"column:image_width" json:"image_width"` + ImageHeight int `gorm:"column:image_height" json:"image_height"` + CreatedAt utils.CustomTime `gorm:"column:created_at" json:"created_at"` + UpdatedAt utils.CustomTime `gorm:"column:updated_at" json:"updated_at"` +} + +type FaceppMapBox struct { + Id int64 `gorm:"column:id;primaryKey" json:"id"` + MapId int64 `gorm:"column:map_id" json:"map_id"` + Content string `gorm:"column:content" json:"content"` + CreatedAt utils.CustomTime `gorm:"column:created_at" json:"created_at"` + UpdatedAt utils.CustomTime `gorm:"column:updated_at" json:"updated_at"` +} + +type FaceppMapBoxItem struct { + Id int64 `json:"id"` + Content interface{} `json:"content"` +} + +type FaceppMapResource struct { + Id int64 `json:"id"` + Type string `json:"type"` + TypeName string `json:"type_name"` + TypeNameEn string `json:"type_name_en"` + Path string `json:"path"` + Boxes []FaceppMapBoxItem `json:"boxes"` + ImageWidth int `json:"image_width"` + ImageHeight int `json:"image_height"` +} diff --git a/services/analysis/internal/dao/graph.go b/services/analysis/internal/dao/graph.go new file mode 100644 index 0000000..795783e --- /dev/null +++ b/services/analysis/internal/dao/graph.go @@ -0,0 +1,39 @@ +package dao + +import "lone-services/pkg/utils" + +type UserGraph struct { + Id int64 `gorm:"column:id;primaryKey" json:"id"` + Type int `gorm:"column:type" json:"type"` + Name string `gorm:"column:name" json:"name"` + Title string `gorm:"column:title" json:"title"` + Images string `gorm:"column:images" json:"images"` + Status int8 `gorm:"column:status" json:"status"` + CreateAt utils.CustomTime `gorm:"column:created_at" json:"created_at"` + UpdateAt utils.CustomTime `gorm:"column:updated_at" json:"updated_at"` +} + +type UserGraphType struct { + Id int64 `gorm:"column:id;primaryKey" json:"id"` + Name string `gorm:"column:name" json:"name"` +} + +type GraphTitleItem struct { + Name string `json:"name"` + Content string `json:"content"` +} + +type GraphImageItem struct { + Url string `json:"url"` + Text string `json:"text"` +} + +type GraphResource struct { + Id int64 `json:"id"` + Type int `json:"type"` + Name string `json:"name"` + Title []GraphTitleItem `json:"title"` + Images []GraphImageItem `json:"images"` + TypeName string `json:"type_name"` + CreateAt utils.CustomTime `json:"created_at"` +} diff --git a/services/analysis/internal/dao/view.go b/services/analysis/internal/dao/view.go new file mode 100644 index 0000000..f2861c4 --- /dev/null +++ b/services/analysis/internal/dao/view.go @@ -0,0 +1,41 @@ +package dao + +type ImageLogResource struct { + Id int64 `json:"id"` + UserId int64 `json:"user_id"` + Cover string `json:"cover"` + Contents map[string]string `json:"contents"` + TaskId string `json:"task_id"` + CreateTime string `json:"create_time"` +} + +type ImageOverviewResource struct { + Id int64 `json:"id"` + UserId int64 `json:"user_id"` + Cover string `json:"cover"` + Contents interface{} `json:"contents"` + CreateTime string `json:"create_time"` +} + +type GalleryImageItem struct { + Date string `json:"date"` + URL string `json:"url"` +} + +type TagItem struct { + Id int64 `json:"id"` + Tag string `json:"tag"` +} + +type ViewUserInfo struct { + Id int64 `json:"id"` + UserId int64 `json:"user_id"` + Username string `json:"username"` + Nickname string `json:"nickname"` + Avatar string `json:"avatar"` + Mobile string `json:"mobile"` + Gender int `json:"gender"` + Birthday string `json:"birthday"` + Age string `json:"age"` + Tag []TagItem `json:"tag"` +} diff --git a/services/analysis/internal/logic/analysis/bannersLogic.go b/services/analysis/internal/logic/analysis/bannersLogic.go new file mode 100644 index 0000000..2c49859 --- /dev/null +++ b/services/analysis/internal/logic/analysis/bannersLogic.go @@ -0,0 +1,47 @@ +package analysislogic + +import ( + "context" + + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/dao" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/model" + "lone-services/services/analysis/internal/svc" + + "github.com/zeromicro/go-zero/core/logx" +) + +type BannersLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewBannersLogic(ctx context.Context, svcCtx *svc.ServiceContext) *BannersLogic { + return &BannersLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *BannersLogic) Banners(in *analysis.EmptyReq) (*analysis.Response, error) { + if _, fail := common.RequireLogin(l.ctx); fail != nil { + return fail, nil + } + var list []dao.BannerItem + err := model.BannerModel{}.Init().Items(modelbase.Params{ + Order: "sort desc", + }, &list) + if err != nil { + l.Errorf("banners: %v", err) + return common.FailResponse(utils.ErrorNotFund), nil + } + if list == nil { + list = []dao.BannerItem{} + } + return common.OkResponse(list), nil +} diff --git a/services/analysis/internal/logic/analysis/deviceUpdateLogic.go b/services/analysis/internal/logic/analysis/deviceUpdateLogic.go new file mode 100644 index 0000000..a41c6b8 --- /dev/null +++ b/services/analysis/internal/logic/analysis/deviceUpdateLogic.go @@ -0,0 +1,93 @@ +package analysislogic + +import ( + "context" + + "lone-services/pkg/utils" + "lone-services/pkg/validate" + analysis "lone-services/rpc/analysis/pb" + equipmentpb "lone-services/rpc/equipment/pb" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + jsoniter "github.com/json-iterator/go" + "github.com/zeromicro/go-zero/core/logx" +) + +type DeviceUpdateLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewDeviceUpdateLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeviceUpdateLogic { + return &DeviceUpdateLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +type equipmentBindSnap struct { + HostCode string `json:"host_code"` + Type int32 `json:"type"` +} + +func (l *DeviceUpdateLogic) DeviceUpdate(in *analysis.DeviceUpdateReq) (*analysis.Response, error) { + var req validator.DeviceUpdateValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return outParams(msg), nil + } + if _, fail := common.RequireLogin(l.ctx); fail != nil { + return fail, nil + } + if l.svcCtx.EquipmentSvcName == utils.StringEmpty { + return common.FailResponse(utils.Fail), nil + } + cli, err := svc.GetRpcClient(l.svcCtx.EquipmentSvcName) + if err != nil { + l.Errorf("device update rpc: %v", err) + return common.FailResponse(utils.Fail), nil + } + equipmentClient := equipmentpb.NewEquipmentClient(cli.Conn()) + + info, err := equipmentClient.InternalBindInfo(l.ctx, &equipmentpb.InternalBindInfoRequest{ + Id: req.Id, + }) + if err != nil { + l.Errorf("device update bind info: %v", err) + return common.FailResponse(utils.Fail), nil + } + if info == nil { + return common.FailResponse(utils.Fail), nil + } + if info.Code != utils.Ok.Code { + return &analysis.Response{Code: info.Code, Msg: info.Msg}, nil + } + + var snap equipmentBindSnap + if info.Data != utils.StringEmpty && info.Data != "null" { + _ = jsoniter.UnmarshalFromString(info.Data, &snap) + } + if snap.HostCode == utils.StringEmpty || snap.Type == utils.NumberZero { + return common.FailResponse(utils.ErrorNotFund), nil + } + + edited, err := equipmentClient.ApiEditName(l.ctx, &equipmentpb.ApiEditNameRequest{ + HostCode: snap.HostCode, + HostNickname: req.DeviceName, + Type: snap.Type, + }) + if err != nil { + l.Errorf("device update edit name: %v", err) + return common.FailResponse(utils.Fail), nil + } + if edited == nil { + return common.FailResponse(utils.Fail), nil + } + if edited.Code != utils.Ok.Code { + return &analysis.Response{Code: edited.Code, Msg: edited.Msg}, nil + } + return common.OkResponse(nil), nil +} diff --git a/services/analysis/internal/logic/analysis/facepp.go b/services/analysis/internal/logic/analysis/facepp.go new file mode 100644 index 0000000..d933874 --- /dev/null +++ b/services/analysis/internal/logic/analysis/facepp.go @@ -0,0 +1,188 @@ +package analysislogic + +import ( + "context" + "encoding/json" + "strconv" + "strings" + + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/dao" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/model" + + jsoniter "github.com/json-iterator/go" + "github.com/zeromicro/go-zero/core/logx" +) + +func jsonUnmarshal(raw string, dest interface{}) error { + return jsoniter.UnmarshalFromString(raw, dest) +} + +func parseFaceppBoxes(raw string) interface{} { + if raw == utils.StringEmpty { + return nil + } + var value interface{} + if err := jsoniter.UnmarshalFromString(raw, &value); err != nil { + return raw + } + return value +} + +func splitBoxContents(boxes string) []string { + boxes = strings.TrimSpace(boxes) + if boxes == utils.StringEmpty { + return nil + } + var arr []json.RawMessage + if err := json.Unmarshal([]byte(boxes), &arr); err != nil { + return []string{boxes} + } + out := make([]string, 0, len(arr)) + for _, item := range arr { + if len(item) == 0 || string(item) == "null" { + continue + } + out = append(out, string(item)) + } + return out +} + +func faceppMaps(ctx context.Context, taskId string) ([]dao.FaceppMapResource, *analysis.Response) { + var rows []dao.FaceppMap + err := model.FaceppMapModel{}.Init().Items(modelbase.Params{ + Eq: map[string]string{"task_id": taskId}, + }, &rows) + if err != nil { + logx.WithContext(ctx).Errorf("facepp maps %s: %v", taskId, err) + return nil, common.FailResponse(utils.Fail) + } + + byType := make(map[string]dao.FaceppMap, len(rows)) + mapIDs := make([]int64, 0, len(rows)) + for _, row := range rows { + byType[row.Type] = row + if row.Id > utils.NumberZero { + mapIDs = append(mapIDs, row.Id) + } + } + boxRows, fail := listFaceppBoxes(ctx, mapIDs) + if fail != nil { + return nil, fail + } + boxesByMap := make(map[int64][]dao.FaceppMapBoxItem, len(mapIDs)) + for _, box := range boxRows { + boxesByMap[box.MapId] = append(boxesByMap[box.MapId], dao.FaceppMapBoxItem{ + Id: box.Id, + Content: parseFaceppBoxes(box.Content), + }) + } + + list := make([]dao.FaceppMapResource, 0, len(dao.FaceppMapTypeMeta)) + for _, meta := range dao.FaceppMapTypeMeta { + item := dao.FaceppMapResource{ + Type: meta.Type, + TypeName: meta.NameCN, + TypeNameEn: meta.NameEN, + Boxes: []dao.FaceppMapBoxItem{}, + } + if row, ok := byType[meta.Type]; ok { + item.Id = row.Id + item.Path = row.Path + item.ImageWidth = row.ImageWidth + item.ImageHeight = row.ImageHeight + if boxes, ok := boxesByMap[row.Id]; ok { + item.Boxes = boxes + } + } + list = append(list, item) + } + return list, nil +} + +func listFaceppBoxes(ctx context.Context, mapIDs []int64) ([]dao.FaceppMapBox, *analysis.Response) { + if len(mapIDs) == utils.NumberZero { + return nil, nil + } + ids := int64Strings(mapIDs) + if len(ids) == utils.NumberZero { + return nil, nil + } + var rows []dao.FaceppMapBox + err := model.FaceppMapBoxModel{}.Init().Items(modelbase.Params{ + In: map[string][]string{"map_id": ids}, + Order: "id asc", + }, &rows) + if err != nil { + logx.WithContext(ctx).Errorf("facepp boxes: %v", err) + return nil, common.FailResponse(utils.Fail) + } + return rows, nil +} + +func loadFaceppMap(ctx context.Context, id int64) (*dao.FaceppMap, *analysis.Response) { + if id < utils.NumberOne { + return nil, common.FailResponse(utils.ErrorNotFund) + } + var row dao.FaceppMap + err := model.FaceppMapModel{}.Init().GetOne(modelbase.Params{ + Eq: map[string]string{"id": strconv.FormatInt(id, utils.NumberTen)}, + }, &row) + if err != nil { + logx.WithContext(ctx).Errorf("facepp map %d: %v", id, err) + return nil, common.FailResponse(utils.Fail) + } + if row.Id < utils.NumberOne { + return nil, common.FailResponse(utils.ErrorNotFund) + } + return &row, nil +} + +func loadFaceppBox(ctx context.Context, id int64) (*dao.FaceppMapBox, *analysis.Response) { + if id < utils.NumberOne { + return nil, common.FailResponse(utils.ErrorNotFund) + } + var row dao.FaceppMapBox + err := model.FaceppMapBoxModel{}.Init().GetOne(modelbase.Params{ + Eq: map[string]string{"id": strconv.FormatInt(id, utils.NumberTen)}, + }, &row) + if err != nil { + logx.WithContext(ctx).Errorf("facepp box %d: %v", id, err) + return nil, common.FailResponse(utils.Fail) + } + if row.Id < utils.NumberOne { + return nil, common.FailResponse(utils.ErrorNotFund) + } + return &row, nil +} + +func saveFaceppBoxes(ctx context.Context, id int64, boxes string) *analysis.Response { + if _, fail := loadFaceppMap(ctx, id); fail != nil { + if fail.Code == utils.ErrorNotFund.Code { + return common.OutResponse(utils.Fail, "facepp map not found") + } + return fail + } + contents := splitBoxContents(boxes) + if len(contents) == utils.NumberZero { + return nil + } + now := utils.Now() + boxModel := model.FaceppMapBoxModel{}.Init() + for _, content := range contents { + row := dao.FaceppMapBox{ + MapId: id, + Content: content, + CreatedAt: now, + UpdatedAt: now, + } + if err := boxModel.Create(&row); err != nil { + logx.WithContext(ctx).Errorf("save facepp boxes %d: %v", id, err) + return common.OutResponse(utils.Fail, err.Error()) + } + } + return nil +} diff --git a/services/analysis/internal/logic/analysis/faceppMapBoxDeleteLogic.go b/services/analysis/internal/logic/analysis/faceppMapBoxDeleteLogic.go new file mode 100644 index 0000000..d407377 --- /dev/null +++ b/services/analysis/internal/logic/analysis/faceppMapBoxDeleteLogic.go @@ -0,0 +1,60 @@ +package analysislogic + +import ( + "context" + "strconv" + + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + "lone-services/pkg/validate" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/dao" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/model" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + "github.com/zeromicro/go-zero/core/logx" +) + +type FaceppMapBoxDeleteLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewFaceppMapBoxDeleteLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FaceppMapBoxDeleteLogic { + return &FaceppMapBoxDeleteLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *FaceppMapBoxDeleteLogic) FaceppMapBoxDelete(in *analysis.IdReq) (*analysis.Response, error) { + var req validator.IdValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return outParams(msg), nil + } + + box, fail := loadFaceppBox(l.ctx, req.Id) + if fail != nil { + return common.FailResponse(utils.ErrorNotFund), nil + } + faceMap, fail := loadFaceppMap(l.ctx, box.MapId) + if fail != nil { + return common.FailResponse(utils.ErrorNotFund), nil + } + if _, fail = authorizeTask(l.ctx, faceMap.TaskId); fail != nil { + return fail, nil + } + + _, err := model.FaceppMapBoxModel{}.Init().Del(modelbase.Params{ + Eq: map[string]string{"id": strconv.FormatInt(req.Id, utils.NumberTen)}, + }, &dao.FaceppMapBox{}) + if err != nil { + l.Errorf("delete facepp box %d: %v", req.Id, err) + return common.FailResponse(utils.Fail), nil + } + return common.OkResponse(nil), nil +} diff --git a/services/analysis/internal/logic/analysis/faceppMapBoxesLogic.go b/services/analysis/internal/logic/analysis/faceppMapBoxesLogic.go new file mode 100644 index 0000000..9bdcab4 --- /dev/null +++ b/services/analysis/internal/logic/analysis/faceppMapBoxesLogic.go @@ -0,0 +1,47 @@ +package analysislogic + +import ( + "context" + + "lone-services/pkg/utils" + "lone-services/pkg/validate" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + "github.com/zeromicro/go-zero/core/logx" +) + +type FaceppMapBoxesLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewFaceppMapBoxesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FaceppMapBoxesLogic { + return &FaceppMapBoxesLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *FaceppMapBoxesLogic) FaceppMapBoxes(in *analysis.FaceppMapBoxesReq) (*analysis.Response, error) { + var req validator.FaceppMapBoxesValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return outParams(msg), nil + } + + faceMap, fail := loadFaceppMap(l.ctx, req.Id) + if fail != nil { + return common.FailResponse(utils.ErrorNotFund), nil + } + if _, fail = authorizeTask(l.ctx, faceMap.TaskId); fail != nil { + return fail, nil + } + if fail = saveFaceppBoxes(l.ctx, req.Id, req.Boxes); fail != nil { + return fail, nil + } + return common.OkResponse(nil), nil +} diff --git a/services/analysis/internal/logic/analysis/faceppMapsLogic.go b/services/analysis/internal/logic/analysis/faceppMapsLogic.go new file mode 100644 index 0000000..1d127bb --- /dev/null +++ b/services/analysis/internal/logic/analysis/faceppMapsLogic.go @@ -0,0 +1,43 @@ +package analysislogic + +import ( + "context" + + "lone-services/pkg/utils" + "lone-services/pkg/validate" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + "github.com/zeromicro/go-zero/core/logx" +) + +type FaceppMapsLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewFaceppMapsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FaceppMapsLogic { + return &FaceppMapsLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *FaceppMapsLogic) FaceppMaps(in *analysis.TaskIdReq) (*analysis.Response, error) { + var req validator.TaskIdValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return outParams(msg), nil + } + if _, fail := authorizeTask(l.ctx, req.TaskId); fail != nil { + return fail, nil + } + list, fail := faceppMaps(l.ctx, req.TaskId) + if fail != nil { + return fail, nil + } + return common.OkResponse(map[string]interface{}{"list": list}), nil +} diff --git a/services/analysis/internal/logic/analysis/gallery.go b/services/analysis/internal/logic/analysis/gallery.go new file mode 100644 index 0000000..ffb659e --- /dev/null +++ b/services/analysis/internal/logic/analysis/gallery.go @@ -0,0 +1,146 @@ +package analysislogic + +import ( + "fmt" + "strings" + "time" + + "lone-services/pkg/utils" + "lone-services/services/analysis/internal/dao" +) + +type skinMode struct { + name string + english string + chinese string +} + +var skinModeList = []skinMode{ + {name: "uv405", english: "blue", chinese: "蓝光分析"}, + {name: "cross", english: "pigment", chinese: "色素分析"}, + {name: "parallel", english: "sensitivity", chinese: "敏感分析"}, + {name: "uv365", english: "red", chinese: "红区分析"}, + {name: "original_parallel", english: "parallel", chinese: "平行偏振"}, + {name: "original_cross", english: "cross", chinese: "交叉偏振"}, + {name: "original_visible", english: "visible", chinese: "可见光"}, + {name: "original_uv365", english: "uv", chinese: "紫外光"}, + {name: "original_uv385", english: "wood", chinese: "伍德"}, + {name: "original_uv405", english: "blue", chinese: "蓝光"}, +} + +func skinModes() []map[string]string { + out := make([]map[string]string, 0, len(skinModeList)) + for _, item := range skinModeList { + out = append(out, map[string]string{ + "name": item.name, + "english": item.english, + "chinese": item.chinese, + }) + } + return out +} + +func galleryModeName(name string) bool { + for _, item := range skinModeList { + if item.name == name { + return true + } + } + return false +} + +func galleryPosition(position string) string { + switch strings.ToLower(strings.TrimSpace(position)) { + case "left": + return "left" + case "mid", "min": + return "mid" + case "right": + return "right" + default: + return utils.StringEmpty + } +} + +func galleryDateRange(start, end string) (time.Time, time.Time, error) { + layout := "2006-01-02" + startDate, err := time.Parse(layout, start) + if err != nil { + return time.Time{}, time.Time{}, fmt.Errorf("开始时间格式错误") + } + endDate, err := time.Parse(layout, end) + if err != nil { + return time.Time{}, time.Time{}, fmt.Errorf("结束时间格式错误") + } + if startDate.After(endDate) { + return time.Time{}, time.Time{}, fmt.Errorf("开始时间不能晚于结束时间") + } + if endDate.After(startDate.AddDate(1, 0, 0)) { + return time.Time{}, time.Time{}, fmt.Errorf("开始和结束时间不能超过一年") + } + return startDate, endDate, nil +} + +type imageGroup struct { + Left string `json:"left"` + Mid string `json:"mid"` + Right string `json:"right"` +} + +type skinImages struct { + Images map[string]imageGroup `json:"images"` +} + +func imageURL(raw, name, position string) string { + if raw == utils.StringEmpty { + return utils.StringEmpty + } + var images skinImages + if err := jsonUnmarshal(raw, &images); err != nil { + return utils.StringEmpty + } + group, ok := images.Images[name] + if !ok { + return utils.StringEmpty + } + switch position { + case "left": + return group.Left + case "mid": + return group.Mid + case "right": + return group.Right + default: + return utils.StringEmpty + } +} + +func taskModeImages(raw string) map[string]string { + images := map[string]string{} + if raw == utils.StringEmpty { + return images + } + var parsed skinImages + if err := jsonUnmarshal(raw, &parsed); err != nil { + return images + } + for name, group := range parsed.Images { + images[name] = group.Mid + } + return images +} + +func galleryItems(rows []dao.Image, mode, position string) []dao.GalleryImageItem { + list := make([]dao.GalleryImageItem, 0) + for _, row := range rows { + url := imageURL(row.Images, mode, position) + if url == utils.StringEmpty { + continue + } + list = append(list, dao.GalleryImageItem{ + Date: row.CreateTime.Format("2006/01/02 15:04"), + URL: url, + }) + } + return list +} diff --git a/services/analysis/internal/logic/analysis/graphDetailLogic.go b/services/analysis/internal/logic/analysis/graphDetailLogic.go new file mode 100644 index 0000000..2e1ad6c --- /dev/null +++ b/services/analysis/internal/logic/analysis/graphDetailLogic.go @@ -0,0 +1,80 @@ +package analysislogic + +import ( + "context" + "strconv" + + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + "lone-services/pkg/validate" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/dao" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/model" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + jsoniter "github.com/json-iterator/go" + "github.com/zeromicro/go-zero/core/logx" +) + +type GraphDetailLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewGraphDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GraphDetailLogic { + return &GraphDetailLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *GraphDetailLogic) GraphDetail(in *analysis.GraphDetailReq) (*analysis.Response, error) { + var req validator.GraphDetailValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return outParams(msg), nil + } + if _, fail := common.RequireLogin(l.ctx); fail != nil { + return fail, nil + } + + var graph dao.UserGraph + err := model.GraphModel{}.Init().GetOne(modelbase.Params{ + Eq: map[string]string{ + "type": strconv.Itoa(int(req.Type)), + "status": strconv.Itoa(utils.StatusOk), + }, + Order: "id desc", + }, &graph) + if err != nil { + l.Errorf("graph detail: %v", err) + return common.FailResponse(utils.Fail), nil + } + + var title []dao.GraphTitleItem + var images []dao.GraphImageItem + _ = jsoniter.UnmarshalFromString(graph.Title, &title) + _ = jsoniter.UnmarshalFromString(graph.Images, &images) + + typeName := utils.StringEmpty + var graphType dao.UserGraphType + err = model.GraphTypeModel{}.Init().GetOne(modelbase.Params{ + Eq: map[string]string{"id": strconv.Itoa(graph.Type)}, + }, &graphType) + if err == nil { + typeName = graphType.Name + } + + return common.OkResponse(&dao.GraphResource{ + Id: graph.Id, + Type: graph.Type, + TypeName: typeName, + Name: graph.Name, + Title: title, + Images: images, + CreateAt: graph.CreateAt, + }), nil +} diff --git a/services/analysis/internal/logic/analysis/imagesDateLogic.go b/services/analysis/internal/logic/analysis/imagesDateLogic.go new file mode 100644 index 0000000..68c95b4 --- /dev/null +++ b/services/analysis/internal/logic/analysis/imagesDateLogic.go @@ -0,0 +1,50 @@ +package analysislogic + +import ( + "context" + + "lone-services/pkg/utils" + "lone-services/pkg/validate" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/model" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + "github.com/zeromicro/go-zero/core/logx" +) + +type ImagesDateLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewImagesDateLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ImagesDateLogic { + return &ImagesDateLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *ImagesDateLogic) ImagesDate(in *analysis.ImagesDateReq) (*analysis.Response, error) { + var req validator.ImagesDateValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return outParams(msg), nil + } + if _, _, err := galleryDateRange(req.StartTime, req.EndTime); err != nil { + return common.OutResponse(utils.Fail, err.Error()), nil + } + userId, fail := authGalleryUser(l.ctx, req.UserId) + if fail != nil { + return fail, nil + } + span := utils.DateRangeWithTime([]string{req.StartTime, req.EndTime}) + list, err := model.ImageModel{}.Dates(userId, utils.StatusOk, span[0], span[1]) + if err != nil { + l.Errorf("image dates: %v", err) + return common.OutResponse(utils.Fail, err.Error()), nil + } + return common.OkResponse(list), nil +} diff --git a/services/analysis/internal/logic/analysis/imagesListLogic.go b/services/analysis/internal/logic/analysis/imagesListLogic.go new file mode 100644 index 0000000..a956c69 --- /dev/null +++ b/services/analysis/internal/logic/analysis/imagesListLogic.go @@ -0,0 +1,71 @@ +package analysislogic + +import ( + "context" + "strconv" + + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + "lone-services/pkg/validate" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/dao" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/model" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + "github.com/zeromicro/go-zero/core/logx" +) + +type ImagesListLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewImagesListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ImagesListLogic { + return &ImagesListLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *ImagesListLogic) ImagesList(in *analysis.ImagesListReq) (*analysis.Response, error) { + var req validator.ImagesListValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return outParams(msg), nil + } + if _, _, err := galleryDateRange(req.StartTime, req.EndTime); err != nil { + return common.OutResponse(utils.Fail, err.Error()), nil + } + if !galleryModeName(req.Mode) { + return common.OutResponse(utils.Fail, "模式不存在"), nil + } + position := galleryPosition(req.Position) + if position == utils.StringEmpty { + return common.OutResponse(utils.Fail, "脸部位置错误"), nil + } + userId, fail := authGalleryUser(l.ctx, req.UserId) + if fail != nil { + return fail, nil + } + + span := utils.DateRangeWithTime([]string{req.StartTime, req.EndTime}) + var rows []dao.Image + err := model.ImageModel{}.Init().Items(modelbase.Params{ + Eq: map[string]string{ + "user_id": strconv.FormatInt(userId, utils.NumberTen), + "status": strconv.Itoa(utils.StatusOk), + }, + Between: map[string][2]string{ + "create_time": span, + }, + Order: "create_time asc", + }, &rows) + if err != nil { + l.Errorf("image list: %v", err) + return common.OutResponse(utils.Fail, err.Error()), nil + } + return common.OkResponse(galleryItems(rows, req.Mode, position)), nil +} diff --git a/services/analysis/internal/logic/analysis/logLogic.go b/services/analysis/internal/logic/analysis/logLogic.go new file mode 100644 index 0000000..bc8b91c --- /dev/null +++ b/services/analysis/internal/logic/analysis/logLogic.go @@ -0,0 +1,35 @@ +package analysislogic + +import ( + "context" + + "lone-services/pkg/utils" + "lone-services/pkg/validate" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + "github.com/zeromicro/go-zero/core/logx" +) + +type LogLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewLogLogic(ctx context.Context, svcCtx *svc.ServiceContext) *LogLogic { + return &LogLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *LogLogic) Log(in *analysis.LogReq) (*analysis.Response, error) { + var req validator.LogValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return outParams(msg), nil + } + return imageLogs(l.ctx, req.UserId, req.Page, req.Size) +} diff --git a/services/analysis/internal/logic/analysis/modeImageLogic.go b/services/analysis/internal/logic/analysis/modeImageLogic.go new file mode 100644 index 0000000..903c93f --- /dev/null +++ b/services/analysis/internal/logic/analysis/modeImageLogic.go @@ -0,0 +1,70 @@ +package analysislogic + +import ( + "context" + "strconv" + + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + "lone-services/pkg/validate" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/dao" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/model" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + "github.com/zeromicro/go-zero/core/logx" +) + +type ModeImageLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewModeImageLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ModeImageLogic { + return &ModeImageLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *ModeImageLogic) ModeImage(in *analysis.TaskIdReq) (*analysis.Response, error) { + var req validator.TaskIdValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return outParams(msg), nil + } + if _, fail := authorizeTask(l.ctx, req.TaskId); fail != nil { + return fail, nil + } + + var row dao.Image + err := model.ImageModel{}.Init().GetOne(modelbase.Params{ + Eq: map[string]string{ + "task_id": req.TaskId, + "status": strconv.Itoa(utils.StatusOk), + }, + Order: "id desc", + }, &row) + if err != nil { + l.Errorf("mode image %s: %v", req.TaskId, err) + return common.FailResponse(utils.Fail), nil + } + images := map[string]string{} + if row.Id > utils.NumberZero && row.Images != utils.StringEmpty { + images = taskModeImages(row.Images) + } + + data := make([]map[string]string, 0, len(skinModeList)) + for _, item := range skinModeList { + data = append(data, map[string]string{ + "name": item.name, + "english": item.english, + "chinese": item.chinese, + "image": images[item.name], + }) + } + return common.OkResponse(data), nil +} diff --git a/services/analysis/internal/logic/analysis/overviewLogic.go b/services/analysis/internal/logic/analysis/overviewLogic.go new file mode 100644 index 0000000..e668622 --- /dev/null +++ b/services/analysis/internal/logic/analysis/overviewLogic.go @@ -0,0 +1,105 @@ +package analysislogic + +import ( + "context" + "strconv" + + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + "lone-services/pkg/validate" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/dao" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/model" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + jsoniter "github.com/json-iterator/go" + "github.com/zeromicro/go-zero/core/logx" +) + +type OverviewLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewOverviewLogic(ctx context.Context, svcCtx *svc.ServiceContext) *OverviewLogic { + return &OverviewLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *OverviewLogic) Overview(in *analysis.OverviewReq) (*analysis.Response, error) { + var req validator.OverviewValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return outParams(msg), nil + } + + login, fail := common.RequireLogin(l.ctx) + if fail != nil { + return fail, nil + } + + var userId int64 + switch login.Type { + case dao.TypeUser: + userId = login.BizId + case dao.TypeStore: + var image dao.Image + err := model.ImageModel{}.Init().GetOne(modelbase.Params{ + Eq: map[string]string{"id": strconv.FormatInt(req.Id, utils.NumberTen)}, + }, &image) + if err != nil { + l.Errorf("overview image: %v", err) + return common.FailResponse(utils.Fail), nil + } + owner, err := common.AuthUserNoExpiry(login.BizId, image.UserId) + if err != nil { + l.Errorf("overview auth: %v", err) + return common.FailResponse(utils.Fail), nil + } + if owner == utils.NumberZero { + return common.NotYoursResponse(), nil + } + userId = image.UserId + default: + return common.FailResponse(utils.ErrorAuthority), nil + } + + where := modelbase.Params{ + Eq: map[string]string{ + "user_id": strconv.FormatInt(userId, utils.NumberTen), + }, + Order: "id desc", + } + if req.Id > utils.NumberZero { + where.Eq["id"] = strconv.FormatInt(req.Id, utils.NumberTen) + } + + var row dao.Image + err := model.ImageModel{}.Init().GetOne(where, &row) + if err != nil { + l.Errorf("overview get: %v", err) + return common.FailResponse(utils.Fail), nil + } + if row.Id < utils.NumberOne { + return common.OkResponse(nil), nil + } + + var contents interface{} + if row.Contents != utils.StringEmpty { + if err := jsoniter.UnmarshalFromString(row.Contents, &contents); err != nil { + contents = nil + } + } + return common.OkResponse(&dao.ImageOverviewResource{ + Id: row.Id, + UserId: row.UserId, + Cover: row.Cover, + Contents: contents, + CreateTime: row.CreateTime.Format(imageTimeLayout), + }), nil +} diff --git a/services/analysis/internal/logic/analysis/params.go b/services/analysis/internal/logic/analysis/params.go new file mode 100644 index 0000000..d89669e --- /dev/null +++ b/services/analysis/internal/logic/analysis/params.go @@ -0,0 +1,11 @@ +package analysislogic + +import ( + "lone-services/pkg/utils" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/logic/common" +) + +func outParams(msg string) *analysis.Response { + return common.OutResponse(utils.ErrorParams, msg) +} diff --git a/services/analysis/internal/logic/analysis/qrcodeShareLogic.go b/services/analysis/internal/logic/analysis/qrcodeShareLogic.go new file mode 100644 index 0000000..cf6c01f --- /dev/null +++ b/services/analysis/internal/logic/analysis/qrcodeShareLogic.go @@ -0,0 +1,157 @@ +package analysislogic + +import ( + "context" + "fmt" + "strconv" + "time" + + "lone-services/pkg/modelbase" + "lone-services/pkg/redis" + "lone-services/pkg/utils" + "lone-services/pkg/validate" + "lone-services/pkg/wechat/qrcode" + pkgws "lone-services/pkg/ws" + analysis "lone-services/rpc/analysis/pb" + chore "lone-services/rpc/chore/pb" + analysisconfig "lone-services/services/analysis/internal/config" + "lone-services/services/analysis/internal/dao" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/model" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + "github.com/google/uuid" + "github.com/zeromicro/go-zero/core/logx" +) + +const qrShareTTL = 24 * time.Hour + +type QrcodeShareLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewQrcodeShareLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QrcodeShareLogic { + return &QrcodeShareLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *QrcodeShareLogic) QrcodeShare(in *analysis.QrcodeShareReq) (*analysis.Response, error) { + var req validator.QrcodeShareValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return outParams(msg), nil + } + login, fail := common.RequireLogin(l.ctx) + if fail != nil { + return fail, nil + } + + owned, err := l.imagesOwned(req.Ids, login.BizId) + if err != nil { + l.Errorf("qrcode share check image: %v", err) + return common.FailResponse(utils.Fail), nil + } + if !owned { + return common.NotYoursResponse(), nil + } + + if redis.Client == nil { + return common.FailResponse(utils.Fail), nil + } + for _, id := range req.Ids { + idStr := strconv.FormatInt(id, utils.NumberTen) + key := pkgws.RedisKeyQRShare + utils.MD5Encrypt(idStr) + if err = redis.Client.Set(l.ctx, key, idStr, qrShareTTL).Err(); err != nil { + l.Errorf("qrcode share redis: %v", err) + return common.FailResponse(utils.Fail), nil + } + } + + typeVal := utils.NumberOne + if len(req.Ids) > utils.NumberOne { + typeVal = utils.NumberTwo + } + wxCfg, err := analysisconfig.LoadWechatConfig() + if err != nil { + l.Errorf("qrcode share wechat config: %v", err) + return common.OutResponse(utils.Fail, "微信配置缺失"), nil + } + path := fmt.Sprintf("%s?type=%d&ids=%s", wxCfg.ReportPage, typeVal, joinIds(req.Ids)) + img, err := wxCfg.NewQrcodeClient().CreateWxaCode(l.ctx, &qrcode.WxaCodeRequest{ + Path: path, + Width: wxCfg.Width, + EnvVersion: wxCfg.EnvVersion, + AutoColor: false, + LineColor: &qrcode.LineColor{R: 255, G: 255, B: 255}, + IsHyaline: true, + }) + if err != nil { + l.Errorf("qrcode share wechat: %v", err) + return common.FailResponse(utils.Fail), nil + } + qrURL, err := l.uploadQrcode(img) + if err != nil { + l.Errorf("qrcode share upload: %v", err) + return common.OutResponse(utils.Fail, "upload qrcode failed"), nil + } + return common.OkResponse(map[string]string{ + "qrcode": qrURL, + "time": utils.Now().String(), + }), nil +} + +func (l *QrcodeShareLogic) imagesOwned(ids []int64, userId int64) (bool, error) { + if userId < utils.NumberOne || len(ids) == utils.NumberZero { + return false, nil + } + var rows []dao.Image + err := model.ImageModel{}.Init().Items(modelbase.Params{ + In: map[string][]string{"id": int64Strings(ids)}, + Eq: map[string]string{ + "user_id": strconv.FormatInt(userId, utils.NumberTen), + "status": strconv.Itoa(utils.StatusOk), + }, + }, &rows) + if err != nil { + return false, err + } + return len(rows) == len(ids), nil +} + +func (l *QrcodeShareLogic) uploadQrcode(content []byte) (string, error) { + if l.svcCtx.ChoreSvcName == utils.StringEmpty { + return "", fmt.Errorf("chore service name empty") + } + cli, err := svc.GetRpcClient(l.svcCtx.ChoreSvcName) + if err != nil { + return "", err + } + res, err := chore.NewChoreClient(cli.Conn()).InternalUpload(l.ctx, &chore.InternalUploadReq{ + Filename: uuid.New().String() + ".png", + Content: content, + }) + if err != nil { + return "", err + } + if res == nil || res.Url == utils.StringEmpty { + return "", fmt.Errorf("chore upload empty url") + } + return res.Url, nil +} + +func joinIds(ids []int64) string { + parts := int64Strings(ids) + out := "" + for i, part := range parts { + if i > 0 { + out += "," + } + out += part + } + return out +} diff --git a/services/analysis/internal/logic/analysis/support.go b/services/analysis/internal/logic/analysis/support.go new file mode 100644 index 0000000..2b8486c --- /dev/null +++ b/services/analysis/internal/logic/analysis/support.go @@ -0,0 +1,133 @@ +package analysislogic + +import ( + "context" + "strconv" + + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/dao" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/model" + + jsoniter "github.com/json-iterator/go" + "github.com/zeromicro/go-zero/core/logx" +) + +func int64Strings(ids []int64) []string { + out := make([]string, 0, len(ids)) + for _, id := range ids { + if id < utils.NumberOne { + continue + } + out = append(out, strconv.FormatInt(id, utils.NumberTen)) + } + return out +} + +func dateHead(value string) string { + if len(value) >= len("2006-01-02") { + return value[:len("2006-01-02")] + } + return value +} + +func authGalleryUser(ctx context.Context, requestUserId int64) (int64, *analysis.Response) { + login, fail := common.RequireLogin(ctx) + if fail != nil { + return utils.NumberZero, fail + } + userId, err := common.GetAuthUser(login, requestUserId) + if err != nil { + logx.WithContext(ctx).Errorf("auth gallery user: %v", err) + return utils.NumberZero, common.FailResponse(utils.Fail) + } + if userId == utils.NumberZero { + return utils.NumberZero, common.NotYoursResponse() + } + return userId, nil +} + +func authorizeTask(ctx context.Context, taskId string) (*dao.ImageAnalysis, *analysis.Response) { + var row dao.ImageAnalysis + err := model.ImageAnalysisModel{}.Init().GetOne(modelbase.Params{ + Eq: map[string]string{"task_id": taskId}, + }, &row) + if err != nil { + logx.WithContext(ctx).Errorf("load analysis %s: %v", taskId, err) + return nil, common.FailResponse(utils.Fail) + } + if row.Id < utils.NumberOne { + return nil, common.FailResponse(utils.ErrorNotFund) + } + login, fail := common.RequireLogin(ctx) + if fail != nil { + return nil, fail + } + owner, err := common.GetAuthUserID(login, row.UserId) + if err != nil { + logx.WithContext(ctx).Errorf("auth analysis %s: %v", taskId, err) + return nil, common.FailResponse(utils.Fail) + } + if owner == utils.NumberZero { + return nil, common.NotYoursResponse() + } + return &row, nil +} + +func queryImageLogs(ctx context.Context, userId int64, page, size int32) ([]dao.ImageLogResource, *analysis.Response) { + var rows []dao.Image + _, err := model.ImageModel{}.Init().Page(modelbase.Params{ + Eq: map[string]string{ + "user_id": strconv.FormatInt(userId, utils.NumberTen), + "status": strconv.Itoa(utils.StatusOk), + }, + Order: "id desc", + Page: int(page), + Size: int(size), + }, &rows) + if err != nil { + logx.WithContext(ctx).Errorf("image logs: %v", err) + return nil, common.FailResponse(utils.ErrorNotFund) + } + if len(rows) == utils.NumberZero { + return nil, nil + } + list := make([]dao.ImageLogResource, 0, len(rows)) + for _, row := range rows { + contents := map[string]string{} + if row.Contents != utils.StringEmpty { + var raw map[string]string + if err = jsoniter.UnmarshalFromString(row.Contents, &raw); err == nil { + if formatted := formatImageContents(raw); formatted != nil { + contents = formatted + } + } + } + list = append(list, dao.ImageLogResource{ + Id: row.Id, + UserId: row.UserId, + Cover: row.Cover, + Contents: contents, + TaskId: row.TaskId, + CreateTime: row.CreateTime.Format(imageTimeLayout), + }) + } + return list, nil +} + +func imageLogs(ctx context.Context, userId int64, page, size int32) (*analysis.Response, error) { + owner, fail := authGalleryUser(ctx, userId) + if fail != nil { + return fail, nil + } + list, fail := queryImageLogs(ctx, owner, page, size) + if fail != nil { + return fail, nil + } + if len(list) == utils.NumberZero { + return common.OkResponse(nil), nil + } + return common.OkResponse(list), nil +} diff --git a/services/analysis/internal/logic/analysis/userDetailLogic.go b/services/analysis/internal/logic/analysis/userDetailLogic.go new file mode 100644 index 0000000..ddb63d3 --- /dev/null +++ b/services/analysis/internal/logic/analysis/userDetailLogic.go @@ -0,0 +1,62 @@ +package analysislogic + +import ( + "context" + "strconv" + + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + "lone-services/pkg/validate" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/dao" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/model" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + "github.com/zeromicro/go-zero/core/logx" +) + +type UserDetailLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewUserDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserDetailLogic { + return &UserDetailLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *UserDetailLogic) UserDetail(in *analysis.UserDetailReq) (*analysis.Response, error) { + var req validator.UserDetailValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return outParams(msg), nil + } + + var detail dao.Image + err := model.ImageModel{}.Init().GetOne(modelbase.Params{ + Eq: map[string]string{"id": strconv.FormatInt(req.Id, utils.NumberTen)}, + }, &detail) + if err != nil { + l.Errorf("user detail image: %v", err) + return common.FailResponse(utils.Fail), nil + } + + login, fail := common.RequireLogin(l.ctx) + if fail != nil { + return fail, nil + } + owner, err := common.GetAuthUserID(login, detail.UserId) + if err != nil { + l.Errorf("user detail auth: %v", err) + return common.FailResponse(utils.Fail), nil + } + if owner == utils.NumberZero { + return common.NotYoursResponse(), nil + } + return common.OkResponse(buildImageDetail(&detail)), nil +} diff --git a/services/analysis/internal/logic/analysis/userFaceppLogic.go b/services/analysis/internal/logic/analysis/userFaceppLogic.go new file mode 100644 index 0000000..a4120ba --- /dev/null +++ b/services/analysis/internal/logic/analysis/userFaceppLogic.go @@ -0,0 +1,55 @@ +package analysislogic + +import ( + "context" + + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + "lone-services/pkg/validate" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/dao" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/model" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + "github.com/zeromicro/go-zero/core/logx" +) + +type UserFaceppLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewUserFaceppLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserFaceppLogic { + return &UserFaceppLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *UserFaceppLogic) UserFacepp(in *analysis.TaskIdReq) (*analysis.Response, error) { + var req validator.TaskIdValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return outParams(msg), nil + } + if _, fail := authorizeTask(l.ctx, req.TaskId); fail != nil { + return fail, nil + } + + var record dao.FaceppAnalysis + err := model.FaceppAnalysisModel{}.Init().GetOne(modelbase.Params{ + Eq: map[string]string{"task_id": req.TaskId}, + Order: "id desc", + }, &record) + if err != nil { + l.Errorf("user facepp %s: %v", req.TaskId, err) + return common.FailResponse(utils.Fail), nil + } + if record.Id < utils.NumberOne || record.ResultOssPath == utils.StringEmpty { + return common.FailResponse(utils.ErrorNotFund), nil + } + return common.OkResponse(map[string]string{"url": record.ResultOssPath}), nil +} diff --git a/services/analysis/internal/logic/analysis/userLogLogic.go b/services/analysis/internal/logic/analysis/userLogLogic.go new file mode 100644 index 0000000..b0e8c54 --- /dev/null +++ b/services/analysis/internal/logic/analysis/userLogLogic.go @@ -0,0 +1,35 @@ +package analysislogic + +import ( + "context" + + "lone-services/pkg/utils" + "lone-services/pkg/validate" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + "github.com/zeromicro/go-zero/core/logx" +) + +type UserLogLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewUserLogLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserLogLogic { + return &UserLogLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *UserLogLogic) UserLog(in *analysis.LogReq) (*analysis.Response, error) { + var req validator.LogValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return outParams(msg), nil + } + return imageLogs(l.ctx, req.UserId, req.Page, req.Size) +} diff --git a/services/analysis/internal/logic/analysis/userLogic.go b/services/analysis/internal/logic/analysis/userLogic.go new file mode 100644 index 0000000..58a139a --- /dev/null +++ b/services/analysis/internal/logic/analysis/userLogic.go @@ -0,0 +1,181 @@ +package analysislogic + +import ( + "context" + "strconv" + + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + "lone-services/pkg/validate" + analysis "lone-services/rpc/analysis/pb" + userpb "lone-services/rpc/user/pb" + "lone-services/services/analysis/internal/dao" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/model" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + "github.com/zeromicro/go-zero/core/logx" +) + +type UserLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewUserLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserLogic { + return &UserLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *UserLogic) User(in *analysis.UserReq) (*analysis.Response, error) { + var req validator.UserValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return outParams(msg), nil + } + + login, fail := common.RequireLogin(l.ctx) + if fail != nil { + return fail, nil + } + + var bizId int64 + var storeId int64 + switch login.Type { + case dao.TypeUser: + bizId = login.BizId + case dao.TypeStore: + owner, err := common.AuthUserNoExpiry(login.BizId, req.UserId) + if err != nil || owner == utils.NumberZero { + if err != nil { + l.Errorf("common user auth: %v", err) + } + return common.FailResponse(utils.ErrorNotFund), nil + } + bizId = req.UserId + storeId = login.BizId + default: + return common.FailResponse(utils.ErrorAuthority), nil + } + if bizId < utils.NumberOne { + return common.FailResponse(utils.ErrorNotFund), nil + } + + profile, err := l.loadProfile(bizId) + if err != nil { + l.Errorf("common user profile: %v", err) + return common.FailResponse(utils.Fail), nil + } + if profile == nil { + return common.FailResponse(utils.ErrorNotFund), nil + } + + platformUserId := profile.GetUserId() + if platformUserId < utils.NumberOne { + platformUserId = bizId + } + birthday := profile.GetBirthday() + info := dao.ViewUserInfo{ + Id: bizId, + UserId: platformUserId, + Username: profile.GetName(), + Nickname: profile.GetName(), + Avatar: profile.GetAvatar(), + Mobile: decryptMobile(profile.GetMobile()), + Gender: int(profile.GetGender()), + Birthday: birthday, + Age: utils.CalcAgeStr(dateHead(birthday)), + Tag: []dao.TagItem{}, + } + + if login.Type == dao.TypeStore { + info.Tag = l.loadTags(storeId, bizId) + l.applyRemark(storeId, bizId, &info) + } + return common.OkResponse(info), nil +} + +func (l *UserLogic) loadProfile(bizId int64) (*userpb.BizUserItem, error) { + if l.svcCtx.UserSvcName == utils.StringEmpty { + return nil, errString("user service empty") + } + cli, err := svc.GetRpcClient(l.svcCtx.UserSvcName) + if err != nil { + return nil, err + } + res, err := userpb.NewUserClient(cli.Conn()).InternalUsersByBiz(l.ctx, &userpb.InternalUsersByBizReq{ + ClientCode: dao.ClientCodeUserSkin, + BizIds: []int64{bizId}, + }) + if err != nil { + return nil, err + } + for _, item := range res.GetItems() { + if item.GetBizId() == bizId { + return item, nil + } + } + return nil, nil +} + +func (l *UserLogic) loadTags(storeId, userId int64) []dao.TagItem { + var rows []dao.UserImageTag + err := model.UserImageTagModel{}.Init().Items(modelbase.Params{ + Eq: map[string]string{ + "user_id": strconv.FormatInt(userId, utils.NumberTen), + "store_id": strconv.FormatInt(storeId, utils.NumberTen), + "status": strconv.Itoa(utils.StatusOk), + }, + }, &rows) + if err != nil { + l.Errorf("common user tags: %v", err) + return []dao.TagItem{} + } + tags := make([]dao.TagItem, 0, len(rows)) + for _, row := range rows { + tags = append(tags, dao.TagItem{Id: row.Id, Tag: row.Tag}) + } + return tags +} + +func (l *UserLogic) applyRemark(storeId, userId int64, info *dao.ViewUserInfo) { + var remark dao.UserRemark + err := model.UserRemarkModel{}.Init().GetOne(modelbase.Params{ + Eq: map[string]string{ + "user_id": strconv.FormatInt(userId, utils.NumberTen), + "store_id": strconv.FormatInt(storeId, utils.NumberTen), + }, + }, &remark) + if err != nil { + l.Errorf("common user remark: %v", err) + return + } + if remark.Name != utils.StringEmpty { + info.Nickname = remark.Name + } + if remark.Gender != utils.NumberZero { + info.Gender = int(remark.Gender) + } + if remark.Birthday != utils.StringEmpty { + info.Birthday = dateHead(remark.Birthday) + info.Age = utils.CalcAgeStr(info.Birthday) + } +} + +func decryptMobile(mobile string) string { + plain, err := utils.DecryptPhone(mobile) + if err != nil { + return utils.StringEmpty + } + return plain +} + +type strErr string + +func (e strErr) Error() string { return string(e) } + +func errString(msg string) error { return strErr(msg) } diff --git a/services/analysis/internal/logic/analysis/userModeLogic.go b/services/analysis/internal/logic/analysis/userModeLogic.go new file mode 100644 index 0000000..5cb6975 --- /dev/null +++ b/services/analysis/internal/logic/analysis/userModeLogic.go @@ -0,0 +1,32 @@ +package analysislogic + +import ( + "context" + + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/svc" + + "github.com/zeromicro/go-zero/core/logx" +) + +type UserModeLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewUserModeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserModeLogic { + return &UserModeLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *UserModeLogic) UserMode(in *analysis.EmptyReq) (*analysis.Response, error) { + if _, fail := common.RequireLogin(l.ctx); fail != nil { + return fail, nil + } + return common.OkResponse(skinModes()), nil +} diff --git a/services/analysis/internal/logic/analysisuser/userLogDeleteLogic.go b/services/analysis/internal/logic/analysisuser/userLogDeleteLogic.go new file mode 100644 index 0000000..ed10f40 --- /dev/null +++ b/services/analysis/internal/logic/analysisuser/userLogDeleteLogic.go @@ -0,0 +1,88 @@ +package analysisuserlogic + +import ( + "context" + "strconv" + + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + "lone-services/pkg/validate" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/dao" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/model" + "lone-services/services/analysis/internal/svc" + "lone-services/services/analysis/validator" + + "github.com/zeromicro/go-zero/core/logx" + "gorm.io/gorm" +) + +type UserLogDeleteLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewUserLogDeleteLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserLogDeleteLogic { + return &UserLogDeleteLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *UserLogDeleteLogic) UserLogDelete(in *analysis.UserLogDeleteReq) (*analysis.Response, error) { + var req validator.UserLogDeleteValidator + if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty { + return common.OutResponse(utils.ErrorParams, msg), nil + } + login, fail := common.RequireLogin(l.ctx) + if fail != nil { + return fail, nil + } + if login.Type != dao.TypeUser { + return common.OkResponse(nil), nil + } + if login.BizId < utils.NumberOne { + return common.OutResponse(utils.ErrorParams, "业务用户不存在"), nil + } + + idStrs := make([]string, 0, len(req.Ids)) + for _, id := range req.Ids { + idStrs = append(idStrs, strconv.FormatInt(id, utils.NumberTen)) + } + where := modelbase.Params{ + In: map[string][]string{"id": idStrs}, + Eq: map[string]string{ + "user_id": strconv.FormatInt(login.BizId, utils.NumberTen), + "status": strconv.Itoa(utils.StatusOk), + }, + } + var images []dao.Image + err := model.ImageModel{}.Init().Items(where, &images) + if err != nil { + l.Errorf("user log delete list: %v", err) + return common.FailResponse(utils.Fail), nil + } + if len(images) == utils.NumberZero { + return common.OkResponse(nil), nil + } + + _, err = model.ImageModel{}.Init().Edit(where, map[string]interface{}{ + "status": utils.StatusFail, + }) + if err != nil { + l.Errorf("user log delete status: %v", err) + return common.FailResponse(utils.Fail), nil + } + + err = model.UserImageLogModel{}.Init().Session(). + Where("user_id = ?", login.BizId). + Update("detection_number", gorm.Expr("detection_number - ?", len(images))).Error + if err != nil { + l.Errorf("user log delete decrement: %v", err) + return common.FailResponse(utils.Fail), nil + } + return common.OkResponse(nil), nil +} diff --git a/services/analysis/internal/logic/analysisuser/userStatusLogic.go b/services/analysis/internal/logic/analysisuser/userStatusLogic.go new file mode 100644 index 0000000..cfeb49b --- /dev/null +++ b/services/analysis/internal/logic/analysisuser/userStatusLogic.go @@ -0,0 +1,55 @@ +package analysisuserlogic + +import ( + "context" + + "lone-services/pkg/utils" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/logic/common" + "lone-services/services/analysis/internal/svc" + + "github.com/zeromicro/go-zero/core/logx" +) + +type UserStatusLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewUserStatusLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserStatusLogic { + return &UserStatusLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *UserStatusLogic) UserStatus(in *analysis.UserStatusReq) (*analysis.Response, error) { + bizId, _, fail := common.RequireAnalysisUserId(l.ctx) + if fail != nil { + return fail, nil + } + + row, err := common.LoadAnalysisUser(bizId) + if err != nil { + l.Errorf("user status load: %v", err) + return common.FailResponse(utils.Fail), nil + } + if row == nil { + return common.FailResponse(utils.ErrorNotFund), nil + } + + status := utils.NumberOne + if row.IsRegistered == uint8(utils.StatusOk) { + status = utils.NumberTwo + } + if row.IsFaceVerified == uint8(utils.StatusOk) { + status = utils.NumberThree + } + if row.IsProfileCompleted == uint8(utils.StatusOk) { + status = utils.NumberFour + } + + return common.OkResponse(map[string]int{"status": status}), nil +} diff --git a/services/analysis/internal/logic/common/authUser.go b/services/analysis/internal/logic/common/authUser.go new file mode 100644 index 0000000..4c0b90e --- /dev/null +++ b/services/analysis/internal/logic/common/authUser.go @@ -0,0 +1,82 @@ +package common + +import ( + "context" + "strconv" + + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + analysis "lone-services/rpc/analysis/pb" + "lone-services/services/analysis/internal/dao" + "lone-services/services/analysis/internal/model" +) + +func RequireLogin(ctx context.Context) (utils.UserInfo, *analysis.Response) { + user := utils.GetUserFromCtx(ctx) + if !user.Valid { + return user, FailResponse(utils.ErrorNoLogin) + } + return user, nil +} + +func NotYoursResponse() *analysis.Response { + return OutResponse(utils.ErrorNotFund, "该数据不属于您") +} + +func GetAuthUser(login utils.UserInfo, requestUserId int64) (int64, error) { + if login.Type == dao.TypeUser { + return login.BizId, nil + } + if login.Type == dao.TypeStore { + return AuthUser(login.BizId, requestUserId) + } + return utils.NumberZero, nil +} + +func GetAuthUserID(login utils.UserInfo, recordUserId int64) (int64, error) { + if login.Type == dao.TypeUser { + if login.BizId != recordUserId { + return utils.NumberZero, nil + } + return login.BizId, nil + } + if login.Type == dao.TypeStore { + return AuthUser(login.BizId, recordUserId) + } + return utils.NumberZero, nil +} + +func AuthUser(storeId, userId int64) (int64, error) { + return authUser(storeId, userId, true) +} + +func AuthUserNoExpiry(storeId, userId int64) (int64, error) { + return authUser(storeId, userId, false) +} + +func authUser(storeId, userId int64, checkExpiry bool) (int64, error) { + if storeId < utils.NumberOne || userId < utils.NumberOne { + return utils.NumberZero, nil + } + params := modelbase.Params{ + Eq: map[string]string{ + "user_id": strconv.FormatInt(userId, utils.NumberTen), + "store_id": strconv.FormatInt(storeId, utils.NumberTen), + "status": strconv.Itoa(utils.StatusOk), + }, + } + if checkExpiry { + params.Other = map[string]string{ + "validity_time >= ?": utils.Now().String(), + } + } + var auth dao.UserStoreAuth + err := model.UserStoreAuthModel{}.Init().GetOne(params, &auth) + if err != nil { + return utils.NumberZero, err + } + if auth.Id < utils.NumberOne { + return utils.NumberZero, nil + } + return userId, nil +} diff --git a/services/analysis/internal/model/banner.go b/services/analysis/internal/model/banner.go new file mode 100644 index 0000000..26f0b71 --- /dev/null +++ b/services/analysis/internal/model/banner.go @@ -0,0 +1,16 @@ +package model + +import "lone-services/pkg/modelbase" + +type BannerModel struct { + modelbase.Base +} + +func (m BannerModel) TableName() string { + return modelbase.Prefix() + "skin_banners" +} + +func (m BannerModel) Init() BannerModel { + m.Table = m.TableName() + return m +} diff --git a/services/analysis/internal/model/facepp.go b/services/analysis/internal/model/facepp.go new file mode 100644 index 0000000..f61a843 --- /dev/null +++ b/services/analysis/internal/model/facepp.go @@ -0,0 +1,49 @@ +package model + +import ( + "lone-services/pkg/modelbase" + "lone-services/services/analysis/internal/dao" +) + +type FaceppAnalysisModel struct { + modelbase.Base +} + +func (m FaceppAnalysisModel) TableName() string { + return modelbase.Prefix() + "skin_facepp_analyses" +} + +func (m FaceppAnalysisModel) Init() FaceppAnalysisModel { + m.Table = m.TableName() + return m +} + +type FaceppMapModel struct { + modelbase.Base +} + +func (m FaceppMapModel) TableName() string { + return modelbase.Prefix() + "skin_facepp_maps" +} + +func (m FaceppMapModel) Init() FaceppMapModel { + m.Table = m.TableName() + return m +} + +type FaceppMapBoxModel struct { + modelbase.Base +} + +func (m FaceppMapBoxModel) TableName() string { + return modelbase.Prefix() + "skin_facepp_map_boxes" +} + +func (m FaceppMapBoxModel) Init() FaceppMapBoxModel { + m.Table = m.TableName() + return m +} + +func (m FaceppMapBoxModel) Create(data *dao.FaceppMapBox) error { + return m.Base.Create(data) +} diff --git a/services/analysis/internal/model/graph.go b/services/analysis/internal/model/graph.go new file mode 100644 index 0000000..91524c2 --- /dev/null +++ b/services/analysis/internal/model/graph.go @@ -0,0 +1,29 @@ +package model + +import "lone-services/pkg/modelbase" + +type GraphModel struct { + modelbase.Base +} + +func (m GraphModel) TableName() string { + return modelbase.Prefix() + "skin_user_graphs" +} + +func (m GraphModel) Init() GraphModel { + m.Table = m.TableName() + return m +} + +type GraphTypeModel struct { + modelbase.Base +} + +func (m GraphTypeModel) TableName() string { + return modelbase.Prefix() + "skin_user_graph_type" +} + +func (m GraphTypeModel) Init() GraphTypeModel { + m.Table = m.TableName() + return m +} diff --git a/services/analysis/internal/model/image.go b/services/analysis/internal/model/image.go index 2fa60d7..e9e0192 100644 --- a/services/analysis/internal/model/image.go +++ b/services/analysis/internal/model/image.go @@ -14,3 +14,27 @@ func (m ImageModel) Init() ImageModel { m.Table = m.TableName() return m } + +func (m ImageModel) Dates(userId int64, status int, start, end string) ([]string, error) { + m = m.Init() + var rows []struct { + Day string `gorm:"column:day"` + } + err := m.Session(). + Select("DATE_FORMAT(create_time, '%Y-%m-%d') AS day"). + Where("user_id = ? AND status = ?", userId, status). + Where("create_time BETWEEN ? AND ?", start, end). + Group("day"). + Order("day ASC"). + Scan(&rows).Error + if err != nil { + return nil, err + } + dates := make([]string, 0, len(rows)) + for _, row := range rows { + if row.Day != "" { + dates = append(dates, row.Day) + } + } + return dates, nil +} diff --git a/services/analysis/internal/server/analysis/analysisServer.go b/services/analysis/internal/server/analysis/analysisServer.go index 2be3e74..c7c9c98 100644 --- a/services/analysis/internal/server/analysis/analysisServer.go +++ b/services/analysis/internal/server/analysis/analysisServer.go @@ -47,3 +47,88 @@ func (s *AnalysisServer) QrcodeInfo(ctx context.Context, in *analysis.QrcodeInfo l := analysislogic.NewQrcodeInfoLogic(ctx, s.svcCtx) return l.QrcodeInfo(in) } + +func (s *AnalysisServer) Log(ctx context.Context, in *analysis.LogReq) (*analysis.Response, error) { + l := analysislogic.NewLogLogic(ctx, s.svcCtx) + return l.Log(in) +} + +func (s *AnalysisServer) Overview(ctx context.Context, in *analysis.OverviewReq) (*analysis.Response, error) { + l := analysislogic.NewOverviewLogic(ctx, s.svcCtx) + return l.Overview(in) +} + +func (s *AnalysisServer) User(ctx context.Context, in *analysis.UserReq) (*analysis.Response, error) { + l := analysislogic.NewUserLogic(ctx, s.svcCtx) + return l.User(in) +} + +func (s *AnalysisServer) UserDetail(ctx context.Context, in *analysis.UserDetailReq) (*analysis.Response, error) { + l := analysislogic.NewUserDetailLogic(ctx, s.svcCtx) + return l.UserDetail(in) +} + +func (s *AnalysisServer) UserFacepp(ctx context.Context, in *analysis.TaskIdReq) (*analysis.Response, error) { + l := analysislogic.NewUserFaceppLogic(ctx, s.svcCtx) + return l.UserFacepp(in) +} + +func (s *AnalysisServer) UserMode(ctx context.Context, in *analysis.EmptyReq) (*analysis.Response, error) { + l := analysislogic.NewUserModeLogic(ctx, s.svcCtx) + return l.UserMode(in) +} + +func (s *AnalysisServer) UserLog(ctx context.Context, in *analysis.LogReq) (*analysis.Response, error) { + l := analysislogic.NewUserLogLogic(ctx, s.svcCtx) + return l.UserLog(in) +} + +func (s *AnalysisServer) Banners(ctx context.Context, in *analysis.EmptyReq) (*analysis.Response, error) { + l := analysislogic.NewBannersLogic(ctx, s.svcCtx) + return l.Banners(in) +} + +func (s *AnalysisServer) QrcodeShare(ctx context.Context, in *analysis.QrcodeShareReq) (*analysis.Response, error) { + l := analysislogic.NewQrcodeShareLogic(ctx, s.svcCtx) + return l.QrcodeShare(in) +} + +func (s *AnalysisServer) GraphDetail(ctx context.Context, in *analysis.GraphDetailReq) (*analysis.Response, error) { + l := analysislogic.NewGraphDetailLogic(ctx, s.svcCtx) + return l.GraphDetail(in) +} + +func (s *AnalysisServer) FaceppMaps(ctx context.Context, in *analysis.TaskIdReq) (*analysis.Response, error) { + l := analysislogic.NewFaceppMapsLogic(ctx, s.svcCtx) + return l.FaceppMaps(in) +} + +func (s *AnalysisServer) FaceppMapBoxes(ctx context.Context, in *analysis.FaceppMapBoxesReq) (*analysis.Response, error) { + l := analysislogic.NewFaceppMapBoxesLogic(ctx, s.svcCtx) + return l.FaceppMapBoxes(in) +} + +func (s *AnalysisServer) FaceppMapBoxDelete(ctx context.Context, in *analysis.IdReq) (*analysis.Response, error) { + l := analysislogic.NewFaceppMapBoxDeleteLogic(ctx, s.svcCtx) + return l.FaceppMapBoxDelete(in) +} + +func (s *AnalysisServer) ImagesDate(ctx context.Context, in *analysis.ImagesDateReq) (*analysis.Response, error) { + l := analysislogic.NewImagesDateLogic(ctx, s.svcCtx) + return l.ImagesDate(in) +} + +func (s *AnalysisServer) ImagesList(ctx context.Context, in *analysis.ImagesListReq) (*analysis.Response, error) { + l := analysislogic.NewImagesListLogic(ctx, s.svcCtx) + return l.ImagesList(in) +} + +func (s *AnalysisServer) ModeImage(ctx context.Context, in *analysis.TaskIdReq) (*analysis.Response, error) { + l := analysislogic.NewModeImageLogic(ctx, s.svcCtx) + return l.ModeImage(in) +} + +func (s *AnalysisServer) DeviceUpdate(ctx context.Context, in *analysis.DeviceUpdateReq) (*analysis.Response, error) { + l := analysislogic.NewDeviceUpdateLogic(ctx, s.svcCtx) + return l.DeviceUpdate(in) +} diff --git a/services/analysis/internal/server/analysisuser/analysisUserServer.go b/services/analysis/internal/server/analysisuser/analysisUserServer.go index 3b257c3..9553939 100644 --- a/services/analysis/internal/server/analysisuser/analysisUserServer.go +++ b/services/analysis/internal/server/analysisuser/analysisUserServer.go @@ -67,3 +67,13 @@ func (s *AnalysisUserServer) DeviceInfo(ctx context.Context, in *analysis.Device l := analysisuserlogic.NewDeviceInfoLogic(ctx, s.svcCtx) return l.DeviceInfo(in) } + +func (s *AnalysisUserServer) UserLogDelete(ctx context.Context, in *analysis.UserLogDeleteReq) (*analysis.Response, error) { + l := analysisuserlogic.NewUserLogDeleteLogic(ctx, s.svcCtx) + return l.UserLogDelete(in) +} + +func (s *AnalysisUserServer) UserStatus(ctx context.Context, in *analysis.UserStatusReq) (*analysis.Response, error) { + l := analysisuserlogic.NewUserStatusLogic(ctx, s.svcCtx) + return l.UserStatus(in) +} diff --git a/services/analysis/validator/view.go b/services/analysis/validator/view.go new file mode 100644 index 0000000..b59e13c --- /dev/null +++ b/services/analysis/validator/view.go @@ -0,0 +1,152 @@ +package validator + +import "lone-services/pkg/validate" + +type UserLogDeleteValidator struct { + Ids []int64 `validate:"required,min=1,dive,gt=0"` +} + +func (p UserLogDeleteValidator) GetMessage() validate.ValidatorMessages { + return validate.ValidatorMessages{ + "Ids.required": "ids 必填", + "Ids.min": "ids 必填", + "Ids.gt": "ids 必填", + } +} + +type LogValidator struct { + UserId int64 `validate:"omitempty,gte=0"` + Page int32 `validate:"omitempty,gte=0"` + Size int32 `validate:"omitempty,gte=0"` +} + +func (p LogValidator) GetMessage() validate.ValidatorMessages { + return validate.ValidatorMessages{} +} + +type OverviewValidator struct { + UserId int64 `validate:"omitempty,gte=0"` + Id int64 `validate:"omitempty,gte=0"` +} + +func (p OverviewValidator) GetMessage() validate.ValidatorMessages { + return validate.ValidatorMessages{} +} + +type UserValidator struct { + UserId int64 `validate:"omitempty,gte=0"` +} + +func (p UserValidator) GetMessage() validate.ValidatorMessages { + return validate.ValidatorMessages{} +} + +type UserDetailValidator struct { + Id int64 `validate:"required,gt=0"` +} + +func (p UserDetailValidator) GetMessage() validate.ValidatorMessages { + return validate.ValidatorMessages{ + "Id.required": "id 必传", + "Id.gt": "id 必传", + } +} + +type TaskIdValidator struct { + TaskId string `validate:"required"` +} + +func (p TaskIdValidator) GetMessage() validate.ValidatorMessages { + return validate.ValidatorMessages{ + "TaskId.required": "TaskId 必传", + } +} + +type QrcodeShareValidator struct { + Ids []int64 `validate:"required,min=1,dive,gt=0"` +} + +func (p QrcodeShareValidator) GetMessage() validate.ValidatorMessages { + return validate.ValidatorMessages{ + "Ids.required": "ids 必传", + "Ids.min": "ids 必传", + "Ids.gt": "ids 必传", + } +} + +type GraphDetailValidator struct { + Type int32 `validate:"required,gt=0"` +} + +func (p GraphDetailValidator) GetMessage() validate.ValidatorMessages { + return validate.ValidatorMessages{ + "Type.required": "type 必传", + "Type.gt": "type 必传", + } +} + +type FaceppMapBoxesValidator struct { + Id int64 `validate:"required,gt=0"` + Boxes string `validate:"omitempty"` +} + +func (p FaceppMapBoxesValidator) GetMessage() validate.ValidatorMessages { + return validate.ValidatorMessages{ + "Id.required": "id 必传", + "Id.gt": "id 必传", + } +} + +type IdValidator struct { + Id int64 `validate:"required,gt=0"` +} + +func (p IdValidator) GetMessage() validate.ValidatorMessages { + return validate.ValidatorMessages{ + "Id.required": "id 必传", + "Id.gt": "id 必传", + } +} + +type ImagesDateValidator struct { + UserId int64 `validate:"omitempty,gte=0"` + StartTime string `validate:"required"` + EndTime string `validate:"required"` +} + +func (p ImagesDateValidator) GetMessage() validate.ValidatorMessages { + return validate.ValidatorMessages{ + "StartTime.required": "开始时间必传", + "EndTime.required": "结束时间必传", + } +} + +type ImagesListValidator struct { + UserId int64 `validate:"omitempty,gte=0"` + Mode string `validate:"required"` + Position string `validate:"required"` + StartTime string `validate:"required"` + EndTime string `validate:"required"` +} + +func (p ImagesListValidator) GetMessage() validate.ValidatorMessages { + return validate.ValidatorMessages{ + "Mode.required": "模式必传", + "Position.required": "脸部位置必传", + "StartTime.required": "开始时间必传", + "EndTime.required": "结束时间必传", + } +} + +type DeviceUpdateValidator struct { + Id int64 `validate:"required,gt=0"` + DeviceName string `validate:"required"` +} + +func (p DeviceUpdateValidator) GetMessage() validate.ValidatorMessages { + return validate.ValidatorMessages{ + "Id.required": "id 必传", + "Id.gt": "id 必传", + "DeviceName.required": "device_name 必传", + } +}