WingCloudServer/Tools/TestTools/client/lib/UserView.dart

import 'dart:convert';
import 'dart:typed_data';

import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:get_it/get_it.dart';
import 'package:sprintf/sprintf.dart';
import 'package:ustest/ConsultationList.dart';
import 'package:ustest/Services/UserService.dart';
import 'package:http/http.dart' as http;

class UserView extends StatelessWidget {
  const UserView();

  @override
  Widget build(BuildContext context) {
    var service = GetIt.instance.get<UserService>();
    var user = service.getCurrentUser();
    if (user == null) {
      print("user is null");
      _showSignInScreen(context);
    }
    var userName = user == null ? "" : user.userName;
    var accessToken = user == null ? "" : user.accessToken;
    return Scaffold(
      body: Center(
        child: Column(
          children: [
            Padding(
              padding: EdgeInsets.all(8.0),
              child: Row(
                children: [
                  user == null
                      ? TextButton(
                          child: const Text("Sign in"),
                          onPressed: () => _showSignInScreen(context))
                      : Text(sprintf(
                          'Name:%s, Token:%s', [userName, accessToken])),
                  TextButton.icon(
                      onPressed: () => onLogout(context),
                      icon: Icon(Icons.logout),
                      label: Text("注銷"))
                ],
              ),
            ),
            Row(
              children: [
                TextButton.icon(
                    onPressed: () => onApplyConsultation(context),
                    icon: Icon(Icons.add),
                    label: Text("Apply")),
              ],
            ),
            Expanded(
                child: Center(
              child: FutureBuilder<List<Consultation>>(
                future: fetchPatients(),
                builder: (context, snapshot) {
                  if (snapshot.hasError) {
                    return const Center(
                      child: Text('An error has occurred!'),
                    );
                  } else if (snapshot.hasData) {
                    return ConsultationList(
                        token: accessToken, patients: snapshot.data!);
                  } else {
                    return const Center(
                      child: CircularProgressIndicator(),
                    );
                  }
                },
              ),
            )),
            StreamBuilder(
              stream: service.Channel.stream,
              builder: (context, snapshot) {
                var message = "";
                // var message =
                //     snapshot.hasData ? '${snapshot.data}' : 'no message';
                if (snapshot.hasData) {
                  var uint8Array =
                      Uint8List.fromList(snapshot.data as List<int>);
                  var byteData = uint8Array.buffer.asByteData();
                  var byteDataLength = byteData.lengthInBytes;
                  var messageConentList =
                      Uint8List.view(uint8Array.buffer, 0, byteDataLength);
                  var messageConentLength = messageConentList.length;
                  var messageConent = Uint8List.fromList(messageConentList);
                  var messageText = Utf8Decoder().convert(messageConent);
                  Map<String, dynamic> messageObject = jsonDecode(messageText);
                  //通知类型区分
                  if (messageObject["NotificationType"] as int ==
                      NotificationTypeEnum.ConnectionNotification.index) {
                    var connectionNotification =
                        ConnectionNotification.fromJson(messageObject);
                    print(
                        "connectionNotification.NotificationType:${connectionNotification.notificationType}");
                  } else if (messageObject["NotificationType"] as int ==
                      NotificationTypeEnum.DisconnectNotification.index) {
                    var disconnectNotification =
                        DisconnectNotification.fromJson(messageObject);
                    print(
                        "disconnectNotification.NotificationType:${disconnectNotification.notificationType}");
                  } else if (messageObject["NotificationType"] as int ==
                      NotificationTypeEnum.FinishNotifyRecordsMessage.index) {
                    var disconnectNotification =
                        FinishNotifyRecordsMessage.fromJson(messageObject);
                    print(
                        "FinishNotifyRecordsMessage.NotificationType:${disconnectNotification.notificationType},  ${disconnectNotification.codes}");
                  }

                  message = messageText;
                }
                return new Padding(
                  padding: const EdgeInsets.symmetric(vertical: 24.0),
                  child: new Text(message),
                );
              },
            )
          ],
        ),
      ),
    );
  }

  void _showSignInScreen(BuildContext context) {
    Future.delayed(Duration.zero, () {
      Navigator.of(context).pushNamed('/signin');
    });
  }

  Future<List<Consultation>> fetchPatients() async {
    var list = <Consultation>[];
    try {
      var service = GetIt.instance.get<UserService>();
      var user = service.getCurrentUser() as User;
      var client = http.Client();

      var body = sprintf(
          '{"jsonrpc": "2.0", "method": "FindPatients", "params": [{"Token": "%s",  "PageIndex": 1, "PageSize": 10}], "id": 1 }',
          [user.accessToken]);
      print('QueryExam http.Client()' + body);
      final response = await client.post(
          Uri.parse('http://192.168.6.80:8303/IPatientService'),
          body: body);
      print('QueryExam response.body' + response.body);
      final parsed = jsonDecode(response.body);
      var datas = parsed['result']['PageData'];

      var list = datas
          .map<Consultation>((json) => Consultation.fromJson(json))
          .toList();
      return list;
    } catch (ex) {
      print('QueryExam.to ex' + ex.toString());
      return list;
    }
  }

  void onLogout(context) {
    var service = GetIt.instance.get<UserService>();
    service.logout();
    Navigator.of(context).pushNamed('/signin');
  }

  void onApplyConsultation(context) {
    print("onApplyConsultation click");
    Navigator.of(context).pushNamed('/applyconsultation');
  }
}

enum NotificationTypeEnum {
  Daiding,

  /// <summary>
  /// ChatMsgNotification|1| 聊天通知
  /// </summary>
  ChatMsgNotification,

  /// <summary>
  /// UpgradeVersionNotification|2| 版本更新通知
  /// </summary>
  UpgradeVersionNotification,

  /// <summary>
  /// LogoffNotification|3| 登出通知
  /// </summary>
  LogoffNotification,

  /// <summary>
  /// DisconnectNotification| 4|与服务器断开连接通知
  /// </summary>
  DisconnectNotification,

  /// <summary>
  /// ConnectionNotification| 5|	与服务器已连接通知
  /// </summary>
  ConnectionNotification,

  /// <summary>
  ///FinishNotifyRecordsMessage| 6 | 检查记录完成消息类型
  /// </summary>
  FinishNotifyRecordsMessage,

  /// <summary>
  ///InvitedEnterRoomNotification| 7 | 邀请用户加入房间通知
  /// </summary>
  InvitedEnterRoomNotification,

  /// <summary>
  ///CancelInvitedEnterRoomNotification| 8 |取消邀请用户通知
  /// </summary>
  CancelInvitedEnterRoomNotification,
}

class ConnectionNotification {
  NotificationTypeEnum notificationType;
  ConnectionNotification({
    this.notificationType = NotificationTypeEnum.Daiding,
  });
  factory ConnectionNotification.fromJson(Map<String, dynamic> map) {
    return ConnectionNotification(
      notificationType: NotificationTypeEnum.values
          .firstWhere((e) => e.index == map['NotificationType']),
    );
  }
}

class DisconnectNotification {
  NotificationTypeEnum notificationType;
  DisconnectNotification({
    this.notificationType = NotificationTypeEnum.Daiding,
  });
  factory DisconnectNotification.fromJson(Map<String, dynamic> map) {
    return DisconnectNotification(
      notificationType: NotificationTypeEnum.values
          .firstWhere((e) => e.index == map['NotificationType']),
    );
  }
}

class FinishNotifyRecordsMessage {
  NotificationTypeEnum notificationType;
  List<String>? codes;
  FinishNotifyRecordsMessage(
      {this.notificationType = NotificationTypeEnum.Daiding, this.codes});
  factory FinishNotifyRecordsMessage.fromJson(Map<String, dynamic> map) {
    return FinishNotifyRecordsMessage(
      notificationType: NotificationTypeEnum.values
          .firstWhere((e) => e.index == map['NotificationType']),
      codes: map['Codes'] != null ? map['Codes'].cast<String>().toList() : null,
    );
  }
}