VERSION 1.12 @ 2018-02-14 07:05:47.033501

Cannot read property 'contains' of null #2442
Terminal: custom sorting for account manager tables #2344
Datafeed not closed after removing chart #2270
order.setPrice() has stopped working #2267
Volume in DOM rounded to 0 #2255
Error on bars request and update order lines #2237
Console error: Uncaught (in promise) formatter not received #2228
DOME doesn't work in new version #2211
Add featureset to hide toolbars by default #2209
Add possibility to move studies through z-order #2187
Unexpected resolution values in getBars #2179
Session breaks line is stuck to the left on reload #2153
Typescript declaration has mistakes #2144
Terminal: cannot specify step less than 1 #2141
Namespace the types in charting_library.d.ts #2137
Widget logo showing momentarily on paid account #2132
Add API to apply overrides for created studies #2098
Baseline chart style #2097
How to hide legend "Data Provided by ICE Data services" #2046
Stoch RSI Calculation #2038
Customize loading screen #2012
Supertrend indicator #1950
Translations in market details widget #1946
"Track time" chart setting #1918
Add tabs for positions #1906
Trading Terminal: Notifications Log #1896
Previous Close Price Line #1843
Set Overlay/Compare styles using createStudy/overrides and applyStudiesOverrides #1812
Session under Symbol info is displaying wrong trading interval(s)? #1787
Add "Go to" specific date #1753
Add session breaks #1752
Allow users to specify a volume for the Long/Short Position drawing tools #1691
Add API to use own charts save/load adapter #1679
Drawing toolbar not available in mobile #1673
Typescript definitions #1591
Support for symbols containing lowercase letters #1581
createMultipointShape long_position stop&profit setting #1459
Cannot change awesome oscillator width #1213
New adaptive drawings panel #1145
Edit shapes, studies and series #1101
Hide an indicator with API #1025
VWAP INDICATOR #106
This commit is contained in:
Jenkins
2018-02-14 01:10:34 -06:00
parent 7feb3edc93
commit d15c5cfb60
98 changed files with 4647 additions and 2034 deletions

View File

@@ -0,0 +1,266 @@
import {
LibrarySymbolInfo,
SearchSymbolResultItem,
} from '../../../charting_library/datafeed-api';
import {
getErrorMessage,
logMessage,
} from './helpers';
import { Requester } from './requester';
interface SymbolInfoMap {
[symbol: string]: LibrarySymbolInfo | undefined;
}
interface ExchangeDataResponseOptionalValues {
'ticker': string;
'minmov2': number;
'minmove2': number;
'minmov': number;
'minmovement': number;
'supported-resolutions': string[];
'force-session-rebuild': boolean;
'has-intraday': boolean;
'has-daily': boolean;
'has-weekly-and-monthly': boolean;
'has-empty-bars': boolean;
'has-no-volume': boolean;
'intraday-multipliers': string[];
'volume-precision': number;
}
interface ExchangeDataResponseMandatoryValues {
'type': string;
'timezone': LibrarySymbolInfo['timezone'];
'description': string;
'exchange-listed': string;
'exchange-traded': string;
'session-regular': string;
'fractional': boolean;
'pricescale': number;
}
// Here is some black magic with types to get compile-time checks of names and types
type ValueOrArray<T> = T | T[];
type ExchangeDataResponse =
{
symbol: string[];
} &
{
[K in keyof ExchangeDataResponseMandatoryValues]: ValueOrArray<ExchangeDataResponseMandatoryValues[K]>;
} &
{
[K in keyof ExchangeDataResponseOptionalValues]?: ValueOrArray<ExchangeDataResponseOptionalValues[K]>;
};
function extractField<Field extends keyof ExchangeDataResponseMandatoryValues>(data: ExchangeDataResponse, field: Field, arrayIndex: number): ExchangeDataResponseMandatoryValues[Field];
function extractField<Field extends keyof ExchangeDataResponseOptionalValues>(data: ExchangeDataResponse, field: Field, arrayIndex: number): ExchangeDataResponseOptionalValues[Field] | undefined;
function extractField<Field extends keyof ExchangeDataResponseMandatoryValues>(data: ExchangeDataResponse, field: Field, arrayIndex: number): (ExchangeDataResponseMandatoryValues & ExchangeDataResponseOptionalValues)[Field] | undefined {
const value = data[field];
return Array.isArray(value) ? value[arrayIndex] : value;
}
export class SymbolsStorage {
private readonly _exchangesList: string[] = ['NYSE', 'FOREX', 'AMEX'];
private readonly _symbolsInfo: SymbolInfoMap = {};
private readonly _symbolsList: string[] = [];
private readonly _datafeedUrl: string;
private readonly _readyPromise: Promise<void>;
private readonly _datafeedSupportedResolutions: string[];
private readonly _requester: Requester;
public constructor(datafeedUrl: string, datafeedSupportedResolutions: string[], requester: Requester) {
this._datafeedUrl = datafeedUrl;
this._datafeedSupportedResolutions = datafeedSupportedResolutions;
this._requester = requester;
this._readyPromise = this._init();
this._readyPromise.catch((error: Error) => {
// seems it is impossible
console.error(`SymbolsStorage: Cannot init, error=${error.toString()}`);
});
}
// BEWARE: this function does not consider symbol's exchange
public resolveSymbol(symbolName: string): Promise<LibrarySymbolInfo> {
return this._readyPromise.then(() => {
const symbolInfo = this._symbolsInfo[symbolName];
if (symbolInfo === undefined) {
return Promise.reject('invalid symbol');
}
return Promise.resolve(symbolInfo);
});
}
public searchSymbols(searchString: string, exchange: string, symbolType: string, maxSearchResults: number): Promise<SearchSymbolResultItem[]> {
interface WeightedItem {
symbolInfo: LibrarySymbolInfo;
weight: number;
}
return this._readyPromise.then(() => {
const weightedResult: WeightedItem[] = [];
const queryIsEmpty = searchString.length === 0;
searchString = searchString.toUpperCase();
for (const symbolName of this._symbolsList) {
const symbolInfo = this._symbolsInfo[symbolName];
if (symbolInfo === undefined) {
continue;
}
if (symbolType.length > 0 && symbolInfo.type !== symbolType) {
continue;
}
if (exchange && exchange.length > 0 && symbolInfo.exchange !== exchange) {
continue;
}
const positionInName = symbolInfo.name.toUpperCase().indexOf(searchString);
const positionInDescription = symbolInfo.description.toUpperCase().indexOf(searchString);
if (queryIsEmpty || positionInName >= 0 || positionInDescription >= 0) {
const alreadyExists = weightedResult.some((item: WeightedItem) => item.symbolInfo === symbolInfo);
if (!alreadyExists) {
const weight = positionInName >= 0 ? positionInName : 8000 + positionInDescription;
weightedResult.push({ symbolInfo: symbolInfo, weight: weight });
}
}
}
const result = weightedResult
.sort((item1: WeightedItem, item2: WeightedItem) => item1.weight - item2.weight)
.slice(0, maxSearchResults)
.map((item: WeightedItem) => {
const symbolInfo = item.symbolInfo;
return {
symbol: symbolInfo.name,
full_name: symbolInfo.full_name,
description: symbolInfo.description,
exchange: symbolInfo.exchange,
params: [],
type: symbolInfo.type,
ticker: symbolInfo.name,
};
});
return Promise.resolve(result);
});
}
private _init(): Promise<void> {
interface BooleanMap {
[key: string]: boolean | undefined;
}
const promises: Promise<void>[] = [];
const alreadyRequestedExchanges: BooleanMap = {};
for (const exchange of this._exchangesList) {
if (alreadyRequestedExchanges[exchange]) {
continue;
}
alreadyRequestedExchanges[exchange] = true;
promises.push(this._requestExchangeData(exchange));
}
return Promise.all(promises)
.then(() => {
this._symbolsList.sort();
logMessage('SymbolsStorage: All exchanges data loaded');
});
}
private _requestExchangeData(exchange: string): Promise<void> {
return new Promise((resolve: () => void, reject: (error: Error) => void) => {
this._requester.sendRequest<ExchangeDataResponse>(this._datafeedUrl, 'symbol_info', { group: exchange })
.then((response: ExchangeDataResponse) => {
try {
this._onExchangeDataReceived(exchange, response);
} catch (error) {
reject(error);
return;
}
resolve();
})
.catch((reason?: string | Error) => {
logMessage(`SymbolsStorage: Request data for exchange '${exchange}' failed, reason=${getErrorMessage(reason)}`);
resolve();
});
});
}
private _onExchangeDataReceived(exchange: string, data: ExchangeDataResponse): void {
let symbolIndex = 0;
try {
const symbolsCount = data.symbol.length;
const tickerPresent = data.ticker !== undefined;
for (; symbolIndex < symbolsCount; ++symbolIndex) {
const symbolName = data.symbol[symbolIndex];
const listedExchange = extractField(data, 'exchange-listed', symbolIndex);
const tradedExchange = extractField(data, 'exchange-traded', symbolIndex);
const fullName = tradedExchange + ':' + symbolName;
const ticker = tickerPresent ? (extractField(data, 'ticker', symbolIndex) as string) : symbolName;
const symbolInfo: LibrarySymbolInfo = {
ticker: ticker,
name: symbolName,
base_name: [listedExchange + ':' + symbolName],
full_name: fullName,
listed_exchange: listedExchange,
exchange: tradedExchange,
description: extractField(data, 'description', symbolIndex),
has_intraday: definedValueOrDefault(extractField(data, 'has-intraday', symbolIndex), false),
has_no_volume: definedValueOrDefault(extractField(data, 'has-no-volume', symbolIndex), false),
minmov: extractField(data, 'minmovement', symbolIndex) || extractField(data, 'minmov', symbolIndex) || 0,
minmove2: extractField(data, 'minmove2', symbolIndex) || extractField(data, 'minmov2', symbolIndex),
fractional: extractField(data, 'fractional', symbolIndex),
pricescale: extractField(data, 'pricescale', symbolIndex),
type: extractField(data, 'type', symbolIndex),
session: extractField(data, 'session-regular', symbolIndex),
timezone: extractField(data, 'timezone', symbolIndex),
supported_resolutions: definedValueOrDefault(extractField(data, 'supported-resolutions', symbolIndex), this._datafeedSupportedResolutions),
force_session_rebuild: extractField(data, 'force-session-rebuild', symbolIndex),
has_daily: definedValueOrDefault(extractField(data, 'has-daily', symbolIndex), true),
intraday_multipliers: definedValueOrDefault(extractField(data, 'intraday-multipliers', symbolIndex), ['1', '5', '15', '30', '60']),
has_weekly_and_monthly: extractField(data, 'has-weekly-and-monthly', symbolIndex),
has_empty_bars: extractField(data, 'has-empty-bars', symbolIndex),
volume_precision: definedValueOrDefault(extractField(data, 'volume-precision', symbolIndex), 0),
};
this._symbolsInfo[ticker] = symbolInfo;
this._symbolsInfo[symbolName] = symbolInfo;
this._symbolsInfo[fullName] = symbolInfo;
this._symbolsList.push(symbolName);
}
} catch (error) {
throw new Error(`SymbolsStorage: API error when processing exchange ${exchange} symbol #${symbolIndex} (${data.symbol[symbolIndex]}): ${error.message}`);
}
}
}
function definedValueOrDefault<T>(value: T | undefined, defaultValue: T): T {
return value !== undefined ? value : defaultValue;
}