mirror of
https://github.com/SyncrowIOT/web.git
synced 2025-07-09 14:47:23 +00:00
330 lines
10 KiB
Dart
330 lines
10 KiB
Dart
import 'dart:async';
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter_bloc/flutter_bloc.dart';
|
|
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
|
|
import 'package:syncrow_web/pages/auth/bloc/auth_event.dart';
|
|
import 'package:syncrow_web/pages/auth/bloc/auth_state.dart';
|
|
import 'package:syncrow_web/pages/auth/model/login_with_email_model.dart';
|
|
import 'package:syncrow_web/pages/auth/model/token.dart';
|
|
import 'package:syncrow_web/pages/auth/model/user_model.dart';
|
|
import 'package:syncrow_web/services/auth_api.dart';
|
|
import 'package:syncrow_web/utils/constants/strings_manager.dart';
|
|
import 'package:syncrow_web/utils/helpers/shared_preferences_helper.dart';
|
|
import 'package:syncrow_web/utils/snack_bar.dart';
|
|
|
|
class AuthBloc extends Bloc<AuthEvent, AuthState> {
|
|
AuthBloc() : super(LoginInitial()) {
|
|
on<LoginButtonPressed>(_login);
|
|
on<CheckBoxEvent>(checkBoxToggle);
|
|
on<ChangePasswordEvent>(changePassword);
|
|
on<StartTimerEvent>(_onStartTimer);
|
|
on<StopTimerEvent>(_onStopTimer);
|
|
on<UpdateTimerEvent>(_onUpdateTimer);
|
|
on<PasswordVisibleEvent>(_passwordVisible);
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////// forget password //////////////////////////////////
|
|
final TextEditingController forgetEmailController = TextEditingController();
|
|
final TextEditingController forgetPasswordController = TextEditingController();
|
|
final TextEditingController forgetOtp = TextEditingController();
|
|
final forgetFormKey = GlobalKey<FormState>();
|
|
Timer? _timer;
|
|
int _remainingTime = 0;
|
|
|
|
Future<void> _onStartTimer(StartTimerEvent event, Emitter<AuthState> emit) async {
|
|
if (_validateInputs(emit)) return;
|
|
print("StartTimerEvent received");
|
|
if (_timer != null && _timer!.isActive) {
|
|
print("Timer is already active");
|
|
return;
|
|
}
|
|
_remainingTime = 60;
|
|
add(UpdateTimerEvent(
|
|
remainingTime: _remainingTime, isButtonEnabled: false));
|
|
print("Timer started, initial remaining time: $_remainingTime");
|
|
await AuthenticationAPI.sendOtp(email: forgetEmailController.text);
|
|
_timer = Timer.periodic(const Duration(seconds: 1), (timer) {
|
|
_remainingTime--;
|
|
print("Timer tick, remaining time: $_remainingTime"); // Debug print
|
|
if (_remainingTime <= 0) {
|
|
_timer?.cancel();
|
|
add(const UpdateTimerEvent(remainingTime: 0, isButtonEnabled: true));
|
|
print("Timer finished"); // Debug print
|
|
} else {
|
|
add(UpdateTimerEvent(
|
|
remainingTime: _remainingTime, isButtonEnabled: false));
|
|
}
|
|
});
|
|
}
|
|
|
|
void _onStopTimer(StopTimerEvent event, Emitter<AuthState> emit) {
|
|
_timer?.cancel();
|
|
emit(const TimerState(isButtonEnabled: true, remainingTime: 0));
|
|
}
|
|
|
|
Future<void> changePassword(
|
|
ChangePasswordEvent event, Emitter<AuthState> emit) async {
|
|
try {
|
|
emit(LoadingForgetState());
|
|
bool response = await AuthenticationAPI.verifyOtp(
|
|
email: forgetEmailController.text, otpCode: forgetOtp.text);
|
|
if (response == true) {
|
|
await AuthenticationAPI.forgetPassword(
|
|
password: forgetPasswordController.text,
|
|
email: forgetEmailController.text);
|
|
_timer?.cancel();
|
|
emit(const TimerState(isButtonEnabled: true, remainingTime: 0));
|
|
}
|
|
emit(SuccessForgetState());
|
|
} catch (failure) {
|
|
emit(FailureForgetState(error: failure.toString()));
|
|
}
|
|
}
|
|
|
|
void _onUpdateTimer(UpdateTimerEvent event, Emitter<AuthState> emit) {
|
|
emit(TimerState(
|
|
isButtonEnabled: event.isButtonEnabled,
|
|
remainingTime: event.remainingTime));
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////// login /////////////////////////////////////
|
|
final TextEditingController loginEmailController = TextEditingController();
|
|
final TextEditingController loginPasswordController = TextEditingController();
|
|
final loginFormKey = GlobalKey<FormState>();
|
|
bool isChecked = false;
|
|
bool obscureText = true;
|
|
String newPassword = '';
|
|
String maskedEmail = '';
|
|
String otpCode = '';
|
|
static Token token = Token.emptyConstructor();
|
|
static UserModel? user;
|
|
bool showValidationMessage = false;
|
|
|
|
void _login(LoginButtonPressed event, Emitter<AuthState> emit) async {
|
|
emit(LoginLoading());
|
|
if (isChecked) {
|
|
try {
|
|
if (event.username.isEmpty || event.password.isEmpty) {
|
|
CustomSnackBar.displaySnackBar('Please enter your credentials');
|
|
emit(const LoginFailure(error: 'Something went wrong'));
|
|
return;
|
|
}
|
|
token = await AuthenticationAPI.loginWithEmail(
|
|
model: LoginWithEmailModel(
|
|
email: event.username,
|
|
password: event.password,
|
|
),
|
|
);
|
|
} catch (failure) {
|
|
emit(const LoginFailure(error: 'Something went wrong'));
|
|
// emit(LoginFailure(error: failure.toString()));
|
|
return;
|
|
}
|
|
if (token.accessTokenIsNotEmpty) {
|
|
debugPrint('token: ${token.accessToken}');
|
|
FlutterSecureStorage storage = const FlutterSecureStorage();
|
|
await storage.write(
|
|
key: Token.loginAccessTokenKey, value: token.accessToken);
|
|
const FlutterSecureStorage().write(
|
|
key: UserModel.userUuidKey,
|
|
value: Token.decodeToken(token.accessToken)['uuid'].toString());
|
|
user = UserModel.fromToken(token);
|
|
loginEmailController.clear();
|
|
loginPasswordController.clear();
|
|
emit(LoginSuccess());
|
|
} else {
|
|
emit(const LoginFailure(error: 'Something went wrong'));
|
|
}
|
|
} else {
|
|
emit(const LoginFailure(error: 'Accept terms and condition'));
|
|
}
|
|
}
|
|
|
|
checkBoxToggle(CheckBoxEvent event, Emitter<AuthState> emit,) {
|
|
emit(LoginLoading());
|
|
isChecked = event.newValue!;
|
|
emit(LoginInitial());
|
|
}
|
|
|
|
checkOtpCode(ChangePasswordEvent event, Emitter<AuthState> emit,) async {
|
|
emit(LoadingForgetState());
|
|
await AuthenticationAPI.verifyOtp(
|
|
email: forgetEmailController.text, otpCode: forgetOtp.text);
|
|
emit(SuccessForgetState());
|
|
}
|
|
|
|
void _passwordVisible(PasswordVisibleEvent event, Emitter<AuthState> emit) {
|
|
emit(LoginLoading());
|
|
obscureText = !event.newValue!;
|
|
emit(PasswordVisibleState());
|
|
}
|
|
|
|
void launchURL(String url) {
|
|
if (kDebugMode) {
|
|
print('Launching URL: $url');
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////VALIDATORS/////////////////////////////////////
|
|
String? validatePassword(String? value) {
|
|
if (value == null || value.isEmpty) {
|
|
return 'Password is required';
|
|
} else if (value.length < 8) {
|
|
return 'Password must be at least 8 characters';
|
|
}
|
|
return null;
|
|
}
|
|
|
|
String? validateEmail(String? value) {
|
|
if (value == null || value.isEmpty) {
|
|
return 'Email is required';
|
|
} else if (!RegExp(r'^[^@]+@[^@]+\.[^@]+').hasMatch(value)) {
|
|
return 'Enter a valid email address';
|
|
}
|
|
return null;
|
|
}
|
|
|
|
String? validateCode(String? value) {
|
|
if (value == null || value.isEmpty) {
|
|
return 'Code is required';
|
|
}
|
|
return null;
|
|
}
|
|
|
|
bool _validateInputs(Emitter<AuthState> emit) {
|
|
emit(LoadingForgetState());
|
|
final nameError = validateEmail(forgetEmailController.text);
|
|
if (nameError != null) {
|
|
emit(FailureForgetState(error: nameError));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
String? validateRegion(String? value) {
|
|
if (value == null || value.isEmpty) {
|
|
return 'Please select a region';
|
|
}
|
|
return null;
|
|
}
|
|
|
|
String? passwordValidator(String? value) {
|
|
if (value == null || value.isEmpty) {
|
|
return 'Please enter your password';
|
|
}
|
|
List<String> validationErrors = [];
|
|
|
|
if (!RegExp(r'^(?=.*[a-z])').hasMatch(value)) {
|
|
validationErrors.add(' - one lowercase letter');
|
|
}
|
|
if (!RegExp(r'^(?=.*[A-Z])').hasMatch(value)) {
|
|
validationErrors.add(' - one uppercase letter');
|
|
}
|
|
if (!RegExp(r'^(?=.*\d)').hasMatch(value)) {
|
|
validationErrors.add(' - one number');
|
|
}
|
|
if (!RegExp(r'^(?=.*[@$!%*?&])').hasMatch(value)) {
|
|
validationErrors.add(' - one special character');
|
|
}
|
|
if (value.length < 8) {
|
|
validationErrors.add(' - minimum 8 characters');
|
|
}
|
|
|
|
if (validationErrors.isNotEmpty) {
|
|
return 'Password must contain at least:\n${validationErrors.join('\n')}';
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
String? fullNameValidator(String? value) {
|
|
if (value == null) return 'Full name is required';
|
|
final withoutExtraSpaces = value.replaceAll(RegExp(r"\s+"), ' ').trim();
|
|
if (withoutExtraSpaces.length < 2 || withoutExtraSpaces.length > 30) {
|
|
return 'Full name must be between 2 and 30 characters long';
|
|
}
|
|
if (RegExp(r"/[^ a-zA-Z0-9-\']/").hasMatch(withoutExtraSpaces)) {
|
|
return 'Only alphanumeric characters, space, dash and single quote are allowed';
|
|
}
|
|
final parts = withoutExtraSpaces.split(' ');
|
|
if (parts.length < 2) return 'Full name must contain first and last names';
|
|
if (parts.length > 3) return 'Full name can at most contain 3 parts';
|
|
if (parts.any((part) => part.length < 2 || part.length > 30)) {
|
|
return 'Full name parts must be between 2 and 30 characters long';
|
|
}
|
|
return null;
|
|
}
|
|
|
|
String maskEmail(String email) {
|
|
final emailParts = email.split('@');
|
|
if (emailParts.length != 2) return email;
|
|
|
|
final localPart = emailParts[0];
|
|
final domainPart = emailParts[1];
|
|
|
|
if (localPart.length < 3) return email;
|
|
|
|
final start = localPart.substring(0, 2);
|
|
final end = localPart.substring(localPart.length - 1);
|
|
|
|
final maskedLocalPart = '$start******$end';
|
|
return '$maskedLocalPart@$domainPart';
|
|
}
|
|
|
|
final List<String> regions = [
|
|
'North America',
|
|
'South America',
|
|
'Europe',
|
|
'Asia',
|
|
'Africa',
|
|
'Australia',
|
|
'Antarctica',
|
|
];
|
|
|
|
|
|
static Future<String> getTokenAndValidate() async {
|
|
try {
|
|
const storage = FlutterSecureStorage();
|
|
final firstLaunch = await SharedPreferencesHelper.readBoolFromSP(StringsManager.firstLaunch) ?? true;
|
|
if (firstLaunch) {
|
|
storage.deleteAll();
|
|
}
|
|
await SharedPreferencesHelper.saveBoolToSP(StringsManager.firstLaunch, false);
|
|
final value = await storage.read(key: Token.loginAccessTokenKey) ?? '';
|
|
if (value.isEmpty) {
|
|
return 'Token not found';
|
|
}
|
|
final tokenData = Token.decodeToken(value);
|
|
if (tokenData.containsKey('exp')) {
|
|
final exp = tokenData['exp'] ?? 0;
|
|
final currentTime = DateTime.now().millisecondsSinceEpoch ~/ 1000;
|
|
if (currentTime < exp) {
|
|
return 'Success';
|
|
} else {
|
|
return 'expired';
|
|
}
|
|
} else {
|
|
return 'Something went wrong';
|
|
}
|
|
} catch (_) {
|
|
return 'Something went wrong';
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|