def add_care_home():
form = CareHomeForm(request.form)
if request.method == 'POST':
operator = Operator(name=form.operator_name.data,
phone=form.phone.data,
certification=form.certification.data,
license_expiration=form.license_expiration.data)
address = Address(street=form.address_street.data,
city=form.address_city.data,
region=form.address_region.data,
state='HI',
zip=form.address_zip.data,
email=form.email.data,
operator=operator)
carehome = CareHome(
name=form.carehome_name.data,
type=form.type.data,
open_rooms=form.open_rooms.data,
max_rooms=form.private_rooms.data + form.shared_rooms.data,
patient_gender=form.patient_gender.data,
patient_max_age=form.patient_age.data,
private_patients=form.patient_private.data,
medicaid_patients=form.patient_medicaid.data,
ssi_patients=form.patient_ssi.data,
assistive_walking_devices=str(
form.patient_walking_device.data).replace('[', '').replace(
']', '').replace('\'', ''),
behavioral_issues_patient=form.patient_behavioral.data,
dialysis_patient=form.patient_dialysis.data,
hospice_patient=form.patient_hospice.data,
insulin_patient=form.patient_insulin.data,
tube_feed_patient=form.patient_tube_feed.data,
wounded_patient=form.patient_wounds.data,
max_weight_patient=form.patient_weight.data,
case_management_company=form.case_management_company.data,
previous_experience=form.previous_experience.data,
subs=form.subs.data,
open_year=form.carehome_open_year.data,
notes=form.notes.data,
operator=operator)
private_rooms = Room(min_price=form.min_price_private.data,
max_price=form.max_price_private.data,
amount=form.private_rooms.data,
type=Room.Type.PRIVATE,
carehome=carehome)
shared_rooms = Room(min_price=form.min_price_shared.data,
max_price=form.max_price_shared.data,
amount=form.shared_rooms.data,
type=Room.Type.SHARED,
carehome=carehome)
db.session.add(operator)
db.session.add(address)
db.session.add(carehome)
db.session.add(private_rooms)
db.session.add(shared_rooms)
db.session.commit()
flash('Care Home added', 'success')
return redirect(url_for('care_homes'))
return render_template('addcarehome.html', form=form)
def create_house(home_id):
# create master bed
session.add(Room(home_id=home_id, name="Master"))
# create kid bed
session.add(Room(home_id=home_id, name="Guest Bed"))
# create kid bed
session.add(Room(home_id=home_id, name="Kids"))
# create 16 windows
for _n in range(16):
session.add(
EntryPoint(home_id=home_id,
name=f'Window{_n}',
type='window',
is_open=False))
# create 3 doors
for _n in range(3):
session.add(
EntryPoint(home_id=home_id,
name=f'Door{_n}',
type='door',
is_open=False))
session.commit()
def fillup_db():
DB['rooms'].append(Room(42, 1, 'closed', 1000))
DB['rooms'].append(Room(7, 1, 'available', 50))
DB['rooms'].append(Room(69, 7, 'available', 9000))
DB['rooms'].append(Room(11, 3, 'closed', 10))
DB['tenants'].append(Tenant('Neo', 'zz0101', 33, 'M',
{
"city": "Zeon",
"street": "Street 255"
}, 42))
DB['tenants'].append(Tenant('Janis', 'bb2222', 40, 'W',
{
"city": "Los Angeles",
"street": "Beverly Hills, 90210"
}, 7))
DB['tenants'].append(Tenant('Sherlock', 'cc3333', 51, 'M',
{
"city": "London",
"street": "Bakerstreet, 221B"
}, 11))
DB['staff'].append(Staff('Taylor', 'aa1111', 'waiter', 100))
DB['staff'].append(Staff('Hannibal', 'et0000', 'cook', 1000))
DB['staff'].append(Staff('Hilton', 'ad1234', 'Administrator', 9000))
def run(self):
from setup import db, db_session, engine, app
from models import Room, User
models.PSABase.metadata.create_all(engine)
db.create_all()
db_session.commit()
db_session.add(Room(name='Glass Room 1', reservable=True))
db_session.add(Room(name='Glass Room 2', reservable=False))
db_session.add(User(id=app.config['SUDO_USERID'], admin=True))
db_session.commit()
def createCode(request, roomid):
newRoom = Room(code=roomid)
if isExists(roomid):
return HttpResponse("Error: Room exists")
else:
newRoom.save()
return HttpResponse("Room created")
def room_create(tokenData):
values = request.get_json()
user = User.query.filter_by(id=tokenData['userId']).first()
if user:
room = Room(name=values['name'],
description=values['description'],
user_set=str(tokenData['userId']),
owner=user.id,
avatar_image='')
db.session.add(room)
db.session.flush()
room.room_hash_id = hashlib.md5(
f'{room.id}{time.time()}'.encode('utf-8')).hexdigest()
room.user_set = f'{room.user_set},{user.id}' if room.user_set else user.id
if values['avatarImage']:
avatartImageList = values['avatarImage'].split(',')
suffix = avatartImageList[0].split('/')[1].split(';')[0]
filename = f'room_avatar/{room.room_hash_id}.{suffix}'
print(filename)
with open(f'media/{filename}', 'wb') as f:
f.write(base64.b64decode(avatartImageList[1]))
room.avatar_image = filename
user.room_id_set = f'{user.room_id_set},{room.id}' if user.room_id_set else room.id
db.session.commit()
return jsonify({
'data': {
'room': JSONHelper.model_to_json(room)
},
'message': '成功',
'status': 200
})
return jsonify({'data': '', 'message': '失败失败', 'status': 500})
def Adm_room_POST(rev_json):
"""
处理Adm_room的POST请求
:param rev_json: 接收到的json数据
:return: 需要发送给前端的数据
"""
# 获取参数
building = rev_json.get('building')
floor = rev_json.get('floor')
org = rev_json.get('org')
room_name = rev_json.get('room_name')
picture = rev_json.get('picture')
max_num = rev_json.get('max_num')
description = rev_json.get('description')
permissible = True if rev_json.get('permission') != 0 else False
# 验证必需参数
if None in (building, floor, room_name, max_num, permissible):
return jsonify(code=-101, data={'tip': '缺少必要参数'})
newRoom = Room(building=building,
floor=floor,
org=org,
room_name=room_name,
picture=picture,
max_num=max_num,
description=description,
permissible=permissible)
db.session.add(newRoom)
try:
db.session.commit()
except:
db.session.rollback()
return jsonify(data={'tip': '教室添加成功'})
def newroom():
if not g.user:
abort(404)
elif request.method == "POST":
POST_ROOM = remove_tags(str(request.form['room']))
POST_CHAT = remove_tags(str(request.form['msg']))
if POST_CHAT != None:
newRoom = Room(POST_ROOM, g.user.id, None, None)
eprint("newRoom: " + str(newRoom))
db.session.add(newRoom)
try:
db.session.commit()
newChat = Chat(newRoom.id, g.user.id, None, POST_CHAT)
eprint("newChat: " + str(newChat))
db.session.add(newChat)
try:
db.session.commit()
flash ("Created room: " + str(newRoom.roomname))
return redirect(url_for("joinroom", rid=newRoom.id))
except Exception as e:
db.session.rollback()
eprint(str(e))
flash("Error adding message to new room")
return redirect(url_for("newroom"))
except Exception as e:
flash("Room creation failed")
else:
flash("Must enter initial message")
return Response(render_template('/rooms/newRoom.html'), mimetype='text/html')
def test_description(self):
k = Room.objects.filter(description__contains='Nice')
self.assertEqual(k.count(), 1)
p = Room(name='a', capacity=1, description='Not nice')
p.save()
self.assertEqual(Room.objects.count(), 4)
p.delete()
self.assertEqual(Room.objects.count(), 3)
def test_name(self):
k = Room.objects.filter(name__startswith='Blue')
self.assertEqual(k.count(), 1)
p = Room(name='Magenta', capacity=1)
p.save()
self.assertEqual(Room.objects.count(), 4)
p.delete()
self.assertEqual(Room.objects.count(), 3)
def create_room():
if request.form:
r = Room(language=request.form.get('room_language'),room_name=request.form.get('room_name'),invite_only=request.form.get('invite_only','')=='on')
r.owner_id = current_user.id
db.session.add(r)
db.session.commit()
return redirect("/r/%s"%r.room_name)
return render_template("admin-pages/create_room.html")
def _save_room(cd):
room = Room()
room.id = cd['id'] or None
room.number = cd['number']
room.description = cd['description']
room.syndic = cd['syndic']
room.save()
return room
def add_rooms(self, item):
rooms = []
if item['room_kinds']:
for room_item in item['room_kinds']:
room = Room(**room_item)
room.conditions = self.add_conditions(room_item)
rooms.append(room)
return rooms
def register(self, password):
room = Room()
room.password = password
try:
room.save()
except:
return None, False
return room.id, True
def rooms():
if request.method == 'POST':
room_data = Room(**get_request_data(request))
if not room_data.validate():
return json_response({"message": "Room form is invalid"}, 400)
return room_data.create(db.rooms)
else:
return list_all(db.rooms, arguments=request.args)
def create_channel(data):
room_name = data["room"]
for room in rooms:
if room.room == room_name:
return
rooms.append(Room(room_name))
data["href"] = f'/room/{room_name}'
data["count"] = 0
emit('channel_created', data, broadcast=True)
def get(self, room_id):
room = Room(room_id)
if not room.exists():
room.create()
self.render("views/room.html",
video_url='',
room_id=room_id,
user_email=self.current_user.email,
user_token=self.current_user.token)
async def process_room_leave(self, command: protocol.RoomLeave):
room_id = command.room_id
if room_id not in self.__user_rooms:
await self.on_error(protocol.Error.ERR_USER_NOT_IN_ROOM, cmd_id=command.cmd_id)
return
await self.__user.rooms.remove(Room(id=room_id))
self.__user_rooms.remove(room_id)
await self.__chat_state.leave_from_rooms(self, room_id)
await self.send_success(command.cmd_id)
def create_room(request):
if request.method == "POST":
form = RoomModelForm(request.POST)
if form.is_valid():
data = form.cleaned_data
room_inst = Room(**data)
room_inst.save()
form = RoomModelForm()
return render(request, "app1/create_room.html", {"form": form})
def on_join(data):
print 'join'
room = data['room']
password = data['password']
username = data['username']
# 查看是否存在该房间
records = len(db.session.query(Room).filter(Room.name == room).all())
if records != 0:
emit('my_response', {'status': 'sorry', 'msg': u'这个房间已经存在'})
else:
room_record = Room(name=room, password=password, count=1)
db.session.add(room_record)
db.session.query(User).filter(User.name == username).update({
'number':
1,
"room_name":
room
})
db.session.commit()
join_room(room)
# 查询用户信息，还原状态
users = db.session.query(User).filter(User.room_name == room).all()
user_arr = []
for user in users:
print user.name
item = {}
item['name'] = user.name
item['number'] = user.number
item['prepare'] = user.prepare
item['cards'] = user.cards
user_arr.append(item)
print user_arr
# emit('my_response', {'status': 'succeed','judge': 'join_room_success','msg':u'test', 'data': username}, room=room)
# emit('my_response', {'status': 'success', 'judge': 'join_room_success', 'msg': u'房间创建成功'}, room=room)
# u'房间：' + room + u'创建成功
emit(
'my_response', {
'status': 'success',
'judge': 'join_room_success',
'msg': u'房间创建成功的消息再次发生',
'data': 1
})
emit('join_response', {
'status': 'success',
'judge': 'join_room_success',
'msg': u'用户信息已更新',
'userInfo': user_arr
},
room=room)
def create_room(db: SessionClass, user_name, room_name):
with session_manager(db) as session:
room = Room(name=room_name)
session.add(room)
session.commit()
user = User(name=user_name, room_id=room.id)
session.add(user)
session.commit()
room.host_user_id = user.id
session.commit()
return {'user': user, 'room': room}
def add_new_room(user_id):
body = request.get_json()
if body is None:
raise APIException("You need to specify the request body as a json object", status_code=400)
if 'name_room' not in body:
raise APIException('You need to specify the name room', status_code=400)
new_room = Room(name_room=body['name_room'], id_user= user_id)
new_room.create()
return jsonify({'status': 'OK', 'message': 'Room Added succesfully'}), 201
def post(self):
data = data_valid_for('POST')
logging.debug(data)
rooms_already_exist = list(filter(lambda r: data['number'] == r.number,
DB['rooms']))
if not rooms_already_exist:
DB['rooms'].append(Room(**data))
new_number = str(DB['rooms'][-1].number)
location = {"Location": f'/api/v0.1/rooms/{new_number}'}
return {"message": "room was added successfully"}, 201, location
msg = f"room with number {data['number']} already exists"
return {"message": msg}, 400
def create_room():
rc = generate_room_code()
host = str(request.json["name"])
gameState = 0
data = [rc, host]
new_room = Room(id=rc, host=host)
new_player = Player(id=rc, name=host)
db.session.add(new_player)
db.session.add(new_room)
db.session.commit()
return jsonify(new_room.serialize())
def submit_form(self):
self.get_lessons_from_lb()
self.get_teachers_from_lb()
room = Room(self.room_id, self.room_name.get(), self.room_lessons.get(), self.room_teachers.get())
if self.new_room.get() == 1:
add_room(self.db, room)
else:
update_room(self.db, room, self.room_id)
messagebox.showinfo("Okey!", "Your order has been applied")
async def create_room(self, first_player, second_player):
first_player.name = CellType.FIRST_PLAYER
second_player.name = CellType.SECOND_PLAYER
room = Room(self.NEXT_ROOM_ID, first_player, second_player)
self.NEXT_ROOM_ID += 1
self.rooms[room.id] = room
first_player.room = room
second_player.room = room
await self.send_last_changes(room)
await self.send_players_info(room)
def get(self, room_id):
room = Room(room_id)
if not room.exists():
self.redirect('/')
self.render(
"views/room.html",
video_key=room.get_video_id(),
user_email=create_signed_value(APPLICATION['cookie_secret'],
'user_email',
self.current_user.email),
user_token=create_signed_value(APPLICATION['cookie_secret'],
'user_token',
self.current_user.token))
def test_anonymous_access(self):
anon_room = Room(allow_anonymous_access=True,
name="Anonymous Room",
slug="anonymous-room")
login_req_room = Room(allow_anonymous_access=False,
name="Login required room",
slug="login-required-room")
anon_room.save()
login_req_room.save()
client = Client()
response = client.get(login_req_room.get_absolute_url())
# a login view may not have been implemented, so assertRedirects fails
self.assertEquals(response.status_code, 302)
url = response['Location']
expected_url = get_login_url(login_req_room.get_absolute_url())
e_scheme, e_netloc, e_path, e_query, e_fragment = urlparse.urlsplit(
expected_url)
if not (e_scheme or e_netloc):
expected_url = urlparse.urlunsplit(
('http', 'testserver', e_path, e_query, e_fragment))
self.assertEquals(url, expected_url)
response = client.get(anon_room.get_absolute_url(), follow=True)
# assert redirect
self.assertRedirects(
response,
'http://testserver/chat/setguestname/?room_slug=anonymous-room')
# post guestname
guestname_posted = client.post(response.redirect_chain[0][0], {
'guest_name': 'guest',
'room_slug': 'anonymous-room'
},
follow=True)
self.assertRedirects(guestname_posted, anon_room.get_absolute_url())
def new_data():
"""
Add a new album
"""
form = roomForm(request.form)
if request.method == 'POST' and form.validate():
# save the album
rooms = Room()
save_changes(rooms, form, new=True)
flash(' created successfully!')
return redirect('/')
return render_template('new_data.html', form=form)
def assign_room(request):
if request.POST:
user = request.POST['user']
rn = request.POST['rno']
sd = request.POST['sd']
ed = request.POST['ed']
r = Room(user_id=user,
r_id=uuid.uuid4(),
room_no=rn,
start_date=sd,
end_date=ed,
available=False)
r.save()
return render_to_response('roomcreatesuccess.html')
