def parseFromStrig(string):
v = string.split(",")
evento = Evento(v[0],v[1],v[2],Data.parseFromString(v[3]),Data.parseFromString(v[4]))
evento.setDataCriacao(v[5])
evento.setEstado(v[6])
evento.setInteresses(v[7])
return evento
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# logical variables
buildings = None
# if error, skip this
if self.error == '':
buildings = Data.getbuildings(self, lang, float(version))
if self.error == '' and buildings is not None:
self.respn = buildings.data
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def __init__(self, nome, descricao, preco, codigo_evento):
self.__nome = nome
self.__descricao = descricao
self.__preco = preco
self.__data = Data.getSystemData()
self.__codigo_evento = codigo_evento
self.__codigo_atividade = Hash.generateHash()
def parseFromString(string): ## ordem: nome,descricao,preco,data,codigo
v = string.split(",")
atividade = Atividade(v[0], v[1], v[2], Data.parseFromDateString(v[3]))
atividade.setCodigoAtividade(v[4])
atividade.setCodigoEvento(v[5])
return atividade
def parse_csv(path: str, encoding="windows-1252"):
_transactions = []
_offset = 8
with open(path, encoding=encoding, newline="") as csv_file:
_reader = reader(csv_file, delimiter=";", quotechar='"')
for _row in _reader:
_line = _reader.line_num
if _line == 1:
_account_number = _row[1]
elif _line == 2:
_account_type = _row[1]
elif _line == 3:
_account_currency = _row[1]
elif _line == 4:
_account_balance_date = parse_date(_row[1])
elif _line == 5:
_account_balance_euros = parse_amount(_row[1])
elif _line == 6:
_account_balance_francs = parse_amount(_row[1])
elif _line > _offset:
_transactions.append(
Transaction(date=parse_date(_row[0]),
memo=_row[1],
amount=parse_amount(_row[2]),
amount_francs=parse_amount(_row[3])))
_account = Account(number=_account_number,
type=_account_type,
currency=_account_currency,
balance_date=_account_balance_date,
balance=_account_balance_euros,
balance_francs=_account_balance_francs)
_data = Data(account=_account, transactions=_transactions)
return _data
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
lang = Utils.required(self, 'lang')
version = self.request.get('version')
if version is None or version == '':
version = config.dictionary['version']
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# if error, skip this
if self.error == '':
data = Data.gettransui(self, float(version))
if data is not None:
try:
self.respn = json.dumps(data.as_obj[lang])
except KeyError:
self.error = 'UI Text for give language was not found!'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
version = self.request.get('version')
if version is None or version == '':
version = config.dictionary['version']
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# if error, skip this
if self.error == '':
data = Data.gettransui(self, float(version))
if data is not None:
self.respn = '['
for lang in data.as_obj:
self.respn += '{"code":"' + lang + '", "lang":"' + data.as_obj[
lang]['language.name'] + '"},'
self.respn = self.respn.rstrip(',') + ']'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def get(self):
Utils.reset(self) # reset/clean standard variables
self.game = 'pro7'
namespace_manager.set_namespace(self.game)
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
type = Utils.required(self, 'type')
version = Utils.required(self, 'version')
data = Utils.required(self, 'data')
# required password to process this action
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# set default parameter
idata = None
# if any error, skip this
if self.error == '':
idata = Data.getData(
self, type,
float(version)) # get data from memcache or datastore
if idata is None: # if no data was found
idata = Data.newData(self) # create a new one
idata.type = type # assign type
idata.version = float(version) # assign version
self.error = '' # clean error
# if any error or idata is none, then skip to the end
if self.error == '' and idata is not None:
idata.data = data # assign lastest deployed data
if Data.setData(self,
idata): # put or update in database and memcache
self.respn = '"Deploy successfully!"' # tell user that his request is success
else: # or
self.error = 'Deploy failed - couldn\'t update database!' # tell him that his required is failed
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def __init__(self,nome,descricao,usuario,data_inicio,data_fim): self.__nome = nome self.__descricao = descricao self.__usuario = usuario self.__codigo = Hash.generateHash() self.__data_inicio = data_inicio self.__data_fim = data_fim self.__data_criacao = Data.getSystemData() self.__estado_atual = 1 self.__interesses ["None"]
def get(self):
Utils.reset(self)
lang = "en"
item = Utils.required(self, 'item')
data = Data.getDataAsObj(self, item,
config.data_version['racewinnings'])
if data is not None:
self.respn += '"' + item + '":' + data.data + ','
else:
data = Data.getData(self, item, vers1ion)
if data is not None:
self.respn += '"' + item + '":' + data.data + ','
self.respn = self.respn.rstrip(',') + '}'
# calculate time taken and return the result
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, 1))
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
if self.error == '' and passwd != config.testing['passwd']: # if password is incorrect
self.error = 'passwd is incorrect.' # inform user via error message
start_time = time.time() # start count
player = None
recentplayerlist = None
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid) # get player state from Player helper class, specified by uuid
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if self.error == '' and player is not None: # if have some data returned
recentplayerlist = Data.GetRecentPlayerList(self)
if self.error == '' and recentplayerlist is not None:
_range = config.recentplayer['maxlist']
if _range > len(recentplayerlist.obj):
_range = len(recentplayerlist.obj)
self.respn = '['
if _range > 0:
_size = config.recentplayer['numlist'];
if _range < _size:
_size = _range
random = Utils.GetRandomOfNumberInArray(self, _size, _range)
for i in random:
recentplayer = recentplayerlist.obj[i]
if recentplayer['uuid'] != player.uuid:
self.respn += '{"fbid":"'+recentplayer['fbid']+'",'
self.respn += '"uuid":"'+recentplayer['uuid']+'",'
self.respn += '"name":"'+recentplayer['name']+'",'
self.respn += '"image":"'+recentplayer['image']+'",'
self.respn += '"total_wins":'+str(recentplayer['total_wins'])+','
self.respn += '"updated":'+str(recentplayer['updated'])+'},'
self.respn = self.respn.rstrip(',') + ']'
# calculate time taken and return result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def calculate(self, events, events2, laptime, laptime2, win_prize,
lose_prize):
# calculate score by linking replay times Race Winnings Data
racewinnings = Data.getDataAsObj(
self, 'racewinnings_en', config.data_version['racewinnings']).obj
if racewinnings is None:
logging.warning(
'cannot get real racewinnings from backend - using default data'
)
racewinnings = Score.GetDefaultRaceWinnings()
if racewinnings is not None:
logging.debug("racewinnings: " + json.dumps(racewinnings))
prize_winner = win_prize if win_prize else 1500
prize_looser = lose_prize if lose_prize else 375
logging.debug('calculating win prize with ' + str(prize_winner) +
' and lose prize with ' + str(prize_looser))
scorings = [{
'player_events': json.loads(events),
'prizes': {},
'total': 0.0
}, {
'player_events': json.loads(events2),
'prizes': {},
'total': 0.0
}]
scorings[0]['prize'] = scorings[0]['total'] = prize_winner if (
laptime < laptime2) else prize_looser
scorings[1]['prize'] = scorings[1]['total'] = prize_winner if (
laptime2 < laptime) else prize_looser
# initialize all scores to zero
for _player in scorings:
for _event_type in _player['player_events']:
_player['prizes'][_event_type] = 0.0
logging.debug('Calculating score with ' + json.dumps(scorings))
for _player in scorings:
for _event_type in _player['player_events']:
for _event in _player['player_events'][_event_type]: #floats
for _threshold in racewinnings:
if abs(_event) < _threshold['timing']:
_player['prizes'][_event_type] += int(
_player['prize'] * _threshold[_event_type])
_player['total'] += int(_player['prize'] *
_threshold[_event_type])
return scorings
def get(self):
Utils.reset(self)
uuid = Utils.required(self, 'uuid')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
track = 'track.1'
if self.request.get('track'):
lang = self.request.get('track')
score = 0
if self.request.get('score'):
lang = self.request.get('score')
uuid = self.request.get('uuid')
start_time = time.time()
# find the right track in buildings and add the score total to it for collection
player = Player.getplayer(self, uuid)
# get all buildings types
buildings = Data.getbuildings(self, lang, version)
# get player buildings
mybuildings = Building.getmybuildings(self, uuid)
#find the building with the track id and give it cash
if buildings is not None and mybuildings is not None:
self.respn += '"building":['
for mybuilding in mybuildings:
_upd = False
# for example: "itid": "track.1",
if mybuilding.itid == track:
mybuilding.amount += score
Building.setmybuilding(self, mybuilding)
self.respn = Building.compose_mybuilding(
self.respn, mybuilding)
self.respn = self.respn.rstrip(',') + '],'
if self.error == '':
self.respn = '{"state":' + player.state + ', "building":['
self.respn = Building.compose_mybuilding(self.respn, mybuilding)
self.respn = self.respn.rstrip(',') + ']'
self.respn += '}'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def load_models(cursor):
print("Loading data..")
for row in cursor.execute('SELECT * FROM papers'):
paper = Paper(row[0], row[1], row[2], row[3], row[4], row[5], row[6])
Data.add_paper(paper)
for row in cursor.execute('SELECT * FROM authors'):
# create new author with id and name
if row[1] != 'None':
author = Author(row[0], row[1])
Data.add_author(author)
for row in cursor.execute('SELECT * FROM paper_authors'):
if row[1] in Data.papers and row[2] in Data.authors:
Data.papers[row[1]].add_author(row[2])
Data.authors[row[2]].add_paper(row[1])
for key, paper in Data.papers.items():
for author in paper.authors:
if author in Data.authors:
Data.authors[author].add_co_author(paper.authors)
print("Loaded data")
def insertMeasurements(self, measurements):
tz = pytz.timezone('Europe/Budapest')
with self.conn:
sql = """INSERT INTO data(
task_id,
first_measurement,
second_measurement,
third_measurement,
created_at) VALUES(?,?,?,?,?) """
values = (self.id, measurements[0], measurements[1],
measurements[2], datetime.datetime.now())
cur = self.conn.cursor()
cur.execute(sql, values)
return Data(cur.lastrowid)
def doPipe(analysisParameters, isIndividual=False):
print("doPipe()")
global USER_ANALYSIS
global USER_INPUT
#Store the data
user = Data(analysisParameters = analysisParameters, file = USER_INPUT)
user.analyseData()
user.cleanPrediction()
# USER
if not isIndividual:
user.deleteData()
# user.deleteData()
USER_ANALYSIS.append(user)
print("END doPipe()")
return user
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
version = config.data_version['research']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# logical variables
researches = None
# if error, skip this
if self.error == '':
researches = Data.getresearches(self, lang, float(version))
if self.error == '' and researches is not None:
self.respn = '['
for research in researches.as_obj:
logging.info(research)
self.respn += json.dumps(researches.as_obj[research][0]) + ','
self.respn = self.respn.rstrip(',') + ']'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# logical variables
player = None
buildings = None
mybuildings = None
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid)
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if self.error == '' and player is not None:
buildings = Data.getbuildings(self, lang, version)
if self.error == '' and buildings is not None:
mybuildings = Building.getmybuildings(self, uuid)
if self.error == '' and mybuildings is not None:
self.respn = '['
for mybuilding in mybuildings:
# update building status, determine production
_upd = False
if mybuilding.status == Building.BuildingStatus.PENDING:
if mybuilding.timestamp + (
buildings.as_obj[mybuilding.itid][
mybuilding.level - 1]['build_time'] *
60) <= start_time:
mybuilding.timestamp = int(start_time)
mybuilding.status = Building.BuildingStatus.DELIVERED
_upd = True
elif mybuilding.status == Building.BuildingStatus.DELIVERED:
mybuilding.status = Building.BuildingStatus.OWNED
_upd = True
if _upd is True:
Building.setmybuilding(self, mybuilding)
self.respn = Building.compose_mybuilding(
self.respn, mybuilding)
self.respn = self.respn.rstrip(',') + ']'
# update timestamp for player
player.state_obj['updated'] = start_time
Player.setplayer(self, player)
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
inid = Utils.required(self, 'inid')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# logical variables
player = None
buildings = None
building = None
mybuilding = None
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid)
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if self.error == '' and player is not None:
buildings = Data.getbuildings(self, lang, float(version))
if self.error == '' and buildings is not None:
mybuilding = Building.getmybuilding(self, uuid, inid)
if self.error == '' and mybuilding is not None:
if mybuilding.status != Building.BuildingStatus.PENDING:
try:
if len(buildings.as_obj[mybuilding.itid]) > mybuilding.level:
building = buildings.as_obj[mybuilding.itid][mybuilding.level]
else:
self.error = 'Level '+str(mybuilding.level+1)+' of building='+mybuilding.itid+' does not exist!'
except KeyError:
self.error = 'Building='+mybuilding.itid+' does not exist!'
else:
self.respn = '{"warning":"Building='+inid+' still under construction, cannot upgrade at the moment!"}'
if self.error == '' and self.respn == '' and building is not None:
self.respn = str(building['cost'])
if player.state_obj['cash'] >= building['cost']:
player.state_obj['cash'] -= building['cost']
# update timestamp for player
player.state_obj['updated'] = start_time
if Player.setplayer(self, player):
mybuilding.itid = building['id']
mybuilding.status = Building.BuildingStatus.PENDING
mybuilding.level = building['level']
mybuilding.timestamp = int(start_time)
Building.setmybuilding(self, mybuilding)
self.respn = '{"state":'+player.state+','
self.respn += '"building":['
self.respn = Building.compose_mybuilding(self.respn, mybuilding)
self.respn = self.respn.rstrip(',') + ']'
self.respn += '}'
else:
self.respn = '{"warning":"not enough cash!"}'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
uuid = self.request.get('uuid')
guid = self.request.get('guid')
fbid = self.request.get('fbid')
self.game = self.request.get('game') or ''
version = config.data_version['building']
token = self.request.get('token') or ''
lang = self.request.get('lang') or config.server["defaultLanguage"]
name = self.request.get('name') or ''
image = 'Textures/profile-pic.png'
if fbid != '':
image = 'https://graph.facebook.com/' + fbid + '/picture?width=200&height=200'
# TODO : Get defaults from Data
gold = 10
cash = 50000
total_wins = 0
total_races = 0
advice_checklist = ''
player = None
# defaultitems = None
if self.error == '' and passwd != config.testing[
'passwd']: # if password is incorrect
self.error = 'passwd is incorrect.' # inform user via error message
start_time = time.time() # start count
Utils.LogRequest(self)
# if error, skip this
if self.error == '':
if fbid != '':
player = Player.getplayerByFbid(self, fbid)
if player is None and uuid != '':
player = Player.getplayer(self,
uuid) # get player from Player model
# class helper, specified by uuid
# TODO : Only get defaultItems if needed, ie a new player
defaultitems = Data.getDataAsObj(
self, 'defaultitems', config.data_version['defaultitems'])
if defaultitems is not None:
if player is None: # if no player data
# returned or doesn't exist
################################################################################################
## Create new player data
player = Player(parent=db.Key.from_path(
'Player', config.db['playerdb_name'])
) # create a new player state data
uuid = Utils.genanyid(self, 'u')
#if fbid == '':
# fbid = uuid
player.uuid = uuid # assign uuid
player.fbid = fbid
# and assign all player info and state
player.info_obj = {
'uuid': player.uuid,
'fbid': player.fbid,
'token': token,
'name': 'Guest ' + str(random.randint(1000, 9999)),
'image': image,
'lang': lang
}
player.state_obj = {
'guid': guid,
'cash': cash,
'gold': gold,
'current_car': 'xxx',
'total_wins': total_wins,
'total_races': total_races,
'advice_checklist': advice_checklist,
'updated': start_time
}
logging.debug("New Player Created")
#################################################################################################
## Init default item for new player
buildings = Data.getbuildings(self, lang, float(version))
cars = Data.getcars(self, lang, float(version))
upgrades = Data.getupgrades(self, lang, float(version))
if buildings is not None and cars is not None and upgrades is not None:
logging.debug("building default stuff")
for item in defaultitems.obj:
if item['type'] == 'state':
player.state_obj[item['id']] = item['value']
elif item['type'] == 'building':
try:
building = buildings.as_obj[item['id']][0]
if building is not None:
new_building = Building.newbuilding(
self)
new_building.uuid = player.uuid
new_building.itid = item['id']
new_building.inid = Utils.genanyid(
self, 'b')
new_building.level = building['level']
new_building.status = Building.BuildingStatus.DELIVERED
new_building.location = item['value']
new_building.amount = 0
new_building.timestamp = int(
start_time)
Building.setmybuilding(
self, new_building)
except KeyError:
logging.warning('KeyError, key not found!')
elif item['type'] == 'car' and cars is not None:
type = ''
car = None
for _car in cars.as_obj:
if _car['id'] == item['id']:
car = _car
break
mycar = Car.create(self, player.uuid)
mycar.data_obj['info'] = {'crid': car['id']}
mycar.data_obj['upgrades'] = []
mycar.data_obj['equip'] = {}
player.state_obj['current_car'] = mycar.cuid
default_upgrades = car[
'default_upgrades'].replace(' ',
'').split(',')
for default_upgrade in default_upgrades:
mycar.data_obj['upgrades'].append(
default_upgrade)
for _type in upgrades.as_obj:
try:
mycar.data_obj['equip'][type]
except KeyError:
for upgrade in upgrades.as_obj[
_type]:
if upgrade[
'id'] == default_upgrade:
mycar.data_obj['equip'][
_type] = default_upgrade
break
break
Car.update(self, mycar)
else:
logging.warning("cant build default stuff")
else: # but if player does exist
#####################################################################################################################
## Found existing user
uuid = player.uuid
if token: # if token is provided from
# apple
player.state_obj[
'token'] = token # assign token to player state
if fbid != '':
player.fbid = fbid
player.info_obj['fbid'] = fbid
player.info_obj['image'] = image # assign image url
if name != '':
player.info_obj['name'] = name # assign name
try:
updated = player.state_obj['updated']
except KeyError:
player.state_obj['updated'] = start_time
if self.request.get('lang'):
player.info_obj['lang'] = lang
# Additional things that have been added and neeed checking for old players
# TODO : Remove try catch, or see performance impact in Python
try:
if guid:
player.state_obj['guid'] = guid
except KeyError:
player.state_obj['guid'] = ''
# try .. cash and assign new property
try:
cash = player.state_obj['cash']
except KeyError:
player.state_obj['cash'] = cash
try:
total_wins = player.state_obj['total_wins']
except KeyError:
player.state_obj['total_wins'] = total_wins
try:
advice_checklist = player.state_obj['advice_checklist']
except KeyError:
player.state_obj['advice_checklist'] = advice_checklist
if Player.setplayer(self, player):
# then obviously, no error
# compose JSON for frontend response
type = ''
for item in config.playerdata:
type += item + ','
type = type.rstrip(',')
self.respn = '{"uuid":"' + uuid + '",'
types = type.split(',')
for item in types:
if item == 'info':
self.respn += '"info":' + player.info + ','
elif item == 'state':
self.respn += '"state":' + player.state + ','
elif item == 'building':
buildings = Data.getbuildings(self, lang, version)
mybuildings = Building.getmybuildings(self, uuid)
if buildings is not None and mybuildings is not None:
self.respn += '"building":['
# loop through my buildings to find out which need their pending status updating
for new_building in mybuildings:
# update building status, determine production
_upd = False
if new_building.status == Building.BuildingStatus.PENDING:
if new_building.timestamp + (
buildings.as_obj[
new_building.itid][
new_building.level - 1]
['build_time'] * 60) <= start_time:
new_building.timestamp = int(
start_time)
new_building.status = Building.BuildingStatus.DELIVERED
_upd = True
elif new_building.status == Building.BuildingStatus.DELIVERED:
new_building.status = Building.BuildingStatus.OWNED
_upd = True
if _upd is True:
Building.setmybuilding(
self, new_building)
self.respn = Building.compose_mybuilding(
self.respn, new_building)
self.respn = self.respn.rstrip(',') + '],'
elif item == 'car':
mycars = Car.list(self, player.uuid)
self.respn += '"car":['
for _car in mycars:
self.respn += Car.compose_mycar('', _car) + ','
self.respn = self.respn.rstrip(',') + '],'
elif item == 'challenge':
Challenge.ComposeChallenges(self, player)
self.respn = self.respn.rstrip(',') + '}'
###################################################################################################
## Add to recent player list
recentplayerlist = Data.GetRecentPlayerList(self)
_add = True
# check if this user hasn't reached the maximum set challengers
# we don't add players to the recent list if they are stacked
num = 0
challengers = Challenge.GetChallengers(
self, player.info_obj['uuid'])
if challengers is None:
Challenge.GetChallengers(self, player.info_obj['fbid'])
if challengers is not None:
for challenger in challengers:
obj = json.loads(challenger.data)
if obj['friend'] is False:
num += 1
if num > config.recentplayer['maxchallengers']:
logging.warn(
'Recent player list exceeded for ' +
uuid)
_add = False
break
# find if it already exists?
num = 0
_deletelist = []
for recentplayer in recentplayerlist.obj:
if recentplayer['uuid'] == player.info_obj['uuid']:
if _add is False: # this player reach the maximum of challengers
_deletelist.append(
num
) # we should delete him from the list, so nobody can challenge him
else:
_add = False
# if the list is longer than maxlist, delete the rest
if num >= config.recentplayer['maxlist']:
_deletelist.append(num)
# remove if player does not exist any more
else:
someplayer = Player.getplayer(
self, recentplayer['uuid'])
if someplayer is None:
self.error = ''
_deletelist.append(num)
num += 1
num = len(_deletelist)
for i in range(0, num):
del recentplayerlist.obj[num - 1 - i]
if _add is True:
recentplayerlist.obj.append({
'fbid':
player.info_obj['fbid'],
'name':
player.info_obj['name'],
'uuid':
player.info_obj['uuid'],
'image':
player.info_obj['image'],
'total_wins':
player.state_obj['total_wins'],
'updated':
player.state_obj['updated']
})
Data.SetRecentPlayerList(self, recentplayerlist)
else: # but if write down to database was failed
self.error = 'unable to insert/update player data.' # inform user bia error message
logging.warn('unable to insert/update player data.')
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, GCVars.passwd)
guid = self.request.get('guid')
uuid = Utils.required(self, 'uuid')
uuid2 = Utils.required(self, 'uid2')
events = Utils.required(self, 'events')
events2 = Utils.required(self, 'events2')
laptime = Utils.required(self, 'laptime')
laptime2 = Utils.required(self, 'laptime2')
track = Utils.required(self, 'track')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
Utils.LogRequest(self)
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# if error, skip this
#if self.error != '' or self.error is None:
player = Player.getplayer(self, uuid)
player2 = Player.getplayer(self, uuid2)
ai = None
my_building = None
win_prize = None
lose_prize = None
data = Data.getDataAsObj(self, 'opponent_en', 1.0)
if data is None:
opponents = {'obj': json.loads(Score.GetDefaultOpponents())}
else:
opponents = data.obj
for _track in opponents:
for opponent in opponents[_track]:
if not win_prize:
win_prize = opponent['win_prize']
if not lose_prize:
lose_prize = opponent['lose_prize']
if player2 is None:
if opponent['id'] == uuid2:
ai = opponent
self.error = ''
if player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if player is not None:
scores = Score.calculate(self, events, events2, laptime, laptime2,
win_prize, lose_prize)
if scores is not None:
score = scores[0]['total']
#player.state_obj['cash'] += score
player.state_obj['updated'] = start_time
if player2 is not None:
player.state_obj[GCVars.total_races] += 1
if laptime < laptime2:
player.state_obj[GCVars.total_wins] += 1
if ai is not None:
# save the resource to a building, ready for collection
my_building = Building.save_resource_to_building(
self, lang, version, player.uuid, track, score)
if player.state_obj.has_key(GCVars.total_ai_races):
player.state_obj[GCVars.total_ai_races] += 1
else:
player.state_obj.setdefault(GCVars.total_ai_races, 1)
if laptime < laptime2:
if player.state_obj.has_key(GCVars.total_ai_wins):
player.state_obj[GCVars.total_ai_wins] += 1
else:
player.state_obj.setdefault(
GCVars.total_ai_wins, 1)
#find star rating
difference = float(laptime2) - float(laptime)
data = {}
star_value = 0
new_star_value = 0
if player.state_obj.has_key('data'):
data = json.loads(player.state_obj['data'])
if data.has_key(uuid2):
star_value = int(data[uuid2])
#0,2,4 = 1 start time, 2 start time, 3 star time
if difference > float(ai['1_star_time']):
new_star_value = 1
if difference > float(ai['2_star_time']):
new_star_value = 2
if difference > float(ai['3_star_time']):
new_star_value = 3
if new_star_value > star_value:
data[uuid2] = new_star_value
logging.debug(
str(new_star_value) + ' > star_value:' +
str(star_value) + ', laptime 1:' + str(laptime) +
', laptime2: ' + str(laptime2))
logging.debug('setting player data to ' +
json.dumps(data))
player.state_obj['data'] = json.dumps(data)
player.state = json.dumps(player.state_obj)
Player.setplayer(self, player)
if 'xxx' in player.state:
self.error += '[KNOWN ISSUE] Player car lost. Please visit showroom and buy X1 again.'
player_score = scores[0]
scores_to_return = {
'score_prize': player_score['prize'],
'score_drift': player_score['prizes']['drift_bonus'],
'score_shift': player_score['prizes']['shift_bonus'],
'score_start': player_score['prizes']['start_bonus']
}
logging.debug('finishrace player state:' + player.state)
self.respn = '{"state":' + player.state
self.respn += ',"scores":' + json.dumps(scores_to_return)
if my_building is not None:
self.respn += ',"building":['
self.respn = Building.compose_mybuilding(
self.respn, my_building)
self.respn = self.respn.rstrip(',') + ']'
self.respn += '}'
if player2 is not None:
score = scores[1]['total']
#player2.state_obj[GCVars.cash] += score
Building.save_resource_to_building(self, lang, version,
player2.uuid, track,
score)
player2.state_obj[GCVars.updated] = start_time
player2.state_obj[GCVars.total_races] += 1
if laptime2 < laptime:
player2.state_obj[GCVars.total_wins] += 1
Player.setplayer(self, player2)
else:
self.error = 'Cant find a player for ' + uuid
#else:
# logging.warn('final error ' + self.error)
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
start_time = time.time() # start count
# if error, skip this
if self.error == '':
player = Player.getplayer_as_obj(
self, uuid) # get player state from Player model class helper
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
# if error or player is none, skip this
if self.error == '' and player is not None:
storeitem = Data.getstoreitem_as_arr(
self) # get store item from Storeitem model class helper
# if error or storeitem is none, skip this
if self.error == '' and storeitem is not None:
myitems = Item.getitems(self, uuid) # get list of items owned
# set result default
self.respn = '['
reason = ''
for item in storeitem: # run through each item in store items
add = True # A variable indicates that is it available for user
if item['dependencies'] != '': # if item has dependencies
add = False # set item to unavailable first, we will change it available after we check all its dependencies
reason = 'You need the following items first: ' + item[
'dependencies']
# also inform user some good reason, not just die. this will eliminate after we check all its dependencies anyway
depc = 0 # A variable stand from dependencies counter
deps = item['dependencies'].replace(' ', '').split(
','
) # and eliminate space from dependencies and split by commas ','
for dep in deps: # run through all dependences of the item
for myitem in myitems: # run through all user's list of items
if myitem.itid == dep: # check if user have dependency item
depc = depc + 1 # increment counter
if depc >= len(
deps
): # alter all counting, if counter is more than all dependecies, it probably means user has all dependencies
add = True # and then yeah!, we turn item to available
if add == True and item[
'maximum'] != '': # check if the item has maximum limitation
depc = 0 # set counter to 0 again, we will use for next logic
for myitem in myitems: # run through myitems
if myitem.itid == item[
'id']: # check if user has same item in hand
depc = depc + 1 # increment counter
if int(depc) >= int(
item['maximum']
): # if counter is more than or equal the item's maximum
add = False # that means user has reached the maximum, and should not available for him any more
reason = 'You\'ve reached the maximum of this item!' # and yes! should inform him that
# hard compose item list
self.respn += '{'
self.respn += ' "itid":"' + item['id'] + '",'
self.respn += ' "type":"' + item['type'] + '",'
self.respn += ' "title":"' + item['title'] + '",'
self.respn += ' "desc":"' + item['description'] + '",'
self.respn += ' "depend":"' + item['dependencies'] + '",'
self.respn += ' "imgurl":"' + item['image_url_sd'] + '",'
self.respn += ' "gold":' + str(item['gold']) + ','
self.respn += ' "time":' + str(item['time']) + ','
self.respn += ' "platinum":' + str(item['platinum']) + ','
if add == True:
self.respn += ' "lock":""'
else:
self.respn += ' "lock":"' + reason + '"'
self.respn += '},'
self.respn = self.respn.rstrip(',') + ']'
# calculate time taken and return result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
class Evento:
__nome = None
__descricao = None
__usuario = None
__codigo = None
__data_criacao = Data()
__data_inicio = Data()
__data_fim = Data()
__interesses = [None]
__estado_atual = None
estados = {1:"novo",2:"inscricoes abertas",3:"em andamento",4:"finalizado"}
def __init__(self,nome,descricao,usuario,data_inicio,data_fim):
self.__nome = nome
self.__descricao = descricao
self.__usuario = usuario
self.__codigo = Hash.generateHash()
self.__data_inicio = data_inicio
self.__data_fim = data_fim
self.__data_criacao = Data.getSystemData()
self.__estado_atual = 1
self.__interesses ["None"]
def getNome():
return self.__nome
def getDescricao():
return self.__descricao
def getUsuario():
return self.__usuario
def getCodigo():
return self.__codigo
def getDataInicio():
return self.__data_inicio
def getDataCriacao():
return self.__data_criacao
def getDataFim():
return self.__data_fim
def getEstado():
return self.__atual
def getInteresses():
return self.__interesses
def __setDataCriacao(self,data):
self.__dataCriacao = data
def __setEstado(self,estado):
self.__estado = estado
def setInteresses(self,interesses):
self.__interesses = interesses
def toCSVString(self):
return (self.__nome + "," + self.__descricao + "," + self.__usuario +","+ self.__codigo + ","\
self.__data_inicio.toString() + "," + self.__data_fim.toString() + ","\
self.__data_criacao.toString() + "," +self.__estado +"," + self.__interesses)
def parseFromStrig(string):
v = string.split(",")
evento = Evento(v[0],v[1],v[2],Data.parseFromString(v[3]),Data.parseFromString(v[4]))
evento.setDataCriacao(v[5])
evento.setEstado(v[6])
evento.setInteresses(v[7])
return evento
def get(self):
# reset/clean standard variables
Utils.reset(self)
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
inid = Utils.required(self, 'inid')
# start count
start_time = time.time()
# set default parameters
player = None
buildings = None
mybuilding = None
economy = None
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid)
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
# if error or player is not, then skip to the end
if self.error == '' and player is not None:
buildings = Data.getbuildings(self, lang, version)
if self.error == '' and buildings is not None:
mybuilding = Building.getmybuilding(self, uuid, inid)
# if any error or mybuilding is none, then skip to the end
if self.error == '' and mybuilding is not None:
if mybuilding.status != Building.BuildingStatus.PENDING:
self.respn = '{"warning":"building=' + inid + ' has been finished."}'
else:
economy = Data.getDataAsObj(self, 'economy',
config.data_version['economy'])
if self.error == '' and self.respn == '' and economy is not None:
_upd = False
time_left = buildings.as_obj[mybuilding.itid][
mybuilding.level - 1]['build_time'] - int(
(start_time - mybuilding.timestamp) / 60)
if mybuilding.status == Building.BuildingStatus.PENDING:
if time_left > 0:
sele = economy.obj[0]
for list in economy.obj:
if time_left >= list['time_in_minutes']:
sele = list
else:
break
if player.state_obj['gold'] >= sele['gold_value']:
player.state_obj['gold'] -= sele['gold_value']
mybuilding.status = Building.BuildingStatus.DELIVERED
_upd = True
player.state_obj['updated'] = start_time
Player.setplayer(self, player)
else:
self.respn = '{"warning":"not enough gold!"}'
else:
mybuilding.status = Building.BuildingStatus.DELIVERED
_upd = True
if _upd is True:
Building.setmybuilding(self, mybuilding)
if self.error == '' and self.respn == '':
self.respn = '{"state":' + player.state + ', "buildings":['
self.respn = Building.compose_mybuilding(
self.respn, mybuilding)
self.respn = self.respn.rstrip(',') + ']'
self.respn += '}'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
itid = Utils.required(self, 'itid')
level = Utils.required(self, 'level')
location = Utils.required(self, 'location')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# logical variables
player = None
buildings = None
building = None
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid)
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if self.error == '' and player is not None:
buildings = Data.getbuildings(self, lang, float(version))
if self.error == '' and buildings is not None:
try:
building = buildings.as_obj[itid][int(level) - 1]
except KeyError:
self.error = itid + " was not found!"
if self.error == '' and building is not None:
if player.state_obj['cash'] >= building['cost']:
player.state_obj['cash'] -= building['cost']
player.state_obj[
'updated'] = start_time # update timestamp for player
if Player.setplayer(self, player):
mybuilding = Building.newbuilding(self)
mybuilding.uuid = uuid
mybuilding.itid = itid
mybuilding.inid = Utils.genanyid(self, 'b')
mybuilding.level = building['level']
mybuilding.status = Building.BuildingStatus.PENDING
mybuilding.location = location
mybuilding.amount = 0
mybuilding.timestamp = int(start_time)
Building.setmybuilding(self, mybuilding)
self.respn = '{"state":' + player.state + ','
self.respn += '"building":['
self.respn = Building.compose_mybuilding(
self.respn, mybuilding)
self.respn = self.respn.rstrip(',') + ']'
self.respn += '}'
else:
self.respn = '{"warning":"not enough cash!"}'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
inid = Utils.required(self, 'inid')
amount = Utils.required(self, 'amount')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
Utils.LogRequest(self)
start_time = time.time() # start count
# logic variables
player = None
buildings = None
mybuilding = None
res_produced = 0
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid)
"""
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
"""
if self.error == '' and player is not None:
buildings = Data.getbuildings(self, lang, version)
if self.error == '' and buildings is not None:
mybuilding = Building.getmybuilding(self, uuid, inid)
if self.error == '' and mybuilding is not None:
_upd = False
if mybuilding.status == Building.BuildingStatus.PENDING:
if mybuilding.timestamp + (
buildings.as_obj[mybuilding.itid][mybuilding.level - 1]['build_time'] * 60) <= start_time:
mybuilding.timestamp = int(start_time)
mybuilding.status = Building.BuildingStatus.DELIVERED
_upd = True
elif mybuilding.status == Building.BuildingStatus.DELIVERED:
mybuilding.status = Building.BuildingStatus.OWNED
_upd = True
if mybuilding.status == Building.BuildingStatus.DELIVERED or mybuilding.status == Building.BuildingStatus.OWNED:
time_delta = (start_time - mybuilding.timestamp) / 60
if time_delta > buildings.as_obj[mybuilding.itid][mybuilding.level - 1]['resource_interval'] > 0:
#mybuilding.status = Building.BuildingStatus.PRODUCED_PARTIAL
#_upd = True
res_produced = int(
time_delta / buildings.as_obj[mybuilding.itid][mybuilding.level - 1]['resource_interval']) * buildings.as_obj[mybuilding.itid][mybuilding.level - 1]['resource_produced']
if res_produced >= buildings.as_obj[mybuilding.itid][mybuilding.level - 1]['resource_capacity']:
res_produced = buildings.as_obj[mybuilding.itid][mybuilding.level - 1]['resource_capacity']
##mybuilding.status = Building.BuildingStatus.PRODUCED
#_upd = True
elif mybuilding.status == Building.BuildingStatus.PRODUCED_PARTIAL or mybuilding.status == Building.BuildingStatus.PRODUCED:
if mybuilding.amount is None:
mybuilding.amount = 0;
res_produced = mybuilding.amount
mybuilding.amount = 0
mybuilding.status = Building.BuildingStatus.OWNED
_upd = True
if res_produced > 0:
if res_produced > amount:
res_produced = amount
try:
# eg player['cash'] += 1
resource_type = buildings.as_obj[mybuilding.itid][mybuilding.level - 1]['resource']
_upd = True
new_amount = int(res_produced) + int(mybuilding.amount)
logging.debug('resource to collect = ' + str(res_produced) + " " + str(resource_type) + " = " + str(new_amount))
logging.debug('building contains = ' + str(res_produced))
player.state_obj[
buildings.as_obj[mybuilding.itid][mybuilding.level - 1]['resource']] += new_amount
# update timestamp for player
player.state_obj['updated'] = start_time
if Player.setplayer(self, player):
#mybuilding.status = Building.BuildingStatus.OWNED
mybuilding.timestamp = int(start_time)
_upd = True
except KeyError:
self.error = 'resource=' + buildings.as_obj[mybuilding.itid][mybuilding.level - 1][
'resource'] + ' doesn\'t exist in player properties!'
if _upd is True:
Building.setmybuilding(self, mybuilding)
if self.error == '':
self.respn = '{"state":' + player.state + ', "building":['
self.respn = Building.compose_mybuilding(self.respn, mybuilding)
self.respn = self.respn.rstrip(',') + ']'
self.respn += '}'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def selectDataTomat(kondisi): conn = Db.getConnection() myCursor = conn.cursor() sql = 'SELECT * from data_crop_tomat WHERE id_kondisi=%s' myCursor.execute(sql,kondisi) result = myCursor.fetchall() conn.commit() conn.close() allData = [] for x in range(0, len(result)): data = Data() data.setId(result[x]['id']) data.setName(result[x]['name']) data.setStDeviasi(result[x]['st_deviasi']) data.setMean(result[x]['mean']) data.setMedian(result[x]['median']) data.setIdKondisi(result[x]['id_kondisi']) data.setR(result[x]['r']) allData.append(data) return allData;
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
crid = Utils.required(self, 'crid')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# logical variables
player = None
cars = None
upgrades = None
car = None
#mycars = None
Utils.LogRequest(self)
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid)
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if self.error == '' and player is not None:
cars = Data.getcars(self, lang, float(version))
if self.error == '' and cars is not None:
found = False
for _car in cars.as_obj:
if _car['id'] == crid:
car = _car
found = True
break
if found is False:
self.error = crid + " was not found!"
if self.error == '' and car is not None:
mycars = Car.list(self, uuid)
for _car in mycars:
data_obj = json.loads(_car.data)
try:
if data_obj['info']['crid'] == crid:
# already own this car type, and you can only 1 of each type
#self.respn = '{"warning":"You have already purchased this car."}'
player.state_obj['current_car'] = _car.cuid
player.state_obj['updated'] = start_time
if Player.setplayer(self, player):
self.respn = '{"state":' + player.state + ','
self.respn += '"car":['
self.respn = Car.compose_mycar(self.respn, _car)
self.respn = self.respn.rstrip(',') + ']'
self.respn += '}'
car = None
break
except KeyError:
self.error = 'Cannot find crid (KeyError issue), please report admin!'
if self.error == '' and car is not None:
upgrades = Data.getupgrades(self, lang, float(version))
if self.error == '' and upgrades is not None:
# good to go as we have a car
if player.state_obj['cash'] >= car['cost']:
player.state_obj['cash'] -= car['cost']
player.state_obj[
'updated'] = start_time # update timestamp for player
mycar = Car.create(self, player.uuid)
mycar.data_obj['info'] = {'crid': car['id']}
mycar.data_obj['upgrades'] = []
mycar.data_obj['equip'] = {}
player.state_obj['current_car'] = mycar.cuid
default_upgrades = car['default_upgrades'].replace(
' ', '').split(',')
for default_upgrade in default_upgrades:
mycar.data_obj['upgrades'].append(default_upgrade)
for _type in upgrades.as_obj:
try:
mycar.data_obj['equip'][type]
except KeyError:
for upgrade in upgrades.as_obj[_type]:
if upgrade['id'] == default_upgrade:
mycar.data_obj['equip'][
_type] = default_upgrade
break
break
player.state = json.dumps(player.state_obj)
if Player.setplayer(self, player):
if Car.update(self, mycar):
self.respn = '{"state":' + player.state + ','
self.respn += '"car":['
self.respn = Car.compose_mycar(self.respn, mycar)
self.respn = self.respn.rstrip(',') + ']'
self.respn += '}'
else:
self.respn = '{"warning":"not enough cash!"}'
logging.warn("not enough cash")
else:
logging.warn("Error with car upgrades")
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
type = Utils.required(self, 'type')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
Utils.LogRequest(self)
if self.request.get('game'):
if self.request.get('game') == 'pro7':
lang = 'de'
# if error, skip this
if self.error == '':
if type == 'all':
type = ''
for item in config.gamedata:
type += item + ','
type = type.rstrip(',')
self.respn = '{'
types = type.split(',')
for item in types:
if (item == 'transui'):
data = Data.getData(self, item, version)
if data is not None:
data_obj = json.loads(data.data)
self.respn += '"transui":' + json.dumps(data_obj[lang]) + ','
else:
data = Data.getData(self, item + '_' + lang, version)
if data is None:
data = Data.getData(self, item, version)
if data is not None:
self.respn += '"' + item + '":' + data.data + ','
else:
data = Data.getData(self, item, version)
if data is not None:
self.respn += '"' + item + '":' + data.data + ','
if not item:
item = ''
if not data:
data = ''
logging.debug(item + ":" + data.data)
self.respn = self.respn.rstrip(',') + '}'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken, False))
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
version = config.data_version['buildings']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# logical variables
player = None
researches = None
myresearches = None
# if error, skip this
if self.error == '':
player = Player.getplayer_as_obj(self, uuid)
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if self.error == '' and player is not None:
researches = Data.getresearches(self, version)
if self.error == '' and researches is not None:
myresearches = Research.getmyresearches(self, uuid)
if self.error == '' and myresearches is not None:
self.respn = '['
for myresearch in myresearches:
# update building status, determine production
_name = str(myresearch.itid)
_pos = myresearch.itid.find('.', len(myresearch.itid)-4)
_bui = myresearch.itid[0:_pos]
_lev = myresearch.itid[_pos+1:len(myresearch.itid)]
_upd = False
if myresearch.status == Research.ResearchStatus.PENDING:
if myresearch.timestamp + (researches.as_obj[_bui][_lev]['wait']*60) <= start_time:
myresearch.timestamp = int(start_time)
myresearch.status = Research.ResearchStatus.REWARD
_upd = True
elif myresearch.status == Research.ResearchStatus.REWARD:
myresearch.status = Research.ResearchStatus.OWNED
_upd = True
if _upd is True:
Research.setmyresearch(self, myresearch)
self.respn = Research.compose_myresearch(self.respn, myresearch)
self.respn = self.respn.rstrip(',') + ']'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
