code.grnet.gr Git - aquarium/blob - logic/src/main/scala/gr/grnet/aquarium/logic/accounting/Accounting.scala

   1 /*
   2  * Copyright 2011 GRNET S.A. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or
   5  * without modification, are permitted provided that the following
   6  * conditions are met:
   7  *
   8  *   1. Redistributions of source code must retain the above
   9  *      copyright notice, this list of conditions and the following
  10  *      disclaimer.
  11  *
  12  *   2. Redistributions in binary form must reproduce the above
  13  *      copyright notice, this list of conditions and the following
  14  *      disclaimer in the documentation and/or other materials
  15  *      provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
  18  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  20  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
  21  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  24  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  25  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  27  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  * The views and conclusions contained in the software and
  31  * documentation are those of the authors and should not be
  32  * interpreted as representing official policies, either expressed
  33  * or implied, of GRNET S.A.
  34  */
  35
  36 package gr.grnet.aquarium.logic.accounting
  37
  38 import dsl._
  39 import gr.grnet.aquarium.logic.events.ResourceEvent
  40 import com.ckkloverdos.maybe.{Failed, Just, Maybe}
  41 import java.util.Date
  42 import collection.immutable.SortedMap
  43
  44 /**
  45  *
  46  *
  47  * @author Georgios Gousios <gousiosg@gmail.com>
  48  */
  49 trait Accounting extends DSLUtils {
  50
  51   def chargeEvent(ev: ResourceEvent) : Maybe[Float] = {
  52
  53     if (!ev.validate())
  54       return Failed(new AccountingException("Event not valid"))
  55
  56     //From now own, we can trust the event contents
  57     val resource = Policy.policy.findResource(ev.resource).get
  58
  59
  60
  61     Just(0F)
  62   }
  63
  64   case class ChargeChunk(value: Float, algorithm: DSLAlgorithm,
  65                          priceList: DSLPriceList) {
  66     def cost(): Float = {
  67       0F
  68     }
  69   }
  70
  71   def calcChangeChunks(agr: DSLAgreement, volume: Float,
  72                        from: Date, to: Date) : List[ChargeChunk] = {
  73
  74     resolveEffectiveAlgorithmsForTimeslot(Timeslot(from, to), agr)
  75     resolveEffectivePricelistsForTimeslot(Timeslot(from, to), agr)
  76
  77     List()
  78   }
  79
  80   def splitChargeChunks(alg: Map[Timeslot, DSLAlgorithm],
  81                         price: Map[Timeslot, DSLPriceList]) :
  82   (Map[Timeslot, DSLAlgorithm], Map[Timeslot, DSLPriceList]) = {
  83
  84     val algsort = alg.toSeq.sortWith((x,y) => sorter(x._1, y._1))
  85     val prisort = price.toSeq.sortWith((x,y) => sorter(x._1, y._1))
  86
  87     // Type: Seq[((Timeslot, DSLAlgorithm),(Timeslot, DSLPriceList))]
  88     val zipped = algsort.zip(prisort)
  89
  90     zipped.find(p => !p._1._1.equals(p._2._1)) match {
  91       case None => (alg, price)
  92       case Some(x) =>
  93         val algTimeslot = x._1._1
  94         val priTimeslot = x._2._1
  95
  96         assert(algTimeslot.from == priTimeslot.from)
  97
  98         if (algTimeslot.endsAfter(priTimeslot)) {
  99           val slices = algTimeslot.slice(priTimeslot.to)
 100           val algo = alg.get(algTimeslot).get
 101           val newalg = alg - algTimeslot ++
 102             Map(slices.apply(0) -> algo) ++ Map(slices.apply(1) -> algo)
 103           splitChargeChunks(newalg, price)
 104         }
 105         else {
 106           val slices = priTimeslot.slice(priTimeslot.to)
 107           val pl = price.get(priTimeslot).get
 108           val newPrice = price - priTimeslot ++
 109             Map(slices.apply(0) -> pl) ++ Map(slices.apply(1) -> pl)
 110           splitChargeChunks(alg, newPrice)
 111         }
 112     }
 113   }
 114 }
 115
 116 /** An exception raised when something goes wrong with accounting */
 117 class AccountingException(msg: String) extends Exception(msg)