def create(cls, product_name_data, serial_number_data, module_id_data,
sensor_id_data, sensor_name_data, odenki_user):
assert isinstance(odenki_user, OdenkiUser)
assert isinstance(product_name_data, Data)
assert isinstance(serial_number_data, Data)
assert isinstance(module_id_data, Data)
assert isinstance(sensor_id_data, Data)
assert isinstance(sensor_name_data, Data)
try:
existing_sensor = cls.getByProductNameSerialNumberModuleIdSensorId(
product_name_data, serial_number_data, module_id_data,
sensor_id_data)
raise EntityExists(
"Equipment", {
"product_name_data": product_name_data,
"serial_number_data": serial_number_data,
"module_id_data": module_id_data,
"sensor_id_data": sensor_id_data
})
except:
sensor = Sensor()
sensor.uniqueSensorId = Counter.GetNextId("equipmentId")
sensor.productName = product_name_data.dataId
sensor.serialNumber = serial_number_data.dataId
sensor.moduleId = module_id_data.dataId
sensor.sensorId = sensor_id_data.dataId
sensor.odenkiId = odenki_user.odenkiId
assert sensor_name_data.dataId is not None
sensor.sensorName = sensor_name_data.dataId
assert sensor.sensorName is not None
sensor.put()
return sensor
def saveToSession(self):
session = gaesessions.get_current_session()
assert isinstance(session, gaesessions.Session)
try:
existing = self.loadFromSession()
assert isinstance(existing, OdenkiUser)
if existing.odenkiId != self.odenkiId:
raise EntityExists({"OdenkiUserInSession": existing, "IncomingOdenkiUser": self})
except EntityNotFound: pass
session[self.SESSION_KEY] = self
def saveToSession(self):
"""saves instance of GmailUser as session variable copying odenkiId from OdenkiUser instance in the session if exists."""
try:
existing = GmailUser.loadFromSession()
assert isinstance(existing, GmailUser)
if existing.gmailId != self.gmailId:
raise EntityExists(self.__class__, {"existing.gmailId": existing.gmailId, "self.GmailId": self.gmailId})
except EntityNotFound: pass
session = gaesessions.get_current_session()
session[self.SESSION_KEY] = self
def create(self, outlet_id):
try:
outlet = Outlet.getByOutletId(outlet_id)
assert isinstance(outlet, Outlet)
raise EntityExists({"outletId": outlet_id})
except:
pass
outlet = Outlet()
outlet.outletId = outlet_id
outlet.put()
return outlet
def register(self, jrequest, jresponse):
assert isinstance(jrequest, JsonRpcRequest)
assert isinstance(jresponse, JsonRpcResponse)
jresponse.setId()
request = jrequest.request
assert isinstance(request, Request)
if len(request.params) < 3:
raise InvalidParams(
"method=register&x=y&z=w&moduleId=mid&sensorId=sid&sensorName=mysensor where x is product field, y is product string, z is serial field, is serial string"
)
assert request.params.items()[0][0] == "method"
assert request.params.items()[0][1] == "register"
(product_name_field, product_name_string) = request.params.items()[1]
(serial_number_field, serial_number_string) = request.params.items()[2]
assert isinstance(product_name_field, str)
product_name_field = unicode(product_name_field)
assert isinstance(product_name_field, unicode)
assert isinstance(serial_number_field, str)
serial_number_field = unicode(serial_number_field)
assert isinstance(serial_number_string, unicode)
try:
product_name_data = Data.prepare(product_name_field,
product_name_string)
serial_number_data = Data.prepare(serial_number_field,
serial_number_string)
module_id_string = request.get("moduleId")
assert len(module_id_string) > 0
sensor_id_string = request.get("sensorId")
assert len(sensor_id_string) > 0
module_id_data = Data.prepare("moduleId", request.get("moduleId"))
sensor_id_data = Data.prepare("sensorId", request.get("sensorId"))
existing_sensor = Sensor.getByProductNameSerialNumberModuleIdSensorId(
product_name_data, serial_number_data, module_id_data,
sensor_id_data)
raise EntityExists(
"Equipment", {
product_name_field: product_name_string,
serial_number_field: serial_number_string,
"moduleId": module_id_string,
"sensorId": sensor_id_string
})
except EntityNotFound:
pass
odenki_user = OdenkiUser.loadFromSession()
assert isinstance(odenki_user, OdenkiUser)
sensor_name = request.get("sensorName")
if len(sensor_name) == 0: sensor_name = unicode(sensor_name)
sensor_name_data = Data.prepare("sensorName", sensor_name)
sensor = Sensor.create(product_name_data, serial_number_data,
module_id_data, sensor_id_data,
sensor_name_data, odenki_user)
jresponse.addResult(sensor)
def setOdenkiId(self, odenki_id):
assert odenki_id is not None
assert self.odenkiId is None
try:
existing_gmail_user = GmailUser.getByOdenkiId(odenki_id)
raise EntityExists({"ExistingGmailUser" : existing_gmail_user,
"IncomingGmailUser": self,
"odenkiId": odenki_id})
except EntityNotFound: pass
self.odenkiId = odenki_id
self.put_async()
def create(cls, field, string, allow_duplication=False):
try:
existing = cls.getByFieldAndString(field, string)
if allow_duplication:
raise EntityNotFound
raise EntityExists("Data", {"field": field, "string": string})
except EntityNotFound:
data = Data()
data.dataId = Counter.GetNextId("dataId")
data.field = field
data.string = string
data.put()
return data
def setOdenkiId(self, odenki_id):
assert odenki_id is not None
assert self.odenkiId is None
try:
existing_twitter_user = TwitterUser.getByOdenkiId(odenki_id)
raise EntityExists({"ExistingTwitterUser" : existing_twitter_user,
"IncomingTwitterUser": self,
"odenkiId": odenki_id},
"TwitterUser.setOdenkiId failed")
except EntityNotFound: pass
self.odenkiId = odenki_id
self.put_async()
def createByEmail(cls, email):
assert isinstance(email, unicode)
try:
existing_email_user = cls.getByEmail(email)
raise EntityExists({"EmailUser": existing_email_user},
"EmailUser %s already exists" % email)
except:
pass
email_user = EmailUser()
assert isinstance(email_user, EmailUser)
email_user.email = email
email_user.registeredDateTime = datetime.now()
email_user.emailUserId = Counter.GetNextId("emailUserId")
#odenki_user = OdenkiUser.createNew()
#assert isinstance(odenki_user, OdenkiUser)
#email_user.odenkiId = odenki_user.odenkiId
email_user.put()
return email_user
def setOdenkiId(self, odenki_id):
assert isinstance(odenki_id, int)
assert self.odenkiId is None
try:
existing_email_user = EmailUser.getByOdenkiId(odenki_id)
raise EntityExists(
{
"ExistingEmailUser": existing_email_user,
"IncomingEmailUser": self,
"odenkiId": odenki_id
},
message="EmailUser with odenkiId %s already exists." %
odenki_id)
except EntityNotFound:
pass
self.odenkiId = odenki_id
self.put_async()