diff --git a/Dockerfile b/Dockerfile index 32639af7a..514a63db4 100644 --- a/Dockerfile +++ b/Dockerfile @@ -3,16 +3,14 @@ FROM golang:1.20 AS builder # Set go mod installation source and proxy ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct + ENV GO111MODULE=$GO111MODULE ENV GOPROXY=$GOPROXY # Set up the working directory WORKDIR /openim/openim-server -COPY go.mod go.sum ./ -RUN go mod download - # Copy all files to the container ADD . . diff --git a/build/images/openim-api/Dockerfile b/build/images/openim-api/Dockerfile index 8c3d710f1..5832c31a6 100644 --- a/build/images/openim-api/Dockerfile +++ b/build/images/openim-api/Dockerfile @@ -19,7 +19,7 @@ FROM golang:1.20 AS builder ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct WORKDIR /openim/openim-server diff --git a/build/images/openim-cmdutils/Dockerfile b/build/images/openim-cmdutils/Dockerfile index 413016f24..5afbe6ece 100644 --- a/build/images/openim-cmdutils/Dockerfile +++ b/build/images/openim-cmdutils/Dockerfile @@ -19,7 +19,7 @@ FROM golang:1.20 AS builder ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct WORKDIR /openim/openim-server diff --git a/build/images/openim-crontask/Dockerfile b/build/images/openim-crontask/Dockerfile index 35ba75784..4019e16c1 100644 --- a/build/images/openim-crontask/Dockerfile +++ b/build/images/openim-crontask/Dockerfile @@ -19,7 +19,7 @@ FROM golang:1.20 AS builder ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct WORKDIR /openim/openim-server diff --git a/build/images/openim-msggateway/Dockerfile b/build/images/openim-msggateway/Dockerfile index fe9db8f32..c9d1ce949 100644 --- a/build/images/openim-msggateway/Dockerfile +++ b/build/images/openim-msggateway/Dockerfile @@ -19,7 +19,7 @@ FROM golang:1.20 AS builder ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct WORKDIR /openim/openim-server diff --git a/build/images/openim-msgtransfer/Dockerfile b/build/images/openim-msgtransfer/Dockerfile index c04425f94..08a026c35 100644 --- a/build/images/openim-msgtransfer/Dockerfile +++ b/build/images/openim-msgtransfer/Dockerfile @@ -19,7 +19,7 @@ FROM golang:1.20 AS builder ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct WORKDIR /openim/openim-server diff --git a/build/images/openim-push/Dockerfile b/build/images/openim-push/Dockerfile index e51b7a44c..43a3833c2 100644 --- a/build/images/openim-push/Dockerfile +++ b/build/images/openim-push/Dockerfile @@ -19,7 +19,7 @@ FROM golang:1.20 AS builder ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct WORKDIR /openim/openim-server diff --git a/build/images/openim-rpc-auth/Dockerfile b/build/images/openim-rpc-auth/Dockerfile index 8054935bd..6a64c3e79 100644 --- a/build/images/openim-rpc-auth/Dockerfile +++ b/build/images/openim-rpc-auth/Dockerfile @@ -19,7 +19,7 @@ FROM golang:1.20 AS builder ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct WORKDIR /openim/openim-server diff --git a/build/images/openim-rpc-conversation/Dockerfile b/build/images/openim-rpc-conversation/Dockerfile index 0cfb681a2..421755094 100644 --- a/build/images/openim-rpc-conversation/Dockerfile +++ b/build/images/openim-rpc-conversation/Dockerfile @@ -19,7 +19,7 @@ FROM golang:1.20 AS builder ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct WORKDIR /openim/openim-server diff --git a/build/images/openim-rpc-friend/Dockerfile b/build/images/openim-rpc-friend/Dockerfile index 36870bc7e..ba3a38116 100644 --- a/build/images/openim-rpc-friend/Dockerfile +++ b/build/images/openim-rpc-friend/Dockerfile @@ -19,7 +19,7 @@ FROM golang:1.20 AS builder ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct WORKDIR /openim/openim-server diff --git a/build/images/openim-rpc-group/Dockerfile b/build/images/openim-rpc-group/Dockerfile index 85ba3b74d..916c8e848 100644 --- a/build/images/openim-rpc-group/Dockerfile +++ b/build/images/openim-rpc-group/Dockerfile @@ -19,7 +19,7 @@ FROM golang:1.20 AS builder ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct WORKDIR /openim/openim-server diff --git a/build/images/openim-rpc-msg/Dockerfile b/build/images/openim-rpc-msg/Dockerfile index 7e1aaf50b..a0ac98c47 100644 --- a/build/images/openim-rpc-msg/Dockerfile +++ b/build/images/openim-rpc-msg/Dockerfile @@ -19,7 +19,7 @@ FROM golang:1.20 AS builder ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct WORKDIR /openim/openim-server diff --git a/build/images/openim-rpc-third/Dockerfile b/build/images/openim-rpc-third/Dockerfile index ab3e6c949..9fe17dd40 100644 --- a/build/images/openim-rpc-third/Dockerfile +++ b/build/images/openim-rpc-third/Dockerfile @@ -19,7 +19,7 @@ FROM golang:1.20 AS builder ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct WORKDIR /openim/openim-server diff --git a/build/images/openim-rpc-user/Dockerfile b/build/images/openim-rpc-user/Dockerfile index cd0121b7d..bdd0a42ee 100644 --- a/build/images/openim-rpc-user/Dockerfile +++ b/build/images/openim-rpc-user/Dockerfile @@ -19,7 +19,7 @@ FROM golang:1.20 AS builder ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct WORKDIR /openim/openim-server diff --git a/build/images/openim-tools/component/Dockerfile b/build/images/openim-tools/component/Dockerfile index 1be6e776f..1f7a1a46a 100644 --- a/build/images/openim-tools/component/Dockerfile +++ b/build/images/openim-tools/component/Dockerfile @@ -19,7 +19,7 @@ FROM golang:1.20 AS builder ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct WORKDIR /openim/openim-server diff --git a/build/images/openim-tools/openim-web/Dockerfile b/build/images/openim-tools/openim-web/Dockerfile index 77ca4cf49..d14501189 100644 --- a/build/images/openim-tools/openim-web/Dockerfile +++ b/build/images/openim-tools/openim-web/Dockerfile @@ -19,7 +19,7 @@ FROM golang:1.20 AS builder ARG GO111MODULE=on -ARG GOPROXY=https://goproxy.cn,direct +ARG GOPROXY=https://goproxy.io,direct WORKDIR /openim/openim-server diff --git a/config/templates/env.template b/config/templates/env.template index b4f9c868d..7a095b2bb 100644 --- a/config/templates/env.template +++ b/config/templates/env.template @@ -118,6 +118,7 @@ MONGO_OPENIM_PASSWORD=openIM123 # Default: MONGO_DATABASE=openim_v3 MONGO_DATABASE=openim_v3 +MONGO_MAX_POOL_SIZE=100 # ----- Redis Configuration ----- # Port on which Redis in-memory data structure store is running. diff --git a/deployments/templates/config.yaml b/deployments/templates/config.yaml index 0aa6e68d6..5da6d5d0b 100644 --- a/deployments/templates/config.yaml +++ b/deployments/templates/config.yaml @@ -535,3 +535,39 @@ prometheus: rtcPrometheusPort: [ ${RTC_PROM_PORT} ] thirdPrometheusPort: [ ${THIRD_PROM_PORT} ] messageTransferPrometheusPort: [ ${MSG_TRANSFER_PROM_PORT} ] # List of ports + +###################### LocalCache configuration information ###################### +# topic: redis subscriber channel +# slotNum: number of slots, multiple slots can prevent too many keys from competing for a lock +# slotSize: number of slots, the number of cached keys per slot, the overall cache quantity is slotNum * slotSize +# successExpire: successful cache time seconds +# failedExpire: failed cache time seconds +# disable local caching and annotate topic, slotNum, and slotSize +localCache: + user: + topic: DELETE_CACHE_USER + slotNum: 100 + slotSize: 2000 + successExpire: 300 + failedExpire: 5 + + group: + topic: DELETE_CACHE_GROUP + slotNum: 100 + slotSize: 2000 + successExpire: 300 + failedExpire: 5 + + friend: + topic: DELETE_CACHE_FRIEND + slotNum: 100 + slotSize: 2000 + successExpire: 300 + failedExpire: 5 + + conversation: + topic: DELETE_CACHE_CONVERSATION + slotNum: 100 + slotSize: 2000 + successExpire: 300 + failedExpire: 5 \ No newline at end of file diff --git a/deployments/templates/env-template.yaml b/deployments/templates/env-template.yaml index 1044dd6bc..85619b422 100644 --- a/deployments/templates/env-template.yaml +++ b/deployments/templates/env-template.yaml @@ -118,6 +118,7 @@ MONGO_OPENIM_PASSWORD=${MONGO_OPENIM_PASSWORD} # Default: MONGO_DATABASE=openim_v3 MONGO_DATABASE=${MONGO_DATABASE} +MONGO_MAX_POOL_SIZE=${MONGO_MAX_POOL_SIZE} # ----- Redis Configuration ----- # Port on which Redis in-memory data structure store is running. diff --git a/docs/contrib/bash-log.md b/docs/contrib/bash-log.md index 7725d5589..f8b319f6c 100644 --- a/docs/contrib/bash-log.md +++ b/docs/contrib/bash-log.md @@ -2,6 +2,8 @@ **PATH:** `scripts/lib/logging.sh` + + ### Introduction OpenIM, an intricate project, requires a robust logging mechanism to diagnose issues, maintain system health, and provide insights. A custom-built logging system embedded within OpenIM ensures consistent and structured logs. Let's delve into the design of this logging system and understand its various functions and their usage scenarios. diff --git a/docs/contrib/go-code.md b/docs/contrib/go-code.md index b122917ca..5c0212725 100644 --- a/docs/contrib/go-code.md +++ b/docs/contrib/go-code.md @@ -266,13 +266,61 @@ errors.New("redis connection failed") - When specifying ranges of numbers, use inclusive ranges whenever possible. - Go 1.13 or above is recommended, and the error generation method is `fmt.Errorf("module xxx: %w", err)`. -### 1.4 panic processing +### 1.4 Panic Processing + +The use of `panic` should be carefully controlled in Go applications to ensure program stability and predictable error handling. Following are revised guidelines emphasizing the restriction on using `panic` and promoting alternative strategies for error handling and program termination. + +- **Prohibited in Business Logic:** Using `panic` within business logic processing is strictly prohibited. Business logic should handle errors gracefully and use error returns to propagate issues up the call stack. + +- **Restricted Use in Main Package:** In the main package, the use of `panic` should be reserved for situations where the program is entirely inoperable, such as failure to open essential files, inability to connect to the database, or other critical startup issues. Even in these scenarios, prefer using structured error handling to terminate the program. + +- **Use `log.Fatal` for Critical Errors:** Instead of panicking, use `log.Fatal` to log critical errors that prevent the program from operating normally. This approach allows the program to terminate while ensuring the error is properly logged for troubleshooting. + +- **Prohibition on Exportable Interfaces:** Exportable interfaces must not invoke `panic`. They should handle errors gracefully and return errors as part of their contract. + +- **Prefer Errors Over Panic:** It is recommended to use error returns instead of panic to convey errors within a package. This approach promotes error handling that integrates smoothly with Go's error handling idioms. + +#### Alternative to Panic: Structured Program Termination + +To enforce these guidelines, consider implementing structured functions to terminate the program gracefully in the face of unrecoverable errors, while providing clear error messages. Here are two recommended functions: + +```go +// ExitWithError logs an error message and exits the program with a non-zero status. +func ExitWithError(err error) { + progName := filepath.Base(os.Args[0]) + fmt.Fprintf(os.Stderr, "%s exit -1: %+v\n", progName, err) + os.Exit(-1) +} + +// SIGTERMExit logs a warning message when the program receives a SIGTERM signal and exits with status 0. +func SIGTERMExit() { + progName := filepath.Base(os.Args[0]) + fmt.Fprintf(os.Stderr, "Warning %s receive process terminal SIGTERM exit 0\n", progName) +} +``` + +#### Example Usage: + +```go +import ( + _ "net/http/pprof" + + "github.com/openimsdk/open-im-server/v3/pkg/common/cmd" + util "github.com/openimsdk/open-im-server/v3/pkg/util/genutil" +) + +func main() { + apiCmd := cmd.NewApiCmd() + apiCmd.AddPortFlag() + apiCmd.AddPrometheusPortFlag() + if err := apiCmd.Execute(); err != nil { + util.ExitWithError(err) + } +} +``` + +In this example, `ExitWithError` is used to terminate the program when an unrecoverable error occurs, providing a clear error message to stderr and exiting with a non-zero status. This approach ensures that critical errors are logged and the program exits in a controlled manner, facilitating troubleshooting and maintaining the stability of the application. -- Panic is prohibited in business logic processing. -- In the main package, panic is only used when the program is completely inoperable, for example, the file cannot be opened, the database cannot be connected, and the program cannot run normally. -- In the main package, use `log.Fatal` to record errors, so that the program can be terminated by the log, or the exception thrown by the panic can be recorded in the log file, which is convenient for troubleshooting. -- An exportable interface must not panic. -- It is recommended to use error instead of panic to convey errors in the package. ### 1.5 Unit Tests @@ -439,10 +487,15 @@ var allowGitHook bool - Local variables should be as short as possible, for example, use buf to refer to buffer, and use i to refer to index. - The code automatically generated by the code generation tool can exclude this rule (such as the Id in `xxx.pb.go`) -### 2.7 Constant naming +### 2.7 Constant Naming + +In Go, constants play a critical role in defining values that do not change throughout the execution of a program. Adhering to best practices in naming constants can significantly improve the readability and maintainability of your code. Here are some guidelines for constant naming: -- The constant name must follow the camel case, and the initial letter is uppercase or lowercase according to the access control decision. -- If it is a constant of enumeration type, you need to create the corresponding type first: +- **Camel Case Naming:** The name of a constant must follow the camel case notation. The initial letter should be uppercase or lowercase based on the access control requirements. Uppercase indicates that the constant is exported (visible outside the package), while lowercase indicates package-private visibility (visible only within its own package). + +- **Enumeration Type Constants:** For constants that represent a set of enumerated values, it's recommended to define a corresponding type first. This approach not only enhances type safety but also improves code readability by clearly indicating the purpose of the enumeration. + +**Example:** ```go // Code defines an error code type. @@ -452,11 +505,40 @@ type Code int const ( // ErrUnknown - 0: An unknown error occurred. ErrUnknown Code = iota - // ErrFatal - 1: An fatal error occurred. + // ErrFatal - 1: A fatal error occurred. ErrFatal ) ``` +In the example above, `Code` is defined as a new type based on `int`. The enumerated constants `ErrUnknown` and `ErrFatal` are then defined with explicit comments to indicate their purpose and values. This pattern is particularly useful for grouping related constants and providing additional context. + +### Global Variables and Constants Across Packages + +- **Use Constants for Global Variables:** When defining variables that are intended to be accessed across packages, prefer using constants to ensure immutability. This practice avoids unintended modifications to the value, which can lead to unpredictable behavior or hard-to-track bugs. + +- **Lowercase for Package-Private Usage:** If a global variable or constant is intended for use only within its own package, it should start with a lowercase letter. This clearly signals its limited scope of visibility, adhering to Go's access control mechanism based on naming conventions. + +**Guideline:** + +- For global constants that need to be accessed across packages, declare them with an uppercase initial letter. This makes them exported, adhering to Go's visibility rules. +- For constants used within the same package, start their names with a lowercase letter to limit their scope to the package. + +**Example:** + +```go +package config + +// MaxConnections - the maximum number of allowed connections. Visible across packages. +const MaxConnections int = 100 + +// minIdleTime - the minimum idle time before a connection is considered stale. Only visible within the config package. +const minIdleTime int = 30 +``` + +In this example, `MaxConnections` is a global constant meant to be accessed across packages, hence it starts with an uppercase letter. On the other hand, `minIdleTime` is intended for use only within the `config` package, so it starts with a lowercase letter. + +Following these guidelines ensures that your Go code is more readable, maintainable, and consistent with Go's design philosophy and access control mechanisms. + ### 2.8 Error naming - The Error type should be written in the form of FooError. @@ -473,6 +555,190 @@ type ExitError struct { var ErrFormat = errors. New("unknown format") ``` +For non-standard Err naming, CICD will report an error + + +### 2.9 Handling Errors Properly + +In Go, proper error handling is crucial for creating reliable and maintainable applications. It's important to ensure that errors are not ignored or discarded, as this can lead to unpredictable behavior and difficult-to-debug issues. Here are the guidelines and examples regarding the proper handling of errors. + +#### Guideline: Do Not Discard Errors + +- **Mandatory Error Propagation:** When calling a function that returns an error, the calling function must handle or propagate the error, instead of ignoring it. This approach ensures that errors are not silently ignored, allowing higher-level logic to make informed decisions about error handling. + +#### Incorrect Example: Discarding an Error + +```go +package main + +import ( + "io/ioutil" + "log" +) + +func ReadFileContent(filename string) string { + content, _ := ioutil.ReadFile(filename) // Incorrect: Error is ignored + return string(content) +} + +func main() { + content := ReadFileContent("example.txt") + log.Println(content) +} +``` + +In this incorrect example, the error returned by `ioutil.ReadFile` is ignored. This can lead to situations where the program continues execution even if the file doesn't exist or cannot be accessed, potentially causing more cryptic errors downstream. + +#### Correct Example: Propagating an Error + +```go +package main + +import ( + "io/ioutil" + "log" +) + +// ReadFileContent attempts to read and return the content of the specified file. +// It returns an error if reading fails. +func ReadFileContent(filename string) (string, error) { + content, err := ioutil.ReadFile(filename) + if err != nil { + // Correct: Propagate the error + return "", err + } + return string(content), nil +} + +func main() { + content, err := ReadFileContent("example.txt") + if err != nil { + log.Fatalf("Failed to read file: %v", err) + } + log.Println(content) +} +``` + +In the correct example, the error returned by `ioutil.ReadFile` is propagated back to the caller. The `main` function then checks the error and terminates the program with an appropriate error message if an error occurred. This approach ensures that errors are handled appropriately, and the program does not proceed with invalid state. + +### Best Practices for Error Handling + +1. **Always check the error returned by a function.** Do not ignore it. +2. **Propagate errors up the call stack unless they can be handled gracefully at the current level.** +3. **Provide context for errors when propagating them, making it easier to trace the source of the error.** This can be achieved using `fmt.Errorf` with the `%w` verb or dedicated wrapping functions provided by some error handling packages. +4. **Log the error at the point where it is handled or makes the program to terminate, to provide insight into the failure.** + +By following these guidelines, you ensure that your Go applications handle errors in a consistent and effective manner, improving their reliability and maintainability. + + +### 2.10 Using Context with IO or Inter-Process Communication (IPC) + +In Go, `context.Context` is a powerful construct for managing deadlines, cancellation signals, and other request-scoped values across API boundaries and between processes. It is particularly important in I/O operations or inter-process communication (IPC), where operations might need to be cancelled or timed out. + +#### Guideline: Use Context for IO and IPC + +- **Mandatory Use of Context:** When performing I/O operations or inter-process communication, it's crucial to use `context.Context` to manage the lifecycle of these operations. This includes setting deadlines, handling cancellation signals, and passing request-scoped values. + +#### Incorrect Example: Ignoring Context in an HTTP Call + +```go +package main + +import ( + "io/ioutil" + "net/http" + "log" +) + +// FetchData makes an HTTP GET request to the specified URL and returns the response body. +// This function does not use context, making it impossible to cancel the request or set a deadline. +func FetchData(url string) (string, error) { + resp, err := http.Get(url) // Incorrect: Ignoring context + if err != nil { + return "", err + } + defer resp.Body.Close() + + body, err := ioutil.ReadAll(resp.Body) + if err != nil { + return "", err + } + + return string(body), nil +} + +func main() { + data, err := FetchData("http://example.com") + if err != nil { + log.Fatalf("Failed to fetch data: %v", err) + } + log.Println(data) +} +``` + +In this incorrect example, the `FetchData` function makes an HTTP GET request without using a `context`. This approach does not allow the request to be cancelled or a timeout to be set, potentially leading to resources being wasted if the server takes too long to respond or if the operation needs to be aborted for any reason. + +#### Correct Example: Using Context in an HTTP Call + +```go +package main + +import ( + "context" + "io/ioutil" + "net/http" + "log" + "time" +) + +// FetchDataWithContext makes an HTTP GET request to the specified URL using the provided context. +// This allows the request to be cancelled or timed out according to the context's deadline. +func FetchDataWithContext(ctx context.Context, url string) (string, error) { + req, err := http.NewRequestWithContext(ctx, "GET", url, nil) + if err != nil { + return "", err + } + + resp, err := http.DefaultClient.Do(req) + if err != nil { + return "", err + } + defer resp.Body.Close() + + body, err := ioutil.ReadAll(resp.Body) + if err != nil { + return "", err + } + + return string(body), nil +} + +func main() { + // Create a context with a 5-second timeout + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + data, err := FetchDataWithContext(ctx, "http://example.com") + if err != nil { + log.Fatalf("Failed to fetch data: %v", err) + } + log.Println(data) +} +``` + +In the correct example, `FetchDataWithContext` uses a context to make the HTTP GET request. This allows the operation to be cancelled or subjected to a timeout, as dictated by the context passed to it. The `context.WithTimeout` function is used in `main` to create a context that cancels the request if it takes longer than 5 seconds, demonstrating a practical use of context to manage operation lifecycle. + +### Best Practices for Using Context + +1. **Pass context as the first parameter of a function**, following the convention `func(ctx context.Context, ...)`. +2. **Never ignore the context** provided to you in functions that support it. Always use it in your I/O or IPC operations. +3. **Avoid storing context in a struct**. Contexts are meant to be passed around within the call stack, not stored. +4. **Use context's cancellation and deadline features** to control the lifecycle of blocking operations, especially in network I/O and IPC scenarios. +5. **Propagate context down the call stack** to any function that supports it, ensuring that your application can respond to cancellation signals and deadlines effectively. + +By adhering to these guidelines and examples, you can ensure that your Go applications handle I/O and IPC operations more reliably and efficiently, with proper support for cancellation, timeouts, and request-scoped values. + + ## 3. Comment specification - Each exportable name must have a comment, which briefly introduces the exported variables, functions, structures, interfaces, etc. diff --git a/docs/contrib/logging.md b/docs/contrib/logging.md index fd9e883ef..e4774929c 100644 --- a/docs/contrib/logging.md +++ b/docs/contrib/logging.md @@ -1,20 +1,386 @@ -## Log Standards - -### Log Standards - -- The unified log package `github.com/openimsdk/open-im-server/internal/pkg/log` should be used for all logging; -- Use structured logging formats: `log.Infow`, `log.Warnw`, `log.Errorw`, etc. For example: `log.Infow("Update post function called")`; -- All logs should start with an uppercase letter and should not end with a `.`. For example: `log.Infow("Update post function called")`; -- Use past tense. For example, use `Could not delete B` instead of `Cannot delete B`; -- Adhere to log level standards: - - Debug level logs use `log.Debugw`; - - Info level logs use `log.Infow`; - - Warning level logs use `log.Warnw`; - - Error level logs use `log.Errorw`; - - Panic level logs use `log.Panicw`; - - Fatal level logs use `log.Fatalw`. -- Log settings: - - Development and test environments: The log level is set to `debug`, the log format can be set to `console` / `json` as needed, and caller is enabled; - - Production environment: The log level is set to `info`, the log format is set to `json`, and caller is enabled. (**Note**: In the early stages of going online, to facilitate troubleshooting, the log level can be set to `debug`) -- When logging, avoid outputting sensitive information, such as passwords, keys, etc. -- If you are calling a logging function in a function/method with a `context.Context` parameter, it is recommended to use `log.L(ctx).Infow()` for logging. \ No newline at end of file +# OpenIM Logging and Error Handling Documentation + +## Script Logging Documentation Link + +If you wish to view the script's logging documentation, you can click on this link: [Logging Documentation](https://github.com/OpenIMSDK/Open-IM-Server/blob/main/docs/contrib/bash-log.md). + +Below is the documentation for logging and error handling in the OpenIM Go project. + +To create a standard set of documentation that is quick to read and easy to understand, we will highlight key information about the `Logger` interface and the `CodeError` interface. This includes the purpose of each interface, key methods, and their use cases. This will help developers quickly grasp how to effectively use logging and error handling within the project. + +## Logging (`Logger` Interface) + +### Purpose +The `Logger` interface aims to provide the OpenIM project with a unified and flexible logging mechanism, supporting structured logging formats for efficient log management and analysis. + +### Key Methods + +- **Debug, Info, Warn, Error** + Log messages of different levels to suit various logging needs and scenarios. These methods accept a context (`context.Context`), a message (`string`), and key-value pairs (`...interface{}`), allowing the log to carry rich context information. + +- **WithValues** + Append key-value pair information to log messages, returning a new `Logger` instance. This helps in adding consistent context information. + +- **WithName** + Set the name of the logger, which helps in identifying the source of the logs. + +- **WithCallDepth** + Adjust the call stack depth to accurately identify the source of the log message. + +### Use Cases + +- Developers should choose the appropriate logging level (such as `Debug`, `Info`, `Warn`, `Error`) based on the importance of the information when logging. +- Use `WithValues` and `WithName` to add richer context information to logs, facilitating subsequent tracking and analysis. + +## Error Handling (`CodeError` Interface) + +### Purpose +The `CodeError` interface is designed to provide a unified mechanism for error handling and wrapping, making error information more detailed and manageable. + +### Key Methods + +- **Code** + Return the error code to distinguish between different types of errors. + +- **Msg** + Return the error message description to display to the user. + +- **Detail** + Return detailed information about the error for further debugging by developers. + +- **WithDetail** + Add detailed information to the error, returning a new `CodeError` instance. + +- **Is** + Determine whether the current error matches a specified error, supporting a flexible error comparison mechanism. + +- **Wrap** + Wrap another error with additional message description, facilitating the tracing of the error's cause. + +### Use Cases + +- When defining errors with specific codes and messages, use error types that implement the `CodeError` interface. +- Use `WithDetail` to add additional context information to errors for more accurate problem localization. +- Use the `Is` method to judge the type of error for conditional branching. +- Use the `Wrap` method to wrap underlying errors while adding more contextual descriptions. + +## Logging Standards and Code Examples + +In the OpenIM project, we use the unified logging package `github.com/OpenIMSDK/tools/log` for logging to achieve efficient log management and analysis. This logging package supports structured logging formats, making it easier for developers to handle log information. + +### Logger Interface and Implementation + +The logger interface is defined as follows: + +```go +type Logger interface { + Debug(ctx context.Context, msg string, keysAndValues ...interface{}) + Info(ctx context.Context, msg string, keysAndValues ...interface{}) + Warn(ctx context.Context, msg string, err error, keysAndValues ...interface{}) + Error(ctx context.Context, msg string, err error, keysAndValues ...interface{}) + WithValues(keysAndValues ...interface{}) Logger + WithName(name string) Logger + WithCallDepth(depth int) Logger +} +``` + +Example code: Using the `Logger` interface to log at the info level. + +```go +func main() { + logger := log.NewLogger().WithName("MyService") + ctx := context.Background() + logger.Info(ctx, "Service started", "port", "8080") +} +``` + +## Error Handling and Code Examples + +We use the `github.com/OpenIMSDK/tools/errs` package for unified error handling and wrapping. + +### CodeError Interface and Implementation + +The error interface is defined as follows: + +```go +type CodeError interface { + Code() int + Msg() string + Detail() string + WithDetail(detail string) CodeError + Is(err error, loose ...bool) bool + Wrap(msg ...string) error + error +} +``` + +Example code: Creating and using the `CodeError` interface to handle errors. + +```go +package main + +import ( + "fmt" + "github.com/OpenIMSDK/tools/errs" +) + +func main() { + err := errs.New(404, "Resource not found") + err = err.WithDetail(" + +More details") + if e, ok := err.(errs.CodeError); ok { + fmt.Println(e.Code(), e.Msg(), e.Detail()) + } +} +``` + +### Detailed Logging Standards and Code Examples + +1. **Print key information at startup** + It is crucial to print entry parameters and key process information at program startup. This helps understand the startup state and configuration of the program. + + **Code Example**: + ```go + package main + + import ( + "fmt" + "os" + ) + + func main() { + fmt.Println("Program startup, version: 1.0.0") + fmt.Printf("Connecting to database: %s\n", os.Getenv("DATABASE_URL")) + } + ``` + +2. **Use `tools/log` and `fmt` for logging** + Logging should be done using a specialized logging library for unified management and formatted log output. + + **Code Example**: Logging an info level message with `tools/log`. + ```go + package main + + import ( + "context" + "github.com/OpenIMSDK/tools/log" + ) + + func main() { + ctx := context.Background() + log.Info(ctx, "Application started successfully") + } + ``` + +3. **Use standard error output for startup failures or critical information** + Critical error messages or program startup failures should be indicated to the user through standard error output. + + **Code Example**: + ```go + package main + + import ( + "fmt" + "os" + ) + + func checkEnvironment() bool { + return os.Getenv("REQUIRED_ENV") != "" + } + + func main() { + if !checkEnvironment() { + fmt.Fprintln(os.Stderr, "Missing required environment variable") + os.Exit(1) + } + } + ``` + + We encapsulate it into separate tools, which can output error information through the `tools/log` package. + + ```go + package main + + import ( + util "github.com/openimsdk/open-im-server/v3/pkg/util/genutil" + ) + + func main() { + if err := apiCmd.Execute(); err != nil { + util.ExitWithError(err) + } + } + ``` + +4. **Use `tools/log` package for runtime logging** + This ensures consistency and control over logging. + + **Code Example**: Same as the above example using `tools/log`. When `tools/log` is not initialized, consider using `fmt` for standard output. + +5. **Error logs should be printed by the top-level caller** + This is to avoid duplicate logging of errors, typically errors are caught and logged at the application's outermost level. + + **Code Example**: + ```go + package main + + import ( + "github.com/OpenIMSDK/tools/log" + "context" + ) + + func doSomething() error { + // An error occurs here + return errs.Wrap(errors.New("An error occurred")) + } + + func controller() error { + err := doSomething() + if err != nil { + return err + } + return nil + } + + func main() { + err := controller() + if err != nil { + log.Error(context.Background(), "Operation failed", err) + } + } + ``` + +6. **Handling logs for API RPC calls and non-RPC applications** + + For API RPC calls using gRPC, logs at the information level are printed by middleware on the gRPC server side, reducing the need to manually log in each RPC method. For non-RPC applications, it's recommended to manually log key execution paths to track the application's execution flow. + + **gRPC Server-Side Logging Middleware:** + + In gRPC, `UnaryInterceptor` and `StreamInterceptor` can intercept Unary and Stream type RPC calls, respectively. Here's an example of how to implement a simple Unary RPC logging middleware: + + ```go + package main + + import ( + "context" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + "log" + "time" + ) + + // unaryServerInterceptor returns a new unary server interceptor that logs each request. + func unaryServerInterceptor() grpc.UnaryServerInterceptor { + return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) { + // Record the start time of the request + start := time.Now() + // Call the actual RPC method + resp, err = handler(ctx, req) + // After the request ends, log the duration and other information + log.Printf("Request method: %s, duration: %s, error status: %v", info.FullMethod, time.Since(start), status.Code(err)) + return resp, err + } + } + + func main() { + // Create a gRPC server and add the middleware + s := grpc.NewServer + +(grpc.UnaryInterceptor(unaryServerInterceptor())) + // Register your service + + // Start the gRPC server + log.Println("Starting gRPC server...") + // ... + } + ``` + + **Logging for Non-RPC Applications:** + + For non-RPC applications, the key is to log at appropriate places in the code to maintain an execution trace. Here's a simple example showing how to log when handling a task: + + ```go + package main + + import ( + "log" + ) + + func processTask(taskID string) { + // Log the start of task processing + log.Printf("Starting task processing: %s", taskID) + // Suppose this is where the task is processed + + // Log after the task is completed + log.Printf("Task processing completed: %s", taskID) + } + + func main() { + // Example task ID + taskID := "task123" + processTask(taskID) + } + ``` + + In both scenarios, appropriate logging can help developers and operators monitor the health of the system, trace the source of issues, and quickly locate and resolve problems. For gRPC logging, using middleware can effectively centralize log management and control. For non-RPC applications, ensuring logs are placed at critical execution points can help understand the program's operational flow and state changes. + +### When to Wrap Errors? + +1. **Wrap errors generated within the function** + When an error occurs within a function, use `errs.Wrap` to add context information to the original error. + + **Code Example**: + ```go + func doSomething() error { + // Suppose an error occurs here + err, _ := someFunc() + if err != nil { + return errs.Wrap(err, "doSomething failed") + } + } + ``` + +2. **Wrap errors from system calls or other packages** + When calling external libraries or system functions that return errors, also add context information to wrap the error. + + **Code Example**: + ```go + func readConfig(file string) error { + _, err := os.ReadFile(file) + if err != nil { + return errs.Wrap(err, "Failed to read config file") + } + return nil + } + ``` + +3. **No need to re-wrap errors for internal module calls** + + If an error has been appropriately wrapped with sufficient context information in an internal module call, there's no need to wrap it again. + + **Code Example**: + ```go + func doSomething() error { + err := doAnotherThing() + if err != nil { + return err + } + return nil + } + ``` + +4. **Ensure comprehensive wrapping of errors with detailed messages** + When wrapping errors, ensure to provide ample context information to make the error more understandable and easier to debug. + + **Code Example**: + ```go + func connectDatabase() error { + err := db.Connect(config.DatabaseURL) + if err != nil { + return errs.Wrap(err, fmt.Sprintf("Failed to connect to database, URL: %s", config.DatabaseURL)) + } + return nil + } + ``` \ No newline at end of file diff --git a/go.mod b/go.mod index 38443ba5a..da2815571 100644 --- a/go.mod +++ b/go.mod @@ -4,7 +4,7 @@ go 1.19 require ( firebase.google.com/go v3.13.0+incompatible - github.com/OpenIMSDK/protocol v0.0.55 + github.com/OpenIMSDK/protocol v0.0.56 github.com/OpenIMSDK/tools v0.0.37 github.com/bwmarrin/snowflake v0.3.0 // indirect github.com/dtm-labs/rockscache v0.1.1 @@ -18,6 +18,7 @@ require ( github.com/minio/minio-go/v7 v7.0.67 github.com/mitchellh/mapstructure v1.5.0 github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 // indirect + github.com/openimsdk/localcache v0.0.1 github.com/pkg/errors v0.9.1 // indirect github.com/prometheus/client_golang v1.18.0 github.com/robfig/cron/v3 v3.0.1 @@ -84,6 +85,7 @@ require ( github.com/hashicorp/errwrap v1.0.0 // indirect github.com/hashicorp/go-multierror v1.1.1 // indirect github.com/hashicorp/go-uuid v1.0.3 // indirect + github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect github.com/jcmturner/aescts/v2 v2.0.0 // indirect @@ -162,3 +164,5 @@ require ( golang.org/x/crypto v0.19.0 // indirect gopkg.in/ini.v1 v1.67.0 // indirect ) + +replace github.com/openimsdk/localcache => ./pkg/localcache diff --git a/go.sum b/go.sum index aa41279af..c3803ef58 100644 --- a/go.sum +++ b/go.sum @@ -18,8 +18,8 @@ firebase.google.com/go v3.13.0+incompatible/go.mod h1:xlah6XbEyW6tbfSklcfe5FHJIw github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/IBM/sarama v1.42.2 h1:VoY4hVIZ+WQJ8G9KNY/SQlWguBQXQ9uvFPOnrcu8hEw= github.com/IBM/sarama v1.42.2/go.mod h1:FLPGUGwYqEs62hq2bVG6Io2+5n+pS6s/WOXVKWSLFtE= -github.com/OpenIMSDK/protocol v0.0.55 h1:eBjg8DyuhxGmuCUjpoZjg6MJJJXU/xJ3xJwFhrn34yA= -github.com/OpenIMSDK/protocol v0.0.55/go.mod h1:F25dFrwrIx3lkNoiuf6FkCfxuwf8L4Z8UIsdTHP/r0Y= +github.com/OpenIMSDK/protocol v0.0.56 h1:mbVFyDBachEsmJLfYW5AU1z2KL8AUEpoHG8RPCIxjgg= +github.com/OpenIMSDK/protocol v0.0.56/go.mod h1:F25dFrwrIx3lkNoiuf6FkCfxuwf8L4Z8UIsdTHP/r0Y= github.com/OpenIMSDK/tools v0.0.37 h1:qvDqmA4RbEJtPjZouWCkVuf/pjm6Y8nUrG5iH2gcnOg= github.com/OpenIMSDK/tools v0.0.37/go.mod h1:wBfR5CYmEyvxl03QJbTkhz1CluK6J4/lX0lviu8JAjE= github.com/QcloudApi/qcloud_sign_golang v0.0.0-20141224014652-e4130a326409/go.mod h1:1pk82RBxDY/JZnPQrtqHlUFfCctgdorsd9M06fMynOM= @@ -178,6 +178,8 @@ github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9 github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= github.com/hashicorp/go-uuid v1.0.3 h1:2gKiV6YVmrJ1i2CKKa9obLvRieoRGviZFL26PcT/Co8= github.com/hashicorp/go-uuid v1.0.3/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= +github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= +github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= diff --git a/go.work b/go.work index be67ce842..8dc91a631 100644 --- a/go.work +++ b/go.work @@ -6,13 +6,11 @@ use ( ./tools/codescan ./tools/changelog ./tools/component - ./tools/data-conversion ./tools/formitychecker ./tools/imctl ./tools/infra ./tools/ncpu ./tools/openim-web - ./tools/up35 ./tools/url2im ./tools/versionchecker ./tools/yamlfmt diff --git a/internal/api/route.go b/internal/api/route.go index 92fa83fb0..ca0b6829e 100644 --- a/internal/api/route.go +++ b/internal/api/route.go @@ -50,7 +50,6 @@ import ( ) func Start(config *config.GlobalConfig, port int, proPort int) error { - log.ZDebug(context.Background(), "configAPI1111111111111111111", config, "port", port, "javafdasfs") if port == 0 || proPort == 0 { err := "port or proPort is empty:" + strconv.Itoa(port) + "," + strconv.Itoa(proPort) return errs.Wrap(fmt.Errorf(err)) diff --git a/internal/msggateway/callback.go b/internal/msggateway/callback.go index ab8c1f51f..afb83bcc4 100644 --- a/internal/msggateway/callback.go +++ b/internal/msggateway/callback.go @@ -100,7 +100,7 @@ func CallbackUserKickOff(ctx context.Context, globalConfig *config.GlobalConfig, // func callbackUserOnline(operationID, userID string, platformID int, token string, isAppBackground bool, connID // string) cbApi.CommonCallbackResp { // callbackResp := cbApi.CommonCallbackResp{OperationID: operationID} -// if !config.Config.Callback.CallbackUserOnline.Enable { +// if !config.Config.Callback.CallbackUserOnline.WithEnable { // return callbackResp // } // callbackUserOnlineReq := cbApi.CallbackUserOnlineReq{ @@ -129,7 +129,7 @@ func CallbackUserKickOff(ctx context.Context, globalConfig *config.GlobalConfig, //} //func callbackUserOffline(operationID, userID string, platformID int, connID string) cbApi.CommonCallbackResp { // callbackResp := cbApi.CommonCallbackResp{OperationID: operationID} -// if !config.Config.Callback.CallbackUserOffline.Enable { +// if !config.Config.Callback.CallbackUserOffline.WithEnable { // return callbackResp // } // callbackOfflineReq := cbApi.CallbackUserOfflineReq{ @@ -156,7 +156,7 @@ func CallbackUserKickOff(ctx context.Context, globalConfig *config.GlobalConfig, //} //func callbackUserKickOff(operationID string, userID string, platformID int) cbApi.CommonCallbackResp { // callbackResp := cbApi.CommonCallbackResp{OperationID: operationID} -// if !config.Config.Callback.CallbackUserKickOff.Enable { +// if !config.Config.Callback.CallbackUserKickOff.WithEnable { // return callbackResp // } // callbackUserKickOffReq := cbApi.CallbackUserKickOffReq{ diff --git a/internal/msggateway/hub_server.go b/internal/msggateway/hub_server.go index 739c4232f..146565561 100644 --- a/internal/msggateway/hub_server.go +++ b/internal/msggateway/hub_server.go @@ -23,7 +23,6 @@ import ( "github.com/OpenIMSDK/tools/errs" "github.com/OpenIMSDK/tools/log" "github.com/OpenIMSDK/tools/mcontext" - "github.com/OpenIMSDK/tools/utils" "github.com/openimsdk/open-im-server/v3/pkg/authverify" "github.com/openimsdk/open-im-server/v3/pkg/common/config" "github.com/openimsdk/open-im-server/v3/pkg/common/db/cache" @@ -58,22 +57,25 @@ type Server struct { rpcPort int prometheusPort int LongConnServer LongConnServer - pushTerminal []int config *config.GlobalConfig + pushTerminal map[int]struct{} } func (s *Server) SetLongConnServer(LongConnServer LongConnServer) { s.LongConnServer = LongConnServer } -func NewServer(rpcPort int, proPort int, longConnServer LongConnServer, config *config.GlobalConfig) *Server { - return &Server{ +func NewServer(rpcPort int, proPort int, longConnServer LongConnServer, conf *config.GlobalConfig) *Server { + s := &Server{ rpcPort: rpcPort, prometheusPort: proPort, LongConnServer: longConnServer, - pushTerminal: []int{constant.IOSPlatformID, constant.AndroidPlatformID}, - config: config, + pushTerminal: make(map[int]struct{}), + config: conf, } + s.pushTerminal[constant.IOSPlatformID] = struct{}{} + s.pushTerminal[constant.AndroidPlatformID] = struct{}{} + return s } func (s *Server) OnlinePushMsg( @@ -127,13 +129,9 @@ func (s *Server) OnlineBatchPushOneMsg( panic("implement me") } -func (s *Server) SuperGroupOnlineBatchPushOneMsg( - ctx context.Context, - req *msggateway.OnlineBatchPushOneMsgReq, +func (s *Server) SuperGroupOnlineBatchPushOneMsg(ctx context.Context, req *msggateway.OnlineBatchPushOneMsgReq, ) (*msggateway.OnlineBatchPushOneMsgResp, error) { - var singleUserResults []*msggateway.SingleMsgToUserResults - for _, v := range req.PushToUserIDs { var resp []*msggateway.SingleMsgToUserPlatform results := &msggateway.SingleMsgToUserResults{ @@ -154,23 +152,22 @@ func (s *Server) SuperGroupOnlineBatchPushOneMsg( } userPlatform := &msggateway.SingleMsgToUserPlatform{ - RecvID: v, RecvPlatFormID: int32(client.PlatformID), } if !client.IsBackground || (client.IsBackground && client.PlatformID != constant.IOSPlatformID) { err := client.PushMessage(ctx, req.MsgData) if err != nil { - userPlatform.ResultCode = -2 + userPlatform.ResultCode = int64(errs.ErrPushMsgErr.Code()) resp = append(resp, userPlatform) } else { - if utils.IsContainInt(client.PlatformID, s.pushTerminal) { + if _, ok := s.pushTerminal[client.PlatformID]; ok { results.OnlinePush = true resp = append(resp, userPlatform) } } } else { - userPlatform.ResultCode = -3 + userPlatform.ResultCode = int64(errs.ErrIOSBackgroundPushErr.Code()) resp = append(resp, userPlatform) } } diff --git a/internal/push/push_rpc_server.go b/internal/push/push_rpc_server.go index 2d2f95336..a8bb18974 100644 --- a/internal/push/push_rpc_server.go +++ b/internal/push/push_rpc_server.go @@ -25,7 +25,7 @@ import ( "github.com/openimsdk/open-im-server/v3/pkg/common/config" "github.com/openimsdk/open-im-server/v3/pkg/common/db/cache" "github.com/openimsdk/open-im-server/v3/pkg/common/db/controller" - "github.com/openimsdk/open-im-server/v3/pkg/common/db/localcache" + "github.com/openimsdk/open-im-server/v3/pkg/rpccache" "github.com/openimsdk/open-im-server/v3/pkg/rpcclient" "google.golang.org/grpc" ) @@ -51,8 +51,8 @@ func Start(config *config.GlobalConfig, client discoveryregistry.SvcDiscoveryReg client, offlinePusher, database, - localcache.NewGroupLocalCache(&groupRpcClient), - localcache.NewConversationLocalCache(&conversationRpcClient), + rpccache.NewGroupLocalCache(groupRpcClient, rdb), + rpccache.NewConversationLocalCache(conversationRpcClient, rdb), &conversationRpcClient, &groupRpcClient, &msgRpcClient, diff --git a/internal/push/push_to_client.go b/internal/push/push_to_client.go index 49bce70ab..d7f30ebce 100644 --- a/internal/push/push_to_client.go +++ b/internal/push/push_to_client.go @@ -36,9 +36,9 @@ import ( "github.com/openimsdk/open-im-server/v3/pkg/common/config" "github.com/openimsdk/open-im-server/v3/pkg/common/db/cache" "github.com/openimsdk/open-im-server/v3/pkg/common/db/controller" - "github.com/openimsdk/open-im-server/v3/pkg/common/db/localcache" "github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics" "github.com/openimsdk/open-im-server/v3/pkg/msgprocessor" + "github.com/openimsdk/open-im-server/v3/pkg/rpccache" "github.com/openimsdk/open-im-server/v3/pkg/rpcclient" "golang.org/x/sync/errgroup" "google.golang.org/grpc" @@ -49,8 +49,8 @@ type Pusher struct { database controller.PushDatabase discov discoveryregistry.SvcDiscoveryRegistry offlinePusher offlinepush.OfflinePusher - groupLocalCache *localcache.GroupLocalCache - conversationLocalCache *localcache.ConversationLocalCache + groupLocalCache *rpccache.GroupLocalCache + conversationLocalCache *rpccache.ConversationLocalCache msgRpcClient *rpcclient.MessageRpcClient conversationRpcClient *rpcclient.ConversationRpcClient groupRpcClient *rpcclient.GroupRpcClient @@ -59,7 +59,7 @@ type Pusher struct { var errNoOfflinePusher = errors.New("no offlinePusher is configured") func NewPusher(config *config.GlobalConfig, discov discoveryregistry.SvcDiscoveryRegistry, offlinePusher offlinepush.OfflinePusher, database controller.PushDatabase, - groupLocalCache *localcache.GroupLocalCache, conversationLocalCache *localcache.ConversationLocalCache, + groupLocalCache *rpccache.GroupLocalCache, conversationLocalCache *rpccache.ConversationLocalCache, conversationRpcClient *rpcclient.ConversationRpcClient, groupRpcClient *rpcclient.GroupRpcClient, msgRpcClient *rpcclient.MessageRpcClient, ) *Pusher { return &Pusher{ diff --git a/internal/rpc/conversation/conversaion.go b/internal/rpc/conversation/conversaion.go index 15e7998af..91eec079b 100644 --- a/internal/rpc/conversation/conversaion.go +++ b/internal/rpc/conversation/conversaion.go @@ -48,14 +48,6 @@ type conversationServer struct { config *config.GlobalConfig } -func (c *conversationServer) GetConversationNotReceiveMessageUserIDs( - ctx context.Context, - req *pbconversation.GetConversationNotReceiveMessageUserIDsReq, -) (*pbconversation.GetConversationNotReceiveMessageUserIDsResp, error) { - //TODO implement me - panic("implement me") -} - func Start(config *config.GlobalConfig, client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error { rdb, err := cache.NewRedis(config) if err != nil { @@ -96,11 +88,11 @@ func (c *conversationServer) GetConversation(ctx context.Context, req *pbconvers return resp, nil } -func (m *conversationServer) GetSortedConversationList(ctx context.Context, req *pbconversation.GetSortedConversationListReq) (resp *pbconversation.GetSortedConversationListResp, err error) { +func (c *conversationServer) GetSortedConversationList(ctx context.Context, req *pbconversation.GetSortedConversationListReq) (resp *pbconversation.GetSortedConversationListResp, err error) { log.ZDebug(ctx, "GetSortedConversationList", "seqs", req, "userID", req.UserID) var conversationIDs []string if len(req.ConversationIDs) == 0 { - conversationIDs, err = m.conversationDatabase.GetConversationIDs(ctx, req.UserID) + conversationIDs, err = c.conversationDatabase.GetConversationIDs(ctx, req.UserID) if err != nil { return nil, err } @@ -108,7 +100,7 @@ func (m *conversationServer) GetSortedConversationList(ctx context.Context, req conversationIDs = req.ConversationIDs } - conversations, err := m.conversationDatabase.FindConversations(ctx, req.UserID, conversationIDs) + conversations, err := c.conversationDatabase.FindConversations(ctx, req.UserID, conversationIDs) if err != nil { return nil, err } @@ -116,22 +108,22 @@ func (m *conversationServer) GetSortedConversationList(ctx context.Context, req return nil, errs.ErrRecordNotFound.Wrap() } - maxSeqs, err := m.msgRpcClient.GetMaxSeqs(ctx, conversationIDs) + maxSeqs, err := c.msgRpcClient.GetMaxSeqs(ctx, conversationIDs) if err != nil { return nil, err } - chatLogs, err := m.msgRpcClient.GetMsgByConversationIDs(ctx, conversationIDs, maxSeqs) + chatLogs, err := c.msgRpcClient.GetMsgByConversationIDs(ctx, conversationIDs, maxSeqs) if err != nil { return nil, err } - conversationMsg, err := m.getConversationInfo(ctx, chatLogs, req.UserID) + conversationMsg, err := c.getConversationInfo(ctx, chatLogs, req.UserID) if err != nil { return nil, err } - hasReadSeqs, err := m.msgRpcClient.GetHasReadSeqs(ctx, req.UserID, conversationIDs) + hasReadSeqs, err := c.msgRpcClient.GetHasReadSeqs(ctx, req.UserID, conversationIDs) if err != nil { return nil, err } @@ -163,8 +155,8 @@ func (m *conversationServer) GetSortedConversationList(ctx context.Context, req UnreadTotal: unreadTotal, } - m.conversationSort(conversation_isPinTime, resp, conversation_unreadCount, conversationMsg) - m.conversationSort(conversation_notPinTime, resp, conversation_unreadCount, conversationMsg) + c.conversationSort(conversation_isPinTime, resp, conversation_unreadCount, conversationMsg) + c.conversationSort(conversation_notPinTime, resp, conversation_unreadCount, conversationMsg) resp.ConversationElems = utils.Paginate(resp.ConversationElems, int(req.Pagination.GetPageNumber()), int(req.Pagination.GetShowNumber())) return resp, nil @@ -535,3 +527,14 @@ func (c *conversationServer) getConversationInfo( } return conversationMsg, nil } + +func (c *conversationServer) GetConversationNotReceiveMessageUserIDs( + ctx context.Context, + req *pbconversation.GetConversationNotReceiveMessageUserIDsReq, +) (*pbconversation.GetConversationNotReceiveMessageUserIDsResp, error) { + userIDs, err := c.conversationDatabase.GetConversationNotReceiveMessageUserIDs(ctx, req.ConversationID) + if err != nil { + return nil, err + } + return &pbconversation.GetConversationNotReceiveMessageUserIDsResp{UserIDs: userIDs}, nil +} diff --git a/internal/rpc/group/group.go b/internal/rpc/group/group.go index 4be8fab0c..d966bfad8 100644 --- a/internal/rpc/group/group.go +++ b/internal/rpc/group/group.go @@ -1068,6 +1068,7 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbgroup.GetGroupsReq) group []*relationtb.GroupModel err error ) + if req.GroupID != "" { group, err = s.db.FindGroup(ctx, []string{req.GroupID}) resp.Total = uint32(len(group)) @@ -1080,15 +1081,7 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbgroup.GetGroupsReq) return nil, err } - var groups []*relationtb.GroupModel - for _, v := range group { - if v.Status == constant.GroupStatusDismissed { - resp.Total-- - continue - } - groups = append(groups, v) - } - groupIDs := utils.Slice(groups, func(e *relationtb.GroupModel) string { + groupIDs := utils.Slice(group, func(e *relationtb.GroupModel) string { return e.GroupID }) ownerMembers, err := s.db.FindGroupsOwner(ctx, groupIDs) @@ -1102,7 +1095,7 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbgroup.GetGroupsReq) if err != nil { return nil, err } - resp.Groups = utils.Slice(groups, func(group *relationtb.GroupModel) *pbgroup.CMSGroup { + resp.Groups = utils.Slice(group, func(group *relationtb.GroupModel) *pbgroup.CMSGroup { var ( userID string username string diff --git a/internal/rpc/msg/as_read.go b/internal/rpc/msg/as_read.go index f16fdc62f..ef7c72368 100644 --- a/internal/rpc/msg/as_read.go +++ b/internal/rpc/msg/as_read.go @@ -41,7 +41,7 @@ func (m *msgServer) GetConversationsHasReadAndMaxSeq(ctx context.Context, req *m if err != nil { return nil, err } - conversations, err := m.Conversation.GetConversations(ctx, req.UserID, conversationIDs) + conversations, err := m.ConversationLocalCache.GetConversations(ctx, req.UserID, conversationIDs) if err != nil { return nil, err } @@ -104,7 +104,7 @@ func (m *msgServer) MarkMsgsAsRead( if hasReadSeq > maxSeq { return nil, errs.ErrArgs.Wrap("hasReadSeq must not be bigger than maxSeq") } - conversation, err := m.Conversation.GetConversation(ctx, req.UserID, req.ConversationID) + conversation, err := m.ConversationLocalCache.GetConversation(ctx, req.UserID, req.ConversationID) if err != nil { return } @@ -144,7 +144,7 @@ func (m *msgServer) MarkConversationAsRead( ctx context.Context, req *msg.MarkConversationAsReadReq, ) (resp *msg.MarkConversationAsReadResp, err error) { - conversation, err := m.Conversation.GetConversation(ctx, req.UserID, req.ConversationID) + conversation, err := m.ConversationLocalCache.GetConversation(ctx, req.UserID, req.ConversationID) if err != nil { return nil, err } diff --git a/internal/rpc/msg/revoke.go b/internal/rpc/msg/revoke.go index 5ac8804c2..99690b0cc 100644 --- a/internal/rpc/msg/revoke.go +++ b/internal/rpc/msg/revoke.go @@ -44,7 +44,7 @@ func (m *msgServer) RevokeMsg(ctx context.Context, req *msg.RevokeMsgReq) (*msg. if err := authverify.CheckAccessV3(ctx, req.UserID, m.config); err != nil { return nil, err } - user, err := m.User.GetUserInfo(ctx, req.UserID) + user, err := m.UserLocalCache.GetUserInfo(ctx, req.UserID) if err != nil { return nil, err } @@ -70,12 +70,7 @@ func (m *msgServer) RevokeMsg(ctx context.Context, req *msg.RevokeMsgReq) (*msg. } role = user.AppMangerLevel case constant.SuperGroupChatType: - members, err := m.Group.GetGroupMemberInfoMap( - ctx, - msgs[0].GroupID, - utils.Distinct([]string{req.UserID, msgs[0].SendID}), - true, - ) + members, err := m.GroupLocalCache.GetGroupMemberInfoMap(ctx, msgs[0].GroupID, utils.Distinct([]string{req.UserID, msgs[0].SendID})) if err != nil { return nil, err } diff --git a/internal/rpc/msg/send.go b/internal/rpc/msg/send.go index 949a880b9..ea59c40cf 100644 --- a/internal/rpc/msg/send.go +++ b/internal/rpc/msg/send.go @@ -97,7 +97,7 @@ func (m *msgServer) setConversationAtInfo(nctx context.Context, msg *sdkws.MsgDa } tagAll := utils.IsContain(constant.AtAllString, msg.AtUserIDList) if tagAll { - memberUserIDList, err := m.Group.GetGroupMemberIDs(ctx, msg.GroupID) + memberUserIDList, err := m.GroupLocalCache.GetGroupMemberIDs(ctx, msg.GroupID) if err != nil { log.ZWarn(ctx, "GetGroupMemberIDs", err) return @@ -143,6 +143,7 @@ func (m *msgServer) sendMsgNotification( } func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *pbmsg.SendMsgReq) (resp *pbmsg.SendMsgResp, err error) { + log.ZDebug(ctx, "sendMsgSingleChat return") if err := m.messageVerification(ctx, req); err != nil { return nil, err } diff --git a/internal/rpc/msg/server.go b/internal/rpc/msg/server.go index 72e0b065a..f2d735a70 100644 --- a/internal/rpc/msg/server.go +++ b/internal/rpc/msg/server.go @@ -22,8 +22,8 @@ import ( "github.com/openimsdk/open-im-server/v3/pkg/common/config" "github.com/openimsdk/open-im-server/v3/pkg/common/db/cache" "github.com/openimsdk/open-im-server/v3/pkg/common/db/controller" - "github.com/openimsdk/open-im-server/v3/pkg/common/db/localcache" "github.com/openimsdk/open-im-server/v3/pkg/common/db/unrelation" + "github.com/openimsdk/open-im-server/v3/pkg/rpccache" "github.com/openimsdk/open-im-server/v3/pkg/rpcclient" "google.golang.org/grpc" ) @@ -33,12 +33,11 @@ type ( msgServer struct { RegisterCenter discoveryregistry.SvcDiscoveryRegistry MsgDatabase controller.CommonMsgDatabase - Group *rpcclient.GroupRpcClient - User *rpcclient.UserRpcClient Conversation *rpcclient.ConversationRpcClient - friend *rpcclient.FriendRpcClient - GroupLocalCache *localcache.GroupLocalCache - ConversationLocalCache *localcache.ConversationLocalCache + UserLocalCache *rpccache.UserLocalCache + FriendLocalCache *rpccache.FriendLocalCache + GroupLocalCache *rpccache.GroupLocalCache + ConversationLocalCache *rpccache.ConversationLocalCache Handlers MessageInterceptorChain notificationSender *rpcclient.NotificationSender config *config.GlobalConfig @@ -84,13 +83,12 @@ func Start(config *config.GlobalConfig, client discoveryregistry.SvcDiscoveryReg } s := &msgServer{ Conversation: &conversationClient, - User: &userRpcClient, - Group: &groupRpcClient, MsgDatabase: msgDatabase, RegisterCenter: client, - GroupLocalCache: localcache.NewGroupLocalCache(&groupRpcClient), - ConversationLocalCache: localcache.NewConversationLocalCache(&conversationClient), - friend: &friendRpcClient, + UserLocalCache: rpccache.NewUserLocalCache(userRpcClient, rdb), + GroupLocalCache: rpccache.NewGroupLocalCache(groupRpcClient, rdb), + ConversationLocalCache: rpccache.NewConversationLocalCache(conversationClient, rdb), + FriendLocalCache: rpccache.NewFriendLocalCache(friendRpcClient, rdb), config: config, } s.notificationSender = rpcclient.NewNotificationSender(config, rpcclient.WithLocalSendMsg(s.SendMsg)) diff --git a/internal/rpc/msg/statistics.go b/internal/rpc/msg/statistics.go index d7d33459b..e62954dea 100644 --- a/internal/rpc/msg/statistics.go +++ b/internal/rpc/msg/statistics.go @@ -40,7 +40,7 @@ func (m *msgServer) GetActiveUser(ctx context.Context, req *msg.GetActiveUserReq var pbUsers []*msg.ActiveUser if len(users) > 0 { userIDs := utils.Slice(users, func(e *unrelation.UserCount) string { return e.UserID }) - userMap, err := m.User.GetUsersInfoMap(ctx, userIDs) + userMap, err := m.UserLocalCache.GetUsersInfoMap(ctx, userIDs) if err != nil { return nil, err } @@ -82,7 +82,7 @@ func (m *msgServer) GetActiveGroup(ctx context.Context, req *msg.GetActiveGroupR var pbgroups []*msg.ActiveGroup if len(groups) > 0 { groupIDs := utils.Slice(groups, func(e *unrelation.GroupCount) string { return e.GroupID }) - resp, err := m.Group.GetGroupInfos(ctx, groupIDs, false) + resp, err := m.GroupLocalCache.GetGroupInfos(ctx, groupIDs) if err != nil { return nil, err } diff --git a/internal/rpc/msg/sync_msg.go b/internal/rpc/msg/sync_msg.go index b714da375..379302e98 100644 --- a/internal/rpc/msg/sync_msg.go +++ b/internal/rpc/msg/sync_msg.go @@ -35,7 +35,7 @@ func (m *msgServer) PullMessageBySeqs( resp.NotificationMsgs = make(map[string]*sdkws.PullMsgs) for _, seq := range req.SeqRanges { if !msgprocessor.IsNotification(seq.ConversationID) { - conversation, err := m.Conversation.GetConversation(ctx, req.UserID, seq.ConversationID) + conversation, err := m.ConversationLocalCache.GetConversation(ctx, req.UserID, seq.ConversationID) if err != nil { log.ZError(ctx, "GetConversation error", err, "conversationID", seq.ConversationID) continue @@ -131,14 +131,14 @@ func (m *msgServer) SearchMessage(ctx context.Context, req *msg.SearchMessageReq sendIDs = append(sendIDs, chatLog.SendID) } switch chatLog.SessionType { - case constant.SingleChatType: + case constant.SingleChatType, constant.NotificationChatType: recvIDs = append(recvIDs, chatLog.RecvID) case constant.GroupChatType, constant.SuperGroupChatType: groupIDs = append(groupIDs, chatLog.GroupID) } } if len(sendIDs) != 0 { - sendInfos, err := m.User.GetUsersInfo(ctx, sendIDs) + sendInfos, err := m.UserLocalCache.GetUsersInfo(ctx, sendIDs) if err != nil { return nil, err } @@ -147,7 +147,7 @@ func (m *msgServer) SearchMessage(ctx context.Context, req *msg.SearchMessageReq } } if len(recvIDs) != 0 { - recvInfos, err := m.User.GetUsersInfo(ctx, recvIDs) + recvInfos, err := m.UserLocalCache.GetUsersInfo(ctx, recvIDs) if err != nil { return nil, err } @@ -156,7 +156,7 @@ func (m *msgServer) SearchMessage(ctx context.Context, req *msg.SearchMessageReq } } if len(groupIDs) != 0 { - groupInfos, err := m.Group.GetGroupInfos(ctx, groupIDs, true) + groupInfos, err := m.GroupLocalCache.GetGroupInfos(ctx, groupIDs) if err != nil { return nil, err } @@ -173,7 +173,7 @@ func (m *msgServer) SearchMessage(ctx context.Context, req *msg.SearchMessageReq pbchatLog.SenderNickname = sendMap[chatLog.SendID] } switch chatLog.SessionType { - case constant.SingleChatType: + case constant.SingleChatType, constant.NotificationChatType: pbchatLog.RecvNickname = recvMap[chatLog.RecvID] case constant.GroupChatType, constant.SuperGroupChatType: diff --git a/internal/rpc/msg/verify.go b/internal/rpc/msg/verify.go index d72e4923e..bdaa7fd87 100644 --- a/internal/rpc/msg/verify.go +++ b/internal/rpc/msg/verify.go @@ -24,6 +24,7 @@ import ( "github.com/OpenIMSDK/protocol/msg" "github.com/OpenIMSDK/protocol/sdkws" "github.com/OpenIMSDK/tools/errs" + "github.com/OpenIMSDK/tools/log" "github.com/OpenIMSDK/tools/utils" ) @@ -59,15 +60,15 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe data.MsgData.ContentType >= constant.NotificationBegin { return nil } - black, err := m.friend.IsBlocked(ctx, data.MsgData.SendID, data.MsgData.RecvID) + black, err := m.FriendLocalCache.IsBlack(ctx, data.MsgData.SendID, data.MsgData.RecvID) if err != nil { return err } if black { return errs.ErrBlockedByPeer.Wrap() } - if *m.config.MessageVerify.FriendVerify { - friend, err := m.friend.IsFriend(ctx, data.MsgData.SendID, data.MsgData.RecvID) + if m.config.MessageVerify.FriendVerify != nil && *m.config.MessageVerify.FriendVerify { + friend, err := m.FriendLocalCache.IsFriend(ctx, data.MsgData.SendID, data.MsgData.RecvID) if err != nil { return err } @@ -78,7 +79,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe } return nil case constant.SuperGroupChatType: - groupInfo, err := m.Group.GetGroupInfoCache(ctx, data.MsgData.GroupID) + groupInfo, err := m.GroupLocalCache.GetGroupInfo(ctx, data.MsgData.GroupID) if err != nil { return err } @@ -99,17 +100,17 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe data.MsgData.ContentType >= constant.NotificationBegin { return nil } - // memberIDs, err := m.GroupLocalCache.GetGroupMemberIDs(ctx, data.MsgData.GroupID) - // if err != nil { - // return err - // } - // if !utils.IsContain(data.MsgData.SendID, memberIDs) { - // return errs.ErrNotInGroupYet.Wrap() - // } + memberIDs, err := m.GroupLocalCache.GetGroupMemberIDMap(ctx, data.MsgData.GroupID) + if err != nil { + return err + } + if _, ok := memberIDs[data.MsgData.SendID]; !ok { + return errs.ErrNotInGroupYet.Wrap() + } - groupMemberInfo, err := m.Group.GetGroupMemberCache(ctx, data.MsgData.GroupID, data.MsgData.SendID) + groupMemberInfo, err := m.GroupLocalCache.GetGroupMember(ctx, data.MsgData.GroupID, data.MsgData.SendID) if err != nil { - if err == errs.ErrRecordNotFound { + if errs.ErrRecordNotFound.Is(err) { return errs.ErrNotInGroupYet.Wrap(err.Error()) } return err @@ -157,6 +158,9 @@ func (m *msgServer) encapsulateMsgData(msg *sdkws.MsgData) { case constant.Custom: fallthrough case constant.Quote: + utils.SetSwitchFromOptions(msg.Options, constant.IsConversationUpdate, true) + utils.SetSwitchFromOptions(msg.Options, constant.IsUnreadCount, true) + utils.SetSwitchFromOptions(msg.Options, constant.IsSenderSync, true) case constant.Revoke: utils.SetSwitchFromOptions(msg.Options, constant.IsUnreadCount, false) utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, false) @@ -187,7 +191,8 @@ func (m *msgServer) modifyMessageByUserMessageReceiveOpt( sessionType int, pb *msg.SendMsgReq, ) (bool, error) { - opt, err := m.User.GetUserGlobalMsgRecvOpt(ctx, userID) + defer log.ZDebug(ctx, "modifyMessageByUserMessageReceiveOpt return") + opt, err := m.UserLocalCache.GetUserGlobalMsgRecvOpt(ctx, userID) if err != nil { return false, err } @@ -203,7 +208,7 @@ func (m *msgServer) modifyMessageByUserMessageReceiveOpt( return true, nil } // conversationID := utils.GetConversationIDBySessionType(conversationID, sessionType) - singleOpt, err := m.Conversation.GetSingleConversationRecvMsgOpt(ctx, userID, conversationID) + singleOpt, err := m.ConversationLocalCache.GetSingleConversationRecvMsgOpt(ctx, userID, conversationID) if errs.ErrRecordNotFound.Is(err) { return true, nil } else if err != nil { diff --git a/internal/rpc/third/log.go b/internal/rpc/third/log.go index b425dd819..97428254c 100644 --- a/internal/rpc/third/log.go +++ b/internal/rpc/third/log.go @@ -133,6 +133,13 @@ func (t *thirdServer) SearchLogs(ctx context.Context, req *third.SearchLogsReq) if req.StartTime > req.EndTime { return nil, errs.ErrArgs.Wrap("startTime>endTime") } + if req.StartTime == 0 && req.EndTime == 0 { + t := time.Date(2019, time.January, 1, 0, 0, 0, 0, time.UTC) + timestampMills := t.UnixNano() / int64(time.Millisecond) + req.StartTime = timestampMills + req.EndTime = time.Now().UnixNano() / int64(time.Millisecond) + } + total, logs, err := t.thirdDatabase.SearchLogs(ctx, req.Keyword, time.UnixMilli(req.StartTime), time.UnixMilli(req.EndTime), req.Pagination) if err != nil { return nil, err diff --git a/tools/up35/up35.go b/pkg/common/cachekey/black.go similarity index 61% rename from tools/up35/up35.go rename to pkg/common/cachekey/black.go index 63b6ec2c2..7d2ee2771 100644 --- a/tools/up35/up35.go +++ b/pkg/common/cachekey/black.go @@ -1,4 +1,4 @@ -// Copyright © 2023 OpenIM. All rights reserved. +// Copyright © 2024 OpenIM. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -12,23 +12,18 @@ // See the License for the specific language governing permissions and // limitations under the License. -package main +package cachekey -import ( - "flag" - "log" - "os" - - "github.com/openimsdk/open-im-server/v3/tools/up35/pkg" +const ( + BlackIDsKey = "BLACK_IDS:" + IsBlackKey = "IS_BLACK:" // local cache ) -func main() { - var path string - flag.StringVar(&path, "c", "", "path config file") - flag.Parse() - if err := pkg.Main(path); err != nil { - log.Fatal(err) - return - } - os.Exit(0) +func GetBlackIDsKey(ownerUserID string) string { + return BlackIDsKey + ownerUserID + +} + +func GetIsBlackIDsKey(possibleBlackUserID, userID string) string { + return IsBlackKey + userID + "-" + possibleBlackUserID } diff --git a/pkg/common/cachekey/conversation.go b/pkg/common/cachekey/conversation.go new file mode 100644 index 000000000..aea4ceec6 --- /dev/null +++ b/pkg/common/cachekey/conversation.go @@ -0,0 +1,58 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cachekey + +const ( + ConversationKey = "CONVERSATION:" + ConversationIDsKey = "CONVERSATION_IDS:" + ConversationIDsHashKey = "CONVERSATION_IDS_HASH:" + ConversationHasReadSeqKey = "CONVERSATION_HAS_READ_SEQ:" + RecvMsgOptKey = "RECV_MSG_OPT:" + SuperGroupRecvMsgNotNotifyUserIDsKey = "SUPER_GROUP_RECV_MSG_NOT_NOTIFY_USER_IDS:" + SuperGroupRecvMsgNotNotifyUserIDsHashKey = "SUPER_GROUP_RECV_MSG_NOT_NOTIFY_USER_IDS_HASH:" + ConversationNotReceiveMessageUserIDsKey = "CONVERSATION_NOT_RECEIVE_MESSAGE_USER_IDS:" +) + +func GetConversationKey(ownerUserID, conversationID string) string { + return ConversationKey + ownerUserID + ":" + conversationID +} + +func GetConversationIDsKey(ownerUserID string) string { + return ConversationIDsKey + ownerUserID +} + +func GetSuperGroupRecvNotNotifyUserIDsKey(groupID string) string { + return SuperGroupRecvMsgNotNotifyUserIDsKey + groupID +} + +func GetRecvMsgOptKey(ownerUserID, conversationID string) string { + return RecvMsgOptKey + ownerUserID + ":" + conversationID +} + +func GetSuperGroupRecvNotNotifyUserIDsHashKey(groupID string) string { + return SuperGroupRecvMsgNotNotifyUserIDsHashKey + groupID +} + +func GetConversationHasReadSeqKey(ownerUserID, conversationID string) string { + return ConversationHasReadSeqKey + ownerUserID + ":" + conversationID +} + +func GetConversationNotReceiveMessageUserIDsKey(conversationID string) string { + return ConversationNotReceiveMessageUserIDsKey + conversationID +} + +func GetUserConversationIDsHashKey(ownerUserID string) string { + return ConversationIDsHashKey + ownerUserID +} diff --git a/pkg/common/cachekey/friend.go b/pkg/common/cachekey/friend.go new file mode 100644 index 000000000..9691b1f5c --- /dev/null +++ b/pkg/common/cachekey/friend.go @@ -0,0 +1,38 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cachekey + +const ( + FriendIDsKey = "FRIEND_IDS:" + TwoWayFriendsIDsKey = "COMMON_FRIENDS_IDS:" + FriendKey = "FRIEND_INFO:" + IsFriendKey = "IS_FRIEND:" // local cache key +) + +func GetFriendIDsKey(ownerUserID string) string { + return FriendIDsKey + ownerUserID +} + +func GetTwoWayFriendsIDsKey(ownerUserID string) string { + return TwoWayFriendsIDsKey + ownerUserID +} + +func GetFriendKey(ownerUserID, friendUserID string) string { + return FriendKey + ownerUserID + "-" + friendUserID +} + +func GetIsFriendKey(possibleFriendUserID, userID string) string { + return IsFriendKey + possibleFriendUserID + "-" + userID +} diff --git a/pkg/common/cachekey/group.go b/pkg/common/cachekey/group.go new file mode 100644 index 000000000..681121ecb --- /dev/null +++ b/pkg/common/cachekey/group.go @@ -0,0 +1,59 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cachekey + +import ( + "strconv" + "time" +) + +const ( + groupExpireTime = time.Second * 60 * 60 * 12 + GroupInfoKey = "GROUP_INFO:" + GroupMemberIDsKey = "GROUP_MEMBER_IDS:" + GroupMembersHashKey = "GROUP_MEMBERS_HASH2:" + GroupMemberInfoKey = "GROUP_MEMBER_INFO:" + JoinedGroupsKey = "JOIN_GROUPS_KEY:" + GroupMemberNumKey = "GROUP_MEMBER_NUM_CACHE:" + GroupRoleLevelMemberIDsKey = "GROUP_ROLE_LEVEL_MEMBER_IDS:" +) + +func GetGroupInfoKey(groupID string) string { + return GroupInfoKey + groupID +} + +func GetJoinedGroupsKey(userID string) string { + return JoinedGroupsKey + userID +} + +func GetGroupMembersHashKey(groupID string) string { + return GroupMembersHashKey + groupID +} + +func GetGroupMemberIDsKey(groupID string) string { + return GroupMemberIDsKey + groupID +} + +func GetGroupMemberInfoKey(groupID, userID string) string { + return GroupMemberInfoKey + groupID + "-" + userID +} + +func GetGroupMemberNumKey(groupID string) string { + return GroupMemberNumKey + groupID +} + +func GetGroupRoleLevelMemberIDsKey(groupID string, roleLevel int32) string { + return GroupRoleLevelMemberIDsKey + groupID + "-" + strconv.Itoa(int(roleLevel)) +} diff --git a/tools/data-conversion/openim/common/console.go b/pkg/common/cachekey/user.go similarity index 62% rename from tools/data-conversion/openim/common/console.go rename to pkg/common/cachekey/user.go index b739a8c4c..473ca1b12 100644 --- a/tools/data-conversion/openim/common/console.go +++ b/pkg/common/cachekey/user.go @@ -1,4 +1,4 @@ -// Copyright © 2023 OpenIM. All rights reserved. +// Copyright © 2024 OpenIM. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -12,18 +12,17 @@ // See the License for the specific language governing permissions and // limitations under the License. -package common +package cachekey -import "fmt" +const ( + UserInfoKey = "USER_INFO:" + UserGlobalRecvMsgOptKey = "USER_GLOBAL_RECV_MSG_OPT_KEY:" +) -func ErrorPrint(s string) { - fmt.Printf("\x1b[%dm%v\x1b[0m\n", 31, s) +func GetUserInfoKey(userID string) string { + return UserInfoKey + userID } -func SuccessPrint(s string) { - fmt.Printf("\x1b[%dm%v\x1b[0m\n", 32, s) -} - -func WarningPrint(s string) { - fmt.Printf("\x1b[%dmWarning: But %v\x1b[0m\n", 33, s) +func GetUserGlobalRecvMsgOptKey(userID string) string { + return UserGlobalRecvMsgOptKey + userID } diff --git a/pkg/common/config/config.go b/pkg/common/config/config.go index ac42395bf..8bc871355 100644 --- a/pkg/common/config/config.go +++ b/pkg/common/config/config.go @@ -16,6 +16,7 @@ package config import ( "bytes" + "time" "github.com/OpenIMSDK/tools/discoveryregistry" "gopkg.in/yaml.v3" @@ -266,6 +267,8 @@ type GlobalConfig struct { FriendVerify *bool `yaml:"friendVerify"` } `yaml:"messageVerify"` + LocalCache localCache `yaml:"localCache"` + IOSPush struct { PushSound string `yaml:"pushSound"` BadgeCount bool `yaml:"badgeCount"` @@ -382,6 +385,33 @@ type notification struct { ConversationSetPrivate NotificationConf `yaml:"conversationSetPrivate"` } +type LocalCache struct { + Topic string `yaml:"topic"` + SlotNum int `yaml:"slotNum"` + SlotSize int `yaml:"slotSize"` + SuccessExpire int `yaml:"successExpire"` // second + FailedExpire int `yaml:"failedExpire"` // second +} + +func (l LocalCache) Failed() time.Duration { + return time.Second * time.Duration(l.FailedExpire) +} + +func (l LocalCache) Success() time.Duration { + return time.Second * time.Duration(l.SuccessExpire) +} + +func (l LocalCache) Enable() bool { + return l.Topic != "" && l.SlotNum > 0 && l.SlotSize > 0 +} + +type localCache struct { + User LocalCache `yaml:"user"` + Group LocalCache `yaml:"group"` + Friend LocalCache `yaml:"friend"` + Conversation LocalCache `yaml:"conversation"` +} + func (c *GlobalConfig) GetServiceNames() []string { return []string{ c.RpcRegisterName.OpenImUserName, diff --git a/pkg/common/config/parse_test.go b/pkg/common/config/parse_test.go index 84dee1165..35b019b83 100644 --- a/pkg/common/config/parse_test.go +++ b/pkg/common/config/parse_test.go @@ -16,9 +16,12 @@ package config import ( _ "embed" + "fmt" "reflect" "testing" + "gopkg.in/yaml.v3" + "github.com/openimsdk/open-im-server/v3/pkg/msgprocessor" ) @@ -116,3 +119,13 @@ func TestInitConfig(t *testing.T) { }) } } + +func TestName(t *testing.T) { + Config.LocalCache.Friend.Topic = "friend" + Config.LocalCache.Friend.SlotNum = 500 + Config.LocalCache.Friend.SlotSize = 20000 + + data, _ := yaml.Marshal(&Config) + + fmt.Println(string(data)) +} diff --git a/pkg/common/db/cache/black.go b/pkg/common/db/cache/black.go index c8cf2ddd3..a5304b4b0 100644 --- a/pkg/common/db/cache/black.go +++ b/pkg/common/db/cache/black.go @@ -18,7 +18,10 @@ import ( "context" "time" + "github.com/OpenIMSDK/tools/log" "github.com/dtm-labs/rockscache" + "github.com/openimsdk/open-im-server/v3/pkg/common/cachekey" + "github.com/openimsdk/open-im-server/v3/pkg/common/config" relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation" "github.com/redis/go-redis/v9" ) @@ -47,11 +50,15 @@ type BlackCacheRedis struct { func NewBlackCacheRedis(rdb redis.UniversalClient, blackDB relationtb.BlackModelInterface, options rockscache.Options) BlackCache { rcClient := rockscache.NewClient(rdb, options) - + mc := NewMetaCacheRedis(rcClient) + b := config.Config.LocalCache.Friend + log.ZDebug(context.Background(), "black local cache init", "Topic", b.Topic, "SlotNum", b.SlotNum, "SlotSize", b.SlotSize, "enable", b.Enable()) + mc.SetTopic(b.Topic) + mc.SetRawRedisClient(rdb) return &BlackCacheRedis{ expireTime: blackExpireTime, rcClient: rcClient, - metaCache: NewMetaCacheRedis(rcClient), + metaCache: mc, blackDB: blackDB, } } @@ -61,12 +68,12 @@ func (b *BlackCacheRedis) NewCache() BlackCache { expireTime: b.expireTime, rcClient: b.rcClient, blackDB: b.blackDB, - metaCache: NewMetaCacheRedis(b.rcClient, b.metaCache.GetPreDelKeys()...), + metaCache: b.Copy(), } } func (b *BlackCacheRedis) getBlackIDsKey(ownerUserID string) string { - return blackIDsKey + ownerUserID + return cachekey.GetBlackIDsKey(ownerUserID) } func (b *BlackCacheRedis) GetBlackIDs(ctx context.Context, userID string) (blackIDs []string, err error) { diff --git a/pkg/common/db/cache/config.go b/pkg/common/db/cache/config.go new file mode 100644 index 000000000..c760e0c03 --- /dev/null +++ b/pkg/common/db/cache/config.go @@ -0,0 +1,81 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cache + +import ( + "strings" + "sync" + + "github.com/openimsdk/open-im-server/v3/pkg/common/cachekey" + "github.com/openimsdk/open-im-server/v3/pkg/common/config" +) + +var ( + once sync.Once + subscribe map[string][]string +) + +func getPublishKey(topic string, key []string) []string { + if topic == "" || len(key) == 0 { + return nil + } + once.Do(func() { + list := []struct { + Local config.LocalCache + Keys []string + }{ + { + Local: config.Config.LocalCache.User, + Keys: []string{cachekey.UserInfoKey, cachekey.UserGlobalRecvMsgOptKey}, + }, + { + Local: config.Config.LocalCache.Group, + Keys: []string{cachekey.GroupMemberIDsKey, cachekey.GroupInfoKey, cachekey.GroupMemberInfoKey}, + }, + { + Local: config.Config.LocalCache.Friend, + Keys: []string{cachekey.FriendIDsKey, cachekey.BlackIDsKey}, + }, + { + Local: config.Config.LocalCache.Conversation, + Keys: []string{cachekey.ConversationKey, cachekey.ConversationIDsKey, cachekey.ConversationNotReceiveMessageUserIDsKey}, + }, + } + subscribe = make(map[string][]string) + for _, v := range list { + if v.Local.Enable() { + subscribe[v.Local.Topic] = v.Keys + } + } + }) + prefix, ok := subscribe[topic] + if !ok { + return nil + } + res := make([]string, 0, len(key)) + for _, k := range key { + var exist bool + for _, p := range prefix { + if strings.HasPrefix(k, p) { + exist = true + break + } + } + if exist { + res = append(res, k) + } + } + return res +} diff --git a/pkg/common/db/cache/conversation.go b/pkg/common/db/cache/conversation.go index 90e400363..c8f752cd3 100644 --- a/pkg/common/db/cache/conversation.go +++ b/pkg/common/db/cache/conversation.go @@ -20,21 +20,24 @@ import ( "strings" "time" + "github.com/OpenIMSDK/tools/log" "github.com/OpenIMSDK/tools/utils" "github.com/dtm-labs/rockscache" + "github.com/openimsdk/open-im-server/v3/pkg/common/cachekey" + "github.com/openimsdk/open-im-server/v3/pkg/common/config" relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation" "github.com/redis/go-redis/v9" ) const ( - conversationKey = "CONVERSATION:" - conversationIDsKey = "CONVERSATION_IDS:" - conversationIDsHashKey = "CONVERSATION_IDS_HASH:" - conversationHasReadSeqKey = "CONVERSATION_HAS_READ_SEQ:" - recvMsgOptKey = "RECV_MSG_OPT:" - superGroupRecvMsgNotNotifyUserIDsKey = "SUPER_GROUP_RECV_MSG_NOT_NOTIFY_USER_IDS:" - superGroupRecvMsgNotNotifyUserIDsHashKey = "SUPER_GROUP_RECV_MSG_NOT_NOTIFY_USER_IDS_HASH:" - conversationNotReceiveMessageUserIDsKey = "CONVERSATION_NOT_RECEIVE_MESSAGE_USER_IDS:" + //conversationKey = "CONVERSATION:" + //conversationIDsKey = "CONVERSATION_IDS:" + //conversationIDsHashKey = "CONVERSATION_IDS_HASH:" + //conversationHasReadSeqKey = "CONVERSATION_HAS_READ_SEQ:" + //recvMsgOptKey = "RECV_MSG_OPT:" + //superGroupRecvMsgNotNotifyUserIDsKey = "SUPER_GROUP_RECV_MSG_NOT_NOTIFY_USER_IDS:" + //superGroupRecvMsgNotNotifyUserIDsHashKey = "SUPER_GROUP_RECV_MSG_NOT_NOTIFY_USER_IDS_HASH:" + //conversationNotReceiveMessageUserIDsKey = "CONVERSATION_NOT_RECEIVE_MESSAGE_USER_IDS:". conversationExpireTime = time.Second * 60 * 60 * 12 ) @@ -81,10 +84,14 @@ type ConversationCache interface { func NewConversationRedis(rdb redis.UniversalClient, opts rockscache.Options, db relationtb.ConversationModelInterface) ConversationCache { rcClient := rockscache.NewClient(rdb, opts) - + mc := NewMetaCacheRedis(rcClient) + c := config.Config.LocalCache.Conversation + log.ZDebug(context.Background(), "black local cache init", "Topic", c.Topic, "SlotNum", c.SlotNum, "SlotSize", c.SlotSize, "enable", c.Enable()) + mc.SetTopic(c.Topic) + mc.SetRawRedisClient(rdb) return &ConversationRedisCache{ rcClient: rcClient, - metaCache: NewMetaCacheRedis(rcClient), + metaCache: mc, conversationDB: db, expireTime: conversationExpireTime, } @@ -115,38 +122,42 @@ type ConversationRedisCache struct { func (c *ConversationRedisCache) NewCache() ConversationCache { return &ConversationRedisCache{ rcClient: c.rcClient, - metaCache: NewMetaCacheRedis(c.rcClient, c.metaCache.GetPreDelKeys()...), + metaCache: c.Copy(), conversationDB: c.conversationDB, expireTime: c.expireTime, } } func (c *ConversationRedisCache) getConversationKey(ownerUserID, conversationID string) string { - return conversationKey + ownerUserID + ":" + conversationID + return cachekey.GetConversationKey(ownerUserID, conversationID) } func (c *ConversationRedisCache) getConversationIDsKey(ownerUserID string) string { - return conversationIDsKey + ownerUserID + return cachekey.GetConversationIDsKey(ownerUserID) } func (c *ConversationRedisCache) getSuperGroupRecvNotNotifyUserIDsKey(groupID string) string { - return superGroupRecvMsgNotNotifyUserIDsKey + groupID + return cachekey.GetSuperGroupRecvNotNotifyUserIDsKey(groupID) } func (c *ConversationRedisCache) getRecvMsgOptKey(ownerUserID, conversationID string) string { - return recvMsgOptKey + ownerUserID + ":" + conversationID + return cachekey.GetRecvMsgOptKey(ownerUserID, conversationID) } func (c *ConversationRedisCache) getSuperGroupRecvNotNotifyUserIDsHashKey(groupID string) string { - return superGroupRecvMsgNotNotifyUserIDsHashKey + groupID + return cachekey.GetSuperGroupRecvNotNotifyUserIDsHashKey(groupID) } func (c *ConversationRedisCache) getConversationHasReadSeqKey(ownerUserID, conversationID string) string { - return conversationHasReadSeqKey + ownerUserID + ":" + conversationID + return cachekey.GetConversationHasReadSeqKey(ownerUserID, conversationID) } func (c *ConversationRedisCache) getConversationNotReceiveMessageUserIDsKey(conversationID string) string { - return conversationNotReceiveMessageUserIDsKey + conversationID + return cachekey.GetConversationNotReceiveMessageUserIDsKey(conversationID) +} + +func (c *ConversationRedisCache) getUserConversationIDsHashKey(ownerUserID string) string { + return cachekey.GetUserConversationIDsHashKey(ownerUserID) } func (c *ConversationRedisCache) GetUserConversationIDs(ctx context.Context, ownerUserID string) ([]string, error) { @@ -166,10 +177,6 @@ func (c *ConversationRedisCache) DelConversationIDs(userIDs ...string) Conversat return cache } -func (c *ConversationRedisCache) getUserConversationIDsHashKey(ownerUserID string) string { - return conversationIDsHashKey + ownerUserID -} - func (c *ConversationRedisCache) GetUserConversationIDsHash(ctx context.Context, ownerUserID string) (hash uint64, err error) { return getCache( ctx, diff --git a/pkg/common/db/cache/friend.go b/pkg/common/db/cache/friend.go index a160837ba..2d20705ef 100644 --- a/pkg/common/db/cache/friend.go +++ b/pkg/common/db/cache/friend.go @@ -18,17 +18,20 @@ import ( "context" "time" + "github.com/OpenIMSDK/tools/log" "github.com/OpenIMSDK/tools/utils" "github.com/dtm-labs/rockscache" + "github.com/openimsdk/open-im-server/v3/pkg/common/cachekey" + "github.com/openimsdk/open-im-server/v3/pkg/common/config" relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation" "github.com/redis/go-redis/v9" ) const ( - friendExpireTime = time.Second * 60 * 60 * 12 - friendIDsKey = "FRIEND_IDS:" - TwoWayFriendsIDsKey = "COMMON_FRIENDS_IDS:" - friendKey = "FRIEND_INFO:" + friendExpireTime = time.Second * 60 * 60 * 12 + //friendIDsKey = "FRIEND_IDS:" + //TwoWayFriendsIDsKey = "COMMON_FRIENDS_IDS:" + //friendKey = "FRIEND_INFO:". ) // FriendCache is an interface for caching friend-related data. @@ -58,8 +61,13 @@ type FriendCacheRedis struct { func NewFriendCacheRedis(rdb redis.UniversalClient, friendDB relationtb.FriendModelInterface, options rockscache.Options) FriendCache { rcClient := rockscache.NewClient(rdb, options) + mc := NewMetaCacheRedis(rcClient) + f := config.Config.LocalCache.Friend + log.ZDebug(context.Background(), "friend local cache init", "Topic", f.Topic, "SlotNum", f.SlotNum, "SlotSize", f.SlotSize, "enable", f.Enable()) + mc.SetTopic(f.Topic) + mc.SetRawRedisClient(rdb) return &FriendCacheRedis{ - metaCache: NewMetaCacheRedis(rcClient), + metaCache: mc, friendDB: friendDB, expireTime: friendExpireTime, rcClient: rcClient, @@ -70,7 +78,7 @@ func NewFriendCacheRedis(rdb redis.UniversalClient, friendDB relationtb.FriendMo func (f *FriendCacheRedis) NewCache() FriendCache { return &FriendCacheRedis{ rcClient: f.rcClient, - metaCache: NewMetaCacheRedis(f.rcClient, f.metaCache.GetPreDelKeys()...), + metaCache: f.Copy(), friendDB: f.friendDB, expireTime: f.expireTime, } @@ -78,17 +86,17 @@ func (f *FriendCacheRedis) NewCache() FriendCache { // getFriendIDsKey returns the key for storing friend IDs in the cache. func (f *FriendCacheRedis) getFriendIDsKey(ownerUserID string) string { - return friendIDsKey + ownerUserID + return cachekey.GetFriendIDsKey(ownerUserID) } // getTwoWayFriendsIDsKey returns the key for storing two-way friend IDs in the cache. func (f *FriendCacheRedis) getTwoWayFriendsIDsKey(ownerUserID string) string { - return TwoWayFriendsIDsKey + ownerUserID + return cachekey.GetTwoWayFriendsIDsKey(ownerUserID) } // getFriendKey returns the key for storing friend info in the cache. func (f *FriendCacheRedis) getFriendKey(ownerUserID, friendUserID string) string { - return friendKey + ownerUserID + "-" + friendUserID + return cachekey.GetFriendKey(ownerUserID, friendUserID) } // GetFriendIDs retrieves friend IDs from the cache or the database if not found. diff --git a/pkg/common/db/cache/group.go b/pkg/common/db/cache/group.go index 4a5266db5..7022461cb 100644 --- a/pkg/common/db/cache/group.go +++ b/pkg/common/db/cache/group.go @@ -17,7 +17,6 @@ package cache import ( "context" "fmt" - "strconv" "time" "github.com/OpenIMSDK/protocol/constant" @@ -25,20 +24,21 @@ import ( "github.com/OpenIMSDK/tools/log" "github.com/OpenIMSDK/tools/utils" "github.com/dtm-labs/rockscache" + "github.com/openimsdk/open-im-server/v3/pkg/common/cachekey" + "github.com/openimsdk/open-im-server/v3/pkg/common/config" relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation" "github.com/redis/go-redis/v9" ) const ( - groupExpireTime = time.Second * 60 * 60 * 12 - groupInfoKey = "GROUP_INFO:" - groupMemberIDsKey = "GROUP_MEMBER_IDS:" - groupMembersHashKey = "GROUP_MEMBERS_HASH2:" - groupMemberInfoKey = "GROUP_MEMBER_INFO:" - //groupOwnerInfoKey = "GROUP_OWNER_INFO:". - joinedGroupsKey = "JOIN_GROUPS_KEY:" - groupMemberNumKey = "GROUP_MEMBER_NUM_CACHE:" - groupRoleLevelMemberIDsKey = "GROUP_ROLE_LEVEL_MEMBER_IDS:" + groupExpireTime = time.Second * 60 * 60 * 12 + //groupInfoKey = "GROUP_INFO:" + //groupMemberIDsKey = "GROUP_MEMBER_IDS:" + //groupMembersHashKey = "GROUP_MEMBERS_HASH2:" + //groupMemberInfoKey = "GROUP_MEMBER_INFO:" + //joinedGroupsKey = "JOIN_GROUPS_KEY:" + //groupMemberNumKey = "GROUP_MEMBER_NUM_CACHE:" + //groupRoleLevelMemberIDsKey = "GROUP_ROLE_LEVEL_MEMBER_IDS:". ) type GroupHash interface { @@ -101,12 +101,16 @@ func NewGroupCacheRedis( opts rockscache.Options, ) GroupCache { rcClient := rockscache.NewClient(rdb, opts) - + mc := NewMetaCacheRedis(rcClient) + g := config.Config.LocalCache.Group + mc.SetTopic(g.Topic) + log.ZDebug(context.Background(), "group local cache init", "Topic", g.Topic, "SlotNum", g.SlotNum, "SlotSize", g.SlotSize, "enable", g.Enable()) + mc.SetRawRedisClient(rdb) return &GroupCacheRedis{ rcClient: rcClient, expireTime: groupExpireTime, groupDB: groupDB, groupMemberDB: groupMemberDB, groupRequestDB: groupRequestDB, groupHash: hashCode, - metaCache: NewMetaCacheRedis(rcClient), + metaCache: mc, } } @@ -117,36 +121,36 @@ func (g *GroupCacheRedis) NewCache() GroupCache { groupDB: g.groupDB, groupMemberDB: g.groupMemberDB, groupRequestDB: g.groupRequestDB, - metaCache: NewMetaCacheRedis(g.rcClient, g.metaCache.GetPreDelKeys()...), + metaCache: g.Copy(), } } func (g *GroupCacheRedis) getGroupInfoKey(groupID string) string { - return groupInfoKey + groupID + return cachekey.GetGroupInfoKey(groupID) } func (g *GroupCacheRedis) getJoinedGroupsKey(userID string) string { - return joinedGroupsKey + userID + return cachekey.GetJoinedGroupsKey(userID) } func (g *GroupCacheRedis) getGroupMembersHashKey(groupID string) string { - return groupMembersHashKey + groupID + return cachekey.GetGroupMembersHashKey(groupID) } func (g *GroupCacheRedis) getGroupMemberIDsKey(groupID string) string { - return groupMemberIDsKey + groupID + return cachekey.GetGroupMemberIDsKey(groupID) } func (g *GroupCacheRedis) getGroupMemberInfoKey(groupID, userID string) string { - return groupMemberInfoKey + groupID + "-" + userID + return cachekey.GetGroupMemberInfoKey(groupID, userID) } func (g *GroupCacheRedis) getGroupMemberNumKey(groupID string) string { - return groupMemberNumKey + groupID + return cachekey.GetGroupMemberNumKey(groupID) } func (g *GroupCacheRedis) getGroupRoleLevelMemberIDsKey(groupID string, roleLevel int32) string { - return groupRoleLevelMemberIDsKey + groupID + "-" + strconv.Itoa(int(roleLevel)) + return cachekey.GetGroupRoleLevelMemberIDsKey(groupID, roleLevel) } func (g *GroupCacheRedis) GetGroupIndex(group *relationtb.GroupModel, keys []string) (int, error) { diff --git a/pkg/common/db/cache/meta_cache.go b/pkg/common/db/cache/meta_cache.go index 4d4f077b6..431b7c867 100644 --- a/pkg/common/db/cache/meta_cache.go +++ b/pkg/common/db/cache/meta_cache.go @@ -26,6 +26,7 @@ import ( "github.com/OpenIMSDK/tools/mw/specialerror" "github.com/OpenIMSDK/tools/utils" "github.com/dtm-labs/rockscache" + "github.com/redis/go-redis/v9" ) const ( @@ -43,6 +44,9 @@ type metaCache interface { AddKeys(keys ...string) ClearKeys() GetPreDelKeys() []string + SetTopic(topic string) + SetRawRedisClient(cli redis.UniversalClient) + Copy() metaCache } func NewMetaCacheRedis(rcClient *rockscache.Client, keys ...string) metaCache { @@ -50,10 +54,36 @@ func NewMetaCacheRedis(rcClient *rockscache.Client, keys ...string) metaCache { } type metaCacheRedis struct { + topic string rcClient *rockscache.Client keys []string maxRetryTimes int retryInterval time.Duration + redisClient redis.UniversalClient +} + +func (m *metaCacheRedis) Copy() metaCache { + var keys []string + if len(m.keys) > 0 { + keys = make([]string, 0, len(m.keys)*2) + keys = append(keys, m.keys...) + } + return &metaCacheRedis{ + topic: m.topic, + rcClient: m.rcClient, + keys: keys, + maxRetryTimes: m.maxRetryTimes, + retryInterval: m.retryInterval, + redisClient: redisClient, + } +} + +func (m *metaCacheRedis) SetTopic(topic string) { + m.topic = topic +} + +func (m *metaCacheRedis) SetRawRedisClient(cli redis.UniversalClient) { + m.redisClient = cli } func (m *metaCacheRedis) ExecDel(ctx context.Context, distinct ...bool) error { @@ -61,7 +91,7 @@ func (m *metaCacheRedis) ExecDel(ctx context.Context, distinct ...bool) error { m.keys = utils.Distinct(m.keys) } if len(m.keys) > 0 { - log.ZDebug(ctx, "delete cache", "keys", m.keys) + log.ZDebug(ctx, "delete cache", "topic", m.topic, "keys", m.keys) for _, key := range m.keys { for i := 0; i < m.maxRetryTimes; i++ { if err := m.rcClient.TagAsDeleted(key); err != nil { @@ -71,31 +101,18 @@ func (m *metaCacheRedis) ExecDel(ctx context.Context, distinct ...bool) error { } break } - - //retryTimes := 0 - //for { - // m.rcClient.TagAsDeleted() - // if err := m.rcClient.TagAsDeletedBatch2(ctx, []string{key}); err != nil { - // if retryTimes >= m.maxRetryTimes { - // err = errs.ErrInternalServer.Wrap( - // fmt.Sprintf( - // "delete cache error: %v, keys: %v, retry times %d, please check redis server", - // err, - // key, - // retryTimes, - // ), - // ) - // log.ZWarn(ctx, "delete cache failed, please handle keys", err, "keys", key) - // return err - // } - // retryTimes++ - // } else { - // break - // } - //} + } + if pk := getPublishKey(m.topic, m.keys); len(pk) > 0 { + data, err := json.Marshal(pk) + if err != nil { + log.ZError(ctx, "keys json marshal failed", err, "topic", m.topic, "keys", pk) + } else { + if err := m.redisClient.Publish(ctx, m.topic, string(data)).Err(); err != nil { + log.ZError(ctx, "redis publish cache delete error", err, "topic", m.topic, "keys", pk) + } + } } } - return nil } diff --git a/pkg/common/db/cache/msg.go b/pkg/common/db/cache/msg.go index 9b488c1bf..b8e9dbc77 100644 --- a/pkg/common/db/cache/msg.go +++ b/pkg/common/db/cache/msg.go @@ -38,12 +38,12 @@ const ( conversationUserMinSeq = "CON_USER_MIN_SEQ:" hasReadSeq = "HAS_READ_SEQ:" - appleDeviceToken = "DEVICE_TOKEN" - getuiToken = "GETUI_TOKEN" - getuiTaskID = "GETUI_TASK_ID" - signalCache = "SIGNAL_CACHE:" - signalListCache = "SIGNAL_LIST_CACHE:" - FCM_TOKEN = "FCM_TOKEN:" + //appleDeviceToken = "DEVICE_TOKEN". + getuiToken = "GETUI_TOKEN" + getuiTaskID = "GETUI_TASK_ID" + //signalCache = "SIGNAL_CACHE:" + //signalListCache = "SIGNAL_LIST_CACHE:". + FCM_TOKEN = "FCM_TOKEN:" messageCache = "MESSAGE_CACHE:" messageDelUserList = "MESSAGE_DEL_USER_LIST:" @@ -143,6 +143,10 @@ func (c *msgCache) getHasReadSeqKey(conversationID string, userID string) string return hasReadSeq + userID + ":" + conversationID } +func (c *msgCache) getConversationUserMinSeqKey(conversationID, userID string) string { + return conversationUserMinSeq + conversationID + "u:" + userID +} + func (c *msgCache) setSeq(ctx context.Context, conversationID string, seq int64, getkey func(conversationID string) string) error { return errs.Wrap(c.rdb.Set(ctx, getkey(conversationID), seq, 0).Err()) } @@ -208,10 +212,6 @@ func (c *msgCache) GetMinSeq(ctx context.Context, conversationID string) (int64, return c.getSeq(ctx, conversationID, c.getMinSeqKey) } -func (c *msgCache) getConversationUserMinSeqKey(conversationID, userID string) string { - return conversationUserMinSeq + conversationID + "u:" + userID -} - func (c *msgCache) GetConversationUserMinSeq(ctx context.Context, conversationID string, userID string) (int64, error) { val, err := c.rdb.Get(ctx, c.getConversationUserMinSeqKey(conversationID, userID)).Int64() if err != nil { diff --git a/pkg/common/db/cache/user.go b/pkg/common/db/cache/user.go index 837e7a5bc..a60f55836 100644 --- a/pkg/common/db/cache/user.go +++ b/pkg/common/db/cache/user.go @@ -27,13 +27,15 @@ import ( "github.com/OpenIMSDK/tools/errs" "github.com/OpenIMSDK/tools/log" "github.com/dtm-labs/rockscache" + "github.com/openimsdk/open-im-server/v3/pkg/common/cachekey" + "github.com/openimsdk/open-im-server/v3/pkg/common/config" relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation" "github.com/redis/go-redis/v9" ) const ( - userExpireTime = time.Second * 60 * 60 * 12 - userInfoKey = "USER_INFO:" + userExpireTime = time.Second * 60 * 60 * 12 + //userInfoKey = "USER_INFO:". userGlobalRecvMsgOptKey = "USER_GLOBAL_RECV_MSG_OPT_KEY:" olineStatusKey = "ONLINE_STATUS:" userOlineStatusExpireTime = time.Second * 60 * 60 * 24 @@ -68,7 +70,11 @@ func NewUserCacheRedis( options rockscache.Options, ) UserCache { rcClient := rockscache.NewClient(rdb, options) - + mc := NewMetaCacheRedis(rcClient) + u := config.Config.LocalCache.User + log.ZDebug(context.Background(), "user local cache init", "Topic", u.Topic, "SlotNum", u.SlotNum, "SlotSize", u.SlotSize, "enable", u.Enable()) + mc.SetTopic(u.Topic) + mc.SetRawRedisClient(rdb) return &UserCacheRedis{ rdb: rdb, metaCache: NewMetaCacheRedis(rcClient), @@ -81,7 +87,7 @@ func NewUserCacheRedis( func (u *UserCacheRedis) NewCache() UserCache { return &UserCacheRedis{ rdb: u.rdb, - metaCache: NewMetaCacheRedis(u.rcClient, u.metaCache.GetPreDelKeys()...), + metaCache: u.Copy(), userDB: u.userDB, expireTime: u.expireTime, rcClient: u.rcClient, @@ -89,18 +95,17 @@ func (u *UserCacheRedis) NewCache() UserCache { } func (u *UserCacheRedis) getUserInfoKey(userID string) string { - return userInfoKey + userID + return cachekey.GetUserInfoKey(userID) } func (u *UserCacheRedis) getUserGlobalRecvMsgOptKey(userID string) string { - return userGlobalRecvMsgOptKey + userID + return cachekey.GetUserGlobalRecvMsgOptKey(userID) } func (u *UserCacheRedis) GetUserInfo(ctx context.Context, userID string) (userInfo *relationtb.UserModel, err error) { return getCache(ctx, u.rcClient, u.getUserInfoKey(userID), u.expireTime, func(ctx context.Context) (*relationtb.UserModel, error) { return u.userDB.Take(ctx, userID) - }, - ) + }) } func (u *UserCacheRedis) GetUsersInfo(ctx context.Context, userIDs []string) ([]*relationtb.UserModel, error) { diff --git a/pkg/common/db/localcache/conversation.go b/pkg/common/db/localcache/conversation.go deleted file mode 100644 index 9147fd3ce..000000000 --- a/pkg/common/db/localcache/conversation.go +++ /dev/null @@ -1,86 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package localcache - -import ( - "context" - "sync" - - "github.com/OpenIMSDK/protocol/conversation" - "github.com/openimsdk/open-im-server/v3/pkg/rpcclient" -) - -type ConversationLocalCache struct { - lock sync.Mutex - superGroupRecvMsgNotNotifyUserIDs map[string]Hash - conversationIDs map[string]Hash - client *rpcclient.ConversationRpcClient -} - -type Hash struct { - hash uint64 - ids []string -} - -func NewConversationLocalCache(client *rpcclient.ConversationRpcClient) *ConversationLocalCache { - return &ConversationLocalCache{ - superGroupRecvMsgNotNotifyUserIDs: make(map[string]Hash), - conversationIDs: make(map[string]Hash), - client: client, - } -} - -func (g *ConversationLocalCache) GetRecvMsgNotNotifyUserIDs(ctx context.Context, groupID string) ([]string, error) { - resp, err := g.client.Client.GetRecvMsgNotNotifyUserIDs(ctx, &conversation.GetRecvMsgNotNotifyUserIDsReq{ - GroupID: groupID, - }) - if err != nil { - return nil, err - } - return resp.UserIDs, nil -} - -func (g *ConversationLocalCache) GetConversationIDs(ctx context.Context, userID string) ([]string, error) { - resp, err := g.client.Client.GetUserConversationIDsHash(ctx, &conversation.GetUserConversationIDsHashReq{ - OwnerUserID: userID, - }) - if err != nil { - return nil, err - } - - g.lock.Lock() - hash, ok := g.conversationIDs[userID] - g.lock.Unlock() - - if !ok || hash.hash != resp.Hash { - conversationIDsResp, err := g.client.Client.GetConversationIDs(ctx, &conversation.GetConversationIDsReq{ - UserID: userID, - }) - if err != nil { - return nil, err - } - - g.lock.Lock() - defer g.lock.Unlock() - g.conversationIDs[userID] = Hash{ - hash: resp.Hash, - ids: conversationIDsResp.ConversationIDs, - } - - return conversationIDsResp.ConversationIDs, nil - } - - return hash.ids, nil -} diff --git a/pkg/common/db/localcache/doc.go b/pkg/common/db/localcache/doc.go deleted file mode 100644 index d349373ee..000000000 --- a/pkg/common/db/localcache/doc.go +++ /dev/null @@ -1,15 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package localcache // import "github.com/openimsdk/open-im-server/v3/pkg/common/db/localcache" diff --git a/pkg/common/db/localcache/group.go b/pkg/common/db/localcache/group.go deleted file mode 100644 index 0fdea8642..000000000 --- a/pkg/common/db/localcache/group.go +++ /dev/null @@ -1,77 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package localcache - -import ( - "context" - "sync" - - "github.com/OpenIMSDK/protocol/group" - "github.com/OpenIMSDK/tools/errs" - "github.com/openimsdk/open-im-server/v3/pkg/rpcclient" -) - -type GroupLocalCache struct { - lock sync.Mutex - cache map[string]GroupMemberIDsHash - client *rpcclient.GroupRpcClient -} - -type GroupMemberIDsHash struct { - memberListHash uint64 - userIDs []string -} - -func NewGroupLocalCache(client *rpcclient.GroupRpcClient) *GroupLocalCache { - return &GroupLocalCache{ - cache: make(map[string]GroupMemberIDsHash, 0), - client: client, - } -} - -func (g *GroupLocalCache) GetGroupMemberIDs(ctx context.Context, groupID string) ([]string, error) { - resp, err := g.client.Client.GetGroupAbstractInfo(ctx, &group.GetGroupAbstractInfoReq{ - GroupIDs: []string{groupID}, - }) - if err != nil { - return nil, err - } - if len(resp.GroupAbstractInfos) < 1 { - return nil, errs.ErrGroupIDNotFound - } - - g.lock.Lock() - localHashInfo, ok := g.cache[groupID] - if ok && localHashInfo.memberListHash == resp.GroupAbstractInfos[0].GroupMemberListHash { - g.lock.Unlock() - return localHashInfo.userIDs, nil - } - g.lock.Unlock() - - groupMembersResp, err := g.client.Client.GetGroupMemberUserIDs(ctx, &group.GetGroupMemberUserIDsReq{ - GroupID: groupID, - }) - if err != nil { - return nil, err - } - - g.lock.Lock() - defer g.lock.Unlock() - g.cache[groupID] = GroupMemberIDsHash{ - memberListHash: resp.GroupAbstractInfos[0].GroupMemberListHash, - userIDs: groupMembersResp.UserIDs, - } - return g.cache[groupID].userIDs, nil -} diff --git a/pkg/common/db/mgo/conversation.go b/pkg/common/db/mgo/conversation.go index 35e8a28e6..bc37ed759 100644 --- a/pkg/common/db/mgo/conversation.go +++ b/pkg/common/db/mgo/conversation.go @@ -96,8 +96,14 @@ func (c *ConversationMgo) FindUserIDAllConversations(ctx context.Context, userID return mgoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{"owner_user_id": userID}) } -func (c *ConversationMgo) FindRecvMsgNotNotifyUserIDs(ctx context.Context, groupID string) ([]string, error) { - return mgoutil.Find[string](ctx, c.coll, bson.M{"group_id": groupID, "recv_msg_opt": constant.ReceiveNotNotifyMessage}, options.Find().SetProjection(bson.M{"_id": 0, "owner_user_id": 1})) +func (c *ConversationMgo) FindRecvMsgUserIDs(ctx context.Context, conversationID string, recvOpts []int) ([]string, error) { + var filter any + if len(recvOpts) == 0 { + filter = bson.M{"conversation_id": conversationID} + } else { + filter = bson.M{"conversation_id": conversationID, "recv_msg_opt": bson.M{"$in": recvOpts}} + } + return mgoutil.Find[string](ctx, c.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "owner_user_id": 1})) } func (c *ConversationMgo) GetUserRecvMsgOpt(ctx context.Context, ownerUserID, conversationID string) (opt int, err error) { diff --git a/pkg/common/db/mgo/group.go b/pkg/common/db/mgo/group.go index 1bef90ebe..a3d777f59 100644 --- a/pkg/common/db/mgo/group.go +++ b/pkg/common/db/mgo/group.go @@ -16,6 +16,7 @@ package mgo import ( "context" + "github.com/OpenIMSDK/protocol/constant" "time" "github.com/OpenIMSDK/tools/errs" @@ -69,7 +70,8 @@ func (g *GroupMgo) Take(ctx context.Context, groupID string) (group *relation.Gr } func (g *GroupMgo) Search(ctx context.Context, keyword string, pagination pagination.Pagination) (total int64, groups []*relation.GroupModel, err error) { - return mgoutil.FindPage[*relation.GroupModel](ctx, g.coll, bson.M{"group_name": bson.M{"$regex": keyword}}, pagination) + return mgoutil.FindPage[*relation.GroupModel](ctx, g.coll, bson.M{"group_name": bson.M{"$regex": keyword}, + "status": bson.M{"$ne": constant.GroupStatusDismissed}}, pagination) } func (g *GroupMgo) CountTotal(ctx context.Context, before *time.Time) (count int64, err error) { diff --git a/pkg/common/db/table/relation/conversation.go b/pkg/common/db/table/relation/conversation.go index e0a5268ca..583e41c0f 100644 --- a/pkg/common/db/table/relation/conversation.go +++ b/pkg/common/db/table/relation/conversation.go @@ -53,7 +53,7 @@ type ConversationModelInterface interface { Take(ctx context.Context, userID, conversationID string) (conversation *ConversationModel, err error) FindConversationID(ctx context.Context, userID string, conversationIDs []string) (existConversationID []string, err error) FindUserIDAllConversations(ctx context.Context, userID string) (conversations []*ConversationModel, err error) - FindRecvMsgNotNotifyUserIDs(ctx context.Context, groupID string) ([]string, error) + FindRecvMsgUserIDs(ctx context.Context, conversationID string, recvOpts []int) ([]string, error) GetUserRecvMsgOpt(ctx context.Context, ownerUserID, conversationID string) (opt int, err error) GetAllConversationIDs(ctx context.Context) ([]string, error) GetAllConversationIDsNumber(ctx context.Context) (int64, error) diff --git a/pkg/common/db/unrelation/msg.go b/pkg/common/db/unrelation/msg.go index 4deca56f8..a129f3e99 100644 --- a/pkg/common/db/unrelation/msg.go +++ b/pkg/common/db/unrelation/msg.go @@ -1063,8 +1063,8 @@ func (m *MsgMongoDriver) searchMessage(ctx context.Context, req *msg.SearchMessa // Changed to keyed fields for bson.M to avoid govet errors condition = append(condition, bson.M{"$eq": bson.A{bson.M{"$dateToString": bson.M{"format": "%Y-%m-%d", "date": bson.M{"$toDate": "$$item.msg.send_time"}}}, req.SendTime}}) } - if req.MsgType != 0 { - condition = append(condition, bson.M{"$eq": bson.A{"$$item.msg.content_type", req.MsgType}}) + if req.ContentType != 0 { + condition = append(condition, bson.M{"$eq": bson.A{"$$item.msg.content_type", req.ContentType}}) } if req.SessionType != 0 { condition = append(condition, bson.M{"$eq": bson.A{"$$item.msg.session_type", req.SessionType}}) diff --git a/tools/data-conversion/chat/v3/admin/register_add_friend.go b/pkg/common/redispubsub/redispubliser.go similarity index 57% rename from tools/data-conversion/chat/v3/admin/register_add_friend.go rename to pkg/common/redispubsub/redispubliser.go index 8281f6485..6e41af73a 100644 --- a/tools/data-conversion/chat/v3/admin/register_add_friend.go +++ b/pkg/common/redispubsub/redispubliser.go @@ -1,4 +1,4 @@ -// Copyright © 2023 OpenIM open source community. All rights reserved. +// Copyright © 2024 OpenIM. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -12,18 +12,19 @@ // See the License for the specific language governing permissions and // limitations under the License. -package admin +package redispubsub -import ( - "time" -) +import "github.com/redis/go-redis/v9" -// RegisterAddFriend Indicates the default friend when registering. -type RegisterAddFriend struct { - UserID string `gorm:"column:user_id;primary_key;type:char(64)"` - CreateTime time.Time `gorm:"column:create_time"` +type Publisher struct { + client redis.UniversalClient + channel string } -func (RegisterAddFriend) TableName() string { - return "register_add_friends" +func NewPublisher(client redis.UniversalClient, channel string) *Publisher { + return &Publisher{client: client, channel: channel} +} + +func (p *Publisher) Publish(message string) error { + return p.client.Publish(ctx, p.channel, message).Err() } diff --git a/pkg/common/redispubsub/redissubscriber.go b/pkg/common/redispubsub/redissubscriber.go new file mode 100644 index 000000000..aea99b318 --- /dev/null +++ b/pkg/common/redispubsub/redissubscriber.go @@ -0,0 +1,49 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package redispubsub + +import ( + "context" + + "github.com/redis/go-redis/v9" +) + +var ctx = context.Background() + +type Subscriber struct { + client redis.UniversalClient + channel string +} + +func NewSubscriber(client redis.UniversalClient, channel string) *Subscriber { + return &Subscriber{client: client, channel: channel} +} + +func (s *Subscriber) OnMessage(ctx context.Context, callback func(string)) error { + messageChannel := s.client.Subscribe(ctx, s.channel).Channel() + + go func() { + for { + select { + case <-ctx.Done(): + return + case msg := <-messageChannel: + callback(msg.Payload) + } + } + }() + + return nil +} diff --git a/pkg/localcache/cache.go b/pkg/localcache/cache.go new file mode 100644 index 000000000..91c490922 --- /dev/null +++ b/pkg/localcache/cache.go @@ -0,0 +1,127 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package localcache + +import ( + "context" + "hash/fnv" + "unsafe" + + "github.com/openimsdk/localcache/link" + "github.com/openimsdk/localcache/lru" +) + +type Cache[V any] interface { + Get(ctx context.Context, key string, fetch func(ctx context.Context) (V, error)) (V, error) + GetLink(ctx context.Context, key string, fetch func(ctx context.Context) (V, error), link ...string) (V, error) + Del(ctx context.Context, key ...string) + DelLocal(ctx context.Context, key ...string) + Stop() +} + +func New[V any](opts ...Option) Cache[V] { + opt := defaultOption() + for _, o := range opts { + o(opt) + } + + c := cache[V]{opt: opt} + if opt.localSlotNum > 0 && opt.localSlotSize > 0 { + createSimpleLRU := func() lru.LRU[string, V] { + if opt.expirationEvict { + return lru.NewExpirationLRU[string, V](opt.localSlotSize, opt.localSuccessTTL, opt.localFailedTTL, opt.target, c.onEvict) + } else { + return lru.NewLayLRU[string, V](opt.localSlotSize, opt.localSuccessTTL, opt.localFailedTTL, opt.target, c.onEvict) + } + } + if opt.localSlotNum == 1 { + c.local = createSimpleLRU() + } else { + c.local = lru.NewSlotLRU[string, V](opt.localSlotNum, func(key string) uint64 { + h := fnv.New64a() + h.Write(*(*[]byte)(unsafe.Pointer(&key))) + return h.Sum64() + }, createSimpleLRU) + } + if opt.linkSlotNum > 0 { + c.link = link.New(opt.linkSlotNum) + } + } + return &c +} + +type cache[V any] struct { + opt *option + link link.Link + local lru.LRU[string, V] +} + +func (c *cache[V]) onEvict(key string, value V) { + if c.link != nil { + lks := c.link.Del(key) + for k := range lks { + if key != k { // prevent deadlock + c.local.Del(k) + } + } + } +} + +func (c *cache[V]) del(key ...string) { + if c.local == nil { + return + } + for _, k := range key { + c.local.Del(k) + if c.link != nil { + lks := c.link.Del(k) + for k := range lks { + c.local.Del(k) + } + } + } +} + +func (c *cache[V]) Get(ctx context.Context, key string, fetch func(ctx context.Context) (V, error)) (V, error) { + return c.GetLink(ctx, key, fetch) +} + +func (c *cache[V]) GetLink(ctx context.Context, key string, fetch func(ctx context.Context) (V, error), link ...string) (V, error) { + if c.local != nil { + return c.local.Get(key, func() (V, error) { + if len(link) > 0 { + c.link.Link(key, link...) + } + return fetch(ctx) + }) + } else { + return fetch(ctx) + } +} + +func (c *cache[V]) Del(ctx context.Context, key ...string) { + for _, fn := range c.opt.delFn { + fn(ctx, key...) + } + c.del(key...) +} + +func (c *cache[V]) DelLocal(ctx context.Context, key ...string) { + c.del(key...) +} + +func (c *cache[V]) Stop() { + c.local.Stop() +} diff --git a/pkg/localcache/cache_test.go b/pkg/localcache/cache_test.go new file mode 100644 index 000000000..c206e6799 --- /dev/null +++ b/pkg/localcache/cache_test.go @@ -0,0 +1,93 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package localcache + +import ( + "context" + "fmt" + "math/rand" + "sync" + "sync/atomic" + "testing" + "time" +) + +func TestName(t *testing.T) { + c := New[string](WithExpirationEvict()) + //c := New[string]() + ctx := context.Background() + + const ( + num = 10000 + tNum = 10000 + kNum = 100000 + pNum = 100 + ) + + getKey := func(v uint64) string { + return fmt.Sprintf("key_%d", v%kNum) + } + + start := time.Now() + t.Log("start", start) + + var ( + get atomic.Int64 + del atomic.Int64 + ) + + incrGet := func() { + if v := get.Add(1); v%pNum == 0 { + //t.Log("#get count", v/pNum) + } + } + incrDel := func() { + if v := del.Add(1); v%pNum == 0 { + //t.Log("@del count", v/pNum) + } + } + + var wg sync.WaitGroup + + for i := 0; i < tNum; i++ { + wg.Add(2) + go func() { + defer wg.Done() + for i := 0; i < num; i++ { + c.Get(ctx, getKey(rand.Uint64()), func(ctx context.Context) (string, error) { + return fmt.Sprintf("index_%d", i), nil + }) + incrGet() + } + }() + + go func() { + defer wg.Done() + time.Sleep(time.Second / 10) + for i := 0; i < num; i++ { + c.Del(ctx, getKey(rand.Uint64())) + incrDel() + } + }() + } + + wg.Wait() + end := time.Now() + t.Log("end", end) + t.Log("time", end.Sub(start)) + t.Log("get", get.Load()) + t.Log("del", del.Load()) + // 137.35s +} diff --git a/pkg/localcache/go.mod b/pkg/localcache/go.mod new file mode 100644 index 000000000..5f0793042 --- /dev/null +++ b/pkg/localcache/go.mod @@ -0,0 +1,5 @@ +module github.com/openimsdk/localcache + +go 1.19 + +require github.com/hashicorp/golang-lru/v2 v2.0.7 diff --git a/pkg/localcache/link/link.go b/pkg/localcache/link/link.go new file mode 100644 index 000000000..8c7701506 --- /dev/null +++ b/pkg/localcache/link/link.go @@ -0,0 +1,123 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package link + +import ( + "hash/fnv" + "sync" + "unsafe" +) + +type Link interface { + Link(key string, link ...string) + Del(key string) map[string]struct{} +} + +func newLinkKey() *linkKey { + return &linkKey{ + data: make(map[string]map[string]struct{}), + } +} + +type linkKey struct { + lock sync.Mutex + data map[string]map[string]struct{} +} + +func (x *linkKey) link(key string, link ...string) { + x.lock.Lock() + defer x.lock.Unlock() + v, ok := x.data[key] + if !ok { + v = make(map[string]struct{}) + x.data[key] = v + } + for _, k := range link { + v[k] = struct{}{} + } +} + +func (x *linkKey) del(key string) map[string]struct{} { + x.lock.Lock() + defer x.lock.Unlock() + ks, ok := x.data[key] + if !ok { + return nil + } + delete(x.data, key) + return ks +} + +func New(n int) Link { + if n <= 0 { + panic("must be greater than 0") + } + slots := make([]*linkKey, n) + for i := 0; i < len(slots); i++ { + slots[i] = newLinkKey() + } + return &slot{ + n: uint64(n), + slots: slots, + } +} + +type slot struct { + n uint64 + slots []*linkKey +} + +func (x *slot) index(s string) uint64 { + h := fnv.New64a() + _, _ = h.Write(*(*[]byte)(unsafe.Pointer(&s))) + return h.Sum64() % x.n +} + +func (x *slot) Link(key string, link ...string) { + if len(link) == 0 { + return + } + mk := key + lks := make([]string, len(link)) + for i, k := range link { + lks[i] = k + } + x.slots[x.index(mk)].link(mk, lks...) + for _, lk := range lks { + x.slots[x.index(lk)].link(lk, mk) + } +} + +func (x *slot) Del(key string) map[string]struct{} { + return x.delKey(key) +} + +func (x *slot) delKey(k string) map[string]struct{} { + del := make(map[string]struct{}) + stack := []string{k} + for len(stack) > 0 { + curr := stack[len(stack)-1] + stack = stack[:len(stack)-1] + if _, ok := del[curr]; ok { + continue + } + del[curr] = struct{}{} + childKeys := x.slots[x.index(curr)].del(curr) + for ck := range childKeys { + stack = append(stack, ck) + } + } + return del +} diff --git a/tools/data-conversion/utils/time.go b/pkg/localcache/link/link_test.go similarity index 67% rename from tools/data-conversion/utils/time.go rename to pkg/localcache/link/link_test.go index 9077a3d88..bb9fee6a0 100644 --- a/tools/data-conversion/utils/time.go +++ b/pkg/localcache/link/link_test.go @@ -1,4 +1,4 @@ -// Copyright © 2023 OpenIM. All rights reserved. +// Copyright © 2024 OpenIM. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -12,17 +12,23 @@ // See the License for the specific language governing permissions and // limitations under the License. -package utils +package link -import "time" +import ( + "testing" +) + +func TestName(t *testing.T) { + + v := New(1) + + //v.Link("a:1", "b:1", "c:1", "d:1") + v.Link("a:1", "b:1", "c:1") + v.Link("z:1", "b:1") + + //v.DelKey("a:1") + v.Del("z:1") + + t.Log(v) -func InitTime(ts ...*time.Time) { - for i := range ts { - if ts[i] == nil { - continue - } - if ts[i].IsZero() || ts[i].UnixMicro() < 0 { - *ts[i] = time.UnixMicro(0) - } - } } diff --git a/tools/data-conversion/openim/mysql/v3/utils.go b/pkg/localcache/lru/lru.go similarity index 58% rename from tools/data-conversion/openim/mysql/v3/utils.go rename to pkg/localcache/lru/lru.go index c944eae8b..64280f238 100644 --- a/tools/data-conversion/openim/mysql/v3/utils.go +++ b/pkg/localcache/lru/lru.go @@ -1,4 +1,4 @@ -// Copyright © 2023 OpenIM. All rights reserved. +// Copyright © 2024 OpenIM. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -12,25 +12,23 @@ // See the License for the specific language governing permissions and // limitations under the License. -package relation +package lru -import ( - "gorm.io/gorm" +import "github.com/hashicorp/golang-lru/v2/simplelru" - "github.com/OpenIMSDK/tools/utils" -) +type EvictCallback[K comparable, V any] simplelru.EvictCallback[K, V] -type BatchUpdateGroupMember struct { - GroupID string - UserID string - Map map[string]any +type LRU[K comparable, V any] interface { + Get(key K, fetch func() (V, error)) (V, error) + Del(key K) bool + Stop() } -type GroupSimpleUserID struct { - Hash uint64 - MemberNum uint32 -} +type Target interface { + IncrGetHit() + IncrGetSuccess() + IncrGetFailed() -func IsNotFound(err error) bool { - return utils.Unwrap(err) == gorm.ErrRecordNotFound + IncrDelHit() + IncrDelNotFound() } diff --git a/pkg/localcache/lru/lru_expiration.go b/pkg/localcache/lru/lru_expiration.go new file mode 100644 index 000000000..970ac083e --- /dev/null +++ b/pkg/localcache/lru/lru_expiration.go @@ -0,0 +1,93 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package lru + +import ( + "sync" + "time" + + "github.com/hashicorp/golang-lru/v2/expirable" +) + +func NewExpirationLRU[K comparable, V any](size int, successTTL, failedTTL time.Duration, target Target, onEvict EvictCallback[K, V]) LRU[K, V] { + var cb expirable.EvictCallback[K, *expirationLruItem[V]] + if onEvict != nil { + cb = func(key K, value *expirationLruItem[V]) { + onEvict(key, value.value) + } + } + core := expirable.NewLRU[K, *expirationLruItem[V]](size, cb, successTTL) + return &ExpirationLRU[K, V]{ + core: core, + successTTL: successTTL, + failedTTL: failedTTL, + target: target, + } +} + +type expirationLruItem[V any] struct { + lock sync.RWMutex + err error + value V +} + +type ExpirationLRU[K comparable, V any] struct { + lock sync.Mutex + core *expirable.LRU[K, *expirationLruItem[V]] + successTTL time.Duration + failedTTL time.Duration + target Target +} + +func (x *ExpirationLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) { + x.lock.Lock() + v, ok := x.core.Get(key) + if ok { + x.lock.Unlock() + x.target.IncrGetSuccess() + v.lock.RLock() + defer v.lock.RUnlock() + return v.value, v.err + } else { + v = &expirationLruItem[V]{} + x.core.Add(key, v) + v.lock.Lock() + x.lock.Unlock() + defer v.lock.Unlock() + v.value, v.err = fetch() + if v.err == nil { + x.target.IncrGetSuccess() + } else { + x.target.IncrGetFailed() + x.core.Remove(key) + } + return v.value, v.err + } +} + +func (x *ExpirationLRU[K, V]) Del(key K) bool { + x.lock.Lock() + ok := x.core.Remove(key) + x.lock.Unlock() + if ok { + x.target.IncrDelHit() + } else { + x.target.IncrDelNotFound() + } + return ok +} + +func (x *ExpirationLRU[K, V]) Stop() { +} diff --git a/pkg/localcache/lru/lru_lazy.go b/pkg/localcache/lru/lru_lazy.go new file mode 100644 index 000000000..d6e64aae4 --- /dev/null +++ b/pkg/localcache/lru/lru_lazy.go @@ -0,0 +1,105 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package lru + +import ( + "sync" + "time" + + "github.com/hashicorp/golang-lru/v2/simplelru" +) + +type layLruItem[V any] struct { + lock sync.Mutex + expires int64 + err error + value V +} + +func NewLayLRU[K comparable, V any](size int, successTTL, failedTTL time.Duration, target Target, onEvict EvictCallback[K, V]) *LayLRU[K, V] { + var cb simplelru.EvictCallback[K, *layLruItem[V]] + if onEvict != nil { + cb = func(key K, value *layLruItem[V]) { + onEvict(key, value.value) + } + } + core, err := simplelru.NewLRU[K, *layLruItem[V]](size, cb) + if err != nil { + panic(err) + } + return &LayLRU[K, V]{ + core: core, + successTTL: successTTL, + failedTTL: failedTTL, + target: target, + } +} + +type LayLRU[K comparable, V any] struct { + lock sync.Mutex + core *simplelru.LRU[K, *layLruItem[V]] + successTTL time.Duration + failedTTL time.Duration + target Target +} + +func (x *LayLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) { + x.lock.Lock() + v, ok := x.core.Get(key) + if ok { + x.lock.Unlock() + v.lock.Lock() + expires, value, err := v.expires, v.value, v.err + if expires != 0 && expires > time.Now().UnixMilli() { + v.lock.Unlock() + x.target.IncrGetHit() + return value, err + } + } else { + v = &layLruItem[V]{} + x.core.Add(key, v) + v.lock.Lock() + x.lock.Unlock() + } + defer v.lock.Unlock() + if v.expires > time.Now().UnixMilli() { + return v.value, v.err + } + v.value, v.err = fetch() + if v.err == nil { + v.expires = time.Now().Add(x.successTTL).UnixMilli() + x.target.IncrGetSuccess() + } else { + v.expires = time.Now().Add(x.failedTTL).UnixMilli() + x.target.IncrGetFailed() + } + return v.value, v.err +} + +func (x *LayLRU[K, V]) Del(key K) bool { + x.lock.Lock() + ok := x.core.Remove(key) + x.lock.Unlock() + if ok { + x.target.IncrDelHit() + } else { + x.target.IncrDelNotFound() + } + return ok +} + +func (x *LayLRU[K, V]) Stop() { + +} diff --git a/pkg/localcache/lru/lru_lazy_test.go b/pkg/localcache/lru/lru_lazy_test.go new file mode 100644 index 000000000..167dd2135 --- /dev/null +++ b/pkg/localcache/lru/lru_lazy_test.go @@ -0,0 +1,118 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package lru + +import ( + "fmt" + "hash/fnv" + "sync" + "sync/atomic" + "testing" + "time" + "unsafe" +) + +type cacheTarget struct { + getHit int64 + getSuccess int64 + getFailed int64 + delHit int64 + delNotFound int64 +} + +func (r *cacheTarget) IncrGetHit() { + atomic.AddInt64(&r.getHit, 1) +} + +func (r *cacheTarget) IncrGetSuccess() { + atomic.AddInt64(&r.getSuccess, 1) +} + +func (r *cacheTarget) IncrGetFailed() { + atomic.AddInt64(&r.getFailed, 1) +} + +func (r *cacheTarget) IncrDelHit() { + atomic.AddInt64(&r.delHit, 1) +} + +func (r *cacheTarget) IncrDelNotFound() { + atomic.AddInt64(&r.delNotFound, 1) +} + +func (r *cacheTarget) String() string { + return fmt.Sprintf("getHit: %d, getSuccess: %d, getFailed: %d, delHit: %d, delNotFound: %d", r.getHit, r.getSuccess, r.getFailed, r.delHit, r.delNotFound) +} + +func TestName(t *testing.T) { + target := &cacheTarget{} + l := NewSlotLRU[string, string](100, func(k string) uint64 { + h := fnv.New64a() + h.Write(*(*[]byte)(unsafe.Pointer(&k))) + return h.Sum64() + }, func() LRU[string, string] { + return NewExpirationLRU[string, string](100, time.Second*60, time.Second, target, nil) + }) + //l := NewInertiaLRU[string, string](1000, time.Second*20, time.Second*5, target) + + fn := func(key string, n int, fetch func() (string, error)) { + for i := 0; i < n; i++ { + //v, err := l.Get(key, fetch) + //if err == nil { + // t.Log("key", key, "value", v) + //} else { + // t.Error("key", key, err) + //} + v, err := l.Get(key, fetch) + //time.Sleep(time.Second / 100) + func(v ...any) {}(v, err) + } + } + + tmp := make(map[string]struct{}) + + var wg sync.WaitGroup + for i := 0; i < 10000; i++ { + wg.Add(1) + key := fmt.Sprintf("key_%d", i%200) + tmp[key] = struct{}{} + go func() { + defer wg.Done() + //t.Log(key) + fn(key, 10000, func() (string, error) { + //time.Sleep(time.Second * 3) + //t.Log(time.Now(), "key", key, "fetch") + //if rand.Uint32()%5 == 0 { + // return "value_" + key, nil + //} + //return "", errors.New("rand error") + return "value_" + key, nil + }) + }() + + //wg.Add(1) + //go func() { + // defer wg.Done() + // for i := 0; i < 10; i++ { + // l.Del(key) + // time.Sleep(time.Second / 3) + // } + //}() + } + wg.Wait() + t.Log(len(tmp)) + t.Log(target.String()) + +} diff --git a/pkg/localcache/lru/lru_slot.go b/pkg/localcache/lru/lru_slot.go new file mode 100644 index 000000000..d034e94d3 --- /dev/null +++ b/pkg/localcache/lru/lru_slot.go @@ -0,0 +1,51 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package lru + +func NewSlotLRU[K comparable, V any](slotNum int, hash func(K) uint64, create func() LRU[K, V]) LRU[K, V] { + x := &slotLRU[K, V]{ + n: uint64(slotNum), + slots: make([]LRU[K, V], slotNum), + hash: hash, + } + for i := 0; i < slotNum; i++ { + x.slots[i] = create() + } + return x +} + +type slotLRU[K comparable, V any] struct { + n uint64 + slots []LRU[K, V] + hash func(k K) uint64 +} + +func (x *slotLRU[K, V]) getIndex(k K) uint64 { + return x.hash(k) % x.n +} + +func (x *slotLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) { + return x.slots[x.getIndex(key)].Get(key, fetch) +} + +func (x *slotLRU[K, V]) Del(key K) bool { + return x.slots[x.getIndex(key)].Del(key) +} + +func (x *slotLRU[K, V]) Stop() { + for _, slot := range x.slots { + slot.Stop() + } +} diff --git a/pkg/localcache/option.go b/pkg/localcache/option.go new file mode 100644 index 000000000..e60d5aa07 --- /dev/null +++ b/pkg/localcache/option.go @@ -0,0 +1,136 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package localcache + +import ( + "context" + "time" + + "github.com/openimsdk/localcache/lru" +) + +func defaultOption() *option { + return &option{ + localSlotNum: 500, + localSlotSize: 20000, + linkSlotNum: 500, + expirationEvict: false, + localSuccessTTL: time.Minute, + localFailedTTL: time.Second * 5, + delFn: make([]func(ctx context.Context, key ...string), 0, 2), + target: emptyTarget{}, + } +} + +type option struct { + localSlotNum int + localSlotSize int + linkSlotNum int + // expirationEvict: true means that the cache will be actively cleared when the timer expires, + // false means that the cache will be lazily deleted. + expirationEvict bool + localSuccessTTL time.Duration + localFailedTTL time.Duration + delFn []func(ctx context.Context, key ...string) + target lru.Target +} + +type Option func(o *option) + +func WithExpirationEvict() Option { + return func(o *option) { + o.expirationEvict = true + } +} + +func WithLazy() Option { + return func(o *option) { + o.expirationEvict = false + } +} + +func WithLocalDisable() Option { + return WithLinkSlotNum(0) +} + +func WithLinkDisable() Option { + return WithLinkSlotNum(0) +} + +func WithLinkSlotNum(linkSlotNum int) Option { + return func(o *option) { + o.linkSlotNum = linkSlotNum + } +} + +func WithLocalSlotNum(localSlotNum int) Option { + return func(o *option) { + o.localSlotNum = localSlotNum + } +} + +func WithLocalSlotSize(localSlotSize int) Option { + return func(o *option) { + o.localSlotSize = localSlotSize + } +} + +func WithLocalSuccessTTL(localSuccessTTL time.Duration) Option { + if localSuccessTTL < 0 { + panic("localSuccessTTL should be greater than 0") + } + return func(o *option) { + o.localSuccessTTL = localSuccessTTL + } +} + +func WithLocalFailedTTL(localFailedTTL time.Duration) Option { + if localFailedTTL < 0 { + panic("localFailedTTL should be greater than 0") + } + return func(o *option) { + o.localFailedTTL = localFailedTTL + } +} + +func WithTarget(target lru.Target) Option { + if target == nil { + panic("target should not be nil") + } + return func(o *option) { + o.target = target + } +} + +func WithDeleteKeyBefore(fn func(ctx context.Context, key ...string)) Option { + if fn == nil { + panic("fn should not be nil") + } + return func(o *option) { + o.delFn = append(o.delFn, fn) + } +} + +type emptyTarget struct{} + +func (e emptyTarget) IncrGetHit() {} + +func (e emptyTarget) IncrGetSuccess() {} + +func (e emptyTarget) IncrGetFailed() {} + +func (e emptyTarget) IncrDelHit() {} + +func (e emptyTarget) IncrDelNotFound() {} diff --git a/pkg/common/db/localcache/meta_local_cache.go b/pkg/localcache/tool.go similarity index 76% rename from pkg/common/db/localcache/meta_local_cache.go rename to pkg/localcache/tool.go index ed9389c27..ec04ea990 100644 --- a/pkg/common/db/localcache/meta_local_cache.go +++ b/pkg/localcache/tool.go @@ -1,4 +1,4 @@ -// Copyright © 2023 OpenIM. All rights reserved. +// Copyright © 2024 OpenIM. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -13,3 +13,11 @@ // limitations under the License. package localcache + +func AnyValue[V any](v any, err error) (V, error) { + if err != nil { + var zero V + return zero, err + } + return v.(V), nil +} diff --git a/tools/data-conversion/chat/v3/admin/client_config.go b/pkg/rpccache/common.go similarity index 57% rename from tools/data-conversion/chat/v3/admin/client_config.go rename to pkg/rpccache/common.go index 48869fceb..5ed007edc 100644 --- a/tools/data-conversion/chat/v3/admin/client_config.go +++ b/pkg/rpccache/common.go @@ -1,4 +1,4 @@ -// Copyright © 2023 OpenIM open source community. All rights reserved. +// Copyright © 2024 OpenIM. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -12,14 +12,23 @@ // See the License for the specific language governing permissions and // limitations under the License. -package admin +package rpccache -// ClientConfig Client related configuration items. -type ClientConfig struct { - Key string `gorm:"column:key;primary_key;type:varchar(255)"` - Value string `gorm:"column:value;not null;type:text"` +func newListMap[V comparable](values []V, err error) (*listMap[V], error) { + if err != nil { + return nil, err + } + lm := &listMap[V]{ + List: values, + Map: make(map[V]struct{}, len(values)), + } + for _, value := range values { + lm.Map[value] = struct{}{} + } + return lm, nil } -func (ClientConfig) TableName() string { - return "client_config" +type listMap[V comparable] struct { + List []V + Map map[V]struct{} } diff --git a/pkg/rpccache/conversation.go b/pkg/rpccache/conversation.go new file mode 100644 index 000000000..027ef42fa --- /dev/null +++ b/pkg/rpccache/conversation.go @@ -0,0 +1,127 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package rpccache + +import ( + "context" + + pbconversation "github.com/OpenIMSDK/protocol/conversation" + "github.com/OpenIMSDK/tools/errs" + "github.com/OpenIMSDK/tools/log" + "github.com/openimsdk/localcache" + "github.com/openimsdk/open-im-server/v3/pkg/common/cachekey" + "github.com/openimsdk/open-im-server/v3/pkg/common/config" + "github.com/openimsdk/open-im-server/v3/pkg/rpcclient" + "github.com/redis/go-redis/v9" +) + +func NewConversationLocalCache(client rpcclient.ConversationRpcClient, cli redis.UniversalClient) *ConversationLocalCache { + lc := config.Config.LocalCache.Conversation + log.ZDebug(context.Background(), "ConversationLocalCache", "topic", lc.Topic, "slotNum", lc.SlotNum, "slotSize", lc.SlotSize, "enable", lc.Enable()) + x := &ConversationLocalCache{ + client: client, + local: localcache.New[any]( + localcache.WithLocalSlotNum(lc.SlotNum), + localcache.WithLocalSlotSize(lc.SlotSize), + localcache.WithLinkSlotNum(lc.SlotNum), + localcache.WithLocalSuccessTTL(lc.Success()), + localcache.WithLocalFailedTTL(lc.Failed()), + ), + } + if lc.Enable() { + go subscriberRedisDeleteCache(context.Background(), cli, lc.Topic, x.local.DelLocal) + } + return x +} + +type ConversationLocalCache struct { + client rpcclient.ConversationRpcClient + local localcache.Cache[any] +} + +func (c *ConversationLocalCache) GetConversationIDs(ctx context.Context, ownerUserID string) (val []string, err error) { + log.ZDebug(ctx, "ConversationLocalCache GetConversationIDs req", "ownerUserID", ownerUserID) + defer func() { + if err == nil { + log.ZDebug(ctx, "ConversationLocalCache GetConversationIDs return", "value", val) + } else { + log.ZError(ctx, "ConversationLocalCache GetConversationIDs return", err) + } + }() + return localcache.AnyValue[[]string](c.local.Get(ctx, cachekey.GetConversationIDsKey(ownerUserID), func(ctx context.Context) (any, error) { + log.ZDebug(ctx, "ConversationLocalCache GetConversationIDs rpc", "ownerUserID", ownerUserID) + return c.client.GetConversationIDs(ctx, ownerUserID) + })) +} + +func (c *ConversationLocalCache) GetConversation(ctx context.Context, userID, conversationID string) (val *pbconversation.Conversation, err error) { + log.ZDebug(ctx, "ConversationLocalCache GetConversation req", "userID", userID, "conversationID", conversationID) + defer func() { + if err == nil { + log.ZDebug(ctx, "ConversationLocalCache GetConversation return", "value", val) + } else { + log.ZError(ctx, "ConversationLocalCache GetConversation return", err) + } + }() + return localcache.AnyValue[*pbconversation.Conversation](c.local.Get(ctx, cachekey.GetConversationKey(userID, conversationID), func(ctx context.Context) (any, error) { + log.ZDebug(ctx, "ConversationLocalCache GetConversation rpc", "userID", userID, "conversationID", conversationID) + return c.client.GetConversation(ctx, userID, conversationID) + })) +} + +func (c *ConversationLocalCache) GetSingleConversationRecvMsgOpt(ctx context.Context, userID, conversationID string) (int32, error) { + conv, err := c.GetConversation(ctx, userID, conversationID) + if err != nil { + return 0, err + } + return conv.RecvMsgOpt, nil +} + +func (c *ConversationLocalCache) GetConversations(ctx context.Context, ownerUserID string, conversationIDs []string) ([]*pbconversation.Conversation, error) { + conversations := make([]*pbconversation.Conversation, 0, len(conversationIDs)) + for _, conversationID := range conversationIDs { + conversation, err := c.GetConversation(ctx, ownerUserID, conversationID) + if err != nil { + if errs.ErrRecordNotFound.Is(err) { + continue + } + return nil, err + } + conversations = append(conversations, conversation) + } + return conversations, nil +} + +func (c *ConversationLocalCache) getConversationNotReceiveMessageUserIDs(ctx context.Context, conversationID string) (*listMap[string], error) { + return localcache.AnyValue[*listMap[string]](c.local.Get(ctx, cachekey.GetConversationNotReceiveMessageUserIDsKey(conversationID), func(ctx context.Context) (any, error) { + return newListMap(c.client.GetConversationNotReceiveMessageUserIDs(ctx, conversationID)) + })) +} + +func (c *ConversationLocalCache) GetConversationNotReceiveMessageUserIDs(ctx context.Context, conversationID string) ([]string, error) { + res, err := c.getConversationNotReceiveMessageUserIDs(ctx, conversationID) + if err != nil { + return nil, err + } + return res.List, nil +} + +func (c *ConversationLocalCache) GetConversationNotReceiveMessageUserIDMap(ctx context.Context, conversationID string) (map[string]struct{}, error) { + res, err := c.getConversationNotReceiveMessageUserIDs(ctx, conversationID) + if err != nil { + return nil, err + } + return res.Map, nil +} diff --git a/pkg/rpccache/friend.go b/pkg/rpccache/friend.go new file mode 100644 index 000000000..35122fff5 --- /dev/null +++ b/pkg/rpccache/friend.go @@ -0,0 +1,81 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package rpccache + +import ( + "context" + + "github.com/OpenIMSDK/tools/log" + "github.com/openimsdk/localcache" + "github.com/openimsdk/open-im-server/v3/pkg/common/cachekey" + "github.com/openimsdk/open-im-server/v3/pkg/common/config" + "github.com/openimsdk/open-im-server/v3/pkg/rpcclient" + "github.com/redis/go-redis/v9" +) + +func NewFriendLocalCache(client rpcclient.FriendRpcClient, cli redis.UniversalClient) *FriendLocalCache { + lc := config.Config.LocalCache.Friend + log.ZDebug(context.Background(), "FriendLocalCache", "topic", lc.Topic, "slotNum", lc.SlotNum, "slotSize", lc.SlotSize, "enable", lc.Enable()) + x := &FriendLocalCache{ + client: client, + local: localcache.New[any]( + localcache.WithLocalSlotNum(lc.SlotNum), + localcache.WithLocalSlotSize(lc.SlotSize), + localcache.WithLinkSlotNum(lc.SlotNum), + localcache.WithLocalSuccessTTL(lc.Success()), + localcache.WithLocalFailedTTL(lc.Failed()), + ), + } + if lc.Enable() { + go subscriberRedisDeleteCache(context.Background(), cli, lc.Topic, x.local.DelLocal) + } + return x +} + +type FriendLocalCache struct { + client rpcclient.FriendRpcClient + local localcache.Cache[any] +} + +func (f *FriendLocalCache) IsFriend(ctx context.Context, possibleFriendUserID, userID string) (val bool, err error) { + log.ZDebug(ctx, "FriendLocalCache IsFriend req", "possibleFriendUserID", possibleFriendUserID, "userID", userID) + defer func() { + if err == nil { + log.ZDebug(ctx, "FriendLocalCache IsFriend return", "value", val) + } else { + log.ZError(ctx, "FriendLocalCache IsFriend return", err) + } + }() + return localcache.AnyValue[bool](f.local.GetLink(ctx, cachekey.GetIsFriendKey(possibleFriendUserID, userID), func(ctx context.Context) (any, error) { + log.ZDebug(ctx, "FriendLocalCache IsFriend rpc", "possibleFriendUserID", possibleFriendUserID, "userID", userID) + return f.client.IsFriend(ctx, possibleFriendUserID, userID) + }, cachekey.GetFriendIDsKey(possibleFriendUserID))) +} + +// IsBlack possibleBlackUserID selfUserID. +func (f *FriendLocalCache) IsBlack(ctx context.Context, possibleBlackUserID, userID string) (val bool, err error) { + log.ZDebug(ctx, "FriendLocalCache IsBlack req", "possibleBlackUserID", possibleBlackUserID, "userID", userID) + defer func() { + if err == nil { + log.ZDebug(ctx, "FriendLocalCache IsBlack return", "value", val) + } else { + log.ZError(ctx, "FriendLocalCache IsBlack return", err) + } + }() + return localcache.AnyValue[bool](f.local.GetLink(ctx, cachekey.GetIsBlackIDsKey(possibleBlackUserID, userID), func(ctx context.Context) (any, error) { + log.ZDebug(ctx, "FriendLocalCache IsBlack rpc", "possibleBlackUserID", possibleBlackUserID, "userID", userID) + return f.client.IsBlack(ctx, possibleBlackUserID, userID) + }, cachekey.GetBlackIDsKey(userID))) +} diff --git a/pkg/rpccache/group.go b/pkg/rpccache/group.go new file mode 100644 index 000000000..402f63185 --- /dev/null +++ b/pkg/rpccache/group.go @@ -0,0 +1,158 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package rpccache + +import ( + "context" + + "github.com/OpenIMSDK/protocol/sdkws" + "github.com/OpenIMSDK/tools/errs" + "github.com/OpenIMSDK/tools/log" + "github.com/openimsdk/localcache" + "github.com/openimsdk/open-im-server/v3/pkg/common/cachekey" + "github.com/openimsdk/open-im-server/v3/pkg/common/config" + "github.com/openimsdk/open-im-server/v3/pkg/rpcclient" + "github.com/redis/go-redis/v9" +) + +func NewGroupLocalCache(client rpcclient.GroupRpcClient, cli redis.UniversalClient) *GroupLocalCache { + lc := config.Config.LocalCache.Group + log.ZDebug(context.Background(), "GroupLocalCache", "topic", lc.Topic, "slotNum", lc.SlotNum, "slotSize", lc.SlotSize, "enable", lc.Enable()) + x := &GroupLocalCache{ + client: client, + local: localcache.New[any]( + localcache.WithLocalSlotNum(lc.SlotNum), + localcache.WithLocalSlotSize(lc.SlotSize), + localcache.WithLinkSlotNum(lc.SlotNum), + localcache.WithLocalSuccessTTL(lc.Success()), + localcache.WithLocalFailedTTL(lc.Failed()), + ), + } + if lc.Enable() { + go subscriberRedisDeleteCache(context.Background(), cli, lc.Topic, x.local.DelLocal) + } + return x +} + +type GroupLocalCache struct { + client rpcclient.GroupRpcClient + local localcache.Cache[any] +} + +func (g *GroupLocalCache) getGroupMemberIDs(ctx context.Context, groupID string) (val *listMap[string], err error) { + log.ZDebug(ctx, "GroupLocalCache getGroupMemberIDs req", "groupID", groupID) + defer func() { + if err == nil { + log.ZDebug(ctx, "GroupLocalCache getGroupMemberIDs return", "value", val) + } else { + log.ZError(ctx, "GroupLocalCache getGroupMemberIDs return", err) + } + }() + return localcache.AnyValue[*listMap[string]](g.local.Get(ctx, cachekey.GetGroupMemberIDsKey(groupID), func(ctx context.Context) (any, error) { + log.ZDebug(ctx, "GroupLocalCache getGroupMemberIDs rpc", "groupID", groupID) + return newListMap(g.client.GetGroupMemberIDs(ctx, groupID)) + })) +} + +func (g *GroupLocalCache) GetGroupMember(ctx context.Context, groupID, userID string) (val *sdkws.GroupMemberFullInfo, err error) { + log.ZDebug(ctx, "GroupLocalCache GetGroupInfo req", "groupID", groupID, "userID", userID) + defer func() { + if err == nil { + log.ZDebug(ctx, "GroupLocalCache GetGroupInfo return", "value", val) + } else { + log.ZError(ctx, "GroupLocalCache GetGroupInfo return", err) + } + }() + return localcache.AnyValue[*sdkws.GroupMemberFullInfo](g.local.Get(ctx, cachekey.GetGroupMemberInfoKey(groupID, userID), func(ctx context.Context) (any, error) { + log.ZDebug(ctx, "GroupLocalCache GetGroupInfo rpc", "groupID", groupID, "userID", userID) + return g.client.GetGroupMemberCache(ctx, groupID, userID) + })) +} + +func (g *GroupLocalCache) GetGroupInfo(ctx context.Context, groupID string) (val *sdkws.GroupInfo, err error) { + log.ZDebug(ctx, "GroupLocalCache GetGroupInfo req", "groupID", groupID) + defer func() { + if err == nil { + log.ZDebug(ctx, "GroupLocalCache GetGroupInfo return", "value", val) + } else { + log.ZError(ctx, "GroupLocalCache GetGroupInfo return", err) + } + }() + return localcache.AnyValue[*sdkws.GroupInfo](g.local.Get(ctx, cachekey.GetGroupInfoKey(groupID), func(ctx context.Context) (any, error) { + log.ZDebug(ctx, "GroupLocalCache GetGroupInfo rpc", "groupID", groupID) + return g.client.GetGroupInfoCache(ctx, groupID) + })) +} + +func (g *GroupLocalCache) GetGroupMemberIDs(ctx context.Context, groupID string) ([]string, error) { + res, err := g.getGroupMemberIDs(ctx, groupID) + if err != nil { + return nil, err + } + return res.List, nil +} + +func (g *GroupLocalCache) GetGroupMemberIDMap(ctx context.Context, groupID string) (map[string]struct{}, error) { + res, err := g.getGroupMemberIDs(ctx, groupID) + if err != nil { + return nil, err + } + return res.Map, nil +} + +func (g *GroupLocalCache) GetGroupInfos(ctx context.Context, groupIDs []string) ([]*sdkws.GroupInfo, error) { + groupInfos := make([]*sdkws.GroupInfo, 0, len(groupIDs)) + for _, groupID := range groupIDs { + groupInfo, err := g.GetGroupInfo(ctx, groupID) + if err != nil { + if errs.ErrRecordNotFound.Is(err) { + continue + } + return nil, err + } + groupInfos = append(groupInfos, groupInfo) + } + return groupInfos, nil +} + +func (g *GroupLocalCache) GetGroupMembers(ctx context.Context, groupID string, userIDs []string) ([]*sdkws.GroupMemberFullInfo, error) { + members := make([]*sdkws.GroupMemberFullInfo, 0, len(userIDs)) + for _, userID := range userIDs { + member, err := g.GetGroupMember(ctx, groupID, userID) + if err != nil { + if errs.ErrRecordNotFound.Is(err) { + continue + } + return nil, err + } + members = append(members, member) + } + return members, nil +} + +func (g *GroupLocalCache) GetGroupMemberInfoMap(ctx context.Context, groupID string, userIDs []string) (map[string]*sdkws.GroupMemberFullInfo, error) { + members := make(map[string]*sdkws.GroupMemberFullInfo) + for _, userID := range userIDs { + member, err := g.GetGroupMember(ctx, groupID, userID) + if err != nil { + if errs.ErrRecordNotFound.Is(err) { + continue + } + return nil, err + } + members[userID] = member + } + return members, nil +} diff --git a/pkg/rpccache/subscriber.go b/pkg/rpccache/subscriber.go new file mode 100644 index 000000000..cd65094e2 --- /dev/null +++ b/pkg/rpccache/subscriber.go @@ -0,0 +1,38 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package rpccache + +import ( + "context" + "encoding/json" + + "github.com/OpenIMSDK/tools/log" + "github.com/redis/go-redis/v9" +) + +func subscriberRedisDeleteCache(ctx context.Context, client redis.UniversalClient, channel string, del func(ctx context.Context, key ...string)) { + for message := range client.Subscribe(ctx, channel).Channel() { + log.ZDebug(ctx, "subscriberRedisDeleteCache", "channel", channel, "payload", message.Payload) + var keys []string + if err := json.Unmarshal([]byte(message.Payload), &keys); err != nil { + log.ZError(ctx, "subscriberRedisDeleteCache json.Unmarshal error", err) + continue + } + if len(keys) == 0 { + continue + } + del(ctx, keys...) + } +} diff --git a/pkg/rpccache/user.go b/pkg/rpccache/user.go new file mode 100644 index 000000000..c48b05821 --- /dev/null +++ b/pkg/rpccache/user.go @@ -0,0 +1,112 @@ +// Copyright © 2024 OpenIM. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package rpccache + +import ( + "context" + + "github.com/OpenIMSDK/protocol/sdkws" + "github.com/OpenIMSDK/tools/errs" + "github.com/OpenIMSDK/tools/log" + "github.com/openimsdk/localcache" + "github.com/openimsdk/open-im-server/v3/pkg/common/cachekey" + "github.com/openimsdk/open-im-server/v3/pkg/common/config" + "github.com/openimsdk/open-im-server/v3/pkg/rpcclient" + "github.com/redis/go-redis/v9" +) + +func NewUserLocalCache(client rpcclient.UserRpcClient, cli redis.UniversalClient) *UserLocalCache { + lc := config.Config.LocalCache.User + log.ZDebug(context.Background(), "UserLocalCache", "topic", lc.Topic, "slotNum", lc.SlotNum, "slotSize", lc.SlotSize, "enable", lc.Enable()) + x := &UserLocalCache{ + client: client, + local: localcache.New[any]( + localcache.WithLocalSlotNum(lc.SlotNum), + localcache.WithLocalSlotSize(lc.SlotSize), + localcache.WithLinkSlotNum(lc.SlotNum), + localcache.WithLocalSuccessTTL(lc.Success()), + localcache.WithLocalFailedTTL(lc.Failed()), + ), + } + if lc.Enable() { + go subscriberRedisDeleteCache(context.Background(), cli, lc.Topic, x.local.DelLocal) + } + return x +} + +type UserLocalCache struct { + client rpcclient.UserRpcClient + local localcache.Cache[any] +} + +func (u *UserLocalCache) GetUserInfo(ctx context.Context, userID string) (val *sdkws.UserInfo, err error) { + log.ZDebug(ctx, "UserLocalCache GetUserInfo req", "userID", userID) + defer func() { + if err == nil { + log.ZDebug(ctx, "UserLocalCache GetUserInfo return", "value", val) + } else { + log.ZError(ctx, "UserLocalCache GetUserInfo return", err) + } + }() + return localcache.AnyValue[*sdkws.UserInfo](u.local.Get(ctx, cachekey.GetUserInfoKey(userID), func(ctx context.Context) (any, error) { + log.ZDebug(ctx, "UserLocalCache GetUserInfo rpc", "userID", userID) + return u.client.GetUserInfo(ctx, userID) + })) +} + +func (u *UserLocalCache) GetUserGlobalMsgRecvOpt(ctx context.Context, userID string) (val int32, err error) { + log.ZDebug(ctx, "UserLocalCache GetUserGlobalMsgRecvOpt req", "userID", userID) + defer func() { + if err == nil { + log.ZDebug(ctx, "UserLocalCache GetUserGlobalMsgRecvOpt return", "value", val) + } else { + log.ZError(ctx, "UserLocalCache GetUserGlobalMsgRecvOpt return", err) + } + }() + return localcache.AnyValue[int32](u.local.Get(ctx, cachekey.GetUserGlobalRecvMsgOptKey(userID), func(ctx context.Context) (any, error) { + log.ZDebug(ctx, "UserLocalCache GetUserGlobalMsgRecvOpt rpc", "userID", userID) + return u.client.GetUserGlobalMsgRecvOpt(ctx, userID) + })) +} + +func (u *UserLocalCache) GetUsersInfo(ctx context.Context, userIDs []string) ([]*sdkws.UserInfo, error) { + users := make([]*sdkws.UserInfo, 0, len(userIDs)) + for _, userID := range userIDs { + user, err := u.GetUserInfo(ctx, userID) + if err != nil { + if errs.ErrRecordNotFound.Is(err) { + continue + } + return nil, err + } + users = append(users, user) + } + return users, nil +} + +func (u *UserLocalCache) GetUsersInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error) { + users := make(map[string]*sdkws.UserInfo, len(userIDs)) + for _, userID := range userIDs { + user, err := u.GetUserInfo(ctx, userID) + if err != nil { + if errs.ErrRecordNotFound.Is(err) { + continue + } + return nil, err + } + users[userID] = user + } + return users, nil +} diff --git a/pkg/rpcclient/conversation.go b/pkg/rpcclient/conversation.go index 6981844b6..127e029e1 100644 --- a/pkg/rpcclient/conversation.go +++ b/pkg/rpcclient/conversation.go @@ -114,6 +114,14 @@ func (c *ConversationRpcClient) GetConversationsByConversationID(ctx context.Con return resp.Conversations, nil } +func (c *ConversationRpcClient) GetConversationOfflinePushUserIDs(ctx context.Context, conversationID string, userIDs []string) ([]string, error) { + resp, err := c.Client.GetConversationOfflinePushUserIDs(ctx, &pbconversation.GetConversationOfflinePushUserIDsReq{ConversationID: conversationID, UserIDs: userIDs}) + if err != nil { + return nil, err + } + return resp.UserIDs, nil +} + func (c *ConversationRpcClient) GetConversations(ctx context.Context, ownerUserID string, conversationIDs []string) ([]*pbconversation.Conversation, error) { if len(conversationIDs) == 0 { return nil, nil @@ -127,3 +135,11 @@ func (c *ConversationRpcClient) GetConversations(ctx context.Context, ownerUserI } return resp.Conversations, nil } + +func (c *ConversationRpcClient) GetConversationNotReceiveMessageUserIDs(ctx context.Context, conversationID string) ([]string, error) { + resp, err := c.Client.GetConversationNotReceiveMessageUserIDs(ctx, &pbconversation.GetConversationNotReceiveMessageUserIDsReq{ConversationID: conversationID}) + if err != nil { + return nil, err + } + return resp.UserIDs, nil +} diff --git a/pkg/rpcclient/friend.go b/pkg/rpcclient/friend.go index e1f6ed076..5a5f38698 100644 --- a/pkg/rpcclient/friend.go +++ b/pkg/rpcclient/friend.go @@ -80,7 +80,7 @@ func (f *FriendRpcClient) GetFriendIDs(ctx context.Context, ownerUserID string) return resp.FriendIDs, nil } -func (b *FriendRpcClient) IsBlocked(ctx context.Context, possibleBlackUserID, userID string) (bool, error) { +func (b *FriendRpcClient) IsBlack(ctx context.Context, possibleBlackUserID, userID string) (bool, error) { r, err := b.Client.IsBlack(ctx, &friend.IsBlackReq{UserID1: possibleBlackUserID, UserID2: userID}) if err != nil { return false, err diff --git a/pkg/rpcclient/group.go b/pkg/rpcclient/group.go index 773637858..ec7aab695 100644 --- a/pkg/rpcclient/group.go +++ b/pkg/rpcclient/group.go @@ -26,11 +26,9 @@ import ( "github.com/OpenIMSDK/tools/utils" "github.com/openimsdk/open-im-server/v3/pkg/common/config" util "github.com/openimsdk/open-im-server/v3/pkg/util/genutil" - "google.golang.org/grpc" ) type Group struct { - conn grpc.ClientConnInterface Client group.GroupClient discov discoveryregistry.SvcDiscoveryRegistry Config *config.GlobalConfig @@ -42,7 +40,7 @@ func NewGroup(discov discoveryregistry.SvcDiscoveryRegistry, config *config.Glob util.ExitWithError(err) } client := group.NewGroupClient(conn) - return &Group{discov: discov, conn: conn, Client: client, Config: config} + return &Group{discov: discov, Client: client, Config: config} } type GroupRpcClient Group diff --git a/scripts/cherry-pick.sh b/scripts/cherry-pick.sh index f8d7912f8..ff303269d 100755 --- a/scripts/cherry-pick.sh +++ b/scripts/cherry-pick.sh @@ -21,10 +21,6 @@ # checks them out to a branch named: # automated-cherry-pick-of--- - - - - OPENIM_ROOT=$(dirname "${BASH_SOURCE[0]}")/.. source "${OPENIM_ROOT}/scripts/lib/init.sh" diff --git a/scripts/docker-start-all.sh b/scripts/docker-start-all.sh index 4c9b7308f..4f8747a2a 100755 --- a/scripts/docker-start-all.sh +++ b/scripts/docker-start-all.sh @@ -25,5 +25,5 @@ OPENIM_ROOT=$(dirname "${BASH_SOURCE[0]}")/.. source "${OPENIM_ROOT}/scripts/install/common.sh" openim::log::info "\n# Use Docker to start all openim service" trap 'openim::util::onCtrlC' INT -"${OPENIM_ROOT}"/scripts/start-all.sh +"${OPENIM_ROOT}"/scripts/start-all.sh 2>&1 & tail -f ${DOCKER_LOG_FILE} diff --git a/scripts/init-config.sh b/scripts/init-config.sh index c7cf16320..c5b21d061 100755 --- a/scripts/init-config.sh +++ b/scripts/init-config.sh @@ -150,6 +150,12 @@ process_file() { exit 1 fi if [[ -n "${env_cmd}" ]]; then + + { + printf "debugggggggggggggggggggg file: %s template: %s\n" "${ENV_FILE}" "${template}" + } | tee /tmp/debug.log + + eval "$env_cmd ${OPENIM_ROOT}/scripts/genconfig.sh '${ENV_FILE}' '${template}' > '${output_file}'" || { openim::log::error "Error processing template file ${template}" exit 1 diff --git a/scripts/install/openim-tools.sh b/scripts/install/openim-tools.sh index 04cd70adf..7f6e1f52b 100755 --- a/scripts/install/openim-tools.sh +++ b/scripts/install/openim-tools.sh @@ -58,7 +58,6 @@ openim::tools::pre_start_name() { local targets=( ncpu component - up35 ) echo "${targets[@]}" } @@ -101,7 +100,13 @@ function openim::tools::start_service() { cmd="${cmd} --prometheus_port ${prometheus_port}" fi openim::log::status "Starting binary ${binary_name}..." + + + ${cmd} + + + local status=$? if [ $status -eq 0 ]; then diff --git a/scripts/install/test.sh b/scripts/install/test.sh index 4ea3f16ca..326307570 100755 --- a/scripts/install/test.sh +++ b/scripts/install/test.sh @@ -1272,7 +1272,7 @@ openim::test::search_msg() { { "sendID": "${sendID}", "recvID": "${recvID}", - "msgType": ${msgType}, + "contentType": ${msgType}, "sendTime": "${sendTime}", "sessionType": ${sessionType}, "pagination": { diff --git a/scripts/lib/util.sh b/scripts/lib/util.sh index e9908ae66..7bcfbad97 100755 --- a/scripts/lib/util.sh +++ b/scripts/lib/util.sh @@ -1795,10 +1795,6 @@ openim::util::stop_services_on_ports() { return 0 fi } -# nc -l -p 12345 -# nc -l -p 123456 -# ps -ef | grep "nc -l" -# openim::util::stop_services_on_ports 1234 12345 # The `openim::util::stop_services_with_name` function stops services with specified names. @@ -1808,68 +1804,7 @@ openim::util::stop_services_on_ports() { # Usage: # openim::util::stop_services_with_name nginx apache # The function returns a status of 1 if any service couldn't be stopped. -openim::util::stop_services_with_name() { - # An array to collect names of processes that couldn't be stopped. - local not_stopped=() - - # An array to collect information about processes that were stopped. - local stopped=() - - echo "Stopping services with names: $*" - # Iterate over each given service name. - for server_name in "$@"; do - # Use the `pgrep` command to find process IDs related to the given service name. - local pids=$(pgrep -f "$server_name") - - # If no process was found with the name, add it to the not_stopped list - if [[ -z $pids ]]; then - not_stopped+=("$server_name") - continue - fi - local stopped_this_time=false - for pid in $pids; do - # Exclude the PID of the current script - if [[ "$pid" == "$$" ]]; then - continue - fi - - # If there's a Process ID, it means the service with the name is running. - if [[ -n $pid ]]; then - # Try to stop the service by killing its process. - if kill -10 $pid 2>/dev/null; then - stopped_this_time=true - fi - fi - done - - if $stopped_this_time; then - stopped+=("$server_name") - else - not_stopped+=("$server_name") - fi - done - - # Print information about services whose processes couldn't be stopped. - if [[ ${#not_stopped[@]} -ne 0 ]]; then - echo "Services that couldn't be stopped:" - for name in "${not_stopped[@]}"; do - openim::log::status "Failed to stop the $name service." - done - fi - - # Print information about services whose processes were successfully stopped. - if [[ ${#stopped[@]} -ne 0 ]]; then - echo - echo "Stopped services:" - for name in "${stopped[@]}"; do - echo "Successfully stopped the $name service." - done - fi - - openim::log::success "All specified services were stopped." - echo "" -} # sleep 333333& # sleep 444444& # ps -ef | grep "sleep" diff --git a/scripts/start-all.sh b/scripts/start-all.sh index aac4b1837..952995032 100755 --- a/scripts/start-all.sh +++ b/scripts/start-all.sh @@ -63,7 +63,7 @@ function execute_start_scripts() { if openim::util::is_running_in_container; then - exec > ${DOCKER_LOG_FILE} 2>&1 + exec >> ${DOCKER_LOG_FILE} 2>&1 fi diff --git a/scripts/verify-shellcheck.sh b/scripts/verify-shellcheck.sh index c7e713d09..0c4f165bf 100755 --- a/scripts/verify-shellcheck.sh +++ b/scripts/verify-shellcheck.sh @@ -87,6 +87,7 @@ disabled=( 2178 2064 2260 + 2261 2043 2178 2044 diff --git a/tools/component/component.go b/tools/component/component.go index e3b5b1956..3220f36f7 100644 --- a/tools/component/component.go +++ b/tools/component/component.go @@ -30,9 +30,9 @@ import ( "github.com/OpenIMSDK/tools/component" "github.com/OpenIMSDK/tools/errs" - "github.com/openimsdk/open-im-server/v3/pkg/common/config" - "gopkg.in/yaml.v3" + + "github.com/openimsdk/open-im-server/v3/pkg/common/config" ) const ( @@ -66,6 +66,23 @@ type checkFunc struct { config *config.GlobalConfig } +// colorErrPrint prints formatted string in red to stderr +func colorErrPrint(msg string) { + // ANSI escape code for red text + const redColor = "\033[31m" + // ANSI escape code to reset color + const resetColor = "\033[0m" + msg = redColor + msg + resetColor + // Print to stderr in red + fmt.Fprintf(os.Stderr, "%s\n", msg) +} + +func colorSuccessPrint(format string, a ...interface{}) { + // ANSI escape code for green text is \033[32m + // \033[0m resets the color + fmt.Printf("\033[32m"+format+"\033[0m", a...) +} + func main() { flag.Parse() @@ -77,7 +94,7 @@ func main() { err = configGetEnv(conf) if err != nil { - fmt.Printf("configGetEnv failed,err:%v", err) + fmt.Printf("configGetEnv failed, err:%v", err) return } @@ -94,7 +111,7 @@ func main() { if i != 0 { time.Sleep(1 * time.Second) } - fmt.Printf("Checking components Round %v...\n", i+1) + fmt.Printf("Checking components round %v...\n", i+1) var err error allSuccess := true @@ -102,33 +119,31 @@ func main() { if !check.flag { err = check.function(check.config) if err != nil { - if errors.Is(err, errMinioNotEnabled) { - fmt.Println(err.Error()) - checks[index].flag = true - } - if errors.Is(err, errSignEndPoint) { - fmt.Fprintf(os.Stderr, err.Error()) - checks[index].flag = true - } - component.ErrorPrint(fmt.Sprintf("Starting %s failed:%v.", check.name, errs.Unwrap(err).Error())) - if !strings.Contains(errs.Unwrap(err).Error(), "connection refused") && - !strings.Contains(errs.Unwrap(err).Error(), "timeout waiting") { - component.ErrorPrint("Some components started failed!") - os.Exit(-1) + allSuccess = false + colorErrPrint(fmt.Sprintf("Check component: %s, failed: %v", check.name, err.Error())) + + if check.name == "Minio" { + if errors.Is(err, errMinioNotEnabled) || + errors.Is(err, errSignEndPoint) || + errors.Is(err, errApiURL) { + checks[index].flag = true + continue + } + break } } else { checks[index].flag = true component.SuccessPrint(fmt.Sprintf("%s connected successfully", check.name)) } } - } + } if allSuccess { component.SuccessPrint("All components started successfully!") return } } - component.ErrorPrint("Some components started failed!") + component.ErrorPrint("Some components checked failed!") os.Exit(-1) } @@ -166,13 +181,13 @@ func checkRedis(config *config.GlobalConfig) error { // checkMinio checks the MinIO connection func checkMinio(config *config.GlobalConfig) error { if strings.Contains(config.Object.ApiURL, "127.0.0.1") { - return errs.Wrap(errApiURL, "config.Object.ApiURL: "+config.Object.ApiURL) + return errs.Wrap(errApiURL) } if config.Object.Enable != "minio" { - return errs.Wrap(errMinioNotEnabled, "config.Object.Enable: "+config.Object.Enable) + return errs.Wrap(errMinioNotEnabled) } if strings.Contains(config.Object.Minio.Endpoint, "127.0.0.1") { - return errs.Wrap(errSignEndPoint, "config.Object.Minio.Endpoint: "+config.Object.Minio.Endpoint) + return errs.Wrap(errSignEndPoint) } minio := &component.Minio{ @@ -258,13 +273,13 @@ func checkKafka(config *config.GlobalConfig) error { _, err = kafka.NewMConsumerGroup(&kafka.MConsumerGroupConfig{ KafkaVersion: sarama.V2_0_0_0, OffsetsInitial: sarama.OffsetNewest, IsReturnErr: false, - }, []string{config.Kafka.MsgToPush.Topic}, + }, []string{config.Kafka.MsgToMongo.Topic}, config.Kafka.Addr, config.Kafka.ConsumerGroupID.MsgToMongo, tlsConfig) if err != nil { return err } - kafka.NewMConsumerGroup(&kafka.MConsumerGroupConfig{ + _, err = kafka.NewMConsumerGroup(&kafka.MConsumerGroupConfig{ KafkaVersion: sarama.V2_0_0_0, OffsetsInitial: sarama.OffsetNewest, IsReturnErr: false, }, []string{config.Kafka.MsgToPush.Topic}, config.Kafka.Addr, @@ -292,15 +307,15 @@ func configGetEnv(config *config.GlobalConfig) error { config.Mongo.Password = getEnv("MONGO_OPENIM_PASSWORD", config.Mongo.Password) config.Mongo.Address = getArrEnv("MONGO_ADDRESS", "MONGO_PORT", config.Mongo.Address) config.Mongo.Database = getEnv("MONGO_DATABASE", config.Mongo.Database) - maxPoolSize, err := getEnvInt("MONGO_DATABASE", config.Mongo.MaxPoolSize) + maxPoolSize, err := getEnvInt("MONGO_MAX_POOL_SIZE", config.Mongo.MaxPoolSize) if err != nil { - return err + return errs.Wrap(err, "MONGO_MAX_POOL_SIZE") } config.Mongo.MaxPoolSize = maxPoolSize config.Redis.Username = getEnv("REDIS_USERNAME", config.Redis.Username) config.Redis.Password = getEnv("REDIS_PASSWORD", config.Redis.Password) - config.Redis.Address = getArrEnv("REDIS_ADDRESS", "REDIS_PASSWORD", config.Redis.Address) + config.Redis.Address = getArrEnv("REDIS_ADDRESS", "REDIS_PORT", config.Redis.Address) config.Object.ApiURL = getEnv("OBJECT_APIURL", config.Object.ApiURL) config.Object.Minio.Endpoint = getEnv("MINIO_ENDPOINT", config.Object.Minio.Endpoint) diff --git a/tools/data-conversion/README.md b/tools/data-conversion/README.md deleted file mode 100644 index 71387af7f..000000000 --- a/tools/data-conversion/README.md +++ /dev/null @@ -1,98 +0,0 @@ -# OpenIM V2 至 V3 数据迁移指南 - -该指南提供了从 OpenIM V2 迁移至 V3 的详细步骤。请确保在开始迁移过程之前，熟悉所有步骤，并按照指南准确执行。 - -+ [OpenIM Chat](https://github.com/OpenIMSDK/chat) -+ [OpenIM Server](https://github.com/OpenIMSDK/Open-IM-Server) - - - -### 1. 数据备份 - -在开始数据迁移之前，强烈建议备份所有相关的数据以防止任何可能的数据丢失。 - -### 2. 迁移 OpenIM MySQL 数据 - -+ 位置: `open-im-server/tools/data-conversion/openim/cmd/conversion-mysql.go` -+ 配置 `conversion-mysql.go` 文件中的数据库信息。 -+ 手动创建 V3 版本的数据库，并确保字符集为 `utf8mb4`。 - -```bash -// V2 数据库配置 -var ( - usernameV2 = "root" - passwordV2 = "openIM" - addrV2 = "127.0.0.1:13306" - databaseV2 = "openIM_v2" -) - -// V3 数据库配置 -var ( - usernameV3 = "root" - passwordV3 = "openIM123" - addrV3 = "127.0.0.1:13306" - databaseV3 = "openim_v3" -) -``` - -**执行数据迁移命令：** - -```bash -make build BINS="conversion-mysql" -``` - -启动的二进制在 `_output/bin/tools` 中 - - -### 3. 转换聊天消息（可选） - -+ 只支持转换存储在 Kafka 中的消息。 -+ 位置: `open-im-server/tools/data-conversion/openim/conversion-msg/conversion-msg.go` -+ 配置 `msg.go` 文件中的消息和服务器信息。 - -```bash -var ( - topic = "ws2ms_chat" // V2 版本 Kafka 主题 - kafkaAddr = "127.0.0.1:9092" // V2 版本 Kafka 地址 - rpcAddr = "127.0.0.1:10130" // V3 版本 RPC 地址 - adminUserID = "openIM123456" // V3 版本管理员用户ID - concurrency = 4 // 并发数量 -) -``` - -**执行数据迁移命令：** - -```bash -make build BINS="conversion-msg" -``` - -### 4. 转换业务服务器数据 - -+ 只支持转换存储在 Kafka 中的消息。 -+ 位置: `open-im-server/tools/data-conversion/chat/cmd/conversion-chat/chat.go` -+ 需要手动创建 V3 版本的数据库，并确保字符集为 `utf8mb4`。 -+ 配置 `main.go` 文件中的数据库信息。 - -```bash -// V2 数据库配置 -var ( - usernameV2 = "root" - passwordV2 = "openIM" - addrV2 = "127.0.0.1:13306" - databaseV2 = "admin_chat" -) - -// V3 数据库配置 -var ( - usernameV3 = "root" - passwordV3 = "openIM123" - addrV3 = "127.0.0.1:13306" - databaseV3 = "openim_enterprise" -) -``` - -**执行数据迁移命令：** - -```bash -make build BINS="conversion-chat" -``` diff --git a/tools/data-conversion/chat/cmd/conversion-chat/chat.go b/tools/data-conversion/chat/cmd/conversion-chat/chat.go deleted file mode 100644 index f68b71b16..000000000 --- a/tools/data-conversion/chat/cmd/conversion-chat/chat.go +++ /dev/null @@ -1,77 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package main - -import ( - "fmt" - "log" - - "gorm.io/driver/mysql" - "gorm.io/gorm" - "gorm.io/gorm/logger" - - "github.com/openimsdk/open-im-server/v3/tools/data-conversion/chat/conversion" - "github.com/openimsdk/open-im-server/v3/tools/data-conversion/utils" -) - -func main() { - var ( - usernameV2 = "root" // Username for MySQL v2 version - passwordV2 = "openIM" // Password for MySQL v2 version - addrV2 = "127.0.0.1:13306" // Address for MySQL v2 version - databaseV2 = "admin_chat" // Database name for MySQL v2 version - ) - - var ( - usernameV3 = "root" // Username for MySQL v3 version - passwordV3 = "openIM123" // Password for MySQL v3 version - addrV3 = "127.0.0.1:13306" // Address for MySQL v3 version - databaseV3 = "openim_enterprise" // Database name for MySQL v3 version - ) - - var concurrency = 1 // Concurrency quantity - - log.SetFlags(log.LstdFlags | log.Llongfile) - dsnV2 := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", usernameV2, passwordV2, addrV2, databaseV2) - dsnV3 := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", usernameV3, passwordV3, addrV3, databaseV3) - dbV2, err := gorm.Open(mysql.Open(dsnV2), &gorm.Config{Logger: logger.Discard}) - if err != nil { - log.Println("open v2 db failed", err) - return - } - dbV3, err := gorm.Open(mysql.Open(dsnV3), &gorm.Config{Logger: logger.Discard}) - if err != nil { - log.Println("open v3 db failed", err) - return - } - - var tasks utils.TakeList - - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.Account) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.Attribute) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.Register) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.UserLoginRecord) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.Admin) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.Applet) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.ForbiddenAccount) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.InvitationRegister) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.IPForbidden) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.LimitUserLoginIP) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.RegisterAddFriend) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.RegisterAddGroup) }) - - utils.RunTask(concurrency, tasks) - -} diff --git a/tools/data-conversion/chat/conversion/conversion.go b/tools/data-conversion/chat/conversion/conversion.go deleted file mode 100644 index 084fff59c..000000000 --- a/tools/data-conversion/chat/conversion/conversion.go +++ /dev/null @@ -1,167 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package conversion - -import ( - v2 "github.com/openimsdk/open-im-server/v3/tools/data-conversion/chat/v2" - "github.com/openimsdk/open-im-server/v3/tools/data-conversion/chat/v3/admin" - "github.com/openimsdk/open-im-server/v3/tools/data-conversion/chat/v3/chat" - "github.com/openimsdk/open-im-server/v3/tools/data-conversion/utils" -) - -// ########## chat ########## - -func Account(v v2.Account) (chat.Account, bool) { - utils.InitTime(&v.CreateTime, &v.ChangeTime) - return chat.Account{ - UserID: v.UserID, - Password: v.Password, - CreateTime: v.CreateTime, - ChangeTime: v.ChangeTime, - OperatorUserID: v.OperatorUserID, - }, true -} - -func Attribute(v v2.Attribute) (chat.Attribute, bool) { - utils.InitTime(&v.CreateTime, &v.ChangeTime, &v.BirthTime) - return chat.Attribute{ - UserID: v.UserID, - Account: v.Account, - PhoneNumber: v.PhoneNumber, - AreaCode: v.AreaCode, - Email: v.Email, - Nickname: v.Nickname, - FaceURL: v.FaceURL, - Gender: v.Gender, - CreateTime: v.CreateTime, - ChangeTime: v.ChangeTime, - BirthTime: v.BirthTime, - Level: v.Level, - AllowVibration: v.AllowVibration, - AllowBeep: v.AllowBeep, - AllowAddFriend: v.AllowAddFriend, - GlobalRecvMsgOpt: 0, - }, true -} - -func Register(v v2.Register) (chat.Register, bool) { - utils.InitTime(&v.CreateTime) - return chat.Register{ - UserID: v.UserID, - DeviceID: v.DeviceID, - IP: v.IP, - Platform: v.Platform, - AccountType: v.AccountType, - Mode: v.Mode, - CreateTime: v.CreateTime, - }, true -} - -func UserLoginRecord(v v2.UserLoginRecord) (chat.UserLoginRecord, bool) { - utils.InitTime(&v.LoginTime) - return chat.UserLoginRecord{ - UserID: v.UserID, - LoginTime: v.LoginTime, - IP: v.IP, - DeviceID: v.DeviceID, - Platform: v.Platform, - }, true -} - -// ########## admin ########## - -func Admin(v v2.Admin) (admin.Admin, bool) { - utils.InitTime(&v.CreateTime) - return admin.Admin{ - Account: v.Account, - Password: v.Password, - FaceURL: v.FaceURL, - Nickname: v.Nickname, - UserID: v.UserID, - Level: v.Level, - CreateTime: v.CreateTime, - }, true -} - -func Applet(v v2.Applet) (admin.Applet, bool) { - utils.InitTime(&v.CreateTime) - return admin.Applet{ - ID: v.ID, - Name: v.Name, - AppID: v.AppID, - Icon: v.Icon, - URL: v.URL, - MD5: v.MD5, - Size: v.Size, - Version: v.Version, - Priority: v.Priority, - Status: v.Status, - CreateTime: v.CreateTime, - }, true -} - -func ForbiddenAccount(v v2.ForbiddenAccount) (admin.ForbiddenAccount, bool) { - utils.InitTime(&v.CreateTime) - return admin.ForbiddenAccount{ - UserID: v.UserID, - Reason: v.Reason, - OperatorUserID: v.OperatorUserID, - CreateTime: v.CreateTime, - }, true -} - -func InvitationRegister(v v2.InvitationRegister) (admin.InvitationRegister, bool) { - utils.InitTime(&v.CreateTime) - return admin.InvitationRegister{ - InvitationCode: v.InvitationCode, - UsedByUserID: v.UsedByUserID, - CreateTime: v.CreateTime, - }, true -} - -func IPForbidden(v v2.IPForbidden) (admin.IPForbidden, bool) { - utils.InitTime(&v.CreateTime) - return admin.IPForbidden{ - IP: v.IP, - LimitRegister: v.LimitRegister > 0, - LimitLogin: v.LimitLogin > 0, - CreateTime: v.CreateTime, - }, true -} - -func LimitUserLoginIP(v v2.LimitUserLoginIP) (admin.LimitUserLoginIP, bool) { - utils.InitTime(&v.CreateTime) - return admin.LimitUserLoginIP{ - UserID: v.UserID, - IP: v.IP, - CreateTime: v.CreateTime, - }, true -} - -func RegisterAddFriend(v v2.RegisterAddFriend) (admin.RegisterAddFriend, bool) { - utils.InitTime(&v.CreateTime) - return admin.RegisterAddFriend{ - UserID: v.UserID, - CreateTime: v.CreateTime, - }, true -} - -func RegisterAddGroup(v v2.RegisterAddGroup) (admin.RegisterAddGroup, bool) { - utils.InitTime(&v.CreateTime) - return admin.RegisterAddGroup{ - GroupID: v.GroupID, - CreateTime: v.CreateTime, - }, true -} diff --git a/tools/data-conversion/chat/v2/admin.go b/tools/data-conversion/chat/v2/admin.go deleted file mode 100644 index 20cf22a36..000000000 --- a/tools/data-conversion/chat/v2/admin.go +++ /dev/null @@ -1,77 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package v2 - -import ( - "time" -) - -// AppVersion manages PC client versions -type AppVersion struct { - Version string `gorm:"column:version;size:64" json:"version"` - Type int `gorm:"column:type;primary_key" json:"type"` - UpdateTime int `gorm:"column:update_time" json:"update_time"` - ForceUpdate bool `gorm:"column:force_update" json:"force_update"` - FileName string `gorm:"column:file_name" json:"file_name"` - YamlName string `gorm:"column:yaml_name" json:"yaml_name"` - UpdateLog string `gorm:"column:update_log" json:"update_log"` -} - -// Admin manages backend administrators -type Admin struct { - Account string `gorm:"column:account;primary_key;type:char(64)" json:"account"` - Password string `gorm:"column:Password;type:char(64)" json:"password"` - FaceURL string `gorm:"column:FaceURL;type:char(64)" json:"faceURL"` - Nickname string `gorm:"column:Nickname;type:char(64)" json:"nickname"` - UserID string `gorm:"column:UserID;type:char(64)" json:"userID"` //openIM userID - Level int32 `gorm:"column:level;default:1" json:"level"` - CreateTime time.Time `gorm:"column:create_time" json:"createTime"` -} - -// RegisterAddFriend specifies default friends when registering -type RegisterAddFriend struct { - UserID string `gorm:"column:user_id;primary_key;type:char(64)" json:"userID"` - CreateTime time.Time `gorm:"column:create_time" json:"createTime"` -} - -// RegisterAddGroup specifies default groups when registering -type RegisterAddGroup struct { - GroupID string `gorm:"column:group_id;primary_key;type:char(64)" json:"userID"` - CreateTime time.Time `gorm:"column:create_time" json:"createTime"` -} - -// ClientInitConfig contains system-related configuration items -type ClientInitConfig struct { - DiscoverPageURL string `gorm:"column:discover_page_url;size:128" json:"discoverPageURL"` - OrdinaryUserAddFriend int32 `gorm:"column:ordinary_user_add_friend; default:1" json:"ordinaryUserAddFriend"` - BossUserID string `gorm:"column:boss_user_id;type:char(64)" json:"bossUserID"` - AdminURL string `gorm:"column:admin_url;type:char(128)" json:"adminURL"` - AllowSendMsgNotFriend int32 `gorm:"column:allow_send_msg_not_friend;default:1" json:"allowSendMsgNotFriend"` - NeedInvitationCodeRegister int32 `gorm:"column:need_invitation_code_register;default:0" json:"needInvitationCodeRegister"` -} - -type Applet struct { - ID string `gorm:"column:id;primary_key;size:64"` - Name string `gorm:"column:name;uniqueIndex;size:64"` - AppID string `gorm:"column:app_id;uniqueIndex;size:255"` - Icon string `gorm:"column:icon;size:255"` - URL string `gorm:"column:url;size:255"` - MD5 string `gorm:"column:md5;size:255"` - Size int64 `gorm:"column:size"` - Version string `gorm:"column:version;size:64"` - Priority uint32 `gorm:"column:priority;size:64"` - Status uint8 `gorm:"column:status"` - CreateTime time.Time `gorm:"column:create_time;autoCreateTime;size:64"` -} diff --git a/tools/data-conversion/chat/v2/chat.go b/tools/data-conversion/chat/v2/chat.go deleted file mode 100644 index 4e0a0c04a..000000000 --- a/tools/data-conversion/chat/v2/chat.go +++ /dev/null @@ -1,109 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package v2 - -import ( - "time" -) - -// Register Registration information sheet -type Register struct { - UserID string `gorm:"column:user_id;primary_key;type:char(64)" json:"userID"` - DeviceID string `gorm:"column:device_id;type:varchar(255)" json:"deviceID"` - IP string `gorm:"column:ip;type:varchar(32)" json:"ip"` - Platform string `gorm:"column:platform;type:varchar(32)" json:"platform"` - AccountType string `gorm:"column:account_type;type:varchar(32)" json:"accountType"` //email phone account - Mode string `gorm:"column:mode;type:varchar(32)"` //user admin - CreateTime time.Time `gorm:"column:create_time" json:"createTime"` -} - -// Account username and password table -type Account struct { - UserID string `gorm:"column:user_id;primary_key;type:char(64)" json:"userID"` - Password string `gorm:"column:password;type:varchar(255)" json:"password"` - CreateTime time.Time `gorm:"column:create_time" json:"createTime"` - ChangeTime time.Time `gorm:"column:change_time" json:"changeTime"` - OperatorUserID string `gorm:"column:operator_user_id;type:varchar(64)" json:"operatorUserID"` -} - -// Attribute user information table -type Attribute struct { - UserID string `gorm:"column:user_id;primary_key;type:char(64)" json:"userID"` - Account string `gorm:"column:account;type:char(64)" json:"account"` - PhoneNumber string `gorm:"column:phone_number;type:varchar(32)" json:"phoneNumber"` - AreaCode string `gorm:"column:area_code;type:varchar(8)" json:"areaCode"` - Email string `gorm:"column:email;type:varchar(64)" json:"email"` - Nickname string `gorm:"column:nickname;type:varchar(64)" json:"nickname"` - FaceURL string `gorm:"column:face_url;type:varchar(255)" json:"faceURL"` - Gender int32 `gorm:"column:gender" json:"gender"` - Birth uint32 `gorm:"column:birth" json:"birth"` - CreateTime time.Time `gorm:"column:create_time" json:"createTime"` - ChangeTime time.Time `gorm:"column:change_time" json:"changeTime"` - BirthTime time.Time `gorm:"column:birth_time" json:"birthTime"` - Level int32 `gorm:"column:level;default:1" json:"level"` - AllowVibration int32 `gorm:"column:allow_vibration;default:1" json:"allowVibration"` - AllowBeep int32 `gorm:"column:allow_beep;default:1" json:"allowBeep"` - AllowAddFriend int32 `gorm:"column:allow_add_friend;default:1" json:"allowAddFriend"` -} - -// User friend relationship table -type ForbiddenAccount struct { - UserID string `gorm:"column:user_id;index:userID;primary_key;type:char(64)" json:"userID"` - CreateTime time.Time `gorm:"column:create_time" json:"createTime"` - Reason string `gorm:"column:reason;type:varchar(255)" json:"reason"` - OperatorUserID string `gorm:"column:operator_user_id;type:varchar(255)" json:"operatorUserID"` -} - -// user login record table -type UserLoginRecord struct { - UserID string `gorm:"column:user_id;size:64" json:"userID"` - LoginTime time.Time `gorm:"column:login_time" json:"loginTime"` - IP string `gorm:"column:ip;type:varchar(32)" json:"ip"` - DeviceID string `gorm:"column:device_id;type:varchar(255)" json:"deviceID"` - Platform string `gorm:"column:platform;type:varchar(32)" json:"platform"` -} - -// ip login registration is prohibited -type IPForbidden struct { - IP string `gorm:"column:ip;primary_key;type:char(32)" json:"ip"` - LimitRegister int32 `gorm:"column:limit_register" json:"limitRegister"` - LimitLogin int32 `gorm:"column:limit_login" json:"limitLogin"` - CreateTime time.Time `gorm:"column:create_time" json:"createTime"` -} - -// Restrict userids to certain ip addresses -type LimitUserLoginIP struct { - UserID string `gorm:"column:user_id;primary_key;type:char(64)" json:"userID"` - IP string `gorm:"column:ip;primary_key;type:char(32)" json:"ip"` - CreateTime time.Time `gorm:"column:create_time" json:"createTime"` -} - -// The invitation code is registered for use -type InvitationRegister struct { - InvitationCode string `gorm:"column:invitation_code;primary_key;type:char(32)" json:"invitationCode"` - CreateTime time.Time `gorm:"column:create_time" json:"createTime"` - UsedByUserID string `gorm:"column:user_id;index:userID;type:char(64)" json:"usedByUserID"` -} - -type SignalRecord struct { - FileName string `gorm:"column:file_name;primary_key;type:char(128)" json:"fileName"` - MediaType string `gorm:"column:media_type;type:char(64);index:media_type_index" json:"mediaType"` - RoomType string `gorm:"column:room_type;type:char(20)" json:"roomType"` - SenderID string `gorm:"column:sender_id;type:char(64);index:sender_id_index" json:"senderID"` - RecvID string `gorm:"column:recv_id;type:char(64);index:recv_id_index" json:"recvID"` - GroupID string `gorm:"column:group_id;type:char(64)" json:"groupID"` - DownloadURL string `gorm:"column:download_url;type:text" json:"downloadURL"` - CreateTime time.Time `gorm:"create_time;index:create_time_index" json:"createTime"` -} diff --git a/tools/data-conversion/chat/v3/admin/admin.go b/tools/data-conversion/chat/v3/admin/admin.go deleted file mode 100644 index 90bd7f8f7..000000000 --- a/tools/data-conversion/chat/v3/admin/admin.go +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright © 2023 OpenIM open source community. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package admin - -import ( - "time" -) - -// Admin Background administrator. -type Admin struct { - Account string `gorm:"column:account;primary_key;type:varchar(64)"` - Password string `gorm:"column:password;type:varchar(64)"` - FaceURL string `gorm:"column:face_url;type:varchar(255)"` - Nickname string `gorm:"column:nickname;type:varchar(64)"` - UserID string `gorm:"column:user_id;type:varchar(64)"` // openIM userID - Level int32 `gorm:"column:level;default:1" ` - CreateTime time.Time `gorm:"column:create_time"` -} - -func (Admin) TableName() string { - return "admins" -} diff --git a/tools/data-conversion/chat/v3/admin/applet.go b/tools/data-conversion/chat/v3/admin/applet.go deleted file mode 100644 index 5f97cf365..000000000 --- a/tools/data-conversion/chat/v3/admin/applet.go +++ /dev/null @@ -1,37 +0,0 @@ -// Copyright © 2023 OpenIM open source community. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package admin - -import ( - "time" -) - -type Applet struct { - ID string `gorm:"column:id;primary_key;size:64"` - Name string `gorm:"column:name;size:64"` - AppID string `gorm:"column:app_id;uniqueIndex;size:255"` - Icon string `gorm:"column:icon;size:255"` - URL string `gorm:"column:url;size:255"` - MD5 string `gorm:"column:md5;size:255"` - Size int64 `gorm:"column:size"` - Version string `gorm:"column:version;size:64"` - Priority uint32 `gorm:"column:priority;size:64"` - Status uint8 `gorm:"column:status"` - CreateTime time.Time `gorm:"column:create_time;autoCreateTime;size:64"` -} - -func (Applet) TableName() string { - return "applets" -} diff --git a/tools/data-conversion/chat/v3/admin/forbidden_account.go b/tools/data-conversion/chat/v3/admin/forbidden_account.go deleted file mode 100644 index e08125699..000000000 --- a/tools/data-conversion/chat/v3/admin/forbidden_account.go +++ /dev/null @@ -1,31 +0,0 @@ -// Copyright © 2023 OpenIM open source community. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package admin - -import ( - "time" -) - -// ForbiddenAccount forbidden account. -type ForbiddenAccount struct { - UserID string `gorm:"column:user_id;index:userID;primary_key;type:char(64)"` - Reason string `gorm:"column:reason;type:varchar(255)" ` - OperatorUserID string `gorm:"column:operator_user_id;type:varchar(255)"` - CreateTime time.Time `gorm:"column:create_time" ` -} - -func (ForbiddenAccount) TableName() string { - return "forbidden_accounts" -} diff --git a/tools/data-conversion/chat/v3/admin/invitation_register.go b/tools/data-conversion/chat/v3/admin/invitation_register.go deleted file mode 100644 index 4b71ccfe0..000000000 --- a/tools/data-conversion/chat/v3/admin/invitation_register.go +++ /dev/null @@ -1,30 +0,0 @@ -// Copyright © 2023 OpenIM open source community. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package admin - -import ( - "time" -) - -// The invitation code is registered for use. -type InvitationRegister struct { - InvitationCode string `gorm:"column:invitation_code;primary_key;type:char(32)"` - UsedByUserID string `gorm:"column:user_id;index:userID;type:char(64)"` - CreateTime time.Time `gorm:"column:create_time"` -} - -func (InvitationRegister) TableName() string { - return "invitation_registers" -} diff --git a/tools/data-conversion/chat/v3/admin/ip_forbidden.go b/tools/data-conversion/chat/v3/admin/ip_forbidden.go deleted file mode 100644 index 886924abb..000000000 --- a/tools/data-conversion/chat/v3/admin/ip_forbidden.go +++ /dev/null @@ -1,31 +0,0 @@ -// Copyright © 2023 OpenIM open source community. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package admin - -import ( - "time" -) - -// ip login registration is prohibited. -type IPForbidden struct { - IP string `gorm:"column:ip;primary_key;type:char(32)"` - LimitRegister bool `gorm:"column:limit_register"` - LimitLogin bool `gorm:"column:limit_login"` - CreateTime time.Time `gorm:"column:create_time"` -} - -func (IPForbidden) TableName() string { - return "ip_forbiddens" -} diff --git a/tools/data-conversion/chat/v3/admin/limit_user_login_ip.go b/tools/data-conversion/chat/v3/admin/limit_user_login_ip.go deleted file mode 100644 index 0eaa5bc1e..000000000 --- a/tools/data-conversion/chat/v3/admin/limit_user_login_ip.go +++ /dev/null @@ -1,30 +0,0 @@ -// Copyright © 2023 OpenIM open source community. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package admin - -import ( - "time" -) - -// Restrict userids to certain ip addresses. -type LimitUserLoginIP struct { - UserID string `gorm:"column:user_id;primary_key;type:char(64)"` - IP string `gorm:"column:ip;primary_key;type:char(32)"` - CreateTime time.Time `gorm:"column:create_time" ` -} - -func (LimitUserLoginIP) TableName() string { - return "limit_user_login_ips" -} diff --git a/tools/data-conversion/chat/v3/admin/register_add_group.go b/tools/data-conversion/chat/v3/admin/register_add_group.go deleted file mode 100644 index 1204ff97b..000000000 --- a/tools/data-conversion/chat/v3/admin/register_add_group.go +++ /dev/null @@ -1,29 +0,0 @@ -// Copyright © 2023 OpenIM open source community. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package admin - -import ( - "time" -) - -// RegisterAddGroup Indicates the default group for registration. -type RegisterAddGroup struct { - GroupID string `gorm:"column:group_id;primary_key;type:char(64)"` - CreateTime time.Time `gorm:"column:create_time"` -} - -func (RegisterAddGroup) TableName() string { - return "register_add_groups" -} diff --git a/tools/data-conversion/chat/v3/chat/account.go b/tools/data-conversion/chat/v3/chat/account.go deleted file mode 100644 index 6d01c20e2..000000000 --- a/tools/data-conversion/chat/v3/chat/account.go +++ /dev/null @@ -1,32 +0,0 @@ -// Copyright © 2023 OpenIM open source community. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package chat - -import ( - "time" -) - -// Account Account password table. -type Account struct { - UserID string `gorm:"column:user_id;primary_key;type:char(64)"` - Password string `gorm:"column:password;type:varchar(32)"` - CreateTime time.Time `gorm:"column:create_time;autoCreateTime"` - ChangeTime time.Time `gorm:"column:change_time;autoUpdateTime"` - OperatorUserID string `gorm:"column:operator_user_id;type:varchar(64)"` -} - -func (Account) TableName() string { - return "accounts" -} diff --git a/tools/data-conversion/chat/v3/chat/attribute.go b/tools/data-conversion/chat/v3/chat/attribute.go deleted file mode 100644 index 23de217bd..000000000 --- a/tools/data-conversion/chat/v3/chat/attribute.go +++ /dev/null @@ -1,43 +0,0 @@ -// Copyright © 2023 OpenIM open source community. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package chat - -import ( - "time" -) - -// Attribute Indicates the user attribute table. -type Attribute struct { - UserID string `gorm:"column:user_id;primary_key;type:char(64)"` - Account string `gorm:"column:account;type:char(64)"` - PhoneNumber string `gorm:"column:phone_number;type:varchar(32)"` - AreaCode string `gorm:"column:area_code;type:varchar(8)"` - Email string `gorm:"column:email;type:varchar(64)" ` - Nickname string `gorm:"column:nickname;type:varchar(64)" ` - FaceURL string `gorm:"column:face_url;type:varchar(255)" ` - Gender int32 `gorm:"column:gender"` - CreateTime time.Time `gorm:"column:create_time"` - ChangeTime time.Time `gorm:"column:change_time"` - BirthTime time.Time `gorm:"column:birth_time"` - Level int32 `gorm:"column:level;default:1"` - AllowVibration int32 `gorm:"column:allow_vibration;default:1"` - AllowBeep int32 `gorm:"column:allow_beep;default:1"` - AllowAddFriend int32 `gorm:"column:allow_add_friend;default:1"` - GlobalRecvMsgOpt int32 `gorm:"column:global_recv_msg_opt;default:0"` -} - -func (Attribute) TableName() string { - return "attributes" -} diff --git a/tools/data-conversion/chat/v3/chat/register.go b/tools/data-conversion/chat/v3/chat/register.go deleted file mode 100644 index 29e5cb698..000000000 --- a/tools/data-conversion/chat/v3/chat/register.go +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright © 2023 OpenIM open source community. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package chat - -import ( - "time" -) - -// Register Indicates the registration information. -type Register struct { - UserID string `gorm:"column:user_id;primary_key;type:char(64)"` - DeviceID string `gorm:"column:device_id;type:varchar(255)"` - IP string `gorm:"column:ip;type:varchar(64)"` - Platform string `gorm:"column:platform;type:varchar(32)"` - AccountType string `gorm:"column:account_type;type:varchar(32)"` // email phone account - Mode string `gorm:"column:mode;type:varchar(32)"` // user admin - CreateTime time.Time `gorm:"column:create_time"` -} - -func (Register) TableName() string { - return "registers" -} diff --git a/tools/data-conversion/chat/v3/chat/user_login_record.go b/tools/data-conversion/chat/v3/chat/user_login_record.go deleted file mode 100644 index 31e57b6ce..000000000 --- a/tools/data-conversion/chat/v3/chat/user_login_record.go +++ /dev/null @@ -1,32 +0,0 @@ -// Copyright © 2023 OpenIM open source community. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package chat - -import ( - "time" -) - -// User login information table. -type UserLoginRecord struct { - UserID string `gorm:"column:user_id;size:64"` - LoginTime time.Time `gorm:"column:login_time"` - IP string `gorm:"column:ip;type:varchar(32)"` - DeviceID string `gorm:"column:device_id;type:varchar(255)"` - Platform string `gorm:"column:platform;type:varchar(32)"` -} - -func (UserLoginRecord) TableName() string { - return "user_login_records" -} diff --git a/tools/data-conversion/go.mod b/tools/data-conversion/go.mod deleted file mode 100644 index 963755923..000000000 --- a/tools/data-conversion/go.mod +++ /dev/null @@ -1,72 +0,0 @@ -module github.com/openimsdk/open-im-server/v3/tools/data-conversion - -go 1.19 - -require ( - github.com/IBM/sarama v1.42.1 - github.com/OpenIMSDK/protocol v0.0.33 - github.com/OpenIMSDK/tools v0.0.20 - github.com/golang/protobuf v1.5.3 - github.com/openimsdk/open-im-server/v3 v3.4.0 - golang.org/x/net v0.19.0 - google.golang.org/grpc v1.60.0 - google.golang.org/protobuf v1.31.0 - gorm.io/driver/mysql v1.5.2 - gorm.io/gorm v1.25.5 -) - -require ( - github.com/bwmarrin/snowflake v0.3.0 // indirect - github.com/bytedance/sonic v1.9.1 // indirect - github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect - github.com/davecgh/go-spew v1.1.1 // indirect - github.com/eapache/go-resiliency v1.4.0 // indirect - github.com/eapache/go-xerial-snappy v0.0.0-20230731223053-c322873962e3 // indirect - github.com/eapache/queue v1.1.0 // indirect - github.com/gabriel-vasile/mimetype v1.4.2 // indirect - github.com/gin-contrib/sse v0.1.0 // indirect - github.com/gin-gonic/gin v1.9.1 // indirect - github.com/go-playground/locales v0.14.1 // indirect - github.com/go-playground/universal-translator v0.18.1 // indirect - github.com/go-playground/validator/v10 v10.15.5 // indirect - github.com/go-sql-driver/mysql v1.7.1 // indirect - github.com/goccy/go-json v0.10.2 // indirect - github.com/golang/snappy v0.0.4 // indirect - github.com/hashicorp/errwrap v1.0.0 // indirect - github.com/hashicorp/go-multierror v1.1.1 // indirect - github.com/hashicorp/go-uuid v1.0.3 // indirect - github.com/jcmturner/aescts/v2 v2.0.0 // indirect - github.com/jcmturner/dnsutils/v2 v2.0.0 // indirect - github.com/jcmturner/gofork v1.7.6 // indirect - github.com/jcmturner/gokrb5/v8 v8.4.4 // indirect - github.com/jcmturner/rpc/v2 v2.0.3 // indirect - github.com/jinzhu/copier v0.4.0 // indirect - github.com/jinzhu/inflection v1.0.0 // indirect - github.com/jinzhu/now v1.1.5 // indirect - github.com/json-iterator/go v1.1.12 // indirect - github.com/klauspost/compress v1.16.7 // indirect - github.com/klauspost/cpuid/v2 v2.2.5 // indirect - github.com/leodido/go-urn v1.2.4 // indirect - github.com/lestrrat-go/file-rotatelogs v2.4.0+incompatible // indirect - github.com/lestrrat-go/strftime v1.0.6 // indirect - github.com/mattn/go-isatty v0.0.19 // indirect - github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect - github.com/modern-go/reflect2 v1.0.2 // indirect - github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 // indirect - github.com/pelletier/go-toml/v2 v2.0.8 // indirect - github.com/pierrec/lz4/v4 v4.1.18 // indirect - github.com/pkg/errors v0.9.1 // indirect - github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect - github.com/twitchyliquid64/golang-asm v0.15.1 // indirect - github.com/ugorji/go/codec v1.2.11 // indirect - go.uber.org/atomic v1.7.0 // indirect - go.uber.org/multierr v1.6.0 // indirect - go.uber.org/zap v1.24.0 // indirect - golang.org/x/arch v0.3.0 // indirect - golang.org/x/crypto v0.17.0 // indirect - golang.org/x/image v0.13.0 // indirect - golang.org/x/sys v0.15.0 // indirect - golang.org/x/text v0.14.0 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20231012201019-e917dd12ba7a // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect -) diff --git a/tools/data-conversion/go.sum b/tools/data-conversion/go.sum deleted file mode 100644 index d6dc23742..000000000 --- a/tools/data-conversion/go.sum +++ /dev/null @@ -1,207 +0,0 @@ -github.com/IBM/sarama v1.42.1 h1:wugyWa15TDEHh2kvq2gAy1IHLjEjuYOYgXz/ruC/OSQ= -github.com/IBM/sarama v1.42.1/go.mod h1:Xxho9HkHd4K/MDUo/T/sOqwtX/17D33++E9Wib6hUdQ= -github.com/OpenIMSDK/protocol v0.0.33 h1:T07KWD0jt7IRlrYRujCa+eXmfgcSi8sRgLL8t2ZlHQA= -github.com/OpenIMSDK/protocol v0.0.33/go.mod h1:F25dFrwrIx3lkNoiuf6FkCfxuwf8L4Z8UIsdTHP/r0Y= -github.com/OpenIMSDK/tools v0.0.20 h1:zBTjQZRJ5lR1FIzP9mtWyAvh5dKsmJXQugi4p8X/97k= -github.com/OpenIMSDK/tools v0.0.20/go.mod h1:eg+q4A34Qmu73xkY0mt37FHGMCMfC6CtmOnm0kFEGFI= -github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8= -github.com/bwmarrin/snowflake v0.3.0 h1:xm67bEhkKh6ij1790JB83OujPR5CzNe8QuQqAgISZN0= -github.com/bwmarrin/snowflake v0.3.0/go.mod h1:NdZxfVWX+oR6y2K0o6qAYv6gIOP9rjG0/E9WsDpxqwE= -github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM= -github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s= -github.com/bytedance/sonic v1.9.1/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U= -github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY= -github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams= -github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk= -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/eapache/go-resiliency v1.4.0 h1:3OK9bWpPk5q6pbFAaYSEwD9CLUSHG8bnZuqX2yMt3B0= -github.com/eapache/go-resiliency v1.4.0/go.mod h1:5yPzW0MIvSe0JDsv0v+DvcjEv2FyD6iZYSs1ZI+iQho= -github.com/eapache/go-xerial-snappy v0.0.0-20230731223053-c322873962e3 h1:Oy0F4ALJ04o5Qqpdz8XLIpNA3WM/iSIXqxtqo7UGVws= -github.com/eapache/go-xerial-snappy v0.0.0-20230731223053-c322873962e3/go.mod h1:YvSRo5mw33fLEx1+DlK6L2VV43tJt5Eyel9n9XBcR+0= -github.com/eapache/queue v1.1.0 h1:YOEu7KNc61ntiQlcEeUIoDTJ2o8mQznoNvUhiigpIqc= -github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I= -github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw= -github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU= -github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA= -github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE= -github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI= -github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg= -github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU= -github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= -github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= -github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY= -github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY= -github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY= -github.com/go-playground/validator/v10 v10.15.5 h1:LEBecTWb/1j5TNY1YYG2RcOUN3R7NLylN+x8TTueE24= -github.com/go-playground/validator/v10 v10.15.5/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU= -github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI= -github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI= -github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI= -github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= -github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= -github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= -github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= -github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= -github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM= -github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= -github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/gorilla/securecookie v1.1.1/go.mod h1:ra0sb63/xPlUeL+yeDciTfxMRAA+MP+HVt/4epWDjd4= -github.com/gorilla/sessions v1.2.1/go.mod h1:dk2InVEVJ0sfLlnXv9EAgkf6ecYs/i80K/zI+bUmuGM= -github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA= -github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= -github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo= -github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= -github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= -github.com/hashicorp/go-uuid v1.0.3 h1:2gKiV6YVmrJ1i2CKKa9obLvRieoRGviZFL26PcT/Co8= -github.com/hashicorp/go-uuid v1.0.3/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= -github.com/jcmturner/aescts/v2 v2.0.0 h1:9YKLH6ey7H4eDBXW8khjYslgyqG2xZikXP0EQFKrle8= -github.com/jcmturner/aescts/v2 v2.0.0/go.mod h1:AiaICIRyfYg35RUkr8yESTqvSy7csK90qZ5xfvvsoNs= -github.com/jcmturner/dnsutils/v2 v2.0.0 h1:lltnkeZGL0wILNvrNiVCR6Ro5PGU/SeBvVO/8c/iPbo= -github.com/jcmturner/dnsutils/v2 v2.0.0/go.mod h1:b0TnjGOvI/n42bZa+hmXL+kFJZsFT7G4t3HTlQ184QM= -github.com/jcmturner/gofork v1.7.6 h1:QH0l3hzAU1tfT3rZCnW5zXl+orbkNMMRGJfdJjHVETg= -github.com/jcmturner/gofork v1.7.6/go.mod h1:1622LH6i/EZqLloHfE7IeZ0uEJwMSUyQ/nDd82IeqRo= -github.com/jcmturner/goidentity/v6 v6.0.1 h1:VKnZd2oEIMorCTsFBnJWbExfNN7yZr3EhJAxwOkZg6o= -github.com/jcmturner/goidentity/v6 v6.0.1/go.mod h1:X1YW3bgtvwAXju7V3LCIMpY0Gbxyjn/mY9zx4tFonSg= -github.com/jcmturner/gokrb5/v8 v8.4.4 h1:x1Sv4HaTpepFkXbt2IkL29DXRf8sOfZXo8eRKh687T8= -github.com/jcmturner/gokrb5/v8 v8.4.4/go.mod h1:1btQEpgT6k+unzCwX1KdWMEwPPkkgBtP+F6aCACiMrs= -github.com/jcmturner/rpc/v2 v2.0.3 h1:7FXXj8Ti1IaVFpSAziCZWNzbNuZmnvw/i6CqLNdWfZY= -github.com/jcmturner/rpc/v2 v2.0.3/go.mod h1:VUJYCIDm3PVOEHw8sgt091/20OJjskO/YJki3ELg/Hc= -github.com/jinzhu/copier v0.4.0 h1:w3ciUoD19shMCRargcpm0cm91ytaBhDvuRpz1ODO/U8= -github.com/jinzhu/copier v0.4.0/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg= -github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= -github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= -github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= -github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= -github.com/jonboulle/clockwork v0.4.0 h1:p4Cf1aMWXnXAUh8lVfewRBx1zaTSYKrKMF2g3ST4RZ4= -github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= -github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= -github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I= -github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= -github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= -github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg= -github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= -github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q= -github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4= -github.com/lestrrat-go/envload v0.0.0-20180220234015-a3eb8ddeffcc h1:RKf14vYWi2ttpEmkA4aQ3j4u9dStX2t4M8UM6qqNsG8= -github.com/lestrrat-go/envload v0.0.0-20180220234015-a3eb8ddeffcc/go.mod h1:kopuH9ugFRkIXf3YoqHKyrJ9YfUFsckUU9S7B+XP+is= -github.com/lestrrat-go/file-rotatelogs v2.4.0+incompatible h1:Y6sqxHMyB1D2YSzWkLibYKgg+SwmyFU9dF2hn6MdTj4= -github.com/lestrrat-go/file-rotatelogs v2.4.0+incompatible/go.mod h1:ZQnN8lSECaebrkQytbHj4xNgtg8CR7RYXnPok8e0EHA= -github.com/lestrrat-go/strftime v1.0.6 h1:CFGsDEt1pOpFNU+TJB0nhz9jl+K0hZSLE205AhTIGQQ= -github.com/lestrrat-go/strftime v1.0.6/go.mod h1:f7jQKgV5nnJpYgdEasS+/y7EsTb8ykN2z68n3TtcTaw= -github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA= -github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= -github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= -github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= -github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= -github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ= -github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8= -github.com/openimsdk/open-im-server/v3 v3.4.0 h1:e7nslaWEHYc5xD1A3zHtnhbIWgfgtJSnPGHIqwjARaE= -github.com/openimsdk/open-im-server/v3 v3.4.0/go.mod h1:HKqjLZSMjD7ec59VV694Yfqnj9SIVotzDSPWgAei2Tg= -github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ= -github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4= -github.com/pierrec/lz4/v4 v4.1.18 h1:xaKrnTkyoqfh1YItXl56+6KJNVYWlEEPuAQW9xsplYQ= -github.com/pierrec/lz4/v4 v4.1.18/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= -github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= -github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 h1:N/ElC8H3+5XpJzTSTfLsJV/mx9Q9g7kxmchpfZyxgzM= -github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= -github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= -github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= -github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= -github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= -github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= -github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= -github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU= -github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= -github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= -go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw= -go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -go.uber.org/goleak v1.1.11 h1:wy28qYRKZgnJTxGxvye5/wgWr1EKjmUDGYox5mGlRlI= -go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4= -go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= -go.uber.org/zap v1.24.0 h1:FiJd5l1UOLj0wCgbSE0rwwXHzEdAZS6hiiSnxJN/D60= -go.uber.org/zap v1.24.0/go.mod h1:2kMP+WWQ8aoFoedH3T2sq6iJ2yDWpHbP0f6MQbS9Gkg= -golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= -golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k= -golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58= -golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k= -golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4= -golang.org/x/image v0.13.0 h1:3cge/F/QTkNLauhf2QoE9zp+7sr+ZcL4HnoZmdwg9sg= -golang.org/x/image v0.13.0/go.mod h1:6mmbMOeV28HuMTgA6OSRkdXKYw/t5W9Uwn2Yv1r3Yxk= -golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= -golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= -golang.org/x/net v0.19.0 h1:zTwKpTd2XuCqf8huc7Fo2iSy+4RHPd10s4KzeTnVr1c= -golang.org/x/net v0.19.0/go.mod h1:CfAk/cbD4CthTvqiEl8NpboMuiuOYsAr/7NOjZJtv1U= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc= -golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= -golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -google.golang.org/genproto/googleapis/rpc v0.0.0-20231012201019-e917dd12ba7a h1:a2MQQVoTo96JC9PMGtGBymLp7+/RzpFc2yX/9WfFg1c= -google.golang.org/genproto/googleapis/rpc v0.0.0-20231012201019-e917dd12ba7a/go.mod h1:4cYg8o5yUbm77w8ZX00LhMVNl/YVBFJRYWDc0uYWMs0= -google.golang.org/grpc v1.60.0 h1:6FQAR0kM31P6MRdeluor2w2gPaS4SVNrD/DNTxrQ15k= -google.golang.org/grpc v1.60.0/go.mod h1:OlCHIeLYqSSsLi6i49B5QGdzaMZK9+M7LXN2FKz4eGM= -google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= -google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8= -google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gorm.io/driver/mysql v1.5.2 h1:QC2HRskSE75wBuOxe0+iCkyJZ+RqpudsQtqkp+IMuXs= -gorm.io/driver/mysql v1.5.2/go.mod h1:pQLhh1Ut/WUAySdTHwBpBv6+JKcj+ua4ZFx1QQTBzb8= -gorm.io/gorm v1.25.2-0.20230530020048-26663ab9bf55/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k= -gorm.io/gorm v1.25.5 h1:zR9lOiiYf09VNh5Q1gphfyia1JpiClIWG9hQaxB/mls= -gorm.io/gorm v1.25.5/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8= -rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= diff --git a/tools/data-conversion/openim/cmd/conversion-msg/conversion-msg.go b/tools/data-conversion/openim/cmd/conversion-msg/conversion-msg.go deleted file mode 100644 index 416fdcb9f..000000000 --- a/tools/data-conversion/openim/cmd/conversion-msg/conversion-msg.go +++ /dev/null @@ -1,227 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package main - -import ( - "context" - "encoding/json" - "log" - "sync" - "sync/atomic" - "time" - - "github.com/IBM/sarama" - "github.com/OpenIMSDK/protocol/constant" - "github.com/OpenIMSDK/protocol/msg" - "github.com/OpenIMSDK/protocol/sdkws" - "github.com/OpenIMSDK/tools/mw" - "github.com/golang/protobuf/proto" - "google.golang.org/grpc" - "google.golang.org/grpc/credentials/insecure" - - "github.com/openimsdk/open-im-server/v3/pkg/apistruct" - pbmsg "github.com/openimsdk/open-im-server/v3/tools/data-conversion/openim/proto/msg" -) - -func main() { - - var ( - // The Kafka topic for ws2ms_chat in version 2 configuration - topic = "ws2ms_chat" - - // The Kafka address in version 2 configuration - kafkaAddr = "127.0.0.1:9092" - - // The RPC address in version 3 configuration - rpcAddr = "127.0.0.1:10130" - - // The administrator userID in version 3 - adminUserID = "openIM123456" - - // The number of concurrent processes - concurrency = 1 - ) - - getRpcConn := func() (*grpc.ClientConn, error) { - ctx, cancel := context.WithTimeout(context.Background(), time.Second*10) - defer cancel() - return grpc.DialContext(ctx, rpcAddr, grpc.WithTransportCredentials(insecure.NewCredentials()), mw.GrpcClient()) - } - conn, err := getRpcConn() - if err != nil { - log.Println("get rpc conn", err) - return - } - defer conn.Close() - - msgClient := msg.NewMsgClient(conn) - - conf := sarama.NewConfig() - conf.Consumer.Offsets.Initial = sarama.OffsetOldest - - consumer, err := sarama.NewConsumer([]string{kafkaAddr}, conf) - if err != nil { - log.Println("kafka consumer conn", err) - return - } - partitions, err := consumer.Partitions(topic) // Get all partitions according to topic - if err != nil { - log.Println("kafka partitions", err) - return - } - - if len(partitions) == 0 { - log.Println("kafka partitions is empty") - return - } - log.Println("kafka partitions", partitions) - - msgCh := make(chan *pbmsg.MsgDataToMQ, concurrency*2) - - var kfkWg sync.WaitGroup - - distinct := make(map[string]struct{}) - var lock sync.Mutex - - for _, partition := range partitions { - kfkWg.Add(1) - go func(partition int32) { - defer kfkWg.Done() - pc, err := consumer.ConsumePartition(topic, partition, sarama.OffsetOldest) - if err != nil { - log.Printf("kafka Consume Partition %d failed %s\n", partition, err) - return - } - defer pc.Close() - ch := pc.Messages() - for { - select { - case <-time.After(time.Second * 10): // 10s Shuts down when the data cannot be read - return - case message, ok := <-ch: - if !ok { - return - } - msgFromMQV2 := pbmsg.MsgDataToMQ{} - err := proto.Unmarshal(message.Value, &msgFromMQV2) - if err != nil { - log.Printf("kafka msg partition %d offset %d unmarshal failed %s\n", message.Partition, message.Offset, message.Value) - continue - } - if msgFromMQV2.MsgData == nil || msgFromMQV2.OperationID == "" { - continue - } - if msgFromMQV2.MsgData.ContentType < constant.ContentTypeBegin || msgFromMQV2.MsgData.ContentType > constant.AdvancedText { - continue - } - lock.Lock() - _, exist := distinct[msgFromMQV2.MsgData.ClientMsgID] - if !exist { - distinct[msgFromMQV2.MsgData.ClientMsgID] = struct{}{} - } - lock.Unlock() - if exist { - continue - } - msgCh <- &msgFromMQV2 - } - } - }(partition) - } - - go func() { - kfkWg.Wait() - close(msgCh) - }() - - var msgWg sync.WaitGroup - - var ( - success int64 - failed int64 - ) - for i := 0; i < concurrency; i++ { - msgWg.Add(1) - go func() { - defer msgWg.Done() - for message := range msgCh { - HandlerV2Msg(msgClient, adminUserID, message, &success, &failed) - } - }() - } - - msgWg.Wait() - log.Printf("total %d success %d failed %d\n", success+failed, success, failed) -} - -func HandlerV2Msg(msgClient msg.MsgClient, adminUserID string, msgFromMQV2 *pbmsg.MsgDataToMQ, success *int64, failed *int64) { - msgData := &sdkws.MsgData{ - SendID: msgFromMQV2.MsgData.SendID, - RecvID: msgFromMQV2.MsgData.RecvID, - GroupID: msgFromMQV2.MsgData.GroupID, - ClientMsgID: msgFromMQV2.MsgData.ClientMsgID, - ServerMsgID: msgFromMQV2.MsgData.ServerMsgID, - SenderPlatformID: msgFromMQV2.MsgData.SenderPlatformID, - SenderNickname: msgFromMQV2.MsgData.SenderNickname, - SenderFaceURL: msgFromMQV2.MsgData.SenderFaceURL, - SessionType: msgFromMQV2.MsgData.SessionType, - MsgFrom: msgFromMQV2.MsgData.MsgFrom, - ContentType: msgFromMQV2.MsgData.ContentType, - SendTime: msgFromMQV2.MsgData.SendTime, - CreateTime: msgFromMQV2.MsgData.CreateTime, - Status: msgFromMQV2.MsgData.Status, - IsRead: false, - Options: msgFromMQV2.MsgData.Options, - AtUserIDList: msgFromMQV2.MsgData.AtUserIDList, - AttachedInfo: msgFromMQV2.MsgData.AttachedInfo, - Ex: msgFromMQV2.MsgData.Ex, - } - - if msgFromMQV2.MsgData.OfflinePushInfo != nil { - msgData.OfflinePushInfo = &sdkws.OfflinePushInfo{ - Title: msgFromMQV2.MsgData.OfflinePushInfo.Title, - Desc: msgFromMQV2.MsgData.OfflinePushInfo.Desc, - Ex: msgFromMQV2.MsgData.OfflinePushInfo.Ex, - IOSPushSound: msgFromMQV2.MsgData.OfflinePushInfo.IOSPushSound, - IOSBadgeCount: msgFromMQV2.MsgData.OfflinePushInfo.IOSBadgeCount, - SignalInfo: "", - } - } - switch msgData.ContentType { - case constant.Text: - data, err := json.Marshal(apistruct.TextElem{ - Content: string(msgFromMQV2.MsgData.Content), - }) - if err != nil { - return - } - msgData.Content = data - default: - msgData.Content = msgFromMQV2.MsgData.Content - } - ctx, cancel := context.WithTimeout(context.Background(), time.Second*10) - defer cancel() - ctx = context.WithValue(context.Background(), constant.OperationID, msgFromMQV2.OperationID) - ctx = context.WithValue(ctx, constant.OpUserID, adminUserID) - - resp, err := msgClient.SendMsg(ctx, &msg.SendMsgReq{MsgData: msgData}) - if err != nil { - atomic.AddInt64(failed, 1) - log.Printf("send msg %+v failed %s\n", msgData, err) - return - } - atomic.AddInt64(success, 1) - log.Printf("send msg success %+v resp %+v\n", msgData, resp) -} diff --git a/tools/data-conversion/openim/cmd/conversion-mysql/conversion-mysql.go b/tools/data-conversion/openim/cmd/conversion-mysql/conversion-mysql.go deleted file mode 100644 index 08fa4ca55..000000000 --- a/tools/data-conversion/openim/cmd/conversion-mysql/conversion-mysql.go +++ /dev/null @@ -1,87 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package main - -import ( - "fmt" - "log" - - "gorm.io/driver/mysql" - "gorm.io/gorm" - "gorm.io/gorm/logger" - - "github.com/openimsdk/open-im-server/v3/tools/data-conversion/openim/mysql/conversion" - "github.com/openimsdk/open-im-server/v3/tools/data-conversion/utils" -) - -func main() { - - var ( - // MySQL username for version 2 - usernameV2 = "root" - - // MySQL password for version 2 - passwordV2 = "openIM" - - // MySQL address for version 2 - addrV2 = "127.0.0.1:13306" - - // MySQL database name for version 2 - databaseV2 = "openIM_v2" - ) - - var ( - // MySQL username for version 3 - usernameV3 = "root" - - // MySQL password for version 3 - passwordV3 = "openIM123" - - // MySQL address for version 3 - addrV3 = "127.0.0.1:13306" - - // MySQL database name for version 3 - databaseV3 = "openim_v3" - ) - - // The number of concurrent processes - var concurrency = 1 - - log.SetFlags(log.LstdFlags | log.Llongfile) - dsnV2 := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", usernameV2, passwordV2, addrV2, databaseV2) - dsnV3 := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", usernameV3, passwordV3, addrV3, databaseV3) - dbV2, err := gorm.Open(mysql.Open(dsnV2), &gorm.Config{Logger: logger.Discard}) - if err != nil { - log.Println("open v2 db failed", err) - return - } - dbV3, err := gorm.Open(mysql.Open(dsnV3), &gorm.Config{Logger: logger.Discard}) - if err != nil { - log.Println("open v3 db failed", err) - return - } - - var tasks utils.TakeList - - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.Friend) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.FriendRequest) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.Group) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.GroupMember) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.GroupRequest) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.User) }) - - utils.RunTask(concurrency, tasks) - -} diff --git a/tools/data-conversion/openim/common/config.go b/tools/data-conversion/openim/common/config.go deleted file mode 100644 index e993038d1..000000000 --- a/tools/data-conversion/openim/common/config.go +++ /dev/null @@ -1,65 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package common - -// =================================== V2 ===================================== -// MySQL -// V2. -const ( - UsernameV2 = "root" - PasswordV2 = "openIM" - IpV2 = "121.5.182.23:13306" - DatabaseV2 = "openIM_v2" -) - -// V2 chat. -const ( - ChatUsernameV2 = "root" - ChatPasswordV2 = "openIM" - ChatIpV2 = "121.5.182.23:13306" - ChatDatabaseV2 = "admin_chat" -) - -// Kafka. -const ( - Topic = "ws2ms_chat" - KafkaAddr = "121.5.182.23:9092" -) - -// =================================== V3 ===================================== -// V3. -const ( - UsernameV3 = "root" - PasswordV3 = "openIM123" - IpV3 = "43.134.63.160:13306" - DatabaseV3 = "openim_v3" -) - -// V3 chat. -const ( - ChatUsernameV3 = "root" - ChatPasswordV3 = "openIM123" - ChatIpV3 = "43.134.63.160:13306" - ChatDatabaseV3 = "openim_enterprise" -) - -// Zookeeper. -const ( - ZkAddr = "43.134.63.160:12181" - ZKSchema = "openim" - ZKUsername = "" - ZKPassword = "" - MsgRpcName = "Msg" -) diff --git a/tools/data-conversion/openim/mysql/cmd.go b/tools/data-conversion/openim/mysql/cmd.go deleted file mode 100644 index ab3857fba..000000000 --- a/tools/data-conversion/openim/mysql/cmd.go +++ /dev/null @@ -1,68 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package mysql - -import ( - "fmt" - "log" - - "gorm.io/driver/mysql" - "gorm.io/gorm" - "gorm.io/gorm/logger" - - "github.com/openimsdk/open-im-server/v3/tools/data-conversion/openim/mysql/conversion" - "github.com/openimsdk/open-im-server/v3/tools/data-conversion/utils" -) - -func Cmd() { - var ( - usernameV2 = "root" - passwordV2 = "openIM" - addrV2 = "121.5.182.23:13306" - databaseV2 = "openIM_v2" - ) - - var ( - usernameV3 = "root" - passwordV3 = "openIM123" - addrV3 = "203.56.175.233:13306" - databaseV3 = "openim_v3" - ) - log.SetFlags(log.LstdFlags | log.Llongfile) - dsnV2 := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", usernameV2, passwordV2, addrV2, databaseV2) - dsnV3 := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", usernameV3, passwordV3, addrV3, databaseV3) - dbV2, err := gorm.Open(mysql.Open(dsnV2), &gorm.Config{Logger: logger.Discard}) - if err != nil { - log.Println("open v2 db failed", err) - return - } - dbV3, err := gorm.Open(mysql.Open(dsnV3), &gorm.Config{Logger: logger.Discard}) - if err != nil { - log.Println("open v3 db failed", err) - return - } - - var tasks utils.TakeList - - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.Friend) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.FriendRequest) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.Group) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.GroupMember) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.GroupRequest) }) - tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.User) }) - - utils.RunTask(4, tasks) - -} diff --git a/tools/data-conversion/openim/mysql/conversion/conversion.go b/tools/data-conversion/openim/mysql/conversion/conversion.go deleted file mode 100644 index f371654df..000000000 --- a/tools/data-conversion/openim/mysql/conversion/conversion.go +++ /dev/null @@ -1,125 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package conversion - -import ( - "github.com/OpenIMSDK/protocol/constant" - - v2 "github.com/openimsdk/open-im-server/v3/tools/data-conversion/openim/mysql/v2" - v3 "github.com/openimsdk/open-im-server/v3/tools/data-conversion/openim/mysql/v3" - "github.com/openimsdk/open-im-server/v3/tools/data-conversion/utils" -) - -func Friend(v v2.Friend) (v3.FriendModel, bool) { - utils.InitTime(&v.CreateTime) - return v3.FriendModel{ - OwnerUserID: v.OwnerUserID, - FriendUserID: v.FriendUserID, - Remark: v.Remark, - CreateTime: v.CreateTime, - AddSource: v.AddSource, - OperatorUserID: v.OperatorUserID, - Ex: v.Ex, - }, true -} - -func FriendRequest(v v2.FriendRequest) (v3.FriendRequestModel, bool) { - utils.InitTime(&v.CreateTime, &v.HandleTime) - return v3.FriendRequestModel{ - FromUserID: v.FromUserID, - ToUserID: v.ToUserID, - HandleResult: v.HandleResult, - ReqMsg: v.ReqMsg, - CreateTime: v.CreateTime, - HandlerUserID: v.HandlerUserID, - HandleMsg: v.HandleMsg, - HandleTime: v.HandleTime, - Ex: v.Ex, - }, true -} - -func Group(v v2.Group) (v3.GroupModel, bool) { - switch v.GroupType { - case constant.WorkingGroup, constant.NormalGroup: - v.GroupType = constant.WorkingGroup - default: - return v3.GroupModel{}, false - } - utils.InitTime(&v.CreateTime, &v.NotificationUpdateTime) - return v3.GroupModel{ - GroupID: v.GroupID, - GroupName: v.GroupName, - Notification: v.Notification, - Introduction: v.Introduction, - FaceURL: v.FaceURL, - CreateTime: v.CreateTime, - Ex: v.Ex, - Status: v.Status, - CreatorUserID: v.CreatorUserID, - GroupType: v.GroupType, - NeedVerification: v.NeedVerification, - LookMemberInfo: v.LookMemberInfo, - ApplyMemberFriend: v.ApplyMemberFriend, - NotificationUpdateTime: v.NotificationUpdateTime, - NotificationUserID: v.NotificationUserID, - }, true -} - -func GroupMember(v v2.GroupMember) (v3.GroupMemberModel, bool) { - utils.InitTime(&v.JoinTime, &v.MuteEndTime) - return v3.GroupMemberModel{ - GroupID: v.GroupID, - UserID: v.UserID, - Nickname: v.Nickname, - FaceURL: v.FaceURL, - RoleLevel: v.RoleLevel, - JoinTime: v.JoinTime, - JoinSource: v.JoinSource, - InviterUserID: v.InviterUserID, - OperatorUserID: v.OperatorUserID, - MuteEndTime: v.MuteEndTime, - Ex: v.Ex, - }, true -} - -func GroupRequest(v v2.GroupRequest) (v3.GroupRequestModel, bool) { - utils.InitTime(&v.ReqTime, &v.HandledTime) - return v3.GroupRequestModel{ - UserID: v.UserID, - GroupID: v.GroupID, - HandleResult: v.HandleResult, - ReqMsg: v.ReqMsg, - HandledMsg: v.HandledMsg, - ReqTime: v.ReqTime, - HandleUserID: v.HandleUserID, - HandledTime: v.HandledTime, - JoinSource: v.JoinSource, - InviterUserID: v.InviterUserID, - Ex: v.Ex, - }, true -} - -func User(v v2.User) (v3.UserModel, bool) { - utils.InitTime(&v.CreateTime) - return v3.UserModel{ - UserID: v.UserID, - Nickname: v.Nickname, - FaceURL: v.FaceURL, - Ex: v.Ex, - CreateTime: v.CreateTime, - AppMangerLevel: v.AppMangerLevel, - GlobalRecvMsgOpt: v.GlobalRecvMsgOpt, - }, true -} diff --git a/tools/data-conversion/openim/mysql/v2/model_struct.go b/tools/data-conversion/openim/mysql/v2/model_struct.go deleted file mode 100644 index f05b84977..000000000 --- a/tools/data-conversion/openim/mysql/v2/model_struct.go +++ /dev/null @@ -1,105 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package db - -import "time" - -type Friend struct { - OwnerUserID string `gorm:"column:owner_user_id;primary_key;size:64"` - FriendUserID string `gorm:"column:friend_user_id;primary_key;size:64"` - Remark string `gorm:"column:remark;size:255"` - CreateTime time.Time `gorm:"column:create_time"` - AddSource int32 `gorm:"column:add_source"` - OperatorUserID string `gorm:"column:operator_user_id;size:64"` - Ex string `gorm:"column:ex;size:1024"` -} - -type FriendRequest struct { - FromUserID string `gorm:"column:from_user_id;primary_key;size:64"` - ToUserID string `gorm:"column:to_user_id;primary_key;size:64"` - HandleResult int32 `gorm:"column:handle_result"` - ReqMsg string `gorm:"column:req_msg;size:255"` - CreateTime time.Time `gorm:"column:create_time"` - HandlerUserID string `gorm:"column:handler_user_id;size:64"` - HandleMsg string `gorm:"column:handle_msg;size:255"` - HandleTime time.Time `gorm:"column:handle_time"` - Ex string `gorm:"column:ex;size:1024"` -} - -func (FriendRequest) TableName() string { - return "friend_requests" -} - -type Group struct { - GroupID string `gorm:"column:group_id;primary_key;size:64" json:"groupID" binding:"required"` - GroupName string `gorm:"column:name;size:255" json:"groupName"` - Notification string `gorm:"column:notification;size:255" json:"notification"` - Introduction string `gorm:"column:introduction;size:255" json:"introduction"` - FaceURL string `gorm:"column:face_url;size:255" json:"faceURL"` - CreateTime time.Time `gorm:"column:create_time;index:create_time"` - Ex string `gorm:"column:ex" json:"ex;size:1024"` - Status int32 `gorm:"column:status"` - CreatorUserID string `gorm:"column:creator_user_id;size:64"` - GroupType int32 `gorm:"column:group_type"` - NeedVerification int32 `gorm:"column:need_verification"` - LookMemberInfo int32 `gorm:"column:look_member_info" json:"lookMemberInfo"` - ApplyMemberFriend int32 `gorm:"column:apply_member_friend" json:"applyMemberFriend"` - NotificationUpdateTime time.Time `gorm:"column:notification_update_time"` - NotificationUserID string `gorm:"column:notification_user_id;size:64"` -} - -type GroupMember struct { - GroupID string `gorm:"column:group_id;primary_key;size:64"` - UserID string `gorm:"column:user_id;primary_key;size:64"` - Nickname string `gorm:"column:nickname;size:255"` - FaceURL string `gorm:"column:user_group_face_url;size:255"` - RoleLevel int32 `gorm:"column:role_level"` - JoinTime time.Time `gorm:"column:join_time"` - JoinSource int32 `gorm:"column:join_source"` - InviterUserID string `gorm:"column:inviter_user_id;size:64"` - OperatorUserID string `gorm:"column:operator_user_id;size:64"` - MuteEndTime time.Time `gorm:"column:mute_end_time"` - Ex string `gorm:"column:ex;size:1024"` -} - -type GroupRequest struct { - UserID string `gorm:"column:user_id;primary_key;size:64"` - GroupID string `gorm:"column:group_id;primary_key;size:64"` - HandleResult int32 `gorm:"column:handle_result"` - ReqMsg string `gorm:"column:req_msg;size:1024"` - HandledMsg string `gorm:"column:handle_msg;size:1024"` - ReqTime time.Time `gorm:"column:req_time"` - HandleUserID string `gorm:"column:handle_user_id;size:64"` - HandledTime time.Time `gorm:"column:handle_time"` - JoinSource int32 `gorm:"column:join_source"` - InviterUserID string `gorm:"column:inviter_user_id;size:64"` - Ex string `gorm:"column:ex;size:1024"` -} - -type User struct { - UserID string `gorm:"column:user_id;primary_key;size:64"` - Nickname string `gorm:"column:name;size:255"` - FaceURL string `gorm:"column:face_url;size:255"` - Gender int32 `gorm:"column:gender"` - PhoneNumber string `gorm:"column:phone_number;size:32"` - Birth time.Time `gorm:"column:birth"` - Email string `gorm:"column:email;size:64"` - Ex string `gorm:"column:ex;size:1024"` - CreateTime time.Time `gorm:"column:create_time;index:create_time"` - AppMangerLevel int32 `gorm:"column:app_manger_level"` - GlobalRecvMsgOpt int32 `gorm:"column:global_recv_msg_opt"` - - status int32 `gorm:"column:status"` -} diff --git a/tools/data-conversion/openim/mysql/v3/black.go b/tools/data-conversion/openim/mysql/v3/black.go deleted file mode 100644 index 59dd12122..000000000 --- a/tools/data-conversion/openim/mysql/v3/black.go +++ /dev/null @@ -1,49 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package relation - -import ( - "context" - "time" -) - -const ( - BlackModelTableName = "blacks" -) - -type BlackModel struct { - OwnerUserID string `gorm:"column:owner_user_id;primary_key;size:64"` - BlockUserID string `gorm:"column:block_user_id;primary_key;size:64"` - CreateTime time.Time `gorm:"column:create_time"` - AddSource int32 `gorm:"column:add_source"` - OperatorUserID string `gorm:"column:operator_user_id;size:64"` - Ex string `gorm:"column:ex;size:1024"` -} - -func (BlackModel) TableName() string { - return BlackModelTableName -} - -type BlackModelInterface interface { - Create(ctx context.Context, blacks []*BlackModel) (err error) - Delete(ctx context.Context, blacks []*BlackModel) (err error) - UpdateByMap(ctx context.Context, ownerUserID, blockUserID string, args map[string]interface{}) (err error) - Update(ctx context.Context, blacks []*BlackModel) (err error) - Find(ctx context.Context, blacks []*BlackModel) (blackList []*BlackModel, err error) - Take(ctx context.Context, ownerUserID, blockUserID string) (black *BlackModel, err error) - FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blacks []*BlackModel, total int64, err error) - FindOwnerBlackInfos(ctx context.Context, ownerUserID string, userIDs []string) (blacks []*BlackModel, err error) - FindBlackUserIDs(ctx context.Context, ownerUserID string) (blackUserIDs []string, err error) -} diff --git a/tools/data-conversion/openim/mysql/v3/chatlog.go b/tools/data-conversion/openim/mysql/v3/chatlog.go deleted file mode 100644 index 810de3db3..000000000 --- a/tools/data-conversion/openim/mysql/v3/chatlog.go +++ /dev/null @@ -1,51 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package relation - -import ( - "time" - - pbmsg "github.com/OpenIMSDK/protocol/msg" -) - -const ( - ChatLogModelTableName = "chat_logs" -) - -type ChatLogModel struct { - ServerMsgID string `gorm:"column:server_msg_id;primary_key;type:char(64)" json:"serverMsgID"` - ClientMsgID string `gorm:"column:client_msg_id;type:char(64)" json:"clientMsgID"` - SendID string `gorm:"column:send_id;type:char(64);index:send_id,priority:2" json:"sendID"` - RecvID string `gorm:"column:recv_id;type:char(64);index:recv_id,priority:2" json:"recvID"` - SenderPlatformID int32 `gorm:"column:sender_platform_id" json:"senderPlatformID"` - SenderNickname string `gorm:"column:sender_nick_name;type:varchar(255)" json:"senderNickname"` - SenderFaceURL string `gorm:"column:sender_face_url;type:varchar(255);" json:"senderFaceURL"` - SessionType int32 `gorm:"column:session_type;index:session_type,priority:2;index:session_type_alone" json:"sessionType"` - MsgFrom int32 `gorm:"column:msg_from" json:"msgFrom"` - ContentType int32 `gorm:"column:content_type;index:content_type,priority:2;index:content_type_alone" json:"contentType"` - Content string `gorm:"column:content;type:varchar(3000)" json:"content"` - Status int32 `gorm:"column:status" json:"status"` - SendTime time.Time `gorm:"column:send_time;index:sendTime;index:content_type,priority:1;index:session_type,priority:1;index:recv_id,priority:1;index:send_id,priority:1" json:"sendTime"` - CreateTime time.Time `gorm:"column:create_time" json:"createTime"` - Ex string `gorm:"column:ex;type:varchar(1024)" json:"ex"` -} - -func (ChatLogModel) TableName() string { - return ChatLogModelTableName -} - -type ChatLogModelInterface interface { - Create(msg *pbmsg.MsgDataToMQ) error -} diff --git a/tools/data-conversion/openim/mysql/v3/conversation.go b/tools/data-conversion/openim/mysql/v3/conversation.go deleted file mode 100644 index e9680873f..000000000 --- a/tools/data-conversion/openim/mysql/v3/conversation.go +++ /dev/null @@ -1,73 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package relation - -import ( - "context" - "time" -) - -const ( - conversationModelTableName = "conversations" -) - -type ConversationModel struct { - OwnerUserID string `gorm:"column:owner_user_id;primary_key;type:char(128)" json:"OwnerUserID"` - ConversationID string `gorm:"column:conversation_id;primary_key;type:char(128)" json:"conversationID"` - ConversationType int32 `gorm:"column:conversation_type" json:"conversationType"` - UserID string `gorm:"column:user_id;type:char(64)" json:"userID"` - GroupID string `gorm:"column:group_id;type:char(128)" json:"groupID"` - RecvMsgOpt int32 `gorm:"column:recv_msg_opt" json:"recvMsgOpt"` - IsPinned bool `gorm:"column:is_pinned" json:"isPinned"` - IsPrivateChat bool `gorm:"column:is_private_chat" json:"isPrivateChat"` - BurnDuration int32 `gorm:"column:burn_duration;default:30" json:"burnDuration"` - GroupAtType int32 `gorm:"column:group_at_type" json:"groupAtType"` - AttachedInfo string `gorm:"column:attached_info;type:varchar(1024)" json:"attachedInfo"` - Ex string `gorm:"column:ex;type:varchar(1024)" json:"ex"` - MaxSeq int64 `gorm:"column:max_seq" json:"maxSeq"` - MinSeq int64 `gorm:"column:min_seq" json:"minSeq"` - CreateTime time.Time `gorm:"column:create_time;index:create_time;autoCreateTime"` - IsMsgDestruct bool `gorm:"column:is_msg_destruct;default:false"` - MsgDestructTime int64 `gorm:"column:msg_destruct_time;default:604800"` - LatestMsgDestructTime time.Time `gorm:"column:latest_msg_destruct_time;autoCreateTime"` -} - -func (ConversationModel) TableName() string { - return conversationModelTableName -} - -type ConversationModelInterface interface { - Create(ctx context.Context, conversations []*ConversationModel) (err error) - Delete(ctx context.Context, groupIDs []string) (err error) - UpdateByMap(ctx context.Context, userIDs []string, conversationID string, args map[string]interface{}) (rows int64, err error) - Update(ctx context.Context, conversation *ConversationModel) (err error) - Find(ctx context.Context, ownerUserID string, conversationIDs []string) (conversations []*ConversationModel, err error) - FindUserID(ctx context.Context, userIDs []string, conversationIDs []string) ([]string, error) - FindUserIDAllConversationID(ctx context.Context, userID string) ([]string, error) - Take(ctx context.Context, userID, conversationID string) (conversation *ConversationModel, err error) - FindConversationID(ctx context.Context, userID string, conversationIDs []string) (existConversationID []string, err error) - FindUserIDAllConversations(ctx context.Context, userID string) (conversations []*ConversationModel, err error) - FindRecvMsgNotNotifyUserIDs(ctx context.Context, groupID string) ([]string, error) - GetUserRecvMsgOpt(ctx context.Context, ownerUserID, conversationID string) (opt int, err error) - FindSuperGroupRecvMsgNotNotifyUserIDs(ctx context.Context, groupID string) ([]string, error) - GetAllConversationIDs(ctx context.Context) ([]string, error) - GetAllConversationIDsNumber(ctx context.Context) (int64, error) - PageConversationIDs(ctx context.Context, pageNumber, showNumber int32) (conversationIDs []string, err error) - GetUserAllHasReadSeqs(ctx context.Context, ownerUserID string) (hashReadSeqs map[string]int64, err error) - GetConversationsByConversationID(ctx context.Context, conversationIDs []string) ([]*ConversationModel, error) - GetConversationIDsNeedDestruct(ctx context.Context) ([]*ConversationModel, error) - GetConversationNotReceiveMessageUserIDs(ctx context.Context, conversationID string) ([]string, error) - NewTx(tx any) ConversationModelInterface -} diff --git a/tools/data-conversion/openim/mysql/v3/doc.go b/tools/data-conversion/openim/mysql/v3/doc.go deleted file mode 100644 index 32185c8c7..000000000 --- a/tools/data-conversion/openim/mysql/v3/doc.go +++ /dev/null @@ -1,15 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package relation // import "github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation" diff --git a/tools/data-conversion/openim/mysql/v3/friend.go b/tools/data-conversion/openim/mysql/v3/friend.go deleted file mode 100644 index 4f3fb6bdf..000000000 --- a/tools/data-conversion/openim/mysql/v3/friend.go +++ /dev/null @@ -1,67 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package relation - -import ( - "context" - "time" -) - -const ( - FriendModelTableName = "friends" -) - -type FriendModel struct { - OwnerUserID string `gorm:"column:owner_user_id;primary_key;size:64"` - FriendUserID string `gorm:"column:friend_user_id;primary_key;size:64"` - Remark string `gorm:"column:remark;size:255"` - CreateTime time.Time `gorm:"column:create_time;autoCreateTime"` - AddSource int32 `gorm:"column:add_source"` - OperatorUserID string `gorm:"column:operator_user_id;size:64"` - Ex string `gorm:"column:ex;size:1024"` -} - -func (FriendModel) TableName() string { - return FriendModelTableName -} - -type FriendModelInterface interface { - // Create inserts multiple friend records. - Create(ctx context.Context, friends []*FriendModel) error - // Delete removes specified friends for an owner user. - Delete(ctx context.Context, ownerUserID string, friendUserIDs []string) error - // UpdateByMap updates a single friend's information for an owner user based on a map of arguments. Zero values are updated. - UpdateByMap(ctx context.Context, ownerUserID string, friendUserID string, args map[string]interface{}) error - // Update modifies the information of friends, excluding zero values. - Update(ctx context.Context, friends []*FriendModel) error - // UpdateRemark updates the remark for a friend, supporting zero values. - UpdateRemark(ctx context.Context, ownerUserID, friendUserID, remark string) error - // Take retrieves a single friend's information. Returns an error if not found. - Take(ctx context.Context, ownerUserID, friendUserID string) (*FriendModel, error) - // FindUserState finds the friendship status between two users, returning both if a mutual friendship exists. - FindUserState(ctx context.Context, userID1, userID2 string) ([]*FriendModel, error) - // FindFriends retrieves a list of friends for an owner, not returning an error for non-existent friendUserIDs. - FindFriends(ctx context.Context, ownerUserID string, friendUserIDs []string) ([]*FriendModel, error) - // FindReversalFriends finds who has added the specified user as a friend, not returning an error for non-existent ownerUserIDs. - FindReversalFriends(ctx context.Context, friendUserID string, ownerUserIDs []string) ([]*FriendModel, error) - // FindOwnerFriends paginates through the friends list of an owner user. - FindOwnerFriends(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) ([]*FriendModel, int64, error) - // FindInWhoseFriends paginates through users who have added the specified user as a friend. - FindInWhoseFriends(ctx context.Context, friendUserID string, pageNumber, showNumber int32) ([]*FriendModel, int64, error) - // FindFriendUserIDs retrieves a list of friend user IDs for an owner user. - FindFriendUserIDs(ctx context.Context, ownerUserID string) ([]string, error) - // NewTx creates a new transactional instance of the FriendModelInterface. - NewTx(tx any) FriendModelInterface -} diff --git a/tools/data-conversion/openim/mysql/v3/friend_request.go b/tools/data-conversion/openim/mysql/v3/friend_request.go deleted file mode 100644 index 4fc5ba7c1..000000000 --- a/tools/data-conversion/openim/mysql/v3/friend_request.go +++ /dev/null @@ -1,70 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package relation - -import ( - "context" - "time" -) - -const FriendRequestModelTableName = "friend_requests" - -type FriendRequestModel struct { - FromUserID string `gorm:"column:from_user_id;primary_key;size:64"` - ToUserID string `gorm:"column:to_user_id;primary_key;size:64"` - HandleResult int32 `gorm:"column:handle_result"` - ReqMsg string `gorm:"column:req_msg;size:255"` - CreateTime time.Time `gorm:"column:create_time; autoCreateTime"` - HandlerUserID string `gorm:"column:handler_user_id;size:64"` - HandleMsg string `gorm:"column:handle_msg;size:255"` - HandleTime time.Time `gorm:"column:handle_time"` - Ex string `gorm:"column:ex;size:1024"` -} - -func (FriendRequestModel) TableName() string { - return FriendRequestModelTableName -} - -type FriendRequestModelInterface interface { - // Insert multiple records - Create(ctx context.Context, friendRequests []*FriendRequestModel) (err error) - - // Delete a record - Delete(ctx context.Context, fromUserID, toUserID string) (err error) - - // Update records with zero values based on a map of changes - UpdateByMap(ctx context.Context, formUserID, toUserID string, args map[string]interface{}) (err error) - - // Update multiple records (non-zero values) - Update(ctx context.Context, friendRequest *FriendRequestModel) (err error) - - // Find a friend request sent to a specific user; does not return an error if not found - Find(ctx context.Context, fromUserID, toUserID string) (friendRequest *FriendRequestModel, err error) - - // Alias for Find (retrieves a friend request between two users) - Take(ctx context.Context, fromUserID, toUserID string) (friendRequest *FriendRequestModel, err error) - - // Get a list of friend requests received by `toUserID` - FindToUserID(ctx context.Context, toUserID string, pageNumber, showNumber int32) (friendRequests []*FriendRequestModel, total int64, err error) - - // Get a list of friend requests sent by `fromUserID` - FindFromUserID(ctx context.Context, fromUserID string, pageNumber, showNumber int32) (friendRequests []*FriendRequestModel, total int64, err error) - - // Find all friend requests between two users (both directions) - FindBothFriendRequests(ctx context.Context, fromUserID, toUserID string) (friends []*FriendRequestModel, err error) - - // Create a new transaction - NewTx(tx any) FriendRequestModelInterface -} diff --git a/tools/data-conversion/openim/mysql/v3/group.go b/tools/data-conversion/openim/mysql/v3/group.go deleted file mode 100644 index ccf61266a..000000000 --- a/tools/data-conversion/openim/mysql/v3/group.go +++ /dev/null @@ -1,67 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package relation - -import ( - "context" - "time" -) - -const ( - GroupModelTableName = "groups" -) - -type GroupModel struct { - GroupID string `gorm:"column:group_id;primary_key;size:64" json:"groupID" binding:"required"` - GroupName string `gorm:"column:name;size:255" json:"groupName"` - Notification string `gorm:"column:notification;size:255" json:"notification"` - Introduction string `gorm:"column:introduction;size:255" json:"introduction"` - FaceURL string `gorm:"column:face_url;size:255" json:"faceURL"` - CreateTime time.Time `gorm:"column:create_time;index:create_time;autoCreateTime"` - Ex string `gorm:"column:ex" json:"ex;size:1024"` - Status int32 `gorm:"column:status"` - CreatorUserID string `gorm:"column:creator_user_id;size:64"` - GroupType int32 `gorm:"column:group_type"` - NeedVerification int32 `gorm:"column:need_verification"` - LookMemberInfo int32 `gorm:"column:look_member_info" json:"lookMemberInfo"` - ApplyMemberFriend int32 `gorm:"column:apply_member_friend" json:"applyMemberFriend"` - NotificationUpdateTime time.Time `gorm:"column:notification_update_time"` - NotificationUserID string `gorm:"column:notification_user_id;size:64"` -} - -func (GroupModel) TableName() string { - return GroupModelTableName -} - -type GroupModelInterface interface { - NewTx(tx any) GroupModelInterface - Create(ctx context.Context, groups []*GroupModel) (err error) - UpdateMap(ctx context.Context, groupID string, args map[string]interface{}) (err error) - UpdateStatus(ctx context.Context, groupID string, status int32) (err error) - Find(ctx context.Context, groupIDs []string) (groups []*GroupModel, err error) - FindNotDismissedGroup(ctx context.Context, groupIDs []string) (groups []*GroupModel, err error) - Take(ctx context.Context, groupID string) (group *GroupModel, err error) - Search( - ctx context.Context, - keyword string, - pageNumber, showNumber int32, - ) (total uint32, groups []*GroupModel, err error) - // GetGroupIDsByCreatorUserID retrieves a list of group IDs created by the specified user. - GetGroupIDsByGroupType(ctx context.Context, groupType int) (groupIDs []string, err error) - // CountTotal retrieves the total number of groups. - CountTotal(ctx context.Context, before *time.Time) (count int64, err error) - // CountRangeEverydayTotal retrieves the total number of groups created every day within the specified time range. - CountRangeEverydayTotal(ctx context.Context, start time.Time, end time.Time) (map[string]int64, error) -} diff --git a/tools/data-conversion/openim/mysql/v3/group_member.go b/tools/data-conversion/openim/mysql/v3/group_member.go deleted file mode 100644 index bfde72834..000000000 --- a/tools/data-conversion/openim/mysql/v3/group_member.go +++ /dev/null @@ -1,74 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package relation - -import ( - "context" - "time" -) - -const ( - GroupMemberModelTableName = "group_members" -) - -type GroupMemberModel struct { - GroupID string `gorm:"column:group_id;primary_key;size:64"` - UserID string `gorm:"column:user_id;primary_key;size:64"` - Nickname string `gorm:"column:nickname;size:255"` - FaceURL string `gorm:"column:user_group_face_url;size:255"` - RoleLevel int32 `gorm:"column:role_level"` - JoinTime time.Time `gorm:"column:join_time"` - JoinSource int32 `gorm:"column:join_source"` - InviterUserID string `gorm:"column:inviter_user_id;size:64"` - OperatorUserID string `gorm:"column:operator_user_id;size:64"` - MuteEndTime time.Time `gorm:"column:mute_end_time"` - Ex string `gorm:"column:ex;size:1024"` -} - -func (GroupMemberModel) TableName() string { - return GroupMemberModelTableName -} - -type GroupMemberModelInterface interface { - NewTx(tx any) GroupMemberModelInterface - Create(ctx context.Context, groupMembers []*GroupMemberModel) (err error) - Delete(ctx context.Context, groupID string, userIDs []string) (err error) - DeleteGroup(ctx context.Context, groupIDs []string) (err error) - Update(ctx context.Context, groupID string, userID string, data map[string]any) (err error) - UpdateRoleLevel(ctx context.Context, groupID string, userID string, roleLevel int32) (rowsAffected int64, err error) - Find( - ctx context.Context, - groupIDs []string, - userIDs []string, - roleLevels []int32, - ) (groupMembers []*GroupMemberModel, err error) - FindMemberUserID(ctx context.Context, groupID string) (userIDs []string, err error) - Take(ctx context.Context, groupID string, userID string) (groupMember *GroupMemberModel, err error) - TakeOwner(ctx context.Context, groupID string) (groupMember *GroupMemberModel, err error) - SearchMember( - ctx context.Context, - keyword string, - groupIDs []string, - userIDs []string, - roleLevels []int32, - pageNumber, showNumber int32, - ) (total uint32, groupList []*GroupMemberModel, err error) - MapGroupMemberNum(ctx context.Context, groupIDs []string) (count map[string]uint32, err error) - FindJoinUserID(ctx context.Context, groupIDs []string) (groupUsers map[string][]string, err error) - FindUserJoinedGroupID(ctx context.Context, userID string) (groupIDs []string, err error) - TakeGroupMemberNum(ctx context.Context, groupID string) (count int64, err error) - FindUsersJoinedGroupID(ctx context.Context, userIDs []string) (map[string][]string, error) - FindUserManagedGroupID(ctx context.Context, userID string) (groupIDs []string, err error) -} diff --git a/tools/data-conversion/openim/mysql/v3/group_request.go b/tools/data-conversion/openim/mysql/v3/group_request.go deleted file mode 100644 index 063b83938..000000000 --- a/tools/data-conversion/openim/mysql/v3/group_request.go +++ /dev/null @@ -1,61 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package relation - -import ( - "context" - "time" -) - -const ( - GroupRequestModelTableName = "group_requests" -) - -type GroupRequestModel struct { - UserID string `gorm:"column:user_id;primary_key;size:64"` - GroupID string `gorm:"column:group_id;primary_key;size:64"` - HandleResult int32 `gorm:"column:handle_result"` - ReqMsg string `gorm:"column:req_msg;size:1024"` - HandledMsg string `gorm:"column:handle_msg;size:1024"` - ReqTime time.Time `gorm:"column:req_time"` - HandleUserID string `gorm:"column:handle_user_id;size:64"` - HandledTime time.Time `gorm:"column:handle_time"` - JoinSource int32 `gorm:"column:join_source"` - InviterUserID string `gorm:"column:inviter_user_id;size:64"` - Ex string `gorm:"column:ex;size:1024"` -} - -func (GroupRequestModel) TableName() string { - return GroupRequestModelTableName -} - -type GroupRequestModelInterface interface { - NewTx(tx any) GroupRequestModelInterface - Create(ctx context.Context, groupRequests []*GroupRequestModel) (err error) - Delete(ctx context.Context, groupID string, userID string) (err error) - UpdateHandler(ctx context.Context, groupID string, userID string, handledMsg string, handleResult int32) (err error) - Take(ctx context.Context, groupID string, userID string) (groupRequest *GroupRequestModel, err error) - FindGroupRequests(ctx context.Context, groupID string, userIDs []string) (int64, []*GroupRequestModel, error) - Page( - ctx context.Context, - userID string, - pageNumber, showNumber int32, - ) (total uint32, groups []*GroupRequestModel, err error) - PageGroup( - ctx context.Context, - groupIDs []string, - pageNumber, showNumber int32, - ) (total uint32, groups []*GroupRequestModel, err error) -} diff --git a/tools/data-conversion/openim/mysql/v3/log.go b/tools/data-conversion/openim/mysql/v3/log.go deleted file mode 100644 index 22198ca7c..000000000 --- a/tools/data-conversion/openim/mysql/v3/log.go +++ /dev/null @@ -1,43 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package relation - -import ( - "context" - "time" -) - -type Log struct { - LogID string `gorm:"column:log_id;primary_key;type:char(64)"` - Platform string `gorm:"column:platform;type:varchar(32)"` - UserID string `gorm:"column:user_id;type:char(64)"` - CreateTime time.Time `gorm:"index:,sort:desc"` - Url string `gorm:"column:url;type varchar(255)"` - FileName string `gorm:"column:filename;type varchar(255)"` - SystemType string `gorm:"column:system_type;type varchar(255)"` - Version string `gorm:"column:version;type varchar(255)"` - Ex string `gorm:"column:ex;type varchar(255)"` -} - -func (Log) TableName() string { - return "logs" -} - -type LogInterface interface { - Create(ctx context.Context, log []*Log) error - Search(ctx context.Context, keyword string, start time.Time, end time.Time, pageNumber int32, showNumber int32) (uint32, []*Log, error) - Delete(ctx context.Context, logID []string, userID string) error - Get(ctx context.Context, logIDs []string, userID string) ([]*Log, error) -} diff --git a/tools/data-conversion/openim/mysql/v3/object.go b/tools/data-conversion/openim/mysql/v3/object.go deleted file mode 100644 index 0ed4130a6..000000000 --- a/tools/data-conversion/openim/mysql/v3/object.go +++ /dev/null @@ -1,45 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package relation - -import ( - "context" - "time" -) - -const ( - ObjectInfoModelTableName = "object" -) - -type ObjectModel struct { - Name string `gorm:"column:name;primary_key"` - UserID string `gorm:"column:user_id"` - Hash string `gorm:"column:hash"` - Key string `gorm:"column:key"` - Size int64 `gorm:"column:size"` - ContentType string `gorm:"column:content_type"` - Cause string `gorm:"column:cause"` - CreateTime time.Time `gorm:"column:create_time"` -} - -func (ObjectModel) TableName() string { - return ObjectInfoModelTableName -} - -type ObjectInfoModelInterface interface { - NewTx(tx any) ObjectInfoModelInterface - SetObject(ctx context.Context, obj *ObjectModel) error - Take(ctx context.Context, name string) (*ObjectModel, error) -} diff --git a/tools/data-conversion/openim/mysql/v3/user.go b/tools/data-conversion/openim/mysql/v3/user.go deleted file mode 100644 index 409689933..000000000 --- a/tools/data-conversion/openim/mysql/v3/user.go +++ /dev/null @@ -1,87 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package relation - -import ( - "context" - "time" -) - -const ( - UserModelTableName = "users" -) - -type UserModel struct { - UserID string `gorm:"column:user_id;primary_key;size:64"` - Nickname string `gorm:"column:name;size:255"` - FaceURL string `gorm:"column:face_url;size:255"` - Ex string `gorm:"column:ex;size:1024"` - CreateTime time.Time `gorm:"column:create_time;index:create_time;autoCreateTime"` - AppMangerLevel int32 `gorm:"column:app_manger_level;default:1"` - GlobalRecvMsgOpt int32 `gorm:"column:global_recv_msg_opt"` -} - -func (u *UserModel) GetNickname() string { - return u.Nickname -} - -func (u *UserModel) GetFaceURL() string { - return u.FaceURL -} - -func (u *UserModel) GetUserID() string { - return u.UserID -} - -func (u *UserModel) GetEx() string { - return u.Ex -} - -func (UserModel) TableName() string { - return UserModelTableName -} - -// UserModelInterface defines the operations available for managing user models. -type UserModelInterface interface { - // Create inserts a new user or multiple users into the database. - Create(ctx context.Context, users []*UserModel) (err error) - - // UpdateByMap updates a user's information based on a map of changes. - UpdateByMap(ctx context.Context, userID string, args map[string]interface{}) (err error) - - // Update modifies a user's information in the database. - Update(ctx context.Context, user *UserModel) (err error) - - // Find retrieves information for a list of users by their IDs. If a user does not exist, it is simply skipped without returning an error. - Find(ctx context.Context, userIDs []string) (users []*UserModel, err error) - - // Take retrieves a specific user's information by their ID. Returns an error if the user does not exist. - Take(ctx context.Context, userID string) (user *UserModel, err error) - - // Page retrieves a paginated list of users and the total count of users. If no users exist, returns an empty list without an error. - Page(ctx context.Context, pageNumber, showNumber int32) (users []*UserModel, count int64, err error) - - // GetAllUserID retrieves all user IDs in a paginated manner. - GetAllUserID(ctx context.Context, pageNumber, showNumber int32) (userIDs []string, err error) - - // GetUserGlobalRecvMsgOpt retrieves a user's global message receiving option. - GetUserGlobalRecvMsgOpt(ctx context.Context, userID string) (opt int, err error) - - // CountTotal returns the total number of users before a specified time. - CountTotal(ctx context.Context, before *time.Time) (count int64, err error) - - // CountRangeEverydayTotal calculates the daily increment of users within a specified time range. - CountRangeEverydayTotal(ctx context.Context, start time.Time, end time.Time) (map[string]int64, error) -} diff --git a/tools/data-conversion/openim/proto/msg/msg.pb.go b/tools/data-conversion/openim/proto/msg/msg.pb.go deleted file mode 100644 index a0a6cdf02..000000000 --- a/tools/data-conversion/openim/proto/msg/msg.pb.go +++ /dev/null @@ -1,3161 +0,0 @@ -// Code generated by protoc-gen-go. DO NOT EDIT. -// source: msg/msg.proto - -package msg // import "Open_IM/pkg/proto/msg" - -import ( - proto "github.com/golang/protobuf/proto" - sdk_ws "github.com/openimsdk/open-im-server/v3/tools/data-conversion/openim/proto/sdk_ws" -) -import fmt "fmt" -import math "math" -import wrapperspb "google.golang.org/protobuf/types/known/wrapperspb" - -import ( - context "golang.org/x/net/context" - grpc "google.golang.org/grpc" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package - -type MsgDataToMQ struct { - Token string `protobuf:"bytes,1,opt,name=token" json:"token,omitempty"` - OperationID string `protobuf:"bytes,2,opt,name=operationID" json:"operationID,omitempty"` - MsgData *sdk_ws.MsgData `protobuf:"bytes,3,opt,name=msgData" json:"msgData,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *MsgDataToMQ) Reset() { *m = MsgDataToMQ{} } -func (m *MsgDataToMQ) String() string { return proto.CompactTextString(m) } -func (*MsgDataToMQ) ProtoMessage() {} -func (*MsgDataToMQ) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{0} -} -func (m *MsgDataToMQ) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MsgDataToMQ.Unmarshal(m, b) -} -func (m *MsgDataToMQ) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MsgDataToMQ.Marshal(b, m, deterministic) -} -func (dst *MsgDataToMQ) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgDataToMQ.Merge(dst, src) -} -func (m *MsgDataToMQ) XXX_Size() int { - return xxx_messageInfo_MsgDataToMQ.Size(m) -} -func (m *MsgDataToMQ) XXX_DiscardUnknown() { - xxx_messageInfo_MsgDataToMQ.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgDataToMQ proto.InternalMessageInfo - -func (m *MsgDataToMQ) GetToken() string { - if m != nil { - return m.Token - } - return "" -} - -func (m *MsgDataToMQ) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -func (m *MsgDataToMQ) GetMsgData() *sdk_ws.MsgData { - if m != nil { - return m.MsgData - } - return nil -} - -type MsgDataToDB struct { - MsgData *sdk_ws.MsgData `protobuf:"bytes,1,opt,name=msgData" json:"msgData,omitempty"` - OperationID string `protobuf:"bytes,2,opt,name=operationID" json:"operationID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *MsgDataToDB) Reset() { *m = MsgDataToDB{} } -func (m *MsgDataToDB) String() string { return proto.CompactTextString(m) } -func (*MsgDataToDB) ProtoMessage() {} -func (*MsgDataToDB) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{1} -} -func (m *MsgDataToDB) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MsgDataToDB.Unmarshal(m, b) -} -func (m *MsgDataToDB) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MsgDataToDB.Marshal(b, m, deterministic) -} -func (dst *MsgDataToDB) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgDataToDB.Merge(dst, src) -} -func (m *MsgDataToDB) XXX_Size() int { - return xxx_messageInfo_MsgDataToDB.Size(m) -} -func (m *MsgDataToDB) XXX_DiscardUnknown() { - xxx_messageInfo_MsgDataToDB.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgDataToDB proto.InternalMessageInfo - -func (m *MsgDataToDB) GetMsgData() *sdk_ws.MsgData { - if m != nil { - return m.MsgData - } - return nil -} - -func (m *MsgDataToDB) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -type PushMsgDataToMQ struct { - OperationID string `protobuf:"bytes,1,opt,name=OperationID" json:"OperationID,omitempty"` - MsgData *sdk_ws.MsgData `protobuf:"bytes,2,opt,name=msgData" json:"msgData,omitempty"` - PushToUserID string `protobuf:"bytes,3,opt,name=pushToUserID" json:"pushToUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *PushMsgDataToMQ) Reset() { *m = PushMsgDataToMQ{} } -func (m *PushMsgDataToMQ) String() string { return proto.CompactTextString(m) } -func (*PushMsgDataToMQ) ProtoMessage() {} -func (*PushMsgDataToMQ) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{2} -} -func (m *PushMsgDataToMQ) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_PushMsgDataToMQ.Unmarshal(m, b) -} -func (m *PushMsgDataToMQ) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_PushMsgDataToMQ.Marshal(b, m, deterministic) -} -func (dst *PushMsgDataToMQ) XXX_Merge(src proto.Message) { - xxx_messageInfo_PushMsgDataToMQ.Merge(dst, src) -} -func (m *PushMsgDataToMQ) XXX_Size() int { - return xxx_messageInfo_PushMsgDataToMQ.Size(m) -} -func (m *PushMsgDataToMQ) XXX_DiscardUnknown() { - xxx_messageInfo_PushMsgDataToMQ.DiscardUnknown(m) -} - -var xxx_messageInfo_PushMsgDataToMQ proto.InternalMessageInfo - -func (m *PushMsgDataToMQ) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -func (m *PushMsgDataToMQ) GetMsgData() *sdk_ws.MsgData { - if m != nil { - return m.MsgData - } - return nil -} - -func (m *PushMsgDataToMQ) GetPushToUserID() string { - if m != nil { - return m.PushToUserID - } - return "" -} - -type MsgDataToMongoByMQ struct { - LastSeq uint64 `protobuf:"varint,1,opt,name=lastSeq" json:"lastSeq,omitempty"` - AggregationID string `protobuf:"bytes,2,opt,name=aggregationID" json:"aggregationID,omitempty"` - MessageList []*MsgDataToMQ `protobuf:"bytes,3,rep,name=messageList" json:"messageList,omitempty"` - TriggerID string `protobuf:"bytes,4,opt,name=triggerID" json:"triggerID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *MsgDataToMongoByMQ) Reset() { *m = MsgDataToMongoByMQ{} } -func (m *MsgDataToMongoByMQ) String() string { return proto.CompactTextString(m) } -func (*MsgDataToMongoByMQ) ProtoMessage() {} -func (*MsgDataToMongoByMQ) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{3} -} -func (m *MsgDataToMongoByMQ) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MsgDataToMongoByMQ.Unmarshal(m, b) -} -func (m *MsgDataToMongoByMQ) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MsgDataToMongoByMQ.Marshal(b, m, deterministic) -} -func (dst *MsgDataToMongoByMQ) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgDataToMongoByMQ.Merge(dst, src) -} -func (m *MsgDataToMongoByMQ) XXX_Size() int { - return xxx_messageInfo_MsgDataToMongoByMQ.Size(m) -} -func (m *MsgDataToMongoByMQ) XXX_DiscardUnknown() { - xxx_messageInfo_MsgDataToMongoByMQ.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgDataToMongoByMQ proto.InternalMessageInfo - -func (m *MsgDataToMongoByMQ) GetLastSeq() uint64 { - if m != nil { - return m.LastSeq - } - return 0 -} - -func (m *MsgDataToMongoByMQ) GetAggregationID() string { - if m != nil { - return m.AggregationID - } - return "" -} - -func (m *MsgDataToMongoByMQ) GetMessageList() []*MsgDataToMQ { - if m != nil { - return m.MessageList - } - return nil -} - -func (m *MsgDataToMongoByMQ) GetTriggerID() string { - if m != nil { - return m.TriggerID - } - return "" -} - -// message PullMessageReq { -// string UserID = 1; -// int64 SeqBegin = 2; -// int64 SeqEnd = 3; -// string OperationID = 4; -// } -// -// message PullMessageResp { -// int32 ErrCode = 1; -// string ErrMsg = 2; -// int64 MaxSeq = 3; -// int64 MinSeq = 4; -// repeated GatherFormat SingleUserMsg = 5; -// repeated GatherFormat GroupUserMsg = 6; -// } -// -// message PullMessageBySeqListReq{ -// string UserID = 1; -// string OperationID = 2; -// repeated int64 seqList =3; -// } -type GetMaxAndMinSeqReq struct { - UserID string `protobuf:"bytes,1,opt,name=UserID" json:"UserID,omitempty"` - OperationID string `protobuf:"bytes,2,opt,name=OperationID" json:"OperationID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GetMaxAndMinSeqReq) Reset() { *m = GetMaxAndMinSeqReq{} } -func (m *GetMaxAndMinSeqReq) String() string { return proto.CompactTextString(m) } -func (*GetMaxAndMinSeqReq) ProtoMessage() {} -func (*GetMaxAndMinSeqReq) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{4} -} -func (m *GetMaxAndMinSeqReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetMaxAndMinSeqReq.Unmarshal(m, b) -} -func (m *GetMaxAndMinSeqReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetMaxAndMinSeqReq.Marshal(b, m, deterministic) -} -func (dst *GetMaxAndMinSeqReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetMaxAndMinSeqReq.Merge(dst, src) -} -func (m *GetMaxAndMinSeqReq) XXX_Size() int { - return xxx_messageInfo_GetMaxAndMinSeqReq.Size(m) -} -func (m *GetMaxAndMinSeqReq) XXX_DiscardUnknown() { - xxx_messageInfo_GetMaxAndMinSeqReq.DiscardUnknown(m) -} - -var xxx_messageInfo_GetMaxAndMinSeqReq proto.InternalMessageInfo - -func (m *GetMaxAndMinSeqReq) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *GetMaxAndMinSeqReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -type GetMaxAndMinSeqResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=ErrCode" json:"ErrCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=ErrMsg" json:"ErrMsg,omitempty"` - MaxSeq uint32 `protobuf:"varint,3,opt,name=MaxSeq" json:"MaxSeq,omitempty"` - MinSeq uint32 `protobuf:"varint,4,opt,name=MinSeq" json:"MinSeq,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GetMaxAndMinSeqResp) Reset() { *m = GetMaxAndMinSeqResp{} } -func (m *GetMaxAndMinSeqResp) String() string { return proto.CompactTextString(m) } -func (*GetMaxAndMinSeqResp) ProtoMessage() {} -func (*GetMaxAndMinSeqResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{5} -} -func (m *GetMaxAndMinSeqResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetMaxAndMinSeqResp.Unmarshal(m, b) -} -func (m *GetMaxAndMinSeqResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetMaxAndMinSeqResp.Marshal(b, m, deterministic) -} -func (dst *GetMaxAndMinSeqResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetMaxAndMinSeqResp.Merge(dst, src) -} -func (m *GetMaxAndMinSeqResp) XXX_Size() int { - return xxx_messageInfo_GetMaxAndMinSeqResp.Size(m) -} -func (m *GetMaxAndMinSeqResp) XXX_DiscardUnknown() { - xxx_messageInfo_GetMaxAndMinSeqResp.DiscardUnknown(m) -} - -var xxx_messageInfo_GetMaxAndMinSeqResp proto.InternalMessageInfo - -func (m *GetMaxAndMinSeqResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *GetMaxAndMinSeqResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -func (m *GetMaxAndMinSeqResp) GetMaxSeq() uint32 { - if m != nil { - return m.MaxSeq - } - return 0 -} - -func (m *GetMaxAndMinSeqResp) GetMinSeq() uint32 { - if m != nil { - return m.MinSeq - } - return 0 -} - -type SendMsgReq struct { - Token string `protobuf:"bytes,1,opt,name=token" json:"token,omitempty"` - OperationID string `protobuf:"bytes,2,opt,name=operationID" json:"operationID,omitempty"` - MsgData *sdk_ws.MsgData `protobuf:"bytes,3,opt,name=msgData" json:"msgData,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SendMsgReq) Reset() { *m = SendMsgReq{} } -func (m *SendMsgReq) String() string { return proto.CompactTextString(m) } -func (*SendMsgReq) ProtoMessage() {} -func (*SendMsgReq) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{6} -} -func (m *SendMsgReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SendMsgReq.Unmarshal(m, b) -} -func (m *SendMsgReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SendMsgReq.Marshal(b, m, deterministic) -} -func (dst *SendMsgReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SendMsgReq.Merge(dst, src) -} -func (m *SendMsgReq) XXX_Size() int { - return xxx_messageInfo_SendMsgReq.Size(m) -} -func (m *SendMsgReq) XXX_DiscardUnknown() { - xxx_messageInfo_SendMsgReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SendMsgReq proto.InternalMessageInfo - -func (m *SendMsgReq) GetToken() string { - if m != nil { - return m.Token - } - return "" -} - -func (m *SendMsgReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -func (m *SendMsgReq) GetMsgData() *sdk_ws.MsgData { - if m != nil { - return m.MsgData - } - return nil -} - -type SendMsgResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - ServerMsgID string `protobuf:"bytes,4,opt,name=serverMsgID" json:"serverMsgID,omitempty"` - ClientMsgID string `protobuf:"bytes,5,opt,name=clientMsgID" json:"clientMsgID,omitempty"` - SendTime int64 `protobuf:"varint,6,opt,name=sendTime" json:"sendTime,omitempty"` - Ex string `protobuf:"bytes,7,opt,name=ex" json:"ex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SendMsgResp) Reset() { *m = SendMsgResp{} } -func (m *SendMsgResp) String() string { return proto.CompactTextString(m) } -func (*SendMsgResp) ProtoMessage() {} -func (*SendMsgResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{7} -} -func (m *SendMsgResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SendMsgResp.Unmarshal(m, b) -} -func (m *SendMsgResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SendMsgResp.Marshal(b, m, deterministic) -} -func (dst *SendMsgResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_SendMsgResp.Merge(dst, src) -} -func (m *SendMsgResp) XXX_Size() int { - return xxx_messageInfo_SendMsgResp.Size(m) -} -func (m *SendMsgResp) XXX_DiscardUnknown() { - xxx_messageInfo_SendMsgResp.DiscardUnknown(m) -} - -var xxx_messageInfo_SendMsgResp proto.InternalMessageInfo - -func (m *SendMsgResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *SendMsgResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -func (m *SendMsgResp) GetServerMsgID() string { - if m != nil { - return m.ServerMsgID - } - return "" -} - -func (m *SendMsgResp) GetClientMsgID() string { - if m != nil { - return m.ClientMsgID - } - return "" -} - -func (m *SendMsgResp) GetSendTime() int64 { - if m != nil { - return m.SendTime - } - return 0 -} - -func (m *SendMsgResp) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -type ClearMsgReq struct { - UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"` - OpUserID string `protobuf:"bytes,2,opt,name=opUserID" json:"opUserID,omitempty"` - OperationID string `protobuf:"bytes,3,opt,name=operationID" json:"operationID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *ClearMsgReq) Reset() { *m = ClearMsgReq{} } -func (m *ClearMsgReq) String() string { return proto.CompactTextString(m) } -func (*ClearMsgReq) ProtoMessage() {} -func (*ClearMsgReq) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{8} -} -func (m *ClearMsgReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ClearMsgReq.Unmarshal(m, b) -} -func (m *ClearMsgReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ClearMsgReq.Marshal(b, m, deterministic) -} -func (dst *ClearMsgReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_ClearMsgReq.Merge(dst, src) -} -func (m *ClearMsgReq) XXX_Size() int { - return xxx_messageInfo_ClearMsgReq.Size(m) -} -func (m *ClearMsgReq) XXX_DiscardUnknown() { - xxx_messageInfo_ClearMsgReq.DiscardUnknown(m) -} - -var xxx_messageInfo_ClearMsgReq proto.InternalMessageInfo - -func (m *ClearMsgReq) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *ClearMsgReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *ClearMsgReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -type ClearMsgResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *ClearMsgResp) Reset() { *m = ClearMsgResp{} } -func (m *ClearMsgResp) String() string { return proto.CompactTextString(m) } -func (*ClearMsgResp) ProtoMessage() {} -func (*ClearMsgResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{9} -} -func (m *ClearMsgResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ClearMsgResp.Unmarshal(m, b) -} -func (m *ClearMsgResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ClearMsgResp.Marshal(b, m, deterministic) -} -func (dst *ClearMsgResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_ClearMsgResp.Merge(dst, src) -} -func (m *ClearMsgResp) XXX_Size() int { - return xxx_messageInfo_ClearMsgResp.Size(m) -} -func (m *ClearMsgResp) XXX_DiscardUnknown() { - xxx_messageInfo_ClearMsgResp.DiscardUnknown(m) -} - -var xxx_messageInfo_ClearMsgResp proto.InternalMessageInfo - -func (m *ClearMsgResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *ClearMsgResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -type SetMsgMinSeqReq struct { - UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"` - GroupID string `protobuf:"bytes,2,opt,name=groupID" json:"groupID,omitempty"` - MinSeq uint32 `protobuf:"varint,3,opt,name=minSeq" json:"minSeq,omitempty"` - OperationID string `protobuf:"bytes,4,opt,name=operationID" json:"operationID,omitempty"` - OpUserID string `protobuf:"bytes,5,opt,name=opUserID" json:"opUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SetMsgMinSeqReq) Reset() { *m = SetMsgMinSeqReq{} } -func (m *SetMsgMinSeqReq) String() string { return proto.CompactTextString(m) } -func (*SetMsgMinSeqReq) ProtoMessage() {} -func (*SetMsgMinSeqReq) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{10} -} -func (m *SetMsgMinSeqReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SetMsgMinSeqReq.Unmarshal(m, b) -} -func (m *SetMsgMinSeqReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SetMsgMinSeqReq.Marshal(b, m, deterministic) -} -func (dst *SetMsgMinSeqReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetMsgMinSeqReq.Merge(dst, src) -} -func (m *SetMsgMinSeqReq) XXX_Size() int { - return xxx_messageInfo_SetMsgMinSeqReq.Size(m) -} -func (m *SetMsgMinSeqReq) XXX_DiscardUnknown() { - xxx_messageInfo_SetMsgMinSeqReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SetMsgMinSeqReq proto.InternalMessageInfo - -func (m *SetMsgMinSeqReq) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *SetMsgMinSeqReq) GetGroupID() string { - if m != nil { - return m.GroupID - } - return "" -} - -func (m *SetMsgMinSeqReq) GetMinSeq() uint32 { - if m != nil { - return m.MinSeq - } - return 0 -} - -func (m *SetMsgMinSeqReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -func (m *SetMsgMinSeqReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -type SetMsgMinSeqResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SetMsgMinSeqResp) Reset() { *m = SetMsgMinSeqResp{} } -func (m *SetMsgMinSeqResp) String() string { return proto.CompactTextString(m) } -func (*SetMsgMinSeqResp) ProtoMessage() {} -func (*SetMsgMinSeqResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{11} -} -func (m *SetMsgMinSeqResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SetMsgMinSeqResp.Unmarshal(m, b) -} -func (m *SetMsgMinSeqResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SetMsgMinSeqResp.Marshal(b, m, deterministic) -} -func (dst *SetMsgMinSeqResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetMsgMinSeqResp.Merge(dst, src) -} -func (m *SetMsgMinSeqResp) XXX_Size() int { - return xxx_messageInfo_SetMsgMinSeqResp.Size(m) -} -func (m *SetMsgMinSeqResp) XXX_DiscardUnknown() { - xxx_messageInfo_SetMsgMinSeqResp.DiscardUnknown(m) -} - -var xxx_messageInfo_SetMsgMinSeqResp proto.InternalMessageInfo - -func (m *SetMsgMinSeqResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *SetMsgMinSeqResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -type SetSendMsgStatusReq struct { - OperationID string `protobuf:"bytes,1,opt,name=operationID" json:"operationID,omitempty"` - Status int32 `protobuf:"varint,2,opt,name=status" json:"status,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SetSendMsgStatusReq) Reset() { *m = SetSendMsgStatusReq{} } -func (m *SetSendMsgStatusReq) String() string { return proto.CompactTextString(m) } -func (*SetSendMsgStatusReq) ProtoMessage() {} -func (*SetSendMsgStatusReq) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{12} -} -func (m *SetSendMsgStatusReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SetSendMsgStatusReq.Unmarshal(m, b) -} -func (m *SetSendMsgStatusReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SetSendMsgStatusReq.Marshal(b, m, deterministic) -} -func (dst *SetSendMsgStatusReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetSendMsgStatusReq.Merge(dst, src) -} -func (m *SetSendMsgStatusReq) XXX_Size() int { - return xxx_messageInfo_SetSendMsgStatusReq.Size(m) -} -func (m *SetSendMsgStatusReq) XXX_DiscardUnknown() { - xxx_messageInfo_SetSendMsgStatusReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SetSendMsgStatusReq proto.InternalMessageInfo - -func (m *SetSendMsgStatusReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -func (m *SetSendMsgStatusReq) GetStatus() int32 { - if m != nil { - return m.Status - } - return 0 -} - -type SetSendMsgStatusResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SetSendMsgStatusResp) Reset() { *m = SetSendMsgStatusResp{} } -func (m *SetSendMsgStatusResp) String() string { return proto.CompactTextString(m) } -func (*SetSendMsgStatusResp) ProtoMessage() {} -func (*SetSendMsgStatusResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{13} -} -func (m *SetSendMsgStatusResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SetSendMsgStatusResp.Unmarshal(m, b) -} -func (m *SetSendMsgStatusResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SetSendMsgStatusResp.Marshal(b, m, deterministic) -} -func (dst *SetSendMsgStatusResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetSendMsgStatusResp.Merge(dst, src) -} -func (m *SetSendMsgStatusResp) XXX_Size() int { - return xxx_messageInfo_SetSendMsgStatusResp.Size(m) -} -func (m *SetSendMsgStatusResp) XXX_DiscardUnknown() { - xxx_messageInfo_SetSendMsgStatusResp.DiscardUnknown(m) -} - -var xxx_messageInfo_SetSendMsgStatusResp proto.InternalMessageInfo - -func (m *SetSendMsgStatusResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *SetSendMsgStatusResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -type GetSendMsgStatusReq struct { - OperationID string `protobuf:"bytes,1,opt,name=operationID" json:"operationID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GetSendMsgStatusReq) Reset() { *m = GetSendMsgStatusReq{} } -func (m *GetSendMsgStatusReq) String() string { return proto.CompactTextString(m) } -func (*GetSendMsgStatusReq) ProtoMessage() {} -func (*GetSendMsgStatusReq) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{14} -} -func (m *GetSendMsgStatusReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetSendMsgStatusReq.Unmarshal(m, b) -} -func (m *GetSendMsgStatusReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetSendMsgStatusReq.Marshal(b, m, deterministic) -} -func (dst *GetSendMsgStatusReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetSendMsgStatusReq.Merge(dst, src) -} -func (m *GetSendMsgStatusReq) XXX_Size() int { - return xxx_messageInfo_GetSendMsgStatusReq.Size(m) -} -func (m *GetSendMsgStatusReq) XXX_DiscardUnknown() { - xxx_messageInfo_GetSendMsgStatusReq.DiscardUnknown(m) -} - -var xxx_messageInfo_GetSendMsgStatusReq proto.InternalMessageInfo - -func (m *GetSendMsgStatusReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -type GetSendMsgStatusResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - Status int32 `protobuf:"varint,3,opt,name=status" json:"status,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GetSendMsgStatusResp) Reset() { *m = GetSendMsgStatusResp{} } -func (m *GetSendMsgStatusResp) String() string { return proto.CompactTextString(m) } -func (*GetSendMsgStatusResp) ProtoMessage() {} -func (*GetSendMsgStatusResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{15} -} -func (m *GetSendMsgStatusResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetSendMsgStatusResp.Unmarshal(m, b) -} -func (m *GetSendMsgStatusResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetSendMsgStatusResp.Marshal(b, m, deterministic) -} -func (dst *GetSendMsgStatusResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetSendMsgStatusResp.Merge(dst, src) -} -func (m *GetSendMsgStatusResp) XXX_Size() int { - return xxx_messageInfo_GetSendMsgStatusResp.Size(m) -} -func (m *GetSendMsgStatusResp) XXX_DiscardUnknown() { - xxx_messageInfo_GetSendMsgStatusResp.DiscardUnknown(m) -} - -var xxx_messageInfo_GetSendMsgStatusResp proto.InternalMessageInfo - -func (m *GetSendMsgStatusResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *GetSendMsgStatusResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -func (m *GetSendMsgStatusResp) GetStatus() int32 { - if m != nil { - return m.Status - } - return 0 -} - -type DelSuperGroupMsgReq struct { - OpUserID string `protobuf:"bytes,1,opt,name=opUserID" json:"opUserID,omitempty"` - UserID string `protobuf:"bytes,2,opt,name=userID" json:"userID,omitempty"` - GroupID string `protobuf:"bytes,3,opt,name=groupID" json:"groupID,omitempty"` - OperationID string `protobuf:"bytes,4,opt,name=operationID" json:"operationID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *DelSuperGroupMsgReq) Reset() { *m = DelSuperGroupMsgReq{} } -func (m *DelSuperGroupMsgReq) String() string { return proto.CompactTextString(m) } -func (*DelSuperGroupMsgReq) ProtoMessage() {} -func (*DelSuperGroupMsgReq) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{16} -} -func (m *DelSuperGroupMsgReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_DelSuperGroupMsgReq.Unmarshal(m, b) -} -func (m *DelSuperGroupMsgReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_DelSuperGroupMsgReq.Marshal(b, m, deterministic) -} -func (dst *DelSuperGroupMsgReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_DelSuperGroupMsgReq.Merge(dst, src) -} -func (m *DelSuperGroupMsgReq) XXX_Size() int { - return xxx_messageInfo_DelSuperGroupMsgReq.Size(m) -} -func (m *DelSuperGroupMsgReq) XXX_DiscardUnknown() { - xxx_messageInfo_DelSuperGroupMsgReq.DiscardUnknown(m) -} - -var xxx_messageInfo_DelSuperGroupMsgReq proto.InternalMessageInfo - -func (m *DelSuperGroupMsgReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *DelSuperGroupMsgReq) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *DelSuperGroupMsgReq) GetGroupID() string { - if m != nil { - return m.GroupID - } - return "" -} - -func (m *DelSuperGroupMsgReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -type DelSuperGroupMsgResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *DelSuperGroupMsgResp) Reset() { *m = DelSuperGroupMsgResp{} } -func (m *DelSuperGroupMsgResp) String() string { return proto.CompactTextString(m) } -func (*DelSuperGroupMsgResp) ProtoMessage() {} -func (*DelSuperGroupMsgResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{17} -} -func (m *DelSuperGroupMsgResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_DelSuperGroupMsgResp.Unmarshal(m, b) -} -func (m *DelSuperGroupMsgResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_DelSuperGroupMsgResp.Marshal(b, m, deterministic) -} -func (dst *DelSuperGroupMsgResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_DelSuperGroupMsgResp.Merge(dst, src) -} -func (m *DelSuperGroupMsgResp) XXX_Size() int { - return xxx_messageInfo_DelSuperGroupMsgResp.Size(m) -} -func (m *DelSuperGroupMsgResp) XXX_DiscardUnknown() { - xxx_messageInfo_DelSuperGroupMsgResp.DiscardUnknown(m) -} - -var xxx_messageInfo_DelSuperGroupMsgResp proto.InternalMessageInfo - -func (m *DelSuperGroupMsgResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *DelSuperGroupMsgResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -type GetSuperGroupMsgReq struct { - OperationID string `protobuf:"bytes,1,opt,name=operationID" json:"operationID,omitempty"` - Seq uint32 `protobuf:"varint,2,opt,name=Seq" json:"Seq,omitempty"` - GroupID string `protobuf:"bytes,3,opt,name=groupID" json:"groupID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GetSuperGroupMsgReq) Reset() { *m = GetSuperGroupMsgReq{} } -func (m *GetSuperGroupMsgReq) String() string { return proto.CompactTextString(m) } -func (*GetSuperGroupMsgReq) ProtoMessage() {} -func (*GetSuperGroupMsgReq) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{18} -} -func (m *GetSuperGroupMsgReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetSuperGroupMsgReq.Unmarshal(m, b) -} -func (m *GetSuperGroupMsgReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetSuperGroupMsgReq.Marshal(b, m, deterministic) -} -func (dst *GetSuperGroupMsgReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetSuperGroupMsgReq.Merge(dst, src) -} -func (m *GetSuperGroupMsgReq) XXX_Size() int { - return xxx_messageInfo_GetSuperGroupMsgReq.Size(m) -} -func (m *GetSuperGroupMsgReq) XXX_DiscardUnknown() { - xxx_messageInfo_GetSuperGroupMsgReq.DiscardUnknown(m) -} - -var xxx_messageInfo_GetSuperGroupMsgReq proto.InternalMessageInfo - -func (m *GetSuperGroupMsgReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -func (m *GetSuperGroupMsgReq) GetSeq() uint32 { - if m != nil { - return m.Seq - } - return 0 -} - -func (m *GetSuperGroupMsgReq) GetGroupID() string { - if m != nil { - return m.GroupID - } - return "" -} - -type GetSuperGroupMsgResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - MsgData *sdk_ws.MsgData `protobuf:"bytes,3,opt,name=msgData" json:"msgData,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GetSuperGroupMsgResp) Reset() { *m = GetSuperGroupMsgResp{} } -func (m *GetSuperGroupMsgResp) String() string { return proto.CompactTextString(m) } -func (*GetSuperGroupMsgResp) ProtoMessage() {} -func (*GetSuperGroupMsgResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{19} -} -func (m *GetSuperGroupMsgResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetSuperGroupMsgResp.Unmarshal(m, b) -} -func (m *GetSuperGroupMsgResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetSuperGroupMsgResp.Marshal(b, m, deterministic) -} -func (dst *GetSuperGroupMsgResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetSuperGroupMsgResp.Merge(dst, src) -} -func (m *GetSuperGroupMsgResp) XXX_Size() int { - return xxx_messageInfo_GetSuperGroupMsgResp.Size(m) -} -func (m *GetSuperGroupMsgResp) XXX_DiscardUnknown() { - xxx_messageInfo_GetSuperGroupMsgResp.DiscardUnknown(m) -} - -var xxx_messageInfo_GetSuperGroupMsgResp proto.InternalMessageInfo - -func (m *GetSuperGroupMsgResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *GetSuperGroupMsgResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -func (m *GetSuperGroupMsgResp) GetMsgData() *sdk_ws.MsgData { - if m != nil { - return m.MsgData - } - return nil -} - -type GetWriteDiffMsgReq struct { - OperationID string `protobuf:"bytes,1,opt,name=operationID" json:"operationID,omitempty"` - Seq uint32 `protobuf:"varint,2,opt,name=Seq" json:"Seq,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GetWriteDiffMsgReq) Reset() { *m = GetWriteDiffMsgReq{} } -func (m *GetWriteDiffMsgReq) String() string { return proto.CompactTextString(m) } -func (*GetWriteDiffMsgReq) ProtoMessage() {} -func (*GetWriteDiffMsgReq) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{20} -} -func (m *GetWriteDiffMsgReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetWriteDiffMsgReq.Unmarshal(m, b) -} -func (m *GetWriteDiffMsgReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetWriteDiffMsgReq.Marshal(b, m, deterministic) -} -func (dst *GetWriteDiffMsgReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetWriteDiffMsgReq.Merge(dst, src) -} -func (m *GetWriteDiffMsgReq) XXX_Size() int { - return xxx_messageInfo_GetWriteDiffMsgReq.Size(m) -} -func (m *GetWriteDiffMsgReq) XXX_DiscardUnknown() { - xxx_messageInfo_GetWriteDiffMsgReq.DiscardUnknown(m) -} - -var xxx_messageInfo_GetWriteDiffMsgReq proto.InternalMessageInfo - -func (m *GetWriteDiffMsgReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -func (m *GetWriteDiffMsgReq) GetSeq() uint32 { - if m != nil { - return m.Seq - } - return 0 -} - -type GetWriteDiffMsgResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - MsgData *sdk_ws.MsgData `protobuf:"bytes,3,opt,name=msgData" json:"msgData,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GetWriteDiffMsgResp) Reset() { *m = GetWriteDiffMsgResp{} } -func (m *GetWriteDiffMsgResp) String() string { return proto.CompactTextString(m) } -func (*GetWriteDiffMsgResp) ProtoMessage() {} -func (*GetWriteDiffMsgResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{21} -} -func (m *GetWriteDiffMsgResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetWriteDiffMsgResp.Unmarshal(m, b) -} -func (m *GetWriteDiffMsgResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetWriteDiffMsgResp.Marshal(b, m, deterministic) -} -func (dst *GetWriteDiffMsgResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetWriteDiffMsgResp.Merge(dst, src) -} -func (m *GetWriteDiffMsgResp) XXX_Size() int { - return xxx_messageInfo_GetWriteDiffMsgResp.Size(m) -} -func (m *GetWriteDiffMsgResp) XXX_DiscardUnknown() { - xxx_messageInfo_GetWriteDiffMsgResp.DiscardUnknown(m) -} - -var xxx_messageInfo_GetWriteDiffMsgResp proto.InternalMessageInfo - -func (m *GetWriteDiffMsgResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *GetWriteDiffMsgResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -func (m *GetWriteDiffMsgResp) GetMsgData() *sdk_ws.MsgData { - if m != nil { - return m.MsgData - } - return nil -} - -type ModifyMessageReactionExtensionsReq struct { - OperationID string `protobuf:"bytes,1,opt,name=operationID" json:"operationID,omitempty"` - SourceID string `protobuf:"bytes,2,opt,name=sourceID" json:"sourceID,omitempty"` - OpUserID string `protobuf:"bytes,3,opt,name=opUserID" json:"opUserID,omitempty"` - SessionType int32 `protobuf:"varint,4,opt,name=sessionType" json:"sessionType,omitempty"` - ReactionExtensionList map[string]*sdk_ws.KeyValue `protobuf:"bytes,5,rep,name=reactionExtensionList" json:"reactionExtensionList,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - ClientMsgID string `protobuf:"bytes,6,opt,name=clientMsgID" json:"clientMsgID,omitempty"` - Ex *wrapperspb.StringValue `protobuf:"bytes,7,opt,name=ex" json:"ex,omitempty"` - AttachedInfo *wrapperspb.StringValue `protobuf:"bytes,8,opt,name=attachedInfo" json:"attachedInfo,omitempty"` - IsReact bool `protobuf:"varint,9,opt,name=isReact" json:"isReact,omitempty"` - IsExternalExtensions bool `protobuf:"varint,10,opt,name=isExternalExtensions" json:"isExternalExtensions,omitempty"` - MsgFirstModifyTime int64 `protobuf:"varint,11,opt,name=msgFirstModifyTime" json:"msgFirstModifyTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *ModifyMessageReactionExtensionsReq) Reset() { *m = ModifyMessageReactionExtensionsReq{} } -func (m *ModifyMessageReactionExtensionsReq) String() string { return proto.CompactTextString(m) } -func (*ModifyMessageReactionExtensionsReq) ProtoMessage() {} -func (*ModifyMessageReactionExtensionsReq) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{22} -} -func (m *ModifyMessageReactionExtensionsReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ModifyMessageReactionExtensionsReq.Unmarshal(m, b) -} -func (m *ModifyMessageReactionExtensionsReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ModifyMessageReactionExtensionsReq.Marshal(b, m, deterministic) -} -func (dst *ModifyMessageReactionExtensionsReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_ModifyMessageReactionExtensionsReq.Merge(dst, src) -} -func (m *ModifyMessageReactionExtensionsReq) XXX_Size() int { - return xxx_messageInfo_ModifyMessageReactionExtensionsReq.Size(m) -} -func (m *ModifyMessageReactionExtensionsReq) XXX_DiscardUnknown() { - xxx_messageInfo_ModifyMessageReactionExtensionsReq.DiscardUnknown(m) -} - -var xxx_messageInfo_ModifyMessageReactionExtensionsReq proto.InternalMessageInfo - -func (m *ModifyMessageReactionExtensionsReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -func (m *ModifyMessageReactionExtensionsReq) GetSourceID() string { - if m != nil { - return m.SourceID - } - return "" -} - -func (m *ModifyMessageReactionExtensionsReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *ModifyMessageReactionExtensionsReq) GetSessionType() int32 { - if m != nil { - return m.SessionType - } - return 0 -} - -func (m *ModifyMessageReactionExtensionsReq) GetReactionExtensionList() map[string]*sdk_ws.KeyValue { - if m != nil { - return m.ReactionExtensionList - } - return nil -} - -func (m *ModifyMessageReactionExtensionsReq) GetClientMsgID() string { - if m != nil { - return m.ClientMsgID - } - return "" -} - -func (m *ModifyMessageReactionExtensionsReq) GetEx() *wrapperspb.StringValue { - if m != nil { - return m.Ex - } - return nil -} - -func (m *ModifyMessageReactionExtensionsReq) GetAttachedInfo() *wrapperspb.StringValue { - if m != nil { - return m.AttachedInfo - } - return nil -} - -func (m *ModifyMessageReactionExtensionsReq) GetIsReact() bool { - if m != nil { - return m.IsReact - } - return false -} - -func (m *ModifyMessageReactionExtensionsReq) GetIsExternalExtensions() bool { - if m != nil { - return m.IsExternalExtensions - } - return false -} - -func (m *ModifyMessageReactionExtensionsReq) GetMsgFirstModifyTime() int64 { - if m != nil { - return m.MsgFirstModifyTime - } - return 0 -} - -type SetMessageReactionExtensionsReq struct { - OperationID string `protobuf:"bytes,1,opt,name=operationID" json:"operationID,omitempty"` - SourceID string `protobuf:"bytes,2,opt,name=sourceID" json:"sourceID,omitempty"` - OpUserID string `protobuf:"bytes,3,opt,name=opUserID" json:"opUserID,omitempty"` - OpUserIDPlatformID int32 `protobuf:"varint,4,opt,name=opUserIDPlatformID" json:"opUserIDPlatformID,omitempty"` - SessionType int32 `protobuf:"varint,5,opt,name=sessionType" json:"sessionType,omitempty"` - ReactionExtensionList map[string]*sdk_ws.KeyValue `protobuf:"bytes,6,rep,name=reactionExtensionList" json:"reactionExtensionList,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - ClientMsgID string `protobuf:"bytes,7,opt,name=clientMsgID" json:"clientMsgID,omitempty"` - Ex *wrapperspb.StringValue `protobuf:"bytes,8,opt,name=ex" json:"ex,omitempty"` - AttachedInfo *wrapperspb.StringValue `protobuf:"bytes,9,opt,name=attachedInfo" json:"attachedInfo,omitempty"` - IsReact bool `protobuf:"varint,10,opt,name=isReact" json:"isReact,omitempty"` - IsExternalExtensions bool `protobuf:"varint,11,opt,name=isExternalExtensions" json:"isExternalExtensions,omitempty"` - MsgFirstModifyTime int64 `protobuf:"varint,12,opt,name=msgFirstModifyTime" json:"msgFirstModifyTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SetMessageReactionExtensionsReq) Reset() { *m = SetMessageReactionExtensionsReq{} } -func (m *SetMessageReactionExtensionsReq) String() string { return proto.CompactTextString(m) } -func (*SetMessageReactionExtensionsReq) ProtoMessage() {} -func (*SetMessageReactionExtensionsReq) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{23} -} -func (m *SetMessageReactionExtensionsReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SetMessageReactionExtensionsReq.Unmarshal(m, b) -} -func (m *SetMessageReactionExtensionsReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SetMessageReactionExtensionsReq.Marshal(b, m, deterministic) -} -func (dst *SetMessageReactionExtensionsReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetMessageReactionExtensionsReq.Merge(dst, src) -} -func (m *SetMessageReactionExtensionsReq) XXX_Size() int { - return xxx_messageInfo_SetMessageReactionExtensionsReq.Size(m) -} -func (m *SetMessageReactionExtensionsReq) XXX_DiscardUnknown() { - xxx_messageInfo_SetMessageReactionExtensionsReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SetMessageReactionExtensionsReq proto.InternalMessageInfo - -func (m *SetMessageReactionExtensionsReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -func (m *SetMessageReactionExtensionsReq) GetSourceID() string { - if m != nil { - return m.SourceID - } - return "" -} - -func (m *SetMessageReactionExtensionsReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *SetMessageReactionExtensionsReq) GetOpUserIDPlatformID() int32 { - if m != nil { - return m.OpUserIDPlatformID - } - return 0 -} - -func (m *SetMessageReactionExtensionsReq) GetSessionType() int32 { - if m != nil { - return m.SessionType - } - return 0 -} - -func (m *SetMessageReactionExtensionsReq) GetReactionExtensionList() map[string]*sdk_ws.KeyValue { - if m != nil { - return m.ReactionExtensionList - } - return nil -} - -func (m *SetMessageReactionExtensionsReq) GetClientMsgID() string { - if m != nil { - return m.ClientMsgID - } - return "" -} - -func (m *SetMessageReactionExtensionsReq) GetEx() *wrapperspb.StringValue { - if m != nil { - return m.Ex - } - return nil -} - -func (m *SetMessageReactionExtensionsReq) GetAttachedInfo() *wrapperspb.StringValue { - if m != nil { - return m.AttachedInfo - } - return nil -} - -func (m *SetMessageReactionExtensionsReq) GetIsReact() bool { - if m != nil { - return m.IsReact - } - return false -} - -func (m *SetMessageReactionExtensionsReq) GetIsExternalExtensions() bool { - if m != nil { - return m.IsExternalExtensions - } - return false -} - -func (m *SetMessageReactionExtensionsReq) GetMsgFirstModifyTime() int64 { - if m != nil { - return m.MsgFirstModifyTime - } - return 0 -} - -type SetMessageReactionExtensionsResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - ClientMsgID string `protobuf:"bytes,3,opt,name=clientMsgID" json:"clientMsgID,omitempty"` - MsgFirstModifyTime int64 `protobuf:"varint,4,opt,name=msgFirstModifyTime" json:"msgFirstModifyTime,omitempty"` - IsReact bool `protobuf:"varint,5,opt,name=isReact" json:"isReact,omitempty"` - Result []*KeyValueResp `protobuf:"bytes,6,rep,name=result" json:"result,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SetMessageReactionExtensionsResp) Reset() { *m = SetMessageReactionExtensionsResp{} } -func (m *SetMessageReactionExtensionsResp) String() string { return proto.CompactTextString(m) } -func (*SetMessageReactionExtensionsResp) ProtoMessage() {} -func (*SetMessageReactionExtensionsResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{24} -} -func (m *SetMessageReactionExtensionsResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SetMessageReactionExtensionsResp.Unmarshal(m, b) -} -func (m *SetMessageReactionExtensionsResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SetMessageReactionExtensionsResp.Marshal(b, m, deterministic) -} -func (dst *SetMessageReactionExtensionsResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetMessageReactionExtensionsResp.Merge(dst, src) -} -func (m *SetMessageReactionExtensionsResp) XXX_Size() int { - return xxx_messageInfo_SetMessageReactionExtensionsResp.Size(m) -} -func (m *SetMessageReactionExtensionsResp) XXX_DiscardUnknown() { - xxx_messageInfo_SetMessageReactionExtensionsResp.DiscardUnknown(m) -} - -var xxx_messageInfo_SetMessageReactionExtensionsResp proto.InternalMessageInfo - -func (m *SetMessageReactionExtensionsResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *SetMessageReactionExtensionsResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -func (m *SetMessageReactionExtensionsResp) GetClientMsgID() string { - if m != nil { - return m.ClientMsgID - } - return "" -} - -func (m *SetMessageReactionExtensionsResp) GetMsgFirstModifyTime() int64 { - if m != nil { - return m.MsgFirstModifyTime - } - return 0 -} - -func (m *SetMessageReactionExtensionsResp) GetIsReact() bool { - if m != nil { - return m.IsReact - } - return false -} - -func (m *SetMessageReactionExtensionsResp) GetResult() []*KeyValueResp { - if m != nil { - return m.Result - } - return nil -} - -type AddMessageReactionExtensionsReq struct { - OperationID string `protobuf:"bytes,1,opt,name=operationID" json:"operationID,omitempty"` - SourceID string `protobuf:"bytes,2,opt,name=sourceID" json:"sourceID,omitempty"` - OpUserID string `protobuf:"bytes,3,opt,name=opUserID" json:"opUserID,omitempty"` - OpUserIDPlatformID int32 `protobuf:"varint,4,opt,name=opUserIDPlatformID" json:"opUserIDPlatformID,omitempty"` - SessionType int32 `protobuf:"varint,5,opt,name=sessionType" json:"sessionType,omitempty"` - ReactionExtensionList map[string]*sdk_ws.KeyValue `protobuf:"bytes,6,rep,name=reactionExtensionList" json:"reactionExtensionList,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - ClientMsgID string `protobuf:"bytes,7,opt,name=clientMsgID" json:"clientMsgID,omitempty"` - Ex *wrapperspb.StringValue `protobuf:"bytes,8,opt,name=ex" json:"ex,omitempty"` - AttachedInfo *wrapperspb.StringValue `protobuf:"bytes,9,opt,name=attachedInfo" json:"attachedInfo,omitempty"` - IsReact bool `protobuf:"varint,10,opt,name=isReact" json:"isReact,omitempty"` - IsExternalExtensions bool `protobuf:"varint,11,opt,name=isExternalExtensions" json:"isExternalExtensions,omitempty"` - MsgFirstModifyTime int64 `protobuf:"varint,12,opt,name=msgFirstModifyTime" json:"msgFirstModifyTime,omitempty"` - Seq uint32 `protobuf:"varint,13,opt,name=seq" json:"seq,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *AddMessageReactionExtensionsReq) Reset() { *m = AddMessageReactionExtensionsReq{} } -func (m *AddMessageReactionExtensionsReq) String() string { return proto.CompactTextString(m) } -func (*AddMessageReactionExtensionsReq) ProtoMessage() {} -func (*AddMessageReactionExtensionsReq) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{25} -} -func (m *AddMessageReactionExtensionsReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_AddMessageReactionExtensionsReq.Unmarshal(m, b) -} -func (m *AddMessageReactionExtensionsReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_AddMessageReactionExtensionsReq.Marshal(b, m, deterministic) -} -func (dst *AddMessageReactionExtensionsReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_AddMessageReactionExtensionsReq.Merge(dst, src) -} -func (m *AddMessageReactionExtensionsReq) XXX_Size() int { - return xxx_messageInfo_AddMessageReactionExtensionsReq.Size(m) -} -func (m *AddMessageReactionExtensionsReq) XXX_DiscardUnknown() { - xxx_messageInfo_AddMessageReactionExtensionsReq.DiscardUnknown(m) -} - -var xxx_messageInfo_AddMessageReactionExtensionsReq proto.InternalMessageInfo - -func (m *AddMessageReactionExtensionsReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -func (m *AddMessageReactionExtensionsReq) GetSourceID() string { - if m != nil { - return m.SourceID - } - return "" -} - -func (m *AddMessageReactionExtensionsReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *AddMessageReactionExtensionsReq) GetOpUserIDPlatformID() int32 { - if m != nil { - return m.OpUserIDPlatformID - } - return 0 -} - -func (m *AddMessageReactionExtensionsReq) GetSessionType() int32 { - if m != nil { - return m.SessionType - } - return 0 -} - -func (m *AddMessageReactionExtensionsReq) GetReactionExtensionList() map[string]*sdk_ws.KeyValue { - if m != nil { - return m.ReactionExtensionList - } - return nil -} - -func (m *AddMessageReactionExtensionsReq) GetClientMsgID() string { - if m != nil { - return m.ClientMsgID - } - return "" -} - -func (m *AddMessageReactionExtensionsReq) GetEx() *wrapperspb.StringValue { - if m != nil { - return m.Ex - } - return nil -} - -func (m *AddMessageReactionExtensionsReq) GetAttachedInfo() *wrapperspb.StringValue { - if m != nil { - return m.AttachedInfo - } - return nil -} - -func (m *AddMessageReactionExtensionsReq) GetIsReact() bool { - if m != nil { - return m.IsReact - } - return false -} - -func (m *AddMessageReactionExtensionsReq) GetIsExternalExtensions() bool { - if m != nil { - return m.IsExternalExtensions - } - return false -} - -func (m *AddMessageReactionExtensionsReq) GetMsgFirstModifyTime() int64 { - if m != nil { - return m.MsgFirstModifyTime - } - return 0 -} - -func (m *AddMessageReactionExtensionsReq) GetSeq() uint32 { - if m != nil { - return m.Seq - } - return 0 -} - -type AddMessageReactionExtensionsResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - ClientMsgID string `protobuf:"bytes,3,opt,name=clientMsgID" json:"clientMsgID,omitempty"` - MsgFirstModifyTime int64 `protobuf:"varint,4,opt,name=msgFirstModifyTime" json:"msgFirstModifyTime,omitempty"` - IsReact bool `protobuf:"varint,5,opt,name=isReact" json:"isReact,omitempty"` - Result []*KeyValueResp `protobuf:"bytes,6,rep,name=result" json:"result,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *AddMessageReactionExtensionsResp) Reset() { *m = AddMessageReactionExtensionsResp{} } -func (m *AddMessageReactionExtensionsResp) String() string { return proto.CompactTextString(m) } -func (*AddMessageReactionExtensionsResp) ProtoMessage() {} -func (*AddMessageReactionExtensionsResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{26} -} -func (m *AddMessageReactionExtensionsResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_AddMessageReactionExtensionsResp.Unmarshal(m, b) -} -func (m *AddMessageReactionExtensionsResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_AddMessageReactionExtensionsResp.Marshal(b, m, deterministic) -} -func (dst *AddMessageReactionExtensionsResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_AddMessageReactionExtensionsResp.Merge(dst, src) -} -func (m *AddMessageReactionExtensionsResp) XXX_Size() int { - return xxx_messageInfo_AddMessageReactionExtensionsResp.Size(m) -} -func (m *AddMessageReactionExtensionsResp) XXX_DiscardUnknown() { - xxx_messageInfo_AddMessageReactionExtensionsResp.DiscardUnknown(m) -} - -var xxx_messageInfo_AddMessageReactionExtensionsResp proto.InternalMessageInfo - -func (m *AddMessageReactionExtensionsResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *AddMessageReactionExtensionsResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -func (m *AddMessageReactionExtensionsResp) GetClientMsgID() string { - if m != nil { - return m.ClientMsgID - } - return "" -} - -func (m *AddMessageReactionExtensionsResp) GetMsgFirstModifyTime() int64 { - if m != nil { - return m.MsgFirstModifyTime - } - return 0 -} - -func (m *AddMessageReactionExtensionsResp) GetIsReact() bool { - if m != nil { - return m.IsReact - } - return false -} - -func (m *AddMessageReactionExtensionsResp) GetResult() []*KeyValueResp { - if m != nil { - return m.Result - } - return nil -} - -type GetMessageListReactionExtensionsReq struct { - OperationID string `protobuf:"bytes,1,opt,name=operationID" json:"operationID,omitempty"` - OpUserID string `protobuf:"bytes,2,opt,name=opUserID" json:"opUserID,omitempty"` - SourceID string `protobuf:"bytes,3,opt,name=sourceID" json:"sourceID,omitempty"` - SessionType int32 `protobuf:"varint,4,opt,name=sessionType" json:"sessionType,omitempty"` - IsExternalExtensions bool `protobuf:"varint,5,opt,name=isExternalExtensions" json:"isExternalExtensions,omitempty"` - TypeKeyList []string `protobuf:"bytes,6,rep,name=typeKeyList" json:"typeKeyList,omitempty"` - MessageReactionKeyList []*GetMessageListReactionExtensionsReq_MessageReactionKey `protobuf:"bytes,7,rep,name=messageReactionKeyList" json:"messageReactionKeyList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GetMessageListReactionExtensionsReq) Reset() { *m = GetMessageListReactionExtensionsReq{} } -func (m *GetMessageListReactionExtensionsReq) String() string { return proto.CompactTextString(m) } -func (*GetMessageListReactionExtensionsReq) ProtoMessage() {} -func (*GetMessageListReactionExtensionsReq) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{27} -} -func (m *GetMessageListReactionExtensionsReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetMessageListReactionExtensionsReq.Unmarshal(m, b) -} -func (m *GetMessageListReactionExtensionsReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetMessageListReactionExtensionsReq.Marshal(b, m, deterministic) -} -func (dst *GetMessageListReactionExtensionsReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetMessageListReactionExtensionsReq.Merge(dst, src) -} -func (m *GetMessageListReactionExtensionsReq) XXX_Size() int { - return xxx_messageInfo_GetMessageListReactionExtensionsReq.Size(m) -} -func (m *GetMessageListReactionExtensionsReq) XXX_DiscardUnknown() { - xxx_messageInfo_GetMessageListReactionExtensionsReq.DiscardUnknown(m) -} - -var xxx_messageInfo_GetMessageListReactionExtensionsReq proto.InternalMessageInfo - -func (m *GetMessageListReactionExtensionsReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -func (m *GetMessageListReactionExtensionsReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *GetMessageListReactionExtensionsReq) GetSourceID() string { - if m != nil { - return m.SourceID - } - return "" -} - -func (m *GetMessageListReactionExtensionsReq) GetSessionType() int32 { - if m != nil { - return m.SessionType - } - return 0 -} - -func (m *GetMessageListReactionExtensionsReq) GetIsExternalExtensions() bool { - if m != nil { - return m.IsExternalExtensions - } - return false -} - -func (m *GetMessageListReactionExtensionsReq) GetTypeKeyList() []string { - if m != nil { - return m.TypeKeyList - } - return nil -} - -func (m *GetMessageListReactionExtensionsReq) GetMessageReactionKeyList() []*GetMessageListReactionExtensionsReq_MessageReactionKey { - if m != nil { - return m.MessageReactionKeyList - } - return nil -} - -type GetMessageListReactionExtensionsReq_MessageReactionKey struct { - ClientMsgID string `protobuf:"bytes,1,opt,name=clientMsgID" json:"clientMsgID,omitempty"` - MsgFirstModifyTime int64 `protobuf:"varint,2,opt,name=msgFirstModifyTime" json:"msgFirstModifyTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GetMessageListReactionExtensionsReq_MessageReactionKey) Reset() { - *m = GetMessageListReactionExtensionsReq_MessageReactionKey{} -} -func (m *GetMessageListReactionExtensionsReq_MessageReactionKey) String() string { - return proto.CompactTextString(m) -} -func (*GetMessageListReactionExtensionsReq_MessageReactionKey) ProtoMessage() {} -func (*GetMessageListReactionExtensionsReq_MessageReactionKey) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{27, 0} -} -func (m *GetMessageListReactionExtensionsReq_MessageReactionKey) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetMessageListReactionExtensionsReq_MessageReactionKey.Unmarshal(m, b) -} -func (m *GetMessageListReactionExtensionsReq_MessageReactionKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetMessageListReactionExtensionsReq_MessageReactionKey.Marshal(b, m, deterministic) -} -func (dst *GetMessageListReactionExtensionsReq_MessageReactionKey) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetMessageListReactionExtensionsReq_MessageReactionKey.Merge(dst, src) -} -func (m *GetMessageListReactionExtensionsReq_MessageReactionKey) XXX_Size() int { - return xxx_messageInfo_GetMessageListReactionExtensionsReq_MessageReactionKey.Size(m) -} -func (m *GetMessageListReactionExtensionsReq_MessageReactionKey) XXX_DiscardUnknown() { - xxx_messageInfo_GetMessageListReactionExtensionsReq_MessageReactionKey.DiscardUnknown(m) -} - -var xxx_messageInfo_GetMessageListReactionExtensionsReq_MessageReactionKey proto.InternalMessageInfo - -func (m *GetMessageListReactionExtensionsReq_MessageReactionKey) GetClientMsgID() string { - if m != nil { - return m.ClientMsgID - } - return "" -} - -func (m *GetMessageListReactionExtensionsReq_MessageReactionKey) GetMsgFirstModifyTime() int64 { - if m != nil { - return m.MsgFirstModifyTime - } - return 0 -} - -type GetMessageListReactionExtensionsResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - SingleMessageResult []*SingleMessageExtensionResult `protobuf:"bytes,3,rep,name=singleMessageResult" json:"singleMessageResult,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GetMessageListReactionExtensionsResp) Reset() { *m = GetMessageListReactionExtensionsResp{} } -func (m *GetMessageListReactionExtensionsResp) String() string { return proto.CompactTextString(m) } -func (*GetMessageListReactionExtensionsResp) ProtoMessage() {} -func (*GetMessageListReactionExtensionsResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{28} -} -func (m *GetMessageListReactionExtensionsResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetMessageListReactionExtensionsResp.Unmarshal(m, b) -} -func (m *GetMessageListReactionExtensionsResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetMessageListReactionExtensionsResp.Marshal(b, m, deterministic) -} -func (dst *GetMessageListReactionExtensionsResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetMessageListReactionExtensionsResp.Merge(dst, src) -} -func (m *GetMessageListReactionExtensionsResp) XXX_Size() int { - return xxx_messageInfo_GetMessageListReactionExtensionsResp.Size(m) -} -func (m *GetMessageListReactionExtensionsResp) XXX_DiscardUnknown() { - xxx_messageInfo_GetMessageListReactionExtensionsResp.DiscardUnknown(m) -} - -var xxx_messageInfo_GetMessageListReactionExtensionsResp proto.InternalMessageInfo - -func (m *GetMessageListReactionExtensionsResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *GetMessageListReactionExtensionsResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -func (m *GetMessageListReactionExtensionsResp) GetSingleMessageResult() []*SingleMessageExtensionResult { - if m != nil { - return m.SingleMessageResult - } - return nil -} - -type SingleMessageExtensionResult struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - ReactionExtensionList map[string]*sdk_ws.KeyValue `protobuf:"bytes,3,rep,name=reactionExtensionList" json:"reactionExtensionList,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - ClientMsgID string `protobuf:"bytes,4,opt,name=clientMsgID" json:"clientMsgID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SingleMessageExtensionResult) Reset() { *m = SingleMessageExtensionResult{} } -func (m *SingleMessageExtensionResult) String() string { return proto.CompactTextString(m) } -func (*SingleMessageExtensionResult) ProtoMessage() {} -func (*SingleMessageExtensionResult) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{29} -} -func (m *SingleMessageExtensionResult) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SingleMessageExtensionResult.Unmarshal(m, b) -} -func (m *SingleMessageExtensionResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SingleMessageExtensionResult.Marshal(b, m, deterministic) -} -func (dst *SingleMessageExtensionResult) XXX_Merge(src proto.Message) { - xxx_messageInfo_SingleMessageExtensionResult.Merge(dst, src) -} -func (m *SingleMessageExtensionResult) XXX_Size() int { - return xxx_messageInfo_SingleMessageExtensionResult.Size(m) -} -func (m *SingleMessageExtensionResult) XXX_DiscardUnknown() { - xxx_messageInfo_SingleMessageExtensionResult.DiscardUnknown(m) -} - -var xxx_messageInfo_SingleMessageExtensionResult proto.InternalMessageInfo - -func (m *SingleMessageExtensionResult) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *SingleMessageExtensionResult) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -func (m *SingleMessageExtensionResult) GetReactionExtensionList() map[string]*sdk_ws.KeyValue { - if m != nil { - return m.ReactionExtensionList - } - return nil -} - -func (m *SingleMessageExtensionResult) GetClientMsgID() string { - if m != nil { - return m.ClientMsgID - } - return "" -} - -type ModifyMessageReactionExtensionsResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - SuccessList []*ExtendMsgResp `protobuf:"bytes,3,rep,name=successList" json:"successList,omitempty"` - FailedList []*ExtendMsgResp `protobuf:"bytes,4,rep,name=failedList" json:"failedList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *ModifyMessageReactionExtensionsResp) Reset() { *m = ModifyMessageReactionExtensionsResp{} } -func (m *ModifyMessageReactionExtensionsResp) String() string { return proto.CompactTextString(m) } -func (*ModifyMessageReactionExtensionsResp) ProtoMessage() {} -func (*ModifyMessageReactionExtensionsResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{30} -} -func (m *ModifyMessageReactionExtensionsResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ModifyMessageReactionExtensionsResp.Unmarshal(m, b) -} -func (m *ModifyMessageReactionExtensionsResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ModifyMessageReactionExtensionsResp.Marshal(b, m, deterministic) -} -func (dst *ModifyMessageReactionExtensionsResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_ModifyMessageReactionExtensionsResp.Merge(dst, src) -} -func (m *ModifyMessageReactionExtensionsResp) XXX_Size() int { - return xxx_messageInfo_ModifyMessageReactionExtensionsResp.Size(m) -} -func (m *ModifyMessageReactionExtensionsResp) XXX_DiscardUnknown() { - xxx_messageInfo_ModifyMessageReactionExtensionsResp.DiscardUnknown(m) -} - -var xxx_messageInfo_ModifyMessageReactionExtensionsResp proto.InternalMessageInfo - -func (m *ModifyMessageReactionExtensionsResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *ModifyMessageReactionExtensionsResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -func (m *ModifyMessageReactionExtensionsResp) GetSuccessList() []*ExtendMsgResp { - if m != nil { - return m.SuccessList - } - return nil -} - -func (m *ModifyMessageReactionExtensionsResp) GetFailedList() []*ExtendMsgResp { - if m != nil { - return m.FailedList - } - return nil -} - -type DeleteMessageListReactionExtensionsReq struct { - OperationID string `protobuf:"bytes,1,opt,name=operationID" json:"operationID,omitempty"` - OpUserID string `protobuf:"bytes,2,opt,name=opUserID" json:"opUserID,omitempty"` - SourceID string `protobuf:"bytes,3,opt,name=sourceID" json:"sourceID,omitempty"` - OpUserIDPlatformID int32 `protobuf:"varint,4,opt,name=opUserIDPlatformID" json:"opUserIDPlatformID,omitempty"` - SessionType int32 `protobuf:"varint,5,opt,name=sessionType" json:"sessionType,omitempty"` - ClientMsgID string `protobuf:"bytes,6,opt,name=clientMsgID" json:"clientMsgID,omitempty"` - IsExternalExtensions bool `protobuf:"varint,7,opt,name=isExternalExtensions" json:"isExternalExtensions,omitempty"` - MsgFirstModifyTime int64 `protobuf:"varint,8,opt,name=msgFirstModifyTime" json:"msgFirstModifyTime,omitempty"` - ReactionExtensionList []*sdk_ws.KeyValue `protobuf:"bytes,9,rep,name=reactionExtensionList" json:"reactionExtensionList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *DeleteMessageListReactionExtensionsReq) Reset() { - *m = DeleteMessageListReactionExtensionsReq{} -} -func (m *DeleteMessageListReactionExtensionsReq) String() string { return proto.CompactTextString(m) } -func (*DeleteMessageListReactionExtensionsReq) ProtoMessage() {} -func (*DeleteMessageListReactionExtensionsReq) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{31} -} -func (m *DeleteMessageListReactionExtensionsReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_DeleteMessageListReactionExtensionsReq.Unmarshal(m, b) -} -func (m *DeleteMessageListReactionExtensionsReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_DeleteMessageListReactionExtensionsReq.Marshal(b, m, deterministic) -} -func (dst *DeleteMessageListReactionExtensionsReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_DeleteMessageListReactionExtensionsReq.Merge(dst, src) -} -func (m *DeleteMessageListReactionExtensionsReq) XXX_Size() int { - return xxx_messageInfo_DeleteMessageListReactionExtensionsReq.Size(m) -} -func (m *DeleteMessageListReactionExtensionsReq) XXX_DiscardUnknown() { - xxx_messageInfo_DeleteMessageListReactionExtensionsReq.DiscardUnknown(m) -} - -var xxx_messageInfo_DeleteMessageListReactionExtensionsReq proto.InternalMessageInfo - -func (m *DeleteMessageListReactionExtensionsReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -func (m *DeleteMessageListReactionExtensionsReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *DeleteMessageListReactionExtensionsReq) GetSourceID() string { - if m != nil { - return m.SourceID - } - return "" -} - -func (m *DeleteMessageListReactionExtensionsReq) GetOpUserIDPlatformID() int32 { - if m != nil { - return m.OpUserIDPlatformID - } - return 0 -} - -func (m *DeleteMessageListReactionExtensionsReq) GetSessionType() int32 { - if m != nil { - return m.SessionType - } - return 0 -} - -func (m *DeleteMessageListReactionExtensionsReq) GetClientMsgID() string { - if m != nil { - return m.ClientMsgID - } - return "" -} - -func (m *DeleteMessageListReactionExtensionsReq) GetIsExternalExtensions() bool { - if m != nil { - return m.IsExternalExtensions - } - return false -} - -func (m *DeleteMessageListReactionExtensionsReq) GetMsgFirstModifyTime() int64 { - if m != nil { - return m.MsgFirstModifyTime - } - return 0 -} - -func (m *DeleteMessageListReactionExtensionsReq) GetReactionExtensionList() []*sdk_ws.KeyValue { - if m != nil { - return m.ReactionExtensionList - } - return nil -} - -type DeleteMessageListReactionExtensionsResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - Result []*KeyValueResp `protobuf:"bytes,6,rep,name=result" json:"result,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *DeleteMessageListReactionExtensionsResp) Reset() { - *m = DeleteMessageListReactionExtensionsResp{} -} -func (m *DeleteMessageListReactionExtensionsResp) String() string { return proto.CompactTextString(m) } -func (*DeleteMessageListReactionExtensionsResp) ProtoMessage() {} -func (*DeleteMessageListReactionExtensionsResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{32} -} -func (m *DeleteMessageListReactionExtensionsResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_DeleteMessageListReactionExtensionsResp.Unmarshal(m, b) -} -func (m *DeleteMessageListReactionExtensionsResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_DeleteMessageListReactionExtensionsResp.Marshal(b, m, deterministic) -} -func (dst *DeleteMessageListReactionExtensionsResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_DeleteMessageListReactionExtensionsResp.Merge(dst, src) -} -func (m *DeleteMessageListReactionExtensionsResp) XXX_Size() int { - return xxx_messageInfo_DeleteMessageListReactionExtensionsResp.Size(m) -} -func (m *DeleteMessageListReactionExtensionsResp) XXX_DiscardUnknown() { - xxx_messageInfo_DeleteMessageListReactionExtensionsResp.DiscardUnknown(m) -} - -var xxx_messageInfo_DeleteMessageListReactionExtensionsResp proto.InternalMessageInfo - -func (m *DeleteMessageListReactionExtensionsResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *DeleteMessageListReactionExtensionsResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -func (m *DeleteMessageListReactionExtensionsResp) GetResult() []*KeyValueResp { - if m != nil { - return m.Result - } - return nil -} - -type ExtendMsgResp struct { - ExtendMsg *ExtendMsg `protobuf:"bytes,1,opt,name=extendMsg" json:"extendMsg,omitempty"` - ErrCode int32 `protobuf:"varint,2,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,3,opt,name=errMsg" json:"errMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *ExtendMsgResp) Reset() { *m = ExtendMsgResp{} } -func (m *ExtendMsgResp) String() string { return proto.CompactTextString(m) } -func (*ExtendMsgResp) ProtoMessage() {} -func (*ExtendMsgResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{33} -} -func (m *ExtendMsgResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ExtendMsgResp.Unmarshal(m, b) -} -func (m *ExtendMsgResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ExtendMsgResp.Marshal(b, m, deterministic) -} -func (dst *ExtendMsgResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_ExtendMsgResp.Merge(dst, src) -} -func (m *ExtendMsgResp) XXX_Size() int { - return xxx_messageInfo_ExtendMsgResp.Size(m) -} -func (m *ExtendMsgResp) XXX_DiscardUnknown() { - xxx_messageInfo_ExtendMsgResp.DiscardUnknown(m) -} - -var xxx_messageInfo_ExtendMsgResp proto.InternalMessageInfo - -func (m *ExtendMsgResp) GetExtendMsg() *ExtendMsg { - if m != nil { - return m.ExtendMsg - } - return nil -} - -func (m *ExtendMsgResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *ExtendMsgResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -type ExtendMsg struct { - ReactionExtensionList map[string]*KeyValueResp `protobuf:"bytes,1,rep,name=reactionExtensionList" json:"reactionExtensionList,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - ClientMsgID string `protobuf:"bytes,2,opt,name=clientMsgID" json:"clientMsgID,omitempty"` - MsgFirstModifyTime int64 `protobuf:"varint,3,opt,name=msgFirstModifyTime" json:"msgFirstModifyTime,omitempty"` - AttachedInfo string `protobuf:"bytes,4,opt,name=attachedInfo" json:"attachedInfo,omitempty"` - Ex string `protobuf:"bytes,5,opt,name=ex" json:"ex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *ExtendMsg) Reset() { *m = ExtendMsg{} } -func (m *ExtendMsg) String() string { return proto.CompactTextString(m) } -func (*ExtendMsg) ProtoMessage() {} -func (*ExtendMsg) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{34} -} -func (m *ExtendMsg) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ExtendMsg.Unmarshal(m, b) -} -func (m *ExtendMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ExtendMsg.Marshal(b, m, deterministic) -} -func (dst *ExtendMsg) XXX_Merge(src proto.Message) { - xxx_messageInfo_ExtendMsg.Merge(dst, src) -} -func (m *ExtendMsg) XXX_Size() int { - return xxx_messageInfo_ExtendMsg.Size(m) -} -func (m *ExtendMsg) XXX_DiscardUnknown() { - xxx_messageInfo_ExtendMsg.DiscardUnknown(m) -} - -var xxx_messageInfo_ExtendMsg proto.InternalMessageInfo - -func (m *ExtendMsg) GetReactionExtensionList() map[string]*KeyValueResp { - if m != nil { - return m.ReactionExtensionList - } - return nil -} - -func (m *ExtendMsg) GetClientMsgID() string { - if m != nil { - return m.ClientMsgID - } - return "" -} - -func (m *ExtendMsg) GetMsgFirstModifyTime() int64 { - if m != nil { - return m.MsgFirstModifyTime - } - return 0 -} - -func (m *ExtendMsg) GetAttachedInfo() string { - if m != nil { - return m.AttachedInfo - } - return "" -} - -func (m *ExtendMsg) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -type KeyValueResp struct { - KeyValue *sdk_ws.KeyValue `protobuf:"bytes,1,opt,name=keyValue" json:"keyValue,omitempty"` - ErrCode int32 `protobuf:"varint,2,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,3,opt,name=errMsg" json:"errMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *KeyValueResp) Reset() { *m = KeyValueResp{} } -func (m *KeyValueResp) String() string { return proto.CompactTextString(m) } -func (*KeyValueResp) ProtoMessage() {} -func (*KeyValueResp) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{35} -} -func (m *KeyValueResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_KeyValueResp.Unmarshal(m, b) -} -func (m *KeyValueResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_KeyValueResp.Marshal(b, m, deterministic) -} -func (dst *KeyValueResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_KeyValueResp.Merge(dst, src) -} -func (m *KeyValueResp) XXX_Size() int { - return xxx_messageInfo_KeyValueResp.Size(m) -} -func (m *KeyValueResp) XXX_DiscardUnknown() { - xxx_messageInfo_KeyValueResp.DiscardUnknown(m) -} - -var xxx_messageInfo_KeyValueResp proto.InternalMessageInfo - -func (m *KeyValueResp) GetKeyValue() *sdk_ws.KeyValue { - if m != nil { - return m.KeyValue - } - return nil -} - -func (m *KeyValueResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *KeyValueResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -type MsgDataToModifyByMQ struct { - AggregationID string `protobuf:"bytes,1,opt,name=aggregationID" json:"aggregationID,omitempty"` - MessageList []*MsgDataToMQ `protobuf:"bytes,2,rep,name=messageList" json:"messageList,omitempty"` - TriggerID string `protobuf:"bytes,3,opt,name=triggerID" json:"triggerID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *MsgDataToModifyByMQ) Reset() { *m = MsgDataToModifyByMQ{} } -func (m *MsgDataToModifyByMQ) String() string { return proto.CompactTextString(m) } -func (*MsgDataToModifyByMQ) ProtoMessage() {} -func (*MsgDataToModifyByMQ) Descriptor() ([]byte, []int) { - return fileDescriptor_msg_53ecdffb017d9c40, []int{36} -} -func (m *MsgDataToModifyByMQ) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MsgDataToModifyByMQ.Unmarshal(m, b) -} -func (m *MsgDataToModifyByMQ) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MsgDataToModifyByMQ.Marshal(b, m, deterministic) -} -func (dst *MsgDataToModifyByMQ) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgDataToModifyByMQ.Merge(dst, src) -} -func (m *MsgDataToModifyByMQ) XXX_Size() int { - return xxx_messageInfo_MsgDataToModifyByMQ.Size(m) -} -func (m *MsgDataToModifyByMQ) XXX_DiscardUnknown() { - xxx_messageInfo_MsgDataToModifyByMQ.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgDataToModifyByMQ proto.InternalMessageInfo - -func (m *MsgDataToModifyByMQ) GetAggregationID() string { - if m != nil { - return m.AggregationID - } - return "" -} - -func (m *MsgDataToModifyByMQ) GetMessageList() []*MsgDataToMQ { - if m != nil { - return m.MessageList - } - return nil -} - -func (m *MsgDataToModifyByMQ) GetTriggerID() string { - if m != nil { - return m.TriggerID - } - return "" -} - -func init() { - proto.RegisterType((*MsgDataToMQ)(nil), "msg.MsgDataToMQ") - proto.RegisterType((*MsgDataToDB)(nil), "msg.MsgDataToDB") - proto.RegisterType((*PushMsgDataToMQ)(nil), "msg.PushMsgDataToMQ") - proto.RegisterType((*MsgDataToMongoByMQ)(nil), "msg.MsgDataToMongoByMQ") - proto.RegisterType((*GetMaxAndMinSeqReq)(nil), "msg.GetMaxAndMinSeqReq") - proto.RegisterType((*GetMaxAndMinSeqResp)(nil), "msg.GetMaxAndMinSeqResp") - proto.RegisterType((*SendMsgReq)(nil), "msg.SendMsgReq") - proto.RegisterType((*SendMsgResp)(nil), "msg.SendMsgResp") - proto.RegisterType((*ClearMsgReq)(nil), "msg.ClearMsgReq") - proto.RegisterType((*ClearMsgResp)(nil), "msg.ClearMsgResp") - proto.RegisterType((*SetMsgMinSeqReq)(nil), "msg.SetMsgMinSeqReq") - proto.RegisterType((*SetMsgMinSeqResp)(nil), "msg.SetMsgMinSeqResp") - proto.RegisterType((*SetSendMsgStatusReq)(nil), "msg.SetSendMsgStatusReq") - proto.RegisterType((*SetSendMsgStatusResp)(nil), "msg.SetSendMsgStatusResp") - proto.RegisterType((*GetSendMsgStatusReq)(nil), "msg.GetSendMsgStatusReq") - proto.RegisterType((*GetSendMsgStatusResp)(nil), "msg.GetSendMsgStatusResp") - proto.RegisterType((*DelSuperGroupMsgReq)(nil), "msg.DelSuperGroupMsgReq") - proto.RegisterType((*DelSuperGroupMsgResp)(nil), "msg.DelSuperGroupMsgResp") - proto.RegisterType((*GetSuperGroupMsgReq)(nil), "msg.GetSuperGroupMsgReq") - proto.RegisterType((*GetSuperGroupMsgResp)(nil), "msg.GetSuperGroupMsgResp") - proto.RegisterType((*GetWriteDiffMsgReq)(nil), "msg.GetWriteDiffMsgReq") - proto.RegisterType((*GetWriteDiffMsgResp)(nil), "msg.GetWriteDiffMsgResp") - proto.RegisterType((*ModifyMessageReactionExtensionsReq)(nil), "msg.ModifyMessageReactionExtensionsReq") - proto.RegisterMapType((map[string]*sdk_ws.KeyValue)(nil), "msg.ModifyMessageReactionExtensionsReq.ReactionExtensionListEntry") - proto.RegisterType((*SetMessageReactionExtensionsReq)(nil), "msg.SetMessageReactionExtensionsReq") - proto.RegisterMapType((map[string]*sdk_ws.KeyValue)(nil), "msg.SetMessageReactionExtensionsReq.ReactionExtensionListEntry") - proto.RegisterType((*SetMessageReactionExtensionsResp)(nil), "msg.SetMessageReactionExtensionsResp") - proto.RegisterType((*AddMessageReactionExtensionsReq)(nil), "msg.AddMessageReactionExtensionsReq") - proto.RegisterMapType((map[string]*sdk_ws.KeyValue)(nil), "msg.AddMessageReactionExtensionsReq.ReactionExtensionListEntry") - proto.RegisterType((*AddMessageReactionExtensionsResp)(nil), "msg.AddMessageReactionExtensionsResp") - proto.RegisterType((*GetMessageListReactionExtensionsReq)(nil), "msg.GetMessageListReactionExtensionsReq") - proto.RegisterType((*GetMessageListReactionExtensionsReq_MessageReactionKey)(nil), "msg.GetMessageListReactionExtensionsReq.MessageReactionKey") - proto.RegisterType((*GetMessageListReactionExtensionsResp)(nil), "msg.GetMessageListReactionExtensionsResp") - proto.RegisterType((*SingleMessageExtensionResult)(nil), "msg.SingleMessageExtensionResult") - proto.RegisterMapType((map[string]*sdk_ws.KeyValue)(nil), "msg.SingleMessageExtensionResult.ReactionExtensionListEntry") - proto.RegisterType((*ModifyMessageReactionExtensionsResp)(nil), "msg.ModifyMessageReactionExtensionsResp") - proto.RegisterType((*DeleteMessageListReactionExtensionsReq)(nil), "msg.DeleteMessageListReactionExtensionsReq") - proto.RegisterType((*DeleteMessageListReactionExtensionsResp)(nil), "msg.DeleteMessageListReactionExtensionsResp") - proto.RegisterType((*ExtendMsgResp)(nil), "msg.ExtendMsgResp") - proto.RegisterType((*ExtendMsg)(nil), "msg.ExtendMsg") - proto.RegisterMapType((map[string]*KeyValueResp)(nil), "msg.ExtendMsg.ReactionExtensionListEntry") - proto.RegisterType((*KeyValueResp)(nil), "msg.KeyValueResp") - proto.RegisterType((*MsgDataToModifyByMQ)(nil), "msg.MsgDataToModifyByMQ") -} - -// Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the grpc package it is being compiled against. -const _ = grpc.SupportPackageIsVersion4 - -// Client API for Msg service - -type MsgClient interface { - GetMaxAndMinSeq(ctx context.Context, in *sdk_ws.GetMaxAndMinSeqReq, opts ...grpc.CallOption) (*sdk_ws.GetMaxAndMinSeqResp, error) - PullMessageBySeqList(ctx context.Context, in *sdk_ws.PullMessageBySeqListReq, opts ...grpc.CallOption) (*sdk_ws.PullMessageBySeqListResp, error) - SendMsg(ctx context.Context, in *SendMsgReq, opts ...grpc.CallOption) (*SendMsgResp, error) - DelMsgList(ctx context.Context, in *sdk_ws.DelMsgListReq, opts ...grpc.CallOption) (*sdk_ws.DelMsgListResp, error) - DelSuperGroupMsg(ctx context.Context, in *DelSuperGroupMsgReq, opts ...grpc.CallOption) (*DelSuperGroupMsgResp, error) - ClearMsg(ctx context.Context, in *ClearMsgReq, opts ...grpc.CallOption) (*ClearMsgResp, error) - SetMsgMinSeq(ctx context.Context, in *SetMsgMinSeqReq, opts ...grpc.CallOption) (*SetMsgMinSeqResp, error) - SetSendMsgStatus(ctx context.Context, in *SetSendMsgStatusReq, opts ...grpc.CallOption) (*SetSendMsgStatusResp, error) - GetSendMsgStatus(ctx context.Context, in *GetSendMsgStatusReq, opts ...grpc.CallOption) (*GetSendMsgStatusResp, error) - GetSuperGroupMsg(ctx context.Context, in *GetSuperGroupMsgReq, opts ...grpc.CallOption) (*GetSuperGroupMsgResp, error) - GetWriteDiffMsg(ctx context.Context, in *GetWriteDiffMsgReq, opts ...grpc.CallOption) (*GetWriteDiffMsgResp, error) - // modify msg - SetMessageReactionExtensions(ctx context.Context, in *SetMessageReactionExtensionsReq, opts ...grpc.CallOption) (*SetMessageReactionExtensionsResp, error) - GetMessageListReactionExtensions(ctx context.Context, in *GetMessageListReactionExtensionsReq, opts ...grpc.CallOption) (*GetMessageListReactionExtensionsResp, error) - AddMessageReactionExtensions(ctx context.Context, in *AddMessageReactionExtensionsReq, opts ...grpc.CallOption) (*AddMessageReactionExtensionsResp, error) - DeleteMessageReactionExtensions(ctx context.Context, in *DeleteMessageListReactionExtensionsReq, opts ...grpc.CallOption) (*DeleteMessageListReactionExtensionsResp, error) -} - -type msgClient struct { - cc *grpc.ClientConn -} - -func NewMsgClient(cc *grpc.ClientConn) MsgClient { - return &msgClient{cc} -} - -func (c *msgClient) GetMaxAndMinSeq(ctx context.Context, in *sdk_ws.GetMaxAndMinSeqReq, opts ...grpc.CallOption) (*sdk_ws.GetMaxAndMinSeqResp, error) { - out := new(sdk_ws.GetMaxAndMinSeqResp) - err := grpc.Invoke(ctx, "/msg.msg/GetMaxAndMinSeq", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) PullMessageBySeqList(ctx context.Context, in *sdk_ws.PullMessageBySeqListReq, opts ...grpc.CallOption) (*sdk_ws.PullMessageBySeqListResp, error) { - out := new(sdk_ws.PullMessageBySeqListResp) - err := grpc.Invoke(ctx, "/msg.msg/PullMessageBySeqList", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) SendMsg(ctx context.Context, in *SendMsgReq, opts ...grpc.CallOption) (*SendMsgResp, error) { - out := new(SendMsgResp) - err := grpc.Invoke(ctx, "/msg.msg/SendMsg", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) DelMsgList(ctx context.Context, in *sdk_ws.DelMsgListReq, opts ...grpc.CallOption) (*sdk_ws.DelMsgListResp, error) { - out := new(sdk_ws.DelMsgListResp) - err := grpc.Invoke(ctx, "/msg.msg/DelMsgList", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) DelSuperGroupMsg(ctx context.Context, in *DelSuperGroupMsgReq, opts ...grpc.CallOption) (*DelSuperGroupMsgResp, error) { - out := new(DelSuperGroupMsgResp) - err := grpc.Invoke(ctx, "/msg.msg/DelSuperGroupMsg", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) ClearMsg(ctx context.Context, in *ClearMsgReq, opts ...grpc.CallOption) (*ClearMsgResp, error) { - out := new(ClearMsgResp) - err := grpc.Invoke(ctx, "/msg.msg/ClearMsg", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) SetMsgMinSeq(ctx context.Context, in *SetMsgMinSeqReq, opts ...grpc.CallOption) (*SetMsgMinSeqResp, error) { - out := new(SetMsgMinSeqResp) - err := grpc.Invoke(ctx, "/msg.msg/SetMsgMinSeq", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) SetSendMsgStatus(ctx context.Context, in *SetSendMsgStatusReq, opts ...grpc.CallOption) (*SetSendMsgStatusResp, error) { - out := new(SetSendMsgStatusResp) - err := grpc.Invoke(ctx, "/msg.msg/SetSendMsgStatus", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) GetSendMsgStatus(ctx context.Context, in *GetSendMsgStatusReq, opts ...grpc.CallOption) (*GetSendMsgStatusResp, error) { - out := new(GetSendMsgStatusResp) - err := grpc.Invoke(ctx, "/msg.msg/GetSendMsgStatus", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) GetSuperGroupMsg(ctx context.Context, in *GetSuperGroupMsgReq, opts ...grpc.CallOption) (*GetSuperGroupMsgResp, error) { - out := new(GetSuperGroupMsgResp) - err := grpc.Invoke(ctx, "/msg.msg/GetSuperGroupMsg", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) GetWriteDiffMsg(ctx context.Context, in *GetWriteDiffMsgReq, opts ...grpc.CallOption) (*GetWriteDiffMsgResp, error) { - out := new(GetWriteDiffMsgResp) - err := grpc.Invoke(ctx, "/msg.msg/GetWriteDiffMsg", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) SetMessageReactionExtensions(ctx context.Context, in *SetMessageReactionExtensionsReq, opts ...grpc.CallOption) (*SetMessageReactionExtensionsResp, error) { - out := new(SetMessageReactionExtensionsResp) - err := grpc.Invoke(ctx, "/msg.msg/SetMessageReactionExtensions", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) GetMessageListReactionExtensions(ctx context.Context, in *GetMessageListReactionExtensionsReq, opts ...grpc.CallOption) (*GetMessageListReactionExtensionsResp, error) { - out := new(GetMessageListReactionExtensionsResp) - err := grpc.Invoke(ctx, "/msg.msg/GetMessageListReactionExtensions", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) AddMessageReactionExtensions(ctx context.Context, in *AddMessageReactionExtensionsReq, opts ...grpc.CallOption) (*AddMessageReactionExtensionsResp, error) { - out := new(AddMessageReactionExtensionsResp) - err := grpc.Invoke(ctx, "/msg.msg/AddMessageReactionExtensions", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) DeleteMessageReactionExtensions(ctx context.Context, in *DeleteMessageListReactionExtensionsReq, opts ...grpc.CallOption) (*DeleteMessageListReactionExtensionsResp, error) { - out := new(DeleteMessageListReactionExtensionsResp) - err := grpc.Invoke(ctx, "/msg.msg/DeleteMessageReactionExtensions", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -// Server API for Msg service - -type MsgServer interface { - GetMaxAndMinSeq(context.Context, *sdk_ws.GetMaxAndMinSeqReq) (*sdk_ws.GetMaxAndMinSeqResp, error) - PullMessageBySeqList(context.Context, *sdk_ws.PullMessageBySeqListReq) (*sdk_ws.PullMessageBySeqListResp, error) - SendMsg(context.Context, *SendMsgReq) (*SendMsgResp, error) - DelMsgList(context.Context, *sdk_ws.DelMsgListReq) (*sdk_ws.DelMsgListResp, error) - DelSuperGroupMsg(context.Context, *DelSuperGroupMsgReq) (*DelSuperGroupMsgResp, error) - ClearMsg(context.Context, *ClearMsgReq) (*ClearMsgResp, error) - SetMsgMinSeq(context.Context, *SetMsgMinSeqReq) (*SetMsgMinSeqResp, error) - SetSendMsgStatus(context.Context, *SetSendMsgStatusReq) (*SetSendMsgStatusResp, error) - GetSendMsgStatus(context.Context, *GetSendMsgStatusReq) (*GetSendMsgStatusResp, error) - GetSuperGroupMsg(context.Context, *GetSuperGroupMsgReq) (*GetSuperGroupMsgResp, error) - GetWriteDiffMsg(context.Context, *GetWriteDiffMsgReq) (*GetWriteDiffMsgResp, error) - // modify msg - SetMessageReactionExtensions(context.Context, *SetMessageReactionExtensionsReq) (*SetMessageReactionExtensionsResp, error) - GetMessageListReactionExtensions(context.Context, *GetMessageListReactionExtensionsReq) (*GetMessageListReactionExtensionsResp, error) - AddMessageReactionExtensions(context.Context, *AddMessageReactionExtensionsReq) (*AddMessageReactionExtensionsResp, error) - DeleteMessageReactionExtensions(context.Context, *DeleteMessageListReactionExtensionsReq) (*DeleteMessageListReactionExtensionsResp, error) -} - -func RegisterMsgServer(s *grpc.Server, srv MsgServer) { - s.RegisterService(&_Msg_serviceDesc, srv) -} - -func _Msg_GetMaxAndMinSeq_Handler(srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor) (any, error) { - in := new(sdk_ws.GetMaxAndMinSeqReq) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).GetMaxAndMinSeq(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/msg.msg/GetMaxAndMinSeq", - } - handler := func(ctx context.Context, req any) (any, error) { - return srv.(MsgServer).GetMaxAndMinSeq(ctx, req.(*sdk_ws.GetMaxAndMinSeqReq)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_PullMessageBySeqList_Handler(srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor) (any, error) { - in := new(sdk_ws.PullMessageBySeqListReq) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).PullMessageBySeqList(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/msg.msg/PullMessageBySeqList", - } - handler := func(ctx context.Context, req any) (any, error) { - return srv.(MsgServer).PullMessageBySeqList(ctx, req.(*sdk_ws.PullMessageBySeqListReq)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_SendMsg_Handler(srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor) (any, error) { - in := new(SendMsgReq) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).SendMsg(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/msg.msg/SendMsg", - } - handler := func(ctx context.Context, req any) (any, error) { - return srv.(MsgServer).SendMsg(ctx, req.(*SendMsgReq)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_DelMsgList_Handler(srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor) (any, error) { - in := new(sdk_ws.DelMsgListReq) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).DelMsgList(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/msg.msg/DelMsgList", - } - handler := func(ctx context.Context, req any) (any, error) { - return srv.(MsgServer).DelMsgList(ctx, req.(*sdk_ws.DelMsgListReq)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_DelSuperGroupMsg_Handler(srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor) (any, error) { - in := new(DelSuperGroupMsgReq) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).DelSuperGroupMsg(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/msg.msg/DelSuperGroupMsg", - } - handler := func(ctx context.Context, req any) (any, error) { - return srv.(MsgServer).DelSuperGroupMsg(ctx, req.(*DelSuperGroupMsgReq)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_ClearMsg_Handler(srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor) (any, error) { - in := new(ClearMsgReq) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).ClearMsg(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/msg.msg/ClearMsg", - } - handler := func(ctx context.Context, req any) (any, error) { - return srv.(MsgServer).ClearMsg(ctx, req.(*ClearMsgReq)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_SetMsgMinSeq_Handler(srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor) (any, error) { - in := new(SetMsgMinSeqReq) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).SetMsgMinSeq(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/msg.msg/SetMsgMinSeq", - } - handler := func(ctx context.Context, req any) (any, error) { - return srv.(MsgServer).SetMsgMinSeq(ctx, req.(*SetMsgMinSeqReq)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_SetSendMsgStatus_Handler(srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor) (any, error) { - in := new(SetSendMsgStatusReq) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).SetSendMsgStatus(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/msg.msg/SetSendMsgStatus", - } - handler := func(ctx context.Context, req any) (any, error) { - return srv.(MsgServer).SetSendMsgStatus(ctx, req.(*SetSendMsgStatusReq)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_GetSendMsgStatus_Handler(srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor) (any, error) { - in := new(GetSendMsgStatusReq) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).GetSendMsgStatus(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/msg.msg/GetSendMsgStatus", - } - handler := func(ctx context.Context, req any) (any, error) { - return srv.(MsgServer).GetSendMsgStatus(ctx, req.(*GetSendMsgStatusReq)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_GetSuperGroupMsg_Handler(srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor) (any, error) { - in := new(GetSuperGroupMsgReq) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).GetSuperGroupMsg(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/msg.msg/GetSuperGroupMsg", - } - handler := func(ctx context.Context, req any) (any, error) { - return srv.(MsgServer).GetSuperGroupMsg(ctx, req.(*GetSuperGroupMsgReq)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_GetWriteDiffMsg_Handler(srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor) (any, error) { - in := new(GetWriteDiffMsgReq) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).GetWriteDiffMsg(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/msg.msg/GetWriteDiffMsg", - } - handler := func(ctx context.Context, req any) (any, error) { - return srv.(MsgServer).GetWriteDiffMsg(ctx, req.(*GetWriteDiffMsgReq)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_SetMessageReactionExtensions_Handler(srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor) (any, error) { - in := new(SetMessageReactionExtensionsReq) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).SetMessageReactionExtensions(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/msg.msg/SetMessageReactionExtensions", - } - handler := func(ctx context.Context, req any) (any, error) { - return srv.(MsgServer).SetMessageReactionExtensions(ctx, req.(*SetMessageReactionExtensionsReq)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_GetMessageListReactionExtensions_Handler(srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor) (any, error) { - in := new(GetMessageListReactionExtensionsReq) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).GetMessageListReactionExtensions(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/msg.msg/GetMessageListReactionExtensions", - } - handler := func(ctx context.Context, req any) (any, error) { - return srv.(MsgServer).GetMessageListReactionExtensions(ctx, req.(*GetMessageListReactionExtensionsReq)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_AddMessageReactionExtensions_Handler(srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor) (any, error) { - in := new(AddMessageReactionExtensionsReq) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).AddMessageReactionExtensions(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/msg.msg/AddMessageReactionExtensions", - } - handler := func(ctx context.Context, req any) (any, error) { - return srv.(MsgServer).AddMessageReactionExtensions(ctx, req.(*AddMessageReactionExtensionsReq)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_DeleteMessageReactionExtensions_Handler(srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor) (any, error) { - in := new(DeleteMessageListReactionExtensionsReq) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).DeleteMessageReactionExtensions(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/msg.msg/DeleteMessageReactionExtensions", - } - handler := func(ctx context.Context, req any) (any, error) { - return srv.(MsgServer).DeleteMessageReactionExtensions(ctx, req.(*DeleteMessageListReactionExtensionsReq)) - } - return interceptor(ctx, in, info, handler) -} - -var _Msg_serviceDesc = grpc.ServiceDesc{ - ServiceName: "msg.msg", - HandlerType: (*MsgServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "GetMaxAndMinSeq", - Handler: _Msg_GetMaxAndMinSeq_Handler, - }, - { - MethodName: "PullMessageBySeqList", - Handler: _Msg_PullMessageBySeqList_Handler, - }, - { - MethodName: "SendMsg", - Handler: _Msg_SendMsg_Handler, - }, - { - MethodName: "DelMsgList", - Handler: _Msg_DelMsgList_Handler, - }, - { - MethodName: "DelSuperGroupMsg", - Handler: _Msg_DelSuperGroupMsg_Handler, - }, - { - MethodName: "ClearMsg", - Handler: _Msg_ClearMsg_Handler, - }, - { - MethodName: "SetMsgMinSeq", - Handler: _Msg_SetMsgMinSeq_Handler, - }, - { - MethodName: "SetSendMsgStatus", - Handler: _Msg_SetSendMsgStatus_Handler, - }, - { - MethodName: "GetSendMsgStatus", - Handler: _Msg_GetSendMsgStatus_Handler, - }, - { - MethodName: "GetSuperGroupMsg", - Handler: _Msg_GetSuperGroupMsg_Handler, - }, - { - MethodName: "GetWriteDiffMsg", - Handler: _Msg_GetWriteDiffMsg_Handler, - }, - { - MethodName: "SetMessageReactionExtensions", - Handler: _Msg_SetMessageReactionExtensions_Handler, - }, - { - MethodName: "GetMessageListReactionExtensions", - Handler: _Msg_GetMessageListReactionExtensions_Handler, - }, - { - MethodName: "AddMessageReactionExtensions", - Handler: _Msg_AddMessageReactionExtensions_Handler, - }, - { - MethodName: "DeleteMessageReactionExtensions", - Handler: _Msg_DeleteMessageReactionExtensions_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "msg/msg.proto", -} - -func init() { proto.RegisterFile("msg/msg.proto", fileDescriptor_msg_53ecdffb017d9c40) } - -var fileDescriptor_msg_53ecdffb017d9c40 = []byte{ - // 1785 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0x4f, 0x6f, 0xdb, 0xc8, - 0x15, 0x07, 0x45, 0x53, 0xb2, 0x9e, 0xec, 0xb5, 0x77, 0xec, 0x75, 0xb5, 0x5c, 0x03, 0xd1, 0x72, - 0xb3, 0x1b, 0xa7, 0x49, 0x64, 0xd4, 0x2d, 0x90, 0xa2, 0x29, 0xd0, 0xc4, 0x91, 0xab, 0x18, 0xa9, - 0xea, 0x98, 0x72, 0x5b, 0xa0, 0x3d, 0x38, 0x8c, 0x34, 0x62, 0x08, 0x4b, 0x24, 0xcd, 0xa1, 0x62, - 0xab, 0xff, 0x0e, 0x05, 0xda, 0x5b, 0x0e, 0x3d, 0xf6, 0x0b, 0xf4, 0x16, 0xf4, 0x03, 0xf4, 0xd4, - 0x0f, 0x10, 0xf4, 0xd2, 0x6f, 0xd1, 0x2f, 0x51, 0xcc, 0x0c, 0x29, 0x0d, 0xff, 0x89, 0xb4, 0x1c, - 0x38, 0x40, 0xdb, 0x9b, 0x66, 0xe6, 0xcd, 0x9b, 0xf7, 0x7b, 0xef, 0xf7, 0x66, 0x86, 0xf3, 0x04, - 0xab, 0x23, 0x62, 0xee, 0x8e, 0x88, 0xd9, 0x74, 0x3d, 0xc7, 0x77, 0x90, 0x3c, 0x22, 0xa6, 0xba, - 0x73, 0xe4, 0x62, 0xfb, 0xc1, 0x61, 0xe7, 0x41, 0x17, 0x7b, 0x6f, 0xb0, 0xb7, 0xeb, 0x9e, 0x99, - 0xbb, 0x6c, 0x78, 0x97, 0xf4, 0xcf, 0x4e, 0x2f, 0xc8, 0xee, 0x05, 0xe1, 0xe2, 0x6a, 0x33, 0x57, - 0xd2, 0x33, 0x5c, 0x17, 0x7b, 0x81, 0xbc, 0xf6, 0x1b, 0xa8, 0x75, 0x88, 0xd9, 0x32, 0x7c, 0xe3, - 0xc4, 0xe9, 0x1c, 0xa3, 0x4d, 0x50, 0x7c, 0xe7, 0x0c, 0xdb, 0x75, 0xa9, 0x21, 0xed, 0x54, 0x75, - 0xde, 0x40, 0x0d, 0xa8, 0x39, 0x2e, 0xf6, 0x0c, 0xdf, 0x72, 0xec, 0xc3, 0x56, 0xbd, 0xc4, 0xc6, - 0xc4, 0x2e, 0xf4, 0x3d, 0xa8, 0x8c, 0xb8, 0x9a, 0xba, 0xdc, 0x90, 0x76, 0x6a, 0x7b, 0x6a, 0x93, - 0x30, 0x03, 0x4e, 0x0d, 0xd7, 0x3a, 0x75, 0x0d, 0xcf, 0x18, 0x91, 0x66, 0xb0, 0x90, 0x1e, 0x8a, - 0x6a, 0x58, 0x58, 0xbc, 0xb5, 0x2f, 0x2a, 0x91, 0x0a, 0x2b, 0xc9, 0x37, 0x4e, 0x7b, 0x2b, 0xc1, - 0xda, 0x8b, 0x31, 0x79, 0x2d, 0x02, 0x6d, 0x40, 0xed, 0x48, 0x98, 0xc5, 0xe1, 0x8a, 0x5d, 0xa2, - 0x35, 0xa5, 0xe2, 0xd6, 0x68, 0xb0, 0xe2, 0x8e, 0xc9, 0xeb, 0x13, 0xe7, 0x67, 0x04, 0x7b, 0x87, - 0x2d, 0xe6, 0x8d, 0xaa, 0x1e, 0xe9, 0xd3, 0xfe, 0x2a, 0x01, 0x9a, 0xd9, 0xe2, 0xd8, 0xa6, 0xb3, - 0x3f, 0xe9, 0x1c, 0xa3, 0x3a, 0x54, 0x86, 0x06, 0xf1, 0xbb, 0xf8, 0x9c, 0x99, 0xb3, 0xa4, 0x87, - 0x4d, 0x74, 0x1b, 0x56, 0x0d, 0xd3, 0xf4, 0xb0, 0x19, 0x05, 0x19, 0xed, 0x44, 0x7b, 0x50, 0x1b, - 0x61, 0x42, 0x0c, 0x13, 0xff, 0xc4, 0x22, 0x7e, 0x5d, 0x6e, 0xc8, 0x3b, 0xb5, 0xbd, 0xf5, 0x26, - 0xa5, 0x92, 0x80, 0x5c, 0x17, 0x85, 0xd0, 0x36, 0x54, 0x7d, 0xcf, 0x32, 0x4d, 0x66, 0xeb, 0x12, - 0xd3, 0x3a, 0xeb, 0xd0, 0x7e, 0x0a, 0xa8, 0x8d, 0xfd, 0x8e, 0x71, 0xf9, 0xc4, 0xee, 0x77, 0x2c, - 0xbb, 0x8b, 0xcf, 0x75, 0x7c, 0x8e, 0xb6, 0xa0, 0x1c, 0x80, 0xe3, 0x5e, 0x0b, 0x5a, 0x71, 0x97, - 0x96, 0x12, 0x2e, 0xd5, 0x2e, 0x60, 0x23, 0xa1, 0x8f, 0xb8, 0x14, 0xf8, 0x81, 0xe7, 0x3d, 0x75, - 0xfa, 0x98, 0x69, 0x54, 0xf4, 0xb0, 0x49, 0x97, 0x3a, 0xf0, 0xbc, 0x0e, 0x31, 0x03, 0x6d, 0x41, - 0x8b, 0xf6, 0x77, 0x8c, 0x4b, 0xea, 0x29, 0xea, 0xdf, 0x55, 0x3d, 0x68, 0xb1, 0x7e, 0xa6, 0x97, - 0x61, 0xa1, 0xfd, 0xac, 0xa5, 0xfd, 0x1a, 0xa0, 0x8b, 0xed, 0x7e, 0x87, 0x98, 0x14, 0xc0, 0xcd, - 0x92, 0xfc, 0x6f, 0x12, 0xd4, 0xa6, 0x8b, 0x73, 0xb4, 0x38, 0x8a, 0x16, 0xcf, 0xd0, 0xe2, 0x08, - 0x5a, 0xde, 0xa2, 0x96, 0xf1, 0x75, 0x3a, 0xc4, 0x9c, 0x86, 0x49, 0xec, 0xa2, 0x12, 0xbd, 0xa1, - 0x85, 0x6d, 0x9f, 0x4b, 0x28, 0x5c, 0x42, 0xe8, 0x42, 0x2a, 0x2c, 0x13, 0x6c, 0xf7, 0x4f, 0xac, - 0x11, 0xae, 0x97, 0x1b, 0xd2, 0x8e, 0xac, 0x4f, 0xdb, 0xe8, 0x13, 0x28, 0xe1, 0xcb, 0x7a, 0x85, - 0x4d, 0x2a, 0xe1, 0x4b, 0xad, 0x07, 0xb5, 0xa7, 0x43, 0x6c, 0x78, 0x81, 0xbb, 0xb6, 0xa0, 0x3c, - 0x8e, 0xc4, 0x9b, 0xb7, 0xa8, 0x4a, 0xc7, 0x0d, 0x98, 0xc0, 0x0d, 0x9e, 0xb6, 0xe3, 0xce, 0x94, - 0x93, 0x49, 0xf9, 0x18, 0x56, 0x66, 0x8b, 0x2c, 0xe2, 0x16, 0xed, 0x2f, 0x12, 0xac, 0x75, 0x31, - 0xc5, 0x17, 0xe1, 0x66, 0xaa, 0xad, 0x75, 0xa8, 0x98, 0x9e, 0x33, 0x76, 0xa7, 0xa6, 0x86, 0x4d, - 0x3a, 0x63, 0xc4, 0x29, 0x13, 0x50, 0x89, 0xb7, 0xe2, 0x08, 0x96, 0x92, 0x74, 0x10, 0xf1, 0x2b, - 0x51, 0xfc, 0x5a, 0x0b, 0xd6, 0xa3, 0xa6, 0x2d, 0x84, 0xf0, 0x08, 0x36, 0xba, 0xd8, 0x0f, 0xc8, - 0xd3, 0xf5, 0x0d, 0x7f, 0x4c, 0xf4, 0xa4, 0x69, 0x52, 0xd2, 0xb4, 0x2d, 0x28, 0x13, 0x26, 0xce, - 0x14, 0x2a, 0x7a, 0xd0, 0xd2, 0x9e, 0xc1, 0x66, 0x52, 0xe1, 0x42, 0xa6, 0x3d, 0x64, 0xa9, 0x7c, - 0x75, 0xd3, 0xb4, 0x97, 0xb0, 0xd9, 0xfe, 0x20, 0x26, 0x08, 0x20, 0xe5, 0x08, 0xc8, 0x3f, 0x4a, - 0xb0, 0xd1, 0xc2, 0xc3, 0xee, 0xd8, 0xc5, 0x5e, 0x9b, 0x46, 0x39, 0xe0, 0xb1, 0x18, 0x2f, 0x29, - 0xc6, 0xd7, 0x19, 0x6f, 0x4a, 0x59, 0xbc, 0x91, 0xa3, 0xbc, 0xc9, 0xe5, 0x07, 0x75, 0x76, 0xd2, - 0x8c, 0x85, 0x9c, 0xdd, 0xe3, 0xce, 0x8e, 0x03, 0xca, 0xe7, 0xc1, 0x3a, 0xc8, 0x94, 0xd9, 0x25, - 0xc6, 0x6c, 0xfa, 0x33, 0x1b, 0x90, 0xf6, 0x7b, 0x1e, 0x98, 0xeb, 0x9b, 0xbb, 0xe0, 0x3e, 0xf9, - 0x8c, 0x1d, 0x36, 0xbf, 0xf0, 0x2c, 0x1f, 0xb7, 0xac, 0xc1, 0x60, 0x71, 0x8c, 0xda, 0xef, 0x98, - 0xbb, 0xa2, 0x9a, 0x6e, 0x10, 0xc8, 0x9f, 0x15, 0xd0, 0x3a, 0x4e, 0xdf, 0x1a, 0x4c, 0x3a, 0xfc, - 0xa4, 0xd5, 0xb1, 0xd1, 0xa3, 0xc6, 0x1e, 0x5c, 0xfa, 0xd8, 0x26, 0x96, 0x63, 0x17, 0xcc, 0x62, - 0xba, 0x67, 0x3b, 0x63, 0xaf, 0x87, 0x67, 0x1b, 0x6c, 0xd8, 0x8e, 0x90, 0x59, 0x4e, 0x6e, 0xbe, - 0x04, 0x13, 0xba, 0xd0, 0xc9, 0xc4, 0xc5, 0x8c, 0x9a, 0x8a, 0x2e, 0x76, 0xa1, 0x4b, 0xf8, 0xcc, - 0x8b, 0x1b, 0xc5, 0x2e, 0x0d, 0x0a, 0xbb, 0x34, 0xec, 0xf3, 0x4b, 0x43, 0x2e, 0x86, 0xa6, 0x9e, - 0xa6, 0xe4, 0xc0, 0xf6, 0xbd, 0x89, 0x9e, 0xbe, 0x40, 0xfc, 0xa4, 0x2a, 0x27, 0x4f, 0xaa, 0xfb, - 0xd3, 0xd3, 0xa8, 0xb6, 0xb7, 0xdd, 0x34, 0x1d, 0xc7, 0x1c, 0x62, 0x7e, 0x59, 0x7d, 0x35, 0x1e, - 0x34, 0xbb, 0xbe, 0x67, 0xd9, 0xe6, 0xcf, 0x8d, 0xe1, 0x18, 0xd3, 0xb3, 0x0a, 0x3d, 0x86, 0x15, - 0xc3, 0xf7, 0x8d, 0xde, 0x6b, 0xdc, 0x3f, 0xb4, 0x07, 0x4e, 0x7d, 0xb9, 0xc0, 0xbc, 0xc8, 0x0c, - 0x4a, 0x0b, 0x8b, 0x30, 0x20, 0xf5, 0x6a, 0x43, 0xda, 0x59, 0xd6, 0xc3, 0x26, 0xda, 0x83, 0x4d, - 0x8b, 0x50, 0xf3, 0x3d, 0xdb, 0x18, 0xce, 0x80, 0xd7, 0x81, 0x89, 0xa5, 0x8e, 0xa1, 0x26, 0xa0, - 0x11, 0x31, 0x7f, 0x6c, 0x79, 0xc4, 0xe7, 0xfe, 0x63, 0x27, 0x6e, 0x8d, 0x9d, 0xb8, 0x29, 0x23, - 0x2a, 0x06, 0x35, 0xdb, 0x89, 0x94, 0xdb, 0x67, 0x78, 0x12, 0x70, 0x83, 0xfe, 0x44, 0xdf, 0x01, - 0xe5, 0x0d, 0x05, 0x11, 0xdc, 0x49, 0xbf, 0x48, 0x21, 0xe4, 0x73, 0x3c, 0xe1, 0x38, 0xb9, 0xe4, - 0x0f, 0x4a, 0xdf, 0x97, 0xb4, 0xbf, 0x2b, 0x70, 0x8b, 0x1e, 0x48, 0x1f, 0x87, 0x90, 0x4d, 0x40, - 0xe1, 0xef, 0x17, 0x43, 0xc3, 0x1f, 0x38, 0xde, 0x28, 0xd8, 0x32, 0x15, 0x3d, 0x65, 0x24, 0x4e, - 0x60, 0x25, 0x49, 0xe0, 0x71, 0x16, 0x81, 0xcb, 0x8c, 0xc0, 0x3f, 0x62, 0x04, 0xce, 0x01, 0x7c, - 0x7d, 0xf6, 0x56, 0xb2, 0xd8, 0xbb, 0xbc, 0x20, 0x7b, 0xab, 0xd7, 0x61, 0x2f, 0x14, 0x63, 0x6f, - 0xed, 0xca, 0xec, 0x5d, 0xf9, 0xd8, 0xec, 0xfd, 0xb7, 0x04, 0x8d, 0xf9, 0xc1, 0x5c, 0xf4, 0x5e, - 0x2d, 0x46, 0x53, 0x4e, 0x46, 0x33, 0xdd, 0x1f, 0x4b, 0x59, 0xfe, 0x10, 0xa3, 0xa1, 0x44, 0xa3, - 0x71, 0x17, 0xca, 0x1e, 0x26, 0xe3, 0x61, 0xc8, 0xd0, 0x4f, 0x19, 0x43, 0xa7, 0x60, 0x31, 0x71, - 0xf5, 0x40, 0x40, 0x7b, 0xaf, 0xc0, 0xad, 0x27, 0xfd, 0xfe, 0xff, 0x56, 0xae, 0xe6, 0x00, 0xfe, - 0x7f, 0xae, 0x5e, 0x37, 0x57, 0x69, 0x36, 0x12, 0x7c, 0x5e, 0x5f, 0xe5, 0xf7, 0x24, 0x82, 0xcf, - 0x6f, 0x32, 0x7b, 0xe7, 0x87, 0xf7, 0xbf, 0x29, 0x7b, 0xff, 0x25, 0xc3, 0x57, 0xed, 0xe9, 0x5e, - 0x45, 0xdd, 0x79, 0x8d, 0x0c, 0xce, 0xfc, 0xbe, 0x16, 0xb3, 0x5b, 0x8e, 0x65, 0x77, 0xfe, 0xf5, - 0x2f, 0x8b, 0x6e, 0xca, 0x1c, 0xba, 0x35, 0xa0, 0xe6, 0x4f, 0x5c, 0xfc, 0x1c, 0x4f, 0xa6, 0xb9, - 0x5b, 0xd5, 0xc5, 0x2e, 0x44, 0x60, 0x6b, 0x14, 0x8d, 0x71, 0x28, 0x5c, 0x61, 0x4e, 0x7b, 0xc4, - 0x9c, 0x56, 0xc0, 0x37, 0xcd, 0x4e, 0x42, 0x8d, 0x9e, 0xa1, 0x5a, 0x1d, 0x00, 0x4a, 0x4a, 0xc7, - 0xb9, 0x21, 0x15, 0xe5, 0x46, 0x29, 0x8b, 0x1b, 0xda, 0x3b, 0x09, 0x6e, 0xe7, 0x9b, 0xbe, 0x10, - 0x91, 0xbb, 0xb0, 0x41, 0x2c, 0xdb, 0x1c, 0xe2, 0x29, 0x10, 0xc6, 0x34, 0xfe, 0x7e, 0xf7, 0x25, - 0xbf, 0xc9, 0x88, 0xe3, 0xd3, 0x05, 0xb9, 0xa0, 0x9e, 0x36, 0x5b, 0x7b, 0x5f, 0x82, 0xed, 0x79, - 0xb3, 0x16, 0xb0, 0xd3, 0xcb, 0xda, 0xc7, 0xb9, 0xa5, 0x3f, 0xcc, 0xb5, 0xf4, 0xfa, 0x9b, 0xf8, - 0x52, 0x22, 0x90, 0x37, 0xb5, 0x89, 0xfd, 0x43, 0x82, 0xaf, 0x72, 0x3f, 0x88, 0x16, 0xfc, 0xc8, - 0xac, 0x91, 0x71, 0xaf, 0x87, 0x09, 0x11, 0x9c, 0x89, 0x98, 0x33, 0x99, 0xee, 0xf0, 0xe1, 0x50, - 0x17, 0xc5, 0xd0, 0x1e, 0xc0, 0xc0, 0xb0, 0x86, 0xb8, 0xcf, 0x26, 0x2d, 0x65, 0x4e, 0x12, 0xa4, - 0xb4, 0x77, 0x32, 0x7c, 0xd3, 0xc2, 0x43, 0xec, 0xe3, 0x8f, 0xb8, 0x3b, 0x7d, 0xf8, 0xfb, 0x45, - 0xfe, 0x27, 0x65, 0xd6, 0x7e, 0x57, 0xb9, 0xf2, 0xf1, 0xba, 0x9c, 0x79, 0x78, 0x1c, 0x67, 0x65, - 0x47, 0x95, 0xc5, 0x66, 0x2e, 0xcf, 0xd2, 0x67, 0x6a, 0x7f, 0x92, 0xe0, 0x4e, 0xa1, 0x78, 0x2d, - 0xc4, 0xbb, 0x2b, 0x9c, 0x69, 0x0e, 0xac, 0x46, 0x58, 0x85, 0xee, 0x43, 0x15, 0x87, 0x1d, 0x41, - 0xad, 0xe6, 0x93, 0x18, 0xf9, 0x66, 0x02, 0xa2, 0x6d, 0xa5, 0x2c, 0xdb, 0xe4, 0xc8, 0x83, 0xd7, - 0x3f, 0x4b, 0x50, 0x9d, 0xaa, 0x42, 0xa7, 0x59, 0xae, 0x95, 0x98, 0xe1, 0x77, 0xa3, 0x2b, 0x5f, - 0x7f, 0x97, 0x29, 0x15, 0x3d, 0x2e, 0xe4, 0x4c, 0x36, 0x68, 0xb1, 0xcb, 0x22, 0xdf, 0xb8, 0xa2, - 0xd7, 0x41, 0xfe, 0xec, 0xae, 0x84, 0xcf, 0xee, 0xea, 0xaf, 0xae, 0xb8, 0x93, 0xdd, 0x89, 0xee, - 0x64, 0x29, 0xf1, 0x13, 0xf6, 0xaf, 0x09, 0xac, 0x88, 0x43, 0xe8, 0x21, 0x2c, 0x9f, 0x05, 0xed, - 0x20, 0x80, 0x73, 0x19, 0x3a, 0x15, 0x5e, 0x20, 0x98, 0x6f, 0x25, 0xd8, 0x10, 0xca, 0x5d, 0xd4, - 0x47, 0xac, 0xde, 0x95, 0xa8, 0x6a, 0x49, 0x05, 0xaa, 0x5a, 0xa5, 0x2b, 0x57, 0xb5, 0xe4, 0x58, - 0x55, 0x6b, 0xef, 0x0f, 0x00, 0xf2, 0x88, 0x98, 0xe8, 0x25, 0xac, 0xc5, 0xaa, 0x51, 0xe8, 0xeb, - 0x14, 0x1f, 0x24, 0x2b, 0x60, 0xea, 0x37, 0x45, 0xc4, 0x88, 0x8b, 0x1c, 0xd8, 0x7c, 0x31, 0x1e, - 0x0e, 0x83, 0xec, 0xdd, 0x9f, 0x74, 0xf1, 0x39, 0xb3, 0xef, 0xdb, 0x29, 0xf3, 0xd3, 0x04, 0xe9, - 0x5a, 0xf7, 0x0a, 0xcb, 0xb2, 0xbc, 0xac, 0x04, 0x2f, 0xeb, 0x68, 0x2d, 0x78, 0x02, 0x09, 0xab, - 0x5e, 0xea, 0x7a, 0xb4, 0x83, 0xb8, 0xe8, 0x18, 0xa0, 0x85, 0x87, 0x1d, 0x62, 0xf2, 0x24, 0x48, - 0x59, 0x68, 0x36, 0x4c, 0x35, 0x7c, 0x99, 0x23, 0x41, 0x5c, 0xd4, 0x86, 0xf5, 0xf8, 0x9b, 0x37, - 0xaa, 0xb3, 0x85, 0x53, 0x5e, 0xe4, 0xd5, 0xcf, 0x33, 0x46, 0x88, 0x8b, 0x76, 0x61, 0x39, 0x2c, - 0x0f, 0x21, 0x6e, 0xb9, 0x50, 0x92, 0x52, 0x3f, 0x8d, 0xf5, 0x10, 0x17, 0x3d, 0x82, 0x15, 0xb1, - 0xe2, 0x82, 0x36, 0xa7, 0x4f, 0x40, 0x42, 0x7d, 0x48, 0xfd, 0x2c, 0xa5, 0x97, 0x9b, 0x1d, 0xaf, - 0x8b, 0x04, 0x66, 0xa7, 0xd4, 0x5f, 0x02, 0xb3, 0x53, 0x0b, 0x29, 0x6d, 0x58, 0x6f, 0xa7, 0x2b, - 0x6a, 0x67, 0x2a, 0x6a, 0xcf, 0x51, 0x94, 0xe2, 0xc8, 0x94, 0x4a, 0x80, 0xa0, 0x28, 0xe1, 0xc8, - 0x16, 0x63, 0xb9, 0xf8, 0x18, 0x8e, 0xbe, 0x15, 0x4a, 0xc7, 0x1e, 0xdb, 0xd5, 0x7a, 0xfa, 0x00, - 0x71, 0xd1, 0x19, 0x6c, 0xcf, 0x7b, 0x80, 0x41, 0xb7, 0x8b, 0x3c, 0xb8, 0xa9, 0x5f, 0x17, 0x90, - 0x22, 0x2e, 0xba, 0x80, 0x46, 0xde, 0x55, 0x1b, 0xed, 0x14, 0xfd, 0x98, 0x50, 0xef, 0x16, 0x94, - 0xe4, 0x28, 0xe7, 0x7d, 0xa8, 0x06, 0x28, 0x73, 0x9e, 0x2a, 0x02, 0x94, 0xb9, 0x5f, 0xbc, 0xbf, - 0x85, 0x5b, 0x91, 0xc3, 0x3d, 0x65, 0xbd, 0x7b, 0x61, 0x7e, 0x14, 0xb8, 0xb2, 0xa9, 0xf7, 0x8b, - 0x0b, 0x13, 0x77, 0xff, 0x8b, 0x5f, 0x7e, 0x7e, 0xe4, 0x62, 0xfb, 0xf4, 0xb0, 0x23, 0xfc, 0x45, - 0x64, 0x44, 0xcc, 0x47, 0x23, 0x62, 0xbe, 0x2a, 0xb3, 0xe6, 0x77, 0xff, 0x13, 0x00, 0x00, 0xff, - 0xff, 0x4c, 0x17, 0xe7, 0xd8, 0x8b, 0x22, 0x00, 0x00, -} diff --git a/tools/data-conversion/openim/proto/msg/msg.proto b/tools/data-conversion/openim/proto/msg/msg.proto deleted file mode 100644 index 3149a7337..000000000 --- a/tools/data-conversion/openim/proto/msg/msg.proto +++ /dev/null @@ -1,329 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -syntax = "proto3"; -import "Open-IM-Server/pkg/proto/sdk_ws/ws.proto"; -import "Open-IM-Server/pkg/proto/sdk_ws/wrappers.proto"; -option go_package = "Open_IM/pkg/proto/msg;msg"; -package msg; - -message MsgDataToMQ{ - string token =1; - string operationID = 2; - server_api_params.MsgData msgData = 3; -} - - -message MsgDataToDB { - server_api_params.MsgData msgData = 1; - string operationID = 2; - -} -message PushMsgDataToMQ{ - string OperationID = 1; - server_api_params.MsgData msgData = 2; - string pushToUserID = 3; -} -message MsgDataToMongoByMQ{ - uint64 lastSeq =1; - string aggregationID = 2; - repeated MsgDataToMQ messageList = 3; - string triggerID = 4; - - -} - -//message PullMessageReq { -// string UserID = 1; -// int64 SeqBegin = 2; -// int64 SeqEnd = 3; -// string OperationID = 4; -//} -// -//message PullMessageResp { -// int32 ErrCode = 1; -// string ErrMsg = 2; -// int64 MaxSeq = 3; -// int64 MinSeq = 4; -// repeated GatherFormat SingleUserMsg = 5; -// repeated GatherFormat GroupUserMsg = 6; -//} -//message PullMessageBySeqListReq{ -// string UserID = 1; -// string OperationID = 2; -// repeated int64 seqList =3; -//} -message GetMaxAndMinSeqReq { - string UserID = 1; - string OperationID = 2; -} -message GetMaxAndMinSeqResp { - int32 ErrCode = 1; - string ErrMsg = 2; - uint32 MaxSeq = 3; - uint32 MinSeq = 4; -} - -message SendMsgReq { - -string token =1; -string operationID = 2; -server_api_params.MsgData msgData = 3; - - -} - -message SendMsgResp { - int32 errCode = 1; - string errMsg = 2; - string serverMsgID = 4; - string clientMsgID = 5; - int64 sendTime = 6; - string ex = 7; -} - - -message ClearMsgReq{ - string userID = 1; - string opUserID = 2; - string operationID = 3; -} - - -message ClearMsgResp{ - int32 errCode = 1; - string errMsg = 2; -} - -message SetMsgMinSeqReq{ - string userID = 1; - string groupID = 2; - uint32 minSeq = 3; - string operationID = 4; - string opUserID = 5; -} -message SetMsgMinSeqResp{ - int32 errCode = 1; - string errMsg = 2; -} - -message SetSendMsgStatusReq{ - string operationID = 1; - int32 status = 2; -} - -message SetSendMsgStatusResp{ - int32 errCode = 1; - string errMsg = 2; -} - -message GetSendMsgStatusReq{ - string operationID = 1; -} - -message GetSendMsgStatusResp{ - int32 errCode = 1; - string errMsg = 2; - int32 status = 3; -} -message DelSuperGroupMsgReq{ - string opUserID = 1; - string userID = 2; - string groupID = 3; - string operationID = 4; -} -message DelSuperGroupMsgResp{ - int32 errCode = 1; - string errMsg = 2; -} -message GetSuperGroupMsgReq{ - string operationID = 1; - uint32 Seq = 2; - string groupID = 3; - -} -message GetSuperGroupMsgResp{ - int32 errCode = 1; - string errMsg = 2; - server_api_params.MsgData msgData = 3; -} -message GetWriteDiffMsgReq{ - string operationID = 1; - uint32 Seq = 2; - - } -message GetWriteDiffMsgResp{ - int32 errCode = 1; - string errMsg = 2; - server_api_params.MsgData msgData = 3; -} - -message ModifyMessageReactionExtensionsReq { - string operationID = 1; - string sourceID = 2; - string opUserID = 3; - int32 sessionType = 4; - map reactionExtensionList = 5; - string clientMsgID = 6; - google.protobuf.StringValue ex = 7; - google.protobuf.StringValue attachedInfo = 8; - bool isReact = 9; - bool isExternalExtensions = 10; - int64 msgFirstModifyTime = 11; -} -message SetMessageReactionExtensionsReq { - string operationID = 1; - string sourceID = 2; - string opUserID = 3; - int32 opUserIDPlatformID = 4; - int32 sessionType = 5; - map reactionExtensionList = 6; - string clientMsgID = 7; - google.protobuf.StringValue ex = 8; - google.protobuf.StringValue attachedInfo = 9; - bool isReact = 10; - bool isExternalExtensions = 11; - int64 msgFirstModifyTime = 12; -} -message SetMessageReactionExtensionsResp { - int32 errCode = 1; - string errMsg = 2; - string clientMsgID = 3; - int64 msgFirstModifyTime = 4; - bool isReact = 5; - repeated KeyValueResp result = 6; -} -message AddMessageReactionExtensionsReq { - string operationID = 1; - string sourceID = 2; - string opUserID = 3; - int32 opUserIDPlatformID = 4; - int32 sessionType = 5; - map reactionExtensionList = 6; - string clientMsgID = 7; - google.protobuf.StringValue ex = 8; - google.protobuf.StringValue attachedInfo = 9; - bool isReact = 10; - bool isExternalExtensions = 11; - int64 msgFirstModifyTime = 12; - uint32 seq = 13; -} -message AddMessageReactionExtensionsResp { - int32 errCode = 1; - string errMsg = 2; - string clientMsgID = 3; - int64 msgFirstModifyTime = 4; - bool isReact = 5; - repeated KeyValueResp result = 6; -} - - -message GetMessageListReactionExtensionsReq { - string operationID = 1; - string opUserID = 2; - string sourceID = 3; - int32 sessionType = 4; - bool isExternalExtensions = 5; - message MessageReactionKey { - string clientMsgID = 1; - int64 msgFirstModifyTime = 2; - } - repeated string typeKeyList = 6; - repeated MessageReactionKey messageReactionKeyList = 7; -} -message GetMessageListReactionExtensionsResp{ - int32 errCode = 1; - string errMsg = 2; - repeated SingleMessageExtensionResult singleMessageResult =3; - -} -message SingleMessageExtensionResult { - int32 errCode = 1; - string errMsg = 2; - map reactionExtensionList = 3; - string clientMsgID = 4; -} - - -message ModifyMessageReactionExtensionsResp { - int32 errCode = 1; - string errMsg = 2; - repeated ExtendMsgResp successList = 3; - repeated ExtendMsgResp failedList = 4; -} - -message DeleteMessageListReactionExtensionsReq { - string operationID = 1; - string opUserID = 2; - string sourceID = 3; - int32 opUserIDPlatformID = 4; - int32 sessionType = 5; - string clientMsgID = 6; - bool isExternalExtensions = 7; - int64 msgFirstModifyTime = 8; - repeated server_api_params.KeyValue reactionExtensionList = 9; -} - -message DeleteMessageListReactionExtensionsResp { - int32 errCode = 1; - string errMsg = 2; - repeated KeyValueResp result = 6; -} - -message ExtendMsgResp { - ExtendMsg extendMsg = 1; - int32 errCode = 2; - string errMsg = 3; -} - -message ExtendMsg { - map reactionExtensionList = 1; - string clientMsgID = 2; - int64 msgFirstModifyTime = 3; - string attachedInfo = 4; - string ex = 5; -} - -message KeyValueResp { - server_api_params.KeyValue keyValue = 1; - int32 errCode = 2; - string errMsg = 3; -} - -message MsgDataToModifyByMQ{ - string aggregationID = 1; - repeated MsgDataToMQ messageList = 2; - string triggerID = 3; -} - - -service msg { - rpc GetMaxAndMinSeq(server_api_params.GetMaxAndMinSeqReq) returns(server_api_params.GetMaxAndMinSeqResp); - rpc PullMessageBySeqList(server_api_params.PullMessageBySeqListReq) returns(server_api_params.PullMessageBySeqListResp); - rpc SendMsg(SendMsgReq) returns(SendMsgResp); - rpc DelMsgList(server_api_params.DelMsgListReq) returns(server_api_params.DelMsgListResp); - rpc DelSuperGroupMsg(DelSuperGroupMsgReq) returns(DelSuperGroupMsgResp); - rpc ClearMsg(ClearMsgReq) returns(ClearMsgResp); - rpc SetMsgMinSeq(SetMsgMinSeqReq) returns(SetMsgMinSeqResp); - rpc SetSendMsgStatus(SetSendMsgStatusReq) returns(SetSendMsgStatusResp); - rpc GetSendMsgStatus(GetSendMsgStatusReq) returns(GetSendMsgStatusResp); - rpc GetSuperGroupMsg(GetSuperGroupMsgReq) returns(GetSuperGroupMsgResp); - rpc GetWriteDiffMsg(GetWriteDiffMsgReq) returns(GetWriteDiffMsgResp); - - // modify msg - rpc SetMessageReactionExtensions(SetMessageReactionExtensionsReq) returns(SetMessageReactionExtensionsResp); - rpc GetMessageListReactionExtensions(GetMessageListReactionExtensionsReq) returns(GetMessageListReactionExtensionsResp); - rpc AddMessageReactionExtensions(AddMessageReactionExtensionsReq) returns(AddMessageReactionExtensionsResp); - rpc DeleteMessageReactionExtensions(DeleteMessageListReactionExtensionsReq) returns(DeleteMessageListReactionExtensionsResp); -} diff --git a/tools/data-conversion/openim/proto/sdk_ws/wrappers.proto b/tools/data-conversion/openim/proto/sdk_ws/wrappers.proto deleted file mode 100644 index c571f0968..000000000 --- a/tools/data-conversion/openim/proto/sdk_ws/wrappers.proto +++ /dev/null @@ -1,123 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Wrappers for primitive (non-message) types. These types are useful -// for embedding primitives in the `google.protobuf.Any` type and for places -// where we need to distinguish between the absence of a primitive -// typed field and its default value. -// -// These wrappers have no meaningful use within repeated fields as they lack -// the ability to detect presence on individual elements. -// These wrappers have no meaningful use within a map or a oneof since -// individual entries of a map or fields of a oneof can already detect presence. - -syntax = "proto3"; - -package google.protobuf; - -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; -option cc_enable_arenas = true; -option go_package = "google.golang.org/protobuf/types/known/wrapperspb"; -option java_package = "com.google.protobuf"; -option java_outer_classname = "WrappersProto"; -option java_multiple_files = true; -option objc_class_prefix = "GPB"; - -// Wrapper message for `double`. -// -// The JSON representation for `DoubleValue` is JSON number. -message DoubleValue { - // The double value. - double value = 1; -} - -// Wrapper message for `float`. -// -// The JSON representation for `FloatValue` is JSON number. -message FloatValue { - // The float value. - float value = 1; -} - -// Wrapper message for `int64`. -// -// The JSON representation for `Int64Value` is JSON string. -message Int64Value { - // The int64 value. - int64 value = 1; -} - -// Wrapper message for `uint64`. -// -// The JSON representation for `UInt64Value` is JSON string. -message UInt64Value { - // The uint64 value. - uint64 value = 1; -} - -// Wrapper message for `int32`. -// -// The JSON representation for `Int32Value` is JSON number. -message Int32Value { - // The int32 value. - int32 value = 1; -} - -// Wrapper message for `uint32`. -// -// The JSON representation for `UInt32Value` is JSON number. -message UInt32Value { - // The uint32 value. - uint32 value = 1; -} - -// Wrapper message for `bool`. -// -// The JSON representation for `BoolValue` is JSON `true` and `false`. -message BoolValue { - // The bool value. - bool value = 1; -} - -// Wrapper message for `string`. -// -// The JSON representation for `StringValue` is JSON string. -message StringValue { - // The string value. - string value = 1; -} - -// Wrapper message for `bytes`. -// -// The JSON representation for `BytesValue` is JSON string. -message BytesValue { - // The bytes value. - bytes value = 1; -} \ No newline at end of file diff --git a/tools/data-conversion/openim/proto/sdk_ws/ws.pb.go b/tools/data-conversion/openim/proto/sdk_ws/ws.pb.go deleted file mode 100644 index 94b6f9be6..000000000 --- a/tools/data-conversion/openim/proto/sdk_ws/ws.pb.go +++ /dev/null @@ -1,6622 +0,0 @@ -// Code generated by protoc-gen-go. DO NOT EDIT. -// source: sdk_ws/ws.proto - -package server_api_params // import "Open_IM/pkg/proto/sdk_ws" - -import proto "github.com/golang/protobuf/proto" -import fmt "fmt" -import math "math" -import wrapperspb "google.golang.org/protobuf/types/known/wrapperspb" - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package - -type GroupInfo struct { - GroupID string `protobuf:"bytes,1,opt,name=groupID" json:"groupID,omitempty"` - GroupName string `protobuf:"bytes,2,opt,name=groupName" json:"groupName,omitempty"` - Notification string `protobuf:"bytes,3,opt,name=notification" json:"notification,omitempty"` - Introduction string `protobuf:"bytes,4,opt,name=introduction" json:"introduction,omitempty"` - FaceURL string `protobuf:"bytes,5,opt,name=faceURL" json:"faceURL,omitempty"` - OwnerUserID string `protobuf:"bytes,6,opt,name=ownerUserID" json:"ownerUserID,omitempty"` - CreateTime uint32 `protobuf:"varint,7,opt,name=createTime" json:"createTime,omitempty"` - MemberCount uint32 `protobuf:"varint,8,opt,name=memberCount" json:"memberCount,omitempty"` - Ex string `protobuf:"bytes,9,opt,name=ex" json:"ex,omitempty"` - Status int32 `protobuf:"varint,10,opt,name=status" json:"status,omitempty"` - CreatorUserID string `protobuf:"bytes,11,opt,name=creatorUserID" json:"creatorUserID,omitempty"` - GroupType int32 `protobuf:"varint,12,opt,name=groupType" json:"groupType,omitempty"` - NeedVerification int32 `protobuf:"varint,13,opt,name=needVerification" json:"needVerification,omitempty"` - LookMemberInfo int32 `protobuf:"varint,14,opt,name=lookMemberInfo" json:"lookMemberInfo,omitempty"` - ApplyMemberFriend int32 `protobuf:"varint,15,opt,name=applyMemberFriend" json:"applyMemberFriend,omitempty"` - NotificationUpdateTime uint32 `protobuf:"varint,16,opt,name=notificationUpdateTime" json:"notificationUpdateTime,omitempty"` - NotificationUserID string `protobuf:"bytes,17,opt,name=notificationUserID" json:"notificationUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GroupInfo) Reset() { *m = GroupInfo{} } -func (m *GroupInfo) String() string { return proto.CompactTextString(m) } -func (*GroupInfo) ProtoMessage() {} -func (*GroupInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{0} -} -func (m *GroupInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupInfo.Unmarshal(m, b) -} -func (m *GroupInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupInfo.Marshal(b, m, deterministic) -} -func (dst *GroupInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupInfo.Merge(dst, src) -} -func (m *GroupInfo) XXX_Size() int { - return xxx_messageInfo_GroupInfo.Size(m) -} -func (m *GroupInfo) XXX_DiscardUnknown() { - xxx_messageInfo_GroupInfo.DiscardUnknown(m) -} - -var xxx_messageInfo_GroupInfo proto.InternalMessageInfo - -func (m *GroupInfo) GetGroupID() string { - if m != nil { - return m.GroupID - } - return "" -} - -func (m *GroupInfo) GetGroupName() string { - if m != nil { - return m.GroupName - } - return "" -} - -func (m *GroupInfo) GetNotification() string { - if m != nil { - return m.Notification - } - return "" -} - -func (m *GroupInfo) GetIntroduction() string { - if m != nil { - return m.Introduction - } - return "" -} - -func (m *GroupInfo) GetFaceURL() string { - if m != nil { - return m.FaceURL - } - return "" -} - -func (m *GroupInfo) GetOwnerUserID() string { - if m != nil { - return m.OwnerUserID - } - return "" -} - -func (m *GroupInfo) GetCreateTime() uint32 { - if m != nil { - return m.CreateTime - } - return 0 -} - -func (m *GroupInfo) GetMemberCount() uint32 { - if m != nil { - return m.MemberCount - } - return 0 -} - -func (m *GroupInfo) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -func (m *GroupInfo) GetStatus() int32 { - if m != nil { - return m.Status - } - return 0 -} - -func (m *GroupInfo) GetCreatorUserID() string { - if m != nil { - return m.CreatorUserID - } - return "" -} - -func (m *GroupInfo) GetGroupType() int32 { - if m != nil { - return m.GroupType - } - return 0 -} - -func (m *GroupInfo) GetNeedVerification() int32 { - if m != nil { - return m.NeedVerification - } - return 0 -} - -func (m *GroupInfo) GetLookMemberInfo() int32 { - if m != nil { - return m.LookMemberInfo - } - return 0 -} - -func (m *GroupInfo) GetApplyMemberFriend() int32 { - if m != nil { - return m.ApplyMemberFriend - } - return 0 -} - -func (m *GroupInfo) GetNotificationUpdateTime() uint32 { - if m != nil { - return m.NotificationUpdateTime - } - return 0 -} - -func (m *GroupInfo) GetNotificationUserID() string { - if m != nil { - return m.NotificationUserID - } - return "" -} - -type GroupInfoForSet struct { - GroupID string `protobuf:"bytes,1,opt,name=groupID" json:"groupID,omitempty"` - GroupName string `protobuf:"bytes,2,opt,name=groupName" json:"groupName,omitempty"` - Notification string `protobuf:"bytes,3,opt,name=notification" json:"notification,omitempty"` - Introduction string `protobuf:"bytes,4,opt,name=introduction" json:"introduction,omitempty"` - FaceURL string `protobuf:"bytes,5,opt,name=faceURL" json:"faceURL,omitempty"` - Ex string `protobuf:"bytes,6,opt,name=ex" json:"ex,omitempty"` - NeedVerification *wrapperspb.Int32Value `protobuf:"bytes,7,opt,name=needVerification" json:"needVerification,omitempty"` - LookMemberInfo *wrapperspb.Int32Value `protobuf:"bytes,8,opt,name=lookMemberInfo" json:"lookMemberInfo,omitempty"` - ApplyMemberFriend *wrapperspb.Int32Value `protobuf:"bytes,9,opt,name=applyMemberFriend" json:"applyMemberFriend,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GroupInfoForSet) Reset() { *m = GroupInfoForSet{} } -func (m *GroupInfoForSet) String() string { return proto.CompactTextString(m) } -func (*GroupInfoForSet) ProtoMessage() {} -func (*GroupInfoForSet) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{1} -} -func (m *GroupInfoForSet) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupInfoForSet.Unmarshal(m, b) -} -func (m *GroupInfoForSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupInfoForSet.Marshal(b, m, deterministic) -} -func (dst *GroupInfoForSet) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupInfoForSet.Merge(dst, src) -} -func (m *GroupInfoForSet) XXX_Size() int { - return xxx_messageInfo_GroupInfoForSet.Size(m) -} -func (m *GroupInfoForSet) XXX_DiscardUnknown() { - xxx_messageInfo_GroupInfoForSet.DiscardUnknown(m) -} - -var xxx_messageInfo_GroupInfoForSet proto.InternalMessageInfo - -func (m *GroupInfoForSet) GetGroupID() string { - if m != nil { - return m.GroupID - } - return "" -} - -func (m *GroupInfoForSet) GetGroupName() string { - if m != nil { - return m.GroupName - } - return "" -} - -func (m *GroupInfoForSet) GetNotification() string { - if m != nil { - return m.Notification - } - return "" -} - -func (m *GroupInfoForSet) GetIntroduction() string { - if m != nil { - return m.Introduction - } - return "" -} - -func (m *GroupInfoForSet) GetFaceURL() string { - if m != nil { - return m.FaceURL - } - return "" -} - -func (m *GroupInfoForSet) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -func (m *GroupInfoForSet) GetNeedVerification() *wrapperspb.Int32Value { - if m != nil { - return m.NeedVerification - } - return nil -} - -func (m *GroupInfoForSet) GetLookMemberInfo() *wrapperspb.Int32Value { - if m != nil { - return m.LookMemberInfo - } - return nil -} - -func (m *GroupInfoForSet) GetApplyMemberFriend() *wrapperspb.Int32Value { - if m != nil { - return m.ApplyMemberFriend - } - return nil -} - -type GroupMemberFullInfo struct { - GroupID string `protobuf:"bytes,1,opt,name=groupID" json:"groupID,omitempty"` - UserID string `protobuf:"bytes,2,opt,name=userID" json:"userID,omitempty"` - RoleLevel int32 `protobuf:"varint,3,opt,name=roleLevel" json:"roleLevel,omitempty"` - JoinTime int32 `protobuf:"varint,4,opt,name=joinTime" json:"joinTime,omitempty"` - Nickname string `protobuf:"bytes,5,opt,name=nickname" json:"nickname,omitempty"` - FaceURL string `protobuf:"bytes,6,opt,name=faceURL" json:"faceURL,omitempty"` - AppMangerLevel int32 `protobuf:"varint,7,opt,name=appMangerLevel" json:"appMangerLevel,omitempty"` - JoinSource int32 `protobuf:"varint,8,opt,name=joinSource" json:"joinSource,omitempty"` - OperatorUserID string `protobuf:"bytes,9,opt,name=operatorUserID" json:"operatorUserID,omitempty"` - Ex string `protobuf:"bytes,10,opt,name=ex" json:"ex,omitempty"` - MuteEndTime uint32 `protobuf:"varint,11,opt,name=muteEndTime" json:"muteEndTime,omitempty"` - InviterUserID string `protobuf:"bytes,12,opt,name=inviterUserID" json:"inviterUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GroupMemberFullInfo) Reset() { *m = GroupMemberFullInfo{} } -func (m *GroupMemberFullInfo) String() string { return proto.CompactTextString(m) } -func (*GroupMemberFullInfo) ProtoMessage() {} -func (*GroupMemberFullInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{2} -} -func (m *GroupMemberFullInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupMemberFullInfo.Unmarshal(m, b) -} -func (m *GroupMemberFullInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupMemberFullInfo.Marshal(b, m, deterministic) -} -func (dst *GroupMemberFullInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupMemberFullInfo.Merge(dst, src) -} -func (m *GroupMemberFullInfo) XXX_Size() int { - return xxx_messageInfo_GroupMemberFullInfo.Size(m) -} -func (m *GroupMemberFullInfo) XXX_DiscardUnknown() { - xxx_messageInfo_GroupMemberFullInfo.DiscardUnknown(m) -} - -var xxx_messageInfo_GroupMemberFullInfo proto.InternalMessageInfo - -func (m *GroupMemberFullInfo) GetGroupID() string { - if m != nil { - return m.GroupID - } - return "" -} - -func (m *GroupMemberFullInfo) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *GroupMemberFullInfo) GetRoleLevel() int32 { - if m != nil { - return m.RoleLevel - } - return 0 -} - -func (m *GroupMemberFullInfo) GetJoinTime() int32 { - if m != nil { - return m.JoinTime - } - return 0 -} - -func (m *GroupMemberFullInfo) GetNickname() string { - if m != nil { - return m.Nickname - } - return "" -} - -func (m *GroupMemberFullInfo) GetFaceURL() string { - if m != nil { - return m.FaceURL - } - return "" -} - -func (m *GroupMemberFullInfo) GetAppMangerLevel() int32 { - if m != nil { - return m.AppMangerLevel - } - return 0 -} - -func (m *GroupMemberFullInfo) GetJoinSource() int32 { - if m != nil { - return m.JoinSource - } - return 0 -} - -func (m *GroupMemberFullInfo) GetOperatorUserID() string { - if m != nil { - return m.OperatorUserID - } - return "" -} - -func (m *GroupMemberFullInfo) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -func (m *GroupMemberFullInfo) GetMuteEndTime() uint32 { - if m != nil { - return m.MuteEndTime - } - return 0 -} - -func (m *GroupMemberFullInfo) GetInviterUserID() string { - if m != nil { - return m.InviterUserID - } - return "" -} - -type PublicUserInfo struct { - UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"` - Nickname string `protobuf:"bytes,2,opt,name=nickname" json:"nickname,omitempty"` - FaceURL string `protobuf:"bytes,3,opt,name=faceURL" json:"faceURL,omitempty"` - Gender int32 `protobuf:"varint,4,opt,name=gender" json:"gender,omitempty"` - Ex string `protobuf:"bytes,5,opt,name=ex" json:"ex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *PublicUserInfo) Reset() { *m = PublicUserInfo{} } -func (m *PublicUserInfo) String() string { return proto.CompactTextString(m) } -func (*PublicUserInfo) ProtoMessage() {} -func (*PublicUserInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{3} -} -func (m *PublicUserInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_PublicUserInfo.Unmarshal(m, b) -} -func (m *PublicUserInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_PublicUserInfo.Marshal(b, m, deterministic) -} -func (dst *PublicUserInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_PublicUserInfo.Merge(dst, src) -} -func (m *PublicUserInfo) XXX_Size() int { - return xxx_messageInfo_PublicUserInfo.Size(m) -} -func (m *PublicUserInfo) XXX_DiscardUnknown() { - xxx_messageInfo_PublicUserInfo.DiscardUnknown(m) -} - -var xxx_messageInfo_PublicUserInfo proto.InternalMessageInfo - -func (m *PublicUserInfo) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *PublicUserInfo) GetNickname() string { - if m != nil { - return m.Nickname - } - return "" -} - -func (m *PublicUserInfo) GetFaceURL() string { - if m != nil { - return m.FaceURL - } - return "" -} - -func (m *PublicUserInfo) GetGender() int32 { - if m != nil { - return m.Gender - } - return 0 -} - -func (m *PublicUserInfo) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -type UserInfo struct { - UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"` - Nickname string `protobuf:"bytes,2,opt,name=nickname" json:"nickname,omitempty"` - FaceURL string `protobuf:"bytes,3,opt,name=faceURL" json:"faceURL,omitempty"` - Gender int32 `protobuf:"varint,4,opt,name=gender" json:"gender,omitempty"` - PhoneNumber string `protobuf:"bytes,5,opt,name=phoneNumber" json:"phoneNumber,omitempty"` - Birth uint32 `protobuf:"varint,6,opt,name=birth" json:"birth,omitempty"` - Email string `protobuf:"bytes,7,opt,name=email" json:"email,omitempty"` - Ex string `protobuf:"bytes,8,opt,name=ex" json:"ex,omitempty"` - CreateTime uint32 `protobuf:"varint,9,opt,name=createTime" json:"createTime,omitempty"` - AppMangerLevel int32 `protobuf:"varint,10,opt,name=appMangerLevel" json:"appMangerLevel,omitempty"` - GlobalRecvMsgOpt int32 `protobuf:"varint,11,opt,name=globalRecvMsgOpt" json:"globalRecvMsgOpt,omitempty"` - BirthStr string `protobuf:"bytes,12,opt,name=birthStr" json:"birthStr,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *UserInfo) Reset() { *m = UserInfo{} } -func (m *UserInfo) String() string { return proto.CompactTextString(m) } -func (*UserInfo) ProtoMessage() {} -func (*UserInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{4} -} -func (m *UserInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_UserInfo.Unmarshal(m, b) -} -func (m *UserInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_UserInfo.Marshal(b, m, deterministic) -} -func (dst *UserInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_UserInfo.Merge(dst, src) -} -func (m *UserInfo) XXX_Size() int { - return xxx_messageInfo_UserInfo.Size(m) -} -func (m *UserInfo) XXX_DiscardUnknown() { - xxx_messageInfo_UserInfo.DiscardUnknown(m) -} - -var xxx_messageInfo_UserInfo proto.InternalMessageInfo - -func (m *UserInfo) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *UserInfo) GetNickname() string { - if m != nil { - return m.Nickname - } - return "" -} - -func (m *UserInfo) GetFaceURL() string { - if m != nil { - return m.FaceURL - } - return "" -} - -func (m *UserInfo) GetGender() int32 { - if m != nil { - return m.Gender - } - return 0 -} - -func (m *UserInfo) GetPhoneNumber() string { - if m != nil { - return m.PhoneNumber - } - return "" -} - -func (m *UserInfo) GetBirth() uint32 { - if m != nil { - return m.Birth - } - return 0 -} - -func (m *UserInfo) GetEmail() string { - if m != nil { - return m.Email - } - return "" -} - -func (m *UserInfo) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -func (m *UserInfo) GetCreateTime() uint32 { - if m != nil { - return m.CreateTime - } - return 0 -} - -func (m *UserInfo) GetAppMangerLevel() int32 { - if m != nil { - return m.AppMangerLevel - } - return 0 -} - -func (m *UserInfo) GetGlobalRecvMsgOpt() int32 { - if m != nil { - return m.GlobalRecvMsgOpt - } - return 0 -} - -func (m *UserInfo) GetBirthStr() string { - if m != nil { - return m.BirthStr - } - return "" -} - -type FriendInfo struct { - OwnerUserID string `protobuf:"bytes,1,opt,name=ownerUserID" json:"ownerUserID,omitempty"` - Remark string `protobuf:"bytes,2,opt,name=remark" json:"remark,omitempty"` - CreateTime uint32 `protobuf:"varint,3,opt,name=createTime" json:"createTime,omitempty"` - FriendUser *UserInfo `protobuf:"bytes,4,opt,name=friendUser" json:"friendUser,omitempty"` - AddSource int32 `protobuf:"varint,5,opt,name=addSource" json:"addSource,omitempty"` - OperatorUserID string `protobuf:"bytes,6,opt,name=operatorUserID" json:"operatorUserID,omitempty"` - Ex string `protobuf:"bytes,7,opt,name=ex" json:"ex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *FriendInfo) Reset() { *m = FriendInfo{} } -func (m *FriendInfo) String() string { return proto.CompactTextString(m) } -func (*FriendInfo) ProtoMessage() {} -func (*FriendInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{5} -} -func (m *FriendInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendInfo.Unmarshal(m, b) -} -func (m *FriendInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendInfo.Marshal(b, m, deterministic) -} -func (dst *FriendInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendInfo.Merge(dst, src) -} -func (m *FriendInfo) XXX_Size() int { - return xxx_messageInfo_FriendInfo.Size(m) -} -func (m *FriendInfo) XXX_DiscardUnknown() { - xxx_messageInfo_FriendInfo.DiscardUnknown(m) -} - -var xxx_messageInfo_FriendInfo proto.InternalMessageInfo - -func (m *FriendInfo) GetOwnerUserID() string { - if m != nil { - return m.OwnerUserID - } - return "" -} - -func (m *FriendInfo) GetRemark() string { - if m != nil { - return m.Remark - } - return "" -} - -func (m *FriendInfo) GetCreateTime() uint32 { - if m != nil { - return m.CreateTime - } - return 0 -} - -func (m *FriendInfo) GetFriendUser() *UserInfo { - if m != nil { - return m.FriendUser - } - return nil -} - -func (m *FriendInfo) GetAddSource() int32 { - if m != nil { - return m.AddSource - } - return 0 -} - -func (m *FriendInfo) GetOperatorUserID() string { - if m != nil { - return m.OperatorUserID - } - return "" -} - -func (m *FriendInfo) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -type BlackInfo struct { - OwnerUserID string `protobuf:"bytes,1,opt,name=ownerUserID" json:"ownerUserID,omitempty"` - CreateTime uint32 `protobuf:"varint,2,opt,name=createTime" json:"createTime,omitempty"` - BlackUserInfo *PublicUserInfo `protobuf:"bytes,3,opt,name=blackUserInfo" json:"blackUserInfo,omitempty"` - AddSource int32 `protobuf:"varint,4,opt,name=addSource" json:"addSource,omitempty"` - OperatorUserID string `protobuf:"bytes,5,opt,name=operatorUserID" json:"operatorUserID,omitempty"` - Ex string `protobuf:"bytes,6,opt,name=ex" json:"ex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *BlackInfo) Reset() { *m = BlackInfo{} } -func (m *BlackInfo) String() string { return proto.CompactTextString(m) } -func (*BlackInfo) ProtoMessage() {} -func (*BlackInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{6} -} -func (m *BlackInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_BlackInfo.Unmarshal(m, b) -} -func (m *BlackInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_BlackInfo.Marshal(b, m, deterministic) -} -func (dst *BlackInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_BlackInfo.Merge(dst, src) -} -func (m *BlackInfo) XXX_Size() int { - return xxx_messageInfo_BlackInfo.Size(m) -} -func (m *BlackInfo) XXX_DiscardUnknown() { - xxx_messageInfo_BlackInfo.DiscardUnknown(m) -} - -var xxx_messageInfo_BlackInfo proto.InternalMessageInfo - -func (m *BlackInfo) GetOwnerUserID() string { - if m != nil { - return m.OwnerUserID - } - return "" -} - -func (m *BlackInfo) GetCreateTime() uint32 { - if m != nil { - return m.CreateTime - } - return 0 -} - -func (m *BlackInfo) GetBlackUserInfo() *PublicUserInfo { - if m != nil { - return m.BlackUserInfo - } - return nil -} - -func (m *BlackInfo) GetAddSource() int32 { - if m != nil { - return m.AddSource - } - return 0 -} - -func (m *BlackInfo) GetOperatorUserID() string { - if m != nil { - return m.OperatorUserID - } - return "" -} - -func (m *BlackInfo) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -type GroupRequest struct { - UserInfo *PublicUserInfo `protobuf:"bytes,1,opt,name=userInfo" json:"userInfo,omitempty"` - GroupInfo *GroupInfo `protobuf:"bytes,2,opt,name=groupInfo" json:"groupInfo,omitempty"` - HandleResult int32 `protobuf:"varint,3,opt,name=handleResult" json:"handleResult,omitempty"` - ReqMsg string `protobuf:"bytes,4,opt,name=reqMsg" json:"reqMsg,omitempty"` - HandleMsg string `protobuf:"bytes,5,opt,name=handleMsg" json:"handleMsg,omitempty"` - ReqTime uint32 `protobuf:"varint,6,opt,name=reqTime" json:"reqTime,omitempty"` - HandleUserID string `protobuf:"bytes,7,opt,name=handleUserID" json:"handleUserID,omitempty"` - HandleTime uint32 `protobuf:"varint,8,opt,name=handleTime" json:"handleTime,omitempty"` - Ex string `protobuf:"bytes,9,opt,name=ex" json:"ex,omitempty"` - JoinSource int32 `protobuf:"varint,10,opt,name=joinSource" json:"joinSource,omitempty"` - InviterUserID string `protobuf:"bytes,11,opt,name=inviterUserID" json:"inviterUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GroupRequest) Reset() { *m = GroupRequest{} } -func (m *GroupRequest) String() string { return proto.CompactTextString(m) } -func (*GroupRequest) ProtoMessage() {} -func (*GroupRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{7} -} -func (m *GroupRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupRequest.Unmarshal(m, b) -} -func (m *GroupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupRequest.Marshal(b, m, deterministic) -} -func (dst *GroupRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupRequest.Merge(dst, src) -} -func (m *GroupRequest) XXX_Size() int { - return xxx_messageInfo_GroupRequest.Size(m) -} -func (m *GroupRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GroupRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GroupRequest proto.InternalMessageInfo - -func (m *GroupRequest) GetUserInfo() *PublicUserInfo { - if m != nil { - return m.UserInfo - } - return nil -} - -func (m *GroupRequest) GetGroupInfo() *GroupInfo { - if m != nil { - return m.GroupInfo - } - return nil -} - -func (m *GroupRequest) GetHandleResult() int32 { - if m != nil { - return m.HandleResult - } - return 0 -} - -func (m *GroupRequest) GetReqMsg() string { - if m != nil { - return m.ReqMsg - } - return "" -} - -func (m *GroupRequest) GetHandleMsg() string { - if m != nil { - return m.HandleMsg - } - return "" -} - -func (m *GroupRequest) GetReqTime() uint32 { - if m != nil { - return m.ReqTime - } - return 0 -} - -func (m *GroupRequest) GetHandleUserID() string { - if m != nil { - return m.HandleUserID - } - return "" -} - -func (m *GroupRequest) GetHandleTime() uint32 { - if m != nil { - return m.HandleTime - } - return 0 -} - -func (m *GroupRequest) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -func (m *GroupRequest) GetJoinSource() int32 { - if m != nil { - return m.JoinSource - } - return 0 -} - -func (m *GroupRequest) GetInviterUserID() string { - if m != nil { - return m.InviterUserID - } - return "" -} - -type FriendRequest struct { - FromUserID string `protobuf:"bytes,1,opt,name=fromUserID" json:"fromUserID,omitempty"` - FromNickname string `protobuf:"bytes,2,opt,name=fromNickname" json:"fromNickname,omitempty"` - FromFaceURL string `protobuf:"bytes,3,opt,name=fromFaceURL" json:"fromFaceURL,omitempty"` - FromGender int32 `protobuf:"varint,4,opt,name=fromGender" json:"fromGender,omitempty"` - ToUserID string `protobuf:"bytes,5,opt,name=toUserID" json:"toUserID,omitempty"` - ToNickname string `protobuf:"bytes,6,opt,name=toNickname" json:"toNickname,omitempty"` - ToFaceURL string `protobuf:"bytes,7,opt,name=toFaceURL" json:"toFaceURL,omitempty"` - ToGender int32 `protobuf:"varint,8,opt,name=toGender" json:"toGender,omitempty"` - HandleResult int32 `protobuf:"varint,9,opt,name=handleResult" json:"handleResult,omitempty"` - ReqMsg string `protobuf:"bytes,10,opt,name=reqMsg" json:"reqMsg,omitempty"` - CreateTime uint32 `protobuf:"varint,11,opt,name=createTime" json:"createTime,omitempty"` - HandlerUserID string `protobuf:"bytes,12,opt,name=handlerUserID" json:"handlerUserID,omitempty"` - HandleMsg string `protobuf:"bytes,13,opt,name=handleMsg" json:"handleMsg,omitempty"` - HandleTime uint32 `protobuf:"varint,14,opt,name=handleTime" json:"handleTime,omitempty"` - Ex string `protobuf:"bytes,15,opt,name=ex" json:"ex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *FriendRequest) Reset() { *m = FriendRequest{} } -func (m *FriendRequest) String() string { return proto.CompactTextString(m) } -func (*FriendRequest) ProtoMessage() {} -func (*FriendRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{8} -} -func (m *FriendRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendRequest.Unmarshal(m, b) -} -func (m *FriendRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendRequest.Marshal(b, m, deterministic) -} -func (dst *FriendRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendRequest.Merge(dst, src) -} -func (m *FriendRequest) XXX_Size() int { - return xxx_messageInfo_FriendRequest.Size(m) -} -func (m *FriendRequest) XXX_DiscardUnknown() { - xxx_messageInfo_FriendRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_FriendRequest proto.InternalMessageInfo - -func (m *FriendRequest) GetFromUserID() string { - if m != nil { - return m.FromUserID - } - return "" -} - -func (m *FriendRequest) GetFromNickname() string { - if m != nil { - return m.FromNickname - } - return "" -} - -func (m *FriendRequest) GetFromFaceURL() string { - if m != nil { - return m.FromFaceURL - } - return "" -} - -func (m *FriendRequest) GetFromGender() int32 { - if m != nil { - return m.FromGender - } - return 0 -} - -func (m *FriendRequest) GetToUserID() string { - if m != nil { - return m.ToUserID - } - return "" -} - -func (m *FriendRequest) GetToNickname() string { - if m != nil { - return m.ToNickname - } - return "" -} - -func (m *FriendRequest) GetToFaceURL() string { - if m != nil { - return m.ToFaceURL - } - return "" -} - -func (m *FriendRequest) GetToGender() int32 { - if m != nil { - return m.ToGender - } - return 0 -} - -func (m *FriendRequest) GetHandleResult() int32 { - if m != nil { - return m.HandleResult - } - return 0 -} - -func (m *FriendRequest) GetReqMsg() string { - if m != nil { - return m.ReqMsg - } - return "" -} - -func (m *FriendRequest) GetCreateTime() uint32 { - if m != nil { - return m.CreateTime - } - return 0 -} - -func (m *FriendRequest) GetHandlerUserID() string { - if m != nil { - return m.HandlerUserID - } - return "" -} - -func (m *FriendRequest) GetHandleMsg() string { - if m != nil { - return m.HandleMsg - } - return "" -} - -func (m *FriendRequest) GetHandleTime() uint32 { - if m != nil { - return m.HandleTime - } - return 0 -} - -func (m *FriendRequest) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -type Department struct { - DepartmentID string `protobuf:"bytes,1,opt,name=departmentID" json:"departmentID,omitempty"` - FaceURL string `protobuf:"bytes,2,opt,name=faceURL" json:"faceURL,omitempty"` - Name string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"` - ParentID string `protobuf:"bytes,4,opt,name=parentID" json:"parentID,omitempty"` - Order int32 `protobuf:"varint,5,opt,name=order" json:"order,omitempty"` - DepartmentType int32 `protobuf:"varint,6,opt,name=departmentType" json:"departmentType,omitempty"` - CreateTime uint32 `protobuf:"varint,7,opt,name=createTime" json:"createTime,omitempty"` - SubDepartmentNum uint32 `protobuf:"varint,8,opt,name=subDepartmentNum" json:"subDepartmentNum,omitempty"` - MemberNum uint32 `protobuf:"varint,9,opt,name=memberNum" json:"memberNum,omitempty"` - Ex string `protobuf:"bytes,10,opt,name=ex" json:"ex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *Department) Reset() { *m = Department{} } -func (m *Department) String() string { return proto.CompactTextString(m) } -func (*Department) ProtoMessage() {} -func (*Department) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{9} -} -func (m *Department) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_Department.Unmarshal(m, b) -} -func (m *Department) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_Department.Marshal(b, m, deterministic) -} -func (dst *Department) XXX_Merge(src proto.Message) { - xxx_messageInfo_Department.Merge(dst, src) -} -func (m *Department) XXX_Size() int { - return xxx_messageInfo_Department.Size(m) -} -func (m *Department) XXX_DiscardUnknown() { - xxx_messageInfo_Department.DiscardUnknown(m) -} - -var xxx_messageInfo_Department proto.InternalMessageInfo - -func (m *Department) GetDepartmentID() string { - if m != nil { - return m.DepartmentID - } - return "" -} - -func (m *Department) GetFaceURL() string { - if m != nil { - return m.FaceURL - } - return "" -} - -func (m *Department) GetName() string { - if m != nil { - return m.Name - } - return "" -} - -func (m *Department) GetParentID() string { - if m != nil { - return m.ParentID - } - return "" -} - -func (m *Department) GetOrder() int32 { - if m != nil { - return m.Order - } - return 0 -} - -func (m *Department) GetDepartmentType() int32 { - if m != nil { - return m.DepartmentType - } - return 0 -} - -func (m *Department) GetCreateTime() uint32 { - if m != nil { - return m.CreateTime - } - return 0 -} - -func (m *Department) GetSubDepartmentNum() uint32 { - if m != nil { - return m.SubDepartmentNum - } - return 0 -} - -func (m *Department) GetMemberNum() uint32 { - if m != nil { - return m.MemberNum - } - return 0 -} - -func (m *Department) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -type OrganizationUser struct { - UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"` - Nickname string `protobuf:"bytes,2,opt,name=nickname" json:"nickname,omitempty"` - EnglishName string `protobuf:"bytes,3,opt,name=englishName" json:"englishName,omitempty"` - FaceURL string `protobuf:"bytes,4,opt,name=faceURL" json:"faceURL,omitempty"` - Gender int32 `protobuf:"varint,5,opt,name=gender" json:"gender,omitempty"` - Mobile string `protobuf:"bytes,6,opt,name=mobile" json:"mobile,omitempty"` - Telephone string `protobuf:"bytes,7,opt,name=telephone" json:"telephone,omitempty"` - Birth uint32 `protobuf:"varint,8,opt,name=birth" json:"birth,omitempty"` - Email string `protobuf:"bytes,9,opt,name=email" json:"email,omitempty"` - CreateTime uint32 `protobuf:"varint,10,opt,name=createTime" json:"createTime,omitempty"` - Ex string `protobuf:"bytes,11,opt,name=ex" json:"ex,omitempty"` - BirthStr string `protobuf:"bytes,12,opt,name=birthStr" json:"birthStr,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *OrganizationUser) Reset() { *m = OrganizationUser{} } -func (m *OrganizationUser) String() string { return proto.CompactTextString(m) } -func (*OrganizationUser) ProtoMessage() {} -func (*OrganizationUser) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{10} -} -func (m *OrganizationUser) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_OrganizationUser.Unmarshal(m, b) -} -func (m *OrganizationUser) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_OrganizationUser.Marshal(b, m, deterministic) -} -func (dst *OrganizationUser) XXX_Merge(src proto.Message) { - xxx_messageInfo_OrganizationUser.Merge(dst, src) -} -func (m *OrganizationUser) XXX_Size() int { - return xxx_messageInfo_OrganizationUser.Size(m) -} -func (m *OrganizationUser) XXX_DiscardUnknown() { - xxx_messageInfo_OrganizationUser.DiscardUnknown(m) -} - -var xxx_messageInfo_OrganizationUser proto.InternalMessageInfo - -func (m *OrganizationUser) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *OrganizationUser) GetNickname() string { - if m != nil { - return m.Nickname - } - return "" -} - -func (m *OrganizationUser) GetEnglishName() string { - if m != nil { - return m.EnglishName - } - return "" -} - -func (m *OrganizationUser) GetFaceURL() string { - if m != nil { - return m.FaceURL - } - return "" -} - -func (m *OrganizationUser) GetGender() int32 { - if m != nil { - return m.Gender - } - return 0 -} - -func (m *OrganizationUser) GetMobile() string { - if m != nil { - return m.Mobile - } - return "" -} - -func (m *OrganizationUser) GetTelephone() string { - if m != nil { - return m.Telephone - } - return "" -} - -func (m *OrganizationUser) GetBirth() uint32 { - if m != nil { - return m.Birth - } - return 0 -} - -func (m *OrganizationUser) GetEmail() string { - if m != nil { - return m.Email - } - return "" -} - -func (m *OrganizationUser) GetCreateTime() uint32 { - if m != nil { - return m.CreateTime - } - return 0 -} - -func (m *OrganizationUser) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -func (m *OrganizationUser) GetBirthStr() string { - if m != nil { - return m.BirthStr - } - return "" -} - -type DepartmentMember struct { - UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"` - DepartmentID string `protobuf:"bytes,2,opt,name=departmentID" json:"departmentID,omitempty"` - Order int32 `protobuf:"varint,3,opt,name=order" json:"order,omitempty"` - Position string `protobuf:"bytes,4,opt,name=position" json:"position,omitempty"` - Leader int32 `protobuf:"varint,5,opt,name=leader" json:"leader,omitempty"` - Status int32 `protobuf:"varint,6,opt,name=status" json:"status,omitempty"` - Ex string `protobuf:"bytes,7,opt,name=ex" json:"ex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *DepartmentMember) Reset() { *m = DepartmentMember{} } -func (m *DepartmentMember) String() string { return proto.CompactTextString(m) } -func (*DepartmentMember) ProtoMessage() {} -func (*DepartmentMember) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{11} -} -func (m *DepartmentMember) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_DepartmentMember.Unmarshal(m, b) -} -func (m *DepartmentMember) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_DepartmentMember.Marshal(b, m, deterministic) -} -func (dst *DepartmentMember) XXX_Merge(src proto.Message) { - xxx_messageInfo_DepartmentMember.Merge(dst, src) -} -func (m *DepartmentMember) XXX_Size() int { - return xxx_messageInfo_DepartmentMember.Size(m) -} -func (m *DepartmentMember) XXX_DiscardUnknown() { - xxx_messageInfo_DepartmentMember.DiscardUnknown(m) -} - -var xxx_messageInfo_DepartmentMember proto.InternalMessageInfo - -func (m *DepartmentMember) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *DepartmentMember) GetDepartmentID() string { - if m != nil { - return m.DepartmentID - } - return "" -} - -func (m *DepartmentMember) GetOrder() int32 { - if m != nil { - return m.Order - } - return 0 -} - -func (m *DepartmentMember) GetPosition() string { - if m != nil { - return m.Position - } - return "" -} - -func (m *DepartmentMember) GetLeader() int32 { - if m != nil { - return m.Leader - } - return 0 -} - -func (m *DepartmentMember) GetStatus() int32 { - if m != nil { - return m.Status - } - return 0 -} - -func (m *DepartmentMember) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -type UserDepartmentMember struct { - OrganizationUser *OrganizationUser `protobuf:"bytes,1,opt,name=organizationUser" json:"organizationUser,omitempty"` - DepartmentMember *DepartmentMember `protobuf:"bytes,2,opt,name=departmentMember" json:"departmentMember,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *UserDepartmentMember) Reset() { *m = UserDepartmentMember{} } -func (m *UserDepartmentMember) String() string { return proto.CompactTextString(m) } -func (*UserDepartmentMember) ProtoMessage() {} -func (*UserDepartmentMember) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{12} -} -func (m *UserDepartmentMember) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_UserDepartmentMember.Unmarshal(m, b) -} -func (m *UserDepartmentMember) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_UserDepartmentMember.Marshal(b, m, deterministic) -} -func (dst *UserDepartmentMember) XXX_Merge(src proto.Message) { - xxx_messageInfo_UserDepartmentMember.Merge(dst, src) -} -func (m *UserDepartmentMember) XXX_Size() int { - return xxx_messageInfo_UserDepartmentMember.Size(m) -} -func (m *UserDepartmentMember) XXX_DiscardUnknown() { - xxx_messageInfo_UserDepartmentMember.DiscardUnknown(m) -} - -var xxx_messageInfo_UserDepartmentMember proto.InternalMessageInfo - -func (m *UserDepartmentMember) GetOrganizationUser() *OrganizationUser { - if m != nil { - return m.OrganizationUser - } - return nil -} - -func (m *UserDepartmentMember) GetDepartmentMember() *DepartmentMember { - if m != nil { - return m.DepartmentMember - } - return nil -} - -type UserInDepartment struct { - OrganizationUser *OrganizationUser `protobuf:"bytes,1,opt,name=organizationUser" json:"organizationUser,omitempty"` - DepartmentMemberList []*DepartmentMember `protobuf:"bytes,2,rep,name=departmentMemberList" json:"departmentMemberList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *UserInDepartment) Reset() { *m = UserInDepartment{} } -func (m *UserInDepartment) String() string { return proto.CompactTextString(m) } -func (*UserInDepartment) ProtoMessage() {} -func (*UserInDepartment) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{13} -} -func (m *UserInDepartment) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_UserInDepartment.Unmarshal(m, b) -} -func (m *UserInDepartment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_UserInDepartment.Marshal(b, m, deterministic) -} -func (dst *UserInDepartment) XXX_Merge(src proto.Message) { - xxx_messageInfo_UserInDepartment.Merge(dst, src) -} -func (m *UserInDepartment) XXX_Size() int { - return xxx_messageInfo_UserInDepartment.Size(m) -} -func (m *UserInDepartment) XXX_DiscardUnknown() { - xxx_messageInfo_UserInDepartment.DiscardUnknown(m) -} - -var xxx_messageInfo_UserInDepartment proto.InternalMessageInfo - -func (m *UserInDepartment) GetOrganizationUser() *OrganizationUser { - if m != nil { - return m.OrganizationUser - } - return nil -} - -func (m *UserInDepartment) GetDepartmentMemberList() []*DepartmentMember { - if m != nil { - return m.DepartmentMemberList - } - return nil -} - -// /////////////////////////////////base end///////////////////////////////////// -type PullMessageBySeqListReq struct { - UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"` - OperationID string `protobuf:"bytes,2,opt,name=operationID" json:"operationID,omitempty"` - SeqList []uint32 `protobuf:"varint,3,rep,packed,name=seqList" json:"seqList,omitempty"` - GroupSeqList map[string]*SeqList `protobuf:"bytes,4,rep,name=groupSeqList" json:"groupSeqList,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *PullMessageBySeqListReq) Reset() { *m = PullMessageBySeqListReq{} } -func (m *PullMessageBySeqListReq) String() string { return proto.CompactTextString(m) } -func (*PullMessageBySeqListReq) ProtoMessage() {} -func (*PullMessageBySeqListReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{14} -} -func (m *PullMessageBySeqListReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_PullMessageBySeqListReq.Unmarshal(m, b) -} -func (m *PullMessageBySeqListReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_PullMessageBySeqListReq.Marshal(b, m, deterministic) -} -func (dst *PullMessageBySeqListReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_PullMessageBySeqListReq.Merge(dst, src) -} -func (m *PullMessageBySeqListReq) XXX_Size() int { - return xxx_messageInfo_PullMessageBySeqListReq.Size(m) -} -func (m *PullMessageBySeqListReq) XXX_DiscardUnknown() { - xxx_messageInfo_PullMessageBySeqListReq.DiscardUnknown(m) -} - -var xxx_messageInfo_PullMessageBySeqListReq proto.InternalMessageInfo - -func (m *PullMessageBySeqListReq) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *PullMessageBySeqListReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -func (m *PullMessageBySeqListReq) GetSeqList() []uint32 { - if m != nil { - return m.SeqList - } - return nil -} - -func (m *PullMessageBySeqListReq) GetGroupSeqList() map[string]*SeqList { - if m != nil { - return m.GroupSeqList - } - return nil -} - -type SeqList struct { - SeqList []uint32 `protobuf:"varint,1,rep,packed,name=seqList" json:"seqList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SeqList) Reset() { *m = SeqList{} } -func (m *SeqList) String() string { return proto.CompactTextString(m) } -func (*SeqList) ProtoMessage() {} -func (*SeqList) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{15} -} -func (m *SeqList) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SeqList.Unmarshal(m, b) -} -func (m *SeqList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SeqList.Marshal(b, m, deterministic) -} -func (dst *SeqList) XXX_Merge(src proto.Message) { - xxx_messageInfo_SeqList.Merge(dst, src) -} -func (m *SeqList) XXX_Size() int { - return xxx_messageInfo_SeqList.Size(m) -} -func (m *SeqList) XXX_DiscardUnknown() { - xxx_messageInfo_SeqList.DiscardUnknown(m) -} - -var xxx_messageInfo_SeqList proto.InternalMessageInfo - -func (m *SeqList) GetSeqList() []uint32 { - if m != nil { - return m.SeqList - } - return nil -} - -type MsgDataList struct { - MsgDataList []*MsgData `protobuf:"bytes,1,rep,name=msgDataList" json:"msgDataList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *MsgDataList) Reset() { *m = MsgDataList{} } -func (m *MsgDataList) String() string { return proto.CompactTextString(m) } -func (*MsgDataList) ProtoMessage() {} -func (*MsgDataList) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{16} -} -func (m *MsgDataList) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MsgDataList.Unmarshal(m, b) -} -func (m *MsgDataList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MsgDataList.Marshal(b, m, deterministic) -} -func (dst *MsgDataList) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgDataList.Merge(dst, src) -} -func (m *MsgDataList) XXX_Size() int { - return xxx_messageInfo_MsgDataList.Size(m) -} -func (m *MsgDataList) XXX_DiscardUnknown() { - xxx_messageInfo_MsgDataList.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgDataList proto.InternalMessageInfo - -func (m *MsgDataList) GetMsgDataList() []*MsgData { - if m != nil { - return m.MsgDataList - } - return nil -} - -type PullMessageBySeqListResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - List []*MsgData `protobuf:"bytes,3,rep,name=list" json:"list,omitempty"` - GroupMsgDataList map[string]*MsgDataList `protobuf:"bytes,4,rep,name=groupMsgDataList" json:"groupMsgDataList,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *PullMessageBySeqListResp) Reset() { *m = PullMessageBySeqListResp{} } -func (m *PullMessageBySeqListResp) String() string { return proto.CompactTextString(m) } -func (*PullMessageBySeqListResp) ProtoMessage() {} -func (*PullMessageBySeqListResp) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{17} -} -func (m *PullMessageBySeqListResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_PullMessageBySeqListResp.Unmarshal(m, b) -} -func (m *PullMessageBySeqListResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_PullMessageBySeqListResp.Marshal(b, m, deterministic) -} -func (dst *PullMessageBySeqListResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_PullMessageBySeqListResp.Merge(dst, src) -} -func (m *PullMessageBySeqListResp) XXX_Size() int { - return xxx_messageInfo_PullMessageBySeqListResp.Size(m) -} -func (m *PullMessageBySeqListResp) XXX_DiscardUnknown() { - xxx_messageInfo_PullMessageBySeqListResp.DiscardUnknown(m) -} - -var xxx_messageInfo_PullMessageBySeqListResp proto.InternalMessageInfo - -func (m *PullMessageBySeqListResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *PullMessageBySeqListResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -func (m *PullMessageBySeqListResp) GetList() []*MsgData { - if m != nil { - return m.List - } - return nil -} - -func (m *PullMessageBySeqListResp) GetGroupMsgDataList() map[string]*MsgDataList { - if m != nil { - return m.GroupMsgDataList - } - return nil -} - -type GetMaxAndMinSeqReq struct { - GroupIDList []string `protobuf:"bytes,1,rep,name=groupIDList" json:"groupIDList,omitempty"` - UserID string `protobuf:"bytes,2,opt,name=userID" json:"userID,omitempty"` - OperationID string `protobuf:"bytes,3,opt,name=operationID" json:"operationID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GetMaxAndMinSeqReq) Reset() { *m = GetMaxAndMinSeqReq{} } -func (m *GetMaxAndMinSeqReq) String() string { return proto.CompactTextString(m) } -func (*GetMaxAndMinSeqReq) ProtoMessage() {} -func (*GetMaxAndMinSeqReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{18} -} -func (m *GetMaxAndMinSeqReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetMaxAndMinSeqReq.Unmarshal(m, b) -} -func (m *GetMaxAndMinSeqReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetMaxAndMinSeqReq.Marshal(b, m, deterministic) -} -func (dst *GetMaxAndMinSeqReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetMaxAndMinSeqReq.Merge(dst, src) -} -func (m *GetMaxAndMinSeqReq) XXX_Size() int { - return xxx_messageInfo_GetMaxAndMinSeqReq.Size(m) -} -func (m *GetMaxAndMinSeqReq) XXX_DiscardUnknown() { - xxx_messageInfo_GetMaxAndMinSeqReq.DiscardUnknown(m) -} - -var xxx_messageInfo_GetMaxAndMinSeqReq proto.InternalMessageInfo - -func (m *GetMaxAndMinSeqReq) GetGroupIDList() []string { - if m != nil { - return m.GroupIDList - } - return nil -} - -func (m *GetMaxAndMinSeqReq) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *GetMaxAndMinSeqReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -type MaxAndMinSeq struct { - MaxSeq uint32 `protobuf:"varint,1,opt,name=maxSeq" json:"maxSeq,omitempty"` - MinSeq uint32 `protobuf:"varint,2,opt,name=minSeq" json:"minSeq,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *MaxAndMinSeq) Reset() { *m = MaxAndMinSeq{} } -func (m *MaxAndMinSeq) String() string { return proto.CompactTextString(m) } -func (*MaxAndMinSeq) ProtoMessage() {} -func (*MaxAndMinSeq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{19} -} -func (m *MaxAndMinSeq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MaxAndMinSeq.Unmarshal(m, b) -} -func (m *MaxAndMinSeq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MaxAndMinSeq.Marshal(b, m, deterministic) -} -func (dst *MaxAndMinSeq) XXX_Merge(src proto.Message) { - xxx_messageInfo_MaxAndMinSeq.Merge(dst, src) -} -func (m *MaxAndMinSeq) XXX_Size() int { - return xxx_messageInfo_MaxAndMinSeq.Size(m) -} -func (m *MaxAndMinSeq) XXX_DiscardUnknown() { - xxx_messageInfo_MaxAndMinSeq.DiscardUnknown(m) -} - -var xxx_messageInfo_MaxAndMinSeq proto.InternalMessageInfo - -func (m *MaxAndMinSeq) GetMaxSeq() uint32 { - if m != nil { - return m.MaxSeq - } - return 0 -} - -func (m *MaxAndMinSeq) GetMinSeq() uint32 { - if m != nil { - return m.MinSeq - } - return 0 -} - -type GetMaxAndMinSeqResp struct { - MaxSeq uint32 `protobuf:"varint,1,opt,name=maxSeq" json:"maxSeq,omitempty"` - MinSeq uint32 `protobuf:"varint,2,opt,name=minSeq" json:"minSeq,omitempty"` - ErrCode int32 `protobuf:"varint,3,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,4,opt,name=errMsg" json:"errMsg,omitempty"` - GroupMaxAndMinSeq map[string]*MaxAndMinSeq `protobuf:"bytes,5,rep,name=groupMaxAndMinSeq" json:"groupMaxAndMinSeq,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GetMaxAndMinSeqResp) Reset() { *m = GetMaxAndMinSeqResp{} } -func (m *GetMaxAndMinSeqResp) String() string { return proto.CompactTextString(m) } -func (*GetMaxAndMinSeqResp) ProtoMessage() {} -func (*GetMaxAndMinSeqResp) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{20} -} -func (m *GetMaxAndMinSeqResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetMaxAndMinSeqResp.Unmarshal(m, b) -} -func (m *GetMaxAndMinSeqResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetMaxAndMinSeqResp.Marshal(b, m, deterministic) -} -func (dst *GetMaxAndMinSeqResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetMaxAndMinSeqResp.Merge(dst, src) -} -func (m *GetMaxAndMinSeqResp) XXX_Size() int { - return xxx_messageInfo_GetMaxAndMinSeqResp.Size(m) -} -func (m *GetMaxAndMinSeqResp) XXX_DiscardUnknown() { - xxx_messageInfo_GetMaxAndMinSeqResp.DiscardUnknown(m) -} - -var xxx_messageInfo_GetMaxAndMinSeqResp proto.InternalMessageInfo - -func (m *GetMaxAndMinSeqResp) GetMaxSeq() uint32 { - if m != nil { - return m.MaxSeq - } - return 0 -} - -func (m *GetMaxAndMinSeqResp) GetMinSeq() uint32 { - if m != nil { - return m.MinSeq - } - return 0 -} - -func (m *GetMaxAndMinSeqResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *GetMaxAndMinSeqResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -func (m *GetMaxAndMinSeqResp) GetGroupMaxAndMinSeq() map[string]*MaxAndMinSeq { - if m != nil { - return m.GroupMaxAndMinSeq - } - return nil -} - -type UserSendMsgResp struct { - ServerMsgID string `protobuf:"bytes,1,opt,name=serverMsgID" json:"serverMsgID,omitempty"` - ClientMsgID string `protobuf:"bytes,2,opt,name=clientMsgID" json:"clientMsgID,omitempty"` - SendTime int64 `protobuf:"varint,3,opt,name=sendTime" json:"sendTime,omitempty"` - Ex string `protobuf:"bytes,4,opt,name=ex" json:"ex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *UserSendMsgResp) Reset() { *m = UserSendMsgResp{} } -func (m *UserSendMsgResp) String() string { return proto.CompactTextString(m) } -func (*UserSendMsgResp) ProtoMessage() {} -func (*UserSendMsgResp) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{21} -} -func (m *UserSendMsgResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_UserSendMsgResp.Unmarshal(m, b) -} -func (m *UserSendMsgResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_UserSendMsgResp.Marshal(b, m, deterministic) -} -func (dst *UserSendMsgResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_UserSendMsgResp.Merge(dst, src) -} -func (m *UserSendMsgResp) XXX_Size() int { - return xxx_messageInfo_UserSendMsgResp.Size(m) -} -func (m *UserSendMsgResp) XXX_DiscardUnknown() { - xxx_messageInfo_UserSendMsgResp.DiscardUnknown(m) -} - -var xxx_messageInfo_UserSendMsgResp proto.InternalMessageInfo - -func (m *UserSendMsgResp) GetServerMsgID() string { - if m != nil { - return m.ServerMsgID - } - return "" -} - -func (m *UserSendMsgResp) GetClientMsgID() string { - if m != nil { - return m.ClientMsgID - } - return "" -} - -func (m *UserSendMsgResp) GetSendTime() int64 { - if m != nil { - return m.SendTime - } - return 0 -} - -func (m *UserSendMsgResp) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -type MsgData struct { - SendID string `protobuf:"bytes,1,opt,name=sendID" json:"sendID,omitempty"` - RecvID string `protobuf:"bytes,2,opt,name=recvID" json:"recvID,omitempty"` - GroupID string `protobuf:"bytes,3,opt,name=groupID" json:"groupID,omitempty"` - ClientMsgID string `protobuf:"bytes,4,opt,name=clientMsgID" json:"clientMsgID,omitempty"` - ServerMsgID string `protobuf:"bytes,5,opt,name=serverMsgID" json:"serverMsgID,omitempty"` - SenderPlatformID int32 `protobuf:"varint,6,opt,name=senderPlatformID" json:"senderPlatformID,omitempty"` - SenderNickname string `protobuf:"bytes,7,opt,name=senderNickname" json:"senderNickname,omitempty"` - SenderFaceURL string `protobuf:"bytes,8,opt,name=senderFaceURL" json:"senderFaceURL,omitempty"` - SessionType int32 `protobuf:"varint,9,opt,name=sessionType" json:"sessionType,omitempty"` - MsgFrom int32 `protobuf:"varint,10,opt,name=msgFrom" json:"msgFrom,omitempty"` - ContentType int32 `protobuf:"varint,11,opt,name=contentType" json:"contentType,omitempty"` - Content []byte `protobuf:"bytes,12,opt,name=content,proto3" json:"content,omitempty"` - Seq uint32 `protobuf:"varint,14,opt,name=seq" json:"seq,omitempty"` - SendTime int64 `protobuf:"varint,15,opt,name=sendTime" json:"sendTime,omitempty"` - CreateTime int64 `protobuf:"varint,16,opt,name=createTime" json:"createTime,omitempty"` - Status int32 `protobuf:"varint,17,opt,name=status" json:"status,omitempty"` - Options map[string]bool `protobuf:"bytes,18,rep,name=options" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` - OfflinePushInfo *OfflinePushInfo `protobuf:"bytes,19,opt,name=offlinePushInfo" json:"offlinePushInfo,omitempty"` - AtUserIDList []string `protobuf:"bytes,20,rep,name=atUserIDList" json:"atUserIDList,omitempty"` - MsgDataList []byte `protobuf:"bytes,21,opt,name=msgDataList,proto3" json:"msgDataList,omitempty"` - AttachedInfo string `protobuf:"bytes,22,opt,name=attachedInfo" json:"attachedInfo,omitempty"` - Ex string `protobuf:"bytes,23,opt,name=ex" json:"ex,omitempty"` - IsReact bool `protobuf:"varint,40,opt,name=isReact" json:"isReact,omitempty"` - IsExternalExtensions bool `protobuf:"varint,41,opt,name=isExternalExtensions" json:"isExternalExtensions,omitempty"` - MsgFirstModifyTime int64 `protobuf:"varint,42,opt,name=msgFirstModifyTime" json:"msgFirstModifyTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *MsgData) Reset() { *m = MsgData{} } -func (m *MsgData) String() string { return proto.CompactTextString(m) } -func (*MsgData) ProtoMessage() {} -func (*MsgData) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{22} -} -func (m *MsgData) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MsgData.Unmarshal(m, b) -} -func (m *MsgData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MsgData.Marshal(b, m, deterministic) -} -func (dst *MsgData) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgData.Merge(dst, src) -} -func (m *MsgData) XXX_Size() int { - return xxx_messageInfo_MsgData.Size(m) -} -func (m *MsgData) XXX_DiscardUnknown() { - xxx_messageInfo_MsgData.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgData proto.InternalMessageInfo - -func (m *MsgData) GetSendID() string { - if m != nil { - return m.SendID - } - return "" -} - -func (m *MsgData) GetRecvID() string { - if m != nil { - return m.RecvID - } - return "" -} - -func (m *MsgData) GetGroupID() string { - if m != nil { - return m.GroupID - } - return "" -} - -func (m *MsgData) GetClientMsgID() string { - if m != nil { - return m.ClientMsgID - } - return "" -} - -func (m *MsgData) GetServerMsgID() string { - if m != nil { - return m.ServerMsgID - } - return "" -} - -func (m *MsgData) GetSenderPlatformID() int32 { - if m != nil { - return m.SenderPlatformID - } - return 0 -} - -func (m *MsgData) GetSenderNickname() string { - if m != nil { - return m.SenderNickname - } - return "" -} - -func (m *MsgData) GetSenderFaceURL() string { - if m != nil { - return m.SenderFaceURL - } - return "" -} - -func (m *MsgData) GetSessionType() int32 { - if m != nil { - return m.SessionType - } - return 0 -} - -func (m *MsgData) GetMsgFrom() int32 { - if m != nil { - return m.MsgFrom - } - return 0 -} - -func (m *MsgData) GetContentType() int32 { - if m != nil { - return m.ContentType - } - return 0 -} - -func (m *MsgData) GetContent() []byte { - if m != nil { - return m.Content - } - return nil -} - -func (m *MsgData) GetSeq() uint32 { - if m != nil { - return m.Seq - } - return 0 -} - -func (m *MsgData) GetSendTime() int64 { - if m != nil { - return m.SendTime - } - return 0 -} - -func (m *MsgData) GetCreateTime() int64 { - if m != nil { - return m.CreateTime - } - return 0 -} - -func (m *MsgData) GetStatus() int32 { - if m != nil { - return m.Status - } - return 0 -} - -func (m *MsgData) GetOptions() map[string]bool { - if m != nil { - return m.Options - } - return nil -} - -func (m *MsgData) GetOfflinePushInfo() *OfflinePushInfo { - if m != nil { - return m.OfflinePushInfo - } - return nil -} - -func (m *MsgData) GetAtUserIDList() []string { - if m != nil { - return m.AtUserIDList - } - return nil -} - -func (m *MsgData) GetMsgDataList() []byte { - if m != nil { - return m.MsgDataList - } - return nil -} - -func (m *MsgData) GetAttachedInfo() string { - if m != nil { - return m.AttachedInfo - } - return "" -} - -func (m *MsgData) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -func (m *MsgData) GetIsReact() bool { - if m != nil { - return m.IsReact - } - return false -} - -func (m *MsgData) GetIsExternalExtensions() bool { - if m != nil { - return m.IsExternalExtensions - } - return false -} - -func (m *MsgData) GetMsgFirstModifyTime() int64 { - if m != nil { - return m.MsgFirstModifyTime - } - return 0 -} - -type OfflinePushInfo struct { - Title string `protobuf:"bytes,1,opt,name=title" json:"title,omitempty"` - Desc string `protobuf:"bytes,2,opt,name=desc" json:"desc,omitempty"` - Ex string `protobuf:"bytes,3,opt,name=ex" json:"ex,omitempty"` - IOSPushSound string `protobuf:"bytes,4,opt,name=iOSPushSound" json:"iOSPushSound,omitempty"` - IOSBadgeCount bool `protobuf:"varint,5,opt,name=iOSBadgeCount" json:"iOSBadgeCount,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *OfflinePushInfo) Reset() { *m = OfflinePushInfo{} } -func (m *OfflinePushInfo) String() string { return proto.CompactTextString(m) } -func (*OfflinePushInfo) ProtoMessage() {} -func (*OfflinePushInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{23} -} -func (m *OfflinePushInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_OfflinePushInfo.Unmarshal(m, b) -} -func (m *OfflinePushInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_OfflinePushInfo.Marshal(b, m, deterministic) -} -func (dst *OfflinePushInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_OfflinePushInfo.Merge(dst, src) -} -func (m *OfflinePushInfo) XXX_Size() int { - return xxx_messageInfo_OfflinePushInfo.Size(m) -} -func (m *OfflinePushInfo) XXX_DiscardUnknown() { - xxx_messageInfo_OfflinePushInfo.DiscardUnknown(m) -} - -var xxx_messageInfo_OfflinePushInfo proto.InternalMessageInfo - -func (m *OfflinePushInfo) GetTitle() string { - if m != nil { - return m.Title - } - return "" -} - -func (m *OfflinePushInfo) GetDesc() string { - if m != nil { - return m.Desc - } - return "" -} - -func (m *OfflinePushInfo) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -func (m *OfflinePushInfo) GetIOSPushSound() string { - if m != nil { - return m.IOSPushSound - } - return "" -} - -func (m *OfflinePushInfo) GetIOSBadgeCount() bool { - if m != nil { - return m.IOSBadgeCount - } - return false -} - -type TipsComm struct { - Detail []byte `protobuf:"bytes,1,opt,name=detail,proto3" json:"detail,omitempty"` - DefaultTips string `protobuf:"bytes,2,opt,name=defaultTips" json:"defaultTips,omitempty"` - JsonDetail string `protobuf:"bytes,3,opt,name=jsonDetail" json:"jsonDetail,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *TipsComm) Reset() { *m = TipsComm{} } -func (m *TipsComm) String() string { return proto.CompactTextString(m) } -func (*TipsComm) ProtoMessage() {} -func (*TipsComm) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{24} -} -func (m *TipsComm) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_TipsComm.Unmarshal(m, b) -} -func (m *TipsComm) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_TipsComm.Marshal(b, m, deterministic) -} -func (dst *TipsComm) XXX_Merge(src proto.Message) { - xxx_messageInfo_TipsComm.Merge(dst, src) -} -func (m *TipsComm) XXX_Size() int { - return xxx_messageInfo_TipsComm.Size(m) -} -func (m *TipsComm) XXX_DiscardUnknown() { - xxx_messageInfo_TipsComm.DiscardUnknown(m) -} - -var xxx_messageInfo_TipsComm proto.InternalMessageInfo - -func (m *TipsComm) GetDetail() []byte { - if m != nil { - return m.Detail - } - return nil -} - -func (m *TipsComm) GetDefaultTips() string { - if m != nil { - return m.DefaultTips - } - return "" -} - -func (m *TipsComm) GetJsonDetail() string { - if m != nil { - return m.JsonDetail - } - return "" -} - -// OnGroupCreated() -type GroupCreatedTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - MemberList []*GroupMemberFullInfo `protobuf:"bytes,3,rep,name=memberList" json:"memberList,omitempty"` - OperationTime int64 `protobuf:"varint,4,opt,name=operationTime" json:"operationTime,omitempty"` - GroupOwnerUser *GroupMemberFullInfo `protobuf:"bytes,5,opt,name=groupOwnerUser" json:"groupOwnerUser,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GroupCreatedTips) Reset() { *m = GroupCreatedTips{} } -func (m *GroupCreatedTips) String() string { return proto.CompactTextString(m) } -func (*GroupCreatedTips) ProtoMessage() {} -func (*GroupCreatedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{25} -} -func (m *GroupCreatedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupCreatedTips.Unmarshal(m, b) -} -func (m *GroupCreatedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupCreatedTips.Marshal(b, m, deterministic) -} -func (dst *GroupCreatedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupCreatedTips.Merge(dst, src) -} -func (m *GroupCreatedTips) XXX_Size() int { - return xxx_messageInfo_GroupCreatedTips.Size(m) -} -func (m *GroupCreatedTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupCreatedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_GroupCreatedTips proto.InternalMessageInfo - -func (m *GroupCreatedTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -func (m *GroupCreatedTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser - } - return nil -} - -func (m *GroupCreatedTips) GetMemberList() []*GroupMemberFullInfo { - if m != nil { - return m.MemberList - } - return nil -} - -func (m *GroupCreatedTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime - } - return 0 -} - -func (m *GroupCreatedTips) GetGroupOwnerUser() *GroupMemberFullInfo { - if m != nil { - return m.GroupOwnerUser - } - return nil -} - -// OnGroupInfoSet() -type GroupInfoSetTips struct { - OpUser *GroupMemberFullInfo `protobuf:"bytes,1,opt,name=opUser" json:"opUser,omitempty"` - MuteTime int64 `protobuf:"varint,2,opt,name=muteTime" json:"muteTime,omitempty"` - Group *GroupInfo `protobuf:"bytes,3,opt,name=group" json:"group,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GroupInfoSetTips) Reset() { *m = GroupInfoSetTips{} } -func (m *GroupInfoSetTips) String() string { return proto.CompactTextString(m) } -func (*GroupInfoSetTips) ProtoMessage() {} -func (*GroupInfoSetTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{26} -} -func (m *GroupInfoSetTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupInfoSetTips.Unmarshal(m, b) -} -func (m *GroupInfoSetTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupInfoSetTips.Marshal(b, m, deterministic) -} -func (dst *GroupInfoSetTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupInfoSetTips.Merge(dst, src) -} -func (m *GroupInfoSetTips) XXX_Size() int { - return xxx_messageInfo_GroupInfoSetTips.Size(m) -} -func (m *GroupInfoSetTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupInfoSetTips.DiscardUnknown(m) -} - -var xxx_messageInfo_GroupInfoSetTips proto.InternalMessageInfo - -func (m *GroupInfoSetTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser - } - return nil -} - -func (m *GroupInfoSetTips) GetMuteTime() int64 { - if m != nil { - return m.MuteTime - } - return 0 -} - -func (m *GroupInfoSetTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -// OnJoinGroupApplication() -type JoinGroupApplicationTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - Applicant *PublicUserInfo `protobuf:"bytes,2,opt,name=applicant" json:"applicant,omitempty"` - ReqMsg string `protobuf:"bytes,3,opt,name=reqMsg" json:"reqMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *JoinGroupApplicationTips) Reset() { *m = JoinGroupApplicationTips{} } -func (m *JoinGroupApplicationTips) String() string { return proto.CompactTextString(m) } -func (*JoinGroupApplicationTips) ProtoMessage() {} -func (*JoinGroupApplicationTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{27} -} -func (m *JoinGroupApplicationTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_JoinGroupApplicationTips.Unmarshal(m, b) -} -func (m *JoinGroupApplicationTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_JoinGroupApplicationTips.Marshal(b, m, deterministic) -} -func (dst *JoinGroupApplicationTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_JoinGroupApplicationTips.Merge(dst, src) -} -func (m *JoinGroupApplicationTips) XXX_Size() int { - return xxx_messageInfo_JoinGroupApplicationTips.Size(m) -} -func (m *JoinGroupApplicationTips) XXX_DiscardUnknown() { - xxx_messageInfo_JoinGroupApplicationTips.DiscardUnknown(m) -} - -var xxx_messageInfo_JoinGroupApplicationTips proto.InternalMessageInfo - -func (m *JoinGroupApplicationTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -func (m *JoinGroupApplicationTips) GetApplicant() *PublicUserInfo { - if m != nil { - return m.Applicant - } - return nil -} - -func (m *JoinGroupApplicationTips) GetReqMsg() string { - if m != nil { - return m.ReqMsg - } - return "" -} - -// OnQuitGroup() -// -// Actively leave the group -type MemberQuitTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - QuitUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=quitUser" json:"quitUser,omitempty"` - OperationTime int64 `protobuf:"varint,3,opt,name=operationTime" json:"operationTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *MemberQuitTips) Reset() { *m = MemberQuitTips{} } -func (m *MemberQuitTips) String() string { return proto.CompactTextString(m) } -func (*MemberQuitTips) ProtoMessage() {} -func (*MemberQuitTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{28} -} -func (m *MemberQuitTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MemberQuitTips.Unmarshal(m, b) -} -func (m *MemberQuitTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MemberQuitTips.Marshal(b, m, deterministic) -} -func (dst *MemberQuitTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_MemberQuitTips.Merge(dst, src) -} -func (m *MemberQuitTips) XXX_Size() int { - return xxx_messageInfo_MemberQuitTips.Size(m) -} -func (m *MemberQuitTips) XXX_DiscardUnknown() { - xxx_messageInfo_MemberQuitTips.DiscardUnknown(m) -} - -var xxx_messageInfo_MemberQuitTips proto.InternalMessageInfo - -func (m *MemberQuitTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -func (m *MemberQuitTips) GetQuitUser() *GroupMemberFullInfo { - if m != nil { - return m.QuitUser - } - return nil -} - -func (m *MemberQuitTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime - } - return 0 -} - -// OnApplicationGroupAccepted() -type GroupApplicationAcceptedTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - HandleMsg string `protobuf:"bytes,4,opt,name=handleMsg" json:"handleMsg,omitempty"` - ReceiverAs int32 `protobuf:"varint,5,opt,name=receiverAs" json:"receiverAs,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GroupApplicationAcceptedTips) Reset() { *m = GroupApplicationAcceptedTips{} } -func (m *GroupApplicationAcceptedTips) String() string { return proto.CompactTextString(m) } -func (*GroupApplicationAcceptedTips) ProtoMessage() {} -func (*GroupApplicationAcceptedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{29} -} -func (m *GroupApplicationAcceptedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupApplicationAcceptedTips.Unmarshal(m, b) -} -func (m *GroupApplicationAcceptedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupApplicationAcceptedTips.Marshal(b, m, deterministic) -} -func (dst *GroupApplicationAcceptedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupApplicationAcceptedTips.Merge(dst, src) -} -func (m *GroupApplicationAcceptedTips) XXX_Size() int { - return xxx_messageInfo_GroupApplicationAcceptedTips.Size(m) -} -func (m *GroupApplicationAcceptedTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupApplicationAcceptedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_GroupApplicationAcceptedTips proto.InternalMessageInfo - -func (m *GroupApplicationAcceptedTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -func (m *GroupApplicationAcceptedTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser - } - return nil -} - -func (m *GroupApplicationAcceptedTips) GetHandleMsg() string { - if m != nil { - return m.HandleMsg - } - return "" -} - -func (m *GroupApplicationAcceptedTips) GetReceiverAs() int32 { - if m != nil { - return m.ReceiverAs - } - return 0 -} - -// OnApplicationGroupRejected() -type GroupApplicationRejectedTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - HandleMsg string `protobuf:"bytes,4,opt,name=handleMsg" json:"handleMsg,omitempty"` - ReceiverAs int32 `protobuf:"varint,5,opt,name=receiverAs" json:"receiverAs,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GroupApplicationRejectedTips) Reset() { *m = GroupApplicationRejectedTips{} } -func (m *GroupApplicationRejectedTips) String() string { return proto.CompactTextString(m) } -func (*GroupApplicationRejectedTips) ProtoMessage() {} -func (*GroupApplicationRejectedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{30} -} -func (m *GroupApplicationRejectedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupApplicationRejectedTips.Unmarshal(m, b) -} -func (m *GroupApplicationRejectedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupApplicationRejectedTips.Marshal(b, m, deterministic) -} -func (dst *GroupApplicationRejectedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupApplicationRejectedTips.Merge(dst, src) -} -func (m *GroupApplicationRejectedTips) XXX_Size() int { - return xxx_messageInfo_GroupApplicationRejectedTips.Size(m) -} -func (m *GroupApplicationRejectedTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupApplicationRejectedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_GroupApplicationRejectedTips proto.InternalMessageInfo - -func (m *GroupApplicationRejectedTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -func (m *GroupApplicationRejectedTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser - } - return nil -} - -func (m *GroupApplicationRejectedTips) GetHandleMsg() string { - if m != nil { - return m.HandleMsg - } - return "" -} - -func (m *GroupApplicationRejectedTips) GetReceiverAs() int32 { - if m != nil { - return m.ReceiverAs - } - return 0 -} - -// OnTransferGroupOwner() -type GroupOwnerTransferredTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - NewGroupOwner *GroupMemberFullInfo `protobuf:"bytes,3,opt,name=newGroupOwner" json:"newGroupOwner,omitempty"` - OperationTime int64 `protobuf:"varint,4,opt,name=operationTime" json:"operationTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GroupOwnerTransferredTips) Reset() { *m = GroupOwnerTransferredTips{} } -func (m *GroupOwnerTransferredTips) String() string { return proto.CompactTextString(m) } -func (*GroupOwnerTransferredTips) ProtoMessage() {} -func (*GroupOwnerTransferredTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{31} -} -func (m *GroupOwnerTransferredTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupOwnerTransferredTips.Unmarshal(m, b) -} -func (m *GroupOwnerTransferredTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupOwnerTransferredTips.Marshal(b, m, deterministic) -} -func (dst *GroupOwnerTransferredTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupOwnerTransferredTips.Merge(dst, src) -} -func (m *GroupOwnerTransferredTips) XXX_Size() int { - return xxx_messageInfo_GroupOwnerTransferredTips.Size(m) -} -func (m *GroupOwnerTransferredTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupOwnerTransferredTips.DiscardUnknown(m) -} - -var xxx_messageInfo_GroupOwnerTransferredTips proto.InternalMessageInfo - -func (m *GroupOwnerTransferredTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -func (m *GroupOwnerTransferredTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser - } - return nil -} - -func (m *GroupOwnerTransferredTips) GetNewGroupOwner() *GroupMemberFullInfo { - if m != nil { - return m.NewGroupOwner - } - return nil -} - -func (m *GroupOwnerTransferredTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime - } - return 0 -} - -// OnMemberKicked() -type MemberKickedTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - KickedUserList []*GroupMemberFullInfo `protobuf:"bytes,3,rep,name=kickedUserList" json:"kickedUserList,omitempty"` - OperationTime int64 `protobuf:"varint,4,opt,name=operationTime" json:"operationTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *MemberKickedTips) Reset() { *m = MemberKickedTips{} } -func (m *MemberKickedTips) String() string { return proto.CompactTextString(m) } -func (*MemberKickedTips) ProtoMessage() {} -func (*MemberKickedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{32} -} -func (m *MemberKickedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MemberKickedTips.Unmarshal(m, b) -} -func (m *MemberKickedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MemberKickedTips.Marshal(b, m, deterministic) -} -func (dst *MemberKickedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_MemberKickedTips.Merge(dst, src) -} -func (m *MemberKickedTips) XXX_Size() int { - return xxx_messageInfo_MemberKickedTips.Size(m) -} -func (m *MemberKickedTips) XXX_DiscardUnknown() { - xxx_messageInfo_MemberKickedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_MemberKickedTips proto.InternalMessageInfo - -func (m *MemberKickedTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -func (m *MemberKickedTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser - } - return nil -} - -func (m *MemberKickedTips) GetKickedUserList() []*GroupMemberFullInfo { - if m != nil { - return m.KickedUserList - } - return nil -} - -func (m *MemberKickedTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime - } - return 0 -} - -// OnMemberInvited() -type MemberInvitedTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - InvitedUserList []*GroupMemberFullInfo `protobuf:"bytes,3,rep,name=invitedUserList" json:"invitedUserList,omitempty"` - OperationTime int64 `protobuf:"varint,4,opt,name=operationTime" json:"operationTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *MemberInvitedTips) Reset() { *m = MemberInvitedTips{} } -func (m *MemberInvitedTips) String() string { return proto.CompactTextString(m) } -func (*MemberInvitedTips) ProtoMessage() {} -func (*MemberInvitedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{33} -} -func (m *MemberInvitedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MemberInvitedTips.Unmarshal(m, b) -} -func (m *MemberInvitedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MemberInvitedTips.Marshal(b, m, deterministic) -} -func (dst *MemberInvitedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_MemberInvitedTips.Merge(dst, src) -} -func (m *MemberInvitedTips) XXX_Size() int { - return xxx_messageInfo_MemberInvitedTips.Size(m) -} -func (m *MemberInvitedTips) XXX_DiscardUnknown() { - xxx_messageInfo_MemberInvitedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_MemberInvitedTips proto.InternalMessageInfo - -func (m *MemberInvitedTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -func (m *MemberInvitedTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser - } - return nil -} - -func (m *MemberInvitedTips) GetInvitedUserList() []*GroupMemberFullInfo { - if m != nil { - return m.InvitedUserList - } - return nil -} - -func (m *MemberInvitedTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime - } - return 0 -} - -// Actively join the group -type MemberEnterTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - EntrantUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=entrantUser" json:"entrantUser,omitempty"` - OperationTime int64 `protobuf:"varint,3,opt,name=operationTime" json:"operationTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *MemberEnterTips) Reset() { *m = MemberEnterTips{} } -func (m *MemberEnterTips) String() string { return proto.CompactTextString(m) } -func (*MemberEnterTips) ProtoMessage() {} -func (*MemberEnterTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{34} -} -func (m *MemberEnterTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MemberEnterTips.Unmarshal(m, b) -} -func (m *MemberEnterTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MemberEnterTips.Marshal(b, m, deterministic) -} -func (dst *MemberEnterTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_MemberEnterTips.Merge(dst, src) -} -func (m *MemberEnterTips) XXX_Size() int { - return xxx_messageInfo_MemberEnterTips.Size(m) -} -func (m *MemberEnterTips) XXX_DiscardUnknown() { - xxx_messageInfo_MemberEnterTips.DiscardUnknown(m) -} - -var xxx_messageInfo_MemberEnterTips proto.InternalMessageInfo - -func (m *MemberEnterTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -func (m *MemberEnterTips) GetEntrantUser() *GroupMemberFullInfo { - if m != nil { - return m.EntrantUser - } - return nil -} - -func (m *MemberEnterTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime - } - return 0 -} - -type GroupDismissedTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - OperationTime int64 `protobuf:"varint,3,opt,name=operationTime" json:"operationTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GroupDismissedTips) Reset() { *m = GroupDismissedTips{} } -func (m *GroupDismissedTips) String() string { return proto.CompactTextString(m) } -func (*GroupDismissedTips) ProtoMessage() {} -func (*GroupDismissedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{35} -} -func (m *GroupDismissedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupDismissedTips.Unmarshal(m, b) -} -func (m *GroupDismissedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupDismissedTips.Marshal(b, m, deterministic) -} -func (dst *GroupDismissedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupDismissedTips.Merge(dst, src) -} -func (m *GroupDismissedTips) XXX_Size() int { - return xxx_messageInfo_GroupDismissedTips.Size(m) -} -func (m *GroupDismissedTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupDismissedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_GroupDismissedTips proto.InternalMessageInfo - -func (m *GroupDismissedTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -func (m *GroupDismissedTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser - } - return nil -} - -func (m *GroupDismissedTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime - } - return 0 -} - -type GroupMemberMutedTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - OperationTime int64 `protobuf:"varint,3,opt,name=operationTime" json:"operationTime,omitempty"` - MutedUser *GroupMemberFullInfo `protobuf:"bytes,4,opt,name=mutedUser" json:"mutedUser,omitempty"` - MutedSeconds uint32 `protobuf:"varint,5,opt,name=mutedSeconds" json:"mutedSeconds,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GroupMemberMutedTips) Reset() { *m = GroupMemberMutedTips{} } -func (m *GroupMemberMutedTips) String() string { return proto.CompactTextString(m) } -func (*GroupMemberMutedTips) ProtoMessage() {} -func (*GroupMemberMutedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{36} -} -func (m *GroupMemberMutedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupMemberMutedTips.Unmarshal(m, b) -} -func (m *GroupMemberMutedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupMemberMutedTips.Marshal(b, m, deterministic) -} -func (dst *GroupMemberMutedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupMemberMutedTips.Merge(dst, src) -} -func (m *GroupMemberMutedTips) XXX_Size() int { - return xxx_messageInfo_GroupMemberMutedTips.Size(m) -} -func (m *GroupMemberMutedTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupMemberMutedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_GroupMemberMutedTips proto.InternalMessageInfo - -func (m *GroupMemberMutedTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -func (m *GroupMemberMutedTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser - } - return nil -} - -func (m *GroupMemberMutedTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime - } - return 0 -} - -func (m *GroupMemberMutedTips) GetMutedUser() *GroupMemberFullInfo { - if m != nil { - return m.MutedUser - } - return nil -} - -func (m *GroupMemberMutedTips) GetMutedSeconds() uint32 { - if m != nil { - return m.MutedSeconds - } - return 0 -} - -type GroupMemberCancelMutedTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - OperationTime int64 `protobuf:"varint,3,opt,name=operationTime" json:"operationTime,omitempty"` - MutedUser *GroupMemberFullInfo `protobuf:"bytes,4,opt,name=mutedUser" json:"mutedUser,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GroupMemberCancelMutedTips) Reset() { *m = GroupMemberCancelMutedTips{} } -func (m *GroupMemberCancelMutedTips) String() string { return proto.CompactTextString(m) } -func (*GroupMemberCancelMutedTips) ProtoMessage() {} -func (*GroupMemberCancelMutedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{37} -} -func (m *GroupMemberCancelMutedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupMemberCancelMutedTips.Unmarshal(m, b) -} -func (m *GroupMemberCancelMutedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupMemberCancelMutedTips.Marshal(b, m, deterministic) -} -func (dst *GroupMemberCancelMutedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupMemberCancelMutedTips.Merge(dst, src) -} -func (m *GroupMemberCancelMutedTips) XXX_Size() int { - return xxx_messageInfo_GroupMemberCancelMutedTips.Size(m) -} -func (m *GroupMemberCancelMutedTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupMemberCancelMutedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_GroupMemberCancelMutedTips proto.InternalMessageInfo - -func (m *GroupMemberCancelMutedTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -func (m *GroupMemberCancelMutedTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser - } - return nil -} - -func (m *GroupMemberCancelMutedTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime - } - return 0 -} - -func (m *GroupMemberCancelMutedTips) GetMutedUser() *GroupMemberFullInfo { - if m != nil { - return m.MutedUser - } - return nil -} - -type GroupMutedTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - OperationTime int64 `protobuf:"varint,3,opt,name=operationTime" json:"operationTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GroupMutedTips) Reset() { *m = GroupMutedTips{} } -func (m *GroupMutedTips) String() string { return proto.CompactTextString(m) } -func (*GroupMutedTips) ProtoMessage() {} -func (*GroupMutedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{38} -} -func (m *GroupMutedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupMutedTips.Unmarshal(m, b) -} -func (m *GroupMutedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupMutedTips.Marshal(b, m, deterministic) -} -func (dst *GroupMutedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupMutedTips.Merge(dst, src) -} -func (m *GroupMutedTips) XXX_Size() int { - return xxx_messageInfo_GroupMutedTips.Size(m) -} -func (m *GroupMutedTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupMutedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_GroupMutedTips proto.InternalMessageInfo - -func (m *GroupMutedTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -func (m *GroupMutedTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser - } - return nil -} - -func (m *GroupMutedTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime - } - return 0 -} - -type GroupCancelMutedTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - OperationTime int64 `protobuf:"varint,3,opt,name=operationTime" json:"operationTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GroupCancelMutedTips) Reset() { *m = GroupCancelMutedTips{} } -func (m *GroupCancelMutedTips) String() string { return proto.CompactTextString(m) } -func (*GroupCancelMutedTips) ProtoMessage() {} -func (*GroupCancelMutedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{39} -} -func (m *GroupCancelMutedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupCancelMutedTips.Unmarshal(m, b) -} -func (m *GroupCancelMutedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupCancelMutedTips.Marshal(b, m, deterministic) -} -func (dst *GroupCancelMutedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupCancelMutedTips.Merge(dst, src) -} -func (m *GroupCancelMutedTips) XXX_Size() int { - return xxx_messageInfo_GroupCancelMutedTips.Size(m) -} -func (m *GroupCancelMutedTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupCancelMutedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_GroupCancelMutedTips proto.InternalMessageInfo - -func (m *GroupCancelMutedTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -func (m *GroupCancelMutedTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser - } - return nil -} - -func (m *GroupCancelMutedTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime - } - return 0 -} - -type GroupMemberInfoSetTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - OperationTime int64 `protobuf:"varint,3,opt,name=operationTime" json:"operationTime,omitempty"` - ChangedUser *GroupMemberFullInfo `protobuf:"bytes,4,opt,name=changedUser" json:"changedUser,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *GroupMemberInfoSetTips) Reset() { *m = GroupMemberInfoSetTips{} } -func (m *GroupMemberInfoSetTips) String() string { return proto.CompactTextString(m) } -func (*GroupMemberInfoSetTips) ProtoMessage() {} -func (*GroupMemberInfoSetTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{40} -} -func (m *GroupMemberInfoSetTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupMemberInfoSetTips.Unmarshal(m, b) -} -func (m *GroupMemberInfoSetTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupMemberInfoSetTips.Marshal(b, m, deterministic) -} -func (dst *GroupMemberInfoSetTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupMemberInfoSetTips.Merge(dst, src) -} -func (m *GroupMemberInfoSetTips) XXX_Size() int { - return xxx_messageInfo_GroupMemberInfoSetTips.Size(m) -} -func (m *GroupMemberInfoSetTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupMemberInfoSetTips.DiscardUnknown(m) -} - -var xxx_messageInfo_GroupMemberInfoSetTips proto.InternalMessageInfo - -func (m *GroupMemberInfoSetTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group - } - return nil -} - -func (m *GroupMemberInfoSetTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser - } - return nil -} - -func (m *GroupMemberInfoSetTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime - } - return 0 -} - -func (m *GroupMemberInfoSetTips) GetChangedUser() *GroupMemberFullInfo { - if m != nil { - return m.ChangedUser - } - return nil -} - -type OrganizationChangedTips struct { - OpUser *UserInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - OperationTime int64 `protobuf:"varint,3,opt,name=operationTime" json:"operationTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *OrganizationChangedTips) Reset() { *m = OrganizationChangedTips{} } -func (m *OrganizationChangedTips) String() string { return proto.CompactTextString(m) } -func (*OrganizationChangedTips) ProtoMessage() {} -func (*OrganizationChangedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{41} -} -func (m *OrganizationChangedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_OrganizationChangedTips.Unmarshal(m, b) -} -func (m *OrganizationChangedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_OrganizationChangedTips.Marshal(b, m, deterministic) -} -func (dst *OrganizationChangedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_OrganizationChangedTips.Merge(dst, src) -} -func (m *OrganizationChangedTips) XXX_Size() int { - return xxx_messageInfo_OrganizationChangedTips.Size(m) -} -func (m *OrganizationChangedTips) XXX_DiscardUnknown() { - xxx_messageInfo_OrganizationChangedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_OrganizationChangedTips proto.InternalMessageInfo - -func (m *OrganizationChangedTips) GetOpUser() *UserInfo { - if m != nil { - return m.OpUser - } - return nil -} - -func (m *OrganizationChangedTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime - } - return 0 -} - -type FriendApplication struct { - AddTime int64 `protobuf:"varint,1,opt,name=addTime" json:"addTime,omitempty"` - AddSource string `protobuf:"bytes,2,opt,name=addSource" json:"addSource,omitempty"` - AddWording string `protobuf:"bytes,3,opt,name=addWording" json:"addWording,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *FriendApplication) Reset() { *m = FriendApplication{} } -func (m *FriendApplication) String() string { return proto.CompactTextString(m) } -func (*FriendApplication) ProtoMessage() {} -func (*FriendApplication) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{42} -} -func (m *FriendApplication) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendApplication.Unmarshal(m, b) -} -func (m *FriendApplication) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendApplication.Marshal(b, m, deterministic) -} -func (dst *FriendApplication) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendApplication.Merge(dst, src) -} -func (m *FriendApplication) XXX_Size() int { - return xxx_messageInfo_FriendApplication.Size(m) -} -func (m *FriendApplication) XXX_DiscardUnknown() { - xxx_messageInfo_FriendApplication.DiscardUnknown(m) -} - -var xxx_messageInfo_FriendApplication proto.InternalMessageInfo - -func (m *FriendApplication) GetAddTime() int64 { - if m != nil { - return m.AddTime - } - return 0 -} - -func (m *FriendApplication) GetAddSource() string { - if m != nil { - return m.AddSource - } - return "" -} - -func (m *FriendApplication) GetAddWording() string { - if m != nil { - return m.AddWording - } - return "" -} - -type FromToUserID struct { - FromUserID string `protobuf:"bytes,1,opt,name=fromUserID" json:"fromUserID,omitempty"` - ToUserID string `protobuf:"bytes,2,opt,name=toUserID" json:"toUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *FromToUserID) Reset() { *m = FromToUserID{} } -func (m *FromToUserID) String() string { return proto.CompactTextString(m) } -func (*FromToUserID) ProtoMessage() {} -func (*FromToUserID) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{43} -} -func (m *FromToUserID) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FromToUserID.Unmarshal(m, b) -} -func (m *FromToUserID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FromToUserID.Marshal(b, m, deterministic) -} -func (dst *FromToUserID) XXX_Merge(src proto.Message) { - xxx_messageInfo_FromToUserID.Merge(dst, src) -} -func (m *FromToUserID) XXX_Size() int { - return xxx_messageInfo_FromToUserID.Size(m) -} -func (m *FromToUserID) XXX_DiscardUnknown() { - xxx_messageInfo_FromToUserID.DiscardUnknown(m) -} - -var xxx_messageInfo_FromToUserID proto.InternalMessageInfo - -func (m *FromToUserID) GetFromUserID() string { - if m != nil { - return m.FromUserID - } - return "" -} - -func (m *FromToUserID) GetToUserID() string { - if m != nil { - return m.ToUserID - } - return "" -} - -// FromUserID apply to add ToUserID -type FriendApplicationTips struct { - FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID" json:"fromToUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *FriendApplicationTips) Reset() { *m = FriendApplicationTips{} } -func (m *FriendApplicationTips) String() string { return proto.CompactTextString(m) } -func (*FriendApplicationTips) ProtoMessage() {} -func (*FriendApplicationTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{44} -} -func (m *FriendApplicationTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendApplicationTips.Unmarshal(m, b) -} -func (m *FriendApplicationTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendApplicationTips.Marshal(b, m, deterministic) -} -func (dst *FriendApplicationTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendApplicationTips.Merge(dst, src) -} -func (m *FriendApplicationTips) XXX_Size() int { - return xxx_messageInfo_FriendApplicationTips.Size(m) -} -func (m *FriendApplicationTips) XXX_DiscardUnknown() { - xxx_messageInfo_FriendApplicationTips.DiscardUnknown(m) -} - -var xxx_messageInfo_FriendApplicationTips proto.InternalMessageInfo - -func (m *FriendApplicationTips) GetFromToUserID() *FromToUserID { - if m != nil { - return m.FromToUserID - } - return nil -} - -// FromUserID accept or reject ToUserID -type FriendApplicationApprovedTips struct { - FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID" json:"fromToUserID,omitempty"` - HandleMsg string `protobuf:"bytes,2,opt,name=handleMsg" json:"handleMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *FriendApplicationApprovedTips) Reset() { *m = FriendApplicationApprovedTips{} } -func (m *FriendApplicationApprovedTips) String() string { return proto.CompactTextString(m) } -func (*FriendApplicationApprovedTips) ProtoMessage() {} -func (*FriendApplicationApprovedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{45} -} -func (m *FriendApplicationApprovedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendApplicationApprovedTips.Unmarshal(m, b) -} -func (m *FriendApplicationApprovedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendApplicationApprovedTips.Marshal(b, m, deterministic) -} -func (dst *FriendApplicationApprovedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendApplicationApprovedTips.Merge(dst, src) -} -func (m *FriendApplicationApprovedTips) XXX_Size() int { - return xxx_messageInfo_FriendApplicationApprovedTips.Size(m) -} -func (m *FriendApplicationApprovedTips) XXX_DiscardUnknown() { - xxx_messageInfo_FriendApplicationApprovedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_FriendApplicationApprovedTips proto.InternalMessageInfo - -func (m *FriendApplicationApprovedTips) GetFromToUserID() *FromToUserID { - if m != nil { - return m.FromToUserID - } - return nil -} - -func (m *FriendApplicationApprovedTips) GetHandleMsg() string { - if m != nil { - return m.HandleMsg - } - return "" -} - -// FromUserID accept or reject ToUserID -type FriendApplicationRejectedTips struct { - FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID" json:"fromToUserID,omitempty"` - HandleMsg string `protobuf:"bytes,2,opt,name=handleMsg" json:"handleMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *FriendApplicationRejectedTips) Reset() { *m = FriendApplicationRejectedTips{} } -func (m *FriendApplicationRejectedTips) String() string { return proto.CompactTextString(m) } -func (*FriendApplicationRejectedTips) ProtoMessage() {} -func (*FriendApplicationRejectedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{46} -} -func (m *FriendApplicationRejectedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendApplicationRejectedTips.Unmarshal(m, b) -} -func (m *FriendApplicationRejectedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendApplicationRejectedTips.Marshal(b, m, deterministic) -} -func (dst *FriendApplicationRejectedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendApplicationRejectedTips.Merge(dst, src) -} -func (m *FriendApplicationRejectedTips) XXX_Size() int { - return xxx_messageInfo_FriendApplicationRejectedTips.Size(m) -} -func (m *FriendApplicationRejectedTips) XXX_DiscardUnknown() { - xxx_messageInfo_FriendApplicationRejectedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_FriendApplicationRejectedTips proto.InternalMessageInfo - -func (m *FriendApplicationRejectedTips) GetFromToUserID() *FromToUserID { - if m != nil { - return m.FromToUserID - } - return nil -} - -func (m *FriendApplicationRejectedTips) GetHandleMsg() string { - if m != nil { - return m.HandleMsg - } - return "" -} - -// FromUserID Added a friend ToUserID -type FriendAddedTips struct { - Friend *FriendInfo `protobuf:"bytes,1,opt,name=friend" json:"friend,omitempty"` - OperationTime int64 `protobuf:"varint,2,opt,name=operationTime" json:"operationTime,omitempty"` - OpUser *PublicUserInfo `protobuf:"bytes,3,opt,name=opUser" json:"opUser,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *FriendAddedTips) Reset() { *m = FriendAddedTips{} } -func (m *FriendAddedTips) String() string { return proto.CompactTextString(m) } -func (*FriendAddedTips) ProtoMessage() {} -func (*FriendAddedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{47} -} -func (m *FriendAddedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendAddedTips.Unmarshal(m, b) -} -func (m *FriendAddedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendAddedTips.Marshal(b, m, deterministic) -} -func (dst *FriendAddedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendAddedTips.Merge(dst, src) -} -func (m *FriendAddedTips) XXX_Size() int { - return xxx_messageInfo_FriendAddedTips.Size(m) -} -func (m *FriendAddedTips) XXX_DiscardUnknown() { - xxx_messageInfo_FriendAddedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_FriendAddedTips proto.InternalMessageInfo - -func (m *FriendAddedTips) GetFriend() *FriendInfo { - if m != nil { - return m.Friend - } - return nil -} - -func (m *FriendAddedTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime - } - return 0 -} - -func (m *FriendAddedTips) GetOpUser() *PublicUserInfo { - if m != nil { - return m.OpUser - } - return nil -} - -// FromUserID deleted a friend ToUserID -type FriendDeletedTips struct { - FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID" json:"fromToUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *FriendDeletedTips) Reset() { *m = FriendDeletedTips{} } -func (m *FriendDeletedTips) String() string { return proto.CompactTextString(m) } -func (*FriendDeletedTips) ProtoMessage() {} -func (*FriendDeletedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{48} -} -func (m *FriendDeletedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendDeletedTips.Unmarshal(m, b) -} -func (m *FriendDeletedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendDeletedTips.Marshal(b, m, deterministic) -} -func (dst *FriendDeletedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendDeletedTips.Merge(dst, src) -} -func (m *FriendDeletedTips) XXX_Size() int { - return xxx_messageInfo_FriendDeletedTips.Size(m) -} -func (m *FriendDeletedTips) XXX_DiscardUnknown() { - xxx_messageInfo_FriendDeletedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_FriendDeletedTips proto.InternalMessageInfo - -func (m *FriendDeletedTips) GetFromToUserID() *FromToUserID { - if m != nil { - return m.FromToUserID - } - return nil -} - -type BlackAddedTips struct { - FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID" json:"fromToUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *BlackAddedTips) Reset() { *m = BlackAddedTips{} } -func (m *BlackAddedTips) String() string { return proto.CompactTextString(m) } -func (*BlackAddedTips) ProtoMessage() {} -func (*BlackAddedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{49} -} -func (m *BlackAddedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_BlackAddedTips.Unmarshal(m, b) -} -func (m *BlackAddedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_BlackAddedTips.Marshal(b, m, deterministic) -} -func (dst *BlackAddedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_BlackAddedTips.Merge(dst, src) -} -func (m *BlackAddedTips) XXX_Size() int { - return xxx_messageInfo_BlackAddedTips.Size(m) -} -func (m *BlackAddedTips) XXX_DiscardUnknown() { - xxx_messageInfo_BlackAddedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_BlackAddedTips proto.InternalMessageInfo - -func (m *BlackAddedTips) GetFromToUserID() *FromToUserID { - if m != nil { - return m.FromToUserID - } - return nil -} - -type BlackDeletedTips struct { - FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID" json:"fromToUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *BlackDeletedTips) Reset() { *m = BlackDeletedTips{} } -func (m *BlackDeletedTips) String() string { return proto.CompactTextString(m) } -func (*BlackDeletedTips) ProtoMessage() {} -func (*BlackDeletedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{50} -} -func (m *BlackDeletedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_BlackDeletedTips.Unmarshal(m, b) -} -func (m *BlackDeletedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_BlackDeletedTips.Marshal(b, m, deterministic) -} -func (dst *BlackDeletedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_BlackDeletedTips.Merge(dst, src) -} -func (m *BlackDeletedTips) XXX_Size() int { - return xxx_messageInfo_BlackDeletedTips.Size(m) -} -func (m *BlackDeletedTips) XXX_DiscardUnknown() { - xxx_messageInfo_BlackDeletedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_BlackDeletedTips proto.InternalMessageInfo - -func (m *BlackDeletedTips) GetFromToUserID() *FromToUserID { - if m != nil { - return m.FromToUserID - } - return nil -} - -type FriendInfoChangedTips struct { - FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID" json:"fromToUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *FriendInfoChangedTips) Reset() { *m = FriendInfoChangedTips{} } -func (m *FriendInfoChangedTips) String() string { return proto.CompactTextString(m) } -func (*FriendInfoChangedTips) ProtoMessage() {} -func (*FriendInfoChangedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{51} -} -func (m *FriendInfoChangedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendInfoChangedTips.Unmarshal(m, b) -} -func (m *FriendInfoChangedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendInfoChangedTips.Marshal(b, m, deterministic) -} -func (dst *FriendInfoChangedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendInfoChangedTips.Merge(dst, src) -} -func (m *FriendInfoChangedTips) XXX_Size() int { - return xxx_messageInfo_FriendInfoChangedTips.Size(m) -} -func (m *FriendInfoChangedTips) XXX_DiscardUnknown() { - xxx_messageInfo_FriendInfoChangedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_FriendInfoChangedTips proto.InternalMessageInfo - -func (m *FriendInfoChangedTips) GetFromToUserID() *FromToUserID { - if m != nil { - return m.FromToUserID - } - return nil -} - -// ////////////////////user///////////////////// -type UserInfoUpdatedTips struct { - UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *UserInfoUpdatedTips) Reset() { *m = UserInfoUpdatedTips{} } -func (m *UserInfoUpdatedTips) String() string { return proto.CompactTextString(m) } -func (*UserInfoUpdatedTips) ProtoMessage() {} -func (*UserInfoUpdatedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{52} -} -func (m *UserInfoUpdatedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_UserInfoUpdatedTips.Unmarshal(m, b) -} -func (m *UserInfoUpdatedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_UserInfoUpdatedTips.Marshal(b, m, deterministic) -} -func (dst *UserInfoUpdatedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_UserInfoUpdatedTips.Merge(dst, src) -} -func (m *UserInfoUpdatedTips) XXX_Size() int { - return xxx_messageInfo_UserInfoUpdatedTips.Size(m) -} -func (m *UserInfoUpdatedTips) XXX_DiscardUnknown() { - xxx_messageInfo_UserInfoUpdatedTips.DiscardUnknown(m) -} - -var xxx_messageInfo_UserInfoUpdatedTips proto.InternalMessageInfo - -func (m *UserInfoUpdatedTips) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -// ////////////////////conversation///////////////////// -type ConversationUpdateTips struct { - UserID string `protobuf:"bytes,1,opt,name=UserID" json:"UserID,omitempty"` - ConversationIDList []string `protobuf:"bytes,2,rep,name=conversationIDList" json:"conversationIDList,omitempty"` - UpdateUnreadCountTime int64 `protobuf:"varint,3,opt,name=updateUnreadCountTime" json:"updateUnreadCountTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *ConversationUpdateTips) Reset() { *m = ConversationUpdateTips{} } -func (m *ConversationUpdateTips) String() string { return proto.CompactTextString(m) } -func (*ConversationUpdateTips) ProtoMessage() {} -func (*ConversationUpdateTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{53} -} -func (m *ConversationUpdateTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ConversationUpdateTips.Unmarshal(m, b) -} -func (m *ConversationUpdateTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ConversationUpdateTips.Marshal(b, m, deterministic) -} -func (dst *ConversationUpdateTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_ConversationUpdateTips.Merge(dst, src) -} -func (m *ConversationUpdateTips) XXX_Size() int { - return xxx_messageInfo_ConversationUpdateTips.Size(m) -} -func (m *ConversationUpdateTips) XXX_DiscardUnknown() { - xxx_messageInfo_ConversationUpdateTips.DiscardUnknown(m) -} - -var xxx_messageInfo_ConversationUpdateTips proto.InternalMessageInfo - -func (m *ConversationUpdateTips) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *ConversationUpdateTips) GetConversationIDList() []string { - if m != nil { - return m.ConversationIDList - } - return nil -} - -func (m *ConversationUpdateTips) GetUpdateUnreadCountTime() int64 { - if m != nil { - return m.UpdateUnreadCountTime - } - return 0 -} - -type ConversationSetPrivateTips struct { - RecvID string `protobuf:"bytes,1,opt,name=recvID" json:"recvID,omitempty"` - SendID string `protobuf:"bytes,2,opt,name=sendID" json:"sendID,omitempty"` - IsPrivate bool `protobuf:"varint,3,opt,name=isPrivate" json:"isPrivate,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *ConversationSetPrivateTips) Reset() { *m = ConversationSetPrivateTips{} } -func (m *ConversationSetPrivateTips) String() string { return proto.CompactTextString(m) } -func (*ConversationSetPrivateTips) ProtoMessage() {} -func (*ConversationSetPrivateTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{54} -} -func (m *ConversationSetPrivateTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ConversationSetPrivateTips.Unmarshal(m, b) -} -func (m *ConversationSetPrivateTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ConversationSetPrivateTips.Marshal(b, m, deterministic) -} -func (dst *ConversationSetPrivateTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_ConversationSetPrivateTips.Merge(dst, src) -} -func (m *ConversationSetPrivateTips) XXX_Size() int { - return xxx_messageInfo_ConversationSetPrivateTips.Size(m) -} -func (m *ConversationSetPrivateTips) XXX_DiscardUnknown() { - xxx_messageInfo_ConversationSetPrivateTips.DiscardUnknown(m) -} - -var xxx_messageInfo_ConversationSetPrivateTips proto.InternalMessageInfo - -func (m *ConversationSetPrivateTips) GetRecvID() string { - if m != nil { - return m.RecvID - } - return "" -} - -func (m *ConversationSetPrivateTips) GetSendID() string { - if m != nil { - return m.SendID - } - return "" -} - -func (m *ConversationSetPrivateTips) GetIsPrivate() bool { - if m != nil { - return m.IsPrivate - } - return false -} - -// //////////////////message/////////////////////// -type DeleteMessageTips struct { - OpUserID string `protobuf:"bytes,1,opt,name=opUserID" json:"opUserID,omitempty"` - UserID string `protobuf:"bytes,2,opt,name=userID" json:"userID,omitempty"` - SeqList []uint32 `protobuf:"varint,3,rep,packed,name=seqList" json:"seqList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *DeleteMessageTips) Reset() { *m = DeleteMessageTips{} } -func (m *DeleteMessageTips) String() string { return proto.CompactTextString(m) } -func (*DeleteMessageTips) ProtoMessage() {} -func (*DeleteMessageTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{55} -} -func (m *DeleteMessageTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_DeleteMessageTips.Unmarshal(m, b) -} -func (m *DeleteMessageTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_DeleteMessageTips.Marshal(b, m, deterministic) -} -func (dst *DeleteMessageTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_DeleteMessageTips.Merge(dst, src) -} -func (m *DeleteMessageTips) XXX_Size() int { - return xxx_messageInfo_DeleteMessageTips.Size(m) -} -func (m *DeleteMessageTips) XXX_DiscardUnknown() { - xxx_messageInfo_DeleteMessageTips.DiscardUnknown(m) -} - -var xxx_messageInfo_DeleteMessageTips proto.InternalMessageInfo - -func (m *DeleteMessageTips) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *DeleteMessageTips) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *DeleteMessageTips) GetSeqList() []uint32 { - if m != nil { - return m.SeqList - } - return nil -} - -// /cms -type RequestPagination struct { - PageNumber int32 `protobuf:"varint,1,opt,name=pageNumber" json:"pageNumber,omitempty"` - ShowNumber int32 `protobuf:"varint,2,opt,name=showNumber" json:"showNumber,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *RequestPagination) Reset() { *m = RequestPagination{} } -func (m *RequestPagination) String() string { return proto.CompactTextString(m) } -func (*RequestPagination) ProtoMessage() {} -func (*RequestPagination) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{56} -} -func (m *RequestPagination) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_RequestPagination.Unmarshal(m, b) -} -func (m *RequestPagination) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_RequestPagination.Marshal(b, m, deterministic) -} -func (dst *RequestPagination) XXX_Merge(src proto.Message) { - xxx_messageInfo_RequestPagination.Merge(dst, src) -} -func (m *RequestPagination) XXX_Size() int { - return xxx_messageInfo_RequestPagination.Size(m) -} -func (m *RequestPagination) XXX_DiscardUnknown() { - xxx_messageInfo_RequestPagination.DiscardUnknown(m) -} - -var xxx_messageInfo_RequestPagination proto.InternalMessageInfo - -func (m *RequestPagination) GetPageNumber() int32 { - if m != nil { - return m.PageNumber - } - return 0 -} - -func (m *RequestPagination) GetShowNumber() int32 { - if m != nil { - return m.ShowNumber - } - return 0 -} - -type ResponsePagination struct { - CurrentPage int32 `protobuf:"varint,5,opt,name=CurrentPage" json:"CurrentPage,omitempty"` - ShowNumber int32 `protobuf:"varint,6,opt,name=ShowNumber" json:"ShowNumber,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *ResponsePagination) Reset() { *m = ResponsePagination{} } -func (m *ResponsePagination) String() string { return proto.CompactTextString(m) } -func (*ResponsePagination) ProtoMessage() {} -func (*ResponsePagination) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{57} -} -func (m *ResponsePagination) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ResponsePagination.Unmarshal(m, b) -} -func (m *ResponsePagination) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ResponsePagination.Marshal(b, m, deterministic) -} -func (dst *ResponsePagination) XXX_Merge(src proto.Message) { - xxx_messageInfo_ResponsePagination.Merge(dst, src) -} -func (m *ResponsePagination) XXX_Size() int { - return xxx_messageInfo_ResponsePagination.Size(m) -} -func (m *ResponsePagination) XXX_DiscardUnknown() { - xxx_messageInfo_ResponsePagination.DiscardUnknown(m) -} - -var xxx_messageInfo_ResponsePagination proto.InternalMessageInfo - -func (m *ResponsePagination) GetCurrentPage() int32 { - if m != nil { - return m.CurrentPage - } - return 0 -} - -func (m *ResponsePagination) GetShowNumber() int32 { - if m != nil { - return m.ShowNumber - } - return 0 -} - -// /////////////////signal////////////// -type SignalReq struct { - // Types that are valid to be assigned to Payload: - // *SignalReq_Invite - // *SignalReq_InviteInGroup - // *SignalReq_Cancel - // *SignalReq_Accept - // *SignalReq_HungUp - // *SignalReq_Reject - // *SignalReq_GetRoomByGroupID - // *SignalReq_OnRoomParticipantConnectedReq - // *SignalReq_OnRoomParticipantDisconnectedReq - // *SignalReq_GetTokenByRoomID - Payload isSignalReq_Payload `protobuf_oneof:"payload"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalReq) Reset() { *m = SignalReq{} } -func (m *SignalReq) String() string { return proto.CompactTextString(m) } -func (*SignalReq) ProtoMessage() {} -func (*SignalReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{58} -} -func (m *SignalReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalReq.Unmarshal(m, b) -} -func (m *SignalReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalReq.Marshal(b, m, deterministic) -} -func (dst *SignalReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalReq.Merge(dst, src) -} -func (m *SignalReq) XXX_Size() int { - return xxx_messageInfo_SignalReq.Size(m) -} -func (m *SignalReq) XXX_DiscardUnknown() { - xxx_messageInfo_SignalReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalReq proto.InternalMessageInfo - -type isSignalReq_Payload interface { - isSignalReq_Payload() -} - -type SignalReq_Invite struct { - Invite *SignalInviteReq `protobuf:"bytes,1,opt,name=invite,oneof"` -} -type SignalReq_InviteInGroup struct { - InviteInGroup *SignalInviteInGroupReq `protobuf:"bytes,2,opt,name=inviteInGroup,oneof"` -} -type SignalReq_Cancel struct { - Cancel *SignalCancelReq `protobuf:"bytes,3,opt,name=cancel,oneof"` -} -type SignalReq_Accept struct { - Accept *SignalAcceptReq `protobuf:"bytes,4,opt,name=accept,oneof"` -} -type SignalReq_HungUp struct { - HungUp *SignalHungUpReq `protobuf:"bytes,5,opt,name=hungUp,oneof"` -} -type SignalReq_Reject struct { - Reject *SignalRejectReq `protobuf:"bytes,6,opt,name=reject,oneof"` -} -type SignalReq_GetRoomByGroupID struct { - GetRoomByGroupID *SignalGetRoomByGroupIDReq `protobuf:"bytes,7,opt,name=getRoomByGroupID,oneof"` -} -type SignalReq_OnRoomParticipantConnectedReq struct { - OnRoomParticipantConnectedReq *SignalOnRoomParticipantConnectedReq `protobuf:"bytes,8,opt,name=onRoomParticipantConnectedReq,oneof"` -} -type SignalReq_OnRoomParticipantDisconnectedReq struct { - OnRoomParticipantDisconnectedReq *SignalOnRoomParticipantDisconnectedReq `protobuf:"bytes,9,opt,name=onRoomParticipantDisconnectedReq,oneof"` -} -type SignalReq_GetTokenByRoomID struct { - GetTokenByRoomID *SignalGetTokenByRoomIDReq `protobuf:"bytes,10,opt,name=getTokenByRoomID,oneof"` -} - -func (*SignalReq_Invite) isSignalReq_Payload() {} -func (*SignalReq_InviteInGroup) isSignalReq_Payload() {} -func (*SignalReq_Cancel) isSignalReq_Payload() {} -func (*SignalReq_Accept) isSignalReq_Payload() {} -func (*SignalReq_HungUp) isSignalReq_Payload() {} -func (*SignalReq_Reject) isSignalReq_Payload() {} -func (*SignalReq_GetRoomByGroupID) isSignalReq_Payload() {} -func (*SignalReq_OnRoomParticipantConnectedReq) isSignalReq_Payload() {} -func (*SignalReq_OnRoomParticipantDisconnectedReq) isSignalReq_Payload() {} -func (*SignalReq_GetTokenByRoomID) isSignalReq_Payload() {} - -func (m *SignalReq) GetPayload() isSignalReq_Payload { - if m != nil { - return m.Payload - } - return nil -} - -func (m *SignalReq) GetInvite() *SignalInviteReq { - if x, ok := m.GetPayload().(*SignalReq_Invite); ok { - return x.Invite - } - return nil -} - -func (m *SignalReq) GetInviteInGroup() *SignalInviteInGroupReq { - if x, ok := m.GetPayload().(*SignalReq_InviteInGroup); ok { - return x.InviteInGroup - } - return nil -} - -func (m *SignalReq) GetCancel() *SignalCancelReq { - if x, ok := m.GetPayload().(*SignalReq_Cancel); ok { - return x.Cancel - } - return nil -} - -func (m *SignalReq) GetAccept() *SignalAcceptReq { - if x, ok := m.GetPayload().(*SignalReq_Accept); ok { - return x.Accept - } - return nil -} - -func (m *SignalReq) GetHungUp() *SignalHungUpReq { - if x, ok := m.GetPayload().(*SignalReq_HungUp); ok { - return x.HungUp - } - return nil -} - -func (m *SignalReq) GetReject() *SignalRejectReq { - if x, ok := m.GetPayload().(*SignalReq_Reject); ok { - return x.Reject - } - return nil -} - -func (m *SignalReq) GetGetRoomByGroupID() *SignalGetRoomByGroupIDReq { - if x, ok := m.GetPayload().(*SignalReq_GetRoomByGroupID); ok { - return x.GetRoomByGroupID - } - return nil -} - -func (m *SignalReq) GetOnRoomParticipantConnectedReq() *SignalOnRoomParticipantConnectedReq { - if x, ok := m.GetPayload().(*SignalReq_OnRoomParticipantConnectedReq); ok { - return x.OnRoomParticipantConnectedReq - } - return nil -} - -func (m *SignalReq) GetOnRoomParticipantDisconnectedReq() *SignalOnRoomParticipantDisconnectedReq { - if x, ok := m.GetPayload().(*SignalReq_OnRoomParticipantDisconnectedReq); ok { - return x.OnRoomParticipantDisconnectedReq - } - return nil -} - -func (m *SignalReq) GetGetTokenByRoomID() *SignalGetTokenByRoomIDReq { - if x, ok := m.GetPayload().(*SignalReq_GetTokenByRoomID); ok { - return x.GetTokenByRoomID - } - return nil -} - -// XXX_OneofFuncs is for the internal use of the proto package. -func (*SignalReq) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []any) { - return _SignalReq_OneofMarshaler, _SignalReq_OneofUnmarshaler, _SignalReq_OneofSizer, []any{ - (*SignalReq_Invite)(nil), - (*SignalReq_InviteInGroup)(nil), - (*SignalReq_Cancel)(nil), - (*SignalReq_Accept)(nil), - (*SignalReq_HungUp)(nil), - (*SignalReq_Reject)(nil), - (*SignalReq_GetRoomByGroupID)(nil), - (*SignalReq_OnRoomParticipantConnectedReq)(nil), - (*SignalReq_OnRoomParticipantDisconnectedReq)(nil), - (*SignalReq_GetTokenByRoomID)(nil), - } -} - -func _SignalReq_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { - m := msg.(*SignalReq) - // payload - switch x := m.Payload.(type) { - case *SignalReq_Invite: - b.EncodeVarint(1<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.Invite); err != nil { - return err - } - case *SignalReq_InviteInGroup: - b.EncodeVarint(2<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.InviteInGroup); err != nil { - return err - } - case *SignalReq_Cancel: - b.EncodeVarint(3<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.Cancel); err != nil { - return err - } - case *SignalReq_Accept: - b.EncodeVarint(4<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.Accept); err != nil { - return err - } - case *SignalReq_HungUp: - b.EncodeVarint(5<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.HungUp); err != nil { - return err - } - case *SignalReq_Reject: - b.EncodeVarint(6<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.Reject); err != nil { - return err - } - case *SignalReq_GetRoomByGroupID: - b.EncodeVarint(7<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.GetRoomByGroupID); err != nil { - return err - } - case *SignalReq_OnRoomParticipantConnectedReq: - b.EncodeVarint(8<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.OnRoomParticipantConnectedReq); err != nil { - return err - } - case *SignalReq_OnRoomParticipantDisconnectedReq: - b.EncodeVarint(9<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.OnRoomParticipantDisconnectedReq); err != nil { - return err - } - case *SignalReq_GetTokenByRoomID: - b.EncodeVarint(10<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.GetTokenByRoomID); err != nil { - return err - } - case nil: - default: - return fmt.Errorf("SignalReq.Payload has unexpected type %T", x) - } - return nil -} - -func _SignalReq_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { - m := msg.(*SignalReq) - switch tag { - case 1: // payload.invite - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalInviteReq) - err := b.DecodeMessage(msg) - m.Payload = &SignalReq_Invite{msg} - return true, err - case 2: // payload.inviteInGroup - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalInviteInGroupReq) - err := b.DecodeMessage(msg) - m.Payload = &SignalReq_InviteInGroup{msg} - return true, err - case 3: // payload.cancel - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalCancelReq) - err := b.DecodeMessage(msg) - m.Payload = &SignalReq_Cancel{msg} - return true, err - case 4: // payload.accept - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalAcceptReq) - err := b.DecodeMessage(msg) - m.Payload = &SignalReq_Accept{msg} - return true, err - case 5: // payload.hungUp - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalHungUpReq) - err := b.DecodeMessage(msg) - m.Payload = &SignalReq_HungUp{msg} - return true, err - case 6: // payload.reject - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalRejectReq) - err := b.DecodeMessage(msg) - m.Payload = &SignalReq_Reject{msg} - return true, err - case 7: // payload.getRoomByGroupID - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalGetRoomByGroupIDReq) - err := b.DecodeMessage(msg) - m.Payload = &SignalReq_GetRoomByGroupID{msg} - return true, err - case 8: // payload.onRoomParticipantConnectedReq - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalOnRoomParticipantConnectedReq) - err := b.DecodeMessage(msg) - m.Payload = &SignalReq_OnRoomParticipantConnectedReq{msg} - return true, err - case 9: // payload.onRoomParticipantDisconnectedReq - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalOnRoomParticipantDisconnectedReq) - err := b.DecodeMessage(msg) - m.Payload = &SignalReq_OnRoomParticipantDisconnectedReq{msg} - return true, err - case 10: // payload.getTokenByRoomID - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalGetTokenByRoomIDReq) - err := b.DecodeMessage(msg) - m.Payload = &SignalReq_GetTokenByRoomID{msg} - return true, err - default: - return false, nil - } -} - -func _SignalReq_OneofSizer(msg proto.Message) (n int) { - m := msg.(*SignalReq) - // payload - switch x := m.Payload.(type) { - case *SignalReq_Invite: - s := proto.Size(x.Invite) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalReq_InviteInGroup: - s := proto.Size(x.InviteInGroup) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalReq_Cancel: - s := proto.Size(x.Cancel) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalReq_Accept: - s := proto.Size(x.Accept) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalReq_HungUp: - s := proto.Size(x.HungUp) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalReq_Reject: - s := proto.Size(x.Reject) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalReq_GetRoomByGroupID: - s := proto.Size(x.GetRoomByGroupID) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalReq_OnRoomParticipantConnectedReq: - s := proto.Size(x.OnRoomParticipantConnectedReq) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalReq_OnRoomParticipantDisconnectedReq: - s := proto.Size(x.OnRoomParticipantDisconnectedReq) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalReq_GetTokenByRoomID: - s := proto.Size(x.GetTokenByRoomID) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case nil: - default: - panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) - } - return n -} - -type SignalResp struct { - // Types that are valid to be assigned to Payload: - // *SignalResp_Invite - // *SignalResp_InviteInGroup - // *SignalResp_Cancel - // *SignalResp_Accept - // *SignalResp_HungUp - // *SignalResp_Reject - // *SignalResp_GetRoomByGroupID - // *SignalResp_GetTokenByRoomID - Payload isSignalResp_Payload `protobuf_oneof:"payload"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalResp) Reset() { *m = SignalResp{} } -func (m *SignalResp) String() string { return proto.CompactTextString(m) } -func (*SignalResp) ProtoMessage() {} -func (*SignalResp) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{59} -} -func (m *SignalResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalResp.Unmarshal(m, b) -} -func (m *SignalResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalResp.Marshal(b, m, deterministic) -} -func (dst *SignalResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalResp.Merge(dst, src) -} -func (m *SignalResp) XXX_Size() int { - return xxx_messageInfo_SignalResp.Size(m) -} -func (m *SignalResp) XXX_DiscardUnknown() { - xxx_messageInfo_SignalResp.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalResp proto.InternalMessageInfo - -type isSignalResp_Payload interface { - isSignalResp_Payload() -} - -type SignalResp_Invite struct { - Invite *SignalInviteReply `protobuf:"bytes,1,opt,name=invite,oneof"` -} -type SignalResp_InviteInGroup struct { - InviteInGroup *SignalInviteInGroupReply `protobuf:"bytes,2,opt,name=inviteInGroup,oneof"` -} -type SignalResp_Cancel struct { - Cancel *SignalCancelReply `protobuf:"bytes,3,opt,name=cancel,oneof"` -} -type SignalResp_Accept struct { - Accept *SignalAcceptReply `protobuf:"bytes,4,opt,name=accept,oneof"` -} -type SignalResp_HungUp struct { - HungUp *SignalHungUpReply `protobuf:"bytes,5,opt,name=hungUp,oneof"` -} -type SignalResp_Reject struct { - Reject *SignalRejectReply `protobuf:"bytes,6,opt,name=reject,oneof"` -} -type SignalResp_GetRoomByGroupID struct { - GetRoomByGroupID *SignalGetRoomByGroupIDReply `protobuf:"bytes,7,opt,name=getRoomByGroupID,oneof"` -} -type SignalResp_GetTokenByRoomID struct { - GetTokenByRoomID *SignalGetTokenByRoomIDReply `protobuf:"bytes,8,opt,name=getTokenByRoomID,oneof"` -} - -func (*SignalResp_Invite) isSignalResp_Payload() {} -func (*SignalResp_InviteInGroup) isSignalResp_Payload() {} -func (*SignalResp_Cancel) isSignalResp_Payload() {} -func (*SignalResp_Accept) isSignalResp_Payload() {} -func (*SignalResp_HungUp) isSignalResp_Payload() {} -func (*SignalResp_Reject) isSignalResp_Payload() {} -func (*SignalResp_GetRoomByGroupID) isSignalResp_Payload() {} -func (*SignalResp_GetTokenByRoomID) isSignalResp_Payload() {} - -func (m *SignalResp) GetPayload() isSignalResp_Payload { - if m != nil { - return m.Payload - } - return nil -} - -func (m *SignalResp) GetInvite() *SignalInviteReply { - if x, ok := m.GetPayload().(*SignalResp_Invite); ok { - return x.Invite - } - return nil -} - -func (m *SignalResp) GetInviteInGroup() *SignalInviteInGroupReply { - if x, ok := m.GetPayload().(*SignalResp_InviteInGroup); ok { - return x.InviteInGroup - } - return nil -} - -func (m *SignalResp) GetCancel() *SignalCancelReply { - if x, ok := m.GetPayload().(*SignalResp_Cancel); ok { - return x.Cancel - } - return nil -} - -func (m *SignalResp) GetAccept() *SignalAcceptReply { - if x, ok := m.GetPayload().(*SignalResp_Accept); ok { - return x.Accept - } - return nil -} - -func (m *SignalResp) GetHungUp() *SignalHungUpReply { - if x, ok := m.GetPayload().(*SignalResp_HungUp); ok { - return x.HungUp - } - return nil -} - -func (m *SignalResp) GetReject() *SignalRejectReply { - if x, ok := m.GetPayload().(*SignalResp_Reject); ok { - return x.Reject - } - return nil -} - -func (m *SignalResp) GetGetRoomByGroupID() *SignalGetRoomByGroupIDReply { - if x, ok := m.GetPayload().(*SignalResp_GetRoomByGroupID); ok { - return x.GetRoomByGroupID - } - return nil -} - -func (m *SignalResp) GetGetTokenByRoomID() *SignalGetTokenByRoomIDReply { - if x, ok := m.GetPayload().(*SignalResp_GetTokenByRoomID); ok { - return x.GetTokenByRoomID - } - return nil -} - -// XXX_OneofFuncs is for the internal use of the proto package. -func (*SignalResp) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []any) { - return _SignalResp_OneofMarshaler, _SignalResp_OneofUnmarshaler, _SignalResp_OneofSizer, []any{ - (*SignalResp_Invite)(nil), - (*SignalResp_InviteInGroup)(nil), - (*SignalResp_Cancel)(nil), - (*SignalResp_Accept)(nil), - (*SignalResp_HungUp)(nil), - (*SignalResp_Reject)(nil), - (*SignalResp_GetRoomByGroupID)(nil), - (*SignalResp_GetTokenByRoomID)(nil), - } -} - -func _SignalResp_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { - m := msg.(*SignalResp) - // payload - switch x := m.Payload.(type) { - case *SignalResp_Invite: - b.EncodeVarint(1<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.Invite); err != nil { - return err - } - case *SignalResp_InviteInGroup: - b.EncodeVarint(2<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.InviteInGroup); err != nil { - return err - } - case *SignalResp_Cancel: - b.EncodeVarint(3<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.Cancel); err != nil { - return err - } - case *SignalResp_Accept: - b.EncodeVarint(4<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.Accept); err != nil { - return err - } - case *SignalResp_HungUp: - b.EncodeVarint(5<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.HungUp); err != nil { - return err - } - case *SignalResp_Reject: - b.EncodeVarint(6<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.Reject); err != nil { - return err - } - case *SignalResp_GetRoomByGroupID: - b.EncodeVarint(7<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.GetRoomByGroupID); err != nil { - return err - } - case *SignalResp_GetTokenByRoomID: - b.EncodeVarint(8<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.GetTokenByRoomID); err != nil { - return err - } - case nil: - default: - return fmt.Errorf("SignalResp.Payload has unexpected type %T", x) - } - return nil -} - -func _SignalResp_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { - m := msg.(*SignalResp) - switch tag { - case 1: // payload.invite - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalInviteReply) - err := b.DecodeMessage(msg) - m.Payload = &SignalResp_Invite{msg} - return true, err - case 2: // payload.inviteInGroup - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalInviteInGroupReply) - err := b.DecodeMessage(msg) - m.Payload = &SignalResp_InviteInGroup{msg} - return true, err - case 3: // payload.cancel - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalCancelReply) - err := b.DecodeMessage(msg) - m.Payload = &SignalResp_Cancel{msg} - return true, err - case 4: // payload.accept - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalAcceptReply) - err := b.DecodeMessage(msg) - m.Payload = &SignalResp_Accept{msg} - return true, err - case 5: // payload.hungUp - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalHungUpReply) - err := b.DecodeMessage(msg) - m.Payload = &SignalResp_HungUp{msg} - return true, err - case 6: // payload.reject - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalRejectReply) - err := b.DecodeMessage(msg) - m.Payload = &SignalResp_Reject{msg} - return true, err - case 7: // payload.getRoomByGroupID - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalGetRoomByGroupIDReply) - err := b.DecodeMessage(msg) - m.Payload = &SignalResp_GetRoomByGroupID{msg} - return true, err - case 8: // payload.getTokenByRoomID - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(SignalGetTokenByRoomIDReply) - err := b.DecodeMessage(msg) - m.Payload = &SignalResp_GetTokenByRoomID{msg} - return true, err - default: - return false, nil - } -} - -func _SignalResp_OneofSizer(msg proto.Message) (n int) { - m := msg.(*SignalResp) - // payload - switch x := m.Payload.(type) { - case *SignalResp_Invite: - s := proto.Size(x.Invite) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalResp_InviteInGroup: - s := proto.Size(x.InviteInGroup) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalResp_Cancel: - s := proto.Size(x.Cancel) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalResp_Accept: - s := proto.Size(x.Accept) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalResp_HungUp: - s := proto.Size(x.HungUp) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalResp_Reject: - s := proto.Size(x.Reject) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalResp_GetRoomByGroupID: - s := proto.Size(x.GetRoomByGroupID) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case *SignalResp_GetTokenByRoomID: - s := proto.Size(x.GetTokenByRoomID) - n += 1 // tag and wire - n += proto.SizeVarint(uint64(s)) - n += s - case nil: - default: - panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) - } - return n -} - -type InvitationInfo struct { - InviterUserID string `protobuf:"bytes,1,opt,name=inviterUserID" json:"inviterUserID,omitempty"` - InviteeUserIDList []string `protobuf:"bytes,2,rep,name=inviteeUserIDList" json:"inviteeUserIDList,omitempty"` - CustomData string `protobuf:"bytes,3,opt,name=customData" json:"customData,omitempty"` - GroupID string `protobuf:"bytes,4,opt,name=groupID" json:"groupID,omitempty"` - RoomID string `protobuf:"bytes,5,opt,name=roomID" json:"roomID,omitempty"` - Timeout int32 `protobuf:"varint,6,opt,name=timeout" json:"timeout,omitempty"` - MediaType string `protobuf:"bytes,7,opt,name=mediaType" json:"mediaType,omitempty"` - PlatformID int32 `protobuf:"varint,8,opt,name=platformID" json:"platformID,omitempty"` - SessionType int32 `protobuf:"varint,9,opt,name=sessionType" json:"sessionType,omitempty"` - InitiateTime int32 `protobuf:"varint,10,opt,name=initiateTime" json:"initiateTime,omitempty"` - BusyLineUserIDList []string `protobuf:"bytes,11,rep,name=busyLineUserIDList" json:"busyLineUserIDList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *InvitationInfo) Reset() { *m = InvitationInfo{} } -func (m *InvitationInfo) String() string { return proto.CompactTextString(m) } -func (*InvitationInfo) ProtoMessage() {} -func (*InvitationInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{60} -} -func (m *InvitationInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_InvitationInfo.Unmarshal(m, b) -} -func (m *InvitationInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_InvitationInfo.Marshal(b, m, deterministic) -} -func (dst *InvitationInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_InvitationInfo.Merge(dst, src) -} -func (m *InvitationInfo) XXX_Size() int { - return xxx_messageInfo_InvitationInfo.Size(m) -} -func (m *InvitationInfo) XXX_DiscardUnknown() { - xxx_messageInfo_InvitationInfo.DiscardUnknown(m) -} - -var xxx_messageInfo_InvitationInfo proto.InternalMessageInfo - -func (m *InvitationInfo) GetInviterUserID() string { - if m != nil { - return m.InviterUserID - } - return "" -} - -func (m *InvitationInfo) GetInviteeUserIDList() []string { - if m != nil { - return m.InviteeUserIDList - } - return nil -} - -func (m *InvitationInfo) GetCustomData() string { - if m != nil { - return m.CustomData - } - return "" -} - -func (m *InvitationInfo) GetGroupID() string { - if m != nil { - return m.GroupID - } - return "" -} - -func (m *InvitationInfo) GetRoomID() string { - if m != nil { - return m.RoomID - } - return "" -} - -func (m *InvitationInfo) GetTimeout() int32 { - if m != nil { - return m.Timeout - } - return 0 -} - -func (m *InvitationInfo) GetMediaType() string { - if m != nil { - return m.MediaType - } - return "" -} - -func (m *InvitationInfo) GetPlatformID() int32 { - if m != nil { - return m.PlatformID - } - return 0 -} - -func (m *InvitationInfo) GetSessionType() int32 { - if m != nil { - return m.SessionType - } - return 0 -} - -func (m *InvitationInfo) GetInitiateTime() int32 { - if m != nil { - return m.InitiateTime - } - return 0 -} - -func (m *InvitationInfo) GetBusyLineUserIDList() []string { - if m != nil { - return m.BusyLineUserIDList - } - return nil -} - -type ParticipantMetaData struct { - GroupInfo *GroupInfo `protobuf:"bytes,1,opt,name=groupInfo" json:"groupInfo,omitempty"` - GroupMemberInfo *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=groupMemberInfo" json:"groupMemberInfo,omitempty"` - UserInfo *PublicUserInfo `protobuf:"bytes,3,opt,name=userInfo" json:"userInfo,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *ParticipantMetaData) Reset() { *m = ParticipantMetaData{} } -func (m *ParticipantMetaData) String() string { return proto.CompactTextString(m) } -func (*ParticipantMetaData) ProtoMessage() {} -func (*ParticipantMetaData) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{61} -} -func (m *ParticipantMetaData) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ParticipantMetaData.Unmarshal(m, b) -} -func (m *ParticipantMetaData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ParticipantMetaData.Marshal(b, m, deterministic) -} -func (dst *ParticipantMetaData) XXX_Merge(src proto.Message) { - xxx_messageInfo_ParticipantMetaData.Merge(dst, src) -} -func (m *ParticipantMetaData) XXX_Size() int { - return xxx_messageInfo_ParticipantMetaData.Size(m) -} -func (m *ParticipantMetaData) XXX_DiscardUnknown() { - xxx_messageInfo_ParticipantMetaData.DiscardUnknown(m) -} - -var xxx_messageInfo_ParticipantMetaData proto.InternalMessageInfo - -func (m *ParticipantMetaData) GetGroupInfo() *GroupInfo { - if m != nil { - return m.GroupInfo - } - return nil -} - -func (m *ParticipantMetaData) GetGroupMemberInfo() *GroupMemberFullInfo { - if m != nil { - return m.GroupMemberInfo - } - return nil -} - -func (m *ParticipantMetaData) GetUserInfo() *PublicUserInfo { - if m != nil { - return m.UserInfo - } - return nil -} - -type SignalInviteReq struct { - OpUserID string `protobuf:"bytes,1,opt,name=opUserID" json:"opUserID,omitempty"` - Invitation *InvitationInfo `protobuf:"bytes,2,opt,name=invitation" json:"invitation,omitempty"` - OfflinePushInfo *OfflinePushInfo `protobuf:"bytes,3,opt,name=offlinePushInfo" json:"offlinePushInfo,omitempty"` - Participant *ParticipantMetaData `protobuf:"bytes,4,opt,name=participant" json:"participant,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalInviteReq) Reset() { *m = SignalInviteReq{} } -func (m *SignalInviteReq) String() string { return proto.CompactTextString(m) } -func (*SignalInviteReq) ProtoMessage() {} -func (*SignalInviteReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{62} -} -func (m *SignalInviteReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalInviteReq.Unmarshal(m, b) -} -func (m *SignalInviteReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalInviteReq.Marshal(b, m, deterministic) -} -func (dst *SignalInviteReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalInviteReq.Merge(dst, src) -} -func (m *SignalInviteReq) XXX_Size() int { - return xxx_messageInfo_SignalInviteReq.Size(m) -} -func (m *SignalInviteReq) XXX_DiscardUnknown() { - xxx_messageInfo_SignalInviteReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalInviteReq proto.InternalMessageInfo - -func (m *SignalInviteReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *SignalInviteReq) GetInvitation() *InvitationInfo { - if m != nil { - return m.Invitation - } - return nil -} - -func (m *SignalInviteReq) GetOfflinePushInfo() *OfflinePushInfo { - if m != nil { - return m.OfflinePushInfo - } - return nil -} - -func (m *SignalInviteReq) GetParticipant() *ParticipantMetaData { - if m != nil { - return m.Participant - } - return nil -} - -type SignalInviteReply struct { - Token string `protobuf:"bytes,1,opt,name=token" json:"token,omitempty"` - RoomID string `protobuf:"bytes,2,opt,name=roomID" json:"roomID,omitempty"` - LiveURL string `protobuf:"bytes,3,opt,name=liveURL" json:"liveURL,omitempty"` - BusyLineUserIDList []string `protobuf:"bytes,4,rep,name=busyLineUserIDList" json:"busyLineUserIDList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalInviteReply) Reset() { *m = SignalInviteReply{} } -func (m *SignalInviteReply) String() string { return proto.CompactTextString(m) } -func (*SignalInviteReply) ProtoMessage() {} -func (*SignalInviteReply) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{63} -} -func (m *SignalInviteReply) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalInviteReply.Unmarshal(m, b) -} -func (m *SignalInviteReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalInviteReply.Marshal(b, m, deterministic) -} -func (dst *SignalInviteReply) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalInviteReply.Merge(dst, src) -} -func (m *SignalInviteReply) XXX_Size() int { - return xxx_messageInfo_SignalInviteReply.Size(m) -} -func (m *SignalInviteReply) XXX_DiscardUnknown() { - xxx_messageInfo_SignalInviteReply.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalInviteReply proto.InternalMessageInfo - -func (m *SignalInviteReply) GetToken() string { - if m != nil { - return m.Token - } - return "" -} - -func (m *SignalInviteReply) GetRoomID() string { - if m != nil { - return m.RoomID - } - return "" -} - -func (m *SignalInviteReply) GetLiveURL() string { - if m != nil { - return m.LiveURL - } - return "" -} - -func (m *SignalInviteReply) GetBusyLineUserIDList() []string { - if m != nil { - return m.BusyLineUserIDList - } - return nil -} - -type SignalInviteInGroupReq struct { - OpUserID string `protobuf:"bytes,1,opt,name=opUserID" json:"opUserID,omitempty"` - Invitation *InvitationInfo `protobuf:"bytes,2,opt,name=invitation" json:"invitation,omitempty"` - OfflinePushInfo *OfflinePushInfo `protobuf:"bytes,3,opt,name=offlinePushInfo" json:"offlinePushInfo,omitempty"` - Participant *ParticipantMetaData `protobuf:"bytes,4,opt,name=participant" json:"participant,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalInviteInGroupReq) Reset() { *m = SignalInviteInGroupReq{} } -func (m *SignalInviteInGroupReq) String() string { return proto.CompactTextString(m) } -func (*SignalInviteInGroupReq) ProtoMessage() {} -func (*SignalInviteInGroupReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{64} -} -func (m *SignalInviteInGroupReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalInviteInGroupReq.Unmarshal(m, b) -} -func (m *SignalInviteInGroupReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalInviteInGroupReq.Marshal(b, m, deterministic) -} -func (dst *SignalInviteInGroupReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalInviteInGroupReq.Merge(dst, src) -} -func (m *SignalInviteInGroupReq) XXX_Size() int { - return xxx_messageInfo_SignalInviteInGroupReq.Size(m) -} -func (m *SignalInviteInGroupReq) XXX_DiscardUnknown() { - xxx_messageInfo_SignalInviteInGroupReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalInviteInGroupReq proto.InternalMessageInfo - -func (m *SignalInviteInGroupReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *SignalInviteInGroupReq) GetInvitation() *InvitationInfo { - if m != nil { - return m.Invitation - } - return nil -} - -func (m *SignalInviteInGroupReq) GetOfflinePushInfo() *OfflinePushInfo { - if m != nil { - return m.OfflinePushInfo - } - return nil -} - -func (m *SignalInviteInGroupReq) GetParticipant() *ParticipantMetaData { - if m != nil { - return m.Participant - } - return nil -} - -type SignalInviteInGroupReply struct { - Token string `protobuf:"bytes,1,opt,name=token" json:"token,omitempty"` - RoomID string `protobuf:"bytes,2,opt,name=roomID" json:"roomID,omitempty"` - LiveURL string `protobuf:"bytes,3,opt,name=liveURL" json:"liveURL,omitempty"` - BusyLineUserIDList []string `protobuf:"bytes,4,rep,name=busyLineUserIDList" json:"busyLineUserIDList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalInviteInGroupReply) Reset() { *m = SignalInviteInGroupReply{} } -func (m *SignalInviteInGroupReply) String() string { return proto.CompactTextString(m) } -func (*SignalInviteInGroupReply) ProtoMessage() {} -func (*SignalInviteInGroupReply) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{65} -} -func (m *SignalInviteInGroupReply) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalInviteInGroupReply.Unmarshal(m, b) -} -func (m *SignalInviteInGroupReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalInviteInGroupReply.Marshal(b, m, deterministic) -} -func (dst *SignalInviteInGroupReply) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalInviteInGroupReply.Merge(dst, src) -} -func (m *SignalInviteInGroupReply) XXX_Size() int { - return xxx_messageInfo_SignalInviteInGroupReply.Size(m) -} -func (m *SignalInviteInGroupReply) XXX_DiscardUnknown() { - xxx_messageInfo_SignalInviteInGroupReply.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalInviteInGroupReply proto.InternalMessageInfo - -func (m *SignalInviteInGroupReply) GetToken() string { - if m != nil { - return m.Token - } - return "" -} - -func (m *SignalInviteInGroupReply) GetRoomID() string { - if m != nil { - return m.RoomID - } - return "" -} - -func (m *SignalInviteInGroupReply) GetLiveURL() string { - if m != nil { - return m.LiveURL - } - return "" -} - -func (m *SignalInviteInGroupReply) GetBusyLineUserIDList() []string { - if m != nil { - return m.BusyLineUserIDList - } - return nil -} - -type SignalCancelReq struct { - OpUserID string `protobuf:"bytes,1,opt,name=opUserID" json:"opUserID,omitempty"` - Invitation *InvitationInfo `protobuf:"bytes,2,opt,name=invitation" json:"invitation,omitempty"` - OfflinePushInfo *OfflinePushInfo `protobuf:"bytes,3,opt,name=offlinePushInfo" json:"offlinePushInfo,omitempty"` - Participant *ParticipantMetaData `protobuf:"bytes,4,opt,name=participant" json:"participant,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalCancelReq) Reset() { *m = SignalCancelReq{} } -func (m *SignalCancelReq) String() string { return proto.CompactTextString(m) } -func (*SignalCancelReq) ProtoMessage() {} -func (*SignalCancelReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{66} -} -func (m *SignalCancelReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalCancelReq.Unmarshal(m, b) -} -func (m *SignalCancelReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalCancelReq.Marshal(b, m, deterministic) -} -func (dst *SignalCancelReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalCancelReq.Merge(dst, src) -} -func (m *SignalCancelReq) XXX_Size() int { - return xxx_messageInfo_SignalCancelReq.Size(m) -} -func (m *SignalCancelReq) XXX_DiscardUnknown() { - xxx_messageInfo_SignalCancelReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalCancelReq proto.InternalMessageInfo - -func (m *SignalCancelReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *SignalCancelReq) GetInvitation() *InvitationInfo { - if m != nil { - return m.Invitation - } - return nil -} - -func (m *SignalCancelReq) GetOfflinePushInfo() *OfflinePushInfo { - if m != nil { - return m.OfflinePushInfo - } - return nil -} - -func (m *SignalCancelReq) GetParticipant() *ParticipantMetaData { - if m != nil { - return m.Participant - } - return nil -} - -type SignalCancelReply struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalCancelReply) Reset() { *m = SignalCancelReply{} } -func (m *SignalCancelReply) String() string { return proto.CompactTextString(m) } -func (*SignalCancelReply) ProtoMessage() {} -func (*SignalCancelReply) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{67} -} -func (m *SignalCancelReply) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalCancelReply.Unmarshal(m, b) -} -func (m *SignalCancelReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalCancelReply.Marshal(b, m, deterministic) -} -func (dst *SignalCancelReply) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalCancelReply.Merge(dst, src) -} -func (m *SignalCancelReply) XXX_Size() int { - return xxx_messageInfo_SignalCancelReply.Size(m) -} -func (m *SignalCancelReply) XXX_DiscardUnknown() { - xxx_messageInfo_SignalCancelReply.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalCancelReply proto.InternalMessageInfo - -type SignalAcceptReq struct { - OpUserID string `protobuf:"bytes,1,opt,name=opUserID" json:"opUserID,omitempty"` - Invitation *InvitationInfo `protobuf:"bytes,2,opt,name=invitation" json:"invitation,omitempty"` - OfflinePushInfo *OfflinePushInfo `protobuf:"bytes,3,opt,name=offlinePushInfo" json:"offlinePushInfo,omitempty"` - Participant *ParticipantMetaData `protobuf:"bytes,4,opt,name=participant" json:"participant,omitempty"` - OpUserPlatformID int32 `protobuf:"varint,5,opt,name=opUserPlatformID" json:"opUserPlatformID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalAcceptReq) Reset() { *m = SignalAcceptReq{} } -func (m *SignalAcceptReq) String() string { return proto.CompactTextString(m) } -func (*SignalAcceptReq) ProtoMessage() {} -func (*SignalAcceptReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{68} -} -func (m *SignalAcceptReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalAcceptReq.Unmarshal(m, b) -} -func (m *SignalAcceptReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalAcceptReq.Marshal(b, m, deterministic) -} -func (dst *SignalAcceptReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalAcceptReq.Merge(dst, src) -} -func (m *SignalAcceptReq) XXX_Size() int { - return xxx_messageInfo_SignalAcceptReq.Size(m) -} -func (m *SignalAcceptReq) XXX_DiscardUnknown() { - xxx_messageInfo_SignalAcceptReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalAcceptReq proto.InternalMessageInfo - -func (m *SignalAcceptReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *SignalAcceptReq) GetInvitation() *InvitationInfo { - if m != nil { - return m.Invitation - } - return nil -} - -func (m *SignalAcceptReq) GetOfflinePushInfo() *OfflinePushInfo { - if m != nil { - return m.OfflinePushInfo - } - return nil -} - -func (m *SignalAcceptReq) GetParticipant() *ParticipantMetaData { - if m != nil { - return m.Participant - } - return nil -} - -func (m *SignalAcceptReq) GetOpUserPlatformID() int32 { - if m != nil { - return m.OpUserPlatformID - } - return 0 -} - -type SignalAcceptReply struct { - Token string `protobuf:"bytes,1,opt,name=token" json:"token,omitempty"` - RoomID string `protobuf:"bytes,2,opt,name=roomID" json:"roomID,omitempty"` - LiveURL string `protobuf:"bytes,3,opt,name=liveURL" json:"liveURL,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalAcceptReply) Reset() { *m = SignalAcceptReply{} } -func (m *SignalAcceptReply) String() string { return proto.CompactTextString(m) } -func (*SignalAcceptReply) ProtoMessage() {} -func (*SignalAcceptReply) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{69} -} -func (m *SignalAcceptReply) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalAcceptReply.Unmarshal(m, b) -} -func (m *SignalAcceptReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalAcceptReply.Marshal(b, m, deterministic) -} -func (dst *SignalAcceptReply) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalAcceptReply.Merge(dst, src) -} -func (m *SignalAcceptReply) XXX_Size() int { - return xxx_messageInfo_SignalAcceptReply.Size(m) -} -func (m *SignalAcceptReply) XXX_DiscardUnknown() { - xxx_messageInfo_SignalAcceptReply.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalAcceptReply proto.InternalMessageInfo - -func (m *SignalAcceptReply) GetToken() string { - if m != nil { - return m.Token - } - return "" -} - -func (m *SignalAcceptReply) GetRoomID() string { - if m != nil { - return m.RoomID - } - return "" -} - -func (m *SignalAcceptReply) GetLiveURL() string { - if m != nil { - return m.LiveURL - } - return "" -} - -type SignalHungUpReq struct { - OpUserID string `protobuf:"bytes,1,opt,name=opUserID" json:"opUserID,omitempty"` - Invitation *InvitationInfo `protobuf:"bytes,2,opt,name=invitation" json:"invitation,omitempty"` - OfflinePushInfo *OfflinePushInfo `protobuf:"bytes,3,opt,name=offlinePushInfo" json:"offlinePushInfo,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalHungUpReq) Reset() { *m = SignalHungUpReq{} } -func (m *SignalHungUpReq) String() string { return proto.CompactTextString(m) } -func (*SignalHungUpReq) ProtoMessage() {} -func (*SignalHungUpReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{70} -} -func (m *SignalHungUpReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalHungUpReq.Unmarshal(m, b) -} -func (m *SignalHungUpReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalHungUpReq.Marshal(b, m, deterministic) -} -func (dst *SignalHungUpReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalHungUpReq.Merge(dst, src) -} -func (m *SignalHungUpReq) XXX_Size() int { - return xxx_messageInfo_SignalHungUpReq.Size(m) -} -func (m *SignalHungUpReq) XXX_DiscardUnknown() { - xxx_messageInfo_SignalHungUpReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalHungUpReq proto.InternalMessageInfo - -func (m *SignalHungUpReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *SignalHungUpReq) GetInvitation() *InvitationInfo { - if m != nil { - return m.Invitation - } - return nil -} - -func (m *SignalHungUpReq) GetOfflinePushInfo() *OfflinePushInfo { - if m != nil { - return m.OfflinePushInfo - } - return nil -} - -type SignalHungUpReply struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalHungUpReply) Reset() { *m = SignalHungUpReply{} } -func (m *SignalHungUpReply) String() string { return proto.CompactTextString(m) } -func (*SignalHungUpReply) ProtoMessage() {} -func (*SignalHungUpReply) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{71} -} -func (m *SignalHungUpReply) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalHungUpReply.Unmarshal(m, b) -} -func (m *SignalHungUpReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalHungUpReply.Marshal(b, m, deterministic) -} -func (dst *SignalHungUpReply) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalHungUpReply.Merge(dst, src) -} -func (m *SignalHungUpReply) XXX_Size() int { - return xxx_messageInfo_SignalHungUpReply.Size(m) -} -func (m *SignalHungUpReply) XXX_DiscardUnknown() { - xxx_messageInfo_SignalHungUpReply.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalHungUpReply proto.InternalMessageInfo - -type SignalRejectReq struct { - OpUserID string `protobuf:"bytes,1,opt,name=opUserID" json:"opUserID,omitempty"` - Invitation *InvitationInfo `protobuf:"bytes,2,opt,name=invitation" json:"invitation,omitempty"` - OfflinePushInfo *OfflinePushInfo `protobuf:"bytes,3,opt,name=offlinePushInfo" json:"offlinePushInfo,omitempty"` - Participant *ParticipantMetaData `protobuf:"bytes,4,opt,name=participant" json:"participant,omitempty"` - OpUserPlatformID int32 `protobuf:"varint,5,opt,name=opUserPlatformID" json:"opUserPlatformID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalRejectReq) Reset() { *m = SignalRejectReq{} } -func (m *SignalRejectReq) String() string { return proto.CompactTextString(m) } -func (*SignalRejectReq) ProtoMessage() {} -func (*SignalRejectReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{72} -} -func (m *SignalRejectReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalRejectReq.Unmarshal(m, b) -} -func (m *SignalRejectReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalRejectReq.Marshal(b, m, deterministic) -} -func (dst *SignalRejectReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalRejectReq.Merge(dst, src) -} -func (m *SignalRejectReq) XXX_Size() int { - return xxx_messageInfo_SignalRejectReq.Size(m) -} -func (m *SignalRejectReq) XXX_DiscardUnknown() { - xxx_messageInfo_SignalRejectReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalRejectReq proto.InternalMessageInfo - -func (m *SignalRejectReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *SignalRejectReq) GetInvitation() *InvitationInfo { - if m != nil { - return m.Invitation - } - return nil -} - -func (m *SignalRejectReq) GetOfflinePushInfo() *OfflinePushInfo { - if m != nil { - return m.OfflinePushInfo - } - return nil -} - -func (m *SignalRejectReq) GetParticipant() *ParticipantMetaData { - if m != nil { - return m.Participant - } - return nil -} - -func (m *SignalRejectReq) GetOpUserPlatformID() int32 { - if m != nil { - return m.OpUserPlatformID - } - return 0 -} - -type SignalRejectReply struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalRejectReply) Reset() { *m = SignalRejectReply{} } -func (m *SignalRejectReply) String() string { return proto.CompactTextString(m) } -func (*SignalRejectReply) ProtoMessage() {} -func (*SignalRejectReply) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{73} -} -func (m *SignalRejectReply) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalRejectReply.Unmarshal(m, b) -} -func (m *SignalRejectReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalRejectReply.Marshal(b, m, deterministic) -} -func (dst *SignalRejectReply) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalRejectReply.Merge(dst, src) -} -func (m *SignalRejectReply) XXX_Size() int { - return xxx_messageInfo_SignalRejectReply.Size(m) -} -func (m *SignalRejectReply) XXX_DiscardUnknown() { - xxx_messageInfo_SignalRejectReply.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalRejectReply proto.InternalMessageInfo - -type SignalGetRoomByGroupIDReq struct { - OpUserID string `protobuf:"bytes,1,opt,name=opUserID" json:"opUserID,omitempty"` - GroupID string `protobuf:"bytes,2,opt,name=groupID" json:"groupID,omitempty"` - Participant *ParticipantMetaData `protobuf:"bytes,3,opt,name=participant" json:"participant,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalGetRoomByGroupIDReq) Reset() { *m = SignalGetRoomByGroupIDReq{} } -func (m *SignalGetRoomByGroupIDReq) String() string { return proto.CompactTextString(m) } -func (*SignalGetRoomByGroupIDReq) ProtoMessage() {} -func (*SignalGetRoomByGroupIDReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{74} -} -func (m *SignalGetRoomByGroupIDReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalGetRoomByGroupIDReq.Unmarshal(m, b) -} -func (m *SignalGetRoomByGroupIDReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalGetRoomByGroupIDReq.Marshal(b, m, deterministic) -} -func (dst *SignalGetRoomByGroupIDReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalGetRoomByGroupIDReq.Merge(dst, src) -} -func (m *SignalGetRoomByGroupIDReq) XXX_Size() int { - return xxx_messageInfo_SignalGetRoomByGroupIDReq.Size(m) -} -func (m *SignalGetRoomByGroupIDReq) XXX_DiscardUnknown() { - xxx_messageInfo_SignalGetRoomByGroupIDReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalGetRoomByGroupIDReq proto.InternalMessageInfo - -func (m *SignalGetRoomByGroupIDReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *SignalGetRoomByGroupIDReq) GetGroupID() string { - if m != nil { - return m.GroupID - } - return "" -} - -func (m *SignalGetRoomByGroupIDReq) GetParticipant() *ParticipantMetaData { - if m != nil { - return m.Participant - } - return nil -} - -type SignalGetRoomByGroupIDReply struct { - Invitation *InvitationInfo `protobuf:"bytes,1,opt,name=invitation" json:"invitation,omitempty"` - Participant []*ParticipantMetaData `protobuf:"bytes,2,rep,name=participant" json:"participant,omitempty"` - RoomID string `protobuf:"bytes,3,opt,name=roomID" json:"roomID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalGetRoomByGroupIDReply) Reset() { *m = SignalGetRoomByGroupIDReply{} } -func (m *SignalGetRoomByGroupIDReply) String() string { return proto.CompactTextString(m) } -func (*SignalGetRoomByGroupIDReply) ProtoMessage() {} -func (*SignalGetRoomByGroupIDReply) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{75} -} -func (m *SignalGetRoomByGroupIDReply) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalGetRoomByGroupIDReply.Unmarshal(m, b) -} -func (m *SignalGetRoomByGroupIDReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalGetRoomByGroupIDReply.Marshal(b, m, deterministic) -} -func (dst *SignalGetRoomByGroupIDReply) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalGetRoomByGroupIDReply.Merge(dst, src) -} -func (m *SignalGetRoomByGroupIDReply) XXX_Size() int { - return xxx_messageInfo_SignalGetRoomByGroupIDReply.Size(m) -} -func (m *SignalGetRoomByGroupIDReply) XXX_DiscardUnknown() { - xxx_messageInfo_SignalGetRoomByGroupIDReply.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalGetRoomByGroupIDReply proto.InternalMessageInfo - -func (m *SignalGetRoomByGroupIDReply) GetInvitation() *InvitationInfo { - if m != nil { - return m.Invitation - } - return nil -} - -func (m *SignalGetRoomByGroupIDReply) GetParticipant() []*ParticipantMetaData { - if m != nil { - return m.Participant - } - return nil -} - -func (m *SignalGetRoomByGroupIDReply) GetRoomID() string { - if m != nil { - return m.RoomID - } - return "" -} - -type SignalOnRoomParticipantConnectedReq struct { - Invitation *InvitationInfo `protobuf:"bytes,1,opt,name=invitation" json:"invitation,omitempty"` - Participant []*ParticipantMetaData `protobuf:"bytes,2,rep,name=participant" json:"participant,omitempty"` - GroupID string `protobuf:"bytes,3,opt,name=groupID" json:"groupID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalOnRoomParticipantConnectedReq) Reset() { *m = SignalOnRoomParticipantConnectedReq{} } -func (m *SignalOnRoomParticipantConnectedReq) String() string { return proto.CompactTextString(m) } -func (*SignalOnRoomParticipantConnectedReq) ProtoMessage() {} -func (*SignalOnRoomParticipantConnectedReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{76} -} -func (m *SignalOnRoomParticipantConnectedReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalOnRoomParticipantConnectedReq.Unmarshal(m, b) -} -func (m *SignalOnRoomParticipantConnectedReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalOnRoomParticipantConnectedReq.Marshal(b, m, deterministic) -} -func (dst *SignalOnRoomParticipantConnectedReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalOnRoomParticipantConnectedReq.Merge(dst, src) -} -func (m *SignalOnRoomParticipantConnectedReq) XXX_Size() int { - return xxx_messageInfo_SignalOnRoomParticipantConnectedReq.Size(m) -} -func (m *SignalOnRoomParticipantConnectedReq) XXX_DiscardUnknown() { - xxx_messageInfo_SignalOnRoomParticipantConnectedReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalOnRoomParticipantConnectedReq proto.InternalMessageInfo - -func (m *SignalOnRoomParticipantConnectedReq) GetInvitation() *InvitationInfo { - if m != nil { - return m.Invitation - } - return nil -} - -func (m *SignalOnRoomParticipantConnectedReq) GetParticipant() []*ParticipantMetaData { - if m != nil { - return m.Participant - } - return nil -} - -func (m *SignalOnRoomParticipantConnectedReq) GetGroupID() string { - if m != nil { - return m.GroupID - } - return "" -} - -type SignalOnRoomParticipantDisconnectedReq struct { - Invitation *InvitationInfo `protobuf:"bytes,1,opt,name=invitation" json:"invitation,omitempty"` - Participant []*ParticipantMetaData `protobuf:"bytes,2,rep,name=participant" json:"participant,omitempty"` - GroupID string `protobuf:"bytes,3,opt,name=groupID" json:"groupID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalOnRoomParticipantDisconnectedReq) Reset() { - *m = SignalOnRoomParticipantDisconnectedReq{} -} -func (m *SignalOnRoomParticipantDisconnectedReq) String() string { return proto.CompactTextString(m) } -func (*SignalOnRoomParticipantDisconnectedReq) ProtoMessage() {} -func (*SignalOnRoomParticipantDisconnectedReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{77} -} -func (m *SignalOnRoomParticipantDisconnectedReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalOnRoomParticipantDisconnectedReq.Unmarshal(m, b) -} -func (m *SignalOnRoomParticipantDisconnectedReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalOnRoomParticipantDisconnectedReq.Marshal(b, m, deterministic) -} -func (dst *SignalOnRoomParticipantDisconnectedReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalOnRoomParticipantDisconnectedReq.Merge(dst, src) -} -func (m *SignalOnRoomParticipantDisconnectedReq) XXX_Size() int { - return xxx_messageInfo_SignalOnRoomParticipantDisconnectedReq.Size(m) -} -func (m *SignalOnRoomParticipantDisconnectedReq) XXX_DiscardUnknown() { - xxx_messageInfo_SignalOnRoomParticipantDisconnectedReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalOnRoomParticipantDisconnectedReq proto.InternalMessageInfo - -func (m *SignalOnRoomParticipantDisconnectedReq) GetInvitation() *InvitationInfo { - if m != nil { - return m.Invitation - } - return nil -} - -func (m *SignalOnRoomParticipantDisconnectedReq) GetParticipant() []*ParticipantMetaData { - if m != nil { - return m.Participant - } - return nil -} - -func (m *SignalOnRoomParticipantDisconnectedReq) GetGroupID() string { - if m != nil { - return m.GroupID - } - return "" -} - -type SignalGetTokenByRoomIDReq struct { - RoomID string `protobuf:"bytes,1,opt,name=roomID" json:"roomID,omitempty"` - OpUserID string `protobuf:"bytes,2,opt,name=opUserID" json:"opUserID,omitempty"` - Participant *ParticipantMetaData `protobuf:"bytes,3,opt,name=participant" json:"participant,omitempty"` - OperationID string `protobuf:"bytes,4,opt,name=operationID" json:"operationID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalGetTokenByRoomIDReq) Reset() { *m = SignalGetTokenByRoomIDReq{} } -func (m *SignalGetTokenByRoomIDReq) String() string { return proto.CompactTextString(m) } -func (*SignalGetTokenByRoomIDReq) ProtoMessage() {} -func (*SignalGetTokenByRoomIDReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{78} -} -func (m *SignalGetTokenByRoomIDReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalGetTokenByRoomIDReq.Unmarshal(m, b) -} -func (m *SignalGetTokenByRoomIDReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalGetTokenByRoomIDReq.Marshal(b, m, deterministic) -} -func (dst *SignalGetTokenByRoomIDReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalGetTokenByRoomIDReq.Merge(dst, src) -} -func (m *SignalGetTokenByRoomIDReq) XXX_Size() int { - return xxx_messageInfo_SignalGetTokenByRoomIDReq.Size(m) -} -func (m *SignalGetTokenByRoomIDReq) XXX_DiscardUnknown() { - xxx_messageInfo_SignalGetTokenByRoomIDReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalGetTokenByRoomIDReq proto.InternalMessageInfo - -func (m *SignalGetTokenByRoomIDReq) GetRoomID() string { - if m != nil { - return m.RoomID - } - return "" -} - -func (m *SignalGetTokenByRoomIDReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *SignalGetTokenByRoomIDReq) GetParticipant() *ParticipantMetaData { - if m != nil { - return m.Participant - } - return nil -} - -func (m *SignalGetTokenByRoomIDReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -type SignalGetTokenByRoomIDReply struct { - Token string `protobuf:"bytes,1,opt,name=token" json:"token,omitempty"` - LiveURL string `protobuf:"bytes,2,opt,name=liveURL" json:"liveURL,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SignalGetTokenByRoomIDReply) Reset() { *m = SignalGetTokenByRoomIDReply{} } -func (m *SignalGetTokenByRoomIDReply) String() string { return proto.CompactTextString(m) } -func (*SignalGetTokenByRoomIDReply) ProtoMessage() {} -func (*SignalGetTokenByRoomIDReply) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{79} -} -func (m *SignalGetTokenByRoomIDReply) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SignalGetTokenByRoomIDReply.Unmarshal(m, b) -} -func (m *SignalGetTokenByRoomIDReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SignalGetTokenByRoomIDReply.Marshal(b, m, deterministic) -} -func (dst *SignalGetTokenByRoomIDReply) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignalGetTokenByRoomIDReply.Merge(dst, src) -} -func (m *SignalGetTokenByRoomIDReply) XXX_Size() int { - return xxx_messageInfo_SignalGetTokenByRoomIDReply.Size(m) -} -func (m *SignalGetTokenByRoomIDReply) XXX_DiscardUnknown() { - xxx_messageInfo_SignalGetTokenByRoomIDReply.DiscardUnknown(m) -} - -var xxx_messageInfo_SignalGetTokenByRoomIDReply proto.InternalMessageInfo - -func (m *SignalGetTokenByRoomIDReply) GetToken() string { - if m != nil { - return m.Token - } - return "" -} - -func (m *SignalGetTokenByRoomIDReply) GetLiveURL() string { - if m != nil { - return m.LiveURL - } - return "" -} - -type DelMsgListReq struct { - OpUserID string `protobuf:"bytes,1,opt,name=opUserID" json:"opUserID,omitempty"` - UserID string `protobuf:"bytes,2,opt,name=userID" json:"userID,omitempty"` - SeqList []uint32 `protobuf:"varint,3,rep,packed,name=seqList" json:"seqList,omitempty"` - OperationID string `protobuf:"bytes,4,opt,name=operationID" json:"operationID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *DelMsgListReq) Reset() { *m = DelMsgListReq{} } -func (m *DelMsgListReq) String() string { return proto.CompactTextString(m) } -func (*DelMsgListReq) ProtoMessage() {} -func (*DelMsgListReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{80} -} -func (m *DelMsgListReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_DelMsgListReq.Unmarshal(m, b) -} -func (m *DelMsgListReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_DelMsgListReq.Marshal(b, m, deterministic) -} -func (dst *DelMsgListReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_DelMsgListReq.Merge(dst, src) -} -func (m *DelMsgListReq) XXX_Size() int { - return xxx_messageInfo_DelMsgListReq.Size(m) -} -func (m *DelMsgListReq) XXX_DiscardUnknown() { - xxx_messageInfo_DelMsgListReq.DiscardUnknown(m) -} - -var xxx_messageInfo_DelMsgListReq proto.InternalMessageInfo - -func (m *DelMsgListReq) GetOpUserID() string { - if m != nil { - return m.OpUserID - } - return "" -} - -func (m *DelMsgListReq) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *DelMsgListReq) GetSeqList() []uint32 { - if m != nil { - return m.SeqList - } - return nil -} - -func (m *DelMsgListReq) GetOperationID() string { - if m != nil { - return m.OperationID - } - return "" -} - -type DelMsgListResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *DelMsgListResp) Reset() { *m = DelMsgListResp{} } -func (m *DelMsgListResp) String() string { return proto.CompactTextString(m) } -func (*DelMsgListResp) ProtoMessage() {} -func (*DelMsgListResp) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{81} -} -func (m *DelMsgListResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_DelMsgListResp.Unmarshal(m, b) -} -func (m *DelMsgListResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_DelMsgListResp.Marshal(b, m, deterministic) -} -func (dst *DelMsgListResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_DelMsgListResp.Merge(dst, src) -} -func (m *DelMsgListResp) XXX_Size() int { - return xxx_messageInfo_DelMsgListResp.Size(m) -} -func (m *DelMsgListResp) XXX_DiscardUnknown() { - xxx_messageInfo_DelMsgListResp.DiscardUnknown(m) -} - -var xxx_messageInfo_DelMsgListResp proto.InternalMessageInfo - -func (m *DelMsgListResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *DelMsgListResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -type SetAppBackgroundStatusReq struct { - UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"` - IsBackground bool `protobuf:"varint,2,opt,name=isBackground" json:"isBackground,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SetAppBackgroundStatusReq) Reset() { *m = SetAppBackgroundStatusReq{} } -func (m *SetAppBackgroundStatusReq) String() string { return proto.CompactTextString(m) } -func (*SetAppBackgroundStatusReq) ProtoMessage() {} -func (*SetAppBackgroundStatusReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{82} -} -func (m *SetAppBackgroundStatusReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SetAppBackgroundStatusReq.Unmarshal(m, b) -} -func (m *SetAppBackgroundStatusReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SetAppBackgroundStatusReq.Marshal(b, m, deterministic) -} -func (dst *SetAppBackgroundStatusReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetAppBackgroundStatusReq.Merge(dst, src) -} -func (m *SetAppBackgroundStatusReq) XXX_Size() int { - return xxx_messageInfo_SetAppBackgroundStatusReq.Size(m) -} -func (m *SetAppBackgroundStatusReq) XXX_DiscardUnknown() { - xxx_messageInfo_SetAppBackgroundStatusReq.DiscardUnknown(m) -} - -var xxx_messageInfo_SetAppBackgroundStatusReq proto.InternalMessageInfo - -func (m *SetAppBackgroundStatusReq) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *SetAppBackgroundStatusReq) GetIsBackground() bool { - if m != nil { - return m.IsBackground - } - return false -} - -type SetAppBackgroundStatusResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *SetAppBackgroundStatusResp) Reset() { *m = SetAppBackgroundStatusResp{} } -func (m *SetAppBackgroundStatusResp) String() string { return proto.CompactTextString(m) } -func (*SetAppBackgroundStatusResp) ProtoMessage() {} -func (*SetAppBackgroundStatusResp) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{83} -} -func (m *SetAppBackgroundStatusResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SetAppBackgroundStatusResp.Unmarshal(m, b) -} -func (m *SetAppBackgroundStatusResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SetAppBackgroundStatusResp.Marshal(b, m, deterministic) -} -func (dst *SetAppBackgroundStatusResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetAppBackgroundStatusResp.Merge(dst, src) -} -func (m *SetAppBackgroundStatusResp) XXX_Size() int { - return xxx_messageInfo_SetAppBackgroundStatusResp.Size(m) -} -func (m *SetAppBackgroundStatusResp) XXX_DiscardUnknown() { - xxx_messageInfo_SetAppBackgroundStatusResp.DiscardUnknown(m) -} - -var xxx_messageInfo_SetAppBackgroundStatusResp proto.InternalMessageInfo - -func (m *SetAppBackgroundStatusResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode - } - return 0 -} - -func (m *SetAppBackgroundStatusResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg - } - return "" -} - -type ExtendMsgSet struct { - SourceID string `protobuf:"bytes,1,opt,name=sourceID" json:"sourceID,omitempty"` - SessionType int32 `protobuf:"varint,2,opt,name=sessionType" json:"sessionType,omitempty"` - ExtendMsgs map[string]*ExtendMsg `protobuf:"bytes,3,rep,name=extendMsgs" json:"extendMsgs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - MaxMsgUpdateTime int64 `protobuf:"varint,4,opt,name=MaxMsgUpdateTime" json:"MaxMsgUpdateTime,omitempty"` - ExtendMsgNum int32 `protobuf:"varint,5,opt,name=extendMsgNum" json:"extendMsgNum,omitempty"` - CreateTime int64 `protobuf:"varint,6,opt,name=createTime" json:"createTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *ExtendMsgSet) Reset() { *m = ExtendMsgSet{} } -func (m *ExtendMsgSet) String() string { return proto.CompactTextString(m) } -func (*ExtendMsgSet) ProtoMessage() {} -func (*ExtendMsgSet) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{84} -} -func (m *ExtendMsgSet) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ExtendMsgSet.Unmarshal(m, b) -} -func (m *ExtendMsgSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ExtendMsgSet.Marshal(b, m, deterministic) -} -func (dst *ExtendMsgSet) XXX_Merge(src proto.Message) { - xxx_messageInfo_ExtendMsgSet.Merge(dst, src) -} -func (m *ExtendMsgSet) XXX_Size() int { - return xxx_messageInfo_ExtendMsgSet.Size(m) -} -func (m *ExtendMsgSet) XXX_DiscardUnknown() { - xxx_messageInfo_ExtendMsgSet.DiscardUnknown(m) -} - -var xxx_messageInfo_ExtendMsgSet proto.InternalMessageInfo - -func (m *ExtendMsgSet) GetSourceID() string { - if m != nil { - return m.SourceID - } - return "" -} - -func (m *ExtendMsgSet) GetSessionType() int32 { - if m != nil { - return m.SessionType - } - return 0 -} - -func (m *ExtendMsgSet) GetExtendMsgs() map[string]*ExtendMsg { - if m != nil { - return m.ExtendMsgs - } - return nil -} - -func (m *ExtendMsgSet) GetMaxMsgUpdateTime() int64 { - if m != nil { - return m.MaxMsgUpdateTime - } - return 0 -} - -func (m *ExtendMsgSet) GetExtendMsgNum() int32 { - if m != nil { - return m.ExtendMsgNum - } - return 0 -} - -func (m *ExtendMsgSet) GetCreateTime() int64 { - if m != nil { - return m.CreateTime - } - return 0 -} - -type ExtendMsg struct { - ReactionExtensionList map[string]*KeyValue `protobuf:"bytes,1,rep,name=reactionExtensionList" json:"reactionExtensionList,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - ClientMsgID string `protobuf:"bytes,2,opt,name=clientMsgID" json:"clientMsgID,omitempty"` - MsgFirstModifyTime int64 `protobuf:"varint,3,opt,name=msgFirstModifyTime" json:"msgFirstModifyTime,omitempty"` - AttachedInfo string `protobuf:"bytes,4,opt,name=attachedInfo" json:"attachedInfo,omitempty"` - Ex string `protobuf:"bytes,5,opt,name=ex" json:"ex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *ExtendMsg) Reset() { *m = ExtendMsg{} } -func (m *ExtendMsg) String() string { return proto.CompactTextString(m) } -func (*ExtendMsg) ProtoMessage() {} -func (*ExtendMsg) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{85} -} -func (m *ExtendMsg) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ExtendMsg.Unmarshal(m, b) -} -func (m *ExtendMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ExtendMsg.Marshal(b, m, deterministic) -} -func (dst *ExtendMsg) XXX_Merge(src proto.Message) { - xxx_messageInfo_ExtendMsg.Merge(dst, src) -} -func (m *ExtendMsg) XXX_Size() int { - return xxx_messageInfo_ExtendMsg.Size(m) -} -func (m *ExtendMsg) XXX_DiscardUnknown() { - xxx_messageInfo_ExtendMsg.DiscardUnknown(m) -} - -var xxx_messageInfo_ExtendMsg proto.InternalMessageInfo - -func (m *ExtendMsg) GetReactionExtensionList() map[string]*KeyValue { - if m != nil { - return m.ReactionExtensionList - } - return nil -} - -func (m *ExtendMsg) GetClientMsgID() string { - if m != nil { - return m.ClientMsgID - } - return "" -} - -func (m *ExtendMsg) GetMsgFirstModifyTime() int64 { - if m != nil { - return m.MsgFirstModifyTime - } - return 0 -} - -func (m *ExtendMsg) GetAttachedInfo() string { - if m != nil { - return m.AttachedInfo - } - return "" -} - -func (m *ExtendMsg) GetEx() string { - if m != nil { - return m.Ex - } - return "" -} - -type KeyValue struct { - TypeKey string `protobuf:"bytes,1,opt,name=typeKey" json:"typeKey,omitempty"` - Value string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` - LatestUpdateTime int64 `protobuf:"varint,3,opt,name=latestUpdateTime" json:"latestUpdateTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *KeyValue) Reset() { *m = KeyValue{} } -func (m *KeyValue) String() string { return proto.CompactTextString(m) } -func (*KeyValue) ProtoMessage() {} -func (*KeyValue) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_bc78a4975e7e5f46, []int{86} -} -func (m *KeyValue) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_KeyValue.Unmarshal(m, b) -} -func (m *KeyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_KeyValue.Marshal(b, m, deterministic) -} -func (dst *KeyValue) XXX_Merge(src proto.Message) { - xxx_messageInfo_KeyValue.Merge(dst, src) -} -func (m *KeyValue) XXX_Size() int { - return xxx_messageInfo_KeyValue.Size(m) -} -func (m *KeyValue) XXX_DiscardUnknown() { - xxx_messageInfo_KeyValue.DiscardUnknown(m) -} - -var xxx_messageInfo_KeyValue proto.InternalMessageInfo - -func (m *KeyValue) GetTypeKey() string { - if m != nil { - return m.TypeKey - } - return "" -} - -func (m *KeyValue) GetValue() string { - if m != nil { - return m.Value - } - return "" -} - -func (m *KeyValue) GetLatestUpdateTime() int64 { - if m != nil { - return m.LatestUpdateTime - } - return 0 -} - -func init() { - proto.RegisterType((*GroupInfo)(nil), "server_api_params.GroupInfo") - proto.RegisterType((*GroupInfoForSet)(nil), "server_api_params.GroupInfoForSet") - proto.RegisterType((*GroupMemberFullInfo)(nil), "server_api_params.GroupMemberFullInfo") - proto.RegisterType((*PublicUserInfo)(nil), "server_api_params.PublicUserInfo") - proto.RegisterType((*UserInfo)(nil), "server_api_params.UserInfo") - proto.RegisterType((*FriendInfo)(nil), "server_api_params.FriendInfo") - proto.RegisterType((*BlackInfo)(nil), "server_api_params.BlackInfo") - proto.RegisterType((*GroupRequest)(nil), "server_api_params.GroupRequest") - proto.RegisterType((*FriendRequest)(nil), "server_api_params.FriendRequest") - proto.RegisterType((*Department)(nil), "server_api_params.Department") - proto.RegisterType((*OrganizationUser)(nil), "server_api_params.OrganizationUser") - proto.RegisterType((*DepartmentMember)(nil), "server_api_params.DepartmentMember") - proto.RegisterType((*UserDepartmentMember)(nil), "server_api_params.UserDepartmentMember") - proto.RegisterType((*UserInDepartment)(nil), "server_api_params.UserInDepartment") - proto.RegisterType((*PullMessageBySeqListReq)(nil), "server_api_params.PullMessageBySeqListReq") - proto.RegisterMapType((map[string]*SeqList)(nil), "server_api_params.PullMessageBySeqListReq.GroupSeqListEntry") - proto.RegisterType((*SeqList)(nil), "server_api_params.seqList") - proto.RegisterType((*MsgDataList)(nil), "server_api_params.MsgDataList") - proto.RegisterType((*PullMessageBySeqListResp)(nil), "server_api_params.PullMessageBySeqListResp") - proto.RegisterMapType((map[string]*MsgDataList)(nil), "server_api_params.PullMessageBySeqListResp.GroupMsgDataListEntry") - proto.RegisterType((*GetMaxAndMinSeqReq)(nil), "server_api_params.GetMaxAndMinSeqReq") - proto.RegisterType((*MaxAndMinSeq)(nil), "server_api_params.MaxAndMinSeq") - proto.RegisterType((*GetMaxAndMinSeqResp)(nil), "server_api_params.GetMaxAndMinSeqResp") - proto.RegisterMapType((map[string]*MaxAndMinSeq)(nil), "server_api_params.GetMaxAndMinSeqResp.GroupMaxAndMinSeqEntry") - proto.RegisterType((*UserSendMsgResp)(nil), "server_api_params.UserSendMsgResp") - proto.RegisterType((*MsgData)(nil), "server_api_params.MsgData") - proto.RegisterMapType((map[string]bool)(nil), "server_api_params.MsgData.OptionsEntry") - proto.RegisterType((*OfflinePushInfo)(nil), "server_api_params.OfflinePushInfo") - proto.RegisterType((*TipsComm)(nil), "server_api_params.TipsComm") - proto.RegisterType((*GroupCreatedTips)(nil), "server_api_params.GroupCreatedTips") - proto.RegisterType((*GroupInfoSetTips)(nil), "server_api_params.GroupInfoSetTips") - proto.RegisterType((*JoinGroupApplicationTips)(nil), "server_api_params.JoinGroupApplicationTips") - proto.RegisterType((*MemberQuitTips)(nil), "server_api_params.MemberQuitTips") - proto.RegisterType((*GroupApplicationAcceptedTips)(nil), "server_api_params.GroupApplicationAcceptedTips") - proto.RegisterType((*GroupApplicationRejectedTips)(nil), "server_api_params.GroupApplicationRejectedTips") - proto.RegisterType((*GroupOwnerTransferredTips)(nil), "server_api_params.GroupOwnerTransferredTips") - proto.RegisterType((*MemberKickedTips)(nil), "server_api_params.MemberKickedTips") - proto.RegisterType((*MemberInvitedTips)(nil), "server_api_params.MemberInvitedTips") - proto.RegisterType((*MemberEnterTips)(nil), "server_api_params.MemberEnterTips") - proto.RegisterType((*GroupDismissedTips)(nil), "server_api_params.GroupDismissedTips") - proto.RegisterType((*GroupMemberMutedTips)(nil), "server_api_params.GroupMemberMutedTips") - proto.RegisterType((*GroupMemberCancelMutedTips)(nil), "server_api_params.GroupMemberCancelMutedTips") - proto.RegisterType((*GroupMutedTips)(nil), "server_api_params.GroupMutedTips") - proto.RegisterType((*GroupCancelMutedTips)(nil), "server_api_params.GroupCancelMutedTips") - proto.RegisterType((*GroupMemberInfoSetTips)(nil), "server_api_params.GroupMemberInfoSetTips") - proto.RegisterType((*OrganizationChangedTips)(nil), "server_api_params.OrganizationChangedTips") - proto.RegisterType((*FriendApplication)(nil), "server_api_params.FriendApplication") - proto.RegisterType((*FromToUserID)(nil), "server_api_params.FromToUserID") - proto.RegisterType((*FriendApplicationTips)(nil), "server_api_params.FriendApplicationTips") - proto.RegisterType((*FriendApplicationApprovedTips)(nil), "server_api_params.FriendApplicationApprovedTips") - proto.RegisterType((*FriendApplicationRejectedTips)(nil), "server_api_params.FriendApplicationRejectedTips") - proto.RegisterType((*FriendAddedTips)(nil), "server_api_params.FriendAddedTips") - proto.RegisterType((*FriendDeletedTips)(nil), "server_api_params.FriendDeletedTips") - proto.RegisterType((*BlackAddedTips)(nil), "server_api_params.BlackAddedTips") - proto.RegisterType((*BlackDeletedTips)(nil), "server_api_params.BlackDeletedTips") - proto.RegisterType((*FriendInfoChangedTips)(nil), "server_api_params.FriendInfoChangedTips") - proto.RegisterType((*UserInfoUpdatedTips)(nil), "server_api_params.UserInfoUpdatedTips") - proto.RegisterType((*ConversationUpdateTips)(nil), "server_api_params.ConversationUpdateTips") - proto.RegisterType((*ConversationSetPrivateTips)(nil), "server_api_params.ConversationSetPrivateTips") - proto.RegisterType((*DeleteMessageTips)(nil), "server_api_params.DeleteMessageTips") - proto.RegisterType((*RequestPagination)(nil), "server_api_params.RequestPagination") - proto.RegisterType((*ResponsePagination)(nil), "server_api_params.ResponsePagination") - proto.RegisterType((*SignalReq)(nil), "server_api_params.SignalReq") - proto.RegisterType((*SignalResp)(nil), "server_api_params.SignalResp") - proto.RegisterType((*InvitationInfo)(nil), "server_api_params.InvitationInfo") - proto.RegisterType((*ParticipantMetaData)(nil), "server_api_params.ParticipantMetaData") - proto.RegisterType((*SignalInviteReq)(nil), "server_api_params.SignalInviteReq") - proto.RegisterType((*SignalInviteReply)(nil), "server_api_params.SignalInviteReply") - proto.RegisterType((*SignalInviteInGroupReq)(nil), "server_api_params.SignalInviteInGroupReq") - proto.RegisterType((*SignalInviteInGroupReply)(nil), "server_api_params.SignalInviteInGroupReply") - proto.RegisterType((*SignalCancelReq)(nil), "server_api_params.SignalCancelReq") - proto.RegisterType((*SignalCancelReply)(nil), "server_api_params.SignalCancelReply") - proto.RegisterType((*SignalAcceptReq)(nil), "server_api_params.SignalAcceptReq") - proto.RegisterType((*SignalAcceptReply)(nil), "server_api_params.SignalAcceptReply") - proto.RegisterType((*SignalHungUpReq)(nil), "server_api_params.SignalHungUpReq") - proto.RegisterType((*SignalHungUpReply)(nil), "server_api_params.SignalHungUpReply") - proto.RegisterType((*SignalRejectReq)(nil), "server_api_params.SignalRejectReq") - proto.RegisterType((*SignalRejectReply)(nil), "server_api_params.SignalRejectReply") - proto.RegisterType((*SignalGetRoomByGroupIDReq)(nil), "server_api_params.SignalGetRoomByGroupIDReq") - proto.RegisterType((*SignalGetRoomByGroupIDReply)(nil), "server_api_params.SignalGetRoomByGroupIDReply") - proto.RegisterType((*SignalOnRoomParticipantConnectedReq)(nil), "server_api_params.SignalOnRoomParticipantConnectedReq") - proto.RegisterType((*SignalOnRoomParticipantDisconnectedReq)(nil), "server_api_params.SignalOnRoomParticipantDisconnectedReq") - proto.RegisterType((*SignalGetTokenByRoomIDReq)(nil), "server_api_params.SignalGetTokenByRoomIDReq") - proto.RegisterType((*SignalGetTokenByRoomIDReply)(nil), "server_api_params.SignalGetTokenByRoomIDReply") - proto.RegisterType((*DelMsgListReq)(nil), "server_api_params.DelMsgListReq") - proto.RegisterType((*DelMsgListResp)(nil), "server_api_params.DelMsgListResp") - proto.RegisterType((*SetAppBackgroundStatusReq)(nil), "server_api_params.SetAppBackgroundStatusReq") - proto.RegisterType((*SetAppBackgroundStatusResp)(nil), "server_api_params.SetAppBackgroundStatusResp") - proto.RegisterType((*ExtendMsgSet)(nil), "server_api_params.ExtendMsgSet") - proto.RegisterMapType((map[string]*ExtendMsg)(nil), "server_api_params.ExtendMsgSet.ExtendMsgsEntry") - proto.RegisterType((*ExtendMsg)(nil), "server_api_params.ExtendMsg") - proto.RegisterMapType((map[string]*KeyValue)(nil), "server_api_params.ExtendMsg.ReactionExtensionListEntry") - proto.RegisterType((*KeyValue)(nil), "server_api_params.KeyValue") -} - -func init() { proto.RegisterFile("sdk_ws/ws.proto", fileDescriptor_ws_bc78a4975e7e5f46) } - -var fileDescriptor_ws_bc78a4975e7e5f46 = []byte{ - // 4162 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x3c, 0x59, 0x8f, 0x1c, 0x57, - 0xb9, 0xa9, 0xea, 0x65, 0xba, 0xbf, 0x9e, 0xa5, 0xa7, 0x6c, 0x4f, 0x3a, 0x13, 0xc7, 0x77, 0x6e, - 0xc5, 0xf2, 0x75, 0x7c, 0x9d, 0xf1, 0xbd, 0xce, 0x72, 0x6f, 0x36, 0xa3, 0x59, 0xec, 0xf1, 0xc4, - 0xee, 0x99, 0x49, 0xb5, 0x1d, 0xa3, 0x24, 0x92, 0xa9, 0xe9, 0x3a, 0xd3, 0x53, 0x99, 0xea, 0xaa, - 0x9a, 0x5a, 0xc6, 0x1e, 0x1e, 0x40, 0x2c, 0x02, 0x24, 0x1e, 0x90, 0x10, 0x8b, 0x04, 0x6f, 0xbc, - 0x20, 0x10, 0x8a, 0x10, 0x0a, 0x12, 0x12, 0x08, 0x21, 0xc4, 0x03, 0x12, 0x48, 0xe4, 0x1d, 0x09, - 0x04, 0x2f, 0x20, 0xc4, 0x1f, 0x40, 0x42, 0x0a, 0x3a, 0x4b, 0x55, 0x9d, 0x53, 0x4b, 0x77, 0xbb, - 0x35, 0x8a, 0x6d, 0x99, 0x27, 0xfb, 0xfb, 0xea, 0x7c, 0xdf, 0xf9, 0xf6, 0xf3, 0x9d, 0xa5, 0x07, - 0x66, 0x7c, 0x63, 0xef, 0xf6, 0x1d, 0xff, 0xc2, 0x1d, 0x7f, 0xd1, 0xf5, 0x9c, 0xc0, 0x51, 0x66, - 0x7d, 0xe4, 0x1d, 0x20, 0xef, 0xb6, 0xee, 0x9a, 0xb7, 0x5d, 0xdd, 0xd3, 0xfb, 0xfe, 0xfc, 0xe2, - 0xa6, 0x8b, 0xec, 0x67, 0xd7, 0xdb, 0xcf, 0x76, 0xc8, 0xa7, 0x0b, 0xee, 0x5e, 0xef, 0x02, 0x19, - 0x7c, 0x21, 0x22, 0xf6, 0x74, 0xd7, 0x45, 0x1e, 0x63, 0xa1, 0xfe, 0xb1, 0x0c, 0xf5, 0x35, 0xcf, - 0x09, 0xdd, 0x75, 0x7b, 0xc7, 0x51, 0x5a, 0x30, 0xd1, 0x23, 0xc0, 0x6a, 0x4b, 0x5a, 0x90, 0xce, - 0xd6, 0xb5, 0x08, 0x54, 0x4e, 0x42, 0x9d, 0xfc, 0x77, 0x43, 0xef, 0xa3, 0x96, 0x4c, 0xbe, 0x25, - 0x08, 0x45, 0x85, 0x49, 0xdb, 0x09, 0xcc, 0x1d, 0xb3, 0xab, 0x07, 0xa6, 0x63, 0xb7, 0x4a, 0x64, - 0x80, 0x80, 0xc3, 0x63, 0x4c, 0x3b, 0xf0, 0x1c, 0x23, 0xec, 0x92, 0x31, 0x65, 0x3a, 0x86, 0xc7, - 0xe1, 0xf9, 0x77, 0xf4, 0x2e, 0xba, 0xa9, 0x5d, 0x6f, 0x55, 0xe8, 0xfc, 0x0c, 0x54, 0x16, 0xa0, - 0xe1, 0xdc, 0xb1, 0x91, 0x77, 0xd3, 0x47, 0xde, 0xfa, 0x6a, 0xab, 0x4a, 0xbe, 0xf2, 0x28, 0xe5, - 0x14, 0x40, 0xd7, 0x43, 0x7a, 0x80, 0x6e, 0x98, 0x7d, 0xd4, 0x9a, 0x58, 0x90, 0xce, 0x4e, 0x69, - 0x1c, 0x06, 0x73, 0xe8, 0xa3, 0xfe, 0x36, 0xf2, 0x56, 0x9c, 0xd0, 0x0e, 0x5a, 0x35, 0x32, 0x80, - 0x47, 0x29, 0xd3, 0x20, 0xa3, 0xbb, 0xad, 0x3a, 0x61, 0x2d, 0xa3, 0xbb, 0xca, 0x1c, 0x54, 0xfd, - 0x40, 0x0f, 0x42, 0xbf, 0x05, 0x0b, 0xd2, 0xd9, 0x8a, 0xc6, 0x20, 0xe5, 0x34, 0x4c, 0x11, 0xbe, - 0x4e, 0x24, 0x4d, 0x83, 0x90, 0x88, 0xc8, 0xd8, 0x62, 0x37, 0x0e, 0x5d, 0xd4, 0x9a, 0x24, 0x0c, - 0x12, 0x84, 0x72, 0x0e, 0x9a, 0x36, 0x42, 0xc6, 0x9b, 0xc8, 0x4b, 0xac, 0x36, 0x45, 0x06, 0x65, - 0xf0, 0xca, 0x19, 0x98, 0xb6, 0x1c, 0x67, 0xaf, 0x4d, 0x44, 0xc5, 0x7e, 0x6a, 0x4d, 0x93, 0x91, - 0x29, 0xac, 0x72, 0x1e, 0x66, 0x75, 0xd7, 0xb5, 0x0e, 0x29, 0xea, 0x8a, 0x67, 0x22, 0xdb, 0x68, - 0xcd, 0x90, 0xa1, 0xd9, 0x0f, 0xca, 0x8b, 0x30, 0xc7, 0xfb, 0xe7, 0xa6, 0x6b, 0x44, 0xb6, 0x6b, - 0x12, 0xd3, 0x14, 0x7c, 0x55, 0x16, 0x41, 0x11, 0xbe, 0x50, 0x13, 0xcc, 0x12, 0x13, 0xe4, 0x7c, - 0x51, 0xbf, 0x56, 0x82, 0x99, 0x38, 0xc2, 0xae, 0x38, 0x5e, 0x07, 0x05, 0x0f, 0x70, 0x9c, 0xd1, - 0x18, 0xa8, 0xc6, 0x31, 0xb0, 0x96, 0xe3, 0x27, 0x1c, 0x5b, 0x8d, 0x8b, 0x4f, 0x2e, 0xf6, 0x1c, - 0xa7, 0x67, 0x21, 0x9a, 0x48, 0xdb, 0xe1, 0xce, 0xe2, 0xba, 0x1d, 0x3c, 0x77, 0xf1, 0x4d, 0xdd, - 0x0a, 0x51, 0x8e, 0x13, 0x57, 0x32, 0x4e, 0xac, 0x0d, 0x67, 0x93, 0xf6, 0xf0, 0x7a, 0x9e, 0x87, - 0xeb, 0xc3, 0xf9, 0x64, 0xa9, 0xd4, 0x0f, 0x65, 0x38, 0x46, 0xdc, 0xc2, 0xb0, 0xa1, 0x65, 0x0d, - 0x29, 0x01, 0x73, 0x50, 0x0d, 0xa9, 0xb3, 0xa9, 0x5f, 0x18, 0x84, 0x5d, 0xe6, 0x39, 0x16, 0xba, - 0x8e, 0x0e, 0x90, 0x45, 0x3c, 0x52, 0xd1, 0x12, 0x84, 0x32, 0x0f, 0xb5, 0x77, 0x1d, 0xd3, 0x26, - 0x81, 0x55, 0x26, 0x1f, 0x63, 0x18, 0x7f, 0xb3, 0xcd, 0xee, 0x9e, 0x8d, 0x7d, 0x4d, 0xfd, 0x10, - 0xc3, 0xbc, 0x8b, 0xaa, 0xa2, 0x8b, 0xce, 0xc0, 0xb4, 0xee, 0xba, 0x6d, 0xdd, 0xee, 0x21, 0x8f, - 0x4e, 0x3a, 0x41, 0xd3, 0x41, 0xc4, 0xe2, 0x82, 0x80, 0x67, 0xea, 0x38, 0xa1, 0xd7, 0x45, 0xc4, - 0xda, 0x15, 0x8d, 0xc3, 0x60, 0x3e, 0x8e, 0x8b, 0x3c, 0x2e, 0x8f, 0x69, 0xea, 0xa7, 0xb0, 0x2c, - 0x24, 0x20, 0x0e, 0x09, 0x5c, 0x48, 0xc2, 0x00, 0x5d, 0xb6, 0x0d, 0xa2, 0x54, 0x83, 0x15, 0x92, - 0x04, 0x85, 0x0b, 0x84, 0x69, 0x1f, 0x98, 0x41, 0x5c, 0xae, 0x26, 0x69, 0x81, 0x10, 0x90, 0xea, - 0x17, 0x24, 0x98, 0xde, 0x0a, 0xb7, 0x2d, 0xb3, 0x4b, 0x10, 0xd8, 0xf8, 0x89, 0x89, 0x25, 0xc1, - 0xc4, 0xbc, 0xa1, 0xe4, 0x62, 0x43, 0x95, 0x44, 0x43, 0xcd, 0x41, 0xb5, 0x87, 0x6c, 0x03, 0x79, - 0xcc, 0xf0, 0x0c, 0x62, 0x0a, 0x55, 0x22, 0x85, 0xd4, 0x3f, 0xc8, 0x50, 0xfb, 0x88, 0x45, 0x58, - 0x80, 0x86, 0xbb, 0xeb, 0xd8, 0x68, 0x23, 0xc4, 0xc1, 0xc7, 0x64, 0xe1, 0x51, 0xca, 0x71, 0xa8, - 0x6c, 0x9b, 0x5e, 0xb0, 0x4b, 0xbc, 0x3f, 0xa5, 0x51, 0x00, 0x63, 0x51, 0x5f, 0x37, 0xa9, 0xcb, - 0xeb, 0x1a, 0x05, 0x98, 0x42, 0xb5, 0xd8, 0x43, 0xe2, 0x52, 0x50, 0xcf, 0x2c, 0x05, 0xd9, 0x08, - 0x82, 0xdc, 0x08, 0x3a, 0x07, 0xcd, 0x9e, 0xe5, 0x6c, 0xeb, 0x96, 0x86, 0xba, 0x07, 0x6d, 0xbf, - 0xb7, 0xe9, 0x06, 0xc4, 0xdd, 0x15, 0x2d, 0x83, 0xc7, 0xf6, 0x21, 0x22, 0x76, 0x02, 0x8f, 0xb9, - 0x3b, 0x86, 0xd5, 0x7f, 0x48, 0x00, 0x34, 0xed, 0x88, 0x89, 0x53, 0x6b, 0x99, 0x94, 0x5d, 0xcb, - 0xe6, 0xa0, 0xea, 0xa1, 0xbe, 0xee, 0xed, 0x45, 0xa9, 0x46, 0xa1, 0x94, 0x62, 0xa5, 0x8c, 0x62, - 0xaf, 0x00, 0xec, 0x90, 0x79, 0x30, 0x1f, 0x62, 0x72, 0x5c, 0x18, 0x32, 0x5d, 0xc2, 0x62, 0xe4, - 0x6d, 0x8d, 0x1b, 0x8e, 0xf3, 0x58, 0x37, 0x0c, 0x96, 0x2e, 0x15, 0x9a, 0xc7, 0x31, 0x22, 0x27, - 0x5b, 0xaa, 0x03, 0xb2, 0x65, 0x22, 0x0e, 0xae, 0xbf, 0x4b, 0x50, 0x5f, 0xb6, 0xf4, 0xee, 0xde, - 0x88, 0xaa, 0x8b, 0x2a, 0xca, 0x19, 0x15, 0xd7, 0x60, 0x6a, 0x1b, 0xb3, 0x8b, 0x54, 0x20, 0x56, - 0x68, 0x5c, 0xfc, 0xcf, 0x1c, 0x2d, 0xc5, 0xe4, 0xd2, 0x44, 0x3a, 0x51, 0xdd, 0xf2, 0x70, 0x75, - 0x2b, 0x03, 0xd4, 0x8d, 0xd7, 0x0b, 0xf5, 0x9b, 0x25, 0x98, 0x24, 0x65, 0x55, 0x43, 0xfb, 0x21, - 0xf2, 0x03, 0xe5, 0x35, 0xa8, 0x85, 0x91, 0xa8, 0xd2, 0xa8, 0xa2, 0xc6, 0x24, 0xca, 0xcb, 0x6c, - 0x3d, 0x24, 0xf4, 0x32, 0xa1, 0x3f, 0x99, 0x43, 0x1f, 0x2f, 0xb0, 0x5a, 0x32, 0x1c, 0xaf, 0x84, - 0xbb, 0xba, 0x6d, 0x58, 0x48, 0x43, 0x7e, 0x68, 0x05, 0xac, 0x36, 0x0b, 0x38, 0x1a, 0x69, 0xfb, - 0x6d, 0xbf, 0xc7, 0xd6, 0x49, 0x06, 0x61, 0xeb, 0xd0, 0x71, 0xf8, 0x13, 0x55, 0x3d, 0x41, 0xe0, - 0x84, 0xf7, 0xd0, 0x3e, 0xf1, 0x10, 0x4d, 0xcf, 0x08, 0x4c, 0xe6, 0x64, 0x56, 0xa3, 0x81, 0x20, - 0xe0, 0xb0, 0x8b, 0x29, 0x4c, 0x18, 0xd0, 0x46, 0x8c, 0xc3, 0x64, 0xfa, 0x30, 0xb1, 0x90, 0x43, - 0xa6, 0x90, 0x67, 0xca, 0x6d, 0x23, 0xaf, 0xdc, 0xfe, 0xbe, 0x04, 0x53, 0x34, 0x09, 0x23, 0xd7, - 0x9c, 0xc2, 0xd9, 0xe2, 0xf4, 0x85, 0x58, 0xe4, 0x30, 0x58, 0x17, 0x0c, 0x6d, 0x88, 0x65, 0x4f, - 0xc0, 0xe1, 0x80, 0xc6, 0xf0, 0x15, 0xa1, 0xfc, 0xf1, 0xa8, 0x68, 0x96, 0x35, 0xbe, 0x0c, 0x72, - 0x18, 0x5c, 0x38, 0x02, 0x47, 0x88, 0xb1, 0x18, 0xc6, 0xb4, 0x81, 0x13, 0xcf, 0x4f, 0xa3, 0x8c, - 0xc3, 0x60, 0x2f, 0x05, 0x4e, 0x34, 0x37, 0x35, 0x75, 0x82, 0xa0, 0x9c, 0xd9, 0xbc, 0x74, 0xf9, - 0x8b, 0xe1, 0x4c, 0x6c, 0xd4, 0x07, 0xc6, 0x06, 0x08, 0xb1, 0x21, 0xa6, 0x68, 0x23, 0x93, 0xa2, - 0xa7, 0x61, 0x8a, 0xf2, 0x49, 0x2d, 0x7f, 0x02, 0x52, 0x8c, 0xb0, 0xa9, 0x74, 0x84, 0x89, 0x31, - 0x32, 0x5d, 0x10, 0x23, 0x33, 0x71, 0xde, 0xfd, 0x48, 0x06, 0x58, 0x45, 0xae, 0xee, 0x05, 0x7d, - 0x64, 0x07, 0x58, 0x3d, 0x23, 0x86, 0x62, 0xe7, 0x0a, 0x38, 0x7e, 0xd5, 0x92, 0xc5, 0x55, 0x4b, - 0x81, 0x32, 0x31, 0x38, 0xf5, 0x26, 0xf9, 0x3f, 0x36, 0xa6, 0xab, 0x7b, 0x94, 0x1b, 0x4d, 0x95, - 0x18, 0xc6, 0xab, 0x92, 0xe3, 0x19, 0x6c, 0x1d, 0xab, 0x68, 0x14, 0xc0, 0x25, 0x24, 0x99, 0x8f, - 0xec, 0x02, 0xaa, 0x74, 0x95, 0x11, 0xb1, 0x43, 0x37, 0x2e, 0xe7, 0xa0, 0xe9, 0x87, 0xdb, 0x89, - 0x72, 0x1b, 0x61, 0x9f, 0x25, 0x4d, 0x06, 0x8f, 0x8d, 0x4a, 0x77, 0x34, 0x78, 0x10, 0x5d, 0xf8, - 0x12, 0x44, 0xba, 0x93, 0x51, 0x7f, 0x2d, 0x43, 0x73, 0xd3, 0xeb, 0xe9, 0xb6, 0xf9, 0xc9, 0xb8, - 0x63, 0x1f, 0xab, 0x01, 0x58, 0x80, 0x06, 0xb2, 0x7b, 0x96, 0xe9, 0xef, 0x6e, 0x24, 0x76, 0xe3, - 0x51, 0xbc, 0xb1, 0xcb, 0x45, 0x2d, 0x42, 0x45, 0x68, 0x11, 0xe6, 0xa0, 0xda, 0x77, 0xb6, 0x4d, - 0x2b, 0x8a, 0x7b, 0x06, 0x91, 0x98, 0x47, 0x16, 0x22, 0xbd, 0x42, 0x1c, 0xf3, 0x11, 0x22, 0x69, - 0x1b, 0x6a, 0xb9, 0x6d, 0x43, 0x9d, 0x6f, 0x1b, 0x44, 0xc3, 0x43, 0xc6, 0xf0, 0xd4, 0x5c, 0x8d, - 0xb8, 0x0e, 0x0d, 0x5a, 0xe2, 0x7f, 0x21, 0x41, 0x33, 0x71, 0x05, 0xed, 0xa9, 0x0b, 0x4d, 0x99, - 0x8e, 0x4e, 0x39, 0x27, 0x3a, 0xe3, 0x98, 0x2a, 0xf1, 0x31, 0x85, 0xa3, 0xd0, 0xf1, 0x4d, 0x6e, - 0x63, 0x13, 0xc3, 0x78, 0x36, 0x0b, 0xe9, 0x9c, 0x21, 0x29, 0xc4, 0x6d, 0x63, 0xab, 0xc2, 0x36, - 0x36, 0xbd, 0x52, 0xff, 0x44, 0x82, 0xe3, 0x38, 0x02, 0x32, 0x6a, 0x6c, 0x42, 0xd3, 0x49, 0x45, - 0x09, 0x5b, 0xca, 0x9e, 0xce, 0x59, 0x8a, 0xd2, 0x01, 0xa5, 0x65, 0x88, 0x31, 0x43, 0x23, 0x35, - 0x09, 0x5b, 0xdb, 0xf2, 0x18, 0xa6, 0xe5, 0xd1, 0x32, 0xc4, 0xea, 0xcf, 0x24, 0x68, 0xd2, 0xc5, - 0x93, 0xab, 0x01, 0x47, 0x2e, 0xf6, 0x2d, 0x38, 0x9e, 0x9e, 0xf9, 0xba, 0xe9, 0x07, 0x2d, 0x79, - 0xa1, 0x34, 0xaa, 0xe8, 0xb9, 0x0c, 0xd4, 0x1f, 0xc8, 0xf0, 0xf8, 0x56, 0x68, 0x59, 0x6d, 0xe4, - 0xfb, 0x7a, 0x0f, 0x2d, 0x1f, 0x76, 0xd0, 0x3e, 0xfe, 0xa0, 0xa1, 0xfd, 0xc2, 0x18, 0xc2, 0x9d, - 0x14, 0x69, 0x45, 0x4c, 0xc7, 0x8e, 0x43, 0x88, 0x47, 0xe1, 0x94, 0xf3, 0x29, 0x9f, 0x56, 0x69, - 0xa1, 0x84, 0x17, 0x69, 0x06, 0x2a, 0x9f, 0x80, 0x49, 0xd2, 0x25, 0xb0, 0x69, 0x5a, 0x65, 0xa2, - 0xc0, 0xab, 0xb9, 0x7d, 0x49, 0xae, 0x54, 0xb4, 0xdf, 0x60, 0xf0, 0x65, 0x3b, 0xf0, 0x0e, 0x35, - 0x81, 0xe3, 0xfc, 0xdb, 0x30, 0x9b, 0x19, 0xa2, 0x34, 0xa1, 0xb4, 0x87, 0x0e, 0x99, 0x1e, 0xf8, - 0xbf, 0xca, 0xff, 0x40, 0xe5, 0x00, 0x6f, 0x50, 0x99, 0xf7, 0xe7, 0x73, 0x24, 0x60, 0x32, 0x6b, - 0x74, 0xe0, 0xcb, 0xf2, 0xff, 0x4b, 0xea, 0xd3, 0xb1, 0x62, 0xbc, 0x8e, 0x92, 0xa0, 0xa3, 0x7a, - 0x0d, 0x1a, 0x6d, 0xbf, 0xb7, 0xaa, 0x07, 0x3a, 0x19, 0xf8, 0x2a, 0x34, 0xfa, 0x09, 0x48, 0x06, - 0xe7, 0xcf, 0xc7, 0x88, 0x34, 0x7e, 0xb8, 0xfa, 0x81, 0x0c, 0xad, 0x7c, 0x53, 0xf8, 0x2e, 0x96, - 0x01, 0x79, 0xde, 0x8a, 0x63, 0x20, 0xa2, 0x5a, 0x45, 0x8b, 0x40, 0xec, 0x3b, 0xe4, 0x79, 0x78, - 0x7d, 0x63, 0x6d, 0x3c, 0x85, 0x94, 0x45, 0x28, 0x5b, 0x91, 0x5b, 0x06, 0x4b, 0x41, 0xc6, 0x29, - 0x7d, 0x68, 0x12, 0xeb, 0x72, 0x0a, 0x31, 0x9f, 0x2d, 0x8d, 0xec, 0x33, 0xdf, 0xa5, 0x4e, 0xe3, - 0x78, 0x50, 0xc7, 0x65, 0x58, 0xcf, 0x77, 0xe1, 0x44, 0xee, 0xd0, 0x1c, 0x07, 0x3e, 0x2f, 0x3a, - 0xf0, 0x54, 0xb1, 0x2a, 0x69, 0x27, 0xba, 0xa0, 0xac, 0xa1, 0xa0, 0xad, 0xdf, 0x5d, 0xb2, 0x8d, - 0xb6, 0x69, 0x77, 0xd0, 0x3e, 0x8e, 0xf6, 0x05, 0x68, 0xb0, 0xe3, 0x86, 0xd8, 0x4d, 0x75, 0x8d, - 0x47, 0x15, 0x9e, 0x42, 0xa4, 0xf2, 0xa1, 0x94, 0xc9, 0x07, 0xf5, 0x12, 0x4c, 0xf2, 0xd3, 0x91, - 0x05, 0x46, 0xbf, 0xdb, 0x41, 0xfb, 0x44, 0xa1, 0x29, 0x8d, 0x41, 0x04, 0x4f, 0x46, 0xb0, 0xdd, - 0x07, 0x83, 0xd4, 0xdf, 0xc8, 0x70, 0x2c, 0x23, 0xb2, 0xef, 0xde, 0x2b, 0x1f, 0x3e, 0x5e, 0x4a, - 0x45, 0xf1, 0x52, 0x16, 0xe2, 0x65, 0x0f, 0x66, 0xa9, 0x93, 0xb8, 0xa9, 0x5b, 0x15, 0x12, 0x00, - 0xaf, 0xe5, 0x6d, 0x06, 0xb2, 0x42, 0x32, 0xdf, 0x73, 0x58, 0xea, 0xfc, 0x2c, 0xdf, 0x79, 0x04, - 0x73, 0xf9, 0x83, 0x73, 0xdc, 0xff, 0x82, 0xe8, 0xfe, 0xff, 0xc8, 0x73, 0x3f, 0x2f, 0x09, 0xe7, - 0xff, 0xcf, 0x48, 0x30, 0x83, 0xab, 0x6a, 0x07, 0xd9, 0x46, 0xdb, 0xef, 0x11, 0x4b, 0x2e, 0x40, - 0x83, 0x32, 0x68, 0xfb, 0xbd, 0x64, 0x77, 0xc8, 0xa1, 0xf0, 0x88, 0xae, 0x65, 0xe2, 0xea, 0x49, - 0x46, 0xb0, 0xaa, 0xc7, 0xa1, 0xf0, 0x0a, 0xe9, 0x23, 0x76, 0x34, 0x83, 0xcd, 0x5b, 0xd2, 0x62, - 0x98, 0xad, 0x78, 0xe5, 0x78, 0xc5, 0x7b, 0x7f, 0x02, 0x26, 0x58, 0x78, 0x92, 0x55, 0x12, 0x6f, - 0xd0, 0xe3, 0x3a, 0x4b, 0x21, 0xda, 0x04, 0x77, 0x0f, 0x92, 0x78, 0xa3, 0x10, 0x7f, 0x4e, 0x56, - 0x12, 0xcf, 0xc9, 0x52, 0x32, 0x96, 0xb3, 0x32, 0xa6, 0xf4, 0xac, 0x64, 0xf5, 0xc4, 0x3d, 0x1f, - 0x69, 0x83, 0xb6, 0x2c, 0x3d, 0xd8, 0x71, 0xbc, 0x3e, 0xdb, 0x6f, 0x57, 0xb4, 0x0c, 0x1e, 0xf7, - 0x99, 0x14, 0x17, 0x6f, 0x14, 0xe8, 0x9a, 0x9e, 0xc2, 0xe2, 0xb6, 0x9c, 0x62, 0xa2, 0x0d, 0x03, - 0x3d, 0x30, 0x11, 0x91, 0x54, 0x36, 0xdf, 0x37, 0x1d, 0x9b, 0xb4, 0xac, 0x74, 0x5f, 0xc0, 0xa3, - 0xb0, 0xe6, 0x7d, 0xbf, 0x77, 0xc5, 0x73, 0xfa, 0x6c, 0x2f, 0x16, 0x81, 0x44, 0x73, 0xc7, 0x0e, - 0xa2, 0x76, 0x97, 0x1e, 0x95, 0xf0, 0x28, 0x4c, 0xcb, 0x40, 0xd2, 0x41, 0x4d, 0x6a, 0x11, 0x88, - 0x83, 0xcb, 0x47, 0xfb, 0xac, 0xd3, 0xc7, 0xff, 0x15, 0x3c, 0x39, 0x93, 0xf2, 0xa4, 0xd8, 0xba, - 0x35, 0xc9, 0x57, 0xbe, 0x75, 0x4b, 0x7a, 0x9e, 0x59, 0xa1, 0xe7, 0x59, 0x82, 0x09, 0xc7, 0xc5, - 0xf5, 0xc0, 0x6f, 0x29, 0x24, 0x7f, 0xfe, 0xab, 0xb8, 0x62, 0x2d, 0x6e, 0xd2, 0x91, 0x34, 0x53, - 0x22, 0x3a, 0xe5, 0x3a, 0xcc, 0x38, 0x3b, 0x3b, 0x96, 0x69, 0xa3, 0xad, 0xd0, 0xdf, 0x25, 0xfb, - 0xf2, 0x63, 0x24, 0xfa, 0xd5, 0xbc, 0xae, 0x42, 0x1c, 0xa9, 0xa5, 0x49, 0x71, 0x2b, 0xa8, 0x07, - 0x74, 0x47, 0x44, 0x2a, 0xde, 0x71, 0x52, 0xf1, 0x04, 0x1c, 0x39, 0x70, 0xe4, 0x2a, 0xff, 0x09, - 0x62, 0x38, 0x1e, 0x45, 0xb9, 0x04, 0x7a, 0x77, 0x17, 0x91, 0x13, 0xa6, 0xd6, 0x1c, 0x6d, 0x28, - 0x79, 0x1c, 0x0b, 0xfe, 0xc7, 0xe3, 0x6e, 0xb6, 0x05, 0x13, 0xa6, 0xaf, 0x21, 0xbd, 0x1b, 0xb4, - 0xce, 0x2e, 0x48, 0x67, 0x6b, 0x5a, 0x04, 0x2a, 0x17, 0xe1, 0xb8, 0xe9, 0x5f, 0xbe, 0x1b, 0x20, - 0xcf, 0xd6, 0x2d, 0xfc, 0xaf, 0xed, 0x13, 0x8b, 0x3d, 0x43, 0x86, 0xe5, 0x7e, 0x53, 0x16, 0x41, - 0xc1, 0x51, 0x60, 0x7a, 0x7e, 0xd0, 0x76, 0x0c, 0x73, 0xe7, 0x90, 0x38, 0xe6, 0x1c, 0x71, 0x4c, - 0xce, 0x97, 0xf9, 0x97, 0x61, 0x92, 0x37, 0x6f, 0x4e, 0x6d, 0x39, 0xce, 0xd7, 0x96, 0x1a, 0x5f, - 0x3a, 0xbe, 0x2e, 0xc1, 0x4c, 0xca, 0xb0, 0x78, 0x74, 0x60, 0x06, 0x16, 0x62, 0x1c, 0x28, 0x80, - 0x37, 0x72, 0x06, 0xf2, 0xbb, 0x2c, 0x75, 0xc9, 0xff, 0x99, 0x1d, 0x4a, 0xb1, 0x1d, 0x54, 0x98, - 0x34, 0x37, 0x3b, 0x98, 0x51, 0xc7, 0x09, 0x6d, 0x23, 0xbe, 0x2f, 0xe0, 0x70, 0xe4, 0x84, 0x61, - 0xb3, 0xb3, 0xac, 0x1b, 0x3d, 0x44, 0x6f, 0x8f, 0x2a, 0x44, 0x26, 0x11, 0xa9, 0x1a, 0x50, 0xbb, - 0x61, 0xba, 0xfe, 0x8a, 0xd3, 0xef, 0xe3, 0x00, 0x34, 0x50, 0x80, 0xb7, 0x1c, 0x12, 0x71, 0x17, - 0x83, 0xb0, 0x2f, 0x0d, 0xb4, 0xa3, 0x87, 0x56, 0x80, 0x87, 0x46, 0x05, 0x8c, 0x43, 0x91, 0xd3, - 0x0e, 0xdf, 0xb1, 0x57, 0x29, 0x35, 0x95, 0x93, 0xc3, 0xa8, 0xbf, 0x92, 0xa1, 0x49, 0x0a, 0xf4, - 0x0a, 0x09, 0x77, 0x83, 0x10, 0x5d, 0x84, 0x0a, 0x29, 0x3f, 0xac, 0xc1, 0x1d, 0x7c, 0x44, 0x44, - 0x87, 0x2a, 0x97, 0xa0, 0xea, 0xb8, 0xa4, 0x2b, 0xa6, 0xd5, 0xfb, 0x4c, 0x11, 0x91, 0x78, 0x43, - 0xa0, 0x31, 0x2a, 0xe5, 0x0a, 0x40, 0x3f, 0x69, 0x82, 0x69, 0x2f, 0x33, 0x2a, 0x0f, 0x8e, 0x12, - 0x1b, 0x37, 0x5e, 0xa6, 0xe3, 0x6b, 0x82, 0x92, 0x26, 0x22, 0x95, 0x0d, 0x98, 0x26, 0x62, 0x6f, - 0x46, 0x67, 0x85, 0xc4, 0x07, 0xa3, 0xcf, 0x98, 0xa2, 0x56, 0xbf, 0x23, 0x31, 0x33, 0xe2, 0xaf, - 0x1d, 0x44, 0x6d, 0x9f, 0x98, 0x44, 0x1a, 0xcb, 0x24, 0xf3, 0x50, 0xeb, 0x87, 0xdc, 0xd1, 0x65, - 0x49, 0x8b, 0xe1, 0xc4, 0x45, 0xa5, 0x91, 0x5d, 0xa4, 0x7e, 0x57, 0x82, 0xd6, 0xeb, 0x8e, 0x69, - 0x93, 0x0f, 0x4b, 0xae, 0x6b, 0xb1, 0xdb, 0xa4, 0xb1, 0x7d, 0xfe, 0x31, 0xa8, 0xeb, 0x94, 0x8d, - 0x1d, 0x30, 0xb7, 0x8f, 0x70, 0x1c, 0x99, 0xd0, 0x70, 0x67, 0x42, 0x25, 0xfe, 0x4c, 0x48, 0x7d, - 0x4f, 0x82, 0x69, 0x6a, 0x94, 0x37, 0x42, 0x33, 0x18, 0x5b, 0xbe, 0x65, 0xa8, 0xed, 0x87, 0x66, - 0x30, 0x46, 0x54, 0xc6, 0x74, 0xd9, 0x78, 0x2a, 0xe5, 0xc4, 0x93, 0xfa, 0x81, 0x04, 0x27, 0xd3, - 0x66, 0x5d, 0xea, 0x76, 0x91, 0x7b, 0x3f, 0x53, 0x4a, 0x38, 0x13, 0x2b, 0xe7, 0x9c, 0x89, 0x79, - 0xa8, 0x8b, 0xcc, 0x03, 0xe4, 0x2d, 0xf9, 0x6c, 0x93, 0xcf, 0x61, 0x72, 0x55, 0xd2, 0xd0, 0xbb, - 0xa8, 0xfb, 0xf0, 0xaa, 0xf4, 0x39, 0x19, 0x9e, 0x58, 0x8b, 0x13, 0xf7, 0x86, 0xa7, 0xdb, 0xfe, - 0x0e, 0xf2, 0xbc, 0xfb, 0xa8, 0xcf, 0x75, 0x98, 0xb2, 0xd1, 0x9d, 0x44, 0x26, 0x96, 0xce, 0xa3, - 0xb2, 0x11, 0x89, 0x47, 0xab, 0x7d, 0xea, 0x3f, 0x25, 0x68, 0x52, 0x3e, 0xd7, 0xcc, 0xee, 0xde, - 0x7d, 0x54, 0x7e, 0x03, 0xa6, 0xf7, 0x88, 0x04, 0x18, 0x1a, 0xa3, 0xec, 0xa7, 0xa8, 0x47, 0x54, - 0xff, 0x43, 0x09, 0x66, 0xa3, 0x4b, 0xf0, 0x03, 0xf3, 0x7e, 0x06, 0xf3, 0x16, 0xcc, 0xd0, 0x4b, - 0x85, 0x71, 0x0d, 0x90, 0x26, 0x1f, 0xd1, 0x02, 0x3f, 0x96, 0x60, 0x86, 0x72, 0xba, 0x6c, 0x07, - 0xc8, 0x1b, 0x5b, 0xff, 0xab, 0xd0, 0x40, 0x76, 0xe0, 0xe9, 0xf6, 0x38, 0x15, 0x96, 0x27, 0x1d, - 0xb1, 0xc8, 0xbe, 0x27, 0x81, 0x42, 0x58, 0xad, 0x9a, 0x7e, 0xdf, 0xf4, 0xfd, 0xfb, 0xe8, 0xba, - 0xd1, 0x04, 0xfe, 0x96, 0x0c, 0xc7, 0x39, 0x2e, 0xed, 0x30, 0x78, 0xd0, 0x45, 0x56, 0x56, 0xa1, - 0x8e, 0x7b, 0x0c, 0xfe, 0xca, 0x77, 0xd4, 0x89, 0x12, 0x42, 0xdc, 0x05, 0x13, 0xa0, 0x83, 0xba, - 0x8e, 0x6d, 0xd0, 0x52, 0x3c, 0xa5, 0x09, 0x38, 0x5c, 0x86, 0xe6, 0x39, 0x36, 0x2b, 0xba, 0xdd, - 0x45, 0xd6, 0x23, 0x63, 0x22, 0xf5, 0xfb, 0x12, 0x4c, 0xd3, 0x21, 0x0f, 0xbe, 0xca, 0xea, 0x0f, - 0x25, 0x16, 0xc8, 0x0f, 0x8d, 0x97, 0x70, 0x78, 0xcd, 0x71, 0x5c, 0xf8, 0xbe, 0xfc, 0xc1, 0x0d, - 0xad, 0xab, 0xd0, 0xe8, 0xee, 0xea, 0x76, 0x6f, 0xac, 0xe0, 0xe2, 0x49, 0xd5, 0x00, 0x1e, 0xe7, - 0xef, 0x20, 0x56, 0xe8, 0x27, 0xa2, 0xfe, 0x73, 0x29, 0x55, 0x06, 0x3e, 0xe9, 0xb8, 0x37, 0xa3, - 0xef, 0xc1, 0x2c, 0xbd, 0x14, 0xe7, 0x7a, 0x46, 0xa5, 0x05, 0x13, 0xba, 0x41, 0x0f, 0x5e, 0x24, - 0x42, 0x14, 0x81, 0xe2, 0xa3, 0x09, 0xf6, 0x3c, 0x2f, 0x79, 0x34, 0x71, 0x0a, 0x40, 0x37, 0x8c, - 0x5b, 0x8e, 0x67, 0x98, 0x76, 0xb4, 0x41, 0xe0, 0x30, 0xea, 0xeb, 0x30, 0x79, 0xc5, 0x73, 0xfa, - 0x37, 0xb8, 0xeb, 0xed, 0x81, 0x17, 0xf0, 0xfc, 0xd5, 0xb8, 0x2c, 0x5e, 0x8d, 0xab, 0xef, 0xc0, - 0x89, 0x8c, 0xe0, 0xc4, 0x58, 0x2b, 0xf4, 0xd6, 0x3e, 0x9a, 0x84, 0x85, 0x4c, 0xde, 0xd1, 0x24, - 0x2f, 0x8b, 0x26, 0x10, 0xa9, 0x9f, 0x95, 0xe0, 0xa9, 0x0c, 0xfb, 0x25, 0xd7, 0xf5, 0x9c, 0x03, - 0xe6, 0x93, 0xa3, 0x98, 0x46, 0x6c, 0x8e, 0xe5, 0x54, 0x73, 0x9c, 0x2f, 0x84, 0xd0, 0xd0, 0x7f, - 0x04, 0x42, 0x7c, 0x4f, 0x82, 0x19, 0x26, 0x84, 0x61, 0xb0, 0x69, 0x5f, 0x80, 0x2a, 0x7d, 0x37, - 0xc4, 0x26, 0x7c, 0x2a, 0x77, 0xc2, 0xe8, 0xbd, 0x93, 0xc6, 0x06, 0x67, 0x23, 0x52, 0xce, 0xcb, - 0xa8, 0x97, 0xe2, 0x60, 0x1f, 0xf9, 0x65, 0x0f, 0x23, 0x50, 0x3f, 0x1e, 0x05, 0xf3, 0x2a, 0xb2, - 0xd0, 0x51, 0xda, 0x48, 0xbd, 0x09, 0xd3, 0xe4, 0x11, 0x53, 0x62, 0x83, 0x23, 0x61, 0x7b, 0x0b, - 0x9a, 0x84, 0xed, 0x91, 0xcb, 0x1b, 0x67, 0x07, 0xb6, 0x0f, 0x5f, 0x4a, 0x8e, 0x84, 0xfb, 0xb3, - 0x70, 0x2c, 0xb2, 0x3d, 0x7d, 0x18, 0x4c, 0x79, 0x17, 0x5c, 0x55, 0xaa, 0xdf, 0x90, 0x60, 0x6e, - 0xc5, 0xb1, 0x0f, 0x90, 0xe7, 0x0b, 0x8f, 0x89, 0x29, 0x89, 0x90, 0xfd, 0x0c, 0x52, 0x16, 0x41, - 0xe9, 0x72, 0x14, 0xec, 0x70, 0x54, 0x26, 0x87, 0xa3, 0x39, 0x5f, 0x94, 0xe7, 0xe1, 0x44, 0x48, - 0xb8, 0xde, 0xb4, 0x3d, 0xa4, 0x1b, 0xe4, 0x3c, 0x8e, 0x2b, 0x7a, 0xf9, 0x1f, 0xd5, 0x77, 0x61, - 0x9e, 0x97, 0xab, 0x83, 0x82, 0x2d, 0xcf, 0x3c, 0xe0, 0x64, 0x63, 0x27, 0xff, 0x92, 0x70, 0xf2, - 0x9f, 0xdc, 0x14, 0xc8, 0xc2, 0x4d, 0xc1, 0x49, 0xa8, 0x9b, 0x3e, 0x63, 0x40, 0xe6, 0xad, 0x69, - 0x09, 0x42, 0xd5, 0x61, 0x96, 0x7a, 0x99, 0x5d, 0xcd, 0x91, 0x29, 0xe6, 0xa1, 0x46, 0x43, 0x37, - 0x9e, 0x24, 0x86, 0x0b, 0x2f, 0xba, 0x0a, 0xaf, 0x75, 0xd5, 0x0e, 0xcc, 0xb2, 0xa7, 0x4d, 0x5b, - 0x7a, 0xcf, 0xb4, 0x69, 0x2d, 0x3f, 0x05, 0xe0, 0xea, 0xbd, 0xe8, 0xa1, 0x25, 0xbd, 0xa0, 0xe4, - 0x30, 0xf8, 0xbb, 0xbf, 0xeb, 0xdc, 0x61, 0xdf, 0x65, 0xfa, 0x3d, 0xc1, 0xa8, 0x6f, 0x82, 0xa2, - 0x21, 0xdf, 0x75, 0x6c, 0x1f, 0x71, 0x5c, 0x17, 0xa0, 0xb1, 0x12, 0x7a, 0x1e, 0xb2, 0xf1, 0x54, - 0xd1, 0x6b, 0x41, 0x1e, 0x85, 0xf9, 0x76, 0x12, 0xbe, 0xf4, 0xee, 0x82, 0xc3, 0xa8, 0x7f, 0xaa, - 0x42, 0xbd, 0x63, 0xf6, 0x6c, 0xdd, 0xd2, 0xd0, 0xbe, 0xf2, 0x2a, 0x54, 0xe9, 0xce, 0x88, 0x05, - 0x64, 0xde, 0x59, 0x3a, 0x1d, 0x4d, 0xb7, 0x80, 0x1a, 0xda, 0xbf, 0xfa, 0x98, 0xc6, 0x68, 0x94, - 0x37, 0xa2, 0x07, 0x60, 0xeb, 0xf4, 0xa4, 0x8c, 0x2d, 0x93, 0xcf, 0x0c, 0x61, 0xc2, 0x46, 0x53, - 0x5e, 0x22, 0x07, 0x2c, 0x50, 0x97, 0x74, 0x4e, 0xac, 0x0a, 0x15, 0x0b, 0x44, 0x1b, 0x2c, 0x26, - 0x10, 0xa5, 0xc1, 0xd4, 0x3a, 0x39, 0x4b, 0x62, 0x0d, 0x41, 0x31, 0x35, 0x3d, 0x72, 0x62, 0xd4, - 0x94, 0x06, 0x53, 0xef, 0x86, 0x76, 0xef, 0xa6, 0xcb, 0x8e, 0x38, 0x8b, 0xa9, 0xaf, 0x92, 0x61, - 0x8c, 0x9a, 0xd2, 0x60, 0x6a, 0x8f, 0xac, 0x11, 0xc4, 0xe8, 0x83, 0xa8, 0xe9, 0x52, 0xc2, 0xa8, - 0x29, 0x8d, 0xf2, 0x16, 0x34, 0x7b, 0x28, 0xd0, 0x1c, 0xa7, 0xbf, 0x7c, 0xb8, 0xc6, 0xee, 0xb7, - 0xe8, 0x7b, 0xf7, 0xf3, 0x85, 0x7c, 0xd6, 0x52, 0x04, 0x94, 0x63, 0x86, 0x8f, 0xf2, 0x29, 0x78, - 0xca, 0xb1, 0x31, 0x6a, 0x4b, 0xf7, 0x02, 0xb3, 0x6b, 0xba, 0xba, 0x1d, 0xac, 0x38, 0xb6, 0x4d, - 0xd6, 0x33, 0x0d, 0xed, 0xb3, 0x17, 0xf1, 0x2f, 0x16, 0x4e, 0xb4, 0x39, 0x88, 0xfa, 0xea, 0x63, - 0xda, 0x60, 0xf6, 0xca, 0x17, 0x25, 0x58, 0xc8, 0x8c, 0x58, 0x35, 0xfd, 0x2e, 0x2f, 0x03, 0x7d, - 0x4d, 0xff, 0xd2, 0xe8, 0x32, 0xa4, 0x18, 0x5c, 0x7d, 0x4c, 0x1b, 0x3a, 0x09, 0xb3, 0xf2, 0x0d, - 0x67, 0x0f, 0xd9, 0xcb, 0x87, 0x78, 0xec, 0xfa, 0x2a, 0xb9, 0x4b, 0x1b, 0x62, 0x65, 0x81, 0x20, - 0xb1, 0xb2, 0x80, 0x5e, 0xae, 0xc3, 0x84, 0xab, 0x1f, 0x5a, 0x8e, 0x6e, 0xa8, 0x7f, 0x2d, 0x03, - 0x44, 0xae, 0xf6, 0x49, 0x47, 0x2c, 0x24, 0xd9, 0xe9, 0xa1, 0x49, 0xe6, 0x5a, 0x87, 0x5c, 0x9a, - 0x75, 0xf2, 0xd3, 0xec, 0xbf, 0x47, 0x4d, 0x33, 0xca, 0x2d, 0x95, 0x68, 0x97, 0x52, 0x89, 0x76, - 0x7a, 0x68, 0xa2, 0x31, 0xa1, 0x58, 0xaa, 0x5d, 0x4a, 0xa5, 0xda, 0xe9, 0xa1, 0xa9, 0xc6, 0xe8, - 0x59, 0xb2, 0x5d, 0x4a, 0x25, 0xdb, 0xe9, 0xa1, 0xc9, 0xc6, 0xe8, 0x59, 0xba, 0x5d, 0x4a, 0xa5, - 0xdb, 0xe9, 0xa1, 0xe9, 0xc6, 0xe8, 0x59, 0xc2, 0xbd, 0x53, 0x98, 0x70, 0x8b, 0xf7, 0x90, 0x70, - 0x94, 0x67, 0x36, 0xe5, 0xde, 0xc9, 0x09, 0xb4, 0xda, 0x70, 0xee, 0xa9, 0x40, 0x4b, 0xb8, 0x17, - 0x86, 0xda, 0xe7, 0x4b, 0x30, 0x4d, 0xdc, 0x4d, 0x57, 0x65, 0x7b, 0xc7, 0xc9, 0x3e, 0xcb, 0x95, - 0x72, 0x9e, 0xe5, 0x2a, 0xe7, 0x61, 0x96, 0x22, 0x10, 0x77, 0x0b, 0x4a, 0x17, 0xfa, 0xec, 0x07, - 0x72, 0xef, 0x1b, 0xfa, 0x81, 0xd3, 0x5f, 0xd5, 0x03, 0x3d, 0xda, 0x61, 0x24, 0x18, 0xfe, 0x56, - 0xbe, 0x9c, 0xf9, 0xf5, 0x8a, 0x47, 0xf5, 0xaf, 0xb0, 0xd5, 0x9c, 0x40, 0x98, 0x22, 0x30, 0xfb, - 0xc8, 0x09, 0x03, 0xb6, 0x48, 0x45, 0x20, 0x7d, 0x4b, 0x69, 0x98, 0x3a, 0xb9, 0xcb, 0x66, 0x0f, - 0x0d, 0x63, 0x04, 0x59, 0x57, 0x93, 0xbb, 0x79, 0xf6, 0xeb, 0x92, 0x04, 0x33, 0xc2, 0x3d, 0x3a, - 0xf9, 0xa1, 0x92, 0x19, 0x98, 0xfc, 0x03, 0xc4, 0x8a, 0x26, 0xe0, 0x70, 0x1f, 0xb4, 0x1d, 0xfa, - 0x87, 0xd7, 0x4d, 0x9b, 0x37, 0x4f, 0x83, 0xf6, 0x41, 0xd9, 0x2f, 0xea, 0x9f, 0x25, 0x38, 0xc6, - 0xd5, 0x9d, 0x36, 0x0a, 0x74, 0x62, 0x17, 0xe1, 0x19, 0xb9, 0x74, 0x6f, 0xcf, 0xc8, 0xb7, 0x60, - 0xa6, 0x27, 0x6e, 0xcb, 0xef, 0x71, 0x47, 0x9d, 0x26, 0x17, 0xde, 0xc4, 0x97, 0xee, 0xf9, 0x4d, - 0xbc, 0xfa, 0x25, 0x19, 0x66, 0x52, 0xcd, 0xc0, 0xc0, 0x4e, 0x6a, 0x09, 0xc0, 0x8c, 0x43, 0x73, - 0xc0, 0xad, 0x97, 0x18, 0xbf, 0x1a, 0x47, 0x94, 0x77, 0xe9, 0x5f, 0x1a, 0xff, 0xd2, 0xff, 0x2a, - 0x34, 0xdc, 0xc4, 0x49, 0x03, 0x0e, 0x0d, 0x72, 0x5c, 0xa9, 0xf1, 0xa4, 0xea, 0x97, 0x25, 0x98, - 0xcd, 0x94, 0x6c, 0x72, 0x19, 0x8e, 0x13, 0x35, 0xbe, 0x0c, 0xc7, 0x00, 0x97, 0x01, 0x72, 0x3a, - 0x03, 0x2c, 0xf3, 0x80, 0xff, 0xf5, 0x0e, 0x03, 0x0b, 0xa2, 0xaf, 0x5c, 0x18, 0x7d, 0x5f, 0x91, - 0x61, 0x2e, 0xbf, 0xc1, 0x7a, 0x54, 0xfd, 0xf3, 0x55, 0x09, 0x5a, 0x45, 0x6b, 0xe1, 0x7d, 0x73, - 0x53, 0x92, 0x3f, 0x71, 0xef, 0xfa, 0xa8, 0xfa, 0xe7, 0x58, 0x94, 0x3e, 0x5c, 0x73, 0xa1, 0xbe, - 0x1f, 0xdb, 0x27, 0xee, 0xce, 0x1f, 0x51, 0xfb, 0x28, 0xe7, 0xa0, 0x49, 0xd5, 0xe4, 0xde, 0xa1, - 0xd1, 0xcd, 0x5e, 0x06, 0xaf, 0xbe, 0x1d, 0xd9, 0x92, 0x6b, 0xb4, 0x8e, 0x2a, 0xc6, 0xd5, 0x9f, - 0x4b, 0x91, 0x4f, 0xe2, 0x3d, 0xcf, 0x43, 0xe5, 0x93, 0x24, 0xd2, 0xb8, 0x36, 0x92, 0x8b, 0xb4, - 0x78, 0x2f, 0xf6, 0xef, 0x48, 0x1b, 0x1e, 0x69, 0xb1, 0x2d, 0xb9, 0x96, 0x5a, 0xfd, 0xb6, 0x04, - 0x4f, 0x14, 0xee, 0x47, 0x07, 0x5a, 0x95, 0x6b, 0x1a, 0x65, 0xb1, 0x69, 0x4c, 0xa9, 0x57, 0x1a, - 0xbf, 0xd0, 0xfc, 0x52, 0x82, 0x27, 0x07, 0x34, 0xef, 0x29, 0xcf, 0x4a, 0xe3, 0x78, 0x36, 0x25, - 0xac, 0x5c, 0x78, 0x31, 0x3d, 0xd4, 0x17, 0x49, 0x7a, 0x96, 0xf8, 0xf4, 0x54, 0x7f, 0x2b, 0xc1, - 0xd3, 0x23, 0xec, 0xc4, 0x1f, 0x2c, 0x65, 0x0a, 0x1f, 0xea, 0xaa, 0xbf, 0x93, 0xe0, 0xcc, 0x68, - 0x9b, 0xfa, 0x87, 0x45, 0xa3, 0x9f, 0xf2, 0x39, 0x90, 0x3e, 0x2d, 0xe0, 0xdc, 0x2a, 0x09, 0x55, - 0x97, 0xcf, 0x0d, 0x39, 0x95, 0x1b, 0x47, 0x96, 0x01, 0xe9, 0x07, 0xfa, 0xe5, 0xec, 0x03, 0xfd, - 0x36, 0x97, 0x22, 0xd9, 0x1d, 0x68, 0xc1, 0x52, 0xc2, 0x2d, 0x19, 0xb2, 0xb8, 0x64, 0x7c, 0x1a, - 0xa6, 0x56, 0x91, 0xd5, 0xf6, 0x7b, 0xd1, 0x4f, 0x69, 0x8e, 0xf4, 0xb4, 0x75, 0x04, 0x7d, 0x96, - 0x61, 0x9a, 0x17, 0x60, 0x9c, 0x9f, 0x8a, 0xa8, 0xb7, 0xe0, 0x89, 0x0e, 0x0a, 0x96, 0x5c, 0x77, - 0x59, 0xef, 0xee, 0x61, 0x37, 0xdb, 0x46, 0x87, 0x3c, 0x65, 0x1e, 0xf4, 0xdb, 0x20, 0xbc, 0xb3, - 0xf4, 0x13, 0x02, 0xf6, 0x82, 0x56, 0xc0, 0xa9, 0x1b, 0x30, 0x5f, 0xc4, 0x78, 0x2c, 0x41, 0xff, - 0x26, 0xc3, 0x24, 0x79, 0x0f, 0x6c, 0xb4, 0xfd, 0x5e, 0x07, 0x91, 0x1f, 0xc4, 0xfb, 0xe4, 0x5a, - 0x30, 0xb1, 0x76, 0x04, 0xa7, 0x37, 0xc7, 0x72, 0x76, 0x73, 0xbc, 0x09, 0x80, 0x22, 0x6e, 0x3e, - 0x7b, 0x64, 0x73, 0x21, 0x27, 0xec, 0xf8, 0x29, 0x13, 0x80, 0xbd, 0xd9, 0xe6, 0x58, 0xe0, 0xf5, - 0xa5, 0xad, 0xdf, 0x6d, 0xfb, 0x3d, 0xee, 0x0f, 0x9d, 0xd0, 0xb7, 0x36, 0x19, 0x3c, 0xb6, 0x5f, - 0x4c, 0xb9, 0x11, 0xf6, 0xd9, 0x3a, 0x24, 0xe0, 0x52, 0x2f, 0xd0, 0xab, 0xe9, 0x17, 0xe8, 0xf3, - 0x6f, 0xc3, 0x4c, 0x4a, 0x9c, 0x9c, 0x37, 0xce, 0x17, 0xc5, 0xdf, 0x4f, 0x9c, 0x1c, 0xa4, 0x20, - 0xff, 0x02, 0xfa, 0x2f, 0x32, 0xd4, 0xe3, 0x0f, 0x4a, 0x1f, 0x4e, 0x78, 0x48, 0x27, 0x7f, 0xd9, - 0x24, 0x7e, 0x91, 0xcd, 0xfd, 0xca, 0xe9, 0xff, 0x06, 0x71, 0x5d, 0xd4, 0xf2, 0x28, 0xa9, 0xf9, - 0xf2, 0xb9, 0x8e, 0xf0, 0x1b, 0x8c, 0xfc, 0xc7, 0xe0, 0xa5, 0xa2, 0xc7, 0xe0, 0x99, 0xe7, 0xeb, - 0xe5, 0xc2, 0xe7, 0xeb, 0xf1, 0x1f, 0xad, 0x98, 0x47, 0x30, 0x5f, 0x2c, 0x7a, 0x8e, 0xa9, 0xff, - 0x57, 0x34, 0x75, 0xde, 0x15, 0xfa, 0x35, 0x74, 0x48, 0xff, 0x5c, 0x0a, 0x67, 0xe9, 0x1d, 0xa8, - 0x45, 0x68, 0x72, 0x54, 0x74, 0xe8, 0xa2, 0x6b, 0x31, 0xe3, 0x08, 0x14, 0xdf, 0xaa, 0xd7, 0x19, - 0x3d, 0x0e, 0x39, 0x4b, 0x0f, 0x90, 0x1f, 0x70, 0x21, 0x47, 0x8d, 0x90, 0xc1, 0x2f, 0x9f, 0x7f, - 0xeb, 0xdc, 0xa6, 0x8b, 0xec, 0xdb, 0xeb, 0xed, 0xcc, 0x9f, 0x6c, 0x7a, 0x25, 0x23, 0xe9, 0x76, - 0x95, 0x7c, 0x7f, 0xee, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x71, 0x3a, 0xae, 0x9b, 0x12, 0x4a, - 0x00, 0x00, -} diff --git a/tools/data-conversion/openim/proto/sdk_ws/ws.proto b/tools/data-conversion/openim/proto/sdk_ws/ws.proto deleted file mode 100644 index 95b956b0e..000000000 --- a/tools/data-conversion/openim/proto/sdk_ws/ws.proto +++ /dev/null @@ -1,754 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -syntax = "proto3"; -import "Open-IM-Server/pkg/proto/sdk_ws/wrappers.proto"; -option go_package = "Open_IM/pkg/proto/sdk_ws;server_api_params"; -package server_api_params; - - -////////////////////////////////base/////////////////////////////// - - -message GroupInfo{ - string groupID = 1; - string groupName = 2; - string notification = 3; - string introduction = 4; - string faceURL = 5; - string ownerUserID = 6; - uint32 createTime = 7; - uint32 memberCount = 8; - string ex = 9; - int32 status = 10; - string creatorUserID = 11; - int32 groupType = 12; - int32 needVerification = 13; - int32 lookMemberInfo = 14; - int32 applyMemberFriend = 15; - uint32 notificationUpdateTime = 16; - string notificationUserID = 17; -} - -message GroupInfoForSet{ - string groupID = 1; - string groupName = 2; - string notification = 3; - string introduction = 4; - string faceURL = 5; - string ex = 6; - google.protobuf.Int32Value needVerification = 7; - google.protobuf.Int32Value lookMemberInfo = 8; - google.protobuf.Int32Value applyMemberFriend = 9; -} - - -message GroupMemberFullInfo { - string groupID = 1 ; - string userID = 2 ; - int32 roleLevel = 3; - int32 joinTime = 4; - string nickname = 5; - string faceURL = 6; - int32 appMangerLevel = 7; //if >0 - int32 joinSource = 8; - string operatorUserID = 9; - string ex = 10; - uint32 muteEndTime = 11; - string inviterUserID = 12; -} - -message PublicUserInfo{ - string userID = 1; - string nickname = 2; - string faceURL = 3; - int32 gender = 4; - string ex = 5; -} - -message UserInfo{ - string userID = 1; - string nickname = 2; - string faceURL = 3; - int32 gender = 4; - string phoneNumber = 5; - uint32 birth = 6; - string email = 7; - string ex = 8; - uint32 createTime = 9; - int32 appMangerLevel = 10; - int32 globalRecvMsgOpt = 11; - string birthStr = 12; -} - -message FriendInfo{ - string ownerUserID = 1; - string remark = 2; - uint32 createTime = 3; - UserInfo friendUser = 4; - int32 addSource = 5; - string operatorUserID = 6; - string ex = 7; -} - -message BlackInfo{ - string ownerUserID = 1; - uint32 createTime = 2; - PublicUserInfo blackUserInfo = 3; - int32 addSource = 4; - string operatorUserID = 5; - string ex = 6; -} - -message GroupRequest{ - PublicUserInfo userInfo = 1; - GroupInfo groupInfo = 2; - int32 handleResult = 3; - string reqMsg = 4; - string handleMsg = 5; - uint32 reqTime = 6; - string handleUserID = 7; - uint32 handleTime = 8; - string ex = 9; - int32 joinSource = 10; - string inviterUserID = 11; -} - -message FriendRequest{ - string fromUserID = 1; - string fromNickname = 2; - string fromFaceURL = 3; - int32 fromGender = 4; - string toUserID = 5; - string toNickname = 6; - string toFaceURL = 7; - int32 toGender = 8; - int32 handleResult = 9; - string reqMsg = 10; - uint32 createTime = 11; - string handlerUserID = 12; - string handleMsg = 13; - uint32 handleTime = 14; - string ex = 15; -} - -///////////////////////////////////organization///////////////////////////////////// - -message Department { - string departmentID = 1; - string faceURL = 2; - string name = 3; - string parentID = 4; - int32 order = 5; - int32 departmentType = 6; - uint32 createTime = 7; - uint32 subDepartmentNum = 8; - uint32 memberNum = 9; - string ex = 10; -} - - - -message OrganizationUser { - string userID = 1; - string nickname = 2; - string englishName = 3; - string faceURL = 4; - int32 gender = 5; - string mobile = 6; - string telephone = 7; - uint32 birth = 8; - string email = 9; - uint32 createTime = 10; - string ex = 11; - string birthStr = 12; -} - -message DepartmentMember { - string userID = 1; - string departmentID = 2; - int32 order = 3; - string position = 4; - int32 leader = 5; - int32 status = 6; - string ex = 7; -} - - -message UserDepartmentMember { - OrganizationUser organizationUser = 1; - DepartmentMember departmentMember = 2; -} - - -message UserInDepartment { - OrganizationUser organizationUser = 1; - repeated DepartmentMember departmentMemberList = 2; -} - - - - - -///////////////////////////////////organization end////////////////////////////////// - - - - - - -///////////////////////////////////base end///////////////////////////////////// -message PullMessageBySeqListReq{ - string userID = 1; - string operationID = 2; - repeated uint32 seqList = 3; - map groupSeqList = 4; -} - -message seqList { - repeated uint32 seqList = 1; -} - - -message MsgDataList { - repeated MsgData msgDataList = 1; -} - -message PullMessageBySeqListResp { - int32 errCode = 1; - string errMsg = 2; - repeated MsgData list = 3; - map groupMsgDataList = 4; -} - - - -message GetMaxAndMinSeqReq { - repeated string groupIDList = 1; - string userID = 2; - string operationID = 3; -} -message MaxAndMinSeq{ - uint32 maxSeq = 1; - uint32 minSeq = 2; -} -message GetMaxAndMinSeqResp { - uint32 maxSeq = 1; - uint32 minSeq = 2; - int32 errCode = 3; - string errMsg = 4; - map groupMaxAndMinSeq = 5; -} - -message UserSendMsgResp { - string serverMsgID = 1; - string clientMsgID = 2; - int64 sendTime = 3; - string ex = 4; -} - -message MsgData { - string sendID = 1; - string recvID = 2; - string groupID = 3; - string clientMsgID = 4; - string serverMsgID = 5; - int32 senderPlatformID = 6; - string senderNickname = 7; - string senderFaceURL = 8; - int32 sessionType = 9; - int32 msgFrom = 10; - int32 contentType = 11; - bytes content = 12; - uint32 seq = 14; - int64 sendTime = 15; - int64 createTime = 16; - int32 status = 17; - map options = 18; - OfflinePushInfo offlinePushInfo = 19; - repeated string atUserIDList = 20; - bytes msgDataList = 21; - string attachedInfo = 22; - string ex = 23; - - bool isReact = 40; - bool isExternalExtensions = 41; - int64 msgFirstModifyTime = 42; - -} -message OfflinePushInfo{ - string title = 1; - string desc = 2; - string ex = 3; - string iOSPushSound = 4; - bool iOSBadgeCount = 5; -} - - - - - - - - - -message TipsComm{ - bytes detail = 1; - string defaultTips = 2; - string jsonDetail = 3; -} - -//////////////////////group///////////////////// - - -// OnGroupCreated() -message GroupCreatedTips{ - GroupInfo group = 1; - GroupMemberFullInfo opUser = 2; - repeated GroupMemberFullInfo memberList = 3; - int64 operationTime = 4; - GroupMemberFullInfo groupOwnerUser = 5; -} - -// OnGroupInfoSet() -message GroupInfoSetTips{ - GroupMemberFullInfo opUser = 1; //who do this - int64 muteTime = 2; - GroupInfo group = 3; -} - -// OnJoinGroupApplication() -message JoinGroupApplicationTips{ - GroupInfo group = 1; - PublicUserInfo applicant = 2; - string reqMsg = 3; -} - -// OnQuitGroup() -//Actively leave the group -message MemberQuitTips{ - GroupInfo group = 1; - GroupMemberFullInfo quitUser = 2; - int64 operationTime = 3; -} - - -// OnApplicationGroupAccepted() -message GroupApplicationAcceptedTips{ - GroupInfo group = 1; - GroupMemberFullInfo opUser = 2; - string handleMsg = 4; - int32 receiverAs = 5; // admin(==1) or applicant(==0) -} - -// OnApplicationGroupRejected() -message GroupApplicationRejectedTips{ - GroupInfo group = 1; - GroupMemberFullInfo opUser = 2; - string handleMsg = 4; - int32 receiverAs = 5; // admin(==1) or applicant(==0) -} - -// OnTransferGroupOwner() -message GroupOwnerTransferredTips{ - GroupInfo group = 1; - GroupMemberFullInfo opUser = 2; - GroupMemberFullInfo newGroupOwner = 3; - int64 operationTime = 4; -} - - -// OnMemberKicked() -message MemberKickedTips{ - GroupInfo group = 1; - GroupMemberFullInfo opUser = 2; - repeated GroupMemberFullInfo kickedUserList = 3; - int64 operationTime = 4; -} - -// OnMemberInvited() -message MemberInvitedTips{ - GroupInfo group = 1; - GroupMemberFullInfo opUser = 2; - repeated GroupMemberFullInfo invitedUserList = 3; - int64 operationTime = 4; -} - -//Actively join the group -message MemberEnterTips{ - GroupInfo group = 1; - GroupMemberFullInfo entrantUser = 2; - int64 operationTime = 3; -} - -message GroupDismissedTips{ - GroupInfo group = 1; - GroupMemberFullInfo opUser = 2; - int64 operationTime = 3; -} - -message GroupMemberMutedTips{ - GroupInfo group = 1; - GroupMemberFullInfo opUser = 2; - int64 operationTime = 3; - GroupMemberFullInfo mutedUser = 4; - uint32 mutedSeconds = 5; -} - -message GroupMemberCancelMutedTips{ - GroupInfo group = 1; - GroupMemberFullInfo opUser = 2; - int64 operationTime = 3; - GroupMemberFullInfo mutedUser = 4; -} - -message GroupMutedTips{ - GroupInfo group = 1; - GroupMemberFullInfo opUser = 2; - int64 operationTime = 3; -} - -message GroupCancelMutedTips{ - GroupInfo group = 1; - GroupMemberFullInfo opUser = 2; - int64 operationTime = 3; -} - -message GroupMemberInfoSetTips{ - GroupInfo group = 1; - GroupMemberFullInfo opUser = 2; - int64 operationTime = 3; - GroupMemberFullInfo changedUser = 4; -} - - -message OrganizationChangedTips{ - UserInfo opUser = 2; - int64 operationTime = 3; -} - - -//////////////////////friend///////////////////// -//message FriendInfo{ -// UserInfo OwnerUser = 1; -// string Remark = 2; -// uint64 CreateTime = 3; -// UserInfo FriendUser = 4; -//} - -message FriendApplication{ - int64 addTime = 1; - string addSource = 2; - string addWording = 3; -} - -message FromToUserID{ - string fromUserID = 1; - string toUserID = 2; -} - -//FromUserID apply to add ToUserID -message FriendApplicationTips{ - FromToUserID fromToUserID = 1; -} - -//FromUserID accept or reject ToUserID -message FriendApplicationApprovedTips{ - FromToUserID fromToUserID = 1; - string handleMsg = 2; -} - -//FromUserID accept or reject ToUserID -message FriendApplicationRejectedTips{ - FromToUserID fromToUserID = 1; - string handleMsg = 2; -} - - -// FromUserID Added a friend ToUserID -message FriendAddedTips{ - FriendInfo friend = 1; - int64 operationTime = 2; - PublicUserInfo opUser = 3; //who do this - -} - -// FromUserID deleted a friend ToUserID -message FriendDeletedTips{ - FromToUserID fromToUserID = 1; -} - - - -message BlackAddedTips{ - FromToUserID fromToUserID = 1; -} - -message BlackDeletedTips{ - FromToUserID fromToUserID = 1; -} - -message FriendInfoChangedTips{ - FromToUserID fromToUserID = 1; -} -//////////////////////user///////////////////// -message UserInfoUpdatedTips{ - string userID = 1; -} - -//////////////////////conversation///////////////////// -message ConversationUpdateTips{ - string UserID = 1; - repeated string conversationIDList = 2; - int64 updateUnreadCountTime = 3; - - -} - -message ConversationSetPrivateTips{ - string recvID = 1; - string sendID = 2; - bool isPrivate = 3; -} - -////////////////////message/////////////////////// -message DeleteMessageTips{ - string opUserID = 1; - string userID = 2; - repeated uint32 seqList = 3; -} -///cms -message RequestPagination { - int32 pageNumber = 1; - int32 showNumber = 2; -} - -message ResponsePagination { - int32 CurrentPage = 5; - int32 ShowNumber = 6; -} - - -///////////////////signal////////////// -message SignalReq { - oneof payload { - SignalInviteReq invite = 1; - SignalInviteInGroupReq inviteInGroup = 2; - SignalCancelReq cancel = 3; - SignalAcceptReq accept = 4; - SignalHungUpReq hungUp = 5; - SignalRejectReq reject = 6; - SignalGetRoomByGroupIDReq getRoomByGroupID = 7; - - SignalOnRoomParticipantConnectedReq onRoomParticipantConnectedReq = 8; - SignalOnRoomParticipantDisconnectedReq onRoomParticipantDisconnectedReq = 9; - SignalGetTokenByRoomIDReq getTokenByRoomID = 10; - } -} - -message SignalResp { - oneof payload { - SignalInviteReply invite = 1; - SignalInviteInGroupReply inviteInGroup = 2; - SignalCancelReply cancel = 3; - SignalAcceptReply accept = 4; - SignalHungUpReply hungUp = 5; - SignalRejectReply reject = 6; - SignalGetRoomByGroupIDReply getRoomByGroupID = 7; - SignalGetTokenByRoomIDReply getTokenByRoomID = 8; - } -} - - -message InvitationInfo { - string inviterUserID = 1; - repeated string inviteeUserIDList = 2; - string customData = 3; - string groupID = 4; - string roomID = 5; - int32 timeout = 6; - string mediaType = 7; - int32 platformID = 8; - int32 sessionType = 9; - int32 initiateTime = 10; - repeated string busyLineUserIDList = 11; -} - -message ParticipantMetaData{ - GroupInfo groupInfo = 1; - GroupMemberFullInfo groupMemberInfo = 2; - PublicUserInfo userInfo = 3; -} - -message SignalInviteReq { - string opUserID = 1; - InvitationInfo invitation = 2; - OfflinePushInfo offlinePushInfo = 3; - ParticipantMetaData participant = 4; - -} - -message SignalInviteReply { - string token = 1; - string roomID = 2; - string liveURL = 3; - repeated string busyLineUserIDList = 4; -} - -message SignalInviteInGroupReq { - string opUserID = 1; - InvitationInfo invitation = 2; - OfflinePushInfo offlinePushInfo = 3; - ParticipantMetaData participant = 4; -} - -message SignalInviteInGroupReply { - string token = 1; - string roomID = 2; - string liveURL = 3; - repeated string busyLineUserIDList = 4; -} - -message SignalCancelReq { - string opUserID = 1; - InvitationInfo invitation = 2; - OfflinePushInfo offlinePushInfo = 3; - ParticipantMetaData participant = 4; -} - -message SignalCancelReply { - -} - -message SignalAcceptReq { - string opUserID = 1; - InvitationInfo invitation = 2; - OfflinePushInfo offlinePushInfo = 3; - ParticipantMetaData participant = 4; - int32 opUserPlatformID = 5; -} - -message SignalAcceptReply { - string token = 1; - string roomID = 2; - string liveURL = 3; -} - -message SignalHungUpReq { - string opUserID = 1; - InvitationInfo invitation = 2; - OfflinePushInfo offlinePushInfo = 3; -} - -message SignalHungUpReply { - -} - - -message SignalRejectReq { - string opUserID = 1; - InvitationInfo invitation = 2; - OfflinePushInfo offlinePushInfo = 3; - ParticipantMetaData participant = 4; - int32 opUserPlatformID = 5; -} - -message SignalRejectReply { - -} - -message SignalGetRoomByGroupIDReq { - string opUserID = 1; - string groupID = 2; - ParticipantMetaData participant = 3; -} - -message SignalGetRoomByGroupIDReply { - InvitationInfo invitation = 1; - repeated ParticipantMetaData participant = 2; - string roomID = 3; -} - -message SignalOnRoomParticipantConnectedReq { - InvitationInfo invitation = 1; - repeated ParticipantMetaData participant = 2; - string groupID = 3; -} - -message SignalOnRoomParticipantDisconnectedReq { - InvitationInfo invitation = 1; - repeated ParticipantMetaData participant = 2; - string groupID = 3; -} - -message SignalGetTokenByRoomIDReq { - string roomID = 1; - string opUserID = 2; - ParticipantMetaData participant = 3; - string operationID = 4; -} - -message SignalGetTokenByRoomIDReply { - string token = 1; - string liveURL = 2; -} - - -message DelMsgListReq{ - string opUserID = 1; - string userID = 2; - repeated uint32 seqList = 3; - string operationID = 4; -} - -message DelMsgListResp{ - int32 errCode = 1; - string errMsg = 2; -} - -message SetAppBackgroundStatusReq { - string userID = 1; - bool isBackground = 2; -} - -message SetAppBackgroundStatusResp { - int32 errCode = 1; - string errMsg = 2; -} - -message ExtendMsgSet { - string sourceID = 1; - int32 sessionType = 2; - map extendMsgs = 3; - int64 MaxMsgUpdateTime = 4; - int32 extendMsgNum = 5; - int64 createTime = 6; -} - -message ExtendMsg { - map reactionExtensionList = 1; - string clientMsgID = 2; - int64 msgFirstModifyTime = 3; - string attachedInfo = 4; - string ex = 5; -} - -message KeyValue { - string typeKey = 1; - string value = 2; - int64 latestUpdateTime = 3; -} - - - diff --git a/tools/data-conversion/utils/find_insert.go b/tools/data-conversion/utils/find_insert.go deleted file mode 100644 index 150820fce..000000000 --- a/tools/data-conversion/utils/find_insert.go +++ /dev/null @@ -1,119 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package utils - -import ( - "fmt" - "log" - "sync" - "sync/atomic" - - "gorm.io/gorm" - "gorm.io/gorm/schema" -) - -func FindAndInsert[V2 any, V3 schema.Tabler](v2db *gorm.DB, v3db *gorm.DB, fn func(V2) (V3, bool)) (string, error) { - const batchSize = 100 - var t V3 - name := t.TableName() - if err := v3db.AutoMigrate(&t); err != nil { - return name, fmt.Errorf("auto migrate v3 %s failed %w", name, err) - } - for i := 0; ; i++ { - var v2s []V2 - if err := v2db.Offset(i * batchSize).Limit(batchSize).Find(&v2s).Error; err != nil { - return name, fmt.Errorf("find v2 %s failed %w", name, err) - } - if len(v2s) == 0 { - return name, nil - } - v3s := make([]V3, 0, len(v2s)) - for _, v := range v2s { - res, ok := fn(v) - if ok { - v3s = append(v3s, res) - } - } - if len(v3s) == 0 { - continue - } - if err := v3db.Create(&v3s).Error; err != nil { - return name, fmt.Errorf("insert v3 %s failed %w", name, err) - } - } -} - -type TakeList []Task - -func (l *TakeList) Append(fn ...Task) { - *l = append(*l, fn...) -} - -type Task func() (string, error) - -func RunTask(concurrency int, tasks TakeList) []string { - if len(tasks) == 0 { - return []string{} - } - if concurrency < 1 { - concurrency = 1 - } - if concurrency > len(tasks) { - concurrency = len(tasks) - } - - taskCh := make(chan func() (string, error), 4) - go func() { - defer close(taskCh) - for i := range tasks { - taskCh <- tasks[i] - } - }() - - var lock sync.Mutex - var failedTables []string - - var wg sync.WaitGroup - wg.Add(concurrency) - var count int64 - - for i := 0; i < concurrency; i++ { - go func() { - defer wg.Done() - for task := range taskCh { - name, err := task() - index := atomic.AddInt64(&count, 1) - if err == nil { - log.Printf("[%d/%d] %s success\n", index, len(tasks), name) - } else { - lock.Lock() - failedTables = append(failedTables, name) - lock.Unlock() - log.Printf("[%d/%d] %s failed %s\n", index, len(tasks), name, err) - return - } - } - }() - } - - wg.Wait() - if len(failedTables) == 0 { - log.Println("all tables success") - } else { - log.Printf("failed tables %d: %+v\n", len(failedTables), failedTables) - } - - return failedTables -} diff --git a/tools/up35/README.md b/tools/up35/README.md deleted file mode 100644 index c5bdcd3b6..000000000 --- a/tools/up35/README.md +++ /dev/null @@ -1,67 +0,0 @@ -# README for OpenIM Server Data Conversion Tool - -## Overview - -This tool is part of the OpenIM Server suite, specifically designed for data conversion between MySQL and MongoDB databases. It handles the migration of various data types, including user information, friendships, group memberships, and more from a MySQL database to MongoDB, ensuring data consistency and integrity during the transition. - -## Features - -+ **Configurable Database Connections:** Supports connections to both MySQL and MongoDB, configurable through a YAML file. -+ **Data Conversion Tasks:** Converts a range of data models, including user profiles, friend requests, group memberships, and logs. -+ **Version Control:** Maintains data versioning, ensuring only necessary migrations are performed. -+ **Error Handling:** Robust error handling for database connectivity and query execution. - -## Requirements - -+ Go programming environment -+ MySQL and MongoDB servers -+ OpenIM Server dependencies installed - -## Installation - -1. Ensure Go is installed and set up on your system. -2. Clone the OpenIM Server repository. -3. Navigate to the directory containing this tool. -4. Install required dependencies. - -## Configuration - -+ Configuration is managed through a YAML file specified at runtime. -+ Set up the MySQL and MongoDB connection parameters in the config file. - -## Usage - -To run the tool, use the following command from the terminal: - -```go -make build BINS="up35" -``` - -Where `path/to/config.yaml` is the path to your configuration file. - -## Functionality - -The main functions of the script include: - -+ `InitConfig(path string)`: Reads and parses the YAML configuration file. -+ `GetMysql()`: Establishes a connection to the MySQL database. -+ `GetMongo()`: Establishes a connection to the MongoDB database. -+ `Main(path string)`: Orchestrates the data migration process. -+ `SetMongoDataVersion(db *mongo.Database, curver string)`: Updates the data version in MongoDB after migration. -+ `NewTask(...)`: Generic function to handle the migration of different data types. -+ `insertMany(coll *mongo.Collection, objs []any)`: Inserts multiple records into a MongoDB collection. -+ `getColl(obj any)`: Retrieves the MongoDB collection associated with a given object. -+ `convert struct`: Contains methods for converting MySQL models to MongoDB models. - -## Notes - -+ Ensure that the MySQL and MongoDB instances are accessible and that the credentials provided in the config file are correct. -+ It is advisable to backup databases before running the migration to prevent data loss. - -## Contributing - -Contributions to improve the tool or address issues are welcome. Please follow the project's contribution guidelines. - -## License - -Refer to the project's license document for usage and distribution rights. \ No newline at end of file diff --git a/tools/up35/go.mod b/tools/up35/go.mod deleted file mode 100644 index 23163a4dc..000000000 --- a/tools/up35/go.mod +++ /dev/null @@ -1,3 +0,0 @@ -module github.com/openimsdk/open-im-server/v3/tools/up35 - -go 1.19 diff --git a/tools/up35/go.sum b/tools/up35/go.sum deleted file mode 100644 index 1a81e5b33..000000000 --- a/tools/up35/go.sum +++ /dev/null @@ -1,125 +0,0 @@ -github.com/OpenIMSDK/protocol v0.0.31 h1:ax43x9aqA6EKNXNukS5MT5BSTqkUmwO4uTvbJLtzCgE= -github.com/OpenIMSDK/protocol v0.0.31/go.mod h1:F25dFrwrIx3lkNoiuf6FkCfxuwf8L4Z8UIsdTHP/r0Y= -github.com/OpenIMSDK/tools v0.0.18 h1:h3CvKB90DNd2aIJcOQ99cqgeW6C0na0PzR1TNsfxwL0= -github.com/OpenIMSDK/tools v0.0.18/go.mod h1:eg+q4A34Qmu73xkY0mt37FHGMCMfC6CtmOnm0kFEGFI= -github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8= -github.com/bwmarrin/snowflake v0.3.0 h1:xm67bEhkKh6ij1790JB83OujPR5CzNe8QuQqAgISZN0= -github.com/bwmarrin/snowflake v0.3.0/go.mod h1:NdZxfVWX+oR6y2K0o6qAYv6gIOP9rjG0/E9WsDpxqwE= -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI= -github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI= -github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI= -github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= -github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= -github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= -github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM= -github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= -github.com/jinzhu/copier v0.4.0 h1:w3ciUoD19shMCRargcpm0cm91ytaBhDvuRpz1ODO/U8= -github.com/jinzhu/copier v0.4.0/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg= -github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= -github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= -github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= -github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= -github.com/jonboulle/clockwork v0.4.0 h1:p4Cf1aMWXnXAUh8lVfewRBx1zaTSYKrKMF2g3ST4RZ4= -github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk= -github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I= -github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= -github.com/lestrrat-go/envload v0.0.0-20180220234015-a3eb8ddeffcc h1:RKf14vYWi2ttpEmkA4aQ3j4u9dStX2t4M8UM6qqNsG8= -github.com/lestrrat-go/envload v0.0.0-20180220234015-a3eb8ddeffcc/go.mod h1:kopuH9ugFRkIXf3YoqHKyrJ9YfUFsckUU9S7B+XP+is= -github.com/lestrrat-go/file-rotatelogs v2.4.0+incompatible h1:Y6sqxHMyB1D2YSzWkLibYKgg+SwmyFU9dF2hn6MdTj4= -github.com/lestrrat-go/file-rotatelogs v2.4.0+incompatible/go.mod h1:ZQnN8lSECaebrkQytbHj4xNgtg8CR7RYXnPok8e0EHA= -github.com/lestrrat-go/strftime v1.0.6 h1:CFGsDEt1pOpFNU+TJB0nhz9jl+K0hZSLE205AhTIGQQ= -github.com/lestrrat-go/strftime v1.0.6/go.mod h1:f7jQKgV5nnJpYgdEasS+/y7EsTb8ykN2z68n3TtcTaw= -github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe h1:iruDEfMl2E6fbMZ9s0scYfZQ84/6SPL6zC8ACM2oIL0= -github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc= -github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ= -github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8= -github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= -github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= -github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c= -github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI= -github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY= -github.com/xdg-go/scram v1.1.2/go.mod h1:RT/sEzTbU5y00aCK8UOx6R7YryM0iF1N2MOmC3kKLN4= -github.com/xdg-go/stringprep v1.0.4 h1:XLI/Ng3O1Atzq0oBs3TWm+5ZVgkq2aqdlvP9JtoZ6c8= -github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM= -github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d h1:splanxYIlg+5LfHAM6xpdFEAYOk8iySO56hMFq6uLyA= -github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA= -github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= -go.mongodb.org/mongo-driver v1.12.1 h1:nLkghSU8fQNaK7oUmDhQFsnrtcoNy7Z6LVFKsEecqgE= -go.mongodb.org/mongo-driver v1.12.1/go.mod h1:/rGBTebI3XYboVmgz+Wv3Bcbl3aD0QF9zl6kDDw18rQ= -go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw= -go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -go.uber.org/goleak v1.1.11 h1:wy28qYRKZgnJTxGxvye5/wgWr1EKjmUDGYox5mGlRlI= -go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4= -go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= -go.uber.org/zap v1.24.0 h1:FiJd5l1UOLj0wCgbSE0rwwXHzEdAZS6hiiSnxJN/D60= -go.uber.org/zap v1.24.0/go.mod h1:2kMP+WWQ8aoFoedH3T2sq6iJ2yDWpHbP0f6MQbS9Gkg= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.14.0 h1:wBqGXzWJW6m1XrIKlAH0Hs1JJ7+9KBwnIO8v66Q9cHc= -golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4= -golang.org/x/image v0.13.0 h1:3cge/F/QTkNLauhf2QoE9zp+7sr+ZcL4HnoZmdwg9sg= -golang.org/x/image v0.13.0/go.mod h1:6mmbMOeV28HuMTgA6OSRkdXKYw/t5W9Uwn2Yv1r3Yxk= -golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM= -golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ= -golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.14.0 h1:Vz7Qs629MkJkGyHxUlRHizWJRG2j8fbQKjELVSNhy7Q= -golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= -golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k= -golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -google.golang.org/genproto/googleapis/rpc v0.0.0-20231012201019-e917dd12ba7a h1:a2MQQVoTo96JC9PMGtGBymLp7+/RzpFc2yX/9WfFg1c= -google.golang.org/genproto/googleapis/rpc v0.0.0-20231012201019-e917dd12ba7a/go.mod h1:4cYg8o5yUbm77w8ZX00LhMVNl/YVBFJRYWDc0uYWMs0= -google.golang.org/grpc v1.59.0 h1:Z5Iec2pjwb+LEOqzpB2MR12/eKFhDPhuqW91O+4bwUk= -google.golang.org/grpc v1.59.0/go.mod h1:aUPDwccQo6OTjy7Hct4AfBPD1GptF4fyUjIkQ9YtF98= -google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= -google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8= -google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gorm.io/driver/mysql v1.5.1 h1:WUEH5VF9obL/lTtzjmML/5e6VfFR/788coz2uaVCAZw= -gorm.io/driver/mysql v1.5.1/go.mod h1:Jo3Xu7mMhCyj8dlrb3WoCaRd1FhsVh+yMXb1jUInf5o= -gorm.io/gorm v1.25.1/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k= -gorm.io/gorm v1.25.4 h1:iyNd8fNAe8W9dvtlgeRI5zSVZPsq3OpcTu37cYcpCmw= -gorm.io/gorm v1.25.4/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k= diff --git a/tools/up35/pkg/convert.go b/tools/up35/pkg/convert.go deleted file mode 100644 index 53ada0e04..000000000 --- a/tools/up35/pkg/convert.go +++ /dev/null @@ -1,242 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package pkg - -import ( - "time" - - mongomodel "github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation" - mysqlmodel "github.com/openimsdk/open-im-server/v3/tools/data-conversion/openim/mysql/v3" - mongomodelrtc "github.com/openimsdk/open-im-server/v3/tools/up35/pkg/internal/rtc/mongo/table" - mysqlmodelrtc "github.com/openimsdk/open-im-server/v3/tools/up35/pkg/internal/rtc/mysql" -) - -type convert struct{} - -func (convert) User(v mysqlmodel.UserModel) mongomodel.UserModel { - return mongomodel.UserModel{ - UserID: v.UserID, - Nickname: v.Nickname, - FaceURL: v.FaceURL, - Ex: v.Ex, - AppMangerLevel: v.AppMangerLevel, - GlobalRecvMsgOpt: v.GlobalRecvMsgOpt, - CreateTime: v.CreateTime, - } -} - -func (convert) Friend(v mysqlmodel.FriendModel) mongomodel.FriendModel { - return mongomodel.FriendModel{ - OwnerUserID: v.OwnerUserID, - FriendUserID: v.FriendUserID, - Remark: v.Remark, - CreateTime: v.CreateTime, - AddSource: v.AddSource, - OperatorUserID: v.OperatorUserID, - Ex: v.Ex, - } -} - -func (convert) FriendRequest(v mysqlmodel.FriendRequestModel) mongomodel.FriendRequestModel { - return mongomodel.FriendRequestModel{ - FromUserID: v.FromUserID, - ToUserID: v.ToUserID, - HandleResult: v.HandleResult, - ReqMsg: v.ReqMsg, - CreateTime: v.CreateTime, - HandlerUserID: v.HandlerUserID, - HandleMsg: v.HandleMsg, - HandleTime: v.HandleTime, - Ex: v.Ex, - } -} - -func (convert) Black(v mysqlmodel.BlackModel) mongomodel.BlackModel { - return mongomodel.BlackModel{ - OwnerUserID: v.OwnerUserID, - BlockUserID: v.BlockUserID, - CreateTime: v.CreateTime, - AddSource: v.AddSource, - OperatorUserID: v.OperatorUserID, - Ex: v.Ex, - } -} - -func (convert) Group(v mysqlmodel.GroupModel) mongomodel.GroupModel { - return mongomodel.GroupModel{ - GroupID: v.GroupID, - GroupName: v.GroupName, - Notification: v.Notification, - Introduction: v.Introduction, - FaceURL: v.FaceURL, - CreateTime: v.CreateTime, - Ex: v.Ex, - Status: v.Status, - CreatorUserID: v.CreatorUserID, - GroupType: v.GroupType, - NeedVerification: v.NeedVerification, - LookMemberInfo: v.LookMemberInfo, - ApplyMemberFriend: v.ApplyMemberFriend, - NotificationUpdateTime: v.NotificationUpdateTime, - NotificationUserID: v.NotificationUserID, - } -} - -func (convert) GroupMember(v mysqlmodel.GroupMemberModel) mongomodel.GroupMemberModel { - return mongomodel.GroupMemberModel{ - GroupID: v.GroupID, - UserID: v.UserID, - Nickname: v.Nickname, - FaceURL: v.FaceURL, - RoleLevel: v.RoleLevel, - JoinTime: v.JoinTime, - JoinSource: v.JoinSource, - InviterUserID: v.InviterUserID, - OperatorUserID: v.OperatorUserID, - MuteEndTime: v.MuteEndTime, - Ex: v.Ex, - } -} - -func (convert) GroupRequest(v mysqlmodel.GroupRequestModel) mongomodel.GroupRequestModel { - return mongomodel.GroupRequestModel{ - UserID: v.UserID, - GroupID: v.GroupID, - HandleResult: v.HandleResult, - ReqMsg: v.ReqMsg, - HandledMsg: v.HandledMsg, - ReqTime: v.ReqTime, - HandleUserID: v.HandleUserID, - HandledTime: v.HandledTime, - JoinSource: v.JoinSource, - InviterUserID: v.InviterUserID, - Ex: v.Ex, - } -} - -func (convert) Conversation(v mysqlmodel.ConversationModel) mongomodel.ConversationModel { - return mongomodel.ConversationModel{ - OwnerUserID: v.OwnerUserID, - ConversationID: v.ConversationID, - ConversationType: v.ConversationType, - UserID: v.UserID, - GroupID: v.GroupID, - RecvMsgOpt: v.RecvMsgOpt, - IsPinned: v.IsPinned, - IsPrivateChat: v.IsPrivateChat, - BurnDuration: v.BurnDuration, - GroupAtType: v.GroupAtType, - AttachedInfo: v.AttachedInfo, - Ex: v.Ex, - MaxSeq: v.MaxSeq, - MinSeq: v.MinSeq, - CreateTime: v.CreateTime, - IsMsgDestruct: v.IsMsgDestruct, - MsgDestructTime: v.MsgDestructTime, - LatestMsgDestructTime: v.LatestMsgDestructTime, - } -} - -func (convert) Object(engine string) func(v mysqlmodel.ObjectModel) mongomodel.ObjectModel { - return func(v mysqlmodel.ObjectModel) mongomodel.ObjectModel { - return mongomodel.ObjectModel{ - Name: v.Name, - UserID: v.UserID, - Hash: v.Hash, - Engine: engine, - Key: v.Key, - Size: v.Size, - ContentType: v.ContentType, - Group: v.Cause, - CreateTime: v.CreateTime, - } - } -} - -func (convert) Log(v mysqlmodel.Log) mongomodel.LogModel { - return mongomodel.LogModel{ - LogID: v.LogID, - Platform: v.Platform, - UserID: v.UserID, - CreateTime: v.CreateTime, - Url: v.Url, - FileName: v.FileName, - SystemType: v.SystemType, - Version: v.Version, - Ex: v.Ex, - } -} - -func (convert) SignalModel(v mysqlmodelrtc.SignalModel) mongomodelrtc.SignalModel { - return mongomodelrtc.SignalModel{ - SID: v.SID, - InviterUserID: v.InviterUserID, - CustomData: v.CustomData, - GroupID: v.GroupID, - RoomID: v.RoomID, - Timeout: v.Timeout, - MediaType: v.MediaType, - PlatformID: v.PlatformID, - SessionType: v.SessionType, - InitiateTime: v.InitiateTime, - EndTime: v.EndTime, - FileURL: v.FileURL, - Title: v.Title, - Desc: v.Desc, - Ex: v.Ex, - IOSPushSound: v.IOSPushSound, - IOSBadgeCount: v.IOSBadgeCount, - SignalInfo: v.SignalInfo, - } -} - -func (convert) SignalInvitationModel(v mysqlmodelrtc.SignalInvitationModel) mongomodelrtc.SignalInvitationModel { - return mongomodelrtc.SignalInvitationModel{ - SID: v.SID, - UserID: v.UserID, - Status: v.Status, - InitiateTime: v.InitiateTime, - HandleTime: v.HandleTime, - } -} - -func (convert) Meeting(v mysqlmodelrtc.MeetingInfo) mongomodelrtc.MeetingInfo { - return mongomodelrtc.MeetingInfo{ - RoomID: v.RoomID, - MeetingName: v.MeetingName, - HostUserID: v.HostUserID, - Status: v.Status, - StartTime: time.Unix(v.StartTime, 0), - EndTime: time.Unix(v.EndTime, 0), - CreateTime: v.CreateTime, - Ex: v.Ex, - } -} - -func (convert) MeetingInvitationInfo(v mysqlmodelrtc.MeetingInvitationInfo) mongomodelrtc.MeetingInvitationInfo { - return mongomodelrtc.MeetingInvitationInfo{ - RoomID: v.RoomID, - UserID: v.UserID, - CreateTime: v.CreateTime, - } -} - -func (convert) MeetingVideoRecord(v mysqlmodelrtc.MeetingVideoRecord) mongomodelrtc.MeetingVideoRecord { - return mongomodelrtc.MeetingVideoRecord{ - RoomID: v.RoomID, - FileURL: v.FileURL, - CreateTime: v.CreateTime, - } -} diff --git a/tools/up35/pkg/internal/rtc/mongo/mgo/meeting.go b/tools/up35/pkg/internal/rtc/mongo/mgo/meeting.go deleted file mode 100644 index fd0f2818b..000000000 --- a/tools/up35/pkg/internal/rtc/mongo/mgo/meeting.go +++ /dev/null @@ -1,102 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package mgo - -import ( - "context" - "time" - - "github.com/OpenIMSDK/tools/mgoutil" - "github.com/OpenIMSDK/tools/pagination" - "go.mongodb.org/mongo-driver/bson" - "go.mongodb.org/mongo-driver/mongo" - "go.mongodb.org/mongo-driver/mongo/options" - - "github.com/openimsdk/open-im-server/v3/tools/up35/pkg/internal/rtc/mongo/table" -) - -func NewMeeting(db *mongo.Database) (table.MeetingInterface, error) { - coll := db.Collection("meeting") - _, err := coll.Indexes().CreateMany(context.Background(), []mongo.IndexModel{ - { - Keys: bson.D{ - {Key: "room_id", Value: 1}, - }, - Options: options.Index().SetUnique(true), - }, - { - Keys: bson.D{ - {Key: "host_user_id", Value: 1}, - }, - }, - { - Keys: bson.D{ - {Key: "create_time", Value: -1}, - }, - }, - }) - if err != nil { - return nil, err - } - return &meeting{coll: coll}, nil -} - -type meeting struct { - coll *mongo.Collection -} - -func (x *meeting) Find(ctx context.Context, roomIDs []string) ([]*table.MeetingInfo, error) { - return mgoutil.Find[*table.MeetingInfo](ctx, x.coll, bson.M{"room_id": bson.M{"$in": roomIDs}}) -} - -func (x *meeting) CreateMeetingInfo(ctx context.Context, meetingInfo *table.MeetingInfo) error { - return mgoutil.InsertMany(ctx, x.coll, []*table.MeetingInfo{meetingInfo}) -} - -func (x *meeting) UpdateMeetingInfo(ctx context.Context, roomID string, update map[string]any) error { - if len(update) == 0 { - return nil - } - return mgoutil.UpdateOne(ctx, x.coll, bson.M{"room_id": roomID}, bson.M{"$set": update}, false) -} - -func (x *meeting) GetUnCompleteMeetingIDList(ctx context.Context, roomIDs []string) ([]string, error) { - if len(roomIDs) == 0 { - return nil, nil - } - return mgoutil.Find[string](ctx, x.coll, bson.M{"room_id": bson.M{"$in": roomIDs}, "status": 0}, options.Find().SetProjection(bson.M{"_id": 0, "room_id": 1})) -} - -func (x *meeting) Delete(ctx context.Context, roomIDs []string) error { - return mgoutil.DeleteMany(ctx, x.coll, bson.M{"room_id": bson.M{"$in": roomIDs}}) -} - -func (x *meeting) GetMeetingRecords(ctx context.Context, hostUserID string, startTime, endTime time.Time, pagination pagination.Pagination) (int64, []*table.MeetingInfo, error) { - var and []bson.M - if hostUserID != "" { - and = append(and, bson.M{"host_user_id": hostUserID}) - } - if !startTime.IsZero() { - and = append(and, bson.M{"create_time": bson.M{"$gte": startTime}}) - } - if !endTime.IsZero() { - and = append(and, bson.M{"create_time": bson.M{"$lte": endTime}}) - } - filter := bson.M{} - if len(and) > 0 { - filter["$and"] = and - } - return mgoutil.FindPage[*table.MeetingInfo](ctx, x.coll, filter, pagination, options.Find().SetSort(bson.M{"create_time": -1})) -} diff --git a/tools/up35/pkg/internal/rtc/mongo/mgo/meeting_invitation.go b/tools/up35/pkg/internal/rtc/mongo/mgo/meeting_invitation.go deleted file mode 100644 index 9926748bf..000000000 --- a/tools/up35/pkg/internal/rtc/mongo/mgo/meeting_invitation.go +++ /dev/null @@ -1,97 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package mgo - -import ( - "context" - "time" - - "github.com/OpenIMSDK/tools/mgoutil" - "github.com/OpenIMSDK/tools/pagination" - "github.com/OpenIMSDK/tools/utils" - "go.mongodb.org/mongo-driver/bson" - "go.mongodb.org/mongo-driver/mongo" - "go.mongodb.org/mongo-driver/mongo/options" - - "github.com/openimsdk/open-im-server/v3/tools/up35/pkg/internal/rtc/mongo/table" -) - -func NewMeetingInvitation(db *mongo.Database) (table.MeetingInvitationInterface, error) { - coll := db.Collection("meeting_invitation") - _, err := coll.Indexes().CreateMany(context.Background(), []mongo.IndexModel{ - { - Keys: bson.D{ - {Key: "room_id", Value: 1}, - {Key: "user_id", Value: 1}, - }, - Options: options.Index().SetUnique(true), - }, - { - Keys: bson.D{ - {Key: "create_time", Value: -1}, - }, - }, - }) - if err != nil { - return nil, err - } - return &meetingInvitation{coll: coll}, nil -} - -type meetingInvitation struct { - coll *mongo.Collection -} - -func (x *meetingInvitation) FindUserIDs(ctx context.Context, roomID string) ([]string, error) { - return mgoutil.Find[string](ctx, x.coll, bson.M{"room_id": roomID}, options.Find().SetProjection(bson.M{"_id": 0, "user_id": 1})) -} - -func (x *meetingInvitation) CreateMeetingInvitationInfo(ctx context.Context, roomID string, inviteeUserIDs []string) error { - now := time.Now() - return mgoutil.InsertMany(ctx, x.coll, utils.Slice(inviteeUserIDs, func(userID string) *table.MeetingInvitationInfo { - return &table.MeetingInvitationInfo{ - RoomID: roomID, - UserID: userID, - CreateTime: now, - } - })) -} - -func (x *meetingInvitation) GetUserInvitedMeetingIDs(ctx context.Context, userID string) (meetingIDs []string, err error) { - fiveDaysAgo := time.Now().AddDate(0, 0, -5) - return mgoutil.Find[string]( - ctx, - x.coll, - bson.M{"user_id": userID, "create_time": bson.M{"$gte": fiveDaysAgo}}, - options.Find().SetSort(bson.M{"create_time": -1}).SetProjection(bson.M{"_id": 0, "room_id": 1}), - ) -} - -func (x *meetingInvitation) Delete(ctx context.Context, roomIDs []string) error { - return mgoutil.DeleteMany(ctx, x.coll, bson.M{"room_id": bson.M{"$in": roomIDs}}) -} - -func (x *meetingInvitation) GetMeetingRecords(ctx context.Context, joinedUserID string, startTime, endTime time.Time, pagination pagination.Pagination) (int64, []string, error) { - var and []bson.M - and = append(and, bson.M{"user_id": joinedUserID}) - if !startTime.IsZero() { - and = append(and, bson.M{"create_time": bson.M{"$gte": startTime}}) - } - if !endTime.IsZero() { - and = append(and, bson.M{"create_time": bson.M{"$lte": endTime}}) - } - opt := options.Find().SetSort(bson.M{"create_time": -1}).SetProjection(bson.M{"_id": 0, "room_id": 1}) - return mgoutil.FindPage[string](ctx, x.coll, bson.M{"$and": and}, pagination, opt) -} diff --git a/tools/up35/pkg/internal/rtc/mongo/mgo/meeting_record.go b/tools/up35/pkg/internal/rtc/mongo/mgo/meeting_record.go deleted file mode 100644 index 4e9dc5e0f..000000000 --- a/tools/up35/pkg/internal/rtc/mongo/mgo/meeting_record.go +++ /dev/null @@ -1,48 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package mgo - -import ( - "context" - - "github.com/OpenIMSDK/tools/mgoutil" - "go.mongodb.org/mongo-driver/bson" - "go.mongodb.org/mongo-driver/mongo" - - "github.com/openimsdk/open-im-server/v3/tools/up35/pkg/internal/rtc/mongo/table" -) - -func NewMeetingRecord(db *mongo.Database) (table.MeetingRecordInterface, error) { - coll := db.Collection("meeting_record") - _, err := coll.Indexes().CreateMany(context.Background(), []mongo.IndexModel{ - { - Keys: bson.D{ - {Key: "room_id", Value: 1}, - }, - }, - }) - if err != nil { - return nil, err - } - return &meetingRecord{coll: coll}, nil -} - -type meetingRecord struct { - coll *mongo.Collection -} - -func (x *meetingRecord) CreateMeetingVideoRecord(ctx context.Context, meetingVideoRecord *table.MeetingVideoRecord) error { - return mgoutil.InsertMany(ctx, x.coll, []*table.MeetingVideoRecord{meetingVideoRecord}) -} diff --git a/tools/up35/pkg/internal/rtc/mongo/mgo/signal.go b/tools/up35/pkg/internal/rtc/mongo/mgo/signal.go deleted file mode 100644 index 47fd3fb02..000000000 --- a/tools/up35/pkg/internal/rtc/mongo/mgo/signal.go +++ /dev/null @@ -1,105 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package mgo - -import ( - "context" - "time" - - "github.com/OpenIMSDK/tools/mgoutil" - "github.com/OpenIMSDK/tools/pagination" - "go.mongodb.org/mongo-driver/bson" - "go.mongodb.org/mongo-driver/mongo" - "go.mongodb.org/mongo-driver/mongo/options" - - "github.com/openimsdk/open-im-server/v3/tools/up35/pkg/internal/rtc/mongo/table" -) - -func NewSignal(db *mongo.Database) (table.SignalInterface, error) { - coll := db.Collection("signal") - _, err := coll.Indexes().CreateMany(context.Background(), []mongo.IndexModel{ - { - Keys: bson.D{ - {Key: "sid", Value: 1}, - }, - Options: options.Index().SetUnique(true), - }, - { - Keys: bson.D{ - {Key: "inviter_user_id", Value: 1}, - }, - }, - { - Keys: bson.D{ - {Key: "initiate_time", Value: -1}, - }, - }, - }) - if err != nil { - return nil, err - } - return &signal{coll: coll}, nil -} - -type signal struct { - coll *mongo.Collection -} - -func (x *signal) Find(ctx context.Context, sids []string) ([]*table.SignalModel, error) { - return mgoutil.Find[*table.SignalModel](ctx, x.coll, bson.M{"sid": bson.M{"$in": sids}}) -} - -func (x *signal) CreateSignal(ctx context.Context, signalModel *table.SignalModel) error { - return mgoutil.InsertMany(ctx, x.coll, []*table.SignalModel{signalModel}) -} - -func (x *signal) Update(ctx context.Context, sid string, update map[string]any) error { - if len(update) == 0 { - return nil - } - return mgoutil.UpdateOne(ctx, x.coll, bson.M{"sid": sid}, bson.M{"$set": update}, false) -} - -func (x *signal) UpdateSignalFileURL(ctx context.Context, sID, fileURL string) error { - return x.Update(ctx, sID, map[string]any{"file_url": fileURL}) -} - -func (x *signal) UpdateSignalEndTime(ctx context.Context, sID string, endTime time.Time) error { - return x.Update(ctx, sID, map[string]any{"end_time": endTime}) -} - -func (x *signal) Delete(ctx context.Context, sids []string) error { - if len(sids) == 0 { - return nil - } - return mgoutil.DeleteMany(ctx, x.coll, bson.M{"sid": bson.M{"$in": sids}}) -} - -func (x *signal) PageSignal(ctx context.Context, sesstionType int32, sendID string, startTime, endTime time.Time, pagination pagination.Pagination) (int64, []*table.SignalModel, error) { - var and []bson.M - if !startTime.IsZero() { - and = append(and, bson.M{"initiate_time": bson.M{"$gte": startTime}}) - } - if !endTime.IsZero() { - and = append(and, bson.M{"initiate_time": bson.M{"$lte": endTime}}) - } - if sesstionType != 0 { - and = append(and, bson.M{"sesstion_type": sesstionType}) - } - if sendID != "" { - and = append(and, bson.M{"inviter_user_id": sendID}) - } - return mgoutil.FindPage[*table.SignalModel](ctx, x.coll, bson.M{"$and": and}, pagination, options.Find().SetSort(bson.M{"initiate_time": -1})) -} diff --git a/tools/up35/pkg/internal/rtc/mongo/mgo/signal_invitation.go b/tools/up35/pkg/internal/rtc/mongo/mgo/signal_invitation.go deleted file mode 100644 index 1f76381e9..000000000 --- a/tools/up35/pkg/internal/rtc/mongo/mgo/signal_invitation.go +++ /dev/null @@ -1,94 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package mgo - -import ( - "context" - "time" - - "github.com/OpenIMSDK/tools/mgoutil" - "github.com/OpenIMSDK/tools/pagination" - "github.com/OpenIMSDK/tools/utils" - "go.mongodb.org/mongo-driver/bson" - "go.mongodb.org/mongo-driver/mongo" - "go.mongodb.org/mongo-driver/mongo/options" - - "github.com/openimsdk/open-im-server/v3/tools/up35/pkg/internal/rtc/mongo/table" -) - -func NewSignalInvitation(db *mongo.Database) (table.SignalInvitationInterface, error) { - coll := db.Collection("signal_invitation") - _, err := coll.Indexes().CreateMany(context.Background(), []mongo.IndexModel{ - { - Keys: bson.D{ - {Key: "sid", Value: 1}, - {Key: "user_id", Value: 1}, - }, - Options: options.Index().SetUnique(true), - }, - { - Keys: bson.D{ - {Key: "initiate_time", Value: -1}, - }, - }, - }) - if err != nil { - return nil, err - } - return &signalInvitation{coll: coll}, nil -} - -type signalInvitation struct { - coll *mongo.Collection -} - -func (x *signalInvitation) Find(ctx context.Context, sid string) ([]*table.SignalInvitationModel, error) { - return mgoutil.Find[*table.SignalInvitationModel](ctx, x.coll, bson.M{"sid": sid}) -} - -func (x *signalInvitation) CreateSignalInvitation(ctx context.Context, sid string, inviteeUserIDs []string) error { - now := time.Now() - return mgoutil.InsertMany(ctx, x.coll, utils.Slice(inviteeUserIDs, func(userID string) *table.SignalInvitationModel { - return &table.SignalInvitationModel{ - UserID: userID, - SID: sid, - InitiateTime: now, - HandleTime: time.Unix(0, 0), - } - })) -} - -func (x *signalInvitation) HandleSignalInvitation(ctx context.Context, sID, InviteeUserID string, status int32) error { - return mgoutil.UpdateOne(ctx, x.coll, bson.M{"sid": sID, "user_id": InviteeUserID}, bson.M{"$set": bson.M{"status": status, "handle_time": time.Now()}}, true) -} - -func (x *signalInvitation) PageSID(ctx context.Context, recvID string, startTime, endTime time.Time, pagination pagination.Pagination) (int64, []string, error) { - var and []bson.M - and = append(and, bson.M{"user_id": recvID}) - if !startTime.IsZero() { - and = append(and, bson.M{"initiate_time": bson.M{"$gte": startTime}}) - } - if !endTime.IsZero() { - and = append(and, bson.M{"initiate_time": bson.M{"$lte": endTime}}) - } - return mgoutil.FindPage[string](ctx, x.coll, bson.M{"$and": and}, pagination, options.Find().SetProjection(bson.M{"_id": 0, "sid": 1}).SetSort(bson.M{"initiate_time": -1})) -} - -func (x *signalInvitation) Delete(ctx context.Context, sids []string) error { - if len(sids) == 0 { - return nil - } - return mgoutil.DeleteMany(ctx, x.coll, bson.M{"sid": bson.M{"$in": sids}}) -} diff --git a/tools/up35/pkg/internal/rtc/mongo/table/meeting.go b/tools/up35/pkg/internal/rtc/mongo/table/meeting.go deleted file mode 100644 index 6ff387bbb..000000000 --- a/tools/up35/pkg/internal/rtc/mongo/table/meeting.go +++ /dev/null @@ -1,66 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package table - -import ( - "context" - "time" - - "github.com/OpenIMSDK/tools/pagination" -) - -type MeetingInfo struct { - RoomID string `bson:"room_id"` - MeetingName string `bson:"meeting_name"` - HostUserID string `bson:"host_user_id"` - Status int64 `bson:"status"` - StartTime time.Time `bson:"start_time"` - EndTime time.Time `bson:"end_time"` - CreateTime time.Time `bson:"create_time"` - Ex string `bson:"ex"` -} - -type MeetingInterface interface { - Find(ctx context.Context, roomIDs []string) ([]*MeetingInfo, error) - CreateMeetingInfo(ctx context.Context, meetingInfo *MeetingInfo) error - UpdateMeetingInfo(ctx context.Context, roomID string, update map[string]any) error - GetUnCompleteMeetingIDList(ctx context.Context, roomIDs []string) ([]string, error) - Delete(ctx context.Context, roomIDs []string) error - GetMeetingRecords(ctx context.Context, hostUserID string, startTime, endTime time.Time, pagination pagination.Pagination) (int64, []*MeetingInfo, error) -} - -type MeetingInvitationInfo struct { - RoomID string `bson:"room_id"` - UserID string `bson:"user_id"` - CreateTime time.Time `bson:"create_time"` -} - -type MeetingInvitationInterface interface { - FindUserIDs(ctx context.Context, roomID string) ([]string, error) - CreateMeetingInvitationInfo(ctx context.Context, roomID string, inviteeUserIDs []string) error - GetUserInvitedMeetingIDs(ctx context.Context, userID string) (meetingIDs []string, err error) - Delete(ctx context.Context, roomIDs []string) error - GetMeetingRecords(ctx context.Context, joinedUserID string, startTime, endTime time.Time, pagination pagination.Pagination) (int64, []string, error) -} - -type MeetingVideoRecord struct { - RoomID string `bson:"room_id"` - FileURL string `bson:"file_url"` - CreateTime time.Time `bson:"create_time"` -} - -type MeetingRecordInterface interface { - CreateMeetingVideoRecord(ctx context.Context, meetingVideoRecord *MeetingVideoRecord) error -} diff --git a/tools/up35/pkg/internal/rtc/mongo/table/signal.go b/tools/up35/pkg/internal/rtc/mongo/table/signal.go deleted file mode 100644 index 8d8aa96ed..000000000 --- a/tools/up35/pkg/internal/rtc/mongo/table/signal.go +++ /dev/null @@ -1,88 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package table - -import ( - "context" - "time" - - "github.com/OpenIMSDK/tools/errs" - "github.com/OpenIMSDK/tools/pagination" - "github.com/redis/go-redis/v9" - "go.mongodb.org/mongo-driver/mongo" -) - -type SignalModel struct { - SID string `bson:"sid"` - InviterUserID string `bson:"inviter_user_id"` - CustomData string `bson:"custom_data"` - GroupID string `bson:"group_id"` - RoomID string `bson:"room_id"` - Timeout int32 `bson:"timeout"` - MediaType string `bson:"media_type"` - PlatformID int32 `bson:"platform_id"` - SessionType int32 `bson:"session_type"` - InitiateTime time.Time `bson:"initiate_time"` - EndTime time.Time `bson:"end_time"` - FileURL string `bson:"file_url"` - - Title string `bson:"title"` - Desc string `bson:"desc"` - Ex string `bson:"ex"` - IOSPushSound string `bson:"ios_push_sound"` - IOSBadgeCount bool `bson:"ios_badge_count"` - SignalInfo string `bson:"signal_info"` -} - -type SignalInterface interface { - Find(ctx context.Context, sids []string) ([]*SignalModel, error) - CreateSignal(ctx context.Context, signalModel *SignalModel) error - Update(ctx context.Context, sid string, update map[string]any) error - UpdateSignalFileURL(ctx context.Context, sID, fileURL string) error - UpdateSignalEndTime(ctx context.Context, sID string, endTime time.Time) error - Delete(ctx context.Context, sids []string) error - PageSignal(ctx context.Context, sesstionType int32, sendID string, startTime, endTime time.Time, pagination pagination.Pagination) (int64, []*SignalModel, error) -} - -type SignalInvitationModel struct { - SID string `bson:"sid"` - UserID string `bson:"user_id"` - Status int32 `bson:"status"` - InitiateTime time.Time `bson:"initiate_time"` - HandleTime time.Time `bson:"handle_time"` -} - -type SignalInvitationInterface interface { - Find(ctx context.Context, sid string) ([]*SignalInvitationModel, error) - CreateSignalInvitation(ctx context.Context, sid string, inviteeUserIDs []string) error - HandleSignalInvitation(ctx context.Context, sID, InviteeUserID string, status int32) error - PageSID(ctx context.Context, recvID string, startTime, endTime time.Time, pagination pagination.Pagination) (int64, []string, error) - Delete(ctx context.Context, sids []string) error -} - -func IsNotFound(err error) bool { - if err == nil { - return false - } - err = errs.Unwrap(err) - return err == mongo.ErrNoDocuments || err == redis.Nil -} - -func IsDuplicate(err error) bool { - if err == nil { - return false - } - return mongo.IsDuplicateKeyError(errs.Unwrap(err)) -} diff --git a/tools/up35/pkg/internal/rtc/mysql/meeting.go b/tools/up35/pkg/internal/rtc/mysql/meeting.go deleted file mode 100644 index 71515c3b7..000000000 --- a/tools/up35/pkg/internal/rtc/mysql/meeting.go +++ /dev/null @@ -1,54 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package relation - -import ( - "time" -) - -type MeetingInfo struct { - RoomID string `gorm:"column:room_id;primary_key;size:128;index:room_id;index:status,priority:1"` - MeetingName string `gorm:"column:meeting_name;size:64"` - HostUserID string `gorm:"column:host_user_id;size:64;index:host_user_id"` - Status int64 `gorm:"column:status;index:status,priority:2"` - StartTime int64 `gorm:"column:start_time"` - EndTime int64 `gorm:"column:end_time"` - CreateTime time.Time `gorm:"column:create_time"` - Ex string `gorm:"column:ex;size:1024"` -} - -func (MeetingInfo) TableName() string { - return "meeting" -} - -type MeetingInvitationInfo struct { - RoomID string `gorm:"column:room_id;primary_key;size:128"` - UserID string `gorm:"column:user_id;primary_key;size:64;index:user_id"` - CreateTime time.Time `gorm:"column:create_time"` -} - -func (MeetingInvitationInfo) TableName() string { - return "meeting_invitation" -} - -type MeetingVideoRecord struct { - RoomID string `gorm:"column:room_id;size:128"` - FileURL string `gorm:"column:file_url"` - CreateTime time.Time `gorm:"column:create_time"` -} - -func (MeetingVideoRecord) TableName() string { - return "meeting_video_record" -} diff --git a/tools/up35/pkg/internal/rtc/mysql/signal.go b/tools/up35/pkg/internal/rtc/mysql/signal.go deleted file mode 100644 index c546360a4..000000000 --- a/tools/up35/pkg/internal/rtc/mysql/signal.go +++ /dev/null @@ -1,57 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package relation - -import ( - "time" -) - -type SignalModel struct { - SID string `gorm:"column:sid;type:char(128);primary_key"` - InviterUserID string `gorm:"column:inviter_user_id;type:char(64);index:inviter_user_id_index"` - CustomData string `gorm:"column:custom_data;type:text"` - GroupID string `gorm:"column:group_id;type:char(64)"` - RoomID string `gorm:"column:room_id;primary_key;type:char(128)"` - Timeout int32 `gorm:"column:timeout"` - MediaType string `gorm:"column:media_type;type:char(64)"` - PlatformID int32 `gorm:"column:platform_id"` - SessionType int32 `gorm:"column:sesstion_type"` - InitiateTime time.Time `gorm:"column:initiate_time"` - EndTime time.Time `gorm:"column:end_time"` - FileURL string `gorm:"column:file_url" json:"-"` - - Title string `gorm:"column:title;size:128"` - Desc string `gorm:"column:desc;size:1024"` - Ex string `gorm:"column:ex;size:1024"` - IOSPushSound string `gorm:"column:ios_push_sound"` - IOSBadgeCount bool `gorm:"column:ios_badge_count"` - SignalInfo string `gorm:"column:signal_info;size:1024"` -} - -func (SignalModel) TableName() string { - return "signal" -} - -type SignalInvitationModel struct { - UserID string `gorm:"column:user_id;primary_key"` - SID string `gorm:"column:sid;type:char(128);primary_key"` - Status int32 `gorm:"column:status"` - InitiateTime time.Time `gorm:"column:initiate_time;primary_key"` - HandleTime time.Time `gorm:"column:handle_time"` -} - -func (SignalInvitationModel) TableName() string { - return "signal_invitation" -} diff --git a/tools/up35/pkg/pkg.go b/tools/up35/pkg/pkg.go deleted file mode 100644 index 54aef1ce9..000000000 --- a/tools/up35/pkg/pkg.go +++ /dev/null @@ -1,230 +0,0 @@ -// Copyright © 2023 OpenIM. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package pkg - -import ( - "context" - "errors" - "fmt" - "log" - "os" - "reflect" - "strconv" - - "github.com/OpenIMSDK/tools/errs" - - "gopkg.in/yaml.v3" - - "github.com/go-sql-driver/mysql" - "go.mongodb.org/mongo-driver/bson" - "go.mongodb.org/mongo-driver/mongo" - "go.mongodb.org/mongo-driver/mongo/options" - gormmysql "gorm.io/driver/mysql" - "gorm.io/gorm" - "gorm.io/gorm/logger" - - "github.com/openimsdk/open-im-server/v3/pkg/common/config" - "github.com/openimsdk/open-im-server/v3/pkg/common/db/mgo" - "github.com/openimsdk/open-im-server/v3/pkg/common/db/unrelation" - rtcmgo "github.com/openimsdk/open-im-server/v3/tools/up35/pkg/internal/rtc/mongo/mgo" -) - -const ( - versionTable = "dataver" - versionKey = "data_version" - versionValue = 35 -) - -func InitConfig(path string) (*config.GlobalConfig, error) { - data, err := os.ReadFile(path) - if err != nil { - return nil, errs.Wrap(err, "ReadFile unmarshal failed") - } - - conf := config.NewGlobalConfig() - err = yaml.Unmarshal(data, &conf) - if err != nil { - return nil, errs.Wrap(err, "InitConfig unmarshal failed") - } - return conf, nil -} - -func GetMysql(config *config.GlobalConfig) (*gorm.DB, error) { - conf := config.Mysql - mysqlDSN := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", conf.Username, conf.Password, conf.Address[0], conf.Database) - return gorm.Open(gormmysql.Open(mysqlDSN), &gorm.Config{Logger: logger.Discard}) -} - -func GetMongo(config *config.GlobalConfig) (*mongo.Database, error) { - mgo, err := unrelation.NewMongo(config) - if err != nil { - return nil, err - } - return mgo.GetDatabase(config.Mongo.Database), nil -} - -func Main(path string) error { - conf, err := InitConfig(path) - if err != nil { - return err - } - if conf.Mysql == nil { - return nil - } - mongoDB, err := GetMongo(conf) - if err != nil { - return err - } - var version struct { - Key string `bson:"key"` - Value string `bson:"value"` - } - switch mongoDB.Collection(versionTable).FindOne(context.Background(), bson.M{"key": versionKey}).Decode(&version) { - case nil: - if ver, _ := strconv.Atoi(version.Value); ver >= versionValue { - return nil - } - case mongo.ErrNoDocuments: - default: - return err - } - mysqlDB, err := GetMysql(conf) - if err != nil { - if mysqlErr, ok := err.(*mysql.MySQLError); ok && mysqlErr.Number == 1049 { - if err := SetMongoDataVersion(mongoDB, version.Value); err != nil { - return err - } - return nil // database not exist - } - return err - } - - var c convert - var tasks []func() error - tasks = append(tasks, - func() error { return NewTask(mysqlDB, mongoDB, mgo.NewUserMongo, c.User) }, - func() error { return NewTask(mysqlDB, mongoDB, mgo.NewFriendMongo, c.Friend) }, - func() error { return NewTask(mysqlDB, mongoDB, mgo.NewFriendRequestMongo, c.FriendRequest) }, - func() error { return NewTask(mysqlDB, mongoDB, mgo.NewBlackMongo, c.Black) }, - func() error { return NewTask(mysqlDB, mongoDB, mgo.NewGroupMongo, c.Group) }, - func() error { return NewTask(mysqlDB, mongoDB, mgo.NewGroupMember, c.GroupMember) }, - func() error { return NewTask(mysqlDB, mongoDB, mgo.NewGroupRequestMgo, c.GroupRequest) }, - func() error { return NewTask(mysqlDB, mongoDB, mgo.NewConversationMongo, c.Conversation) }, - func() error { return NewTask(mysqlDB, mongoDB, mgo.NewS3Mongo, c.Object(conf.Object.Enable)) }, - func() error { return NewTask(mysqlDB, mongoDB, mgo.NewLogMongo, c.Log) }, - - func() error { return NewTask(mysqlDB, mongoDB, rtcmgo.NewSignal, c.SignalModel) }, - func() error { return NewTask(mysqlDB, mongoDB, rtcmgo.NewSignalInvitation, c.SignalInvitationModel) }, - func() error { return NewTask(mysqlDB, mongoDB, rtcmgo.NewMeeting, c.Meeting) }, - func() error { return NewTask(mysqlDB, mongoDB, rtcmgo.NewMeetingInvitation, c.MeetingInvitationInfo) }, - func() error { return NewTask(mysqlDB, mongoDB, rtcmgo.NewMeetingRecord, c.MeetingVideoRecord) }, - ) - - for _, task := range tasks { - if err := task(); err != nil { - return err - } - } - - if err := SetMongoDataVersion(mongoDB, version.Value); err != nil { - return err - } - return nil -} - -func SetMongoDataVersion(db *mongo.Database, curver string) error { - filter := bson.M{"key": versionKey, "value": curver} - update := bson.M{"$set": bson.M{"key": versionKey, "value": strconv.Itoa(versionValue)}} - _, err := db.Collection(versionTable).UpdateOne(context.Background(), filter, update, options.Update().SetUpsert(true)) - return err -} - -// NewTask A mysql table B mongodb model C mongodb table -func NewTask[A interface{ TableName() string }, B any, C any](gormDB *gorm.DB, mongoDB *mongo.Database, mongoDBInit func(db *mongo.Database) (B, error), convert func(v A) C) error { - obj, err := mongoDBInit(mongoDB) - if err != nil { - return err - } - var zero A - tableName := zero.TableName() - coll, err := getColl(obj) - if err != nil { - return errs.Wrap(fmt.Errorf("get mongo collection %s failed, err: %w", tableName, err)) - } - var count int - defer func() { - log.Printf("completed convert %s total %d\n", tableName, count) - }() - const batch = 100 - for page := 0; ; page++ { - res := make([]A, 0, batch) - if err := gormDB.Limit(batch).Offset(page * batch).Find(&res).Error; err != nil { - if mysqlErr, ok := err.(*mysql.MySQLError); ok && mysqlErr.Number == 1146 { - return nil // table not exist - } - return errs.Wrap(fmt.Errorf("find mysql table %s failed, err: %w", tableName, err)) - } - if len(res) == 0 { - return nil - } - temp := make([]any, len(res)) - for i := range res { - temp[i] = convert(res[i]) - } - if err := insertMany(coll, temp); err != nil { - return errs.Wrap(fmt.Errorf("insert mongo table %s failed, err: %w", tableName, err)) - } - count += len(res) - if len(res) < batch { - return nil - } - log.Printf("current convert %s completed %d\n", tableName, count) - } -} - -func insertMany(coll *mongo.Collection, objs []any) error { - if _, err := coll.InsertMany(context.Background(), objs); err != nil { - if !mongo.IsDuplicateKeyError(err) { - return errs.Wrap(err) - } - } - for i := range objs { - _, err := coll.InsertOne(context.Background(), objs[i]) - switch { - case err == nil: - case mongo.IsDuplicateKeyError(err): - default: - return err - } - } - return nil -} - -func getColl(obj any) (_ *mongo.Collection, err error) { - defer func() { - if e := recover(); e != nil { - err = fmt.Errorf("not found %+v", e) - } - }() - stu := reflect.ValueOf(obj).Elem() - typ := reflect.TypeOf(&mongo.Collection{}).String() - for i := 0; i < stu.NumField(); i++ { - field := stu.Field(i) - if field.Type().String() == typ { - return (*mongo.Collection)(field.UnsafePointer()), nil - } - } - return nil, errors.New("not found") -}