adressevedligehold/fileupload/AddressManager.java

package dk.daoas.adressevedligehold;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;

import org.apache.commons.lang3.StringUtils;

import dk.daoas.adressevedligehold.AddressSourceEntry.EntryType;
import dk.daoas.adressevedligehold.beans.Address;
import dk.daoas.adressevedligehold.beans.Address.AddressState;
import dk.daoas.adressevedligehold.db.DatabaseLayerImplementation;
import dk.daoas.adressevedligehold.util.DeduplicateHelper;
import dk.daoas.adressevedligehold.util.TimingHelper;

/*
 * TODO: håndtering af entry dupletter ! (+ rapportering af dem)
 * TODO: ajourføring af DBKbane
DAO:
UPDATE fulddaekning.adressetabel 
SET dbkbane = case
        when substr(korelisteMa,1,2) IN ('07','10','11','12','14','15','16','18','19','20') then 205 #DAO-BRA
    when substr(korelisteMa,1,2) BETWEEN 24 and 30 then 201 #DAO-Ovrige
    else 202 #dao syd (52-99=
END
WHERE distributor='DAO'
AND ruteMa is not null;

FD: Altid 200
NS: Altid 204
BK: 195,196,197,198

 
 */

public class AddressManager {
        
        
        List<Address> addressList;
        
        Map<Integer, TreeMap<Short, ArrayList<Address>> > searchStructure;
        
        ArrayList<AddressSourceEntry> afvisteEntries = new ArrayList<AddressSourceEntry>(); 
        
        public AddressManager() throws SQLException {
                DatabaseLayerImplementation db = new DatabaseLayerImplementation();
                
                searchStructure = new TreeMap<Integer, TreeMap<Short, ArrayList<Address>> >();
                
                addressList = db.getAllAdresses();

                DeduplicateHelper<Integer> intHelper = new DeduplicateHelper<Integer>();
                DeduplicateHelper<Short> shortHelper = new DeduplicateHelper<Short>();

                List<ArrayList<Address>> arraylistCache = new ArrayList<ArrayList<Address>>(); 
                
                TimingHelper timer = new TimingHelper();
                
                for (Address a : addressList) {
                        Integer gadeid = intHelper.getInstance( a.gadeid );
                        Short husnr = shortHelper.getInstance( a.husnr );
                        TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( gadeid );
                        
                        if (gade == null) {
                                gade = new TreeMap<Short,ArrayList<Address>>();
                                searchStructure.put(gadeid, gade);
                        }
                        
                        ArrayList<Address> litraList = gade.get(husnr);
                        if (litraList == null) {
                                litraList = new ArrayList<Address>();
                                gade.put(husnr, litraList);
                                arraylistCache.add(litraList);
                        }
                        
                        litraList.add(a);
                }
                
                for (ArrayList<Address> list : arraylistCache) {
                        list.trimToSize();
                }
                
                System.out.println("AddressManager ready, elapsed " + timer.getElapsed() + "ms");
                
                
        }
        
        public void closeUnvisitedAddresses(String distributor, EntryUgedage ugedage) {
                for (Address addr : addressList) {
                        if (addr.distributor == null)
                                continue;
                        
                        if (addr.distributor.equals(distributor) == false)//irrelevant for denne indlæsning
                                continue;
                        
                        int closedCount = 0;
                        
                        if (addr.visitedMan == false && ugedage.mandag) {
                                if (addr.ruteMandag != null)  {
                                        addr.ruteMandag = null;
                                        addr.korelisteMandag = null;
                                        addr.stateMan = AddressState.CLOSED;
                                        closedCount++;
                                }
                        }
                        if (addr.visitedTir == false && ugedage.tirsdag) {
                                if (addr.ruteTirsdag != null)  {
                                        addr.ruteTirsdag = null;
                                        addr.korelisteTirsdag = null;
                                        addr.stateTir = AddressState.CLOSED;
                                        closedCount++;
                                }
                        }

                        if (addr.visitedOns == false && ugedage.onsdag) {
                                if (addr.ruteOnsdag != null)  {
                                        addr.ruteOnsdag = null;
                                        addr.korelisteOnsdag = null;
                                        addr.stateOns = AddressState.CLOSED;
                                        closedCount++;
                                }
                        }

                        if (addr.visitedTor == false && ugedage.torsdag) {
                                if (addr.ruteTorsdag != null)  {
                                        addr.ruteTorsdag = null;
                                        addr.korelisteTorsdag = null;
                                        addr.stateTor = AddressState.CLOSED;
                                        closedCount++;
                                }
                        }

                        if (addr.visitedFre == false && ugedage.fredag) {
                                if (addr.ruteFredag != null)  {
                                        addr.ruteFredag = null;
                                        addr.korelisteFredag = null;
                                        addr.stateFre = AddressState.CLOSED;
                                        closedCount++;
                                }
                        }

                        if (addr.visitedLor == false && ugedage.lordag) {
                                if (addr.ruteLordag != null)  {
                                        addr.ruteLordag = null;
                                        addr.korelisteLordag = null;
                                        addr.stateLor = AddressState.CLOSED;
                                        closedCount++;
                                }
                        }

                        if (addr.visitedSon == false && ugedage.sondag) {
                                if (addr.ruteSondag != null)  {
                                        addr.ruteSondag = null;
                                        addr.korelisteSondag = null;
                                        addr.stateSon = AddressState.CLOSED;
                                        closedCount++;
                                }
                        }
                        
                        if (addr.state == AddressState.NOT_CHANGED && closedCount>0) {
                                addr.state = AddressState.CLOSED;
                        }
                
                }
        }
        public void dumpChanged() {
                int count = 0;
                for (Address addr : addressList) {
                        if (addr.state == AddressState.NOT_CHANGED) {
                                continue;
                        }
                        /*if (addr.stateMan == AddressState.NOT_CHANGED || addr.stateMan == AddressState.CREATED) {
                                continue;
                        }*/
                        
                        if (addr.stateMan != AddressState.OPENED ) {
                                continue;
                        }
                        
                        System.out.println(addr.state + ": " + addr.toStringExtended() );
                        System.out.println(addr.getRuteString() );
                        
                        if (count++ > 15)
                                return;
                }
        }
        
        public void writeBackChanges() {
                System.out.println("Writing back changes");
                TimingHelper timer = new TimingHelper();
                
                List<Address> updates = new ArrayList<Address>(1024*1024);
                List<Address> inserts = new ArrayList<Address>(16*1024);
                
                for (Address addr : addressList) {
                        if (addr.state == AddressState.CREATED) {
                                inserts.add(addr);
                        }
                        if (addr.state == AddressState.MODIFIED || addr.state == AddressState.OPENED || addr.state == AddressState.CLOSED) {
                                updates.add(addr);
                        }
                }
                
                DatabaseLayerImplementation db = new DatabaseLayerImplementation();
                
                db.updateAddresses(updates);

                
                
                System.out.println("Writeback done: elapsed " + timer.getElapsed() + "ms.");
        }
        
        
        public void visit(AddressSourceEntry entry) {
                if (entry.type == EntryType.TypeSingleAddress) {
                        visitSingle(entry);
                } else {
                        visitRange(entry);
                }
        }
        
        private void visitSingle(AddressSourceEntry entry) {
                TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( entry.gadeid );
                if (gade == null) {
                        createFromEntry(entry); // if we get here there was no match - so we need to create it
                        return;
                }
                
                ArrayList<Address> litraList = gade.get(entry.husnr);
                if (litraList == null) {
                        createFromEntry(entry); // if we get here there was no match - so we need to create it
                        return;
                }
                
                for (Address addr : litraList) {
                        if (addr.husnrbogstav.equals(entry.litra) ) {
                                updateAddress(addr, entry);
                                return; //Done for now - no need to look at the rest of the list
                        }
                }
                
                createFromEntry(entry); // if we get here there was no match - so we need to create it
        }
        
        private void visitRange(AddressSourceEntry entry) {
                
                TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( entry.gadeid );
                if (gade == null) {
                        System.out.println("[Range] Ukendt gadeID " + entry);
                        return;
                }
                
                for (Entry<Short, ArrayList<Address>> husnrEntry: gade.entrySet()) {
                        
                        short husnummer = husnrEntry.getKey();
                        
                        if ( (entry.husnr % 2) != (husnummer%2) ){ //lige/ulige skal passe sammen
                                continue;
                        }
                        
                        if ( husnummer < entry.husnr || husnummer > entry.tilHusnr) {
                                continue;
                        }
                        
                        ArrayList<Address> litraList = husnrEntry.getValue();
                        
                        /* a=adressetabel u=input
                         * and (a.husnr>u.FraHusNr OR (a.husnr=u.FraHusNr AND a.HusnrBogstav >= u.FraBog))
                         * AND (a.husnr<u.TilHusNr OR (a.husnr=u.TilHusNr AND a.HusnrBogstav <= u.TilBog))
                         */
                         
                         
                        for (Address addr: litraList) {
                                if (addr.husnr > entry.husnr || (addr.husnr == entry.husnr && addr.husnrbogstav.compareTo(entry.litra) >= 0 )) {
                                        //Using nested IF instead of &&
                                        if (addr.husnr < entry.tilHusnr || (addr.husnr == entry.tilHusnr && addr.husnrbogstav.compareTo(entry.tilLitra) <= 0 )) {
                                                updateAddress(addr, entry);
                                        }                                       
                                }
                        }
                }
        }
        
        
        
        private void updateAddress(Address addr, AddressSourceEntry entry) {
                if ( addr.distributor != null && addr.distributor.equals(entry.distributor) == false) {
                        afvisteEntries.add(entry);
                        System.out.println("Afviser " + entry);
                        return;
                }
                

                
                if (entry.ugedage.mandag) {
                        addr.visitedMan = true;
                        if (addr.ruteMandag == null) {
                                addr.stateMan = AddressState.OPENED;
                                addr.ruteMandag = entry.rute;
                                addr.korelisteMandag = entry.koreliste;
                        } else {
                                
                                if (StringUtils.equals(addr.ruteMandag, entry.rute) == false || StringUtils.equals(addr.korelisteMandag, entry.koreliste) == false) {
                                        addr.stateMan = AddressState.MODIFIED;
                                        addr.ruteMandag = entry.rute;
                                        addr.korelisteMandag = entry.koreliste;                                 
                                }
                        }
                }
                
                
                if (entry.ugedage.tirsdag) {
                        addr.visitedTir = true;
                        if (addr.ruteTirsdag == null) {
                                addr.stateTir = AddressState.OPENED;
                                addr.ruteTirsdag = entry.rute;
                                addr.korelisteTirsdag = entry.koreliste;
                        } else {
                                
                                if (StringUtils.equals(addr.ruteTirsdag, entry.rute) == false || StringUtils.equals(addr.korelisteTirsdag, entry.koreliste) == false) {
                                        addr.stateTir = AddressState.MODIFIED;
                                        addr.ruteTirsdag = entry.rute;
                                        addr.korelisteTirsdag = entry.koreliste;                                        
                                }
                        }
                }

                if (entry.ugedage.onsdag) {
                        addr.visitedOns = true;
                        if (addr.ruteOnsdag == null) {
                                addr.stateOns = AddressState.OPENED;
                                addr.ruteOnsdag = entry.rute;
                                addr.korelisteOnsdag = entry.koreliste;
                        } else {
                                
                                if (StringUtils.equals(addr.ruteOnsdag, entry.rute) == false || StringUtils.equals(addr.korelisteOnsdag, entry.koreliste) == false) {
                                        addr.stateOns = AddressState.MODIFIED;
                                        addr.ruteOnsdag = entry.rute;
                                        addr.korelisteOnsdag = entry.koreliste;                                 
                                }
                        }
                }

                
                if (entry.ugedage.torsdag) {
                        addr.visitedTor = true;
                        if (addr.ruteTorsdag == null) {
                                addr.stateTor = AddressState.OPENED;
                                addr.ruteTorsdag = entry.rute;
                                addr.korelisteTorsdag = entry.koreliste;
                        } else {
                                
                                
                                if (StringUtils.equals(addr.ruteTorsdag, entry.rute) == false || StringUtils.equals(addr.korelisteTorsdag, entry.koreliste) == false) {
                                        addr.stateTor = AddressState.MODIFIED;
                                        addr.ruteTorsdag = entry.rute;
                                        addr.korelisteTorsdag = entry.koreliste;                                        
                                }
                        }
                }

                
                if (entry.ugedage.fredag) {
                        addr.visitedFre = true;
                        if (addr.ruteFredag == null) {
                                addr.stateFre = AddressState.OPENED;
                                addr.ruteFredag = entry.rute;
                                addr.korelisteFredag = entry.koreliste;
                        } else {
                                
                                if (StringUtils.equals(addr.ruteFredag, entry.rute) == false || StringUtils.equals(addr.korelisteFredag, entry.koreliste) == false) {
                                        addr.stateFre = AddressState.MODIFIED;
                                        addr.ruteFredag = entry.rute;
                                        addr.korelisteFredag = entry.koreliste;                                 
                                }
                        }
                }

                
                if (entry.ugedage.lordag) {
                        addr.visitedLor = true;
                        if (addr.ruteLordag == null) {
                                addr.stateLor = AddressState.OPENED;
                                addr.ruteLordag = entry.rute;
                                addr.korelisteLordag = entry.koreliste;
                        } else {
                                
                                
                                if (StringUtils.equals(addr.ruteLordag, entry.rute) == false || StringUtils.equals(addr.korelisteLordag, entry.koreliste) == false) {
                                        addr.stateLor = AddressState.MODIFIED;
                                        addr.ruteLordag = entry.rute;
                                        addr.korelisteLordag = entry.koreliste;                                 
                                }
                        }
                }

                
                if (entry.ugedage.sondag) {
                        addr.visitedSon = true;
                        if (addr.ruteSondag == null) {
                                addr.stateSon = AddressState.OPENED;
                                addr.ruteSondag = entry.rute;
                                addr.korelisteSondag = entry.koreliste;
                        } else {
                                
                                if (StringUtils.equals(addr.ruteSondag, entry.rute) == false || StringUtils.equals(addr.korelisteSondag, entry.koreliste) == false) {
                                        addr.stateSon = AddressState.MODIFIED;
                                        addr.ruteSondag = entry.rute;
                                        addr.korelisteSondag = entry.koreliste;                                 
                                }
                        }
                }
                
                
                
                addr.visited = true;
                if (addr.state == AddressState.NOT_CHANGED) {
                        if (addr.distributor == null) {
                                addr.state = AddressState.OPENED;
                                addr.distributor = entry.distributor;
                        } else {
                                if (addr.stateMan != AddressState.NOT_CHANGED || addr.stateTir != AddressState.NOT_CHANGED 
                                                || addr.stateOns != AddressState.NOT_CHANGED || addr.stateTor != AddressState.NOT_CHANGED 
                                                || addr.stateFre != AddressState.NOT_CHANGED || addr.stateLor != AddressState.NOT_CHANGED || addr.stateSon != AddressState.NOT_CHANGED ){
                                        
                                        addr.state = AddressState.MODIFIED;     
                                }
                        }
                }               
                
                
        }
        
        
        
        private void createFromEntry(AddressSourceEntry entry) {
                System.out.println("Opretter adresse ud fra " + entry);
                
                Address a = new Address();
                a.state = AddressState.CREATED;
                
                a.distributor = entry.distributor;
                a.gadeid = entry.gadeid;
                a.kommunekode = entry.kommunekode;
                a.vejkode = entry.vejkode;
                a.vejnavn = entry.vejnavn;
                a.husnr = entry.husnr;
                a.husnrbogstav = entry.litra;
                a.postnr = entry.postnr;
                a.visited = true;
                
                if (entry.ugedage.mandag) {
                        a.ruteMandag = entry.rute;
                        a.korelisteMandag = entry.koreliste;
                }
                if (entry.ugedage.tirsdag) {
                        a.ruteTirsdag = entry.rute;
                        a.korelisteTirsdag = entry.koreliste;
                }
                if (entry.ugedage.onsdag) {
                        a.ruteOnsdag = entry.rute;
                        a.korelisteOnsdag = entry.koreliste;
                }               
                if (entry.ugedage.torsdag) {
                        a.ruteTorsdag = entry.rute;
                        a.korelisteTorsdag = entry.koreliste;
                }               
                if (entry.ugedage.fredag) {
                        a.ruteFredag = entry.rute;
                        a.korelisteFredag = entry.koreliste;
                }               
                if (entry.ugedage.lordag) {
                        a.ruteLordag = entry.rute;
                        a.korelisteLordag = entry.koreliste;
                }               
                if (entry.ugedage.sondag) {
                        a.ruteSondag = entry.rute;
                        a.korelisteLordag = entry.koreliste;
                }               
                
                // Nu er det nye adresse object oprettet - nu skal det gemmes i søge strukturen og totallisten
                

                TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( a.gadeid );
                
                if (gade == null) {
                        gade = new TreeMap<Short,ArrayList<Address>>();
                        searchStructure.put(a.gadeid, gade);
                }
                
                ArrayList<Address> litraList = gade.get(a.husnr);
                if (litraList == null) {
                        litraList = new ArrayList<Address>();
                        gade.put(a.husnr, litraList);
                }
                
                litraList.add(a);
                addressList.add(a);
                                
        }
        
        public List<Address> getAddressList() {
                return Collections.unmodifiableList(addressList);
        }
        
        public int getAfvistAntal() {
                return afvisteEntries.size();
        }
        
}
1	torben	2838	package dk.daoas.adressevedligehold;
2
3			import java.sql.SQLException;
4			import java.util.ArrayList;
5			import java.util.Collections;
6			import java.util.List;
7			import java.util.Map;
8	torben	2844	import java.util.Map.Entry;
9	torben	2838	import java.util.TreeMap;
10
11			import org.apache.commons.lang3.StringUtils;
12
13			import dk.daoas.adressevedligehold.AddressSourceEntry.EntryType;
14			import dk.daoas.adressevedligehold.beans.Address;
15			import dk.daoas.adressevedligehold.beans.Address.AddressState;
16			import dk.daoas.adressevedligehold.db.DatabaseLayerImplementation;
17			import dk.daoas.adressevedligehold.util.DeduplicateHelper;
18			import dk.daoas.adressevedligehold.util.TimingHelper;
19
20	torben	2840	/*
21			* TODO: håndtering af entry dupletter ! (+ rapportering af dem)
22	torben	2845	* TODO: ajourføring af DBKbane
23			DAO:
24			UPDATE fulddaekning.adressetabel
25			SET dbkbane = case
26			when substr(korelisteMa,1,2) IN ('07','10','11','12','14','15','16','18','19','20') then 205 #DAO-BRA
27			when substr(korelisteMa,1,2) BETWEEN 24 and 30 then 201 #DAO-Ovrige
28			else 202 #dao syd (52-99=
29			END
30			WHERE distributor='DAO'
31			AND ruteMa is not null;
32
33			FD: Altid 200
34			NS: Altid 204
35			BK: 195,196,197,198
36
37
38	torben	2840	*/
39
40	torben	2838	public class AddressManager {
41
42
43			List<Address> addressList;
44
45			Map<Integer, TreeMap<Short, ArrayList<Address>> > searchStructure;
46
47			ArrayList<AddressSourceEntry> afvisteEntries = new ArrayList<AddressSourceEntry>();
48
49			public AddressManager() throws SQLException {
50			DatabaseLayerImplementation db = new DatabaseLayerImplementation();
51
52			searchStructure = new TreeMap<Integer, TreeMap<Short, ArrayList<Address>> >();
53
54			addressList = db.getAllAdresses();
55
56			DeduplicateHelper<Integer> intHelper = new DeduplicateHelper<Integer>();
57			DeduplicateHelper<Short> shortHelper = new DeduplicateHelper<Short>();
58
59			List<ArrayList<Address>> arraylistCache = new ArrayList<ArrayList<Address>>();
60
61			TimingHelper timer = new TimingHelper();
62
63			for (Address a : addressList) {
64			Integer gadeid = intHelper.getInstance( a.gadeid );
65			Short husnr = shortHelper.getInstance( a.husnr );
66			TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( gadeid );
67
68			if (gade == null) {
69			gade = new TreeMap<Short,ArrayList<Address>>();
70			searchStructure.put(gadeid, gade);
71			}
72
73			ArrayList<Address> litraList = gade.get(husnr);
74			if (litraList == null) {
75			litraList = new ArrayList<Address>();
76			gade.put(husnr, litraList);
77			arraylistCache.add(litraList);
78			}
79
80			litraList.add(a);
81			}
82
83			for (ArrayList<Address> list : arraylistCache) {
84			list.trimToSize();
85			}
86
87			System.out.println("AddressManager ready, elapsed " + timer.getElapsed() + "ms");
88
89
90			}
91
92			public void closeUnvisitedAddresses(String distributor, EntryUgedage ugedage) {
93			for (Address addr : addressList) {
94			if (addr.distributor == null)
95			continue;
96
97			if (addr.distributor.equals(distributor) == false)//irrelevant for denne indlæsning
98			continue;
99
100			int closedCount = 0;
101
102			if (addr.visitedMan == false && ugedage.mandag) {
103			if (addr.ruteMandag != null) {
104			addr.ruteMandag = null;
105			addr.korelisteMandag = null;
106			addr.stateMan = AddressState.CLOSED;
107			closedCount++;
108			}
109			}
110			if (addr.visitedTir == false && ugedage.tirsdag) {
111			if (addr.ruteTirsdag != null) {
112			addr.ruteTirsdag = null;
113			addr.korelisteTirsdag = null;
114			addr.stateTir = AddressState.CLOSED;
115			closedCount++;
116			}
117			}
118
119			if (addr.visitedOns == false && ugedage.onsdag) {
120			if (addr.ruteOnsdag != null) {
121			addr.ruteOnsdag = null;
122			addr.korelisteOnsdag = null;
123			addr.stateOns = AddressState.CLOSED;
124			closedCount++;
125			}
126			}
127
128			if (addr.visitedTor == false && ugedage.torsdag) {
129			if (addr.ruteTorsdag != null) {
130			addr.ruteTorsdag = null;
131			addr.korelisteTorsdag = null;
132			addr.stateTor = AddressState.CLOSED;
133			closedCount++;
134			}
135			}
136
137			if (addr.visitedFre == false && ugedage.fredag) {
138			if (addr.ruteFredag != null) {
139			addr.ruteFredag = null;
140			addr.korelisteFredag = null;
141			addr.stateFre = AddressState.CLOSED;
142			closedCount++;
143			}
144			}
145
146			if (addr.visitedLor == false && ugedage.lordag) {
147			if (addr.ruteLordag != null) {
148			addr.ruteLordag = null;
149			addr.korelisteLordag = null;
150			addr.stateLor = AddressState.CLOSED;
151			closedCount++;
152			}
153			}
154
155			if (addr.visitedSon == false && ugedage.sondag) {
156			if (addr.ruteSondag != null) {
157			addr.ruteSondag = null;
158			addr.korelisteSondag = null;
159			addr.stateSon = AddressState.CLOSED;
160			closedCount++;
161			}
162			}
163
164			if (addr.state == AddressState.NOT_CHANGED && closedCount>0) {
165			addr.state = AddressState.CLOSED;
166			}
167
168			}
169			}
170			public void dumpChanged() {
171			int count = 0;
172			for (Address addr : addressList) {
173			if (addr.state == AddressState.NOT_CHANGED) {
174			continue;
175			}
176	torben	2845	/*if (addr.stateMan == AddressState.NOT_CHANGED \|\| addr.stateMan == AddressState.CREATED) {
177	torben	2838	continue;
178	torben	2845	}*/
179	torben	2838
180	torben	2845	if (addr.stateMan != AddressState.OPENED ) {
181	torben	2838	continue;
182			}
183
184			System.out.println(addr.state + ": " + addr.toStringExtended() );
185			System.out.println(addr.getRuteString() );
186
187			if (count++ > 15)
188			return;
189			}
190			}
191
192			public void writeBackChanges() {
193			System.out.println("Writing back changes");
194			TimingHelper timer = new TimingHelper();
195
196			List<Address> updates = new ArrayList<Address>(1024*1024);
197			List<Address> inserts = new ArrayList<Address>(16*1024);
198
199			for (Address addr : addressList) {
200			if (addr.state == AddressState.CREATED) {
201			inserts.add(addr);
202			}
203			if (addr.state == AddressState.MODIFIED \|\| addr.state == AddressState.OPENED \|\| addr.state == AddressState.CLOSED) {
204			updates.add(addr);
205			}
206			}
207
208			DatabaseLayerImplementation db = new DatabaseLayerImplementation();
209	torben	2845
210	torben	2838	db.updateAddresses(updates);
211	torben	2845
212	torben	2838
213	torben	2845
214	torben	2838	System.out.println("Writeback done: elapsed " + timer.getElapsed() + "ms.");
215			}
216
217
218			public void visit(AddressSourceEntry entry) {
219			if (entry.type == EntryType.TypeSingleAddress) {
220			visitSingle(entry);
221			} else {
222			visitRange(entry);
223			}
224			}
225
226			private void visitSingle(AddressSourceEntry entry) {
227			TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( entry.gadeid );
228			if (gade == null) {
229			createFromEntry(entry); // if we get here there was no match - so we need to create it
230			return;
231			}
232
233			ArrayList<Address> litraList = gade.get(entry.husnr);
234			if (litraList == null) {
235			createFromEntry(entry); // if we get here there was no match - so we need to create it
236			return;
237			}
238
239			for (Address addr : litraList) {
240			if (addr.husnrbogstav.equals(entry.litra) ) {
241			updateAddress(addr, entry);
242			return; //Done for now - no need to look at the rest of the list
243			}
244			}
245
246			createFromEntry(entry); // if we get here there was no match - so we need to create it
247			}
248
249			private void visitRange(AddressSourceEntry entry) {
250
251	torben	2844	TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( entry.gadeid );
252			if (gade == null) {
253			System.out.println("[Range] Ukendt gadeID " + entry);
254			return;
255			}
256
257			for (Entry<Short, ArrayList<Address>> husnrEntry: gade.entrySet()) {
258
259			short husnummer = husnrEntry.getKey();
260
261			if ( (entry.husnr % 2) != (husnummer%2) ){ //lige/ulige skal passe sammen
262			continue;
263			}
264
265			if ( husnummer < entry.husnr \|\| husnummer > entry.tilHusnr) {
266			continue;
267			}
268
269			ArrayList<Address> litraList = husnrEntry.getValue();
270
271			/* a=adressetabel u=input
272			* and (a.husnr>u.FraHusNr OR (a.husnr=u.FraHusNr AND a.HusnrBogstav >= u.FraBog))
273			* AND (a.husnr<u.TilHusNr OR (a.husnr=u.TilHusNr AND a.HusnrBogstav <= u.TilBog))
274			*/
275
276
277			for (Address addr: litraList) {
278			if (addr.husnr > entry.husnr \|\| (addr.husnr == entry.husnr && addr.husnrbogstav.compareTo(entry.litra) >= 0 )) {
279			//Using nested IF instead of &&
280			if (addr.husnr < entry.tilHusnr \|\| (addr.husnr == entry.tilHusnr && addr.husnrbogstav.compareTo(entry.tilLitra) <= 0 )) {
281			updateAddress(addr, entry);
282			}
283			}
284			}
285			}
286	torben	2838	}
287
288
289
290			private void updateAddress(Address addr, AddressSourceEntry entry) {
291			if ( addr.distributor != null && addr.distributor.equals(entry.distributor) == false) {
292			afvisteEntries.add(entry);
293			System.out.println("Afviser " + entry);
294			return;
295			}
296
297	torben	2845
298	torben	2838
299			if (entry.ugedage.mandag) {
300			addr.visitedMan = true;
301			if (addr.ruteMandag == null) {
302			addr.stateMan = AddressState.OPENED;
303			addr.ruteMandag = entry.rute;
304			addr.korelisteMandag = entry.koreliste;
305			} else {
306
307			if (StringUtils.equals(addr.ruteMandag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteMandag, entry.koreliste) == false) {
308			addr.stateMan = AddressState.MODIFIED;
309			addr.ruteMandag = entry.rute;
310			addr.korelisteMandag = entry.koreliste;
311			}
312			}
313			}
314
315
316			if (entry.ugedage.tirsdag) {
317			addr.visitedTir = true;
318			if (addr.ruteTirsdag == null) {
319			addr.stateTir = AddressState.OPENED;
320			addr.ruteTirsdag = entry.rute;
321			addr.korelisteTirsdag = entry.koreliste;
322			} else {
323
324			if (StringUtils.equals(addr.ruteTirsdag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteTirsdag, entry.koreliste) == false) {
325			addr.stateTir = AddressState.MODIFIED;
326			addr.ruteTirsdag = entry.rute;
327			addr.korelisteTirsdag = entry.koreliste;
328			}
329			}
330			}
331
332			if (entry.ugedage.onsdag) {
333			addr.visitedOns = true;
334			if (addr.ruteOnsdag == null) {
335			addr.stateOns = AddressState.OPENED;
336			addr.ruteOnsdag = entry.rute;
337			addr.korelisteOnsdag = entry.koreliste;
338			} else {
339
340			if (StringUtils.equals(addr.ruteOnsdag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteOnsdag, entry.koreliste) == false) {
341			addr.stateOns = AddressState.MODIFIED;
342			addr.ruteOnsdag = entry.rute;
343			addr.korelisteOnsdag = entry.koreliste;
344			}
345			}
346			}
347
348
349			if (entry.ugedage.torsdag) {
350			addr.visitedTor = true;
351			if (addr.ruteTorsdag == null) {
352			addr.stateTor = AddressState.OPENED;
353			addr.ruteTorsdag = entry.rute;
354			addr.korelisteTorsdag = entry.koreliste;
355			} else {
356
357
358			if (StringUtils.equals(addr.ruteTorsdag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteTorsdag, entry.koreliste) == false) {
359			addr.stateTor = AddressState.MODIFIED;
360			addr.ruteTorsdag = entry.rute;
361			addr.korelisteTorsdag = entry.koreliste;
362			}
363			}
364			}
365
366
367			if (entry.ugedage.fredag) {
368			addr.visitedFre = true;
369			if (addr.ruteFredag == null) {
370			addr.stateFre = AddressState.OPENED;
371			addr.ruteFredag = entry.rute;
372			addr.korelisteFredag = entry.koreliste;
373			} else {
374
375			if (StringUtils.equals(addr.ruteFredag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteFredag, entry.koreliste) == false) {
376			addr.stateFre = AddressState.MODIFIED;
377			addr.ruteFredag = entry.rute;
378			addr.korelisteFredag = entry.koreliste;
379			}
380			}
381			}
382
383
384			if (entry.ugedage.lordag) {
385			addr.visitedLor = true;
386			if (addr.ruteLordag == null) {
387			addr.stateLor = AddressState.OPENED;
388			addr.ruteLordag = entry.rute;
389			addr.korelisteLordag = entry.koreliste;
390			} else {
391
392
393			if (StringUtils.equals(addr.ruteLordag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteLordag, entry.koreliste) == false) {
394			addr.stateLor = AddressState.MODIFIED;
395			addr.ruteLordag = entry.rute;
396			addr.korelisteLordag = entry.koreliste;
397			}
398			}
399			}
400
401
402			if (entry.ugedage.sondag) {
403			addr.visitedSon = true;
404			if (addr.ruteSondag == null) {
405			addr.stateSon = AddressState.OPENED;
406			addr.ruteSondag = entry.rute;
407			addr.korelisteSondag = entry.koreliste;
408			} else {
409
410			if (StringUtils.equals(addr.ruteSondag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteSondag, entry.koreliste) == false) {
411			addr.stateSon = AddressState.MODIFIED;
412			addr.ruteSondag = entry.rute;
413			addr.korelisteSondag = entry.koreliste;
414			}
415			}
416			}
417
418
419	torben	2845
420			addr.visited = true;
421			if (addr.state == AddressState.NOT_CHANGED) {
422			if (addr.distributor == null) {
423			addr.state = AddressState.OPENED;
424			addr.distributor = entry.distributor;
425			} else {
426			if (addr.stateMan != AddressState.NOT_CHANGED \|\| addr.stateTir != AddressState.NOT_CHANGED
427			\|\| addr.stateOns != AddressState.NOT_CHANGED \|\| addr.stateTor != AddressState.NOT_CHANGED
428			\|\| addr.stateFre != AddressState.NOT_CHANGED \|\| addr.stateLor != AddressState.NOT_CHANGED \|\| addr.stateSon != AddressState.NOT_CHANGED ){
429
430			addr.state = AddressState.MODIFIED;
431			}
432			}
433			}
434
435
436	torben	2838	}
437
438
439
440			private void createFromEntry(AddressSourceEntry entry) {
441			System.out.println("Opretter adresse ud fra " + entry);
442
443			Address a = new Address();
444			a.state = AddressState.CREATED;
445
446			a.distributor = entry.distributor;
447			a.gadeid = entry.gadeid;
448			a.kommunekode = entry.kommunekode;
449			a.vejkode = entry.vejkode;
450			a.vejnavn = entry.vejnavn;
451			a.husnr = entry.husnr;
452			a.husnrbogstav = entry.litra;
453			a.postnr = entry.postnr;
454			a.visited = true;
455
456			if (entry.ugedage.mandag) {
457			a.ruteMandag = entry.rute;
458			a.korelisteMandag = entry.koreliste;
459			}
460			if (entry.ugedage.tirsdag) {
461			a.ruteTirsdag = entry.rute;
462			a.korelisteTirsdag = entry.koreliste;
463			}
464			if (entry.ugedage.onsdag) {
465			a.ruteOnsdag = entry.rute;
466			a.korelisteOnsdag = entry.koreliste;
467			}
468			if (entry.ugedage.torsdag) {
469			a.ruteTorsdag = entry.rute;
470			a.korelisteTorsdag = entry.koreliste;
471			}
472			if (entry.ugedage.fredag) {
473			a.ruteFredag = entry.rute;
474			a.korelisteFredag = entry.koreliste;
475			}
476			if (entry.ugedage.lordag) {
477			a.ruteLordag = entry.rute;
478			a.korelisteLordag = entry.koreliste;
479			}
480			if (entry.ugedage.sondag) {
481			a.ruteSondag = entry.rute;
482			a.korelisteLordag = entry.koreliste;
483			}
484
485			// Nu er det nye adresse object oprettet - nu skal det gemmes i søge strukturen og totallisten
486
487
488			TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( a.gadeid );
489
490			if (gade == null) {
491			gade = new TreeMap<Short,ArrayList<Address>>();
492			searchStructure.put(a.gadeid, gade);
493			}
494
495			ArrayList<Address> litraList = gade.get(a.husnr);
496			if (litraList == null) {
497			litraList = new ArrayList<Address>();
498			gade.put(a.husnr, litraList);
499			}
500
501			litraList.add(a);
502			addressList.add(a);
503
504			}
505
506			public List<Address> getAddressList() {
507			return Collections.unmodifiableList(addressList);
508			}
509
510	torben	2839	public int getAfvistAntal() {
511			return afvisteEntries.size();
512			}
513
514	torben	2838	}