Integration with new Version of Strategizer complete

This commit is contained in:
Luis Fernando Molina committed 2019-06-04 11:36:02 +02:00
1 parent 5374744799
commit 4d78d5d921
5 files changed
+211 -373

No files matched your search

Whitespace-only changes.
-7
View File
@@ -1,7 +0,0 @@
const GRAPHQL_MUTATION_UPDATE_STRATEGIES = Apollo.gql`
mutation strategizer_EditStrategy($id: ID!, $strategy: strategizer_StrategyInput!) {
strategizer_EditStrategy(id: $id, strategy: $strategy) {
id
}
}
`
@@ -0,0 +1 @@
+184 -350
View File
@@ -1,353 +1,187 @@
function newStrategizerGateway () {
const MODULE_NAME = 'Strategizer Gateway'
const ERROR_LOG = true
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
let thisObject = {
strategizerData: undefined,
container: undefined,
loadFromStrategyzer: loadFromStrategyzer,
saveToStrategyzer: saveToStrategyzer,
draw: draw,
getContainer: getContainer,
initialize: initialize
}
let colletionItems = []
thisObject.container = newContainer()
thisObject.container.name = MODULE_NAME
thisObject.container.initialize()
thisObject.container.frame.width = 0
thisObject.container.frame.height = 0
thisObject.container.frame.position.x = 0
thisObject.container.frame.position.y = 0
thisObject.container.isDraggeable = false
thisObject.container.isClickeable = false
return thisObject
function initialize () {
}
async function saveToStrategyzer () {
try {
const accessToken = window.localStorage.getItem(LOGGED_IN_ACCESS_TOKEN_LOCAL_STORAGE_KEY)
let user = window.localStorage.getItem(LOGGED_IN_USER_LOCAL_STORAGE_KEY)
if (user === null) {
if (ERROR_LOG === true) { logger.write('[ERROR] saveToStrategyzer -> Can not save because user is not logged in. ') }
return
}
user = JSON.parse(user)
const authId = user.authId
const apolloClient = new Apollo.lib.ApolloClient({
networkInterface: Apollo.lib.createNetworkInterface({
uri: window.canvasApp.graphQL.masterAppApiUrl,
transportBatching: true
}),
connectToDevTools: true
})
/* Updating all Strategies */
const networkInterface = Apollo.lib.createNetworkInterface({
uri: window.canvasApp.graphQL.masterAppApiUrl
})
networkInterface.use([{
applyMiddleware (req, next) {
req.options.headers = {
authorization: `Bearer ${accessToken}`
}
next()
function newStrategizerGateway () {
const MODULE_NAME = 'Strategizer Gateway'
const ERROR_LOG = true
const logger = newWebDebugLog()
logger.fileName = MODULE_NAME
let thisObject = {
strategizerData: undefined,
container: undefined,
loadFromStrategyzer: loadFromStrategyzer,
saveToStrategyzer: saveToStrategyzer,
draw: draw,
getContainer: getContainer,
initialize: initialize
}
let colletionItems = []
thisObject.container = newContainer()
thisObject.container.name = MODULE_NAME
thisObject.container.initialize()
thisObject.container.frame.width = 0
thisObject.container.frame.height = 0
thisObject.container.frame.position.x = 0
thisObject.container.frame.position.y = 0
thisObject.container.isDraggeable = false
thisObject.container.isClickeable = false
return thisObject
function initialize () {
}
async function saveToStrategyzer () {
try {
const accessToken = window.localStorage.getItem(LOGGED_IN_ACCESS_TOKEN_LOCAL_STORAGE_KEY)
let user = window.localStorage.getItem(LOGGED_IN_USER_LOCAL_STORAGE_KEY)
if (user === null) {
if (ERROR_LOG === true) { logger.write('[ERROR] saveToStrategyzer -> Can not save because user is not logged in. ') }
return
}
user = JSON.parse(user)
let fbSlug = 'simulator' + '-' + user.alias
/* See if we need to update or create a new record at the strategizer */
let tradingSystem = canvas.strategySpace.workspace.getProtocolTradingSystem()
let idAtStrategizer = canvas.strategySpace.workspace.idAtStrategizer
if (idAtStrategizer === undefined) {
let response = await axios({
url: window.canvasApp.graphQL.masterAppApiUrl,
method: 'post',
data: {
query: `
mutation strategizer_CreateTradingSystem
(
$fbSlug: String!, $data: strategizer_JSON!
)
{
strategizer_CreateTradingSystem(fbSlug: $fbSlug, tradingSystem: { data: $data })
{
id
}
}
`,
variables: {
fbSlug: fbSlug,
data: tradingSystem
}
},
headers: {
authorization: 'Bearer ' + accessToken
}
})
if (response.data.errors) {
console.log('Error getting events: ' + JSON.stringify(response.data.errors))
throw 'Error getting events: ' + JSON.stringify(response.data.errors)
} else {
canvas.strategySpace.workspace.idAtStrategizer = response.data.data.strategizer_CreateTradingSystem.id
}
}])
let tradingSystem = canvas.strategySpace.workspace.tradingSystem
let idAtStrategizer = canvas.strategySpace.workspace.idAtStrategizer
let dataToSave = buildGraphQLDataToSave(tradingSystem)
const updateStrategies = () => {
return new Promise((resolve, reject) => {
apolloClient.mutate({
mutation: GRAPHQL_MUTATION_UPDATE_STRATEGIES,
variables: {
id: idAtStrategizer,
strategy: dataToSave.strategy
}
})
.then(response => {
resolve(true)
})
.catch(err => {
if (ERROR_LOG === true) { logger.write('[ERROR] saveToStrategyzer -> ApolloClient error updating user strategies -> err = ' + err.stack) }
reject(err)
})
} else {
const graphQLServer = await axios({
url: window.canvasApp.graphQL.masterAppApiUrl,
method: 'post',
data: {
query: `
mutation strategizer_EditTradingSystem
(
$id: ID!, $data: strategizer_JSON!
)
{
strategizer_EditTradingSystem(id: $id, tradingSystem: { data: $data })
{
id
}
}
`,
variables: {
id: idAtStrategizer,
data: tradingSystem
}
},
headers: {
authorization: 'Bearer ' + accessToken
}
})
}
return true
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] saveToStrategyzer -> err = ' + err.stack) }
}
}
async function loadFromStrategyzer () {
try {
const accessToken = window.localStorage.getItem(LOGGED_IN_ACCESS_TOKEN_LOCAL_STORAGE_KEY)
let user = window.localStorage.getItem(LOGGED_IN_USER_LOCAL_STORAGE_KEY)
if (user === null) {
// if there is no user that means that we are logged off, which means this object can not be used.
return
}
user = JSON.parse(user)
let fbSlug = 'simulator' + '-' + user.alias
let response = await axios({
url: window.canvasApp.graphQL.masterAppApiUrl,
method: 'post',
data: {
query:
`
query($fbSlug: String!){
strategizer_TradingSystemByFb(fbSlug: $fbSlug){
id
fbSlug
data
}
}
`,␍
variables: {
fbSlug: fbSlug
}
},
headers: {
authorization: 'Bearer ' + accessToken
}
})
if (response.data.errors) {
if (response.data.errors[0] === 'Ressource not found : None of the tradingSystem are linked to that fbSlug') {
return false
} else {
logger.write('[ERROR] Error while getting Trading System from Strategizer: ' + JSON.stringify(response.data.errors))
return false
}
} else {
window.localStorage.setItem('userStrategies', JSON.stringify(response.data.data.strategizer_TradingSystemByFb.data))
thisObject.strategizerData = JSON.parse(JSON.stringify(response.data.data.strategizer_TradingSystemByFb.data))
canvas.strategySpace.workspace.idAtStrategizer = response.data.data.strategizer_TradingSystemByFb.id
return true
}
let result = await updateStrategies()
return result
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] saveToStrategyzer -> err = ' + err.stack) }
}
}
function buildGraphQLDataToSave (tradingSystem) {
let graphQL_Mutation = ''
let dataToSave = {
strategy: {
subStrategies: []
}
}
for (m = 0; m < tradingSystem.strategies.length; m++) {
let strategizerGatewayStrategy = tradingSystem.strategies[m]
let strategy = {
name: strategizerGatewayStrategy.name,
active: strategizerGatewayStrategy.active,
triggerOn: {
situations: []
},
triggerOff: {
situations: []
},
takePosition: {
situations: []
},
stopLoss: {
phases: []
},
takeProfit: {
phases: []
}
}
for (let k = 0; k < strategizerGatewayStrategy.triggerOn.situations.length; k++) {
let strategizerGatewaySituation = strategizerGatewayStrategy.triggerOn.situations[k]
let situation = {
name: strategizerGatewaySituation.name,
conditions: []
}
for (let m = 0; m < strategizerGatewaySituation.conditions.length; m++) {
let strategizerGatewayCondition = strategizerGatewaySituation.conditions[m]
let condition = {
name: strategizerGatewayCondition.name,
code: strategizerGatewayCondition.code
}
situation.conditions.push(condition)
}
strategy.triggerOn.situations.push(situation)
}
for (let k = 0; k < strategizerGatewayStrategy.triggerOff.situations.length; k++) {
let strategizerGatewaySituation = strategizerGatewayStrategy.triggerOff.situations[k]
let situation = {
name: strategizerGatewaySituation.name,
conditions: []
}
for (let m = 0; m < strategizerGatewaySituation.conditions.length; m++) {
let strategizerGatewayCondition = strategizerGatewaySituation.conditions[m]
let condition = {
name: strategizerGatewayCondition.name,
code: strategizerGatewayCondition.code
}
situation.conditions.push(condition)
}
strategy.triggerOff.situations.push(situation)
}
for (let k = 0; k < strategizerGatewayStrategy.takePosition.situations.length; k++) {
let strategizerGatewaySituation = strategizerGatewayStrategy.takePosition.situations[k]
let situation = {
name: strategizerGatewaySituation.name,
conditions: []
}
for (let m = 0; m < strategizerGatewaySituation.conditions.length; m++) {
let strategizerGatewayCondition = strategizerGatewaySituation.conditions[m]
let condition = {
name: strategizerGatewayCondition.name,
code: strategizerGatewayCondition.code
}
situation.conditions.push(condition)
}
strategy.takePosition.situations.push(situation)
}
for (let p = 0; p < strategizerGatewayStrategy.stopLoss.phases.length; p++) {
let strategizerGatewayPhase = strategizerGatewayStrategy.stopLoss.phases[p]
let phase = {
name: strategizerGatewayPhase.name,
code: strategizerGatewayPhase.code,
situations: []
}
for (let k = 0; k < strategizerGatewayPhase.situations.length; k++) {
let strategizerGatewaySituation = strategizerGatewayPhase.situations[k]
let situation = {
name: strategizerGatewaySituation.name,
conditions: []
}
for (let m = 0; m < strategizerGatewaySituation.conditions.length; m++) {
let strategizerGatewayCondition = strategizerGatewaySituation.conditions[m]
let condition = {
name: strategizerGatewayCondition.name,
code: strategizerGatewayCondition.code
}
situation.conditions.push(condition)
}
phase.situations.push(situation)
}
strategy.stopLoss.phases.push(phase)
}
for (let p = 0; p < strategizerGatewayStrategy.takeProfit.phases.length; p++) {
let strategizerGatewayPhase = strategizerGatewayStrategy.takeProfit.phases[p]
let phase = {
name: strategizerGatewayPhase.name,
code: strategizerGatewayPhase.code,
situations: []
}
for (let k = 0; k < strategizerGatewayPhase.situations.length; k++) {
let strategizerGatewaySituation = strategizerGatewayPhase.situations[k]
let situation = {
name: strategizerGatewaySituation.name,
conditions: []
}
for (let m = 0; m < strategizerGatewaySituation.conditions.length; m++) {
let strategizerGatewayCondition = strategizerGatewaySituation.conditions[m]
let condition = {
name: strategizerGatewayCondition.name,
code: strategizerGatewayCondition.code
}
situation.conditions.push(condition)
}
phase.situations.push(situation)
}
strategy.takeProfit.phases.push(phase)
}
dataToSave.strategy.subStrategies.push(strategy)
}
return dataToSave
}
async function loadFromStrategyzer () {
try {
const accessToken = window.localStorage.getItem(LOGGED_IN_ACCESS_TOKEN_LOCAL_STORAGE_KEY)
let user = window.localStorage.getItem(LOGGED_IN_USER_LOCAL_STORAGE_KEY)
if (user === null) {
// if there is no user that means that we are logged off, which means this object can not be used.
return
}
user = JSON.parse(user)
const authId = user.authId
const apolloClient = new Apollo.lib.ApolloClient({
networkInterface: Apollo.lib.createNetworkInterface({
uri: window.canvasApp.graphQL.masterAppApiUrl,
transportBatching: true
}),
connectToDevTools: true
})
/* Getting the FB that own the Strategies */
let teamtradingSystemSimulationFB = ''
let ecosystem = JSON.parse(window.localStorage.getItem('ecosystem'))
let teams = ecosystem.devTeams
for (let i = 0; i < teams.length; i++) {
let team = teams[i]
for (let j = 0; j < team.bots.length; j++) {
let bot = team.bots[j]
if (bot.codeName.indexOf('simulator') >= 0) {
teamtradingSystemSimulationFB = bot.codeName
}
}
}
if (teamtradingSystemSimulationFB === '') {
if (ERROR_LOG === true) { logger.write('[ERROR] loadFromStrategyzer -> no simulation FB found at user teams. ') }
return
}
/* Getting all Strategies */
const networkInterface = Apollo.lib.createNetworkInterface({
uri: window.canvasApp.graphQL.masterAppApiUrl
})
networkInterface.use([{
applyMiddleware (req, next) {
req.options.headers = {
authorization: `Bearer ${accessToken}`
}
next()
}
}])
const getStrategies = () => {
return new Promise((resolve, reject) => {
apolloClient.query({
query: GRAPHQL_QUERY_GET_STRATEGIES,
variables: { fbSlug: teamtradingSystemSimulationFB}
})
.then(response => {
window.localStorage.setItem('userStrategies', JSON.stringify(response.data.strategizer_StrategyByFb))
thisObject.strategizerData = JSON.parse(JSON.stringify(response.data.strategizer_StrategyByFb))
resolve({ strategies: response.data.strategizer_StrategyByFb.subStrategies})
})
.catch(err => {
if (ERROR_LOG === true) { logger.write('[ERROR] loadFromStrategyzer -> ApolloClient error getting user strategies -> err = ' + err.stack) }
reject(err)
})
})
}
// To avoid race conditions, add asynchronous fetches to array
let fetchDataPromises = []
fetchDataPromises.push(getStrategies())
// When all asynchronous fetches resolve, authenticate user or throw error.
await Promise.all(fetchDataPromises).then(result => {
}, err => {
if (ERROR_LOG === true) { logger.write('[ERROR] loadFromStrategyzer -> GraphQL Fetch Error -> err = ' + err.stack) }
})
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] loadFromStrategyzer -> err = ' + err.stack) }
}
}
function getContainer (point) {
let container
return undefined
}
function draw () {
}
}
} catch (err) {
if (ERROR_LOG === true) { logger.write('[ERROR] loadFromStrategyzer -> err = ' + err.stack) }
}
}
function getContainer (point) {
let container
return undefined
}
function draw () {
}
}
+26 -16
View File
@@ -7,6 +7,7 @@ function newWorkspace () {
container: undefined,
idAtStrategizer: undefined,
onMenuItemClick: onMenuItemClick,
getProtocolTradingSystem: getProtocolTradingSystem,
physics: physics,
spawn: spawn,
detachNode: detachNode,
@@ -41,6 +42,7 @@ function newWorkspace () {
functionLibraryProtocolNode = newProtocolNode()
functionLibraryWorkspaceNodes = newWorkspaceNode()
let isInitialized = false
return thisObject
function finalize () {
@@ -63,36 +65,43 @@ function newWorkspace () {
workspace = JSON.parse(savedWorkspace)
rootNodes = workspace.rootNodes
thisObject.idAtStrategizer = workspace.idAtStrategizer
if (thisObject.idAtStrategizer === undefined) {
initializeLoadingFromStrategizer()
} else {
for (let i = 0; i < rootNodes.length; i++) {
let rootNode = rootNodes[i]
functionLibraryPartsFromNodes.createPartFromNode(rootNode, undefined, undefined)
}
for (let i = 0; i < rootNodes.length; i++) {
let rootNode = rootNodes[i]
functionLibraryPartsFromNodes.createPartFromNode(rootNode, undefined, undefined)
}
isInitialized = true
}
}
async function initializeLoadingFromStrategizer () {
await canvas.strategySpace.strategizerGateway.loadFromStrategyzer()
let tradingSystem = canvas.strategySpace.strategizerGateway.strategizerData
if (tradingSystem !== undefined) {
let adaptedTradingSystem = {
strategies: tradingSystem.subStrategies
let result = await canvas.strategySpace.strategizerGateway.loadFromStrategyzer()
if (result === true) {
thisObject.tradingSystem = canvas.strategySpace.strategizerGateway.strategizerData
rootNodes.push(thisObject.tradingSystem)
functionLibraryPartsFromNodes.createPartFromNode(thisObject.tradingSystem, undefined, undefined)
thisObject.tradingSystem.payload.uiObject.setRunningStatus()
} else {
// First use of the Designer, lets help by creating the first Trading System
thisObject.tradingSystem = {
type: 'Trading System',
strategies: []
}
thisObject.idAtStrategizer = tradingSystem.id
rootNodes.push(adaptedTradingSystem)
functionLibraryPartsFromNodes.createPartFromNode(adaptedTradingSystem, undefined, undefined)
thisObject.tradingSystem = adaptedTradingSystem
rootNodes.push(thisObject.tradingSystem)
functionLibraryPartsFromNodes.createPartFromNode(thisObject.tradingSystem, undefined, undefined)
thisObject.tradingSystem.payload.uiObject.setRunningStatus()
}
isInitialized = true
}
function getContainer (point) {
}
function getProtocolTradingSystem () {
return functionLibraryProtocolNode.getProtocolNode(thisObject.tradingSystem)
}
function detachNode (node) {
functionLibraryAttachDetach.detachNode(node, rootNodes)
}
@@ -102,6 +111,7 @@ function newWorkspace () {
}
function physics () {
if (isInitialized !== true) { return }
/* Here we will save all the workspace related objects into the local storage */
let stringifyReadyNodes = []
for (let i = 0; i < rootNodes.length; i++) {