trytonpsk-farming/crop.py

# This file is part of Tryton.  The COPYRIGHT file at the top level
# of this repository contains the full copyright notices and license terms.

from decimal import Decimal
from datetime import date, datetime, timedelta
import copy

from trytond.model import Workflow, ModelView, ModelSQL, fields
from trytond.pyson import Eval, If, Bool, In, Get
from trytond.transaction import Transaction
from trytond.pool import Pool
from trytond.exceptions import UserError
from trytond.report import Report
from trytond.wizard import Wizard, StateReport, StateView, Button
from trytond.modules.company import CompanyReport

STATES = {
    'readonly': (Eval('state') != 'draft'),
}
MAX_WEEKS = 18


class FarmingStage(ModelSQL, ModelView):
    "Farming Stage"
    __name__ = "farming.stage"
    name = fields.Char('Name', required=True)


class Variety(ModelSQL, ModelView):
    'Variety'
    __name__ = 'farming.variety'
    product = fields.Many2One('product.product', 'Product', required=True)
    production_rate = fields.Float('Production Rate', digits=(16, 2))
    production_uom = fields.Many2One('product.uom', 'UoM')
    standard_cycle = fields.Integer('Standard Cycle', help='In weeks')
    stages = fields.One2Many('farming.variety.stage', 'variety', 'Stages')
    location = fields.Many2One('farming.location', 'Location')
    # cycles = fields.One2Many('farming.variety.cycle', 'variety', 'Cycles')

    def get_rec_name(self, name=None):
        if self.location:
            return self.product.template.name + '\u2014' + self.location.name
        else:
            return self.product.template.name


class VarietyStage(ModelSQL, ModelView):
    "Variety Stage"
    __name__ = "farming.variety.stage"
    variety = fields.Many2One('farming.variety', 'Variety')
    lot = fields.Many2One('farming.location.lot', 'Lot')
    sequence = fields.Integer('Sequence', required=True)
    stage = fields.Many2One('farming.stage', 'Stage', required=True)
    start_time = fields.Integer('Start Time', help='Harvest week',
        required=True)
    production_rate = fields.Float('Production Rate', digits=(3, 2))
    activities = fields.One2Many('farming.variety.stage.activity', 'stage',
        'Activities')


class VarietyStageActivity(ModelSQL, ModelView):
    'Variety Stage Activity'
    # 'farming.variety.activity' => 'farming.variety.stage.activity'
    __name__ = 'farming.variety.stage.activity'
    # variety = fields.Many2One('farming.variety', 'Variety')
    stage = fields.Many2One('farming.variety.stage', 'Stage')
    sequence = fields.Integer('Sequence', required=True)
    kind = fields.Many2One('farming.activity.kind', 'Kind', required=True)
    work_time = fields.Numeric('Work Time', required=True)
    cost_per_hour = fields.Numeric('Cost Per Hour', digits=(16, 2))
    uom = fields.Many2One('product.uom', 'Unit')
    uom_time = fields.Many2One('product.uom', 'Unit of Time',
                               states={'required': True})
    supplies = fields.One2Many('farming.variety.stage.activity.supply',
        'activity', 'Supply')
    time_of_realization = fields.Integer('Time of Realization', required=True,
        help='In weeks')

    @fields.depends('kind', 'uom')
    def on_change_kind(self):
        if self.kind:
            self.uom = self.kind.uom.id


class VarietyStageActivitySupply(ModelSQL, ModelView):
    'Variety Stage Activity Supply'
    __name__ = 'farming.variety.stage.activity.supply'
    # farming.variety.activity.supply => farming.variety.stage.activity.supply
    activity = fields.Many2One('farming.variety.stage.activity', 'Activity')
    product = fields.Many2One("product.product", "Product", required=True)
    quantity = fields.Float('Quantity', required=True)
    unit = fields.Many2One('product.uom', 'Unit', domain=[
            If(Bool(Eval('product_uom_category')),
                ('category', '=', Eval('product_uom_category')),
                ('category', '!=', -1)),
        ], depends=['product_uom_category'])
    product_uom_category = fields.Function(fields.Many2One(
        'product.uom.category', 'Product Uom Category'),
        'on_change_with_product_uom_category')
    unit_price = fields.Numeric('Unit Price', digits=(16, 2))

    @fields.depends('product')
    def on_change_with_unit(self, name=None):
        if self.product:
            unit = self.product.default_uom.id
            return unit

    @fields.depends('product')
    def on_change_with_product_uom_category(self, name=None):
        if self.product:
            return self.product.default_uom_category.id
        else:
            return None


class CropStage(Workflow, ModelSQL, ModelView):
    "Crop Stage"
    __name__ = "farming.crop.stage"
    sequence = fields.Integer('Sequence', required=True)
    crop = fields.Many2One('farming.crop', 'Crop', required=True)
    stage = fields.Many2One('farming.stage', 'Stage', required=True)
    week = fields.Float('Week', required=True)
    effective_date = fields.Date('Effective Date')
    activities = fields.One2Many('farming.crop.stage.activity', 'stage',
        'Activity')
    production_rate = fields.Float('Production Rate', digits=(3, 2))
    quantity_planned = fields.Function(fields.Float('Qty. Planned',
        digits=(6, 2)), 'get_quantity_planned')
    quantity_produced = fields.Float('Qty. Produced', digits=(6, 2))
    total_cost = fields.Function(fields.Numeric(
        'Total Cost', digits=(16, 2)), 'get_total_cost')
    losses = fields.One2Many('farming.crop.stage.loss', 'stage', 'Losses')
    total_losses = fields.Function(fields.Numeric(
        'Total Losses', digits=(16, 2)), 'get_total_losses')
    state = fields.Selection([
            ('pending', 'Pending'),
            ('running', 'Running'),
            ('finished', 'Finished'),
            ('cancelled', 'Cancelled'),
        ], 'State', readonly=True, required=True)

    @classmethod
    def __setup__(cls):
        super(CropStage, cls).__setup__()
        cls._order.insert(0, ('sequence', 'ASC'))
        cls._transitions |= set((
            ('pending', 'running'),
            ('running', 'finished'),
            ('running', 'pending'),
        ))
        cls._buttons.update({
            'pending': {
                'invisible': Eval('state').in_(['pending', 'finished'])
            },
            'running': {
                'invisible': Eval('state').in_(['finished', 'running']),
            },
            'finished': {
                'invisible': Eval('state') != 'running',
            }})

    @classmethod
    @ModelView.button
    @Workflow.transition('pending')
    def pending(cls, records):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('running')
    def running(cls, records):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('finished')
    def finished(cls, records):
        pass

    @staticmethod
    def default_state():
        return 'pending'

    def get_total_losses(self, name=None):
        return sum(lo.quantity for lo in self.losses)

    def get_total_cost(self, name=None):
        return sum(act.total_cost or 0 for act in self.activities)

    def get_quantity_planned(self, name=None):
        res = 0
        if self.production_rate and self.crop.quantity_planned:
            res = (self.production_rate / 100) * self.crop.quantity_planned
        return round(res, 2)


class CropStageLoss(Workflow, ModelSQL, ModelView):
    'Crop Stage Loss'
    __name__ = 'farming.crop.stage.loss'
    stage = fields.Many2One('farming.crop.stage', 'Stage', ondelete='CASCADE')
    date = fields.Date('Date', required=True)
    quantity = fields.Integer('Quantity', required=True)
    reason = fields.Text('Reason', required=True)


class Kind(ModelSQL, ModelView):
    "Activity Kind"
    __name__ = "farming.activity.kind"
    name = fields.Char('Name', required=True)
    activity_time = fields.Float('Act. Time', required=True)
    uom = fields.Many2One('product.uom', 'Unit', required=True,
        help="Unit of time, according to activity time")


class Crop(Workflow, ModelSQL, ModelView):
    'Farming Crop'
    __name__ = 'farming.crop'
    _rec_name = 'number'
    number = fields.Char('Number', readonly=True)
    variety = fields.Many2One('farming.variety', 'Variety', required=True,
        states=STATES)
    location = fields.Many2One('farming.location', 'Location', required=True,
        states=STATES)
    company = fields.Many2One('company.company', 'Company', required=True,
            states=STATES, domain=[('id', If(In('company',
            Eval('context', {})), '=', '!='), Get(Eval('context', {}),
            'company', 0)), ])
    start_date = fields.Date('Start Date', states=STATES, depends=['state'])
    end_date = fields.Date('End Date', states=STATES, depends=['state'])
    field_size = fields.Float('Field Size', states=STATES, select=True,
        help='In hectares')
    total_plants = fields.Integer('Total Plants')
    quantity_planned = fields.Function(fields.Float('Quantity Planned'),
        'get_quantity_planned')
    quantity_planned_net = fields.Function(fields.Float('Net. Quantity Planned'),
        'get_quantity_planned_net')
    quantity_produced = fields.Float('Quantity Produced', states=STATES)
    production_uom = fields.Many2One('product.uom', 'Production UoM', states=STATES)
    lots = fields.One2Many('farming.crop.lot', 'crop', 'Lots', states=STATES)
    stages = fields.One2Many('farming.crop.stage', 'crop', 'Stages',
        states=STATES)
    seed = fields.Many2One('farming.seed', 'Seed', required=True)
    analytic_account = fields.Many2One('analytic_account.account', 'Analytic Account')
    production_rate = fields.Float('Production Rate')
    notes = fields.Text('Notes', states=STATES)
    state = fields.Selection([
            ('draft', 'Draft'),
            ('production', 'Production'),
            ('finished', 'Finished'),
            ('cancelled', 'Cancelled'),
        ], 'State', readonly=True, required=True)
    # moves for supplies
    # supplies = fields.One2Many('farming.crop.stage.activity.supply',
    #     'crop', 'Supply')
    # Financial indicators
    production_time = fields.Function(fields.Integer('Production Time'),
        'get_production_time')
    production_cost = fields.Function(fields.Numeric('Production Cost'),
        'get_production_cost')
    performance = fields.Function(fields.Float('Performance', digits=(4, 2)),
        'get_performance')
    gross_profit_rate = fields.Function(fields.Float('Gross Profit Rate'),
        'get_gross_profit_rate')
    gross_profit = fields.Function(fields.Numeric('Gross Profit'),
        'get_gross_profit')
    # Deprecation warning: activities was moved to farming.crop.stage
    # activities = fields.One2Many('farming.crop.activity', 'crop', 'Activities')
    total_cost = fields.Function(fields.Numeric(
        'Total Cost', digits=(16, 2)), 'get_total_cost')
    total_losses = fields.Function(fields.Numeric(
        'Total Losses', digits=(16, 2)), 'get_total_losses')

    @classmethod
    def __setup__(cls):
        super(Crop, cls).__setup__()
        cls._order.insert(0, ('create_date', 'DESC'))
        cls._order.insert(1, ('id', 'DESC'))
        cls._transitions |= set((
            ('draft', 'production'),
            ('production', 'draft'),
            ('production', 'finished'),
            ('production', 'cancelled'),
        ))
        cls._buttons.update({
            'draft': {
                'invisible': Eval('state').in_(['draft', 'finished'])
                },
            'cancel': {
                'invisible': Eval('state') == 'finished',
                },
            'load_stages': {
                'invisible': Eval('lines', []) | (Eval('state') != 'draft'),
                'depends': ['state'],
            },
            'load_lots': {
                'invisible': Eval('lines', []) | (Eval('state') != 'draft'),
                'depends': ['state'],
            },
            'production': {
                'invisible': Eval('state').in_(['cancelled', 'finished']),
                },
            'finished': {
                'invisible': Eval('state') != 'production',
                },
            })

    @staticmethod
    def default_start_date():
        return date.today()

    @staticmethod
    def default_company():
        return Transaction().context.get('company') or False

    @staticmethod
    def default_state():
        return 'draft'

    @classmethod
    @ModelView.button
    @Workflow.transition('finished')
    def finished(cls, records):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('cancelled')
    def cancel(cls, services):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('draft')
    def draft(cls, records):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('production')
    def production(cls, records):
        for record in records:
            record.set_number()

    def get_total_cost(self, name=None):
        return sum(act.total_cost or 0 for act in self.stages)

    def get_total_losses(self, name=None):
        return sum(st.total_losses for st in self.stages)

    @classmethod
    def clear_bed_lines(cls, crops):
        Line = Pool().get('farming.crop.lot.bed')
        lines_to_delete = []
        for crop in crops:
            for lot in crop.lots:
                for bed in lot.beds:
                    lines_to_delete.append(bed)
        Line.delete(lines_to_delete)

    @classmethod
    def create_beds_lines(cls, crops):
        Line = Pool().get('farming.crop.lot.bed')
        lines = []
        for crop in crops:
            for lot in crop.lots:
                for bed in lot.lot.beds:
                    line = Line(
                        lot=lot.id,
                        bed=bed.id,
                        quantity_plants=bed.quantity,
                    )
                    lines.append(line)
        Line.save(lines)

    @classmethod
    def create_lots_lines(cls, crops):
        Line = Pool().get('farming.crop.lot')
        Lot = Pool().get('farming.location.lot')
        lines = []
        cls.clear_bed_lines(crops)
        cls.clear_lots_lines(crops)
        for crop in crops:
            lots = Lot.search([('location', '=', crop.location)])
            for lot in lots:
                line = Line(
                    crop=crop.id,
                    lot=lot.id,
                    cycle=0,
                    beds=[],
                    activities=[],
                    total_plants=lot.quantity
                )
                lines.append(line)

        Line.save(lines)
        cls.create_beds_lines(crops)

    @classmethod
    def clear_lots_lines(cls, crops):
        Line = Pool().get('farming.crop.lot')
        lines_to_delete = []
        for crop in crops:
            for lot in crop.lots:
                lines_to_delete.append(lot)
        Line.delete(lines_to_delete)

    def _create_supplies(self, activity, crop_activity):
        Supply = Pool().get('farming.crop.stage.activity.supply')
        res = []
        for sup in activity.supplies:
            unit_price = sup.unit_price
            if not unit_price:
                unit_price = sup.product.cost_price
            qty = sup.quantity * self.total_plants
            amount = round(qty * float(unit_price), 2)
            supply = Supply(
                activity=crop_activity.id,
                product=sup.product.id,
                unit=sup.unit.id,
                unit_price=unit_price,
                quantity=qty,
                cost_planned=amount,
                cost_real=amount
            )
            res.append(supply)
        return res

    def _create_activities(self, stage, crop_stage):
        Activity = Pool().get('farming.crop.stage.activity')
        res = []
        crop = crop_stage.crop
        for act in stage.activities:
            _date = crop.start_date + timedelta(weeks=act.time_of_realization)
            work_time = act.work_time * crop.total_plants
            # if act.uom_time.symbol == 'min':
            #     _cost = round((act.cost_per_hour / 60) * work_time, 2)
            # elif act.uom_time.symbol == 'h':
            #     _cost = round(act.cost_per_hour * work_time, 2)
            # elif act.uom_time.symbol == 's':
            #     _cost = round((act.cost_per_hour / 3600) * work_time, 2)
            # else:
            #     _cost = round(act.cost_per_hour * work_time, 2)

            activity = Activity(
                stage=crop_stage.id,
                sequence=act.sequence,
                kind=act.kind.id,
                work_time=work_time,
                uom_time=act.uom_time.id,
                week=act.time_of_realization,
                planned_date=_date,
                effective_date=_date,
            )
            supplies = self._create_supplies(act, activity)
            activity.supplies = supplies
            res.append(activity)
        return res

    def create_stages(self):
        CropStage = Pool().get('farming.crop.stage')
        to_save = []
        for stage in self.variety.stages:
            effec_date = self.start_date + timedelta(weeks=stage.start_time)
            _stage = CropStage(
                sequence=stage.sequence,
                crop=self.id,
                stage=stage.stage.id,
                production_rate=stage.production_rate,
                week=stage.start_time,
                effective_date=effec_date,
            )
            _stage.activities = self._create_activities(stage, _stage)
            to_save.append(_stage)
        CropStage.save(to_save)

    @classmethod
    def clear_stages_lines(cls, crops):
        Line = Pool().get('farming.crop.stage')
        to_delete = []
        for crop in crops:
            for stage in crop.stages:
                to_delete.append(stage)
        Line.delete(to_delete)

    # @classmethod
    # def clear_activities_lines(cls, crops):
    #     Line = Pool().get('farming.crop.stage.activity')
    #     lines_to_delete = []
    #     for crop in crops:
    #         for activity in crop.activities:
    #             lines_to_delete.append(activity)
    #     Line.delete(lines_to_delete)

    # @classmethod
    # def create_activities_lines(cls, crops):
    #     Line = Pool().get('farming.crop.activity')
    #     lines = []
    #     for crop in crops:
    #         for act in crop.variety.activities:
    #             _date = crop.start_date + timedelta(
    #                 weeks=act.time_of_realization)
    #             work_time = act.work_time * crop.total_plants
    #             if act.uom_time.symbol == 'min':
    #                 _cost = round((act.cost_per_hour / 60) * work_time, 2)
    #             elif act.uom_time.symbol == 'h':
    #                 _cost = round(act.cost_per_hour * work_time, 2)
    #             elif act.uom_time.symbol == 's':
    #                 _cost = round((act.cost_per_hour / 3600) * work_time, 2)
    #             else:
    #                 _cost = round(act.cost_per_hour * work_time, 2)
    #
    #             line = Line(
    #                 crop=crop.id,
    #                 sequence=act.sequence,
    #                 kind=act.kind.id,
    #                 work_time=work_time,
    #                 workforce_cost=_cost,
    #                 uom=act.uom.id,
    #                 uom_time=act.uom_time.id,
    #                 week=act.time_of_realization,
    #                 planned_date=_date,
    #                 effective_date=_date,
    #             )
    #             lines.append(line)
    #     Line.save(lines)
    #     cls.create_activity_supplies_lines(crops)

    @classmethod
    def create_activity_supplies_lines(cls, crops):
        Line = Pool().get('farming.crop.stage.activity.supply')
        lines = []
        for crop in crops:
            for act_crop, act_variety in zip(
                crop.activities, crop.variety.activities):
                for supply in act_variety.supplies:
                    line = Line(
                        activity=act_crop.id,
                        product=supply.product.id,
                        unit=supply.unit,
                        quantity=supply.quantity * crop.total_plants,
                        cost_planned=supply.product.cost_price,
                        cost_real=supply.product.cost_price
                    )
                    lines.append(line)
        Line.save(lines)

    @classmethod
    def clear_supplies_lines(cls, crops):
        Line = Pool().get('farming.crop.lot.bed')
        lines_to_delete = []
        for crop in crops:
            for stage in crop.stages:
                for activity in stage.activities:
                    for supply in activity.supplies:
                        lines_to_delete.append(supply)
        Line.delete(lines_to_delete)

    @classmethod
    def get_total_plants(cls, crops):
        Line = Pool().get('farming.crop')
        lines = []
        for crop in crops:
            quantity = 0
            for lot in crop.lots:
                quantity += lot.total_plants
            crop.total_plants = quantity
            lines.append(crop)
        Line.save(lines)

    @classmethod
    @ModelView.button
    def load_stages(cls, crops):
        cls.clear_stages_lines(crops)
        for crop in crops:
            crop.create_stages()
        # cls.clear_stages_lines(crops)
        # cls.clear_supplies_lines(crops)
        # cls.clear_activities_lines(crops)
        # cls.create_activities_lines(crops)

    @classmethod
    @ModelView.button
    def load_lots(cls, crops):
        cls.create_lots_lines(crops)
        cls.get_total_plants(crops)

    @classmethod
    def supplies_shipment(cls, records):
        pool = Pool()
        SupplyMoves = pool.get('crop.supply.moves')
        supplyMoves = []
        for record in records:
            for activity in record.activities:
                for supply in activity.supplies:
                    supplyMove = SupplyMoves(
                        crop=record.id,
                        product=supply.product,
                        unit=supply.unit,
                        quantity=supply.quantity,
                    )
                    supplyMoves.append(supplyMove)
            SupplyMoves.save(supplyMoves)

    def set_number(self):
        Config = Pool().get('farming.configuration')
        config = Config.get_config()
        if not config.farming_production_sequence:
            raise UserError('missing_sequence_farming_production')

        number = config.farming_production_sequence.get()
        self.write([self], {'number': number})

    def get_quantity_planned_net(self, name=None):
        return self.quantity_planned - (
            self.total_losses * self.production_rate)

    def get_quantity_planned(self, name=None):
        res = []
        _append = res.append
        for lot in self.lots:
            if self.production_rate and lot.total_plants:
                _append(self.production_rate * lot.total_plants)
        return round(sum(res), 2)

    def get_production_time(self, name=None):
        res = None
        if self.start_date:
            today = date.today()
            if self.end_date:
                res = (self.end_date - self.start_date).days
            else:
                res = (today - self.start_date).days
        return res

    def get_production_cost(self, name):
        res = 0
        return res

    def get_performance(self, name):
        res = 0
        if self.quantity_produced and self.quantity_planned_net:
            res = (self.quantity_produced / self.quantity_planned_net) * 100
        return res

    def get_gross_profit_rate(self, name):
        res = 0
        return res

    def get_gross_profit(self, name):
        res = 0
        return res

    @fields.depends('stages')
    def on_change_stages(self):
        if self.stages:
            res = []
            for stage in self.stages:
                res.append(stage.quantity_produced or 0)
            self.quantity_produced = sum(res)

    @fields.depends('variety', 'production_uom', 'production_rate')
    def on_change_variety(self):
        if self.variety and self.variety.production_uom:
            self.production_uom = self.variety.production_uom.id
            self.production_rate = self.variety.production_rate
            if self.variety.standard_cycle:
                self.end_date = date.today() + timedelta(
                    weeks=self.variety.standard_cycle)

    @fields.depends('start_date', 'variety')
    def on_change_start_date(self):
        if self.variety:
            self.end_date = self.start_date + timedelta(
                weeks=self.variety.standard_cycle)

    @fields.depends('lots')
    def on_change_with_total_plants(self, name=None):
        quantity = 0
        for lot in self.lots:
            if lot.total_plants:
                quantity += lot.total_plants
        return quantity


class SupplyMoves(ModelSQL, ModelView):
    'Supply moves'
    __name__ = 'crop.supply.moves'
    crop = fields.Many2One('farming.crop', 'Crop', ondelete='CASCADE',
        required=True)
    product = fields.Many2One("product.product", "Product", required=True,
        select=True)
    unit = fields.Many2One('product.uom', 'Unit')
    quantity = fields.Float('Quantity', required=True)
    origin = fields.Reference('Origin', selection='get_origin', select=True)

    @classmethod
    def _get_origin(cls):
        'Return list of Model names for origin Reference'
        return ['stock.move']

    @classmethod
    def get_origin(cls):
        Model = Pool().get('ir.model')
        get_name = Model.get_name
        models = cls._get_origin()
        return [(None, '')] + [(m, get_name(m)) for m in models]


class FarmingCropLot(ModelSQL, ModelView):
    'Farming Crop Lot'
    __name__ = 'farming.crop.lot'
    crop = fields.Many2One('farming.crop', 'Crop', ondelete='CASCADE',
        required=True)
    lot = fields.Many2One('farming.location.lot', 'Lot', required=True)
    cycle = fields.Float('Cycle', digits=(16, 2), help="In weeks")
    beds = fields.One2Many('farming.crop.lot.bed', 'lot', 'Beds')
    activities = fields.One2Many('farming.activity', 'lot', 'Activities')
    analytic_account = fields.Many2One('analytic_account.account',
        'Analytic Account')
    total_plants = fields.Integer('Total Plants', states={
        'readonly': Bool(Eval('beds'))}, depends=['beds'])

    @fields.depends('beds')
    def on_change_with_total_plants(self, name=None):
        quantity = 0
        if self.beds:
            for bed in self.beds:
                if bed.quantity_plants:
                    quantity += bed.quantity_plants
        return quantity


class FarmingCropLotBed(ModelSQL, ModelView):
    'Crop Lot Bed'
    __name__ = 'farming.crop.lot.bed'
    lot = fields.Many2One('farming.crop.lot', 'Lot', ondelete='CASCADE',
        required=True)
    bed = fields.Many2One('farming.location.lot.bed', 'Bed',
        ondelete='CASCADE', required=True)
    quantity_plants = fields.Integer('Quantity Plants')


class CropStageActivity(Workflow, ModelSQL, ModelView):
    'Crop Stage Activity'
    #  farming.crop.activity => farming.crop.stage.activity
    __name__ = 'farming.crop.stage.activity'
    # crop = fields.Many2One('farming.crop', 'Crop', ondelete='CASCADE')
    stage = fields.Many2One('farming.crop.stage', 'Stage', ondelete='CASCADE')
    sequence = fields.Char('Sequence', states=STATES)
    kind = fields.Many2One('farming.activity.kind', 'Kind')
    work_time = fields.Numeric('Work Time')
    # uom = fields.Many2One('product.uom', 'Unit')
    uom_time = fields.Many2One('product.uom', 'UoM of Time')
    supplies = fields.One2Many('farming.crop.stage.activity.supply',
        'activity', 'Supply')
    week = fields.Integer('Week')
    planned_date = fields.Date('Planned Date')
    effective_date = fields.Date('Effective Date')
    state = fields.Selection([
            ('draft', 'Draft'),
            ('production', 'Production'),
            ('finished', 'Finished'),
            ('cancelled', 'Cancelled'),
        ], 'State', readonly=True, required=True)
    workforce_cost = fields.Function(fields.Numeric(
        'Workforce Cost', digits=(16, 2)), 'get_cost')
    materials_cost = fields.Function(fields.Numeric(
        'Materials Cost', digits=(16, 2)), 'get_cost')
    indirect_cost = fields.Function(fields.Numeric(
        'Indirect Cost', digits=(16, 2)), 'get_cost')
    total_cost = fields.Function(fields.Numeric(
        'Total Cost', digits=(16, 2)), 'get_cost')

    @classmethod
    def generate_shipment(cls, records):
        pool = Pool()
        company = Transaction().context.get('company')
        Supply = pool.get('farming.crop.stage.activity.supply')
        supplies = []
        for record in records:
            location = record.crop.location.warehouse
            for supplyRec in record.supplies:
                supply = Supply(
                    crop=record.crop,
                    product=supplyRec.product,
                    unit=supplyRec.unit,
                    quantity=supplyRec.quantity,
                )
                # move = record._move(
                #     record,
                #     location.output_location,
                #     location.production_location,
                #     company,
                #     supplyRec.product,
                #     supplyRec.unit,
                #     supplyRec.quantity)
                supplies.append(supply)
        Supply.save(supplies)

    @classmethod
    @ModelView.button
    def generate_shipment_button(cls, records):
        pass

    def _move(self, activity, from_location, to_location, company, product,
            uom, quantity):
        Move = Pool().get('stock.move')
        move = Move(
            product=product,
            uom=uom,
            quantity=quantity,
            from_location=from_location,
            to_location=to_location,
            company=company,
            origin=str(activity),
            state='draft'
            )
        Move.save([move])
        return move

    def get_cost(self, name=None):
        res = []
        for supply in self.supplies:
            _name, _name_cost = name.split('_')
            print(name, _name, _name_cost)
            if supply.product.template.cost_type == _name or _name == 'total':
                res.append(supply.cost_planned)
        return sum(res)

    @classmethod
    def create_supply_moves(cls, location):
        # pool = Pool()
        # Move = pool.get('stock.move')
        # Location = pool.get('stock.location')
        # Date = pool.get('ir.date')
        # Shipment = pool.get('stock.shipment.internal')
        # moves = []
        # for supply in activity.supplies:
        #     print(supply.unit, 'esto no es correcto')
        #     move = Move(
        #             quantity = supply.quantity,
        #             uom = supply.unit.id,
        #             product = supply.product.id,
        #             from_location =
        #             to_location =
        #             state = 'draft',
        #             company = Transaction().context.get('company'),
        #             unit_price = supply.product.cost_price,
        #             planned_date = Date.today(),
        #             #origin = ['production']
        #     )
        #     moves.append(move)
        # shipment.moves = moves
        # Shipment.save([shipment])
        # #Move.save(moves)
        # #BUG(ERROR: SHIPMENT INTERRUPTS STATUS, NOT GENERATED)
        pass

    @classmethod
    def __setup__(cls):
        super(CropStageActivity, cls).__setup__()
        cls._order.insert(0, ('planned_date', 'ASC'))
        cls._transitions |= set((
            ('draft', 'production'),
            ('production', 'draft'),
            ('production', 'finished'),
            ('production', 'cancelled'),
            ('finished', 'production'),  # only developings
        ))
        cls._buttons.update({
            'draft': {
                'invisible': Eval('state').in_(['draft', 'finished'])
                },
            'cancel': {
                'invisible': Eval('state') == 'finished',
                },
            'load_configuration': {
                'invisible': Eval('lines', []) | (Eval('state') != 'draft'),
                'depends': ['state'],
            },
            'production': {},
            'finished': {
                'invisible': Eval('state') != 'production',
                },
            })

    @staticmethod
    def default_state():
        return 'draft'

    @classmethod
    @ModelView.button
    @Workflow.transition('finished')
    def finished(cls, records):
        pool = Pool()
        AccountMove = pool.get('account.move')
        Journal = pool.get('account.journal')
        journal = Journal.search([('type', '=', 'expense')])
        for record in records:
            account_move = {
                'company': Transaction().context.get('company'),
                'journal': journal[0].id,
                'date': date.today(),
                'origin': str(record.crop),
                'lines': None,
            }
            account_move_lines = []
            for supply in record.supplies:
                product = supply.product
                account = product.account_category
                product_name = product.name
                lineC = {
                    'debit': Decimal(0),
                    'credit': product.cost_price,
                    'account': account.account_stock.id,
                    'description': product_name,
                }
                lineD = {
                    'debit': product.cost_price,
                    'credit': Decimal(0),
                    'account': account.account_expense.id,
                    'description': product_name,
                    'analytic_lines': [('create', [{
                        'debit': product.cost_price,
                        'credit': Decimal(0),
                        'account': supply.analytic_account,
                        'date': date.today()
                    }])]
                }
                account_move_lines.append(lineC)
                account_move_lines.append(lineD)
            account_move['lines'] = [('create', account_move_lines)]
            AccountMove.create([account_move])

    @classmethod
    @ModelView.button
    @Workflow.transition('cancelled')
    def cancel(cls, services):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('draft')
    def draft(cls, records):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('production')
    def production(cls, records):
        for record in records:
            #cls.create_shipment(record)
            cls.generate_shipment([record])
            record.set_number()

    def set_number(self):
        #Config = Pool().get('farming.configuration')
        #config = Config.get_config()
        #if not config.farming_production_sequence:
        #    raise UserError('missing_sequence_farming_production')
        pass


class CropStageActivitySupply(ModelSQL, ModelView):
    'Crop Stage Activity Supply'
    #  farming.crop.activity.supply => farming.crop.stage.activity.supply
    __name__ = 'farming.crop.stage.activity.supply'
    # crop = fields.Many2One('farming.crop', 'Crop')
    activity = fields.Many2One('farming.crop.stage.activity', 'Activity',
        states={"invisible": False})
    product = fields.Many2One("product.product", "Product", required=True,
        select=True)
    unit = fields.Many2One('product.uom', 'Unit')
    quantity = fields.Float('Quantity', required=True)
    unit_price = fields.Numeric('Unit Price')
    analytic_account = fields.Many2One('analytic_account.account',
        'Analytic Account')
    cost_planned = fields.Numeric('Cost Planned', readonly=True)
    cost_real = fields.Numeric('Cost Real')

    # def get_unit(self, name=None):
    #     unit = self.product.default_uom.name
    #     return unit


class Activity(Workflow, ModelSQL, ModelView):
    'Activity'
    __name__ = 'farming.activity'
    _rec_name = 'kind'
    sequence = fields.Char('Sequence', states=STATES)
    lot = fields.Many2One('farming.crop.lot', 'Lot', required=True,
        states=STATES)
    employee = fields.Many2One('party.party', 'Employee', states=STATES)
    planned_date = fields.Date('Planned Date', states=STATES, required=True)
    start_date = fields.Date('Start Date', states=STATES, required=True)
    end_date = fields.Date('End Date', states=STATES)
    kind = fields.Many2One('farming.activity.kind', 'Kind', states=STATES)
    notes = fields.Text('Notes', states=STATES)
    days = fields.Function(fields.Integer('Days', states=STATES), 'get_days')
    shipments = fields.Many2Many('farming.activity-shipment.internal',
        'activity', 'shipment', 'Shipments', states=STATES)
    state = fields.Selection([
            ('draft', 'Draft'),
            ('execution', 'Execution'),
            ('done', 'Done'),
            ('cancelled', 'Cancelled'),
        ], 'State', readonly=True, required=True)
    amount = fields.Function(fields.Numeric('Amount', digits=(16, 2)),
        'get_amount')

    @classmethod
    def __setup__(cls):
        super(Activity, cls).__setup__()
        cls._order.insert(0, ('planned_date', 'DESC'))
        cls._order.insert(1, ('id', 'DESC'))
        cls._transitions |= set((
            ('draft', 'execution'),
            ('execution', 'done'),
            ('execution', 'draft'),
            ('execution', 'cancelled'),
            ('cancelled', 'draft'),
        ))
        cls._buttons.update({
            'draft': {
                'invisible': Eval('state').in_(['draft', 'done']),
                },
            'cancel': {
                'invisible': Eval('state').in_(['cancelled', 'done']),
                },
            'execution': {
                'invisible': Eval('state') != 'draft',
                },
            'done': {
                'invisible': Eval('state') != 'execution',
                },
            })

    @staticmethod
    def default_company():
        return Transaction().context.get('company') or False

    @staticmethod
    def default_state():
        return 'draft'

    @classmethod
    @ModelView.button
    @Workflow.transition('done')
    def done(cls, records):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('execution')
    def execution(cls, records):
        for record in records:
            record.set_number()

    @classmethod
    @ModelView.button
    @Workflow.transition('cancelled')
    def cancel(cls, records):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('draft')
    def draft(cls, records):
        pass

    def get_amount(self, name):
        res = 0
        for shipment in self.shipments:
            for m in shipment.outgoing_moves:
                res += m.product.template.cost_price * Decimal(m.quantity)
        for w in self.works:
            res += w.unit_price * Decimal(w.quantity)
        return res

    def get_days(self, name):
        res = 0
        if self.start_date and self.end_date:
            res = (self.end_date - self.start_date).days
        return res


class CropForecastStart(ModelView):
    'Crop Forecast Start'
    __name__ = 'farming.crop_forecast.start'
    company = fields.Many2One('company.company', 'Company', required=True)
    start_date = fields.Date("Start Date", required=True)
    end_date = fields.Date("End Date", required=True)

    @staticmethod
    def default_company():
        return Transaction().context.get('company')


class CropForecast(Wizard):
    'Crop Forecast'
    __name__ = 'farming.crop_forecast'
    start = StateView(
        'farming.crop_forecast.start',
        'farming.farming_crop_forecast_start_view_form', [
            Button('Cancel', 'end', 'tryton-cancel'),
            Button('Print', 'print_', 'tryton-ok', default=True),
        ])
    print_ = StateReport('farming.crop_forecast.report')

    def do_print_(self, action):
        data = {
            'company': self.start.company.id,
            'start_date': self.start.start_date,
        }
        return action, data

    def transition_print_(self):
        return 'end'


class CropForecastReport(Report):
    'Crop Forecast Report'
    __name__ = 'farming.crop_forecast.report'

    @classmethod
    def get_context(cls, records, header, data):
        report_context = super().get_context(records, header, data)
        pool = Pool()
        Crop = pool.get('farming.crop')
        Company = pool.get('company.company')

        recs = {}
        week_range = []
        for nd in range(MAX_WEEKS):
            week_n = 'day' + str((nd + 1))
            first_date = data['start_date'] + timedelta(nd * 7)
            last_date = first_date + timedelta(6)
            data[week_n] = first_date.strftime("%d %b")
            data['total_' + week_n] = 0
            data['week' + str(nd + 1)] = first_date.strftime("%W")
            recs[week_n] = ''
            recs[first_date] = {
                'week': week_n
            }
            week_range.append((first_date, last_date))

        crops = Crop.search([
            ('start_date', '<=', data['start_date']),
            ('end_date', '>=', data['start_date']),
        ])
        records = {}

        for crop in crops:
            records[crop] = []
            start_date = crop.start_date
            recs_days = copy.deepcopy(recs)
            for stage in crop.stages:
                prod_date = start_date + timedelta(days=stage.week * 7)
                for (start_day, end_day) in week_range:
                    if prod_date >= start_day and prod_date < end_day:
                        week_n = recs_days[start_day]['week']
                        recs_days[week_n] = int(stage.quantity_planned)
                        data['total_' + week_n] += int(stage.quantity_planned)

            records[crop] = recs_days

        report_context['records'] = records.items()
        company_id = Transaction().context.get('company')
        report_context['company'] = Company(company_id)
        return report_context


class FarmingActivityShipmentInternal(ModelSQL):
    'Farming Activity - Shipment Internal'
    __name__ = 'farming.activity-shipment.internal'
    _table = 'farming_activity_shipment_internal_rel'
    activity = fields.Many2One('farming.activity', 'Activity',
            ondelete='CASCADE', select=True, required=True)
    shipment = fields.Many2One('stock.shipment.internal', 'Tax',
        ondelete='RESTRICT', required=True)


class ActivityTask(ModelView, ModelSQL):
    "Execute Activity"
    __name__ = 'crop.activity.task'
    STATES = {
        'readonly': Eval('state') == 'finished',
    }
    effective_date = fields.Date('Effective Date ', states=STATES,
        required=True)
    employee = fields.Many2One('company.employee', 'Employee', states=STATES)
    quantity = fields.Float('Quantity', states=STATES, required=True)
    start_time = fields.DateTime('Start Time')
    production = fields.Many2One('production', 'Production', states=STATES)
    state = fields.Selection([
            ('draft', 'Draft'),
            ('processing', 'Processing'),
            ('finished', 'Finished'),
            ], 'State', select=True)

    @staticmethod
    def default_state():
        return 'draft'


class CropActivitiesStart(ModelView):
    'Crop Activities Start'
    __name__ = 'farming.crop_activities.start'
    company = fields.Many2One('company.company', 'Company', required=True)
    crop = fields.Many2One('farming.crop', 'Crop')
    start_date = fields.Date("Start Date")
    location = fields.Many2One('farming.location', 'Location')

    @staticmethod
    def default_company():
        return Transaction().context.get('company')

    def default_start_date():
        return datetime.today()


class CropActivitiesWizard(Wizard):
    'Crop Activities'
    __name__ = 'farming.crop_activities'
    start = StateView(
        'farming.crop_activities.start',
        'farming.farming_crop_activities_start_view_form', [
            Button('Cancel', 'end', 'tryton-cancel'),
            Button('Print', 'print_', 'tryton-ok', default=True),
        ])
    print_ = StateReport('farming.crop_activities.report')

    def do_print_(self, action):
        location_id = None
        if self.start.location:
            location_id = self.start.location.id
        data = {
            'company': self.start.company.id,
            'start_date': self.start.start_date,
            'location': location_id,
        }
        return action, data

    def transition_print_(self):
        return 'end'


class CropActivitiesReport(Report):
    'Crop Activities Report'
    __name__ = 'farming.crop_activities.report'

    @classmethod
    def get_context(cls, records, header, data):
        report_context = super().get_context(records, header, data)
        RANGE_WEEKS = 17
        pool = Pool()
        Company = pool.get('company.company')
        Crop = pool.get('farming.crop')
        date_start = data['start_date']
        date_end = data['start_date'] + timedelta(days=(7*17))
        dom = [
            ('activities.planned_date', '>=', date_start),
            ('activities.planned_date', '<=', date_end),
        ]

        if data['location']:
            dom.append(('location', '=', data['location']))

        days = {}
        matrix_dates = []
        _date = date_start
        for nd in range(1, RANGE_WEEKS):
            sday = str(nd)
            nday = 'day' + sday
            days[nday] = ''
            days['activity' + sday] = ''
            data['week' + sday] = _date.strftime("%W")
            data[nday] = _date.strftime("%d %b")
            data['total_' + nday] = 0
            last_date = _date + timedelta(days=1)
            _date = _date + timedelta(days=7)
            matrix_dates.append((last_date, _date, sday))

        records = []
        crops = Crop.search(dom)
        for crop in crops:
            lots_beds = []
            for lot in crop.lots:
                beds = '-'.join(bed.bed.number for bed in lot.beds)
                lots_beds.append((lot.lot.number, beds))

            # lots_beds = f'{lot.lot.number} ({beds})'
            record = {
                'number': crop.number,
                'variety': crop.variety.product.name,
                'location': crop.location.name,
                'plants': crop.total_plants,
                'lots': lots_beds,
                'activities': [],
            }
            variety_acts = {
                act.kind.id: act.time_of_realization
                for act in crop.variety.activities
            }
            add_line = True
            _days = copy.deepcopy(days)
            for activity in crop.activities:
                for start, end, sday in matrix_dates:
                    pdate = activity.planned_date
                    if pdate >= start and pdate <= end:
                        nday = 'day' + sday
                        if _days[nday] != '':
                            _days = copy.deepcopy(days)
                            record['activities'].append(_days)
                        elif add_line:
                            record['activities'].append(_days)
                            add_line = False
                        tr = variety_acts[activity.kind.id]
                        _days['activity' + sday] = f'{activity.kind.name}({tr})'
                        _days[nday] = activity.work_time
                        data['total_' + nday] += activity.work_time
            records.append(record)

        report_context['records'] = records
        report_context['company'] = Company(data['company'])
        return report_context


class CropSuppliesStart(ModelView):
    'Crop Activities Start'
    __name__ = 'farming.crop_supplies.start'
    company = fields.Many2One('company.company', 'Company', required=True)
    crop = fields.Many2One('farming.crop', 'Crop')
    start_date = fields.Date("Start Date")
    location = fields.Many2One('farming.location', 'Location', required=True)

    @staticmethod
    def default_company():
        return Transaction().context.get('company')

    def default_start_date():
        return datetime.today()


class CropSuppliesWizard(Wizard):
    'Crop Activities'
    __name__ = 'farming.crop_supplies'
    start = StateView(
        'farming.crop_activities.start',
        'farming.farming_crop_activities_start_view_form', [
            Button('Cancel', 'end', 'tryton-cancel'),
            Button('Print', 'print_', 'tryton-ok', default=True),
        ])
    print_ = StateReport('farming.crop_supplies.report')

    def do_print_(self, action):
        data = {
            #'crop': self.start.crop.id,
            'company': self.start.company.id,
            'start_date': self.start.start_date,
            'location': self.start.location.id,
            #'end_date': self.start.end_date,
        }
        return action, data

    def transition_print_(self):
        return 'end'


class CropSuppliesReport(Report):
    'Crop Activities Report'
    __name__ = 'farming.crop_supplies.report'

    @classmethod
    def get_context(cls, records, header, data):
        report_context = super().get_context(records, header, data)
        pool = Pool()
        Company = pool.get('company.company')
        date_start = date(data['start_date'].year, data['start_date'].month, 1)
        calculate_month = data['start_date'] + timedelta(days=30)
        date_end = date(data['start_date'].year, calculate_month.month, 28)
        week_list = []
        date_calculate_week = date_start + timedelta(7)
        for w in range(13):
            week_data = {
                'number': date_calculate_week.isocalendar()[1],
                'range': date_calculate_week
            }
            week_list.append(week_data)
            date_calculate_week = date_calculate_week  + timedelta(days=7)

        Location = pool.get('farming.location')
        locations = Location.search([('id', '=', data['location'])])
        # location_list = []
        for location in locations:
            Crop = pool.get('farming.crop')
            crops = Crop.search([
                ('location', '=', location.id),
                ('end_date', '>=', date_end),
                ('activities', '!=', None)
                ])

            supplies_list = []

            for crop in crops:
                for activity in crop.activities:
                    for supply in activity.supplies:
                        supply_record = supply.product.name
                        supplies_list.append(supply_record)
            supplies_list = set(supplies_list)
            supplies_list = [{'supply': spl} for spl in supplies_list]

            crop_list = []
            for crop in crops:

                for activity in crop.activities:
                    activity_week = activity.planned_date.isocalendar()[1]
                    supply_info_list = []
                    for week in week_list:
                        spl = {
                                'quantity': '',
                                'unit': '',
                            }
                        supply_info_list.append(spl)

                    for supply in activity.supplies:
                        for index, week in enumerate(week_list):
                            week_number = week['number']
                            if activity_week == week_number:
                                for spl in supplies_list:
                                    if spl['supply'] == supply.product.name:
                                        supply_info_list[index-1] = {
                                                'name': supply.product.name,
                                                'quantity': supply.quantity,
                                                'unit': supply.unit
                                            }
                                        #spl['info'] = supply_info_list
                                        break
                    suply_crop = {
                        'crop': crop.number,
                        'info': supply_info_list
                    }
                    crop_list.append(suply_crop)

        report_context['weeks'] = week_list
        report_context['supplies'] = supplies_list
        report_context['company'] = Company(data['company'])
        report_context['date_start'] = date_start
        report_context['date_end'] = date_end
        return report_context


class CropForecastWeekStart(ModelView):
    'Crop Activities Start'
    __name__ = 'farming.crop_forecast_week.start'
    company = fields.Many2One('company.company', 'Company', required=True)
    crop = fields.Many2One('farming.crop', 'Crop')
    start_date = fields.Date("Start Date")
    location = fields.Many2One('farming.location', 'Location')

    @staticmethod
    def default_company():
        return Transaction().context.get('company')

    def default_start_date():
        return datetime.today()


class CropForecastWeekWizard(Wizard):
    'Crop Activities'
    __name__ = 'farming.crop_forecast_week'
    start = StateView(
        'farming.crop_forecast_week.start',
        'farming.farming_crop_forecast_week_start_view_form', [
            Button('Cancel', 'end', 'tryton-cancel'),
            Button('Print', 'print_', 'tryton-ok', default=True),
        ])
    print_ = StateReport('farming.crop_forecast_week.report')

    def do_print_(self, action):
        data = {
            # 'crop': self.start.crop.id,
            'company': self.start.company.id,
            'start_date': self.start.start_date,
            'location': self.start.location.id if self.start.location else self.start.location,
            # 'end_date': self.start.end_date,
        }
        return action, data

    def transition_print_(self):
        return 'end'


class CropForecastWeekReport(Report):
    'Crop Activities Report'
    __name__ = 'farming.crop_forecast_week.report'

    @classmethod
    def get_context(cls, records, header, data):
        report_context = super().get_context(records, header, data)
        pool = Pool()
        Company = pool.get('company.company')

        date_start = date(data['start_date'].year, data['start_date'].month, 1)
        calculate_month = data['start_date'] + timedelta(days=30)
        date_end = date(data['start_date'].year, calculate_month.month, 28)
        week_list = []
        date_calculate_week = date_start
        for w in range(13):
            week_data = {
                'number': date_calculate_week.isocalendar()[1],
                'range': date_calculate_week
            }
            week_list.append(week_data)
            date_calculate_week = date_calculate_week + timedelta(days=7)

        Location = pool.get('farming.location')
        if data['location']:
            locations = Location.search([('id', '=', data['location'])])
        else:
            locations = Location.search([('name', '!=', '')])
        location_list = []
        for location in locations:
            Crop = pool.get('farming.crop')
            crops = Crop.search([
                ('location', '=', location.id),
                ('end_date', '>=', date_end),
                ('activities', '!=', None)
                ])
            crop_list = []
            total_list = [0 for x in range(13)]

            for crop in crops:
                crop_report = {
                    'lots': []
                }
                lots_report = []
                for lot in crop.lots:
                    beds = ''
                    for bed in lot.beds:
                        beds = beds + '-' + bed.bed.number
                    lot_dict = {
                        'number': crop.number,
                        'variety': crop.variety.product.name,
                        'lot': 'Lote: ' + lot.lot.number,
                        'total_plants': lot.total_plants,
                        'beds': 'Camas: ' + beds,
                        'stages': []
                    }
                    lots_report.append(lot_dict)
                crop_report['lots'] = lots_report
                Stage = pool.get('farming.crop.stage')
                stages = Stage.search(['crop', "=", crop.id])

                for lot_report in lots_report:
                    stage_list = []
                    for stage in stages:
                        stage_week = stage.effective_date.isocalendar()[1]
                        for week in week_list:
                            act = {
                                'name': '',
                                'production_rate': 0
                            }
                            stage_list.append(act)
                        for index, week in enumerate(week_list):
                            week_number = week['number']
                            if stage_week == week_number:
                                stage_list[index-1] = {
                                    'name': stage.stage.name,
                                    'production_rate': int(
                                        stage.production_rate * lot_report['total_plants'] * crop.production_rate * .01)
                                }
                                total_list[index-1] = int(total_list[index-1] + (stage.production_rate * lot_report['total_plants'] * crop.production_rate * .01))
                                break
                        lot_report['stages'] = stage_list

                crop_list.append(crop_report)
            location_list.append({'name': location.name, 'crops': crop_list, 'total_time': total_list})

        report_context['weeks'] = week_list
        report_context['records'] = location_list
        report_context['company'] = Company(data['company'])
        report_context['date_start'] = date_start
        report_context['date_end'] = date_end
        return report_context


class FarmingCropReport(CompanyReport):
    __name__ = 'farming.crop'