コード例 #1
0
    def handle(self, *args, **options):

        verbosity = options['verbosity']
        if verbosity == '0':
            self.logger.setLevel(logging.ERROR)
        elif verbosity == '1':
            self.logger.setLevel(logging.WARNING)
        elif verbosity == '2':
            self.logger.setLevel(logging.INFO)
        elif verbosity == '3':
            self.logger.setLevel(logging.DEBUG)

        self.input_file = options['file']
        self.logger.info('Input file:{}'.format(self.input_file))
        data = None
        interventi_counter = 0
        vari_territori_counter = 0

        # read file
        try:
            json_file = open(self.input_file)
            data = json.load(json_file, encoding=self.encoding)
        except IOError:
            self.logger.error("It was impossible to open file '{}'".format(
                self.input_file))
            exit(1)

        self.logger.info(
            "Deleting all previous InterventoProgramma and Impresa...")
        InterventoProgramma.objects.all().delete()
        Impresa.objects.all().delete()
        Variante.objects.all().delete()
        self.logger.info("Done")
        set_autocommit(False)
        for intervento_a_progr_json in data['interventi_a_programma']:

            interventi_counter += 1
            istat_comune = intervento_a_progr_json['comune']['cod_istat_com']
            territorio = None
            vari_territori = False

            # checks if istat_id == vari_territori, else find the territorio in the db
            if istat_comune == self.istat_code_vari_territori:
                self.logger.debug(u"Territorio found: VARI TERRITORI")
                vari_territori = True
                vari_territori_counter += 1
            else:
                try:
                    territorio = Territorio.objects.get(istat_id=istat_comune)
                except ObjectDoesNotExist:
                    self.logger.error(
                        "Territorio does not exist:{}".format(istat_comune))
                    if istat_comune not in self.not_found_territori:
                        self.not_found_territori[istat_comune] = 1
                    else:
                        self.not_found_territori[istat_comune] += 1

                    continue
                else:

                    got_gps_data = False
                    if territorio.gps_lon is None:
                        territorio.gps_lon = intervento_a_progr_json['comune'][
                            'long']
                        got_gps_data = True

                    if territorio.gps_lat is None:
                        territorio.gps_lat = intervento_a_progr_json['comune'][
                            'lat']
                        got_gps_data = True

                    if got_gps_data:
                        territorio.save()

            intervento_programma = InterventoProgramma()
            # gets Programma
            programma, is_created = Programma.objects.get_or_create(
                id_fenice=intervento_a_progr_json['id_progr'], )
            if is_created:
                self.logger.warning("Created new Programma with id:{}".format(
                    programma.id_fenice))

            # gets Soggetto Attuatore
            soggetto_att, is_created = SoggettoAttuatore.objects.get_or_create(
                id_fenice=intervento_a_progr_json['id_sogg_att'], )

            if is_created:
                self.logger.warning(
                    "Created new Soggetto Attuatore with id:{}".format(
                        soggetto_att.id_fenice))

            intervento_programma.programma = programma
            intervento_programma.id_fenice = intervento_a_progr_json[
                'id_interv_a_progr']
            intervento_programma.n_ordine = intervento_a_progr_json[
                'n_ordine'].strip()
            intervento_programma.importo_generale = Decimal(
                intervento_a_progr_json['imp_gen'])
            intervento_programma.importo_a_programma = Decimal(
                intervento_a_progr_json['imp_a_progr'])
            intervento_programma.denominazione = intervento_a_progr_json[
                'denominazione'].strip()
            intervento_programma.soggetto_attuatore = soggetto_att
            intervento_programma.territorio = territorio
            intervento_programma.vari_territori = vari_territori
            intervento_programma.id_categ_imm = intervento_a_progr_json[
                'id_categ_imm']
            try:
                propr_immobile = ProprietarioImmobile.objects.get(
                    id_fenice=intervento_a_progr_json['id_propr_imm'])
            except ObjectDoesNotExist:
                self.logger.error(
                    "Int.Programma with id_fenice:{}, cannot find propr.immobile for id:{}"
                    .format(intervento_programma.id_fenice,
                            intervento_a_progr_json['id_propr_imm']))
            else:
                intervento_programma.propr_immobile = propr_immobile

            intervento_programma.slug = slugify(u"{}-{}".format(
                intervento_programma.denominazione[:45],
                str(intervento_programma.id_fenice)))
            intervento_programma.tipo_immobile_fenice = intervento_a_progr_json[
                'id_tipo_imm']
            intervento_programma.tipo_immobile = self.translate_tipo_imm(
                intervento_a_progr_json['id_tipo_imm'])
            intervento_programma.save()
            self.logger.debug(u"Import Interv.Programma:{}".format(
                intervento_programma.slug))

            # calculate importo cofinanziamente as difference between imp. generale and imp.programma
            importo_cofinanziamenti = intervento_programma.importo_generale - intervento_programma.importo_a_programma

            # save cofinanziamenti
            for cofinanziamento in list(
                    filter(lambda x: x['importo'] > 0,
                           intervento_a_progr_json['cofinanziamenti'])):
                cof = Cofinanziamento()
                cof.intervento_programma = intervento_programma
                cof.tipologia = cofinanziamento['id_tipo_cofin']
                cof.importo = cofinanziamento['importo']
                cof.save()

            # save interventi a piano
            for intervento_piano_json in intervento_a_progr_json[
                    'interventi_a_piano']:
                intervento_piano = InterventoPiano()
                intervento_piano.intervento_programma = intervento_programma
                intervento_piano.id_fenice = intervento_piano_json[
                    'id_interv_a_piano']
                intervento_piano.imp_a_piano = intervento_piano_json[
                    'imp_a_piano']
                # NOTE: this works only if there is only ONE intervento piano
                # and ONE intervento for intervento programma
                intervento_piano.imp_consolidato = Decimal(
                    intervento_piano.imp_a_piano) + importo_cofinanziamenti
                # gets or create a Piano
                piano, is_created = Piano.objects.get_or_create(
                    id_fenice=intervento_piano_json['piano']['id_piano'],
                    tipologia=intervento_piano_json['piano']['id_tipo_piano'])
                intervento_piano.piano = piano
                intervento_piano.save()

                # save interventi
                for intervento_json in intervento_piano_json['interventi']:
                    intervento = Intervento()
                    intervento.intervento_piano = intervento_piano
                    intervento.id_fenice = intervento_json['id_interv']
                    intervento.is_variante = intervento_json['variante']

                    intervento.imp_congr_spesa = Decimal(0)
                    intervento.imp_consolidato = Decimal(0)
                    if intervento_json['imp_congr_spesa']:
                        intervento.imp_congr_spesa = Decimal(
                            intervento_json['imp_congr_spesa'])
                        # NOTE: this works only if there is only ONE intervento piano
                        # and ONE intervento for intervento programma
                        intervento.imp_consolidato = intervento.imp_congr_spesa + importo_cofinanziamenti
                    else:
                        self.logger.warning(
                            u"Intervento programma:'{}' in ATTUAZIONE but Intervento['imp_congr_spesa'] = NULL, use Importo a piano"
                            .format(intervento_programma.slug))
                        intervento.imp_consolidato = intervento_piano.imp_consolidato

                    intervento.denominazione = intervento_json['denominazione']
                    intervento.tipologia = intervento_json['id_tipo_interv']
                    intervento.stato = intervento_json['id_stato_interv']
                    intervento.gps_lat = intervento_json['lat']
                    intervento.gps_long = intervento_json['long']
                    intervento.save()

                    # save quadro economico for Intervento
                    for qe_intervento in intervento_json['qe']:
                        QuadroEconomicoIntervento(
                            **{
                                'id_fenice': qe_intervento['id_qe'],
                                'intervento': intervento,
                                'tipologia': qe_intervento['id_tipo_qe'],
                                'importo': Decimal(qe_intervento['imp_qe']),
                            }).save()

                    #     import progetti
                    for progetto_json in intervento_json['progetti']:

                        data_deposito = None
                        data_inizio = None
                        data_fine = None
                        if progetto_json['iter'].get('data_dep', None):
                            data_deposito = datetime.strptime(
                                progetto_json['iter']['data_dep'],
                                self.date_format)
                        if progetto_json['iter'].get('data_inizio', None):
                            data_inizio = datetime.strptime(
                                progetto_json['iter']['data_inizio'],
                                self.date_format)
                        if progetto_json['iter'].get('data_fine', None):
                            data_fine = datetime.strptime(
                                progetto_json['iter']['data_fine'],
                                self.date_format)

                        progetto = Progetto(
                            **{
                                'id_fenice': progetto_json['id_prog'],
                                'intervento': intervento,
                                'tipologia': progetto_json['id_tipo_prog'],
                                'stato': progetto_json['id_stato_prog'],
                                'data_deposito': data_deposito,
                                'data_inizio': data_inizio,
                                'data_fine': data_fine,
                            })
                        progetto.save()
                        # save quadro economico for Progetto
                        for qe_progetto_json in progetto_json['qe']:
                            qep = QuadroEconomicoProgetto(
                                **{
                                    'id_fenice': qe_progetto_json['id_qe'],
                                    'progetto': progetto,
                                    'tipologia':
                                    qe_progetto_json['id_tipo_qe'],
                                    'importo': Decimal(
                                        qe_progetto_json['imp_qe']),
                                }).save()

                    #  import liquidazioni
                    for liquidazione in intervento_json['liquidazioni']:
                        data_ord = None
                        if liquidazione['data_ord']:
                            data_ord = datetime.strptime(
                                liquidazione['data_ord'], self.date_format)
                        Liquidazione(
                            **{
                                'intervento': intervento,
                                'tipologia':
                                liquidazione['id_tipo_liq'].strip(),
                                'data': data_ord,
                                'importo': Decimal(liquidazione['imp_ord'])
                            }).save()

                    #  Eventi contr.
                    for evento_contr in intervento_json['eventi_contrattuali']:
                        EventoContrattuale(
                            **{
                                'intervento':
                                intervento,
                                'tipologia':
                                evento_contr['id_tipo_evento_contr'],
                                'data':
                                datetime.strptime(evento_contr['data'],
                                                  self.date_format),
                            }).save()

                    # imprese
                    for impresa_json in intervento_json['imprese']:
                        impresa, _ = Impresa.objects.get_or_create(
                            partita_iva=impresa_json['p_iva'],
                            defaults={
                                'ragione_sociale':
                                impresa_json['rag_soc'],
                                'slug':
                                slugify(u"{}-{}".format(
                                    impresa_json['rag_soc'][:45],
                                    impresa_json['p_iva']))
                            })
                        intervento.imprese.add(impresa)

                    # varianti
                    for variante in intervento_json['varianti']:
                        progetto_variante = None
                        qev = None
                        if variante['id_prog']:
                            try:
                                progetto_variante = Progetto.objects.get(
                                    id_fenice=variante['id_prog'])
                            except ObjectDoesNotExist:
                                self.logger.error(
                                    "Intervento with id_fenice:{}, Variante: id_prog:{} does not exist in db"
                                    .format(intervento.id_fenice,
                                            variante['id_prog']))

                        # import Quadro economico
                        if variante['id_qe']:
                            try:
                                qev = QuadroEconomicoIntervento.objects.get(
                                    id_fenice=variante['id_qe'])
                            except ObjectDoesNotExist:
                                self.logger.error(
                                    "Intervento with id_fenice:{}, Variante: id_qe:{} does not exist in db"
                                    .format(intervento.id_fenice,
                                            variante['id_qe']))

                        variante_data_deposito = None
                        if variante['iter']['data_dep']:
                            variante_data_deposito = datetime.strptime(
                                variante['iter']['data_dep'], self.date_format)

                        variante_data_fine = None
                        if variante['iter']['data_fine']:
                            variante_data_fine = datetime.strptime(
                                variante['iter']['data_fine'],
                                self.date_format)

                        Variante(
                            **{
                                'qe': qev,
                                'tipologia': variante['id_tipo_var'],
                                'stato': variante['id_stato_var'],
                                'intervento': intervento,
                                'progetto': progetto_variante,
                                'data_deposito': variante_data_deposito,
                                'data_fine': variante_data_fine
                            }).save()

            # set state and attuazione state for the considered intervento_programma
            intervento_programma.stato, intervento_programma.a_piano, intervento_programma.in_attuazione, intervento_programma.stato_attuazione = \
                self.get_intervento_stato(intervento_programma)
            intervento_programma.save()

        commit()
        set_autocommit(True)
        self.logger.info(
            "Imported {} interventi, {} of which were on ALTRI TERRITORI".
            format(interventi_counter, vari_territori_counter))
        UltimoAggiornamento.objects.update_or_create(
            tipologia=UltimoAggiornamento.TIPOLOGIA.INTERVENTI,
            defaults={
                'data': datetime.today(),
            })
        self.logger.info("Set Ultimo aggiornamento to today")

        # prints out not-found Territori
        if len(self.not_found_territori.keys()):
            for t, counter in self.not_found_territori.iteritems():
                self.logger.error(
                    u"Cannot find territorio with istat_id:'{}' {} times".
                    format(t, counter))

        if len(self.tipo_imm_not_found) > 0:
            for id_not_found in self.tipo_imm_not_found:
                self.logger.error(
                    u"Cannot map id_tipo_imm:'{}', update mapping!".format(
                        id_not_found))
        self.logger.info("Done")
コード例 #2
0
    def get_aggregates(self):
        ##
        # calls the functions to get the aggregates and returns a dict
        # all the function called depend on the filters passed to AggregatePageMixin on initialization
        # so they return context-based data
        ##

        agg_dict = {
            'status': {
                'programmazione': self._get_programmazione_status(),
                'pianificazione': self._get_pianificazione_status(),
                'attuazione': self._get_attuazione_status(),
                'varianti': self._get_varianti_status(),
                'progettazione': self._get_progettazione_status(),
                'in_corso': self._get_in_corso_status(),
                'conclusi': self._get_conclusi_status(),
            },
            'total_percentage': {
                'programmazione': 0,
                'pianificazione': 0,
                'attuazione': 0,
            }
        }

        # calculates percentages of programmazione / pianificazione / attuazione compared to the whole of projects
        agg_dict['total_percentage']['programmazione'] = (agg_dict['status']['programmazione']['sum'] /
                                                          InterventoProgramma.programmati.all().with_count()[
                                                              'sum']) * Decimal(100.0)
        agg_dict['total_percentage']['pianificazione'] = (agg_dict['status']['pianificazione']['sum'] /
                                                          InterventoProgramma.pianificati.all().with_count()[
                                                              'sum']) * Decimal(100.0)
        agg_dict['total_percentage']['attuazione'] = (agg_dict['status']['attuazione']['sum'] /
                                                      InterventoProgramma.attuazione.all().with_count()[
                                                          'sum']) * Decimal(100.0)

        agg_dict['total_percentage']['programmazione'] = "{0:.2f}".format(
            agg_dict['total_percentage']['programmazione'])
        agg_dict['total_percentage']['pianificazione'] = "{0:.2f}".format(
            agg_dict['total_percentage']['pianificazione'])
        agg_dict['total_percentage']['attuazione'] = "{0:.2f}".format(agg_dict['total_percentage']['attuazione'])


        # calculate percentages of pianificazione / attuazione / varianti based on current filters
        agg_dict['status']['pianificazione']['percentage'] = 0.0
        agg_dict['status']['attuazione']['percentage'] = 0.0
        agg_dict['status']['varianti']['percentage'] = 0.0

        if agg_dict['status']['programmazione']['sum'] > 0 and agg_dict['status']['pianificazione']['sum'] > 0:
            agg_dict['status']['pianificazione']['percentage'] = Decimal(100.0) * (
                agg_dict['status']['pianificazione']['sum'] /
                agg_dict['status']['programmazione']['sum'])

            if agg_dict['status']['attuazione']['sum']:
                agg_dict['status']['attuazione']['percentage'] = Decimal(100.0) * (
                    agg_dict['status']['attuazione']['sum'] /
                    agg_dict['status']['programmazione']['sum'])

        # calculates % in varianti compared to attuazione importo
        if agg_dict['status']['attuazione']['sum'] > 0 and agg_dict['status']['varianti']['sum']:
            agg_dict['status']['varianti']['percentage'] = Decimal(100.0) * (
                agg_dict['status']['varianti']['sum'] /
                agg_dict['status']['attuazione']['sum'])

        # top importo interventi fetch
        agg_dict['interventi_top_importo'] = self.fetch_top_interventi_attuazione()

        # Get tipo immobile pie data
        if self.tipologia != self.TIPO_IMMOBILE:
            agg_dict['tipo_immobile_aggregates'] = InterventoProgramma.get_tipo_immobile_aggregates(
                **self.programmazione_filters)

        if self.tipologia != self.IMPRESA:
            agg_dict['imprese_top'] = self.fetch_imprese()

        # Get tipo sogg.att data
        if self.tipologia != self.SOGG_ATT and self.tipologia != self.IMPRESA:
            agg_dict['sogg_att_aggregates'] = InterventoProgramma.get_sogg_attuatore_aggregates(
                **self.programmazione_filters)
            agg_dict['sogg_att_top'] = self.fetch_sogg_att()

        # Get donazioni data

        # if home or localita page: use programmazione filters ( no filters or territorio filters)
        # else (tipo immobile) use DonazioneInterventoProgramma filters
        if self.tipologia == self.HOME or self.tipologia == self.TERRITORIO:
            agg_dict['donazioni_aggregates'] = self._get_aggr_donazioni()
            agg_dict['donazioni_totale'] = self._get_totale_donazioni()
        else:
            agg_dict['donazioni_aggregates'] = self._get_aggr_donazioni_interventi()
            agg_dict['donazioni_totale'] = self._get_totale_donazioni_interventi()

        return agg_dict
コード例 #3
0
    def handle(self, *args, **options):

        verbosity = options['verbosity']
        if verbosity == '0':
            self.logger.setLevel(logging.ERROR)
        elif verbosity == '1':
            self.logger.setLevel(logging.WARNING)
        elif verbosity == '2':
            self.logger.setLevel(logging.INFO)
        elif verbosity == '3':
            self.logger.setLevel(logging.DEBUG)

        self.input_file = options['file']
        self.logger.info('Input file:{}'.format(self.input_file))
        data = None
        interventi_counter = 0
        vari_territori_counter = 0

        # read file
        try:
            json_file = open(self.input_file)
            data = json.load(json_file, encoding=self.encoding)
        except IOError:
            self.logger.error("It was impossible to open file '{}'".format(self.input_file))
            exit(1)

        self.logger.info("Deleting all previous InterventoProgramma and Impresa...")
        InterventoProgramma.objects.all().delete()
        Impresa.objects.all().delete()
        Variante.objects.all().delete()
        self.logger.info("Done")
        set_autocommit(False)
        for intervento_a_progr_json in data['interventi_a_programma']:

            interventi_counter += 1
            istat_comune = intervento_a_progr_json['comune']['cod_istat_com']
            territorio = None
            vari_territori = False

            # checks if istat_id == vari_territori, else find the territorio in the db
            if istat_comune == self.istat_code_vari_territori:
                self.logger.debug(u"Territorio found: VARI TERRITORI")
                vari_territori = True
                vari_territori_counter += 1
            else:
                try:
                    territorio = Territorio.objects.get(istat_id=istat_comune)
                except ObjectDoesNotExist:
                    self.logger.error("Territorio does not exist:{}".format(istat_comune))
                    if istat_comune not in self.not_found_territori:
                        self.not_found_territori[istat_comune] = 1
                    else:
                        self.not_found_territori[istat_comune] += 1

                    continue
                else:

                    got_gps_data = False
                    if territorio.gps_lon is None:
                        territorio.gps_lon = intervento_a_progr_json['comune']['long']
                        got_gps_data = True

                    if territorio.gps_lat is None:
                        territorio.gps_lat = intervento_a_progr_json['comune']['lat']
                        got_gps_data = True

                    if got_gps_data:
                        territorio.save()

            intervento_programma = InterventoProgramma()
            # gets Programma
            programma, is_created = Programma.objects.get_or_create(
                id_fenice=intervento_a_progr_json['id_progr'],
            )
            if is_created:
                self.logger.warning("Created new Programma with id:{}".format(programma.id_fenice))

            # gets Soggetto Attuatore
            soggetto_att, is_created = SoggettoAttuatore.objects.get_or_create(
                id_fenice=intervento_a_progr_json['id_sogg_att'],
            )

            if is_created:
                self.logger.warning("Created new Soggetto Attuatore with id:{}".format(soggetto_att.id_fenice))

            intervento_programma.programma = programma
            intervento_programma.id_fenice = intervento_a_progr_json['id_interv_a_progr']
            intervento_programma.n_ordine = intervento_a_progr_json['n_ordine'].strip()
            intervento_programma.importo_generale = Decimal(intervento_a_progr_json['imp_gen'])
            intervento_programma.importo_a_programma = Decimal(intervento_a_progr_json['imp_a_progr'])
            intervento_programma.denominazione = intervento_a_progr_json['denominazione'].strip()
            intervento_programma.soggetto_attuatore = soggetto_att
            intervento_programma.territorio = territorio
            intervento_programma.vari_territori = vari_territori
            intervento_programma.id_categ_imm = intervento_a_progr_json['id_categ_imm']
            try:
                propr_immobile = ProprietarioImmobile.objects.get(id_fenice=intervento_a_progr_json['id_propr_imm'] )
            except ObjectDoesNotExist:
                self.logger.error("Int.Programma with id_fenice:{}, cannot find propr.immobile for id:{}".format(intervento_programma.id_fenice, intervento_a_progr_json['id_propr_imm']))
            else:
                intervento_programma.propr_immobile = propr_immobile

            intervento_programma.slug = slugify(
                u"{}-{}".format(intervento_programma.denominazione[:45], str(intervento_programma.id_fenice)))
            intervento_programma.tipo_immobile_fenice = intervento_a_progr_json['id_tipo_imm']
            intervento_programma.tipo_immobile = self.translate_tipo_imm(intervento_a_progr_json['id_tipo_imm'])
            intervento_programma.save()
            self.logger.debug(u"Import Interv.Programma:{}".format(intervento_programma.slug))

            # calculate importo cofinanziamente as difference between imp. generale and imp.programma
            importo_cofinanziamenti = intervento_programma.importo_generale - intervento_programma.importo_a_programma

            # save cofinanziamenti
            for cofinanziamento in list(
                    filter(lambda x: x['importo'] > 0, intervento_a_progr_json['cofinanziamenti'])):
                cof = Cofinanziamento()
                cof.intervento_programma = intervento_programma
                cof.tipologia = cofinanziamento['id_tipo_cofin']
                cof.importo = cofinanziamento['importo']
                cof.save()

            # save interventi a piano
            for intervento_piano_json in intervento_a_progr_json['interventi_a_piano']:
                intervento_piano = InterventoPiano()
                intervento_piano.intervento_programma = intervento_programma
                intervento_piano.id_fenice = intervento_piano_json['id_interv_a_piano']
                intervento_piano.imp_a_piano = intervento_piano_json['imp_a_piano']
                # NOTE: this works only if there is only ONE intervento piano
                # and ONE intervento for intervento programma
                intervento_piano.imp_consolidato = Decimal(intervento_piano.imp_a_piano) + importo_cofinanziamenti
                # gets or create a Piano
                piano, is_created = Piano.objects.get_or_create(
                    id_fenice=intervento_piano_json['piano']['id_piano'],
                    tipologia=intervento_piano_json['piano']['id_tipo_piano']
                )
                intervento_piano.piano = piano
                intervento_piano.save()

                # save interventi
                for intervento_json in intervento_piano_json['interventi']:
                    intervento = Intervento()
                    intervento.intervento_piano = intervento_piano
                    intervento.id_fenice = intervento_json['id_interv']
                    intervento.is_variante = intervento_json['variante']

                    intervento.imp_congr_spesa = Decimal(0)
                    intervento.imp_consolidato = Decimal(0)
                    if intervento_json['imp_congr_spesa']:
                        intervento.imp_congr_spesa = Decimal(intervento_json['imp_congr_spesa'])
                        # NOTE: this works only if there is only ONE intervento piano
                        # and ONE intervento for intervento programma
                        intervento.imp_consolidato = intervento.imp_congr_spesa + importo_cofinanziamenti
                    else:
                        self.logger.warning(u"Intervento programma:'{}' in ATTUAZIONE but Intervento['imp_congr_spesa'] = NULL, use Importo a piano".format(intervento_programma.slug))
                        intervento.imp_consolidato = intervento_piano.imp_consolidato

                    intervento.denominazione = intervento_json['denominazione']
                    intervento.tipologia = intervento_json['id_tipo_interv']
                    intervento.stato = intervento_json['id_stato_interv']
                    intervento.gps_lat = intervento_json['lat']
                    intervento.gps_long = intervento_json['long']
                    intervento.save()

                    # save quadro economico for Intervento
                    for qe_intervento in intervento_json['qe']:
                        QuadroEconomicoIntervento.objects.create(**{
                            'id_fenice': qe_intervento['id_qe'],
                            'intervento': intervento,
                            'tipologia': qe_intervento['id_tipo_qe'],
                            'importo': Decimal(qe_intervento['imp_qe']),
                        })


                    #     import progetti
                    for progetto_json in intervento_json['progetti']:

                        data_deposito = None
                        data_inizio = None
                        data_fine = None
                        if progetto_json['iter'].get('data_dep', None):
                            data_deposito = datetime.strptime(progetto_json['iter']['data_dep'], self.date_format)
                        if progetto_json['iter'].get('data_inizio', None):
                            data_inizio = datetime.strptime(progetto_json['iter']['data_inizio'], self.date_format)
                        if progetto_json['iter'].get('data_fine', None):
                            data_fine = datetime.strptime(progetto_json['iter']['data_fine'], self.date_format)

                        progetto = Progetto(**{
                            'id_fenice': progetto_json['id_prog'],
                            'intervento': intervento,
                            'tipologia': progetto_json['id_tipo_prog'],
                            'stato': progetto_json['id_stato_prog'],
                            'data_deposito': data_deposito,
                            'data_inizio': data_inizio,
                            'data_fine': data_fine,
                        })
                        progetto.save()
                        # save quadro economico for Progetto
                        for qe_progetto_json in progetto_json['qe']:
                            qep = QuadroEconomicoProgetto(**{
                                'id_fenice': qe_progetto_json['id_qe'],
                                'progetto': progetto,
                                'tipologia': qe_progetto_json['id_tipo_qe'],
                                'importo': Decimal(qe_progetto_json['imp_qe']),
                            }).save()


                    #  import liquidazioni
                    for liquidazione in intervento_json['liquidazioni']:
                        data_ord = None
                        if liquidazione['data_ord']:
                            data_ord = datetime.strptime(liquidazione['data_ord'], self.date_format)
                        Liquidazione(**{
                            'intervento': intervento,
                            'tipologia': liquidazione['id_tipo_liq'].strip(),
                            'data': data_ord,
                            'importo': Decimal(liquidazione['imp_ord'])
                        }).save()

                    #  Eventi contr.
                    for evento_contr in intervento_json['eventi_contrattuali']:
                        EventoContrattuale(**{
                            'intervento': intervento,
                            'tipologia': evento_contr['id_tipo_evento_contr'],
                            'data': datetime.strptime(evento_contr['data'], self.date_format),
                        }).save()

                    # imprese
                    for impresa_json in intervento_json['imprese']:
                        impresa, _ = Impresa.objects.get_or_create(
                            partita_iva=impresa_json['p_iva'],
                            defaults={
                                'ragione_sociale': impresa_json['rag_soc'],
                                'slug': slugify(u"{}-{}".format(impresa_json['rag_soc'][:45], impresa_json['p_iva']))
                            }
                        )
                        intervento.imprese.add(impresa)

                    # varianti
                    for variante in intervento_json['varianti']:
                        progetto_variante = None
                        qev = None
                        if variante['id_prog']:
                            try:
                                progetto_variante = Progetto.objects.get(id_fenice=variante['id_prog'])
                            except ObjectDoesNotExist:
                                self.logger.error(
                                    "Intervento with id_fenice:{}, Variante: id_prog:{} does not exist in db".format(
                                        intervento.id_fenice, variante['id_prog']))

                        # import Quadro economico
                        if variante['id_qe']:
                            try:
                                qev = QuadroEconomicoIntervento.objects.get(id_fenice=variante['id_qe'])

                                variante_data_deposito = None
                                if variante['iter']['data_dep']:
                                    variante_data_deposito = datetime.strptime(variante['iter']['data_dep'], self.date_format)

                                variante_data_fine = None
                                if variante['iter']['data_fine']:
                                    variante_data_fine = datetime.strptime(variante['iter']['data_fine'], self.date_format)

                                Variante(**{
                                    'qe': qev,
                                    'tipologia': variante['id_tipo_var'],
                                    'stato': variante['id_stato_var'],
                                    'intervento': intervento,
                                    'progetto': progetto_variante,
                                    'data_deposito': variante_data_deposito,
                                    'data_fine': variante_data_fine
                                }).save()


                            except ObjectDoesNotExist:
                                self.logger.warning(
                                    "Intervento with id_fenice:{}, Variante: id_qe:{} does not exist in db, cannot import QE for Variante".format(
                                        intervento.id_fenice, variante['id_qe']))

            # set state and attuazione state for the considered intervento_programma
            intervento_programma.stato, intervento_programma.a_piano, intervento_programma.in_attuazione, intervento_programma.stato_attuazione = \
                self.get_intervento_stato(intervento_programma)
            intervento_programma.save()

        commit()
        set_autocommit(True)
        self.logger.info("Imported {} interventi, {} of which were on ALTRI TERRITORI".format(interventi_counter,
                                                                                              vari_territori_counter))
        UltimoAggiornamento.objects.update_or_create(
            tipologia=UltimoAggiornamento.TIPOLOGIA.INTERVENTI,
            defaults={
                'data': datetime.today(),
            }
        )
        self.logger.info("Set Ultimo aggiornamento to today")

        # prints out not-found Territori
        if len(self.not_found_territori.keys()):
            for t, counter in self.not_found_territori.iteritems():
                self.logger.error(u"Cannot find territorio with istat_id:'{}' {} times".format(t, counter))

        if len(self.tipo_imm_not_found) > 0:
            for id_not_found in self.tipo_imm_not_found:
                self.logger.error(u"Cannot map id_tipo_imm:'{}', update mapping!".format(id_not_found))
        self.logger.info("Done")