def _item_contains_term(item, search_term):
s = get_structure()
or_items = s.get_or_items()
if item.name in or_items:
item = s.get_or_item_by_name(item.name)[0]
item_name = ''
if get_supported_language() in item.localized_names:
item_name = item.accentless_local_names[get_supported_language()].lower()
else:
item_name = item.name.lower()
return search_term in re.sub(r'\W+', '', item_name)
def _order_items(item_type, char, search_term):
structure = get_structure()
items = structure.get_unique_items_by_type_and_level(item_type, char.level)
search_term = search_term.lower()
search_term = strip_accents(search_term)
if search_term is not None:
items = filter(lambda i: _item_contains_term(i, re.sub(r'\W+', '', search_term)),
items)
items = filter(lambda i: _hide_removed_item(i), items)
weights = pickle.loads(char.stats_weight)
sorted_items = sorted(items, key=lambda item: _rate(structure, item, weights), reverse=True)
return sorted_items
def get_item_stats(request):
item_id = request.POST.get('itemId', None)
if item_id == '':
return HttpResponseJson(None)
structure = get_structure()
item = structure.get_item_by_id(int(item_id))
result_item = ModelResultItem(item)
evolve_result_item(result_item)
json_response = jsonpickle.encode(result_item, unpicklable=False)
return HttpResponseJson(json_response)
def edit_item(request, item_id=None):
structure = get_structure()
types_list = structure.get_types_list()
return set_response(
request, 'chardata/edit_item.html', {
'types': sorted(types_list),
'stats_order': json.dumps(structure.get_stats_list_names_sorted()),
'item_id': json.dumps(item_id),
'non_en_languages': NON_EN_LANGUAGES,
'languages': LANGUAGES
})
def _order_by_hits(item_type, char, search_term):
structure = get_structure()
items = structure.get_unique_items_by_type_and_level(item_type, char.level)
search_term = search_term.lower()
search_term = strip_accents(search_term)
if search_term is not None and search_term is not '':
items = filter(lambda i: _item_contains_term(i, re.sub(r'\W+', '', search_term)),
items)
items = filter(lambda i: _hide_removed_item(i), items)
solution = get_solution(char)
sorted_items = sorted(items, key=lambda item: _get_weapon_rate(item, char, solution), reverse=True)
#print sorted_items[:5]
return sorted_items
def edit_item_search_sets(request):
name_piece = request.POST.get('name[term]', None)
set_list = []
if name_piece:
name_piece = name_piece.lower()
structure = get_structure()
sets = structure.get_sets_list() + structure.get_sets_list(True)
for s in sets:
if name_piece in s.name.lower():
set_list.append('[DT] %d %s' %
(s.id, s.name) if s.dofus_touch else '%d %s' %
(s.id, s.name))
return HttpResponseJson(json.dumps(set_list))
def get_stats_weights(char):
weights = {}
if char.stats_weight:
weights = pickle.loads(char.stats_weight)
# Fill in 0 for all stats that exist but have no weight, or a default value
# from smart_build if it's in STATS_TO_FILL_DEFAULT.
stats_to_calculate = []
changed = False
for stat in get_structure().get_stats_list():
if stat.key not in weights:
if stat.key in STATS_TO_FILL_DEFAULT:
stats_to_calculate.append(stat.key)
else:
changed = True
weights[stat.key] = 0
# Call smart_build if necessary
if stats_to_calculate:
changed = True
stan_w = get_standard_weights(char)
for stat_key in stats_to_calculate:
weights[stat_key] = stan_w[stat_key]
# Filter out all non-existent stats.
for stat_key in weights.keys():
if stat_key in DEPRECATED_STATS:
changed = True
del weights[stat_key]
elif stat_key not in get_structure().get_stats_list(
) and stat_key != 'meleeness':
assert stat_key in STAT_KEY_TO_NAME, '%s is not a stat' % stat_key
# Save if anything was changed
if changed:
set_stats_weights(char, weights)
return weights
def switch_item(request, char_id):
char = get_char_or_raise(request, char_id)
item_name = request.POST.get('itemName', None)
slot = request.POST.get('slot', None)
assert slot in SLOTS
structure = get_structure()
result = get_solution(char)
result.switch_item(structure.get_item_by_id(int(item_name)), slot)
set_solution(char, result)
remove_cache_for_char(char_id)
return HttpResponseText('ok')
def choose_set(request):
structure = get_structure()
set_stats = {}
set_id = safe_int(request.POST.get('id', None))
set_reference = request.POST.get('name', None)
set_reference = set_reference.split(' ', 1)
if set_id == None:
set_id = safe_int(set_reference[0])
set_name = set_reference[1]
s = None
if set_id:
s = structure.get_set_by_id(set_id)
if not s and set_name:
s = structure.get_set_by_name(set_name)
if not s:
return HttpResponseJson(json.dumps(set_stats))
set_stats['name'] = s.name
set_stats['id'] = s.id
set_stats['ankama_id'] = s.ankama_id
for lang in NON_EN_LANGUAGES:
set_stats['translated_name_%s' % lang] = s.localized_names.get(
lang, '')
stats_per_num_items = {}
for num_items in range(2, 8 + 1):
for stat, value in s.bonus_per_num_items.get(num_items,
{}).iteritems():
stats_per_num_items.setdefault(STAT_KEY_TO_NAME[stat],
{})[num_items] = value
stats = []
for stat_name in sorted(
stats_per_num_items,
key=lambda stat: STAT_ORDER[structure.get_stat_by_name(stat).key]):
stats.append((stat_name, stats_per_num_items[stat_name]))
set_stats['stats'] = stats
items = []
for item_id in s.items:
item = structure.get_item_by_id(item_id)
item_name = item.name
items.append({'name': item_name, 'id': item_id})
result = {'set': set_stats, 'items': items}
return HttpResponseJson(json.dumps(result))
def _get_weapon_rate(weapon, char, result):
structure = get_structure()
result_item = result.switch_item(weapon, 'weapon')
new_stats = result.stats_total.copy()
weapon_obj = structure.get_weapon_by_name(weapon.name)
if result_item.is_mageable:
result_item.mage_weapon_smartly(new_stats)
element = result_item.element_maged
else:
element = NEUTRAL
calculated_damage = {}
for elementnew in DAMAGE_TYPES:
calculated_damage[elementnew] = calculate_damage(weapon_obj.non_crit_hits[element],
new_stats, critical_hit=False, is_spell=False)
total_damage = 0
for damage in calculated_damage[element]:
if damage.heals:
total_damage -= (damage.min_dam + damage.max_dam)/2
else:
total_damage += (damage.min_dam + damage.max_dam)/2
rating_non_crit = total_damage / float(weapon_obj.ap)
if weapon_obj.has_crits:
calculated_crit_damage = {}
for elementnew in DAMAGE_TYPES:
calculated_crit_damage[elementnew] = calculate_damage(weapon_obj.crit_hits[element],
new_stats, critical_hit=True, is_spell=False)
total_damage = 0
for damage in calculated_crit_damage[element]:
if damage.heals:
total_damage -= (damage.min_dam + damage.max_dam)/2
else:
total_damage += (damage.min_dam + damage.max_dam)/2
rating_crit = total_damage / float(weapon_obj.ap)
crits_total = new_stats['ch']
if weapon_obj.crit_chance_percent:
crits_total += weapon_obj.crit_chance_percent
if weapon_obj.has_crits:
rating = (rating_non_crit * (100 - crits_total) + rating_crit * crits_total)/100
else:
rating = rating_non_crit
return rating if rating > 0 else -rating
def get_item_details(request):
item_id = request.POST.get('item', None)
info = {}
if item_id is not None:
structure = get_structure()
item = structure.get_item_by_id(int(item_id))
info['level'] = item.level
info['file'] = static(
get_image_url(structure.get_type_name_by_id(item.type), item.name))
json_response = jsonpickle.encode(info, unpicklable=False)
return HttpResponseJson(json_response)
def edit_item_search_item(request):
name_piece = request.POST.get('name[term]', None)
item_list = []
if name_piece:
name_piece = name_piece.lower()
structure = get_structure()
items = structure.get_concatenated_items_lists()
for item in items:
if name_piece in item.name.lower():
item_list.append('[DT] %d %s' %
(item.id,
item.name) if item.dofus_touch else '%d %s' %
(item.id, item.name))
return HttpResponseJson(json.dumps(item_list))
def update_item_post(request):
item = json.loads(request.POST.get('item', None))
if item == None:
return HttpResponseText('not ok')
item_id = safe_int(item['id'])
if item_id:
new_item, new_weapon = _convert_json_item_to_item(item)
old_item = get_structure().get_item_by_id(item_id)
update_item(old_item, new_item, new_weapon, True)
return HttpResponseText('ok')
else:
_insert_item(item)
return HttpResponseText('ok')
def min_stats_post(request, char_id):
char = get_char_or_raise(request, char_id)
structure = get_structure()
minimum_values = {}
for stat in get_structure().get_stats_list():
minimum = safe_int(request.POST.get('min_%s' % stat.key, ''))
if minimum is not None:
minimum_values[stat.name] = minimum
minimum = safe_int(request.POST.get('min_hp'))
if minimum is not None:
minimum_values['HP'] = minimum
adv_stats = structure.get_adv_mins()
minimum_values['adv_mins'] = {}
for stat in adv_stats:
minimum = safe_int(request.POST.get('min_%s' % stat['key'], ''))
if minimum is not None:
minimum_values['adv_mins'][stat['name']] = minimum
set_min_stats(char, minimum_values)
return HttpResponseJson(json.dumps(_get_initial_data(char)))
def store_set_data(item_id, ankama_id, set_data):
if 'removed' in set_data:
return
else:
new_set = _convert_json_item_to_item(set_data)
old_set = get_structure().get_set_by_id(item_id)
print 'Checking %s' % new_set.name
new_set.items = old_set.items
for lang in NON_EN_LANGUAGES:
new_set.localized_names[lang] = old_set.localized_names.get(lang)
update_set(item_id, new_set, False)
def inclusions(request, char_id):
char = get_char_or_raise(request, char_id)
structure = get_structure()
types_list = structure.get_types_list()
items_by_type = {}
items_by_type_and_name = {}
for item_type in types_list:
items_by_type[item_type] = {}
items_by_type_and_name[item_type] = {}
for item_type in items_by_type:
for item in structure.get_unique_items_by_type_and_level(
item_type, char.level):
item_name = structure.get_item_name_in_language(
item, get_supported_language())
items_by_type[item_type][item.id] = item_name
items_by_type_and_name[item_type][item_name] = item.id
images_urls = {}
for item_slot in SLOT_NAME_TO_TYPE:
images_urls[item_slot] = static('chardata/%s.png' %
SLOT_NAME_TO_TYPE[item_slot])
inclusions = get_inclusions_dict(char)
for slot in SLOTS:
inclusions.setdefault(slot, '')
return set_response(
request, 'chardata/inclusions.html', {
'char_id':
char_id,
'advanced':
True,
'types':
items_by_type,
'types_json':
jsonpickle.encode(items_by_type, unpicklable=False),
'names_and_types_json':
jsonpickle.encode(items_by_type_and_name, unpicklable=False),
'inclusions_json':
json.dumps(inclusions),
'images_json':
json.dumps(images_urls),
'slot_to_type_json':
json.dumps(SLOT_NAME_TO_TYPE),
'ajax_loader':
json.dumps(get_ajax_loader_URL(request))
}, char)
def set_exclusions_list_by_name(char, excluded_items):
s = get_structure()
items = []
for item_name in excluded_items:
item = s.get_item_by_name(item_name)
if item is None:
item = s.get_or_item_by_name(item_name)[0]
if item is not None:
item_id = item.id
items.append(item_id)
else:
print 'Item %s does not exist and cannot be excluded' % item_name
set_exclusions_list_and_check_inclusions(char, items)
def min_stats(request, char_id):
char = get_char_or_raise(request, char_id)
initial_data = _get_initial_data(char)
structure = get_structure()
stats = []
for stat in structure.get_stats_list():
stat_to_add = {}
stat_to_add['key'] = stat.key
stat_to_add['name'] = _(stat.name)
stats.append(stat_to_add)
stats = [
stat
for stat in sorted(stats, key=lambda stat: STAT_ORDER[stat['key']])
]
fixed_fields = []
ap = {}
ap['key'] = 'ap'
ap['name'] = _('AP')
fixed_fields.append(ap)
mp = {}
mp['key'] = 'mp'
mp['name'] = _('MP')
fixed_fields.append(mp)
rangestat = {}
rangestat['key'] = 'range'
rangestat['name'] = _('Range')
fixed_fields.append(rangestat)
adv_min_fields = structure.get_adv_mins()
return set_response(
request, 'chardata/min_stats.html', {
'advanced': True,
'char_id': char_id,
'stats_order': json.dumps(stats),
'stats_fixed': json.dumps(fixed_fields),
'stats_adv': json.dumps(adv_min_fields),
'initial_data': json.dumps(initial_data),
'crit_targets': CRIT_TARGETS,
'agility_targets': AGI_TARGETS
}, char)
def store_set_data(set_ID, ankama_id, set_data):
if 'removed' in set_data:
return
else:
new_set = _convert_json_item_to_item(set_data)
old_set = get_structure().get_set_by_name(new_set.name, True)
print 'Checking %s' % new_set.name
if old_set:
for lang in NON_EN_LANGUAGES:
new_set.localized_names[lang] = old_set.localized_names.get(
lang)
set_id = update_set(set_ID, new_set, False)
invalidate_structure()
for item in new_set.items:
store_item_set(item, set_id)
def __init__(self, char, slots):
structure = get_structure()
self.items_by_type = {}
self.items_by_type_and_name = {}
for slot in slots:
item_type = SLOT_NAME_TO_TYPE[slot]
self.items_by_type[item_type] = {}
self.items_by_type_and_name[item_type] = {}
for item in structure.get_unique_items_by_type_and_level(
item_type, char.level):
item_name = structure.get_item_name_in_language(
item, get_supported_language())
self.items_by_type[item_type][item.id] = item_name
self.items_by_type_and_name[item_type][item_name] = item.id
self.images_urls = {}
self.images_urls[slot] = static('chardata/' + item_type + '.png')
self.slot_to_type = SLOT_NAME_TO_TYPE
def store_weapon_data(item_id, weapon_name, weapon_data):
if item_id:
if 'removed' in weapon_data:
fake_delete_item(item_id, True)
else:
new_item, new_weapon = _convert_json_item_to_item(weapon_data)
old_item = get_structure().get_item_by_id(item_id)
if old_item.name == 'Gelano (#1)':
return
print 'Checking %s' % new_item.name
if '(' in old_item.name:
new_item.name = old_item.name
new_item.ankama_type = old_item.ankama_type
new_item.set = old_item.set
new_item.type = old_item.type
for wc in WEIRD_CONDITIONS:
new_item.weird_conditions[wc] = old_item.weird_conditions[wc]
new_item.min_stats_to_equip = old_item.min_stats_to_equip
new_item.max_stats_to_equip = old_item.max_stats_to_equip
for lang in NON_EN_LANGUAGES:
new_item.localized_names[lang] = old_item.localized_names.get(
lang)
new_item.localized_extras = old_item.localized_extras
#new_item.is_one_handed = old_item.is_one_handed
update_item(old_item, new_item, new_weapon, False)
else:
new_item, new_weapon = _convert_json_item_to_item(weapon_data)
if new_item:
print 'Adding %s' % new_item.name
insert_item(new_item, new_weapon)
else:
print 'Could not insert item'
def get_items_of_type(request, char_id):
char = get_char_or_raise(request, char_id)
page = int(request.POST.get('page', None))
search_term = request.POST.get('search_term', None)
slot = request.POST.get('slot', None)
itype = SLOT_NAME_TO_TYPE[slot]
structure = get_structure()
cache_key = ('%s-%s-%s' % (char_id, structure.get_type_id_by_name(itype), search_term))
cache_key = re.sub(r"\s+", '_', cache_key)
items = cache.get(cache_key)
if items == None:
items = _order_items(itype, char, search_term)
cache.set(cache_key, items, 300)
max_page = math.ceil(len(items) / 10.0)
items_to_return = items[(page - 1) * 10 : page * 10]
itemResults = []
for item in items_to_return:
if item.name in structure.or_items:
for or_item in structure.get_or_item_by_name(item.name):
result_item = ModelResultItem(or_item)
evolve_result_item(result_item)
itemResults.append(result_item)
else:
result_item = ModelResultItem(item)
evolve_result_item(result_item)
itemResults.append(result_item)
response = {'items': itemResults,
'violations': None,
'page': page,
'max_page': max_page,
'differences': None}
json_response = jsonpickle.encode(response, unpicklable=False)
return HttpResponseJson(json_response)
def options_post(request, char_id):
char = get_char_or_raise(request, char_id)
options = parse_options_post(request)
set_options(char, options)
too_high = get_dofus_not_for_char(char)
forbidden_dofus = []
allowed_dofus = []
for (red, item) in DOFUS_OPTIONS.iteritems():
if red not in too_high:
forbidden = request.POST.get(red) is None
structure = get_structure()
item_id = structure.get_item_by_name(item).id
if forbidden:
forbidden_dofus.append(int(item_id))
else:
allowed_dofus.append(int(item_id))
add_items_to_exclusions(char, forbidden_dofus)
remove_items_from_exclusions(char, allowed_dofus)
return HttpResponseJson(json.dumps(get_options(char)))
def wizard_post(request, char_id):
char = get_char_or_raise(request, char_id)
minimum_values = get_min_stats(char)
for stat_name in STATS_WITH_CONFIG_MINS:
minimum = safe_int(request.POST.get('min_%s' % stat_name, ''))
minimum_values[stat_name] = minimum
set_min_stats(char, minimum_values)
weapon_to_lock = request.POST.get('weapon', None)
if weapon_to_lock:
set_item_included(char, weapon_to_lock, 'weapon', True)
else:
inclusions = get_inclusions_dict(char)
weapon = inclusions.get('weapon')
if weapon:
set_item_included(char, weapon, 'weapon', False)
options = get_options(char)
options.update(parse_options_post(request))
set_options(char, options)
for (red, item) in DOFUS_OPTIONS.iteritems():
forbidden = request.POST.get(red) is None
s = get_structure()
item_id = s.get_item_by_name(item).id
set_excluded(char, item_id, forbidden)
set_wizard_sliders(char, request.POST)
scroll = request.POST.get('scrolling', 'leave')
if scroll == 'fully':
_full_scroll_char(char)
elif scroll == 'clean':
_clean_scroll_char(char)
return HttpResponseRedirect(
reverse('chardata.fashion_action.fashion', args=(char.id, )))
def set_item_forbidden(request, char_id):
char = get_char_or_raise(request, char_id)
slot = request.POST.get('slot', None)
item_name = request.POST.get('equip', None)
forbidden = request.POST.get('forbidden', None)
structure = get_structure()
item = structure.get_item_by_name(item_name)
if item is None:
or_item = structure.get_or_item_by_name(item_name)
item_id = or_item[0].id
else:
item_id = structure.get_item_by_name(item_name).id
if forbidden == 'true':
set_excluded(char, item_id, True)
elif forbidden == 'false':
set_excluded(char, item_id, False)
return HttpResponseText('char_id %s, slot %s, equip %s, forbidden %s'
% (char_id, slot, item_name, str(forbidden)))
def store_weapon_data(item_id, weapon_name, weapon_data):
s = get_structure()
if 'removed' in weapon_data:
delete_item(item_id)
else:
new_item = Item()
old_item = s.get_item_by_id(item_id)
new_item.id = old_item.id
new_item.name = old_item.name
new_item.or_name = old_item.or_name
new_item.type = old_item.type
new_item.level = old_item.level
new_item.set = old_item.set
new_item.ankama_id = old_item.ankama_id
new_item.ankama_type = old_item.ankama_type
new_item.stats = old_item.stats
new_item.min_stats_to_equip = old_item.min_stats_to_equip
new_item.max_stats_to_equip = old_item.max_stats_to_equip
for lang in NON_EN_LANGUAGES:
new_item.localized_names[lang] = old_item.localized_names.get(lang)
for lang in NON_EN_LANGUAGES:
new_item.localized_extras[lang] = old_item.localized_extras.get(lang)
new_item.localized_extras['en'] = old_item.localized_extras.get('en')
for wc in WEIRD_CONDITIONS:
new_item.weird_conditions[wc] = old_item.weird_conditions[wc]
new_item = _convert_json_item_to_item(weapon_data, new_item, s)
if '(' in old_item.name:
new_item.name = old_item.name
print 'Checking %s' % new_item.name
update_item(old_item, new_item, None, False)
def store_item_set(item_name, set_id):
s = get_structure()
item = s.get_item_by_name(item_name, True)
if not item:
filetomod = open('MissingItemsInSets.txt', 'a')
name_to_print = item_name + '\n'
filetomod.write(name_to_print.encode('utf-8'))
filetomod.close()
return
new_item = Item()
new_item.id = item.id
new_item.name = item.name
new_item.or_name = item.or_name
new_item.type = item.type
new_item.level = item.level
new_item.set = set_id
new_item.ankama_id = item.ankama_id
new_item.ankama_type = item.ankama_type
new_item.is_one_handed = item.is_one_handed
new_item.stats = item.stats
new_item.min_stats_to_equip = item.min_stats_to_equip
new_item.max_stats_to_equip = item.max_stats_to_equip
new_item.localized_extras = item.localized_extras
new_item.localized_names = item.localized_names
new_item.accentless_local_names = item.accentless_local_names
new_item.weird_conditions = item.weird_conditions
new_item.removed = item.removed
new_item.dofus_touch = item.dofus_touch
weapon = s.get_weapon_by_name(item_name, True)
update_item(item, new_item, weapon, False)
def set_item_locked(request, char_id):
char = get_char_or_raise(request, char_id)
slot = request.POST.get('slot', None)
item_name = request.POST.get('equip', None)
locked = request.POST.get('locked', None)
assert slot in SLOTS
structure = get_structure()
item = structure.get_item_by_name(item_name)
if item is None:
or_item = structure.get_or_item_by_name(item_name)
item_id = or_item[0].id
else:
item_id = structure.get_item_by_name(item_name).id
if locked == 'true':
set_item_included(char, item_id, slot, True)
elif locked == 'false':
set_item_included(char, item_id, slot, False)
return HttpResponseText('char_id %s, slot %s, equip %s, locked %s'
% (char_id, slot, item_name, str(locked)))
def _convert_json_item_to_item(json_item):
structure = get_structure()
item = Item()
item.name = json_item['name']
item.ankama_id = json_item['ankama_id']
item.ankama_type = json_item['ankama_type']
item.level = json_item['level']
item.removed = json_item['removed']
item.dofus_touch = json_item['dofus_touch']
item.type = structure.get_type_id_by_name(json_item['type'])
if json_item['set']:
item_set = json_item['set']
if '[DT]' in item_set:
set_reference = item_set.split(' ', 2)
item.set = safe_int(set_reference[1])
else:
item.set = structure.get_set_id_by_name(item_set)
item.weird_conditions = json_item['weird_conditions']
for stat in json_item['stats']:
if stat['stat'] == '' or stat['stat'] == None:
continue
_add_to_old_stat(item,
structure.get_stat_by_name(stat['stat']).id,
int(stat['value']))
for cond in json_item['conditions']:
if cond['stat'] == '' or cond['stat'] == None:
continue
new_value = (int(cond['value']) -
1 if cond['min_max'] == '<' else int(cond['value']) + 1)
_add_to_old_cond(item,
structure.get_stat_by_name(cond['stat']).id,
cond['min_max'] == '>', new_value)
for lang, extras in json_item['extras'].iteritems():
for extra in extras:
if extra == '':
continue
_add_to_old_extra(item, lang, extra)
for lang in NON_EN_LANGUAGES:
name_translated = json_item['translated_name_%s' % lang]
if not name_translated.startswith('[!]'):
item.localized_names[lang] = name_translated
weapon = None
if json_item['type'] == 'Weapon':
weapon = Weapon()
weapon.ap = int(json_item['ap'])
weapon.crit_chance = int(json_item['crit_chance'])
weapon.crit_bonus = int(json_item['crit_bonus'])
# item.is_one_handed = json_item['one_handed']
weapon.weapon_type = structure.get_weapon_type_by_name(
json_item['weapon_type']).id
for hit in json_item['hits']:
if hit['min_hit'] == '':
continue
index = int(hit['index'])
weapon.hits_dict[index] = DamageDigest(
int(hit['min_hit']), int(hit['max_hit']),
ELEMENT_NAME_TO_KEY[hit['stat']], hit['steals'], hit['heals'])
return item, weapon
def choose_item(request):
structure = get_structure()
item_id = safe_int(request.POST.get('id', None))
item_reference = request.POST.get('name', None)
item_name = None
if item_reference:
if '[DT]' in item_reference:
item_reference = item_reference.split(' ', 2)
if item_id == None:
item_id = safe_int(item_reference[1])
item_name = item_reference[2]
dofus_touch = True
else:
item_reference = item_reference.split(' ', 1)
if item_id == None:
item_id = safe_int(item_reference[0])
item_name = item_reference[1]
dofus_touch = False
item = None
if item_id:
item = structure.get_item_by_id(item_id)
dofus_touch = item.dofus_touch
if not item and item_name:
item = structure.get_item_by_name(item_name, dofus_touch)
if not item:
return HttpResponseJson(json.dumps({}))
item_stats = {}
item_stats['name'] = item.name
item_stats['id'] = item.id
item_stats['ankama_id'] = item.ankama_id
item_stats['ankama_type'] = item.ankama_type
item_stats['level'] = item.level
item_stats['type'] = structure.get_type_name_by_id(item.type)
item_stats['removed'] = item.removed
item_stats['dofus_touch'] = item.dofus_touch
if item.set:
item_stats['set'] = structure.get_set_by_id(item.set).name
item_stats['weird_conditions'] = item.weird_conditions
stats = []
for stat, value in sorted(item.stats,
key=lambda stats: STAT_ORDER[
structure.get_stat_by_id(stats[0]).key]):
stats.append((structure.get_stat_by_id(stat).name, value))
item_stats['stats'] = stats
conditions = {}
if item.min_stats_to_equip:
for stat, value in item.min_stats_to_equip:
conditions[structure.get_stat_by_id(stat).name] = ('>', value - 1)
if item.max_stats_to_equip:
for stat, value in item.max_stats_to_equip:
conditions[structure.get_stat_by_id(stat).name] = ('<', value + 1)
item_stats['conditions'] = conditions
item_stats['extras'] = {
lang: item.localized_extras.get(lang, [])
for lang in LANGUAGES
}
if item_stats['type'] == 'Weapon':
weapon = structure.get_weapon_by_name(item.name, dofus_touch)
# item_stats['one_handed'] = item.is_one_handed
item_stats['ap'] = weapon.ap
item_stats['crit_chance'] = weapon.crit_chance
item_stats['crit_bonus'] = weapon.crit_bonus
item_stats['weapon_type'] = structure.get_weapon_type_by_id(
weapon.weapon_type).name
hits = {}
for key, value in weapon.hits_dict.iteritems():
hits[key] = (value.min_dam, value.max_dam,
ELEMENT_KEY_TO_NAME[value.element], value.steals,
value.heals)
item_stats['hits'] = hits
for lang in NON_EN_LANGUAGES:
item_stats['translated_name_%s' % lang] = item.localized_names.get(
lang, '')
or_items = []
# Handle artificial items(Gelano, Turquoise Dofus)
for alt_item in structure.get_items_by_or_name(item.or_name, dofus_touch):
if alt_item.id != item.id:
or_items.append({'id': alt_item.id, 'name': alt_item.name})
result = {'item': item_stats, 'or_items': or_items}
return HttpResponseJson(json.dumps(result))
