# -*- coding: utf-8 -*-
import xml.etree.ElementTree as ET
import csv
import datetime
import requests
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
from django.shortcuts import render
from ftplib import FTP
from bs4 import BeautifulSoup
from .models import *
from decimal import Decimal, ROUND_HALF_UP
from prestashop_api import PrestashopApi

api = PrestashopApi('http://sklep.wojnaopon.pl/api', 'F5FU6EVYCENBY74NXS31Z24SSJN8QW3P')

USERNAME = 'F5FU6EVYCENBY74NXS31Z24SSJN8QW3P'
PASSWORD = ''

# ELIT #
serverE = "178.217.140.125"
directoryE = "/"
filenameE = "elit-2018.csv"
filenameEC = "cennik_Dakol_opony_csv.csv"

# GLOBETYRE #
serverG = "178.217.140.125"
directoryG = "/"
filenameG = "WojnaOpon.csv"
filenameP = "PlatformaOpon.csv"

# informacje dodatkowe
id_tax_rules_group = 7
state = 1
redirect_type = 404
show_price = 1
id_shop = 1
id_product_attribute = 0
depends_on_stock = 0
out_of_stock = 2
active = 1
weight = 1
in_price_compare = 1
ceneo_basket = 2
available_for_order = 1
minimal_quantity = 1

def get_platformaopon(request):
    # pobieranie stanów PO
    PlatformaOpon.objects.update(available=False)
    PlatformaOpon.objects.update(stock='0')

    ftpG = FTP(serverG)  # Set server address
    ftpG.login("stany_mag", "GlobeTyre$#")  # Connect to server
    ftpG.cwd(directoryG)  # Move to the desired folder in server
    ftpG.retrbinary('RETR ' + filenameP, open(filenameP, 'wb').write)  # Download file from server
    ftpG.close()  # Close connection

    # Load the CSV file into CSV reader
    csvfile = open('PlatformaOpon.csv', 'rt', encoding="utf8")
    creader = csv.reader(csvfile, delimiter=';', quotechar='|')

    # Iterate through the CSV reader, inserting values into the database
    next(creader)
    for row in creader:
        sap = row[3]
        producer = row[1].upper()
        model = row[2].upper()
        size = row[5].upper()
        speed_index = row[6].upper()
        load_index = row[7]
        rolling_resistance = row[8].upper()
        adhesion = row[9].upper()
        noise = row[10]
        stock = row[11]
        price = row[12].replace(",", ".")
        dot = row[15]
        season = row[22].upper()
        type = row[21].upper().replace("OSOB", "OSOBOWE").replace("BUS", "DOSTAWCZE")
        noise_symbole = row[20]
        available = True


        defaults = {'producer': producer, 'model': model, 'sap': sap, 'size': size, 'speed_index': speed_index, 'load_index': load_index, 'rolling_resistance': rolling_resistance, 'adhesion': adhesion, 'noise': noise, 'dot': dot, 'stock': stock, 'price': price, 'available': available, 'season': season, 'type': type, 'noise_symbol': noise_symbole}
        try:
            obj = PlatformaOpon.objects.get(sap=sap)
            for key, value in defaults.items():
                setattr(obj, key, value)
            obj.save()
        except PlatformaOpon.DoesNotExist:
            new_values = {'producer': producer, 'model': model, 'sap': sap, 'size': size, 'speed_index': speed_index, 'load_index': load_index, 'rolling_resistance': rolling_resistance, 'adhesion': adhesion, 'noise': noise, 'dot': dot, 'stock': stock, 'price': price, 'available': available, 'season': season, 'type': type, 'noise_symbol': noise_symbole}
            new_values.update(defaults)
            obj = PlatformaOpon(**new_values)
            obj.save()


    return render(request, 'get.html')

def export_platformaopon(request):

    with open('oferta_hurtopon_wo.csv', "w", newline='') as csv_file:
        writer = csv.writer(csv_file, delimiter=';')
        writer.writerow(['kod', 'nazwa', 'ilosc', 'cena', 'uwagi', 'dot', 'bieznikowana'])
        tyres = PlatformaOpon.objects.all().values_list('sap', 'producer', 'model', 'size', 'speed_index', 'load_index', 'rolling_resistance', 'adhesion', 'noise', 'stock', 'price', 'dot', 'available')

        bieznikowana = 'nie'
        uwagi = 'JEZELI DOSTEPNOSC PONIZEJ 8 SZTUK, PROSIMY O TELEFON W CELU POTWIERDZENIA DOSTEPNOSCI'
        opis = ''

        for tyre in tyres:
            if tyre[12] is True:
                opis = tyre[1] + ' ' + tyre[3] + ' ' + tyre[2] + ' ' + tyre[5] + '' + tyre[4] + ' ' + tyre[6] + ' ' + tyre[7] + ' ' + tyre[8] + 'dB'
                writer.writerow([tyre[0], opis, tyre[9], tyre[10], uwagi.encode('utf-8'), tyre[11], bieznikowana])

    with open('PlatformaOpon_import.csv', "w", newline='') as csv_file:
        writer = csv.writer(csv_file, delimiter=';')
        writer.writerow(['kod', 'liczba', 'cena', 'opis', 'nazwa', 'rozmiar', 'nosnosc', 'predkosc', 'typ', 'producent', 'sezon', 'dostawa', 'ee', 'hnm', 'wg', 'pg', 'data_produkcji'])
        tyres = PlatformaOpon.objects.all().values_list('sap', 'producer', 'model', 'size', 'speed_index', 'load_index', 'rolling_resistance', 'adhesion', 'noise', 'stock', 'price', 'dot', 'available', 'season', 'type', 'noise_symbol')

        dostawa = '1'
        empty = ''
        opis = ''

        for tyre in tyres:
            if tyre[12] is True:
                opis = tyre[1] + ' ' + tyre[3] + ' ' + tyre[2] + ' ' + tyre[5] + '' + tyre[4] + ' ' + tyre[6] + ' ' + tyre[7] + ' ' + tyre[8]
                size = tyre[3].replace('C', '').replace('Z', '').replace('V','')
                if len(size) < 7:
                    size = size.replace('R', '/80R')
                type = tyre[14]
                if type == '4X4':
                    type = '4X4/SUV'
                if type == 'SUV':
                    type = '4X4/SUV'
                season = tyre[13]
                noise_symbol = tyre[15]
                if noise_symbol == ')))':
                    noise_symbol = '3'
                if noise_symbol == '))':
                    noise_symbol = '2'
                if noise_symbol == ')':
                    noise_symbol = '1'
                writer.writerow([tyre[0], tyre[9], tyre[10], opis, tyre[2], size, tyre[5], tyre[4], type, tyre[1], season, dostawa, tyre[6], tyre[7], tyre[8], noise_symbol, tyre[11]])

    # Upload plików
    serverG = "78.46.90.170"
    serverH = "91.206.7.227"

    directoryG = "/gtcenter/media/exports/wojnaopon/"
    directoryH = "/"

    filenameP = "PlatformaOpon_import.csv"
    filenameH = "oferta_hurtopon_wo.csv"

    ftpG = FTP(serverG)  # Set server address
    ftpG.login("gtyr2016", "lvvld8663")  # Connect to server
    ftpG.cwd(directoryG)  # Move to the desired folder in server
    ftpG.storbinary('STOR ' + filenameP, open(filenameP, 'rb'))  # Download file from server
    ftpG.close()  # Close connection

    ftpG = FTP(serverG)  # Set server address
    ftpG.login("gtyr2016", "lvvld8663")  # Connect to server
    ftpG.cwd(directoryG)  # Move to the desired folder in server
    ftpG.storbinary('STOR ' + filenameH, open(filenameH, 'rb'))  # Download file from server
    ftpG.close()  # Close connection

    ftpH = FTP(serverH)  # Set server address
    ftpH.login("globetyre", "45GtY81.P1")  # Connect to server
    ftpH.cwd(directoryH)  # Move to the desired folder in server
    ftpH.storbinary('STOR ' + filenameH, open(filenameH, 'rb'))  # Download file from server
    ftpH.close()  # Close connection

    return render(request, 'get.html')

## pobieranie producentów i modeli
# pobieranie producentów i modeli ELIT
def get_models_elit(request):

    # pobieranie produktów ELIT
    ftpE = FTP(serverE)  # Set server address
    ftpE.login("stany_mag", "GlobeTyre$#")  # Connect to server
    ftpE.cwd(directoryE)  # Move to the desired folder in server
    ftpE.retrbinary('RETR ' + filenameE, open(filenameE, 'wb').write)  # Download file from server
    ftpE.close()  # Close connection

    # Load the CSV file into CSV reader
    csvfile = open('elit-2018.csv', 'rt', encoding="utf8")
    creader = csv.reader(csvfile, delimiter=';', quotechar='|')
    # Iterate through the CSV reader, inserting values into the database
    next(creader)
    for row in creader:
        producer = row[7].upper()
        model = row[8].upper()
        season = row[17].upper()
        typ = row[2].upper()
        available = True

        if season == 'LATO':
            season = 'Letnie'

        if season == 'ZIMA':
            season = 'Zimowe'

        if season == 'M+S':
            season = 'Całoroczne'

        if typ == 'VAN':
            typ = 'Dostawcze'
        else:
            typ = 'Osobowe'

        if model == 'FRIGO 2 ':
            model = 'FRIGO 2'

        defaults = {'name': producer}
        try:
            obj = Producer.objects.get(name=producer)
            for key, value in defaults.items():
                setattr(obj, key, value)
            obj.save()
        except Producer.DoesNotExist:
            new_values = {'name': producer}
            obj = Producer(**new_values)
            obj.save()

        defaults = {'producer': Producer.objects.get(name=producer), 'name': model, 'season': season, 'type': typ, 'active': available}
        try:
            obj = Model.objects.get(name=model)
            for key, value in defaults.items():
                setattr(obj, key, value)
            obj.save()
        except Model.DoesNotExist:
            new_values = {'producer': Producer.objects.get(name=producer), 'name': model, 'season': season, 'type': typ, 'active': available}
            obj = Model(**new_values)
            obj.save()

    return render(request, 'get.html')
# pobieranie producentów i modeli WOJNAOPON
def get_models(request):
    # pobieranie stanów WO
    ftpG = FTP(serverG)  # Set server address
    ftpG.login("stany_mag", "GlobeTyre$#")  # Connect to server
    ftpG.cwd(directoryG)  # Move to the desired folder in server
    ftpG.retrbinary('RETR ' + filenameG, open(filenameG, 'wb').write)  # Download file from server
    ftpG.close()  # Close connection

    # Load the CSV file into CSV reader
    csvfile = open('WojnaOpon.csv', 'rt', encoding="utf8")
    creader = csv.reader(csvfile, delimiter=';', quotechar='|')

    # Iterate through the CSV reader, inserting values into the database
    next(creader)
    for row in creader:
        producer = row[1].upper()
        model = row[2].upper()
        season = row[22].upper()
        typ = row[21].upper()
        available = True

        if season == 'LATO':
            season = 'Letnie'

        if season == 'ZIMA':
            season = 'Zimowe'

        if season == 'Całoroczne':
            season = 'Całoroczne'

        if typ == 'OSOB':
            typ = 'Osobowe'

        if typ == 'BUS':
            typ = 'Dostawcze'

        defaults = {'name': producer}
        try:
            obj = Producer.objects.get(name=producer)
            for key, value in defaults.items():
                setattr(obj, key, value)
            obj.save()
        except Producer.DoesNotExist:
            new_values = {'name': producer}
            obj = Producer(**new_values)
            obj.save()

        defaults = {'producer': Producer.objects.get(name=producer), 'name': model, 'season': season, 'type': typ, 'active': available}
        try:
            obj = Model.objects.get(name=model)
            for key, value in defaults.items():
                setattr(obj, key, value)
            obj.save()
        except Model.DoesNotExist:
            new_values = {'producer': Producer.objects.get(name=producer), 'name': model, 'season': season, 'type': typ, 'active': available}
            obj = Model(**new_values)
            obj.save()
            print(model)


    return render(request, 'get.html')
## pobieranie stanów magazynowych
# pobieranie stanów magazynowych WOJNAOPON
def get_wojnaopon(request):

    WojnaOpon.objects.filter(provider=1).update(available=False)
    WojnaOpon.objects.filter(provider=1).update(stock='0')

    # DODOAWANIE PRODUKTÓW WOJNAOPON
    ftpG = FTP(serverG)  # Set server address
    ftpG.login("stany_mag", "GlobeTyre$#")  # Connect to server
    ftpG.cwd(directoryG)  # Move to the desired folder in server
    ftpG.retrbinary('RETR ' + filenameG, open(filenameG, 'wb').write)  # Download file from server
    ftpG.close()  # Close connection

    # Load the CSV file into CSV reader
    csvfile = open('WojnaOpon.csv', 'rt', encoding="utf8")
    creader = csv.reader(csvfile, delimiter=';', quotechar='|')

    # Iterate through the CSV reader, inserting values into the database
    next(creader)
    for row in creader:
        producer = row[1].upper()
        model = row[2].upper()
        sap = row[3]
        ean = row[4]
        width = row[5].split("/")[0]
        profile = row[5].split("/")[1].split("R")[0]
        rim = row[5].split("R")[1]
        speed_index = row[6].upper()
        load_index = row[7]
        rolling_resistance = row[8].upper()
        adhesion = row[9].upper()
        additional_marking = row[23].upper()
        noise = row[10]
        noise_symbole = row[20].upper()
        dot = row[15]
        stock = row[11]
        price = row[12].replace(",", ".")
        price_wo = row[18].replace(",", ".")
        available = True
        provider = 1

        if len(price_wo) > 1:
            price = price_wo

        if int(stock) > Provider.objects.get(id=provider).limit:
            defaults = {'producer': Producer.objects.get(name=producer), 'model': Model.objects.get(name=model), 'sap': sap, 'width': width, 'profile': profile, 'rim': rim, 'speed_index': speed_index, 'load_index': load_index, 'rolling_resistance': rolling_resistance, 'adhesion': adhesion, 'additional_marking': additional_marking, 'noise': noise, 'noise_symbole': noise_symbole, 'dot': dot, 'stock': stock, 'price': price, 'provider': Provider.objects.get(id=provider), 'available': available}

            print(sap)
            try:
                obj = WojnaOpon.objects.get(sap=sap)
                for key, value in defaults.items():
                    setattr(obj, key, value)
                obj.save()
            except WojnaOpon.DoesNotExist:
                new_values = {'producer': Producer.objects.get(name=producer), 'model': Model.objects.get(name=model), 'sap': sap, 'width': width, 'profile': profile, 'rim': rim, 'speed_index': speed_index, 'load_index': load_index, 'rolling_resistance': rolling_resistance, 'adhesion': adhesion, 'additional_marking': additional_marking, 'noise': noise, 'noise_symbole': noise_symbole, 'dot': dot, 'stock': stock, 'price': price, 'provider': Provider.objects.get(id=provider), 'available': available}
                new_values.update(defaults)
                obj = WojnaOpon(**new_values)
                obj.save()


    return render(request, 'get.html')
# pobieranie stanów magazynowych ELIT
def get_elit(request):

    WojnaOpon.objects.filter(provider=2).update(available=False)
    WojnaOpon.objects.filter(provider=2).update(stock='0')

    # DODOAWANIE PRODUKTÓW ELIT
    ftpE = FTP(serverE)  # Set server address
    ftpE.login("stany_mag", "GlobeTyre$#")  # Connect to server
    ftpE.cwd(directoryE)  # Move to the desired folder in server
    ftpE.retrbinary('RETR ' + filenameE, open(filenameE, 'wb').write)  # Download file from server
    ftpE.close()  # Close connection

    # Load the CSV file into CSV reader
    csvfile = open(filenameE, 'rt', encoding="latin-1")
    creader = csv.reader(csvfile, delimiter=';', quotechar='|')

    # Iterate through the CSV reader, inserting values into the database
    next(creader)
    for row in creader:
        producer = row[7].upper()
        model = row[8].upper()
        sap = row[1]
        width = row[3]
        profile = row[4]
        rim = row[5]
        speed_index = row[10].upper()
        load_index = row[9]
        rolling_resistance = row[21].upper()
        adhesion = row[22].upper()
        additional_marking = ''
        noise = row[23]
        noise_symbole = row[24].upper()
        xl_row = row[11].upper()
        rof_row = row[13].upper()
        fr_row = row[14].upper()
        hom_row = row[15]
        dot = 'Opony nie starsze niż 2 lata'
        stock = '0'
        price = '0'
        provider = 2
        product_available = False

        if len(xl_row) > 1:
            xl = 'XL '
            additional_marking += xl

        if len(rof_row) > 1:
            rof = 'ROF '
            additional_marking += rof

        if len(fr_row) > 1:
            fr = 'FR '
            additional_marking += fr

        if len(hom_row) > 1:
            hom = hom_row + ' '
            additional_marking += hom

        if model[-1:] == ' ':
            model = model[:-1]


        defaults = {'producer': Producer.objects.get(name=producer), 'model': Model.objects.get(name=model), 'sap': sap, 'width': width, 'profile': profile, 'rim': rim, 'speed_index': speed_index, 'load_index': load_index, 'rolling_resistance': rolling_resistance, 'adhesion': adhesion, 'additional_marking': additional_marking, 'noise': noise, 'noise_symbole': noise_symbole, 'dot': dot, 'stock': stock, 'price': price, 'provider': Provider.objects.get(id=provider), 'available': product_available}

        try:
            obj = WojnaOpon.objects.get(sap=sap)
            for key, value in defaults.items():
                setattr(obj, key, value)
            obj.save()
        except WojnaOpon.DoesNotExist:
            new_values = {'producer': Producer.objects.get(name=producer), 'model': Model.objects.get(name=model), 'sap': sap, 'width': width, 'profile': profile, 'rim': rim, 'speed_index': speed_index, 'load_index': load_index, 'rolling_resistance': rolling_resistance, 'adhesion': adhesion, 'additional_marking': additional_marking, 'noise': noise, 'noise_symbole': noise_symbole, 'dot': dot, 'stock': stock, 'price': price, 'provider': Provider.objects.get(id=provider), 'available': product_available}
            new_values.update(defaults)
            obj = WojnaOpon(**new_values)
            obj.save()

    # DODOAWANIE CENY ELIT
    ftpE = FTP(serverE)  # Set server address
    ftpE.login("ad", "!ADdakol$#")  # Connect to server
    ftpE.cwd(directoryE)  # Move to the desired folder in server
    ftpE.retrbinary('RETR ' + filenameEC, open(filenameEC, 'wb').write)  # Download file from server
    ftpE.close()  # Close connection

    # Load the CSV file into CSV reader
    csvfile = open('cennik_Dakol_opony_csv.csv', 'rt', encoding="latin-1")
    creader = csv.reader(csvfile, delimiter=';', quotechar='|')

    # Iterate through the CSV reader, inserting values into the database
    next(creader)
    for row in creader:
        sap = row[9].split('/')[0]
        # status = row[8]
        stock = row[5]
        price = round(float(row[3].replace(",", ".")), 1)
        available = True
        provider = 2
        price = price + Provider.objects.get(id=provider).margin + Provider.objects.get(id=provider).delivery_costs

        if int(stock) > Provider.objects.get(id=provider).limit:
            defaults = {'stock': stock, 'price': price, 'provider': Provider.objects.get(id=provider), 'available': available}

            try:
                obj = WojnaOpon.objects.get(sap=sap)
                for key, value in defaults.items():
                    setattr(obj, key, value)
                obj.save()
            except WojnaOpon.DoesNotExist:
                pass

    return render(request, 'get.html')
## PRESTASHOP
def get_type_of_features(request):

    url = 'http://sklep.wojnaopon.pl/api/product_features'

    type_of_feature_response = requests.get(url, auth=(USERNAME, PASSWORD))
    tree = ET.fromstring(type_of_feature_response.content)

    # type_of_feature ID #
    type_of_feature = []
    for node in tree.iter('product_feature'):
        type_of_feature_id = node.get('id')
        type_of_feature.append(type_of_feature_id)

    # type_of_feature details #
    for feature_id in type_of_feature:
        features_url = url + '/' + feature_id
        type_of_feature_response = requests.get(features_url, auth=(USERNAME, PASSWORD))
        tree = ET.fromstring(type_of_feature_response.content)

        for child in tree:
            wo_feature_id = child.find('id').text
            wo_feature_name = child.find('name')
            for node in wo_feature_name:
                wo_feature_name = node.text

            defaults = {'name': wo_feature_name}
            try:
                obj = Type_of_feature.objects.get(name=wo_feature_name)
                for key, value in defaults.items():
                    setattr(obj, key, value)
                obj.save()
            except Type_of_feature.DoesNotExist:
                new_values = {'name': wo_feature_name, 'type_of_feature_wo_id': wo_feature_id}
                obj = Type_of_feature(**new_values)
                obj.save()

    return render(request, 'get.html')

def get_feature_details(request):

    presta = WojnaOpon.objects.all().values_list('speed_index', 'load_index', 'rolling_resistance', 'adhesion', 'noise', 'noise_symbole', 'additional_marking', 'width', 'profile', 'rim', 'dot')
    for row in presta:
        speed_index = row[0]
        load_index = row[1]
        rolling_resistance = row[2]
        adhesion = row[3]
        noise = row[4]
        noise_symbole = row[5]
        additional_marking = row[6]
        width = row[7]
        profile = row[8]
        rim = row[9]
        dot = row[10]

        if len(dot) < 5:
            if len(dot) == 4:
                dot = dot[2:]
                dot = '20' + dot
            else:
                dot = '20' + dot

        type_of_feature_id = 11
        defaults = {'value': noise}
        try:
            obj = Feature.objects.get(value=noise, type_of_feature_wo_id=Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id))
            for key, value in defaults.items():
                setattr(obj, key, value)
            obj.save()
        except Feature.DoesNotExist:
            new_values = {'value': noise, 'type_of_feature_wo_id': Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id)}
            obj = Feature(**new_values)
            obj.save()

        # type_of_feature_id = 19
        # defaults = {'value': additional_marking}
        # try:
        #     obj = Feature.objects.get(value=additional_marking, type_of_feature_wo_id=Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id))
        #     for key, value in defaults.items():
        #         setattr(obj, key, value)
        #     obj.save()
        # except Feature.DoesNotExist:
        #     new_values = {'value': additional_marking, 'type_of_feature_wo_id': Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id)}
        #     obj = Feature(**new_values)
        #     obj.save()

        # type_of_feature_id = 13
        # defaults = {'value': dot}
        # try:
        #     obj = Feature.objects.get(value=dot, type_of_feature_wo_id=Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id))
        #     for key, value in defaults.items():
        #         setattr(obj, key, value)
        #     obj.save()
        # except Feature.DoesNotExist:
        #     new_values = {'value': dot, 'type_of_feature_wo_id': Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id)}
        #     obj = Feature(**new_values)
        #     obj.save()

        # type_of_feature_id = 7
        # defaults = {'value': speed_index}
        # try:
        #     obj = Feature.objects.get(value=speed_index, type_of_feature_wo_id=Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id))
        #     for key, value in defaults.items():
        #         setattr(obj, key, value)
        #     obj.save()
        # except Feature.DoesNotExist:
        #     new_values = {'value': speed_index, 'type_of_feature_wo_id': Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id)}
        #     obj = Feature(**new_values)
        #     obj.save()


        # type_of_feature_id = 8
        # defaults = {'value': load_index}
        # try:
        #     obj = Feature.objects.get(value=load_index, type_of_feature_wo_id=Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id))
        #     for key, value in defaults.items():
        #         setattr(obj, key, value)
        #     obj.save()
        # except Feature.DoesNotExist:
        #     new_values = {'value': load_index, 'type_of_feature_wo_id': Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id)}
        #     obj = Feature(**new_values)
        #     obj.save()


        # type_of_feature_id = 9
        # defaults = {'value': rolling_resistance}
        # try:
        #     obj = Feature.objects.get(value=rolling_resistance, type_of_feature_wo_id=Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id))
        #     for key, value in defaults.items():
        #         setattr(obj, key, value)
        #     obj.save()
        # except Feature.DoesNotExist:
        #     new_values = {'value': rolling_resistance, 'type_of_feature_wo_id': Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id)}
        #     obj = Feature(**new_values)
        #     obj.save()


        # type_of_feature_id = 10
        # defaults = {'value': adhesion}
        # try:
        #     obj = Feature.objects.get(value=adhesion, type_of_feature_wo_id=Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id))
        #     for key, value in defaults.items():
        #         setattr(obj, key, value)
        #     obj.save()
        # except Feature.DoesNotExist:
        #     new_values = {'value': adhesion, 'type_of_feature_wo_id': Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id)}
        #     obj = Feature(**new_values)
        #     obj.save()


        # type_of_feature_id = 11
        # defaults = {'value': noise}
        # try:
        #     obj = Feature.objects.get(value=noise, type_of_feature_wo_id=Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id))
        #     for key, value in defaults.items():
        #         setattr(obj, key, value)
        #     obj.save()
        # except Feature.DoesNotExist:
        #     new_values = {'value': noise, 'type_of_feature_wo_id': Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id)}
        #     obj = Feature(**new_values)
        #     obj.save()


        # type_of_feature_id = 12
        # defaults = {'value': noise_symbole}
        # try:
        #     obj = Feature.objects.get(value=noise_symbole, type_of_feature_wo_id=Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id))
        #     for key, value in defaults.items():
        #         setattr(obj, key, value)
        #     obj.save()
        # except Feature.DoesNotExist:
        #     new_values = {'value': noise_symbole, 'type_of_feature_wo_id': Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id)}
        #     obj = Feature(**new_values)
        #     obj.save()

        # type_of_feature_id = 1
        # defaults = {'value': width}
        # try:
        #     obj = Feature.objects.get(value=width, type_of_feature_wo_id=Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id))
        #     for key, value in defaults.items():
        #         setattr(obj, key, value)
        #     obj.save()
        # except Feature.DoesNotExist:
        #     new_values = {'value': width, 'type_of_feature_wo_id': Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id)}
        #     obj = Feature(**new_values)
        #     obj.save()


        # type_of_feature_id = 2
        # defaults = {'value': profile}
        # try:
        #     obj = Feature.objects.get(value=profile, type_of_feature_wo_id=Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id))
        #     for key, value in defaults.items():
        #         setattr(obj, key, value)
        #     obj.save()
        # except Feature.DoesNotExist:
        #     new_values = {'value': profile, 'type_of_feature_wo_id': Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id)}
        #     obj = Feature(**new_values)
        #     obj.save()


        # type_of_feature_id = 3
        # defaults = {'value': rim}
        # try:
        #     obj = Feature.objects.get(value=rim, type_of_feature_wo_id=Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id))
        #     for key, value in defaults.items():
        #         setattr(obj, key, value)
        #     obj.save()
        # except Feature.DoesNotExist:
        #     new_values = {'value': rim, 'type_of_feature_wo_id': Type_of_feature.objects.get(type_of_feature_wo_id=type_of_feature_id)}
        #     obj = Feature(**new_values)
        #     obj.save()


    return render(request, 'get.html')

def get_features_id(request):

    url = 'http://sklep.wojnaopon.pl/api/product_feature_values'

    type_of_feature_response = requests.get(url, auth=(USERNAME, PASSWORD))
    tree = ET.fromstring(type_of_feature_response.content)

    id_of_feature = []
    for node in tree.iter('product_feature_value'):
        feature_id = node.get('id')
        id_of_feature.append(feature_id)

    # type_of_feature details #
    for feature_id in id_of_feature:
        features_url = url + '/' + feature_id
        type_of_feature_response = requests.get(features_url, auth=(USERNAME, PASSWORD))
        tree = ET.fromstring(type_of_feature_response.content)

        for child in tree:
            wo_feature_id = child.find('id').text
            id_feature = child.find('id_feature').text
            wo_feature_name = child.find('value')
            for node in wo_feature_name:
                wo_feature_name = node.text

            if wo_feature_name is not None:
                defaults = {'feature_wo_id': wo_feature_id}
                try:
                    obj = Feature.objects.get(value=wo_feature_name, type_of_feature_wo_id=Type_of_feature.objects.get(type_of_feature_wo_id=id_feature))
                    for key, value in defaults.items():
                        setattr(obj, key, value)
                    obj.save()
                except Feature.DoesNotExist:
                    pass

    return render(request, 'get.html')

def create_feature(request):

    # type_of_features = Type_of_feature.objects.all().values_list('type_of_feature_wo_id')
    # for item in type_of_features:
    #     presta_type_feature = item[0]
    presta_type_feature = '1'
    features = Feature.objects.filter(type_of_feature_wo_id__type_of_feature_wo_id=presta_type_feature).values_list('value', 'type_of_feature_wo_id__type_of_feature_wo_id')
    # id_feature = '11'
    for item in features:
        value = item[0]
        type_of_feature_wo_id = item[1]

        data_1 = u"""<?xml version="1.0" encoding="UTF-8"?><prestashop xmlns:xlink="http://www.w3.org/1999/xlink"><product_feature_value><id></id><id_feature>"""
        data_2 = type_of_feature_wo_id
        data_3 = u"""</id_feature><custom></custom><value><language id="1">"""
        data_4 = value
        data_5 = u"""</language></value></product_feature_value></prestashop>"""
        data = data_1 + data_2 + data_3 + data_4 + data_5
        r = requests.post('http://sklep.wojnaopon.pl/api/product_feature_values?schema=blank', auth=(USERNAME, PASSWORD), data = data.encode('utf-8'))

    return render(request, 'get.html')

def get_product_id(request):

    WojnaOpon.objects.update(wo_product_id='')
    WojnaOpon.objects.update(stock_availables_id='')

    url = 'http://sklep.wojnaopon.pl/api/products'
    # url_stocks = 'http://sklep.wojnaopon.pl/api/stock_availables'

    ordersID_response = requests.get(url, auth=(USERNAME, PASSWORD))
    tree = ET.fromstring(ordersID_response.content)

    # PRODUCTS ID #
    products_ids = []
    for node in tree.iter():
        productID = node.get('id')
        if productID is not None:
            products_ids.append(productID)

    for node in products_ids:
        order_url = url + '/' + node
        order_response = requests.get(order_url, auth=(USERNAME, PASSWORD))
        root = ET.fromstring(order_response.content)
        for child in root:
            wo_product_id = child.find('id').text
            sap = child.find('reference').text

            # PRODUKT #
            defaults = {'wo_product_id': wo_product_id}
            try:
                obj = WojnaOpon.objects.get(sap=sap)
                for key, value in defaults.items():
                    setattr(obj, key, value)
                obj.save()
            except WojnaOpon.DoesNotExist:
                pass
            # PRODUKT #

            associations = child.find('associations')
            stock_availables = associations.find('stock_availables')
            stock_available = stock_availables.find('stock_available')
            stock_available_id = stock_available.find('id').text

            defaults = {'stock_availables_id': stock_available_id}
            try:
                obj = WojnaOpon.objects.get(sap=sap)
                for key, value in defaults.items():
                    setattr(obj, key, value)
                obj.save()
            except WojnaOpon.DoesNotExist:
                pass
            # PRODUKT #

    return render(request, 'get.html')
# aktualizacja produktów prestashop
def update_product(request):

    product = WojnaOpon.objects.all().values_list('producer__wo_id', 'model__name', 'provider__name', 'sap', 'wo_product_id', 'stock_availables_id', 'width', 'profile', 'rim', 'speed_index', 'load_index', 'rolling_resistance', 'adhesion', 'noise', 'noise_symbole', 'additional_marking', 'dot', 'price', 'stock', 'available', 'model__season', 'model__type', 'model__description', 'producer__name', 'model__image', 'producer__warranty')
    for row in product:
        producer_wo_id = row[0]
        model = row[1]
        provider = row[2]
        sap = row[3]
        # ean = row[4]
        wo_product_id = row[4]
        stock_availables_id = row[5]
        width = row[6]
        profile = row[7]
        rim = row[8]
        speed_index = row[9]
        load_index = row[10]
        rolling_resistance = row[11]
        adhesion = row[12]
        noise = row[13]
        noise_symbole = row[14]
        additional_marking = row[15]
        dot = row[16]
        price = row[17]
        stock = row[18]
        available = row[19]
        season = row[20]
        type = row[21]
        description = row[22]
        producer_name = row[23]
        model_image = row[24]
        warranty = row[25]

        if warranty is '':
            warranty = '6113'

        # NAME
        if len(additional_marking) > 0:
            name = producer_name + ' ' + width + '/' + profile + 'R' + rim + ' ' + model + ' ' + load_index + '' + speed_index + ' ' + additional_marking + ' ' + rolling_resistance + ' ' + adhesion + ' ' + noise + ' ' + noise_symbole
        else:
            name = producer_name + ' ' + width + '/' + profile + 'R' + rim + ' ' + model + ' ' + load_index + '' + speed_index + ' ' + rolling_resistance + ' ' + adhesion + ' ' + noise + ' ' + noise_symbole

        # width
        width_id = ''
        features = Feature.objects.filter(value__exact=width, type_of_feature_wo_id__type_of_feature_wo_id=1).values_list('feature_wo_id')
        for item in features:
            width_id += item[0]

        # profile
        profile_id = ''
        features = Feature.objects.filter(value__exact=profile, type_of_feature_wo_id__type_of_feature_wo_id=2).values_list('feature_wo_id')
        for item in features:
            profile_id += item[0]

        # rim
        rim_id = ''
        features = Feature.objects.filter(value__exact=rim, type_of_feature_wo_id__type_of_feature_wo_id=3).values_list('feature_wo_id')
        for item in features:
            rim_id += item[0]

        # speed_index
        speed_index_id = ''
        features = Feature.objects.filter(value__exact=speed_index, type_of_feature_wo_id__type_of_feature_wo_id=7).values_list('feature_wo_id')
        for item in features:
            speed_index_id += item[0]

        # load_index
        load_index_id = ''
        features = Feature.objects.filter(value__exact=load_index, type_of_feature_wo_id__type_of_feature_wo_id=8).values_list('feature_wo_id')
        for item in features:
            load_index_id += item[0]

        # rolling_resistance
        rolling_resistance_id = ''
        features = Feature.objects.filter(value__exact=rolling_resistance, type_of_feature_wo_id__type_of_feature_wo_id=9).values_list('feature_wo_id')
        for item in features:
            rolling_resistance_id += item[0]

        # adhesion
        adhesion_id = ''
        features = Feature.objects.filter(value__exact=adhesion, type_of_feature_wo_id__type_of_feature_wo_id=10).values_list('feature_wo_id')
        for item in features:
            adhesion_id += item[0]

        # noise
        noise_id = ''
        features = Feature.objects.filter(value__exact=noise, type_of_feature_wo_id__type_of_feature_wo_id=11).values_list('feature_wo_id')
        for item in features:
            noise_id += item[0]

        # noise_symbole
        noise_symbole_id = ''
        features = Feature.objects.filter(value__exact=noise_symbole, type_of_feature_wo_id__type_of_feature_wo_id=12).values_list('feature_wo_id')
        for item in features:
            noise_symbole_id += item[0]

        # additional_marking
        additional_marking_id = ''
        features = Feature.objects.filter(value__exact=additional_marking, type_of_feature_wo_id__type_of_feature_wo_id=19).values_list('feature_wo_id')
        for item in features:
            additional_marking_id += item[0]

        # type
        type_id = ''
        features = Feature.objects.filter(value__exact=type, type_of_feature_wo_id__type_of_feature_wo_id=21).values_list('feature_wo_id')
        for item in features:
            type_id += item[0]

        # dot
        if len(dot) < 5:
            if len(dot) == 4:
                dot = dot[2:]
                dot = '20' + dot
            else:
                dot = '20' + dot

        dot_id = ''
        features = Feature.objects.filter(value__exact=dot, type_of_feature_wo_id__type_of_feature_wo_id=13).values_list('feature_wo_id')
        for item in features:
            dot_id += item[0]

        # season
        if season == 'Letnie':
            season_id = '723'
        if season == 'Zimowe':
            season_id = '724'
        if season == 'Całoroczne':
            season_id = '1257'

        # provider
        if provider == 'Elit':
            provider_id = '1935'
            realization_id = '116'
        else:
            provider_id = '1934'
            realization_id = '6112'

        # category
        category_id_1 = 2
        if season == 'Letnie' and type == 'Osobowe':
            category_id_2 = 15
            category_id_3 = 18

        if season == 'Letnie' and type == 'Dostawcze':
            category_id_2 = 15
            category_id_3 = 19

        if season == 'Zimowe' and type == 'Osobowe':
            category_id_2 = 16
            category_id_3 = 20

        if season == 'Zimowe' and type == 'Dostawcze':
            category_id_2 = 16
            category_id_3 = 21

        if season == 'Całoroczne' and type == 'Osobowe':
            category_id_2 = 17
            category_id_3 = 22

        if season == 'Całoroczne' and type == 'Dostawcze':
            category_id_2 = 17
            category_id_3 = 23


        # informacje dodatkowe
        extra_text_product = ' - Ekspresowa dostawa! ROK PRODUKCJI: ' + str(dot)
        name_slug = name.lower().replace(' ', '-').replace(')','').replace('/','').replace('+','').replace('.','-')
        link_rewrite = name_slug

        if  wo_product_id is not '':
            categories = {'category1': {'id': category_id_1}, 'category2': {'id': category_id_2}, 'category3': {'id': category_id_3}}
            if additional_marking_id is not '':
                product_features = {'product_feature1': {'id': '1', 'id_feature_value': width_id}, 'product_feature2': {'id': '2', 'id_feature_value': profile_id}, 'product_feature3': {'id': '3', 'id_feature_value': rim_id}, 'product_feature4': {'id': '7', 'id_feature_value': speed_index_id}, 'product_feature5': {'id': '8', 'id_feature_value': load_index_id}, 'product_feature6': {'id': '9', 'id_feature_value': rolling_resistance_id}, 'product_feature7': {'id': '10', 'id_feature_value': adhesion_id}, 'product_feature8': {'id': '11', 'id_feature_value': noise_id}, 'product_feature9': {'id': '12', 'id_feature_value': noise_symbole_id}, 'product_feature10': {'id': '6', 'id_feature_value': season_id}, 'product_feature11': {'id': '21', 'id_feature_value': type_id}, 'product_feature12': {'id': '20', 'id_feature_value': provider_id}, 'product_feature13': {'id': '13', 'id_feature_value': dot_id}, 'product_feature14': {'id': '19', 'id_feature_value': additional_marking_id}, 'product_feature15': {'id': '18', 'id_feature_value': realization_id}, 'product_feature16': {'id': '22', 'id_feature_value': warranty}}
            else:
                product_features = {'product_feature1': {'id': '1', 'id_feature_value': width_id}, 'product_feature2': {'id': '2', 'id_feature_value': profile_id}, 'product_feature3': {'id': '3', 'id_feature_value': rim_id}, 'product_feature4': {'id': '7', 'id_feature_value': speed_index_id}, 'product_feature5': {'id': '8', 'id_feature_value': load_index_id}, 'product_feature6': {'id': '9', 'id_feature_value': rolling_resistance_id}, 'product_feature7': {'id': '10', 'id_feature_value': adhesion_id}, 'product_feature8': {'id': '11', 'id_feature_value': noise_id}, 'product_feature9': {'id': '12', 'id_feature_value': noise_symbole_id}, 'product_feature10': {'id': '6', 'id_feature_value': season_id}, 'product_feature11': {'id': '21', 'id_feature_value': type_id}, 'product_feature12': {'id': '20', 'id_feature_value': provider_id}, 'product_feature13': {'id': '13', 'id_feature_value': dot_id}, 'product_feature14': {'id': '18', 'id_feature_value': realization_id}, 'product_feature15': {'id': '22', 'id_feature_value': warranty}}
            associations = {'categories': categories, 'product_features': product_features}

            # print('Update Product:', sap)
            # edit stocks
            data = {'stock_availables': {'id': stock_availables_id, 'id_product': wo_product_id, 'id_shop ': id_shop, 'id_product_attribute': id_product_attribute, 'depends_on_stock': depends_on_stock, 'out_of_stock': out_of_stock, 'quantity': stock}}
            res = api.edit('stock_availables', data)['stock_available']
            # edit product
            data = {'products': {'id': wo_product_id, 'name': name, 'price': str(price), 'extra_text_product': extra_text_product, 'active': active, 'weight': weight, 'reference': sap, 'ean13': ean, 'id_manufacturer': producer_wo_id, 'description': description, 'id_category_default': category_id_3, 'in_price_compare': in_price_compare, 'ceneo_basket': ceneo_basket, 'available_for_order': available_for_order, 'link_rewrite': link_rewrite, 'minimal_quantity': minimal_quantity, 'associations': associations, 'id_tax_rules_group': id_tax_rules_group, 'state': state, 'redirect_type': redirect_type, 'show_price': show_price}}
            res = api.edit('products', data)['product']
    # print('Zadanie wykonane')
    return render(request, 'get.html')
# dodawanie produktów na prestashop
def add_product(request):

    product = WojnaOpon.objects.all().values_list('producer__wo_id', 'model__name', 'provider__name', 'sap', 'wo_product_id', 'stock_availables_id', 'width', 'profile', 'rim', 'speed_index', 'load_index', 'rolling_resistance', 'adhesion', 'noise', 'noise_symbole', 'additional_marking', 'dot', 'price', 'stock', 'available', 'model__season', 'model__type', 'model__description', 'producer__name', 'model__image')
    for row in product:
        producer_name = row[23]
        width = row[6]
        profile = row[7]
        rim = row[8]
        model = row[1]
        load_index = row[10]
        speed_index = row[9]
        additional_marking = row[15]
        rolling_resistance = row[11]
        adhesion = row[12]
        noise = row[13]
        noise_symbole = row[14]
        sap = row[3]
        price = row[17]
        model_image = row[24]
        wo_product_id = row[4]
        available = row[19]

        category_id_1 = 2
        # NAME
        if len(additional_marking) > 0:
            name = producer_name + ' ' + width + '/' + profile + 'R' + rim + ' ' + model + ' ' + load_index + '' + speed_index + ' ' + additional_marking + ' ' + rolling_resistance + ' ' + adhesion + ' ' + noise + ' ' + noise_symbole
        else:
            name = producer_name + ' ' + width + '/' + profile + 'R' + rim + ' ' + model + ' ' + load_index + '' + speed_index + ' ' + rolling_resistance + ' ' + adhesion + ' ' + noise + ' ' + noise_symbole

        if wo_product_id is '' and available is True:
            data_1 = """<?xml version="1.0" encoding="UTF-8"?><prestashop xmlns:xlink="http://www.w3.org/1999/xlink"><product><id_category_default>"""
            data_2 = str(category_id_1)
            data_3 = """</id_category_default><new></new><id_tax_rules_group>7</id_tax_rules_group><id_shop_default>1</id_shop_default><reference>"""
            data_4 = str(sap)
            data_5 = """</reference><state>1</state><minimal_quantity>1</minimal_quantity><price>"""
            data_6 = str(price)
            data_7 = """</price><active>1</active><redirect_type>404</redirect_type><available_for_order>1</available_for_order><show_price>1</show_price><indexed>1</indexed><visibility>both</visibility><name><language id="1">"""
            data_8 = str(name)
            data_9 = """</language></name><associations><categories><category><id>"""
            data_10 = str(category_id_1)
            data_11 = """</id></category></categories></associations></product></prestashop>"""

            data = data_1 + data_2 + data_3 + data_4 + data_5 + data_6 + data_7 + data_8 + data_9 + data_10 + data_11
            r = requests.post('http://sklep.wojnaopon.pl/api/products', auth=(USERNAME, PASSWORD), data = data)

            # print(sap)
            res = api.get('search', {'query': sap, 'language': 1})
            pres_id = res['products']['product']['@id']

            # add image
            with open('temp.jpg', 'wb') as handler:
                handler.write(requests.get(model_image).content)
            res = api.add_image('products/' + str(pres_id), 'temp.jpg')

            # add presta_id
            defaults = {'wo_product_id': pres_id}
            try:
                obj = WojnaOpon.objects.get(sap=sap)
                for key, value in defaults.items():
                    setattr(obj, key, value)
                obj.save()
            except WojnaOpon.DoesNotExist:
                pass

            # add stock_id
            res = api.get('products/' + str(pres_id))
            presta_stock_id = res['product']['associations']['stock_availables']['stock_available']['id']
            defaults = {'stock_availables_id': presta_stock_id}
            try:
                obj = WojnaOpon.objects.get(sap=sap)
                for key, value in defaults.items():
                    setattr(obj, key, value)
                obj.save()
            except WojnaOpon.DoesNotExist:
                pass

    print('Zadanie wykonane')
    return render(request, 'get.html')

# def get_producers(request):
#     # pobieranie stanów WO
#     ftpG = FTP(serverG)  # Set server address
#     ftpG.login("stany_mag", "GlobeTyre$#")  # Connect to server
#     ftpG.cwd(directoryG)  # Move to the desired folder in server
#     ftpG.retrbinary('RETR ' + filenameG, open(filenameG, 'wb').write)  # Download file from server
#     ftpG.close()  # Close connection

#     # Load the CSV file into CSV reader
#     csvfile = open('WojnaOpon.csv', 'rt', encoding="utf8")
#     creader = csv.reader(csvfile, delimiter=';', quotechar='|')

#     # Iterate through the CSV reader, inserting values into the database
#     next(creader)
#     for row in creader:
#         producer = row[1].upper()


#         defaults = {'name': producer}
#         try:
#             obj = Producer.objects.get(name=producer)
#             for key, value in defaults.items():
#                 setattr(obj, key, value)
#             obj.save()
#         except Producer.DoesNotExist:
#             new_values = {'name': producer}
#             obj = Producer(**new_values)
#             obj.save()
#     return render(request, 'get.html')