Merge pull request #33 from Wolfteam/feature/materials

feature/materials

lib/application/artifact/artifact_bloc.dart

@@ -31,7 +31,7 @@ class ArtifactBloc extends PopBloc<ArtifactEvent, ArtifactState> {
       loadArtifact: (e) async {
         final artifact = _genshinService.getArtifact(e.key);
         final translation = _genshinService.getArtifactTranslation(e.key);
-        final charImgs = _genshinService.getCharactersImgUsingArtifact(e.key);
+        final charImgs = _genshinService.getCharacterImgsUsingArtifact(e.key);
 
         var image = artifact.image.split('.png').first;
         image = image.substring(0, image.length - 1);

lib/application/bloc.dart

@@ -9,9 +9,11 @@ export 'game_codes/game_codes_bloc.dart';
 export 'home/home_bloc.dart';
 export 'main/main_bloc.dart';
 export 'main_tab/main_tab_bloc.dart';
+export 'material/material_bloc.dart';
 export 'materials/materials_bloc.dart';
 export 'settings/settings_bloc.dart';
 export 'tierlist/tier_list_bloc.dart';
+export 'today_materials/today_materials_bloc.dart';
 export 'url_page/url_page_bloc.dart';
 export 'weapon/weapon_bloc.dart';
 export 'weapons/weapons_bloc.dart';

lib/application/calculator_asc_materials/calculator_asc_materials_bloc.dart

@@ -161,7 +161,7 @@ class CalculatorAscMaterialsBloc extends Bloc<CalculatorAscMaterialsEvent, Calcu
           case MaterialType.weaponPrimary:
             key = AscensionMaterialSummaryType.common;
             break;
-          case MaterialType.elemental:
+          case MaterialType.elementalStone:
           case MaterialType.jewels:
           case MaterialType.talents:
           case MaterialType.others:

lib/application/material/material_bloc.dart

@@ -0,0 +1,67 @@
+import 'dart:async';
+
+import 'package:flutter/cupertino.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:genshindb/application/common/pop_bloc.dart';
+import 'package:genshindb/domain/enums/enums.dart';
+import 'package:genshindb/domain/models/models.dart';
+import 'package:genshindb/domain/services/genshin_service.dart';
+import 'package:genshindb/domain/services/telemetry_service.dart';
+import 'package:meta/meta.dart';
+
+part 'material_bloc.freezed.dart';
+part 'material_event.dart';
+part 'material_state.dart';
+
+class MaterialBloc extends PopBloc<MaterialEvent, MaterialState> {
+  final GenshinService _genshinService;
+  final TelemetryService _telemetryService;
+
+  MaterialBloc(this._genshinService, this._telemetryService) : super(const MaterialState.loading());
+
+  @override
+  MaterialEvent getEventForPop(String key) => MaterialEvent.loadFromName(key: key, addToQueue: false);
+
+  @override
+  Stream<MaterialState> mapEventToState(MaterialEvent event) async* {
+    final s = await event.map(
+      loadFromName: (e) async {
+        final material = _genshinService.getMaterial(e.key);
+        if (e.addToQueue) {
+          await _telemetryService.trackMaterialLoaded(e.key);
+          currentItemsInStack.add(material.key);
+        }
+        return _buildInitialState(material);
+      },
+      loadFromImg: (e) async {
+        final material = _genshinService.getMaterialByImage(e.image);
+        if (e.addToQueue) {
+          await _telemetryService.trackMaterialLoaded(material.image, loadedFromName: false);
+          currentItemsInStack.add(material.key);
+        }
+        return _buildInitialState(material);
+      },
+    );
+
+    yield s;
+  }
+
+  MaterialState _buildInitialState(MaterialFileModel material) {
+    final translation = _genshinService.getMaterialTranslation(material.key);
+    final charImgs = _genshinService.getCharacterImgsUsingMaterial(material.key);
+    final weaponImgs = _genshinService.getWeaponImgsUsingMaterial(material.key);
+    final relatedMaterials = _genshinService.getRelatedMaterialImgsToMaterial(material.key);
+    return MaterialState.loaded(
+      name: translation.name,
+      fullImage: material.fullImagePath,
+      rarity: material.rarity,
+      type: material.type,
+      description: translation.description,
+      charImages: charImgs,
+      weaponImages: weaponImgs,
+      days: material.days,
+      obtainedFrom: material.obtainedFrom,
+      relatedMaterials: relatedMaterials,
+    );
+  }
+}

lib/application/material/material_event.dart

@@ -0,0 +1,14 @@
+part of 'material_bloc.dart';
+
+@freezed
+abstract class MaterialEvent implements _$MaterialEvent {
+  const factory MaterialEvent.loadFromName({
+    @required String key,
+    @Default(true) bool addToQueue,
+  }) = _LoadMaterialFromName;
+
+  const factory MaterialEvent.loadFromImg({
+    @required String image,
+    @Default(true) bool addToQueue,
+  }) = _LoadMaterialFromImg;
+}

lib/application/material/material_state.dart

@@ -0,0 +1,18 @@
+part of 'material_bloc.dart';
+
+@freezed
+abstract class MaterialState implements _$MaterialState {
+  const factory MaterialState.loading() = _LoadingState;
+  const factory MaterialState.loaded({
+    @required String name,
+    @required String fullImage,
+    @required int rarity,
+    @required MaterialType type,
+    String description,
+    @required List<String> charImages,
+    @required List<String> weaponImages,
+    @required List<int> days,
+    @required List<ObtainedFromFileModel> obtainedFrom,
+    @required List<String> relatedMaterials,
+  }) = _LoadedState;
+}

lib/application/materials/materials_bloc.dart

@@ -2,63 +2,144 @@ import 'dart:async';
 
 import 'package:bloc/bloc.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:genshindb/domain/enums/enums.dart';
+import 'package:genshindb/domain/enums/material_type.dart';
 import 'package:genshindb/domain/models/models.dart';
 import 'package:genshindb/domain/services/genshin_service.dart';
-import 'package:genshindb/domain/services/telemetry_service.dart';
 
 part 'materials_bloc.freezed.dart';
 part 'materials_event.dart';
 part 'materials_state.dart';
 
 class MaterialsBloc extends Bloc<MaterialsEvent, MaterialsState> {
   final GenshinService _genshinService;
-  final TelemetryService _telemetryService;
 
-  MaterialsBloc(this._genshinService, this._telemetryService) : super(const MaterialsState.loading());
+  _LoadedState get currentState => state as _LoadedState;
+
+  MaterialsBloc(this._genshinService) : super(const MaterialsState.loading());
 
   @override
-  Stream<MaterialsState> mapEventToState(
-    MaterialsEvent event,
-  ) async* {
-    await _telemetryService.trackAscensionMaterialsOpened();
-    final s = event.when(
-      init: () {
-        final days = [
-          DateTime.monday,
-          DateTime.tuesday,
-          DateTime.wednesday,
-          DateTime.thursday,
-          DateTime.friday,
-          DateTime.saturday,
-          DateTime.sunday,
-        ];
+  Stream<MaterialsState> mapEventToState(MaterialsEvent event) async* {
+    final s = event.map(
+      init: (e) => _buildInitialState(),
+      rarityChanged: (e) => currentState.copyWith.call(tempRarity: e.rarity),
+      sortDirectionTypeChanged: (e) => currentState.copyWith.call(tempSortDirectionType: e.sortDirectionType),
+      typeChanged: (e) => currentState.copyWith.call(tempType: e.type),
+      filterTypeChanged: (e) => currentState.copyWith.call(tempFilterType: e.type),
+      searchChanged: (e) => _buildInitialState(
+        search: e.search,
+        rarity: currentState.rarity,
+        type: currentState.type,
+        filterType: currentState.filterType,
+        sortDirectionType: currentState.sortDirectionType,
+      ),
+      applyFilterChanges: (_) => _buildInitialState(
+        search: currentState.search,
+        rarity: currentState.tempRarity,
+        type: currentState.tempType,
+        filterType: currentState.tempFilterType,
+        sortDirectionType: currentState.tempSortDirectionType,
+      ),
+      cancelChanges: (_) => currentState.copyWith.call(
+        tempFilterType: currentState.filterType,
+        tempRarity: currentState.rarity,
+        tempSortDirectionType: currentState.sortDirectionType,
+        tempType: currentState.type,
+      ),
+    );
 
-        final charMaterials = <TodayCharAscensionMaterialsModel>[];
-        final weaponMaterials = <TodayWeaponAscensionMaterialModel>[];
-//TODO: YOU MAY WANT TO SHOW THE BOSS ITEMS AS WELL
-        for (final day in days) {
-          final charMaterialsForDay = _genshinService.getCharacterAscensionMaterials(day);
-          final weaponMaterialsForDay = _genshinService.getWeaponAscensionMaterials(day);
+    yield s;
+  }
 
-          for (final material in charMaterialsForDay) {
-            if (charMaterials.any((m) => m.name == material.name)) {
-              continue;
-            }
-            charMaterials.add(material);
-          }
+  MaterialsState _buildInitialState({
+    String search,
+    int rarity = 0,
+    MaterialType type = MaterialType.all,
+    MaterialFilterType filterType = MaterialFilterType.rarity,
+    SortDirectionType sortDirectionType = SortDirectionType.asc,
+  }) {
+    final isLoaded = state is _LoadedState;
+    var data = _genshinService.getAllMaterials();
 
-          for (final material in weaponMaterialsForDay) {
-            if (weaponMaterials.any((m) => m.name == material.name)) {
-              continue;
-            }
-            weaponMaterials.add(material);
-          }
-        }
+    if (!isLoaded) {
+      _sortData(data, filterType, sortDirectionType);
+      return MaterialsState.loaded(
+        materials: data,
+        search: search,
+        rarity: rarity,
+        tempRarity: rarity,
+        type: type,
+        tempType: type,
+        filterType: filterType,
+        tempFilterType: filterType,
+        sortDirectionType: sortDirectionType,
+        tempSortDirectionType: sortDirectionType,
+      );
+    }
+
+    if (search != null && search.isNotEmpty) {
+      data = data.where((el) => el.name.toLowerCase().contains(search.toLowerCase())).toList();
+    }
+
+    if (rarity > 0) {
+      data = data.where((el) => el.rarity == rarity).toList();
+    }
 
-        return MaterialsState.loaded(charAscMaterials: charMaterials, weaponAscMaterials: weaponMaterials);
-      },
+    if (type != MaterialType.all) {
+      switch (type) {
+        case MaterialType.expWeapon:
+        case MaterialType.expCharacter:
+          data = data.where((el) => [MaterialType.expWeapon, MaterialType.expCharacter].contains(el.type)).toList();
+          break;
+        case MaterialType.weaponPrimary:
+        case MaterialType.weapon:
+          data = data.where((el) => [MaterialType.weaponPrimary, MaterialType.weapon].contains(el.type)).toList();
+          break;
+        default:
+          data = data.where((el) => el.type == type).toList();
+          break;
+      }
+    }
+
+    _sortData(data, filterType, sortDirectionType);
+
+    final s = currentState.copyWith.call(
+      materials: data,
+      search: search,
+      rarity: rarity,
+      tempRarity: rarity,
+      type: type,
+      tempType: type,
+      filterType: filterType,
+      tempFilterType: filterType,
+      sortDirectionType: sortDirectionType,
+      tempSortDirectionType: sortDirectionType,
     );
+    return s;
+  }
 
-    yield s;
+  void _sortData(
+    List<MaterialCardModel> data,
+    MaterialFilterType filterType,
+    SortDirectionType sortDirectionType,
+  ) {
+    switch (filterType) {
+      case MaterialFilterType.name:
+        if (sortDirectionType == SortDirectionType.asc) {
+          data.sort((x, y) => x.name.compareTo(y.name));
+        } else {
+          data.sort((x, y) => y.name.compareTo(x.name));
+        }
+        break;
+      case MaterialFilterType.rarity:
+        if (sortDirectionType == SortDirectionType.asc) {
+          data.sort((x, y) => x.rarity.compareTo(y.rarity));
+        } else {
+          data.sort((x, y) => y.rarity.compareTo(x.rarity));
+        }
+        break;
+      default:
+        break;
+    }
   }
 }

lib/application/materials/materials_event.dart

@@ -1,6 +1,17 @@
 part of 'materials_bloc.dart';
 
 @freezed
-abstract class MaterialsEvent with _$MaterialsEvent {
+abstract class MaterialsEvent implements _$MaterialsEvent {
   const factory MaterialsEvent.init() = _Init;
+  const factory MaterialsEvent.searchChanged({
+    @required String search,
+  }) = _SearchChanged;
+
+  const factory MaterialsEvent.rarityChanged(int rarity) = _RarityChanged;
+  const factory MaterialsEvent.typeChanged(MaterialType type) = _TypeChanged;
+  const factory MaterialsEvent.filterTypeChanged(MaterialFilterType type) = _FilterTypeChanged;
+  const factory MaterialsEvent.applyFilterChanges() = _ApplyFilterChanges;
+  const factory MaterialsEvent.sortDirectionTypeChanged(SortDirectionType sortDirectionType) = _SortDirectionTypeChanged;
+
+  const factory MaterialsEvent.cancelChanges() = _CancelChanges;
 }

lib/application/materials/materials_state.dart

@@ -1,10 +1,19 @@
 part of 'materials_bloc.dart';
 
 @freezed
-abstract class MaterialsState with _$MaterialsState {
+abstract class MaterialsState implements _$MaterialsState {
   const factory MaterialsState.loading() = _LoadingState;
+
   const factory MaterialsState.loaded({
-    @required List<TodayCharAscensionMaterialsModel> charAscMaterials,
-    @required List<TodayWeaponAscensionMaterialModel> weaponAscMaterials,
+    @required List<MaterialCardModel> materials,
+    String search,
+    @required int rarity,
+    @required int tempRarity,
+    @required MaterialFilterType filterType,
+    @required MaterialFilterType tempFilterType,
+    @required MaterialType type,
+    @required MaterialType tempType,
+    @required SortDirectionType sortDirectionType,
+    @required SortDirectionType tempSortDirectionType,
   }) = _LoadedState;
 }