express_dt 1.0.3

express_dt: ^1.0.3 copied to clipboard

example/example.dart

// import 'dart:html';
import 'dart:async';
import 'dart:convert';
import 'package:universal_io/io.dart';
import 'dart:math';
import 'package:express_dt/express_dt.dart';
import 'package:path/path.dart' as p;
import 'package:dotenv/dotenv.dart' show load, clean, isEveryDefined, env;

// import 'websocket.dart';
// EXPRESS_SECRET_KEY

dynamic main() {
  load();

  var config =
      ExpressJwtConfig(env['EXPRESS_SECRET_KEY']!, issuer: 'express.com');

  var expressSession =
      JwtSession(config, io: SessionIoCookie(cookieName: 'express'));

  var express = Express();

  //let express know to serve from the /web directory
  express.use(Express.static('example/web'));

  //Allowe cross Origin requests
  express.use(Cors(['*']));

  //do this if you want all routes to be protected by session. Routes will fail with unauthorzed sessions.
  // express.use(ExpressSessions(env['EXPRESS_SECRET_KEY']!, expressSession));

  //Use path to get directory of the files to serve on that route

  express.get(ExpressMethod(route: '/home', callbacks: [
    (ExpressRequest req, ExpressResponse res) {
      int numb = Random().nextInt(7);
      if (numb % 2 == 0) {
      } else {
        return res
            .statusCode(400)
            .toJson({"message": "Only even numbers allowed"});
      }
    },
    (
      ExpressRequest req,
      ExpressResponse res,
    ) {
      return res.statusCode(200).sendFile(p.absolute('web/index.html'));
    }
  ]));

  express.get(ExpressMethod(route: '/', callbacks: [
    (ExpressRequest req, ExpressResponse res) {
      int numb = Random().nextInt(7);
      // print(numb);
      if (numb % 2 == 0) {
      } else {
        return res
            .statusCode(400)
            .toJson({"message": "Only even numbers allowed"});
      }
    },
    (ExpressRequest req, ExpressResponse res) {
      // req.sessions!.addAll({'state': "secret"});
      return res.statusCode(200).send('<h1>Hello World</h1>');
    },
  ]));

  //route to create a jwt token
  express.get(ExpressMethod(route: '/tokenRoute', callbacks: [
    (req, res) {
      String token = expressSign('Sjkbdjaksdjas', env['EXPRESS_SECRET_KEY']!);
      return res.statusCode(200).toJson({"token": token});
    }
  ]));

  //route with a middleware to verify jwt token
  express.get(ExpressMethod(route: '/verifyToken', callbacks: [
    (req, res) {
      String? token = extractTokenFromHeader(req.headers);
      if (token == null) {
        return res.statusCode(400).send('Authorization Failed');
      } else {
        var data = expressVerify(token, env['EXPRESS_SECRET_KEY']!);
        if (data == null) {
          return res.statusCode(400).send('Authorization Failed');
        }
      }
    },
    (req, res) {
      return res.statusCode(200).send('Authorized');
    }
  ]));

  //post request
//Handle session manually
  express.post(ExpressMethod(route: '/post', callbacks: [
    (ExpressRequest req, ExpressResponse res) async {
//Handle session manually
      final Session session = await req.session;
      session.clear();
      session['authorization'] = 'AuthorizationValue';
      //save the value in the response cookie
      res.cookiess(Cookie('authorization', 'AuthorizationValue'));
      return res.statusCode(200).toJson({"sas": req.cookies});
    }
  ]));

  //plain text
//manually verify session
  express.get(ExpressMethod(route: '/text', callbacks: [
    (ExpressRequest req, ExpressResponse res) async {
      //manually check session
      print(req.cookies.toString());
      Cookie? auth = req.cookies['authorization'];
      if (auth == null || auth.value != 'AuthorizationValue') {
        return res.statusCode(HttpStatus.unauthorized);
      }

      return res.statusCode(200).send('data');
    }
  ]));

  // request parameters

  express.get(ExpressMethod(route: '/param/:username', callbacks: [
    (ExpressRequest req, ExpressResponse res) {
      return res.statusCode(200).toJson({'params': req.params});
    }
  ]));

  // query parameters
  express.get(ExpressMethod(route: '/query', callbacks: [
    (ExpressRequest req, ExpressResponse res) {
      return res.statusCode(200).toJson(req.query);
    }
  ]));

  //Upload Files

  express.post(ExpressMethod(route: '/upload', callbacks: [
    (req, res) async {
      for (var i = 0; i < req.files.keys.length; i++) {
        //Handle your file stream as you see fit, write to file, pipe to a cdn etc --->
        var file = File(req.files[req.files.keys.toList()[i]]!.filename!);
        await for (var data in req
            .files[req.files.keys.toList()[i]]!.streamController!.stream) {
          if (data is String) {
            await file.writeAsString(data, mode: FileMode.append);
          } else {
            await file.writeAsBytes(data, mode: FileMode.append);
          }
        }
      }

      return res.statusCode(200).toJson(req.body);
    }
  ]));

  //Manage sessions example
  //This route creates a session automatically because we have told express to use EXPRESS SESSION above
  express.post(ExpressMethod(route: '/sessions', callbacks: [
    (req, res) async {
      // print(res.cookies.toString());
      return res.statusCode(200).toJson({'session': res.cookies.toString()});
    }
  ]));

//this route verifies session.
//Request fails if the session is invalid

  //Verify session
  express.get(
    ExpressMethod(
      route: '/verify_sessions',
      callbacks: [
        (req, res) async {
          Session session = await expressSession.parse(req);
          print(session['authorization']);
        }
      ],
    ),
  );

  express.get(ExpressMethod(route: '/websockets', callbacks: [
    (req, res) {
      // print(req.url.)
      if (req.url.path == '/websockets') {
        print('Herte');

        WebSocketTransformer.upgrade(req.req!).then((WebSocket ws) {
          ws.listen((event) {
            print('Hello + $event');
            Timer(Duration(seconds: 1), () {
              if (ws.readyState == WebSocket.open)
                // checking connection state helps to avoid unprecedented errors
                ws.add(json.encode({
                  'data': 'from server at ${DateTime.now().toString()}',
                }));
            });
          });
        }, onError: (e) {
          print(e);
        });
      }
      // print('Here');
    }
  ]));

  //Bind server to port 4000
  express.stream(8080, callback: () {});
}

//  final Session session = await ctx.session;
//       // Invalidate old session data
//       session.clear();
//       // Add new session data
//       session.addAll(
//           <String, String>{authorizationIdKey: subject.authorizationId});