zhengchen.tao/ezbookkeeping
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

code refactor

Browse Source
This commit is contained in:
MaysWind
2025-07-06 15:50:53 +08:00
parent a54275d307
commit 82b98eca95
9 changed files with 239 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/api/model_context_protocols.go
+24 -2
View File
@@ -102,8 +102,25 @@ func (a *ModelContextProtocolAPI) ReadResourceHandler(c *core.WebContext, jsonRP
// ListToolsHandler returns the list of tools for model context protocol
func (a *ModelContextProtocolAPI) ListToolsHandler(c *core.WebContext, jsonRPCRequest *core.JSONRPCRequest) (any, *errs.Error) {
mcpVersion := a.getMCPVersion(c)
toolsInfo := mcp.Container.GetMCPTools()
finalToolsInfos := make([]*mcp.MCPTool, len(toolsInfo))
for i := 0; i < len(toolsInfo); i++ {
finalToolsInfos[i] = &mcp.MCPTool{
Name: toolsInfo[i].Name,
InputSchema: toolsInfo[i].InputSchema,
Title: toolsInfo[i].Title,
Description: toolsInfo[i].Description,
}
if mcpVersion >= string(mcp.ToolResultStructuredContentMinVersion) {
finalToolsInfos[i].OutputSchema = toolsInfo[i].OutputSchema
}
}
listToolsResp := mcp.MCPListToolsResponse{
Tools: mcp.AllMCPToolInfos,
Tools: finalToolsInfos,
}
return listToolsResp, nil
@@ -121,7 +138,7 @@ func (a *ModelContextProtocolAPI) CallToolHandler(c *core.WebContext, jsonRPCReq
return nil, errs.ErrIncompleteOrIncorrectSubmission
}
result, err := mcp.MCPToolHandle(c, &callToolReq, a.CurrentConfig(), a)
result, err := mcp.Container.HandleTool(c, &callToolReq, a.CurrentConfig(), a)
if err != nil {
return nil, err
@@ -159,3 +176,8 @@ func (a *ModelContextProtocolAPI) GetAccountService() *services.AccountService {
func (a *ModelContextProtocolAPI) GetUserService() *services.UserService {
return a.users
}
// getMCPVersion returns the MCP protocol version from the request header
func (a *ModelContextProtocolAPI) getMCPVersion(c *core.WebContext) string {
return c.GetHeader(mcp.MCPProtocolVersionHeaderName)
}
pkg/mcp/all_handlers.go
-12
View File
@@ -1,12 +0,0 @@
package mcp
var mcpTextContentTools = map[string]MCPToolHandler[MCPTextContent]{
"query_latest_exchange_rates": MCPQueryLatestExchangeRatesRequestToolHandler,
}
var mcpImageContentTools = map[string]MCPToolHandler[MCPImageContent]{}
var mcpAudioContentTools = map[string]MCPToolHandler[MCPAudioContent]{}
var mcpResourceLinkTools = map[string]MCPToolHandler[MCPResourceLink]{}
var mcpEmbeddedResourceTools = map[string]MCPToolHandler[MCPEmbeddedResource]{}
var AllMCPToolInfos = GetAllMCPToolInfos()
pkg/mcp/handler.go
+4 -154
View File
@@ -3,7 +3,6 @@ package mcp
import (
"reflect"
"github.com/invopop/jsonschema"
"github.com/mayswind/ezbookkeeping/pkg/core"
"github.com/mayswind/ezbookkeeping/pkg/errs"
"github.com/mayswind/ezbookkeeping/pkg/services"
@@ -21,6 +20,9 @@ type MCPAvailableServices interface {
// MCPToolHandler defines the MCP tool handler
type MCPToolHandler[T MCPTextContent | MCPImageContent | MCPAudioContent | MCPResourceLink | MCPEmbeddedResource] interface {
// Name returns the name of the MCP tool
Name() string
// Description returns the description of the MCP tool
Description() string
@@ -31,157 +33,5 @@ type MCPToolHandler[T MCPTextContent | MCPImageContent | MCPAudioContent | MCPRe
OutputType() reflect.Type
// Handle processes the MCP call tool request and returns the response
Handle(*core.WebContext, *MCPCallToolRequest, *settings.Config, MCPAvailableServices) ([]*T, *errs.Error)
}
// GetAllMCPToolInfos returns all available MCP tool information
func GetAllMCPToolInfos() []*MCPTool {
toolInfos := make([]*MCPTool, 0)
for name, handler := range mcpTextContentTools {
toolInfos = append(toolInfos, getMCPToolInfo(name, handler))
}
for name, handler := range mcpImageContentTools {
toolInfos = append(toolInfos, getMCPToolInfo(name, handler))
}
for name, handler := range mcpAudioContentTools {
toolInfos = append(toolInfos, getMCPToolInfo(name, handler))
}
for name, handler := range mcpResourceLinkTools {
toolInfos = append(toolInfos, getMCPToolInfo(name, handler))
}
for name, handler := range mcpEmbeddedResourceTools {
toolInfos = append(toolInfos, getMCPToolInfo(name, handler))
}
return toolInfos
}
// MCPToolHandle handles the MCP tool request based on the tool name
func MCPToolHandle(c *core.WebContext, callToolReq *MCPCallToolRequest, currentConfig *settings.Config, services MCPAvailableServices) (any, *errs.Error) {
if handler, exists := mcpTextContentTools[callToolReq.Name]; exists {
return mcpTextContentToolHandle(c, handler, currentConfig, services, callToolReq)
}
if handler, exists := mcpImageContentTools[callToolReq.Name]; exists {
return mcpImageContentToolHandle(c, handler, currentConfig, services, callToolReq)
}
if handler, exists := mcpAudioContentTools[callToolReq.Name]; exists {
return mcpAudioContentToolHandle(c, handler, currentConfig, services, callToolReq)
}
if handler, exists := mcpResourceLinkTools[callToolReq.Name]; exists {
return mcpResourceLinkToolHandle(c, handler, currentConfig, services, callToolReq)
}
if handler, exists := mcpEmbeddedResourceTools[callToolReq.Name]; exists {
return mcpEmbeddedResourceToolHandle(c, handler, currentConfig, services, callToolReq)
}
return nil, errs.ErrApiNotFound
}
func mcpTextContentToolHandle(c *core.WebContext, handler MCPToolHandler[MCPTextContent], currentConfig *settings.Config, services MCPAvailableServices, callToolReq *MCPCallToolRequest) (any, *errs.Error) {
result, err := handler.Handle(c, callToolReq, currentConfig, services)
if err != nil {
return nil, errs.Or(err, errs.ErrOperationFailed)
}
callToolResp := MCPCallToolResponse[MCPTextContent]{
Content: result,
IsError: false,
}
return callToolResp, nil
}
func mcpImageContentToolHandle(c *core.WebContext, handler MCPToolHandler[MCPImageContent], currentConfig *settings.Config, services MCPAvailableServices, callToolReq *MCPCallToolRequest) (any, *errs.Error) {
result, err := handler.Handle(c, callToolReq, currentConfig, services)
if err != nil {
return nil, errs.Or(err, errs.ErrOperationFailed)
}
callToolResp := MCPCallToolResponse[MCPImageContent]{
Content: result,
IsError: false,
}
return callToolResp, nil
}
func mcpAudioContentToolHandle(c *core.WebContext, handler MCPToolHandler[MCPAudioContent], currentConfig *settings.Config, services MCPAvailableServices, callToolReq *MCPCallToolRequest) (any, *errs.Error) {
result, err := handler.Handle(c, callToolReq, currentConfig, services)
if err != nil {
return nil, errs.Or(err, errs.ErrOperationFailed)
}
callToolResp := MCPCallToolResponse[MCPAudioContent]{
Content: result,
IsError: false,
}
return callToolResp, nil
}
func mcpResourceLinkToolHandle(c *core.WebContext, handler MCPToolHandler[MCPResourceLink], currentConfig *settings.Config, services MCPAvailableServices, callToolReq *MCPCallToolRequest) (any, *errs.Error) {
result, err := handler.Handle(c, callToolReq, currentConfig, services)
if err != nil {
return nil, errs.Or(err, errs.ErrOperationFailed)
}
callToolResp := MCPCallToolResponse[MCPResourceLink]{
Content: result,
IsError: false,
}
return callToolResp, nil
}
func mcpEmbeddedResourceToolHandle(c *core.WebContext, handler MCPToolHandler[MCPEmbeddedResource], currentConfig *settings.Config, services MCPAvailableServices, callToolReq *MCPCallToolRequest) (any, *errs.Error) {
result, err := handler.Handle(c, callToolReq, currentConfig, services)
if err != nil {
return nil, errs.Or(err, errs.ErrOperationFailed)
}
callToolResp := MCPCallToolResponse[MCPEmbeddedResource]{
Content: result,
IsError: false,
}
return callToolResp, nil
}
func getMCPToolInfo[T MCPTextContent | MCPImageContent | MCPAudioContent | MCPResourceLink | MCPEmbeddedResource](name string, handler MCPToolHandler[T]) *MCPTool {
mcpTool := &MCPTool{
Name: name,
Description: handler.Description(),
}
schemeGenerator := jsonschema.Reflector{
Anonymous: true,
DoNotReference: true,
ExpandedStruct: true,
}
if handler.InputType() != nil {
schema := schemeGenerator.ReflectFromType(handler.InputType())
mcpTool.InputSchema = schema
}
if handler.OutputType() != nil {
schema := schemeGenerator.ReflectFromType(handler.OutputType())
mcpTool.OutputSchema = schema
}
return mcpTool
Handle(*core.WebContext, *MCPCallToolRequest, *settings.Config, MCPAvailableServices) (any, []*T, *errs.Error)
}
pkg/mcp/mcp_container.go
+159
View File
@@ -0,0 +1,159 @@
package mcp
import (
"github.com/invopop/jsonschema"
orderedmap "github.com/wk8/go-ordered-map/v2"
"github.com/mayswind/ezbookkeeping/pkg/core"
"github.com/mayswind/ezbookkeeping/pkg/errs"
"github.com/mayswind/ezbookkeeping/pkg/settings"
)
// MCPContainer contains the all mcp handlers
type MCPContainer struct {
mcpTextContentTools *orderedmap.OrderedMap[string, MCPToolHandler[MCPTextContent]]
mcpImageContentTools *orderedmap.OrderedMap[string, MCPToolHandler[MCPImageContent]]
mcpAudioContentTools *orderedmap.OrderedMap[string, MCPToolHandler[MCPAudioContent]]
mcpResourceLinkTools *orderedmap.OrderedMap[string, MCPToolHandler[MCPResourceLink]]
mcpEmbeddedResourceTools *orderedmap.OrderedMap[string, MCPToolHandler[MCPEmbeddedResource]]
mcpTools []*MCPTool
}
// Initialize a mcp handler container singleton instance
var (
Container = &MCPContainer{}
)
// GetMCPTools returns the registered MCP tools
func (c *MCPContainer) GetMCPTools() []*MCPTool {
if len(c.mcpTools) == 0 {
return nil
}
return c.mcpTools
}
// HandleTool returns the result of the MCP tool handler based on the tool name
func (c *MCPContainer) HandleTool(ctx *core.WebContext, callToolReq *MCPCallToolRequest, currentConfig *settings.Config, services MCPAvailableServices) (any, *errs.Error) {
if handler, exists := c.mcpTextContentTools.Get(callToolReq.Name); exists {
return handleTool(ctx, handler, currentConfig, services, callToolReq)
}
if handler, exists := c.mcpImageContentTools.Get(callToolReq.Name); exists {
return handleTool(ctx, handler, currentConfig, services, callToolReq)
}
if handler, exists := c.mcpAudioContentTools.Get(callToolReq.Name); exists {
return handleTool(ctx, handler, currentConfig, services, callToolReq)
}
if handler, exists := c.mcpResourceLinkTools.Get(callToolReq.Name); exists {
return handleTool(ctx, handler, currentConfig, services, callToolReq)
}
if handler, exists := c.mcpEmbeddedResourceTools.Get(callToolReq.Name); exists {
return handleTool(ctx, handler, currentConfig, services, callToolReq)
}
return nil, errs.ErrApiNotFound
}
// InitializeMCPHandlers initializes the all mcp handlers according to the config
func InitializeMCPHandlers(config *settings.Config) error {
container := &MCPContainer{
mcpTextContentTools: orderedmap.New[string, MCPToolHandler[MCPTextContent]](),
mcpImageContentTools: orderedmap.New[string, MCPToolHandler[MCPImageContent]](),
mcpAudioContentTools: orderedmap.New[string, MCPToolHandler[MCPAudioContent]](),
mcpResourceLinkTools: orderedmap.New[string, MCPToolHandler[MCPResourceLink]](),
mcpEmbeddedResourceTools: orderedmap.New[string, MCPToolHandler[MCPEmbeddedResource]](),
mcpTools: make([]*MCPTool, 0),
}
registerMCPTextContentToolHandler(container, MCPQueryLatestExchangeRatesToolHandler)
Container = container
return nil
}
func registerMCPTextContentToolHandler(c *MCPContainer, handler MCPToolHandler[MCPTextContent]) {
registerMCPToolHandler(c, c.mcpTextContentTools, handler)
}
func registerMCPImageContentToolHandler(c *MCPContainer, handler MCPToolHandler[MCPImageContent]) {
registerMCPToolHandler(c, c.mcpImageContentTools, handler)
}
func registerMCPAudioContentToolHandler(c *MCPContainer, handler MCPToolHandler[MCPAudioContent]) {
registerMCPToolHandler(c, c.mcpAudioContentTools, handler)
}
func registerMCPResourceLinkToolHandler(c *MCPContainer, handler MCPToolHandler[MCPResourceLink]) {
registerMCPToolHandler(c, c.mcpResourceLinkTools, handler)
}
func registerMCPEmbeddedResourceToolHandler(c *MCPContainer, handler MCPToolHandler[MCPEmbeddedResource]) {
registerMCPToolHandler(c, c.mcpEmbeddedResourceTools, handler)
}
func registerMCPToolHandler[T MCPTextContent | MCPImageContent | MCPAudioContent | MCPResourceLink | MCPEmbeddedResource](c *MCPContainer, mcpToolHandlerMap *orderedmap.OrderedMap[string, MCPToolHandler[T]], handler MCPToolHandler[T]) {
if _, exists := mcpToolHandlerMap.Get(handler.Name()); exists {
return
}
mcpToolHandlerMap.Set(handler.Name(), handler)
c.mcpTools = append(c.mcpTools, createNewMCPToolInfo(handler.Name(), handler))
}
func handleTool[T MCPTextContent | MCPImageContent | MCPAudioContent | MCPResourceLink | MCPEmbeddedResource](ctx *core.WebContext, handler MCPToolHandler[T], currentConfig *settings.Config, services MCPAvailableServices, callToolReq *MCPCallToolRequest) (any, *errs.Error) {
structuredResponse, result, err := handler.Handle(ctx, callToolReq, currentConfig, services)
if err != nil {
return nil, errs.Or(err, errs.ErrOperationFailed)
}
callToolResp := MCPCallToolResponse[T]{
Content: result,
IsError: false,
}
if ctx.GetHeader(MCPProtocolVersionHeaderName) > string(ToolResultStructuredContentMinVersion) {
callToolResp.StructuredContent = structuredResponse
}
return callToolResp, nil
}
func createNewMCPToolInfo[T MCPTextContent | MCPImageContent | MCPAudioContent | MCPResourceLink | MCPEmbeddedResource](name string, handler MCPToolHandler[T]) *MCPTool {
mcpTool := &MCPTool{
Name: name,
Description: handler.Description(),
}
schemeGenerator := jsonschema.Reflector{
Anonymous: true,
DoNotReference: true,
ExpandedStruct: true,
}
if handler.InputType() != nil {
schema := schemeGenerator.ReflectFromType(handler.InputType())
schema.Version = ""
mcpTool.InputSchema = schema
} else {
mcpTool.InputSchema = &jsonschema.Schema{
Type: "object",
}
}
if handler.OutputType() != nil {
schema := schemeGenerator.ReflectFromType(handler.OutputType())
schema.Version = ""
mcpTool.OutputSchema = schema
} else {
mcpTool.OutputSchema = &jsonschema.Schema{
Type: "object",
}
}
return mcpTool
}
pkg/mcp/model_context_protocol.go
+10 -3
View File
@@ -20,6 +20,12 @@ const (
// LatestSupportedMCPVersion defines the latest supported version of Model Context Protocol (MCP)
const LatestSupportedMCPVersion = MCPProtocolVersion20250618
// ToolResultStructuredContentMinVersion defines the minimum version of structured content supported in tool results
const ToolResultStructuredContentMinVersion = MCPProtocolVersion20250618
// MCPProtocolVersionHeaderName defines the HTTP header name for the MCP protocol version
const MCPProtocolVersionHeaderName = "MCP-Protocol-Version"
// SupportedMCPVersion defines a map of supported MCP versions
var SupportedMCPVersion = map[MCPProtocolVersion]bool{
MCPProtocolVersion20250618: true,
@@ -120,7 +126,7 @@ type MCPListToolsResponse struct {
type MCPTool struct {
Name string `json:"name"`
InputSchema *jsonschema.Schema `json:"inputSchema"`
OutputSchema *jsonschema.Schema `json:"outputSchema"`
OutputSchema *jsonschema.Schema `json:"outputSchema,omitempty"`
Title string `json:"title,omitempty"`
Description string `json:"description,omitempty"`
}
@@ -133,8 +139,9 @@ type MCPCallToolRequest struct {
// MCPCallToolResponse defines the response structure for calling a tool in the MCP
type MCPCallToolResponse[T MCPTextContent | MCPImageContent | MCPAudioContent | MCPResourceLink | MCPEmbeddedResource] struct {
Content []*T `json:"content"`
IsError bool `json:"isError,omitempty"`
Content []*T `json:"content"`
StructuredContent any `json:"structuredContent,omitempty"`
IsError bool `json:"isError,omitempty"`
}
// MCPTextContent defines the text content structure used in MCP
pkg/mcp/query_latest_exchange_rates.go
+13 -13
View File
@@ -29,7 +29,7 @@ type MCPQueryExchangeRatesResponse struct {
// MCPQueryExchangeRateInfo defines the structure of exchange rate information for a specific currency
type MCPQueryExchangeRateInfo struct {
Currency string `json:"currency" jsonschema_description:"Currency code (e.g. USD)"`
Rate string `json:"rate" jsonschema_description:"The amount of the base currency that can be exchanged for 1 of this currency"`
Rate string `json:"rate_to_base" jsonschema_description:"The amount of the base currency that can be obtained for 1 unit of this currency"`
}
type mcpQueryLatestExchangeRatesToolHandler struct{}
@@ -57,39 +57,39 @@ func (h *mcpQueryLatestExchangeRatesToolHandler) OutputType() reflect.Type {
}
// Handle processes the MCP call tool request and returns the response
func (h *mcpQueryLatestExchangeRatesToolHandler) Handle(c *core.WebContext, callToolReq *MCPCallToolRequest, currentConfig *settings.Config, services MCPAvailableServices) ([]*MCPTextContent, *errs.Error) {
func (h *mcpQueryLatestExchangeRatesToolHandler) Handle(c *core.WebContext, callToolReq *MCPCallToolRequest, currentConfig *settings.Config, services MCPAvailableServices) (any, []*MCPTextContent, *errs.Error) {
var exchangeRatesRequest MCPQueryExchangeRatesRequest
if callToolReq.Arguments != nil {
if err := json.Unmarshal(callToolReq.Arguments, &exchangeRatesRequest); err != nil {
return nil, errs.NewIncompleteOrIncorrectSubmissionError(err)
return nil, nil, errs.NewIncompleteOrIncorrectSubmissionError(err)
}
} else {
return nil, errs.ErrIncompleteOrIncorrectSubmission
return nil, nil, errs.ErrIncompleteOrIncorrectSubmission
}
dataSource := exchangerates.Container.Current
if dataSource == nil {
return nil, errs.ErrInvalidExchangeRatesDataSource
return nil, nil, errs.ErrInvalidExchangeRatesDataSource
}
exchangeRateResponse, err := dataSource.GetLatestExchangeRates(c, c.GetCurrentUid(), currentConfig)
if err != nil {
return nil, errs.Or(err, errs.ErrOperationFailed)
return nil, nil, errs.Or(err, errs.ErrOperationFailed)
}
response, err := h.createNewMCPQueryExchangeRatesResponse(exchangeRatesRequest.Currencies, exchangeRateResponse)
structuredResponse, response, err := h.createNewMCPQueryExchangeRatesResponse(exchangeRatesRequest.Currencies, exchangeRateResponse)
if err != nil {
return nil, errs.Or(err, errs.ErrOperationFailed)
return nil, nil, errs.Or(err, errs.ErrOperationFailed)
}
return response, nil
return structuredResponse, response, nil
}
func (h *mcpQueryLatestExchangeRatesToolHandler) createNewMCPQueryExchangeRatesResponse(currencies string, exchangeRatesResp *models.LatestExchangeRateResponse) ([]*MCPTextContent, error) {
func (h *mcpQueryLatestExchangeRatesToolHandler) createNewMCPQueryExchangeRatesResponse(currencies string, exchangeRatesResp *models.LatestExchangeRateResponse) (any, []*MCPTextContent, error) {
queryCurrencies := make(map[string]bool)
for _, currency := range strings.Split(currencies, ",") {
@@ -102,7 +102,7 @@ func (h *mcpQueryLatestExchangeRatesToolHandler) createNewMCPQueryExchangeRatesR
response := &MCPQueryExchangeRatesResponse{
BaseCurrency: exchangeRatesResp.BaseCurrency,
UpdateTime: utils.FormatUnixTimeToLongDateTimeWithTimezoneRFC3389Format(exchangeRatesResp.UpdateTime, time.UTC),
UpdateTime: utils.FormatUnixTimeToLongDateTimeWithTimezoneRFC3339Format(exchangeRatesResp.UpdateTime, time.UTC),
Rates: make([]*MCPQueryExchangeRateInfo, 0, len(exchangeRatesResp.ExchangeRates)),
}
@@ -120,10 +120,10 @@ func (h *mcpQueryLatestExchangeRatesToolHandler) createNewMCPQueryExchangeRatesR
content, err := json.Marshal(response)
if err != nil {
return nil, err
return nil, nil, err
}
return []*MCPTextContent{
return response, []*MCPTextContent{
NewMCPTextContent(string(content)),
}, nil
}
pkg/utils/datetimes.go
+9 -4
View File
@@ -13,7 +13,7 @@ const (
longDateTimeFormat = "2006-01-02 15:04:05"
longDateTimeWithTimezoneFormat = "2006-01-02 15:04:05Z07:00"
longDateTimeWithTimezoneFormat2 = "2006-01-02 15:04:05 Z0700"
longDateTimeWithTimezoneRFC3389Format = "2006-01-02T15:04:05Z07:00"
longDateTimeWithTimezoneRFC3339Format = "2006-01-02T15:04:05Z07:00"
longDateTimeWithoutSecondFormat = "2006-01-02 15:04"
shortDateTimeFormat = "2006-1-2 15:4:5"
yearMonthDateTimeFormat = "2006-01"
@@ -77,15 +77,15 @@ func FormatUnixTimeToLongDateTimeWithTimezone(unixTime int64, timezone *time.Loc
return t.Format(longDateTimeWithTimezoneFormat)
}
// FormatUnixTimeToLongDateTimeWithTimezoneRFC3389Format returns a textual representation of the unix time formatted by long date time with timezone RFC 3389 format
func FormatUnixTimeToLongDateTimeWithTimezoneRFC3389Format(unixTime int64, timezone *time.Location) string {
// FormatUnixTimeToLongDateTimeWithTimezoneRFC3339Format returns a textual representation of the unix time formatted by long date time with timezone RFC 3339 format
func FormatUnixTimeToLongDateTimeWithTimezoneRFC3339Format(unixTime int64, timezone *time.Location) string {
t := parseFromUnixTime(unixTime)
if timezone != nil {
t = t.In(timezone)
}
return t.Format(longDateTimeWithTimezoneRFC3389Format)
return t.Format(longDateTimeWithTimezoneRFC3339Format)
}
func FormatYearMonthDayToLongDateTime(year string, month string, day string) (string, error) {
@@ -229,6 +229,11 @@ func ParseFromLongDateTimeWithTimezone2(t string) (time.Time, error) {
return time.Parse(longDateTimeWithTimezoneFormat2, t)
}
// ParseFromLongDateTimeWithTimezoneRFC3339Format parses a formatted string in long date time RFC 3378 format
func ParseFromLongDateTimeWithTimezoneRFC3339Format(t string) (time.Time, error) {
return time.Parse(longDateTimeWithTimezoneRFC3339Format, t)
}
// ParseFromLongDateTimeWithoutSecond parses a formatted string in long date time format (no second)
func ParseFromLongDateTimeWithoutSecond(t string, utcOffset int16) (time.Time, error) {
timezone := time.FixedZone("Timezone", int(utcOffset)*60)
pkg/utils/datetimes_test.go
+12 -3
View File
@@ -46,17 +46,17 @@ func TestFormatUnixTimeToLongDateTimeWithTimezone(t *testing.T) {
assert.Equal(t, expectedValue, actualValue)
}
func TestFormatUnixTimeToLongDateTimeWithTimezoneRFC3389Format(t *testing.T) {
func TestFormatUnixTimeToLongDateTimeWithTimezoneRFC3339Format(t *testing.T) {
unixTime := int64(1617228083)
utcTimezone := time.FixedZone("Test Timezone", 0) // UTC
utc8Timezone := time.FixedZone("Test Timezone", 28800) // UTC+8
expectedValue := "2021-03-31T22:01:23Z"
actualValue := FormatUnixTimeToLongDateTimeWithTimezoneRFC3389Format(unixTime, utcTimezone)
actualValue := FormatUnixTimeToLongDateTimeWithTimezoneRFC3339Format(unixTime, utcTimezone)
assert.Equal(t, expectedValue, actualValue)
expectedValue = "2021-04-01T06:01:23+08:00"
actualValue = FormatUnixTimeToLongDateTimeWithTimezoneRFC3389Format(unixTime, utc8Timezone)
actualValue = FormatUnixTimeToLongDateTimeWithTimezoneRFC3339Format(unixTime, utc8Timezone)
assert.Equal(t, expectedValue, actualValue)
}
@@ -228,6 +228,15 @@ func TestParseFromLongDateTimeWithTimezone2(t *testing.T) {
assert.Equal(t, expectedValue, actualValue)
}
func TestParseFromLongDateTimeWithTimezoneRFC3339Format(t *testing.T) {
expectedValue := int64(1617238883)
actualTime, err := ParseFromLongDateTimeWithTimezoneRFC3339Format("2021-04-01T06:01:23+05:00")
assert.Equal(t, nil, err)
actualValue := actualTime.Unix()
assert.Equal(t, expectedValue, actualValue)
}
func TestParseFromLongDateTimeWithoutSecond(t *testing.T) {
expectedValue := int64(1691947440)
actualTime, err := ParseFromLongDateTimeWithoutSecond("2023-08-13 17:24", 0)