public func get() -> Response<[Order],String> {
            return get(page: 1).flatMap { result in
                guard let page = result.value else { return .just(.init(error: result.error!)) }
                if page.totalPages == 1 {
                    return .just(.init(value: page.content))
                } else {
                    let iterator = (2...page.totalPages)
                    let sequences = iterator.map{ self.get(page: $0).asObservable() }
                    let concatenation = Observable.concat(sequences)
                    let scaning: Observable<Result<Page<Order>, DictionaryError<String>>> = concatenation.scan(result, accumulator: { (totalResult, result) in
                        switch (totalResult, result) {
                        case (.failure(let error), _): throw error
                        case (_, .failure(let error)): throw error
                        case (.success(let totalPage), .success(let newPage)): return .init(value: Page.new(content: totalPage.content + newPage.content, index: totalPage.index, totalPages: totalPage.totalPages))
                        }
                    })
                    let driver = scaning.asDriver(onErrorRecover: { (error) -> Response<Page<Order>,String> in
                        return .just(.init(error: error as! DictionaryError<String>))
                    })
                    let resultingDriver: Response<[Order],String> = driver.map{
                        switch $0 {
                        case .success(let sumPage): return .init(value: sumPage.content)
                        case .failure(let error): return .init(error: error)
                        }
                    }
                    return resultingDriver
                }
            }
        }

        private func get(page: Int) -> Response<Page<Order>,String> {
            return .empty()
        }