Пример #1
0
        public AlgoMetaDataBuilder WithFunction(FunctionParamsDTO functionParams, FunctionType functionType)
        {
            if (functionParams != null)
            {
                AlgoMetaDataFunction functionMetaData = new AlgoMetaDataFunction(functionType)
                {
                    Id         = functionParams.FunctionInstanceIdentifier,
                    Parameters = GetParamBuilder().CreateParameters()
                                 //.WithParameterFunctionInstanceIdentifier(functionParams.FunctionInstanceIdentifier)
                                 .WithParameterStartingDate(functionParams.StartingDate.ToString(GlobalConstants.ISO_8601_DATE_FORMAT))
                                 .WithParameterEndingDate(functionParams.EndingDate.ToString(GlobalConstants.ISO_8601_DATE_FORMAT))
                                 .WithParameterAssetPair(functionParams.AssetPair)
                                 .WithParameterPeriod(functionParams.Period)
                                 .WithParameterCandleOperationMode(functionParams.CandleOperationMode)
                                 .WithParameterCandleTimeInterval(functionParams.CandleTimeInterval)
                                 .Build()
                };

                // Make keys for functions parametes camelCase
                ChangeKeyToCamelCase(functionMetaData);

                algoMetaDataInformation.Functions.Add(functionMetaData);
            }
            return(this);
        }
 private static void AddToFunctionsDictionary(FunctionType functionType, FunctionParamsDTO functionParamsDTO)
 {
     if (FunctionsDictionary.ContainsKey(functionType.ToString()))
     {
         FunctionsDictionary[functionType.ToString()] = functionParamsDTO;
     }
     else
     {
         FunctionsDictionary.Add(functionType.ToString(), functionParamsDTO);
     }
 }
        public AlgoMetaDataBuilder WithFunction(FunctionParamsDTO functionParams, FunctionType functionType)
        {
            if (functionParams != null)
            {
                AlgoMetaDataFunction functionMetaData = new AlgoMetaDataFunction(functionType)
                {
                    Id         = functionParams.FunctionInstanceIdentifier,
                    Parameters = GetParamBuilder().CreateParameters()
                                 .WithParameterFunctionInstanceIdentifier(functionParams.FunctionInstanceIdentifier)
                                 .WithParameterStartingDate(functionParams.StartingDate.ToString(Constants.ISO_8601_DATE_FORMAT))
                                 .WithParameterEndingDate(functionParams.EndingDate.ToString(Constants.ISO_8601_DATE_FORMAT))
                                 .WithParameterAssetPair(functionParams.AssetPair)
                                 .WithParameterCapacity(functionParams.Capacity)
                                 .WithParameterCandleOperationMode(functionParams.CandleOperationMode)
                                 .WithParameterCandleTimeInterval(functionParams.CandleTimeInterval)
                                 .Build()
                };

                algoMetaDataInformation.Functions.Add(functionMetaData);
            }
            return(this);
        }
        private static AlgoMetaDataInformation BuildAlgoMetaDataInformation(InstanceParameters instanceParameters, DaysOffsetDTO daysOffsetDTO)
        {
            FunctionParamsDTO smaShortFunctionParamsDTO = null;
            FunctionParamsDTO smaLongFunctionParamsDTO  = null;
            FunctionParamsDTO adxFunctionParamsDTO      = null;
            FunctionParamsDTO macdFunctionParamsDTO     = null;

            AlgoParamsDTO algoParamsDTO = new AlgoParamsDTO(daysOffsetDTO.AlgoStartOffset, daysOffsetDTO.AlgoEndOffset,
                                                            instanceParameters.AssetPair, instanceParameters.TradedAsset,
                                                            instanceParameters.InstanceTradeVolume, instanceParameters.InstanceCandleInterval);

            // Create SMA_SHORT function parameters
            if (instanceParameters.InstanceFunctions.Contains(FunctionType.SMA_Short))
            {
                smaShortFunctionParamsDTO = new FunctionParamsDTO(FunctionType.SMA_Short, daysOffsetDTO.SmaShortStartOffset, daysOffsetDTO.SmaShortEndOffset,
                                                                  instanceParameters.AssetPair, instanceParameters.FunctionPeriod,
                                                                  instanceParameters.FunctionCandleOperationMode, instanceParameters.FunctionCandleInterval);

                // Add the function params to the functionsDictionary
                AddToFunctionsDictionary(FunctionType.SMA_Short, smaShortFunctionParamsDTO);
            }

            // Create SMA_Long function parameters
            if (instanceParameters.InstanceFunctions.Contains(FunctionType.SMA_Long))
            {
                smaLongFunctionParamsDTO = new FunctionParamsDTO(FunctionType.SMA_Long, daysOffsetDTO.SmaLongStartOffset, daysOffsetDTO.SmaLongEndOffset,
                                                                 instanceParameters.AssetPair, instanceParameters.FunctionPeriod,
                                                                 instanceParameters.FunctionCandleOperationMode, instanceParameters.FunctionCandleInterval);

                // Add the function params to the functionsDictionary
                AddToFunctionsDictionary(FunctionType.SMA_Long, smaLongFunctionParamsDTO);
            }

            // Create ADX function parameters
            if (instanceParameters.InstanceFunctions.Contains(FunctionType.ADX))
            {
                throw new NotImplementedException("Creating parameters for ADX function is not yet implemented");

                // Add the function params to the functionsDictionary
                //AddToFunctionsDictionary(FunctionType.ADX, adxFunctionParamsDTO);
            }

            // Create MACD function parameters
            if (instanceParameters.InstanceFunctions.Contains(FunctionType.MACD))
            {
                throw new NotImplementedException("Creating parameters for MACD function is not yet implemented");

                // Add the function params to the functionsDictionary
                //AddToFunctionsDictionary(FunctionType.MACD, macdFunctionParamsDTO);
            }

            // Build Algo Metadata
            return(GetAlgoMetaDataBuilder()
                   .CreateAlgoMetaData()
                   .WithAlgoParams(algoParamsDTO)
                   .WithFunction(smaShortFunctionParamsDTO, FunctionType.SMA_Short)
                   .WithFunction(smaLongFunctionParamsDTO, FunctionType.SMA_Long)
                   .WithFunction(adxFunctionParamsDTO, FunctionType.ADX)
                   .WithFunction(macdFunctionParamsDTO, FunctionType.MACD)
                   .Build());
        }