def load_spots(self):
spots_data = self.__read_csv("spots")
localized_spots_data = self.__read_csv("spots_localized")
#load content
self.spots = {}
for item in spots_data:
s = Spot()
self.__fill_members_with_csv_data(
s, ('spot_id', 'name', 'image', 'category', 'location',
'content', 'tags'), item)
s.tags = s.tags.split(',') #split tags
s.location = s.location.split(',') #split location
s.category = int(s.category) #parse category to int
self.spots[s.spot_id] = s #add to spots
#load localized info
for item in localized_spots_data:
lang = LocalizedSpotInformation()
self.__fill_members_with_csv_data(
lang, ('spot_id', 'language', 'display_name', 'description'),
item)
#add to right content
if self.spots.has_key(item[0]):
self.spots[item[0]].localized_information[item[1]] = lang
else:
logging.warn("Localized Spot Data with invalid spot id: " +
item[0])
def add_spot(request):
"""
View to add a new spot to upspot.
"""
if request.method == 'GET':
spots = Spot.objects.filter(owner=request.user)
return render(request, 'park/spot.html', {'spots': spots})
elif request.method == 'POST':
owner = request.user
lat = float(request.POST.get("lat"))
lng = float(request.POST.get("lng"))
sv_lat = float(request.POST.get("sv_lat"))
sv_lng = float(request.POST.get("sv_lng"))
address = request.POST.get("address")
spot_number = request.POST.get("spot_number")
instructions = request.POST.get("instructions")
new_spot = Spot()
new_spot.owner = owner
new_spot.location = Point(lng, lat)
new_spot.sv_location = Point(sv_lng, sv_lat)
new_spot.address = address
new_spot.spot_number = spot_number
new_spot.instructions = instructions
new_spot.save()
# Find geohash to get grid value and retrieve geobucket.
spot_geohash = geohash_encode(lat, lng)[:6]
geobucket, _ = GeoBucket.objects.get_or_create(geohash=spot_geohash)
# Add a spot to the given geobucket and save.
geobucket.spot()
geobucket.save()
return redirect('/park/spots')
def create_own_spot():
user_id = _get_user_from_cookie(request.cookies.get(COOKIE_KEY))
if not user_id:
return _get_response('fail', message='user_id is missing')
try:
content = request.get_json()
name = content['name']
zone = content.get('zone', '')
if zone and zone not in (AREA_LIST):
return _get_response('fail', message='zone is out of list')
address = content['address']
describe = content.get('describe')
tel = content.get('tel')
website = content.get('website')
pic1_b64 = content.get('pic1')
pic2_b64 = content.get('pic2')
pic3_b64 = content.get('pic3')
pic1, del_pic1 = upload_img_and_get_link(pic1_b64) if pic1_b64 else (
None, None)
pic2, del_pic2 = upload_img_and_get_link(pic2_b64) if pic2_b64 else (
None, None)
pic3, del_pic3 = upload_img_and_get_link(pic3_b64) if pic3_b64 else (
None, None)
except:
return _get_response('fail', message='input is not correct')
keyword = None
px = None
py = None
for detail, (_code, _px, _py) in POSITITION[zone].items():
if detail == 'ALL':
continue
print(detail + address)
if detail in address:
px = _px
py = _py
break
else:
_, px, py = POSITITION[zone]['ALL']
spot = Spot(name, zone, describe, tel, website, keyword, address, pic1,
pic2, pic3, px, py, del_pic1, del_pic2, del_pic3, user_id)
db.session.add(spot)
db.session.commit()
# add to like-spot
favorite_spot = FavoriteSpot(user_id, spot.id)
db.session.add(favorite_spot)
db.session.commit()
return _get_response('success', content=spot.to_dict())
def restart(self):
self.car_list = []
self.world = World(SCREEN_WIDTH, SCREEN_HEIGHT)
self.background = arcade.load_texture("Wallpaper2.jpg")
self.spot_sprite = Spot(100, 50, angle=0)
self.spot_sprite.add_texture('car_move.png')
self.world.add_car(self.spot_sprite)
park_car_list = ['parking_car1.png', 'parking_car2.png']
for i in self.world.car_park:
self.car_list.append(
ModelSprite(random.choice(park_car_list), model=i))
def spot_with_id(self, request, pk=None):
"""
Creates spot with beacon id
POST params - user, spot_timestamp, lat, lng, namespace_id, instance_id
"""
request_dict = json.loads(request.body)[0]
try:
user = str(request_dict['user'])
except (KeyError, TypeError):
return return_bad_request('parameter user missing or incorrect',
request_dict)
try:
spot_timestamp = int(request_dict['spot_timestamp'])
except (KeyError, TypeError):
return return_bad_request(
'parameter spot_timestamp missing or incorrect', request_dict)
try:
lat = float(request_dict['lat'])
except (KeyError, TypeError):
return return_bad_request('parameter lat missing or incorrect',
request_dict)
try:
lng = float(request_dict['lng'])
except (KeyError, TypeError):
return return_bad_request('parameter lng missing or incorrect',
request_dict)
try:
namespace_id = str(request_dict['namespace_id'])
except (KeyError, TypeError):
return return_bad_request(
'parameter namespace_id missing or incorrect', request_dict)
try:
instance_id = str(request_dict['instance_id'])
except (KeyError, TypeError):
return return_bad_request(
'parameter instance_id missing or incorrect', request_dict)
values = {
'user': user,
'spot_timestamp': spot_timestamp,
'lat': lat,
'lng': lng,
}
spot = Spot(**values)
spot.save(namespace_id=namespace_id, instance_id=instance_id)
return return_request_ok()
def add_spot():
fields = ['name', 'description', 'lat', 'lng']
vals = dict([(k, request.form.get(k)) for k in fields])
print(vals)
try:
spot = Spot(**vals)
db.session.add(spot)
db.session.commit()
except:
pass
return redirect(url_for('home'))
def create_spot_query(spot_name, price, ground_id, owner_id, address_id,
contact_id):
new_spot = Spot(owner_id=owner_id,
name=spot_name,
price=price,
address_id=address_id,
contact_id=contact_id,
ground_id=ground_id)
db.session.add(new_spot)
db.session.flush()
db.session.commit()
return new_spot.id
def load_spots(self):
spots_data = self.__read_csv("spots")
localized_spots_data = self.__read_csv("spots_localized")
#load content
self.spots = {}
for item in spots_data:
s = Spot()
self.__fill_members_with_csv_data(s,('spot_id','name','image','category','location','content','tags'),item)
s.tags = s.tags.split(',') #split tags
s.location = s.location.split(',') #split location
s.category = int(s.category) #parse category to int
self.spots[s.spot_id] = s #add to spots
#load localized info
for item in localized_spots_data:
lang = LocalizedSpotInformation()
self.__fill_members_with_csv_data(lang,('spot_id','language','display_name','description'),item)
#add to right content
if self.spots.has_key(item[0]):
self.spots[item[0]].localized_information[item[1]] = lang
else:
logging.warn("Localized Spot Data with invalid spot id: " + item[0])
def insert_tw_spot_to_db():
with io.open(FILE_TW_SPOT, 'r', encoding='utf-8-sig') as fr:
# print(json.load(fr))
data = json.loads(fr.read())
df = pd.read_json(json.dumps(data['XML_Head']['Infos']['Info']))
for i, content in df.iterrows():
name = content['Name']
describe = content['Toldescribe']
tel = content['Tel']
website = content['Website']
keyword = content['Keyword']
address = content['Add']
pic1 = content['Picture1']
pic2 = content['Picture2']
pic3 = content['Picture3']
px = content['Px']
py = content['Py']
for a in AREA_LIST:
if address.find(a) >= 0 or address.find(a.replace('臺', '台')) >= 0:
zone = a
break
else:
zone = ''
params = [
name, zone, describe, tel, website, keyword, address, pic1, pic2,
pic3, px, py
]
try:
spot = Spot(*params)
db.session.add(spot)
db.session.commit()
except:
print('error on row {}'.format(i))
print('finish {}'.format(i))
class MazeWindow(arcade.Window):
def __init__(self, width, height):
self.car_list = []
super().__init__(width, height)
self.world = World(SCREEN_WIDTH, SCREEN_HEIGHT)
self.background = arcade.load_texture("Wallpaper2.jpg")
self.spot_sprite = Spot(100, 50, angle=0)
self.spot_sprite.add_texture('car_move.png')
self.world.add_car(self.spot_sprite)
park_car_list = ['parking_car1.png', 'parking_car2.png']
for i in self.world.car_park:
self.car_list.append(
ModelSprite(random.choice(park_car_list), model=i))
def update(self, delta):
self.world.update(delta)
def on_draw(self):
arcade.start_render()
arcade.draw_texture_rectangle(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2,
SCREEN_WIDTH, SCREEN_HEIGHT,
self.background)
self.world.spot.draw()
if self.world.state != self.world.STATE_FROZEN:
arcade.draw_text(f"Time: {self.world.start_time:.0f}", 23, 450,
arcade.color.RED, 30)
if self.world.state == self.world.STATE_FROZEN:
arcade.draw_text(f"CAR PARKING GAME", 210, 440, arcade.color.RED,
30)
arcade.draw_text(f"Press any key to start", 180, 30,
arcade.color.BLACK, 15)
for i in self.car_list:
i.draw()
if self.world.state == self.world.STATE_DEAD:
self.background = arcade.load_texture("Wallpaper2END.jpg")
if self.world.start_time < 15:
ModelSprite('star_score3.png', model=self.world.win).draw()
arcade.draw_text(f"You get 3 star!!!!!", 300, 250,
arcade.color.BLUE, 25)
elif self.world.start_time < 20:
ModelSprite('star_score2.png', model=self.world.win).draw()
arcade.draw_text(f"You get 2 star!!!!!", 300, 250,
arcade.color.BLUE, 25)
elif self.world.start_time > 20:
ModelSprite('star_score1.png', model=self.world.win).draw()
arcade.draw_text(f"You get 1 star!!!!!", 300, 250,
arcade.color.BLUE, 25)
arcade.draw_text(f"Thank you for playing", 240, 200,
arcade.color.BLUE, 30)
arcade.draw_text("Press any key to restart.", 235, 150,
arcade.color.BLACK, 30)
self.world.die()
def restart(self):
self.car_list = []
self.world = World(SCREEN_WIDTH, SCREEN_HEIGHT)
self.background = arcade.load_texture("Wallpaper2.jpg")
self.spot_sprite = Spot(100, 50, angle=0)
self.spot_sprite.add_texture('car_move.png')
self.world.add_car(self.spot_sprite)
park_car_list = ['parking_car1.png', 'parking_car2.png']
for i in self.world.car_park:
self.car_list.append(
ModelSprite(random.choice(park_car_list), model=i))
def on_key_press(self, key, key_modifiers):
self.world.on_key_press(key, key_modifiers)
if self.world.state == World.STATE_RESTART:
self.restart()
if not self.world.is_dead():
self.world.start()
def on_key_release(self, key, key_modifiers):
self.world.on_key_release(key, key_modifiers)
def post_spot():
to_string = request.data.decode("utf-8")
# Body of POST is in this format: spot_id taken
tokens = to_string.split(" ")
spot_id = tokens[0]
taken = tokens[1]
print(tokens)
if len(tokens) == 3:
median = tokens[2]
if median is not None:
print("median: ")
print(median)
# Time to string, we'll store the date as a string in our DB
now = datetime.datetime.now()
date_time = now.strftime("%m/%d/%Y, %H:%M:%S")
try:
print("spot id")
print(spot_id)
print("taken")
print(taken)
spot=Spot(
spot_id=spot_id,
taken=taken
)
exists = Spot.query.filter_by(spot_id=spot_id).first()
# Check case if the spot with that ID already exists in the database
if exists is not None:
taken = int(taken)
exists.taken = taken
# Change in state, update timestamp
if exists.taken != taken:
taken = str(taken)
print("Change in state")
exists.taken = taken
timestamp = TimestampChange(
spot_detail_id = spot_id+taken,
spot_id = spot_id,
timestamp = date_time,
state = taken
)
timeExists = TimestampChange.query.filter_by(spot_detail_id=timestamp.spot_detail_id).first()
if timeExists is not None:
timeExists.timestamp = date_time
else:
db.session.add(timestamp)
db.session.commit()
# If 1/0 statements here -- TO DO
if taken == "0":
print("update average")
time = TimestampChange.query.filter_by(spot_detail_id=timestamp.spot_id+"1").first()
as_date = datetime.datetime.strptime(time.timestamp, '%m/%d/%Y, %H:%M:%S')
difference = now - as_date
difference = difference.seconds / 60
hist = Average(
time_parked = difference,
timestamp = date_time,
spot_id=spot_id
)
db.session.add(hist)
db.session.commit()
# Set taken to taken if spot with that ID exists
taken = str(taken)
exists.taken = taken
db.session.commit()
# If spot does not already exist, create in the database
else:
db.session.add(spot)
db.session.commit()
return "Spot updated. spot id= "+spot_id+" taken= "+taken
except Exception as e:
return(str(e))
return to_string