import os,xml.dom.minidom
class general:
    def __init__(self,code=0):
        self.setCode(code)
    def setCode(self,value):self.__code=value
    def getCode(self):return self.__code

class Client(general):
    def __init__ (self, code, surname, name, middlename, passport):
        general.__init__(self,code)
        self.setSurname(surname)
        self.setName(name)
        self.setMiddlename(middlename)
        self.setPassport(passport)
    def setSurname (self, value): self.__surname = value
    def getSurname (self): return self.__surname
    def setName (self, value): self.__name = value
    def getName (self): return self.__name
    def setMiddlename (self, value): self.__middlename = value
    def getMiddlename (self): return self.__middlename
    def setPassport (self, value): self.__passport = value
    def getPassport (self): return self.__passport
    def ChangeSurname (self, newSurname): self.__surname = newSurname
    def ChangeName (self, newName): self.__name = newName
    def ChangeMiddlename (self, newMiddlename): self.__midllename = newMiddlename
    def ChangePassport (self, newPassport): self.__passport = newPassport
    def getClient(self):
        s1 = "%s %s %s %s" % (self.getSurname(), self.getName(), self.getMiddlename(),self.getPassport())
        return s1

class Phone(general):
    def __init__ (self, code, color, phonetype, phonenumber):
        general.__init__(self,code)
        self.setColor(color)
        self.setPhoneType(phonetype)
        self.setPhoneNumber(phonenumber)
    def setColor(self, value): self.__color = value
    def getColor(self): return self.__color
    def setPhoneType(self, value): self.__phonetype = value
    def getPhoneType(self): return self.__phonetype
    def setPhoneNumber(self, value): self.__phonenumber = value
    def getPhoneNumber(self): return self.__phonenumber
    def ChangePhonenumber(self, newPhonenumber): self.__phonenumber = newPhonenumber
    def getPhone(self):
        s2 = "%s %s %s" % (self.getColor(), self.getPhoneType(), self.getPhoneNumber())
        return s2

class Service(Client, Phone, general):
    def __init__ (self, code, Client, Phone, ServiceType, Price):
        general.__init__(self,code)
        self.setPhone(Phone)
        self.setClient(Client)
        self.setServiceType(ServiceType)
        self.setPrice(Price)
    def setServiceType (self, value): self.__ServiceType = value
    def getServiceType (self): return self.__ServiceType
    def setPrice (self, value): self.__price = value
    def getPrice (self): return self.__price
    def setClient (self, value): self.__Client = value
    def setPhone (self, value): self.__Phone = value
    def getClientCode(self):
        if self.__Client:return self.__Client.getCode()
    def getPhoneCode(self):
        if self.__Phone:return self.__Phone.getCode()
    def getService(self):
        s3 = "%s %s %s %s" % (self.__Client.getClient(),self.__Phone.getPhone(), self.getServiceType(), self.getPrice())
        return s3

class generalList:
 def __init__(self):self.__list=[]
 def clear(self):self.__list=[]
 def findByCode(self,code):
    for l in self.__list:
        if l.getCode()==code:
          return l
          break
 def getCodes(self):return [s.getCode() for s in self.__list]
 def appendList(self,value):self.__list.append(value)
 def removeList(self,code):
    for s in self.__list:
        if s.getCode()==code:self.__list.remove(s)
 def getCode(self,code):return self.findByCode(code).getCode()

class ClientList(generalList):
    def getSurname(self,code):return self.findByCode(code).getSurname()
    def getName(self,code):return self.findByCode(code).getName()
    def getMiddlename(self,code):return self.findByCode(code).getMiddlename()
    def getPassport(self,code):return self.findByCode(code).getPassport()
    def getClientList(self, code):
        s4 = "%s %s %s %s" % (self.findByCode(code).getSurname(), self.findByCode(code).getName(),self.findByCode(code).getMiddlename(), self.findByCode(code).getPassport())
        return s4

class PhoneList(generalList):
    def getColor(self,code):return self.findByCode(code).getColor()
    def getPhoneType(self,code):return self.findByCode(code).getPhoneType()
    def getPhoneNumber(self,code):return self.findByCode(code).getPhoneNumber()
    def getPhoneList(self, code):
        s5 = "%s %s %s" % (self.findByCode(code).getColor(), self.findByCode(code).getPhoneType(),self.findByCode(code).getPhoneNumber())
        return s5

class ServiceList(generalList):
    def getCode(self,code):return self.findByCode(code).getCode()
    def getServiceType(self,code):return self.findByCode(code).getServiceType()
    def getPrice(self,code):return self.findByCode(code).getPrice()
    def getServiceList(self, code):
        s6 = "%s %s" % (self.findByCode(code).getServiceType(),self.findByCode(code).getPrice())
        return s6

class generalListEdit(generalList):
 def getNewCode(self):
  m=0
  for c in self.getCodes():
   if c>m:m=c
  return m+1
 def setName(self,code,value):return self.findByCode(code).setName(value)

class ClientListEdit(ClientList,generalListEdit):
 def newRec(self,code=0,surname='',name='',middlename='',passport=''):self.appendList(Client(code,surname,name,middlename,passport))
 def setSurname(self,code,value):self.findByCode(code).setSurname(value)
 def setName(self,code,value):self.findByCode(code).setName(value)
 def setMiddlename(self,code,value):self.findByCode(code).setMiddlename(value)
 def setPassport(self,code,value):self.findByCode(code).setPassport(value)

class PhoneListEdit(PhoneList,generalListEdit):
 def newRec(self,code=0, color='',phonetype='',phonenumber=''):self.appendList(Phone(code, color, phonetype, phonenumber))
 def setColor(self,code,value):self.findByCode(code).setColor(value)
 def setPhoneType(self,code,value):self.findByCode(code).setPhoneType(value)
 def setPhoneNumber(self,code,value):self.findByCode(code).setPhoneNumber(value)

class ServiceListEdit(ServiceList,generalListEdit):
 def newRec(self,code,Client='', Phone='', ServiceType='', Price=''):
     self.appendList(Service(code,Client, Phone, ServiceType, Price))
 def setServiceType(self,code,value):self.findByCode(code).setServiceType(value)
 def setPrice(self,code,value):self.findByCode(code).setPrice(value)
 def getClientCode(self,code):return self.findByCode(code).getClientCode()
 def getPhoneCode(self,code):
     return self.findByCode(code).getPhoneCode()




class Servicecenter(ClientListEdit,PhoneListEdit,ServiceListEdit):
    def __init__(self):
        self.__Clients=ClientListEdit()
        self.__Phones=PhoneListEdit()
        self.__Services=ServiceListEdit()
    def removeClient(self,code):
        b = True
        for c in self.getServiceCodes():
            if self.getServiceClientCode(c) == code:
                b = False
                break
        if b:
            self.__Clients.removeList(code)
        #for c in self.__Services.getCodes():
          #self.__Services.removeClient(c, code)
    def removePhone(self,code):
        d = True
        for c in self.getServiceCodes():
            if self.getServicePhoneCode(c) == code:
                d = False
                break
        if d:
            self.__Phones.removeList(code)
        #for c in self.__Services.getCodes():
         #self.__Services.setPhone(c,None)
    def test(self,code):
        return self.__Services.findByCode(code).getCode()
    def clear(self):
        self.__Services.clear()
        self.__Clients.clear()
        self.__Phones.clear()
    def newClient(self,code=0,surname='',name='',middlename='',passport=''):self.__Clients.newRec(code,surname,name, middlename, passport)
    def findClientByCode(self,code):return self.__Clients.findByCode(code)
    def getClientNewCode(self):return self.__Clients.getNewCode()
    def getClientCodes(self):return self.__Clients.getCodes()
    def getClientName(self,code):return self.__Clients.getName(code)
    def getClientSurname(self,code):return self.__Clients.getSurname(code)
    def getClientMiddleName(self,code):return self.__Clients.getMiddlename(code)
    def getClientPassport(self,code):return self.__Clients.getPassport(code)
    def setClientName(self,code,value):self.__Clients.setName(code,value)
    def setClientSurname(self,code,value):self.__Clients.setSurname(code,value)
    def setClientMiddlename(self,code,value):self.__Clients.setMiddlename(code,value)
    def setClientPassport(self,code,value):self.__Clients.setPassport(code,value)

    def newPhone(self,code=0,color='',Phonetype='', Phonenumber=''):self.__Phones.newRec(code,color,Phonetype, Phonenumber)
    def findPhoneByCode(self,code):return self.__Phones.findByCode(code)
    def getPhoneNewCode(self):return self.__Phones.getNewCode()
    def getPhoneCodes(self):return self.__Phones.getCodes()
    def getPhoneColor(self,code):return self.__Phones.getColor(code)
    def getPhoneType(self,code):return self.__Phones.getPhoneType(code)
    def getPhoneNumber(self,code):return self.__Phones.getPhoneNumber(code)
    def getPhoneNewCode(self):return self.__Phones.getNewCode()
    def setPhoneColor(self,code,value):self.__Phones.setColor(code,value)
    def setPhoneType(self,code,value):self.__Phones.setPhoneType(code,value)
    def setPhoneNumber(self,code,value):self.__Phones.setPhoneNumber(code,value)
    def removeService(self,code):
        self.__Services.removeList(code)

    def newService(self,code, client, phone, ServiceType='', Price=''):
        self.__Services.newRec(code, client, phone,ServiceType, Price)
    def findSericeByCode(self,code):return self.__Services.findByCode(code).getService()
    def setServiceServiceType(self,code,value):self.__Services.setServiceType(code,value)
    def setServicePrice(self,code,value):self.__Services.setPrice(code,value)
    def getServiceCodes(self):return self.__Services.getCodes()
    def getServiceNewCode(self):return self.__Services.getNewCode()
    def getServiceType(self,code):return self.__Services.getServiceType(code)
    def getServicePrice(self,code):return self.__Services.getPrice(code)
    def getServiceClientCode(self,code):return self.__Services.getClientCode(code)
    def getServicePhoneCode(self, code):return self.__Services.getPhoneCode(code)
    def getAll(self, code):
        s10="%s %s %s" % (self.__Clients.getClientList(code),self.__Phones.getPhoneList(code), self.__Services.getServiceList(code))
        return s10

class dataxml:
    def read(self, inp, cent):
        dom = xml.dom.minidom.parse(inp)
        dom.normalize()
        for node in dom.childNodes[0].childNodes:
            if (node.nodeType == node.ELEMENT_NODE) and (node.nodeName == "client"):
                code, name, surname, middlename, passport = 0, "", "", "", ""
                for t in node.attributes.items():
                    if t[0] == "code":
                        code = int(t[1])
                    if t[0] == "name":
                        name = t[1]
                    if t[0] == "surname":
                        surname = t[1]
                    if t[0] == "middlename":
                        middlename = t[1]
                    if t[0] == "passport":
                        passport = t[1]
                cent.newClient(code, name, surname, middlename, passport)
            if (node.nodeType == node.ELEMENT_NODE) and (node.nodeName == "phone"):
                code, color, phonetype, phonenumber = 0,"", "", ""
                for t in node.attributes.items():
                    if t[0] == "code":
                        code = int(t[1])
                    if t[0] == "color":
                        color = t[1]
                    if t[0] == "phonetype":
                        phonetype = t[1]
                    if t[0] == "phonenumber":
                        phonenumber = t[1]
                cent.newPhone(code, color, phonetype, phonenumber)
            if (node.nodeType == node.ELEMENT_NODE) and (node.nodeName == "service"):
                code, servicetype, price, client, phone, = 0, "", "",None,None
                for t in node.attributes.items():
                    if t[0] == "code":
                        code = int(t[1])
                    if t[0] == "servicetype":
                        servicetype = t[1]
                    if t[0] == "price":
                        price = t[1]
                    if t[0] == "Client":
                        client = cent.findClientByCode(int(t[1]))
                    if t[0] == "Phone":
                        phone = cent.findPhoneByCode(int(t[1]))
                cent.newService(code, servicetype, price, client, phone)
                for n in node.childNodes:
                    if (n.nodeType == n.ELEMENT_NODE) and (n.nodeName == "Client"):
                        for t in n.attributes.items():
                            if t[0] == "code":
                                Client = cent.findClientByCode(int(t[1]))
                for n in node.childNodes:
                    if (n.nodeType == n.ELEMENT_NODE) and (n.nodeName == "Phone"):
                        for t in n.attributes.items():
                            if t[0] == "code":
                                Phone = cent.findPhoneByCode(int(t[1]))
    def write(self, out, cent):
        dom = xml.dom.minidom.Document()
        root = dom.createElement("Servicecenter")
        dom.appendChild(root)
        for c in cent.getClientCodes():
            bk = dom.createElement("Client")
            bk.setAttribute("code", str(c))
            bk.setAttribute("name", str(cent.getClientName(c)))
            bk.setAttribute("surname", cent.getClientSurname(c))
            bk.setAttribute("middlename", str(cent.getClientMiddleName(c)))
            bk.setAttribute("passport", str(cent.getClientPassport(c)))
            root.appendChild(bk)
        for c in cent.getPhoneCodes():
            rd = dom.createElement("Phone")
            rd.setAttribute("code", str(c))
            rd.setAttribute("color", cent.getPhoneColor(c))
            rd.setAttribute("phonetype", cent.getPhoneType(c))
            rd.setAttribute("phonenumber", cent.getPhoneNumber(c))
            root.appendChild(rd)
        for c in cent.getServiceCodes():
            vbk = dom.createElement("Service")
            vbk.setAttribute("code", str(c))
            vbk.setAttribute("servicetype", cent.getServiceType(c))
            vbk.setAttribute("price", cent.getServicePrice(c))
            #vbk.setAttribute("Client", str(cent.getClientList(c)))
            #for ac in cent.getClientCodes(c):
            bk = dom.createElement("Client")
            bk.setAttribute("code", str(cent.getServiceClientCode(c)))
            #vbk.setAttribute("Phone", str(cent.getPhoneList(c)))
            #for ac in cent.getPhoneCodes(c):
            rd = dom.createElement("Phone")
            rd.setAttribute("code", str(cent.getServicePhoneCode(c)))
            vbk.appendChild(bk)
            vbk.appendChild(rd)
            root.appendChild(vbk)
        f = open(out, "wb")
        f.write(dom.toprettyxml(encoding='utf-8'))

cent1 = Servicecenter()
dat1 = dataxml()
dat1.read("olda.xml", cent1)
print (4)
print(cent1.getServiceCodes())
for s in cent1.getServiceCodes():
    print(cent1.getAll(s))
print(3)
dat1.write("newa.xml", cent1)
for s in cent1.getServiceCodes():
    print(cent1.getAll(s))
print(1)




import os
import sqlite3 as db

emptydb = """
PRAGMA foreign_keys = ON;

create table client
(code integer primary key,
 surname text,
 name text,
 middlename text,
 passport text);

create table phone
(code integer primary key,
 color text,
 phonetype text,
 phonenumber text);

create table service
(code integer primary key,
 servicetype text,
 price text,
 client integer references author(code) on update cascade on delete set null,
 phone integer references studio(code) on update cascade on delete set null);
"""
class datasql:
    def read(self,inp,lib):
        conn = db.connect(inp)
        curs = conn.cursor()

        curs.execute('select code,surname,name, middlename, passport from client')
        data=curs.fetchall()
        for r in data:lib.newClient(r[0],r[1],r[2], r[3], r[4])

        curs.execute('select code, color, phonetype, phonenumber from phone')
        data=curs.fetchall()
        for r in data:lib.newPhone(r[0],r[1],r[2],r[3])

        curs.execute('select code, servicetype, price, client, phone from service')
        data=curs.fetchall()
        for r in data:lib.newService(r[0],r[1],r[2],lib.findClientByCode(r[3]),lib.findPhoneByCode(r[4]))
    def write(self,out,lib):
        conn = db.connect(out)
        curs = conn.cursor()
        curs.executescript(emptydb)

        for c in lib.getClientCodes():
            curs.execute("insert into client(code,surname,name,middlename,passport) values('%s','%s','%s', '%s', '%s')"%(
                str(c),
                lib.getClientSurname(c),
                lib.getClientName(c),
                lib.getClientMiddleName(c),
                str(lib.getClientPassport(c))))

        for c in lib.getPhoneCodes():
            curs.execute("insert into phone(code,color,phonetype,phonenumber) values('%s','%s','%s','%s')"%(
                str(c),
                lib.getPhoneColor(c),
                lib.getPhoneType(c),
                str(lib.getPhoneNumber(c))))
        for c in lib.getServiceCodes():
            curs.execute("insert into service(code, servicetype, price, client, phone) values('%s','%s','%s','%s','%s')"%(
                str(c),
                lib.getServiceType(c),
                str(lib.getServicePrice(c)),
                str(lib.getServiceClientCode(c)),
                str(lib.getServicePhoneCode(c))))
        conn.commit()
        conn.close()


lib2 = Servicecenter()
dat1 = dataxml()
dat2 = datasql()
dat1.read("olda.xml", lib2)
dat2.write("newa.sqlite", lib2)
lib2.clear()
dat2.read("newa.sqlite", lib2)
dat1.write("tempa.xml", lib2)
print(2)
print(lib2.getServiceCodes())
for s in lib2.getServiceCodes():
    print (lib2.getAll(s))