ClearingPointRepositoryOld.java

/*******************************************************************************
 * Copyright 2012 the original author or authors.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/
package emlab.repository;

import java.util.Iterator;
import java.util.List;

import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import com.tinkerpop.blueprints.pgm.Vertex;
import com.tinkerpop.gremlin.pipes.filter.PropertyFilterPipe;
import com.tinkerpop.pipes.Pipe;
import com.tinkerpop.pipes.filter.FilterPipe;
import com.tinkerpop.pipes.util.Pipeline;

import emlab.domain.market.ClearingPoint;
import emlab.domain.market.DecarbonizationMarket;
import emlab.domain.market.electricity.Segment;
import emlab.domain.market.electricity.SegmentClearingPoint;
import emlab.util.Utils;

/**
 * Repository for {ClearingPoint}s
 * 
 * @author ejlchappin
 * 
 */
@Repository
public class ClearingPointRepositoryOld extends AbstractRepository<ClearingPoint> {

    public ClearingPoint findClearingPointForSegmentAndTime(Segment segment, long time) {
        Iterator<ClearingPoint> i = findClearingPointsForSegmentAndTime(segment, time).iterator();
        if (i.hasNext()) {
            return i.next();
        }
        return null;
    }

    public Iterable<ClearingPoint> findClearingPointsForSegmentAndTime(Segment segment, long time) {
        Pipe<Vertex, Vertex> clearingPointsPipe2 = new LabeledEdgePipe("SEGMENT_POINT", LabeledEdgePipe.Step.IN_OUT);
        // filter by time
        Pipe<Vertex, Vertex> timeFilter = new PropertyFilterPipe<Vertex, Long>("time", time, FilterPipe.Filter.EQUAL);
        Pipeline<Vertex, Vertex> clearingPoint = new Pipeline<Vertex, Vertex>(clearingPointsPipe2, timeFilter);
        return findAllByPipe(segment, clearingPoint);
    }

    public ClearingPoint findClearingPointForMarketAndTime(DecarbonizationMarket market, long time) {

        Iterator<ClearingPoint> i = findClearingPointsForMarketAndTime(market, time).iterator();
        if (i.hasNext()) {
            return i.next();
        }
        return null;
    }

    public Iterable<ClearingPoint> findClearingPointsForMarketAndTime(DecarbonizationMarket market, long time) {
        // TODO: test this
        Pipe<Vertex, Vertex> clearingPoints = new LabeledEdgePipe("MARKET_POINT", LabeledEdgePipe.Step.IN_OUT);
        // filter by time
        Pipe<Vertex, Vertex> timeFilter = new PropertyFilterPipe<Vertex, Long>("time", time, FilterPipe.Filter.EQUAL);
        Pipeline<Vertex, Vertex> clearingPoint = new Pipeline<Vertex, Vertex>(clearingPoints, timeFilter);

        return findAllByPipe(market, clearingPoint);
    }

    @Transactional
    public ClearingPoint createOrUpdateClearingPoint(DecarbonizationMarket abstractMarket, double price, double volume, long time) {
        ClearingPoint point = null;
        if (findClearingPointsForMarketAndTime(abstractMarket, time).iterator().hasNext()) {
            point = findClearingPointsForMarketAndTime(abstractMarket, time).iterator().next();
        } else {
            point = new ClearingPoint().persist();
        }
        point.setAbstractMarket(abstractMarket);
        point.setPrice(price);
        point.setTime(time);
        point.setVolume(volume);
        return point;
    }

    @Transactional
    public SegmentClearingPoint createOrUpdateSegmentClearingPoint(Segment segment, DecarbonizationMarket abstractMarket, double price,
            double volume, long time) {
        SegmentClearingPoint point = null;
        // TODO make this a pipe
        List<SegmentClearingPoint> points = Utils.asCastedList(findClearingPointsForMarketAndTime(abstractMarket, time));
        for (SegmentClearingPoint onepoint : points) {
            if (onepoint.getSegment().equals(segment)) {
                point = onepoint;
            }
        }
        if (point == null) {
            point = new SegmentClearingPoint().persist();
        }
        point.setAbstractMarket(abstractMarket);
        point.setPrice(price);
        point.setTime(time);
        point.setVolume(volume);
        point.setSegment(segment);
        return point;
    }

}