def GetSender(request):
#logging.info(("GetSender", request.url))
assert isinstance(request, Request)
ip_address = request.remote_addr
parsed_url = urlparse(request.url)
if parsed_url.scheme == "http":
protocol = "http"
port = 80
elif parsed_url["scheme"] == "https":
protocol = "https"
port = 443
else:
protocol = ""
port = -1
#logging.info((ip_address, port, protocol))
gql_query = Sender.gql(
"WHERE ipAddress = :1 AND port = :2 AND protocol = :3", ip_address,
port, protocol)
existing_sender = gql_query.get()
#logging.info(existing_sender)
if existing_sender is not None:
#logging.info((existing_sender.senderId, existing_sender.ipAddress, existing_sender.port, existing_sender.protocol))
return existing_sender
else:
sender = Sender()
sender.senderId = Counter.GetNextId("senderId")
sender.ipAddress = ip_address
sender.port = port
sender.protocol = protocol
return sender.put()
def createSender(request):
#logging.info(("GetSender", request.url))
assert isinstance(request, Request)
ip_address = request.remote_addr
parsed_url = urlparse(request.url)
if parsed_url.scheme == "http":
protocol = "http"
port = 80
elif parsed_url["scheme"] == "https":
protocol = "https"
port = 443
else:
protocol = ""
port = -1
query = Sender.querySender(ip_address, port, protocol)
existing_sender = query.get(keys_only=True)
if existing_sender: return existing_sender
sender = Sender()
sender.senderId = Counter.GetNextId("senderId")
sender.ipAddress = ip_address
sender.port = port
sender.protocol = protocol
return sender.put()
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 putMetadata(sender_, raw_data, data_list):
metadata = Metadata()
metadata.metadataId = Counter.GetNextId("metadataId")
now = datetime.datetime.now()
#logging.info(now.strftime('%Y/%m/%d %H:%M:%S%z'))
metadata.receivedDateTime = now
metadata.sender = sender_
metadata.rawData = raw_data
metadata.dataList = data_list
return metadata.put()
def createNew(cls):
"""create new OdenkiUser with new odenkiId and put it to datastore"""
odenki_user = OdenkiUser()
odenki_user.odenkiId = Counter.GetNextId("odenkiId")
odenki_user.odenkiName = "Odenki %s" % odenki_user.odenkiId
odenki_user.createdDateTime = datetime.now()
key = odenki_user.put()
assert isinstance(key, ndb.Key)
entity = key.get()
assert isinstance(entity, OdenkiUser)
return entity
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 putMetadata(cls, sender, raw_data, data_keys):
assert isinstance(sender, Sender)
assert isinstance(raw_data, RawData)
assert isinstance(data_keys, list)
metadata = Metadata()
metadata.metadataId = Counter.GetNextId("metadataId")
now = datetime.datetime.now()
info(now.strftime('%Y/%m/%d %H:%M:%S%z'))
metadata.receivedDateTime = now
metadata.sender = sender
metadata.rawData = raw_data
metadata.dataList = data_keys
return metadata.put()
def putEntity(cls, field, string):
assert isinstance(field, unicode) or isinstance(field, str)
assert isinstance(string, unicode) or isinstance(string, str)
if isinstance(field, str): field = field.decode()
if isinstance(string, str): string = string.decode()
key = cls.getKeyByFieldAndString(field, string)
if key: return key
key = cls.getKeyByFieldAndStringFromDatastore(field, string)
if key: return key
data = Data()
data.dataId = Counter.GetNextId("dataId")
data.field = field
data.string = string
return data.put()
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 putEntity(cls, field, string):
raise PendingDeprecationWarning(
"NdbData.Data.putEntity is being deprecated.")
debug("type of field is %s" % type(field))
field = unicode(field)
assert isinstance(field, unicode)
string = unicode(string)
assert isinstance(string, unicode)
q = cls.getByFieldAndString(field, string)
k = q.get(keys_only=True)
if k: return k
data = cls()
assert isinstance(data, ndb.Model)
data.dataId = Counter.GetNextId("dataId")
data.field = field
data.string = string
data.put()
q = cls.getByFieldAndString(field, string)
k = q.get(keys_only=True)
return k