355 lines
15 KiB
Dart
355 lines
15 KiB
Dart
// ignore_for_file: curly_braces_in_flow_control_structures, use_build_context_synchronously, unrelated_type_equality_checks
|
|
|
|
import 'dart:developer';
|
|
|
|
import 'package:flutter/material.dart';
|
|
import 'package:hub/backend/api_requests/api_calls.dart';
|
|
import 'package:hub/components/organism_components/bottom_arrow_linked_locals_component/bottom_arrow_linked_locals_component_widget.dart';
|
|
import 'package:hub/flutter_flow/flutter_flow_util.dart';
|
|
import 'package:hub/flutter_flow/internationalization.dart';
|
|
import 'package:hub/flutter_flow/nav/nav.dart';
|
|
import 'package:hub/shared/helpers/database/database_helper.dart';
|
|
|
|
import 'package:hub/shared/helpers/storage/base_storage.dart';
|
|
import 'package:hub/shared/helpers/storage/storage_helper.dart';
|
|
import 'package:hub/shared/services/authentication/authentication_service.dart';
|
|
import 'package:hub/shared/services/license/license_service.dart';
|
|
import 'package:hub/shared/utils/dialog_util.dart';
|
|
import 'package:hub/shared/utils/log_util.dart';
|
|
import 'package:hub/shared/utils/snackbar_util.dart';
|
|
import 'package:hub/shared/extensions/string_extensions.dart';
|
|
|
|
class LocalizationService {
|
|
static Future<void> checkLocals(BuildContext context) async {
|
|
try {
|
|
final GetLocalsCall callback = PhpGroup.getLocalsCall;
|
|
var response = await callback.call();
|
|
final bool? isError = response.jsonBody['error'];
|
|
|
|
if (isError == true) {
|
|
_handleError(context, response.jsonBody['error_msg']);
|
|
return;
|
|
}
|
|
if (response.jsonBody == null) {
|
|
final String errorMsg = FFLocalizations.of(context).getVariableText(
|
|
enText: 'Verify your connection',
|
|
ptText: 'Verifique sua conexão',
|
|
);
|
|
await DialogUtil.error(context, errorMsg).whenComplete(() => selectLocal(context, response));
|
|
return;
|
|
}
|
|
|
|
final List<dynamic> locals = response.jsonBody['locais'] ?? [];
|
|
final bool isEmpty = locals.isEmpty;
|
|
final bool isActive = locals.where((local) => local['CLU_STATUS'] != 'B').isNotEmpty;
|
|
final bool isEnable = !isEmpty && isActive;
|
|
|
|
if (isEnable) {
|
|
await StorageHelper().s(SecureStorageKey.haveLocal.value, true);
|
|
await StorageHelper().s(SecureStorageKey.isLogged.value, true);
|
|
await WidgetsBinding.instance.endOfFrame;
|
|
await StorageHelper().s(KeychainStorageKey.clientUUID.value, '');
|
|
await StorageHelper().s(KeychainStorageKey.ownerUUID.value, '');
|
|
StorageHelper().context?.go('/homePage');
|
|
}
|
|
} catch (e, s) {
|
|
log(e.toString(), stackTrace: s);
|
|
}
|
|
}
|
|
|
|
static Future<bool> processLocals(BuildContext context) async {
|
|
try {
|
|
await LicenseService().cleanLicense();
|
|
final GetLocalsCall callback = PhpGroup.getLocalsCall;
|
|
final ApiCallResponse response = await callback.call();
|
|
final bool? isError = response.jsonBody['error'];
|
|
|
|
if (isError == true) {
|
|
final String errorMsg = response.jsonBody['error_msg'];
|
|
_handleError(context, errorMsg);
|
|
return false;
|
|
}
|
|
if (response.jsonBody == null) {
|
|
final String errorMsg = FFLocalizations.of(context).getVariableText(
|
|
enText: 'Verify your connection',
|
|
ptText: 'Verifique sua conexão',
|
|
);
|
|
await DialogUtil.error(context, errorMsg).whenComplete(() => selectLocal(context, response));
|
|
return false;
|
|
}
|
|
|
|
final List<dynamic> locals = response.jsonBody['locais'].toList() ?? [];
|
|
_logLocalsStatus(locals);
|
|
|
|
final bool isActive = _isActive(locals);
|
|
final bool isInactived = await _isInactived(locals);
|
|
final bool isPending = _isPending(locals);
|
|
final bool isUnique = locals.length == 1;
|
|
final bool isBlocked = locals.where((local) => local['CLU_STATUS'] == 'B').isNotEmpty;
|
|
final bool isEnabled = isUnique && isActive;
|
|
final bool isDisabled = isUnique && isBlocked;
|
|
final bool isUnselected = await _isUnselected();
|
|
final bool isSelected = await _isSelected(isInactived);
|
|
final bool isUnavailable = isPending && isUnselected && isUnique;
|
|
final bool isAvailable = await _isAvailable();
|
|
|
|
if (isDisabled) {
|
|
AuthenticationService.signOut(context);
|
|
return true;
|
|
} else if (isUnavailable) {
|
|
return await _handleUnavailable(context, locals);
|
|
} else if (isEnabled) {
|
|
return await _handleEnabled(context, locals[0]);
|
|
} else if (isUnselected) {
|
|
log('() => isUnselected');
|
|
return await selectLocal(context, response);
|
|
} else if (isSelected) {
|
|
log('() => isSelected');
|
|
return await processData(context);
|
|
} else if (isAvailable) {
|
|
log('() => isAvailable');
|
|
return await processData(context);
|
|
} else {
|
|
if (!isUnique && !isActive) log('() => not unique and not active');
|
|
if (!isUnique && isInactived) log('() => not unique and inactived');
|
|
if (!isUnique && isPending) log('() => not unique and pending');
|
|
if (!isUnique && isBlocked) log('() => not unique and blocked');
|
|
log('() => else');
|
|
return await selectLocal(context, response);
|
|
}
|
|
} catch (e, s) {
|
|
log('() => stack: $s');
|
|
log('() => catch: $e', stackTrace: s);
|
|
// return await selectLocal(context);
|
|
final String errorMsg = FFLocalizations.of(context).getVariableText(
|
|
enText: 'Error getting locals, verify your connection',
|
|
ptText: 'Erro ao obter locais, verifique sua conexão',
|
|
);
|
|
await DialogUtil.error(context, errorMsg).whenComplete(() => selectLocal(context, null));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> processData(BuildContext context) async {
|
|
try {
|
|
final GetDadosCall callback = PhpGroup.getDadosCall;
|
|
ApiCallResponse? response = await callback.call();
|
|
final bool? isError = response.jsonBody['error'];
|
|
|
|
if (isError == true) {
|
|
final GetLocalsCall callback = PhpGroup.getLocalsCall;
|
|
response = await callback.call();
|
|
final String errorMsg = response.jsonBody['error_msg'];
|
|
await DialogUtil.error(context, errorMsg).whenComplete(() => selectLocal(context, response));
|
|
return false;
|
|
} else if (response.jsonBody == null) {
|
|
final GetLocalsCall callback = PhpGroup.getLocalsCall;
|
|
response = await callback.call();
|
|
final String errorMsg = FFLocalizations.of(context).getVariableText(
|
|
enText: 'Verify your connection',
|
|
ptText: 'Verifique sua conexão',
|
|
);
|
|
await DialogUtil.error(context, errorMsg).whenComplete(() => selectLocal(context, response));
|
|
return false;
|
|
} else {
|
|
final bool isNewVersion = await _updateStorageUtil(response.jsonBody);
|
|
if (isNewVersion) {
|
|
return await LicenseService().fetchLicenses();
|
|
} else {
|
|
await LicenseService().setupLicense(DatabaseStorage.database);
|
|
}
|
|
log('() => isNewVersion: $isNewVersion');
|
|
|
|
return false;
|
|
}
|
|
} catch (e, s) {
|
|
log('() => stack processData: $s');
|
|
log('() => error processData: $e', stackTrace: s);
|
|
final String errorMsg = FFLocalizations.of(context).getVariableText(
|
|
enText: 'Error getting data, verify your connection',
|
|
ptText: 'Erro ao obter dados, verifique sua conexão',
|
|
);
|
|
await DialogUtil.error(context, errorMsg).whenComplete(() => selectLocal(context, null));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> selectLocal(BuildContext context, ApiCallResponse? response) async {
|
|
return await showModalBottomSheet(
|
|
isScrollControlled: true,
|
|
backgroundColor: Colors.transparent,
|
|
enableDrag: false,
|
|
isDismissible: false,
|
|
showDragHandle: false,
|
|
useSafeArea: true,
|
|
context: context,
|
|
builder: (context) => PopScope(
|
|
canPop: false,
|
|
child: Padding(
|
|
padding: MediaQuery.viewInsetsOf(context),
|
|
child: BottomArrowLinkedLocalsComponentWidget(response: response),
|
|
),
|
|
),
|
|
).then((_) async => await processData(context));
|
|
}
|
|
|
|
static Future<void> unlinkLocal(BuildContext context) async {
|
|
String content;
|
|
try {
|
|
content = FFLocalizations.of(context).getVariableText(
|
|
enText: 'Device unlinked successfully',
|
|
ptText: 'Dispositivo desvinculado com sucesso',
|
|
);
|
|
|
|
await PhpGroup.resopndeVinculo.call(tarefa: 'I').then((value) async {
|
|
if (value.jsonBody['error'] == false) {
|
|
await StorageHelper().s(KeychainStorageKey.clientName.value, '');
|
|
await StorageHelper().s(KeychainStorageKey.clientUUID.value, '');
|
|
context.pop();
|
|
context.go(
|
|
'/homePage',
|
|
extra: <String, dynamic>{
|
|
kTransitionInfoKey: const TransitionInfo(
|
|
hasTransition: true,
|
|
transitionType: PageTransitionType.scale,
|
|
alignment: Alignment.bottomCenter,
|
|
),
|
|
},
|
|
);
|
|
SnackBarUtil.showSnackBar(context, content);
|
|
}
|
|
}).catchError((err, stack) {
|
|
context.pop();
|
|
content = FFLocalizations.of(context).getVariableText(
|
|
enText: 'Error unlinking device',
|
|
ptText: 'Erro ao desvincular dispositivo',
|
|
);
|
|
SnackBarUtil.showSnackBar(context, content, isError: true);
|
|
});
|
|
} catch (err, stack) {
|
|
context.pop();
|
|
log(err.toString(), stackTrace: stack);
|
|
content = FFLocalizations.of(context).getVariableText(
|
|
enText: 'Error unlinking device',
|
|
ptText: 'Erro ao desvincular dispositivo',
|
|
);
|
|
SnackBarUtil.showSnackBar(context, content, isError: true);
|
|
}
|
|
}
|
|
|
|
static void _handleError(BuildContext context, String errorMsg) async {
|
|
final String devUUID = await StorageHelper().g(KeychainStorageKey.devUUID.value) ?? '';
|
|
final String userUUID = await StorageHelper().g(KeychainStorageKey.userUUID.value) ?? '';
|
|
final bool isAuthenticated = userUUID.isNotEmpty && devUUID.isNotEmpty;
|
|
final bool isDevLinked = !errorMsg.contains('Esse dispositivo nao pertence a esse usuario');
|
|
log('() => isLinked: $errorMsg');
|
|
log('() => isLinked: $errorMsg');
|
|
if (!isAuthenticated) {
|
|
errorMsg = FFLocalizations.of(context).getVariableText(
|
|
ptText: 'Erro ao obter credenciais de autenticação',
|
|
enText: 'Error getting authentication credentials',
|
|
);
|
|
await DialogUtil.error(context, errorMsg);
|
|
return;
|
|
// await DialogUtil.error(context, errorMsg).whenComplete(() async => await AuthenticationService.signOut(context));
|
|
}
|
|
if (!isDevLinked) {
|
|
errorMsg = FFLocalizations.of(context).getVariableText(
|
|
ptText: 'Não foi possível vincular o dispositivo, tente novamente.',
|
|
enText: 'Unable to link device, try again',
|
|
);
|
|
await DialogUtil.warning(context, errorMsg);
|
|
return;
|
|
}
|
|
await DialogUtil.error(context, errorMsg).whenComplete(() async => await selectLocal(context, null));
|
|
}
|
|
|
|
static Future<bool> _handleUnavailable(BuildContext context, List<dynamic> locals) async {
|
|
log('() => isUnavailable');
|
|
try {
|
|
await StorageHelper().s(KeychainStorageKey.clientUUID.value, locals[0]['CLI_ID']);
|
|
await StorageHelper().s(KeychainStorageKey.ownerUUID.value, locals[0]['CLU_OWNER_ID']);
|
|
await StorageHelper().s(KeychainStorageKey.clientName.value, locals[0]['CLI_NOME']);
|
|
var response = await PhpGroup.resopndeVinculo.call(tarefa: 'A');
|
|
if (response.jsonBody['error'] == true) {
|
|
await StorageHelper().s(KeychainStorageKey.clientUUID.value, '');
|
|
await StorageHelper().s(KeychainStorageKey.ownerUUID.value, '');
|
|
await StorageHelper().s(KeychainStorageKey.clientName.value, '');
|
|
return false;
|
|
}
|
|
if (response.jsonBody['error'] == false) return await processData(context).then((value) => value);
|
|
} catch (e, s) {
|
|
await DialogUtil.errorDefault(context);
|
|
LogUtil.requestAPIFailed('responderVinculo.php', '', 'Responder Vínculo', e, s);
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static Future<bool> _handleEnabled(BuildContext context, dynamic local) async {
|
|
log('() => isEnabled');
|
|
await StorageHelper().s(KeychainStorageKey.clientUUID.value, local['CLI_ID']);
|
|
await StorageHelper().s(KeychainStorageKey.ownerUUID.value, local['CLU_OWNER_ID']);
|
|
await StorageHelper().s(KeychainStorageKey.clientName.value, local['CLI_NOME']);
|
|
await StorageHelper().s(KeychainStorageKey.userName.value, local['USU_NOME']);
|
|
return await processData(context);
|
|
}
|
|
|
|
static void _logLocalsStatus(List<dynamic> locals) {
|
|
for (var local in locals) {
|
|
final String status = local['CLU_STATUS'];
|
|
log('() => CLU_STATUS: $status');
|
|
}
|
|
}
|
|
|
|
static Future<bool> _updateStorageUtil(Map<String, dynamic> jsonBody) async {
|
|
await StorageHelper().s(KeychainStorageKey.whatsapp.value, jsonBody['whatsapp'] != null && jsonBody['whatsapp']);
|
|
await StorageHelper().s(KeychainStorageKey.provisional.value, jsonBody['provisional'] != null && jsonBody['provisional']);
|
|
await StorageHelper().s(KeychainStorageKey.pets.value, jsonBody['pet'] != null && jsonBody['pet']);
|
|
await StorageHelper().s(KeychainStorageKey.petAmount.value,
|
|
jsonBody['petAmountRegister'] != null && jsonBody['petAmountRegister'].toString().isEmpty ? '0' : jsonBody['petAmountRegister'].toString());
|
|
await StorageHelper().s(KeychainStorageKey.userName.value, jsonBody['visitado']['VDO_NOME']);
|
|
|
|
late final bool isNewVersion;
|
|
if (jsonBody['newVersion'] != null)
|
|
isNewVersion = jsonBody['newVersion'];
|
|
else
|
|
isNewVersion = false;
|
|
log('() => isNewVersion: ${jsonBody['newVersion']}');
|
|
await StorageHelper().s(KeychainStorageKey.isNewVersion.value, isNewVersion);
|
|
return isNewVersion;
|
|
}
|
|
|
|
static bool _isActive(List<dynamic> locals) {
|
|
return locals.where((local) => local['CLU_STATUS'] == 'A').isNotEmpty;
|
|
}
|
|
|
|
static Future<bool> _isInactived(List<dynamic> locals) async {
|
|
String cliUUID = (await StorageHelper().g(KeychainStorageKey.clientUUID.value)) ?? '';
|
|
return locals.where((local) => local['CLI_ID'] != cliUUID && local['CLU_STATUS'] == 'A').isNotEmpty;
|
|
}
|
|
|
|
static bool _isPending(List<dynamic> locals) {
|
|
return locals.where((local) => local['CLU_STATUS'] != 'B' && local['CLU_STATUS'] != 'A').isNotEmpty;
|
|
}
|
|
|
|
static Future<bool> _isUnselected() async {
|
|
String cliUUID = (await StorageHelper().g(KeychainStorageKey.clientUUID.value)) ?? '';
|
|
String cliName = (await StorageHelper().g(KeychainStorageKey.clientName.value)) ?? '';
|
|
String ownerUUID = (await StorageHelper().g(KeychainStorageKey.ownerUUID.value)) ?? '';
|
|
return cliUUID.isEmpty && cliName.isEmpty && ownerUUID.isEmpty;
|
|
}
|
|
|
|
static Future<bool> _isSelected(bool isInactived) async {
|
|
String cliUUID = (await StorageHelper().g(KeychainStorageKey.clientUUID.value)) ?? '';
|
|
String cliName = (await StorageHelper().g(KeychainStorageKey.clientName.value)) ?? '';
|
|
return cliUUID.isNotEmpty && cliName.isNotEmpty && isInactived;
|
|
}
|
|
|
|
static Future<bool> _isAvailable() async {
|
|
String cliUUID = (await StorageHelper().g(KeychainStorageKey.clientUUID.value)) ?? '';
|
|
String cliName = (await StorageHelper().g(KeychainStorageKey.clientName.value)) ?? '';
|
|
return cliUUID.isNotEmpty && cliName.isNotEmpty;
|
|
}
|
|
}
|