def test_update_message(self):
self.message1.save()
message1 = Message.get(id=1)
message1.update({'content': 'new_content'})
self.assertEqual('new_content', Message.get(id=1).content)
self.assertTrue(
isinstance(message1.update({'random': 'bad field'}), dict))
def remindFeedBack(request):
"""
提醒某个用户提交反馈
:param request:
:return:
"""
id = request.data.get('id',None)
userType = request.data.get('user',None)
user = AuthUser.objects.get(username=request.user.username)
message_title = u"好学吧家教邀请您填写反馈意见！"
message_content = u"好学吧家教邀请您填写反馈意见！"
if userType == "parent":
objs = ParentOrder.objects.filter(pd_id = id)
elif userType == "teacher":
objs = Teacher.objects.filter(tea_id = id)
else:
return JsonError(u"输入数据的user值不对")
if len(objs):
obj = objs[0]
now = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
message = Message(sender=user, receiver=obj.wechat, message_title=message_title,
message_content=message_content,status=0,update_time=now,create_time=now)
message.save()
return JsonResponse()
else:
return JsonError(u"找不到用户！")
def test_0_second(self):
from api.models import Message
message = Message()
message.date = datetime.datetime.utcnow()
age = message.get_age()
self.assertEqual(age, "0 second")
def test_now(self):
from api.models import Message
message = Message()
dt = datetime.datetime.fromtimestamp(time.time() + 100)
message.date = dt
age = message.get_age()
self.assertEqual(age, "now")
def test_1_day(self):
from api.models import Message
message = Message()
dt = datetime.datetime.fromtimestamp(time.time() - 3600 * 25)
message.date = dt
age = message.get_age()
self.assertEqual(age, "1 day")
def message(self, request, db_session, clean_channel_repo,
clean_notifications_repo):
self.db_session = db_session
self.message1 = Message(payload={"receiver": "AU"})
self.message2 = Message(payload={"receiver": "AU"})
with freeze_time('2020-06-17 12:04:01.111111'):
messages = [
self.message1,
self.message2,
Message(payload={"receiver": "SG"}),
]
for m in messages:
self.db_session.add(m)
self.db_session.commit()
with freeze_time('2020-06-17 12:04:03.111111'):
messages = [
Message(payload={"receiver": "SG"}),
]
for m in messages:
self.db_session.add(m)
self.message1.status = MessageStatus.REVOKED
self.db_session.commit()
self.channel_repo = clean_channel_repo
self.notifications_repo = clean_notifications_repo
self.use_case = NewMessagesNotifyUseCase('AU', clean_channel_repo,
clean_notifications_repo)
def test_now(self):
from api.models import Message
message = Message()
dt = datetime.datetime.fromtimestamp(time.time() + 100)
message.date = dt
age = message.get_age()
self.assertEqual(age, "now")
def test_1_day(self):
from api.models import Message
message = Message()
dt = datetime.datetime.fromtimestamp(time.time() - 3600 * 25)
message.date = dt
age = message.get_age()
self.assertEqual(age, "1 day")
def get_replies(flyer_id):
data = request.get_json()
logger.info("Data recieved: %s", data)
if "sender" not in data:
msg = "No sender provided for reply."
logger.info(msg)
return create_response(status=422, message=msg)
flyer = SearchFlyer.query.get(flyer_id)
sender = data['sender']
data['content'] = f'{sender} se quiere contactar con vos por tu aviso.'
data['flyer_id'] = flyer_id
data['recipient'] = flyer.created_by
data['status'] = 'sent'
# create SQLAlchemy Object
message = Message(**data)
# commit it to database
db.session.add_all([message])
db.session.commit()
submit_notification(
flyer.created_by, {
'title': '¡Respondieron tu aviso!',
'body': f'{sender} se quiere contactar con vos por tu aviso.',
'flyer_id': flyer_id
})
return create_response(
message=f"Successfully created message with id: {message.id}",
data={"message": message.to_dict()})
def post(self: View, request: HttpRequest, slug: str) -> JsonResponse:
"""Add a new message to the specified room."""
payload = json.loads(request.body.decode())
content = str(payload.get('content', ''))
if not 1 <= len(content) <= 256:
return error('Content length must be between 1 and 256.')
if not request.session.get('registered'):
return error('You are not registered.')
room = Room.objects.filter(slug=slug).first()
if room is None:
return error('That room does not exist.')
message = Message(
author=request.session.get('username'),
content=content,
room=room
)
message.save()
return JsonResponse({
'success': True,
'message': {
'content': message.content,
'author': message.author
}
})
def test_get_all_messages(self):
self.assertEqual(True, isinstance(Message.get(id=1), dict))
self.message1.save()
self.message2.save()
self.assertEqual(True, isinstance(Message.get_all()[0], Message))
self.assertEqual(True, isinstance(Message.get_all()[1], Message))
self.assertEqual(2, len(Message.get_all()))
def sendPhone(request):
"""
发送联系方式给某个老师
:param request:{"tea_id":1,"tel":18812345678,"oa_id":3}
:return:
"""
tea_id = request.data.get('tea_id',None)
oa_id = request.data.get('oa_id',None)
tel = request.data.get('tel',None)
teas = Teacher.objects.filter(tea_id=tea_id)
oas = OrderApply.objects.filter(oa_id=oa_id)
user = AuthUser.objects.get(username=request.user.username)
if len(teas) and len(oas):
tea = teas[0]
oa = oas[0]
pd_name = oa.pd.name
message_title = u"向您发送了" + pd_name +u"家长的联系方式！"
message_content = pd_name + u"家长的联系方式是" + str(tel)
now = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
message = Message(sender=user, receiver=tea.wechat, message_title=message_title,
message_content=message_content,status=0,update_time=now,create_time=now)
message.save()
oa.tel = str(tel)
oa.finished = 1
oa.save()
return JsonResponse()
else:
return JsonError(u"输入数据有误")
def post_message():
message = Message(message=json.loads(request.data))
channel_repo = ChannelRepo(current_app.config['CHANNEL_REPO_CONF'])
channel_queue_repo = ChannelQueueRepo(current_app.config['CHANNEL_QUEUE_REPO_CONF'])
use_case = ReceiveMessageUseCase(channel_repo, channel_queue_repo)
use_case.receive(message)
message_data = message.to_dict()
return JsonResponse(message_data, status=200)
def messages(request):
if request.method == 'GET':
return JsonResponse([message.serialize() for message in Message.objects.all()], safe=False)
else:
data = request.POST
message = Message(author=data['author'], content=data['content'])
message.save()
return JsonResponse(message.serialize(), safe=False)
def setUp(self):
"""
Set up test application.
"""
self.app = create_app('testing')
self.client = self.app.test_client()
self.client.headers = {'Authorization': getenv('TEST_TOKEN')}
self.app_context = self.app.app_context()
self.app_context.push()
db.drop_all()
db.create_all()
self.board1 = Board()
self.board2 = Board()
self.conversation1 = Conversation()
self.conversation2 = Conversation()
self.deposit1 = Deposit()
self.deposit2 = Deposit()
self.estate1 = Estate(address="Random Address 1")
self.estate2 = Estate(address="Random Address 2")
self.estate3 = Estate()
self.headers = {'Authorization': getenv('TEST_TOKEN')}
self.message1 = Message(sender=1, content='Random Content')
self.message2 = Message(sender=2, content='Random Content')
self.message3 = Message()
self.payment1 = Payment()
self.payment2 = Payment()
self.role1 = Role(title='basic')
self.role2 = Role(title='admin')
self.role3 = Role(title='super_admin')
self.role4 = Role()
self.unit1 = Unit(name="Random Unit 1")
self.unit2 = Unit(name="Random Unit 2")
self.unit3 = Unit()
self.user1 = User(name="First1 Middle1 Last1",
phone_number="000 12 3456781",
email="*****@*****.**",
password=digest('ABC123!@#'))
self.user2 = User(name="First2 Middle2 Last2",
phone_number="000 12 3456782",
email="*****@*****.**",
password=digest('ABC123!@#'))
self.user3 = User()
self.user_new_data1 = {'phone_number': "000 12 3456783"}
self.user_new_data2 = {'bad_field': "random"}
self.wallet1 = Wallet()
self.wallet2 = Wallet()
self.user1_dict = {
"name": "First1 Middle1 Last1",
"phone_number": "000 12 3456781",
"email": "*****@*****.**",
"password": "******"
}
self.conversation3_dict = {"participants": [1, 2]}
self.message4_dict = {"content": "New Message."}
self.board3_dict = {'members': [1, 2]}
def messages(request):
if request.method == 'GET':
return JsonResponse(
[message.serialize() for message in Message.objects.all()],
safe=False)
else:
data = request.POST
message = Message(author=data['author'], content=data['content'])
message.save()
return JsonResponse(message.serialize(), safe=False)
def test_list_all_messages(self):
Message.objects.bulk_create([
Message(content='message1'),
Message(content='message2'),
Message(content='message3'),
])
response = self.client.get(f'{self.BASE_URL}/messages',
**self.bearer_token)
self.assertEqual(response.status_code, HTTP_200_OK)
self.assertEqual(len(response.json()), 3)
def __uploadhelper(request):
if request.FILES is None or request.FILES['original_file'] is None:
raise Exception('No file sent.')
# Get uploaded file.
origFile = request.FILES['original_file']
# Apply reverse reverb (aka "creepify")?
soxCreepify = True if request.POST['creepify'] == 'yes' else False
# Check that this is a wav file.
if origFile.content_type not in settings.ALLOWABLE_INPUT_FILE_TYPES:
raise Exception('You can only upload WAV files!')
# TODO: Eventually, extract file extention and check for a list of supported file types.
# Create unique user path.
fileRoot = settings.MEDIA_ROOT + settings.VOICE_FILES_DIR
urlRoot = settings.MEDIA_URL + settings.VOICE_FILES_DIR
uniqueId = str(uuid.uuid4())
userDir = os.path.join(fileRoot, uniqueId)
userUrl = '/'.join([urlRoot, uniqueId])
os.makedirs(userDir)
# origFilePath = os.path.join(userDir, origFile.name) # Removed the input file name since it will be passed to a shell script command.
origFilePath = os.path.join(userDir, settings.ORIG_FILE_NAME)
origFileUrl = '/'.join([userUrl, settings.ORIG_FILE_NAME])
# Save uploaded file.
__handle_uploaded_file(origFile, origFilePath)
# Now generate altered file.
altFilePath = os.path.join(userDir, settings.ALT_FILE_NAME)
altFileUrl = '/'.join([userUrl, settings.ALT_FILE_NAME])
# Temp files.
soxTmpFilePath = os.path.join(userDir, 'tmp.wav')
soxTmpFileRevPath = os.path.join(userDir, 'tmprev.wav')
if soxCreepify:
# Example: sox original.wav tmp.wav norm vad gain -7 pitch -600 overdrive 20 pad .25; sox tmp.wav tmprev.wav reverse reverb -w reverse; sox -m tmp.wav tmprev.wav altered.mp3
# First create temp file with standard voice mods.
soxCmd = ' '.join([settings.SOX_PATH, origFilePath, soxTmpFilePath, 'norm vad gain', settings.SOX_GAIN, 'pitch', settings.SOX_PITCH, 'overdrive', settings.SOX_OVERDRIVE, 'pad', settings.SOX_PAD])
subprocess.call(soxCmd, shell=True)
# Then add the reverse reverb (two shell commands).
soxCmd = ' '.join([settings.SOX_PATH, soxTmpFilePath, soxTmpFileRevPath, 'reverse reverb -w reverse'])
subprocess.call(soxCmd, shell=True)
soxCmd = ' '.join([settings.SOX_PATH, '-m', soxTmpFilePath, soxTmpFileRevPath, altFilePath])
subprocess.call(soxCmd, shell=True)
# Then delete the temp files.
os.remove(soxTmpFilePath)
os.remove(soxTmpFileRevPath)
else:
# Example: sox original.wav altered.wav norm vad gain -7 pitch -600 overdrive 20 pad .25
soxCmd = ' '.join([settings.SOX_PATH, origFilePath, altFilePath, 'norm vad gain', settings.SOX_GAIN, 'pitch', settings.SOX_PITCH, 'overdrive', settings.SOX_OVERDRIVE, 'pad', settings.SOX_PAD])
subprocess.call(soxCmd, shell=True)
newMsg = Message(
unique_id=uniqueId,
original_file=origFileUrl,
altered_file=altFileUrl
)
newMsg.save()
# Return the Message object that you just created.
return newMsg
def checkUpload():
"""
检查上传截图是否过期
:return:
"""
now = datetime.datetime.now()
start = now - datetime.timedelta(minutes=30)
#半个小时之外,并且到上传截图这步骤
oas = OrderApply.objects.filter(update_time__lte=start,finished=0,teacher_willing=2,parent_willing=2)
for oa in oas:
try:
with transaction.atomic():
#没有上传截图，当做老师拒绝操作
oa.finished =1
oa.teacher_willing = 0
oa.save()
#给老师发送消息，老师过期
message_title = u"你的订单已过期，没有在相应的时间内上传截图！"
message_content = u"你的订单已过期，没有在相应的时间内上传截图！"
#应该是管理员发送
message = Message(sender=oa.tea.wechat, receiver=oa.tea.wechat, message_title=message_title, message_content=message_content,status=0)
message.save()
#老家长发送消息，审核不通过
message_title = u"订单审核不通过！"
message_content = u"订单审核不通过！"
message = Message(sender=oa.tea.wechat, receiver=oa.pd.wechat, message_title=message_title, message_content=message_content,status=0)
message.save()
#推送到微信端
except Exception,e:
print e.message
def post(self, request):
data = parsers.JSONParser().parse(request)
try:
jwt.decode(data['auth_token'], 'secret', algorithm='HS256')
except jwt.InvalidSignatureError:
return HttpResponse('Unathorized', status=401)
message = Message(
user_id=UserAuthen.objects.get(token=data['auth_token']).user_id,
text=data['text'])
try:
message.save()
except db.IntegrityError:
return HttpResponse('Conflict', status=409)
return HttpResponse('OK', status=200)
class MessageModelTest(TestCase):
def setUp(self):
self.user = User.objects.create(username="******")
self.message = Message(body='message body', author=self.user)
def test_create_message(self):
old_count = Message.objects.count()
self.message.save()
new_count = Message.objects.count()
self.assertEqual(new_count - old_count, 1)
self.assertNotEqual(new_count, old_count)
def test_str_representation(self):
self.assertEqual(unicode(self.message), self.message.body)
def test_add_and_remove_message_from_conversation(self):
self.conversation1.save()
self.message1.save()
self.message2.save()
conversation1 = Conversation.get(id=1)
self.assertEqual(0, len(conversation1.messages))
conversation1.insert(
'messages',
[Message.get(id=1), Message.get(id=2)])
self.assertEqual(True, isinstance(conversation1.messages[0], Message))
self.assertEqual(True, isinstance(conversation1.messages[1], Message))
self.assertEqual(2, len(conversation1.messages))
conversation1.remove('messages', id=1)
self.assertEqual(1, len(conversation1.messages))
def message_on_save(message):
try:
room = Room.objects.get(name=message.content['room'])
except Room.DoesNotExist:
room = Room.objects.create(name=message.content['room'])
try:
user = User.objects.get(username=message.content['username'])
except User.DoesNotExist:
return
message = Message(author=user, room=room, body=message.content['text'])
message.save()
print "Saving message: %s from %s for room %s" % (
message.body, message.author.username, message.room.name)
def post(self, conversation_id):
"""
Send a message into a conversation.
"""
payload = request.get_json()
required = ['content']
result = validate_json(required, payload, empty=True)
if isinstance(result, bool) is False:
return {
'status': 'fail',
'message': 'Content required for a message.'
}, 400
else:
current_user_id = current_user_id = view_token(
request.headers.get('Authorization'))['id']
message = Message(sender=current_user_id,
content=payload['content'])
conversation = Conversation.get(id=conversation_id)
conversation.insert('messages', [message])
return {
'status': 'success',
'data': {
'updated_conversation': conversation.view()
}
}, 201
def test_get_message_status__when_exist__should_return_delivered(self):
message = self.channel_repo.save_message(Message(payload={'obj': 'test'}))
url = url_for('views.get_message', id=str(message.id))
response = self.client.get(f'{url}?fields=status')
assert response.status_code == 200
assert response.json == {'status': 'received'}
def post_message():
"""
Post a new message endpoint
---
post:
requestBody:
content:
application/json:
schema: MessagePayloadSchema
responses:
201:
description: Returns message id
content:
application/json:
schema: PostedMessageSchema
"""
schema = MessagePayloadSchema()
try:
schema.load(request.json)
except ValidationError as e:
return JsonResponse(e.messages, status=400)
message = Message(payload=request.json)
db.session.add(message)
db.session.commit()
return_schema = PostedMessageSchema()
return JsonResponse(return_schema.dump(message), status=201)
def test_put_message(when, client):
source = Source(name="test_5", environment="env_5", encoding="encoding_5")
run.db.session.add(source)
run.db.session.commit()
assert source.id
source_id = source.id
message = Message(source_id=source_id,
message="message_5",
status="status_5")
run.db.session.add(message)
run.db.session.commit()
assert message.id
message_id = message.id
res = client.put(
url_for("put_message", id=message_id, _method="PUT"),
json={"message": "message_5_updated"},
)
assert res.status == "200 OK"
assert res.json["message"] == "message_5_updated"
assert "id" in res.json and res.json["id"]
assert ("created_at" in res.json and res.json["created_at"]
== message.created_at.replace(tzinfo=timezone.utc).isoformat())
assert "updated_at" in res.json and res.json["updated_at"]
def handle(self, *args, **options):
end = date2timestamp(now().date())
start = end - 86400
instances = Instance.objects.values_list('cluster_id', 'owner_id', 'app_id'). \
filter(timestamp__gte=start, timestamp__lt=end).order_by('owner_id'). \
annotate(Count('app_id'))
for instance in instances:
config_fee(instance, start, end)
volume_fee(instance, start, end)
network_fee(instance, start, end)
fs = Funding.objects.distinct('owner_id').filter(credit__lt=0).order_by(
'owner_id', '-created').values_list('owner_id', 'credit')
msgs = []
for f in fs:
msg_data = {
'owner_id': f[0],
'code': 2,
'sender': 'system',
'body': 'You are in arrears, please recharge in time.',
}
msg = Message(
**msg_data
)
msgs.append(msg)
Message.objects.bulk_create(msgs)
self.stdout.write("done")
def create_message(id, user_id, date, text):
message = Message()
message.id = id
message.user_id = user_id
message.date = date
message.text = text
message.save()
return message
def handleUserOrder(request):
"""
管理员处理订单
:param request:
{
"oa_id": 1 订单ID
"user":teacher/parent, 修改老师还是家长的意愿
"willing": 0/1/2 0/1/2 0：拒绝 1：待处理 2：接受
}
:return:
"""
user = AuthUser.objects.get(username=request.user.username)
oa_id = int(request.data.get('oa_id',0))
userType = request.data.get('user',None)
willing = request.data.get('willing',None)
try:
oa = OrderApply.objects.get(oa_id = oa_id)
if userType == 'teacher':
#TODO：管理员暂时无法处理老师的订单
if willing == 0:
oa.teacher_willing = 0
oa.finished = 1
if willing == 2:
oa.teacher_willing = 2
if userType == 'parent':
#将家长意愿修改为拒绝
if willing == 0:
oa.parent_willing = 0
oa.finished = 1
message_title = oa.pd.name + u"拒绝了你的报名！"
message_content = oa.pd.name + u"拒绝了你的报名！请到“我的家长”处查看详细信息!"
if willing == 2:
oa.parent_willing = 2
oa.finished = 0
message_title = oa.pd.name + u"接受了你的报名！"
message_content = oa.pd.name + u"接受了你的报名！请到“我的家长”处查看详细信息!"
now = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
message = Message(sender=user, receiver=oa.tea.wechat, message_title=message_title,
message_content=message_content,status=0,update_time=now,create_time=now)
oa.save()
message.save()
return JsonResponse()
except Exception,e:
print 'traceback.print_exc():'; traceback.print_exc()
return JsonError(e.message)
def send_email(self, bcc=False):
# send email using the self.cleaned_data dictionary
# get this message
old_message = self.instance
# get this thread
thread = old_message.thread
house_id = ""
try:
house_id = thread.messages[
0].receiver.home_owner_profile.house.all()[0].pk
except:
pass
# Create a new message instance
message = Message(text="",
sender=old_message.receiver,
receiver=old_message.sender,
thread=thread)
message.save()
text_with_header = insert_response_url_header(
key=message.key, text=self.cleaned_data['text'])
message.text = text_with_header
message.save()
# send
bcc_email = None
if bcc:
bcc_email = old_message.receiver.email
try:
con = SMTPConnection()
success = con.send_email(
recipient_address=message.receiver.email,
subject="Greendoors Communications [House {0}]".format(
house_id),
body=message.text,
bcc=bcc_email)
except SMTPRecipientsRefused:
logger.error("Email sending refused for message {0}".format(
message.pk))
if success:
message.sent = True
message.save()
def get_message(self, message_id):
path = self._get_message_path(message_id)
try:
message_json = self.get_object_content(path)
except self.client.exceptions.NoSuchKey:
logger.warning("Message not found, path: %s", path)
return
return Message.from_json(message_json)
def create(self, request, *args, **kwargs):
"""
parameters: 'recipientID', 'textFirstMessage'
"""
for parameter in ['recipientID', 'textFirstMessage']:
if parameter not in request.data:
print(3333)
return Response(status=status.HTTP_400_BAD_REQUEST)
recipientID = request.data['recipientID']
textFirstMessage = request.data['textFirstMessage']
querysetDialogsUser = list()
querysetDialogsRecipient = list()
#exist dialog?
for item in DialogOwners.objects.filter(owner=request.user):
querysetDialogsUser.append(item.dialog)
for item in DialogOwners.objects.filter(owner=User.objects.get(id=recipientID)):
querysetDialogsRecipient.append(item.dialog)
#if dialog exist
for item in querysetDialogsUser:
if querysetDialogsRecipient.count(item) != 0:
return Response(status=status.HTTP_400_BAD_REQUEST)
dialog = Dialog()
dialog.save()
message = Message()
message.owner = request.user
message.ownerDialog = dialog
message.text = textFirstMessage
message.date = timezone.now()
message.save()
dialog.textLastMessage = textFirstMessage
dialog.dateLastMessage = message.date
dialog.idLastMessage = message.id
dialog.save()
dialogOwner1 = DialogOwners()
dialogOwner2 = DialogOwners()
dialogOwner1.owner = request.user
dialogOwner1.dialog = dialog
dialogOwner2.owner = User.objects.get(id=recipientID)
dialogOwner2.dialog = dialog
dialogOwner1.save()
dialogOwner2.save()
#data = [{ 'id':dialog.id }]
return Response(status=status.HTTP_201_CREATED)
def test_message__can_be_created(db_session):
message = Message(id=42, payload={"sender": "AU"})
db_session.add(message)
db_session.commit()
message = db_session.query(Message).get(42)
assert message.status == MessageStatus.CONFIRMED
assert message.payload == {"sender": "AU"}
assert message.created_at == datetime(2020, 4, 7, 14, 21, 22, 123456)
def home(request):
if request.method == 'POST':
message_split = request.POST['message'].split('&|!')
mobile_number = request.POST['mobile_number']
channel_name = message_split[0]
latitude = message_split[1]
longitude = message_split[2]
description = message_split[3]
contents = message_split[4]
channel = Channel.objects.filter(name=channel_name)
if not channel:
channel = Channel(name=channel_name)
channel.save()
else:
channel = channel[0]
sentiment = int(requests.get('%s?message=%s' % (settings.SENTIMENT_ANALYSIS_URL, contents)).text)
message = Message(
channel=channel,
latitude=float(latitude),
longitude=float(longitude),
description=description,
message=contents,
mobile_number=mobile_number,
sentiment=sentiment,
)
message.save()
return HttpResponse('Accepted')
else:
return JsonResponse(User.objects.all()[0].email, safe=False)
def test_asctime(self):
from api.models import Message
message = Message()
dt = datetime.datetime(2016, 10, 22, 10, 16, 40)
message.date = dt
asctime = message.get_asctime()
self.assertEqual(asctime, "Sat Oct 22 10:16:40 2016")
message = Message()
dt = datetime.datetime(2016, 10, 22, 9, 6, 4)
message.date = dt
asctime = message.get_asctime()
self.assertEqual(asctime, "Sat Oct 22 9:06:04 2016")
def test_0_second(self):
from api.models import Message
message = Message()
message.date = datetime.datetime.utcnow()
age = message.get_age()
self.assertEqual(age, "0 second")
def create_AC_enabled_message(enabled):
message = Message()
message.type = "AC_enabled"
message.value = enabled
message.save()
def create_time_message(time):
message = Message()
message.type = "AC_timer"
message.value = time
message.save()
def create_temperature_message(temperature):
message = Message()
message.type = "AC_temperature"
message.value = temperature
message.save()
