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> rejectedEntries = new ArrayList<AddressSourceEntry>();
        
        Map<Integer,String> unknownStreets = new TreeMap<Integer, String>();
        
        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);
                db.saveNewAddresses(inserts);

                
                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) {
                        if (! unknownStreets.containsKey(entry.gadeid)) {
                                unknownStreets.put(entry.gadeid, entry.vejnavn);                                
                        }
                        
                        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;
                }
                boolean found = false;
                for (Address addr : litraList) {
                        if (addr.husnrbogstav.equals(entry.litra) ) {
                                updateAddress(addr, entry);
                                found = true; // 1 visit should be enough but as long as there's duplicates on gadeid+husnr+litra we will visit them all
                                //when the issue with duplicates is resolved this should be reverted to a return or break
                        }
                }
                if (found == false) {
                        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) {
                        if (! unknownStreets.containsKey(entry.gadeid)) {
                                unknownStreets.put(entry.gadeid, entry.vejnavn);                                
                        }
                        
                        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) {
                        rejectedEntries.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 (entry.gadeid == 0) {
                        return;
                }
                
                String gadeidStr = Integer.toString(entry.gadeid);
                if (gadeidStr.length() != 9) {
                        return;
                }
                if (Short.parseShort(gadeidStr.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;
                default:
                        throw new RuntimeException("Ukendt distributor" + a.distributor); //Silence findBugs
                }
                
                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 Map<Integer,String> getUnknownStreets() {
                return Collections.unmodifiableMap( unknownStreets );
        }
        
        
        public int getRejectedCount() {
                return rejectedEntries.size();
        }
        
}
1	package dk.daoas.adressevedligehold;
2
3	import java.sql.SQLException;
4	import java.util.ArrayList;
5	import java.util.Arrays;
6	import java.util.Collections;
7	import java.util.List;
8	import java.util.Map;
9	import java.util.Map.Entry;
10	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	import dk.daoas.adressevedligehold.util.MiscUtils;
20	import dk.daoas.adressevedligehold.util.TimingHelper;
21
22	/*
23	* TODO: håndtering af entry dupletter ! (+ rapportering af dem)
24
25
26
27	*/
28
29	public class AddressManager {
30
31
32	List<Address> addressList;
33
34	Map<Integer, TreeMap<Short, ArrayList<Address>> > searchStructure;
35
36	ArrayList<AddressSourceEntry> rejectedEntries = new ArrayList<AddressSourceEntry>();
37
38	Map<Integer,String> unknownStreets = new TreeMap<Integer, String>();
39
40	Map<Short,Short> dbkBaneMap = new TreeMap<Short,Short>();
41
42	public AddressManager() throws SQLException {
43	DatabaseLayerImplementation db = new DatabaseLayerImplementation();
44
45	searchStructure = new TreeMap<Integer, TreeMap<Short, ArrayList<Address>> >();
46
47	addressList = db.getAllAdresses();
48
49	DeduplicateHelper<Integer> intHelper = new DeduplicateHelper<Integer>();
50	DeduplicateHelper<Short> shortHelper = new DeduplicateHelper<Short>();
51
52	List<ArrayList<Address>> arraylistCache = new ArrayList<ArrayList<Address>>();
53
54	TimingHelper timer = new TimingHelper();
55
56	for (Address a : addressList) {
57	Integer gadeid = intHelper.getInstance( a.gadeid );
58	Short husnr = shortHelper.getInstance( a.husnr );
59	TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( gadeid );
60
61	if (a.dbkBane > 0 && a.postnr<=4999) {
62	Short bane = dbkBaneMap.get(a.postnr);
63	if (bane == null) {
64	dbkBaneMap.put(a.postnr, a.dbkBane);
65	}
66	}
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	/*if (addr.stateMan == AddressState.NOT_CHANGED \|\| addr.stateMan == AddressState.CREATED) {
177	continue;
178	}*/
179
180	if (addr.stateMan != AddressState.MODIFIED ) {
181	continue;
182	}
183
184	System.out.println(addr.state + ": " + addr.toStringExtended() );
185	System.out.println(addr.getRuteString() );
186
187	if (count++ > 50)
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
210	db.updateAddresses(updates);
211	db.saveNewAddresses(inserts);
212
213
214
215	System.out.println("Writeback done: elapsed " + timer.getElapsed() + "ms.");
216	}
217
218
219	public void visit(AddressSourceEntry entry) {
220	if (entry.type == EntryType.TypeSingleAddress) {
221	visitSingle(entry);
222	} else {
223	visitRange(entry);
224	}
225	}
226
227	private void visitSingle(AddressSourceEntry entry) {
228	TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( entry.gadeid );
229	if (gade == null) {
230	if (! unknownStreets.containsKey(entry.gadeid)) {
231	unknownStreets.put(entry.gadeid, entry.vejnavn);
232	}
233
234	createFromEntry(entry); // if we get here there was no match - so we need to create it
235	return;
236	}
237
238	ArrayList<Address> litraList = gade.get(entry.husnr);
239	if (litraList == null) {
240	createFromEntry(entry); // if we get here there was no match - so we need to create it
241	return;
242	}
243	boolean found = false;
244	for (Address addr : litraList) {
245	if (addr.husnrbogstav.equals(entry.litra) ) {
246	updateAddress(addr, entry);
247	found = true; // 1 visit should be enough but as long as there's duplicates on gadeid+husnr+litra we will visit them all
248	//when the issue with duplicates is resolved this should be reverted to a return or break
249	}
250	}
251	if (found == false) {
252	createFromEntry(entry); // if we get here there was no match - so we need to create it
253	}
254	}
255
256	private void visitRange(AddressSourceEntry entry) {
257
258	TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( entry.gadeid );
259	if (gade == null) {
260	if (! unknownStreets.containsKey(entry.gadeid)) {
261	unknownStreets.put(entry.gadeid, entry.vejnavn);
262	}
263
264	System.out.println("[Range] Ukendt gadeID " + entry);
265	return;
266	}
267
268	for (Entry<Short, ArrayList<Address>> husnrEntry: gade.entrySet()) {
269
270	short husnummer = husnrEntry.getKey();
271
272	if ( (entry.husnr % 2) != (husnummer%2) ){ //lige/ulige skal passe sammen
273	continue;
274	}
275
276	if ( husnummer < entry.husnr \|\| husnummer > entry.tilHusnr) {
277	continue;
278	}
279
280	ArrayList<Address> litraList = husnrEntry.getValue();
281
282	/* a=adressetabel u=input
283	* and (a.husnr>u.FraHusNr OR (a.husnr=u.FraHusNr AND a.HusnrBogstav >= u.FraBog))
284	* AND (a.husnr<u.TilHusNr OR (a.husnr=u.TilHusNr AND a.HusnrBogstav <= u.TilBog))
285	*/
286
287
288	for (Address addr: litraList) {
289	if (addr.husnr > entry.husnr \|\| (addr.husnr == entry.husnr && addr.husnrbogstav.compareTo(entry.litra) >= 0 )) {
290	//Using nested IF instead of &&
291	if (addr.husnr < entry.tilHusnr \|\| (addr.husnr == entry.tilHusnr && addr.husnrbogstav.compareTo(entry.tilLitra) <= 0 )) {
292	updateAddress(addr, entry);
293	}
294	}
295	}
296	}
297	}
298
299
300
301	private void updateAddress(Address addr, AddressSourceEntry entry) {
302	if ( addr.distributor != null && addr.distributor.equals(entry.distributor) == false) {
303	rejectedEntries.add(entry);
304	System.out.println("Afviser " + entry);
305	return;
306	}
307
308
309
310	if (entry.ugedage.mandag) {
311	if (addr.visitedMan == false) {
312	addr.visitedMan = true;
313	if (addr.ruteMandag == null) {
314	addr.stateMan = AddressState.OPENED;
315	addr.ruteMandag = entry.rute;
316	addr.korelisteMandag = entry.koreliste;
317	} else {
318
319	if (StringUtils.equals(addr.ruteMandag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteMandag, entry.koreliste) == false) {
320	addr.stateMan = AddressState.MODIFIED;
321	addr.ruteMandag = entry.rute;
322	addr.korelisteMandag = entry.koreliste;
323	}
324	}
325	} else {
326	System.out.println( "Double visit monday " + addr);
327	}
328
329	}
330
331
332	if (entry.ugedage.tirsdag) {
333	if (addr.visitedTir == false) {
334	addr.visitedTir = true;
335	if (addr.ruteTirsdag == null) {
336	addr.stateTir = AddressState.OPENED;
337	addr.ruteTirsdag = entry.rute;
338	addr.korelisteTirsdag = entry.koreliste;
339	} else {
340
341	if (StringUtils.equals(addr.ruteTirsdag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteTirsdag, entry.koreliste) == false) {
342	addr.stateTir = AddressState.MODIFIED;
343	addr.ruteTirsdag = entry.rute;
344	addr.korelisteTirsdag = entry.koreliste;
345	}
346	}
347	} else {
348	System.out.println( "Double visit tuesday " + addr);
349	}
350	}
351
352	if (entry.ugedage.onsdag) {
353	if (addr.visitedOns == false) {
354	addr.visitedOns = true;
355	if (addr.ruteOnsdag == null) {
356	addr.stateOns = AddressState.OPENED;
357	addr.ruteOnsdag = entry.rute;
358	addr.korelisteOnsdag = entry.koreliste;
359	} else {
360
361	if (StringUtils.equals(addr.ruteOnsdag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteOnsdag, entry.koreliste) == false) {
362	addr.stateOns = AddressState.MODIFIED;
363	addr.ruteOnsdag = entry.rute;
364	addr.korelisteOnsdag = entry.koreliste;
365	}
366	}
367	} else {
368	System.out.println( "Double visit wednesday " + addr);
369	}
370	}
371
372
373	if (entry.ugedage.torsdag) {
374	if (addr.visitedTor == false) {
375	addr.visitedTor = true;
376	if (addr.ruteTorsdag == null) {
377	addr.stateTor = AddressState.OPENED;
378	addr.ruteTorsdag = entry.rute;
379	addr.korelisteTorsdag = entry.koreliste;
380	} else {
381
382
383	if (StringUtils.equals(addr.ruteTorsdag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteTorsdag, entry.koreliste) == false) {
384	addr.stateTor = AddressState.MODIFIED;
385	addr.ruteTorsdag = entry.rute;
386	addr.korelisteTorsdag = entry.koreliste;
387	}
388	}
389	} else {
390	System.out.println( "Double visit thursday " + addr);
391	}
392	}
393
394
395	if (entry.ugedage.fredag) {
396	if (addr.visitedFre == false) {
397	addr.visitedFre = true;
398	if (addr.ruteFredag == null) {
399	addr.stateFre = AddressState.OPENED;
400	addr.ruteFredag = entry.rute;
401	addr.korelisteFredag = entry.koreliste;
402	} else {
403
404	if (StringUtils.equals(addr.ruteFredag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteFredag, entry.koreliste) == false) {
405	addr.stateFre = AddressState.MODIFIED;
406	addr.ruteFredag = entry.rute;
407	addr.korelisteFredag = entry.koreliste;
408	}
409	}
410	} else {
411	System.out.println( "Double visit friday " + addr);
412	}
413	}
414
415
416	if (entry.ugedage.lordag) {
417	if (addr.visitedLor == false) {
418	addr.visitedLor = true;
419	if (addr.ruteLordag == null) {
420	addr.stateLor = AddressState.OPENED;
421	addr.ruteLordag = entry.rute;
422	addr.korelisteLordag = entry.koreliste;
423	} else {
424
425
426	if (StringUtils.equals(addr.ruteLordag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteLordag, entry.koreliste) == false) {
427	addr.stateLor = AddressState.MODIFIED;
428	addr.ruteLordag = entry.rute;
429	addr.korelisteLordag = entry.koreliste;
430	}
431	}
432	} else {
433	System.out.println( "Double visit saturday " + addr);
434	}
435	}
436
437
438	if (entry.ugedage.sondag) {
439	if (addr.visitedSon == false) {
440	addr.visitedSon = true;
441	if (addr.ruteSondag == null) {
442	addr.stateSon = AddressState.OPENED;
443	addr.ruteSondag = entry.rute;
444	addr.korelisteSondag = entry.koreliste;
445	} else {
446
447	if (StringUtils.equals(addr.ruteSondag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteSondag, entry.koreliste) == false) {
448	addr.stateSon = AddressState.MODIFIED;
449	addr.ruteSondag = entry.rute;
450	addr.korelisteSondag = entry.koreliste;
451	}
452	}
453	} else {
454	System.out.println( "Double visit sunday " + addr);
455	}
456	}
457
458
459
460	//addr.visited = true;
461	if (addr.state == AddressState.NOT_CHANGED) {
462	if (addr.distributor == null) {
463	addr.state = AddressState.OPENED;
464	addr.distributor = entry.distributor;
465	} else {
466	if (addr.stateMan != AddressState.NOT_CHANGED \|\| addr.stateTir != AddressState.NOT_CHANGED
467	\|\| addr.stateOns != AddressState.NOT_CHANGED \|\| addr.stateTor != AddressState.NOT_CHANGED
468	\|\| addr.stateFre != AddressState.NOT_CHANGED \|\| addr.stateLor != AddressState.NOT_CHANGED \|\| addr.stateSon != AddressState.NOT_CHANGED ){
469
470	addr.state = AddressState.MODIFIED;
471	}
472	}
473	}
474
475	updateDbkBane(addr);
476
477	}
478
479
480
481	private void createFromEntry(AddressSourceEntry entry) {
482	if (entry.husnr == 999) {
483	return;
484	}
485	if (entry.kommunekode == 0 \|\| entry.vejkode == 0) {
486	return;
487	}
488	if (entry.kommunekode < 100) {
489	return;
490	}
491
492	if (entry.gadeid == 0) {
493	return;
494	}
495
496	String gadeidStr = Integer.toString(entry.gadeid);
497	if (gadeidStr.length() != 9) {
498	return;
499	}
500	if (Short.parseShort(gadeidStr.substring(0, 4)) != entry.postnr) {
501	return; //gadeid / postnr mismatch
502	}
503
504
505
506	System.out.println("Opretter adresse ud fra " + entry);
507
508	Address a = new Address();
509	a.state = AddressState.CREATED;
510
511	a.distributor = entry.distributor;
512	a.gadeid = entry.gadeid;
513	a.kommunekode = entry.kommunekode;
514	a.vejkode = entry.vejkode;
515	a.vejnavn = entry.vejnavn;
516	a.husnr = entry.husnr;
517	a.husnrbogstav = entry.litra;
518	a.postnr = entry.postnr;
519	//a.visited = true;
520
521	if (entry.ugedage.mandag) {
522	a.ruteMandag = entry.rute;
523	a.korelisteMandag = entry.koreliste;
524	}
525	if (entry.ugedage.tirsdag) {
526	a.ruteTirsdag = entry.rute;
527	a.korelisteTirsdag = entry.koreliste;
528	}
529	if (entry.ugedage.onsdag) {
530	a.ruteOnsdag = entry.rute;
531	a.korelisteOnsdag = entry.koreliste;
532	}
533	if (entry.ugedage.torsdag) {
534	a.ruteTorsdag = entry.rute;
535	a.korelisteTorsdag = entry.koreliste;
536	}
537	if (entry.ugedage.fredag) {
538	a.ruteFredag = entry.rute;
539	a.korelisteFredag = entry.koreliste;
540	}
541	if (entry.ugedage.lordag) {
542	a.ruteLordag = entry.rute;
543	a.korelisteLordag = entry.koreliste;
544	}
545	if (entry.ugedage.sondag) {
546	a.ruteSondag = entry.rute;
547	a.korelisteLordag = entry.koreliste;
548	}
549
550	updateDbkBane(a);
551
552	// Nu er det nye adresse object oprettet - nu skal det gemmes i søge strukturen og totallisten
553
554
555	TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( a.gadeid );
556
557	if (gade == null) {
558	gade = new TreeMap<Short,ArrayList<Address>>();
559	searchStructure.put(a.gadeid, gade);
560	}
561
562	ArrayList<Address> litraList = gade.get(a.husnr);
563	if (litraList == null) {
564	litraList = new ArrayList<Address>();
565	gade.put(a.husnr, litraList);
566	}
567
568	litraList.add(a);
569	addressList.add(a);
570
571	}
572
573
574
575	/*
576	DAO:
577	UPDATE fulddaekning.adressetabel
578	SET dbkbane = case
579	when substr(korelisteMa,1,2) IN ('07','10','11','12','14','15','16','18','19','20') then 205 #DAO-BRA
580	when substr(korelisteMa,1,2) BETWEEN 24 and 30 then 201 #DAO-Ovrige
581	else 202 #dao syd (52-99=
582	END
583	WHERE distributor='DAO'
584	AND ruteMa is not null;
585
586	FD: Altid 200
587	NS: Altid 204
588	BK: 195,196,197,198
589	*/
590
591	private void updateDbkBane(Address a) {
592	List<Short> daoBane205 = Arrays.asList( new Short[] {7,10,11,12,12,14,15,16,18,19,20} );
593
594
595	Short bane = null;
596
597	switch (a.distributor) {
598	case "BK":
599	bane = dbkBaneMap.get(a.postnr);
600	break;
601	case "DAO":
602	String koreliste = MiscUtils.firstNonNull(a.korelisteMandag,a.korelisteLordag, a.korelisteSondag); //DAO har kun 3 dækningstyper
603	short first2 = Short.parseShort( koreliste.substring(0,2) );
604	if ( daoBane205.contains(first2) ) {
605	bane = 205;
606	} else if (first2 >= 24 && first2<=30) {
607	bane = 201;
608	} else {
609	bane = 202;
610	}
611
612	break;
613	case "FD":
614	bane = 200;
615	break;
616	case "NS":
617	bane = 204;
618	break;
619	default:
620	throw new RuntimeException("Ukendt distributor" + a.distributor); //Silence findBugs
621	}
622
623	if (bane == null) {
624	throw new RuntimeException("Ukendt bane for postnr" + a.postnr);
625	}
626
627	if (a.dbkBane != bane) {
628	a.dbkBane = bane;
629	if (a.state ==AddressState.NOT_CHANGED) {
630	a.state = AddressState.MODIFIED;
631	}
632	}
633	}
634
635	public List<Address> getAddressList() {
636	return Collections.unmodifiableList(addressList);
637	}
638
639	public Map<Integer,String> getUnknownStreets() {
640	return Collections.unmodifiableMap( unknownStreets );
641	}
642
643
644
645	public int getRejectedCount() {
646	return rejectedEntries.size();
647	}
648
649	}