Create & Init Project...

app/interface/main/creative/model/reply/BUILD

@@ -0,0 +1,44 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "reply.go",
+        "xints.go",
+    ],
+    importpath = "go-common/app/interface/main/creative/model/reply",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/reply/model/reply:go_default_library",
+        "//library/time:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["xints_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+)

app/interface/main/creative/model/reply/reply.go

@@ -0,0 +1,50 @@
+package reply
+
+import (
+	"go-common/app/interface/main/reply/model/reply"
+	xtime "go-common/library/time"
+)
+
+// Reply str
+type Reply struct {
+	RpID      int64      `json:"rpid"`
+	Oid       int64      `json:"oid"`
+	Type      int8       `json:"type"`
+	Mid       int64      `json:"mid"`
+	Root      int64      `json:"root"`
+	Parent    int64      `json:"parent"`
+	Count     int        `json:"count"`
+	RCount    int        `json:"rcount"`
+	Floor     int        `json:"floor"`
+	State     int8       `json:"state"`
+	Attr      int8       `json:"attr"`
+	CTime     xtime.Time `json:"ctime"`
+	MTime     xtime.Time `json:"-"`
+	RpIDStr   string     `json:"rpid_str,omitempty"`
+	RootStr   string     `json:"root_str,omitempty"`
+	ParentStr string     `json:"parent_str,omitempty"`
+	// action count, from ReplyAction count
+	Like   int  `json:"like"`
+	Hate   int  `json:"-"`
+	Action int8 `json:"action"`
+	// member info
+	Member *reply.Info `json:"member"`
+	// other
+	Content *CreativeReplyCont `json:"content"`
+	Replies []*Reply           `json:"replies"`
+}
+
+// CreativeReplyCont str
+type CreativeReplyCont struct {
+	RpID    int64      `json:"-"`
+	Message string     `json:"message"`
+	Ats     Ints       `json:"ats,omitempty"`
+	IP      uint32     `json:"ipi,omitempty"`
+	Plat    int8       `json:"plat"`
+	Device  string     `json:"device"`
+	Version string     `json:"version,omitempty"`
+	CTime   xtime.Time `json:"-"`
+	MTime   xtime.Time `json:"-"`
+	// ats member info
+	Members []*reply.Info `json:"members"`
+}

app/interface/main/creative/model/reply/xints.go

@@ -0,0 +1,91 @@
+package reply
+
+import (
+	"database/sql/driver"
+	"encoding/binary"
+)
+
+//Ints be used to MySql\Protobuf varbinary converting.
+type Ints []int64
+
+// MarshalTo  marshal int64 slice to bytes,each int64 will occupy Fixed 8 bytes.
+//if the argument data not supplied with the full size,it will return the actual written size
+func (is Ints) MarshalTo(data []byte) (int, error) {
+	for i, n := range is {
+		start := i * 8
+		end := (i + 1) * 8
+
+		if len(data) < end {
+			return start, nil
+		}
+		bs := data[start:end]
+		binary.BigEndian.PutUint64(bs, uint64(n))
+	}
+
+	return 8 * len(is), nil
+}
+
+// Size return the total size it will occupy in bytes
+func (is Ints) Size() int {
+	return len(is) * 8
+}
+
+// Unmarshal parse the data into int64 slice
+func (is *Ints) Unmarshal(data []byte) error {
+	return is.Scan(data)
+}
+
+// Scan parse the data into int64 slice
+func (is *Ints) Scan(src interface{}) (err error) {
+	switch sc := src.(type) {
+	case []byte:
+		var res []int64
+		for i := 0; i < len(sc) && i+8 <= len(sc); i += 8 {
+			ui := binary.BigEndian.Uint64(sc[i : i+8])
+			res = append(res, int64(ui))
+		}
+		*is = res
+	}
+	return
+}
+
+// Value marshal int64 slice to driver.Value,each int64 will occupy Fixed 8 bytes
+func (is Ints) Value() (driver.Value, error) {
+	return is.Bytes(), nil
+}
+
+// Bytes marshal int64 slice to bytes,each int64 will occupy Fixed 8 bytes
+func (is Ints) Bytes() []byte {
+	res := make([]byte, 0, 8*len(is))
+	for _, i := range is {
+		bs := make([]byte, 8)
+		binary.BigEndian.PutUint64(bs, uint64(i))
+		res = append(res, bs...)
+	}
+	return res
+}
+
+// Evict get rid of the sepcified num  from the slice
+func (is *Ints) Evict(e int64) (ok bool) {
+	res := make([]int64, len(*is)-1)
+	for _, v := range *is {
+		if v != e {
+			res = append(res, v)
+		} else {
+			ok = true
+		}
+	}
+	*is = res
+	return
+}
+
+// Exist judge the sepcified num is in the slice or not
+func (is Ints) Exist(i int64) (e bool) {
+	for _, v := range is {
+		if v == i {
+			e = true
+			return
+		}
+	}
+	return
+}

app/interface/main/creative/model/reply/xints_test.go

@@ -0,0 +1,74 @@
+package reply
+
+import (
+	"testing"
+)
+
+func TestMarshalAndUnmarshal(t *testing.T) {
+	var a = Ints{1, 2, 3}
+	data := make([]byte, a.Size())
+	n, err := a.MarshalTo(data)
+	if n != 24 {
+		t.Logf("marshal size must be 24")
+		t.FailNow()
+	}
+	if err != nil {
+		t.Fatalf("err:%v", err)
+	}
+
+	var b Ints
+	err = b.Unmarshal(data)
+	if err != nil {
+		t.Fatalf("err:%v", err)
+	}
+	if b[0] != 1 || b[1] != 2 || b[2] != 3 {
+		t.Logf("unmarshal failed!b:%v", b)
+		t.FailNow()
+	}
+}
+
+func TestUncompleteMarshal(t *testing.T) {
+	var a = Ints{1, 2, 3}
+	data := make([]byte, a.Size()-7)
+	n, err := a.MarshalTo(data)
+	if n != 16 {
+		t.Logf("marshal size must be 16")
+		t.FailNow()
+	}
+	if err != nil {
+		t.Fatalf("err:%v", err)
+	}
+
+	var b Ints
+	err = b.Unmarshal(data)
+	if err != nil {
+		t.Fatalf("err:%v", err)
+	}
+	if b[0] != 1 || b[1] != 2 {
+		t.Logf("unmarshal failed!b:%v", b)
+		t.FailNow()
+	}
+}
+
+func TestNilMarshal(t *testing.T) {
+	var a = Ints{1, 2, 3}
+	var data []byte
+	n, err := a.MarshalTo(data)
+	if n != 0 {
+		t.Logf("marshal size must be 0")
+		t.FailNow()
+	}
+	if err != nil {
+		t.Fatalf("err:%v", err)
+	}
+	var b Ints
+	err = b.Unmarshal(data)
+	if err != nil {
+		t.Fatalf("err:%v", err)
+	}
+	if b != nil {
+		t.Logf("unmarshal failed!b:%v", b)
+		t.FailNow()
+	}
+
+}