331 lines
13 KiB
Dart
331 lines
13 KiB
Dart
import 'dart:io';
|
|
|
|
import 'package:bloc/bloc.dart';
|
|
import 'package:equatable/equatable.dart';
|
|
import 'package:fluttertoast/fluttertoast.dart';
|
|
import 'package:path_provider/path_provider.dart';
|
|
import 'package:permission_handler/permission_handler.dart';
|
|
import 'package:share_plus/share_plus.dart';
|
|
import 'package:unit2/screens/profile/components/eligibility/eligibility_view_attachment.dart';
|
|
import 'package:unit2/utils/attachment_services.dart';
|
|
import '../../../model/location/city.dart';
|
|
import '../../../model/location/country.dart';
|
|
import '../../../model/location/provinces.dart';
|
|
import '../../../model/location/region.dart';
|
|
import '../../../model/profile/attachment.dart';
|
|
import '../../../model/profile/eligibility.dart';
|
|
import '../../../model/utils/eligibility.dart';
|
|
import '../../../sevices/profile/eligibility_services.dart';
|
|
import '../../../utils/location_utilities.dart';
|
|
import '../../../utils/profile_utilities.dart';
|
|
import '../../../utils/request_permission.dart';
|
|
import '../../../utils/urls.dart';
|
|
part 'eligibility_event.dart';
|
|
part 'eligibility_state.dart';
|
|
|
|
class EligibilityBloc extends Bloc<EligibilityEvent, EligibilityState> {
|
|
EligibilityBloc() : super(EligibilityInitial()) {
|
|
List<Country> globalCountries = [];
|
|
List<Region> globalRegions = [];
|
|
List<Eligibility> globalEligibilities = [];
|
|
List<EligibityCert> eligibilities = [];
|
|
List<AttachmentCategory> attachmentCategories = [];
|
|
//// LOAD ELIGIBILTY
|
|
on<LoadEligibility>((event, emit) {
|
|
emit(EligibilityLoadingState());
|
|
emit(EligibilityLoaded(
|
|
eligibilities: eligibilities,
|
|
attachmentCategory: attachmentCategories));
|
|
});
|
|
|
|
//// DELETE
|
|
on<DeleteEligibility>((event, emit) async {
|
|
try {
|
|
final bool success = await EligibilityService.instance.delete(
|
|
eligibilityId: event.eligibilityId,
|
|
profileId: int.parse(event.profileId),
|
|
token: event.token);
|
|
if (success) {
|
|
eligibilities.removeWhere(
|
|
((EligibityCert element) => element.id == event.eligibilityId));
|
|
emit(EligibilityDeletedState(
|
|
success: success,
|
|
));
|
|
} else {
|
|
emit(EligibilityDeletedState(success: success));
|
|
}
|
|
} catch (e) {
|
|
emit(EligibilityErrorState(message: e.toString()));
|
|
}
|
|
});
|
|
|
|
//// GET ELIGIBILITY
|
|
on<GetEligibilities>((event, emit) async {
|
|
emit(EligibilityLoadingState());
|
|
try {
|
|
if (attachmentCategories.isEmpty) {
|
|
attachmentCategories =
|
|
await AttachmentServices.instance.getCategories();
|
|
}
|
|
if (eligibilities.isNotEmpty) {
|
|
emit(EligibilityLoaded(
|
|
eligibilities: eligibilities,
|
|
attachmentCategory: attachmentCategories));
|
|
} else {
|
|
emit(EligibilityLoadingState());
|
|
eligibilities = await EligibilityService.instance
|
|
.getEligibilities(event.profileId, event.token);
|
|
emit(EligibilityLoaded(
|
|
eligibilities: eligibilities,
|
|
attachmentCategory: attachmentCategories));
|
|
}
|
|
} catch (e) {
|
|
emit(EligibilityErrorState(message: e.toString()));
|
|
}
|
|
});
|
|
//// SHOW EDIT FORM
|
|
on<ShowEditEligibilityForm>((event, emit) async {
|
|
try {
|
|
if (globalCountries.isEmpty) {
|
|
List<Country> countries = await LocationUtils.instance.getCountries();
|
|
globalCountries = countries;
|
|
}
|
|
if (globalRegions.isEmpty) {
|
|
List<Region> regions = await LocationUtils.instance.getRegions();
|
|
globalRegions = regions;
|
|
}
|
|
if (globalEligibilities.isEmpty) {
|
|
List<Eligibility> eligibilities =
|
|
await ProfileUtilities.instance.getEligibilities();
|
|
globalEligibilities = eligibilities;
|
|
}
|
|
Eligibility currentEligibility = globalEligibilities.firstWhere(
|
|
(Eligibility eligibility) =>
|
|
event.eligibityCert.eligibility!.id == eligibility.id);
|
|
bool? isOverseas = event.eligibityCert.overseas;
|
|
Country currentCountry = globalCountries.firstWhere((Country country) =>
|
|
event.eligibityCert.examAddress!.country!.code == country.code);
|
|
if (event.eligibityCert.examAddress?.cityMunicipality?.province
|
|
?.region !=
|
|
null) {
|
|
Region currrentRegion = globalRegions.firstWhere((Region region) =>
|
|
event.eligibityCert.examAddress!.cityMunicipality!.province!
|
|
.region!.code ==
|
|
region.code);
|
|
List<Province> provinces = await LocationUtils.instance
|
|
.getProvinces(regionCode: currrentRegion.code.toString());
|
|
Province currentProvince = provinces.firstWhere((Province province) =>
|
|
event.eligibityCert.examAddress!.cityMunicipality!.province!
|
|
.code ==
|
|
province.code);
|
|
List<CityMunicipality> cities = await LocationUtils.instance
|
|
.getCities(code: currentProvince.code.toString());
|
|
CityMunicipality currentCity = cities.firstWhere(
|
|
(CityMunicipality cityMunicipality) =>
|
|
event.eligibityCert.examAddress!.cityMunicipality!.code ==
|
|
cityMunicipality.code);
|
|
|
|
emit(EditEligibilityState(
|
|
currentCity: currentCity,
|
|
selectedCountry: currentCountry,
|
|
currentProvince: currentProvince,
|
|
currentRegion: currrentRegion,
|
|
currentEligibility: currentEligibility,
|
|
provinces: provinces,
|
|
cities: cities,
|
|
isOverseas: isOverseas!,
|
|
eligibityCert: event.eligibityCert,
|
|
countries: globalCountries,
|
|
regions: globalRegions,
|
|
eligibilities: globalEligibilities));
|
|
} else {
|
|
emit(EditEligibilityState(
|
|
selectedCountry: currentCountry,
|
|
currentCity: null,
|
|
currentProvince: null,
|
|
currentRegion: null,
|
|
provinces: null,
|
|
cities: null,
|
|
currentEligibility: currentEligibility,
|
|
isOverseas: isOverseas!,
|
|
eligibityCert: event.eligibityCert,
|
|
countries: globalCountries,
|
|
regions: globalRegions,
|
|
eligibilities: globalEligibilities));
|
|
}
|
|
} catch (e) {
|
|
emit(EligibilityErrorState(message: e.toString()));
|
|
}
|
|
});
|
|
|
|
//// UPDATE
|
|
on<UpdateEligibility>((event, emit) async {
|
|
try {
|
|
Map<dynamic, dynamic> status = await EligibilityService.instance.update(
|
|
eligibityCert: event.eligibityCert,
|
|
token: event.token,
|
|
profileId: int.parse(event.profileId),
|
|
oldEligibility: event.oldEligibility);
|
|
if (status['success']) {
|
|
EligibityCert newEligibility = EligibityCert.fromJson(status['data']);
|
|
eligibilities.removeWhere(
|
|
(EligibityCert element) => element.id == event.eligibityCert.id);
|
|
eligibilities.add(newEligibility);
|
|
emit(EligibilityEditedState(response: status));
|
|
} else {
|
|
emit(EligibilityEditedState(response: status));
|
|
}
|
|
} catch (e) {
|
|
emit(EligibilityErrorState(message: e.toString()));
|
|
}
|
|
});
|
|
//// SHOW ADD FORM
|
|
on<ShowAddEligibilityForm>((event, emit) async {
|
|
emit(EligibilityLoadingState());
|
|
try {
|
|
if (globalRegions.isEmpty) {
|
|
List<Region> regions = await LocationUtils.instance.getRegions();
|
|
globalRegions = regions;
|
|
}
|
|
if (globalEligibilities.isEmpty) {
|
|
List<Eligibility> eligibilities =
|
|
await ProfileUtilities.instance.getEligibilities();
|
|
globalEligibilities = eligibilities;
|
|
}
|
|
if (globalCountries.isEmpty) {
|
|
List<Country> countries = await LocationUtils.instance.getCountries();
|
|
globalCountries = countries;
|
|
}
|
|
|
|
emit(AddEligibilityState(
|
|
eligibilities: globalEligibilities,
|
|
regions: globalRegions,
|
|
countries: globalCountries));
|
|
} catch (e) {
|
|
emit(EligibilityErrorState(message: e.toString()));
|
|
}
|
|
});
|
|
|
|
//// ADD
|
|
on<AddEligibility>(
|
|
(event, emit) async {
|
|
try {
|
|
Map<dynamic, dynamic> status = await EligibilityService.instance.add(
|
|
eligibityCert: event.eligibityCert,
|
|
token: event.token,
|
|
profileId: int.parse(event.profileId));
|
|
if (status['success']) {
|
|
EligibityCert? eligibityCert =
|
|
EligibityCert.fromJson(status['data']);
|
|
eligibilities.add(eligibityCert);
|
|
emit(EligibilityAddedState(response: status));
|
|
} else {
|
|
emit(EligibilityAddedState(response: status));
|
|
}
|
|
} catch (e) {
|
|
emit(EligibilityErrorState(message: e.toString()));
|
|
}
|
|
},
|
|
);
|
|
on<CallErrorState>((event, emit) {
|
|
emit(const EligibilityErrorState(
|
|
message: "Something went wrong. Please try again"));
|
|
});
|
|
////Add attachment
|
|
on<AddEligibiltyAttachment>((event, emit) async {
|
|
emit(EligibilityLoadingState());
|
|
List<Attachment> attachments = [];
|
|
EligibityCert eligibityCert = eligibilities.firstWhere(
|
|
(element) => element.id.toString() == event.attachmentModule);
|
|
try {
|
|
Map<dynamic, dynamic> status = await AttachmentServices.instance
|
|
.attachment(
|
|
categoryId: event.categoryId,
|
|
module: event.attachmentModule,
|
|
paths: event.filePaths,
|
|
token: event.token,
|
|
profileId: event.profileId);
|
|
if (status['success']) {
|
|
status['data'].forEach((element) {
|
|
Attachment newAttachment = Attachment.fromJson(element);
|
|
attachments.add(newAttachment);
|
|
});
|
|
eligibityCert.attachments == null
|
|
? eligibityCert.attachments = attachments
|
|
: eligibityCert.attachments = [
|
|
...eligibityCert.attachments!,
|
|
...attachments
|
|
];
|
|
emit(EligibilityAttachmentAddedState(response: status));
|
|
} else {
|
|
emit(EligibilityAttachmentAddedState(response: status));
|
|
}
|
|
} catch (e) {
|
|
emit(EligibilityErrorState(message: e.toString()));
|
|
}
|
|
});
|
|
|
|
on<DeleteEligibyAttachment>((event, emit) async {
|
|
emit(EligibilityLoadingState());
|
|
try {
|
|
final bool success = await AttachmentServices.instance.deleteAttachment(
|
|
attachment: event.attachment,
|
|
moduleId: int.parse(event.moduleId),
|
|
profileId: event.profileId.toString(),
|
|
token: event.token);
|
|
if (success) {
|
|
final EligibityCert eligibityCert = eligibilities
|
|
.firstWhere((element) => element.id.toString() == event.moduleId);
|
|
eligibityCert.attachments
|
|
?.removeWhere((element) => element.id == event.attachment.id);
|
|
eligibilities.removeWhere(
|
|
(element) => element.id.toString() == event.moduleId);
|
|
eligibilities.add(eligibityCert);
|
|
emit(EligibilitytAttachmentDeletedState(success: success));
|
|
} else {
|
|
emit(EligibilitytAttachmentDeletedState(success: success));
|
|
}
|
|
} catch (e) {
|
|
emit(EligibilityErrorState(message: e.toString()));
|
|
}
|
|
});
|
|
on<EligibiltyViewAttachmentEvent>((event,emit){
|
|
String fileUrl = '${Url.instance.prefixHost()}://${Url.instance.host()}/media/${event.source}';
|
|
emit(EligibilityAttachmentViewState(fileUrl: fileUrl,fileName: event.filename));
|
|
});
|
|
on<ShareAttachment>((event, emit) async {
|
|
emit(EligibilityLoadingState());
|
|
Directory directory;
|
|
String? appDocumentPath;
|
|
if (await requestPermission(Permission.storage)) {
|
|
directory = await getApplicationDocumentsDirectory();
|
|
appDocumentPath = directory.path;
|
|
}
|
|
try{
|
|
final bool success = await AttachmentServices.instance.downloadAttachment(
|
|
filename: event.fileName,
|
|
source: event.source,
|
|
downLoadDir: appDocumentPath!);
|
|
if (success) {
|
|
final result = await Share.shareXFiles(
|
|
[XFile("$appDocumentPath/${event.fileName}")]);
|
|
if (result.status == ShareResultStatus.success) {
|
|
Fluttertoast.showToast(msg: "Attachment shared successful");
|
|
emit(EligibilityAttachmentViewState(
|
|
fileUrl: event.source, fileName: event.fileName));
|
|
} else {
|
|
Fluttertoast.showToast(msg: "Attachment shared unsuccessful");
|
|
emit(EligibilityAttachmentViewState(
|
|
fileUrl: event.source, fileName: event.fileName));
|
|
}
|
|
} else {
|
|
emit(EligibilityAttachmentViewState(
|
|
fileUrl: event.source, fileName: event.fileName));
|
|
}
|
|
}catch(e){
|
|
emit(EligibilityErrorState(message: e.toString()));
|
|
}
|
|
});
|
|
}
|
|
}
|