daoas/adressevedligehold/AddressManager.java

package dk.daoas.adressevedligehold;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
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.MiscUtils;
import dk.daoas.adressevedligehold.util.TimingHelper;

/*
 * TODO: håndtering af entry dupletter ! (+ rapportering af dem)


 */

public class AddressManager {
        
        
        List<Address> addressList;
        
        Map<Integer, TreeMap<Short, ArrayList<Address>> > searchStructure;
        
        ArrayList<AddressSourceEntry> afvisteEntries = new ArrayList<AddressSourceEntry>();
        
        Map<Short,Short> dbkBaneMap = new TreeMap<Short,Short>();
        
        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 (a.dbkBane > 0 && a.postnr<=4999) {
                                Short bane = dbkBaneMap.get(a.postnr);
                                if (bane == null) {
                                        dbkBaneMap.put(a.postnr, a.dbkBane);
                                }
                        }
                        
                        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.MODIFIED ) {
                                continue;
                        }
                        
                        System.out.println(addr.state + ": " + addr.toStringExtended() );
                        System.out.println(addr.getRuteString() );
                        
                        if (count++ > 50)
                                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) {
                        if (addr.visitedMan == false) {
                                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;                                 
                                        }
                                }                               
                        } else {
                                System.out.println( "Double visit monday " + addr);
                        }

                }
                
                
                if (entry.ugedage.tirsdag) {
                        if (addr.visitedTir == false) {
                                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;                                        
                                        }
                                }
                        } else {
                                System.out.println( "Double visit tuesday " + addr);
                        }                               
                }

                if (entry.ugedage.onsdag) {
                        if (addr.visitedOns == false) {
                                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;                                 
                                        }
                                }
                        } else {
                                System.out.println( "Double visit wednesday " + addr);
                        }               
                }

                
                if (entry.ugedage.torsdag) {
                        if (addr.visitedTor == false) {
                                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;                                        
                                        }
                                }
                        } else {
                                System.out.println( "Double visit thursday " + addr);
                        }                                       
                }

                
                if (entry.ugedage.fredag) {
                        if (addr.visitedFre == false) {
                                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;                                 
                                        }
                                }
                        } else {
                                System.out.println( "Double visit friday " + addr);
                        }       
                }

                
                if (entry.ugedage.lordag) {
                        if (addr.visitedLor == false) {
                                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;                                 
                                        }
                                }
                        } else {
                                System.out.println( "Double visit saturday " + addr);
                        }                                       
                }

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