/home/report/report/utility/table_engine/src/ Current File: //home/report/report/utility/table_engine/src/table_engine.py
import os
from typing import Optional, Iterable

from django.db.models import Q, QuerySet
from django.forms import model_to_dict
from django.http import HttpResponseServerError
from django.db.models import Sum
from utility.file_manager.interfaces import FileManager
from utility.table_engine.src.table_engine_input import TableEngineInput
import xlsxwriter
import csv


class TableEngine:
    input: TableEngineInput
    model: QuerySet
    init_search_cols: Optional[list]

    def __init__(self, model, table_engine_input: dict):
        self.init_search_cols = None
        self.model = model
        self.input = TableEngineInput(table_engine_input)
        self.sum = {}
        pass

    def init_cols(self, cols: list) -> 'TableEngine':
        self.init_search_cols = cols
        return self

    def init_search(self) -> None:
        if self.input.has_search():
            query = Q()
            for key in self.init_search_cols:
                query.add(Q(**{"%s__contains" % key: self.input.search}), Q.OR)
            self.model = self.model.filter(query)

    def hidden(self) -> None:
        pass

    def filter(self) -> None:
        q = self.get_q(self.input.filters)
        self.model = self.model.filter(q)
        if self.input.sum is not None:
            for s in self.input.sum:
                _sum_ = self.model.aggregate(Sum(s))
                self.sum.update(_sum_)

    def get_q(self, filters):
        q = Q()

        for i in filters:
            if i.op != "closure":
                q.add(Q(**{i.lookup: i.value}), Q.AND if str.lower(i.con) == "and" else Q.OR)
            else:
                q.add(self.get_q(i.items), Q.AND if str.lower(i.con) == "and" else Q.OR)
        return q

    def execute(self) -> dict:
        self.init_search()
        self.filter()
        self.sort()

        resultDict = {
            'page': self.input.page,
            'count': self.total()
        }

        data = self.paginate()
        resultDict["sum"] = self.sum
        if self.input.export is None or self.input.export == "json":
            resultDict["rows"] = data,
        elif self.input.export == "xlsx" or self.input.export == "exel":
            resultDict["url"] = TableEngine.generate_xlsx_file_and_get_url(data)
        elif self.input.export == "csv":
            resultDict["url"] = TableEngine.generate_csv_file_and_get_url(data)

        return resultDict

    def paginate(self) -> Iterable:

        q = self.model.values(*[f.name for f in self.model.model._meta.fields] + self.model.model.SELECT)

        return [entry for entry in q[self.input.offset:self.input.offset + self.input.limit]]

    def total(self) -> int:
        return self.model.count()

    def sort(self) -> None:
        if self.input.has_sort():
            self.model = self.model.order_by(self.input.sort)

    @staticmethod
    def generate_xlsx_file_and_get_url(data):
        dirPath = FileManager.get_temp_folder_path()
        fileFullName = dirPath + FileManager.get_hash_name_for_file("report.xlsx")
        workbook = xlsxwriter.Workbook(fileFullName)
        worksheet = workbook.add_worksheet()
        rowNumber = 0
        columns = {}
        for row in data:
            keyCounter = 0
            for key in row.keys():
                if key not in columns:
                    columns[key] = keyCounter
                    worksheet.write(0, keyCounter, key)
                    keyCounter += 1

                worksheet.write(rowNumber + 1, columns[key], str(row[key]))
            rowNumber += 1
        workbook.close()

        return "/temp/" + fileFullName.split("/")[-1]

    @staticmethod
    def generate_csv_file_and_get_url(data):
        dirPath = FileManager.get_temp_folder_path()
        fileFullName = dirPath + FileManager.get_hash_name_for_file("report.csv")
        try:
            with open(fileFullName, 'w', encoding="utf-8") as csvFile:
                keysArray = []
                if len(data) > 0:
                    keysArray = data[0].keys()
                writer = csv.DictWriter(csvFile, fieldnames=keysArray)
                writer.writeheader()
                for row in data:
                    writer.writerow(row)
        except Exception as e:
            print("Error k10g941 :", str(e))
            return None

        return "/temp/" + fileFullName.split("/")[-1]