fix issue when 443 port is used

[flutter/proxmox_login_manager.git] / lib / proxmox_login_form.dart

import 'dart:io';

import 'package:flutter/material.dart';
import 'package:proxmox_dart_api_client/proxmox_dart_api_client.dart'
    as proxclient;
import 'package:proxmox_dart_api_client/proxmox_dart_api_client.dart';
import 'package:proxmox_login_manager/proxmox_general_settings_form.dart';
import 'package:proxmox_login_manager/proxmox_general_settings_model.dart';
import 'package:proxmox_login_manager/proxmox_login_model.dart';
import 'package:proxmox_login_manager/proxmox_tfa_form.dart';
import 'package:proxmox_login_manager/extension.dart';

class ProxmoxProgressModel {
  bool inProgress;
  String message;
  ProxmoxProgressModel({
    this.inProgress = false,
    this.message = 'Loading...',
  });
}

class ProxmoxLoginForm extends StatefulWidget {
  final TextEditingController originController;
  final FormFieldValidator<String> originValidator;
  final TextEditingController usernameController;
  final TextEditingController passwordController;
  final List<PveAccessDomainModel> accessDomains;
  final PveAccessDomainModel selectedDomain;
  final ValueChanged<PveAccessDomainModel> onDomainChanged;
  final Function onPasswordSubmitted;
  final Function onOriginSubmitted;

  const ProxmoxLoginForm({
    Key key,
    @required this.originController,
    @required this.usernameController,
    @required this.passwordController,
    @required this.accessDomains,
    @required this.originValidator,
    this.selectedDomain,
    @required this.onDomainChanged,
    this.onPasswordSubmitted,
    this.onOriginSubmitted,
  }) : super(key: key);

  @override
  _ProxmoxLoginFormState createState() => _ProxmoxLoginFormState();
}

class _ProxmoxLoginFormState extends State<ProxmoxLoginForm> {
  bool _obscure = true;
  FocusNode passwordFocusNode;

  @override
  Widget build(BuildContext context) {
    if (widget.accessDomains == null) {
      return TextFormField(
        decoration: InputDecoration(
            icon: Icon(Icons.vpn_lock),
            labelText: 'Origin',
            hintText: 'e.g. 192.168.1.2',
            helperText: 'Protocol (https) and default port (8006) implied'),
        controller: widget.originController,
        validator: widget.originValidator,
        onFieldSubmitted: (value) => widget.onOriginSubmitted(),
      );
    }

    return AutofillGroup(
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          TextFormField(
            decoration: InputDecoration(
              icon: Icon(Icons.vpn_lock),
              labelText: 'Origin',
            ),
            controller: widget.originController,
            enabled: false,
          ),
          TextFormField(
            decoration: InputDecoration(
              icon: Icon(Icons.person),
              labelText: 'Username',
            ),
            controller: widget.usernameController,
            validator: (value) {
              if (value.isEmpty) {
                return 'Please enter username';
              }
              return null;
            },
            autofillHints: [AutofillHints.username],
          ),
          DropdownButtonFormField(
            decoration: InputDecoration(icon: Icon(Icons.domain)),
            items: widget.accessDomains
                .map((e) => DropdownMenuItem(
                      child: ListTile(
                        title: Text(e.realm),
                        subtitle: Text(e.comment ?? ''),
                      ),
                      value: e,
                    ))
                .toList(),
            onChanged: widget.onDomainChanged,
            selectedItemBuilder: (context) =>
                widget.accessDomains.map((e) => Text(e.realm)).toList(),
            value: widget.selectedDomain,
          ),
          Stack(
            children: [
              TextFormField(
                decoration: InputDecoration(
                  icon: Icon(Icons.lock),
                  labelText: 'Password',
                ),
                controller: widget.passwordController,
                obscureText: _obscure,
                autocorrect: false,
                focusNode: passwordFocusNode,
                validator: (value) {
                  if (value.isEmpty) {
                    return 'Please enter password';
                  }
                  return null;
                },
                onFieldSubmitted: (value) => widget.onPasswordSubmitted(),
                autofillHints: [AutofillHints.password],
              ),
              Align(
                alignment: Alignment.bottomRight,
                child: IconButton(
                  constraints: BoxConstraints.tight(Size(58, 58)),
                  iconSize: 24,
                  icon:
                      Icon(_obscure ? Icons.visibility : Icons.visibility_off),
                  onPressed: () => setState(() {
                    _obscure = !_obscure;
                  }),
                ),
              )
            ],
          ),
        ],
      ),
    );
  }

  @override
  void dispose() {
    passwordFocusNode?.dispose();
    super.dispose();
  }
}

class ProxmoxLoginPage extends StatefulWidget {
  final ProxmoxLoginModel userModel;
  final bool isCreate;
  final String ticket;

  const ProxmoxLoginPage({
    Key key,
    this.userModel,
    this.isCreate,
    this.ticket = '',
  }) : super(key: key);
  @override
  _ProxmoxLoginPageState createState() => _ProxmoxLoginPageState();
}

class _ProxmoxLoginPageState extends State<ProxmoxLoginPage> {
  final _originController = TextEditingController();
  final _usernameController = TextEditingController();
  final _passwordController = TextEditingController();
  Future<List<PveAccessDomainModel>> _accessDomains;
  PveAccessDomainModel _selectedDomain;
  final _formKey = GlobalKey<FormState>();
  ProxmoxProgressModel _progressModel;
  bool _submittButtonEnabled = true;

  @override
  void initState() {
    super.initState();
    final userModel = widget.userModel;
    _progressModel = ProxmoxProgressModel();
    if (!widget.isCreate && userModel != null) {
      _progressModel
        ..inProgress = true
        ..message = 'Connection test...';
      _originController.text =
          '${userModel.origin?.host}:${userModel.origin?.port}';
      _accessDomains = _getAccessDomains();
      _usernameController.text = userModel.username;
      if (widget.ticket.isNotEmpty && userModel.activeSession) {
        _onLoginButtonPressed(ticket: widget.ticket, mRealm: userModel.realm);
      }
    }
  }

  @override
  Widget build(BuildContext context) {
    return Theme(
      data: ThemeData.dark().copyWith(accentColor: Color(0xFFE47225)),
      child: Scaffold(
        backgroundColor: Theme.of(context).primaryColor,
        extendBodyBehindAppBar: true,
        appBar: AppBar(
          elevation: 0.0,
          backgroundColor: Colors.transparent,
          leading: IconButton(
            icon: Icon(Icons.close),
            onPressed: () => Navigator.of(context).pop(),
          ),
        ),
        body: Stack(
          children: [
            SingleChildScrollView(
              child: ConstrainedBox(
                constraints: BoxConstraints.tightFor(
                    height: MediaQuery.of(context).size.height),
                child: Padding(
                  padding: const EdgeInsets.all(8.0),
                  child: FutureBuilder<List<PveAccessDomainModel>>(
                      future: _accessDomains,
                      builder: (context, snapshot) {
                        return Form(
                          key: _formKey,
                          onChanged: () {
                            setState(() {
                              _submittButtonEnabled =
                                  _formKey.currentState.validate();
                            });
                          },
                          child: Column(
                            mainAxisAlignment: MainAxisAlignment.center,
                            children: [
                              Expanded(
                                child: Container(
                                  child: Column(
                                    mainAxisAlignment: MainAxisAlignment.center,
                                    children: [
                                      Image.asset(
                                        'assets/images/proxmox_logo_symbol_wordmark.png',
                                        package: 'proxmox_login_manager',
                                      ),
                                    ],
                                  ),
                                ),
                              ),
                              ProxmoxLoginForm(
                                originController: _originController,
                                originValidator: (value) {
                                  if (value.isEmpty) {
                                    return 'Please enter origin';
                                  }
                                  if (value.startsWith('https://') ||
                                      value.startsWith('http://')) {
                                    return 'Do not prefix with scheme';
                                  }
                                  try {
                                    Uri.https(value, '');
                                    return null;
                                  } on FormatException catch (_) {
                                    return 'Invalid URI';
                                  }
                                },
                                usernameController: _usernameController,
                                passwordController: _passwordController,
                                accessDomains: snapshot.data,
                                selectedDomain: _selectedDomain,
                                onDomainChanged: (value) {
                                  setState(() {
                                    _selectedDomain = value;
                                  });
                                },
                                onOriginSubmitted: _submittButtonEnabled
                                    ? () {
                                        final isValid =
                                            _formKey.currentState.validate();
                                        setState(() {
                                          _submittButtonEnabled = isValid;
                                        });
                                        if (isValid) {
                                          setState(() {
                                            _accessDomains =
                                                _getAccessDomains();
                                          });
                                        }
                                      }
                                    : null,
                                onPasswordSubmitted: _submittButtonEnabled
                                    ? () {
                                        final isValid =
                                            _formKey.currentState.validate();
                                        setState(() {
                                          _submittButtonEnabled = isValid;
                                        });
                                        if (isValid) {
                                          _onLoginButtonPressed();
                                        }
                                      }
                                    : null,
                              ),
                              if (snapshot.hasData)
                                Expanded(
                                  child: Align(
                                    alignment: Alignment.bottomCenter,
                                    child: Container(
                                      width: MediaQuery.of(context).size.width,
                                      child: FlatButton(
                                        onPressed: _submittButtonEnabled
                                            ? () {
                                                final isValid = _formKey
                                                    .currentState
                                                    .validate();
                                                setState(() {
                                                  _submittButtonEnabled =
                                                      isValid;
                                                });
                                                if (isValid) {
                                                  _onLoginButtonPressed();
                                                }
                                              }
                                            : null,
                                        color: Color(0xFFE47225),
                                        disabledColor: Colors.grey,
                                        child: Text('Continue'),
                                      ),
                                    ),
                                  ),
                                ),
                              if (!snapshot.hasData)
                                Expanded(
                                  child: Align(
                                    alignment: Alignment.bottomCenter,
                                    child: Container(
                                      width: MediaQuery.of(context).size.width,
                                      child: FlatButton(
                                        onPressed: _submittButtonEnabled
                                            ? () {
                                                final isValid = _formKey
                                                    .currentState
                                                    .validate();
                                                setState(() {
                                                  _submittButtonEnabled =
                                                      isValid;
                                                });
                                                if (isValid) {
                                                  setState(() {
                                                    _accessDomains =
                                                        _getAccessDomains();
                                                  });
                                                }
                                              }
                                            : null,
                                        color: Color(0xFFE47225),
                                        child: Text('Continue'),
                                        disabledColor: Colors.grey,
                                      ),
                                    ),
                                  ),
                                ),
                            ],
                          ),
                        );
                      }),
                ),
              ),
            ),
            if (_progressModel.inProgress)
              ProxmoxProgressOverlay(message: _progressModel.message),
          ],
        ),
      ),
    );
  }

  Future<void> _onLoginButtonPressed(
      {String ticket = '', String mRealm}) async {
    setState(() {
      _progressModel
        ..inProgress = true
        ..message = 'Authenticating...';
    });

    try {
      final settings = await ProxmoxGeneralSettingsModel.fromLocalStorage();

      //cleaned form fields
      final origin = Uri.https(_originController.text.trim(), '');
      final username = _usernameController.text.trim();
      final password =
          ticket.isNotEmpty ? ticket : _passwordController.text.trim();
      final realm = _selectedDomain?.realm ?? mRealm;

      var client = await proxclient.authenticate(
          '$username@$realm', password, origin, settings.sslValidation);

      if (client.credentials.tfa) {
        client = await Navigator.of(context).push(MaterialPageRoute(
          builder: (context) => ProxmoxTfaForm(
            apiClient: client,
          ),
        ));

        if (client == null) {
          setState(() {
            _progressModel.inProgress = false;
          });
          return;
        }
      }

      final status = await client.getClusterStatus();
      final hostname =
          status.singleWhere((element) => element.local ?? false).name;
      var loginStorage = await ProxmoxLoginStorage.fromLocalStorage();

      if (widget.isCreate) {
        final newLogin = ProxmoxLoginModel((b) => b
          ..origin = origin
          ..username = username
          ..realm = realm
          ..productType = ProxmoxProductType.pve
          ..ticket = client.credentials.ticket
          ..hostname = hostname);

        loginStorage = loginStorage.rebuild((b) => b..logins.add(newLogin));
      } else {
        loginStorage = loginStorage.rebuild((b) => b
          ..logins.rebuildWhere(
              (m) => m == widget.userModel,
              (b) => b
                ..ticket = client.credentials.ticket
                ..hostname = hostname));
      }
      await loginStorage.saveToDisk();

      Navigator.of(context).pop(client);
    } on proxclient.ProxmoxApiException catch (e) {
      print(e);
      showDialog(
        context: context,
        builder: (context) => ProxmoxApiErrorDialog(
          exception: e,
        ),
      );
    } catch (e, trace) {
      print(e);
      print(trace);
      if (e.runtimeType == HandshakeException) {
        showDialog(
          context: context,
          builder: (context) => ProxmoxCertificateErrorDialog(),
        );
      }
    }
    setState(() {
      _progressModel.inProgress = false;
    });
  }

  Future<List<PveAccessDomainModel>> _getAccessDomains() async {
    setState(() {
      _progressModel
        ..inProgress = true
        ..message = 'Connection test...';
    });
    var host = _originController.text.trim();
    var apiBaseUrl = Uri.https(host, '');

    RegExp portRE = new RegExp(r":\d{1,5}$");

    if (!portRE.hasMatch(host)) {
      _originController.text += ':8006';
      apiBaseUrl = apiBaseUrl.replace(port: 8006);
    }

    final settings = await ProxmoxGeneralSettingsModel.fromLocalStorage();
    List<PveAccessDomainModel> response;
    try {
      response =
          await proxclient.accessDomains(apiBaseUrl, settings.sslValidation);
    } on proxclient.ProxmoxApiException catch (e) {
      print(e);
      showDialog(
        context: context,
        builder: (context) => ProxmoxApiErrorDialog(
          exception: e,
        ),
      );
    } catch (e, trace) {
      print(e);
      print(trace);
      if (e.runtimeType == HandshakeException) {
        showDialog(
          context: context,
          builder: (context) => ProxmoxCertificateErrorDialog(),
        );
      } else {
        showDialog(
          context: context,
          builder: (context) => AlertDialog(
            title: Text('Connection error'),
            content: Text('Could not establish connection.'),
            actions: [
              FlatButton(
                onPressed: () => Navigator.of(context).pop(),
                child: Text('Close'),
              ),
            ],
          ),
        );
      }
    }

    response?.sort((a, b) => a.realm.compareTo(b.realm));

    final selection = response?.singleWhere(
      (e) => e.realm == widget.userModel?.realm,
      orElse: () => response?.first,
    );

    setState(() {
      _progressModel.inProgress = false;
      _selectedDomain = selection;
    });

    return response;
  }

  @override
  void dispose() {
    _originController.dispose();
    _usernameController.dispose();
    _passwordController.dispose();
    super.dispose();
  }
}

class ProxmoxProgressOverlay extends StatelessWidget {
  const ProxmoxProgressOverlay({
    Key key,
    @required this.message,
  }) : super(key: key);

  final String message;

  @override
  Widget build(BuildContext context) {
    return Container(
      decoration: new BoxDecoration(color: Colors.black.withOpacity(0.5)),
      child: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text(
              message,
              style: TextStyle(
                color: Theme.of(context).accentColor,
                fontSize: 20,
              ),
            ),
            Padding(
              padding: const EdgeInsets.only(top: 20.0),
              child: CircularProgressIndicator(),
            )
          ],
        ),
      ),
    );
  }
}

class ProxmoxApiErrorDialog extends StatelessWidget {
  final proxclient.ProxmoxApiException exception;

  const ProxmoxApiErrorDialog({
    Key key,
    @required this.exception,
  }) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return AlertDialog(
      title: Text('API Error'),
      content: SingleChildScrollView(
        child: Text(exception.message),
      ),
      actions: [
        FlatButton(
          onPressed: () => Navigator.of(context).pop(),
          child: Text('Close'),
        ),
      ],
    );
  }
}

class ProxmoxCertificateErrorDialog extends StatelessWidget {
  const ProxmoxCertificateErrorDialog({
    Key key,
  }) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return AlertDialog(
      title: Text('Certificate error'),
      content: SingleChildScrollView(
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text('Your connection is not private.'),
            Text(
              'Note: Consider to disable SSL validation,'
              ' if you use a self signed, not commonly trusted, certificate.',
              style: Theme.of(context).textTheme.caption,
            ),
          ],
        ),
      ),
      actions: [
        FlatButton(
          onPressed: () => Navigator.of(context).pop(),
          child: Text('Close'),
        ),
        FlatButton(
          onPressed: () => Navigator.of(context).pushReplacement(
              MaterialPageRoute(
                  builder: (context) => ProxmoxGeneralSettingsForm())),
          child: Text('Settings'),
        )
      ],
    );
  }
}