--- /dev/null
+from SmartAPI.model.Obj import Obj
+
+class CalculationMethod(Obj):
+
+ def __init__(self, uri = None):
+ Obj.__init__(self, uri)
\ No newline at end of file
--- /dev/null
+from SmartAPI.common.PROPERTY import PROPERTY
+
+from SmartAPI.model.PriceSpecification import PriceSpecification
+from SmartAPI.model.Condition import Condition
+
+
+class DependentPriceSpecification(PriceSpecification):
+
+ def __init__(uri = None, value = None, unit = None, validFrom = None, validThrough = None):
+ super(DependentPriceSpecification, self).__init__(uri = uri, value = value, unit = unit, validFrom = validFrom, validThrough = validThrough)
+
+ self.init_property(PROPERTY.LIST, 'conditions', self.hasCondition, self.getConditions, islist = True)
+
+ def hasCondition(self):
+ return len(self.conditions) > 0
+
+ def getConditions(self):
+ return self.conditions
+
+ def addCondition(self, c):
+ self.conditions.append(c)
+
+ def _parseStatement(self, statement, custom_classes = None):
+ self.parse_property(statement, PROPERTY.LIST, self.addCondition, Condition, custom_classes = custom_classes)
+ super(DependentPriceSpecification, self)._parseStatement(statement, custom_classes = custom_classes)
\ No newline at end of file
--- /dev/null
+from SmartAPI.model.TravelDistanceDependentPriceSpecification import TravelDistanceDependentPriceSpecification
+from SmartAPI.model.Coordinates import Coordinates
+from SmartAPI.common.PROPERTY import PROPERTY
+from SmartAPI.common.RESOURCE import RESOURCE
+
+
+class DistanceDependentPriceSpecification(TravelDistanceDependentPriceSpecification):
+
+ def __init__(uri = None, value = None, unit = None, validFrom = None, validThrough = None):
+ super(DistanceDependentPriceSpecification, self).__init__(uri = uri, value = value, unit = unit, validFrom = validFrom, validThrough = validThrough)
+ self.setType(RESOURCE.DISTANCEDEPENDENTPRICESPECIFICATION)
+ self.init_property(PROPERTY.LOCATION, 'coordinates', self.hasCoordinates, self.getCoordinates)
+
+ def hasCoordinates(self):
+ return self.coordinates is not None
+
+ def getCoordinates(self):
+ return self.coordinates
+
+ def setCoordinates(self, coordinates=None, latitude=None, longitude=None):
+ if (latitude is not None and longitude is not None):
+ coordinates = Coordinates(latitude=None, longitude=None)
+ self.coordinates = coordinates
+
+ def _parseStatement(self, statement, custom_classes = None):
+ self.parse_property(statement, PROPERTY.LOCATION, self.setCoordinates, Coordinates, custom_classes = custom_classes)
+ super(DistanceDependentPriceSpecification, self)._parseStatement(statement, custom_classes = custom_classes)
+
+
--- /dev/null
+from SmartAPI.model.DependentPriceSpecification import DependentPriceSpecification
+from SmartAPI.model.Coordinates import Coordinates
+from SmartAPI.common.PROPERTY import PROPERTY
+from SmartAPI.common.RESOURCE import RESOURCE
+
+
+class DurationAtDistanceDependentPriceSpecification(DependentPriceSpecification):
+
+ def __init__(uri = None, value = None, unit = None, validFrom = None, validThrough = None):
+ super(DurationAtDistanceDependentPriceSpecification, self).__init__(uri = uri, value = value, unit = unit, validFrom = validFrom, validThrough = validThrough)
+ self.setType(RESOURCE.DURATIONATDISTANCEDEPENDENTPRICESPECIFICATION)
+ self.init_property(PROPERTY.LOCATION, 'coordinates', self.hasCoordinates, self.getCoordinates)
+
+ def hasCoordinates(self):
+ return self.coordinates is not None
+
+ def getCoordinates(self):
+ return self.coordinates
+
+ def setCoordinates(self, coordinates=None, latitude=None, longitude=None):
+ if (latitude is not None and longitude is not None):
+ coordinates = Coordinates(latitude=None, longitude=None)
+ self.coordinates = coordinates
+
+ def _parseStatement(self, statement, custom_classes = None):
+ self.parse_property(statement, PROPERTY.LOCATION, self.setCoordinates, Coordinates, custom_classes = custom_classes)
+ super(DurationAtDistanceDependentPriceSpecification, self)._parseStatement(statement, custom_classes = custom_classes)
+
+
--- /dev/null
+from SmartAPI.model.DependentPriceSpecification import DependentPriceSpecification
+from SmartAPI.common.RESOURCE import RESOURCE
+
+
+class DurationAtZoneDependentPriceSpecification(DependentPriceSpecification):
+
+ def __init__(uri = None, value = None, unit = None, validFrom = None, validThrough = None):
+ super(DurationAtZoneDependentPriceSpecification, self).__init__(uri = uri, value = value, unit = unit, validFrom = validFrom, validThrough = validThrough)
+ self.setType(RESOURCE.DURATIONATDISTANCEDEPENDENTPRICESPECIFICATION)
+
+ def _parseStatement(self, statement, custom_classes = None):
+ super(DurationAtZoneDependentPriceSpecification, self)._parseStatement(statement, custom_classes = custom_classes)
+
--- /dev/null
+from SmartAPI.model.DependentPriceSpecification import DependentPriceSpecification
+from SmartAPI.common.RESOURCE import RESOURCE
+
+
+class DurationDependentPriceSpecification(DependentPriceSpecification):
+
+ def __init__(uri = None, value = None, unit = None, validFrom = None, validThrough = None):
+ super(DurationDependentPriceSpecification, self).__init__(uri = uri, value = value, unit = unit, validFrom = validFrom, validThrough = validThrough)
+ self.setType(RESOURCE.DURATIONDEPENDENTPRICESPECIFICATION)
+
+ def _parseStatement(self, statement, custom_classes = None):
+ super(DurationDependentPriceSpecification, self)._parseStatement(statement, custom_classes = custom_classes)
+
--- /dev/null
+from SmartAPI.model.CalculationMethod import CalculationMethod
+from SmartAPI.common.RESOURCE import RESOURCE
+from SmartAPI.common.PROPERTY import PROPERTY
+
+"""
+ * Linear calculation represents a calculation of an n-variable linear equation:
+ *
+ * a(1)x(1) + ... + a(n)x(n) + c = y
+ *
+ * where
+ * a(n) is Nth multiplier
+ * x(n) is Nth variable
+ * c is offset
+ * y is the calculation result
+ *
+ * @author Asema 2018
+ *
+"""
+
+class LinearCalculation(CalculationMethod):
+
+ def __init__(self, uri = None):
+ CalculationMethod.__init__(self, uri)
+ self.setType(RESOURCE.LINEARCALCULATION);
+
+ self.init_property(PROPERTY.OFFSET, 'offset', self.hasOffset, self.getOffset)
+ self.init_property(PROPERTY.LIST, 'multipliers', self.hasMultiplier, self.getMultipliers, islist = True)
+
+ def hasOffset(self):
+ return self.offset is not None
+
+ def getOffset(self):
+ return self.offset
+
+ def setOffset(self, o):
+ if o is not None:
+ if not isinstance(o, Variant):
+ o = Variant(o)
+ self.offset = o
+
+ def hasMultiplier(self):
+ return len(self.multipliers) > 0
+
+ def getMultipliers(self):
+ return self.multipliers
+
+ def getMultiplier(self, index):
+ return self.multipliers[index]
+
+ def addMultiplier(self, m):
+ self.multipliers.append(m)
+
+ # calculates y as the result
+ def calculate(args):
+ res = 0.0
+ for a in args:
+ if a is not None:
+ res = res + a * self.getMultiplier(i)
+
+ if self.hasOffset() and (self.offset.isInteger() or self.offset.isDouble() or self.offset.isFloat()):
+ res = res + self.getOffset().getValue()
+
+ return res;
+
if isinstance(m, str):
m = Variant(URIRef(m))
elif isinstance(m, URIRef):
- m = Variant(m)
+ m = Variant(m)
self.method = m
def hasId(self):
'''
@param e: string or Obj type
'''
- from Obj import Obj
+ from Obj import Obj
if isinstance(e, str):
e = Obj(e)
self.transactionId = e
--- /dev/null
+from SmartAPI.model.PropertyDependentPriceSpecification import PropertyDependentPriceSpecification
+from SmartAPI.common.RESOURCE import RESOURCE
+
+
+class ObjectOperationDependentPriceSpecification(DependentPriceSpecification):
+
+ def __init__(uri = None, value = None, unit = None, validFrom = None, validThrough = None):
+ super(ObjectOperationDependentPriceSpecification, self).__init__(uri = uri, value = value, unit = unit, validFrom = validFrom, validThrough = validThrough)
+ self.setType(RESOURCE.OBJECTOPERATIONDEPENDENTPRICESPECIFICATION)
+
+ def _parseStatement(self, statement, custom_classes = None):
+ super(ObjectOperationDependentPriceSpecification, self)._parseStatement(statement, custom_classes = custom_classes)
+
+
\ No newline at end of file
--- /dev/null
+from SmartAPI.model.DependentPriceSpecification import DependentPriceSpecification
+from SmartAPI.common.RESOURCE import RESOURCE
+from SmartAPI.common.PROPERTY import PROPERTY
+from SmartAPI.rdf.Variant import Variant
+
+from rdflib import URIRef, XSD
+
+
+class PropertyDependentPriceSpecification(DependentPriceSpecification):
+
+ def __init__(uri = None, value = None, unit = None, validFrom = None, validThrough = None):
+ super(PropertyDependentPriceSpecification, self).__init__(uri = uri, value = value, unit = unit, validFrom = validFrom, validThrough = validThrough)
+ self.setType(RESOURCE.PROPERTYDEPENDENTPRICESPECIFICATION)
+
+ self.init_property(PROPERTY.REFERENCEOBJECT, 'referenceObject', self.hasReferenceObject, self.getReferenceObject)
+ self.init_property(PROPERTY.SMARTAPI_PROPERTY, 'property', self.hasProperty, self.getProperty)
+
+ def hasReferenceObject(self):
+ return self.referenceObject is not None
+
+ def getReferenceObject(self):
+ return self.referenceObject
+
+ def setReferenceObject(self, r):
+ if r is not None:
+ if isinstance(r, str):
+ r = Variant(URIRef(r))
+ elif isinstance(r, URIRef):
+ r = Variant(r)
+ self.referenceObject = r
+
+ def hasProperty(self):
+ return self.property is not None
+
+ def getProperty(self):
+ return self.property
+
+ def setProperty(self, p):
+ if p is not None:
+ if isinstance(p, str):
+ p = Variant(URIRef(p))
+ elif isinstance(r, URIRef):
+ p = Variant(p)
+ self.referenceObject = p
+
+ def _parseStatement(self, statement, custom_classes = None):
+ self.parse_property(statement, PROPERTY.REFERENCEOBJECT, self.setCoordinates, Variant, custom_classes = custom_classes)
+ self.parse_property(statement, PROPERTY.SMARTAPI_PROPERTY, self.setCoordinates, Variant, custom_classes = custom_classes)
+ super(PropertyDependentPriceSpecification, self)._parseStatement(statement, custom_classes = custom_classes)
+
--- /dev/null
+from SmartAPI.model.TimeDependentPriceSpecification import TimeDependentPriceSpecification
+from SmartAPI.common.RESOURCE import RESOURCE
+
+
+class TimeDependentPriceListSpecification(TimeDependentPriceSpecification):
+
+ def __init__(uri = None, value = None, unit = None, validFrom = None, validThrough = None):
+ super(TimeDependentPriceListSpecification, self).__init__(uri = uri, value = value, unit = unit, validFrom = validFrom, validThrough = validThrough)
+ self.setType(RESOURCE.TIMEDEPENDENTPRICELISTSPECIFICATION)
+
+ def _parseStatement(self, statement, custom_classes = None):
+ super(TimeDependentPriceListSpecification, self)._parseStatement(statement, custom_classes = custom_classes)
+
+
+
\ No newline at end of file
--- /dev/null
+from SmartAPI.model.DependentPriceSpecification import DependentPriceSpecification
+from SmartAPI.common.RESOURCE import RESOURCE
+
+
+class TimeDependentPriceSpecification(DependentPriceSpecification):
+
+ def __init__(uri = None, value = None, unit = None, validFrom = None, validThrough = None):
+ super(TimeDependentPriceSpecification, self).__init__(uri = uri, value = value, unit = unit, validFrom = validFrom, validThrough = validThrough)
+ self.setType(RESOURCE.TIMEDEPENDENTPRICESPECIFICATION)
+
+ def _parseStatement(self, statement, custom_classes = None):
+ super(TimeDependentPriceSpecification, self)._parseStatement(statement, custom_classes = custom_classes)
+
\ No newline at end of file
--- /dev/null
+from SmartAPI.model.DependentPriceSpecification import DependentPriceSpecification
+from SmartAPI.model.CalculationMethod import CalculationMethod
+from SmartAPI.model.LinearCalculation import LinearCalculation
+from SmartAPI.common.RESOURCE import RESOURCE
+from SmartAPI.common.PROPERTY import PROPERTY
+
+
+class TravelDistanceDependentPriceSpecification(DependentPriceSpecification):
+
+ def __init__(uri = None, value = None, unit = None, validFrom = None, validThrough = None):
+ super(TravelDistanceDependentPriceSpecification, self).__init__(uri = uri, value = value, unit = unit, validFrom = validFrom, validThrough = validThrough)
+ self.setType(RESOURCE.TRAVELDISTANCEDEPENDENTPRICESPECIFICATION)
+
+ self.init_property(PROPERTY.CALCULATIONMETHOD, 'calculationMethod', self.hasCoordinates, self.getCoordinates)
+
+
+ def hasCalculationMethod(self):
+ return self.calculationMethod is not None
+
+ def getCalculationMethod(self):
+ return self.calculationMethod
+
+ def setCalculationMethod(self, m):
+ if isinstance(m, LinearCalculation):
+ self.addType(RESOURCE.LINEARPRICESPECIFICATION)
+ self.calculationMethod = m
+
+ def addCondition(condition):
+ self.addType(RESOURCE.STEPPRICESPECIFICATION)
+ super(TravelDistanceDependentPriceSpecification, self).addCondition(condition)
+
+ def isStepPriceSpecification():
+ self. hasType(RESOURCE.STEPPRICESPECIFICATION)
+
+ def isLinearPriceSpecification():
+ self. hasType(RESOURCE.LINEARPRICESPECIFICATION)
+
+ def calculatePrice(distance):
+ if self.hasCalculationMethod():
+ return self.getCalculationMethod().calculate(distance)
+ else:
+ print "Unable to calculate price for a distance dependent price specification because the calculation method is not defined. Returning none."
+ return None
+
+ def _parseStatement(self, statement, custom_classes = None):
+ self.parse_property(statement, PROPERTY.CALCULATIONMETHOD, self.setCalculationMethod, CalculationMethod, custom_classes = custom_classes)
+
+ super(TravelDistanceDependentPriceSpecification, self)._parseStatement(statement, custom_classes = custom_classes)
+
+
+
\ No newline at end of file
--- /dev/null
+from SmartAPI.model.DependentPriceSpecification import DependentPriceSpecification
+from SmartAPI.common.RESOURCE import RESOURCE
+
+
+class TravelDistanceDurationDependentPriceSpecification(DependentPriceSpecification):
+
+ def __init__(uri = None, value = None, unit = None, validFrom = None, validThrough = None):
+ super(TravelDistanceDurationDependentPriceSpecification, self).__init__(uri = uri, value = value, unit = unit, validFrom = validFrom, validThrough = validThrough)
+ self.setType(RESOURCE.TRAVELDISTANCEDURATIONDEPENDENTPRICESPECIFICATION)
+
+ def _parseStatement(self, statement, custom_classes = None):
+ super(TravelDistanceDurationDependentPriceSpecification, self)._parseStatement(statement, custom_classes = custom_classes)
+
+
\ No newline at end of file
--- /dev/null
+from SmartAPI.model.DependentPriceSpecification import DependentPriceSpecification
+from SmartAPI.common.RESOURCE import RESOURCE
+
+
+class ZoneDependentPriceSpecification(DependentPriceSpecification):
+
+ def __init__(uri = None, value = None, unit = None, validFrom = None, validThrough = None):
+ super(ZoneDependentPriceSpecification, self).__init__(uri = uri, value = value, unit = unit, validFrom = validFrom, validThrough = validThrough)
+ self.setType(RESOURCE.ZONEDEPENDENTPRICESPECIFICATION)
+
+ def _parseStatement(self, statement, custom_classes = None):
+ super(ZoneDependentPriceSpecification, self)._parseStatement(statement, custom_classes = custom_classes)
+
+
\ No newline at end of file
--- /dev/null
+from SmartAPI.model.DependentPriceSpecification import DependentPriceSpecification
+from SmartAPI.common.RESOURCE import RESOURCE
+
+
+class ZoneTravelDependentPriceSpecification(DependentPriceSpecification):
+
+ def __init__(uri = None, value = None, unit = None, validFrom = None, validThrough = None):
+ super(ZoneTravelDependentPriceSpecification, self).__init__(uri = uri, value = value, unit = unit, validFrom = validFrom, validThrough = validThrough)
+ self.setType(RESOURCE.ZONETRAVELDEPENDENTPRICESPECIFICATION)
+
+ def _parseStatement(self, statement, custom_classes = None):
+ super(ZoneTravelDependentPriceSpecification, self)._parseStatement(statement, custom_classes = custom_classes)
+
+
+
\ No newline at end of file
--- /dev/null
+from SmartAPI.model.DependentPriceSpecification import DependentPriceSpecification
+from SmartAPI.common.RESOURCE import RESOURCE
+
+
+class ZoneTravelDurationDependentPriceSpecification(DependentPriceSpecification):
+
+ def __init__(uri = None, value = None, unit = None, validFrom = None, validThrough = None):
+ super(ZoneTravelDurationDependentPriceSpecification, self).__init__(uri = uri, value = value, unit = unit, validFrom = validFrom, validThrough = validThrough)
+ self.setType(RESOURCE.ZONETRAVELDURATIONDEPENDENTPRICESPECIFICATION)
+
+ def _parseStatement(self, statement, custom_classes = None):
+ super(ZoneTravelDurationDependentPriceSpecification, self)._parseStatement(statement, custom_classes = custom_classes)
+
\ No newline at end of file
return "Obj"
elif self.isList():
return "List"
- elif self.isVariant():
+ elif self.isVariant():
return "Variant"
- else:
+ else:
return None
def getAsString(self):
projects / smartapi.git / commitdiff