adressevedligehold/fileupload/AddressManager.java

package dk.daoas.adressevedligehold.fileupload;

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.beans.Address;
import dk.daoas.adressevedligehold.beans.Address.AddressState;
import dk.daoas.adressevedligehold.db.DatabaseCoverageUpdate;
import dk.daoas.adressevedligehold.fileupload.AddressSourceEntry.EntryType;
import dk.daoas.adressevedligehold.tasks.TaskLogger;
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 {
        
        private TaskLogger logger = TaskLogger.getInstance();
        
        private int duplicateCount;
        
        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 {
                DatabaseCoverageUpdate db = new DatabaseCoverageUpdate();
                
                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();
                }
                
                logger.info("AddressManager ready, elapsed " + timer.getElapsed() + "ms");
                
                
        }

        @SuppressWarnings("PMD.CollapsibleIfStatements")        
        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;
                        }
                        
                        logger.info(addr.state + ": " + addr.toStringExtended() );
                        logger.info(addr.getRuteString() );
                        
                        if (count++ > 50)
                                return;
                }
        }
        
        public void writeBackChanges() {
                logger.info("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);
                        }
                }
                
                DatabaseCoverageUpdate db = new DatabaseCoverageUpdate();
                
                db.updateAddresses(updates);
                db.saveNewAddresses(inserts);

                
                logger.info("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
                }
        }
        
        @SuppressWarnings("PMD.CollapsibleIfStatements")        
        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);                                
                        }
                        
                        logger.info("[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);
                        logger.info("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 {
                                duplicateCount++;
                                logger.info( "Double visit monday " + addr);
                                return; // if the entry is duplicate on one day that it covers - then it will be as well on all the othters
                        }

                }
                
                
                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 {
                                duplicateCount++;
                                logger.info( "Double visit tuesday " + addr);
                                return; // if the entry is duplicate on one day that it covers - then it will be as well on all the othters
                        }                               
                }

                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 {
                                duplicateCount++;
                                logger.info( "Double visit wednesday " + addr);
                                return; // if the entry is duplicate on one day that it covers - then it will be as well on all the othters
                        }               
                }

                
                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 {
                                duplicateCount++;
                                logger.info( "Double visit thursday " + addr);
                                return; // if the entry is duplicate on one day that it covers - then it will be as well on all the othters
                        }                                       
                }

                
                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 {
                                duplicateCount++;
                                logger.info( "Double visit friday " + addr);
                                return; // if the entry is duplicate on one day that it covers - then it will be as well on all the othters
                        }       
                }

                
                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 {
                                duplicateCount++;
                                logger.info( "Double visit saturday " + addr);
                                return; // if the entry is duplicate on one day that it covers - then it will be as well on all the othters
                        }                                       
                }

                
                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 {
                                duplicateCount++;
                                logger.info( "Double visit sunday " + addr);
                                return; // if the entry is duplicate on one day that it covers - then it will be as well on all the othters
                        }                                       
                }
                
                
                //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 >= 1000) { //husnumre i DK må kun være på 3 cifre
                        return;
                }
                
                if (entry.husnr == 999) {
                        return;
                }
                
                if (entry.litra.length() > 1) { //litra må kun være på 1 tegn
                        return;
                }
                if (entry.litra.length() == 1) {
                        char litra = entry.litra.charAt(0);
                        if ( Character.isLetter(litra) == false ) {
                                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
                }
                
                
                logger.info("Opretter adresse ud fra " + entry);
                
                Address addr = new Address();
                addr.state = AddressState.CREATED;
                
                addr.distributor = entry.distributor;
                addr.gadeid = entry.gadeid;
                addr.kommunekode = entry.kommunekode;
                addr.vejkode = entry.vejkode;
                addr.vejnavn = entry.vejnavn;
                addr.husnr = entry.husnr;
                addr.husnrbogstav = entry.litra;
                addr.postnr = entry.postnr;
                
                
                updateAddress(addr, entry);

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