powerage-ristoris-flutter/lib/database/daos/articoli_dao.dart

import 'package:drift/drift.dart';
import '../database.dart';
import '../tables/articoli.dart';
import '../tables/listini.dart';
import '../tables/listini_articolo.dart';
import '../tables/listini_cliente.dart';
import '../views/top_item.dart';

class ArticoliDao {
  final AppDatabase db;
  ArticoliDao(this.db);

  Future<Articolo?> getByCode(String code) {
    return (db.select(
      db.articoli,
    )..where((t) => t.codArticolo.equals(code))).getSingleOrNull();
  }

  Future<List<Articolo>> getItems(String filter) async {
    final words = filter.split(' ').where((w) => w.isNotEmpty).toList();
    final q = db.select(db.articoli)
      ..where(
        (t) =>
            (t.gruppo.isNotNull() & t.gruppo.equals('*').not()) &
            (t.categoria.isNotNull() & t.categoria.equals('PPP').not()) &
            (t.descrizione.isNotNull() &
                t.descrizione.like('%.ANNULLATO%').not()),
      )
      ..orderBy([(t) => OrderingTerm(expression: t.descrizione)])
      ..limit(200);
    for (final word in words) {
      final pattern = '%$word%';
      q.where(
        (t) =>
            t.codArticolo.like(pattern) |
            t.descrizione.like(pattern) |
            t.ean.like(pattern),
      );
    }
    return q.get();
  }

  Future<List<Articolo>> getActiveItems(String filter) async {
    final items = await getItems(filter);
    return items.where((a) => a.attivo == 1).toList();
  }

  Future<List<TopItemData>> getMostSoldItems(int limit) {
    return (db.select(db.topItem)..limit(limit)).get();
  }

  Future<List<Listino>> getListini() {
    return (db.select(db.listini)..where(
          (t) =>
              t.codListino.isNotNull() &
              t.codListino.like('OF2').not() &
              t.codListino.like('OF4').not() &
              t.codListino.like('I0').not(),
        ))
        .get();
  }

  Future<List<ListinoArticolo>> getListinoArticoli(int idListino) {
    return (db.select(db.listiniArticolo)
          ..where((t) => t.idListino.equals(idListino) & (t.attivo.equals(1))))
        .get();
  }

  Future<ListinoArticolo?> getListPrice(
    int idListino,
    int idArticolo,
    String date,
  ) {
    return (db.select(db.listiniArticolo)..where(
          (t) =>
              t.idListino.equals(idListino) &
              t.idArticolo.equals(idArticolo) &
              (t.attivo.equals(1)),
        ))
        .getSingleOrNull();
  }

  Future<ListinoCliente?> getCustomerListPrice(
    int idCliente,
    int idArticolo,
    String date,
  ) {
    return (db.select(db.listiniCliente)
          ..where(
            (t) =>
                t.idCliente.equals(idCliente) &
                t.idArticolo.equals(idArticolo) &
                (t.attivo.equals(1)) &
                (t.annullato.equals('N')),
          )
          ..orderBy([
            (t) =>
                OrderingTerm(expression: t.validoDa, mode: OrderingMode.desc),
          ])
          ..limit(1))
        .getSingleOrNull();
  }

  Future<List<Listino>> getPriceCodes(int idArticolo) {
    return (db.select(db.listini)
          ..join([
            innerJoin(
              db.listiniArticolo,
              db.listiniArticolo.idListino.equalsExp(db.listini.idListino) &
                  db.listiniArticolo.idArticolo.equals(idArticolo),
            ),
          ])
          ..where(
            (t) =>
                t.codListino.isNotNull() &
                t.codListino.like('OF2').not() &
                t.codListino.like('OF4').not() &
                t.codListino.like('I0').not(),
          ))
        .get();
  }

  Future<List<Articolo>> getArticoliPerListinoAttivo(String dataOrdine) async {
    final q =
        db.select(db.articoli).join([
            innerJoin(
              db.listiniArticolo,
              db.listiniArticolo.idArticolo.equalsExp(db.articoli.idArticolo),
            ),
          ])
          ..where(
            db.listiniArticolo.attivo.equals(1) &
                db.listiniArticolo.validoDa.isSmallerOrEqualValue(dataOrdine) &
                db.listiniArticolo.validoA.isBiggerOrEqualValue(dataOrdine) &
                db.articoli.attivo.equals(1) &
                db.articoli.gruppo.isNotNull() &
                db.articoli.gruppo.equals('*').not() &
                db.articoli.categoria.isNotNull() &
                db.articoli.categoria.equals('PPP').not() &
                db.articoli.descrizione.isNotNull() &
                db.articoli.descrizione.like('%.ANNULLATO%').not(),
          )
          ..orderBy([OrderingTerm(expression: db.articoli.descrizione)]);

    final results = await q.get();
    final seen = <int>{};
    final items = <Articolo>[];
    for (final row in results) {
      final art = row.readTable(db.articoli);
      if (seen.add(art.idArticolo)) items.add(art);
    }
    return items;
  }

  Future<List<Articolo>> getArticoliPerListinoCliente(
    int idCliente,
    String dataOrdine,
  ) async {
    final q =
        db.select(db.articoli).join([
            innerJoin(
              db.listiniCliente,
              db.listiniCliente.idArticolo.equalsExp(db.articoli.idArticolo),
            ),
          ])
          ..where(
            db.listiniCliente.idCliente.equals(idCliente) &
                db.listiniCliente.attivo.equals(1) &
                db.listiniCliente.annullato.equals('N') &
                db.listiniCliente.validoDa.isSmallerOrEqualValue(dataOrdine) &
                db.listiniCliente.validoA.isBiggerOrEqualValue(dataOrdine) &
                db.articoli.attivo.equals(1),
          )
          ..orderBy([OrderingTerm(expression: db.articoli.descrizione)]);

    final results = await q.get();
    final seen = <int>{};
    final items = <Articolo>[];
    for (final row in results) {
      final art = row.readTable(db.articoli);
      if (seen.add(art.idArticolo)) items.add(art);
    }
    return items;
  }
}