def test_reserve_lot(self):
with self.check_delta(models.Lot.objects.count, 1):
lot = logic.reserve_lot(account_id=self.account_1.id,
good=self.good_2,
price=777)
lot_model = models.Lot.objects.latest()
self.assertEqual(lot.id, lot_model.id)
self.assertEqual(lot.type, lot_model.type)
self.assertEqual(lot.seller_id, lot_model.seller_id)
self.assertEqual(lot.buyer_id, lot_model.buyer_id)
self.assertEqual(lot.name, lot_model.name)
self.assertEqual(lot.state, lot_model.state)
self.assertEqual(lot.price, lot_model.price)
self.assertTrue(lot.closed_at-lot.created_at > datetime.timedelta(days=conf.settings.LOT_LIVE_TIME, seconds=-1))
self.assertEqual(lot.good.serialize(), s11n.from_json(lot_model.data)['good'])
self.assertEqual(lot.type, self.good_2.type)
self.assertEqual(lot.seller_id, self.account_1.id)
self.assertEqual(lot.buyer_id, None)
self.assertEqual(lot.name, self.good_2.name)
self.assertTrue(lot.state.is_RESERVED)
self.assertEqual(lot.price, 777)
self.assertEqual(lot.commission, 54)
self.assertTrue(lot.closed_at-lot.created_at > datetime.timedelta(days=conf.settings.LOT_LIVE_TIME, seconds=-1))
self.assertEqual(lot.good.serialize(), self.good_2.serialize())
def test_choose_ability_request_wrong_ability(self):
self.request_login('*****@*****.**')
response = self.client.post(
reverse('game:heroes:choose-ability', args=[self.hero.id + 1]) +
'?ability_id=xxxyyy')
self.assertEqual(response.status_code, 200)
self.assertEqual(s11n.from_json(response.content)['status'], 'error')
def load_person(person_id=None, person_model=None):
# TODO: get values instead model
# TODO: check that load_hero everywhere called with correct arguments
try:
if person_id is not None:
person_model = models.Person.objects.get(id=person_id)
elif person_model is None:
return None
except models.Person.DoesNotExist:
return None
data = s11n.from_json(person_model.data)
return objects.Person(
id=person_model.id,
created_at_turn=person_model.created_at_turn,
updated_at_turn=person_model.updated_at_turn,
place_id=person_model.place_id,
gender=person_model.gender,
race=person_model.race,
type=person_model.type,
attrs=attributes.Attributes.deserialize(data.get("attributes", {})),
politic_power=PersonPoliticPower.deserialize(data["politic_power"])
if "politic_power" in data
else PersonPoliticPower.create(),
utg_name=utg_words.Word.deserialize(data["name"]),
job=PersonJob.deserialize(data["job"])
if "job" in data
else PersonJob.create(normal_power=NORMAL_PERSON_JOB_POWER),
personality_cosmetic=relations.PERSONALITY_COSMETIC(data["personality"]["cosmetic"]),
personality_practical=relations.PERSONALITY_PRACTICAL(data["personality"]["practical"]),
moved_at_turn=data.get("moved_at_turn", 0),
updated_at=person_model.updated_at,
)
def statistics(self):
statistics = s11n.from_json(self._model.statistics)
statistics['race_percents'] = dict( (RACE(int(key)), value) for key, value in statistics['race_percents'].items())
statistics['person_race_percents'] = dict( (RACE(int(key)), value) for key, value in statistics['person_race_percents'].items())
statistics['race_cities'] = dict( (RACE(int(key)), value) for key, value in statistics['race_cities'].items())
statistics['terrain_percents'] = dict( (MAP_STATISTICS(int(key)), value) for key, value in statistics['terrain_percents'].items())
return statistics
def test_download(self):
word_type = relations.ALLOWED_WORD_TYPE.random().utg_type
parent_word = utg_words.Word.create_test_word(word_type, prefix='parent-')
child_word = utg_words.Word.create_test_word(word_type, prefix='child-')
ingame_word = utg_words.Word.create_test_word(word_type, prefix='ingame-')
outgame_word = utg_words.Word.create_test_word(word_type, prefix='outgame-')
parent = prototypes.WordPrototype.create(parent_word)
parent.state = relations.WORD_STATE.IN_GAME
parent.save()
prototypes.WordPrototype.create(child_word, parent=parent) # child
ingame = prototypes.WordPrototype.create(ingame_word)
ingame.state = relations.WORD_STATE.IN_GAME
ingame.save()
prototypes.WordPrototype.create(outgame_word) # outgame
response = self.client.get(url('linguistics:words:dictionary-download'))
data = s11n.from_json(response.content.decode('utf-8'))
self.assertEqual(len(data['words']), 2)
self.assertIn(parent.utg_word.serialize(), data['words'])
self.assertIn(ingame.utg_word.serialize(), data['words'])
def test_logined(self):
response = self.client.get(self.game_info_url_1)
self.assertEqual(response.status_code, 200)
self.assertEqual(
set(s11n.from_json(response.content)['data'].keys()),
set(('turn', 'mode', 'map_version', 'account', 'enemy',
'game_state')))
def test_full__logged_out_before_token_accept(self):
api_client = Client()
request_token_url = url('accounts:third-party:tokens:request-authorisation', api_version='1.0', api_client=project_settings.API_CLIENT)
response = api_client.post(request_token_url, {'application_name': 'app-name',
'application_info': 'app-info',
'application_description': 'app-descr'})
self.check_ajax_ok(response)
token_url = s11n.from_json(response.content.decode('utf-8'))['data']['authorisation_page']
token = prototypes.AccessTokenPrototype._db_latest()
self.assertEqual(url('accounts:third-party:tokens:show', token.uid), token_url)
self.check_html_ok(self.request_html(token_url), texts=['app-name', 'app-info', 'app-descr'])
authorisation_state_url = url('accounts:third-party:tokens:authorisation-state', api_version='1.0', api_client=project_settings.API_CLIENT)
self.check_ajax_ok(api_client.get(authorisation_state_url),
data={'account_id': None,
'account_name': None,
'state': relations.AUTHORISATION_STATE.UNPROCESSED.value,
'session_expire_at': 666.6})
self.check_ajax_ok(api_client.post(logout_url()))
self.assertNotIn('_auth_user_id', api_client.session)
self.assertNotEqual(prototypes.AccessTokenPrototype.get_by_uid(token.uid), None)
self.assertNotIn(third_party_settings.ACCESS_TOKEN_SESSION_KEY, api_client.session)
def test_reserve_lot(self):
with self.check_delta(models.Lot.objects.count, 1):
lot = logic.reserve_lot(account_id=self.account_1.id,
good=self.good_2,
price=777)
lot_model = models.Lot.objects.latest()
self.assertEqual(lot.id, lot_model.id)
self.assertEqual(lot.type, lot_model.type)
self.assertEqual(lot.seller_id, lot_model.seller_id)
self.assertEqual(lot.buyer_id, lot_model.buyer_id)
self.assertEqual(lot.name, lot_model.name)
self.assertEqual(lot.state, lot_model.state)
self.assertEqual(lot.price, lot_model.price)
self.assertTrue(lot.closed_at-lot.created_at > datetime.timedelta(days=conf.settings.LOT_LIVE_TIME, seconds=-1))
self.assertEqual(lot.good.serialize(), s11n.from_json(lot_model.data)['good'])
self.assertEqual(lot.type, self.good_2.type)
self.assertEqual(lot.seller_id, self.account_1.id)
self.assertEqual(lot.buyer_id, None)
self.assertEqual(lot.name, self.good_2.name)
self.assertTrue(lot.state.is_RESERVED)
self.assertEqual(lot.price, 777)
self.assertEqual(lot.commission, 54)
self.assertTrue(lot.closed_at-lot.created_at > datetime.timedelta(days=conf.settings.LOT_LIVE_TIME, seconds=-1))
self.assertEqual(lot.good.serialize(), self.good_2.serialize())
def from_model(cls, model):
from the_tale.game.artifacts import objects as artifacts_objects
data = s11n.from_json(model.data)
weapons = [
artifacts_objects.Weapon.deserialize(weapon_data)
for weapon_data in data.get('weapons', ())
]
return cls(id=model.id,
state=model.state,
type=model.type,
max_health=model.max_health,
dedication=model.dedication,
archetype=model.archetype,
mode=model.mode,
communication_verbal=model.communication_verbal,
communication_gestures=model.communication_gestures,
communication_telepathic=model.communication_telepathic,
intellect_level=model.intellect_level,
abilities=abilities_container.Container.deserialize(
data.get('abilities', {})),
utg_name=utg_words.Word.deserialize(data['name']),
description=data['description'],
structure=beings_relations.STRUCTURE(
data.get('structure', 0)),
features=frozenset(
beings_relations.FEATURE(feature)
for feature in data.get('features', ())),
movement=beings_relations.MOVEMENT(data.get('movement', 0)),
body=beings_relations.BODY(data.get('body', 0)),
size=beings_relations.SIZE(data.get('size', 0)),
weapons=weapons)
def test_choose_ability_request_wrong_ability(self):
self.request_login("*****@*****.**")
response = self.client.post(
reverse("game:heroes:choose-ability", args=[self.hero.id + 1]) + "?ability_id=xxxyyy"
)
self.assertEqual(response.status_code, 200)
self.assertEqual(s11n.from_json(response.content)["status"], "error")
def preferences(self):
from the_tale.game.heroes.preferences import HeroPreferences
preferences = HeroPreferences.deserialize(hero=self,
data=s11n.from_json(
self._model.preferences))
if preferences.energy_regeneration_type is None:
preferences.set_energy_regeneration_type(
self.race.energy_regeneration,
change_time=datetime.datetime.fromtimestamp(0))
if preferences.risk_level is None:
preferences.set_risk_level(
relations.RISK_LEVEL.NORMAL,
change_time=datetime.datetime.fromtimestamp(0))
if preferences.archetype is None:
preferences.set_archetype(
game_relations.ARCHETYPE.NEUTRAL,
change_time=datetime.datetime.fromtimestamp(0))
if preferences.companion_dedication is None:
preferences.set_companion_dedication(
relations.COMPANION_DEDICATION.NORMAL,
change_time=datetime.datetime.fromtimestamp(0))
if preferences.companion_empathy is None:
preferences.set_companion_empathy(
relations.COMPANION_EMPATHY.ORDINAL,
change_time=datetime.datetime.fromtimestamp(0))
return preferences
def load_person(person_id=None, person_model=None):
# TODO: get values instead model
# TODO: check that load_hero everywhere called with correct arguments
try:
if person_id is not None:
person_model = models.Person.objects.get(id=person_id)
elif person_model is None:
return None
except models.Person.DoesNotExist:
return None
data = s11n.from_json(person_model.data)
return objects.Person(
id=person_model.id,
created_at_turn=person_model.created_at_turn,
updated_at_turn=person_model.updated_at_turn,
place_id=person_model.place_id,
gender=person_model.gender,
race=person_model.race,
type=person_model.type,
attrs=attributes.Attributes.deserialize(data.get('attributes', {})),
politic_power=PersonPoliticPower.deserialize(data['politic_power'])
if 'politic_power' in data else PersonPoliticPower.create(),
utg_name=utg_words.Word.deserialize(data['name']),
job=PersonJob.deserialize(data['job']) if 'job' in data else
PersonJob.create(normal_power=NORMAL_PERSON_JOB_POWER),
personality_cosmetic=relations.PERSONALITY_COSMETIC(
data['personality']['cosmetic']),
personality_practical=relations.PERSONALITY_PRACTICAL(
data['personality']['practical']),
moved_at_turn=data.get('moved_at_turn', 0),
updated_at=person_model.updated_at)
def terrain(self):
data = s11n.from_json(self._model.terrain)
terrain = []
for row in data:
terrain.append([])
for cell in row:
terrain[-1].append(TERRAIN(cell))
return terrain
def refresh(self):
self.clear()
for forms in self._words_query().iterator():
word = utg_words.Word.deserialize(s11n.from_json(forms))
self._item.add_word(word)
self._version = settings.get(self.SETTINGS_KEY)
def to_python(self, value):
if not value:
return None
try:
return s11n.from_json(value)
except:
raise forms.ValidationError("Неверный формат json")
def refresh(self):
self.clear()
for forms in self._words_query().iterator():
word = utg_words.Word.deserialize(s11n.from_json(forms))
self._item.add_word(word)
self._version = settings.get(self.SETTINGS_KEY)
def test_choose_ability_request_anonymous(self):
response = self.client.post(
reverse('game:heroes:choose-ability', args=[self.hero.id]) +
'?ability_id=' + self.get_new_ability_id())
self.assertEqual(response.status_code, 200)
self.assertEqual(
s11n.from_json(response.content.decode('utf-8'))['status'],
'error')
def check_ajax_error(self, response, code, content_type='application/json', encoding='utf-8', status_code=200):
self.assertTrue(content_type in response['Content-Type'])
self.assertTrue(encoding in response['Content-Type'])
self.assertEqual(response.status_code, status_code)
data = s11n.from_json(response.content.decode(encoding))
self.assertEqual(data['status'], 'error')
self.assertEqual(data['code'], code)
def from_model(cls, model):
return cls(id=model.id,
state=model.state,
data=s11n.from_json(model.data),
type=model.type,
max_health=model.max_health,
dedication=model.dedication,
archetype=model.archetype,
mode=model.mode)
def from_model(cls, model):
return cls(id=model.id,
state=model.state,
data=s11n.from_json(model.data),
type=model.type,
max_health=model.max_health,
dedication=model.dedication,
archetype=model.archetype,
mode=model.mode)
def check_ajax_processing(self, response, status_url=None, content_type='application/json', encoding='utf-8'):
self.assertTrue(content_type in response['Content-Type'])
self.assertTrue(encoding in response['Content-Type'])
self.assertEqual(response.status_code, 200)
data = s11n.from_json(response.content.decode(encoding))
self.assertEqual(data['status'], 'processing')
if status_url:
self.assertEqual(data['status_url'], status_url)
def from_model(cls, model):
data = s11n.from_json(model.data)
goods = {}
for good_data in data.get('goods', ()):
good = Good.deserialize(good_data)
goods[good.uid] = good
return cls(id=model.id, account_id=model.account_id, goods=goods)
def construct_from_model(model):
data = s11n.from_json(model.data)
abilities = frozenset(s11n.from_json(model.abilities))
terrains = frozenset(
map_relations.TERRAIN(terrain)
for terrain in s11n.from_json(model.terrains))
features = frozenset(
beings_relations.FEATURE(feature)
for feature in data.get('features', ()))
weapons = [
artifacts_objects.Weapon.deserialize(weapon_data)
for weapon_data in data.get('weapons', ())
]
mob = objects.MobRecord(
id=model.id,
editor_id=model.editor_id,
level=model.level,
uuid=model.uuid,
description=model.description,
state=model.state,
type=model.type,
archetype=model.archetype,
communication_verbal=model.communication_verbal,
communication_gestures=model.communication_gestures,
communication_telepathic=model.communication_telepathic,
intellect_level=model.intellect_level,
is_mercenary=model.is_mercenary,
is_eatable=model.is_eatable,
abilities=abilities,
terrains=terrains,
structure=beings_relations.STRUCTURE(data.get('structure', 0)),
features=features,
movement=beings_relations.MOVEMENT(data.get('movement', 0)),
body=beings_relations.BODY(data.get('body', 0)),
size=beings_relations.SIZE(data.get('size', 0)),
orientation=beings_relations.ORIENTATION(data.get('orientation', 0)),
weapons=weapons,
utg_name=utg_words.Word.deserialize(data['name']))
return mob
def refresh(self):
self.clear()
for key, data in self._templates_query().iterator():
data = s11n.from_json(data)
template = utg_templates.Template.deserialize(data['template'])
restrictions = frozenset(
tuple(key) for key in data.get('restrictions', ()))
self._item.add_template(key, template, restrictions=restrictions)
self._version = settings.get(self.SETTINGS_KEY)
def from_model(cls, model):
data = s11n.from_json(model.data)
goods = {}
for good_data in data.get('goods', ()):
good = Good.deserialize(good_data)
goods[good.uid] = good
return cls(id=model.id,
account_id=model.account_id,
goods=goods)
def test_login(self):
response = self.client.post(url('accounts:auth:api-login', api_version='1.0', api_client='test-1.0', next_url='/bla-bla'),
{'email': '*****@*****.**', 'password': '******'})
self.check_ajax_ok(response)
data = s11n.from_json(response.content)
self.assertEqual(data['data']['next_url'], '/bla-bla')
self.assertEqual(data['data']['account_id'], self.account_id)
self.assertEqual(data['data']['account_name'], 'test_user')
self.assertTrue(data['data']['session_expire_at'] > time.time())
def test_handler(self):
self.assertEqual(
s11n.from_json(
self.resource.test_view(
arg_1=6, api_version='1.1',
api_client='client-v0.1').content.decode('utf-8')), {
'status': 'ok',
'data': {
'arg_1': 6
}
})
def test_handler__depricated_api_version(self):
self.assertEqual(
s11n.from_json(
self.resource.test_view(arg_1=6,
api_version='1.0',
api_client='client-v0.1').content), {
'status': 'ok',
'data': {
'arg_1': 6
},
'depricated': True
})
def refresh(self):
from the_tale.linguistics.lexicon.keys import LEXICON_KEY
self.clear()
for key, data in self._templates_query().iterator():
data = s11n.from_json(data)
template = utg_templates.Template.deserialize(data["template"])
restrictions = frozenset(tuple(key) for key in data.get("restrictions", ()))
self._item.add_template(LEXICON_KEY(key), template, restrictions=restrictions)
self._version = settings.get(self.SETTINGS_KEY)
def from_model(cls, model):
return cls(id=model.id,
state=model.state,
data=s11n.from_json(model.data),
type=model.type,
max_health=model.max_health,
dedication=model.dedication,
archetype=model.archetype,
mode=model.mode,
communication_verbal=model.communication_verbal,
communication_gestures=model.communication_gestures,
communication_telepathic=model.communication_telepathic,
intellect_level=model.intellect_level)
def check_ajax_ok(self, response, data=None, content_type='application/json', encoding='utf-8'):
self.assertTrue(content_type in response['Content-Type'])
self.assertTrue(encoding in response['Content-Type'])
self.assertEqual(response.status_code, 200)
content = s11n.from_json(response.content.decode(encoding))
self.assertEqual(content['status'], 'ok')
if data is not None:
self.assertEqual(content['data'], data)
return content.get('data')
def from_model(cls, model):
return cls(id=model.id,
state=model.state,
data=s11n.from_json(model.data),
type=model.type,
max_health=model.max_health,
dedication=model.dedication,
archetype=model.archetype,
mode=model.mode,
communication_verbal=model.communication_verbal,
communication_gestures=model.communication_gestures,
communication_telepathic=model.communication_telepathic,
intellect_level=model.intellect_level)
def handle(self, *args, **options):
for companion in models.CompanionRecord.objects.all().order_by(
'id').iterator():
print('process companion {}'.format(companion.id))
data = s11n.from_json(companion.data)
data['weapons'] = [{'weapon': 0, 'material': 0, 'power_type': 2}]
companion.data = s11n.to_json(data)
companion.save()
def load_place(place_id=None, place_model=None):
# TODO: get values instead model
# TODO: check that load_hero everywhere called with correct arguments
try:
if place_id is not None:
place_model = models.Place.objects.get(id=place_id)
elif place_model is None:
return None
except models.Place.DoesNotExist:
return None
data = s11n.from_json(place_model.data)
if 'nearest_cells' in data:
data['nearest_cells'] = list(map(tuple, data['nearest_cells']))
place = objects.Place(
id=place_model.id,
x=place_model.x,
y=place_model.y,
created_at_turn=place_model.created_at_turn,
updated_at_turn=place_model.updated_at_turn,
updated_at=place_model.updated_at,
created_at=place_model.created_at,
habit_honor=habits.Honor(raw_value=place_model.habit_honor),
habit_honor_positive=place_model.habit_honor_positive,
habit_honor_negative=place_model.habit_honor_negative,
habit_peacefulness=habits.Peacefulness(
raw_value=place_model.habit_peacefulness),
habit_peacefulness_positive=place_model.habit_peacefulness_positive,
habit_peacefulness_negative=place_model.habit_peacefulness_negative,
is_frontier=place_model.is_frontier,
description=place_model.description,
race=place_model.race,
persons_changed_at_turn=place_model.persons_changed_at_turn,
politic_power=PlacePoliticPower.deserialize(data['politic_power'])
if 'politic_power' in data else PlacePoliticPower.create(),
utg_name=utg_words.Word.deserialize(data['name']),
attrs=attributes.Attributes.deserialize(data.get('attributes', {})),
races=races.Races.deserialize(data['races']),
nearest_cells=data.get('nearest_cells', []),
effects=EffectsContainer.deserialize(data.get('effects')),
job=PlaceJob.deserialize(data['job']) if 'job' in data else
PlaceJob.create(normal_power=NORMAL_PLACE_JOB_POWER),
modifier=place_model.modifier)
place.attrs.sync()
return place
def from_model(cls, model):
data = s11n.from_json(model.data)
return cls(id=model.id,
created_at=model.created_at,
type=model.type,
name=model.name,
seller_id=model.seller_id,
buyer_id=model.buyer_id,
state=model.state,
good=Good.deserialize(data['good']),
price=model.price,
closed_at=model.closed_at,
commission=model.commission,
group_id=model.group_id)
def get_currencies_info(base_currency, currencies_list):
if base_currency not in currencies_list:
currencies_list.append(base_currency)
resource = urllib2.urlopen(utils_settings.OPEN_EXCHANGE_RATES_API_LATEST_URL + '?app_id=' + utils_settings.OPEN_EXCHANGE_RATES_API_ID)
data = s11n.from_json(resource.read())
resource.close()
currencies = {}
for currency in currencies_list:
currencies[currency] = float(data['rates'][currency]) / data['rates'][base_currency]
return currencies
def from_model(cls, model):
data = s11n.from_json(model.data)
return cls(id=model.id,
created_at=model.created_at,
type=model.type,
name=model.name,
seller_id=model.seller_id,
buyer_id=model.buyer_id,
state=model.state,
good=Good.deserialize(data['good']),
price=model.price,
closed_at=model.closed_at,
commission=model.commission,
group_id=model.group_id)
def refresh(self):
from the_tale.linguistics.lexicon.keys import LEXICON_KEY
self.clear()
for key, data in self._templates_query().iterator():
data = s11n.from_json(data)
template = utg_templates.Template.deserialize(data['template'])
restrictions = frozenset(
tuple(key) for key in data.get('restrictions', ()))
self._item.add_template(LEXICON_KEY(key),
template,
restrictions=restrictions)
self._version = settings.get(self.SETTINGS_KEY)
def test_sync(self):
self.assertEqual(len(self.storage._data), 3)
self.assertNotEqual(self.p1.attrs.size, 7)
place = Place.objects.get(id=self.p1.id)
data = s11n.from_json(place.data)
data['attributes']['size'] = 7
place.data = s11n.to_json(data)
place.save()
self.storage.sync()
self.assertNotEqual(self.storage[self.p1.id].attrs.size, 7)
self.storage.sync(force=True)
self.assertEqual(self.storage[self.p1.id].attrs.size, 7)
def load_cards(account_id):
answer = tt_api.sync_request(
url=conf.settings.TT_STORAGE_GET_ITEMS_URL,
data=storage_pb2.GetItemsRequest(owner_id=account_id),
AnswerType=storage_pb2.GetItemsResponse)
cards = {}
for item in answer.items:
id = uuid.UUID(item.id)
cards[id] = objects.Card.deserialize(uid=id,
data=s11n.from_json(item.data),
storage=relations.STORAGE(
item.storage_id))
return cards
def test_sync(self):
self.assertEqual(len(self.storage._data), 3)
self.assertNotEqual(self.p1.attrs.size, 7)
place = Place.objects.get(id=self.p1.id)
data = s11n.from_json(place.data)
data['attributes']['size'] = 7
place.data = s11n.to_json(data)
place.save()
self.storage.sync()
self.assertNotEqual(self.storage[self.p1.id].attrs.size, 7)
self.storage.sync(force=True)
self.assertEqual(self.storage[self.p1.id].attrs.size, 7)
def load_place(place_id=None, place_model=None):
# TODO: get values instead model
# TODO: check that load_hero everywhere called with correct arguments
try:
if place_id is not None:
place_model = models.Place.objects.get(id=place_id)
elif place_model is None:
return None
except models.Place.DoesNotExist:
return None
data = s11n.from_json(place_model.data)
if 'nearest_cells' in data:
data['nearest_cells'] = list(map(tuple, data['nearest_cells']))
place = objects.Place(id=place_model.id,
x=place_model.x,
y=place_model.y,
created_at_turn=place_model.created_at_turn,
updated_at_turn=place_model.updated_at_turn,
updated_at=place_model.updated_at,
created_at=place_model.created_at,
habit_honor=habits.Honor(raw_value=place_model.habit_honor),
habit_honor_positive=place_model.habit_honor_positive,
habit_honor_negative=place_model.habit_honor_negative,
habit_peacefulness=habits.Peacefulness(raw_value=place_model.habit_peacefulness),
habit_peacefulness_positive=place_model.habit_peacefulness_positive,
habit_peacefulness_negative=place_model.habit_peacefulness_negative,
is_frontier=place_model.is_frontier,
description=place_model.description,
race=place_model.race,
persons_changed_at_turn=place_model.persons_changed_at_turn,
politic_power=PlacePoliticPower.deserialize(data['politic_power']) if 'politic_power'in data else PlacePoliticPower.create(),
utg_name=utg_words.Word.deserialize(data['name']),
attrs=attributes.Attributes.deserialize(data.get('attributes', {})),
races=races.Races.deserialize(data['races']),
nearest_cells=data.get('nearest_cells', []),
effects=EffectsContainer.deserialize(data.get('effects')),
job=PlaceJob.deserialize(data['job']) if 'job' in data else PlaceJob.create(normal_power=NORMAL_PLACE_JOB_POWER),
modifier=place_model.modifier)
place.attrs.sync()
return place
def handle(self, *args, **options):
for artifact in models.ArtifactRecord.objects.all().order_by(
'id').iterator():
print('process artifact {}'.format(artifact.id))
if artifact.id not in WEAPONS:
continue
data = s11n.from_json(artifact.data)
data['weapon_type'] = WEAPONS[artifact.id][0].value
data['material'] = WEAPONS[artifact.id][-1].value
artifact.data = s11n.to_json(data)
artifact.save()
def clean_words(self):
data = self.cleaned_data.get('words')
if data is None:
raise ValidationError(u'Нет данных', code='not_json')
try:
words_data = s11n.from_json(data)
except ValueError:
raise ValidationError(u'Данные должны быть в формате JSON', code='not_json')
try:
words = [utg_words.Word.deserialize(word_data) for word_data in words_data.get('words')]
except:
raise ValidationError(u'Неверный формат описания слов', code='wrong_words_format')
return words
def preferences(self):
from the_tale.game.heroes.preferences import HeroPreferences
preferences = HeroPreferences.deserialize(hero=self, data=s11n.from_json(self._model.preferences))
if preferences.energy_regeneration_type is None:
preferences.set_energy_regeneration_type(self.race.energy_regeneration, change_time=datetime.datetime.fromtimestamp(0))
if preferences.risk_level is None:
preferences.set_risk_level(relations.RISK_LEVEL.NORMAL, change_time=datetime.datetime.fromtimestamp(0))
if preferences.archetype is None:
preferences.set_archetype(game_relations.ARCHETYPE.NEUTRAL, change_time=datetime.datetime.fromtimestamp(0))
if preferences.companion_dedication is None:
preferences.set_companion_dedication(relations.COMPANION_DEDICATION.NORMAL, change_time=datetime.datetime.fromtimestamp(0))
if preferences.companion_empathy is None:
preferences.set_companion_empathy(relations.COMPANION_EMPATHY.ORDINAL, change_time=datetime.datetime.fromtimestamp(0))
return preferences
def test_sync_after_settings_update(self):
self.assertEqual(len(self.storage._data), 3)
self.assertNotEqual(self.p1.attrs.size, 7)
place = Place.objects.get(id=self.p1.id)
data = s11n.from_json(place.data)
data['attributes']['size'] = 7
place.data = s11n.to_json(data)
place.save()
self.storage.sync()
self.assertNotEqual(self.storage[self.p1.id].attrs.size, 7)
settings[self.storage.SETTINGS_KEY] = uuid.uuid4().hex
self.storage.sync()
self.assertEqual(self.storage[self.p1.id].attrs.size, 7)
def test_sync_after_settings_update(self):
self.assertEqual(len(self.storage._data), 3)
self.assertNotEqual(self.p1.attrs.size, 7)
place = Place.objects.get(id=self.p1.id)
data = s11n.from_json(place.data)
data['attributes']['size'] = 7
place.data = s11n.to_json(data)
place.save()
self.storage.sync()
self.assertNotEqual(self.storage[self.p1.id].attrs.size, 7)
settings[self.storage.SETTINGS_KEY] = uuid.uuid4().hex
self.storage.sync()
self.assertEqual(self.storage[self.p1.id].attrs.size, 7)
def load_place(place_id=None, place_model=None):
try:
if place_id is not None:
place_model = models.Place.objects.get(id=place_id)
elif place_model is None:
return None
except models.Place.DoesNotExist:
return None
data = s11n.from_json(place_model.data)
if 'nearest_cells' in data:
data['nearest_cells'] = list(map(tuple, data['nearest_cells']))
place = objects.Place(
id=place_model.id,
x=place_model.x,
y=place_model.y,
created_at_turn=place_model.created_at_turn,
updated_at_turn=place_model.updated_at_turn,
updated_at=place_model.updated_at,
created_at=place_model.created_at,
habit_honor=habits.Honor(raw_value=place_model.habit_honor),
habit_honor_positive=place_model.habit_honor_positive,
habit_honor_negative=place_model.habit_honor_negative,
habit_peacefulness=habits.Peacefulness(
raw_value=place_model.habit_peacefulness),
habit_peacefulness_positive=place_model.habit_peacefulness_positive,
habit_peacefulness_negative=place_model.habit_peacefulness_negative,
is_frontier=place_model.is_frontier,
description=place_model.description,
race=place_model.race,
persons_changed_at_turn=place_model.persons_changed_at_turn,
utg_name=utg_words.Word.deserialize(data['name']),
attrs=attributes.Attributes.deserialize(data.get('attributes', {})),
races=races.Races.deserialize(data['races']),
nearest_cells=data.get('nearest_cells', []),
effects=EffectsContainer.deserialize(data.get('effects')),
job=PlaceJob.deserialize(data['job']),
modifier=place_model.modifier)
place.attrs.sync()
return place
def load_building(building_id=None, building_model=None):
try:
if building_id is not None:
building_model = models.Building.objects.get(id=building_id)
elif building_model is None:
return None
except models.Building.DoesNotExist:
return None
data = s11n.from_json(building_model.data)
building = objects.Building(id=building_model.id,
x=building_model.x,
y=building_model.y,
created_at_turn=building_model.created_at_turn,
utg_name=utg_words.Word.deserialize(data['name']),
type=building_model.type,
integrity=building_model.integrity,
state=building_model.state,
person_id=building_model.person_id)
return building
def test_full__reject(self):
api_client = Client()
request_token_url = url('accounts:third-party:tokens:request-authorisation', api_version='1.0', api_client=project_settings.API_CLIENT)
response = api_client.post(request_token_url, {'application_name': 'app-name',
'application_info': 'app-info',
'application_description': 'app-descr'})
self.check_ajax_ok(response)
token_url = s11n.from_json(response.content)['data']['authorisation_page']
token = prototypes.AccessTokenPrototype._db_latest()
self.assertEqual(url('accounts:third-party:tokens:show', token.uid), token_url)
self.check_html_ok(self.request_html(token_url), texts=['app-name', 'app-info', 'app-descr'])
authorisation_state_url = url('accounts:third-party:tokens:authorisation-state', api_version='1.0', api_client=project_settings.API_CLIENT)
self.check_ajax_ok(api_client.get(authorisation_state_url),
data={'account_id': None,
'account_name': None,
'state': relations.AUTHORISATION_STATE.UNPROCESSED.value,
'session_expire_at': 666.6})
token.remove()
self.check_ajax_ok(api_client.get(authorisation_state_url),
data={'account_id': None,
'account_name': None,
'state': relations.AUTHORISATION_STATE.REJECTED.value,
'session_expire_at': 666.6})
def test_logined(self):
response = self.client.get(self.game_info_url_1)
self.assertEqual(response.status_code, 200)
self.assertEqual(set(s11n.from_json(response.content)['data'].keys()), set(('turn', 'mode', 'map_version', 'account', 'enemy', 'game_state')))
def load_hero(hero_id=None, account_id=None, hero_model=None):
# TODO: get values instead model
# TODO: check that load_hero everywhere called with correct arguments
try:
if hero_id is not None:
hero_model = models.Hero.objects.get(id=hero_id)
elif account_id is not None:
hero_model = models.Hero.objects.get(account_id=account_id)
elif hero_model is None:
return None
except models.Hero.DoesNotExist:
return None
if isinstance(hero_model.data, str):
data = s11n.from_json(hero_model.data)
else:
data = hero_model.data
companion_data = data.get('companion')
companion = companions_objects.Companion.deserialize(companion_data) if companion_data else None
return objects.Hero(id=hero_model.id,
account_id=hero_model.account_id,
health=hero_model.health,
level=hero_model.level,
experience=hero_model.experience,
energy=hero_model.energy,
energy_bonus=hero_model.energy_bonus,
money=hero_model.money,
next_spending=hero_model.next_spending,
habit_honor=habits.Honor(raw_value=hero_model.habit_honor),
habit_peacefulness=habits.Peacefulness(raw_value=hero_model.habit_peacefulness),
position=hero_position_from_model(hero_model),
statistics=hero_statistics_from_model(hero_model),
preferences=preferences.HeroPreferences.deserialize(data=s11n.from_json(hero_model.preferences)),
actions=actions_container.ActionsContainer.deserialize(s11n.from_json(hero_model.actions)),
companion=companion,
journal=messages.JournalContainer(), # we are not storrings journal in database, since messages in it replaced very fast
quests=quests_container.QuestsContainer.deserialize(data.get('quests', {})),
places_history=places_help_statistics.PlacesHelpStatistics.deserialize(data['places_history']),
cards=cards_container.CardsContainer.deserialize(s11n.from_json(hero_model.cards)),
abilities=habilities.AbilitiesPrototype.deserialize(s11n.from_json(hero_model.abilities)),
bag=bag.Bag.deserialize(data['bag']),
equipment=bag.Equipment.deserialize(data['equipment']),
created_at_turn=hero_model.created_at_turn,
saved_at_turn=hero_model.saved_at_turn,
saved_at=hero_model.saved_at,
is_bot=hero_model.is_bot,
is_alive=hero_model.is_alive,
is_fast=hero_model.is_fast,
gender=hero_model.gender,
race=hero_model.race,
last_energy_regeneration_at_turn=hero_model.last_energy_regeneration_at_turn,
might=hero_model.might,
ui_caching_started_at=hero_model.ui_caching_started_at,
active_state_end_at=hero_model.active_state_end_at,
premium_state_end_at=hero_model.premium_state_end_at,
ban_state_end_at=hero_model.ban_state_end_at,
last_rare_operation_at_turn=hero_model.last_rare_operation_at_turn,
settings_approved=hero_model.settings_approved,
actual_bills=data['actual_bills'],
utg_name=utg_words.Word.deserialize(data['name']))
def data(self): return s11n.from_json(self._model.data)
@property
def hero_2_context(self):
if not hasattr(self, '_hero_2_context'):
self._hero_2_context = contexts.BattleContext.deserialize(s11n.from_json(self.members_by_roles[self.ROLES.HERO_2].context))
self._hero_2_context.use_pvp_advantage_stike_damage(self.hero_2.basic_damage * c.DAMAGE_PVP_FULL_ADVANTAGE_STRIKE_MODIFIER)
return self._hero_2_context
def data(self):
from the_tale.game.bills.bills import deserialize_bill
if not hasattr(self, '_data'):
self._data = deserialize_bill(s11n.from_json(self._model.technical_data))
return self._data
