From 7939917ba0a22bac4c5db5adff4902f59680cf79 Mon Sep 17 00:00:00 2001 From: gjs Date: Mon, 21 Sep 2026 15:50:44 +0800 Subject: [PATCH] message --- rpc/message/message.pb | Bin 0 -> 14150 bytes rpc/message/message.proto | 59 +++ rpc/message/pb/message.pb.go | 410 ++++++++++++++++++ rpc/message/pb/message_grpc.pb.go | 235 ++++++++++ .../internal/logic/apiBeansAddLogic.go | 85 ++++ .../internal/logic/apiBeansItemsLogic.go | 52 +++ .../internal/logic/apiBeansLastLogic.go | 53 +++ services/message/.gitignore | 3 + services/message/Dockerfile | 37 ++ services/message/internal/config/config.go | 13 + services/message/internal/dao/message.go | 41 ++ .../internal/logic/adminMessageLogic.go | 54 +++ .../message/internal/logic/apiMessageLogic.go | 66 +++ .../internal/logic/apiMessageNumberLogic.go | 53 +++ services/message/internal/logic/base.go | 48 ++ .../message/internal/logic/messageAddLogic.go | 48 ++ services/message/internal/model/message.go | 23 + .../message/internal/server/messageServer.go | 44 ++ .../message/internal/svc/servicecontext.go | 22 + services/message/message.go | 170 ++++++++ services/message/messageclient/message.go | 59 +++ services/message/validator/message.go | 27 ++ 22 files changed, 1602 insertions(+) create mode 100644 rpc/message/message.pb create mode 100644 rpc/message/message.proto create mode 100644 rpc/message/pb/message.pb.go create mode 100644 rpc/message/pb/message_grpc.pb.go create mode 100644 services/equipment/internal/logic/apiBeansAddLogic.go create mode 100644 services/equipment/internal/logic/apiBeansItemsLogic.go create mode 100644 services/equipment/internal/logic/apiBeansLastLogic.go create mode 100644 services/message/.gitignore create mode 100644 services/message/Dockerfile create mode 100644 services/message/internal/config/config.go create mode 100644 services/message/internal/dao/message.go create mode 100644 services/message/internal/logic/adminMessageLogic.go create mode 100644 services/message/internal/logic/apiMessageLogic.go create mode 100644 services/message/internal/logic/apiMessageNumberLogic.go create mode 100644 services/message/internal/logic/base.go create mode 100644 services/message/internal/logic/messageAddLogic.go create mode 100644 services/message/internal/model/message.go create mode 100644 services/message/internal/server/messageServer.go create mode 100644 services/message/internal/svc/servicecontext.go create mode 100644 services/message/message.go create mode 100644 services/message/messageclient/message.go create mode 100644 services/message/validator/message.go diff --git a/rpc/message/message.pb b/rpc/message/message.pb new file mode 100644 index 0000000000000000000000000000000000000000..7b20ecf7b0448ca6b679316d5854cc1b36510ddd GIT binary patch literal 14150 zcmd5@U5s1DbvDT*mmIFRckk{>^h%CoI<{rm;wF@1%W{yET;5$#=927?D@$&Q+q>l5 z6>a{7mz1@B2+}kUF46)CS`=!5v_M|m7A+7IXn_KK>1$9FEs6p~--;Hoix%ihAM%!d zXJ+mXc`0cfz=id&;+#3>%$YN1&N*{tF8h->+dLi)k9+pEHR^8Pn@mRe(Rer+>P&+3 z0OwBF(oOW}S6F;J?b%K?aw&E>UD(L`IC(RB>su`8*gd;F8IB=B=uEOp3Mg87mL)piJh8KJ1y^nTEQ^nlXOrki7oG_!V@LFm+zo3ovBv|9uFxUW(&4akl3gZ#T>RFbV`reB z(Qx3{rs!M|ohvS|1OjMu-Rg9@6R6JWnTOp$r#m=yvgyaHh3*rS6n-himN6j`D)%N^ z3rR}yy$4*SVDXz^pt&ct%f;`~G0U`v{lKhCDKTNPo<`)IqOy(SVb2;I=ZE9t?PGf& zY-?L~!Ll4-b=F`ooLDq3=gq+HA4Qk;ijB%)LJ(bJAO0Gul)=KxM~YbSL2w-KPEp#ya-M9(3$M`vle+gIxq5`pax> zG(GHf+t^DU8UtFKYqF#4!Sxr}>if3!UJ#WmB+fGg4j}HZmA>sbkjI>yjBIQO+S8Xp zy6`n8^^jInEfDENma+%azT^-W9KzZ(fHBV{No0z}GI@q>+r}0n5nc?5(3Ji2JX|_` z2U0wk*wU*k3ntHpnCy1#UT2<#Pp7}emWLx@glb1$SiquZ*Ch^jk@X7GoZ)obwoT#Z zx`U%(HYHrb#Snw0K-_^ptN@K?B%#}euSqy3gNgMZEBC)@=>@iI%Z;DSfODph4RJPP zKX(yxf1O~fbF*D&mT$875orcSNyx44LnWqFHVq;H#!#7Wg9O**Xy7uLE4q4~{%XraO&MYN_$UkvrZakI~qZlP(xSW>^ zS~92$Z$~aE#VKeBU=3bx>jRdVRSyDi+?iP8iExf_E*rYWVsL=MGsZdn)PKpJFa_{* z;f0X6vz+JWz4bafGc$qH4xRhECAPVcw|<9hOb6WoqUUIgY@uUHmy!KgdY!P*9R#tZ zgnWI5g#_w%S(@y_8jC=vc4OgmQ_hoxD9Tdo!$_0|c_CFv9@*ApiiOD*geuR6`0h#s z1V`>6>wUIz-yV05x@{>GtwW}8Jw&`vSNYok(k9}&eS;m;ZX3L^TQSN~%o+AuzZ+rc zz)Z*;B1jzCGTDoB)zZ(i6y=PjFgi*ikp~ih432!9aw8)2(r?NeU85BFU6Olk**C)M z?T$$CM4xQmT1qZy@!YFyEi@H<6`~qD)gmvpD)pN7l%8RM*=dn0spKci+PCp9n)}-X z+gKER7W!j<(xh#F(nS{US%-E{B(9ml%b`VBG(x^gBwSMJUsI}~6gN}2ayky=U%5~z z>7CRm^)Aw3o+NM8l0|{6PB3vtI zaX7yf$)Iw_D1#(13jxlueukw4PN`n6YDtf0v&Ad5JuT(&+~f6whQ>S&`$n@_+%vSa zhf%uQGMd_o$AZMd5NEt0jM~AzmeJSP88KpWm&5|b>Kq7?Y95!S6BPNAqB>e{+g?o7SLX-m{#0*$rY)ie@AHX+qpn zc!oeL4mvl1q~Bm?1sCWL3N+jI?Dl)+baHe(dpwr@MCB5S>NQhnncx@bKNX zG%OQrj=B%BUj#vluTqCFtA+sUFM+pn&l-?|R{%UK<3Vg;~Y5!f5( z#m*OZI{D9hF4UBU5-T6jOuP`5lVHHxe?p=aQ06!*Cey z!FP!T=BlOdvBbNM;7y@3QwY}}W_aIf3g)R>O|w?#`^73(%YS36Res2{lPHR^fk&4o@kyU{7%M7Q(!|5^ZjXG9)G8<1&-9Q%?J^EWL zMWvVlDOw!eGKH&;SFc(p7GaZeFD8Zc-^iL4T zEe%N;o>5Givi;eW#J1i+?NFAr)#QVPaB^0sDTLFp#674{P?n9Y-;1)$?8LB696Wt5K_XHC&mJdz+I-_MC%dm2V%KNs0%>n;NrxB0#`Mm6zR-e+<>(DkMfQlijVEo)2j;Cjud@1pE8H@YahBv6n%8{|Py6FT8{Q3RTsNYmiA zE0}f?!9foa?HjF|^|F>)6tQ$|J@;o3BtUfGAXPQ%RLJ5#SHU*-k5QHm)Iz9KX!Ux- z_f4zUMS3pdArqh?K~5WgPM^AnQ>i$*ecIGTUeir`41f z4IVZw8iF?W2Qjw3;I0uFfqaP~tJLAdcmYkGPWKJm&~iaaRST#W`Snp31vHsU(Z)rA z!-tC^tNsep@wf_4l_eft0VHSGtrTZ!by%i1T)x&MhV-M1{S=5dE5J8lt0 zzCHfxV>W|JmiIZ$))BbJjZVzCsOt9dhEW}apL}9g1d69%VLg~(Avf$}4&8l8pjd4E z3|FF$680A=deqnkPXFUE91=y$Bk8FeF}EjV>+1nRC6l9p9gHxMwo}O({JVO1t-$(Z2sItqdg6}9Wz0RGCt!{4ymqJF0 zYi@^!e1kph^6lU*1-E-0e*k(wnd0XZLRs~@v~y37{~^lO#1$9CQ11olK4bn1YSgZ% z-WX2$LUj3}_XL{<7;ODlgfYMCky^xgT)t!#H>Kh{j!R_;qPs?_!5!Mi-GR^{-u#IM zYDwbFAL&ZH`Q!A!zi%PeY>P5>nOdbIqw(mXg|ll<FdA!cVE?%H2;dJL2u@rn~`^}hQ9-F z@we&L!U??LA07S-`D`?{*C_pIbZbw1my#Ep@YX-i?IZg30~s0n<0!kJJ_Vr9R(z9p z)Mo&JuUEDff8et9#BT|1yv3I8(PuADcma|9@lXCnp6M5V5F?nB2BFU-G=FC~Vv?W9 zR}=r1V4Et(+gAT89WATo)?-zfgEz*5A@OYrJvc#@E{`j5E`HN4?mNe7)6-AFq8nu8 zFvag2TtuCh!`Zn2hLK2`WNiDEdt>2Tv8mSb))Q zf{__1&mw;3eoStQMw6`Y552jOL4bJg+zJXo8l9nMV#Mdn$KBIS-<27Ip3wUv1l64 zilNTyXXl5KOlcOcGp5u7yU^GDQ9LWz+L#4Oi!Ysj=jk4vrCxO(wrr0_ZC6R|mr4Hz DsNq)7 literal 0 HcmV?d00001 diff --git a/rpc/message/message.proto b/rpc/message/message.proto new file mode 100644 index 0000000..98aaec2 --- /dev/null +++ b/rpc/message/message.proto @@ -0,0 +1,59 @@ +syntax = "proto3"; + +package message; +import "google/api/annotations.proto"; +option go_package="lone-services/rpc/message"; + +message Response { + int32 code = 1; + string msg = 2; + string data = 3; +} + +message AddResponse { + int32 num = 1; +} + +message ItemsRequest { + int32 page = 1; + int32 size = 2; + int32 type =3; +} + +message AddRequest { + string content = 1; + int32 target_type = 2; + int64 target_id = 3; + int32 type_status = 4; + int32 type = 5; + int64 obj_id = 6; +} + +message ApiMessageNumberRequest { + int32 type = 1; +} + + +service Message { + rpc AdminMessage(ItemsRequest) returns(Response){ + option (google.api.http) = { + get: "/admin/v3/message/items" + body: "*" + }; + }; + + rpc ApiMessage(ItemsRequest) returns(Response){ + option (google.api.http) = { + get: "/api/v3/message/items" + body: "*" + }; + }; + rpc ApiMessageNumber(ApiMessageNumberRequest) returns(Response){ + option (google.api.http) = { + get: "/api/v3/message/Number" + body: "*" + }; + }; + + rpc MessageAdd(AddRequest) returns(AddResponse); +} diff --git a/rpc/message/pb/message.pb.go b/rpc/message/pb/message.pb.go new file mode 100644 index 0000000..999f701 --- /dev/null +++ b/rpc/message/pb/message.pb.go @@ -0,0 +1,410 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.11 +// protoc v4.25.8 +// source: message/message.proto + +package message + +import ( + _ "google.golang.org/genproto/googleapis/api/annotations" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Response struct { + state protoimpl.MessageState `protogen:"open.v1"` + Code int32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` + Msg string `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg,omitempty"` + Data string `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Response) Reset() { + *x = Response{} + mi := &file_message_message_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Response) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Response) ProtoMessage() {} + +func (x *Response) ProtoReflect() protoreflect.Message { + mi := &file_message_message_proto_msgTypes[0] + 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 Response.ProtoReflect.Descriptor instead. +func (*Response) Descriptor() ([]byte, []int) { + return file_message_message_proto_rawDescGZIP(), []int{0} +} + +func (x *Response) GetCode() int32 { + if x != nil { + return x.Code + } + return 0 +} + +func (x *Response) GetMsg() string { + if x != nil { + return x.Msg + } + return "" +} + +func (x *Response) GetData() string { + if x != nil { + return x.Data + } + return "" +} + +type AddResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Num int32 `protobuf:"varint,1,opt,name=num,proto3" json:"num,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AddResponse) Reset() { + *x = AddResponse{} + mi := &file_message_message_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AddResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AddResponse) ProtoMessage() {} + +func (x *AddResponse) ProtoReflect() protoreflect.Message { + mi := &file_message_message_proto_msgTypes[1] + 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 AddResponse.ProtoReflect.Descriptor instead. +func (*AddResponse) Descriptor() ([]byte, []int) { + return file_message_message_proto_rawDescGZIP(), []int{1} +} + +func (x *AddResponse) GetNum() int32 { + if x != nil { + return x.Num + } + return 0 +} + +type ItemsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Page int32 `protobuf:"varint,1,opt,name=page,proto3" json:"page,omitempty"` + Size int32 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"` + Type int32 `protobuf:"varint,3,opt,name=type,proto3" json:"type,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ItemsRequest) Reset() { + *x = ItemsRequest{} + mi := &file_message_message_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ItemsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ItemsRequest) ProtoMessage() {} + +func (x *ItemsRequest) ProtoReflect() protoreflect.Message { + mi := &file_message_message_proto_msgTypes[2] + 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 ItemsRequest.ProtoReflect.Descriptor instead. +func (*ItemsRequest) Descriptor() ([]byte, []int) { + return file_message_message_proto_rawDescGZIP(), []int{2} +} + +func (x *ItemsRequest) GetPage() int32 { + if x != nil { + return x.Page + } + return 0 +} + +func (x *ItemsRequest) GetSize() int32 { + if x != nil { + return x.Size + } + return 0 +} + +func (x *ItemsRequest) GetType() int32 { + if x != nil { + return x.Type + } + return 0 +} + +type AddRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Content string `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"` + TargetType int32 `protobuf:"varint,2,opt,name=target_type,json=targetType,proto3" json:"target_type,omitempty"` + TargetId int64 `protobuf:"varint,3,opt,name=target_id,json=targetId,proto3" json:"target_id,omitempty"` + TypeStatus int32 `protobuf:"varint,4,opt,name=type_status,json=typeStatus,proto3" json:"type_status,omitempty"` + Type int32 `protobuf:"varint,5,opt,name=type,proto3" json:"type,omitempty"` + ObjId int64 `protobuf:"varint,6,opt,name=obj_id,json=objId,proto3" json:"obj_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AddRequest) Reset() { + *x = AddRequest{} + mi := &file_message_message_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AddRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AddRequest) ProtoMessage() {} + +func (x *AddRequest) ProtoReflect() protoreflect.Message { + mi := &file_message_message_proto_msgTypes[3] + 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 AddRequest.ProtoReflect.Descriptor instead. +func (*AddRequest) Descriptor() ([]byte, []int) { + return file_message_message_proto_rawDescGZIP(), []int{3} +} + +func (x *AddRequest) GetContent() string { + if x != nil { + return x.Content + } + return "" +} + +func (x *AddRequest) GetTargetType() int32 { + if x != nil { + return x.TargetType + } + return 0 +} + +func (x *AddRequest) GetTargetId() int64 { + if x != nil { + return x.TargetId + } + return 0 +} + +func (x *AddRequest) GetTypeStatus() int32 { + if x != nil { + return x.TypeStatus + } + return 0 +} + +func (x *AddRequest) GetType() int32 { + if x != nil { + return x.Type + } + return 0 +} + +func (x *AddRequest) GetObjId() int64 { + if x != nil { + return x.ObjId + } + return 0 +} + +type ApiMessageNumberRequest 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 *ApiMessageNumberRequest) Reset() { + *x = ApiMessageNumberRequest{} + mi := &file_message_message_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ApiMessageNumberRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ApiMessageNumberRequest) ProtoMessage() {} + +func (x *ApiMessageNumberRequest) ProtoReflect() protoreflect.Message { + mi := &file_message_message_proto_msgTypes[4] + 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 ApiMessageNumberRequest.ProtoReflect.Descriptor instead. +func (*ApiMessageNumberRequest) Descriptor() ([]byte, []int) { + return file_message_message_proto_rawDescGZIP(), []int{4} +} + +func (x *ApiMessageNumberRequest) GetType() int32 { + if x != nil { + return x.Type + } + return 0 +} + +var File_message_message_proto protoreflect.FileDescriptor + +const file_message_message_proto_rawDesc = "" + + "\n" + + "\x15message/message.proto\x12\amessage\x1a\x1cgoogle/api/annotations.proto\"D\n" + + "\bResponse\x12\x12\n" + + "\x04code\x18\x01 \x01(\x05R\x04code\x12\x10\n" + + "\x03msg\x18\x02 \x01(\tR\x03msg\x12\x12\n" + + "\x04data\x18\x03 \x01(\tR\x04data\"\x1f\n" + + "\vAddResponse\x12\x10\n" + + "\x03num\x18\x01 \x01(\x05R\x03num\"J\n" + + "\fItemsRequest\x12\x12\n" + + "\x04page\x18\x01 \x01(\x05R\x04page\x12\x12\n" + + "\x04size\x18\x02 \x01(\x05R\x04size\x12\x12\n" + + "\x04type\x18\x03 \x01(\x05R\x04type\"\xb0\x01\n" + + "\n" + + "AddRequest\x12\x18\n" + + "\acontent\x18\x01 \x01(\tR\acontent\x12\x1f\n" + + "\vtarget_type\x18\x02 \x01(\x05R\n" + + "targetType\x12\x1b\n" + + "\ttarget_id\x18\x03 \x01(\x03R\btargetId\x12\x1f\n" + + "\vtype_status\x18\x04 \x01(\x05R\n" + + "typeStatus\x12\x12\n" + + "\x04type\x18\x05 \x01(\x05R\x04type\x12\x15\n" + + "\x06obj_id\x18\x06 \x01(\x03R\x05objId\"-\n" + + "\x17ApiMessageNumberRequest\x12\x12\n" + + "\x04type\x18\x01 \x01(\x05R\x04type2\xe6\x02\n" + + "\aMessage\x12\\\n" + + "\fAdminMessage\x12\x15.message.ItemsRequest\x1a\x11.message.Response\"\"\x82\xd3\xe4\x93\x02\x1c:\x01*\x12\x17/admin/v3/message/items\x12X\n" + + "\n" + + "ApiMessage\x12\x15.message.ItemsRequest\x1a\x11.message.Response\" \x82\xd3\xe4\x93\x02\x1a:\x01*\x12\x15/api/v3/message/items\x12j\n" + + "\x10ApiMessageNumber\x12 .message.ApiMessageNumberRequest\x1a\x11.message.Response\"!\x82\xd3\xe4\x93\x02\x1b:\x01*\x12\x16/api/v3/message/Number\x127\n" + + "\n" + + "MessageAdd\x12\x13.message.AddRequest\x1a\x14.message.AddResponseB\x1bZ\x19lone-services/rpc/messageb\x06proto3" + +var ( + file_message_message_proto_rawDescOnce sync.Once + file_message_message_proto_rawDescData []byte +) + +func file_message_message_proto_rawDescGZIP() []byte { + file_message_message_proto_rawDescOnce.Do(func() { + file_message_message_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_message_message_proto_rawDesc), len(file_message_message_proto_rawDesc))) + }) + return file_message_message_proto_rawDescData +} + +var file_message_message_proto_msgTypes = make([]protoimpl.MessageInfo, 5) +var file_message_message_proto_goTypes = []any{ + (*Response)(nil), // 0: message.Response + (*AddResponse)(nil), // 1: message.AddResponse + (*ItemsRequest)(nil), // 2: message.ItemsRequest + (*AddRequest)(nil), // 3: message.AddRequest + (*ApiMessageNumberRequest)(nil), // 4: message.ApiMessageNumberRequest +} +var file_message_message_proto_depIdxs = []int32{ + 2, // 0: message.Message.AdminMessage:input_type -> message.ItemsRequest + 2, // 1: message.Message.ApiMessage:input_type -> message.ItemsRequest + 4, // 2: message.Message.ApiMessageNumber:input_type -> message.ApiMessageNumberRequest + 3, // 3: message.Message.MessageAdd:input_type -> message.AddRequest + 0, // 4: message.Message.AdminMessage:output_type -> message.Response + 0, // 5: message.Message.ApiMessage:output_type -> message.Response + 0, // 6: message.Message.ApiMessageNumber:output_type -> message.Response + 1, // 7: message.Message.MessageAdd:output_type -> message.AddResponse + 4, // [4:8] is the sub-list for method output_type + 0, // [0:4] 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 +} + +func init() { file_message_message_proto_init() } +func file_message_message_proto_init() { + if File_message_message_proto != nil { + return + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_message_message_proto_rawDesc), len(file_message_message_proto_rawDesc)), + NumEnums: 0, + NumMessages: 5, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_message_message_proto_goTypes, + DependencyIndexes: file_message_message_proto_depIdxs, + MessageInfos: file_message_message_proto_msgTypes, + }.Build() + File_message_message_proto = out.File + file_message_message_proto_goTypes = nil + file_message_message_proto_depIdxs = nil +} diff --git a/rpc/message/pb/message_grpc.pb.go b/rpc/message/pb/message_grpc.pb.go new file mode 100644 index 0000000..cf27b7f --- /dev/null +++ b/rpc/message/pb/message_grpc.pb.go @@ -0,0 +1,235 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.6.2 +// - protoc v4.25.8 +// source: message/message.proto + +package message + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + Message_AdminMessage_FullMethodName = "/message.Message/AdminMessage" + Message_ApiMessage_FullMethodName = "/message.Message/ApiMessage" + Message_ApiMessageNumber_FullMethodName = "/message.Message/ApiMessageNumber" + Message_MessageAdd_FullMethodName = "/message.Message/MessageAdd" +) + +// MessageClient is the client API for Message service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type MessageClient interface { + AdminMessage(ctx context.Context, in *ItemsRequest, opts ...grpc.CallOption) (*Response, error) + ApiMessage(ctx context.Context, in *ItemsRequest, opts ...grpc.CallOption) (*Response, error) + ApiMessageNumber(ctx context.Context, in *ApiMessageNumberRequest, opts ...grpc.CallOption) (*Response, error) + MessageAdd(ctx context.Context, in *AddRequest, opts ...grpc.CallOption) (*AddResponse, error) +} + +type messageClient struct { + cc grpc.ClientConnInterface +} + +func NewMessageClient(cc grpc.ClientConnInterface) MessageClient { + return &messageClient{cc} +} + +func (c *messageClient) AdminMessage(ctx context.Context, in *ItemsRequest, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Message_AdminMessage_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *messageClient) ApiMessage(ctx context.Context, in *ItemsRequest, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Message_ApiMessage_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *messageClient) ApiMessageNumber(ctx context.Context, in *ApiMessageNumberRequest, opts ...grpc.CallOption) (*Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Response) + err := c.cc.Invoke(ctx, Message_ApiMessageNumber_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *messageClient) MessageAdd(ctx context.Context, in *AddRequest, opts ...grpc.CallOption) (*AddResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(AddResponse) + err := c.cc.Invoke(ctx, Message_MessageAdd_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MessageServer is the server API for Message service. +// All implementations must embed UnimplementedMessageServer +// for forward compatibility. +type MessageServer interface { + AdminMessage(context.Context, *ItemsRequest) (*Response, error) + ApiMessage(context.Context, *ItemsRequest) (*Response, error) + ApiMessageNumber(context.Context, *ApiMessageNumberRequest) (*Response, error) + MessageAdd(context.Context, *AddRequest) (*AddResponse, error) + mustEmbedUnimplementedMessageServer() +} + +// UnimplementedMessageServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedMessageServer struct{} + +func (UnimplementedMessageServer) AdminMessage(context.Context, *ItemsRequest) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method AdminMessage not implemented") +} +func (UnimplementedMessageServer) ApiMessage(context.Context, *ItemsRequest) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method ApiMessage not implemented") +} +func (UnimplementedMessageServer) ApiMessageNumber(context.Context, *ApiMessageNumberRequest) (*Response, error) { + return nil, status.Error(codes.Unimplemented, "method ApiMessageNumber not implemented") +} +func (UnimplementedMessageServer) MessageAdd(context.Context, *AddRequest) (*AddResponse, error) { + return nil, status.Error(codes.Unimplemented, "method MessageAdd not implemented") +} +func (UnimplementedMessageServer) mustEmbedUnimplementedMessageServer() {} +func (UnimplementedMessageServer) testEmbeddedByValue() {} + +// UnsafeMessageServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to MessageServer will +// result in compilation errors. +type UnsafeMessageServer interface { + mustEmbedUnimplementedMessageServer() +} + +func RegisterMessageServer(s grpc.ServiceRegistrar, srv MessageServer) { + // If the following call panics, it indicates UnimplementedMessageServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&Message_ServiceDesc, srv) +} + +func _Message_AdminMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ItemsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MessageServer).AdminMessage(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Message_AdminMessage_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MessageServer).AdminMessage(ctx, req.(*ItemsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Message_ApiMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ItemsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MessageServer).ApiMessage(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Message_ApiMessage_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MessageServer).ApiMessage(ctx, req.(*ItemsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Message_ApiMessageNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ApiMessageNumberRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MessageServer).ApiMessageNumber(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Message_ApiMessageNumber_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MessageServer).ApiMessageNumber(ctx, req.(*ApiMessageNumberRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Message_MessageAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AddRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MessageServer).MessageAdd(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Message_MessageAdd_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MessageServer).MessageAdd(ctx, req.(*AddRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// Message_ServiceDesc is the grpc.ServiceDesc for Message service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Message_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "message.Message", + HandlerType: (*MessageServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "AdminMessage", + Handler: _Message_AdminMessage_Handler, + }, + { + MethodName: "ApiMessage", + Handler: _Message_ApiMessage_Handler, + }, + { + MethodName: "ApiMessageNumber", + Handler: _Message_ApiMessageNumber_Handler, + }, + { + MethodName: "MessageAdd", + Handler: _Message_MessageAdd_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "message/message.proto", +} diff --git a/services/equipment/internal/logic/apiBeansAddLogic.go b/services/equipment/internal/logic/apiBeansAddLogic.go new file mode 100644 index 0000000..2e43f30 --- /dev/null +++ b/services/equipment/internal/logic/apiBeansAddLogic.go @@ -0,0 +1,85 @@ +package logic + +import ( + "context" + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + "lone-services/services/equipment/internal/dao" + "lone-services/services/equipment/internal/model" + "lone-services/services/equipment/validator" + "strconv" + + "lone-services/rpc/equipment/pb" + "lone-services/services/equipment/internal/svc" + + "github.com/zeromicro/go-zero/core/logx" +) + +type ApiBeansAddLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger + BaseLogic +} + +func NewApiBeansAddLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ApiBeansAddLogic { + return &ApiBeansAddLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *ApiBeansAddLogic) ApiBeansAdd(in *equipment.ApiBeansAddRequest) (*equipment.Response, error) { + var v validator.BeansImagesValidator + if fail := l.checkParams(in, &v); fail != nil { + return fail, nil + } + adminInfo := utils.GetUserFromCtx(l.ctx) + if adminInfo.ID < utils.NumberOne { + return l.fail(utils.ErrorNoLoginInfo) + } + + if in.Id < utils.NumberOne { + return l.add(in, adminInfo) + } + + return l.update(in) +} + +func (l *ApiBeansAddLogic) update(in *equipment.ApiBeansAddRequest) (*equipment.Response, error) { + var info dao.BeansInfo + w := modelbase.Params{Eq: map[string]string{"id": strconv.FormatInt(in.Id, utils.NumberTen)}} + err := model.BeansModel{}.Init().GetOne(w, &info) + if err != nil { + l.Logger.Error(err) + return l.fail(utils.Fail) + } + if info.Id < utils.NumberOne { + return l.fail(utils.ErrorNotFund) + } + info.SecondTime = utils.Now() + info.SecondImage = in.Image + _, err = model.BeansModel{}.Init().Edit(w, &info) + if err != nil { + l.Logger.Error(err) + return l.fail(utils.Fail) + } + return l.ok(utils.NumberOne) +} + +func (l *ApiBeansAddLogic) add(in *equipment.ApiBeansAddRequest, adminInfo utils.UserInfo) (*equipment.Response, error) { + create := dao.BeansCreate{ + UserId: adminInfo.ID, + UserName: adminInfo.Name, + UserNickName: adminInfo.Name, + FirstImage: in.Image, + FirstTime: utils.Now(), + } + err := model.BeansModel{}.Init().Create(&create) + if err != nil { + l.Logger.Error(err) + return l.fail(utils.Fail) + } + return l.ok(utils.NumberOne) +} diff --git a/services/equipment/internal/logic/apiBeansItemsLogic.go b/services/equipment/internal/logic/apiBeansItemsLogic.go new file mode 100644 index 0000000..471ecc0 --- /dev/null +++ b/services/equipment/internal/logic/apiBeansItemsLogic.go @@ -0,0 +1,52 @@ +package logic + +import ( + "context" + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + "lone-services/services/equipment/internal/dao" + "lone-services/services/equipment/internal/model" + "strconv" + + "lone-services/rpc/equipment/pb" + "lone-services/services/equipment/internal/svc" + + "github.com/zeromicro/go-zero/core/logx" +) + +type ApiBeansItemsLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger + BaseLogic +} + +func NewApiBeansItemsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ApiBeansItemsLogic { + return &ApiBeansItemsLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *ApiBeansItemsLogic) ApiBeansItems(in *equipment.ApiBeansItemsRequest) (*equipment.Response, error) { + adminInfo := utils.GetUserFromCtx(l.ctx) + if adminInfo.ID < utils.NumberOne { + return l.fail(utils.ErrorNoLoginInfo) + } + var info []dao.BeansInfo + w := modelbase.Params{ + Size: int(in.Size), + Order: "id desc", + Page: int(in.Page), + Eq: map[string]string{"user_id": strconv.FormatInt(adminInfo.ID, utils.NumberTen)}, + } + + items, err := model.BeansModel{}.Init().Page(w, &info) + if err != nil { + l.Logger.Error(err) + return l.fail(utils.Fail) + } + + return l.ok(items) +} diff --git a/services/equipment/internal/logic/apiBeansLastLogic.go b/services/equipment/internal/logic/apiBeansLastLogic.go new file mode 100644 index 0000000..04ce855 --- /dev/null +++ b/services/equipment/internal/logic/apiBeansLastLogic.go @@ -0,0 +1,53 @@ +package logic + +import ( + "context" + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + "lone-services/services/equipment/internal/dao" + "lone-services/services/equipment/internal/model" + "strconv" + + "lone-services/rpc/equipment/pb" + "lone-services/services/equipment/internal/svc" + + "github.com/zeromicro/go-zero/core/logx" +) + +type ApiBeansLastLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger + BaseLogic +} + +func NewApiBeansLastLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ApiBeansLastLogic { + return &ApiBeansLastLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *ApiBeansLastLogic) ApiBeansLast(in *equipment.EmptyRequest) (*equipment.Response, error) { + adminInfo := utils.GetUserFromCtx(l.ctx) + if adminInfo.ID < utils.NumberOne { + return l.fail(utils.ErrorNoLoginInfo) + } + + var info dao.BeansInfo + w := modelbase.Params{ + Eq: map[string]string{"user_id": strconv.FormatInt(adminInfo.ID, utils.NumberTen)}, + Order: "id desc", + } + err := model.BeansModel{}.Init().GetOne(w, &info) + if err != nil { + l.Logger.Error(err) + return l.fail(utils.Fail) + } + if info.Id < utils.NumberOne { + return l.fail(utils.ErrorNotFund) + } + + return l.ok(info) +} diff --git a/services/message/.gitignore b/services/message/.gitignore new file mode 100644 index 0000000..e01ad78 --- /dev/null +++ b/services/message/.gitignore @@ -0,0 +1,3 @@ +run.toml +etc/message.yaml +tmp \ No newline at end of file diff --git a/services/message/Dockerfile b/services/message/Dockerfile new file mode 100644 index 0000000..9ac2ac9 --- /dev/null +++ b/services/message/Dockerfile @@ -0,0 +1,37 @@ +FROM golang:1.26.5-alpine AS builder + +WORKDIR /src + +ENV GOPROXY=https://goproxy.cn,direct \ + CGO_ENABLED=0 \ + GOOS=linux \ + GOARCH=amd64 + +COPY pkg ./pkg +COPY go.mod go.sum ./ + +RUN --mount=type=cache,target=/go/pkg/mod \ + go mod download + +COPY rpc/ ./rpc +COPY services/message/ ./services/message/ + +WORKDIR /src/services/message + +RUN --mount=type=cache,target=/go/pkg/mod \ + --mount=type=cache,target=/root/.cache/go-build \ + go build -ldflags="-s -w" -o /out/main ./ + +FROM alpine:3.22 + +WORKDIR /app + +ENV TZ=Asia/Shanghai + +RUN apk add --no-cache tzdata \ + && cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \ + && echo "Asia/Shanghai" > /etc/timezone + +COPY --from=builder /out/main . + +CMD ["./main", "-f", "etc/message.yaml"] diff --git a/services/message/internal/config/config.go b/services/message/internal/config/config.go new file mode 100644 index 0000000..a1979dd --- /dev/null +++ b/services/message/internal/config/config.go @@ -0,0 +1,13 @@ +package config + +type Config struct { + Nacos NacosConf +} + +type NacosConf struct { + Hosts []string + NamespaceId string `json:",optional"` + Group string `json:",optional"` + RegisterIP string `json:",optional"` + ConfigID string `json:",optional"` +} diff --git a/services/message/internal/dao/message.go b/services/message/internal/dao/message.go new file mode 100644 index 0000000..c98f5a8 --- /dev/null +++ b/services/message/internal/dao/message.go @@ -0,0 +1,41 @@ +package dao + +import "lone-services/pkg/utils" + +const ( + // 目标类型 + TargetTypeAgent = 1 //代理 + TargetTypeStore = 2 //门店 + TargetTypeUser = 3 //个人 + // 类型 + ObjTypeAgent = 1 //添加代理 + ObjTypeStore = 2 //加门店 + ObjTypeSupply = 3 //审核补货 +) + +type MessageCreate struct { + Id int64 `gorm:"column:id;type:int(11);primary_key;AUTO_INCREMENT;comment:ID" json:"id"` + Content string `gorm:"column:content;type:varchar(255);comment:内容;NOT NULL" json:"content"` + TargetType int32 `gorm:"column:target_type;type:tinyint(1);comment:目标类型，1为销售，2为门店，3为个人;NOT NULL" json:"target_type"` + TargetId int64 `gorm:"column:target_id;type:int(11);comment:目标ID,发给谁;NOT NULL" json:"target_id"` + TypeStatus int32 `gorm:"column:type_status;type:tinyint(1);comment:类型状态，目前1为通过，2为未通过;NOT NULL" json:"type_status"` + Type int32 `gorm:"column:type;type:tinyint(2);comment:类型，1为申请代理，2为添加门店，3为审核补货;NOT NULL" json:"type"` + ObjId int64 `gorm:"column:obj_id;type:int(11);comment:对像ID;NOT NULL" json:"obj_id"` +} + +type MessageInfo struct { + Id int64 `gorm:"column:id;type:int(11);primary_key;AUTO_INCREMENT;comment:ID" json:"id"` + Content string `gorm:"column:content;type:varchar(255);comment:内容;NOT NULL" json:"content"` + TargetType int32 `gorm:"column:target_type;type:tinyint(1);comment:目标类型，1为销售，2为门店，3为个人;NOT NULL" json:"target_type"` + TargetId int64 `gorm:"column:target_id;type:int(11);comment:目标ID,发给谁;NOT NULL" json:"target_id"` + TypeStatus int32 `gorm:"column:type_status;type:tinyint(1);comment:类型状态，目前1为通过，2为未通过;NOT NULL" json:"type_status"` + Type int32 `gorm:"column:type;type:tinyint(2);comment:类型，1为申请代理，2为添加门店，3为审核补货;NOT NULL" json:"type"` + ObjId int64 `gorm:"column:obj_id;type:int(11);comment:对像ID;NOT NULL" json:"obj_id"` + Status int32 `gorm:"column:status;type:tinyint(1);default:2;comment:状态，1为已读，2为未读;NOT NULL" json:"status"` + UpdateTime utils.CustomTime `gorm:"column:update_time;type:datetime;default:CURRENT_TIMESTAMP;comment:更新时间" json:"update_time"` + CreateTime utils.CustomTime `gorm:"column:create_time;type:datetime;default:CURRENT_TIMESTAMP;comment:添加时间" json:"create_time"` +} + +type MessageStatus struct { + Status int32 `gorm:"column:status;type:tinyint(1);default:9;comment:9是待处理 1是已通过 2是未通过,3为禁用;NOT NULL" json:"status"` +} diff --git a/services/message/internal/logic/adminMessageLogic.go b/services/message/internal/logic/adminMessageLogic.go new file mode 100644 index 0000000..fd4bf23 --- /dev/null +++ b/services/message/internal/logic/adminMessageLogic.go @@ -0,0 +1,54 @@ +package logic + +import ( + "context" + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + "lone-services/services/message/internal/dao" + "lone-services/services/message/internal/model" + "lone-services/services/order/validator" + + "lone-services/rpc/message/pb" + "lone-services/services/message/internal/svc" + + "github.com/zeromicro/go-zero/core/logx" +) + +type AdminMessageLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger + BaseLogic +} + +func NewAdminMessageLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminMessageLogic { + return &AdminMessageLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *AdminMessageLogic) AdminMessage(in *message.ItemsRequest) (*message.Response, error) { + var v validator.OrderItemsValidator + if fail := l.checkParams(in, &v); fail != nil { + return fail, nil + } + adminInfo := utils.GetUserFromCtx(l.ctx) + if adminInfo.ID < utils.NumberOne { + return l.fail(utils.ErrorNoLoginInfo) + } + var info []dao.MessageInfo + w := modelbase.Params{ + Page: int(in.Page), + Size: int(in.Size), + Order: "id desc", + } + + items, err := model.MessageModel{}.Init().Page(w, &info) + if err != nil { + l.Logger.Error(err) + return l.fail(utils.Fail) + } + return l.ok(items) +} diff --git a/services/message/internal/logic/apiMessageLogic.go b/services/message/internal/logic/apiMessageLogic.go new file mode 100644 index 0000000..c02d6f8 --- /dev/null +++ b/services/message/internal/logic/apiMessageLogic.go @@ -0,0 +1,66 @@ +package logic + +import ( + "context" + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + "lone-services/services/message/internal/dao" + "lone-services/services/message/internal/model" + "lone-services/services/order/validator" + "strconv" + + "lone-services/rpc/message/pb" + "lone-services/services/message/internal/svc" + + "github.com/zeromicro/go-zero/core/logx" +) + +type ApiMessageLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger + BaseLogic +} + +func NewApiMessageLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ApiMessageLogic { + return &ApiMessageLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *ApiMessageLogic) ApiMessage(in *message.ItemsRequest) (*message.Response, error) { + var v validator.OrderItemsValidator + if fail := l.checkParams(in, &v); fail != nil { + return fail, nil + } + adminInfo := utils.GetUserFromCtx(l.ctx) + if adminInfo.ID < utils.NumberOne { + return l.fail(utils.ErrorNoLoginInfo) + } + var info []dao.MessageInfo + w := modelbase.Params{ + Page: int(in.Page), + Size: int(in.Size), + Order: "id desc", + } + + items, err := model.MessageModel{}.Init().Page(w, &info) + if err != nil { + l.Logger.Error(err) + return l.fail(utils.Fail) + } + var ids []string + for _, v := range info { + ids = append(ids, strconv.Itoa(int(v.Id))) + } + + if len(ids) > utils.NumberZero { + status := dao.MessageStatus{Status: utils.StatusOk} + + ww := modelbase.Params{In: map[string][]string{"id": ids}} + _, err = model.MessageModel{}.Init().Edit(ww, &status) + } + return l.ok(items) +} diff --git a/services/message/internal/logic/apiMessageNumberLogic.go b/services/message/internal/logic/apiMessageNumberLogic.go new file mode 100644 index 0000000..053ee60 --- /dev/null +++ b/services/message/internal/logic/apiMessageNumberLogic.go @@ -0,0 +1,53 @@ +package logic + +import ( + "context" + "lone-services/pkg/modelbase" + "lone-services/pkg/utils" + "lone-services/services/message/internal/dao" + "lone-services/services/message/internal/model" + "strconv" + + "lone-services/rpc/message/pb" + "lone-services/services/message/internal/svc" + + "github.com/zeromicro/go-zero/core/logx" +) + +type ApiMessageNumberLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger + BaseLogic +} + +func NewApiMessageNumberLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ApiMessageNumberLogic { + return &ApiMessageNumberLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *ApiMessageNumberLogic) ApiMessageNumber(in *message.ApiMessageNumberRequest) (*message.Response, error) { + adminInfo := utils.GetUserFromCtx(l.ctx) + if adminInfo.ID < utils.NumberOne { + return l.fail(utils.ErrorNoLoginInfo) + } + + var info []dao.MessageInfo + w := modelbase.Params{ + Eq: map[string]string{ + "status": strconv.Itoa(utils.StatusFail), + "target_id": strconv.FormatInt(adminInfo.ID, utils.NumberTen), + "type": strconv.Itoa(int(in.Type)), + }, + } + + count, err := model.MessageModel{}.Init().Count(w, &info) + if err != nil { + utils.Logger.Error(err) + return l.fail(utils.Fail) + } + return l.ok(count) +} diff --git a/services/message/internal/logic/base.go b/services/message/internal/logic/base.go new file mode 100644 index 0000000..9a1afb0 --- /dev/null +++ b/services/message/internal/logic/base.go @@ -0,0 +1,48 @@ +package logic + +import ( + "lone-services/pkg/utils" + "lone-services/pkg/validate" + message "lone-services/rpc/message/pb" + "reflect" + + jsoniter "github.com/json-iterator/go" +) + +type BaseLogic struct { +} + +func (l *BaseLogic) checkParams(in interface{}, v validate.IValidator) *message.Response { + rv := reflect.ValueOf(in) + if rv.Kind() != reflect.Ptr || rv.IsNil() { + return &message.Response{ + Code: utils.ErrorParams.Code, + Msg: "request must be non‑nil proto pointer", + } + } + + resp := validate.ValidateFromProto(in, v) + if resp != utils.StringEmpty { + return &message.Response{ + Code: utils.ErrorParams.Code, + Msg: resp, + } + } + return nil +} + +func (l *BaseLogic) fail(status utils.Status) (*message.Response, error) { + return l.out(status, status.Msg) +} +func (l *BaseLogic) out(status utils.Status, msg string) (*message.Response, error) { + return &message.Response{Code: status.Code, Msg: msg}, nil +} + +func (l *BaseLogic) outData(status utils.Status, msg, data string) (*message.Response, error) { + return &message.Response{Code: status.Code, Msg: msg, Data: data}, nil +} + +func (l *BaseLogic) ok(data any) (*message.Response, error) { + buf, _ := jsoniter.Marshal(data) + return &message.Response{Code: utils.Ok.Code, Msg: utils.Ok.Msg, Data: string(buf)}, nil +} diff --git a/services/message/internal/logic/messageAddLogic.go b/services/message/internal/logic/messageAddLogic.go new file mode 100644 index 0000000..679ceb8 --- /dev/null +++ b/services/message/internal/logic/messageAddLogic.go @@ -0,0 +1,48 @@ +package logic + +import ( + "context" + "lone-services/pkg/utils" + "lone-services/services/message/internal/dao" + "lone-services/services/message/internal/model" + + "lone-services/rpc/message/pb" + "lone-services/services/message/internal/svc" + + "github.com/zeromicro/go-zero/core/logx" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" +) + +type MessageAddLogic struct { + ctx context.Context + svcCtx *svc.ServiceContext + logx.Logger +} + +func NewMessageAddLogic(ctx context.Context, svcCtx *svc.ServiceContext) *MessageAddLogic { + return &MessageAddLogic{ + ctx: ctx, + svcCtx: svcCtx, + Logger: logx.WithContext(ctx), + } +} + +func (l *MessageAddLogic) MessageAdd(in *message.AddRequest) (*message.AddResponse, error) { + add := dao.MessageCreate{ + Content: in.Content, + TargetType: in.TargetType, + TargetId: in.TargetId, + TypeStatus: in.TypeStatus, + Type: in.Type, + ObjId: in.ObjId, + } + + err := model.MessageModel{}.Init().Create(&add) + if err != nil { + l.Logger.Error("Failed to create message:", err) + return nil, status.Error(codes.Internal, utils.Fail.Msg) + } + + return &message.AddResponse{Num: utils.NumberOne}, nil +} diff --git a/services/message/internal/model/message.go b/services/message/internal/model/message.go new file mode 100644 index 0000000..25f312c --- /dev/null +++ b/services/message/internal/model/message.go @@ -0,0 +1,23 @@ +package model + +import ( + "lone-services/pkg/modelbase" + "lone-services/services/message/internal/dao" +) + +type MessageModel struct { + modelbase.Base +} + +func (m MessageModel) TableName() string { + return modelbase.Prefix() + "message" +} + +func (m MessageModel) Init() MessageModel { + m.Table = m.TableName() + return m +} + +func (m MessageModel) Create(data *dao.MessageCreate) error { + return m.Base.Create(data) +} diff --git a/services/message/internal/server/messageServer.go b/services/message/internal/server/messageServer.go new file mode 100644 index 0000000..c7cca15 --- /dev/null +++ b/services/message/internal/server/messageServer.go @@ -0,0 +1,44 @@ +// Code generated by goctl. DO NOT EDIT. +// goctl 1.10.2 +// Source: message.proto + +package server + +import ( + "context" + + "lone-services/rpc/message/pb" + "lone-services/services/message/internal/logic" + "lone-services/services/message/internal/svc" +) + +type MessageServer struct { + svcCtx *svc.ServiceContext + message.UnimplementedMessageServer +} + +func NewMessageServer(svcCtx *svc.ServiceContext) *MessageServer { + return &MessageServer{ + svcCtx: svcCtx, + } +} + +func (s *MessageServer) AdminMessage(ctx context.Context, in *message.ItemsRequest) (*message.Response, error) { + l := logic.NewAdminMessageLogic(ctx, s.svcCtx) + return l.AdminMessage(in) +} + +func (s *MessageServer) ApiMessage(ctx context.Context, in *message.ItemsRequest) (*message.Response, error) { + l := logic.NewApiMessageLogic(ctx, s.svcCtx) + return l.ApiMessage(in) +} + +func (s *MessageServer) ApiMessageNumber(ctx context.Context, in *message.ApiMessageNumberRequest) (*message.Response, error) { + l := logic.NewApiMessageNumberLogic(ctx, s.svcCtx) + return l.ApiMessageNumber(in) +} + +func (s *MessageServer) MessageAdd(ctx context.Context, in *message.AddRequest) (*message.AddResponse, error) { + l := logic.NewMessageAddLogic(ctx, s.svcCtx) + return l.MessageAdd(in) +} diff --git a/services/message/internal/svc/servicecontext.go b/services/message/internal/svc/servicecontext.go new file mode 100644 index 0000000..e47e5d3 --- /dev/null +++ b/services/message/internal/svc/servicecontext.go @@ -0,0 +1,22 @@ +package svc + +import ( + "lone-services/pkg/utils" + "lone-services/services/message/internal/config" + + "gorm.io/gorm" +) + +type ServiceContext struct { + Config config.Config + DB *gorm.DB + Prefix string +} + +func NewServiceContext(c config.Config, db *gorm.DB) *ServiceContext { + return &ServiceContext{ + Config: c, + DB: db, + Prefix: utils.GetConfigString("mysql.prefix"), + } +} diff --git a/services/message/message.go b/services/message/message.go new file mode 100644 index 0000000..dd56330 --- /dev/null +++ b/services/message/message.go @@ -0,0 +1,170 @@ +package main + +import ( + "flag" + "lone-services/pkg/discovery" + "lone-services/pkg/logRedis" + "lone-services/pkg/modelbase" + "lone-services/pkg/mysql" + "lone-services/pkg/redis" + "lone-services/pkg/utils" + "lone-services/pkg/validate" + "net" + "os" + "strconv" + + "lone-services/services/message/internal/config" + "lone-services/services/message/internal/server" + "lone-services/services/message/internal/svc" + "lone-services/services/message/message" + + "github.com/zeromicro/go-zero/core/conf" + "github.com/zeromicro/go-zero/core/logx" + "github.com/zeromicro/go-zero/core/service" + "github.com/zeromicro/go-zero/zrpc" + "google.golang.org/grpc" + "google.golang.org/grpc/reflection" +) + +var configFile = flag.String("f", "etc/message.yaml", "the config file") + +func main() { + flag.Parse() + var c config.Config + conf.MustLoad(*configFile, &c) + + // Nacos配置拉取初始化 + nacosParam := utils.NacosConfig{ + Hosts: c.Nacos.Hosts, + NamespaceId: c.Nacos.NamespaceId, + Group: c.Nacos.Group, + ConfigID: c.Nacos.ConfigID, + } + utils.InitConfig(nacosParam) + + // 日志配置 + logConf := logx.LogConf{ + ServiceName: utils.GetConfigString("log.serviceName"), + Mode: utils.GetConfigString("log.mode"), + Encoding: utils.GetConfigString("log.encoding"), + Level: utils.GetConfigString("log.level"), + Path: utils.GetConfigString("log.path"), + KeepDays: utils.GetConfigInt("log.keepDays"), + MaxSize: utils.GetConfigInt("log.maxSize"), + MaxBackups: utils.GetConfigInt("log.maxBackups"), + Compress: utils.GetConfigBool("log.compress"), + } + logx.SetUp(logConf) + logx.AddWriter(logx.NewWriter(os.Stdout)) + + listenOn := utils.GetConfigString("base.listenOn") + mode := utils.GetConfigString("base.mode") + serviceName := utils.GetConfigString("base.name") + + // 初始化服务发现 + if err := discovery.Init(discovery.Config{ + Hosts: c.Nacos.Hosts, + NamespaceId: c.Nacos.NamespaceId, + Group: c.Nacos.Group, + }); err != nil { + logx.Errorf("nacos init: %v", err) + os.Exit(1) + } + + port, err := listenPort(listenOn) + if err != nil { + logx.Errorf("parse ListenOn: %v", err) + os.Exit(1) + } + + // 注册服务 + if err := discovery.Register(discovery.Instance{ + ServiceName: serviceName, + IP: c.Nacos.RegisterIP, + Port: port, + Group: c.Nacos.Group, + }); err != nil { + logx.Errorf("nacos register: %v", err) + os.Exit(1) + } + logx.Infof("服务注册成功: %s:%d", c.Nacos.RegisterIP, port) + + defer func() { + if err := discovery.Deregister(); err != nil { + logx.Errorf("nacos deregister: %v", err) + } + }() + + // 初始化MySQL + db, err := mysql.New(mysql.Config{ + Host: utils.GetConfigString("mysql.host"), + Port: utils.GetConfigInt("mysql.port"), + User: utils.GetConfigString("mysql.user"), + Password: utils.GetConfigString("mysql.password"), + Database: utils.GetConfigString("mysql.database"), + Charset: utils.GetConfigString("mysql.charset"), + Prefix: utils.GetConfigString("mysql.prefix"), + ReadHost: utils.GetConfigString("mysql_read.host"), + ReadPort: utils.GetConfigInt("mysql_read.port"), + ReadUser: utils.GetConfigString("mysql_read.user"), + ReadPassword: utils.GetConfigString("mysql_read.password"), + ReadDatabase: utils.GetConfigString("mysql_read.database"), + }) + if err != nil { + logx.Errorf("mysql init: %v", err) + os.Exit(1) + } + + // 初始化Redis + if err := redis.Init(redis.Config{ + Host: utils.GetConfigString("redis.host"), + Port: utils.GetConfigInt("redis.port"), + Password: utils.GetConfigString("redis.password"), + DB: utils.GetConfigInt("redis.db"), + }); err != nil { + logx.Errorf("redis init: %v", err) + os.Exit(1) + } + + if err := logRedis.Init(logRedis.LogRedisConfig{ + Host: utils.GetConfigString("log-redis.host"), + Port: utils.GetConfigInt("log-redis.port"), + Password: utils.GetConfigString("log-redis.password"), + DB: utils.GetConfigInt("log-redis.db"), + }); err != nil { + logx.Errorf("log redis init: %v", err) + os.Exit(1) + } + + debug := utils.GetConfigBool("mysql.debug") + modelbase.Init(db, modelbase.Config{Prefix: utils.GetConfigString("mysql.prefix"), Debug: debug}) + + // 初始化服务信息 + rpcConf := zrpc.RpcServerConf{ + ListenOn: listenOn, + } + rpcConf.Mode = mode + ctx := svc.NewServiceContext(c, db) + + s := zrpc.MustNewServer(rpcConf, func(grpcServer *grpc.Server) { + message.RegisterMessageServer(grpcServer, server.NewMessageServer(ctx)) + if mode == service.DevMode || mode == service.TestMode { + reflection.Register(grpcServer) + } + }) + defer s.Stop() + + s.AddUnaryInterceptors(validate.UnaryServerInterceptor(validate.MustNew())) + + logx.Infof("Starting rpc server at %s...", listenOn) + s.Start() +} + +// listenPort 拆分端口 +func listenPort(listenOn string) (uint64, error) { + _, portStr, err := net.SplitHostPort(listenOn) + if err != nil { + return utils.NumberZero, err + } + return strconv.ParseUint(portStr, utils.NumberTen, utils.NumberSixtyFourth) +} diff --git a/services/message/messageclient/message.go b/services/message/messageclient/message.go new file mode 100644 index 0000000..d02c71b --- /dev/null +++ b/services/message/messageclient/message.go @@ -0,0 +1,59 @@ +// Code generated by goctl. DO NOT EDIT. +// goctl 1.10.2 +// Source: message.proto + +package messageClient + +import ( + "context" + + "lone-services/rpc/message/pb" + + "github.com/zeromicro/go-zero/zrpc" + "google.golang.org/grpc" +) + +type ( + AddRequest = message.AddRequest + AddResponse = message.AddResponse + ApiMessageNumberRequest = message.ApiMessageNumberRequest + ItemsRequest = message.ItemsRequest + Response = message.Response + + Message interface { + AdminMessage(ctx context.Context, in *ItemsRequest, opts ...grpc.CallOption) (*Response, error) + ApiMessage(ctx context.Context, in *ItemsRequest, opts ...grpc.CallOption) (*Response, error) + ApiMessageNumber(ctx context.Context, in *ApiMessageNumberRequest, opts ...grpc.CallOption) (*Response, error) + MessageAdd(ctx context.Context, in *AddRequest, opts ...grpc.CallOption) (*AddResponse, error) + } + + defaultMessage struct { + cli zrpc.Client + } +) + +func NewMessage(cli zrpc.Client) Message { + return &defaultMessage{ + cli: cli, + } +} + +func (m *defaultMessage) AdminMessage(ctx context.Context, in *ItemsRequest, opts ...grpc.CallOption) (*Response, error) { + client := message.NewMessageClient(m.cli.Conn()) + return client.AdminMessage(ctx, in, opts...) +} + +func (m *defaultMessage) ApiMessage(ctx context.Context, in *ItemsRequest, opts ...grpc.CallOption) (*Response, error) { + client := message.NewMessageClient(m.cli.Conn()) + return client.ApiMessage(ctx, in, opts...) +} + +func (m *defaultMessage) ApiMessageNumber(ctx context.Context, in *ApiMessageNumberRequest, opts ...grpc.CallOption) (*Response, error) { + client := message.NewMessageClient(m.cli.Conn()) + return client.ApiMessageNumber(ctx, in, opts...) +} + +func (m *defaultMessage) MessageAdd(ctx context.Context, in *AddRequest, opts ...grpc.CallOption) (*AddResponse, error) { + client := message.NewMessageClient(m.cli.Conn()) + return client.MessageAdd(ctx, in, opts...) +} diff --git a/services/message/validator/message.go b/services/message/validator/message.go new file mode 100644 index 0000000..7780094 --- /dev/null +++ b/services/message/validator/message.go @@ -0,0 +1,27 @@ +package validator + +import "lone-services/pkg/validate" + +type MessageItemsValidator struct { + Page int32 `form:"page" json:"page"` + Size int32 `form:"size" json:"size"` + Type int32 `form:"type" json:"type" validate:"required"` +} + +// GetMessage 提示消息 +func (p MessageItemsValidator) GetMessage() validate.ValidatorMessages { + return validate.ValidatorMessages{ + validate.FieldType: validate.FieldType, + } +} + +type MessageNumberValidator struct { + Type int32 `form:"type" json:"type" binding:"required"` +} + +// GetMessage 提示消息 +func (p MessageNumberValidator) GetMessage() validate.ValidatorMessages { + return validate.ValidatorMessages{ + validate.FieldType: validate.FieldType, + } +}