logic_example.dart

import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:spreadsheet_decoder/spreadsheet_decoder.dart';
import 'package:uk_web/model/models.dart';
import 'package:uk_web/services/database/database_service_parse_server.dart';

class ParseTableWidget extends StatefulWidget {
  final House house;
  ParseTableWidget(this.house);

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

class _ParseTableWidgetState extends State<ParseTableWidget> {
  final _db = DBSParseServer();
  final _fileTEC = TextEditingController();
  bool _isAdding = false;

  @override
  Widget build(BuildContext context) {
    return Row(children: [
      Container(width: 100, child: TextField(controller: _fileTEC, onChanged: (value) => print(value))),
      TextButton(
        style: ElevatedButton.styleFrom(primary: Colors.grey),
        // disabledColor: Colors.red,
        child: _isAdding
            ? CircularProgressIndicator(valueColor: AlwaysStoppedAnimation<Color>(Colors.white))
            : Text('add flat to house'),
        onPressed: () async {
          setState(() => _isAdding = true);

          // get all flats related to this house
          final flatList = await _db.getFlatListForHouse(houseId: widget.house.objectId);

          // get all accounts
          final accountList = await _db.getAccountList();

          // get all owners
          final ownerList = await _db.getOwnerList();

          // parse excel table
          final table = await parseTable();

          // stores items amount to show informative logs in console
          var itemCounter = 1;

          table.forEach((row) async {
            var flat = Flat();

            // check if flat exist in this house
            final isFlatExist = flatList.any((flat) => flat.flatNumber == row.flatNumber);

            if (isFlatExist) {
              flat = flatList.firstWhere((flat) => flat.flatNumber == row.flatNumber);
              print('= flat ${row.flatNumber} is already exist');
            } else {
              print('create flat ${row.flatNumber}');
              flat = await createFlat(
                  flatNumber: row.flatNumber, flatSquare: row.flatSquare, numberOfResidents: row.numberOfResidents);
            }

            var account = Account();

            // check if account is already exist
            final isAccountExist = accountList.any((account) => account.accountNumber == row.accountNumber);

            if (isAccountExist) {
              account = accountList.firstWhere((account) => account.accountNumber == row.accountNumber);
              print('= account ${account.accountNumber} is already exist');
            } else {
              account = await createAccount(accountNumber: row.accountNumber, debt: row.debt);
            }

            var owner = Owner();

            // check if owner already exist by account id
            final isOwnerExist = isAccountExist
                ? account.ownerIdList.any((ownerId) => ownerList.any((owner) => owner.objectId == ownerId))
                : false;

            if (isOwnerExist) {
              owner = ownerList.firstWhere((owner) => owner.accountId == account.objectId);
              print('= owner ${owner.name} is already exist');
            } else {
              owner = await createOwner(ownerName: row.ownerName, flatSquare: row.flatSquare);
            }

            // update objects data from row
            if (isOwnerExist) {
              owner.squareMeters = row.flatSquare;
              if (!owner.phoneNumberList.contains(owner.phoneNumber)) {
                owner.setAdd(Owner.keyPhoneNumberList, owner.phoneNumber);
              }
            } else {
              owner.accountId = account.objectId;
              owner.setAdd(Owner.keyPhoneNumberList, 1);
            }

            if (isAccountExist) {
              print('prev debt: ${account.debt}, new debt: ${row.debt}');
              account.debt = row.debt;
            } else {
              account.setAdd(Account.keyOwnerIdList, owner.objectId);
              account.flatId = flat.objectId;
            }

            if (isFlatExist) {
              flat.numberOfResidents = row.numberOfResidents;
            } else {
              flat.setAdd(Flat.keyAccountIdList, account.objectId);
              widget.house.setAdd(House.keyFlatIdList, flat.objectId);
            }

            // get update results
            final ownerUpdateResult = await owner.update();
            final accountUpdateResult = await account.update();
            final flatUpdateResult = await flat.update();
            final houseUpdateResult = await widget.house.update();

            print(
                '\n${ownerUpdateResult.success ? '+' : '-'} owner ${owner.name} updated: ${ownerUpdateResult.success ? 'true' : ownerUpdateResult.error}\n'
                '${accountUpdateResult.success ? '+' : '-'} account ${account.accountNumber} updated: ${accountUpdateResult.success ? 'true' : accountUpdateResult.error}\n'
                '${flatUpdateResult.success ? '+' : '-'} flat ${flat.flatNumber} updated: ${flatUpdateResult.success ? 'true' : flatUpdateResult.error}\n'
                '${houseUpdateResult.success ? '+' : '-'} house ${widget.house.houseNumber} updated: ${houseUpdateResult.success ? 'true' : houseUpdateResult.error}');

            setState(() => _isAdding = false);
            print('${itemCounter == table.length ? 'end file' : ''}');

            _isAdding = itemCounter == table.length ? false : true;
            itemCounter++;
          });
        },
      )
    ]);
  }

  Future<List<HouseTableData>> parseTable() async {
    // decode *.xlsx file
    ByteData data = await rootBundle.load("files/${_fileTEC.text}.xlsx");
    List<int> bytes = data.buffer.asUint8List(data.offsetInBytes, data.lengthInBytes);
    var decoder = SpreadsheetDecoder.decodeBytes(bytes);

    List<HouseTableData> result = [];

    for (var table in decoder.tables.keys) {
      final tbl = decoder.tables[table];

      for (var i = 9; i < tbl.maxRows - 1; i++) {
        final row = tbl.rows[i];

        // parse data from excel table's cells
        final _accountNumber = '${row[1]}'.contains('№') ? '${row[1]}'.split('№')[1] : '${row[1]}';
        final _flatNumber = '${row[2]}'.split(' ')[1];
        final _ownerName = '${row[3]}';
        final _flatSquare = row[4] as double;
        final _numberOfResidents = row[5] as int;
        final _debt = row[9] as double;

        final dataItem = HouseTableData(
            accountNumber: _accountNumber,
            flatNumber: _flatNumber,
            ownerName: _ownerName,
            flatSquare: _flatSquare,
            numberOfResidents: _numberOfResidents,
            debt: _debt);

        result.add(dataItem);
      }
    }

    return result;
  }

  Future<Owner> createOwner({@required String ownerName, @required double flatSquare}) async {
    Owner owner = Owner();
    owner
      ..name = ownerName
      ..squareMeters = flatSquare
      ..email = 'email@email.com'
      ..phoneNumber = 0
      ..phoneNumberList = [1];

    final result = await owner.save();
    print('new owner, saved: ${result.success ? 'true' : result.error}: $ownerName');

    return result.results.first as Owner;
  }

  Future<Account> createAccount({@required String accountNumber, @required double debt}) async {
    Account account = Account();
    account
      ..accountNumber = accountNumber
      ..debt = debt
      ..purpose = accountNumber.characters.first == '7' ? AccountPurpose.overhaul : AccountPurpose.common;

    final result = await account.save();
    print('new account, saved: ${result.success ? 'true' : result.error}: $accountNumber');

    return result.results.first as Account;
  }

  Future<Flat> createFlat(
      {@required String flatNumber, @required double flatSquare, @required int numberOfResidents}) async {
    Flat flat = Flat();
    flat
      ..houseId = widget.house.objectId
      ..flatNumber = flatNumber
      ..flatSquare = flatSquare
      ..numberOfResidents = numberOfResidents
      ..purpose = FlatPurpose.living;

    flat.setAddAll(Flat.keyCounterIdList, []);

    final result = await flat.save();
    print('new flat, saved: ${result.success ? 'true' : result.error}: $flatNumber');

    return result.results.first as Flat;
  }
}