repo stringlengths 6 47 | file_url stringlengths 77 269 | file_path stringlengths 5 186 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-07 08:35:43 2026-01-07 08:55:24 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/mocks/eth.mock.go | mocks/eth.mock.go | // Code generated by counterfeiter. DO NOT EDIT.
package mocks
import (
"context"
"sync"
"github.com/RTradeLtd/grpc/pay"
"github.com/RTradeLtd/grpc/pay/request"
"github.com/RTradeLtd/grpc/pay/response"
"google.golang.org/grpc"
)
type FakeSignerClient struct {
GetSignedMessageStub func(context.Context, *request.SignRequest, ...grpc.CallOption) (*response.SignResponse, error)
getSignedMessageMutex sync.RWMutex
getSignedMessageArgsForCall []struct {
arg1 context.Context
arg2 *request.SignRequest
arg3 []grpc.CallOption
}
getSignedMessageReturns struct {
result1 *response.SignResponse
result2 error
}
getSignedMessageReturnsOnCall map[int]struct {
result1 *response.SignResponse
result2 error
}
invocations map[string][][]interface{}
invocationsMutex sync.RWMutex
}
func (fake *FakeSignerClient) GetSignedMessage(arg1 context.Context, arg2 *request.SignRequest, arg3 ...grpc.CallOption) (*response.SignResponse, error) {
fake.getSignedMessageMutex.Lock()
ret, specificReturn := fake.getSignedMessageReturnsOnCall[len(fake.getSignedMessageArgsForCall)]
fake.getSignedMessageArgsForCall = append(fake.getSignedMessageArgsForCall, struct {
arg1 context.Context
arg2 *request.SignRequest
arg3 []grpc.CallOption
}{arg1, arg2, arg3})
fake.recordInvocation("GetSignedMessage", []interface{}{arg1, arg2, arg3})
fake.getSignedMessageMutex.Unlock()
if fake.GetSignedMessageStub != nil {
return fake.GetSignedMessageStub(arg1, arg2, arg3...)
}
if specificReturn {
return ret.result1, ret.result2
}
fakeReturns := fake.getSignedMessageReturns
return fakeReturns.result1, fakeReturns.result2
}
func (fake *FakeSignerClient) GetSignedMessageCallCount() int {
fake.getSignedMessageMutex.RLock()
defer fake.getSignedMessageMutex.RUnlock()
return len(fake.getSignedMessageArgsForCall)
}
func (fake *FakeSignerClient) GetSignedMessageCalls(stub func(context.Context, *request.SignRequest, ...grpc.CallOption) (*response.SignResponse, error)) {
fake.getSignedMessageMutex.Lock()
defer fake.getSignedMessageMutex.Unlock()
fake.GetSignedMessageStub = stub
}
func (fake *FakeSignerClient) GetSignedMessageArgsForCall(i int) (context.Context, *request.SignRequest, []grpc.CallOption) {
fake.getSignedMessageMutex.RLock()
defer fake.getSignedMessageMutex.RUnlock()
argsForCall := fake.getSignedMessageArgsForCall[i]
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}
func (fake *FakeSignerClient) GetSignedMessageReturns(result1 *response.SignResponse, result2 error) {
fake.getSignedMessageMutex.Lock()
defer fake.getSignedMessageMutex.Unlock()
fake.GetSignedMessageStub = nil
fake.getSignedMessageReturns = struct {
result1 *response.SignResponse
result2 error
}{result1, result2}
}
func (fake *FakeSignerClient) GetSignedMessageReturnsOnCall(i int, result1 *response.SignResponse, result2 error) {
fake.getSignedMessageMutex.Lock()
defer fake.getSignedMessageMutex.Unlock()
fake.GetSignedMessageStub = nil
if fake.getSignedMessageReturnsOnCall == nil {
fake.getSignedMessageReturnsOnCall = make(map[int]struct {
result1 *response.SignResponse
result2 error
})
}
fake.getSignedMessageReturnsOnCall[i] = struct {
result1 *response.SignResponse
result2 error
}{result1, result2}
}
func (fake *FakeSignerClient) Invocations() map[string][][]interface{} {
fake.invocationsMutex.RLock()
defer fake.invocationsMutex.RUnlock()
fake.getSignedMessageMutex.RLock()
defer fake.getSignedMessageMutex.RUnlock()
copiedInvocations := map[string][][]interface{}{}
for key, value := range fake.invocations {
copiedInvocations[key] = value
}
return copiedInvocations
}
func (fake *FakeSignerClient) recordInvocation(key string, args []interface{}) {
fake.invocationsMutex.Lock()
defer fake.invocationsMutex.Unlock()
if fake.invocations == nil {
fake.invocations = map[string][][]interface{}{}
}
if fake.invocations[key] == nil {
fake.invocations[key] = [][]interface{}{}
}
fake.invocations[key] = append(fake.invocations[key], args)
}
var _ pay.SignerClient = new(FakeSignerClient)
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/mocks/orchestrator.mock.go | mocks/orchestrator.mock.go | // Code generated by counterfeiter. DO NOT EDIT.
package mocks
import (
"context"
"sync"
"github.com/RTradeLtd/grpc/nexus"
"google.golang.org/grpc"
)
type FakeServiceClient struct {
NetworkDiagnosticsStub func(context.Context, *nexus.NetworkRequest, ...grpc.CallOption) (*nexus.NetworkDiagnosticsResponse, error)
networkDiagnosticsMutex sync.RWMutex
networkDiagnosticsArgsForCall []struct {
arg1 context.Context
arg2 *nexus.NetworkRequest
arg3 []grpc.CallOption
}
networkDiagnosticsReturns struct {
result1 *nexus.NetworkDiagnosticsResponse
result2 error
}
networkDiagnosticsReturnsOnCall map[int]struct {
result1 *nexus.NetworkDiagnosticsResponse
result2 error
}
NetworkStatsStub func(context.Context, *nexus.NetworkRequest, ...grpc.CallOption) (*nexus.NetworkStatusReponse, error)
networkStatsMutex sync.RWMutex
networkStatsArgsForCall []struct {
arg1 context.Context
arg2 *nexus.NetworkRequest
arg3 []grpc.CallOption
}
networkStatsReturns struct {
result1 *nexus.NetworkStatusReponse
result2 error
}
networkStatsReturnsOnCall map[int]struct {
result1 *nexus.NetworkStatusReponse
result2 error
}
PingStub func(context.Context, *nexus.Empty, ...grpc.CallOption) (*nexus.Empty, error)
pingMutex sync.RWMutex
pingArgsForCall []struct {
arg1 context.Context
arg2 *nexus.Empty
arg3 []grpc.CallOption
}
pingReturns struct {
result1 *nexus.Empty
result2 error
}
pingReturnsOnCall map[int]struct {
result1 *nexus.Empty
result2 error
}
RemoveNetworkStub func(context.Context, *nexus.NetworkRequest, ...grpc.CallOption) (*nexus.Empty, error)
removeNetworkMutex sync.RWMutex
removeNetworkArgsForCall []struct {
arg1 context.Context
arg2 *nexus.NetworkRequest
arg3 []grpc.CallOption
}
removeNetworkReturns struct {
result1 *nexus.Empty
result2 error
}
removeNetworkReturnsOnCall map[int]struct {
result1 *nexus.Empty
result2 error
}
StartNetworkStub func(context.Context, *nexus.NetworkRequest, ...grpc.CallOption) (*nexus.StartNetworkResponse, error)
startNetworkMutex sync.RWMutex
startNetworkArgsForCall []struct {
arg1 context.Context
arg2 *nexus.NetworkRequest
arg3 []grpc.CallOption
}
startNetworkReturns struct {
result1 *nexus.StartNetworkResponse
result2 error
}
startNetworkReturnsOnCall map[int]struct {
result1 *nexus.StartNetworkResponse
result2 error
}
StopNetworkStub func(context.Context, *nexus.NetworkRequest, ...grpc.CallOption) (*nexus.Empty, error)
stopNetworkMutex sync.RWMutex
stopNetworkArgsForCall []struct {
arg1 context.Context
arg2 *nexus.NetworkRequest
arg3 []grpc.CallOption
}
stopNetworkReturns struct {
result1 *nexus.Empty
result2 error
}
stopNetworkReturnsOnCall map[int]struct {
result1 *nexus.Empty
result2 error
}
UpdateNetworkStub func(context.Context, *nexus.NetworkRequest, ...grpc.CallOption) (*nexus.Empty, error)
updateNetworkMutex sync.RWMutex
updateNetworkArgsForCall []struct {
arg1 context.Context
arg2 *nexus.NetworkRequest
arg3 []grpc.CallOption
}
updateNetworkReturns struct {
result1 *nexus.Empty
result2 error
}
updateNetworkReturnsOnCall map[int]struct {
result1 *nexus.Empty
result2 error
}
invocations map[string][][]interface{}
invocationsMutex sync.RWMutex
}
func (fake *FakeServiceClient) NetworkDiagnostics(arg1 context.Context, arg2 *nexus.NetworkRequest, arg3 ...grpc.CallOption) (*nexus.NetworkDiagnosticsResponse, error) {
fake.networkDiagnosticsMutex.Lock()
ret, specificReturn := fake.networkDiagnosticsReturnsOnCall[len(fake.networkDiagnosticsArgsForCall)]
fake.networkDiagnosticsArgsForCall = append(fake.networkDiagnosticsArgsForCall, struct {
arg1 context.Context
arg2 *nexus.NetworkRequest
arg3 []grpc.CallOption
}{arg1, arg2, arg3})
fake.recordInvocation("NetworkDiagnostics", []interface{}{arg1, arg2, arg3})
fake.networkDiagnosticsMutex.Unlock()
if fake.NetworkDiagnosticsStub != nil {
return fake.NetworkDiagnosticsStub(arg1, arg2, arg3...)
}
if specificReturn {
return ret.result1, ret.result2
}
fakeReturns := fake.networkDiagnosticsReturns
return fakeReturns.result1, fakeReturns.result2
}
func (fake *FakeServiceClient) NetworkDiagnosticsCallCount() int {
fake.networkDiagnosticsMutex.RLock()
defer fake.networkDiagnosticsMutex.RUnlock()
return len(fake.networkDiagnosticsArgsForCall)
}
func (fake *FakeServiceClient) NetworkDiagnosticsCalls(stub func(context.Context, *nexus.NetworkRequest, ...grpc.CallOption) (*nexus.NetworkDiagnosticsResponse, error)) {
fake.networkDiagnosticsMutex.Lock()
defer fake.networkDiagnosticsMutex.Unlock()
fake.NetworkDiagnosticsStub = stub
}
func (fake *FakeServiceClient) NetworkDiagnosticsArgsForCall(i int) (context.Context, *nexus.NetworkRequest, []grpc.CallOption) {
fake.networkDiagnosticsMutex.RLock()
defer fake.networkDiagnosticsMutex.RUnlock()
argsForCall := fake.networkDiagnosticsArgsForCall[i]
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}
func (fake *FakeServiceClient) NetworkDiagnosticsReturns(result1 *nexus.NetworkDiagnosticsResponse, result2 error) {
fake.networkDiagnosticsMutex.Lock()
defer fake.networkDiagnosticsMutex.Unlock()
fake.NetworkDiagnosticsStub = nil
fake.networkDiagnosticsReturns = struct {
result1 *nexus.NetworkDiagnosticsResponse
result2 error
}{result1, result2}
}
func (fake *FakeServiceClient) NetworkDiagnosticsReturnsOnCall(i int, result1 *nexus.NetworkDiagnosticsResponse, result2 error) {
fake.networkDiagnosticsMutex.Lock()
defer fake.networkDiagnosticsMutex.Unlock()
fake.NetworkDiagnosticsStub = nil
if fake.networkDiagnosticsReturnsOnCall == nil {
fake.networkDiagnosticsReturnsOnCall = make(map[int]struct {
result1 *nexus.NetworkDiagnosticsResponse
result2 error
})
}
fake.networkDiagnosticsReturnsOnCall[i] = struct {
result1 *nexus.NetworkDiagnosticsResponse
result2 error
}{result1, result2}
}
func (fake *FakeServiceClient) NetworkStats(arg1 context.Context, arg2 *nexus.NetworkRequest, arg3 ...grpc.CallOption) (*nexus.NetworkStatusReponse, error) {
fake.networkStatsMutex.Lock()
ret, specificReturn := fake.networkStatsReturnsOnCall[len(fake.networkStatsArgsForCall)]
fake.networkStatsArgsForCall = append(fake.networkStatsArgsForCall, struct {
arg1 context.Context
arg2 *nexus.NetworkRequest
arg3 []grpc.CallOption
}{arg1, arg2, arg3})
fake.recordInvocation("NetworkStats", []interface{}{arg1, arg2, arg3})
fake.networkStatsMutex.Unlock()
if fake.NetworkStatsStub != nil {
return fake.NetworkStatsStub(arg1, arg2, arg3...)
}
if specificReturn {
return ret.result1, ret.result2
}
fakeReturns := fake.networkStatsReturns
return fakeReturns.result1, fakeReturns.result2
}
func (fake *FakeServiceClient) NetworkStatsCallCount() int {
fake.networkStatsMutex.RLock()
defer fake.networkStatsMutex.RUnlock()
return len(fake.networkStatsArgsForCall)
}
func (fake *FakeServiceClient) NetworkStatsCalls(stub func(context.Context, *nexus.NetworkRequest, ...grpc.CallOption) (*nexus.NetworkStatusReponse, error)) {
fake.networkStatsMutex.Lock()
defer fake.networkStatsMutex.Unlock()
fake.NetworkStatsStub = stub
}
func (fake *FakeServiceClient) NetworkStatsArgsForCall(i int) (context.Context, *nexus.NetworkRequest, []grpc.CallOption) {
fake.networkStatsMutex.RLock()
defer fake.networkStatsMutex.RUnlock()
argsForCall := fake.networkStatsArgsForCall[i]
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}
func (fake *FakeServiceClient) NetworkStatsReturns(result1 *nexus.NetworkStatusReponse, result2 error) {
fake.networkStatsMutex.Lock()
defer fake.networkStatsMutex.Unlock()
fake.NetworkStatsStub = nil
fake.networkStatsReturns = struct {
result1 *nexus.NetworkStatusReponse
result2 error
}{result1, result2}
}
func (fake *FakeServiceClient) NetworkStatsReturnsOnCall(i int, result1 *nexus.NetworkStatusReponse, result2 error) {
fake.networkStatsMutex.Lock()
defer fake.networkStatsMutex.Unlock()
fake.NetworkStatsStub = nil
if fake.networkStatsReturnsOnCall == nil {
fake.networkStatsReturnsOnCall = make(map[int]struct {
result1 *nexus.NetworkStatusReponse
result2 error
})
}
fake.networkStatsReturnsOnCall[i] = struct {
result1 *nexus.NetworkStatusReponse
result2 error
}{result1, result2}
}
func (fake *FakeServiceClient) Ping(arg1 context.Context, arg2 *nexus.Empty, arg3 ...grpc.CallOption) (*nexus.Empty, error) {
fake.pingMutex.Lock()
ret, specificReturn := fake.pingReturnsOnCall[len(fake.pingArgsForCall)]
fake.pingArgsForCall = append(fake.pingArgsForCall, struct {
arg1 context.Context
arg2 *nexus.Empty
arg3 []grpc.CallOption
}{arg1, arg2, arg3})
fake.recordInvocation("Ping", []interface{}{arg1, arg2, arg3})
fake.pingMutex.Unlock()
if fake.PingStub != nil {
return fake.PingStub(arg1, arg2, arg3...)
}
if specificReturn {
return ret.result1, ret.result2
}
fakeReturns := fake.pingReturns
return fakeReturns.result1, fakeReturns.result2
}
func (fake *FakeServiceClient) PingCallCount() int {
fake.pingMutex.RLock()
defer fake.pingMutex.RUnlock()
return len(fake.pingArgsForCall)
}
func (fake *FakeServiceClient) PingCalls(stub func(context.Context, *nexus.Empty, ...grpc.CallOption) (*nexus.Empty, error)) {
fake.pingMutex.Lock()
defer fake.pingMutex.Unlock()
fake.PingStub = stub
}
func (fake *FakeServiceClient) PingArgsForCall(i int) (context.Context, *nexus.Empty, []grpc.CallOption) {
fake.pingMutex.RLock()
defer fake.pingMutex.RUnlock()
argsForCall := fake.pingArgsForCall[i]
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}
func (fake *FakeServiceClient) PingReturns(result1 *nexus.Empty, result2 error) {
fake.pingMutex.Lock()
defer fake.pingMutex.Unlock()
fake.PingStub = nil
fake.pingReturns = struct {
result1 *nexus.Empty
result2 error
}{result1, result2}
}
func (fake *FakeServiceClient) PingReturnsOnCall(i int, result1 *nexus.Empty, result2 error) {
fake.pingMutex.Lock()
defer fake.pingMutex.Unlock()
fake.PingStub = nil
if fake.pingReturnsOnCall == nil {
fake.pingReturnsOnCall = make(map[int]struct {
result1 *nexus.Empty
result2 error
})
}
fake.pingReturnsOnCall[i] = struct {
result1 *nexus.Empty
result2 error
}{result1, result2}
}
func (fake *FakeServiceClient) RemoveNetwork(arg1 context.Context, arg2 *nexus.NetworkRequest, arg3 ...grpc.CallOption) (*nexus.Empty, error) {
fake.removeNetworkMutex.Lock()
ret, specificReturn := fake.removeNetworkReturnsOnCall[len(fake.removeNetworkArgsForCall)]
fake.removeNetworkArgsForCall = append(fake.removeNetworkArgsForCall, struct {
arg1 context.Context
arg2 *nexus.NetworkRequest
arg3 []grpc.CallOption
}{arg1, arg2, arg3})
fake.recordInvocation("RemoveNetwork", []interface{}{arg1, arg2, arg3})
fake.removeNetworkMutex.Unlock()
if fake.RemoveNetworkStub != nil {
return fake.RemoveNetworkStub(arg1, arg2, arg3...)
}
if specificReturn {
return ret.result1, ret.result2
}
fakeReturns := fake.removeNetworkReturns
return fakeReturns.result1, fakeReturns.result2
}
func (fake *FakeServiceClient) RemoveNetworkCallCount() int {
fake.removeNetworkMutex.RLock()
defer fake.removeNetworkMutex.RUnlock()
return len(fake.removeNetworkArgsForCall)
}
func (fake *FakeServiceClient) RemoveNetworkCalls(stub func(context.Context, *nexus.NetworkRequest, ...grpc.CallOption) (*nexus.Empty, error)) {
fake.removeNetworkMutex.Lock()
defer fake.removeNetworkMutex.Unlock()
fake.RemoveNetworkStub = stub
}
func (fake *FakeServiceClient) RemoveNetworkArgsForCall(i int) (context.Context, *nexus.NetworkRequest, []grpc.CallOption) {
fake.removeNetworkMutex.RLock()
defer fake.removeNetworkMutex.RUnlock()
argsForCall := fake.removeNetworkArgsForCall[i]
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}
func (fake *FakeServiceClient) RemoveNetworkReturns(result1 *nexus.Empty, result2 error) {
fake.removeNetworkMutex.Lock()
defer fake.removeNetworkMutex.Unlock()
fake.RemoveNetworkStub = nil
fake.removeNetworkReturns = struct {
result1 *nexus.Empty
result2 error
}{result1, result2}
}
func (fake *FakeServiceClient) RemoveNetworkReturnsOnCall(i int, result1 *nexus.Empty, result2 error) {
fake.removeNetworkMutex.Lock()
defer fake.removeNetworkMutex.Unlock()
fake.RemoveNetworkStub = nil
if fake.removeNetworkReturnsOnCall == nil {
fake.removeNetworkReturnsOnCall = make(map[int]struct {
result1 *nexus.Empty
result2 error
})
}
fake.removeNetworkReturnsOnCall[i] = struct {
result1 *nexus.Empty
result2 error
}{result1, result2}
}
func (fake *FakeServiceClient) StartNetwork(arg1 context.Context, arg2 *nexus.NetworkRequest, arg3 ...grpc.CallOption) (*nexus.StartNetworkResponse, error) {
fake.startNetworkMutex.Lock()
ret, specificReturn := fake.startNetworkReturnsOnCall[len(fake.startNetworkArgsForCall)]
fake.startNetworkArgsForCall = append(fake.startNetworkArgsForCall, struct {
arg1 context.Context
arg2 *nexus.NetworkRequest
arg3 []grpc.CallOption
}{arg1, arg2, arg3})
fake.recordInvocation("StartNetwork", []interface{}{arg1, arg2, arg3})
fake.startNetworkMutex.Unlock()
if fake.StartNetworkStub != nil {
return fake.StartNetworkStub(arg1, arg2, arg3...)
}
if specificReturn {
return ret.result1, ret.result2
}
fakeReturns := fake.startNetworkReturns
return fakeReturns.result1, fakeReturns.result2
}
func (fake *FakeServiceClient) StartNetworkCallCount() int {
fake.startNetworkMutex.RLock()
defer fake.startNetworkMutex.RUnlock()
return len(fake.startNetworkArgsForCall)
}
func (fake *FakeServiceClient) StartNetworkCalls(stub func(context.Context, *nexus.NetworkRequest, ...grpc.CallOption) (*nexus.StartNetworkResponse, error)) {
fake.startNetworkMutex.Lock()
defer fake.startNetworkMutex.Unlock()
fake.StartNetworkStub = stub
}
func (fake *FakeServiceClient) StartNetworkArgsForCall(i int) (context.Context, *nexus.NetworkRequest, []grpc.CallOption) {
fake.startNetworkMutex.RLock()
defer fake.startNetworkMutex.RUnlock()
argsForCall := fake.startNetworkArgsForCall[i]
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}
func (fake *FakeServiceClient) StartNetworkReturns(result1 *nexus.StartNetworkResponse, result2 error) {
fake.startNetworkMutex.Lock()
defer fake.startNetworkMutex.Unlock()
fake.StartNetworkStub = nil
fake.startNetworkReturns = struct {
result1 *nexus.StartNetworkResponse
result2 error
}{result1, result2}
}
func (fake *FakeServiceClient) StartNetworkReturnsOnCall(i int, result1 *nexus.StartNetworkResponse, result2 error) {
fake.startNetworkMutex.Lock()
defer fake.startNetworkMutex.Unlock()
fake.StartNetworkStub = nil
if fake.startNetworkReturnsOnCall == nil {
fake.startNetworkReturnsOnCall = make(map[int]struct {
result1 *nexus.StartNetworkResponse
result2 error
})
}
fake.startNetworkReturnsOnCall[i] = struct {
result1 *nexus.StartNetworkResponse
result2 error
}{result1, result2}
}
func (fake *FakeServiceClient) StopNetwork(arg1 context.Context, arg2 *nexus.NetworkRequest, arg3 ...grpc.CallOption) (*nexus.Empty, error) {
fake.stopNetworkMutex.Lock()
ret, specificReturn := fake.stopNetworkReturnsOnCall[len(fake.stopNetworkArgsForCall)]
fake.stopNetworkArgsForCall = append(fake.stopNetworkArgsForCall, struct {
arg1 context.Context
arg2 *nexus.NetworkRequest
arg3 []grpc.CallOption
}{arg1, arg2, arg3})
fake.recordInvocation("StopNetwork", []interface{}{arg1, arg2, arg3})
fake.stopNetworkMutex.Unlock()
if fake.StopNetworkStub != nil {
return fake.StopNetworkStub(arg1, arg2, arg3...)
}
if specificReturn {
return ret.result1, ret.result2
}
fakeReturns := fake.stopNetworkReturns
return fakeReturns.result1, fakeReturns.result2
}
func (fake *FakeServiceClient) StopNetworkCallCount() int {
fake.stopNetworkMutex.RLock()
defer fake.stopNetworkMutex.RUnlock()
return len(fake.stopNetworkArgsForCall)
}
func (fake *FakeServiceClient) StopNetworkCalls(stub func(context.Context, *nexus.NetworkRequest, ...grpc.CallOption) (*nexus.Empty, error)) {
fake.stopNetworkMutex.Lock()
defer fake.stopNetworkMutex.Unlock()
fake.StopNetworkStub = stub
}
func (fake *FakeServiceClient) StopNetworkArgsForCall(i int) (context.Context, *nexus.NetworkRequest, []grpc.CallOption) {
fake.stopNetworkMutex.RLock()
defer fake.stopNetworkMutex.RUnlock()
argsForCall := fake.stopNetworkArgsForCall[i]
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}
func (fake *FakeServiceClient) StopNetworkReturns(result1 *nexus.Empty, result2 error) {
fake.stopNetworkMutex.Lock()
defer fake.stopNetworkMutex.Unlock()
fake.StopNetworkStub = nil
fake.stopNetworkReturns = struct {
result1 *nexus.Empty
result2 error
}{result1, result2}
}
func (fake *FakeServiceClient) StopNetworkReturnsOnCall(i int, result1 *nexus.Empty, result2 error) {
fake.stopNetworkMutex.Lock()
defer fake.stopNetworkMutex.Unlock()
fake.StopNetworkStub = nil
if fake.stopNetworkReturnsOnCall == nil {
fake.stopNetworkReturnsOnCall = make(map[int]struct {
result1 *nexus.Empty
result2 error
})
}
fake.stopNetworkReturnsOnCall[i] = struct {
result1 *nexus.Empty
result2 error
}{result1, result2}
}
func (fake *FakeServiceClient) UpdateNetwork(arg1 context.Context, arg2 *nexus.NetworkRequest, arg3 ...grpc.CallOption) (*nexus.Empty, error) {
fake.updateNetworkMutex.Lock()
ret, specificReturn := fake.updateNetworkReturnsOnCall[len(fake.updateNetworkArgsForCall)]
fake.updateNetworkArgsForCall = append(fake.updateNetworkArgsForCall, struct {
arg1 context.Context
arg2 *nexus.NetworkRequest
arg3 []grpc.CallOption
}{arg1, arg2, arg3})
fake.recordInvocation("UpdateNetwork", []interface{}{arg1, arg2, arg3})
fake.updateNetworkMutex.Unlock()
if fake.UpdateNetworkStub != nil {
return fake.UpdateNetworkStub(arg1, arg2, arg3...)
}
if specificReturn {
return ret.result1, ret.result2
}
fakeReturns := fake.updateNetworkReturns
return fakeReturns.result1, fakeReturns.result2
}
func (fake *FakeServiceClient) UpdateNetworkCallCount() int {
fake.updateNetworkMutex.RLock()
defer fake.updateNetworkMutex.RUnlock()
return len(fake.updateNetworkArgsForCall)
}
func (fake *FakeServiceClient) UpdateNetworkCalls(stub func(context.Context, *nexus.NetworkRequest, ...grpc.CallOption) (*nexus.Empty, error)) {
fake.updateNetworkMutex.Lock()
defer fake.updateNetworkMutex.Unlock()
fake.UpdateNetworkStub = stub
}
func (fake *FakeServiceClient) UpdateNetworkArgsForCall(i int) (context.Context, *nexus.NetworkRequest, []grpc.CallOption) {
fake.updateNetworkMutex.RLock()
defer fake.updateNetworkMutex.RUnlock()
argsForCall := fake.updateNetworkArgsForCall[i]
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}
func (fake *FakeServiceClient) UpdateNetworkReturns(result1 *nexus.Empty, result2 error) {
fake.updateNetworkMutex.Lock()
defer fake.updateNetworkMutex.Unlock()
fake.UpdateNetworkStub = nil
fake.updateNetworkReturns = struct {
result1 *nexus.Empty
result2 error
}{result1, result2}
}
func (fake *FakeServiceClient) UpdateNetworkReturnsOnCall(i int, result1 *nexus.Empty, result2 error) {
fake.updateNetworkMutex.Lock()
defer fake.updateNetworkMutex.Unlock()
fake.UpdateNetworkStub = nil
if fake.updateNetworkReturnsOnCall == nil {
fake.updateNetworkReturnsOnCall = make(map[int]struct {
result1 *nexus.Empty
result2 error
})
}
fake.updateNetworkReturnsOnCall[i] = struct {
result1 *nexus.Empty
result2 error
}{result1, result2}
}
func (fake *FakeServiceClient) Invocations() map[string][][]interface{} {
fake.invocationsMutex.RLock()
defer fake.invocationsMutex.RUnlock()
fake.networkDiagnosticsMutex.RLock()
defer fake.networkDiagnosticsMutex.RUnlock()
fake.networkStatsMutex.RLock()
defer fake.networkStatsMutex.RUnlock()
fake.pingMutex.RLock()
defer fake.pingMutex.RUnlock()
fake.removeNetworkMutex.RLock()
defer fake.removeNetworkMutex.RUnlock()
fake.startNetworkMutex.RLock()
defer fake.startNetworkMutex.RUnlock()
fake.stopNetworkMutex.RLock()
defer fake.stopNetworkMutex.RUnlock()
fake.updateNetworkMutex.RLock()
defer fake.updateNetworkMutex.RUnlock()
copiedInvocations := map[string][][]interface{}{}
for key, value := range fake.invocations {
copiedInvocations[key] = value
}
return copiedInvocations
}
func (fake *FakeServiceClient) recordInvocation(key string, args []interface{}) {
fake.invocationsMutex.Lock()
defer fake.invocationsMutex.Unlock()
if fake.invocations == nil {
fake.invocations = map[string][][]interface{}{}
}
if fake.invocations[key] == nil {
fake.invocations[key] = [][]interface{}{}
}
fake.invocations[key] = append(fake.invocations[key], args)
}
var _ nexus.ServiceClient = new(FakeServiceClient)
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/grpc-clients/lens.go | grpc-clients/lens.go | package clients
import (
"fmt"
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/grpc/dialer"
pb "github.com/RTradeLtd/grpc/lensv2"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
)
const (
defaultURL = "127.0.0.1:9998"
)
// LensClient is a lens client used to make requests to the Lens gRPC server
type LensClient struct {
conn *grpc.ClientConn
pb.LensV2Client
}
// NewLensClient is used to generate our lens client
func NewLensClient(opts config.Services) (*LensClient, error) {
dialOpts := make([]grpc.DialOption, 0)
if opts.Lens.TLS.CertPath != "" {
creds, err := credentials.NewClientTLSFromFile(opts.Lens.TLS.CertPath, "")
if err != nil {
return nil, fmt.Errorf("could not load tls cert: %s", err)
}
dialOpts = append(dialOpts,
grpc.WithTransportCredentials(creds),
grpc.WithPerRPCCredentials(dialer.NewCredentials(opts.Lens.AuthKey, true)))
} else {
dialOpts = append(dialOpts,
grpc.WithInsecure(),
grpc.WithPerRPCCredentials(dialer.NewCredentials(opts.Lens.AuthKey, false)))
}
var url string
if opts.Lens.URL == "" {
url = defaultURL
} else {
url = opts.Lens.URL
}
conn, err := grpc.Dial(url, dialOpts...)
if err != nil {
return nil, err
}
return &LensClient{
conn: conn,
LensV2Client: pb.NewLensV2Client(conn),
}, nil
}
// Close shuts down the client's gRPC connection
func (l *LensClient) Close() { l.conn.Close() }
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/grpc-clients/bch.go | grpc-clients/bch.go | package clients
import (
"fmt"
"github.com/RTradeLtd/config/v2"
pb "github.com/gcash/bchwallet/rpc/walletrpc"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
)
// BchWalletClient provides a gRPC API
// to manage a BCH wallet
type BchWalletClient struct {
pb.WalletServiceClient
conn *grpc.ClientConn
}
// NewBchWalletClient is used to instantaite our connection
// to a bchwallet daemon for wallet management functionality
func NewBchWalletClient(opts config.Services) (*BchWalletClient, error) {
dialOpts := make([]grpc.DialOption, 0)
if opts.BchGRPC.Wallet.CertFile != "" {
creds, err := credentials.NewClientTLSFromFile(opts.BchGRPC.Wallet.CertFile, "")
if err != nil {
return nil, fmt.Errorf("could not load tls cert: %s", err)
}
dialOpts = append(dialOpts, grpc.WithTransportCredentials(creds))
} else {
dialOpts = append(dialOpts, grpc.WithInsecure())
}
gConn, err := grpc.Dial(opts.BchGRPC.Wallet.URL, dialOpts...)
if err != nil {
return nil, err
}
return &BchWalletClient{pb.NewWalletServiceClient(gConn), gConn}, nil
}
// Close is used to close the gRPC connection
func (bw *BchWalletClient) Close() { bw.conn.Close() }
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/grpc-clients/orchestrator.go | grpc-clients/orchestrator.go | package clients
import (
"fmt"
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/grpc/dialer"
nexus "github.com/RTradeLtd/grpc/nexus"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
)
// IPFSOrchestratorClient is a lighweight container for the orchestrator's
// gRPC API client
type IPFSOrchestratorClient struct {
nexus.ServiceClient
conn *grpc.ClientConn
}
// NewOcrhestratorClient instantiates a new orchestrator API client
func NewOcrhestratorClient(opts config.Nexus) (*IPFSOrchestratorClient, error) {
c := &IPFSOrchestratorClient{}
// set up parameters for core conn
dialOpts := make([]grpc.DialOption, 0)
if opts.TLS.CertPath != "" {
creds, err := credentials.NewClientTLSFromFile(opts.TLS.CertPath, "")
if err != nil {
return nil, fmt.Errorf("could not load tls cert: %s", err)
}
dialOpts = append(dialOpts,
grpc.WithTransportCredentials(creds),
grpc.WithPerRPCCredentials(dialer.NewCredentials(opts.Key, true)))
} else {
dialOpts = append(dialOpts,
grpc.WithInsecure(),
grpc.WithPerRPCCredentials(dialer.NewCredentials(opts.Key, false)))
}
// connect to orchestrator
var err error
c.conn, err = grpc.Dial(opts.Host+":"+opts.Port, dialOpts...)
if err != nil {
return nil, fmt.Errorf("failed to connect to core service: %s", err.Error())
}
c.ServiceClient = nexus.NewServiceClient(c.conn)
return c, nil
}
// Close shuts down the client's gRPC connection
func (i *IPFSOrchestratorClient) Close() { i.conn.Close() }
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/grpc-clients/clients_test.go | grpc-clients/clients_test.go | package clients_test
import (
"testing"
clients "github.com/RTradeLtd/Temporal/grpc-clients"
"github.com/RTradeLtd/config/v2"
)
const (
testCfgPath = "../testenv/config.json"
)
func TestLensClient_Fail(t *testing.T) {
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
cfg.Services.Lens.TLS.CertPath = "fakepath"
if _, err = clients.NewLensClient(cfg.Services); err == nil {
t.Fatal("error expected")
}
}
func TestLensClient_Pass(t *testing.T) {
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
if _, err = clients.NewLensClient(cfg.Services); err != nil {
t.Fatal(err)
}
}
func TestWalletService_Fail(t *testing.T) {
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
cfg.Services.BchGRPC.Wallet.CertFile = "fakepath"
if _, err = clients.NewBchWalletClient(cfg.Services); err == nil {
t.Fatal("error expected")
}
}
func TestWalletService_Pass(t *testing.T) {
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
if _, err = clients.NewBchWalletClient(cfg.Services); err != nil {
t.Fatal(err)
}
}
func TestSignerClient_Pass(t *testing.T) {
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
if _, err = clients.NewSignerClient(cfg); err != nil {
t.Fatal(err)
}
}
func TestOrchestratorClient_Fail(t *testing.T) {
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
cfg.Nexus.TLS.CertPath = "fakepath"
if _, err = clients.NewOcrhestratorClient(cfg.Nexus); err == nil {
t.Fatal("error expected")
}
}
func TestOrchestratorClient_Pass(t *testing.T) {
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
if _, err = clients.NewOcrhestratorClient(cfg.Nexus); err != nil {
t.Fatal(err)
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/grpc-clients/eth.go | grpc-clients/eth.go | package clients
import (
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/grpc/dialer"
pb "github.com/RTradeLtd/grpc/pay"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
)
const (
defaultSignerURL = "127.0.0.1:9090"
)
// SignerClient is how we interface with the Signer server as a client
type SignerClient struct {
pb.SignerClient
conn *grpc.ClientConn
}
// NewSignerClient is used to instantiate our connection with our grpc payment api
func NewSignerClient(cfg *config.TemporalConfig) (*SignerClient, error) {
dialOpts := make([]grpc.DialOption, 0)
if cfg.Pay.TLS.CertPath != "" {
creds, err := credentials.NewClientTLSFromFile(cfg.Pay.TLS.CertPath, "")
if err != nil {
return nil, err
}
dialOpts = append(dialOpts,
grpc.WithTransportCredentials(creds),
grpc.WithPerRPCCredentials(dialer.NewCredentials(cfg.Pay.AuthKey, true)))
} else {
dialOpts = append(dialOpts,
grpc.WithInsecure(),
grpc.WithPerRPCCredentials(dialer.NewCredentials(cfg.Pay.AuthKey, false)))
}
var url string
if cfg.Pay.Address == "" {
url = defaultSignerURL
} else {
url = cfg.Pay.Address + ":" + cfg.Pay.Port
}
conn, err := grpc.Dial(url, dialOpts...)
if err != nil {
return nil, err
}
return &SignerClient{
conn: conn,
SignerClient: pb.NewSignerClient(conn),
}, nil
}
// Close shuts down the client's gRPC connection
func (s *SignerClient) Close() { s.conn.Close() }
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/grpc-clients/doc.go | grpc-clients/doc.go | // Package clients provides GRPC client constructors for various RTrade services
// that Temporal relies on.
package clients
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/mail/mail_test.go | mail/mail_test.go | package mail_test
import (
"fmt"
"os"
"testing"
"github.com/RTradeLtd/Temporal/mail"
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/database/v2"
)
var (
testRecipientEmail1 = "postables+test1@rtradetechnologies.com"
testRecipientEmail2 = "postables+test2@rtradetechnologies.com"
testRecipientName1 = "postables1"
testRecipientName2 = "postables2"
testCfgPath = "../testenv/config.json"
)
func TestMail(t *testing.T) {
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
dbm, err := database.New(cfg, database.Options{SSLModeDisable: true})
if err != nil {
t.Fatal(err)
}
if cfg.Sendgrid.APIKey == "" {
cfg.Sendgrid.APIKey = os.Getenv("SENDGRID_API_KEY")
cfg.Sendgrid.EmailAddress = "temporal@rtradetechnologies.com"
cfg.Sendgrid.EmailName = "Temporal TravisCI Test"
}
mm, err := mail.NewManager(cfg, dbm.DB)
if err != nil {
t.Fatal(err)
}
content := fmt.Sprint("<br>WowSuchEmail<br>WowSuchFormat")
if _, err = mm.SendEmail(
"testEmail",
content,
"",
testRecipientName1,
testRecipientEmail1,
); err != nil {
t.Fatal(err)
}
if _, err = mm.SendEmail(
"testEmail",
content,
"text/html",
testRecipientName1,
testRecipientEmail1,
); err != nil {
t.Fatal(err)
}
if err = mm.BulkSend(
"testEmail",
content,
"text/html",
[]string{testRecipientName1, testRecipientName2},
[]string{testRecipientEmail1, testRecipientEmail2},
); err != nil {
t.Fatal(err)
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/mail/mail.go | mail/mail.go | package mail
import (
"errors"
"sync"
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/database/v2/models"
"github.com/jinzhu/gorm"
"github.com/sendgrid/rest"
sendgrid "github.com/sendgrid/sendgrid-go"
"github.com/sendgrid/sendgrid-go/helpers/mail"
)
// Mailer is a class that handles mail delivery
type Mailer interface {
Send(email *mail.SGMailV3) (*rest.Response, error)
}
// Manager is our manager that handles email sending
type Manager struct {
APIKey string `json:"api_key"`
EmailAddress string `json:"email_address"` // EmailAddress is the address from which messages will be sent from
EmailName string `json:"email_name"` // EmailName is the name of the email address
userManager *models.UserManager
client Mailer
cmux sync.Mutex
}
// NewManager is used to create our mail manager, allowing us to send email
func NewManager(tCfg *config.TemporalConfig, db *gorm.DB) (*Manager, error) {
var (
apiKey = tCfg.Sendgrid.APIKey
emailAddress = tCfg.Sendgrid.EmailAddress
emailName = tCfg.Sendgrid.EmailName
client = sendgrid.NewSendClient(apiKey)
um = models.NewUserManager(db)
)
return &Manager{
APIKey: apiKey,
EmailAddress: emailAddress,
EmailName: emailName,
client: client,
userManager: um,
}, nil
}
// BulkSend is used to handle sending a single email, to multiple recipients
func (mm *Manager) BulkSend(subject, content, contentType string, recipientNames, recipientEmails []string) error {
if len(recipientNames) != len(recipientEmails) {
return errors.New("recipientNames and recipientEmails must be fo equal length")
}
for k, v := range recipientEmails {
if _, err := mm.SendEmail(subject, content, contentType, recipientNames[k], v); err != nil {
return err
}
}
return nil
}
// SendEmail is used to send an email to temporal users
func (mm *Manager) SendEmail(subject, content, contentType, recipientName, recipientEmail string) (int, error) {
mm.cmux.Lock()
if contentType == "" {
contentType = "text/html"
}
var (
from = mail.NewEmail(mm.EmailName, mm.EmailAddress)
to = mail.NewEmail(recipientName, recipientEmail)
message = mail.NewContent(contentType, content)
)
response, err := mm.client.Send(mail.NewV3MailInit(from, subject, to, message))
mm.cmux.Unlock()
if err != nil {
return -1, err
}
return response.StatusCode, nil
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/mail/doc.go | mail/doc.go | // Package mail provides Temporal's email utilities
package mail
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/utils/random_test.go | utils/random_test.go | package utils_test
import (
"testing"
"github.com/RTradeLtd/Temporal/utils"
)
const (
letterBytesLower = "abcdefghijklmnopqrstuvwxyz"
letterBytesLowerUpper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
letterBytesMixed = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPRQRSTUVWXYZ"
)
func TestRandomUtils(t *testing.T) {
ru := utils.GenerateRandomUtils()
oldSeed := ru.Seed
ru.ReSeed()
newSeed := ru.Seed
if oldSeed == newSeed {
t.Fatal("failed to generate new seed")
}
random1 := ru.GenerateString(5, letterBytesLower)
if len(random1) != 5 {
t.Fatal("failed to contruct random string of valid length")
}
random2 := ru.GenerateString(5, letterBytesLowerUpper)
if len(random2) != 5 {
t.Fatal("failed to construct random string of valid length")
}
random3 := ru.GenerateString(5, letterBytesMixed)
if len(random3) != 5 {
t.Fatal("failed to construct random string of valid length")
}
if random1 == random2 {
t.Fatal("generated two random strings that were the same")
}
if random2 == random3 {
t.Fatal("generated two random strings that were the same")
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/utils/time.go | utils/time.go | package utils
import "time"
// CalculateGarbageCollectDate is used to calculate the date at which data is removed from our system
func CalculateGarbageCollectDate(holdTimeInMonths int) time.Time {
return time.Now().AddDate(0, holdTimeInMonths, 0)
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/utils/time_test.go | utils/time_test.go | package utils_test
import (
"testing"
"time"
"github.com/RTradeLtd/Temporal/utils"
)
func TestCalculateGarbageCollectDate(t *testing.T) {
esimatedTime := utils.CalculateGarbageCollectDate(5)
if esimatedTime == time.Now() {
t.Fatal("invalid time retrieved")
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/utils/cmc.go | utils/cmc.go | package utils
import (
"encoding/json"
"errors"
"fmt"
"io/ioutil"
"net/http"
"net/url"
"sync"
"time"
)
var (
tickerURL = "https://pro-api.coinmarketcap.com/v1/cryptocurrency/quotes/latest"
pricer *priceChecker
)
type coinPrice struct {
price float64
nextRefresh time.Time
}
type priceChecker struct {
coins map[string]coinPrice
mux *sync.RWMutex
}
// USD contains USD prices for a cryptocurrency
type USD struct {
Price float64 `json:"price"`
Volume24H float64 `json:"volume_24h"`
PercentChange1H float64 `json:"percent_change_1h"`
PercentChange24H float64 `json:"percent_change_24h"`
PercentChange7D float64 `json:"percent_change_7d"`
MarketCap float64 `json:"market_cap"`
LastUpdated time.Time `json:"last_updated"`
}
func init() {
pricer = &priceChecker{
coins: make(map[string]coinPrice),
mux: &sync.RWMutex{},
}
}
// RetrieveUsdPrice is used to retrieve the USD price for a coin from CMC.
//
// Whenever we have a "fresh" coin price that is newer than 10 minutes
// we will return that price instead of querying coinmarketcap. In the event
// of a "stale" value we will hit the coinmarketcap api. If that errors
// then we return both the error, and whatever price we have in-memory
func RetrieveUsdPrice(coin, apiKey string) (float64, error) {
pricer.mux.RLock()
if pricer.coins[coin].price != 0 {
if time.Now().After(pricer.coins[coin].nextRefresh) {
goto REFRESH
}
cost := pricer.coins[coin].price
pricer.mux.RUnlock()
return cost, nil
}
REFRESH:
pricer.mux.RUnlock()
pricer.mux.Lock()
defer pricer.mux.Unlock()
if pricer.coins[coin].price != 0 && !time.Now().After(pricer.coins[coin].nextRefresh) {
return pricer.coins[coin].price, nil
}
req, err := http.NewRequest("GET", tickerURL, nil)
if err != nil {
fmt.Println("error: ", err)
return pricer.coins[coin].price, err
}
req.Header.Add("X-CMC_PRO_API_KEY", apiKey)
q := url.Values{}
q.Add("slug", coin)
req.URL.RawQuery = q.Encode()
client := &http.Client{}
response, err := client.Do(req)
if err != nil {
fmt.Println("error: ", err)
return pricer.coins[coin].price, err
}
body, err := ioutil.ReadAll(response.Body)
if err != nil {
fmt.Println("error: ", err)
return pricer.coins[coin].price, err
}
var decode map[string]map[string]interface{}
if err = json.Unmarshal(body, &decode); err != nil {
fmt.Println("error: ", err)
return pricer.coins[coin].price, err
}
// we're only interested in the "data" field
data := decode["data"]
var (
datamap, quotemap, usdmap map[string]interface{}
usd USD
parsed bool
)
for k := range data {
out := data[k]
b, err := json.Marshal(out)
if err != nil {
fmt.Println("error: ", err)
return pricer.coins[coin].price, err
}
if err := json.Unmarshal(b, &datamap); err != nil {
fmt.Println("error: ", err)
return pricer.coins[coin].price, err
}
b, err = json.Marshal(datamap)
if err != nil {
fmt.Println("error: ", err)
return pricer.coins[coin].price, err
}
if err := json.Unmarshal(b, "emap); err != nil {
return pricer.coins[coin].price, err
}
if quotemap["quote"] != nil {
b, err = json.Marshal(quotemap["quote"])
if err != nil {
return pricer.coins[coin].price, err
}
if err := json.Unmarshal(b, &usdmap); err != nil {
fmt.Println("error: ", err)
return pricer.coins[coin].price, err
}
b, err = json.Marshal(usdmap["USD"])
if err != nil {
fmt.Println("error: ", err)
return pricer.coins[coin].price, err
}
if err := json.Unmarshal(b, &usd); err != nil {
fmt.Println("error: ", err)
return pricer.coins[coin].price, err
}
if usd.Price != 0 {
parsed = true
pricer.coins[coin] = coinPrice{
price: usd.Price,
nextRefresh: time.Now().Add(time.Minute * 10),
}
}
}
}
if !parsed {
return pricer.coins[coin].price, errors.New("failed to get price")
}
return pricer.coins[coin].price, nil
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/utils/multiaddr_validator.go | utils/multiaddr_validator.go | package utils
import (
au "github.com/ipfs/go-ipfs-addr"
ma "github.com/multiformats/go-multiaddr"
)
/*
Utilities that allow the user to validate multiaddr formatted addresses
*/
// GenerateMultiAddrFromString is used to take a string, and convert it to a multiformat based address
func GenerateMultiAddrFromString(addr string) (ma.Multiaddr, error) {
var maddr ma.Multiaddr
maddr, err := ma.NewMultiaddr(addr)
if err != nil {
return nil, err
}
return maddr, nil
}
// ParseMultiAddrForIPFSPeer is used to parse a multiaddress to determine whether its a valid ipfs address
func ParseMultiAddrForIPFSPeer(address ma.Multiaddr) (bool, error) {
protocols := address.Protocols()
for _, v := range protocols {
if v.Name == "ipfs" || v.Name == "p2p" {
return true, nil
}
}
return false, nil
}
// ParsePeerIDFromIPFSMultiAddr is used to parse a multiaddress and extract the IPFS peer id
func ParsePeerIDFromIPFSMultiAddr(address ma.Multiaddr) (string, error) {
parsed, err := au.ParseMultiaddr(address)
if err != nil {
return "", err
}
pretty := parsed.ID().Pretty()
return pretty, nil
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/utils/utils.go | utils/utils.go | package utils
import (
"math/big"
"github.com/RTradeLtd/database/v2/models"
"github.com/RTradeLtd/rtfs/v2"
"github.com/c2h5oh/datasize"
)
// CalculatePinCost is used to calculate the cost of pining a particular content hash
// it returns the cost to bill the user, as well as the calculated size of the pin
func CalculatePinCost(username, contentHash string, holdTimeInMonths int64, im rtfs.Manager, um *models.UsageManager) (float64, int64, error) {
// get total size of content hash in bytes ensuring that we calculate size
// by following unique references
sizeInBytes, _, err := rtfs.DedupAndCalculatePinSize(contentHash, im)
if err != nil {
return 0, 0, err
}
// if this is true, fall back to default calculation
// as it wont always be possible to calculate deduplicated
// storage costs if the object is not of a unixfs type
if sizeInBytes <= 0 {
stats, err := im.Stat(contentHash)
if err != nil {
return 0, 0, err
}
sizeInBytes = int64(stats.CumulativeSize)
}
// get gigabytes convert to bytes
gigaInBytes := datasize.GB.Bytes()
// convert size of content hash form int to float64
sizeInBytesFloat := float64(sizeInBytes)
// convert gigabytes to float
gigabytesFloat := float64(gigaInBytes)
// convert object size from bytes to gigabytes
objectSizeInGigabytesFloat := sizeInBytesFloat / gigabytesFloat
// get the users usage model
usage, err := um.FindByUserName(username)
if err != nil {
return 0, 0, err
}
// if they are free tier, they don't incur data charges
if usage.Tier == models.Free || usage.Tier == models.WhiteLabeled || usage.Tier == models.Unverified {
return 0, sizeInBytes, nil
}
// dynamic pricing based on their usage tier
costPerMonthFloat := objectSizeInGigabytesFloat * usage.Tier.PricePerGB()
return costPerMonthFloat * float64(holdTimeInMonths), sizeInBytes, nil
}
// CalculateFileCost is used to calculate the cost of storing a file
func CalculateFileCost(username string, holdTimeInMonths, size int64, um *models.UsageManager) (float64, error) {
gigabytesFloat := float64(datasize.GB.Bytes())
sizeFloat := float64(size)
sizeGigabytesFloat := sizeFloat / gigabytesFloat
// get the users usage model
usage, err := um.FindByUserName(username)
if err != nil {
return 0, err
}
// if they are free tier, they don't incur data charges
if usage.Tier == models.Free || usage.Tier == models.WhiteLabeled || usage.Tier == models.Unverified {
return 0, nil
}
// dynamic pricing based on their usage tier
costPerMonthFloat := sizeGigabytesFloat * usage.Tier.PricePerGB()
return costPerMonthFloat * float64(holdTimeInMonths), nil
}
// FloatToBigInt used to convert a float to big int
func FloatToBigInt(val float64) *big.Int {
bigval := new(big.Float)
bigval.SetFloat64(val)
// Set precision if required.
// bigval.SetPrec(64)
coin := new(big.Float)
coin.SetInt(big.NewInt(1000000000000000000))
bigval.Mul(bigval, coin)
result := new(big.Int)
bigval.Int(result) // store converted number in result
return result
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/utils/cmc_test.go | utils/cmc_test.go | package utils_test
import (
"os"
"testing"
"github.com/RTradeLtd/Temporal/utils"
)
func TestRetrieveUsdPrice(t *testing.T) {
type args struct {
coin string
}
tests := []struct {
name string
args args
wantErr bool
}{
{"Ethereum", args{"ethereum"}, false},
{"Monero", args{"monero"}, false},
{"Bitcoin", args{"bitcoin"}, false},
{"Litecoin", args{"litecoin"}, false},
{"NotARealCoin", args{"NotARealCoin"}, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
price, err := utils.RetrieveUsdPrice(tt.args.coin, os.Getenv("CMC_API"))
if (err != nil) != tt.wantErr {
t.Error(err)
}
if price == 0 && tt.args.coin != "NotARealCoin" {
t.Error("price is 0, unexpected result")
}
price, err = utils.RetrieveUsdPrice(tt.args.coin, os.Getenv("CMC_API"))
if (err != nil) != tt.wantErr {
t.Error(err)
}
if price == 0 && tt.args.coin != "NotARealCoin" {
t.Error("price is 0, unexpected result")
}
})
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/utils/utils_test.go | utils/utils_test.go | package utils_test
import (
"testing"
"time"
"github.com/RTradeLtd/Temporal/utils"
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/database/v2"
"github.com/RTradeLtd/database/v2/models"
"github.com/RTradeLtd/rtfs/v2"
"github.com/jinzhu/gorm"
)
const (
testHash = "QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv"
nodeOneAPIAddr = "127.0.0.1:5001"
testSize = int64(132520817)
)
func TestUtils_CalculatePinCost(t *testing.T) {
manager, err := rtfs.NewManager(nodeOneAPIAddr, "", time.Minute*60)
if err != nil {
t.Fatal(err)
}
cfg, err := config.LoadConfig("../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
usage := models.NewUsageManager(db)
type args struct {
username string
hash string
months int64
}
tests := []struct {
name string
args args
wantErr bool
}{
{"Pass", args{"testuser", testHash, int64(10)}, false},
{"Fail", args{"thisusertotallydoesnotexist", testHash, int64(10)}, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if _, _, err := utils.CalculatePinCost(
tt.args.username,
tt.args.hash,
tt.args.months,
manager,
usage,
); (err != nil) != tt.wantErr {
t.Fatalf("CalculatePinCost err = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestUtils_CalculateFileCost(t *testing.T) {
cfg, err := config.LoadConfig("../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
usage := models.NewUsageManager(db)
type args struct {
username string
size int64
months int64
}
tests := []struct {
name string
args args
wantErr bool
}{
{"Pass", args{"testuser", testSize, int64(10)}, false},
{"Fail", args{"totallydoesnotexist", testSize, int64(10)}, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if _, err := utils.CalculateFileCost(
tt.args.username,
tt.args.months,
tt.args.size,
usage,
); (err != nil) != tt.wantErr {
t.Fatalf("CalculateFileCost err = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestUtils_FloatToBigInt(t *testing.T) {
want := int64(500000000000000000)
bigInt := utils.FloatToBigInt(0.5)
if bigInt.Int64() != want {
t.Fatal("failed to properly calculate big int")
}
}
func loadDatabase(cfg *config.TemporalConfig) (*gorm.DB, error) {
dbm, err := database.New(cfg, database.Options{SSLModeDisable: true})
if err != nil {
return nil, err
}
return dbm.DB, nil
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/utils/ma_test.go | utils/ma_test.go | package utils_test
import (
"testing"
"github.com/RTradeLtd/Temporal/utils"
)
var testIpfsMultiAddrString = "/ip4/192.168.1.242/tcp/4001/ipfs/QmXivHtDyAe8nS7cbQiS7ri9haUM2wGvbinjKws3a4EstT"
var testP2PMultiAddrString = "/ip4/192.168.1.242/tcp/4001/p2p/QmXivHtDyAe8nS7cbQiS7ri9haUM2wGvbinjKws3a4EstT"
var testInvalidIpfsMultiAddr = "/onion/erhkddypoy6qml6h:4003"
var testPeerID = "QmXivHtDyAe8nS7cbQiS7ri9haUM2wGvbinjKws3a4EstT"
func TestMultiAddrValidator(t *testing.T) {
if _, err := utils.GenerateMultiAddrFromString("notarealmultiaddr"); err == nil {
t.Fatal("error expected")
}
addr, err := utils.GenerateMultiAddrFromString(testInvalidIpfsMultiAddr)
if err != nil {
t.Fatal(err)
}
if valid, err := utils.ParseMultiAddrForIPFSPeer(addr); err != nil {
t.Fatal(err)
} else if valid {
t.Fatal("address should not be a valid ipfs address")
}
addr, err = utils.GenerateMultiAddrFromString(testIpfsMultiAddrString)
if err != nil {
t.Fatal(err)
}
if addr == nil {
t.Fatal("addr is nil when it shouldn't be")
}
if valid, err := utils.ParseMultiAddrForIPFSPeer(addr); err != nil {
t.Fatal(err)
} else if !valid {
t.Fatal("address should be a valid ipfs address")
}
peerID, err := utils.ParsePeerIDFromIPFSMultiAddr(addr)
if err != nil {
t.Fatal(err)
}
if peerID != testPeerID {
t.Fatal("recovered peer id does not match")
}
addr, err = utils.GenerateMultiAddrFromString(testP2PMultiAddrString)
if err != nil {
t.Fatal(err)
}
peerID, err = utils.ParsePeerIDFromIPFSMultiAddr(addr)
if err != nil {
t.Fatal(err)
}
if peerID != testPeerID {
t.Fatal("recovered peer id does not match")
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/utils/doc.go | utils/doc.go | // Package utils provides miscellaneous helpers and utilities
package utils
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/utils/random.go | utils/random.go | package utils
import (
"math/rand"
"time"
)
/*
collection of random generating functions
Taken from https://www.calhoun.io/creating-random-strings-in-go/
*/
const (
// LetterBytes are the letters of an alphabet used to generate a random number
LetterBytes = "abcdefghijklmnopqrstuvwxyz"
)
// RandomUtils is our helper struct for random related utilities
type RandomUtils struct {
Seed *rand.Rand
}
// GenerateRandomUtils is used to generate our random utils struct
func GenerateRandomUtils() *RandomUtils {
seed := generateSeed()
return &RandomUtils{Seed: seed}
}
// generateSeed is used to generate a random seed
func generateSeed() *rand.Rand {
return rand.New(rand.NewSource(time.Now().UnixNano()))
}
// ReSeed is used to reseed our RNG
func (u *RandomUtils) ReSeed() {
preSeed := u.Seed.Int63()
u.Seed = rand.New(rand.NewSource(time.Now().UnixNano() + ((preSeed / 3) % 2)))
}
// GenerateString is used to generate a fixed length random string
// from the specified charset, using a fresh seed each time
func (u *RandomUtils) GenerateString(length int, charset string) string {
u.ReSeed()
b := make([]byte, length)
for i := range b {
b[i] = charset[u.Seed.Intn(len(charset))]
}
return string(b)
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/middleware/cors.go | api/middleware/cors.go | package middleware
import (
"github.com/gin-gonic/gin"
rscors "github.com/rs/cors/wrapper/gin"
)
var (
// DefaultAllowedOrigins are the default allowed origins for the api, allowing for access
// via both of our internet uplinks when using the web interface.
DefaultAllowedOrigins = []string{"https://temporal.cloud", "https://backup.temporal.cloud"}
)
// CORSMiddleware is used to load our CORS handling logic
func CORSMiddleware(devMode bool, debug bool, allowedOrigins []string) gin.HandlerFunc {
opts := rscors.Options{}
if devMode {
opts.AllowedOrigins = []string{"*"}
opts.AllowCredentials = true
} else {
opts.AllowedOrigins = allowedOrigins
}
opts.AllowedMethods = []string{"GET", "POST", "OPTIONS", "DELETE", "PUT", "HEAD"}
opts.AllowedHeaders = []string{
"cache-control",
"Authorization",
"X-Request-ID",
"Origin",
"Accept",
"Content-Type",
"X-Requested-With",
"user-agent",
}
if debug {
opts.Debug = true
}
return rscors.New(opts)
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/middleware/middleware_test.go | api/middleware/middleware_test.go | package middleware
import (
"net/http"
"net/http/httptest"
"reflect"
"testing"
"go.uber.org/zap/zaptest"
"github.com/gin-gonic/gin"
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/database/v2"
)
func TestRequestIDMiddleware(t *testing.T) {
testRecorder := httptest.NewRecorder()
_, engine := gin.CreateTestContext(testRecorder)
engine.Use(RequestID())
req, err := http.NewRequest("GET", "/foo", nil)
if err != nil {
t.Fatal(err)
}
engine.GET("/foo", func(c *gin.Context) {
c.String(200, "hello")
})
engine.ServeHTTP(testRecorder, req)
if testRecorder.Result().Header.Get("X-Request-ID") == "" {
t.Fatal("failed to set a request header")
}
}
func TestJwtMiddleware(t *testing.T) {
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
logger := zaptest.NewLogger(t).Sugar()
jwt := JwtConfigGenerate(cfg.JWT.Key, cfg.JWT.Realm, db.DB, logger)
if reflect.TypeOf(jwt).String() != "*jwt.GinJWTMiddleware" {
t.Fatal("failed to reflect correct middleware type")
}
if jwt.Realm != cfg.JWT.Realm {
t.Fatal("failed to set correct realm name")
}
testRecorder := httptest.NewRecorder()
testCtx, _ := gin.CreateTestContext(testRecorder)
if token, valid := jwt.Authenticator("testuser", "admin", testCtx); !valid {
t.Fatal("failed to authenticate user")
} else if token != "testuser" {
t.Fatal("failed to authenticate")
}
// test a failed auth
if _, valid := jwt.Authenticator("testuser22", "admin22", testCtx); valid {
t.Fatal("user authenticated when auth should've failed")
}
if valid := jwt.Authorizator("testuser", testCtx); !valid {
t.Fatal("failed to authorize user")
}
if valid := jwt.Authorizator("testuser2", testCtx); valid {
t.Fatal("failed to authorize user")
}
jwt.Unauthorized(testCtx, 401, "unauthorized access")
if testRecorder.Code != 401 {
t.Fatal("failed to validate http status code")
}
}
func TestCORSMiddleware(t *testing.T) {
cors := CORSMiddleware(true, true, DefaultAllowedOrigins)
if reflect.TypeOf(cors).String() != "gin.HandlerFunc" {
t.Fatal("failed to reflect correct middleware type")
}
cors = CORSMiddleware(false, true, DefaultAllowedOrigins)
if reflect.TypeOf(cors).String() != "gin.HandlerFunc" {
t.Fatal("failed to reflect correct middleware type")
}
cors = CORSMiddleware(false, true, []string{})
if reflect.TypeOf(cors).String() != "gin.HandlerFunc" {
t.Fatal("failed to reflect correct middleware type")
}
}
func TestSecMiddleware(t *testing.T) {
sec := NewSecWare(false)
if reflect.TypeOf(sec).String() != "gin.HandlerFunc" {
t.Fatal("failed to reflect correct middleware type")
}
sec = NewSecWare(true)
if reflect.TypeOf(sec).String() != "gin.HandlerFunc" {
t.Fatal("failed to reflect correct middleware type")
}
}
func loadDatabase(cfg *config.TemporalConfig) (*database.Manager, error) {
return database.New(cfg, database.Options{
SSLModeDisable: true,
})
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/middleware/jwt.go | api/middleware/jwt.go | package middleware
import (
"time"
"github.com/RTradeLtd/database/v2/models"
jwt "github.com/appleboy/gin-jwt"
"github.com/gin-gonic/gin"
"github.com/jinzhu/gorm"
"go.uber.org/zap"
)
// Login is used to unmarshal a login in request so that we can parse it
type Login struct {
Username string `form:"username" json:"username" binding:"required"`
Password string `form:"password" json:"password" binding:"required"`
}
// JwtConfigGenerate is used to generate our JWT configuration
func JwtConfigGenerate(jwtKey, realmName string, db *gorm.DB, l *zap.SugaredLogger) *jwt.GinJWTMiddleware {
l = l.Named("jwt-middleware")
authMiddleware := &jwt.GinJWTMiddleware{
Realm: realmName,
Key: []byte(jwtKey),
Timeout: time.Hour * 24,
MaxRefresh: time.Hour * 24,
// userId will be either the username or email address
Authenticator: func(userId string, password string, c *gin.Context) (string, bool) {
lAuth := l.With("user", userId)
userManager := models.NewUserManager(db)
validLogin, err := userManager.SignIn(userId, password)
if err != nil {
lAuth.Warn("bad sign in", "error", err)
return userId, false
}
if !validLogin {
lAuth.Warn("bad login")
return userId, false
}
// fixes https://github.com/RTradeLtd/Temporal/issues/405
// regardless of whether or not they are providing username or email
// always return the username
usr, err := userManager.FindByUserName(userId)
if err != nil {
usr, err = userManager.FindByEmail(userId)
if err != nil {
lAuth.Warn("failed to find user", "error", err)
return "", false
}
}
// email enabled implies they have verified their email
if !usr.EmailEnabled {
return "", false
}
lAuth.Info("successful login", "username", usr.UserName)
return usr.UserName, true
},
Authorizator: func(userId string, c *gin.Context) bool {
// as a final security step, ensure that we can find the user in our database
userManager := models.NewUserManager(db)
usr, err := userManager.FindByUserName(userId)
if err != nil {
return false
}
return usr.EmailEnabled && usr.AccountEnabled
},
Unauthorized: func(c *gin.Context, code int, message string) {
l.Error("invalid login detected")
c.JSON(code, gin.H{
"code": code,
"message": message,
})
},
TokenLookup: "header:Authorization",
TokenHeadName: "Bearer",
TimeFunc: time.Now,
}
return authMiddleware
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/middleware/requestid.go | api/middleware/requestid.go | package middleware
import (
"github.com/gin-gonic/gin"
"github.com/google/uuid"
)
// RequestID is used to insert a randomly generated
// uuid as a value to a X-Request-ID header
func RequestID() gin.HandlerFunc {
return func(c *gin.Context) {
c.Header("X-Request-Id", uuid.New().String())
c.Next()
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/middleware/security.go | api/middleware/security.go | package middleware
import (
"github.com/gin-contrib/secure"
"github.com/gin-gonic/gin"
)
// NewSecWare is used to initialize our security middleware
func NewSecWare(devMode bool) gin.HandlerFunc {
config := secure.DefaultConfig()
config.IsDevelopment = devMode
config.ContentSecurityPolicy = "default-src 'self' https://checkout.stripe.com; connect-src https://checkout.stripe.com; frame-src https://checkout.stripe.com; script-src https://checkout.stripe.com; img-src https://*.stripe.com; object-src 'none'"
return secure.New(config)
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/middleware/doc.go | api/middleware/doc.go | // Package middleware provides the middleware used by Temporal's APIs
package middleware
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_organizations_test.go | api/v2/routes_organizations_test.go | package v2
import (
"fmt"
"io/ioutil"
"net/http"
"net/http/httptest"
"net/url"
"testing"
"github.com/RTradeLtd/Temporal/mocks"
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/database/v2/models"
)
func Test_API_Routes_Organization(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
// upgrade account to partner for test.
if err := api.usage.UpdateTier("testuser", models.Partner); err != nil {
t.Fatal(err)
}
// create organization
testRecorder := httptest.NewRecorder()
req := httptest.NewRequest("POST", "/v2/org/new", nil)
req.Header.Add("Authorization", authHeader)
urlValues := url.Values{}
urlValues.Add("name", "testorg")
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
if testRecorder.Result().StatusCode != http.StatusOK {
t.Fatal("bad status returned")
}
// find the organization model to ensure it is create
org, err := models.NewOrgManager(db).FindByName("testorg")
if err != nil {
t.Fatal(err)
}
defer db.Unscoped().Delete(org)
// register organization user
testRecorder = httptest.NewRecorder()
req = httptest.NewRequest("POST", "/v2/org/register/user", nil)
req.Header.Add("Authorization", authHeader)
urlValues = url.Values{}
urlValues.Add("username", "testorg-user")
urlValues.Add("password", "password123")
urlValues.Add("email_address", "testorg+22@example.org")
urlValues.Add("organization_name", "testorg")
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
if testRecorder.Result().StatusCode != http.StatusOK {
t.Fatal("bad status returned")
}
usr, err := models.NewUserManager(db).FindByUserName("testorg-user")
if err != nil {
t.Fatal(err)
}
defer db.Unscoped().Delete(usr)
if usr.Organization != "testorg" {
t.Fatal("bad organization found")
}
usg, err := models.NewUsageManager(db).FindByUserName("testorg-user")
if err != nil {
t.Fatal(err)
}
defer db.Unscoped().Delete(usg)
if usg.Tier != models.WhiteLabeled {
t.Fatal("bad tier found")
}
// search for the organization
testRecorder = httptest.NewRecorder()
req = httptest.NewRequest("GET", "/v2/org/get/model", nil)
req.Header.Add("Authorization", authHeader)
urlValues = url.Values{}
urlValues.Add("name", "testorg")
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
if testRecorder.Result().StatusCode != http.StatusOK {
t.Fatal("bad status returned")
}
// get a billing report
testRecorder = httptest.NewRecorder()
req = httptest.NewRequest("GET", "/v2/org/get/billing/report", nil)
req.Header.Add("Authorization", authHeader)
urlValues = url.Values{}
urlValues.Add("name", "testorg")
urlValues.Add("number_of_days", "30")
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
if testRecorder.Result().StatusCode != http.StatusOK {
t.Fatal("bad status returned")
}
// user upload tests
type args struct {
name string
user string
asCSV string
}
tests := []struct {
name string
args args
wantCode int
}{
{"NoCSV", args{"testorg", "testorg-user", "false"}, 200},
{"WithCSV", args{"testorg", "testorg-user", "false"}, 200},
{"No-OrgName", args{"", "testorg-user", "false"}, 400},
{"No-Users", args{"testorg", "", "false"}, 400},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
testRecorder = httptest.NewRecorder()
req = httptest.NewRequest("POST", "/v2/org/user/uploads", nil)
req.Header.Add("Authorization", authHeader)
urlValues = url.Values{}
// set org name
urlValues.Add("name", tt.args.name)
// set users
urlValues.Add("user", tt.args.user)
// set as csv
urlValues.Add("as_csv", tt.args.asCSV)
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
if testRecorder.Result().StatusCode != tt.wantCode {
data, err := ioutil.ReadAll(testRecorder.Result().Body)
if err != nil {
t.Error(err)
}
fmt.Printf("response:\t%s\t", string(data))
t.Fatal("bad status")
}
})
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_ipns.go | api/v2/routes_ipns.go | package v2
import (
"fmt"
"net/http"
"strconv"
"strings"
"time"
"github.com/gin-gonic/gin"
path "github.com/ipfs/go-path"
"github.com/RTradeLtd/Temporal/eh"
"github.com/RTradeLtd/Temporal/queue"
"github.com/RTradeLtd/Temporal/utils"
"github.com/RTradeLtd/database/v2/models"
gocid "github.com/ipfs/go-cid"
)
// PublishToIPNSDetails is used to publish a record on IPNS with more fine grained control over typical publishing methods
func (api *API) publishToIPNSDetails(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// extract post forms
forms, missingField := api.extractPostForms(c, "hash", "life_time", "ttl", "key", "resolve")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// validate that the hash is an ipfs one
if _, err := gocid.Decode(forms["hash"]); err != nil {
Fail(c, err)
return
}
// ensure user owns the key
if ownsKey, err := api.um.CheckIfKeyOwnedByUser(username, forms["key"]); err != nil {
api.LogError(c, err, eh.KeySearchError)(http.StatusBadRequest)
return
} else if !ownsKey {
err = fmt.Errorf("unauthorized access to key by user %s", username)
api.LogError(c, err, eh.KeyUseError)(http.StatusBadRequest)
return
}
// parse resolve into boolean type
resolve, err := strconv.ParseBool(forms["resolve"])
if err != nil {
Fail(c, err)
return
}
// parse lifetime into time.Duration
lifetime, err := time.ParseDuration(forms["life_time"])
if err != nil {
Fail(c, err)
return
}
// parse ttl into time.Duration
ttl, err := time.ParseDuration(forms["ttl"])
if err != nil {
Fail(c, err)
return
}
if err := api.usage.CanPublishIPNS(username); err != nil {
api.LogError(c, err, "too many ipns records published this month, please wait until next billing cycle")(http.StatusBadRequest)
return
}
if err := api.usage.IncrementIPNSUsage(username, 1); err != nil {
api.LogError(c, err, "failed to increment ipns usage")
return
}
// create ipns entry creation message
ie := queue.IPNSEntry{
CID: forms["hash"],
LifeTime: lifetime,
TTL: ttl,
Resolve: resolve,
Key: forms["key"],
UserName: username,
NetworkName: "public",
}
// send message for processing
if err = api.queues.ipns.PublishMessage(ie); err != nil {
api.LogError(c, err, eh.QueuePublishError)(http.StatusBadRequest)
return
}
// log and return
api.l.With("user", username).Info("ipns entry creation sent to backend")
Respond(c, http.StatusOK, gin.H{"response": "ipns entry creation sent to backend"})
}
// getIPNSRecordsPublishedByUser is used to fetch IPNS records published by a user
func (api *API) getIPNSRecordsPublishedByUser(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
if c.Query("paged") == "true" {
api.pageIt(c, api.upm.DB.Where("user_name = ?", username), &[]models.IPNS{})
return
}
// search for all records published by this user
records, err := api.im.FindByUserName(username)
if err != nil {
api.LogError(c, err, eh.IpnsRecordSearchError)(http.StatusBadRequest)
return
}
// if they haven't uploaded any records, don't fail just notify them
if records == nil || len(*records) == 0 {
Respond(c, http.StatusOK, gin.H{"response": "no ipns records found"})
return
}
// return
Respond(c, http.StatusOK, gin.H{"response": records})
}
// PinIPNSHash is used to pin the content referenced by an IPNS record
// only usable by public IPFS.
// The processing logic is as follows:
// 1) parse the path which will be /ipns/hash
// 2) validate that it is a valid path
// 3) resolve the cid referenced by the record
// 4) pop the last segment of the path, which will be the hash we are looking to pin
func (api *API) pinIPNSHash(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// extract post forms
forms, missingField := api.extractPostForms(c, "hold_time", "ipns_path")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// validate the provided path is legit
parsedPath := path.FromString(forms["ipns_path"])
if err := parsedPath.IsValid(); err != nil {
Fail(c, err, http.StatusBadRequest)
return
}
// parse hold time
holdTimeInt, err := api.validateHoldTime(username, forms["hold_time"])
if err != nil {
Fail(c, err)
return
}
// resolve the ipns path to get the hash
hashToPin, err := api.ipfs.Resolve(forms["ipns_path"])
if err != nil {
api.LogError(c, err, eh.IpnsRecordSearchError)(http.StatusBadRequest)
return
}
// extract the hash to pin by using the cid at the very end of the path
// if someone is passing in a multi-cid path like /ipfs/cidA/cidB/cidC
// IPFS will pin cidC, although most of our service will recognize this as a valid hash
// IPFS Cluster doesn't, so to keep consistency with the rest of our endpoints
// we should only operate on a bare cidC
hash := strings.Split(hashToPin, "/")[len(strings.Split(hashToPin, "/"))-1]
upload, err := api.upm.FindUploadByHashAndUserAndNetwork(username, hash, "public")
// by this conditional if statement passing, it means the user has
// upload content matching this hash before, and we don't want to charge them
// so we should gracefully abort further processing
if err == nil || upload != nil {
Respond(c, http.StatusBadRequest, gin.H{"response": alreadyUploadedMessage})
return
}
// get the cost of this object
cost, size, err := utils.CalculatePinCost(username, hash, holdTimeInt, api.ipfs, api.usage)
if err != nil {
api.LogError(c, err, eh.CostCalculationError)(http.StatusBadRequest)
return
}
// ensure they have enough credits
if err := api.validateUserCredits(username, cost); err != nil {
api.LogError(c, err, eh.InvalidBalanceError)(http.StatusPaymentRequired)
return
}
if err := api.usage.UpdateDataUsage(username, uint64(size)); err != nil {
api.LogError(c, err, eh.CantUploadError)(http.StatusBadRequest)
api.refundUserCredits(username, "pin", cost)
return
}
// create pin message
qp := queue.IPFSClusterPin{
CID: hash,
NetworkName: "public",
UserName: username,
HoldTimeInMonths: holdTimeInt,
CreditCost: cost,
Size: int64(size),
}
// send message for processing
if err = api.queues.cluster.PublishMessage(qp); err != nil {
api.LogError(c, err, eh.QueuePublishError)(http.StatusBadRequest)
api.refundUserCredits(username, "pin", cost)
api.usage.ReduceDataUsage(username, uint64(size))
return
}
// log and return
api.l.Infow("ipfs pin request sent to backend", "user", username)
Respond(c, http.StatusOK, gin.H{"response": "pin request sent to backend"})
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/rtfsp_management_test.go | api/v2/rtfsp_management_test.go | package v2
import (
"net/url"
"testing"
"github.com/RTradeLtd/database/v2/models"
"github.com/RTradeLtd/Temporal/mocks"
"github.com/RTradeLtd/config/v2"
)
func Test_API_Routes_IPFS_Private_User_Management(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
if _, err := api.um.NewUserAccount("testaccount2323", "password123", "example@example.org"); err != nil {
t.Fatal(err)
}
if _, err := api.nm.CreateHostedPrivateNetwork(
"testnetworkdude",
"swarmkey",
nil,
models.NetworkAccessOptions{Owner: "testuser", Users: []string{"testuser"}},
); err != nil {
t.Fatal(err)
}
var apiResp = apiResponse{}
urlValues := url.Values{}
urlValues.Add("network_name", "testnetworkdude")
urlValues.Add("users", "testaccount2323")
urlValues.Add("owners", "testaccount2323")
// test adding a user
if err := sendRequest(
api, "POST", "/v2/ipfs/private/network/users/add", 200, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
// test removing a user
if err := sendRequest(
api, "DELETE", "/v2/ipfs/private/network/users/remove", 200, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
// test adding an owner
if err := sendRequest(
api, "POST", "/v2/ipfs/private/network/owners/add", 200, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_rtfsp_management.go | api/v2/routes_rtfsp_management.go | package v2
import (
"errors"
"net/http"
"strings"
"github.com/RTradeLtd/Temporal/eh"
"github.com/RTradeLtd/database/v2/models"
nexus "github.com/RTradeLtd/grpc/nexus"
"github.com/gin-gonic/gin"
)
// these API calls are used to handle management of private IPFS networks
// CreateIPFSNetwork is used to create an entry in the database for a private ipfs network
func (api *API) createIPFSNetwork(c *gin.Context) {
if !dev {
Fail(c, errors.New("private networks not supported in production, please use https://dev.api.temporal.cloud"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// extract network name
networkName, exists := c.GetPostForm("network_name")
if !exists {
FailWithMissingField(c, "network_name")
return
}
switch strings.ToLower(networkName) {
case "public", "etherswarm":
Fail(c, errors.New("networok name cant be public, PUBLIC, etherswarm, or ETHERSWARM"))
return
}
// retrieve parameters - thse are all optional
swarmKey, _ := c.GetPostForm("swarm_key")
bPeers, _ := c.GetPostFormArray("bootstrap_peers")
users := c.PostFormArray("users")
if users == nil {
users = []string{username}
} else {
users = append(users, username)
}
// create the network in our database
network, err := api.nm.CreateHostedPrivateNetwork(networkName, swarmKey, bPeers, models.NetworkAccessOptions{Users: users, Owner: username})
if err != nil {
api.LogError(c, err, eh.NetworkCreationError)(http.StatusBadRequest)
return
}
// request orchestrator to start up network and create it after registering it in the database
resp, err := api.orch.StartNetwork(c, &nexus.NetworkRequest{
Network: networkName,
})
if err != nil {
api.LogError(c, err, "failed to start private network",
"network_name", networkName,
)(http.StatusBadRequest)
return
}
logger := api.l.With("user", username, "network_name", networkName)
logger.Info("network creation request received")
logger.With("db_id", network.ID).Info("database entry created")
// update allows users who can access the network
if len(users) > 0 {
for _, v := range users {
if err := api.um.AddIPFSNetworkForUser(v, networkName); err != nil && err.Error() != "network already configured for user" {
api.LogError(c, err, eh.NetworkCreationError)(http.StatusBadRequest)
return
}
api.l.With("user", v).Info("network added to user)")
}
}
api.l.With("response", resp).Info("network node started")
// respond with network details
Respond(c, http.StatusOK, gin.H{
"response": gin.H{
"id": network.ID,
"peer_id": resp.GetPeerId(),
"network_name": networkName,
"swarm_key": resp.GetSwarmKey(),
"users": network.Users,
},
})
}
func (api *API) startIPFSPrivateNetwork(c *gin.Context) {
if !dev {
Fail(c, errors.New("private networks not supported in production, please use https://dev.api.temporal.cloud"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get network name
networkName, exists := c.GetPostForm("network_name")
if !exists {
FailWithMissingField(c, "network_name")
return
}
logger := api.l.With("user", username, "network_name", networkName)
logger.Info("private ipfs network start requested")
if err := api.isNetworkOwner(networkName, username); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusUnauthorized)
return
}
if _, err := api.orch.StartNetwork(c, &nexus.NetworkRequest{
Network: networkName}); err != nil {
api.LogError(c, err, "failed to start network")(http.StatusBadRequest)
return
}
// log and return
logger.Info("network started")
Respond(c, http.StatusOK, gin.H{
"response": gin.H{
"network_name": networkName,
"state": "started",
},
})
}
func (api *API) stopIPFSPrivateNetwork(c *gin.Context) {
if !dev {
Fail(c, errors.New("private networks not supported in production, please use https://dev.api.temporal.cloud"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get network name
networkName, exists := c.GetPostForm("network_name")
if !exists {
FailWithMissingField(c, "network_name")
return
}
logger := api.l.With("user", username, "network_name", networkName)
logger.Info("private ipfs network shutdown requested")
// verify admin access to network
if err := api.isNetworkOwner(networkName, username); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusUnauthorized)
return
}
// send a stop network request
if _, err := api.orch.StopNetwork(c, &nexus.NetworkRequest{
Network: networkName}); err != nil {
api.LogError(c, err, "failed to stop network")(http.StatusBadRequest)
return
}
// log and return
logger.Info("network stopped")
Respond(c, http.StatusOK, gin.H{
"response": gin.H{
"network_name": networkName,
"state": "stopped",
},
})
}
func (api *API) removeIPFSPrivateNetwork(c *gin.Context) {
if !dev {
Fail(c, errors.New("private networks not supported in production, please use https://dev.api.temporal.cloud"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get the network name
networkName, exists := c.GetPostForm("network_name")
if !exists {
FailWithMissingField(c, "network_name")
return
}
logger := api.l.With("user", username, "network_name", networkName)
logger.Info("private ipfs network shutdown requested")
// verify admin access to network
network, err := api.nm.GetNetworkByName(networkName)
if err != nil {
api.LogError(c, err, eh.NetworkSearchError)(http.StatusInternalServerError)
return
}
if err := api.isNetworkOwner(networkName, username); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusUnauthorized)
return
}
// send node removal request, removing all data stored
// this is a DESTRUCTIVE action
if _, err = api.orch.RemoveNetwork(c, &nexus.NetworkRequest{
Network: networkName}); err != nil {
api.LogError(c, err, "failed to remove network assets")(http.StatusBadRequest)
return
}
// remove network from database
if err = api.nm.Delete(networkName); err != nil {
api.LogError(c, err, "failed to remove network from database")(http.StatusBadRequest)
return
}
// remove network from users authorized networks
for _, v := range network.Users {
if err = api.um.RemoveIPFSNetworkForUser(v, networkName); err != nil {
api.LogError(c, err, "failed to remove network from users")(http.StatusBadRequest)
return
}
}
// log and return
logger.Info("network removed")
Respond(c, http.StatusOK, gin.H{
"response": gin.H{
"network_name": networkName,
"state": "removed",
},
})
}
// GetIPFSPrivateNetworkByName is used to private ipfs network information
func (api *API) getIPFSPrivateNetworkByName(c *gin.Context) {
if !dev {
Fail(c, errors.New("private networks not supported in production, please use https://dev.api.temporal.cloud"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get the network name
netName := c.Param("name")
// get all networks user has access to
networks, err := api.um.GetPrivateIPFSNetworksForUser(username)
if err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusBadRequest)
return
}
// ensure they can access this network
var found bool
for _, v := range networks {
if v == netName {
found = true
break
}
}
if !found {
Fail(c, errors.New(eh.PrivateNetworkAccessError))
return
}
logger := api.l.With("user", username, "network_name", netName)
logger.Info("private ipfs network by name requested")
// get network details from database
net, err := api.nm.GetNetworkByName(netName)
if err != nil {
api.LogError(c, err, eh.NetworkSearchError)(http.StatusBadRequest)
return
}
// retrieve additional stats if requested
// otherwise send generic information from the database directly
if c.Param("stats") == "true" {
logger.Info("retrieving additional stats from orchestrator")
stats, err := api.orch.NetworkStats(c, &nexus.NetworkRequest{Network: netName})
if err != nil {
api.LogError(c, err, eh.NetworkSearchError)(http.StatusBadRequest)
return
}
// return
Respond(c, http.StatusOK, gin.H{"response": gin.H{
"database": net,
"network_stats": stats,
}})
} else {
// return
Respond(c, http.StatusOK, gin.H{"response": gin.H{
"database": net,
}})
}
}
// GetAuthorizedPrivateNetworks is used to retrieve authorized private networks
// an authorized private network is defined as a network a user has API access to
func (api *API) getAuthorizedPrivateNetworks(c *gin.Context) {
if !dev {
Fail(c, errors.New("private networks not supported in production, please use https://dev.api.temporal.cloud"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get all networks the user has access too
networks, err := api.um.GetPrivateIPFSNetworksForUser(username)
if err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusBadRequest)
return
}
// log and return
api.l.Infow("authorized private ipfs network listing requested", "user", username)
Respond(c, http.StatusOK, gin.H{"response": networks})
}
// addUsersToNetwork is used to add a user to the list of authorized users
// for a given private network.
func (api *API) addUsersToNetwork(c *gin.Context) {
if !dev {
Fail(c, errors.New("private networks not supported in production, please use https://dev.api.temporal.cloud"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
networkName, exists := c.GetPostForm("network_name")
if !exists {
FailWithMissingField(c, "network_name")
return
}
users, exists := c.GetPostFormArray("users")
if !exists {
FailWithMissingField(c, "users")
return
}
network, err := api.nm.GetNetworkByName(networkName)
if err != nil {
api.LogError(c, err, eh.NetworkSearchError)(http.StatusInternalServerError)
return
}
if err := api.isNetworkOwner(networkName, username); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusUnauthorized)
return
}
// make sure the user accounts exist
for _, user := range users {
if _, err := api.um.FindByUserName(user); err != nil {
api.LogError(c, err, eh.UserSearchError)(http.StatusInternalServerError)
return
}
}
// combine both the currrent list of authorized users, and the list of users to add
network.Users = append(network.Users, users...)
// update the users field of the database model only
if err := api.nm.UpdateNetworkByName(networkName, map[string]interface{}{"users": network.Users}); err != nil {
api.LogError(c, err, "failed to update authorized users for network")
return
}
for _, user := range users {
if err := api.um.AddIPFSNetworkForUser(user, networkName); err != nil {
api.LogError(c, err, "failed to update network for user")(http.StatusInternalServerError)
return
}
}
Respond(c, http.StatusOK, gin.H{"response": "authorized user list updated"})
}
// removeUsersFromNetwork is used to remove a user from being able
// to access a network.
func (api *API) removeUsersFromNetwork(c *gin.Context) {
if !dev {
Fail(c, errors.New("private networks not supported in production, please use https://dev.api.temporal.cloud"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
networkName, exists := c.GetPostForm("network_name")
if !exists {
FailWithMissingField(c, "network_name")
return
}
users, exists := c.GetPostFormArray("users")
if !exists {
FailWithMissingField(c, "users")
return
}
network, err := api.nm.GetNetworkByName(networkName)
if err != nil {
api.LogError(c, err, eh.NetworkSearchError)(http.StatusInternalServerError)
return
}
if err := api.isNetworkOwner(networkName, username); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusUnauthorized)
return
}
var (
usersToRemove = make(map[string]bool)
newUsers []string
)
for _, user := range users {
usersToRemove[user] = true
}
// iterate over all current users
// and compare against users to remove list
// if they aren't found, then we add them
// to the new users list.
for _, user := range network.Users {
if !usersToRemove[user] {
newUsers = append(newUsers, user)
}
}
if err := api.nm.UpdateNetworkByName(networkName, map[string]interface{}{"users": newUsers}); err != nil {
api.LogError(c, err, "failed to update authorized users for network")
return
}
for user := range usersToRemove {
if err := api.um.RemoveIPFSNetworkForUser(user, networkName); err != nil {
api.LogError(c, err, "failed to remove network from user")
return
}
}
Respond(c, http.StatusOK, gin.H{"response": "authorized user list updated"})
}
func (api *API) addOwnersToNetwork(c *gin.Context) {
if !dev {
Fail(c, errors.New("private networks not supported in production, please use https://dev.api.temporal.cloud"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
networkName, exists := c.GetPostForm("network_name")
if !exists {
FailWithMissingField(c, "network_name")
return
}
owners, exists := c.GetPostFormArray("owners")
if !exists {
FailWithMissingField(c, "owners")
return
}
if err := api.isNetworkOwner(networkName, username); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusUnauthorized)
return
}
// make sure the user accounts exist
for _, owner := range owners {
if _, err := api.um.FindByUserName(owner); err != nil {
api.LogError(c, err, eh.UserSearchError)(http.StatusInternalServerError)
return
}
}
network, err := api.nm.GetNetworkByName(networkName)
if err != nil { // remove network from users authorized networks
api.LogError(c, err, eh.NetworkSearchError)(http.StatusInternalServerError)
return
}
network.Owners = append(network.Owners, owners...)
if err := api.nm.UpdateNetworkByName(networkName, map[string]interface{}{"owners": network.Owners}); err != nil {
api.LogError(c, err, "failed to update network owners")
return
}
Respond(c, http.StatusOK, gin.H{"response": "network owners updated"})
}
func (api *API) isNetworkOwner(network, username string) error {
n, err := api.nm.GetNetworkByName(network)
if err != nil {
return err
}
for _, owner := range n.Owners {
if owner == username {
return nil
}
}
return errors.New("user is not owner")
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_payment_test.go | api/v2/routes_payment_test.go | package v2
import (
"net/http/httptest"
"net/url"
"testing"
"github.com/RTradeLtd/Temporal/mocks"
"github.com/RTradeLtd/config/v2"
)
func Test_API_Routes_Payments(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
// test basic dash payment
// /v2/payments/create/dash
testRecorder := httptest.NewRecorder()
req := httptest.NewRequest("POST", "/v2/payments/dash/create", nil)
req.Header.Add("Authorization", authHeader)
urlValues := url.Values{}
urlValues.Add("credit_value", "10")
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
// test request signed payment message - rtc
// /v2/payments/request
testRecorder = httptest.NewRecorder()
req = httptest.NewRequest("POST", "/v2/payments/eth/request", nil)
req.Header.Add("Authorization", authHeader)
urlValues = url.Values{}
urlValues.Add("payment_type", "rtc")
urlValues.Add("sender_address", "0x0")
urlValues.Add("credit_value", "10")
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
// test request signed payment message - eth
// /v2/payments/request
testRecorder = httptest.NewRecorder()
req = httptest.NewRequest("POST", "/v2/payments/eth/request", nil)
req.Header.Add("Authorization", authHeader)
urlValues = url.Values{}
urlValues.Add("payment_type", "eth")
urlValues.Add("sender_address", "0x0")
urlValues.Add("credit_value", "10")
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
// test payment confirmation
// /v2/payments/confirm
testRecorder = httptest.NewRecorder()
req = httptest.NewRequest("POST", "/v2/payments/eth/confirm", nil)
req.Header.Add("Authorization", authHeader)
urlValues = url.Values{}
urlValues.Add("payment_number", "10")
urlValues.Add("tx_hash", "0x1")
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
// test bch create
testRecorder = httptest.NewRecorder()
req = httptest.NewRequest("POST", "/v2/payments/bch/create", nil)
req.Header.Add("Authorization", authHeader)
urlValues = url.Values{}
urlValues.Add("credit_value", "10")
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
// test bch confirm
testRecorder = httptest.NewRecorder()
req = httptest.NewRequest("POST", "/v2/payments/bch/confirm", nil)
req.Header.Add("Authorization", authHeader)
urlValues = url.Values{}
urlValues.Add("payment_number", "10")
urlValues.Add("tx_hash", "0x1")
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_frontend.go | api/v2/routes_frontend.go | package v2
import (
"net/http"
"strconv"
"github.com/jinzhu/gorm"
"github.com/RTradeLtd/Temporal/eh"
"github.com/RTradeLtd/Temporal/utils"
"github.com/RTradeLtd/database/v2/models"
"github.com/gin-gonic/gin"
gocid "github.com/ipfs/go-cid"
)
// CalculatePinCost is used to calculate the cost of pinning something to temporal
func (api *API) calculatePinCost(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// hash to calculate pin cost for
hash := c.Param("hash")
if _, err := gocid.Decode(hash); err != nil {
Fail(c, err)
return
}
// months to store pin for
holdTime := c.Param("hold_time")
// parse hold time
holdTimeInt, err := strconv.ParseInt(holdTime, 10, 64)
if err != nil {
Fail(c, err)
return
}
// calculate pin cost
totalCost, _, err := utils.CalculatePinCost(username, hash, holdTimeInt, api.ipfs, api.usage)
if err != nil {
api.LogError(c, err, eh.CostCalculationError)(http.StatusBadRequest)
Fail(c, err)
return
}
// log and return
api.l.With("user", username).Info("pin cost calculation requested")
Respond(c, http.StatusOK, gin.H{"response": totalCost})
}
// CalculateFileCost is used to calculate the cost of uploading a file to our system
func (api *API) calculateFileCost(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// retrieve file to upload
file, err := c.FormFile("file")
if err != nil {
Fail(c, err)
return
}
// validate the file size is within limits
if err := api.FileSizeCheck(file.Size); err != nil {
Fail(c, err)
return
}
// how many months to store file for
forms, missingField := api.extractPostForms(c, "hold_time")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// parse hold time
holdTimeInt, err := strconv.ParseInt(forms["hold_time"], 10, 64)
if err != nil {
Fail(c, err)
return
}
api.l.With("user", username).Info("file cost calculation requested")
// calculate cost
cost, err := utils.CalculateFileCost(username, holdTimeInt, file.Size, api.usage)
if err != nil {
api.LogError(c, err, eh.CostCalculationError)(http.StatusBadRequest)
return
}
// return
Respond(c, http.StatusOK, gin.H{"response": cost})
}
// GetEncryptedUploadsForUser is used to get all the encrypted uploads a user has
func (api *API) getEncryptedUploadsForUser(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
if c.Query("paged") == "true" {
api.pageIt(c, api.ue.DB.Where("user_name = ?", username), &[]models.EncryptedUpload{})
return
}
// find all uploads by this user
uploads, err := api.ue.FindUploadsByUser(username)
if err != nil && err != gorm.ErrRecordNotFound {
api.LogError(c, err, eh.UploadSearchError)(http.StatusBadRequest)
return
}
// if they haven't made any encrypted uploads, return a friendly message
if len(*uploads) == 0 {
Respond(c, http.StatusOK, gin.H{"response": "no encrypted uploads found, try them out :D"})
return
}
// return
Respond(c, http.StatusOK, gin.H{"response": uploads})
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/stats.go | api/v2/stats.go | package v2
import (
"net/http"
"github.com/RTradeLtd/Temporal/eh"
"github.com/gin-gonic/gin"
stats "github.com/semihalev/gin-stats"
)
func (api *API) getStats(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
if err := api.validateAdminRequest(username); err != nil {
FailNotAuthorized(c, eh.UnAuthorizedAdminAccess)
return
}
c.JSON(http.StatusOK, gin.H{
"version": api.version,
"response": stats.Report(),
})
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_organizations.go | api/v2/routes_organizations.go | package v2
import (
"bytes"
"errors"
"html"
"net/http"
"strconv"
"strings"
"time"
"github.com/RTradeLtd/Temporal/eh"
"github.com/RTradeLtd/database/v2/models"
gpaginator "github.com/RTradeLtd/gpaginator"
"github.com/gin-gonic/gin"
"github.com/jszwec/csvutil"
)
// creates a new organization
func (api *API) newOrganization(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// first validate they are a partner
if org, err := api.usage.FindByUserName(username); err != nil {
api.LogError(c, err, eh.UserSearchError)(http.StatusBadRequest)
return
} else if org.Tier != models.Partner {
api.LogError(
c,
errors.New("account tier is not partner"),
"only partner accounts can create orgs",
)(http.StatusBadRequest)
return
}
// get the organization name
forms, missingField := api.extractPostForms(c, "name")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// create the organization
if _, err := api.orgs.NewOrganization(
forms["name"],
username,
); err != nil {
// creation failed, send an error message
api.LogError(
c,
err,
"failed to create organization",
)(http.StatusInternalServerError)
return
}
api.l.Infow("organization created",
"name", forms["name"], "owner", username)
Respond(c, http.StatusOK, gin.H{"response": "organization created"})
}
// getOrganization returns the organization model
// can only be called by organization owner
func (api *API) getOrganization(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get the organization name
forms, missingField := api.extractPostForms(c, "name")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
org, ok := api.validateOrgOwner(c, forms["name"], username)
if !ok {
return
}
Respond(c, http.StatusOK, gin.H{"response": org})
}
func (api *API) getOrgBillingReport(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get the organization name
forms, missingField := api.extractPostForms(c, "name", "number_of_days")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// validate number_of_days parameter
numDays, err := strconv.Atoi(forms["number_of_days"])
if err != nil {
api.LogError(
c,
err,
"number_of_days is not an int",
)(http.StatusBadRequest)
return
}
if _, ok := api.validateOrgOwner(c, forms["name"], username); !ok {
return
}
// generate a billing report
report, err := api.orgs.GenerateBillingReport(
forms["name"],
time.Now().AddDate(0, 0, -numDays),
time.Now(),
)
if err != nil {
api.LogError(
c,
err,
"failed to generate billing report",
)(http.StatusInternalServerError)
return
}
Respond(c, http.StatusOK, gin.H{"response": report})
}
// registerOrgUser is used to register an organization user
// unlike regular user registration, we dont check catch all
// email addresses
func (api *API) registerOrgUser(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// extract post forms
forms, missingField := api.extractPostForms(
c,
"username",
"password",
"email_address",
"organization_name",
)
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// prevent people from registering usernames that contain an `@` sign
// this prevents griefing by prevent user sign-ins by using a username
// that is based off an email address
if strings.ContainsRune(forms["username"], '@') {
Fail(c, errors.New("usernames cant contain @ sign"))
return
}
if _, ok := api.validateOrgOwner(c, forms["organization_name"], username); !ok {
return
}
// parse html encoded strings
forms["password"] = html.UnescapeString(forms["password"])
// create the org user. this process is similar to regular
// user registration, so we handle the errors in the same way
_, err = api.orgs.RegisterOrgUser(
forms["organization_name"],
forms["username"],
forms["password"],
forms["email_address"],
)
api.handleUserCreate(c, forms, err)
}
// getOrgUserUploads allows returning uploads for organization users
// optionally
func (api *API) getOrgUserUploads(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
forms, missingField := api.extractPostForms(c, "name", "user")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// allows optional returning the response as a generated csv file
asCSV := c.PostForm("as_csv") == "true"
// validate user is owner
if _, ok := api.validateOrgOwner(c, forms["name"], username); !ok {
return
}
if asCSV {
uplds, err := api.getUploads(forms["name"], []string{forms["user"]})
if err != nil {
api.LogError(c, err, "failed to get user uploads"+err.Error())
return
}
csvBytes, err := csvutil.Marshal(uplds[forms["user"]])
if err != nil {
api.LogError(c, err, "failed to generate csv file "+err.Error())
return
}
c.DataFromReader(
200,
int64(len(csvBytes)),
"application/octet-stream",
bytes.NewReader(csvBytes),
make(map[string]string),
)
return
}
page := c.PostForm("page")
if page == "" {
page = "1"
}
limit := c.PostForm("limit")
if limit == "" {
limit = "10"
}
pageInt, err := strconv.Atoi(page)
if err != nil {
Fail(c, err, http.StatusBadRequest)
return
}
limitInt, err := strconv.Atoi(limit)
if err != nil {
Fail(c, err, http.StatusBadRequest)
return
}
// validate that the user is part of the organization
// however dont fail on an error, simply continue
usr, err := api.um.FindByUserName(forms["user"])
if err != nil {
api.LogError(c, err, eh.UserSearchError)
return
}
if usr.Organization != forms["name"] {
Fail(c, errors.New("user is not part of organization"))
return
}
var uploads []models.Upload
paged, err := gpaginator.Paging(
&gpaginator.Param{
DB: api.upm.DB.Where("user_name = ?", forms["user"]),
Page: pageInt,
Limit: limitInt,
},
&uploads,
)
if err != nil {
api.LogError(c, err, "failed to get paged user upload")
return
}
// return the response
Respond(c, http.StatusOK, gin.H{"response": paged})
}
func (api *API) getUploads(orgName string, users []string) (map[string][]models.Upload, error) {
resp := make(map[string][]models.Upload)
for _, user := range users {
uplds, err := api.orgs.GetUserUploads(orgName, user)
if err != nil {
continue
}
resp[user] = uplds
}
return resp, nil
}
// returns true if user is owner
func (api *API) validateOrgOwner(c *gin.Context, organization, username string) (*models.Organization, bool) {
org, err := api.orgs.FindByName(organization)
if err != nil {
api.LogError(
c,
err,
"failed to find org",
)(http.StatusInternalServerError)
return nil, false
}
if org.AccountOwner != username {
api.LogError(
c,
errors.New("user is not owner"),
"you are not the organization owner",
)(http.StatusForbidden)
return nil, false
}
return org, true
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/api.go | api/v2/api.go | package v2
import (
"context"
"crypto/tls"
"fmt"
"net/http"
"os"
"strconv"
"time"
"github.com/RTradeLtd/ChainRider-Go/dash"
"github.com/RTradeLtd/Temporal/queue"
"github.com/RTradeLtd/Temporal/rtfscluster"
pbLens "github.com/RTradeLtd/grpc/lensv2"
pbOrch "github.com/RTradeLtd/grpc/nexus"
pbSigner "github.com/RTradeLtd/grpc/pay"
"github.com/RTradeLtd/kaas/v2"
"github.com/RTradeLtd/rtfs/v2"
"github.com/RTradeLtd/swampi"
recaptcha "github.com/ezzarghili/recaptcha-go"
pbBchWallet "github.com/gcash/bchwallet/rpc/walletrpc"
"github.com/streadway/amqp"
"github.com/ulule/limiter/v3"
mgin "github.com/ulule/limiter/v3/drivers/middleware/gin"
"github.com/ulule/limiter/v3/drivers/store/memory"
"go.uber.org/zap"
"github.com/RTradeLtd/config/v2"
stats "github.com/semihalev/gin-stats"
"github.com/RTradeLtd/Temporal/api/middleware"
"github.com/RTradeLtd/database/v2"
"github.com/RTradeLtd/database/v2/models"
"github.com/gin-gonic/gin"
)
// API is our API service
type API struct {
ipfs rtfs.Manager
ipfsCluster *rtfscluster.ClusterManager
keys keys
r *gin.Engine
cfg *config.TemporalConfig
dbm *database.Manager
um *models.UserManager
im *models.IpnsManager
pm *models.PaymentManager
ue *models.EncryptedUploadManager
upm *models.UploadManager
zm *models.ZoneManager
rm *models.RecordManager
nm *models.HostedNetworkManager
usage *models.UsageManager
orgs *models.OrgManager
l *zap.SugaredLogger
signer pbSigner.SignerClient
orch pbOrch.ServiceClient
lens pbLens.LensV2Client
bchWallet pbBchWallet.WalletServiceClient
dc *dash.Client
queues queues
service string
version string
swarmEndpoints []*swampi.Swampi
captcha recaptcha.ReCAPTCHA
captchaEnabled bool
}
// Initialize is used ot initialize our API service. debug = true is useful
// for debugging database issues.
func Initialize(
ctx context.Context,
// configuration
cfg *config.TemporalConfig,
version string,
opts Options,
clients Clients,
// API dependencies
l *zap.SugaredLogger,
) (*API, error) {
var (
err error
router = gin.Default()
)
// if we dont set this, rate limiting wont work properly
router.ForwardedByClientIP = true
// update dev mode
dev = opts.DevMode
l = l.Named("api")
im, err := rtfs.NewManager(
cfg.IPFS.APIConnection.Host+":"+cfg.IPFS.APIConnection.Port,
"", time.Minute*60,
)
if err != nil {
return nil, err
}
imCluster, err := rtfscluster.Initialize(
ctx,
cfg.IPFSCluster.APIConnection.Host,
cfg.IPFSCluster.APIConnection.Port,
)
if err != nil {
return nil, err
}
// set up API struct
api, err := new(cfg, router, l, clients, im, imCluster, opts.DebugLogging)
if err != nil {
return nil, err
}
api.version = version
if api.getCaptchaKey() != "" {
captcha, err := recaptcha.NewReCAPTCHA(api.getCaptchaKey(), recaptcha.V3, time.Second*20)
if err != nil {
return nil, err
}
api.captcha = captcha
api.captchaEnabled = true
}
// init routes
if err = api.setupRoutes(opts.DebugLogging); err != nil {
return nil, err
}
api.l.Info("api initialization successful")
// return our configured API service
return api, nil
}
func new(cfg *config.TemporalConfig, router *gin.Engine, l *zap.SugaredLogger, clients Clients, ipfs rtfs.Manager, ipfsCluster *rtfscluster.ClusterManager, debug bool) (*API, error) {
var (
dbm *database.Manager
err error
)
// set up database manager
dbm, err = database.New(cfg, database.Options{LogMode: debug})
if err != nil {
l.Warnw("failed to connect to database with secure connection - attempting insecure", "error", err.Error())
dbm, err = database.New(cfg, database.Options{
LogMode: debug,
SSLModeDisable: true,
})
if err != nil {
return nil, fmt.Errorf("failed to connect to database with insecure connection: %s", err.Error())
}
l.Warn("insecure database connection established")
} else {
l.Info("secure database connection established")
}
var networkVersion string
if dev {
networkVersion = "testnet"
} else {
networkVersion = "main"
}
dc := dash.NewClient(&dash.ConfigOpts{
APIVersion: "v1",
DigitalCurrency: "dash",
//TODO: change to main before production release
Blockchain: networkVersion,
Token: cfg.APIKeys.ChainRider,
})
kb1, err := kaas.NewClient(cfg.Services, false)
if err != nil {
return nil, err
}
kb2, err := kaas.NewClient(cfg.Services, true)
if err != nil {
return nil, err
}
// setup our queues
qmIpns, err := queue.New(queue.IpnsEntryQueue, cfg.RabbitMQ.URL, true, dev, cfg, l.Named("ipns"))
if err != nil {
return nil, err
}
qmPin, err := queue.New(queue.IpfsPinQueue, cfg.RabbitMQ.URL, true, dev, cfg, l.Named("pin"))
if err != nil {
return nil, err
}
qmCluster, err := queue.New(queue.IpfsClusterPinQueue, cfg.RabbitMQ.URL, true, dev, cfg, l.Named("cluster"))
if err != nil {
return nil, err
}
qmEmail, err := queue.New(queue.EmailSendQueue, cfg.RabbitMQ.URL, true, dev, cfg, l.Named("email"))
if err != nil {
return nil, err
}
qmKey, err := queue.New(queue.IpfsKeyCreationQueue, cfg.RabbitMQ.URL, true, dev, cfg, l.Named("key"))
if err != nil {
return nil, err
}
qmDash, err := queue.New(queue.DashPaymentConfirmationQueue, cfg.RabbitMQ.URL, true, dev, cfg, l.Named("dash"))
if err != nil {
return nil, err
}
qmEth, err := queue.New(queue.EthPaymentConfirmationQueue, cfg.RabbitMQ.URL, true, dev, cfg, l.Named("eth"))
if err != nil {
return nil, err
}
qmBch, err := queue.New(queue.BitcoinCashPaymentConfirmationQueue, cfg.RabbitMQ.URL, true, dev, cfg, l.Named("bch"))
if err != nil {
return nil, err
}
qmENS, err := queue.New(queue.ENSRequestQueue, cfg.RabbitMQ.URL, true, dev, cfg, l.Named("ens"))
if err != nil {
return nil, err
}
if cfg.Stripe.SecretKey == "" {
stripeSecretKey := os.Getenv("STRIPE_SECRET_KEY")
cfg.Stripe.SecretKey = stripeSecretKey
}
if cfg.Stripe.PublishableKey == "" {
stripePublishableKey := os.Getenv("STRIPE_PUBLISHABLE_KEY")
cfg.Stripe.PublishableKey = stripePublishableKey
}
// return
return &API{
ipfs: ipfs,
ipfsCluster: ipfsCluster,
keys: keys{kb1: kb1, kb2: kb2},
cfg: cfg,
service: "api",
r: router,
l: l,
dbm: dbm,
um: models.NewUserManager(dbm.DB),
im: models.NewIPNSManager(dbm.DB),
pm: models.NewPaymentManager(dbm.DB),
ue: models.NewEncryptedUploadManager(dbm.DB),
upm: models.NewUploadManager(dbm.DB),
usage: models.NewUsageManager(dbm.DB),
orgs: models.NewOrgManager(dbm.DB),
lens: clients.Lens,
signer: clients.Signer,
orch: clients.Orch,
bchWallet: clients.BchWallet,
dc: dc,
queues: queues{
pin: qmPin,
cluster: qmCluster,
email: qmEmail,
ipns: qmIpns,
key: qmKey,
dash: qmDash,
eth: qmEth,
bch: qmBch,
ens: qmENS,
},
swarmEndpoints: getSwarmEndpoints(cfg.Ethereum),
zm: models.NewZoneManager(dbm.DB),
rm: models.NewRecordManager(dbm.DB),
nm: models.NewHostedNetworkManager(dbm.DB),
}, nil
}
// Close releases API resources
func (api *API) Close() {
// close queue resources
if err := api.queues.cluster.Close(); err != nil {
api.l.Error(err, "failed to properly close cluster queue connection")
}
if err := api.queues.email.Close(); err != nil {
api.l.Error(err, "failed to properly close email queue connection")
}
if err := api.queues.ipns.Close(); err != nil {
api.l.Error(err, "failed to properly close ipns queue connection")
}
if err := api.queues.key.Close(); err != nil {
api.l.Error(err, "failed to properly close key queue connection")
}
if err := api.queues.pin.Close(); err != nil {
api.l.Error(err, "failed to properly close pin queue connection")
}
}
// TLSConfig is used to enable TLS on the API service
type TLSConfig struct {
CertFile string
KeyFile string
}
// ListenAndServe spins up the API server
func (api *API) ListenAndServe(ctx context.Context, addr string, tlsConfig *TLSConfig) error {
server := &http.Server{
Addr: addr,
Handler: api.r,
}
errChan := make(chan error, 1)
go func() {
if tlsConfig != nil {
// configure TLS to override defaults
tlsCfg := &tls.Config{
CurvePreferences: []tls.CurveID{tls.CurveP521, tls.CurveP384, tls.CurveP256},
//PreferServerCipherSuites: true,
CipherSuites: []uint16{
// http/2 mandated supported cipher
// unforunately this is a less secure cipher
// but specifying it first is the only way to accept
// http/2 connections without go throwing an error
tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
// super duper secure ciphers
tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
tls.TLS_RSA_WITH_AES_256_GCM_SHA384,
tls.TLS_RSA_WITH_AES_256_CBC_SHA,
},
// consider whether or not to fix to tls1.2
MinVersion: tls.VersionTLS11,
}
// set tls configuration
server.TLSConfig = tlsCfg
errChan <- server.ListenAndServeTLS(tlsConfig.CertFile, tlsConfig.KeyFile)
return
}
errChan <- server.ListenAndServe()
}()
for {
select {
case err := <-errChan:
return err
case <-ctx.Done():
return server.Close()
case msg := <-api.queues.cluster.ErrCh:
qmCluster, err := api.handleQueueError(msg, api.cfg.RabbitMQ.URL, queue.IpfsClusterPinQueue, true)
if err != nil {
return server.Close()
}
api.queues.cluster = qmCluster
case msg := <-api.queues.dash.ErrCh:
qmDash, err := api.handleQueueError(msg, api.cfg.RabbitMQ.URL, queue.DashPaymentConfirmationQueue, true)
if err != nil {
return server.Close()
}
api.queues.dash = qmDash
case msg := <-api.queues.email.ErrCh:
qmEmail, err := api.handleQueueError(msg, api.cfg.RabbitMQ.URL, queue.EmailSendQueue, true)
if err != nil {
return server.Close()
}
api.queues.email = qmEmail
case msg := <-api.queues.ipns.ErrCh:
qmIpns, err := api.handleQueueError(msg, api.cfg.RabbitMQ.URL, queue.IpnsEntryQueue, true)
if err != nil {
return server.Close()
}
api.queues.ipns = qmIpns
case msg := <-api.queues.key.ErrCh:
qmKey, err := api.handleQueueError(msg, api.cfg.RabbitMQ.URL, queue.IpfsKeyCreationQueue, true)
if err != nil {
return server.Close()
}
api.queues.key = qmKey
case msg := <-api.queues.eth.ErrCh:
qmEth, err := api.handleQueueError(msg, api.cfg.RabbitMQ.URL, queue.EthPaymentConfirmationQueue, true)
if err != nil {
return server.Close()
}
api.queues.eth = qmEth
case msg := <-api.queues.pin.ErrCh:
qmPin, err := api.handleQueueError(msg, api.cfg.RabbitMQ.URL, queue.IpfsPinQueue, true)
if err != nil {
return server.Close()
}
api.queues.pin = qmPin
case msg := <-api.queues.bch.ErrCh:
qmBch, err := api.handleQueueError(msg, api.cfg.RabbitMQ.URL, queue.BitcoinCashPaymentConfirmationQueue, true)
if err != nil {
return server.Close()
}
api.queues.bch = qmBch
}
}
}
// setupRoutes is used to setup all of our api routes
func (api *API) setupRoutes(debug bool) error {
var (
connLimit int
err error
)
if api.cfg.API.Connection.Limit == "" {
connLimit = 50
} else {
// setup the connection limit
connLimit, err = strconv.Atoi(api.cfg.API.Connection.Limit)
if err != nil {
return err
}
}
// make sure we dont throttle dev too much
var rateLimit string
if dev {
rateLimit = "100000-H"
} else {
rateLimit = fmt.Sprintf("%v-H", connLimit)
}
rate, err := limiter.NewRateFromFormatted(rateLimit)
if err != nil {
return err
}
// ensure we have valid cors configuration, otherwise default to allow all
var allowedOrigins []string
if len(api.cfg.API.Connection.CORS.AllowedOrigins) > 0 {
allowedOrigins = api.cfg.API.Connection.CORS.AllowedOrigins
}
// set up defaults
api.r.Use(
// cors middleware
middleware.CORSMiddleware(dev, debug, allowedOrigins),
// allows for automatic xss removal
// greater than what can be configured with HTTP Headers
xssMdlwr.RemoveXss(),
// rate limiting
mgin.NewMiddleware(limiter.New(memory.NewStore(), rate)),
// security middleware
middleware.NewSecWare(dev),
// request id middleware
middleware.RequestID(),
// stats middleware
stats.RequestStats())
// set up middleware
ginjwt := middleware.JwtConfigGenerate(api.cfg.JWT.Key, api.cfg.JWT.Realm, api.dbm.DB, api.l)
authware := []gin.HandlerFunc{ginjwt.MiddlewareFunc()}
// V2 API
v2 := api.r.Group("/v2")
// system checks used to verify the integrity of our services
systemChecks := v2.Group("/systems")
{
systemChecks.GET("/check", api.SystemsCheck)
}
// authless account recovery routes
forgot := v2.Group("/forgot")
{
forgot.POST("/username", api.forgotUserName)
forgot.POST("/password", api.resetPassword)
}
// authentication
auth := v2.Group("/auth")
{
auth.POST("/register", api.registerUserAccount)
auth.POST("/login", ginjwt.LoginHandler)
auth.GET("/refresh", ginjwt.RefreshHandler)
}
// statistics
statistics := v2.Group("/statistics").Use(authware...)
{
statistics.GET("/stats", api.getStats)
}
// lens search engine
lens := v2.Group("/lens")
{
lens.POST("/index", api.submitIndexRequest)
// only allow registered users to search
lens.POST("/search", api.submitSearchRequest)
}
// payments
payments := v2.Group("/payments", authware...)
{
dash := payments.Group("/dash")
{
dash.POST("/create", api.CreateDashPayment)
}
eth := payments.Group("/eth")
{
eth.POST("/request", api.RequestSignedPaymentMessage)
eth.POST("/confirm", api.ConfirmETHPayment)
}
bch := payments.Group("/bch")
{
bch.POST("/create", api.createBchPayment)
bch.POST("/confirm", api.confirmBchPayment)
}
stripe := payments.Group("/stripe")
{
stripe.POST("/charge", api.stripeCharge)
}
payments.GET("/status/:number", api.getPaymentStatus)
}
// accounts
account := v2.Group("/account")
{
token := account.Group("/token", authware...)
{
token.GET("/username", api.getUserFromToken)
}
password := account.Group("/password", authware...)
{
password.POST("/change", api.changeAccountPassword)
}
key := account.Group("/key", authware...)
{
key.GET("/export/:name", api.exportKey)
ipfs := key.Group("/ipfs")
{
ipfs.GET("/get", api.getIPFSKeyNamesForAuthUser)
ipfs.POST("/new", api.createIPFSKey)
}
}
credits := account.Group("/credits", authware...)
{
credits.GET("/available", api.getCredits)
}
email := account.Group("/email")
{
// auth-less account email routes
token := email.Group("/verify")
{
token.GET("/:user/:token", api.verifyEmailAddress)
}
// authenticatoin email routes
auth := email.Use(authware...)
{
auth.POST("/forgot", api.forgotEmail)
}
}
auth := account.Use(authware...)
{
// used to upgrade account to light tier
auth.POST("/upgrade", api.upgradeAccount)
auth.GET("/usage", api.usageData)
}
}
// ipfs routes
ipfs := v2.Group("/ipfs", authware...)
{
// public ipfs routes
public := ipfs.Group("/public")
{
// pinning routes
pin := public.Group("/pin")
{
pin.POST("/:hash", api.pinHashLocally)
pin.POST("/:hash/extend", api.extendPin)
}
// file upload routes
file := public.Group("/file")
{
file.POST("/add", api.addFile)
}
// pubsub routes
pubsub := public.Group("/pubsub")
{
pubsub.POST("/publish/:topic", api.ipfsPubSubPublish)
}
// general routes
public.GET("/stat/:hash", api.getObjectStatForIpfs)
public.GET("/dag/:hash", api.getDagObject)
}
// private ipfs routes
private := ipfs.Group("/private")
{
// network management routes
private.GET("/networks", api.getAuthorizedPrivateNetworks)
network := private.Group("/network")
{
users := network.Group("/users")
{
users.DELETE("/remove", api.removeUsersFromNetwork)
users.POST("/add", api.addUsersToNetwork)
}
owners := network.Group("/owners")
{
owners.POST("/add", api.addOwnersToNetwork)
}
network.GET("/:name", api.getIPFSPrivateNetworkByName)
network.POST("/new", api.createIPFSNetwork)
network.POST("/stop", api.stopIPFSPrivateNetwork)
network.POST("/start", api.startIPFSPrivateNetwork)
network.DELETE("/remove", api.removeIPFSPrivateNetwork)
}
// pinning routes
pin := private.Group("/pin")
{
pin.POST("/:hash", api.pinToHostedIPFSNetwork)
pin.GET("/check/:hash/:networkName", api.checkLocalNodeForPinForHostedIPFSNetwork)
}
// file upload routes
file := private.Group("/file")
{
file.POST("/add", api.addFileToHostedIPFSNetwork)
}
// pubsub routes
pubsub := private.Group("/pubsub")
{
pubsub.POST("/publish/:topic", api.ipfsPubSubPublishToHostedIPFSNetwork)
}
// object stat route
private.GET("/stat/:hash/:networkName", api.getObjectStatForIpfsForHostedIPFSNetwork)
// general routes
private.GET("/dag/:hash/:networkName", api.getDagObjectForHostedIPFSNetwork)
private.GET("/uploads/:networkName", api.getUploadsByNetworkName)
}
// utility routes
utils := ipfs.Group("/utils")
{
// generic download
utils.POST("/download/:hash", api.downloadContentHash)
laser := utils.Group("/laser")
{
laser.POST("/beam", api.beamContent)
}
}
}
// ipns
ipns := v2.Group("/ipns", authware...)
{
// public ipns routes
public := ipns.Group("/public")
{
public.POST("/publish/details", api.publishToIPNSDetails)
// used to handle pinning of IPNS records on public ipfs
// this involves first resolving the record, parsing it
// and extracting the hash to pin
public.POST("/pin", api.pinIPNSHash)
}
// general routes
ipns.GET("/records", api.getIPNSRecordsPublishedByUser)
}
// database
database := v2.Group("/database", authware...)
{
database.GET("/uploads", api.getUploadsForUser)
database.GET("/uploads/encrypted", api.getEncryptedUploadsForUser)
database.POST("/uploads/search", api.searchUploadsForUser)
}
// frontend
frontend := v2.Group("/frontend", authware...)
{
cost := frontend.Group("/cost")
{
calculate := cost.Group("/calculate")
{
calculate.GET("/:hash/:hold_time", api.calculatePinCost)
calculate.POST("/file", api.calculateFileCost)
}
}
}
// organization routes
org := v2.Group("/org", authware...)
{
get := org.Group("/get")
{
get.GET("/model", api.getOrganization)
get.GET("/billing/report", api.getOrgBillingReport)
}
org.POST("/new", api.newOrganization)
org.POST("/register/user", api.registerOrgUser)
org.POST("/user/uploads", api.getOrgUserUploads)
}
// ens routes
ens := v2.Group("/ens", authware...)
{
ens.POST("/claim", api.ClaimENSName)
ens.POST("/update", api.UpdateContentHash)
}
if api.captchaEnabled {
recap := v2.Group("/captcha")
{
recap.POST("/verify", api.verifyCaptcha)
}
}
// swarm routes
swarm := v2.Group("/swarm", authware...)
{
swarm.POST("/upload", api.SwarmUpload)
}
api.l.Info("Routes initialized")
return nil
}
// HandleQueueError is used to handle queue connectivity issues requiring us to re-connect
func (api *API) handleQueueError(amqpErr *amqp.Error, rabbitMQURL string, queueType queue.Queue, publish bool) (*queue.Manager, error) {
api.l.Errorw(
"a protocol connection error stopping rabbitmq was received",
"queue", queueType.String(),
"error", amqpErr.Error())
qManager, err := queue.New(queueType, rabbitMQURL, publish, dev, api.cfg, api.l)
if err != nil {
api.l.Errorw(
"failed to re-establish queue process, exiting",
"queue", queueType.String(),
"error", err.Error())
return nil, err
}
api.l.Warnw(
"successfully re-established queue connection", "queue", queueType.String())
return qManager, nil
}
// currently only supports 2 endpoints
func getSwarmEndpoints(cfg config.Ethereum) []*swampi.Swampi {
var endpoints []*swampi.Swampi
if cfg.Swarm.URL1 != "" {
endpoints = append(endpoints, swampi.New(cfg.Swarm.URL1))
}
if cfg.Swarm.URL2 != "" {
endpoints = append(endpoints, swampi.New(cfg.Swarm.URL2))
}
return endpoints
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_payment.go | api/v2/routes_payment.go | package v2
import (
"context"
"errors"
"fmt"
"net/http"
"strconv"
"github.com/gcash/bchutil"
"github.com/stripe/stripe-go/charge"
"github.com/RTradeLtd/Temporal/eh"
"github.com/jinzhu/gorm"
"github.com/stripe/stripe-go"
"github.com/RTradeLtd/ChainRider-Go/dash"
"github.com/RTradeLtd/Temporal/queue"
"github.com/RTradeLtd/Temporal/utils"
greq "github.com/RTradeLtd/grpc/pay/request"
pbBchWallet "github.com/gcash/bchwallet/rpc/walletrpc"
"github.com/gin-gonic/gin"
)
// ConfirmETHPayment is used to confirm an ethereum based payment
func (api *API) ConfirmETHPayment(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// extract post forms
forms, missingField := api.extractPostForms(c, "payment_number", "tx_hash")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// parse payment number
paymentNumberInt, err := strconv.ParseInt(forms["payment_number"], 10, 64)
if err != nil {
Fail(c, err)
return
}
// check to see if this payment is already registered
payment, err := api.pm.FindPaymentByNumber(username, paymentNumberInt)
if err != nil {
api.LogError(c, err, eh.PaymentSearchError)(http.StatusBadRequest)
return
}
// validate that the payment is for the appropriate blockchain
if payment.Blockchain != "ethereum" {
Fail(c, errors.New("payment you are trying to confirm is not for the ethereum blockchain"))
return
}
// this is used to prevent people from abusing the payment system, and getting
// a single payment to be processed multiple times without having to send additional funds
if payment.TxHash[0:2] == "0x" {
Fail(c, errors.New("payment is already being processed, if your payment hasn't been confirmed after 90 minutes please contact support@rtradetechnologies.com"))
return
}
// update payment with the new tx hash
if _, err = api.pm.UpdatePaymentTxHash(username, forms["tx_hash"], paymentNumberInt); err != nil {
api.LogError(c, err, err.Error())(http.StatusBadRequest)
return
}
// create payment confirmation message
paymentConfirmation := queue.EthPaymentConfirmation{
UserName: username,
PaymentNumber: paymentNumberInt,
}
// send message for processing
if err = api.queues.eth.PublishMessage(paymentConfirmation); err != nil {
api.LogError(c, err, eh.QueuePublishError)(http.StatusBadRequest)
return
}
// return
Respond(c, http.StatusOK, gin.H{"response": payment})
}
// RequestSignedPaymentMessage is used to get a signed message from the GRPC API Payments Server
// this is currently used for ETH+RTC smart-contract facilitated payments
func (api *API) RequestSignedPaymentMessage(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// extract post forms
forms, missingField := api.extractPostForms(c, "payment_type", "sender_address", "credit_value")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
var (
paymentType string
method uint64
)
// ensure it is a valid payment type
switch forms["payment_type"] {
case "0":
paymentType = "rtc"
method = 0
case "1":
paymentType = "eth"
method = 1
default:
Fail(c, errors.New("payment_type must be '0 (rtc)' or '1 (eth)'"))
return
}
// get the current value of a single (ie, 1.0 eth) unit of currency of the given payment type
usdValueFloat, err := api.getUSDValue(paymentType)
if err != nil {
api.LogError(c, err, eh.CmcCheckError)(http.StatusBadRequest)
return
}
// get the number of the current payment we are processing
paymentNumber, err := api.pm.GetLatestPaymentNumber(username)
if err != nil && err != gorm.ErrRecordNotFound {
api.LogError(c, err, eh.PaymentSearchError)(http.StatusBadRequest)
return
}
// convert the credits the user wants to buy from string to float
creditValueFloat, err := strconv.ParseFloat(forms["credit_value"], 64)
if err != nil {
Fail(c, err)
return
}
// calculate how much of the given currency we need to charge them
chargeAmountFloat := creditValueFloat / usdValueFloat
// convert the float to a big int, as whenever we are processing uint256 in our smart contracts, this is the equivalent of a big.Int in golang
chargeAmountBig := utils.FloatToBigInt(chargeAmountFloat)
// format the big int, as a string
chargeAmountString := chargeAmountBig.String()
// do some formatting
numberString := strconv.FormatInt(paymentNumber, 10)
methodString := strconv.FormatUint(method, 10)
// the following pieces of information are used to construct a hash which we then sign
// using this signed hash, we can then present it to the smart contract, along with the data needed to reconstruct the hash
// by presenting this information to the smart contract via a transaction sent by the senderAddress, we can validate our payment
// on-chain, in a trustless manner ensuring transfer of payment and validation of payment within a single smart contract call.
signRequest := greq.SignRequest{
// the address that will be sending the transactoin
Address: forms["sender_address"],
// the method of the payment
Method: methodString,
// the number of the current payment
Number: numberString,
// the amount we are charging them
ChargeAmount: chargeAmountString,
}
// send a call to the signer service, which will take the data, hash it, and sign it
// using the returned values, we have the information needed to send a call to the smart contract
resp, err := api.signer.GetSignedMessage(context.Background(), &signRequest)
if err != nil {
api.LogError(c, err, err.Error())(http.StatusBadRequest)
return
}
// format a unique payment number to take the place of deposit address and tx hash temporarily
paymentNumberString := fmt.Sprintf("%s-%s", username, strconv.FormatInt(paymentNumber, 10))
if _, err = api.pm.NewPayment(
paymentNumber,
paymentNumberString,
paymentNumberString,
creditValueFloat,
chargeAmountFloat,
"ethereum",
paymentType,
username,
); err != nil {
api.LogError(c, err, err.Error())(http.StatusBadRequest)
return
}
// parse the v parameter into uint type
vUint, err := strconv.ParseUint(resp.GetV(), 10, 64)
if err != nil {
api.LogError(c, err, err.Error())(http.StatusBadRequest)
return
}
// format signed message components to send to be used
// for submission to contracts
formattedH := fmt.Sprintf("0x%s", resp.GetH())
formattedR := fmt.Sprintf("0x%s", resp.GetR())
formattedS := fmt.Sprintf("0x%s", resp.GetS())
response := gin.H{
"charge_amount_big": chargeAmountString,
"method": uint8(method),
"payment_number": paymentNumber,
"prefixed": true,
"v": uint8(vUint),
"formatted": gin.H{
"h": formattedH,
"r": formattedR,
"s": formattedS,
},
}
// return
Respond(c, http.StatusOK, gin.H{"response": response})
}
func (api *API) createBchPayment(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
forms, missingField := api.extractPostForms(c, "credit_value")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
usdValueFloat, err := api.getUSDValue("bch")
if err != nil {
Fail(c, err)
return
}
creditValueFloat, err := strconv.ParseFloat(forms["credit_value"], 64)
if err != nil {
Fail(c, err)
return
}
chargeAmountFloat := creditValueFloat / usdValueFloat
paymentNumber, err := api.pm.GetLatestPaymentNumber(username)
if err != nil {
api.LogError(c, err, eh.PaymentSearchError)(http.StatusBadRequest)
return
}
/*
addrReq, err := api.bchWallet.CurrentAddress(context.Background(), &pbBchWallet.CurrentAddressRequest{Account: 0})
if err != nil {
api.LogError(c, err, "failed to get bch deposit address", http.StatusInternalServerError)
return
}
one thing to note about the below solution, this is technically only usable with a fully synced blockchain
so it may/may not cause issues in the future. If this does cause issues, then we will need to disable
this section, and enable the previously commented section above
this is temporary fix until the underlying issue is fixed
https://github.com/gcash/bchwallet/issues/41
*/
addrReq, err := api.bchWallet.NextAddress(context.Background(), &pbBchWallet.NextAddressRequest{Account: 0})
if err != nil {
api.LogError(c, err, "failed to get bch deposit address", http.StatusInternalServerError)
return
}
bchChargeAmount, err := bchutil.NewAmount(chargeAmountFloat)
if err != nil {
api.LogError(c, err, err.Error())(http.StatusBadRequest)
return
}
// format a unique payment number to take the place of deposit address and tx hash temporarily
paymentNumberString := fmt.Sprintf("%s-%s", username, strconv.FormatInt(paymentNumber, 10))
if _, err := api.pm.NewPayment(
paymentNumber,
addrReq.GetAddress(),
// temporary fake tx hash
// will get updated when
// confirming the payment
paymentNumberString,
creditValueFloat,
bchChargeAmount.ToBCH(),
"bitcoin-cash",
"bch",
username,
); err != nil {
api.LogError(c, err, err.Error())(http.StatusBadRequest)
return
}
response := gin.H{
"deposit_address": addrReq.GetAddress(),
"charge_amount": bchChargeAmount.ToBCH(),
"payment_number": paymentNumber,
}
Respond(c, http.StatusOK, gin.H{"response": response})
}
func (api *API) confirmBchPayment(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
forms, missingField := api.extractPostForms(c, "payment_number", "tx_hash")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// parse payment number
paymentNumberInt, err := strconv.ParseInt(forms["payment_number"], 10, 64)
if err != nil {
Fail(c, err)
return
}
// check to see if this payment is already registered
payment, err := api.pm.FindPaymentByNumber(username, paymentNumberInt)
if err != nil {
api.LogError(c, err, eh.PaymentSearchError)(http.StatusBadRequest)
return
}
if payment.Blockchain != "bitcoin-cash" {
Fail(c, errors.New("payment you are trying to confirm is not for the bitcoin-cash blockchain"))
return
}
if payment.Confirmed {
Fail(c, errors.New("payment is already confirmed"))
return
}
// when a payment is first created, we insert temporary data into the TxHash field
// this field only gets updated when confirming a payment. In order to prevent
// abuse and multiple transactions being submitted for the same payment
// before it is confirmed, ensure that we only allow processing if the temporary
// TxHash is present
if payment.TxHash != fmt.Sprintf("%s-%s", username, strconv.FormatInt(payment.Number, 10)) {
Fail(c, errors.New("payment is already being processed"))
return
}
if _, err := api.pm.UpdatePaymentTxHash(username, forms["tx_hash"], paymentNumberInt); err != nil {
api.LogError(c, err, err.Error())(http.StatusBadRequest)
return
}
confirmation := queue.BchPaymentConfirmation{
UserName: username,
PaymentNumber: paymentNumberInt,
}
if err := api.queues.bch.PublishMessage(confirmation); err != nil {
api.LogError(c, err, eh.QueuePublishError)(http.StatusBadRequest)
return
}
Respond(c, http.StatusOK, gin.H{"response": confirmation})
}
// CreateDashPayment is used to create a dash payment via chainrider
func (api *API) CreateDashPayment(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
forms, missingField := api.extractPostForms(c, "credit_value")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
usdValueFloat, err := api.getUSDValue("dash")
if err != nil {
Fail(c, err)
return
}
creditValueFloat, err := strconv.ParseFloat(forms["credit_value"], 64)
if err != nil {
Fail(c, err)
return
}
chargeAmountFloat := creditValueFloat / usdValueFloat
paymentNumber, err := api.pm.GetLatestPaymentNumber(username)
if err != nil {
api.LogError(c, err, eh.PaymentSearchError)(http.StatusBadRequest)
return
}
// as we require tx hashes be unique in the database
// we need to create a fake, but also unique value as a temporary place holder
fakeTxHash := fmt.Sprintf("%s-%v", username, paymentNumber)
// dash is only up to 8 decimals, so we must parse accordingly
chargeAmountParsed := fmt.Sprintf("%.8f", chargeAmountFloat)
chargeAmountFloat, err = strconv.ParseFloat(chargeAmountParsed, 64)
if err != nil {
Fail(c, err)
}
response, err := api.dc.CreatePaymentForward(
&dash.PaymentForwardOpts{
DestinationAddress: api.cfg.Wallets.DASH,
},
)
if err != nil {
api.LogError(c, err, eh.ChainRiderAPICallError, "wallet_address", api.cfg.Wallets.DASH)(http.StatusBadRequest)
return
}
if response.Error != "" {
api.LogError(c, errors.New(response.Error), eh.ChainRiderAPICallError, "wallet_address", api.cfg.Wallets.DASH)(http.StatusBadRequest)
return
}
if _, err = api.pm.NewPayment(
paymentNumber,
response.PaymentAddress,
fakeTxHash,
creditValueFloat,
chargeAmountFloat,
"dash",
"dash",
username,
); err != nil {
api.LogError(c, err, err.Error())(http.StatusBadRequest)
return
}
confirmation := &queue.DashPaymenConfirmation{
UserName: username,
PaymentForwardID: response.PaymentForwardID,
PaymentNumber: paymentNumber,
}
if err = api.queues.dash.PublishMessage(confirmation); err != nil {
api.LogError(c, err, eh.QueuePublishError)(http.StatusBadRequest)
return
}
type pay struct {
PaymentNumber int64
ChargeAmount float64
Blockchain string
Status string
Network string
DepositAddress string
PaymentForwardID string
}
// calculate the mining fee required by chainrider to forward the payment
miningFeeDash := dash.DuffsToDash(float64(int64(response.MiningFeeDuffs)))
// update the charge amount with the mining fee
chargeAmountFloat = chargeAmountFloat + miningFeeDash
p := pay{
PaymentNumber: paymentNumber,
ChargeAmount: chargeAmountFloat,
Blockchain: "dash",
Status: "please send exactly the charge amount. The mining fee required by the chainrider payment forward api call is incldued in the charge amount",
//TODO: change to main before production release
Network: "main",
DepositAddress: response.PaymentAddress,
PaymentForwardID: response.PaymentForwardID,
}
Respond(c, http.StatusOK, gin.H{"response": p})
}
func (api *API) stripeCharge(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
forms, missingField := api.extractPostForms(c, "stripe_token", "stripe_email", "value_in_cents")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
valueInCentsInt, err := strconv.ParseInt(forms["value_in_cents"], 10, 64)
if err != nil {
Fail(c, err)
return
}
valueInCentsFloat, err := strconv.ParseFloat(forms["value_in_cents"], 64)
if err != nil {
Fail(c, err)
return
}
// set the secret key after input validation
stripe.Key = api.cfg.Stripe.SecretKey
// set the source for the charge
// in this case it is a tokenized version of the credit card
source, err := stripe.SourceParamsFor(forms["stripe_token"])
if err != nil {
Fail(c, err)
return
}
// initialize credit card charge parameters
ch, err := charge.New(&stripe.ChargeParams{
Amount: stripe.Int64(valueInCentsInt),
Currency: stripe.String(string(stripe.CurrencyUSD)),
Description: stripe.String("temporal credit purchase"),
// StatementDescriptor is what appears in their credit card billing report
StatementDescriptor: stripe.String("credit purchase"),
// email the receipt goes to
ReceiptEmail: stripe.String(forms["stripe_email"]),
Source: source,
Params: stripe.Params{
Metadata: map[string]string{
"order_type": "temporal.credits",
},
},
})
if err != nil {
api.LogError(c, err, err.Error())(http.StatusBadRequest)
return
}
api.l.Infow("payment complete", "payment.method", "stripe", "user", username, "charge", ch)
// add credits to use
if _, err := api.um.AddCredits(username, valueInCentsFloat/100); err != nil {
api.LogError(c, err, "failed to grant credits")(http.StatusInternalServerError)
return
}
api.l.Infow("credits granted", "payment.method", "stripe", "credit.amount", valueInCentsFloat/100)
Respond(c, http.StatusOK, gin.H{"response": "stripe credit purchase successful"})
}
// GetPaymentStatus is used to retrieve whether or not a payment is confirmed
func (api *API) getPaymentStatus(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
number, err := strconv.ParseInt(c.Param("number"), 10, 64)
if err != nil {
Fail(c, err)
return
}
payment, err := api.pm.FindPaymentByNumber(username, number)
if err != nil {
api.LogError(c, err, eh.PaymentSearchError)(http.StatusBadRequest)
return
}
Respond(c, http.StatusOK, gin.H{"response": payment.Confirmed})
}
// GetUSDValue is used to retrieve the usd value of a given payment type
func (api *API) getUSDValue(paymentType string) (float64, error) {
var (
cost float64
err error
)
switch paymentType {
case "eth":
cost, err = utils.RetrieveUsdPrice("ethereum", api.getCMCKey())
case "xmr":
cost, err = utils.RetrieveUsdPrice("monero", api.getCMCKey())
case "dash":
cost, err = utils.RetrieveUsdPrice("dash", api.getCMCKey())
case "btc":
cost, err = utils.RetrieveUsdPrice("bitcoin", api.getCMCKey())
case "bch":
cost, err = utils.RetrieveUsdPrice("bitcoin-cash", api.getCMCKey())
case "ltc":
cost, err = utils.RetrieveUsdPrice("litecoin", api.getCMCKey())
case "rtc":
cost, err = RtcCostUsd, nil
default:
return 0, errors.New(eh.InvalidPaymentTypeError)
}
// if we have an error, and the cost is 0 return the error
// otherwise if we have an error, and a non-zero cost
// then we should return the most recent price we have
if err != nil && cost == 0 {
return 0, err
}
return cost, nil
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/log_test.go | api/v2/log_test.go | package v2
import (
"encoding/json"
"errors"
"io/ioutil"
"net/http"
"net/http/httptest"
"strings"
"testing"
"go.uber.org/zap"
"go.uber.org/zap/zaptest/observer"
"github.com/gin-gonic/gin"
)
func TestAPI_LogError(t *testing.T) {
type args struct {
err error
message string
fields []interface{}
}
tests := []struct {
name string
args args
wantLog string
wantResp string
}{
{"with err no message", args{errors.New("hi"), "", nil}, "hi", "hi"},
{"with err and message", args{errors.New("hi"), "bye", nil}, "hi", "bye"},
{"message and additional fields", args{errors.New("hi"), "hi", []interface{}{"wow", "amazing"}}, "amazing", "hi"},
{"message and odd fields should ignore fields", args{errors.New("hi"), "hi", []interface{}{"wow"}}, "hi", "hi"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
observer, out := observer.New(zap.InfoLevel)
logger := zap.New(observer).Sugar()
r := httptest.NewRecorder()
c, e := gin.CreateTestContext(r)
api := API{l: logger, service: "test", r: e}
// log error and execute callback
c.Request = httptest.NewRequest("GET", "/", nil)
if tt.args.fields != nil {
api.LogError(c, tt.args.err, tt.args.message, tt.args.fields...)(http.StatusBadRequest)
} else {
api.LogError(c, tt.args.err, tt.args.message)(http.StatusBadRequest)
}
// check log message and context
b, _ := json.Marshal(out.All()[0].ContextMap())
entry := out.All()[0].Message + string(b)
if !strings.Contains(entry, tt.wantLog) {
t.Errorf("got %s, want %s", entry, tt.wantLog)
}
// check http response
b, err := ioutil.ReadAll(r.Body)
if err != nil {
t.Error(err)
}
if strings.Count(string(b), tt.wantResp) > 1 {
t.Errorf("had duplicate counts of %s", tt.wantResp)
}
if !strings.Contains(string(b), tt.wantResp) {
t.Errorf("got %s, want %s", string(b), tt.wantResp)
}
})
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_ipns_test.go | api/v2/routes_ipns_test.go | package v2
import (
"net/url"
"testing"
"time"
"github.com/RTradeLtd/Temporal/mocks"
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/database/v2/models"
shell "github.com/RTradeLtd/go-ipfs-api"
)
var (
validIPNSTestPath = "/ipns/docs.api.temporal.cloud"
badIPNSTestPath = "/not/a/real/path"
validResolveResult = "/ipfs/QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv"
)
func Test_API_Routes_IPNS_Publish(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// create a fake key for testing purposes
models.NewUserManager(db).AddIPFSKeyForUser("testuser", "mytestkey", "suchkeymuchwow")
type args struct {
hash string
lifeTime string
ttl string
key string
resolve string
}
tests := []struct {
name string
args args
wantStatus int
}{
{"Fail-Does-Not-Own-Key", args{hash, "24h", "1h", "notarealkeythisuserowns", "true"}, 400},
{"Fail-Bad-Hash", args{"notavalidipfshash", "24h", "1h", "mytestkey", "true"}, 400},
{"Success", args{hash, "24h", "1h", "mytestkey", "true"}, 200},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
var apiResp apiResponse
urlValues := url.Values{}
urlValues.Add("hash", tt.args.hash)
urlValues.Add("life_time", tt.args.lifeTime)
urlValues.Add("ttl", tt.args.ttl)
urlValues.Add("key", tt.args.key)
urlValues.Add("resolve", tt.args.resolve)
if err := sendRequest(
api, "POST", "/v2/ipns/public/publish/details", tt.wantStatus, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
})
}
}
func Test_API_Routes_IPNS_GET(t *testing.T) {
type args struct {
keyID string
keyName string
hash string
network string
user string
ttl time.Duration
lifeTime time.Duration
}
tests := []struct {
name string
args args
wantStatus int
}{
{"Fail", args{"blah", "blah", "blah", "blah", "blah", time.Minute, time.Minute}, 200},
{"Success", args{"fakeyKeyID", "fakekeyName", "fakeHash", "public", "testuser", time.Minute, time.Minute}, 200},
}
for _, tt := range tests {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
if tt.wantStatus == 200 {
if _, err := models.NewIPNSManager(db).CreateEntry(
tt.args.keyID,
tt.args.hash,
tt.args.keyName,
tt.args.network,
tt.args.user,
tt.args.lifeTime,
tt.args.ttl,
); err != nil {
t.Fatal(err)
}
}
var intAPIResp interfaceAPIResponse
if err := sendRequest(
api, "GET", "/v2/ipns/records", tt.wantStatus, nil, nil, &intAPIResp,
); err != nil {
t.Fatal(err)
}
intAPIResp = interfaceAPIResponse{}
if err := sendRequestPaged(
api,
"GET",
"/v2/ipns/records",
200,
nil,
url.Values{"paged": {"true"}},
&intAPIResp,
); err != nil {
t.Fatal(err)
}
}
}
func Test_API_Routes_IPNS_Pin(t *testing.T) {
type args struct {
holdTime string
ipnsPath string
}
tests := []struct {
name string
args args
wantStatus int
}{
{"Success", args{"1", validIPNSTestPath}, 200},
{"Fail-Bad-Hold-Time", args{"notanumber", validIPNSTestPath}, 400},
{"Fail-Bad-IPNS-Path", args{"1", badIPNSTestPath}, 400},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
fakeManager := &mocks.FakeManager{}
api.ipfs = fakeManager
fakeManager.ResolveReturnsOnCall(0, validResolveResult, nil)
fakeManager.StatReturnsOnCall(0, &shell.ObjectStats{CumulativeSize: 5000000}, nil)
fakeManager.StatReturnsOnCall(1, &shell.ObjectStats{CumulativeSize: 5000000}, nil)
fakeManager.StatReturnsOnCall(2, &shell.ObjectStats{CumulativeSize: 5000000}, nil)
fakeManager.StatReturnsOnCall(3, &shell.ObjectStats{CumulativeSize: 5000000}, nil)
fakeManager.RefsReturnsOnCall(0, []string{"QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv", "QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv"}, nil)
fakeManager.RefsReturnsOnCall(1, []string{"QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv", "QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv"}, nil)
fakeManager.RefsReturnsOnCall(2, []string{"QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv", "QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv"}, nil)
fakeManager.RefsReturnsOnCall(3, []string{"QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv", "QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv"}, nil)
var apiResp apiResponse
urlValues := url.Values{}
urlValues.Add("hold_time", tt.args.holdTime)
urlValues.Add("ipns_path", tt.args.ipnsPath)
if err := sendRequest(
api, "POST", "/v2/ipns/public/pin", tt.wantStatus, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
})
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/types.go | api/v2/types.go | package v2
import (
"github.com/RTradeLtd/Temporal/queue"
"github.com/RTradeLtd/kaas/v2"
xss "github.com/dvwright/xss-mw"
pbLens "github.com/RTradeLtd/grpc/lensv2"
pbOrch "github.com/RTradeLtd/grpc/nexus"
pbSigner "github.com/RTradeLtd/grpc/pay"
pbBchWallet "github.com/gcash/bchwallet/rpc/walletrpc"
)
var (
xssMdlwr xss.XssMw
dev = false
devTermsAndServiceURL = "https://gateway.temporal.cloud/ipns/docs.dev.ts.temporal.cloud"
prodTermsAndServiceURL = "https://gateway.temporal.cloud/ipns/docs.ts.temporal.cloud"
alreadyUploadedMessage = "it seems like you have uploaded content matching this hash already. To save your credits, no charge was placed and the call was gracefully aborted. Please contact support@rtradetechnologies.com if you believe this is an issue"
)
// Options is used to non-critical options
type Options struct {
DebugLogging bool
DevMode bool
}
// Clients is used to configure service clients we use
type Clients struct {
Lens pbLens.LensV2Client
Orch pbOrch.ServiceClient
Signer pbSigner.SignerClient
BchWallet pbBchWallet.WalletServiceClient
}
// CreditRefund is a data object to contain refund information
type CreditRefund struct {
Username string
CallType string
Cost float64
}
type queues struct {
pin *queue.Manager
cluster *queue.Manager
email *queue.Manager
ipns *queue.Manager
key *queue.Manager
dash *queue.Manager
eth *queue.Manager
bch *queue.Manager
ens *queue.Manager
}
// kaas key managers
type keys struct {
kb1 *kaas.Client
kb2 *kaas.Client
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_rtfs.go | api/v2/routes_rtfs.go | package v2
import (
"bytes"
"errors"
"html"
"io"
"io/ioutil"
"net/http"
"github.com/c2h5oh/datasize"
"github.com/RTradeLtd/Temporal/eh"
"github.com/RTradeLtd/Temporal/queue"
"github.com/RTradeLtd/Temporal/utils"
"github.com/RTradeLtd/crypto/v2"
"github.com/RTradeLtd/database/v2/models"
ipfsapi "github.com/RTradeLtd/go-ipfs-api"
"github.com/gin-gonic/gin"
gocid "github.com/ipfs/go-cid"
multihash "github.com/multiformats/go-multihash"
)
// PinHashLocally is used to pin a hash to the local ipfs node
func (api *API) pinHashLocally(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// validate hash
hash := c.Param("hash")
if _, err := gocid.Decode(hash); err != nil {
Fail(c, err)
return
}
// extract post forms
forms, missingField := api.extractPostForms(c, "hold_time")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// parse hold time
holdTimeInt, err := api.validateHoldTime(username, forms["hold_time"])
if err != nil {
Fail(c, err)
return
}
upload, err := api.upm.FindUploadByHashAndUserAndNetwork(username, hash, "public")
// by this conditional if statement passing, it means the user has
// upload content matching this hash before, and we don't want to charge them
// so we should abort further processing
if err == nil || upload != nil {
Respond(c, http.StatusBadRequest, gin.H{"response": alreadyUploadedMessage})
return
}
// determine cost of upload
cost, size, err := utils.CalculatePinCost(username, hash, holdTimeInt, api.ipfs, api.usage)
if err != nil {
api.LogError(c, err, eh.CostCalculationError)(http.StatusBadRequest)
return
}
// validate, and deduct credits if they can upload
if err := api.validateUserCredits(username, cost); err != nil {
api.LogError(c, err, eh.InvalidBalanceError)(http.StatusPaymentRequired)
return
}
// update their data usage
if err := api.usage.UpdateDataUsage(username, uint64(size)); err != nil {
api.LogError(c, err, eh.CantUploadError)(http.StatusBadRequest)
api.refundUserCredits(username, "pin", cost)
return
}
// construct pin message
qp := queue.IPFSClusterPin{
CID: hash,
NetworkName: "public",
UserName: username,
HoldTimeInMonths: holdTimeInt,
Size: size,
CreditCost: cost,
FileName: c.PostForm("file_name"),
}
// sent pin message
if err = api.queues.cluster.PublishMessage(qp); err != nil {
api.LogError(c, err, eh.QueuePublishError)(http.StatusBadRequest)
api.refundUserCredits(username, "pin", cost)
api.usage.ReduceDataUsage(username, uint64(size))
return
}
// log success and return
api.l.Infow("ipfs pin request sent to backend", "user", username)
Respond(c, http.StatusOK, gin.H{"response": "pin request sent to backend"})
}
// AddFile is used to add a file to ipfs with optional encryption
func (api *API) addFile(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// extract post forms
forms, missingField := api.extractPostForms(c, "hold_time")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// parse hold time
holdTimeInMonthsInt, err := api.validateHoldTime(username, forms["hold_time"])
if err != nil {
Fail(c, err)
return
}
var defaultHash = "sha2-256"
hashType := c.PostForm("hash_type")
if hashType == "" {
hashType = defaultHash
}
if _, ok := multihash.Names[hashType]; !ok {
Fail(c, errors.New("invalid multihash type given in post form hash_type"))
return
}
// fetch the file, and create a handler to interact with it
fileHandler, err := c.FormFile("file")
if err != nil {
Fail(c, err)
return
}
fileName := fileHandler.Filename
// validate the size of upload is within limits
if err := api.FileSizeCheck(fileHandler.Size); err != nil {
Fail(c, err)
return
}
api.l.Debug("opening file")
openFile, err := fileHandler.Open()
if err != nil {
api.LogError(c, err, eh.FileOpenError)(http.StatusBadRequest)
return
}
// we need a small hack because reading from openFile once
// drains it's contents, by holding it in a temporary bytes object
// we can avoid any issues that may be caused
fileBytes, err := ioutil.ReadAll(openFile)
if err != nil {
Fail(c, err)
return
}
hash, err := api.ipfs.Add(bytes.NewReader(fileBytes), ipfsapi.OnlyHash(true), ipfsapi.Hash(hashType))
if err != nil {
api.LogError(c, err, eh.IPFSAddError)(http.StatusBadRequest)
return
}
upload, err := api.upm.FindUploadByHashAndUserAndNetwork(username, hash, "public")
// by this conditional if statement passing, it means the user has
// upload content matching this hash before, and we don't want to charge them
// so we should gracefully abort further processing
if err == nil || upload != nil {
Respond(c, http.StatusOK, gin.H{"response": hash, "notice": alreadyUploadedMessage})
return
}
// format size of file into gigabytes
fileSizeInGB := uint64(fileHandler.Size) / datasize.GB.Bytes()
api.l.Debug("user", username, "file_size_in_gb", fileSizeInGB)
// calculate code of upload
cost, err := utils.CalculateFileCost(username, holdTimeInMonthsInt, fileHandler.Size, api.usage)
if err != nil {
api.LogError(c, err, eh.CostCalculationError)(http.StatusBadRequest)
return
}
// validate they have enough credits to pay for the upload
if err = api.validateUserCredits(username, cost); err != nil {
api.LogError(c, err, eh.InvalidBalanceError)(http.StatusPaymentRequired)
return
}
// update their data usage
if err := api.usage.UpdateDataUsage(username, uint64(fileHandler.Size)); err != nil {
api.LogError(c, err, eh.CantUploadError)(http.StatusBadRequest)
api.refundUserCredits(username, "file", cost)
return
}
var reader io.Reader
// encrypt file is passphrase is given
if c.PostForm("passphrase") != "" {
userUsage, err := api.usage.FindByUserName(username)
if err != nil {
api.LogError(c, err, eh.UserSearchError)(http.StatusBadRequest)
return
}
// if the user is within the free tier, then we throttle on-demand encryption
// free accounts are limited to a file upload size of 275MB when performing
// on-demand encryption. Non free accounts do not have this limit
if userUsage.Tier == models.Free || userUsage.Tier == models.Unverified {
megabytesUint := datasize.MB.Bytes()
maxSize := megabytesUint * 275
if fileHandler.Size > int64(maxSize) {
Fail(c, errors.New("free accounts are limited to a max file size of 275MB when using on-demand encryption"))
api.refundUserCredits(username, "file", cost)
api.usage.ReduceDataUsage(username, uint64(fileHandler.Size))
return
}
}
// html decode strings
decodedPassPhrase := html.UnescapeString(c.PostForm("passphrase"))
encrypted, err := crypto.NewEncryptManager(decodedPassPhrase).Encrypt(bytes.NewReader(fileBytes))
if err != nil {
api.LogError(c, err, eh.EncryptionError)(http.StatusBadRequest)
api.refundUserCredits(username, "file", cost)
api.usage.ReduceDataUsage(username, uint64(fileHandler.Size))
return
}
reader = bytes.NewReader(encrypted)
// generate an encryption manager and encrypt
} else {
reader = bytes.NewReader(fileBytes)
}
api.l.Debug("adding file...")
resp, err := api.ipfs.Add(reader, ipfsapi.Hash(hashType))
if err != nil {
api.LogError(c, err, eh.IPFSAddError)(http.StatusBadRequest)
api.refundUserCredits(username, "file", cost)
api.usage.ReduceDataUsage(username, uint64(fileHandler.Size))
return
}
// if this was an encrypted upload we need to update the encrypted upload table
// ipfs cluster pin handles updating the regular uploads table
if c.PostForm("passphrase") != "" {
if _, err := api.ue.NewUpload(username, fileHandler.Filename, "public", resp); err != nil {
api.LogError(c, err, eh.DatabaseUpdateError)(http.StatusBadRequest)
// dont refund here as the data is already available on ipfs
return
}
}
api.l.Debug("file uploaded to ipfs")
qp := queue.IPFSClusterPin{
CID: resp,
NetworkName: "public",
UserName: username,
HoldTimeInMonths: holdTimeInMonthsInt,
FileName: fileName,
Size: fileHandler.Size,
}
// send message to rabbitmq
if err = api.queues.cluster.PublishMessage(qp); err != nil {
api.LogError(c, err, eh.QueuePublishError)(http.StatusBadRequest)
return
}
// log and return
api.l.Infow("simple ipfs file upload processed", "user", username)
Respond(c, http.StatusOK, gin.H{"response": resp})
}
// IpfsPubSubPublish is used to publish a pubsub msg
func (api *API) ipfsPubSubPublish(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// topic is the topic which the pubsub message will be addressed to
topic := c.Param("topic")
// extract post form
forms, missingField := api.extractPostForms(c, "message")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// validate they can submit pubsub message calls
if err := api.usage.CanPublishPubSub(username); err != nil {
api.LogError(c, err, "sending a pubsub message will go over your monthly limit")(http.StatusBadRequest)
return
}
// publish the actual message
if err = api.ipfs.PubSubPublish(topic, forms["message"]); err != nil {
api.LogError(c, err, eh.IPFSPubSubPublishError)(http.StatusBadRequest)
return
}
// update pubsub message usage
if err := api.usage.IncrementPubSubUsage(username, 1); err != nil {
api.LogError(c, err, "failed to increment pubsub usage counter")(http.StatusBadRequest)
return
}
// log and return
api.l.Infow("ipfs pub sub message published", "user", username)
Respond(c, http.StatusOK, gin.H{"response": gin.H{"topic": topic, "message": forms["message"]}})
}
// GetObjectStatForIpfs is used to get the object stats for the particular cid
func (api *API) getObjectStatForIpfs(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// hash is the object to retrieve stats for
hash := c.Param("hash")
if _, err := gocid.Decode(hash); err != nil {
Fail(c, err)
return
}
// retrieve stats for the object
stats, err := api.ipfs.Stat(hash)
if err != nil {
api.LogError(c, err, eh.IPFSObjectStatError)
Fail(c, err)
return
}
// log and return
api.l.Infow("ipfs object stat requested", "user", username)
Respond(c, http.StatusOK, gin.H{"response": stats})
}
// GetDagObject is used to retrieve an IPLD object from ipfs
func (api *API) getDagObject(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// hash to retrieve dag for
hash := c.Param("hash")
if _, err := gocid.Decode(hash); err != nil {
Fail(c, err)
return
}
var out interface{}
if err := api.ipfs.DagGet(hash, &out); err != nil {
api.LogError(c, err, eh.IPFSDagGetError)(http.StatusBadRequest)
return
}
api.l.Infow("ipfs dag get requested", "user", username)
Respond(c, http.StatusOK, gin.H{"response": out})
}
// extendPin is used to extend the lifetime of a pin by a certain number of months
func (api *API) extendPin(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// hash to retrieve dag for
hash := c.Param("hash")
if _, err := gocid.Decode(hash); err != nil {
Fail(c, err)
return
}
// extract needed post forms
forms, missingField := api.extractPostForms(c, "hold_time")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// validate the hold time
holdTimeInt, err := api.validateHoldTime(username, forms["hold_time"])
if err != nil {
Fail(c, err)
return
}
usg, err := api.usage.FindByUserName(username)
if err != nil {
api.LogError(c, err, eh.UserSearchError)
return
}
// find upload
upload, err := api.upm.FindUploadByHashAndUserAndNetwork(username, hash, "public")
if err != nil {
api.LogError(c, err, eh.UploadSearchError)(http.StatusBadRequest)
return
}
// ensure even with pin time extension, it wont breach two year limit
if err := api.ensureLEMaxPinTime(upload, holdTimeInt, usg.Tier); err != nil {
Fail(c, err)
return
}
// calculate cost of hold time extension
cost, _, err := utils.CalculatePinCost(username, hash, holdTimeInt, api.ipfs, api.usage)
if err != nil {
api.LogError(c, err, eh.CostCalculationError)(http.StatusBadRequest)
return
}
// validate they have enough credits
if err := api.validateUserCredits(username, cost); err != nil {
api.LogError(c, err, eh.InvalidBalanceError)(http.StatusPaymentRequired)
return
}
// extend garbage collection period
if err := api.upm.ExtendGarbageCollectionPeriod(username, hash, "public", int(holdTimeInt)); err != nil {
api.LogError(c, err, eh.PinExtendError)(http.StatusBadRequest)
api.refundUserCredits(username, "pin", cost)
return
}
// return
Respond(c, http.StatusOK, gin.H{"response": "pin time successfully extended"})
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_ens.go | api/v2/routes_ens.go | package v2
import (
"errors"
"net/http"
"github.com/RTradeLtd/Temporal/eh"
"github.com/RTradeLtd/Temporal/queue"
"github.com/RTradeLtd/database/v2/models"
"github.com/gin-gonic/gin"
gocid "github.com/ipfs/go-cid"
)
// ClaimENSName is used to claim a username based ens subdomain
func (api *API) ClaimENSName(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
usage, err := api.usage.FindByUserName(username)
if err != nil {
api.LogError(c, err, eh.UserSearchError)(http.StatusBadRequest)
return
}
// prevent processing if account is free tier
if usage.Tier == models.Free || usage.Tier == models.Unverified {
Fail(c, errors.New("free accounts not eligible for ens claim"), http.StatusBadRequest)
return
}
// prevent processing if account is using an already claimed name
if usage.ClaimedENSName {
Fail(c, errors.New("user already claimed ens name"), http.StatusBadRequest)
return
}
if err := api.validateUserCredits(username, 0.45); err != nil {
api.LogError(c, err, eh.InvalidBalanceError)(http.StatusPaymentRequired)
return
}
// mark account as having claimed ens name
if err := api.usage.ClaimENSName(username); err != nil {
api.LogError(c, err, "failed to claim ens name")(http.StatusBadRequest)
api.refundUserCredits(username, "ens", 0.45)
return
}
if err := api.queues.ens.PublishMessage(queue.ENSRequest{
Type: queue.ENSRegisterSubName,
UserName: username,
}); err != nil {
// this fails, unclaim
if err := api.usage.UnclaimENSName(username); err != nil {
api.l.Errorw("failed to unclaim ens name", "user", username, "error", err)
}
api.LogError(c, err, eh.QueuePublishError)(http.StatusBadRequest)
api.refundUserCredits(username, "ens", 0.45)
return
}
api.l.Infow("ens name claim request sent to backend", "user", username)
Respond(c, http.StatusOK, gin.H{
"response": "request is being processed, you will receive an email with an update when finished",
})
}
// UpdateContentHash is used to update the content hash for an ens name
func (api *API) UpdateContentHash(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
usage, err := api.usage.FindByUserName(username)
if err != nil {
api.LogError(c, err, eh.UserSearchError)(http.StatusBadRequest)
return
}
// prevent processing if account is free tier
if usage.Tier == models.Free || usage.Tier == models.Unverified {
Fail(c, errors.New("free accounts not eligible for ens claim"), http.StatusBadRequest)
return
}
// prevent processing if name is unclaimed
if !usage.ClaimedENSName {
Fail(c, errors.New("user has not claimed ens name"), http.StatusBadRequest)
return
}
// extract post forms
forms, missingField := api.extractPostForms(c, "content_hash")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// validate the content is is valid
if _, err := gocid.Decode(forms["content_hash"]); err != nil {
Fail(c, err)
return
}
if err := api.validateUserCredits(username, 0.15); err != nil {
api.LogError(c, err, eh.InvalidBalanceError)(http.StatusPaymentRequired)
return
}
if err := api.queues.ens.PublishMessage(queue.ENSRequest{
Type: queue.ENSUpdateContentHash,
UserName: username,
ContentHash: forms["content_hash"],
}); err != nil {
api.LogError(c, err, eh.QueuePublishError)(http.StatusBadRequest)
api.refundUserCredits(username, "ens", 0.15)
return
}
api.l.Infow("ens content hash update request sent to backend", "user", username)
Respond(c, http.StatusOK, gin.H{
"response": "request is being processed, you will receive an email with an update when finished",
})
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/context_test.go | api/v2/context_test.go | package v2
import (
"net/http"
"testing"
)
func Test_status(t *testing.T) {
type args struct {
i []int
}
tests := []struct {
name string
args args
wantStatus int
}{
{"given code", args{[]int{404}}, 404},
{"not given code", args{[]int{}}, http.StatusBadRequest},
{"given nil", args{nil}, http.StatusBadRequest},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if gotStatus := status(tt.args.i); gotStatus != tt.wantStatus {
t.Errorf("status() = %v, want %v", gotStatus, tt.wantStatus)
}
})
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_rtfsp_usage.go | api/v2/routes_rtfsp_usage.go | package v2
import (
"bytes"
"errors"
"html"
"io"
"io/ioutil"
"net/http"
"time"
"github.com/RTradeLtd/Temporal/eh"
"github.com/RTradeLtd/Temporal/queue"
"github.com/RTradeLtd/crypto/v2"
"github.com/RTradeLtd/database/v2/models"
ipfsapi "github.com/RTradeLtd/go-ipfs-api"
"github.com/RTradeLtd/rtfs/v2"
gocid "github.com/ipfs/go-cid"
"github.com/jinzhu/gorm"
"github.com/gin-gonic/gin"
)
// PinToHostedIPFSNetwork is used to pin content to a private ipfs network
func (api *API) pinToHostedIPFSNetwork(c *gin.Context) {
if !dev {
Fail(c, errors.New("private networks not supported in production, please use https://dev.api.temporal.cloud"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get hash to pin
hash := c.Param("hash")
// ensure validity of hash
if _, err := gocid.Decode(hash); err != nil {
Fail(c, err)
return
}
// extract post forms
forms, missingField := api.extractPostForms(c, "network_name", "hold_time")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// ensure user has access to network
if err = CheckAccessForPrivateNetwork(username, forms["network_name"], api.dbm.DB); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusBadRequest)
return
}
// parse hold time
holdTimeInt, err := api.validateHoldTime(username, forms["hold_time"])
if err != nil {
Fail(c, err)
return
}
upload, err := api.upm.FindUploadByHashAndUserAndNetwork(username, hash, forms["network_name"])
if err == nil || upload != nil {
Respond(c, http.StatusBadRequest, gin.H{"response": alreadyUploadedMessage})
return
}
// create pin message
ip := queue.IPFSPin{
CID: hash,
NetworkName: forms["network_name"],
UserName: username,
HoldTimeInMonths: holdTimeInt,
CreditCost: 0,
JWT: GetAuthToken(c),
FileName: c.PostForm("file_name"),
}
// send message for processing
if err = api.queues.pin.PublishMessage(ip); err != nil {
api.LogError(c, err, eh.QueuePublishError)(http.StatusBadRequest)
return
}
// log and return
api.l.With("user", username).Info("private network pin request sent to backend")
Respond(c, http.StatusOK, gin.H{"response": "content pin request sent to backend"})
}
// AddFileToHostedIPFSNetwork is used to add a file to a private IPFS network via the simple method
func (api *API) addFileToHostedIPFSNetwork(c *gin.Context) {
if !dev {
Fail(c, errors.New("private networks not supported in production, please use https://dev.api.temporal.cloud"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// extract post forms
forms, missingField := api.extractPostForms(c, "network_name", "hold_time")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// verify user has access to private network
if err := CheckAccessForPrivateNetwork(username, forms["network_name"], api.dbm.DB); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)
Fail(c, err)
return
}
// parse hold time
holdTimeInt, err := api.validateHoldTime(username, forms["hold_time"])
if err != nil {
Fail(c, err)
return
}
// fetch the file, and create a handler to interact with it
fileHandler, err := c.FormFile("file")
if err != nil {
// user error, do not log
Fail(c, err)
return
}
fileName := fileHandler.Filename
// validate file size
if err := api.FileSizeCheck(fileHandler.Size); err != nil {
Fail(c, err)
return
}
// open file into memory
file, err := fileHandler.Open()
if err != nil {
api.LogError(c, err, eh.FileOpenError)(http.StatusBadRequest)
return
}
fileBytes, err := ioutil.ReadAll(file)
if err != nil {
Fail(c, err)
return
}
hash, err := api.ipfs.Add(bytes.NewReader(fileBytes), ipfsapi.OnlyHash(true))
if err != nil {
api.LogError(c, err, eh.IPFSAddError)(http.StatusInternalServerError)
return
}
upload, err := api.upm.FindUploadByHashAndUserAndNetwork(username, hash, forms["network_name"])
if err == nil || upload != nil {
Respond(c, http.StatusOK, gin.H{"response": hash, "notice": alreadyUploadedMessage})
return
}
var reader io.Reader
// encrypt file if passphrase is given
if c.PostForm("passphrase") != "" {
// html decode strings
decodedPassPhrase := html.UnescapeString(c.PostForm("passphrase"))
encrypted, err := crypto.NewEncryptManager(decodedPassPhrase).Encrypt(file)
if err != nil {
api.LogError(c, err, eh.EncryptionError)(http.StatusBadRequest)
return
}
reader = bytes.NewReader(encrypted)
} else {
reader = bytes.NewReader(fileBytes)
}
// format a url to connect to for private network
apiURL := api.GetIPFSEndpoint(forms["network_name"])
// connect to private ifps network
ipfsManager, err := rtfs.NewManager(apiURL, GetAuthToken(c), time.Minute*60)
if err != nil {
api.LogError(c, err, eh.IPFSConnectionError)(http.StatusBadRequest)
return
}
// add file to ipfs
resp, err := ipfsManager.Add(reader)
if err != nil {
api.LogError(c, err, eh.IPFSAddError)(http.StatusBadRequest)
return
}
// if this was an encrypted upload we need to update the encrypted upload table
// ipfs cluster pin handles updating the regular uploads table
if c.PostForm("passphrase") != "" {
if _, err := api.ue.NewUpload(username, fileHandler.Filename, "public", resp); err != nil {
api.LogError(c, err, eh.DatabaseUpdateError)(http.StatusBadRequest)
return
}
}
upload, err = api.upm.FindUploadByHashAndUserAndNetwork(
username,
resp,
forms["network_name"],
)
if err != nil && err != gorm.ErrRecordNotFound {
api.LogError(c, err, eh.UploadSearchError)(http.StatusBadRequest)
return
}
if upload == nil {
_, err = api.upm.NewUpload(resp, "file", models.UploadOptions{
NetworkName: forms["network_name"],
Username: username,
HoldTimeInMonths: holdTimeInt,
FileName: fileName,
Size: fileHandler.Size,
})
} else {
_, err = api.upm.UpdateUpload(holdTimeInt, username, resp, forms["network_name"])
}
if err != nil {
api.LogError(c, err, eh.DatabaseUpdateError)(http.StatusBadRequest)
return
}
// log and return
api.l.Infow("simple private ipfs file upload processed", "user", username)
Respond(c, http.StatusOK, gin.H{"response": resp})
}
// IpfsPubSubPublishToHostedIPFSNetwork is used to publish a pubsub message to a private ipfs network
func (api *API) ipfsPubSubPublishToHostedIPFSNetwork(c *gin.Context) {
if !dev {
Fail(c, errors.New("private networks not supported in production, please use https://dev.api.temporal.cloud"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get the topic to publish a message too
topic := c.Param("topic")
// extract post forms
forms, missingField := api.extractPostForms(c, "network_name", "message")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// validate access to private network
if err := CheckAccessForPrivateNetwork(username, forms["network_name"], api.dbm.DB); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusBadRequest)
return
}
// format a url to connect too
apiURL := api.GetIPFSEndpoint(forms["network_name"])
// connect to private ipfs network
manager, err := rtfs.NewManager(apiURL, GetAuthToken(c), time.Minute*60)
if err != nil {
api.LogError(c, err, eh.IPFSConnectionError)(http.StatusBadRequest)
return
}
// publish the actual message
if err = manager.PubSubPublish(topic, forms["message"]); err != nil {
api.LogError(c, err, eh.IPFSPubSubPublishError)(http.StatusBadRequest)
return
}
// log and return
api.l.Infow("private ipfs pub sub message published", "user", username)
Respond(c, http.StatusOK, gin.H{"response": gin.H{"topic": topic, "message": forms["message"]}})
}
// GetObjectStatForIpfsForHostedIPFSNetwork is used to get object stats from a private ipfs network
func (api *API) getObjectStatForIpfsForHostedIPFSNetwork(c *gin.Context) {
if !dev {
Fail(c, errors.New("private networks not supported in production, please use https://dev.api.temporal.cloud"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get the hash to retrieve stats for
hash := c.Param("hash")
if _, err := gocid.Decode(hash); err != nil {
Fail(c, err)
return
}
//get the network to connect to
networkName := c.Param("networkName")
// validate access to network
if err := CheckAccessForPrivateNetwork(username, networkName, api.dbm.DB); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusBadRequest)
return
}
// format a url to connect to
apiURL := api.GetIPFSEndpoint(networkName)
// connect to private ipfs network
manager, err := rtfs.NewManager(apiURL, GetAuthToken(c), time.Minute*60)
if err != nil {
api.LogError(c, err, eh.IPFSConnectionError)(http.StatusBadRequest)
return
}
// get stats for object
stats, err := manager.Stat(hash)
if err != nil {
api.LogError(c, err, eh.IPFSObjectStatError)(http.StatusBadRequest)
return
}
// log and return
api.l.Infow("private ipfs object stat requested", "user", username)
Respond(c, http.StatusOK, gin.H{"response": stats})
}
// CheckLocalNodeForPinForHostedIPFSNetwork is used to check the serving node for a pin
func (api *API) checkLocalNodeForPinForHostedIPFSNetwork(c *gin.Context) {
if !dev {
Fail(c, errors.New("private networks not supported in production, please use https://dev.api.temporal.cloud"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// hash to check pin for
hash := c.Param("hash")
// validate the type of hash
if _, err := gocid.Decode(hash); err != nil {
Fail(c, err)
return
}
// network to connect to
networkName := c.Param("networkName")
// validate access to network
if err := CheckAccessForPrivateNetwork(username, networkName, api.dbm.DB); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusBadRequest)
return
}
// format a url to connect to
apiURL := api.GetIPFSEndpoint(networkName)
// connect to the actual private network
manager, err := rtfs.NewManager(apiURL, GetAuthToken(c), time.Minute*60)
if err != nil {
api.LogError(c, err, eh.IPFSConnectionError)(http.StatusBadRequest)
return
}
// check node for pin
present, err := manager.CheckPin(hash)
if err != nil {
api.LogError(c, err, eh.IPFSPinParseError)(http.StatusBadRequest)
return
}
// log and return
api.l.Infow("private ipfs pin check requested", "user", username)
Respond(c, http.StatusOK, gin.H{"response": present})
}
// GetDagObject is used to retrieve an IPLD object from ipfs
func (api *API) getDagObjectForHostedIPFSNetwork(c *gin.Context) {
if !dev {
Fail(c, errors.New("private networks not supported in production, please use https://dev.api.temporal.cloud"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get the hash to retrieve dag object for
hash := c.Param("hash")
// validate type of hash
if _, err := gocid.Decode(hash); err != nil {
Fail(c, err)
return
}
// get network to connect to
networkName := c.Param("networkName")
// validate the user has access to the private network
if err := CheckAccessForPrivateNetwork(username, networkName, api.dbm.DB); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusBadRequest)
return
}
// format a url to connect to
apiURL := api.GetIPFSEndpoint(networkName)
// connect to the private ipfs network
im, err := rtfs.NewManager(apiURL, GetAuthToken(c), time.Minute*60)
if err != nil {
api.LogError(c, err, eh.IPFSConnectionError)(http.StatusBadRequest)
return
}
// retrieve the dag object
var out interface{}
if err := im.DagGet(hash, &out); err != nil {
api.LogError(c, err, eh.IPFSDagGetError)(http.StatusBadRequest)
return
}
// return
Respond(c, http.StatusOK, gin.H{"response": out})
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/utils.go | api/v2/utils.go | package v2
import (
"bytes"
"errors"
"fmt"
"io/ioutil"
"net/http"
"os"
"strconv"
"time"
"github.com/RTradeLtd/Temporal/eh"
"github.com/RTradeLtd/database/v2/models"
gpaginator "github.com/RTradeLtd/gpaginator"
"github.com/RTradeLtd/swampi"
"github.com/c2h5oh/datasize"
"github.com/gin-gonic/gin"
"github.com/jinzhu/gorm"
jwt "gopkg.in/dgrijalva/jwt-go.v3"
)
const (
// RtcCostUsd is the price of a single RTC in USD
RtcCostUsd = 0.125
)
// pageIt is used to serve paginated responses
func (api *API) pageIt(c *gin.Context, db *gorm.DB, model interface{}) {
page := c.Query("page")
if page == "" {
page = "1"
}
limit := c.Query("limit")
if limit == "" {
limit = "10"
}
pageInt, err := strconv.Atoi(page)
if err != nil {
Fail(c, err, http.StatusBadRequest)
return
}
limitInt, err := strconv.Atoi(limit)
if err != nil {
Fail(c, err, http.StatusBadRequest)
return
}
paged, err := gpaginator.Paging(
&gpaginator.Param{
DB: db,
Page: pageInt,
Limit: limitInt,
// sort results starting with newest first
OrderBy: []string{"created_at DESC"},
},
model,
)
if err != nil {
api.LogError(c, err, "failed to get paged user upload "+err.Error())(http.StatusBadRequest)
return
}
Respond(c, http.StatusOK, gin.H{"response": paged})
}
// CheckAccessForPrivateNetwork checks if a user has access to a private network
func CheckAccessForPrivateNetwork(username, networkName string, db *gorm.DB) error {
um := models.NewUserManager(db)
canUpload, err := um.CheckIfUserHasAccessToNetwork(username, networkName)
if err != nil {
return err
}
if !canUpload {
return errors.New("unauthorized access to private network")
}
return nil
}
// GetIPFSEndpoint is used to construct the api url to connect to
// for private ipfs networks. in the case of dev mode it returns
// an default, non nexus based ipfs api address
func (api *API) GetIPFSEndpoint(networkName string) string {
if dev {
return api.cfg.IPFS.APIConnection.Host + ":" + api.cfg.IPFS.APIConnection.Port
}
return api.cfg.Nexus.Host + ":" + api.cfg.Nexus.Delegator.Port + "/network/" + networkName
}
// FileSizeCheck is used to check and validate the size of the uploaded file
func (api *API) FileSizeCheck(size int64) error {
sizeInt, err := strconv.ParseInt(
api.cfg.API.SizeLimitInGigaBytes,
10,
64,
)
if err != nil {
return err
}
gbInt := int64(datasize.GB.Bytes()) * sizeInt
if size > gbInt {
return errors.New(eh.FileTooBigError)
}
return nil
}
// generateEmailJWTToken is used to generate a jwt token used to validate emails
func (api *API) generateEmailJWTToken(username, verificationString string) (string, error) {
// generate a jwt with claims to verify email
verificationJWT := jwt.NewWithClaims(jwt.SigningMethodHS512, jwt.MapClaims{
"user": username,
"emailVerificationString": verificationString,
"expire": time.Now().Add(time.Hour * 24).UTC().String(),
})
// return a signed version of the jwt
return verificationJWT.SignedString([]byte(api.cfg.API.JWT.Key))
}
func (api *API) verifyEmailJWTToken(jwtString, username string) error {
// parse the jwt for a token
token, err := jwt.Parse(jwtString, func(token *jwt.Token) (interface{}, error) {
// Don't forget to validate the alg is what you expect:
if method, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
return nil, fmt.Errorf("unable to validate signing method: %v", token.Header["alg"])
} else if method != jwt.SigningMethodHS512 {
return nil, errors.New("expect hs512 signing method")
}
// return byte version of signing key
return []byte(api.cfg.JWT.Key), nil
})
// verify jwt was parsed properly
if err != nil {
return err
}
// verify that the token is valid
if !token.Valid {
return errors.New("failed to validate token")
}
// extract claims from token
claims, ok := token.Claims.(jwt.MapClaims)
if !ok {
return errors.New("failed to parse claims")
}
// verify the username matches what we are expected
if claims["user"] != username {
return fmt.Errorf("username from claim does not match expected user of %s", username)
}
// get user model so we can validate the email verification string
user, err := api.um.FindByUserName(username)
if err != nil {
return errors.New(eh.UserSearchError)
}
emailVerificationString, ok := claims["emailVerificationString"].(string)
if !ok {
return errors.New("failed to convert verification token to string")
}
// validate email verification string
if claims["emailVerificationString"] != user.EmailVerificationToken {
return errors.New("failed to validate email verification token")
}
// ensure we can cast claims["expire"] to string type
expireString, ok := claims["expire"].(string)
if !ok {
return errors.New("failed to convert expire value to string")
}
// parse expire string into time.Time
expireTime, err := time.Parse("2006-01-02 15:04:05.999999999 -0700 MST", expireString)
if err != nil {
return err
}
// validate that the token hasn't expired
if time.Now().UTC().Unix() > expireTime.Unix() {
return errors.New("token is expired")
}
// enable email activity
if _, err := api.um.ValidateEmailVerificationToken(username, emailVerificationString); err != nil {
return err
}
// upgrade to free tier if unverified
usg, err := api.usage.FindByUserName(username)
if err != nil {
return err
}
// only update tier if they are an unverified user
// this is to provide backwards compatability where some unverified users
// may already be in a different tier
if usg.Tier == models.Unverified {
api.usage.UpdateTier(username, models.Free)
}
return nil
}
// validateUserCredits is used to validate whether or not a user has enough credits to pay for an action
// and if they do, it is deducted from their account
func (api *API) validateUserCredits(username string, cost float64) error {
availableCredits, err := api.um.GetCreditsForUser(username)
if err != nil {
return err
}
if availableCredits < cost {
return errors.New(eh.InvalidBalanceError)
}
if _, err := api.um.RemoveCredits(username, cost); err != nil {
return err
}
return nil
}
// refundUserCredits is used to trigger a credit refund for a user, in the event of an API level processing failure.
// Note that we do not do any error handling here, instead we will log the information so that we may manually
// remediate the situation
func (api *API) refundUserCredits(username, callType string, cost float64) {
if _, err := api.um.AddCredits(username, cost); err != nil {
api.l.With("user", username, "call_type", callType, "error", err.Error()).Error(eh.CreditRefundError)
}
}
// validateAdminRequest is used to validate whether or not the requesting user is an administrator
func (api *API) validateAdminRequest(username string) error {
isAdmin, err := api.um.CheckIfAdmin(username)
if err != nil {
return err
}
if !isAdmin {
return errors.New(eh.UnAuthorizedAdminAccess)
}
return nil
}
// used to extract needed post forms that should be provided with api calls.
// if the second return parameter, the string is non-empty, this is the name of the field which was missing
// we then use this to fail with a meaningful message
func (api *API) extractPostForms(c *gin.Context, formNames ...string) (map[string]string, string) {
forms := make(map[string]string)
for _, name := range formNames {
value, exists := c.GetPostForm(name)
if !exists {
return nil, name
}
if value == "" { // prevent empty values counting as valid
return nil, name
}
forms[name] = value
}
return forms, ""
}
// ValidateHoldTime is used to perform parsing of requested hold times,
// returning an int64 type of the provided hold time
func (api *API) validateHoldTime(username, holdTime string) (int64, error) {
var (
// 1 year
freeHoldTimeLimitInMonths int64 = 12
// two years
nonFreeHoldTimeLimitInMonths int64 = 24
)
holdTimeInt, err := strconv.ParseInt(holdTime, 10, 64)
if err != nil {
return 0, err
}
usageTier, err := api.usage.FindByUserName(username)
if err != nil {
return 0, err
}
switch usageTier.Tier {
case models.Free, models.Unverified:
if holdTimeInt > freeHoldTimeLimitInMonths {
return 0, errors.New("free accounts are limited to maximum hold times of 12 month")
}
default:
if holdTimeInt > nonFreeHoldTimeLimitInMonths {
return 0, errors.New("non free accounts are limited to a maximum hold time of 24 months")
}
}
return holdTimeInt, nil
}
func (api *API) ensureLEMaxPinTime(upload *models.Upload, holdTime int64, tier models.DataUsageTier) error {
var limit time.Time
switch tier {
case models.Free, models.Unverified:
limit = time.Now().AddDate(1, 0, 0)
case models.Paid, models.Partner, models.WhiteLabeled:
limit = time.Now().AddDate(2, 0, 0)
default:
return errors.New("invalid usage tier")
}
if upload.GarbageCollectDate.AddDate(0, int(holdTime), 0).After(limit) {
return errors.New(eh.MaxHoldTimeError)
}
return nil
}
func (api *API) getCMCKey() string {
if os.Getenv("CMC_API") != "" {
return os.Getenv("CMC_API")
}
return api.cfg.APIKeys.CoinMarketCap
}
func (api *API) getCaptchaKey() string {
if os.Getenv("RECAPTCHA_KEY") != "" {
return os.Getenv("RECAPTCHA_KEY")
}
return api.cfg.APIKeys.ReCAPTCHA
}
// swarmUpload allows upload a file to multiple swarm backends
// and is a poor mans way of replicating data amongst multiple swarm nodes
func (api *API) swarmUpload(data []byte, isTar bool) (string, error) {
var hashes []string
for _, endpoint := range api.swarmEndpoints {
resp, err := endpoint.Send(swampi.SingleFileUpload, bytes.NewReader(data), map[string][]string{
"content-type": {swampi.SingleFileUpload.ContentType(isTar)},
})
if err != nil {
return "", err
}
responseData, err := ioutil.ReadAll(resp.Body)
if err != nil {
resp.Body.Close()
return "", err
}
hashes = append(hashes, string(responseData))
resp.Body.Close()
}
if len(hashes) == 0 {
return "", errors.New("failed to upload any data")
}
var found = make(map[string]bool)
for i, hash := range hashes {
if i == 0 {
found[hash] = true
}
if !found[hash] {
return "", fmt.Errorf("found mismatching hashes %s", hashes)
}
}
return hashes[0], nil
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_utils.go | api/v2/routes_utils.go | package v2
import (
"bytes"
"context"
"errors"
"fmt"
"net/http"
"os"
"time"
"github.com/RTradeLtd/Temporal/eh"
"github.com/RTradeLtd/Temporal/queue"
"github.com/RTradeLtd/crypto/v2"
"github.com/RTradeLtd/database/v2/models"
mnemonics "github.com/RTradeLtd/entropy-mnemonics"
pb "github.com/RTradeLtd/grpc/krab"
"github.com/RTradeLtd/rtfs/v2"
"github.com/RTradeLtd/rtfs/v2/beam"
"github.com/ezzarghili/recaptcha-go"
"github.com/gin-gonic/gin"
gocid "github.com/ipfs/go-cid"
)
// SystemsCheck is a basic check of system integrity
func (api *API) SystemsCheck(c *gin.Context) {
hostname, err := os.Hostname()
if err != nil {
api.LogError(c, err, eh.HostNameNotFoundError)(http.StatusInternalServerError)
return
}
c.Writer.Header().Set("X-API-Hostname", hostname)
Respond(c, http.StatusOK, gin.H{
"version": api.version,
"response": "systems online",
})
}
// BeamContent is used to beam content from one network to another
func (api *API) beamContent(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// extract post forms
forms, missingField := api.extractPostForms(c, "source_network", "destination_network", "content_hash")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
var (
source, dest string
net1Conn *rtfs.IpfsManager
)
// validate the network to connect to
if forms["source_network"] == "public" {
source = api.cfg.IPFS.APIConnection.Host + ":" + api.cfg.IPFS.APIConnection.Port
net1Conn, err = rtfs.NewManager(source, "", time.Minute*60)
} else {
// if non public network, validate user has access
if err := CheckAccessForPrivateNetwork(username, forms["source_network"], api.dbm.DB); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusBadRequest)
return
}
// format a url to connect to
source = api.GetIPFSEndpoint(forms["source_network"])
// connect to the actual network
net1Conn, err = rtfs.NewManager(source, GetAuthToken(c), time.Minute*60)
}
// ensure connection was successful
if err != nil {
api.LogError(c, err, eh.IPFSConnectionError)(http.StatusBadRequest)
return
}
// validate the network to connect to
if forms["destination_network"] == "public" {
dest = api.cfg.IPFS.APIConnection.Host + ":" + api.cfg.IPFS.APIConnection.Port
} else {
// non public network, validate user has access
if err := CheckAccessForPrivateNetwork(username, forms["destination_network"], api.dbm.DB); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusBadRequest)
return
}
dest = api.GetIPFSEndpoint(forms["destination_network"])
}
// perform optional encryption of content
if passphrase := c.PostForm("passphrase"); passphrase != "" {
// encrypt the file file
data, err := net1Conn.Cat(forms["content_hash"])
if err != nil {
api.LogError(c, err, eh.IPFSCatError)(http.StatusBadRequest)
return
}
// re-add the encrypted content to the source network
newCid, err := net1Conn.Add(bytes.NewReader(data))
if err != nil {
api.LogError(c, err, eh.IPFSAddError)(http.StatusBadRequest)
return
}
// update the content hash to beam
forms["content_hash"] = newCid
}
// create our dual network connection
laserBeam, err := beam.NewLaser(source, dest, GetAuthToken(c))
if err != nil {
api.LogError(c, err, "failed to initialize laser beam")(http.StatusBadRequest)
return
}
// initiate the content transfer
if err := laserBeam.BeamFromSource(forms["content_hash"]); err != nil {
api.LogError(c, err, "failed to tranfer content")(http.StatusBadRequest)
return
}
// return
Respond(c, http.StatusOK, gin.H{"response": gin.H{"status": "content transferred", "content_hash": forms["content_hash"]}})
}
// ExportKey is used to export an ipfs key as a mnemonic phrase
func (api *API) exportKey(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get the key name
keyName := c.Param("name")
// validate user owns key name
if owns, err := api.um.CheckIfKeyOwnedByUser(username, keyName); err != nil {
api.LogError(c, err, eh.KeySearchError)(http.StatusBadRequest)
return
} else if !owns {
api.LogError(c, errors.New(eh.KeyUseError), eh.KeyUseError)(http.StatusBadRequest)
return
}
// get private key from krab keystore
resp, err := api.keys.kb1.GetPrivateKey(context.Background(), &pb.KeyGet{Name: keyName})
if err != nil {
api.LogError(c, err, eh.KeyExportError)(http.StatusBadRequest)
return
}
// convert private key to mnemonic phrase
phrase, err := mnemonics.ToPhrase(resp.PrivateKey, mnemonics.English)
if err != nil {
api.LogError(c, err, eh.KeyExportError)(http.StatusBadRequest)
return
}
// after successful parsing delete key from krab primary
if resp, err := api.keys.kb1.DeletePrivateKey(context.Background(), &pb.KeyDelete{Name: keyName}); err != nil {
api.l.Warnw("failed to delete key from primary krab", "error", err.Error())
} else if resp.Status != "private key deleted" {
api.l.Warnw("bad status from primary krab key delete", "status", resp.Status)
}
// only delete from secondary krab keystore if we arent in dev mode
if !dev {
// after successful parsing delete key from krab fallback
if resp, err := api.keys.kb2.DeletePrivateKey(context.Background(), &pb.KeyDelete{Name: keyName}); err != nil {
api.l.Warnw("failed to delete key from backup krab", "error", err.Error())
} else if resp.Status != "private key deleted" {
api.l.Warnw("bad status from backup krab key delete", "status", resp.Status)
}
}
// get key id from database
keyID, err := api.um.GetKeyIDByName(username, keyName)
if err != nil {
api.LogError(c, err, eh.KeySearchError)(http.StatusBadRequest)
return
}
// remove key id from database
if err := api.um.RemoveIPFSKeyForUser(username, keyName, keyID); err != nil {
api.LogError(c, err, "failed to remove key from database")(http.StatusBadRequest)
return
}
// decrease key count
if err := api.usage.ReduceKeyCount(username, 1); err != nil {
api.LogError(c, err, "failed to decrease key count")(http.StatusBadRequest)
return
}
// return
Respond(c, http.StatusOK, gin.H{"response": phrase})
}
// downloadContentHash is used to download content from a private ipfs network
func (api *API) downloadContentHash(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get the content hash that is to be downloaded
contentHash := c.Param("hash")
// ensure it's a valid content hash
if _, err := gocid.Decode(contentHash); err != nil {
Fail(c, err)
return
}
// get the network name, default to public if not specified
networkName := c.PostForm("network_name")
var manager rtfs.Manager
if networkName == "" {
networkName = "public"
manager = api.ipfs
} else if networkName != "public" {
// validate user access to network
if err := CheckAccessForPrivateNetwork(username, networkName, api.dbm.DB); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusBadRequest)
return
}
// retrieve api url
apiURL := api.GetIPFSEndpoint(networkName)
// initialize our connection to IPFS
manager, err = rtfs.NewManager(apiURL, GetAuthToken(c), time.Minute*60)
if err != nil {
api.LogError(c, err, eh.IPFSConnectionError)(http.StatusBadRequest)
return
}
}
// fetch the specified content type from the user
contentType := c.PostForm("content_type")
// if not specified, provide a default
if contentType == "" {
contentType = "application/octet-stream"
}
// get any extra headers the user might want
exHeaders := c.PostFormArray("extra_headers")
// read the contents of the file
contents, err := manager.Cat(contentHash)
if err != nil {
api.LogError(c, err, eh.IPFSCatError)(http.StatusBadRequest)
return
}
reader := bytes.NewReader(contents)
size := len(contents)
// decrypt Temporal-encrypted content if key is provided
decryptKey := c.PostForm("decrypt_key")
if decryptKey != "" {
decrypted, err := crypto.NewEncryptManager(decryptKey).Decrypt(reader)
if err != nil {
Fail(c, err)
return
}
size = len(decrypted)
reader = bytes.NewReader(decrypted)
}
// parse extra headers if there are any
extraHeaders := make(map[string]string)
// only process if there is actual data to process
if len(exHeaders) > 0 {
// the array must be of equal length, as a header has two parts
// the name of the header, and its value
if len(exHeaders)%2 != 0 {
FailWithMessage(c, "extra_headers post form is not even in length")
return
}
// parse through the available headers
for i := 0; i < len(exHeaders); i += 2 {
if i+1 < len(exHeaders) {
header := exHeaders[i]
value := exHeaders[i+1]
extraHeaders[header] = value
}
}
}
api.l.Infow("ipfs content download served", "user", username)
c.DataFromReader(200, int64(size), contentType, reader, extraHeaders)
}
func (api *API) handleUserCreate(c *gin.Context, forms map[string]string, createErr error) {
if createErr != nil {
switch createErr.Error() {
case eh.DuplicateEmailError:
api.LogError(
c,
createErr,
eh.DuplicateEmailError,
"email",
forms["email_address"])(http.StatusBadRequest)
return
case eh.DuplicateUserNameError:
api.LogError(
c,
createErr,
eh.DuplicateUserNameError,
"username",
forms["username"])(http.StatusBadRequest)
return
default:
api.LogError(
c,
createErr,
eh.UserAccountCreationError)(http.StatusBadRequest)
return
}
}
// generate a random token to validate email
user, err := api.um.GenerateEmailVerificationToken(forms["username"])
if err != nil {
api.LogError(c, err, eh.EmailTokenGenerationError)(http.StatusBadRequest)
return
}
// generate a jwt used to trigger email validation
token, err := api.generateEmailJWTToken(user.UserName, user.EmailVerificationToken)
if err != nil {
api.LogError(c, err, "failed to generate email verification jwt")
return
}
var url string
// format the url the user clicks to activate email
if dev {
url = fmt.Sprintf(
"https://dev.api.temporal.cloud/v2/account/email/verify/%s/%s",
user.UserName, token,
)
} else {
url = fmt.Sprintf(
"https://api.temporal.cloud/v2/account/email/verify/%s/%s",
user.UserName, token,
)
}
// format a link tag
link := fmt.Sprintf("<a href=\"%s\">link</a>", url)
emailSubject := fmt.Sprintf(
"%s Welcome To Temporal 🌌 Read This For Crucial Getting Started Tips", forms["organization_name"],
)
// build email message
es := queue.EmailSend{
Subject: emailSubject,
Content: fmt.Sprintf(
"%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
"Thanks for signing up with Temporal, before you get started it's important we discuss our pinning system.\n",
"When uploading to Temporal you must specify a \"hold time\" which tells our system how long your data should be around for.\n",
"When you're using Temporal via the playground, or the API directly you can configure this for up to 24 months with paid accounts, and up to 12 months for free accounts.\n",
"Temporal’s free tier offers 3GB of storage on the house, paid tier rates are just $0.07/GB and partner tier rates are $0.05/GB.\n",
"<br>",
"<br>",
"When using Temporal through third-party implementations like our IPFS HTTP API reverse proxy, or the ENS management app, we use a default hold time of 12 months for free users and 1 month for paid users.\n",
"We use 1 month for paid users because being in the paid tier means you have to pay for the data consumption and we don't want to overcharge paid users.\n",
"For example if you used the ENS management app to upload your website, and want it to stick around for longer than the default duration you need to extend the pin.\n",
"Pin extension can be done via the <a href=\"https://play2.temporal.cloud\">Temporal Playground</a> or via the API.\n",
"<br>",
"<br>",
"Lastly let's talk about emails! We try our best to not spam your inbox, so we limit emails to a few things: payment notifications, pin expiration warnings, password/username retrieval and processing failures.\n",
"But before we do this, you must validate your email. Additionally before validating your email, you are in the 'unverified' tier which is limited to 100MB of data consumption. Email verification is now mandatory\n",
"To validate your email, just click the following "+link+"\n",
"<br>",
"<br>",
"Questions, comments, concerns, or just feeling talkative? Join us on Telegram where you can receive live support and updates: <a href=\"https://t.me/RTradeTEMPORAL\">click here</a>\n",
"<br>",
"<br>",
"Thanks for signing up!",
),
ContentType: "text/html",
UserNames: []string{user.UserName},
Emails: []string{user.EmailAddress},
}
// send email message to queue for processing
if err = api.queues.email.PublishMessage(es); err != nil {
api.LogError(c, err, eh.QueuePublishError)(http.StatusBadRequest)
return
}
// remove hashed password from output
user.HashedPassword = "scrubbed"
// remove the verification token from output
user.EmailVerificationToken = "scrubbed"
// format a custom response that includes the user model
// and an additional status field
var status string
if dev {
status = fmt.Sprintf(
"by continuing to use this service you agree to be bound by the following api terms and service %s",
devTermsAndServiceURL,
)
} else {
status = fmt.Sprintf(
"by continuing to use this service you agree to be bound by the following api terms and service %s",
prodTermsAndServiceURL,
)
}
// return
Respond(c, http.StatusOK, gin.H{"response": struct {
*models.User
Status string
}{
user, status,
},
})
}
func (api *API) verifyCaptcha(c *gin.Context) {
err := api.captcha.VerifyWithOptions(
c.PostForm("g-recaptcha-response"),
// require a threshold of 0.8, default is 0.5
recaptcha.VerifyOption{Threshold: 0.8},
)
if err != nil {
Fail(c, errors.New("captcha validation failed"))
}
Respond(c, http.StatusOK, gin.H{"response": "captcha validation succeeded"})
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_ens_test.go | api/v2/routes_ens_test.go | package v2
import (
"net/url"
"testing"
"github.com/RTradeLtd/Temporal/mocks"
"github.com/RTradeLtd/config/v2"
)
func Test_API_Routes_ENS(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
// instantiate the test api
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
// test update content hash (fail, unclaimed)
var resp interface{}
urlValues := url.Values{}
urlValues.Add("content_hash", hash)
if err := sendRequest(
api, "POST", "/v2/ens/update", 400, nil, urlValues, &resp,
); err != nil {
t.Fatal(err)
}
// test claiming name (200)
if err := sendRequest(
api, "POST", "/v2/ens/claim", 200, nil, nil, &resp,
); err != nil {
t.Fatal(err)
}
// test updating content hash (200)
urlValues = url.Values{}
urlValues.Add("content_hash", hash)
if err := sendRequest(
api, "POST", "/v2/ens/update", 200, nil, urlValues, &resp,
); err != nil {
t.Fatal(err)
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/api_test.go | api/v2/api_test.go | package v2
import (
"context"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"testing"
"time"
"go.uber.org/zap/zaptest"
"github.com/RTradeLtd/Temporal/mocks"
"github.com/RTradeLtd/Temporal/queue"
"github.com/RTradeLtd/Temporal/rtfscluster"
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/database/v2"
"github.com/RTradeLtd/database/v2/models"
"github.com/RTradeLtd/rtfs/v2"
"github.com/c2h5oh/datasize"
"github.com/gin-gonic/gin"
"github.com/jinzhu/gorm"
"github.com/streadway/amqp"
)
const (
tooManyCredits = 10.9999997e+07
testUser = "testuser"
testSwarmKey = "7fcb5a1b19bdda69da7307162e3becd2d6bd485d5aad778470b305f3f306cf79"
testBootstrapPeer1 = "/ip4/172.218.49.115/tcp/5002/ipfs/Qmf964tiE9JaxqntDsSBGasD4aaofPQtfYZyMSJJkRrVTQ"
testBootstrapPeer2 = "/ip4/192.168.1.249/tcp/4001/ipfs/QmXuGVPzEz2Ji7g54AYyqoobRJNHqtnrfaEceAes2bTKMh"
testPIN = "QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv"
testPIN2 = "QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn"
)
var (
hash = "QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv"
authHeader string
)
type apiResponse struct {
Code int `json:"code"`
Response string `json:"response"`
}
type loginResponse struct {
Expire string `json:"expire"`
Token string `json:"token"`
}
type boolAPIResponse struct {
Code int `json:"code"`
Response bool `json:"bool"`
}
type mapAPIResponse struct {
Code int `json:"code"`
Response gin.H `json:"response"`
}
type interfaceAPIResponse struct {
Code int `json:"code"`
Response interface{} `json:"response"`
}
type floatAPIResponse struct {
Code int `json:"code"`
Response float64 `json:"response"`
}
type stringSliceAPIResponse struct {
Code int `json:"code"`
Response []string `json:"response"`
}
type searchAPIResponse struct {
Code int `json:"code"`
Response []models.Upload `json:"response"`
}
// sendRequestPaged is a helper method used to handle sending an api request with paged responses
// If `out` is not nil, the response from the API will be unmarshaled into `out`.
func sendRequestPaged(
api *API,
method, url string,
wantStatus int,
body io.Reader,
urlValues url.Values,
out interface{},
) error {
testRecorder := httptest.NewRecorder()
req := httptest.NewRequest(method, url, body)
req.Header.Add("Authorization", authHeader)
for k, v := range urlValues {
for _, kv := range v {
req.URL.Query().Add(k, kv)
}
}
api.r.ServeHTTP(testRecorder, req)
if testRecorder.Code != wantStatus {
bodyBytes, err := ioutil.ReadAll(testRecorder.Result().Body)
if err != nil {
api.l.Error(err)
}
fmt.Printf("reason for failure: %+v\n", string(bodyBytes))
return fmt.Errorf("received status %v expected %v from api call %s", testRecorder.Code, wantStatus, url)
}
if out == nil {
return nil
}
// unmarshal the response
bodyBytes, err := ioutil.ReadAll(testRecorder.Result().Body)
if err != nil {
return err
}
return json.Unmarshal(bodyBytes, out)
}
// sendRequest is a helper method used to handle sending an api request
// If `out` is not nil, the response from the API will be unmarshaled into `out`.
func sendRequest(api *API, method, url string, wantStatus int, body io.Reader, urlValues url.Values, out interface{}) error {
testRecorder := httptest.NewRecorder()
req := httptest.NewRequest(method, url, body)
req.Header.Add("Authorization", authHeader)
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
if testRecorder.Code != wantStatus {
bodyBytes, err := ioutil.ReadAll(testRecorder.Result().Body)
if err != nil {
api.l.Error(err)
}
fmt.Printf("reason for failure: %+v\n", string(bodyBytes))
return fmt.Errorf("received status %v expected %v from api call %s", testRecorder.Code, wantStatus, url)
}
if out == nil {
return nil
}
// unmarshal the response
bodyBytes, err := ioutil.ReadAll(testRecorder.Result().Body)
if err != nil {
return err
}
return json.Unmarshal(bodyBytes, out)
}
func setupAPI(t *testing.T, fakeLens *mocks.FakeLensV2Client, fakeOrch *mocks.FakeServiceClient, fakeSigner *mocks.FakeSignerClient, fakeBchWallet *mocks.FakeWalletServiceClient, cfg *config.TemporalConfig, db *gorm.DB) (*API, error) {
dev = true
// setup connection to ipfs-node-1
im, err := rtfs.NewManager(
cfg.IPFS.APIConnection.Host+":"+cfg.IPFS.APIConnection.Port,
"", time.Minute*60,
)
if err != nil {
return nil, err
}
imCluster, err := rtfscluster.Initialize(
context.Background(),
cfg.IPFSCluster.APIConnection.Host,
cfg.IPFSCluster.APIConnection.Port,
)
if err != nil {
return nil, err
}
// create our test api
testRecorder := httptest.NewRecorder()
_, engine := gin.CreateTestContext(testRecorder)
logger := zaptest.NewLogger(t).Sugar()
clients := Clients{
Lens: fakeLens,
Orch: fakeOrch,
Signer: fakeSigner,
BchWallet: fakeBchWallet,
}
api, err := new(cfg, engine, logger, clients, im, imCluster, false)
if err != nil {
return nil, err
}
// setup api routes
if err = api.setupRoutes(true); err != nil {
return nil, err
}
return api, nil
}
// this does a quick initial test of the API, and setups a second user account to use for testing
func Test_API_Setup(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
type args struct {
method string
call string
username string
password string
email string
}
// register calls
tests := []struct {
name string
args args
wantCode int
}{
{"Register-testuser2", args{"POST", "/v2/auth/register", "testuser2", "password123!@#$%^&&**(!@#!", "testuser@example.org"}, 200},
{"Register-Email-Fail", args{"POST", "/v2/auth/register", "testuer3", "password123", "testuser+test22@example.org"}, 400},
{"Register-DuplicateUser", args{"POST", "/v2/auth/register", "testuser2", "password123", "testuser+user22example.org"}, 400},
{"Register-DuplicateEmail", args{"POST", "/v2/auth/register", "testuser333", "password123", "testuser@example.org"}, 400},
{"Register-BadUserName", args{"POST", "/v2/auth/register", "testuser333@", "password123", "testusernotafailure@example.org"}, 400},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// register user account
// /v2/auth/register
var interfaceAPIResp interfaceAPIResponse
urlValues := url.Values{}
urlValues.Add("username", tt.args.username)
urlValues.Add("password", tt.args.password)
urlValues.Add("email_address", tt.args.email)
if err := sendRequest(
api, "POST", "/v2/auth/register", tt.wantCode, nil, urlValues, &interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if interfaceAPIResp.Code != tt.wantCode {
t.Fatalf("bad api status code from %s", tt.args.call)
}
})
}
// login calls
tests = []struct {
name string
args args
wantCode int
}{
// this test should fail due to invalid email
{"Login-testuser2", args{"POST", "/v2/auth/login", "testuser2", "password123!@#$%^&&**(!@#!", ""}, 401},
{"Login-testuser", args{"POST", "/v2/auth/login", "testuser", "admin", ""}, 200},
// tests login via the email instead of using
{"Login-TestUser-Email", args{"POST", "/v2/auth/login", "test@email.com", "admin", ""}, 200},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
testRecorder := httptest.NewRecorder()
req := httptest.NewRequest(
tt.args.method,
tt.args.call,
strings.NewReader(fmt.Sprintf("{\n \"username\": \"%s\",\n \"password\": \"%s\"\n}", tt.args.username, tt.args.password)),
)
api.r.ServeHTTP(testRecorder, req)
if testRecorder.Code != tt.wantCode {
t.Fatalf("bad http status code from %s. got %v, want %v", tt.args.call, testRecorder.Code, tt.wantCode)
}
bodBytes, err := ioutil.ReadAll(testRecorder.Result().Body)
if err != nil {
t.Fatal(err)
}
// if we're logging in with the account used for testing the v2 api, update our authorization header
if tt.args.username == "testuser" || tt.args.email == "test@email.com" {
var loginResp loginResponse
if err = json.Unmarshal(bodBytes, &loginResp); err != nil {
t.Fatal(err)
}
authHeader = "Bearer " + loginResp.Token
}
})
}
if str := api.GetIPFSEndpoint("networkName"); str == "" {
t.Fatal("failed to construct api endpoint")
}
}
func Test_API_Routes_Misc(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
// test systems check route
// //v2/systems/check
var apiResp apiResponse
if err := sendRequest(
api, "GET", "/v2/systems/check", 200, nil, nil, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 200 {
t.Fatal("bad api status code from /v2/systems/check")
}
if apiResp.Response != "systems online" {
t.Fatal("bad system status recovered")
}
// test systems statistics
// /v2/statistics/stats
if err := sendRequest(
api, "GET", "/v2/statistics/stats", 200, nil, nil, nil,
); err != nil {
t.Fatal(err)
}
// test token refresh
// /v2/auth/refresh
if err := sendRequest(
api, "GET", "/v2/auth/refresh", 200, nil, nil, nil,
); err != nil {
t.Fatal(err)
}
}
func Test_Utils(t *testing.T) {
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
logger := zaptest.NewLogger(t).Sugar()
clients := Clients{
Lens: &mocks.FakeLensV2Client{},
Orch: &mocks.FakeServiceClient{},
Signer: &mocks.FakeSignerClient{},
}
api, err := Initialize(context.Background(), cfg, "", Options{DevMode: true, DebugLogging: true}, clients, logger)
if err != nil {
t.Fatal(err)
}
if err := api.FileSizeCheck(int64(datasize.GB.Bytes() * 1)); err != nil {
t.Fatal(err)
}
if err := api.FileSizeCheck(int64(datasize.GB.Bytes() * 1)); err != nil {
t.Fatal(err)
}
if err := api.FileSizeCheck(int64(datasize.GB.Bytes() * 10)); err == nil {
t.Fatal("error expected")
}
type args struct {
paymentType string
blockchain string
}
tests := []struct {
name string
args args
wantErr bool
}{
{"ETHFail", args{"ETH", "ETH"}, true},
{"ETHPass", args{"eth", "ethereum"}, false},
{"RTCFail", args{"RTC", "bitcoinz"}, true},
{"RTCPass", args{"rtc", "ethereum"}, false},
{"BTCFail", args{"BTC", "BTC"}, true},
{"BTCPass", args{"btc", "bitcoin"}, false},
{"LTCFail", args{"LTC", "LTC"}, true},
{"LTCPass", args{"ltc", "litecoin"}, false},
{"XMRFail", args{"XMR", "XMR"}, true},
{"XMRPass", args{"xmr", "monero"}, false},
{"DASHFail", args{"DASH", "DASH"}, true},
{"DASHPass", args{"dash", "dash"}, false},
{"BitcoinCashPass", args{"bch", "bitcoin-cash"}, false},
{"BitcoinCashFail", args{"bhc", "bticoin-csah"}, true},
{"InvalidCoinFail", args{"biiiitcoooonnneeeeeeecccct", "biiiitcoooonnneeeeeeecccct"}, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if _, err := api.getUSDValue(tt.args.paymentType); (err != nil) != tt.wantErr {
t.Errorf("getUSDValue() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
if err := api.validateUserCredits(testUser, 1); err != nil {
t.Fatal(err)
}
if err := api.validateUserCredits(testUser, tooManyCredits); err == nil {
t.Fatal("error expected")
}
if err := api.validateAdminRequest(testUser); err != nil {
t.Fatal(err)
}
if err := api.validateAdminRequest("notareallaccount"); err == nil {
t.Fatal("error expected")
}
user, err := api.um.FindByUserName(testUser)
if err != nil {
t.Fatal(err)
}
previousCreditAmount := user.Credits
api.refundUserCredits(testUser, "ipfs-pin", 10)
user, err = api.um.FindByUserName(testUser)
if err != nil {
t.Fatal(err)
}
if user.Credits != previousCreditAmount+10 {
t.Fatal("failed to refund credits")
}
recorder := httptest.NewRecorder()
testCtx, _ := gin.CreateTestContext(recorder)
urlValues := url.Values{}
urlValues.Add("suchkey", "muchvalue")
testCtx.Request = &http.Request{PostForm: urlValues}
forms, missingField := api.extractPostForms(testCtx, "suchkey")
if missingField != "" {
t.Fatal("failed to extract post forms")
}
if forms["suchkey"] != "muchvalue" {
t.Fatal("failed to extract proper postform")
}
}
func Test_API_Initialize_Cluster_Failure(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
logger := zaptest.NewLogger(t).Sugar()
// setup an unreachable cluster host
cfg.IPFSCluster.APIConnection.Host = "10.255.255.255"
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
clients := Clients{
Lens: fakeLens,
Orch: fakeOrch,
Signer: fakeSigner,
}
if _, err := Initialize(context.Background(), cfg, "", Options{DevMode: true, DebugLogging: true}, clients, logger); err == nil {
t.Fatal("expected error")
}
}
func Test_API_Initialize_IPFS_Failure(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
logger := zaptest.NewLogger(t).Sugar()
// setup an unreachable cluster host
cfg.IPFS.APIConnection.Host = "notarealip"
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
clients := Clients{
Lens: fakeLens,
Orch: fakeOrch,
Signer: fakeSigner,
}
if _, err := Initialize(context.Background(), cfg, "", Options{DevMode: true, DebugLogging: true}, clients, logger); err == nil {
t.Fatal("expected error")
}
}
func Test_API_Initialize_Setup_Routes_Failure(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
logger := zaptest.NewLogger(t).Sugar()
// setup an invalid connection limit
cfg.API.Connection.Limit = "notanumber"
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
clients := Clients{
Lens: fakeLens,
Orch: fakeOrch,
Signer: fakeSigner,
}
if _, err := Initialize(context.Background(), cfg, "", Options{DevMode: true, DebugLogging: true}, clients, logger); err == nil {
t.Fatal("expected error")
}
}
func Test_API_Initialize_Kaas_Failure(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
logger := zaptest.NewLogger(t).Sugar()
// setup an invalid connection limit
cfg.Services.Krab.TLS.CertPath = "/root"
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
clients := Clients{
Lens: fakeLens,
Orch: fakeOrch,
Signer: fakeSigner,
}
if _, err := Initialize(context.Background(), cfg, "", Options{DevMode: true, DebugLogging: true}, clients, logger); err == nil {
t.Fatal("expected error")
}
}
func Test_API_Initialize_Queue_Failure(t *testing.T) {
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
logger := zaptest.NewLogger(t).Sugar()
cfg.RabbitMQ.URL = "notarealip"
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
clients := Clients{
Lens: fakeLens,
Orch: fakeOrch,
Signer: fakeSigner,
}
if _, err := Initialize(context.Background(), cfg, "", Options{DevMode: true, DebugLogging: true}, clients, logger); err == nil {
t.Fatal("expected error")
}
}
func Test_API_Initialize_Main_Network(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
logger := zaptest.NewLogger(t).Sugar()
dev = false
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
clients := Clients{
Lens: fakeLens,
Orch: fakeOrch,
Signer: fakeSigner,
}
api, err := Initialize(context.Background(), cfg, "", Options{DevMode: true, DebugLogging: true}, clients, logger)
if err != nil {
t.Fatal(err)
}
api.Close()
}
func Test_API_Initialize_ListenAndServe(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
type args struct {
certFilePath string
keyFilePath string
}
tests := []struct {
name string
args args
wantErr bool
}{
{"NoTLS", args{"", ""}, false},
{"TLS", args{"../../testenv/certs/api.cert", "../../testenv/certs/api.key"}, false},
{"TLS-Missing-Cert", args{"../../README.md", "../../testenv/certs/api.key"}, true},
{"TLS-Missing-Key", args{"../../testenv/certs/api.cert", "../../README.md"}, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
logger := zaptest.NewLogger(t).Sugar()
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
clients := Clients{
Lens: fakeLens,
Orch: fakeOrch,
Signer: fakeSigner,
}
api, err := Initialize(context.Background(), cfg, "", Options{DevMode: true, DebugLogging: true}, clients, logger)
if err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithTimeout(context.Background(), time.Second*2)
defer cancel()
defer api.Close()
if tt.args.certFilePath != "" {
err = api.ListenAndServe(ctx, "127.0.0.1:6700", &TLSConfig{tt.args.certFilePath, tt.args.keyFilePath})
} else {
err = api.ListenAndServe(ctx, "127.0.0.1:6701", nil)
}
if (err != nil) != tt.wantErr {
t.Fatalf("ListenAndServer() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestAPI_HandleQueuError_Success(t *testing.T) {
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
logger := zaptest.NewLogger(t).Sugar()
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
clients := Clients{
Lens: fakeLens,
Orch: fakeOrch,
Signer: fakeSigner,
}
api, err := Initialize(context.Background(), cfg, "", Options{DevMode: true, DebugLogging: true}, clients, logger)
if err != nil {
t.Fatal(err)
}
go func() {
if err := api.ListenAndServe(context.Background(), "127.0.0.1:6799", &TLSConfig{"../../testenv/certs/api.cert", "../../testenv/certs/api.key"}); err != nil && err != http.ErrServerClosed {
t.Error(err)
}
}()
type args struct {
queueType queue.Queue
}
tests := []struct {
name string
args args
}{
{queue.IpfsClusterPinQueue.String(), args{queue.IpfsClusterPinQueue}},
{queue.EmailSendQueue.String(), args{queue.EmailSendQueue}},
{queue.IpnsEntryQueue.String(), args{queue.IpnsEntryQueue}},
{queue.IpfsPinQueue.String(), args{queue.IpfsPinQueue}},
{queue.IpfsKeyCreationQueue.String(), args{queue.IpfsKeyCreationQueue}},
{queue.DashPaymentConfirmationQueue.String(), args{queue.DashPaymentConfirmationQueue}},
{queue.EthPaymentConfirmationQueue.String(), args{queue.EthPaymentConfirmationQueue}},
{queue.BitcoinCashPaymentConfirmationQueue.String(), args{queue.BitcoinCashPaymentConfirmationQueue}},
}
// declare an error to use for testing
amqpErr := &amqp.Error{Code: 400, Reason: "test", Server: true, Recover: false}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// test ListenAndServe queue function handling
switch tt.args.queueType {
case queue.IpfsClusterPinQueue:
api.queues.cluster.ErrCh <- amqpErr
case queue.EmailSendQueue:
api.queues.email.ErrCh <- amqpErr
case queue.IpnsEntryQueue:
api.queues.ipns.ErrCh <- amqpErr
case queue.IpfsPinQueue:
api.queues.pin.ErrCh <- amqpErr
case queue.IpfsKeyCreationQueue:
api.queues.key.ErrCh <- amqpErr
case queue.DashPaymentConfirmationQueue:
api.queues.dash.ErrCh <- amqpErr
case queue.EthPaymentConfirmationQueue:
api.queues.eth.ErrCh <- amqpErr
case queue.BitcoinCashPaymentConfirmationQueue:
api.queues.bch.ErrCh <- amqpErr
}
// test handleQueueError function directly
if _, err := api.handleQueueError(amqpErr, api.cfg.RabbitMQ.URL, tt.args.queueType, true); err != nil {
t.Fatal(err)
}
})
}
}
func TestAPI_HandleQueuError_Failure(t *testing.T) {
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
logger := zaptest.NewLogger(t).Sugar()
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
clients := Clients{
Lens: fakeLens,
Orch: fakeOrch,
Signer: fakeSigner,
}
api, err := Initialize(context.Background(), cfg, "", Options{DevMode: true, DebugLogging: true}, clients, logger)
if err != nil {
t.Fatal(err)
}
type args struct {
queueType queue.Queue
}
tests := []struct {
name string
args args
}{
{queue.IpfsClusterPinQueue.String(), args{queue.IpfsClusterPinQueue}},
{queue.EmailSendQueue.String(), args{queue.EmailSendQueue}},
{queue.IpnsEntryQueue.String(), args{queue.IpnsEntryQueue}},
{queue.IpfsPinQueue.String(), args{queue.IpfsPinQueue}},
{queue.IpfsKeyCreationQueue.String(), args{queue.IpfsKeyCreationQueue}},
{queue.DashPaymentConfirmationQueue.String(), args{queue.DashPaymentConfirmationQueue}},
{queue.EthPaymentConfirmationQueue.String(), args{queue.EthPaymentConfirmationQueue}},
{queue.BitcoinCashPaymentConfirmationQueue.String(), args{queue.BitcoinCashPaymentConfirmationQueue}},
}
// setup a bad rabbitmq url for testing connectivity failures
api.cfg.RabbitMQ.URL = "notarealprotocol://notarealurl"
// declare an error to use for testing
amqpErr := &amqp.Error{Code: 400, Reason: "test", Server: true, Recover: false}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
//TODO: enable this kind of testing within ListenAndServe eventually
// test handleQueueError function directly
if _, err := api.handleQueueError(amqpErr, api.cfg.RabbitMQ.URL, tt.args.queueType, true); err == nil {
t.Fatal("error expected")
}
})
}
}
func loadDatabase(cfg *config.TemporalConfig) (*gorm.DB, error) {
dbm, err := database.New(cfg, database.Options{SSLModeDisable: true})
if err != nil {
return nil, err
}
return dbm.DB, nil
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_account.go | api/v2/routes_account.go | package v2
import (
"errors"
"fmt"
"html"
"net/http"
"strconv"
"strings"
"github.com/RTradeLtd/Temporal/eh"
"github.com/RTradeLtd/Temporal/queue"
"github.com/RTradeLtd/database/v2/models"
"github.com/gin-gonic/gin"
)
// getUserFromToken is used to get the username of the associated token
func (api *API) getUserFromToken(c *gin.Context) {
// get username from jwt
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// return username
Respond(c, http.StatusOK, gin.H{"response": username})
}
// verifyEmailAddress is used to verify a users email
// without requiring authentication
func (api *API) verifyEmailAddress(c *gin.Context) {
// get username
user := c.Param("user")
// get the token
token := c.Param("token")
if err := api.verifyEmailJWTToken(token, user); err != nil {
api.LogError(c, err, err.Error())(http.StatusBadRequest)
return
}
// log and return
Respond(c, http.StatusOK, gin.H{"response": "email verified"})
}
// ChangeAccountPassword is used to change a users password
func (api *API) changeAccountPassword(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// extract post forms
forms, missingField := api.extractPostForms(c, "old_password", "new_password")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// parse html encoded strings
forms["old_password"] = html.UnescapeString(forms["old_password"])
forms["new_password"] = html.UnescapeString(forms["new_password"])
api.l.With("user", username).Info("password change requested")
// change password
if ok, err := api.um.ChangePassword(username, forms["old_password"], forms["new_password"]); err != nil {
api.LogError(c, err, eh.PasswordChangeError)(http.StatusBadRequest)
return
} else if !ok {
err = fmt.Errorf("password changed failed for user %s to due an unspecified error", username)
api.LogError(c, err, eh.PasswordChangeError)(http.StatusBadRequest)
return
}
// log and return
api.l.Infow("password changed",
"user", username)
Respond(c, http.StatusOK, gin.H{"response": "password changed"})
}
// RegisterUserAccount is used to sign up with temporal
func (api *API) registerUserAccount(c *gin.Context) {
// extract post forms
forms, missingField := api.extractPostForms(c, "username", "password", "email_address")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// parse emails to prevent exploit of catch-all routing
// where people sign up with an email like myuser+test@example.org
// by having the +test they are effectively signing up under a new email
// granting them another free account.
if strings.ContainsRune(forms["email_address"], '+') {
Fail(c, errors.New("emails must not contain + signs, this is to prevent abuse of catch all routing"))
return
}
// prevent people from registering usernames that contain an `@` sign
// this prevents griefing by prevent user sign-ins by using a username
// that is based off an email address
if strings.ContainsRune(forms["username"], '@') {
Fail(c, errors.New("usernames cant contain @ sign"))
return
}
// parse html encoded strings
forms["password"] = html.UnescapeString(forms["password"])
// create user model
_, err := api.um.NewUserAccount(
forms["username"],
forms["password"],
forms["email_address"],
)
api.handleUserCreate(c, forms, err)
}
// CreateIPFSKey is used to create an IPFS key
func (api *API) createIPFSKey(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// extract forms
forms, missingField := api.extractPostForms(c, "key_type", "key_bits", "key_name")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// validate key type
switch forms["key_type"] {
case "rsa", "ed25519":
break
default:
// user error, do not log
err := fmt.Errorf("%s is invalid key type must be rsa, or ed25519", forms["key_type"])
Fail(c, err, http.StatusBadRequest)
return
}
// get a list of users current keys
keys, err := api.um.GetKeysForUser(username)
if err != nil {
api.LogError(c, err, eh.KeySearchError)(http.StatusNotFound)
return
}
// format key name
// we prepend with the username to prevent key name collisions
keyName := fmt.Sprintf("%s-%s", username, forms["key_name"])
// parse through existing key names, and ensure one doesnt' already exist
for _, v := range keys["key_names"] {
if v == keyName {
err = fmt.Errorf("key with name already exists")
api.LogError(c, err, eh.DuplicateKeyCreationError)(http.StatusConflict)
return
}
}
// parse key bits
bitsInt, err := strconv.Atoi(forms["key_bits"])
if err != nil {
Fail(c, err)
return
}
// verify the user can create keys
if err := api.usage.CanCreateKey(username); err != nil {
api.LogError(c, err, err.Error())(http.StatusBadRequest)
return
}
// increment their key count
if err := api.usage.IncrementKeyCount(username, 1); err != nil {
api.LogError(c, err, "failed to increment key count")(http.StatusBadRequest)
return
}
// create key creation message
key := queue.IPFSKeyCreation{
UserName: username,
Name: keyName,
Type: forms["key_type"],
Size: bitsInt,
NetworkName: "public",
}
// send message for processing
if err = api.queues.key.PublishMessage(key); err != nil {
api.LogError(c, err, eh.QueuePublishError)(http.StatusBadRequest)
return
}
// log and return
api.l.With("user", username).Info("key creation request sent to backend")
Respond(c, http.StatusOK, gin.H{"response": "key creation sent to backend"})
}
// GetIPFSKeyNamesForAuthUser is used to get the keys a user has setup
func (api *API) getIPFSKeyNamesForAuthUser(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// search for keys created by user
keys, err := api.um.GetKeysForUser(username)
if err != nil {
api.LogError(c, err, eh.KeySearchError)(http.StatusBadRequest)
return
}
// if the user has no keys, fail with an error
if len(keys["key_names"]) == 0 || len(keys["key_ids"]) == 0 {
Fail(c, errors.New(eh.NoKeyError), http.StatusNotFound)
return
}
// log and return
api.l.Infow("key name list requested", "user", username)
Respond(c, http.StatusOK, gin.H{"response": gin.H{"key_names": keys["key_names"], "key_ids": keys["key_ids"]}})
}
// GetCredits is used to get a users available credits
func (api *API) getCredits(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get credits tied with the user account
credits, err := api.um.GetCreditsForUser(username)
if err != nil {
api.LogError(c, err, eh.CreditCheckError)(http.StatusBadRequest)
return
}
// log and return
api.l.Infow("credit check requested", "user", username)
Respond(c, http.StatusOK, gin.H{"response": credits})
}
// ForgotEmail is used to retrieve an email if the user forgets it
func (api *API) forgotEmail(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// search for the user
user, err := api.um.FindByUserName(username)
if err != nil {
api.LogError(c, err, eh.UserSearchError)(http.StatusBadRequest)
return
}
// return email address associated with the user account
Respond(c, http.StatusOK, gin.H{"response": user.EmailAddress})
}
// ForgotUserName is used to send a username reminder to the email associated with the account
func (api *API) forgotUserName(c *gin.Context) {
forms, missingField := api.extractPostForms(c, "email_address")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// find email address associated with the user account
user, err := api.um.FindByEmail(forms["email_address"])
if err != nil {
Fail(c, errors.New(eh.UserSearchError), http.StatusBadRequest)
return
}
// account email must be enabled in order to engage in account recovery processes
if !user.EmailEnabled {
Fail(c, errors.New("account does not have email enabled, unfortunately for security reasons we can't assist in recovery"))
return
}
// construct email message
es := queue.EmailSend{
Subject: "TEMPORAL User Name Reminder",
Content: fmt.Sprintf("your username is %s", user.UserName),
ContentType: "text/html",
UserNames: []string{user.UserName},
Emails: []string{user.EmailAddress},
}
// send message for processing
if err = api.queues.email.PublishMessage(es); err != nil {
api.LogError(c, err, eh.QueuePublishError)(http.StatusBadRequest)
return
}
// return
Respond(c, http.StatusOK, gin.H{"response": "username reminder sent account email"})
}
// ResetPassword is used to reset the password associated with a user account
func (api *API) resetPassword(c *gin.Context) {
forms, missingField := api.extractPostForms(c, "email_address")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// find user account associated with the email
user, err := api.um.FindByEmail(forms["email_address"])
if err != nil {
api.LogError(c, err, eh.UserSearchError)(http.StatusBadRequest)
return
}
// account email must be enabled in order to engage in account reovery process
if !user.EmailEnabled {
Fail(c, errors.New("account does not have email enabled, unfortunately for security reasons we can't assist in recovery"))
return
}
// reset password, generating a random one
newPass, err := api.um.ResetPassword(user.UserName)
if err != nil {
api.LogError(c, err, eh.PasswordResetError)(http.StatusBadRequest)
return
}
// create email message
es := queue.EmailSend{
Subject: "TEMPORAL Password Reset",
Content: fmt.Sprintf("your password is %s", newPass),
ContentType: "text/html",
UserNames: []string{user.UserName},
Emails: []string{user.EmailAddress},
}
// send message to queue system for processing
if err = api.queues.email.PublishMessage(es); err != nil {
api.LogError(c, err, eh.QueuePublishError)(http.StatusBadRequest)
return
}
// return
Respond(c, http.StatusOK, gin.H{"response": "password reset, please check your email for a new password"})
}
// UpgradeAccount is used to remove free tier restrictions and enable paid access
// once upgraded, your account can't be reverted
func (api *API) upgradeAccount(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
usages, err := api.usage.FindByUserName(username)
if err != nil {
api.LogError(c, err, eh.UserSearchError)(http.StatusBadRequest)
return
}
if usages.Tier == models.Unverified {
Fail(c, errors.New("unverified account upgrade process must be done via email verification"))
}
// prevent people from repeatedly calling this granting perpetual credits
if usages.Tier != models.Free {
Fail(c, errors.New("user account is already upgrade"))
return
}
// update tier
if err := api.usage.UpdateTier(username, models.Paid); err != nil {
api.LogError(c, err, eh.TierUpgradeError)(http.StatusBadRequest)
return
}
// find user
user, err := api.um.FindByUserName(username)
if err != nil {
api.LogError(c, err, eh.UserSearchError)(http.StatusBadRequest)
return
}
// create email message
es := queue.EmailSend{
Subject: "TEMPORAL Account Upgraded",
Content: "your account has been upgraded to a paid account!",
ContentType: "text/html",
UserNames: []string{username},
Emails: []string{user.EmailAddress},
}
// send message to queue system for processing
if err = api.queues.email.PublishMessage(es); err != nil {
api.LogError(c, err, eh.QueuePublishError)(http.StatusBadRequest)
return
}
// return
Respond(c, http.StatusOK, gin.H{"response": "account upgraded"})
}
func (api *API) usageData(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get usage data
usages, err := api.usage.FindByUserName(username)
if err != nil {
api.LogError(c, err, "failed to search for account usage data")(http.StatusBadRequest)
return
}
// return data
Respond(c, http.StatusOK, gin.H{"response": usages})
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_frontend_test.go | api/v2/routes_frontend_test.go | package v2
import (
"bytes"
"encoding/json"
"io"
"io/ioutil"
"mime/multipart"
"net/http/httptest"
"net/url"
"os"
"testing"
"github.com/RTradeLtd/Temporal/mocks"
"github.com/RTradeLtd/config/v2"
)
func Test_API_Routes_Frontend(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
// test pin cost calculate
// /v2/frontend/cost/calculate/:hash/:holTime
var floatAPIResp floatAPIResponse
if err := sendRequest(
api, "GET", "/v2/frontend/cost/calculate/"+hash+"/5", 200, nil, nil, &floatAPIResp,
); err != nil {
t.Fatal(err)
}
if floatAPIResp.Code != 200 {
t.Fatal("bad response code from /v2/frontend/cost/calculate")
}
// test file upload cost calculation
// /v2/frontend/cost/calculate/file
bodyBuf := &bytes.Buffer{}
bodyWriter := multipart.NewWriter(bodyBuf)
fileWriter, err := bodyWriter.CreateFormFile("file", "../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
fh, err := os.Open("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
defer fh.Close()
if _, err = io.Copy(fileWriter, fh); err != nil {
t.Fatal(err)
}
bodyWriter.Close()
testRecorder := httptest.NewRecorder()
req := httptest.NewRequest("POST", "/v2/frontend/cost/calculate/file", bodyBuf)
req.Header.Add("Authorization", authHeader)
req.Header.Add("Content-Type", bodyWriter.FormDataContentType())
urlValues := url.Values{}
urlValues.Add("hold_time", "5")
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
if testRecorder.Code != 200 {
t.Fatal("bad http status code recovered from /v2/frontend/cost/calculate/file")
}
floatAPIResp = floatAPIResponse{}
// unmarshal the response
bodyBytes, err := ioutil.ReadAll(testRecorder.Result().Body)
if err != nil {
t.Fatal(err)
}
if err = json.Unmarshal(bodyBytes, &floatAPIResp); err != nil {
t.Fatal(err)
}
// validate the response code
if floatAPIResp.Code != 200 {
t.Fatal("bad api status code from /v2/frontend/cost/calculate/file")
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_database_test.go | api/v2/routes_database_test.go | package v2
import (
"net/url"
"testing"
"github.com/RTradeLtd/Temporal/mocks"
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/database/v2/models"
)
func Test_API_Routes_Database(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
// create uploads to test searching with
up1, err := api.upm.NewUpload("testhash123", "file", models.UploadOptions{
Username: "testuser",
FileName: "dogpic123.jpg",
HoldTimeInMonths: 1,
})
if err != nil {
t.Fatal(err)
}
defer api.upm.DB.Unscoped().Delete(up1)
up2, err := api.upm.NewUpload("testhash1234", "file", models.UploadOptions{
Username: "testuser",
FileName: "catpic123.jpg",
HoldTimeInMonths: 1,
})
if err != nil {
t.Fatal(err)
}
defer api.upm.DB.Unscoped().Delete(up2)
up3, err := api.upm.NewUpload("testhash12345", "file", models.UploadOptions{
Username: "testuser",
FileName: "bigdogpic123.jpg",
HoldTimeInMonths: 1,
})
if err != nil {
t.Fatal(err)
}
defer api.upm.DB.Unscoped().Delete(up3)
type args struct {
wantName map[string]bool
query string
wantCode int
}
tests := []struct {
name string
args args
}{
{"dog", args{
map[string]bool{"bigdogpic123.jpg": true, "dogpic123.jpg": true},
"%dog%", 200,
}},
{"cat", args{
map[string]bool{"catpic123.jpg": true},
"%cat%", 200,
}},
{"pic", args{
map[string]bool{"dogpic123.jpg": true, "bigdogpic123.jpg": true, "catpic123.jpg": true},
"%pic%", 200,
}},
}
// test search (non paged)
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var searchAPIResp searchAPIResponse
if err := sendRequest(
api, "POST", "/v2/database/uploads/search", tt.args.wantCode, nil, url.Values{
"search_query": []string{tt.args.query},
}, &searchAPIResp,
); err != nil {
t.Fatal(err)
}
if len(searchAPIResp.Response) != len(tt.args.wantName) {
t.Fatal("bad count")
}
for _, up := range searchAPIResp.Response {
if !tt.args.wantName[up.FileNameLowerCase] {
t.Fatal("bad upload found")
}
}
})
}
// test search (paged)
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var searchAPIResp searchAPIResponse
if err := sendRequest(
api, "POST", "/v2/database/uploads/search", tt.args.wantCode, nil, url.Values{
"search_query": []string{tt.args.query},
"paged": []string{"true"},
}, &searchAPIResp,
); err != nil {
t.Fatal(err)
}
if len(searchAPIResp.Response) != len(tt.args.wantName) {
t.Fatal("bad count")
}
for _, up := range searchAPIResp.Response {
if !tt.args.wantName[up.FileNameLowerCase] {
t.Fatal("bad upload found")
}
}
})
}
tests = []struct {
name string
args args
}{
{"1", args{
nil,
"drop table", 400,
}},
{"2", args{
nil,
"drop column", 400,
}},
{"3", args{
nil,
"drop row", 400,
}},
{"4", args{
nil,
"delete table", 400,
}},
{"5", args{
nil,
"delete column", 400,
}},
{"6", args{
nil,
"delete row", 400,
}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var interfaceAPIResp interfaceAPIResponse
if err := sendRequest(
api, "POST", "/v2/database/uploads/search", tt.args.wantCode, nil, url.Values{
"search_query": []string{tt.args.query},
}, &interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
})
}
// test database specific uploads
// /v2/database/uploads/testuser
var interfaceAPIResp interfaceAPIResponse
if err := sendRequest(
api, "GET", "/v2/database/uploads", 200, nil, nil, &interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
// test paginated
interfaceAPIResp = interfaceAPIResponse{}
if err := sendRequestPaged(
api,
"GET",
"/v2/database/uploads",
200,
nil,
url.Values{"paged": {"true"}},
&interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
// test get encrypted uploads
// /v2/frontend/uploads/encrypted
if err := sendRequest(
api, "GET", "/v2/database/uploads/encrypted", 200, nil, nil, nil,
); err != nil {
t.Fatal(err)
}
interfaceAPIResp = interfaceAPIResponse{}
if err := sendRequestPaged(
api,
"GET",
"/v2/database/uploads/encrypted",
200,
nil,
url.Values{"paged": {"true"}},
&interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_lens.go | api/v2/routes_lens.go | package v2
import (
"errors"
"net/http"
"github.com/RTradeLtd/Temporal/eh"
pb "github.com/RTradeLtd/grpc/lensv2"
"github.com/gin-gonic/gin"
gocid "github.com/ipfs/go-cid"
)
func (api *API) submitIndexRequest(c *gin.Context) {
// extract post forms
forms, missingField := api.extractPostForms(c, "object_type", "object_identifier")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
var indexType pb.IndexReq_Type
// ensure the type being requested is supported
switch forms["object_type"] {
case "ipld":
// validate the object identifier
if _, err := gocid.Decode(forms["object_identifier"]); err != nil {
Fail(c, err)
return
}
indexType = pb.IndexReq_IPLD
default:
Fail(c, errors.New(eh.InvalidObjectTypeError))
return
}
resp, err := api.lens.Index(c, &pb.IndexReq{
Type: indexType,
Hash: forms["object_identifier"],
Options: &pb.IndexReq_Options{
Reindex: c.PostForm("reindex") == "true",
},
})
if err != nil {
api.LogError(c, err, eh.FailedToIndexError)(http.StatusBadRequest)
return
}
Respond(c, http.StatusOK, gin.H{"response": resp.GetDoc()})
}
func (api *API) submitSearchRequest(c *gin.Context) {
// query we will use to perform as the main search
query, exists := c.GetPostForm("query")
if !exists {
FailWithMissingField(c, "query")
return
}
var (
tags, _ = c.GetPostFormArray("tags")
categories, _ = c.GetPostFormArray("categories")
mimeTypes, _ = c.GetPostFormArray("mime_types")
hashes, _ = c.GetPostFormArray("hashes")
required, _ = c.GetPostFormArray("required")
)
resp, err := api.lens.Search(c, &pb.SearchReq{
Query: query,
Options: &pb.SearchReq_Options{
Tags: tags,
Categories: categories,
MimeTypes: mimeTypes,
Hashes: hashes,
Required: required,
},
})
if err != nil {
api.LogError(c, err, eh.FailedToSearchError)(http.StatusBadRequest)
return
}
// check to ensure some objects were found, otherwise log a warning
if len(resp.Results) == 0 {
Respond(c, http.StatusBadRequest, gin.H{"response": "no results found"})
return
}
Respond(c, http.StatusOK, gin.H{"response": resp})
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/log.go | api/v2/log.go | package v2
import (
"github.com/gin-gonic/gin"
)
// LogError is a wrapper used by the API to handle logging of errors. Returns a
// callback to also fail a gin context with an optional status code, which
// defaults to http.StatusInternalServerError. Fields is an optional set of
// params provided in pairs, where the first of a pair is the key, and the second
// is the value
//
// Passing in the initial gin.Context to LogError is used to extract the X-Request-ID associated
// with the given request to make it easier to debug user-submitted erros.
func (api *API) LogError(c *gin.Context, err error, message string, fields ...interface{}) func(code ...int) {
// create base entry with the associated request id
// for some reason this is being set as `X-Request-Id` despite initially
// setting the header to `X-Request-ID`
var logger = api.l.With("request-id", c.GetHeader("X-Request-Id"))
// write log
if fields != nil && len(fields)%2 == 0 {
logger.Errorw(message, append(fields, "error", err.Error())...)
} else {
logger.Errorw(message, "error", err.Error())
}
// return utility callback
if message == "" && err != nil {
return func(code ...int) { Fail(c, err, code...) }
}
return func(code ...int) { FailWithMessage(c, message, code...) }
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/utils_test.go | api/v2/utils_test.go | package v2
import (
"testing"
"github.com/RTradeLtd/Temporal/mocks"
"github.com/RTradeLtd/Temporal/utils"
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/database/v2/models"
)
func TestEmailJWT(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
randUtils := utils.GenerateRandomUtils()
// create a user for this test
randEmail := randUtils.GenerateString(32, utils.LetterBytes) + "@example.org"
randUser := randUtils.GenerateString(32, utils.LetterBytes)
if _, err := api.um.NewUserAccount(randUser, "password123", randEmail); err != nil {
t.Fatal(err)
}
// generate the email verification string
userModel, err := api.um.GenerateEmailVerificationToken(randUser)
if err != nil {
t.Fatal(err)
}
tkn, err := api.generateEmailJWTToken(randUser, userModel.EmailVerificationToken)
if err != nil {
t.Fatal(err)
}
if err := api.verifyEmailJWTToken(tkn, randUser); err != nil {
t.Fatal(err)
}
}
func Test_CheckAccessForPrivateNetwork(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
um := models.NewUserManager(db)
if err := um.AddIPFSNetworkForUser("testuser", "mynewnetworktotestwith"); err != nil {
t.Fatal(err)
}
// search for a non-existent user
if err := CheckAccessForPrivateNetwork("notarealuseraccount", "notarealnetwork", db); err == nil {
t.Fatal("expected error")
}
// search for network user does not have access to
if err := CheckAccessForPrivateNetwork("testuser", "thisnetworkdoesnotexist", db); err == nil {
t.Fatal("expected error")
}
if err := CheckAccessForPrivateNetwork("testuser", "mynewnetworktotestwith", db); err != nil {
t.Fatal(err)
}
}
func Test_GetIPFSEndPoint(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
dev = !dev
if net := api.GetIPFSEndpoint("network"); net == "" {
t.Fatal("bad network url recovered")
}
dev = !dev
if net := api.GetIPFSEndpoint("network"); net == "" {
t.Fatal("bad network url recovered")
}
}
func Test_Ensure_Two_Year_Max(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
randUtils := utils.GenerateRandomUtils()
randString := randUtils.GenerateString(32, utils.LetterBytes)
um := models.NewUploadManager(db)
if err != nil {
t.Fatal(err)
}
type args struct {
holdTimeInMonths int64
tier models.DataUsageTier
}
tests := []struct {
name string
args args
wantErr bool
}{
{"12-Months-paid", args{12, models.Paid}, false},
{"22-Months-paid", args{22, models.Paid}, false},
{"25-Months-paid", args{25, models.Paid}, true},
{"10-Months-unverified", args{10, models.Unverified}, false},
{"11-Months-unverified", args{11, models.Unverified}, false},
{"12-Months-unverified", args{12, models.Unverified}, true},
{"22-Months-unverified", args{22, models.Unverified}, true},
{"25-Months-unverified", args{25, models.Unverified}, true},
{"10-Months-free", args{10, models.Free}, false},
{"11-Months-free", args{11, models.Free}, false},
{"12-Months-free", args{12, models.Free}, true},
{"22-Months-free", args{22, models.Free}, true},
{"25-Months-free", args{25, models.Free}, true},
{"12-Months-partner", args{12, models.Partner}, false},
{"22-Months-partner", args{22, models.Partner}, false},
{"25-Months-partner", args{25, models.Partner}, true},
{"12-Months-whitelabeled", args{12, models.WhiteLabeled}, false},
{"22-Months-whitelabeled", args{22, models.WhiteLabeled}, false},
{"25-Months-whitelabeled", args{25, models.WhiteLabeled}, true},
{"not-a-real-tier", args{12, models.DataUsageTier("thetierisalie")}, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
upload, err := um.NewUpload(
randString,
"file",
models.UploadOptions{
Username: "testuser",
NetworkName: "public",
HoldTimeInMonths: 1,
Encrypted: false,
},
)
if err != nil {
t.Fatal(err)
}
if err := api.ensureLEMaxPinTime(
upload,
tt.args.holdTimeInMonths,
tt.args.tier,
); (err != nil) != tt.wantErr {
t.Fatalf("ensureTwoYearMax err = %v, wantErr %v", err, tt.wantErr)
}
um.DB.Unscoped().Delete(upload)
})
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_swarm_test.go | api/v2/routes_swarm_test.go | package v2
import (
"bytes"
"encoding/json"
"io"
"io/ioutil"
"mime/multipart"
"net/http/httptest"
"net/url"
"os"
"testing"
"github.com/RTradeLtd/Temporal/mocks"
"github.com/RTradeLtd/config/v2"
)
func Test_Routes_Swarm(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
cfg.Ethereum.Swarm.URL1 = "http://localhost:8500"
cfg.Ethereum.Swarm.URL2 = "http://localhost:8500"
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
usr, err := api.um.NewUserAccount("ethswarmtest", "password123", "ethswarmtest@google.ca")
if err != nil {
t.Fatal(err)
}
usr, err = api.um.ValidateEmailVerificationToken("ethswarmtest", usr.EmailVerificationToken)
if err != nil {
t.Fatal(err)
}
// add a file normally
bodyBuf := &bytes.Buffer{}
bodyWriter := multipart.NewWriter(bodyBuf)
fileWriter, err := bodyWriter.CreateFormFile("file", "../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
fh, err := os.Open("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
defer fh.Close()
if _, err := io.Copy(fileWriter, fh); err != nil {
t.Fatal(err)
}
bodyWriter.Close()
testRecorder := httptest.NewRecorder()
req := httptest.NewRequest("POST", "/v2/swarm/upload", bodyBuf)
req.Header.Add("Authorization", authHeader)
req.Header.Add("Content-Type", bodyWriter.FormDataContentType())
urlValues := url.Values{}
urlValues.Add("hold_time", "5")
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
if testRecorder.Code != 200 {
t.Fatal("bad http status code recovered from /v2/swarm/upload")
}
var apiResp apiResponse
bodyBytes, err := ioutil.ReadAll(testRecorder.Result().Body)
if err != nil {
t.Fatal(err)
}
if err := json.Unmarshal(bodyBytes, &apiResp); err != nil {
t.Fatal(err)
}
if apiResp.Code != 200 {
t.Fatal("bad api response status code from /v2/swarm/upload")
}
if _, err := api.upm.FindUploadByHashAndNetwork(apiResp.Response, "etherswarm"); err != nil {
t.Fatal(err)
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_account_test.go | api/v2/routes_account_test.go | package v2
import (
"net/url"
"testing"
"github.com/RTradeLtd/Temporal/mocks"
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/database/v2/models"
)
func Test_API_Routes_Account(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
// verify the username from the token
// /v2/account/token/username
var apiResp apiResponse
if err := sendRequest(
api, "GET", "/v2/account/token/username", 200, nil, nil, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 200 {
t.Fatal("bad api status code from /v2/account/token/username")
}
if apiResp.Response != "testuser" {
t.Fatal("bad username recovered from token")
}
// verify account password change - success
// /v2/account/password/change
urlValues := url.Values{}
urlValues.Add("old_password", "admin")
urlValues.Add("new_password", "admin1234@")
apiResp = apiResponse{}
if err := sendRequest(
api, "POST", "/v2/account/password/change", 200, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 200 {
t.Fatal("bad api status code from /v2/account/password/change")
}
// verify account password change - failure
// /v2/account/password/change
urlValues = url.Values{}
urlValues.Add("old_password", "admin")
urlValues.Add("new_password", "admin1234@")
apiResp = apiResponse{}
if err := sendRequest(
api, "POST", "/v2/account/password/change", 400, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 400 {
t.Fatal("bad api status code from /v2/account/password/change")
}
// get ipfs keys - no keys created
// /v2/account/key/ipfs/get
apiResp = apiResponse{}
if err := sendRequest(
api, "GET", "/v2/account/key/ipfs/get", 404, nil, nil, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 404 {
t.Fatal("bad api status code from /v2/account/key/ipfs/get")
}
// create ipfs keys
// /v2/account/key/ipfs/new
urlValues = url.Values{}
urlValues.Add("key_type", "ed25519")
urlValues.Add("key_bits", "256")
urlValues.Add("key_name", "key1")
apiResp = apiResponse{}
if err := sendRequest(
api, "POST", "/v2/account/key/ipfs/new", 200, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 200 {
t.Fatal("bad api status code from /v2/account/key/ipfs/new")
}
// test rsa keys
urlValues.Add("key_type", "rsa")
urlValues.Add("key_bits", "2048")
urlValues.Add("key_name", "key2")
apiResp = apiResponse{}
if err := sendRequest(
api, "POST", "/v2/account/key/ipfs/new", 200, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 200 {
t.Fatal("bad api status code from /v2/account/key/ipfs/new")
}
if apiResp.Code != 200 {
t.Fatal("bad api status code from /v2/account/key/ipfs/new")
}
// manually create the keys since we arent using queues
if err := models.NewUserManager(db).AddIPFSKeyForUser("testuser", "key1", "muchwow"); err != nil {
t.Fatal(err)
}
if err := models.NewUserManager(db).AddIPFSKeyForUser("testuser", "key2", "suchkey"); err != nil {
t.Fatal(err)
}
// create ipfs key - bad key bit
// /v2/account/key/ipfs/new
urlValues = url.Values{}
urlValues.Add("key_type", "ed25519")
urlValues.Add("key_bits", "notanumber")
urlValues.Add("key_name", "key1")
apiResp = apiResponse{}
if err := sendRequest(
api, "POST", "/v2/account/key/ipfs/new", 400, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 400 {
t.Fatal("bad api status code from /v2/account/key/ipfs/new")
}
// get ipfs keys
// /v2/account/key/ipfs/get
var mapAPIResp mapAPIResponse
if err := sendRequest(
api, "GET", "/v2/account/key/ipfs/get", 200, nil, nil, &mapAPIResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if mapAPIResp.Code != 200 {
t.Fatal("bad api status code from /v2/account/key/ipfs/get")
}
// get available credits
// /v2/account/credits/available
var floatAPIResp floatAPIResponse
if err := sendRequest(
api, "GET", "/v2/account/credits/available", 200, nil, nil, &floatAPIResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if floatAPIResp.Code != 200 {
t.Fatal("bad api status code from /v2/account/credits/available")
}
// test email activation
// /v2/account/email/verify/:user/:token
if _, err := api.um.NewUserAccount("verificationtestuser", "password123", "verificationtestuser@example.org"); err != nil {
t.Fatal(err)
}
userModel, err := api.um.GenerateEmailVerificationToken("verificationtestuser")
if err != nil {
t.Fatal(err)
}
token, err := api.generateEmailJWTToken("verificationtestuser", userModel.EmailVerificationToken)
if err != nil {
t.Fatal(err)
}
apiResp = apiResponse{}
if err := sendRequest(
api, "GET", "/v2/account/email/verify/"+userModel.UserName+"/"+token, 200, nil, nil, &apiResp,
); err != nil {
t.Fatal(err)
}
// forgot email
// /v2/account/email/forgot
apiResp = apiResponse{}
if err := sendRequest(
api, "POST", "/v2/account/email/forgot", 200, nil, nil, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 200 {
t.Fatal("bad api status code from /v2/account/email/forgot")
}
// test@email.com
// forgot username
// /v2/forgot/username
apiResp = apiResponse{}
urlValues = url.Values{}
urlValues.Add("email_address", "test@email.com")
if err := sendRequest(
api, "POST", "/v2/forgot/username", 200, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 200 {
t.Fatal("bad api status code from /v2/forgot/username")
}
// test@email.com
// forgot password
// /v2/forgot/password
apiResp = apiResponse{}
urlValues = url.Values{}
urlValues.Add("email_address", "test@email.com")
if err := sendRequest(
api, "POST", "/v2/forgot/password", 200, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 200 {
t.Fatal("bad api status code from /v2/forgot/password")
}
// upgrade account
// /v2/account/upgrade
apiResp = apiResponse{}
if err := sendRequest(
api, "POST", "/v2/account/upgrade", 200, nil, nil, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 200 {
t.Fatal("bad api status code from /v2/account/upgrade")
}
// usage data
// /v2/account/upgrade
var interfaceAPIResp interfaceAPIResponse
if err := sendRequest(
api, "GET", "/v2/account/usage", 200, nil, nil, &interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if interfaceAPIResp.Code != 200 {
t.Fatal("bad api status code from /v2/account/usage")
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/context.go | api/v2/context.go | package v2
import (
"errors"
"fmt"
"net/http"
"strings"
jwt "github.com/appleboy/gin-jwt"
"github.com/gin-gonic/gin"
)
// Fail fails context with given error and optional status code. Defaults to
// http.StatusInternalServerError
func Fail(c *gin.Context, err error, code ...int) {
c.JSON(status(code), gin.H{
"code": status(code),
"response": err.Error(),
})
}
// FailWithMessage fails context with given message and optional status code.
// Defaults to http.StatusInternalServerError
func FailWithMessage(c *gin.Context, message string, code ...int) {
c.JSON(status(code), gin.H{
"code": status(code),
"response": message,
})
}
// FailWithBadRequest fails context with a bad request error and given message
func FailWithBadRequest(c *gin.Context, message string) {
FailWithMessage(c, message, http.StatusBadRequest)
}
// FailWithMissingField is a failure used when a post form does not exist
func FailWithMissingField(c *gin.Context, field string) {
FailWithBadRequest(c, fmt.Sprintf("%s not present", field))
}
// FailNotAuthorized is a failure used when a user is unauthorized for an action
func FailNotAuthorized(c *gin.Context, message string) {
c.JSON(http.StatusForbidden, gin.H{
"code": http.StatusForbidden,
"response": message,
})
}
// GetAuthenticatedUserFromContext is used to pull the eth address of hte user
func GetAuthenticatedUserFromContext(c *gin.Context) (string, error) {
claims := jwt.ExtractClaims(c)
id, ok := claims["id"]
if !ok {
return "", errors.New("failed to extract claim id")
}
strID, ok := id.(string)
if !ok {
return "", errors.New("failed to parse claim id")
}
if strID == "" {
return "", errors.New("no username recovered")
}
// this is their eth address
return strID, nil
}
// GetAuthToken is used to retrieve the jwt token
// from an authenticated request
func GetAuthToken(c *gin.Context) string {
token := strings.Split(c.GetHeader("Authorization"), " ")
if len(token) < 2 {
return ""
}
return token[1]
}
// Respond is a wrapper used to handle API responses
func Respond(c *gin.Context, status int, body gin.H) {
body["code"] = status
c.JSON(status, body)
}
// status is used to handle optional status code params
func status(i []int) (status int) {
if len(i) == 0 {
status = http.StatusBadRequest
} else {
status = i[0]
}
return
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_rtfsp_test.go | api/v2/routes_rtfsp_test.go | package v2
import (
"bytes"
"encoding/json"
"io"
"io/ioutil"
"mime/multipart"
"net/http/httptest"
"net/url"
"os"
"testing"
"github.com/RTradeLtd/Temporal/mocks"
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/database/v2/models"
pbOrch "github.com/RTradeLtd/grpc/nexus"
)
func Test_API_Routes_IPFS_Private(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
nm := models.NewHostedNetworkManager(db)
// create private network - failure missing name
// /v2/ipfs/private/new
var apiResp apiResponse
if err := sendRequest(
api, "POST", "/v2/ipfs/private/network/new", 400, nil, nil, &apiResp,
); err != nil {
t.Fatal(err)
}
if apiResp.Code != 400 {
t.Fatal("bad api status code from /v2/ipfs/private/network/new")
}
if apiResp.Response != "network_name not present" {
t.Fatal("failed to detect missing network_name field")
}
// create private network - failure name is PUBLIC
// /v2/ipfs/private/new
apiResp = apiResponse{}
urlValues := url.Values{}
urlValues.Add("network_name", "PUBLIC")
if err := sendRequest(
api, "POST", "/v2/ipfs/private/network/new", 400, nil, nil, &apiResp,
); err != nil {
t.Fatal(err)
}
if apiResp.Code != 400 {
t.Fatal("bad api status code from /v2/ipfs/private/network/new")
}
// create private network - failure name is public
// /v2/ipfs/private/new
apiResp = apiResponse{}
urlValues = url.Values{}
urlValues.Add("network_name", "public")
if err := sendRequest(
api, "POST", "/v2/ipfs/private/network/new", 400, nil, nil, &apiResp,
); err != nil {
t.Fatal(err)
}
if apiResp.Code != 400 {
t.Fatal("bad api status code from /v2/ipfs/private/network/new")
}
// create private network
// /v2/ipfs/private/new
var mapAPIResp mapAPIResponse
urlValues = url.Values{}
urlValues.Add("network_name", "abc123")
fakeOrch.StartNetworkReturnsOnCall(0, &pbOrch.StartNetworkResponse{PeerId: "hello", SwarmKey: testSwarmKey}, nil)
if err := sendRequest(
api, "POST", "/v2/ipfs/private/network/new", 200, nil, urlValues, &mapAPIResp,
); err != nil {
t.Fatal(err)
}
if mapAPIResp.Code != 200 {
t.Fatal("bad api response status code from /v2/ipfs/private/new")
}
if mapAPIResp.Response["network_name"] != "abc123" {
t.Fatal("failed to retrieve correct network name")
}
if mapAPIResp.Response["peer_id"] != "hello" {
t.Fatal("failed to retrieve correct api url")
}
if mapAPIResp.Response["swarm_key"] != testSwarmKey {
t.Fatal("failed to get correct swarm key")
}
if err := nm.UpdateNetworkByName("abc123", map[string]interface{}{
"api_url": cfg.IPFS.APIConnection.Host + ":" + cfg.IPFS.APIConnection.Port,
}); err != nil {
t.Fatal(err)
}
// create private network with parameters
// /v2/ipfs/private/network
mapAPIResp = mapAPIResponse{}
urlValues = url.Values{}
urlValues.Add("network_name", "xyz123")
urlValues.Add("swarm_key", testSwarmKey)
urlValues.Add("bootstrap_peers", testBootstrapPeer1)
urlValues.Add("bootstrap_peers", testBootstrapPeer2)
urlValues.Add("users", "testuser")
urlValues.Add("users", "testuser2")
fakeOrch.StartNetworkReturnsOnCall(1, &pbOrch.StartNetworkResponse{PeerId: "hello", SwarmKey: "swarmStorm"}, nil)
if err := sendRequest(
api, "POST", "/v2/ipfs/private/network/new", 200, nil, urlValues, &mapAPIResp,
); err != nil {
t.Fatal(err)
}
if mapAPIResp.Code != 200 {
t.Fatal("bad api response status code from /v2/ipfs/private/new")
}
if mapAPIResp.Response["network_name"] != "xyz123" {
t.Fatal("failed to retrieve correct network name")
}
if mapAPIResp.Response["peer_id"] != "hello" {
t.Fatal("failed to retrieve correct api url")
}
if mapAPIResp.Response["swarm_key"] != "swarmStorm" {
t.Fatal("failed to get correct swarm key")
}
// get private network information
// /v2/ipfs/private/network/:name
var interfaceAPIResp interfaceAPIResponse
if err := sendRequest(
api, "GET", "/v2/ipfs/private/network/abc123", 200, nil, nil, &interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
if interfaceAPIResp.Code != 200 {
t.Fatal("bad api response status code from /v2/ipfs/private/network/abc123")
}
// get all authorized private networks
// /v2/ipfs/private/networks
var stringSliceAPIResp stringSliceAPIResponse
if err := sendRequest(
api, "GET", "/v2/ipfs/private/networks", 200, nil, nil, &stringSliceAPIResp,
); err != nil {
t.Fatal(err)
}
if stringSliceAPIResp.Code != 200 {
t.Fatal("bad api response status code from /v2/ipfs/private/networks")
}
if len(stringSliceAPIResp.Response) == 0 {
t.Fatal("failed to find any from /v2/ipfs/private/networks")
}
var found bool
for _, v := range stringSliceAPIResp.Response {
if v == "abc123" {
found = true
break
}
}
if !found {
t.Fatal("failed to find correct network from /v2/ipfs/private/networks")
}
// stop private network
// /v2/ipfs/private/network/stop
// for now until we implement proper grpc testing, this will fail
mapAPIResp = mapAPIResponse{}
urlValues = url.Values{}
urlValues.Add("network_name", "abc123")
fakeOrch.StopNetworkReturnsOnCall(0, &pbOrch.Empty{}, nil)
if err := sendRequest(
api, "POST", "/v2/ipfs/private/network/stop", 200, nil, urlValues, &mapAPIResp,
); err != nil {
t.Fatal(err)
}
if mapAPIResp.Code != 200 {
t.Fatal("bad api resposne code from /v2/ipfs/private/network/stop")
}
if mapAPIResp.Response["state"] != "stopped" {
t.Fatal("failed to stop network")
}
// start private network
// /v2/ipfs/private/network/start
// for now until we implement proper grpc testing, this will fail
mapAPIResp = mapAPIResponse{}
urlValues = url.Values{}
urlValues.Add("network_name", "abc123")
fakeOrch.StartNetworkReturnsOnCall(2, &pbOrch.StartNetworkResponse{PeerId: "hello", SwarmKey: "test"}, nil)
if err := sendRequest(
api, "POST", "/v2/ipfs/private/network/start", 200, nil, urlValues, &mapAPIResp,
); err != nil {
t.Fatal(err)
}
if mapAPIResp.Code != 200 {
t.Fatal("bad api resposne code from /v2/ipfs/private/network/stop")
}
if mapAPIResp.Response["state"] != "started" {
t.Fatal("failed to stop network")
}
// add a file normally
// /v2/ipfs/private/file/add
bodyBuf := &bytes.Buffer{}
bodyWriter := multipart.NewWriter(bodyBuf)
fileWriter, err := bodyWriter.CreateFormFile("file", "../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
fh, err := os.Open("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
defer fh.Close()
if _, err = io.Copy(fileWriter, fh); err != nil {
t.Fatal(err)
}
bodyWriter.Close()
testRecorder := httptest.NewRecorder()
req := httptest.NewRequest("POST", "/v2/ipfs/private/file/add", bodyBuf)
req.Header.Add("Authorization", authHeader)
req.Header.Add("Content-Type", bodyWriter.FormDataContentType())
urlValues = url.Values{}
urlValues.Add("hold_time", "5")
urlValues.Add("network_name", "abc123")
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
if testRecorder.Code != 200 {
t.Fatal("bad http status code recovered from /v2/ipfs/private/file/add")
}
apiResp = apiResponse{}
// unmarshal the response
bodyBytes, err := ioutil.ReadAll(testRecorder.Result().Body)
if err != nil {
t.Fatal(err)
}
if err = json.Unmarshal(bodyBytes, &apiResp); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 200 {
t.Fatal("bad api status code from /v2/ipfs/private/file/add")
}
hash = apiResp.Response
// create a temporary object with
// default template
newObj, err := api.ipfs.NewObject("")
if err != nil {
t.Fatal(err)
}
// test pinning
// /v2/ipfs/private/pin
apiResp = apiResponse{}
urlValues = url.Values{}
urlValues.Add("hold_time", "5")
urlValues.Add("network_name", "abc123")
if err := sendRequest(
api, "POST", "/v2/ipfs/private/pin/"+newObj, 200, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 200 {
t.Fatal("bad api status code from /v2/ipfs/private/pin")
}
// test pin check
// /v2/ipfs/private/check/pin
var boolAPIResp boolAPIResponse
if err := sendRequest(
api, "GET", "/v2/ipfs/private/pin/check/"+hash+"/abc123", 200, nil, nil, &boolAPIResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if boolAPIResp.Code != 200 {
t.Fatal("bad api status code from /v2/ipfs/private/check/pin")
}
// test pubsub publish
// /v2/ipfs/private/publish/topic
mapAPIResp = mapAPIResponse{}
urlValues = url.Values{}
urlValues.Add("message", "bar")
urlValues.Add("network_name", "abc123")
if err := sendRequest(
api, "POST", "/v2/ipfs/private/pubsub/publish/foo", 200, nil, urlValues, &mapAPIResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if mapAPIResp.Code != 200 {
t.Fatal("bad api status code from /v2/ipfs/private/pubsub/publish/topic")
}
if mapAPIResp.Response["topic"] != "foo" {
t.Fatal("bad response")
}
if mapAPIResp.Response["message"] != "bar" {
t.Fatal("bad response")
}
// test object stat
// /v2/ipfs/private/stat
interfaceAPIResp = interfaceAPIResponse{}
if err := sendRequest(
api, "GET", "/v2/ipfs/private/stat/"+hash+"/abc123", 200, nil, nil, &interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
if interfaceAPIResp.Code != 200 {
t.Fatal("bad response status code from /v2/ipfs/private/stat")
}
// test get dag
// /v2/ipfs/private/dag
interfaceAPIResp = interfaceAPIResponse{}
if err := sendRequest(
api, "GET", "/v2/ipfs/private/dag/"+hash+"/abc123", 200, nil, nil, &interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
if interfaceAPIResp.Code != 200 {
t.Fatal("bad response status code from /v2/ipfs/private/dag/")
}
// test download
// /v2/ipfs/utils/download
urlValues = url.Values{}
urlValues.Add("network_name", "abc123")
if err := sendRequest(
api, "POST", "/v2/ipfs/utils/download/"+hash, 200, nil, urlValues, nil,
); err != nil {
t.Fatal(err)
}
// test get authorized networks
// /v2/ipfs/private/networks
interfaceAPIResp = interfaceAPIResponse{}
if err := sendRequest(
api, "GET", "/v2/ipfs/private/networks", 200, nil, nil, &interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
if interfaceAPIResp.Code != 200 {
t.Fatal("bad response status code from /v2/ipfs/private/networks/")
}
// test get authorized networks
// /v2/ipfs/private/networks
interfaceAPIResp = interfaceAPIResponse{}
if err := sendRequest(
api, "GET", "/v2/ipfs/private/uploads/abc123", 200, nil, nil, &interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
if interfaceAPIResp.Code != 200 {
t.Fatal("bad response status code from /v2/ipfs/private/uploads")
}
// test private network beam - source private, dest public
urlValues = url.Values{}
urlValues.Add("source_network", "abc123")
urlValues.Add("destination_network", "public")
urlValues.Add("content_hash", hash)
urlValues.Add("passphrase", "password123")
if err := sendRequest(
api, "POST", "/v2/ipfs/utils/laser/beam", 200, nil, urlValues, nil,
); err != nil {
t.Fatal(err)
}
// test private network beam - source public, dest private
// /v2/ipfs/utils/laser/beam
urlValues = url.Values{}
urlValues.Add("source_network", "public")
urlValues.Add("destination_network", "abc123")
urlValues.Add("content_hash", hash)
urlValues.Add("passphrase", "password123")
if err := sendRequest(
api, "POST", "/v2/ipfs/utils/laser/beam", 200, nil, urlValues, nil,
); err != nil {
t.Fatal(err)
}
// test private network beam - source private, dest private
// /v2/ipfs/utils/laser/beam
urlValues = url.Values{}
urlValues.Add("source_network", "abc123")
urlValues.Add("destination_network", "abc123")
urlValues.Add("content_hash", hash)
urlValues.Add("passphrase", "password123")
if err := sendRequest(
api, "POST", "/v2/ipfs/utils/laser/beam", 200, nil, urlValues, nil,
); err != nil {
t.Fatal(err)
}
// remove private network
// /v2/ipfs/private/network/remove
// for now until we implement proper grpc testing, this will fail
mapAPIResp = mapAPIResponse{}
urlValues = url.Values{}
urlValues.Add("network_name", "abc123")
fakeOrch.RemoveNetworkReturnsOnCall(0, &pbOrch.Empty{}, nil)
if err := sendRequest(
api, "DELETE", "/v2/ipfs/private/network/remove", 200, nil, urlValues, &mapAPIResp,
); err != nil {
t.Fatal(err)
}
if mapAPIResp.Code != 200 {
t.Fatal("bad api response status code from /v2/ipfs/private/network/remove")
}
if mapAPIResp.Response["state"] != "removed" {
t.Fatal("failed to remove network")
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_rtfs_test.go | api/v2/routes_rtfs_test.go | package v2
import (
"bytes"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"mime/multipart"
"net/http/httptest"
"net/url"
"os"
"testing"
"github.com/RTradeLtd/Temporal/mocks"
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/database/v2/models"
)
func Test_API_Routes_IPFS_Public(t *testing.T) {
// load configuration
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
// update the users tier
if err := api.usage.UpdateTier("testuser", models.Paid); err != nil {
t.Fatal(err)
}
// add a file normally
// /v2/ipfs/public/file/add
bodyBuf := &bytes.Buffer{}
bodyWriter := multipart.NewWriter(bodyBuf)
fileWriter, err := bodyWriter.CreateFormFile("file", "../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
fh, err := os.Open("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
defer fh.Close()
if _, err = io.Copy(fileWriter, fh); err != nil {
t.Fatal(err)
}
bodyWriter.Close()
testRecorder := httptest.NewRecorder()
req := httptest.NewRequest("POST", "/v2/ipfs/public/file/add", bodyBuf)
req.Header.Add("Authorization", authHeader)
req.Header.Add("Content-Type", bodyWriter.FormDataContentType())
urlValues := url.Values{}
urlValues.Add("hold_time", "5")
req.PostForm = urlValues
api.r.ServeHTTP(testRecorder, req)
if testRecorder.Code != 200 {
t.Fatal("bad http status code recovered from /v2/ipfs/public/file/add")
}
var apiResp apiResponse
// unmarshal the response
bodyBytes, err := ioutil.ReadAll(testRecorder.Result().Body)
if err != nil {
t.Fatal(err)
}
if err = json.Unmarshal(bodyBytes, &apiResp); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 200 {
t.Fatal("bad api status code from /v2/ipfs/public/file/add")
}
hash = apiResp.Response
// temporary fix for a badly written this
// this will be solved in test refactoring
models.NewUploadManager(db).NewUpload(
hash, "file", models.UploadOptions{
Username: "testuser",
NetworkName: "public",
Encrypted: false,
},
)
// test pinning - success
// /v2/ipfs/public/pin
apiResp = apiResponse{}
urlValues = url.Values{}
urlValues.Add("hold_time", "5")
if err := sendRequest(
api, "POST", "/v2/ipfs/public/pin/"+testPIN2, 200, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 200 {
fmt.Printf("%+v\n", apiResp)
t.Fatal("bad api status code from /v2/ipfs/public/pin")
}
// test pinning - failure (bad hash)
// /v2/ipfs/public/pin
apiResp = apiResponse{}
urlValues = url.Values{}
urlValues.Add("hold_time", "5")
if err := sendRequest(
api, "POST", "/v2/ipfs/public/pin/notarealhash", 400, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 400 {
t.Fatal("bad api status code from /v2/ipfs/public/pin")
}
// test pinning - failure (bad hold_time)
// /v2/ipfs/public/pin
apiResp = apiResponse{}
urlValues = url.Values{}
urlValues.Add("hold_time", "notanumber")
if err := sendRequest(
api, "POST", "/v2/ipfs/public/pin/"+hash, 400, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if apiResp.Code != 400 {
t.Fatal("bad api status code from /v2/ipfs/public/pin")
}
// test pubsub publish (success)
// /v2/ipfs/pubsub/publish/topic
urlValues = url.Values{}
urlValues.Add("message", "bar")
var mapAPIResp mapAPIResponse
if err := sendRequest(
api, "POST", "/v2/ipfs/public/pubsub/publish/foo", 200, nil, urlValues, &mapAPIResp,
); err != nil {
t.Fatal(err)
}
// validate the response code
if mapAPIResp.Code != 200 {
t.Fatal("bad api status code from /v2/pubsub/publish/topic")
}
if mapAPIResp.Response["topic"] != "foo" {
t.Fatal("bad response")
}
if mapAPIResp.Response["message"] != "bar" {
t.Fatal("bad response")
}
// test pubsub publish (fail)
// /v2/ipfs/pubsub/publish/topic
urlValues = url.Values{}
urlValues.Add("message", "")
apiResp = apiResponse{}
if err := sendRequest(
api, "POST", "/v2/ipfs/public/pubsub/publish/foo", 400, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
if apiResp.Code != 400 {
t.Fatal("bad response status code from /v2/ipfs/public/pubsub/publish")
}
// test object stat (success)
// /v2/ipfs/stat
var interfaceAPIResp interfaceAPIResponse
if err := sendRequest(
api, "GET", "/v2/ipfs/public/stat/"+hash, 200, nil, nil, &interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
if interfaceAPIResp.Code != 200 {
t.Fatal("bad response status code from /v2/ipfs/public/stat")
}
// test object stat (fail)
// /v2/ipfs/stat
interfaceAPIResp = interfaceAPIResponse{}
if err := sendRequest(
api, "GET", "/v2/ipfs/public/stat/notarealhash", 400, nil, nil, &interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
if interfaceAPIResp.Code != 400 {
t.Fatal("bad response status code from /v2/ipfs/public/stat")
}
// test get dag (success)
// /v2/ipfs/public/dag
interfaceAPIResp = interfaceAPIResponse{}
if err := sendRequest(
api, "GET", "/v2/ipfs/public/dag/"+hash, 200, nil, nil, &interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
if interfaceAPIResp.Code != 200 {
t.Fatal("bad response status code from /v2/ipfs/public/dag/")
}
// test get dag (fail)
// /v2/ipfs/public/dag
interfaceAPIResp = interfaceAPIResponse{}
if err := sendRequest(
api, "GET", "/v2/ipfs/public/dag/notarealhash", 400, nil, nil, &interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
if interfaceAPIResp.Code != 400 {
t.Fatal("bad response status code from /v2/ipfs/public/dag/")
}
// test download
// /v2/ipfs/utils/download
if err := sendRequest(
api, "POST", "/v2/ipfs/utils/download/"+hash, 200, nil, nil, nil,
); err != nil {
t.Fatal(err)
}
// test public network beam
// /v2/ipfs/utils/laser/beam
urlValues = url.Values{}
urlValues.Add("source_network", "public")
urlValues.Add("destination_network", "public")
urlValues.Add("content_hash", hash)
urlValues.Add("passphrase", "password123")
if err := sendRequest(
api, "POST", "/v2/ipfs/utils/laser/beam", 200, nil, urlValues, nil,
); err != nil {
t.Fatal(err)
}
// test extend pin
// /v2/ipfs/public/pin/:hash/extend
urlValues = url.Values{}
urlValues.Add("hold_time", "5")
apiResp = apiResponse{}
if err := sendRequest(
api, "POST", "/v2/ipfs/public/pin/"+hash+"/extend", 200, nil, urlValues, &apiResp,
); err != nil {
t.Fatal(err)
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_lens_test.go | api/v2/routes_lens_test.go | package v2
import (
"errors"
"net/url"
"testing"
"github.com/RTradeLtd/Temporal/mocks"
"github.com/RTradeLtd/config/v2"
pb "github.com/RTradeLtd/grpc/lensv2"
)
var (
lensTestHash = "QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv"
)
func Test_API_Routes_Lens_Index(t *testing.T) {
type args struct {
objectType string
objectIdentifier string
reindex string
callCount int
err error
}
tests := []struct {
name string
args args
wantStatus int
}{
{"Index-Requqest-Pass-Reindex", args{"ipld", lensTestHash, "true", 0, nil}, 200},
{"Index-Request-Pass-NoReindex", args{"ipld", lensTestHash, "false", 0, nil}, 200},
{"Index-Request-Fail-Reindex", args{"ipld", lensTestHash, "true", 0, errors.New("bad")}, 400},
{"Index-Request-Fail-NoReindex", args{"ipld", lensTestHash, "false", 0, errors.New("bad")}, 400},
{"Index-Bad-Object-Type", args{"storj", lensTestHash, "false", 0, errors.New("bad")}, 400},
{"Index-Bad-Object-Identifier", args{"ipld", "blah", "false", 0, errors.New("bad")}, 400},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
var interfaceAPIResp interfaceAPIResponse
urlValues := url.Values{}
urlValues.Add("object_identifier", tt.args.objectIdentifier)
urlValues.Add("object_type", tt.args.objectType)
urlValues.Add("reindex", tt.args.reindex)
fakeLens.IndexReturnsOnCall(tt.args.callCount, &pb.IndexResp{Doc: &pb.Document{Hash: tt.args.objectIdentifier}}, tt.args.err)
if err := sendRequest(
api, "POST", "/v2/lens/index", tt.wantStatus, nil, urlValues, &interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
if interfaceAPIResp.Code != tt.wantStatus {
t.Fatalf("bad api response status = %v, wantStatus %v", interfaceAPIResp.Code, tt.wantStatus)
}
})
}
}
func Test_API_Routes_Lens_Search(t *testing.T) {
// index tests
type args struct {
query string
tag string
category string
mimeType string
hash string
required string
callCount int
result bool
err error
}
testsIndex := []struct {
name string
args args
wantStatus int
}{
{"Search-Pass-NoResponse", args{"dog", "food", "isnt", "very", "good", "tasting", 0, false, nil}, 400},
{"Search-Pass-Response", args{"cat", "food", "is", "even", "worse", "tasting", 0, true, nil}, 200},
{"Search-Fail", args{"pet", "food", "is", "bad", "in", "general", 0, false, errors.New("bad")}, 400},
}
for _, tt := range testsIndex {
t.Run(tt.name, func(t *testing.T) {
cfg, err := config.LoadConfig("../../testenv/config.json")
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
// setup fake mock clients
fakeLens := &mocks.FakeLensV2Client{}
fakeOrch := &mocks.FakeServiceClient{}
fakeSigner := &mocks.FakeSignerClient{}
fakeWalletService := &mocks.FakeWalletServiceClient{}
api, err := setupAPI(t, fakeLens, fakeOrch, fakeSigner, fakeWalletService, cfg, db)
if err != nil {
t.Fatal(err)
}
if !tt.args.result {
fakeLens.SearchReturnsOnCall(
tt.args.callCount,
&pb.SearchResp{},
tt.args.err,
)
} else {
fakeLens.SearchReturnsOnCall(
tt.args.callCount,
&pb.SearchResp{
Results: []*pb.SearchResp_Result{
{
Score: 0.32,
},
},
},
tt.args.err,
)
}
var interfaceAPIResp interfaceAPIResponse
urlValues := url.Values{}
urlValues.Add("query", tt.args.query)
urlValues.Add("tags", tt.args.tag)
urlValues.Add("categories", tt.args.category)
urlValues.Add("hashes", tt.args.hash)
urlValues.Add("required", tt.args.required)
if err := sendRequest(
api, "POST", "/v2/lens/search", tt.wantStatus, nil, urlValues, &interfaceAPIResp,
); err != nil {
t.Fatal(err)
}
if interfaceAPIResp.Code != tt.wantStatus {
t.Fatalf("bad api response status = %v, wantStatus %v", interfaceAPIResp.Code, tt.wantStatus)
}
})
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/doc.go | api/v2/doc.go | // Package v2 is the main package for Temporal's V2 http API.
// API reference is available [here](https://documenter.getpostman.com/view/4295780/RWEcQM6W#intro)
package v2
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_swarm.go | api/v2/routes_swarm.go | package v2
import (
"errors"
"io/ioutil"
"net/http"
"github.com/RTradeLtd/Temporal/eh"
"github.com/RTradeLtd/Temporal/utils"
"github.com/RTradeLtd/database/v2/models"
"github.com/gin-gonic/gin"
)
// SwarmUpload is used to upload data to ethereum swarm
func (api *API) SwarmUpload(c *gin.Context) {
if len(api.swarmEndpoints) == 0 {
Fail(c, errors.New("must have at least one swarm client"))
return
}
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
holdTime := c.PostForm("hold_time")
holdTimeInMonthsInt, err := api.validateHoldTime(username, holdTime)
if err != nil {
Fail(c, err)
return
}
fileHandler, err := c.FormFile("file")
if err != nil {
Fail(c, err)
return
}
fileSize := fileHandler.Size
// ensure file size is within acceptable parameters
if err := api.FileSizeCheck(fileHandler.Size); err != nil {
Fail(c, err)
return
}
// calculate the cost of the file
cost, err := utils.CalculateFileCost(username, holdTimeInMonthsInt, fileSize, api.usage)
if err != nil {
api.LogError(c, err, eh.CostCalculationError)(http.StatusBadRequest)
return
}
// validate they have enough credits to pay for the upload
if err = api.validateUserCredits(username, cost); err != nil {
api.LogError(c, err, eh.InvalidBalanceError)(http.StatusPaymentRequired)
return
}
// update their data usage
if err := api.usage.UpdateDataUsage(username, uint64(fileSize)); err != nil {
api.LogError(c, err, eh.CantUploadError)(http.StatusBadRequest)
api.refundUserCredits(username, "file", cost)
return
}
// now begin with the actual file uploading
isTar := c.PostForm("is_tar")
// open file handler
openFile, err := fileHandler.Open()
if err != nil {
Fail(c, err)
api.refundUserCredits(username, "file", cost)
api.usage.ReduceDataUsage(username, uint64(fileSize))
return
}
// read file data
fileBytes, err := ioutil.ReadAll(openFile)
if err != nil {
Fail(c, err)
api.refundUserCredits(username, "file", cost)
api.usage.ReduceDataUsage(username, uint64(fileSize))
return
}
// upload to both of our swarm nodes
swarmHash, err := api.swarmUpload(fileBytes, isTar == "true")
if err != nil {
api.LogError(c, err, err.Error())
api.refundUserCredits(username, "file", cost)
api.usage.ReduceDataUsage(username, uint64(fileSize))
return
}
// update uploads
if _, err := api.upm.NewUpload(swarmHash, "swarm-file", models.UploadOptions{
Username: username,
NetworkName: "etherswarm",
HoldTimeInMonths: holdTimeInMonthsInt,
Size: fileSize,
}); err != nil {
Fail(c, err)
api.refundUserCredits(username, "file", cost)
api.usage.ReduceDataUsage(username, uint64(fileSize))
return
}
Respond(c, http.StatusOK, gin.H{"response": swarmHash})
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/api/v2/routes_database.go | api/v2/routes_database.go | package v2
import (
"errors"
"html"
"net/http"
"strings"
"github.com/RTradeLtd/Temporal/eh"
"github.com/RTradeLtd/database/v2/models"
"github.com/gin-gonic/gin"
)
// allows performing arbitrary searches against upload file names
func (api *API) searchUploadsForUser(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
forms, missingField := api.extractPostForms(c, "search_query")
if missingField != "" {
FailWithMissingField(c, missingField)
return
}
// escape string to prevent html encoded characters causing issues
forms["search_query"] = html.UnescapeString(forms["search_query"])
// force lower-case to make matching more likely s
lower := strings.ToLower(forms["search_query"])
// just in case lets try and avoid any possible headaches
if strings.Contains(lower, "drop table") ||
strings.Contains(lower, "drop column") ||
strings.Contains(lower, "drop row") ||
strings.Contains(lower, "delete table") ||
strings.Contains(lower, "delete column") ||
strings.Contains(lower, "delete row") {
Fail(c, errors.New("possible sql injection attack, goodbye"), http.StatusBadRequest)
return
}
if c.Query("paged") == "true" {
api.pageIt(
c,
api.upm.DB.Where(
"user_name = ? AND file_name_lower_case LIKE ?",
username, lower,
),
&[]models.Upload{},
)
return
}
uploads, err := api.upm.Search(username, lower)
if err != nil {
api.LogError(c, err, eh.UploadSearchError)(http.StatusBadRequest)
return
}
Respond(c, http.StatusOK, gin.H{"response": uploads})
}
// GetUploadsForUser is used to retrieve all uploads for the authenticated user
func (api *API) getUploadsForUser(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
if c.Query("paged") == "true" {
api.pageIt(c, api.upm.DB.Where("user_name = ?", username), &[]models.Upload{})
return
}
// fetch all uploads by the specified user
uploads, err := api.upm.GetUploadsForUser(username)
if err != nil {
api.LogError(c, err, eh.UploadSearchError)(http.StatusInternalServerError)
return
}
// log and return
api.l.Info("specific uploads from database requested")
Respond(c, http.StatusOK, gin.H{"response": uploads})
}
// getUploadsByNetworkName is used to get uploads for a network by its name
func (api *API) getUploadsByNetworkName(c *gin.Context) {
username, err := GetAuthenticatedUserFromContext(c)
if err != nil {
api.LogError(c, err, eh.NoAPITokenError)(http.StatusBadRequest)
return
}
// get network name to retrieve uploads from
networkName := c.Param("networkName")
// validate the user can access the network
if err := CheckAccessForPrivateNetwork(username, networkName, api.dbm.DB); err != nil {
api.LogError(c, err, eh.PrivateNetworkAccessError)(http.StatusBadRequest)
return
}
if c.Query("paged") == "true" {
api.pageIt(c, api.upm.DB.Where(
"user_name = ? AND network_name = ?",
username, networkName,
), &[]models.Upload{})
return
}
// find uploads for the network
uploads, err := api.upm.FindUploadsByNetwork(networkName)
if err != nil {
api.LogError(c, err, eh.UploadSearchError)(http.StatusInternalServerError)
return
}
// log and return
api.l.Infow("uploads forprivate ifps network requested", "user", username)
Respond(c, http.StatusOK, gin.H{"response": uploads})
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/queue/queue_test.go | queue/queue_test.go | package queue
import (
"context"
"sync"
"testing"
"time"
"go.uber.org/zap/zaptest"
"github.com/streadway/amqp"
"github.com/RTradeLtd/config/v2"
"github.com/RTradeLtd/database/v2"
"github.com/jinzhu/gorm"
)
const (
testCID = "QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv"
testCID2 = "QmQ5vhrL7uv6tuoN9KeVBwd4PwfQkXdVVmDLUZuTNxqgvm"
testRabbitAddress = "amqp://127.0.0.1:5672"
testLogFilePath = "../testenv/"
testCfgPath = "../testenv/config.json"
)
func TestQueue_Publish(t *testing.T) {
dev = true
type args struct {
queueName Queue
publish bool
}
tests := []struct {
name string
args args
}{
{"PConfirmQ", args{EthPaymentConfirmationQueue, true}},
{"DPCQ", args{DashPaymentConfirmationQueue, true}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
logger := zaptest.NewLogger(t).Sugar()
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
qm, err := New(tt.args.queueName,
testRabbitAddress, tt.args.publish, dev, cfg, logger)
if err != nil {
t.Fatal(err)
}
if tt.name == "PConfirmQ" {
// test a successful publish
if err := qm.PublishMessage(EthPaymentConfirmation{
UserName: "testuser",
PaymentNumber: 22,
}); err != nil {
t.Fatal(err)
}
// test a bad publish
if err := qm.PublishMessage(map[string]interface{}{
"foo": make(chan int),
}); err == nil {
t.Fatal("expected error")
}
} else if tt.name == "DPCQ" {
// test a successful publish
if err := qm.PublishMessage(DashPaymenConfirmation{
UserName: "testuser",
PaymentForwardID: "paymentforwardi",
PaymentNumber: 23,
}); err != nil {
t.Fatal(err)
}
// test a bad publish
if err := qm.PublishMessage(map[string]interface{}{
"foo": make(chan int),
}); err == nil {
t.Fatal("expected error")
}
}
})
}
}
func TestRegisterChannelClosure(t *testing.T) {
dev = true
logger := zaptest.NewLogger(t).Sugar()
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
qmPublisher, err := New(IpfsPinQueue, testRabbitAddress, true, dev, cfg, logger)
if err != nil {
t.Fatal(err)
}
// declare the channel to receive messages on
qmPublisher.RegisterConnectionClosure()
go func() {
qmPublisher.ErrCh <- &amqp.Error{Code: 400, Reason: "test", Server: true, Recover: false}
}()
msg := <-qmPublisher.ErrCh
if msg.Code != 400 {
t.Fatal("bad code received")
}
if msg.Reason != "test" {
t.Fatal("bad reason")
}
if !msg.Server {
t.Fatal("bad server")
}
if msg.Recover {
t.Fatal("bad recover")
}
if err := qmPublisher.Close(); err != nil {
t.Fatal(err)
}
}
func TestQueue_RefundCredits(t *testing.T) {
dev = true
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
logger := zaptest.NewLogger(t).Sugar()
// setup our queue backend
qmConsumer, err := New(IpfsClusterPinQueue, testRabbitAddress, false, dev, cfg, logger)
if err != nil {
t.Fatal(err)
}
qmConsumer.db = db
type args struct {
username string
callType string
cost float64
}
tests := []struct {
name string
args args
wantErr bool
}{
{"HasCost", args{"testuser", "ipfs-pin", 1}, false},
{"NoCost", args{"testuser", "ipfs-pin", 0}, false},
{"RefundFail", args{"userdoesnotexist", "ipfs-pin", 10}, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := qmConsumer.refundCredits(tt.args.username, tt.args.callType, tt.args.cost); (err != nil) != tt.wantErr {
t.Fatal(err)
}
})
}
}
func TestQueue_ConnectionClosure(t *testing.T) {
dev = true
logger := zaptest.NewLogger(t).Sugar()
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
type args struct {
queueName Queue
}
tests := []struct {
name string
args args
}{
{IpfsClusterPinQueue.String(), args{IpfsClusterPinQueue}},
{EmailSendQueue.String(), args{EmailSendQueue}},
{IpnsEntryQueue.String(), args{IpnsEntryQueue}},
{IpfsPinQueue.String(), args{IpfsPinQueue}},
{IpfsKeyCreationQueue.String(), args{IpfsKeyCreationQueue}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
qmPublisher, err := New(tt.args.queueName, testRabbitAddress, false, dev, cfg, logger)
if err != nil {
t.Fatal(err)
}
wg := &sync.WaitGroup{}
wg.Add(1)
go func() {
if err := qmPublisher.ConsumeMessages(context.Background(), wg, db, cfg); err != nil && err.Error() != ErrReconnect {
t.Error(err)
}
}()
go func() {
qmPublisher.ErrCh <- &amqp.Error{Code: 400, Reason: "error", Server: true, Recover: false}
}()
wg.Wait()
})
}
}
// Does not conduct validation of whether or not a message was successfully processed
func TestQueue_IPFSClusterPin(t *testing.T) {
dev = true
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
loggerConsumer := zaptest.NewLogger(t).Sugar()
loggerPublisher := zaptest.NewLogger(t).Sugar()
// setup our queue backend
qmConsumer, err := New(IpfsClusterPinQueue, testRabbitAddress, false, dev, cfg, loggerConsumer)
if err != nil {
t.Fatal(err)
}
qmPublisher, err := New(IpfsClusterPinQueue, testRabbitAddress, true, dev, cfg, loggerPublisher)
if err != nil {
t.Fatal(err)
}
defer func() {
if err := qmPublisher.Close(); err != nil {
t.Error(err)
}
}()
// test an already seen update (this comes from the previous database file add)
if err := qmPublisher.PublishMessage(IPFSClusterPin{
CID: testCID,
NetworkName: "public",
UserName: "testuser",
HoldTimeInMonths: 10,
CreditCost: 10,
}); err != nil {
t.Fatal(err)
}
// test a previously unseen upload
if err := qmPublisher.PublishMessage(IPFSClusterPin{
CID: testCID2,
NetworkName: "public",
UserName: "testuser",
HoldTimeInMonths: 10,
CreditCost: 10,
}); err != nil {
t.Fatal(err)
}
// test a bad publish
if err := qmPublisher.PublishMessage(""); err != nil {
t.Fatal(err)
}
// test private network detection
if err := qmPublisher.PublishMessage(IPFSClusterPin{
CID: testCID,
NetworkName: "myprivatenetwork",
UserName: "testuser",
HoldTimeInMonths: 10,
CreditCost: 10,
}); err != nil {
t.Fatal(err)
}
// test invalid cid format
if err := qmPublisher.PublishMessage(IPFSClusterPin{
CID: "notarealcid",
NetworkName: "public",
UserName: "testuser",
HoldTimeInMonths: 10,
CreditCost: 10,
}); err != nil {
t.Fatal(err)
}
waitGroup := &sync.WaitGroup{}
waitGroup.Add(1)
ctx, cancel := context.WithTimeout(context.Background(), time.Second*20)
defer cancel()
if err = qmConsumer.ConsumeMessages(ctx, waitGroup, db, cfg); err != nil {
t.Fatal(err)
}
waitGroup.Wait()
}
// Does not conduct validation of whether or not a message was successfully processed
func TestQueue_EmailSend(t *testing.T) {
dev = true
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
loggerConsumer := zaptest.NewLogger(t).Sugar()
loggerPublisher := zaptest.NewLogger(t).Sugar()
// setup our queue backend
qmConsumer, err := New(EmailSendQueue, testRabbitAddress, false, dev, cfg, loggerConsumer)
if err != nil {
t.Fatal(err)
}
qmPublisher, err := New(EmailSendQueue, testRabbitAddress, true, dev, cfg, loggerPublisher)
if err != nil {
t.Fatal(err)
}
defer func() {
if err := qmPublisher.Close(); err != nil {
t.Error(err)
}
}()
// test a email send
if err := qmPublisher.PublishMessage(EmailSend{
Subject: "test email",
Content: "this is a test email",
ContentType: "text/html",
UserNames: []string{"testuser", "testuser"},
Emails: []string{"testuser@example.com", "testuser2@example.com"},
}); err != nil {
t.Fatal(err)
}
// test a bad publish
if err := qmPublisher.PublishMessage(""); err != nil {
t.Fatal(err)
}
waitGroup := &sync.WaitGroup{}
waitGroup.Add(1)
ctx, cancel := context.WithTimeout(context.Background(), time.Second*20)
defer cancel()
if err = qmConsumer.ConsumeMessages(ctx, waitGroup, db, cfg); err != nil {
t.Fatal(err)
}
waitGroup.Wait()
}
// Does not conduct validation of whether or not a message was successfully processed
func TestQueue_IPNSEntry(t *testing.T) {
dev = true
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
cfg.Services.RTNS.DatastorePath = "test-ipns"
cfg.Services.RTNS.MultiAddresses = []string{"/ip4/0.0.0.0/tcp/3999"}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
loggerConsumer := zaptest.NewLogger(t).Sugar()
loggerPublisher := zaptest.NewLogger(t).Sugar()
// setup our queue backend
qmConsumer, err := New(IpnsEntryQueue, testRabbitAddress, false, dev, cfg, loggerConsumer)
if err != nil {
t.Fatal(err)
}
qmPublisher, err := New(IpnsEntryQueue, testRabbitAddress, true, dev, cfg, loggerPublisher)
if err != nil {
t.Fatal(err)
}
defer func() {
if err := qmPublisher.Close(); err != nil {
t.Error(err)
}
}()
// test a valid publish
if err := qmPublisher.PublishMessage(IPNSEntry{
CID: testCID,
LifeTime: time.Minute,
TTL: time.Second,
Resolve: true,
Key: "testkey",
UserName: "testuser",
NetworkName: "public",
CreditCost: 10,
}); err != nil {
t.Fatal(err)
}
// test a bad publish
if err := qmPublisher.PublishMessage(""); err != nil {
t.Fatal(err)
}
// test private network detection
if err := qmPublisher.PublishMessage(IPNSEntry{
CID: testCID,
LifeTime: time.Minute,
TTL: time.Second,
Resolve: true,
Key: "testkey",
UserName: "testuser",
NetworkName: "myprivatenetwork",
CreditCost: 10,
}); err != nil {
t.Fatal(err)
}
waitGroup := &sync.WaitGroup{}
waitGroup.Add(1)
ctx, cancel := context.WithTimeout(context.Background(), time.Second*20)
defer cancel()
if err = qmConsumer.ConsumeMessages(ctx, waitGroup, db, cfg); err != nil {
t.Fatal(err)
}
waitGroup.Wait()
}
// Does not conduct validation of whether or not a message was successfully processed
func TestQueue_IPFSPin(t *testing.T) {
dev = true
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
loggerConsumer := zaptest.NewLogger(t).Sugar()
loggerPublisher := zaptest.NewLogger(t).Sugar()
// setup our queue backend
qmConsumer, err := New(IpfsPinQueue, testRabbitAddress, false, dev, cfg, loggerConsumer)
if err != nil {
t.Fatal(err)
}
qmPublisher, err := New(IpfsPinQueue, testRabbitAddress, true, dev, cfg, loggerPublisher)
if err != nil {
t.Fatal(err)
}
defer func() {
if err := qmPublisher.Close(); err != nil {
t.Error(err)
}
}()
// test a valid pin
if err := qmPublisher.PublishMessage(IPFSPin{
CID: testCID,
NetworkName: "public",
HoldTimeInMonths: 10},
); err != nil {
t.Fatal(err)
}
// test a bad publish
if err := qmPublisher.PublishMessage(""); err != nil {
t.Fatal(err)
}
// test a private network
if err := qmPublisher.PublishMessage(IPFSPin{
CID: testCID,
NetworkName: "myprivatenetwork",
HoldTimeInMonths: 10},
); err != nil {
t.Fatal(err)
}
waitGroup := &sync.WaitGroup{}
waitGroup.Add(1)
// set temporary log dig
cfg.LogDir = "./tmp/"
ctx, cancel := context.WithTimeout(context.Background(), time.Second*20)
defer cancel()
if err = qmConsumer.ConsumeMessages(ctx, waitGroup, db, cfg); err != nil {
t.Fatal(err)
}
waitGroup.Wait()
}
// Does not conduct validation of whether or not a message was successfully processed
func TestQueue_IPFSKeyCreation(t *testing.T) {
dev = true
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
loggerConsumer := zaptest.NewLogger(t).Sugar()
loggerPublisher := zaptest.NewLogger(t).Sugar()
// setup our queue backend
qmConsumer, err := New(IpfsKeyCreationQueue, testRabbitAddress, false, dev, cfg, loggerConsumer)
if err != nil {
t.Fatal(err)
}
qmPublisher, err := New(IpfsKeyCreationQueue, testRabbitAddress, true, dev, cfg, loggerPublisher)
if err != nil {
t.Fatal(err)
}
defer func() {
if err := qmPublisher.Close(); err != nil {
t.Error(err)
}
}()
// test a normal publish
if err := qmPublisher.PublishMessage(IPFSKeyCreation{
UserName: "testuser",
Name: "testuser-mykey",
Type: "rsa",
Size: 2048,
NetworkName: "public",
CreditCost: 0},
); err != nil {
t.Fatal(err)
}
if err := qmPublisher.PublishMessage(IPFSKeyCreation{
UserName: "testuser",
Name: "mykey",
Type: "rsa",
Size: 2048,
NetworkName: "public",
CreditCost: 0},
); err != nil {
t.Fatal(err)
}
// test a bad publish
if err := qmPublisher.PublishMessage(""); err != nil {
t.Fatal(err)
}
waitGroup := &sync.WaitGroup{}
waitGroup.Add(1)
ctx, cancel := context.WithTimeout(context.Background(), time.Second*20)
defer cancel()
if err = qmConsumer.ConsumeMessages(ctx, waitGroup, db, cfg); err != nil {
t.Fatal(err)
}
waitGroup.Wait()
}
func TestQueue_IPFSKeyCreation_Failure(t *testing.T) {
dev = true
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
loggerConsumer := zaptest.NewLogger(t).Sugar()
loggerPublisher := zaptest.NewLogger(t).Sugar()
// setup our queue backend
qmConsumer, err := New(IpfsKeyCreationQueue, testRabbitAddress, false, dev, cfg, loggerConsumer)
if err != nil {
t.Fatal(err)
}
qmPublisher, err := New(IpfsKeyCreationQueue, testRabbitAddress, true, dev, cfg, loggerPublisher)
if err != nil {
t.Fatal(err)
}
defer func() {
if err := qmPublisher.Close(); err != nil {
t.Error(err)
}
}()
if err := qmPublisher.PublishMessage(IPFSKeyCreation{
UserName: "testuser",
Name: "mykey",
Type: "rsa",
Size: 2048,
NetworkName: "public",
CreditCost: 0},
); err != nil {
t.Fatal(err)
}
cfg.Services.Krab.TLS.CertPath = "/root"
ctx, cancel := context.WithTimeout(context.Background(), time.Second*20)
defer cancel()
if err = qmConsumer.ConsumeMessages(ctx, &sync.WaitGroup{}, db, cfg); err == nil {
t.Fatal("expected error")
}
}
func TestQueue_IPFSPin_Failure_RabbitMQ(t *testing.T) {
dev = true
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
loggerConsumer := zaptest.NewLogger(t).Sugar()
// setup our queue backend
qmConsumer, err := New(IpfsPinQueue, testRabbitAddress, false, dev, cfg, loggerConsumer)
if err != nil {
t.Fatal(err)
}
cfg.RabbitMQ.URL = "notarealurl"
// we don't need time-out since this test will automatically fail
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
if err = qmConsumer.ConsumeMessages(ctx, &sync.WaitGroup{}, db, cfg); err == nil {
t.Fatal("expected error")
}
}
func TestQueue_IPFSPin_Failure_LogFile(t *testing.T) {
dev = true
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
loggerConsumer := zaptest.NewLogger(t).Sugar()
// setup our queue backend
qmConsumer, err := New(IpfsPinQueue, testRabbitAddress, false, dev, cfg, loggerConsumer)
if err != nil {
t.Fatal(err)
}
cfg.LogDir = "/root/toor"
// we don't need time-out since this test will automatically fail
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
if err = qmConsumer.ConsumeMessages(ctx, &sync.WaitGroup{}, db, cfg); err == nil {
t.Fatal("expected error")
}
}
func TestQueue_IPNSEntry_Failure_Krab(t *testing.T) {
dev = true
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
db, err := loadDatabase(cfg)
if err != nil {
t.Fatal(err)
}
loggerConsumer := zaptest.NewLogger(t).Sugar()
// setup our queue backend
qmConsumer, err := New(IpnsEntryQueue, testRabbitAddress, false, dev, cfg, loggerConsumer)
if err != nil {
t.Fatal(err)
}
cfg.Services.Krab.TLS.CertPath = "/root/toor"
// we don't need time-out since this test will automatically fail
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
if err = qmConsumer.ConsumeMessages(ctx, &sync.WaitGroup{}, db, cfg); err == nil {
t.Fatal(err)
}
}
func TestQueue_Bad_TLS_Config_CACertFile(t *testing.T) {
dev = true
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
logger := zaptest.NewLogger(t).Sugar()
cfg.RabbitMQ.TLSConfig.CACertFile = "../README.md"
if _, err := New(IpnsEntryQueue, cfg.RabbitMQ.URL, false, dev, cfg, logger); err == nil {
t.Fatal("expected error")
}
cfg.RabbitMQ.TLSConfig.CACertFile = "/root/toor"
if _, err := New(IpnsEntryQueue, cfg.RabbitMQ.URL, false, dev, cfg, logger); err == nil {
t.Fatal("expected error")
}
}
func loadDatabase(cfg *config.TemporalConfig) (*gorm.DB, error) {
dbm, err := database.New(cfg, database.Options{SSLModeDisable: true})
if err != nil {
return nil, err
}
return dbm.DB, nil
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/queue/ipfs.go | queue/ipfs.go | package queue
import (
"context"
"encoding/json"
"errors"
"fmt"
"strings"
"sync"
"time"
kaas "github.com/RTradeLtd/kaas/v2"
"github.com/RTradeLtd/rtfs/v2"
"github.com/RTradeLtd/database/v2/models"
"github.com/jinzhu/gorm"
"github.com/streadway/amqp"
"go.bobheadxi.dev/zapx/zapx"
pb "github.com/RTradeLtd/grpc/krab"
ci "github.com/libp2p/go-libp2p-core/crypto"
peer "github.com/libp2p/go-libp2p-core/peer"
)
// ProcessIPFSKeyCreation is used to create IPFS keys
func (qm *Manager) ProcessIPFSKeyCreation(ctx context.Context, wg *sync.WaitGroup, msgs <-chan amqp.Delivery) error {
kbPrimary, err := kaas.NewClient(qm.cfg.Services, false)
if err != nil {
return err
}
var kbBackup *kaas.Client
if !qm.dev {
kbBackup, err = kaas.NewClient(qm.cfg.Services, true)
if err != nil {
return err
}
}
userManager := models.NewUserManager(qm.db)
qm.l.Info("processing ipfs key creation requests")
for {
select {
case d := <-msgs:
wg.Add(1)
go qm.processIPFSKeyCreation(d, wg, kbPrimary, kbBackup, userManager)
case <-ctx.Done():
qm.Close()
wg.Done()
return nil
case msg := <-qm.ErrCh:
qm.Close()
wg.Done()
qm.l.Errorw(
"a protocol connection error stopping rabbitmq was received",
"error", msg.Error())
return errors.New(ErrReconnect)
}
}
}
// ProccessIPFSPins is used to process IPFS pin requests
func (qm *Manager) ProccessIPFSPins(ctx context.Context, wg *sync.WaitGroup, msgs <-chan amqp.Delivery) error {
userManager := models.NewUserManager(qm.db)
networkManager := models.NewHostedNetworkManager(qm.db)
uploadManager := models.NewUploadManager(qm.db)
// TODO: new loggers should not be instantiated here
logger, err := zapx.New(qm.cfg.LogDir+"cluster_publisher.log", false)
if err != nil {
return err
}
// initialize a connection to the cluster pin queue so we can trigger pinning of this content to our cluster
qmCluster, err := New(IpfsClusterPinQueue, qm.cfg.RabbitMQ.URL, true, dev, qm.cfg, logger.Sugar())
if err != nil {
qm.l.Errorw("failed to intialize cluster pin queue connection", "error", err.Error())
return err
}
ipfsManager, err := rtfs.NewManager(qm.cfg.IPFS.APIConnection.Host+":"+qm.cfg.IPFS.APIConnection.Port, "", time.Minute*60)
if err != nil {
qm.l.Errorw("failed to initialize connection to ipfs", "error", err.Error())
return err
}
qm.l.Info("processing ipfs pins")
for {
select {
case d := <-msgs:
wg.Add(1)
go qm.processIPFSPin(d, wg, userManager, networkManager, uploadManager, qmCluster, ipfsManager)
case <-ctx.Done():
qm.Close()
wg.Done()
return nil
case msg := <-qm.ErrCh:
qm.Close()
wg.Done()
qm.l.Errorw(
"a protocol connection error stopping rabbitmq was received",
"error", msg.Error())
return errors.New(ErrReconnect)
}
}
}
func (qm *Manager) processIPFSPin(d amqp.Delivery, wg *sync.WaitGroup, usrm *models.UserManager, nm *models.HostedNetworkManager, upldm *models.UploadManager, qmCluster *Manager, ipfsManager *rtfs.IpfsManager) {
defer wg.Done()
qm.l.Info("new pin request detected")
pin := &IPFSPin{}
if err := json.Unmarshal(d.Body, pin); err != nil {
qm.l.Errorw("failed to unmarshal message", "error", err.Error())
d.Ack(false)
return
}
// check whether or not this pin is for a private network
// if it is, verify whether the user has acess to the network, and retrieve the api url
if pin.NetworkName != "public" {
canAccess, err := usrm.CheckIfUserHasAccessToNetwork(pin.UserName, pin.NetworkName)
if err != nil {
qm.l.Errorw("failed to lookup private network in database", "error", err.Error())
d.Ack(false)
return
}
if !canAccess {
qm.l.Errorw(
"unauthorized private network access",
"error", errors.New("user does not have access to private network").Error(),
"user", pin.UserName)
d.Ack(false)
return
}
apiURL := fmt.Sprintf("%s/network/%s/api", qm.cfg.Nexus.Host+":"+qm.cfg.Nexus.Delegator.Port, pin.NetworkName)
// connect to ipfs
ipfsManager, err = rtfs.NewManager(apiURL, pin.JWT, time.Minute*60)
if err != nil {
qm.l.Infow(
"failed to initialize connection to ipfs",
"error", err.Error(),
"user", pin.UserName,
"network", pin.NetworkName)
d.Ack(false)
return
}
}
qm.l.Infow(
"initializing connection to ipfs",
"user", pin.UserName)
qm.l.Infow(
"pinning hash to ipfs",
"cid", pin.CID,
"user", pin.UserName,
"network", pin.NetworkName)
// pin the content
if err := ipfsManager.Pin(pin.CID); err != nil {
if pin.NetworkName == "public" {
qm.refundCredits(pin.UserName, "pin", pin.CreditCost)
}
models.NewUsageManager(qm.db).ReduceDataUsage(pin.UserName, uint64(pin.Size))
qm.l.Errorw(
"failed to pin hash to ipfs",
"error", err.Error(),
"user", pin.UserName,
"network", pin.NetworkName)
d.Ack(false)
return
}
// cluster support for private networks isn't available yet
// as such, skip additional processing for cluster pins
qm.l.Infof(
"successfully process pin request",
"user", pin.UserName,
"network", pin.NetworkName)
upload, err := upldm.FindUploadByHashAndUserAndNetwork(pin.UserName, pin.CID, pin.NetworkName)
if err != nil && err != gorm.ErrRecordNotFound {
qm.l.Errorw(
"fail to check database for upload",
"error", err.Error(),
"user", pin.UserName)
d.Ack(false)
return
}
// check whether or not we have seen this content hash before to determine how database needs to be updated
if upload == nil {
_, err = upldm.NewUpload(pin.CID, "pin", models.UploadOptions{
NetworkName: pin.NetworkName,
Username: pin.UserName,
HoldTimeInMonths: pin.HoldTimeInMonths,
FileName: pin.FileName,
Size: pin.Size})
} else {
// the record already exists so we will update
_, err = upldm.UpdateUpload(pin.HoldTimeInMonths, pin.UserName, pin.CID, pin.NetworkName)
}
// validate whether or not the database was updated properly
if err != nil {
qm.l.Errorw(
"failed to update database",
"error", err.Error(),
"user", pin.UserName)
}
d.Ack(false)
}
func (qm *Manager) processIPFSKeyCreation(d amqp.Delivery, wg *sync.WaitGroup, kbPrimary *kaas.Client, kbBackup *kaas.Client, um *models.UserManager) {
defer wg.Done()
qm.l.Info("new key creation request detected")
key := IPFSKeyCreation{}
if err := json.Unmarshal(d.Body, &key); err != nil {
qm.l.Errorw(
"failed to unmarshal message",
"error", err.Error())
d.Ack(false)
return
}
// to prevent key name collision, we need to ensure that the keyname was prefixed with their username and a hyphen
// whenever a user creates a key, the API call will prepend their username and a hyphen before sending the message for processing
// this check ensures that the key was properly prefixed
if strings.Split(key.Name, "-")[0] != key.UserName {
qm.l.Errorf("invalid key name %s, must be prefixed with: %s-", key.Name, key.UserName)
d.Ack(false)
return
}
var (
keyTypeInt int
bitsInt int
)
// validate the key parameters used for creation
switch key.Type {
case "rsa":
keyTypeInt = ci.RSA
// ensure the provided key size is within a valid range, otherwise default to 2048
if key.Size > 4096 || key.Size < 2048 {
bitsInt = 2048
} else {
bitsInt = key.Size
}
case "ed25519":
keyTypeInt = ci.Ed25519
// ed25519 keys use 256 bits, so regardless of what the user provides for bit size, hard set 256
bitsInt = 256
default:
qm.l.Errorw(
"invalid key type for creation request",
"error", fmt.Errorf("key must be ed25519 or rsa, not %s", key.Type),
"user", key.UserName,
"key_name", key.Name)
d.Ack(false)
return
}
// generate the appropriate keypair
pk, _, err := ci.GenerateKeyPair(keyTypeInt, bitsInt)
if err != nil {
qm.l.Errorw(
"failed to create key",
"error", err.Error(),
"user", key.UserName,
"key_name", key.Name)
d.Ack(false)
return
}
// retrieve a human friendly format, also verifying the key is a valid ipfs key
id, err := peer.IDFromPrivateKey(pk)
if err != nil {
qm.l.Errorw(
"failed to get peer id from private key",
"error", err.Error(),
"user", key.UserName,
"Key_name", key.Name)
d.Ack(false)
return
}
// convert the key to bytes to send to krab for processing
pkBytes, err := pk.Bytes()
if err != nil {
qm.l.Errorw(
"failed to marshal key to bytes",
"error", err.Error(),
"user", key.UserName,
"key_name", key.Name)
d.Ack(false)
return
}
// store the key in local krab
if _, err := kbPrimary.PutPrivateKey(context.Background(), &pb.KeyPut{Name: key.Name, PrivateKey: pkBytes}); err != nil {
qm.l.Errorw(
"failed to store key in primary krab",
"error", err.Error(),
"user", key.UserName,
"key_name", key.Name)
d.Ack(false)
return
}
if !qm.dev {
// store the key in remote krab
// dont fail on fallback
if _, err := kbBackup.PutPrivateKey(context.Background(), &pb.KeyPut{Name: key.Name, PrivateKey: pkBytes}); err != nil {
qm.l.Warnw(
"failed to store key in krab",
"error", err.Error(),
"user", key.UserName,
"key_name", key.Name)
}
}
// doesn't need a refund, key was generated and stored in our keystore, but information not saved to db
if err := um.AddIPFSKeyForUser(key.UserName, key.Name, id.Pretty()); err != nil {
qm.l.Errorw(
"failed to update database",
"error", err.Error(),
"user", key.UserName,
"key_name", key.Name)
} else {
qm.l.Infow(
"successfully processed key creation request",
"user", key.UserName,
"key_name", key.Name)
}
d.Ack(false)
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/queue/log_test.go | queue/log_test.go | package queue
import (
"testing"
"github.com/RTradeLtd/config/v2"
"go.uber.org/zap"
"go.uber.org/zap/zaptest/observer"
)
func TestLog_Publisher(t *testing.T) {
dev = true
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
observer, out := observer.New(zap.InfoLevel)
logger := zap.New(observer).Sugar()
_, err = New(IpfsClusterPinQueue, cfg.RabbitMQ.URL, true, dev, cfg, logger)
if err != nil {
t.Fatal(err)
}
if out.All()[out.Len()-1].Message != "channel opened" {
t.Fatal("failed to recover correct message")
}
}
func TestLog_Consumer(t *testing.T) {
dev = true
cfg, err := config.LoadConfig(testCfgPath)
if err != nil {
t.Fatal(err)
}
observer, out := observer.New(zap.InfoLevel)
logger := zap.New(observer).Sugar()
qm, err := New(IpfsClusterPinQueue, cfg.RabbitMQ.URL, false, dev, cfg, logger)
if err != nil {
t.Fatal(err)
}
if out.All()[out.Len()-1].Message != "queue declared" {
t.Fatal("failed to recover correct message")
}
if err = qm.Close(); err != nil {
t.Fatal(err)
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/queue/types.go | queue/types.go | package queue
import (
"time"
"github.com/RTradeLtd/config/v2"
"github.com/jinzhu/gorm"
"go.uber.org/zap"
"github.com/streadway/amqp"
)
// Various variables and types used by our queue package
// Queue is a typed string used to declare the various queue names
type Queue string
func (qt Queue) String() string {
return string(qt)
}
var (
dev = false
// ENSRequestQueue is a queue used to handle ens requests
ENSRequestQueue Queue = "ens-request-queue"
// IpfsPinQueue is a queue used for ipfs pins
IpfsPinQueue Queue = "ipfs-pin-queue"
// IpfsClusterPinQueue is a queue used for ipfs cluster pins
IpfsClusterPinQueue Queue = "ipfs-cluster-add-queue"
// EmailSendQueue is a queue used to handle sending email messages
EmailSendQueue Queue = "email-send-queue"
// IpnsEntryQueue is a queue used to handle ipns entry creation
IpnsEntryQueue Queue = "ipns-entry-queue"
// IpfsKeyCreationQueue is a queue used to handle ipfs key creation
IpfsKeyCreationQueue Queue = "ipfs-key-creation-queue"
// EthPaymentConfirmationQueue is a queue used to handle ethereum based payment confirmations
EthPaymentConfirmationQueue Queue = "eth-payment-confirmation-queue"
// DashPaymentConfirmationQueue is a queue used to handle confirming dash payments
DashPaymentConfirmationQueue Queue = "dash-payment-confirmation-queue"
// BitcoinCashPaymentConfirmationQueue is a queue used to handle confirming bitcoin cash payments
BitcoinCashPaymentConfirmationQueue Queue = "bitcoin-cash-payment-confirmation-queue"
// AdminEmail is the email used to notify RTrade about any critical errors
AdminEmail = "temporal.reports@rtradetechnologies.com"
// IpfsPinFailedContent is a to-be formatted message sent on IPFS pin failures
IpfsPinFailedContent = "Pin failed for content hash %s on IPFS network %s, for reason %s"
// IpfsPinFailedSubject is a subject for IPFS pin failed messages
IpfsPinFailedSubject = "IPFS Pin Failed"
// IpfsFileFailedContent is a to be formatted message sent on ipfs add failures
IpfsFileFailedContent = "IPFS File Add Failed for object name %s on IPFS network %s"
// IpfsFileFailedSubject is a subject for ipfs file add fails
IpfsFileFailedSubject = "IPFS File Add Failed"
// IpfsPrivateNetworkUnauthorizedSubject is a subject whenever someone tries to access a bad private network
IpfsPrivateNetworkUnauthorizedSubject = "Unauthorized access to IPFS private network"
// IpfsInitializationFailedSubject is a subject used when connecting to ipfs fails
IpfsInitializationFailedSubject = "Connection to IPFS failed"
// IpnsEntryFailedSubject is a subject sent upon IPNS failures
IpnsEntryFailedSubject = "IPNS Entry Creation Failed"
// IpnsEntryFailedContent is the content used when sending an email for IPNS entry creation failures
IpnsEntryFailedContent = "IPNS Entry creation failed for content hash %s using key %s for reason %s"
// PaymentConfirmationFailedSubject is a subject used when payment confirmations fail
PaymentConfirmationFailedSubject = "Payment Confirmation Failed"
// PaymentConfirmationFailedContent is a content used when a payment confirmation failure occurs
PaymentConfirmationFailedContent = "Payment failed for content hash %s with error %s"
// ErrReconnect is an error emitted when a protocol connection error occurs
// It is used to signal reconnect of queue consumers and publishers
ErrReconnect = "protocol connection error, reconnect"
)
// Manager is a helper struct to interact with rabbitmq
type Manager struct {
connection *amqp.Connection
channel *amqp.Channel
queue *amqp.Queue
l *zap.SugaredLogger
db *gorm.DB
cfg *config.TemporalConfig
ErrCh chan *amqp.Error
QueueName Queue
ExchangeName string
dev bool
}
// Queue Messages - These are used to format messages to send through rabbitmq
// IPFSKeyCreation is a message used for processing key creation
// only supported for the public IPFS network at the moment
type IPFSKeyCreation struct {
UserName string `json:"user_name"`
Name string `json:"name"`
Type string `json:"type"`
Size int `json:"size"`
NetworkName string `json:"network_name"`
CreditCost float64 `json:"credit_cost"`
}
// IPFSPin is a struct used when sending pin request
type IPFSPin struct {
CID string `json:"cid"`
NetworkName string `json:"network_name"`
UserName string `json:"user_name"`
HoldTimeInMonths int64 `json:"hold_time_in_months"`
CreditCost float64 `json:"credit_cost"`
Size int64 `json:"size"`
JWT string `json:"jwt,omitempty"`
FileName string `json:"file_name,omitempty"`
}
// IPFSClusterPin is a queue message used when sending a message to the cluster to pin content
type IPFSClusterPin struct {
CID string `json:"cid"`
NetworkName string `json:"network_name"`
UserName string `json:"user_name"`
HoldTimeInMonths int64 `json:"hold_time_in_months"`
Size int64 `json:"size"`
CreditCost float64 `json:"credit_cost"`
FileName string `json:"file_name,omitempty"`
}
// IPNSUpdate is our message for the ipns update queue
type IPNSUpdate struct {
CID string `json:"content_hash"`
IPNSHash string `json:"ipns_hash"`
LifeTime string `json:"life_time"`
TTL string `json:"ttl"`
Key string `json:"key"`
Resolve bool `json:"resolve"`
UserName string `json:"user_name"`
NetworkName string `json:"network_name"`
CreditCost float64 `json:"credit_cost"`
}
// EmailSend is a helper struct used to contained formatted content ot send as an email
type EmailSend struct {
Subject string `json:"subject"`
Content string `json:"content"`
ContentType string `json:"content_type"`
UserNames []string `json:"user_names"`
Emails []string `json:"emails,omitempty"`
}
// IPNSEntry is used to hold relevant information needed to process IPNS entry creation requests
type IPNSEntry struct {
CID string `json:"cid"`
LifeTime time.Duration `json:"life_time"`
TTL time.Duration `json:"ttl"`
Resolve bool `json:"resolve"`
Key string `json:"key"`
UserName string `json:"user_name"`
NetworkName string `json:"network_name"`
CreditCost float64 `json:"credit_cost"`
}
// DashPaymenConfirmation is a message used to signal processing of a dash payment
type DashPaymenConfirmation struct {
UserName string `json:"user_name"`
PaymentForwardID string `json:"payment_forward_id"`
PaymentNumber int64 `json:"payment_number"`
}
// EthPaymentConfirmation is a message used to confirm an ethereum based payment
type EthPaymentConfirmation struct {
UserName string `json:"user_name"`
PaymentNumber int64 `json:"payment_number"`
}
// BchPaymentConfirmation is used to confirm a bitcoin cash based payment
type BchPaymentConfirmation struct {
UserName string `json:"user_name"`
PaymentNumber int64 `json:"payment_number"`
}
// ENSRequestType denotes a particular request type
type ENSRequestType string
func (ert ENSRequestType) String() string {
return string(ert)
}
const (
// ENSRegisterName is a name registration request message
ENSRegisterName = ENSRequestType("register-name")
// ENSRegisterSubName is a subdomain name registration request message
ENSRegisterSubName = ENSRequestType("regsiter-sub-name")
// ENSUpdateContentHash is used to update the content hash for a record
ENSUpdateContentHash = ENSRequestType("update-content-hash")
)
// ENSRequest is used to process an ens api request
type ENSRequest struct {
Type ENSRequestType `json:"type"`
UserName string `json:"user_name"`
ContentHash string `json:"content_hash"`
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/queue/utils.go | queue/utils.go | package queue
import (
"github.com/RTradeLtd/database/v2/models"
)
// refundCredits is used to refund a users credits. We do not check for errors,
// as these are logged and manually corrected if they occur
func (qm *Manager) refundCredits(username, callType string, cost float64) error {
if cost == 0 {
return nil
}
um := models.NewUserManager(qm.db)
if _, err := um.AddCredits(username, cost); err != nil {
qm.l.Errorw(
"failed to refund user credits",
"error", err.Error(),
"user", username,
"call_type", callType,
"cost", cost)
return err
}
return nil
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/queue/ipns.go | queue/ipns.go | package queue
import (
"context"
"encoding/json"
"errors"
"sync"
"time"
ci "github.com/libp2p/go-libp2p-core/crypto"
peer "github.com/libp2p/go-libp2p-core/peer"
"github.com/streadway/amqp"
"github.com/RTradeLtd/database/v2/models"
pb "github.com/RTradeLtd/grpc/krab"
kaas "github.com/RTradeLtd/kaas/v2"
"github.com/RTradeLtd/rtns"
datastore "github.com/ipfs/go-datastore"
dssync "github.com/ipfs/go-datastore/sync"
badger "github.com/ipfs/go-ds-badger"
"github.com/multiformats/go-multiaddr"
)
type contextKey string
const (
ipnsPublishTTL contextKey = "ipns-publish-ttl"
)
func (qm *Manager) getPublisherKey(ctx context.Context, kb *kaas.Client) (ci.PrivKey, error) {
// generate a temporary key if we have not specified a key name
if qm.cfg.Services.RTNS.KeyName == "" {
qm.l.Info("using a temporary publisher identity")
pk, _, err := ci.GenerateKeyPair(ci.Ed25519, 256)
return pk, err
}
qm.l.Info("using a persistent publisher identity")
resp, err := kb.GetPrivateKey(ctx, &pb.KeyGet{Name: qm.cfg.Services.RTNS.KeyName})
if err != nil {
return nil, err
}
return ci.UnmarshalPrivateKey(resp.GetPrivateKey())
}
func (qm *Manager) getDatastore() (datastore.Batching, error) {
if qm.dev || qm.cfg.Services.RTNS.DatastorePath == "" {
qm.l.Info("using map datastore")
return dssync.MutexWrap(datastore.NewMapDatastore()), nil
}
qm.l.Info("using badger datastore")
return badger.NewDatastore(qm.cfg.Services.RTNS.DatastorePath, &badger.DefaultOptions)
}
// ProcessIPNSEntryCreationRequests is used to process IPNS entry creation requests
func (qm *Manager) ProcessIPNSEntryCreationRequests(ctx context.Context, wg *sync.WaitGroup, msgs <-chan amqp.Delivery) error {
kbPrimary, err := kaas.NewClient(qm.cfg.Services, false)
if err != nil {
return err
}
kbBackup, err := kaas.NewClient(qm.cfg.Services, true)
if err != nil {
return err
}
pubPK, err := qm.getPublisherKey(ctx, kbPrimary)
if err != nil {
return err
}
addr, err := multiaddr.NewMultiaddr("/ip4/0.0.0.0/tcp/3999")
if err != nil {
return err
}
pid, err := peer.IDFromPublicKey(pubPK.GetPublic())
if err != nil {
return err
}
ds, err := qm.getDatastore()
if err != nil {
return err
}
qm.l.Infof("usering peerid of %s for publisher", pid.String())
rConfig := rtns.Config{
PK: pubPK,
ListenAddrs: []multiaddr.Multiaddr{addr},
Datastore: ds,
}
publisher, err := rtns.NewService(ctx, kbPrimary, rConfig)
if err != nil {
return err
}
publisher.Bootstrap(publisher.DefaultBootstrapPeers())
ipnsManager := models.NewIPNSManager(qm.db)
qm.l.Info("processing ipns entry creation requests")
for {
select {
case d := <-msgs:
wg.Add(1)
go qm.processIPNSEntryCreationRequest(ctx, d, wg, kbBackup, ipnsManager, publisher)
case <-ctx.Done():
qm.Close()
wg.Done()
return nil
case msg := <-qm.ErrCh:
qm.Close()
wg.Done()
publisher.Close()
qm.l.Errorw(
"a protocol connection error stopping rabbitmq was received",
"error", msg.Error())
return errors.New(ErrReconnect)
}
}
}
func (qm *Manager) processIPNSEntryCreationRequest(ctx context.Context, d amqp.Delivery, wg *sync.WaitGroup, kbBackup *kaas.Client, im *models.IpnsManager, pub rtns.Service) {
defer wg.Done()
qm.l.Info("new ipns entry creation detected")
ie := IPNSEntry{}
if err := json.Unmarshal(d.Body, &ie); err != nil {
qm.l.Errorw(
"failed to unmarshal message",
"error", err.Error())
d.Ack(false)
return
}
// temporarily do not process ipns creation requests for non public networks
if ie.NetworkName != "public" {
qm.l.Errorw(
"private networks not supported for ipns",
"user", ie.UserName)
d.Ack(false)
return
}
qm.l.Infow(
"publishing ipns entry",
"user", ie.UserName,
"key", ie.Key,
"cid", ie.CID)
var cache bool
// first attempt to retrieve private key
// from the primary krab keystore which
// is embedded into the RTNS publisher
pk, err := pub.GetKey(ie.Key)
if err != nil {
// do not cache entries if the key is not available in the primary keystore
cache = false
qm.l.Warnw(
"failed to retrieve private key from priamry krab, attempting backup",
"error", err.Error(),
"user", ie.UserName,
"key", ie.Key,
"cid", ie.CID,
)
if !qm.dev {
var errCheck error
resp, errCheck := kbBackup.GetPrivateKey(context.Background(), &pb.KeyGet{Name: ie.Key})
if errCheck != nil {
qm.refundCredits(ie.UserName, "ipns", ie.CreditCost)
qm.l.Errorw(
"failed to retrieve private key from backup krab",
"error", err.Error(),
"user", ie.UserName,
"key", ie.Key,
"cid", ie.CID)
d.Ack(false)
return
}
pk, err = ci.UnmarshalPrivateKey(resp.GetPrivateKey())
if err != nil {
qm.refundCredits(ie.UserName, "ipns", ie.CreditCost)
qm.l.Errorw(
"failed to unmarshal private key",
"error", err.Error(),
"user", ie.UserName,
"key", ie.Key,
"cid", ie.CID)
d.Ack(false)
return
}
} else {
qm.l.Errorw(
"primary krab key retrieval failure, with dev mode disabled, aborting",
"user", ie.UserName,
"key", ie.Key,
"cid", ie.CID,
)
d.Ack(false)
return
}
} else {
// only cache entries whose key is available via the primary keystore
cache = true
}
// Note: context is used to pass in the experimental ttl value
// see https://discuss.ipfs.io/t/clarification-over-ttl-and-lifetime-for-ipns-records/4346 for more information
cctx := context.WithValue(ctx, ipnsPublishTTL, ie.TTL)
eol := time.Now().Add(ie.LifeTime)
if err := pub.PublishWithEOL(cctx, pk, eol, cache, ie.Key, ie.CID); err != nil {
qm.refundCredits(ie.UserName, "ipns", ie.CreditCost)
qm.l.Errorw(
"failed to publish ipns entry",
"error", err.Error(),
"user", ie.UserName,
"key", ie.Key,
"cid", ie.CID)
d.Ack(false)
return
}
// retrieve the peer id from the private key used to resolve the IPNS record
id, err := peer.IDFromPrivateKey(pk)
if err != nil {
// do not refund here since the record is published
qm.l.Errorw(
"failed to unmarshal peer identity private key",
"error", err.Error(),
"user", ie.UserName,
"key", ie.Key,
"cid", ie.CID)
d.Ack(false)
return
}
// determine whether or not this ipns has been used, if so update record, otherwise create new one
if _, err = im.FindByIPNSHash(id.Pretty()); err != nil {
_, err = im.CreateEntry(id.Pretty(), ie.CID, ie.Key, ie.NetworkName, ie.UserName, ie.LifeTime, ie.TTL)
} else {
_, err = im.UpdateIPNSEntry(id.Pretty(), ie.CID, ie.NetworkName, ie.UserName, ie.LifeTime, ie.TTL)
}
if err != nil {
qm.l.Errorw(
"failed to update ipns entry in database",
"error", err.Error(),
"user", ie.UserName,
"key", ie.Key,
"cid", ie.CID)
} else {
qm.l.Infow(
"successfully processed ipns entry creation request",
"user", ie.UserName,
"key", ie.Key,
"cid", ie.CID)
}
d.Ack(false)
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/queue/ipfs_cluster.go | queue/ipfs_cluster.go | package queue
import (
"context"
"encoding/json"
"errors"
"sync"
"github.com/RTradeLtd/Temporal/rtfscluster"
"github.com/RTradeLtd/database/v2/models"
"github.com/jinzhu/gorm"
"github.com/streadway/amqp"
)
// ProcessIPFSClusterPins is used to process messages sent to rabbitmq requesting be pinned to our cluster
func (qm *Manager) ProcessIPFSClusterPins(ctx context.Context, wg *sync.WaitGroup, msgs <-chan amqp.Delivery) error {
clusterManager, err := rtfscluster.Initialize(ctx, qm.cfg.IPFSCluster.APIConnection.Host, qm.cfg.IPFSCluster.APIConnection.Port)
if err != nil {
return err
}
uploadManager := models.NewUploadManager(qm.db)
qm.l.Info("processing ipfs cluster pin requests")
for {
select {
case d := <-msgs:
wg.Add(1)
go qm.processIPFSClusterPin(ctx, d, wg, clusterManager, uploadManager)
case <-ctx.Done():
qm.Close()
wg.Done()
return nil
case msg := <-qm.ErrCh:
qm.Close()
wg.Done()
qm.l.Errorw(
"a protocol connection error stopping rabbitmq was received",
"error", msg.Error())
return errors.New(ErrReconnect)
}
}
}
func (qm *Manager) processIPFSClusterPin(ctx context.Context, d amqp.Delivery, wg *sync.WaitGroup, cm *rtfscluster.ClusterManager, um *models.UploadManager) {
defer wg.Done()
qm.l.Info("new cluster pin request detected")
clusterAdd := IPFSClusterPin{}
if err := json.Unmarshal(d.Body, &clusterAdd); err != nil {
qm.l.Errorw(
"failed to unmarshal message",
"error", err.Error())
d.Ack(false)
return
}
if clusterAdd.NetworkName != "public" {
qm.l.Errorw(
"private clustered networks not yet supported",
"error", errors.New("private network clusters not supported").Error(),
"cid", clusterAdd.CID,
"user", clusterAdd.UserName)
d.Ack(false)
return
}
encodedCid, err := cm.DecodeHashString(clusterAdd.CID)
if err != nil {
qm.refundCredits(clusterAdd.UserName, "pin", clusterAdd.CreditCost)
models.NewUsageManager(qm.db).ReduceDataUsage(clusterAdd.UserName, uint64(clusterAdd.Size))
qm.l.Errorw(
"bad cid format detected",
"error", err.Error(),
"cid", clusterAdd.CID,
"user", clusterAdd.UserName)
d.Ack(false)
return
}
qm.l.Infow(
"pinning hash to cluster",
"cid", clusterAdd.CID,
"user", clusterAdd.UserName)
if err = cm.Pin(ctx, encodedCid); err != nil {
_ = qm.refundCredits(clusterAdd.UserName, "pin", clusterAdd.CreditCost)
_ = models.NewUsageManager(qm.db).ReduceDataUsage(clusterAdd.UserName, uint64(clusterAdd.Size))
qm.l.Errorw(
"failed to pin hash to cluster",
"error", err.Error(),
"cid", clusterAdd.CID,
"user", clusterAdd.UserName)
d.Ack(false)
return
}
upload, err := um.FindUploadByHashAndUserAndNetwork(clusterAdd.UserName, clusterAdd.CID, clusterAdd.NetworkName)
if err != nil && err != gorm.ErrRecordNotFound {
qm.l.Errorw(
"failed to check database for upload",
"error", err.Error(),
"cid", clusterAdd.CID,
"user", clusterAdd.UserName)
d.Ack(false)
return
}
if upload == nil {
_, err = um.NewUpload(clusterAdd.CID, "pin-cluster", models.UploadOptions{
NetworkName: clusterAdd.NetworkName,
Username: clusterAdd.UserName,
HoldTimeInMonths: clusterAdd.HoldTimeInMonths,
FileName: clusterAdd.FileName,
Size: clusterAdd.Size})
} else {
_, err = um.UpdateUpload(clusterAdd.HoldTimeInMonths, clusterAdd.UserName, clusterAdd.CID, clusterAdd.NetworkName)
}
if err != nil {
qm.l.Errorw(
"failed to update database",
"error", err.Error(),
"cid", clusterAdd.CID,
"user", clusterAdd.UserName)
} else {
qm.l.Infow(
"successfully processed cluster pin request",
"cid", clusterAdd.CID,
"user", clusterAdd.UserName)
}
d.Ack(false)
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/queue/mail.go | queue/mail.go | package queue
import (
"context"
"encoding/json"
"errors"
"sync"
"github.com/RTradeLtd/Temporal/mail"
"github.com/jinzhu/gorm"
"github.com/streadway/amqp"
)
// ProcessMailSends is a function used to process mail send queue messages
func (qm *Manager) ProcessMailSends(ctx context.Context, wg *sync.WaitGroup, db *gorm.DB, msgs <-chan amqp.Delivery) error {
mm, err := mail.NewManager(qm.cfg, db)
if err != nil {
return err
}
qm.l.Info("processing email send requests")
for {
select {
case d := <-msgs:
wg.Add(1)
go qm.processMailSend(d, wg, mm)
case <-ctx.Done():
qm.Close()
wg.Done()
return nil
case msg := <-qm.ErrCh:
qm.Close()
wg.Done()
qm.l.Errorw(
"a protocol connection error stopping rabbitmq was received",
"error", msg.Error())
return errors.New(ErrReconnect)
}
}
}
func (qm *Manager) processMailSend(d amqp.Delivery, wg *sync.WaitGroup, mm *mail.Manager) {
defer wg.Done()
qm.l.Info("new email send request detected")
es := EmailSend{}
if err := json.Unmarshal(d.Body, &es); err != nil {
qm.l.Errorw(
"failed to unmarshal message",
"error", err.Error())
d.Ack(false)
return
}
for k, v := range es.Emails {
_, err := mm.SendEmail(es.Subject, es.Content, es.ContentType, es.UserNames[k], v)
if err != nil {
qm.l.Errorw(
"failed to send email",
"error", err.Error(),
"email", v,
"user", es.UserNames[k])
}
qm.l.Infow(
"email sent",
"email", v,
"user", es.UserNames[k])
}
d.Ack(false)
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/queue/doc.go | queue/doc.go | // Package queue implements Temporal's various queue consumers and publishers
package queue
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/queue/queue.go | queue/queue.go | package queue
import (
"context"
"crypto/tls"
"crypto/x509"
"encoding/json"
"errors"
"io/ioutil"
"sync"
"github.com/jinzhu/gorm"
"go.uber.org/zap"
"github.com/RTradeLtd/config/v2"
"github.com/streadway/amqp"
)
// New is used to instantiate a new connection to rabbitmq as a publisher or consumer
func New(queue Queue, url string, publish, devMode bool, cfg *config.TemporalConfig, logger *zap.SugaredLogger) (*Manager, error) {
conn, err := setupConnection(url, cfg)
if err != nil {
return nil, err
}
var queueType string
if publish {
queueType = "publish"
} else {
queueType = "consumer"
}
// create base queue manager
qm := Manager{connection: conn, QueueName: queue, l: logger.Named(queue.String() + "." + queueType), dev: devMode}
// open a channel
if err := qm.openChannel(); err != nil {
return nil, err
}
// if we aren't publishing, and are consuming
// setup a queue to receive messages on
if !publish {
if err = qm.declareQueue(); err != nil {
return nil, err
}
}
// register err channel notifier
qm.RegisterConnectionClosure()
return &qm, nil
}
func setupConnection(connectionURL string, cfg *config.TemporalConfig) (*amqp.Connection, error) {
switch cfg.RabbitMQ.TLSConfig.CACertFile {
case "":
return amqp.Dial(connectionURL)
default:
// see https://godoc.org/github.com/streadway/amqp#DialTLS for more information
tlsConfig := new(tls.Config)
tlsConfig.RootCAs = x509.NewCertPool()
ca, err := ioutil.ReadFile(cfg.RabbitMQ.TLSConfig.CACertFile)
if err != nil {
return nil, err
}
if !tlsConfig.RootCAs.AppendCertsFromPEM(ca) {
return nil, errors.New("failed to successfully append cert file")
}
cert, err := tls.LoadX509KeyPair(cfg.RabbitMQ.TLSConfig.CertFile, cfg.RabbitMQ.TLSConfig.KeyFile)
if err != nil {
return nil, err
}
tlsConfig.Certificates = append(tlsConfig.Certificates, cert)
return amqp.DialTLS(connectionURL, tlsConfig)
}
}
// OpenChannel is used to open a channel to the rabbitmq server
func (qm *Manager) openChannel() error {
ch, err := qm.connection.Channel()
if err != nil {
return err
}
qm.l.Info("channel opened")
qm.channel = ch
return qm.channel.Qos(10, 0, false)
}
// DeclareQueue is used to declare a queue for which messages will be sent to
func (qm *Manager) declareQueue() error {
// we declare the queue as durable so that even if rabbitmq server stops
// our messages won't be lost
q, err := qm.channel.QueueDeclare(
qm.QueueName.String(), // name
true, // durable
false, // delete when unused
false, // exclusive
false, // no-wait
nil, // arguments
)
if err != nil {
return err
}
qm.l.Info("queue declared")
qm.queue = &q
return nil
}
// ConsumeMessages is used to consume messages that are sent to the queue
// Question, do we really want to ack messages that fail to be processed?
// Perhaps the error was temporary, and we allow it to be retried?
func (qm *Manager) ConsumeMessages(ctx context.Context, wg *sync.WaitGroup, db *gorm.DB, cfg *config.TemporalConfig) error {
// embed database into queue manager
qm.db = db
// embed config into queue manager
qm.cfg = cfg
// we do not auto-ack, as if a consumer dies we don't want the message to be lost
// not specifying the consumer name uses an automatically generated id
msgs, err := qm.channel.Consume(
qm.QueueName.String(), // queue
"", // consumer
false, // auto-ack
false, // exclusive
false, // no-local
false, // no-wait
nil, // args
)
if err != nil {
return err
}
// check the queue name
switch qm.QueueName {
case IpfsKeyCreationQueue:
return qm.ProcessIPFSKeyCreation(ctx, wg, msgs)
case IpfsPinQueue:
return qm.ProccessIPFSPins(ctx, wg, msgs)
case EmailSendQueue:
return qm.ProcessMailSends(ctx, wg, db, msgs)
case IpnsEntryQueue:
return qm.ProcessIPNSEntryCreationRequests(ctx, wg, msgs)
case IpfsClusterPinQueue:
return qm.ProcessIPFSClusterPins(ctx, wg, msgs)
default:
return errors.New("invalid queue name")
}
}
// PublishMessage is used to produce messages that are sent to the queue, with a worker queue (one consumer)
func (qm *Manager) PublishMessage(body interface{}) error {
bodyMarshaled, err := json.Marshal(body)
if err != nil {
return err
}
if err = qm.channel.Publish(
"", // exchange - this is left empty, and becomes the default exchange
qm.QueueName.String(), // routing key
false, // mandatory
false, // immediate
amqp.Publishing{
DeliveryMode: amqp.Persistent, // messages will persist through crashes, etc..
ContentType: "text/plain",
Body: bodyMarshaled,
},
); err != nil {
return err
}
return nil
}
// RegisterConnectionClosure is used to register a channel which we may receive
// connection level errors. This covers all channel, and connection errors.
func (qm *Manager) RegisterConnectionClosure() {
qm.ErrCh = qm.connection.NotifyClose(make(chan *amqp.Error))
}
// Close is used to close our queue resources
func (qm *Manager) Close() error {
// closing the connection also closes the channel
return qm.connection.Close()
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/log/middleware.go | log/middleware.go | package log
import (
"time"
"net/http"
"github.com/go-chi/chi/middleware"
"go.uber.org/zap"
)
type loggerMiddleware struct {
l *zap.Logger
}
// NewMiddleware instantiates a middleware function that logs all requests
// using the provided logger
func NewMiddleware(l *zap.SugaredLogger) func(next http.Handler) http.Handler {
return loggerMiddleware{l.Desugar()}.Handler
}
func (z loggerMiddleware) Handler(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
next.ServeHTTP(ww, r)
latency := time.Since(start)
var requestID string
if reqID := r.Context().Value(middleware.RequestIDKey); reqID != nil {
requestID = reqID.(string)
}
z.l.Info("request completed",
// request metadata
zap.String("path", r.URL.Path),
zap.String("query", r.URL.RawQuery),
zap.String("method", r.Method),
zap.String("user-agent", r.UserAgent()),
// response metadata
zap.Int("status", ww.Status()),
zap.Duration("took", latency),
// additional metadata
zap.String("real-ip", r.RemoteAddr),
zap.String("request-id", requestID))
},
)
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/log/middleware_test.go | log/middleware_test.go | package log
import (
"io"
"net/http"
"net/http/httptest"
"testing"
"github.com/go-chi/chi"
"github.com/go-chi/chi/middleware"
"go.bobheadxi.dev/res"
"go.bobheadxi.dev/zapx/ztest"
)
func Test_loggerMiddleware(t *testing.T) {
type args struct {
method string
path string
body io.Reader
middlewares []func(http.Handler) http.Handler
}
tests := []struct {
name string
args args
want []string
}{
{
"GET with requestID",
args{"GET", "/", nil, []func(http.Handler) http.Handler{middleware.RequestID}},
[]string{"path", "request-id"},
},
{
"GET with realIP",
args{"GET", "/", nil, []func(http.Handler) http.Handler{middleware.RealIP}},
[]string{"path", "real-ip"},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// create bootstrapped logger and middleware
var l, out = ztest.NewObservable()
var handler = NewMiddleware(l.Sugar())
// set up mock router
m := chi.NewRouter()
m.Use(tt.args.middlewares...)
m.Use(handler)
m.Get("/", func(w http.ResponseWriter, r *http.Request) {
res.R(w, r, res.MsgOK("hello world!"))
})
// create a mock request to use
req := httptest.NewRequest(tt.args.method, "http://testing"+tt.args.path,
tt.args.body)
// serve request
m.ServeHTTP(httptest.NewRecorder(), req)
// check for desired log fields
for _, e := range out.All() {
for _, f := range tt.want {
// find field, cast as string, and check if empty
if val, _ := e.ContextMap()[f].(string); val == "" {
t.Errorf("field %s unexpectedly empty", f)
}
}
}
})
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/log/log_test.go | log/log_test.go | package log
import (
"testing"
"go.bobheadxi.dev/zapx/ztest"
)
func TestNewProcessLogger(t *testing.T) {
l, out := ztest.NewObservable()
logger := NewProcessLogger(l.Sugar(), "network_up", "id", "1234")
logger.Info("hi")
if out.All()[0].ContextMap()["network_up.id"].(string) != "1234" {
t.Error("bad logger")
}
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/log/log.go | log/log.go | package log
import (
"go.uber.org/zap"
)
// NewProcessLogger creates a new logger that sets prefixes on fields for
// logging a specific process
func NewProcessLogger(l *zap.SugaredLogger, process string, fields ...interface{}) *zap.SugaredLogger {
args := make([]interface{}, len(fields))
for i := 0; i < len(fields); i += 2 {
args[i] = process + "." + fields[i].(string)
args[i+1] = fields[i+1]
}
return l.With(args...)
}
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/log/doc.go | log/doc.go | // Package log provides utility functions that wrap Uber's Zap logging library
package log
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/eh/errors.go | eh/errors.go | package eh
const (
// LoginError indicates an unexpected error occurred when logging in
LoginError = "an error occurred while signing in"
// IPFSConnectionError is an error used for ipfs connection failures
IPFSConnectionError = "failed to connect to ipfs"
// PrivateNetworkAccessError is used for invalid access to private networks
PrivateNetworkAccessError = "invalid access to private network"
// APIURLCheckError is an error ussed when failing to retrieve an api url
APIURLCheckError = "failed to get api url"
// IPFSCatError is an error used when failing to can an ipfs file
IPFSCatError = "failed to execute ipfs cat"
// IPFSObjectStatError is an error used when failure to execute object stat occurs
IPFSObjectStatError = "failed to execute ipfs object stat"
// IPFSPubSubPublishError is an error message used whe nfailing to publish pubsub msgs
IPFSPubSubPublishError = "failed to publish pubsub message"
// UploadSearchError is a error used when searching for uploads fails
UploadSearchError = "failed to search for uploads in database"
// NetworkSearchError is an error used when searching for networks fail
NetworkSearchError = "faild to search for networks"
// NetworkCreationError is an error used when creating networks in database fail
NetworkCreationError = "failed to create network"
// QueueInitializationError is an error used when failing to connect to the queue
QueueInitializationError = "failed to initialize queue"
// QueuePublishError is a message used when failing to publish to queue
QueuePublishError = "failed to publish message to queue"
// KeySearchError is an error used when failing to search for a key
KeySearchError = "failed to search for key"
// KeyUseError is an error used when attempting to use a key the user down ot own
KeyUseError = "user does not own key"
// IPFSPinParseError is an error used when failure to parse ipfs pins occurs
IPFSPinParseError = "failed to parse ipfs pins"
// IPFSAddError is an error used when failing to add a file to ipfs
IPFSAddError = "failed to add file to ipfs"
// FileOpenError is an error used when failing to open a file
FileOpenError = "failed to open file"
// IPFSMultiHashGenerationError is an error used when calculating an ipfs multihash
IPFSMultiHashGenerationError = "failed to generate ipfs multihash"
// IPFSClusterStatusError is a error used when getting the status of ipfs cluster
IPFSClusterStatusError = "failed to get ipfs cluster status"
// IPFSClusterConnectionError is an error used when connecting to ipfs cluster
IPFSClusterConnectionError = "failed to connect to IPFS cluster"
// IPFSClusterPinRemovalError is an error used when failing to remove a pin from the cluster
IPFSClusterPinRemovalError = "failed to remove pin from cluster"
// DNSLinkManagerError is an error used when creating a dns link manager
DNSLinkManagerError = "failed to create dnslink manager"
// DNSLinkEntryError is an error used when creating dns link entries
DNSLinkEntryError = "failed to create dns link entry"
// PaymentCreationError is an error used when creating payments
PaymentCreationError = "failed to create payment"
// CostCalculationError is an error message emitted when we are unable to calculate the cost of something
CostCalculationError = "failed to calculate cost"
// PaymentSearchError is an error used when searching for payment
PaymentSearchError = "failed to search for payment"
// DuplicateKeyCreationError is an error used when creating a key of the same name
DuplicateKeyCreationError = "key name already exists"
// UserAccountCreationError is an error used when creating a user account
UserAccountCreationError = "failed to create user account"
// PasswordChangeError is an error used when changing your password
PasswordChangeError = "failed to change password"
// NoKeyError is an error message given to a user when they search for keys, but have none
NoKeyError = "no keys"
// FileTooBigError is an error message given to a user when attempting to upload a file larger than our limit
FileTooBigError = "attempting to upload too big of a file"
// InvalidPaymentTypeError is an error message given to a user when using an invalid payment method
InvalidPaymentTypeError = "payment type not supported, must be one of: 'eth' 'rtc' 'btc' 'ltc' 'xmr'"
// InvalidPaymentBlockchainError is an error message given to a user when they provide an invalid blockchain
InvalidPaymentBlockchainError = "blockchain must be one of: 'ethereum' 'bitcoin' 'litecoin' 'monero'"
// CreditCheckError is an error messagen given to a user when searching for their credits fails
CreditCheckError = "failed to search for user credits"
// InvalidBalanceError is an error message given to a user when they don't have enough credits to pay
InvalidBalanceError = "user does not have enough credits to pay for api call"
// CmcCheckError is an error message given to a user when checking cmc fails
CmcCheckError = "failed to retrieve value from coinmarketcap"
// DepositAddressCheckError is an error message given to a user when searching for a deposit address fails
DepositAddressCheckError = "failed to get deposit address"
// UserSearchError is an error message given to a user when a username cant be found
UserSearchError = "unable to find username"
// CreditRefundError is an error message used when we are unable to refund a users credits
CreditRefundError = "failed to refund credits for user"
// IpnsRecordSearchError is an error message given to users when we can't search for any records
IpnsRecordSearchError = "failed to search for IPNS records, user likely has published none"
// UnAuthorizedAdminAccess is an error message used whena user attempts to access an administrative route
UnAuthorizedAdminAccess = "user is not an administrator"
// DuplicateEmailError is an error used when a user attempts to register with an already taken email address
DuplicateEmailError = "email address already taken"
// DuplicateUserNameError is an error used whe na user attempts to register with an already taken user name
DuplicateUserNameError = "username is already taken"
// UnableToSaveUserError is an error that occurs when saving the user account
UnableToSaveUserError = "saving user account to database failed"
// EmailVerificationError is an error used when a user fails to validate their email address
EmailVerificationError = "failed to verify email address"
// EmailTokenGenerationError is an error messaged used when failing to generate a token
EmailTokenGenerationError = "failed to generate email verification token"
// ZoneSearchError is an error message used when failing to search for a zone
ZoneSearchError = "failed to search for zone"
// RecordSearchError is an error message used when failing to search for a record
RecordSearchError = "failed to search for record"
// IPFSDagGetError is an error message when failing to retrieve a dag from ipfs
IPFSDagGetError = "failed to get dag from ipfs"
// InvalidObjectIdentifierError is a generic error to indicate that the object identifier that was provided is invalid
InvalidObjectIdentifierError = "object identifier is of an invalid format"
// InvalidObjectTypeError is an error message when a user submits an incorrect type to be indexed
InvalidObjectTypeError = "object type is invalid, must be ipld"
// FailedToIndexError is an error message when a lens index request fails
FailedToIndexError = "an error occurred while trying to index this object"
// FailedToSearchError is an error message when a lens search request fails
FailedToSearchError = "an error occurred while submitting your search to lens"
// NoSearchResultsError is an error message used when no search results were returned
NoSearchResultsError = "there were no entries matching your search query"
// ChainRiderAPICallError is an error message used when a call to chainrider api fails
ChainRiderAPICallError = "failed to call chainrider api"
// KeyExportError is an error messaged used if a key export request fails
KeyExportError = "failed to export key"
// PasswordResetError is an error message used when an error occurins during password reset
PasswordResetError = "failed to reset password"
// NoAPITokenError is an error when we can't properly validate the jwt token
NoAPITokenError = "invalid token provided"
// CantUploadError is an error when a user tries to upload more data than their monthly limit
CantUploadError = "uploading would breach monthly data limit, please upload a smaller object"
// DataUsageUpdateError is an error when a failure occurs while trying to update a users
// current data usage
DataUsageUpdateError = "an error occurred while updating your account data usage"
// TierUpgradeError is an error when a failure to upgrade a user tier occurs
TierUpgradeError = "an error occurred upgrading your tier"
// EncryptionError is an error when a failure to encrypt data occurs
EncryptionError = "an error occurred when trying to encrypt file"
// DatabaseUpdateError is an error message used when a failure to update the database happesn
DatabaseUpdateError = "en error occurred wile updating the database"
// PinExtendError is an error message used when someone attempts to extend the pin for content they haven't uploaded
PinExtendError = "failed to extend pin duration, this likely means you haven't actually uploaded this content before"
// MaxHoldTimeError is an error message when the current hold time value would breach set pin time limits
MaxHoldTimeError = "a hold time of this long would result in a longer maximum pin time than what your account allow, please reduce your hold time and try again"
// HostNameNotFoundError is an error message when api server has not hostname
HostNameNotFoundError = "an api host has not hostname, please set hostname"
)
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
RTradeLtd/Temporal | https://github.com/RTradeLtd/Temporal/blob/4547df5e64d9823c6f670da4261de9e6d7353fb8/eh/doc.go | eh/doc.go | // Package eh stands for "error handling", and provides error definitions
package eh
| go | MIT | 4547df5e64d9823c6f670da4261de9e6d7353fb8 | 2026-01-07T09:35:24.447786Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/main.go | main.go | package main
import (
"beaver/app/backend/backend_models"
"beaver/app/chat/chat_models"
"beaver/app/datasync/datasync_models"
"beaver/app/emoji/emoji_models"
"beaver/app/feedback/feedback_models"
"beaver/app/file/file_models"
"beaver/app/friend/friend_models"
"beaver/app/group/group_models"
"beaver/app/moment/moment_models"
"beaver/app/notification/notification_models"
"beaver/app/track/track_models"
"beaver/app/update/update_models"
"beaver/app/user/user_models"
"beaver/core"
"beaver/database"
"flag"
"fmt"
)
type Options struct {
DB bool
}
// go run main.go -db
func main() {
var opt Options
flag.BoolVar(&opt.DB, "db", false, "db")
flag.Parse()
if opt.DB {
db := core.InitGorm("root:123456@tcp(127.0.0.1:3306)/beaver?charset=utf8mb4&parseTime=True&loc=Local")
// 禁用外键检查
db.Exec("SET FOREIGN_KEY_CHECKS = 0")
defer db.Exec("SET FOREIGN_KEY_CHECKS = 1")
// 创建所有表
err := db.AutoMigrate(
// 基础表
&user_models.UserModel{},
&user_models.UserChangeLogModel{},
&friend_models.FriendModel{},
&friend_models.FriendVerifyModel{},
&chat_models.ChatMessage{},
&chat_models.ChatConversationMeta{},
&chat_models.ChatUserConversation{},
&file_models.FileModel{},
&moment_models.MomentModel{},
&moment_models.MomentLikeModel{},
&moment_models.MomentCommentModel{},
&emoji_models.EmojiPackage{},
&emoji_models.Emoji{},
&emoji_models.EmojiPackageEmoji{},
&emoji_models.EmojiPackageCollect{},
&emoji_models.EmojiCollectEmoji{},
&track_models.TrackBucket{},
&track_models.TrackEvent{},
&track_models.TrackLogger{},
&feedback_models.FeedbackModel{},
// 版本管理相关表
&update_models.UpdateApp{},
&update_models.UpdateArchitecture{},
&update_models.UpdateVersion{},
&update_models.UpdateStrategy{},
&update_models.UpdateReport{},
&datasync_models.DatasyncModel{},
&group_models.GroupModel{},
&group_models.GroupMemberModel{},
&group_models.GroupJoinRequestModel{},
&group_models.GroupMemberChangeLogModel{},
// 通知中心表
¬ification_models.NotificationEvent{},
¬ification_models.NotificationInbox{},
¬ification_models.NotificationRead{},
// 后台管理相关表
&backend_models.AdminUser{},
&backend_models.AdminSystemAuthority{},
&backend_models.AdminSystemAuthorityMenu{},
&backend_models.AdminSystemAuthorityUser{},
&backend_models.AdminSystemMenu{},
)
if err != nil {
fmt.Printf("表结构生成失败: %v\n", err)
return
}
fmt.Println("所有表结构生成成功")
database.InitAllData(db)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_models/chat_conversation_setting_model.go | app/chat/chat_models/chat_conversation_setting_model.go | package chat_models
import (
"beaver/common/models"
)
// 存储用户级别的会话设置（每个用户独立）
// 记录用户对会话的个性化操作（置顶、免打扰、删除等）
// 记录用户在该会话中的已读状态
// 用于UI显示（会话列表、未读消息等）
type ChatUserConversation struct {
models.Model
UserID string `gorm:"size:64;index" json:"userId"` // 用户ID
ConversationID string `gorm:"size:128;index" json:"conversationId"` // 关联的会话ID
IsHidden bool `gorm:"default:false" json:"isHidden"` // 是否在当前用户的会话列表隐藏
IsPinned bool `gorm:"default:false" json:"isPinned"` // 置顶
IsMuted bool `gorm:"default:false" json:"isMuted"` // 免打扰
UserReadSeq int64 `gorm:"not;default:0" json:"userReadSeq"` // 当前用户已读游标
Version int64 `gorm:"not;default:0;index" json:"version"` // 用户会话设置版本，用于多端同步（基于UserID递增，所有会话设置共享版本号，从1开始）
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_models/chat_datasync_model.go | app/chat/chat_models/chat_datasync_model.go | package chat_models
import (
"beaver/common/models"
)
// 存储会话级别的信息（所有用户共享）
// 记录会话类型（私聊/群聊）
// 记录会话的最新消息序列号
// 用于数据同步（客户端需要知道哪些会话有更新）
// ChatConversationMeta 数据同步模型
type ChatConversationMeta struct {
models.Model
ConversationID string `gorm:"size:128;uniqueIndex" json:"conversationId"` // 唯一会话ID（私聊/群聊/系统）
Type int `gorm:"not" json:"type"` // 1=私聊 2=群聊 3=系统会话
MaxSeq int64 `gorm:"not;default:0" json:"maxSeq"` // 会话全局最新消息序号
LastMessage string `gorm:"size:256" json:"lastMessage"` // 会话最后一条消息预览（全局唯一）
Version int64 `gorm:"not;default:0;index" json:"version"` // 会话元信息版本，用于同步（基于ConversationID递增，从1开始）
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_models/chat_model.go | app/chat/chat_models/chat_model.go | package chat_models
import (
"beaver/common/models"
"beaver/common/models/ctype"
)
type ChatMessage struct {
models.Model
MessageID string `gorm:"size:64;uniqueIndex" json:"messageId"` // 唯一消息ID（客户端生成+服务端确认）
ConversationID string `gorm:"size:128;index" json:"conversationId"` // 所属会话ID
ConversationType int `gorm:"not" json:"conversationType"` // 会话类型（1=私聊 2=群聊）
Seq int64 `gorm:"not;default:0;index" json:"seq"` // 消息在会话内的序列号（基于ConversationID递增，从1开始）
SendUserID *string `gorm:"size:64;index" json:"sendUserId,omitempty"` // 发送者用户ID（通知消息可为null）
MsgType ctype.MsgType `gorm:"not" json:"msgType"` // 消息类型（TEXT/IMAGE/VIDEO/REVOKE/DELETE/EDIT等）
TargetMessageID string `gorm:"size:64;index" json:"targetMessageId,omitempty"` // 针对的原消息ID（撤回/删除/编辑事件）
MsgPreview string `gorm:"size:256" json:"msgPreview"` // 消息预览文本
Msg *ctype.Msg `gorm:"type:json" json:"msg"` // 消息内容（JSON）
// 数据状态管理 - 处理违规内容等情况
Status int8 `gorm:"not null;default:1;index" json:"status"` // 消息状态：1=正常 2=违规待审核 3=违规已屏蔽 4=已删除
}
func (chat ChatMessage) MsgPreviewMethod() string {
switch chat.Msg.Type {
case 1:
return chat.Msg.TextMsg.Content
case 2:
return "[图片消息]"
case 3:
return "[视频消息]"
case 4:
return "[文件消息]"
case 5:
return "[语音消息]"
case 6:
return "[表情消息]"
case 7:
return "[通知消息]"
case 8:
return "[音频文件]"
default:
return "[未知消息]"
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_utils/sync_utils.go | app/chat/chat_utils/sync_utils.go | package chat_utils
import (
"strings"
"time"
"beaver/app/chat/chat_models"
core "beaver/core/version"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
// CreateOrUpdateConversation 更新会话信息，返回新版本号（表记录肯定存在）
func CreateOrUpdateConversation(db *gorm.DB, versionGen *core.VersionGenerator, conversationID string, conversationType int, lastSeq int64, lastMessage string) (int64, error) {
// 生成新版本号
version := versionGen.GetNextVersion("chat_conversation_metas", "conversation_id", conversationID)
// 直接更新会话信息
err := db.Model(&chat_models.ChatConversationMeta{}).
Where("conversation_id = ?", conversationID).
Updates(map[string]interface{}{
"max_seq": lastSeq,
"last_message": lastMessage,
"version": version,
"updated_at": time.Now(),
}).Error
if err != nil {
logx.Errorf("更新会话信息失败: conversationID=%s, error=%v", conversationID, err)
return 0, err
}
logx.Infof("更新会话信息成功: conversationID=%s, version=%d", conversationID, version)
return version, nil
}
// UpdateUserConversation 更新用户会话关系，返回新版本号（表记录肯定存在）
func UpdateUserConversation(db *gorm.DB, versionGen *core.VersionGenerator, userID, conversationID string, isDeleted bool) (int64, error) {
// 生成新版本号
version := versionGen.GetNextVersion("chat_user_conversations", "user_id", userID)
// 准备更新字段
updateFields := map[string]interface{}{
"updated_at": time.Now(),
"version": version,
}
if !isDeleted {
// 发送消息时自动恢复显示（取消隐藏状态）
updateFields["is_hidden"] = false
}
// 直接更新用户会话关系
err := db.Model(&chat_models.ChatUserConversation{}).
Where("conversation_id = ? AND user_id = ?", conversationID, userID).
Updates(updateFields).Error
if err != nil {
logx.Errorf("更新用户会话关系失败: userID=%s, conversationID=%s, error=%v", userID, conversationID, err)
return 0, err
}
if !isDeleted {
logx.Infof("更新用户会话关系成功并自动恢复显示: userID=%s, conversationID=%s, version=%d", userID, conversationID, version)
} else {
logx.Infof("更新用户会话关系成功: userID=%s, conversationID=%s, version=%d", userID, conversationID, version)
}
return version, nil
}
// UpdateAllUserConversationsInChat 更新聊天中所有用户的会话关系，返回所有用户的更新信息（表记录肯定存在）
func UpdateAllUserConversationsInChat(db *gorm.DB, versionGen *core.VersionGenerator, conversationID, senderID string, messageSeq int64) ([]UserConversationUpdate, error) {
// 查询该会话相关的所有用户会话记录
var userConversations []chat_models.ChatUserConversation
err := db.Where("conversation_id = ?", conversationID).Find(&userConversations).Error
if err != nil {
logx.Errorf("查询会话用户关系失败: conversationID=%s, error=%v", conversationID, err)
return nil, err
}
var updates []UserConversationUpdate
// 更新每条记录，每个用户独立版本号
for _, convo := range userConversations {
// 总是更新版本号，因为发送消息会影响所有用户的会话状态
version := versionGen.GetNextVersion("chat_user_conversations", "user_id", convo.UserID)
updateFields := map[string]interface{}{
"updated_at": time.Now(),
"version": version,
}
// 如果是隐藏状态，自动恢复显示
if convo.IsHidden {
updateFields["is_hidden"] = false
}
// 处理已读序列号更新
shouldUpdateReadSeq := false
if senderID == "*" {
// "*"表示所有用户都标记为已读
shouldUpdateReadSeq = true
} else {
// 检查用户是否在已读用户列表中（senderID可能包含多个用户ID，用逗号分隔）
readUserIDs := strings.Split(senderID, ",")
for _, readUserID := range readUserIDs {
if strings.TrimSpace(readUserID) == convo.UserID {
shouldUpdateReadSeq = true
break
}
}
}
if shouldUpdateReadSeq {
updateFields["user_read_seq"] = messageSeq
logx.Infof("更新用户已读序列号: userID=%s, conversationID=%s, readSeq=%d, version=%d", convo.UserID, conversationID, messageSeq, version)
}
// 直接批量更新所有用户的会话关系
err = db.Model(&chat_models.ChatUserConversation{}).
Where("conversation_id = ? AND user_id = ?", conversationID, convo.UserID).
Updates(updateFields).Error
if err != nil {
logx.Errorf("更新用户会话失败: userID=%s, conversationID=%s, error=%v", convo.UserID, conversationID, err)
// 继续处理其他用户，不要因为一个失败而中断整个流程
} else {
updates = append(updates, UserConversationUpdate{
UserID: convo.UserID,
ConversationID: conversationID,
Version: version,
})
}
}
logx.Infof("更新会话用户关系成功: conversationID=%s, 更新用户数=%d", conversationID, len(updates))
return updates, nil
}
// UpdateUserConversationsReadSeq 更新用户会话的已读序列号
func UpdateUserConversationsReadSeq(db *gorm.DB, versionGen *core.VersionGenerator, conversationID string, readUserIDs []string, readSeq int64) ([]UserConversationUpdate, error) {
// 查询该会话相关的所有用户会话记录
var userConversations []chat_models.ChatUserConversation
err := db.Where("conversation_id = ?", conversationID).Find(&userConversations).Error
if err != nil {
logx.Errorf("查询会话用户关系失败: conversationID=%s, error=%v", conversationID, err)
return nil, err
}
var updates []UserConversationUpdate
// 更新每条记录，每个用户独立版本号
for _, convo := range userConversations {
// 总是更新版本号，因为发送消息会影响所有用户的会话状态
version := versionGen.GetNextVersion("chat_user_conversations", "user_id", convo.UserID)
updateFields := map[string]interface{}{
"updated_at": time.Now(),
"version": version,
}
// 如果是隐藏状态，自动恢复显示
if convo.IsHidden {
updateFields["is_hidden"] = false
}
// 处理已读序列号更新
shouldUpdateReadSeq := false
if len(readUserIDs) == 0 {
// 如果readUserIDs为空，所有用户都标记为已读
shouldUpdateReadSeq = true
} else {
// 如果指定了readUserIDs，只有这些用户标记为已读
for _, readUserID := range readUserIDs {
if readUserID == convo.UserID {
shouldUpdateReadSeq = true
break
}
}
}
if shouldUpdateReadSeq {
updateFields["user_read_seq"] = readSeq
logx.Infof("更新用户已读序列号: userID=%s, conversationID=%s, readSeq=%d, version=%d", convo.UserID, conversationID, readSeq, version)
}
// 直接批量更新所有用户的会话关系
err = db.Model(&chat_models.ChatUserConversation{}).
Where("conversation_id = ? AND user_id = ?", conversationID, convo.UserID).
Updates(updateFields).Error
if err != nil {
logx.Errorf("更新用户会话失败: userID=%s, conversationID=%s, error=%v", convo.UserID, conversationID, err)
// 继续处理其他用户，不要因为一个失败而中断整个流程
} else {
updates = append(updates, UserConversationUpdate{
UserID: convo.UserID,
ConversationID: conversationID,
Version: version,
})
}
}
return updates, nil
}
// UserConversationUpdate 用户会话更新信息
type UserConversationUpdate struct {
UserID string
ConversationID string
Version int64
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/chat.go | app/chat/chat_api/chat.go | package main
import (
"beaver/app/chat/chat_api/internal/config"
"beaver/app/chat/chat_api/internal/handler"
"beaver/app/chat/chat_api/internal/svc"
"beaver/common/etcd"
"beaver/common/middleware"
"flag"
"fmt"
"github.com/zeromicro/go-zero/core/conf"
"github.com/zeromicro/go-zero/rest"
)
var configFile = flag.String("f", "etc/chat.yaml", "the config file")
func main() {
flag.Parse()
var c config.Config
conf.MustLoad(*configFile, &c)
server := rest.MustNewServer(c.RestConf)
defer server.Stop()
ctx := svc.NewServiceContext(c)
handler.RegisterHandlers(server, ctx)
// 添加请求日志中间件
server.Use(middleware.RequestLogMiddleware)
etcd.DeliveryAddress(c.Etcd, c.Name+"_api", fmt.Sprintf("%s:%d", c.Host, c.Port))
fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
server.Start()
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/svc/servicecontext.go | app/chat/chat_api/internal/svc/servicecontext.go | package svc
import (
"beaver/app/chat/chat_api/internal/config"
"beaver/app/chat/chat_rpc/chat"
"beaver/app/chat/chat_rpc/types/chat_rpc"
"beaver/app/friend/friend_rpc/friend"
"beaver/app/friend/friend_rpc/types/friend_rpc"
"beaver/app/group/group_rpc/group"
"beaver/app/group/group_rpc/types/group_rpc"
"beaver/app/user/user_rpc/types/user_rpc"
"beaver/app/user/user_rpc/user"
"beaver/common/zrpc_interceptor"
"beaver/core"
versionPkg "beaver/core/version"
"github.com/go-redis/redis"
"github.com/zeromicro/go-zero/zrpc"
"gorm.io/gorm"
)
type ServiceContext struct {
Config config.Config
Redis *redis.Client
UserRpc user_rpc.UserClient
ChatRpc chat_rpc.ChatClient
FriendRpc friend_rpc.FriendClient
GroupRpc group_rpc.GroupClient
DB *gorm.DB
VersionGen *versionPkg.VersionGenerator
}
func NewServiceContext(c config.Config) *ServiceContext {
mysqlDb := core.InitGorm(c.Mysql.DataSource)
client := core.InitRedis(c.Redis.Addr, c.Redis.Password, c.Redis.Db)
versionGen := versionPkg.NewVersionGenerator(client, mysqlDb)
return &ServiceContext{
DB: mysqlDb,
Redis: client,
Config: c,
UserRpc: user.NewUser(zrpc.MustNewClient(c.UserRpc, zrpc.WithUnaryClientInterceptor(zrpc_interceptor.ClientInfoInterceptor))),
ChatRpc: chat.NewChat(zrpc.MustNewClient(c.ChatRpc, zrpc.WithUnaryClientInterceptor(zrpc_interceptor.ClientInfoInterceptor))),
FriendRpc: friend.NewFriend(zrpc.MustNewClient(c.FriendRpc, zrpc.WithUnaryClientInterceptor(zrpc_interceptor.ClientInfoInterceptor))),
GroupRpc: group.NewGroup(zrpc.MustNewClient(c.GroupRpc, zrpc.WithUnaryClientInterceptor(zrpc_interceptor.ClientInfoInterceptor))),
VersionGen: versionGen,
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/types/types.go | app/chat/chat_api/internal/types/types.go | // Code generated by goctl. DO NOT EDIT.
package types
type AudioFileMsg struct {
FileKey string `json:"fileKey"` //音频文件ID
FileName string `json:"fileName,optional"` //原始文件名（可选，用于显示）
Duration int `json:"duration,optional"` //音频时长（秒，可选）
Size int64 `json:"size,optional"` //文件大小（字节，可选）
}
type ChatHistoryReq struct {
UserID string `header:"Beaver-User-Id"`
ConversationID string `json:"conversationId"` // 会话Id
Page int `json:"page,optional"`
Limit int `json:"limit,optional"`
}
type ChatHistoryRes struct {
Count int64 `json:"count"`
List []Message `json:"list"`
}
type ChatSyncMessage struct {
MessageID string `json:"messageId"` //客户端消息ID
ConversationID string `json:"conversationId"` //会话id
ConversationType int `json:"conversationType"` //会话类型（1=私聊 2=群聊）
SendUserID string `json:"sendUserId"` //发送者用户ID
MsgType uint32 `json:"msgType"` //消息类型
MsgPreview string `json:"msgPreview"` //消息预览
Msg string `json:"msg"` //消息内容JSON字符串
IsDeleted bool `json:"isDeleted"` //是否已删除
Seq int64 `json:"seq"` //序列号，用于数据同步
CreatedAt int64 `json:"createdAt"` //创建时间戳
}
type ChatSyncReq struct {
UserID string `header:"Beaver-User-Id"`
ConversationID string `json:"conversationId,optional"` // 会话ID，可选，不传则同步所有会话
FromSeq int64 `json:"fromSeq"` // 起始序列号
ToSeq int64 `json:"toSeq"` // 结束序列号
Limit int `json:"limit,optional"` // 限制数量，默认100
}
type ChatSyncRes struct {
Messages []ChatSyncMessage `json:"messages"` // 消息列表
HasMore bool `json:"hasMore"` // 是否还有更多数据
NextSeq int64 `json:"nextSeq"` // 下次同步的起始序列号
}
type ConversationById struct {
ConversationID string `json:"conversationId"` // 会话ID
Type int `json:"type"` // 会话类型 1=私聊 2=群聊 3=系统会话
MaxSeq int64 `json:"maxSeq"` // 会话消息的最大Seq
LastMessage string `json:"lastMessage"` // 会话最后一条消息预览
Version int64 `json:"version"` // 版本号
CreatedAt int64 `json:"createdAt"` // 创建时间戳
UpdatedAt int64 `json:"updatedAt"` // 更新时间戳
}
type ConversationInfoReq struct {
UserID string `header:"Beaver-User-Id"`
ConversationID string `json:"conversationId"` //会话id
}
type ConversationInfoRes struct {
Avatar string `json:"avatar"`
NickName string `json:"nickName"`
MsgPreview string `json:"msg_preview"` //消息预览
UpdatedAt string `json:"updated_at"` //消息时间
IsTop bool `json:"is_top"` //是否置顶
ConversationID string `json:"conversationId"` //会话id
ChatType int `json:"chatType"` //会话类型 1:好友 2:群聊 3:AI机器人
Notice string `json:"notice"` //备注
}
type DeleteRecentReq struct {
UserID string `header:"Beaver-User-Id"`
ConversationID string `json:"conversationId"` //会话id
}
type DeleteRecentRes struct {
}
type EditMessageReq struct {
UserID string `header:"Beaver-User-Id"`
MessageID string `json:"messageId"` //客户端消息ID
Content string `json:"content"` //新的消息内容
}
type EditMessageRes struct {
Id uint `json:"id"` //数据库自增ID
MessageID string `json:"messageId"` //客户端消息ID
Content string `json:"content"` //编辑后的内容
EditTime string `json:"editTime"` //编辑时间
}
type EmojiMsg struct {
FileKey string `json:"fileKey"` // 表情图片文件ID（Emoji.FileName）
EmojiID string `json:"emojiId"` // 表情ID（Emoji.Id，单个表情时使用）
PackageID string `json:"packageId"` // 表情包ID（EmojiPackage.Id，表情包分享时使用）
}
type FileMsg struct {
FileKey string `json:"fileKey"` //文件ID
FileName string `json:"fileName,optional"` //原始文件名（可选，用于显示）
Size int64 `json:"size,optional"` //文件大小（字节，可选）
MimeType string `json:"mimeType,optional"` //MIME类型（可选，如 application/pdf）
}
type ForwardMessageReq struct {
UserID string `header:"Beaver-User-Id"`
MessageID string `json:"messageId"` //客户端消息ID
TargetID string `json:"targetId"` // 目标会话ID
ForwardType int `json:"forwardType"` // 1: 单聊 2: 群聊
}
type ForwardMessageRes struct {
Id uint `json:"id"` //数据库自增ID
MessageID string `json:"messageId"` //客户端消息ID
ForwardTime string `json:"forwardTime"`
}
type GetConversationsListByIdsReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID
ConversationIds []string `json:"conversationIds"` // 会话ID列表
}
type GetConversationsListByIdsRes struct {
Conversations []ConversationById `json:"conversations"` // 会话列表
}
type GetUserConversationSettingsListByIdsReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID
ConversationIds []string `json:"conversationIds"` // 会话ID列表
}
type GetUserConversationSettingsListByIdsRes struct {
UserConversationSettings []UserConversationSettingById `json:"userConversationSettings"` // 用户会话设置列表
}
type HideChatReq struct {
UserID string `header:"Beaver-User-Id"`
ConversationID string `json:"conversationId"` //会话id
IsHidden bool `json:"isHidden"` // true表示隐藏 false表示显示
}
type HideChatRes struct {
}
type ImageMsg struct {
FileKey string `json:"fileKey"` //图片文件ID
Width int `json:"width,optional"` //图片宽度（可选）
Height int `json:"height,optional"` //图片高度（可选）
Size int64 `json:"size,optional"` //文件大小（字节，可选）
}
type Message struct {
Id uint `json:"id"` //数据库自增ID
MessageID string `json:"messageId"` //客户端消息ID
ConversationID string `json:"conversationId"` //会话id
ConversationType int `json:"conversationType"` //会话类型（1=私聊 2=群聊）
Msg Msg `json:"msg"`
Sender Sender `json:"sender"` //发送者
CreatedAt string `json:"created_at"` //消息时间
Status uint32 `json:"status"` //消息状态 1:正常 2:已撤回 3:已编辑
Seq int64 `json:"seq"` //序列号，用于数据同步
}
type Msg struct {
Type uint32 `json:"type"` //消息类型 1:文本 2:图片 3:视频 4:文件 5:语音 6:表情 7:通知消息 8:音频文件
TextMsg *TextMsg `json:"textMsg,optional"` //文本消息
ImageMsg *ImageMsg `json:"imageMsg,optional"` //图片
VideoMsg *VideoMsg `json:"videoMsg,optional"` //视频
FileMsg *FileMsg `json:"fileMsg,optional"` //文件
VoiceMsg *VoiceMsg `json:"voiceMsg,optional"` //语音
EmojiMsg *EmojiMsg `json:"emojiMsg,optional"` //表情
NotificationMsg *NotificationMsg `json:"notificationMsg,optional"` //通知消息（会话内的通知，如：xxx加入了群聊、xxx创建了群等）
AudioFileMsg *AudioFileMsg `json:"audioFileMsg,optional"` //音频文件
ReplyMsg *ReplyMsg `json:"replyMsg,optional"` //回复消息
}
type MuteChatReq struct {
UserID string `header:"Beaver-User-Id"`
ConversationID string `json:"conversationId"` //会话id
IsMuted bool `json:"isMuted"` // true表示免打扰 false表示取消免打扰
}
type MuteChatRes struct {
}
type NotificationMsg struct {
Type int `json:"type"` // 通知类型：1=好友欢迎 2=创建群 3=加入群 4=退出群 5=踢出成员 6=转让群主等
Actors []string `json:"actors"` // 相关用户ID列表
}
type PinnedChatReq struct {
UserID string `header:"Beaver-User-Id"`
ConversationID string `json:"conversationId"` //会话id
IsPinned bool `json:"isPinned"` // true表示置顶 false表示不置顶
}
type PinnedChatRes struct {
}
type RecallMessageReq struct {
UserID string `header:"Beaver-User-Id"`
MessageID string `json:"messageId"` //客户端消息ID
}
type RecallMessageRes struct {
Id uint `json:"id"` //数据库自增ID
MessageID string `json:"messageId"` //客户端消息ID
RecallTime string `json:"recallTime"` //撤回时间
}
type RecentChatListReq struct {
UserID string `header:"Beaver-User-Id"`
Page int `form:"page,optional"`
Limit int `form:"limit,optional"`
}
type RecentChatListRes struct {
Count int64 `json:"count"`
List []ConversationInfoRes `json:"list"`
}
type ReplyMsg struct {
ReplyToMessageID string `json:"replyToMessageId"` // 被回复的消息ID
ReplyToContent string `json:"replyToContent"` // 被回复的消息内容预览
ReplyToSender string `json:"replyToSender"` // 被回复消息的发送者昵称
}
type SendMsgReq struct {
UserID string `header:"Beaver-User-Id"`
ConversationID string `json:"conversationId"` //会话id
MessageID string `json:"messageId"` //客户端消息ID
Msg Msg `json:"msg"`
}
type SendMsgRes struct {
Id uint `json:"id"` //数据库自增ID
MessageID string `json:"messageId"` //客户端消息ID
ConversationID string `json:"conversationId"` //会话id
Msg Msg `json:"msg"`
Sender Sender `json:"sender"` //发送者
CreatedAt string `json:"created_at"` //消息时间
MsgPreview string `json:"msgPreview"` //消息预览
Status uint32 `json:"status"` //消息状态 1:正常 2:已撤回 3:已编辑
Seq int64 `json:"seq"` //消息序列号，用于数据同步
}
type Sender struct {
UserID string `json:"userId"`
Avatar string `json:"avatar"`
NickName string `json:"nickName"`
}
type TextMsg struct {
Content string `json:"content"` //文本消息内容
}
type UpdateReadSeqReq struct {
UserID string `header:"Beaver-User-Id"` // 用户ID
ConversationID string `json:"conversationId"` // 会话ID
ReadSeq int64 `json:"readSeq"` // 已读序列号（用户已读到的消息seq）
}
type UpdateReadSeqRes struct {
Success bool `json:"success"` // 是否成功
}
type UserConversationSettingById struct {
UserID string `json:"userId"` // 用户ID
ConversationID string `json:"conversationId"` // 会话ID
IsHidden bool `json:"isHidden"` // 是否隐藏
IsPinned bool `json:"isPinned"` // 是否置顶
IsMuted bool `json:"isMuted"` // 是否免打扰
UserReadSeq int64 `json:"userReadSeq"` // 用户已读序列号
Version int64 `json:"version"` // 版本号
CreatedAt int64 `json:"createdAt"` // 创建时间戳
UpdatedAt int64 `json:"updatedAt"` // 更新时间戳
}
type VideoMsg struct {
FileKey string `json:"fileKey"` //视频文件ID
Width int `json:"width,optional"` //视频宽度（可选）
Height int `json:"height,optional"` //视频高度（可选）
Duration int `json:"duration,optional"` //视频时长（秒，可选）
ThumbnailKey string `json:"thumbnailKey,optional"` //视频封面图文件ID（可选）
Size int64 `json:"size,optional"` //文件大小（字节，可选）
}
type VoiceMsg struct {
FileKey string `json:"fileKey"` //语音文件ID
Duration int `json:"duration,optional"` //语音时长（秒，可选）
Size int64 `json:"size,optional"` //文件大小（字节，可选）
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/config/config.go | app/chat/chat_api/internal/config/config.go | package config
import (
"github.com/zeromicro/go-zero/rest"
"github.com/zeromicro/go-zero/zrpc"
)
type Config struct {
rest.RestConf
Mysql struct {
DataSource string
}
Redis struct {
Addr string
Password string
Db int
}
Etcd string
UserRpc zrpc.RpcClientConf
ChatRpc zrpc.RpcClientConf
FriendRpc zrpc.RpcClientConf
GroupRpc zrpc.RpcClientConf
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/hidechathandler.go | app/chat/chat_api/internal/handler/hidechathandler.go | package handler
import (
"beaver/app/chat/chat_api/internal/logic"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func hideChatHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.HideChatReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewHideChatLogic(r.Context(), svcCtx)
resp, err := l.HideChat(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/getuserconversationsettingslistbyidshandler.go | app/chat/chat_api/internal/handler/getuserconversationsettingslistbyidshandler.go | package handler
import (
"beaver/app/chat/chat_api/internal/logic"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func getUserConversationSettingsListByIdsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetUserConversationSettingsListByIdsReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewGetUserConversationSettingsListByIdsLogic(r.Context(), svcCtx)
resp, err := l.GetUserConversationSettingsListByIds(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/recentchatlisthandler.go | app/chat/chat_api/internal/handler/recentchatlisthandler.go | package handler
import (
"beaver/app/chat/chat_api/internal/logic"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func recentChatListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.RecentChatListReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewRecentChatListLogic(r.Context(), svcCtx)
resp, err := l.RecentChatList(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/editmessagehandler.go | app/chat/chat_api/internal/handler/editmessagehandler.go | package handler
import (
"beaver/app/chat/chat_api/internal/logic"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func editMessageHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.EditMessageReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewEditMessageLogic(r.Context(), svcCtx)
resp, err := l.EditMessage(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/deleterecenthandler.go | app/chat/chat_api/internal/handler/deleterecenthandler.go | package handler
import (
"beaver/app/chat/chat_api/internal/logic"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func deleteRecentHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DeleteRecentReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewDeleteRecentLogic(r.Context(), svcCtx)
resp, err := l.DeleteRecent(&req)
response.Response(r, w, resp, err, "删除最近会话成功")
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/mutechathandler.go | app/chat/chat_api/internal/handler/mutechathandler.go | package handler
import (
"beaver/app/chat/chat_api/internal/logic"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func muteChatHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.MuteChatReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewMuteChatLogic(r.Context(), svcCtx)
resp, err := l.MuteChat(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/updatereadseqhandler.go | app/chat/chat_api/internal/handler/updatereadseqhandler.go | package handler
import (
"beaver/app/chat/chat_api/internal/logic"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func updateReadSeqHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UpdateReadSeqReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewUpdateReadSeqLogic(r.Context(), svcCtx)
resp, err := l.UpdateReadSeq(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/sendmsghandler.go | app/chat/chat_api/internal/handler/sendmsghandler.go | package handler
import (
"errors"
"net/http"
"beaver/app/chat/chat_api/internal/logic"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/common/response"
"github.com/zeromicro/go-zero/rest/httpx"
)
func SendMsgHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.SendMsgReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
// 验证必填参数
if req.UserID == "" {
response.Response(r, w, nil, errors.New("用户ID不能为空"))
return
}
if req.ConversationID == "" {
response.Response(r, w, nil, errors.New("会话ID不能为空"))
return
}
if req.MessageID == "" {
response.Response(r, w, nil, errors.New("消息ID不能为空"))
return
}
l := logic.NewSendMsgLogic(r.Context(), svcCtx)
resp, err := l.SendMsg(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/conversationinfohandler.go | app/chat/chat_api/internal/handler/conversationinfohandler.go | package handler
import (
"beaver/app/chat/chat_api/internal/logic"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func ConversationInfoHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.ConversationInfoReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewConversationInfoLogic(r.Context(), svcCtx)
resp, err := l.ConversationInfo(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
wsrh8888/beaver-server | https://github.com/wsrh8888/beaver-server/blob/71409b80d00457511f57d8fec96e7366a8520b60/app/chat/chat_api/internal/handler/chathistoryhandler.go | app/chat/chat_api/internal/handler/chathistoryhandler.go | package handler
import (
"beaver/app/chat/chat_api/internal/logic"
"beaver/app/chat/chat_api/internal/svc"
"beaver/app/chat/chat_api/internal/types"
"beaver/common/response"
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
)
func chatHistoryHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.ChatHistoryReq
if err := httpx.Parse(r, &req); err != nil {
response.Response(r, w, nil, err)
return
}
l := logic.NewChatHistoryLogic(r.Context(), svcCtx)
resp, err := l.ChatHistory(&req)
response.Response(r, w, resp, err)
}
}
| go | MIT | 71409b80d00457511f57d8fec96e7366a8520b60 | 2026-01-07T09:45:42.639179Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.