initial commit

[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';

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;

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

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

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

  @override
  void initState() {
    super.initState();

    if (widget.usernameController.text.isNotEmpty) {
      passwordFocusNode = FocusNode();
      passwordFocusNode.requestFocus();
    }
  }

  @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,
      );
    }

    return 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;
          },
        ),
        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;
              },
            ),
            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;

  const ProxmoxLoginPage({
    Key key,
    this.userModel,
    this.isCreate,
  }) : 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;
    }
  }

  @override
  Widget build(BuildContext context) {
    return Theme(
      data: ThemeData.dark().copyWith(accentColor: Color(0xFFE47225)),
      child: Material(
        color: Theme.of(context).primaryColor,
        child: 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: [
                                      Text(
                                        'PROXMOX',
                                        style: TextStyle(
                                          fontFamily: 'Proxmox',
                                          fontSize: 36,
                                        ),
                                      ),
                                      Text(
                                        'Open Source',
                                        style: TextStyle(
                                          fontSize: 18,
                                        ),
                                      ),
                                    ],
                                  ),
                                ),
                              ),
                              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;
                                  });
                                },
                              ),
                              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() async {
    setState(() {
      _progressModel
        ..inProgress = true
        ..message = 'Authenticating...';
    });

    try {
      final settings = await ProxmoxGeneralSettingsModel.fromLocalStorage();
      final origin = Uri.https(_originController.text, '');
      var client = await proxclient.authenticate(
          '${_usernameController.text}@${_selectedDomain.realm}',
          _passwordController.text,
          origin,
          settings.sslValidation);

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

      var loginStorage = await ProxmoxLoginStorage.fromLocalStorage();

      if (widget.isCreate) {
        final newLogin = ProxmoxLoginModel((b) => b
          ..origin = origin
          ..username = _usernameController.text
          ..realm = _selectedDomain.realm
          ..productType = ProxmoxProductType.pve
          ..ticket = client.credentials.ticket);
        loginStorage = loginStorage.rebuild((b) => b..logins.add(newLogin));
      } else {
        loginStorage = loginStorage.rebuild((b) => b
          ..logins.remove(widget.userModel)
          ..logins.add(widget.userModel
              .rebuild((b) => b..ticket = client.credentials.ticket)));
      }
      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 apiBaseUrl = Uri.https(_originController.text, '');

    if (!apiBaseUrl.hasPort) {
      _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'),
              ),
            ],
          ),
        );
      }
    }
    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'),
        )
      ],
    );
  }
}