org.unlaxer.jaddress.parser.DataAccessContextImpl Maven / Gradle / Ivy

Go to download
package org.unlaxer.jaddress.parser;

import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.TreeMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.stream.Stream;

import org.elasticsearch.action.bulk.BulkProcessor;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.seasar.doma.jdbc.Config;
import org.seasar.doma.jdbc.tx.TransactionManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.unlaxer.jaddress.ElaticeSearchAccessor;
import org.unlaxer.jaddress.Indexes;
import org.unlaxer.jaddress.JyuusyoJPDomaConfig;
import org.unlaxer.jaddress.UserHomeContext;
import org.unlaxer.jaddress.dao.JyuusyoJPDao;
import org.unlaxer.jaddress.dao.JyuusyoJPDaoImpl;
import org.unlaxer.jaddress.entity.jyuusyojp.JyuusyoJP;
import org.unlaxer.jaddress.entity.standard.郵便番号;
import org.unlaxer.util.Either;
import org.unlaxer.util.collection.ID;

public class DataAccessContextImpl implements DataAccessContext{
	
	ElaticeSearchAccessor elaticeSearchAccessor;
	
	AddressParser addressParser = new AddressParserImpl();
	
	static Logger logger = LoggerFactory.getLogger(DataAccessContextImpl.class);

	public static final Path DEFAULT_SQLITE_PATH =  UserHomeContext.getPathWithFolderAndFile("jyuusyojp","zenkoku.sqlite3");
	
	JyuusyoJPDao jyuusyoJPDao;
	TransactionManager transactionManager;
	
	Config config;
	
	public DataAccessContextImpl(Path pathToJyuusyoJpSqlite) {
		super();
		config = new JyuusyoJPDomaConfig(pathToJyuusyoJpSqlite);
		jyuusyoJPDao = new JyuusyoJPDaoImpl(config);
		transactionManager = config.getTransactionManager();
		elaticeSearchAccessor = new ElaticeSearchAccessor();
	}
	
	public DataAccessContextImpl() {
		this(DEFAULT_SQLITE_PATH);
	}


	@Override
	public List selectJyuusyoJPsByZip(郵便番号 zip){
		
		List addresses = transactionManager.required(() -> {
			
			List selectAll = jyuusyoJPDao.selectByZip(zip);
			
			return selectAll;
		});
		return addresses;
	}

	@Override
	public Stream selectAllJyuusyoJP() {
		Stream addresses = transactionManager.required(() -> {

			List selectAll = jyuusyoJPDao.selectAll();
			
			return selectAll.stream();
		});
		return addresses;
	}

	@Override
	public void addIndexToJyuusyoJP() {
		transactionManager.required(() -> {
			jyuusyoJPDao.addIndex();
		});
	}

	@Override
	public void dropIndexFromJyuusyoJP() {
		transactionManager.required(() -> {
			jyuusyoJPDao.dropIndex();
		});
	}
	
	// elastic search

	@Override
	public CheckExistenceResponse search(CheckExistenceParameter parameter) {
		// TODO Auto-generated method stub
		return null;
	}
	
	@Override
	public UpdateResponse update(Stream addresses) {
		
		UpdateResponse updateResponse = new UpdateResponse();
		
		RestHighLevelClient client = elaticeSearchAccessor.get();
		
		CountableBulkProcessorListerner listener = new CountableBulkProcessorListerner();

		try(BulkProcessor bulkProcessor = BulkProcessor
				.builder(
						(request, bulkListener) -> client.bulkAsync(request, RequestOptions.DEFAULT, bulkListener),
						listener)
				.build()){
		
			addresses.forEach(addressContext->{
				IndexRequest indexRequest = Indexes.ad_address.createIndexRequest();
				indexRequest.id(addressContext.id.toString());
				Map source = createSource(addressContext);
				if(source.isEmpty()) {
					updateResponse.addFailed(1);
					updateResponse.addParseError(addressContext.id);
				}else {
					indexRequest.source(source);
					bulkProcessor.add(indexRequest);
					updateResponse.addSucceded(1);
				}
			});

			boolean terminated = bulkProcessor.awaitClose(30L, TimeUnit.SECONDS);
			logger.info("terminated:" + terminated);
			
			updateResponse.addFailed(listener.failed); 
			updateResponse.addIndexError(listener.errorsIds); 
			
			return updateResponse;

		} catch (Exception e) {
			logger.error("error",e);
			updateResponse.addFailed(1);
			updateResponse.addErrorMessage(e.getMessage());
			return updateResponse;
		}
	}
	

	
	private Map createSource(AddressContext addressContext) {

		ParsingContext parsingContext = new ParsingContext(
				new DataAccessContextImpl(),
				addressContext
		);
		
		addressParser.parse(parsingContext);
		
		AddressContext returning  = parsingContext.addressContext;
//		var id = returning.id.getName();
		Map valueByKey = new TreeMap<>();
		valueByKey.put("zip", returning.zip.hyphonated);
		valueByKey.put("input", addressContext.addressString.joined());

		Either results = parsingContext.addressContext.results();
		results.right.ifPresent(result -> {
			result.get().stream().forEach(as -> {
				as.get().forEach(addressElement -> {
					String value = addressElement.asString();
					if (value != null && !value.isBlank()) {
						valueByKey.put(String.valueOf(addressElement.階層要素().level), value);
					}
				});
			});
		});
		return valueByKey;
	}

	
	
	
	


	@Override
	public CheckExistenceResponse get(ID id) {
		return null;
	}
}