Warframe Market partial intergration

.gitignore

@@ -20,6 +20,13 @@ flutter_*.mp4
 *.iws
 .idea/
 
+# Gradle
+.gradle/
+gradle/
+gradlew
+gradlew.bat
+local.properties
+
 # Visual Studio Code related
 .vscode/
 

analysis_options.yaml

@@ -1,12 +1,15 @@
 include: package:very_good_analysis/analysis_options.yaml
+
 analyzer:
   exclude:
     - lib/generated/l10n.dart
     - lib/generated/intl/messages_*.dart
     - lib/src/**/*g.dart
     - lib/src/models/**/*.g.dart
+
 linter:
   rules:
     public_member_api_docs: false
     prefer_relative_imports: true
+    always_use_package_imports: false
 

android/app/src/main/res/values/styles.xml

@@ -5,6 +5,7 @@
         <!-- Show a splash screen on the activity. Automatically removed when
              Flutter draws its first frame -->
         <item name="android:windowBackground">@drawable/launch_background</item>
+        <item name="android:defaultFocusHighlightEnabled">false</item>
     </style>
     <!-- Theme applied to the Android Window as soon as the process has started.
          This theme determines the color of the Android Window while your
@@ -14,5 +15,6 @@
          This Theme is only used starting with V2 of Flutter's Android embedding. -->
     <style name="NormalTheme" parent="@android:style/Theme.Black.NoTitleBar">
         <item name="android:windowBackground">@android:color/white</item>
+        <item name="android:defaultFocusHighlightEnabled">false</item>
     </style>
 </resources>

android/build.gradle

@@ -7,7 +7,7 @@ buildscript {
 
     dependencies {
         //noinspection GradleDependency
-        classpath 'com.android.tools.build:gradle:4.2.1'
+        classpath 'com.android.tools.build:gradle:4.2.2'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
         classpath 'com.google.gms:google-services:4.3.8'
     }

lib/core/local/user_settings.dart

@@ -1,11 +1,9 @@
 import 'dart:developer';
-import 'dart:io';
 
 import 'package:flutter/material.dart';
 import 'package:hive/hive.dart';
 import 'package:logging/logging.dart';
 import 'package:matomo/matomo.dart';
-import 'package:path_provider/path_provider.dart';
 import 'package:wfcd_client/wfcd_client.dart';
 
 import '../../constants/storage_keys.dart';
@@ -17,13 +15,8 @@ class Usersettings {
 
   static Usersettings? _instance;
 
-  static Future<Usersettings> initUsersettings([Directory? directory]) async {
+  static Future<Usersettings> initUsersettings() async {
     log('Initializing Usersettings Hive', level: Level.INFO.value);
-
-    Hive.init(
-      directory?.path ?? (await getApplicationDocumentsDirectory()).path,
-    );
-
     final box = await Hive.openBox<dynamic>('user_settings');
 
     return _instance ??= Usersettings._(box);

lib/features/codex/data/datasources/market_cache.dart

@@ -0,0 +1,72 @@
+import 'dart:developer';
+
+import 'package:hive/hive.dart';
+import 'package:market_client/market_client.dart';
+
+class MarketCache {
+  const MarketCache._(this._box);
+
+  final Box<dynamic> _box;
+
+  static MarketCache? _instance;
+
+  static Future<MarketCache> initCache() async {
+    log('Initializing MarketCache Hive');
+    final box = await Hive.openBox<dynamic>('market_cache').catchError(
+      (Object error, StackTrace stack) {
+        log('Unable to open Hive box', error: error, stackTrace: stack);
+      },
+    );
+
+    return _instance ??= MarketCache._(box);
+  }
+
+  static const _itemsTimestamp = 'marketItemTimestampe';
+  static const _marketItems = 'marketItems';
+  static const _orderTimestamp = 'orderTimestamp';
+  static const _itemName = 'itemName';
+  static const _ordersKey = 'marketOrders';
+
+  void cacheItems(List<MarketItem> items) {
+    _box
+      ..put(_itemsTimestamp, DateTime.now())
+      ..put(_marketItems, items.map((e) => e.toJson()).toList());
+  }
+
+  void cacheOrders(String itemName, List<ItemOrder> orders) {
+    _box
+      ..put(_orderTimestamp, DateTime.now())
+      ..put(_itemName, itemName)
+      ..put(_ordersKey, orders.map((o) => o.toJson()).toList());
+  }
+
+  DateTime? getItemsTimestamp() {
+    return _box.get(_itemsTimestamp);
+  }
+
+  String? getCachedItemName() {
+    return _box.get(_itemName);
+  }
+
+  DateTime? getOrderTimestamp() {
+    return _box.get(_orderTimestamp);
+  }
+
+  List<ItemOrder>? getCachedOrders() {
+    final cached = _box.get(_ordersKey) as List<Map<String, dynamic>>?;
+
+    if (cached != null) {
+      return cached.map((e) => ItemOrder.fromJson(e)).toList();
+    }
+
+    return null;
+  }
+
+  List<MarketItem>? getCachedItems() {
+    final cached = _box.get(_marketItems) as List<Map<String, dynamic>>?;
+
+    if (cached != null) {
+      return cached.map((e) => MarketItem.fromJson(e)).toList();
+    }
+  }
+}

lib/features/codex/data/repositories/market_repository_impl.dart

@@ -0,0 +1,158 @@
+import 'dart:io';
+
+import 'package:flutter/foundation.dart';
+import 'package:market_client/market_client.dart';
+import 'package:oxidized/oxidized.dart';
+import 'package:wfcd_client/wfcd_client.dart';
+
+import '../../../../core/error/exceptions.dart';
+import '../../../../core/error/failures.dart';
+import '../../../../core/local/user_settings.dart';
+import '../../../../core/network/network_info.dart';
+import '../../domian/repositories/market_repository.dart';
+import '../datasources/market_cache.dart';
+
+class MarketRepositoryImpl extends MarketRepository {
+  const MarketRepositoryImpl(this.networkInfo, this.usersettings, this.cache);
+
+  final NetworkInfo networkInfo;
+  final Usersettings usersettings;
+  final MarketCache cache;
+
+  @override
+  Future<Result<List<ItemOrder>, Failure>> retriveOrders(
+      String itemName) async {
+    const _expiredCacheTime = Duration(minutes: 5);
+    final cTimestamp = cache.getOrderTimestamp()?.difference(DateTime.now());
+    final cItem = cache.getCachedItemName();
+
+    Result<List<ItemOrder>, Failure> getcached() {
+      final cached = cache.getCachedOrders();
+
+      if (cached != null) {
+        return Ok(cached);
+      } else {
+        return Err(CacheFailure());
+      }
+    }
+
+    if (cItem != itemName &&
+        (cTimestamp ?? _expiredCacheTime) <= _expiredCacheTime) {
+      if (await networkInfo.isConnected) {
+        final items = await getItems();
+
+        final req = MarketRequest(
+          itemUrl: itemName,
+          languageCode: usersettings.language?.languageCode ?? 'en',
+          platform: usersettings.platform,
+          items: items.match((i) => i, (f) => throw CacheException()),
+        );
+
+        try {
+          final orders = await compute(_retriveOrders, req);
+
+          cache.cacheOrders(itemName, orders);
+          return Ok(orders);
+        } on SocketException {
+          return Err(ServerFailure());
+        }
+      } else {
+        return getcached();
+      }
+    } else {
+      return getcached();
+    }
+  }
+
+  Future<Result<List<MarketItem>, Failure>> getItems() async {
+    const _expiredCacheTime = Duration(days: 7);
+    final cTimestamp = cache.getItemsTimestamp();
+    final cDuration =
+        cTimestamp?.difference(DateTime.now()) ?? _expiredCacheTime;
+
+    Result<List<MarketItem>, Failure> getcached() {
+      final cached = cache.getCachedItems();
+
+      if (cached != null) {
+        return Ok(cached);
+      } else {
+        return Err(CacheFailure());
+      }
+    }
+
+    if (cDuration >= _expiredCacheTime) {
+      if (await networkInfo.isConnected) {
+        final req = MarketRequest(
+          languageCode: usersettings.language?.languageCode ?? 'en',
+          platform: usersettings.platform,
+        );
+
+        try {
+          final items = await compute(_getItems, req);
+
+          cache.cacheItems(items);
+          return Ok(items);
+        } on SocketException {
+          return getcached();
+        }
+      } else {
+        return getcached();
+      }
+    } else {
+      return getcached();
+    }
+  }
+
+  static Future<List<ItemOrder>> _retriveOrders(MarketRequest req) async {
+    final client = MarketHttpClient(
+      platform: req.platform.marketPlatform,
+      language: req.languageCode,
+    );
+    final api = MarketClient(client: client);
+    final itemUrl =
+        req.items.firstWhere((e) => e.itemName.contains(req.itemUrl!));
+
+    return (await api.searchOrders(itemUrl.urlName))
+        .where((o) => o.orderType == OrderType.sell)
+        .toList();
+  }
+
+  static Future<List<MarketItem>> _getItems(MarketRequest req) async {
+    final client = MarketHttpClient(
+      platform: req.platform.marketPlatform,
+      language: req.languageCode,
+    );
+    final api = MarketClient(client: client);
+
+    return await api.getMarketItems();
+  }
+}
+
+class MarketRequest {
+  const MarketRequest({
+    this.itemUrl,
+    required this.languageCode,
+    required this.platform,
+    this.items = const <MarketItem>[],
+  });
+
+  final String? itemUrl;
+  final String languageCode;
+  final GamePlatforms platform;
+  final List<MarketItem> items;
+}
+
+extension GamePlatformsX on GamePlatforms {
+  MarketPlatform get marketPlatform {
+    switch (this) {
+      case GamePlatforms.pc:
+        return MarketPlatform.pc;
+      case GamePlatforms.ps4:
+        return MarketPlatform.ps4;
+      case GamePlatforms.xb1:
+        return MarketPlatform.xbox;
+      case GamePlatforms.swi:
+        return MarketPlatform.swi;
+    }
+  }
+}

lib/features/codex/domian/repositories/market_repository.dart

@@ -0,0 +1,10 @@
+import 'package:market_client/market_client.dart';
+import 'package:oxidized/oxidized.dart';
+
+import '../../../../core/error/failures.dart';
+
+abstract class MarketRepository {
+  const MarketRepository();
+
+  Future<Result<List<ItemOrder>, Failure>> retriveOrders(String itemName);
+}

lib/features/codex/domian/usercases/get_orders.dart

@@ -0,0 +1,17 @@
+import 'package:market_client/market_client.dart';
+import 'package:oxidized/oxidized.dart';
+
+import '../../../../core/error/failures.dart';
+import '../../../../core/usecases/usecases.dart';
+import '../repositories/market_repository.dart';
+
+class GetOrders extends Usecase<List<ItemOrder>, String> {
+  const GetOrders(this.marketRepository);
+
+  final MarketRepository marketRepository;
+
+  @override
+  Future<Result<List<ItemOrder>, Failure>> call(String params) {
+    return marketRepository.retriveOrders(params);
+  }
+}