Release v14

src/__mocks__/setting.ts

@@ -4,6 +4,12 @@ export class Setting {
   }
 
   static load(): object {
-    return { token: 'foo' }
+    return {
+      token: 'foo',
+      ondemandApiEnabled: false,
+      ondemandApiCallMode: 'default',
+      isOndemandApiCallModeDefault: (): boolean => true,
+      isOndemandApiCallModeForce: (): boolean => false
+    }
   }
 }

src/custom-functions/v3/bcode-daily.test.ts

@@ -16,7 +16,7 @@ test('bcodeDaily', () => {
   expect(DailyCache.get(ticker, date)).toBeNull()
 
   const client = new CachingBuffettCodeApiClientV3('token')
-  const result = bcodeDaily(client, ticker, date, propertyName, false)
+  const result = bcodeDaily(client, ticker, date, propertyName, false, false)
 
   expect(result).toEqual(new BcodeResult(propertyName, 550294097166, '円'))
   expect(DailyCache.get(ticker, date)).not.toBeNull()

src/custom-functions/v3/bcode-daily.ts

@@ -15,15 +15,16 @@ export function bcodeDaily(
   ticker: string,
   date: DateParam,
   propertyName: string,
-  ondemandApiEnabled: boolean
+  ondemandApiEnabled: boolean,
+  forceOndemandApiEnabled: boolean
 ): BcodeResult {
   const companyService = new CompanyService(ticker, client)
   if (!companyService.isSupportedTicker()) {
     throw new UnsupportedTickerError()
   }
 
   let daily: Daily
-  if (companyService.isOndemandDailyApiPeriod(date)) {
+  if (forceOndemandApiEnabled || companyService.isOndemandDailyApiPeriod(date)) {
     if (!ondemandApiEnabled) {
       throw new OndemandApiNotEnabledError()
     }

src/custom-functions/v3/bcode-quarter.test.ts

@@ -17,7 +17,7 @@ test('bcodeQuarter', () => {
   expect(QuarterCache.get(ticker, period)).toBeNull()
 
   const client = new CachingBuffettCodeApiClientV3('token')
-  const result = bcodeQuarter(client, ticker, YearQuarterParam.fromYearQuarter(period), propertyName, false)
+  const result = bcodeQuarter(client, ticker, YearQuarterParam.fromYearQuarter(period), propertyName, false, false)
 
   expect(result).toEqual(new BcodeResult(propertyName, 12513000000, '円'))
   expect(QuarterCache.get(ticker, period)).not.toBeNull()

src/custom-functions/v3/bcode-quarter.ts

@@ -15,15 +15,16 @@ export function bcodeQuarter(
   ticker: string,
   period: YearQuarterParam,
   propertyName: string,
-  ondemandApiEnabled: boolean
+  ondemandApiEnabled: boolean,
+  forceOndemandApiEnabled: boolean
 ): BcodeResult {
   const companyService = new CompanyService(ticker, client)
   if (!companyService.isSupportedTicker()) {
     throw new UnsupportedTickerError()
   }
 
   let quarter: Quarter
-  if (companyService.isOndemandQuarterApiPeriod(period)) {
+  if (forceOndemandApiEnabled || companyService.isOndemandQuarterApiPeriod(period)) {
     if (!ondemandApiEnabled) {
       throw new OndemandApiNotEnabledError()
     }

src/custom-functions/v3/bcode.ts

@@ -78,9 +78,23 @@ export function bcode(
     const parsedPeriod = PeriodParser.parse(period)
     let result: BcodeResult
     if (parsedPeriod instanceof DateParam) {
-      result = bcodeDaily(client, ticker, parsedPeriod, propertyName, setting.ondemandApiEnabled)
+      result = bcodeDaily(
+        client,
+        ticker,
+        parsedPeriod,
+        propertyName,
+        setting.ondemandApiEnabled,
+        setting.isOndemandApiCallModeForce()
+      )
     } else {
-      result = bcodeQuarter(client, ticker, parsedPeriod, propertyName, setting.ondemandApiEnabled)
+      result = bcodeQuarter(
+        client,
+        ticker,
+        parsedPeriod,
+        propertyName,
+        setting.ondemandApiEnabled,
+        setting.isOndemandApiCallModeForce()
+      )
     }
 
     return result.format(isRawValue, isWithUnits)

src/main.ts

@@ -17,6 +17,7 @@ global.onInstall = (): void => {
   const setting = Setting.load()
   setting.setDefaultToken()
   setting.setDefaultOndemandApiEnabled()
+  setting.setDefaultOndemandApiCallMode()
   setting.save()
 
   global.onOpen()

src/services/csv-exporter.ts

@@ -35,8 +35,15 @@ export class CsvExporter {
 
     const ondemandQuarterApiPeriodRange = new OndemandApiPeriodRange(companyService)
 
-    const ondemandQuarterApiPeriods = ondemandQuarterApiPeriodRange.selectOndemandQuarterApiPeriod(ticker, range)
-    const quarterApiPeriods = ondemandQuarterApiPeriodRange.filterOndemandQuarterApiPeriod(ticker, range)
+    let ondemandQuarterApiPeriods = []
+    let quarterApiPeriods = []
+
+    if (setting.isOndemandApiCallModeForce()) {
+      ondemandQuarterApiPeriods = range.range()
+    } else {
+      ondemandQuarterApiPeriods = ondemandQuarterApiPeriodRange.selectOndemandQuarterApiPeriod(ticker, range)
+      quarterApiPeriods = ondemandQuarterApiPeriodRange.filterOndemandQuarterApiPeriod(ticker, range)
+    }
 
     if (ondemandQuarterApiPeriods.length > 0 && !setting.ondemandApiEnabled) {
       throw new Error(

src/setting.test.ts

@@ -5,7 +5,10 @@ declare const global: any
 
 test('load', () => {
   const mockGetProperty = jest.fn()
-  mockGetProperty.mockReturnValueOnce('foo').mockReturnValueOnce('true')
+  mockGetProperty
+    .mockReturnValueOnce('foo')
+    .mockReturnValueOnce('true')
+    .mockReturnValueOnce('force')
 
   global.PropertiesService = {
     getUserProperties: (): object => {
@@ -16,12 +19,13 @@ test('load', () => {
   }
 
   const setting = Setting.load()
-  expect(mockGetProperty.mock.calls.length).toBe(2)
+  expect(mockGetProperty.mock.calls.length).toBe(3)
   expect(setting.token).toBe('foo')
   expect(setting.ondemandApiEnabled).toBe(true)
+  expect(setting.ondemandApiCallMode).toBe('force')
 })
 
-test('load__ondemandApiEnabledCasting', () => {
+test('load (ondemandApiEnabled casting)', () => {
   const mockGetProperty = jest.fn()
   mockGetProperty.mockReturnValue(undefined)
 
@@ -37,6 +41,76 @@ test('load__ondemandApiEnabledCasting', () => {
   expect(setting.ondemandApiEnabled).toBe(false)
 })
 
+test('load (ondemandApiCallMode fallback)', () => {
+  const mockGetProperty = jest.fn()
+  mockGetProperty.mockReturnValue(undefined)
+
+  global.PropertiesService = {
+    getUserProperties: (): object => {
+      return {
+        getProperty: mockGetProperty
+      }
+    }
+  }
+
+  const setting = Setting.load()
+  expect(setting.ondemandApiCallMode).toBe(Setting.defaultOndemandApiCallMode)
+})
+
+test('isValid (true)', () => {
+  const mockGetProperty = jest.fn()
+
+  global.PropertiesService = {
+    getUserProperties: (): object => {
+      return {
+        getProperty: mockGetProperty
+      }
+    }
+  }
+
+  const setting = Setting.load()
+  setting.token = 'bar'
+  setting.ondemandApiEnabled = true
+  setting.ondemandApiCallMode = 'force'
+  expect(setting.isValid()).toBeTruthy()
+})
+
+test('isValid (true)', () => {
+  const mockGetProperty = jest.fn()
+
+  global.PropertiesService = {
+    getUserProperties: (): object => {
+      return {
+        getProperty: mockGetProperty
+      }
+    }
+  }
+
+  const setting = Setting.load()
+  setting.token = 'bar'
+  setting.ondemandApiEnabled = true
+  setting.ondemandApiCallMode = 'foo' as 'default' | 'force'
+  expect(setting.isValid()).toBeFalsy()
+})
+
+test('isValid (ondemandApiEnabled is false but ondemandApiCallMode is changed)', () => {
+  const mockGetProperty = jest.fn()
+
+  global.PropertiesService = {
+    getUserProperties: (): object => {
+      return {
+        getProperty: mockGetProperty
+      }
+    }
+  }
+
+  const setting = Setting.load()
+  setting.token = 'bar'
+  setting.ondemandApiEnabled = false
+  setting.ondemandApiCallMode = 'force'
+  expect(setting.isValid()).toBeFalsy()
+})
+
 test('save', () => {
   const mockGetProperty = jest.fn()
   const mockSetProperty = jest.fn()
@@ -53,11 +127,33 @@ test('save', () => {
   const setting = Setting.load()
   setting.token = 'bar'
   setting.ondemandApiEnabled = true
+  setting.ondemandApiCallMode = 'default'
   setting.save()
 
-  expect(mockSetProperty.mock.calls.length).toBe(2)
+  expect(mockSetProperty.mock.calls.length).toBe(3)
   expect(mockSetProperty.mock.calls[0]).toEqual([Setting.tokenProperty, 'bar'])
-  expect(mockSetProperty.mock.calls[1]).toEqual([Setting.ondemandApiEnabledProperty, true])
+  expect(mockSetProperty.mock.calls[1]).toEqual([Setting.ondemandApiEnabledProperty, 'true'])
+  expect(mockSetProperty.mock.calls[2]).toEqual([Setting.ondemandApiCallModeProperty, 'default'])
+})
+
+test('save (ondemandApiEnabled is false but ondemandApiCallMode is changed)', () => {
+  const mockGetProperty = jest.fn()
+  const mockSetProperty = jest.fn()
+
+  global.PropertiesService = {
+    getUserProperties: (): object => {
+      return {
+        getProperty: mockGetProperty,
+        setProperty: mockSetProperty
+      }
+    }
+  }
+
+  const setting = Setting.load()
+  setting.token = 'bar'
+  setting.ondemandApiEnabled = false
+  setting.ondemandApiCallMode = 'force'
+  expect(() => setting.save()).toThrow(Error)
 })
 
 test('setDefaultToken', () => {
@@ -79,6 +175,44 @@ test('setDefaultToken', () => {
   expect(setting.token).toBe(Setting.defaultToken)
 })
 
+test('setDefaultOndemandApiEnabled', () => {
+  const mockGetProperty = jest.fn()
+  mockGetProperty.mockReturnValue(undefined)
+
+  global.PropertiesService = {
+    getUserProperties: (): object => {
+      return {
+        getProperty: mockGetProperty
+      }
+    }
+  }
+
+  const setting = Setting.load()
+  expect(setting.ondemandApiEnabled).toBeFalsy()
+
+  setting.setDefaultToken()
+  expect(setting.ondemandApiEnabled).toBe(Setting.defaultOndemandApiEnabled)
+})
+
+test('setDefaultOndemandApiCallMode', () => {
+  const mockGetProperty = jest.fn()
+  mockGetProperty.mockReturnValue(undefined)
+
+  global.PropertiesService = {
+    getUserProperties: (): object => {
+      return {
+        getProperty: mockGetProperty
+      }
+    }
+  }
+
+  const setting = Setting.load()
+  expect(setting.ondemandApiCallMode).toBe(Setting.defaultOndemandApiCallMode)
+
+  setting.setDefaultToken()
+  expect(setting.ondemandApiCallMode).toBe(Setting.defaultOndemandApiCallMode)
+})
+
 test('toObject', () => {
   const mockGetProperty = jest.fn()
   mockGetProperty.mockReturnValue(undefined)
@@ -94,9 +228,22 @@ test('toObject', () => {
   const setting = Setting.load()
   setting.setDefaultToken()
   setting.setDefaultOndemandApiEnabled()
+  setting.setDefaultOndemandApiCallMode()
 
   expect(setting.toObject()).toStrictEqual({
     token: Setting.defaultToken,
-    ondemandApiEnabled: Setting.defaultOndemandApiEnabled
+    ondemandApiEnabled: Setting.defaultOndemandApiEnabled,
+    ondemandApiCallMode: Setting.defaultOndemandApiCallMode
   })
 })
+
+test('Setting.validOndemanApiCallModes', () => {
+  expect(Setting.validOndemanApiCallModes()).toEqual(['default', 'force'])
+})
+
+test('Setting.castOndemandApiCallModeString', () => {
+  expect(Setting.castOndemandApiCallModeString('default')).toEqual('default')
+  expect(Setting.castOndemandApiCallModeString('force')).toEqual('force')
+  expect(() => Setting.castOndemandApiCallModeString('FORCE')).toThrow(TypeError)
+  expect(() => Setting.castOndemandApiCallModeString('foo')).toThrow(TypeError)
+})