actions-test/lib/screens/auth.dart

import 'package:flutter/material.dart';
import 'package:outbag_app/backend/crypto.dart';
import 'package:outbag_app/backend/request.dart';
import 'package:outbag_app/backend/user.dart';
import 'package:outbag_app/tools/fetch_wrapper.dart';
import 'package:outbag_app/tools/snackbar.dart';
import 'package:routemaster/routemaster.dart';
import '../backend/resolve_url.dart';

enum Mode {
  signin,
  signup,
  signupOTA,
}

class AuthPage extends StatefulWidget {
  final Mode mode;
  const AuthPage({super.key, this.mode = Mode.signin});

  @override
  State<StatefulWidget> createState() => _AuthPageState();
}

class _AuthPageState extends State<AuthPage> {
  final TextEditingController _ctrServer = TextEditingController();
  final TextEditingController _ctrUsername = TextEditingController();
  final TextEditingController _ctrPassword = TextEditingController();
  final TextEditingController _ctrPasswordRpt = TextEditingController();
  final TextEditingController _ctrOTA = TextEditingController();

  bool showSpinner = false;

  @override
  Widget build(BuildContext context) {
    String modeName = "Sign In";
    if (widget.mode != Mode.signin) {
      modeName = "Sign Up";
    }
    String modeDescription = "Log into account";
    if (widget.mode != Mode.signin) {
      modeDescription = "Create new account";
    }

    final textTheme = Theme.of(context)
        .textTheme
        .apply(displayColor: Theme.of(context).colorScheme.onSurface);

    return showSpinner
        ? Scaffold(
            body: Center(
                child: Column(
                    crossAxisAlignment: CrossAxisAlignment.center,
                    mainAxisAlignment: MainAxisAlignment.center,
                    children: [
                const CircularProgressIndicator(),
                Text('Loading', style: textTheme.titleLarge),
              ])))
        : Scaffold(
            appBar: AppBar(
              title: Text(modeName),
              leading: IconButton(
                onPressed: () {
                  // go back
                  Routemaster.of(context).history.back();
                },
                icon: const Icon(Icons.arrow_back),
                tooltip: "Go back",
              ),
            ),
            body: Center(
                child: ConstrainedBox(
                    constraints: const BoxConstraints(maxWidth: 400),
                    child: Column(
                      crossAxisAlignment: CrossAxisAlignment.center,
                      mainAxisAlignment: MainAxisAlignment.center,
                      children: [
                        Padding(
                          padding: const EdgeInsets.all(8),
                          child: TextField(
                            controller: _ctrServer,
                            keyboardType: TextInputType.url,
                            decoration: const InputDecoration(
                              prefixIcon: Icon(Icons.dns),
                              labelText: 'Server',
                              hintText: 'Your homeserver url',
                              helperText:
                                  'Your data will be stored on your homeserver',
                              border: OutlineInputBorder(),
                            ),
                          ),
                        ),
                        Padding(
                          padding: const EdgeInsets.all(8),
                          child: TextField(
                            controller: _ctrUsername,
                            keyboardType: TextInputType.emailAddress,
                            decoration: const InputDecoration(
                              prefixIcon: Icon(Icons.person),
                              labelText: 'Username',
                              hintText: 'Your username',
                              helperText:
                                  'your username and server tag allow others to identify you',
                              border: OutlineInputBorder(),
                            ),
                          ),
                        ),
                        Padding(
                          padding: const EdgeInsets.all(8),
                          child: TextField(
                            controller: _ctrPassword,
                            keyboardType: TextInputType.visiblePassword,
                            obscureText: true,
                            decoration: const InputDecoration(
                              prefixIcon: Icon(Icons.lock),
                              labelText: 'Password',
                              hintText: 'Your password',
                              helperText:
                                  'Password have to be at least six characters long',
                              border: OutlineInputBorder(),
                            ),
                          ),
                        ),
                        // ONLY SIGNUP
                        ...((widget.mode != Mode.signin)
                            ? [
                                Padding(
                                  padding: const EdgeInsets.all(8),
                                  child: TextField(
                                    controller: _ctrPasswordRpt,
                                    keyboardType: TextInputType.visiblePassword,
                                    obscureText: true,
                                    decoration: const InputDecoration(
                                      prefixIcon: Icon(Icons.lock),
                                      labelText: 'Repeat Password',
                                      hintText: 'Type your password again',
                                      helperText:
                                          'Make sure to type the correct password',
                                      border: OutlineInputBorder(),
                                    ),
                                  ),
                                )
                              ]
                            : []),
                        // ONLY SIGNUP OTA
                        ...((widget.mode == Mode.signupOTA)
                            ? [
                                Padding(
                                  padding: const EdgeInsets.all(8),
                                  child: TextField(
                                    controller: _ctrOTA,
                                    keyboardType: TextInputType.visiblePassword,
                                    decoration: const InputDecoration(
                                      prefixIcon: Icon(Icons.key),
                                      labelText: 'OTA',
                                      hintText: 'One-Time-Authorization token',
                                      helperText:
                                          'This token might be required if the server is rate limited',
                                      border: OutlineInputBorder(),
                                    ),
                                  ),
                                )
                              ]
                            : []),
                      ],
                    ))),
            floatingActionButton: FloatingActionButton.extended(
              onPressed: () async {
                setState(() {
                  showSpinner = true;
                });

                final scaffMgr = ScaffoldMessenger.of(context);

                // verify that both passwords are the same
                if (widget.mode != Mode.signin) {
                  if (_ctrPassword.text != _ctrPasswordRpt.text) {
                    setState(() {
                      showSpinner = false;
                    });

                    showSimpleSnackbar(scaffMgr,
                        text: 'Passwords do not match', action: 'Dismiss');

                    _ctrPasswordRpt.clear();
                    return;
                  }
                }

                // password has to be at least 6 characters long
                if (_ctrPassword.text.length < 6) {
                  setState(() {
                    showSpinner = false;
                  });

                  showSimpleSnackbar(scaffMgr,
                      text: 'Password has to be at least 6 characters longs',
                      action: 'Dismiss');

                  _ctrPasswordRpt.clear();
                  return;
                }

                // resolve homeserver url
                OutbagServer server;
                try {
                  server = await getOutbagServerUrl(_ctrServer.text);
                } catch (e) {
                  // unable to find outbag server
                  // at given server address
                  // stop authentification
                  setState(() {
                    showSpinner = false;
                  });

                  showSimpleSnackbar(scaffMgr,
                      text:
                          'Unable to find valid outbag server on ${_ctrServer.text}',
                      action: 'Dismiss');

                  return;
                }

                // hash password
                final password = hashPassword(_ctrPassword.text);

                doNetworkRequest(scaffMgr, req: () {
                  if (widget.mode == Mode.signin) {
                    return postUnauthorized(
                        target: server,
                        path: 'signin',
                        body: {
                          'name': _ctrUsername.text,
                          'server': server.tag,
                          'accountKey': password
                        });
                  } else if (widget.mode == Mode.signup) {
                    return postUnauthorized(
                        target: server,
                        path: 'signup',
                        body: {
                          'name': _ctrUsername.text,
                          'server': server.tag,
                          'accountKey': password
                        });
                  } else {
                    // signup OTA
                    return postUnauthorized(
                        target: server,
                        path: 'signupOTA',
                        body: {
                          'name': _ctrUsername.text,
                          'server': server.tag,
                          'accountKey': password,
                          'OTA': _ctrOTA.text
                        });
                  }
                }, onOK: (body) async {
                  // authorize user
                  await User(
                          username: _ctrUsername.text,
                          password: password,
                          server: server)
                      .toDisk();
                }, after: () {
                  setState(() {
                    showSpinner = false;
                  });
                });
              },
              label: Text(modeName),
              icon: const Icon(Icons.check),
              tooltip: modeDescription,
            ),
          );
  }
}