def _page(request, char_id, is_new_char):
char = get_char_or_raise(request, char_id)
stats = _get_stats(char)
stats['distrib'] = char.allow_points_distribution
lower_soft_caps = {}
for stat, lis in SOFT_CAPS[char.char_class].iteritems():
new_list = []
for entry in lis:
if entry is not None:
new_list.append(entry + 1)
else:
new_list.append(None)
lower_soft_caps[stat] = new_list
return set_response(
request, 'chardata/chardata.html', {
'char_id': char_id,
'is_new_char': json.dumps(is_new_char),
'stats_json': json.dumps(stats),
'advanced': True,
'soft_caps': SOFT_CAPS[char.char_class],
'lower_soft_caps': lower_soft_caps,
'theme': get_theme(request)
}, char)
def _solution(request, char_id, is_guest, encoded_char_id=None):
char = get_object_or_404(Char, pk=char_id)
inclusions = get_all_inclusions_en_names(char)
exclusions = get_all_exclusions_en_names(char)
solution = get_solution(char)
solution_result = SolutionResult(solution,
inclusions,
exclusions)
params = {'char_id': char_id,
'lock_item': static('chardata/lock-icon.png'),
'switch_item': static('chardata/1412645636_Left-right.png'),
'delete_item': static('chardata/delete-icon.png'),
'add_item': static('chardata/add-icon.png'),
'ajax_loader': json.dumps(get_ajax_loader_URL(request)),
'link_external_image': json.dumps(get_external_image_URL(request)),
'is_guest': is_guest,
'is_guest_json': json.dumps(is_guest),
'encoded_char_id': encoded_char_id,
'link_shared': char.link_shared,
'owner_alias': get_alias(char.owner),
'is_dueler': chardata.smart_build.char_has_aspect(char, 'duel')}
if char.link_shared:
params['initial_link'] = generate_link(char)
params.update(solution_result.get_params())
response = set_response(request,
'chardata/solution.html',
params,
char)
return response
def _recover_password_page(request, email, from_register):
non_social_users = _get_non_social_users_for_email(email)
if not non_social_users:
raise SuspiciousOperation
username = non_social_users[0].username
password = non_social_users[0].password
link = request.build_absolute_uri(
reverse('chardata.login_view.recover_password',
args=(username,
_generate_token_for_password_reset(username, password))))
try:
send_mail(
_('Password change requested for The Dofus Fashionista'),
_('A password reset has been requested for The Dofus Fashionista!\n'
'Please click the link below to generate a new one for your account.\n'
'{link}\n\n'
'If you don\'t want to reset your password, just ignore this email.'
).format(link=link), '*****@*****.**', [email])
except (BadHeaderError, SMTPRecipientsRefused) as e:
raise e
return set_response(request, 'chardata/recover_password.html', {
'request': request,
'email': email,
'from_register': from_register
})
def _spells(request, char, is_guest, char_id, encoded_char_id=None):
char_class = char.char_class
solution = get_solution(char)
if solution is None:
return fashion(request, char_id, True)
digests = []
weapons = solution.items['Weapon']
if len(weapons) > 0:
weapon = weapons[0]
if weapon.item_added:
web_digest = _create_weapon_web_digest(weapon)
digests.append(web_digest)
for spell in DAMAGE_SPELLS[char_class] + DAMAGE_SPELLS['default']:
web_digest = _create_spell_web_digest(spell)
digests.append(web_digest)
digests_json = jsonpickle.encode(digests, unpicklable=False)
stats_json = jsonpickle.encode(solution.get_stats_total(), unpicklable=False)
return set_response(request,
'chardata/spells.html',
{'request': request,
'is_guest': is_guest,
'encoded_char_id': encoded_char_id,
'user': request.user,
'digests_json': digests_json,
'char_id': char_id,
'char_level': char.level,
'char_stats_json': stats_json},
char)
def exclusions(request, char_id):
char = get_char_or_raise(request, char_id)
s = get_structure()
language = get_supported_language()
sets_names = s.get_set_names(language)
sets_names_dicts = {set_name: None for set_name in sets_names}
all_items = s.get_all_unique_items_ids_with_type()
all_items_names = s.get_all_unique_items_names_with_ids(language)
all_names = sets_names_dicts.copy()
all_names.update(all_items_names)
complete_sets = s.get_complete_sets_list(language)
exclusions = get_all_exclusions_with_names(char, language)
return set_response(
request, 'chardata/exclusions.html', {
'char_id': char_id,
'advanced': True,
'type_columns': TYPE_COLUMNS,
'all_items_json': json.dumps(all_items),
'all_items_names_json': json.dumps(all_names),
'sets_with_items_json': json.dumps(complete_sets),
'exclusions': json.dumps(exclusions)
}, char)
def about(request, char_id=0):
return set_response(
request, 'chardata/about.html', {
'request': request,
'user': request.user,
'char_id': char_id,
'site_version': settings.SITE_VERSION
})
def edit_set(request):
structure = get_structure()
return set_response(
request, 'chardata/edit_set.html', {
'stats_order': json.dumps(structure.get_stats_list_names_sorted()),
'languages': NON_EN_LANGUAGES
})
def stats(request, char_id):
char = get_char_or_raise(request, char_id)
return set_response(
request, 'chardata/stats.html', {
'char_id': char_id,
'advanced': True,
'default_weights_json': json.dumps(get_stats_weights(char))
}, char)
def choose_compare_sets(request):
params = {}
for i in range(4):
char_id = request.POST.get('char%d' % i, None)
if char_id:
params['char%d' % i] = char_id
return set_response(request, 'chardata/choose_compare_sets.html', params)
def options(request, char_id):
char = get_char_or_raise(request, char_id)
options = get_options(char)
return set_response(request, 'chardata/options.html', {
'advanced': True,
'options': json.dumps(options),
'char_id': char_id
}, char)
def _login_page_generic(request, from_confirmation, prefilled_user, char_id,
already_confirmed):
return set_response(
request, 'chardata/login.html', {
'request': request,
'user': request.user,
'char_id': char_id,
'from_confirmation': from_confirmation,
'prefilled_user': prefilled_user,
'already_confirmed': already_confirmed == 'yes'
})
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 compare_sets(request, sets_params):
char_strs = _process_parameters(sets_params)
chars = [
get_char_possibly_encoded_or_raise(request, char_str)
for char_str in char_strs
]
solutions = {}
is_guest = {}
links = {}
all_chars_are_shared = True
for char in chars:
solution = get_solution(char)
sol_result = SolutionResult(solution)
solutions[char.pk] = sol_result.get_params()
is_guest[char.pk] = not char_belongs_to_user(request, char)
if not char_belongs_to_user(request, char):
links[char.pk] = generate_link(char)
else:
links[char.pk] = request.build_absolute_uri(
reverse('chardata.solution_view.solution', args=(char.pk, )))
all_chars_are_shared = all_chars_are_shared and char.link_shared
char_ids = [char.pk for char in chars]
if len(char_ids) > 2:
char_ids_cols = char_ids
else:
char_ids_cols = char_ids + ['diff']
compare_link_shared = None
if all_chars_are_shared:
compare_link_shared = _generate_share_compare_link(char_ids)
get_compare_link_url = reverse(
'chardata.compare_sets_view.get_sharing_link', args=(sets_params, ))
params = {
'chars': chars,
'char_ids': char_ids,
'char_ids_cols': char_ids_cols,
'solutions': solutions,
'items_sorted': _sort_items(solutions),
'char_is_guest': is_guest,
'links': links,
'compare_link_shared': compare_link_shared,
'get_compare_link_url': get_compare_link_url
}
response = set_response(request, 'chardata/compare_sets.html', params)
return response
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 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 setup(request, char_id=0):
too_many_projects_problem = False
is_new_char = (char_id == 0)
if is_new_char:
char = Char()
char.name = ''
char.level = 200
char.char_name = ''
char.char_class = ''
char.char_build = ''
else:
char = get_char_or_raise(request, char_id)
if is_anon_cant_create(request) and is_new_char:
can_create = False
login_problem = True
else:
can_create = True
login_problem = False
if (is_new_char and request.user is not None
and not request.user.is_anonymous() and can_create):
chars = Char.objects.filter(owner=request.user)
chars = chars.exclude(deleted=True)
if len(
chars
) >= MAXIMUM_NUMBER_OF_PROJECTS and request.user.email not in TESTER_USERS:
can_create = False
too_many_projects_problem = True
classes = list(_get_class_to_name().keys())
return set_response(
request, 'chardata/projdetails.html', {
'classes': sorted(classes),
'class_to_name': _get_class_to_name(),
'can_create': can_create,
'login_problem': login_problem,
'too_many_projects_problem': too_many_projects_problem,
'state': json.dumps(_get_state_from_char(char)),
'char_id': char_id,
'aspect_to_name': _get_json_aspect_to_name(),
'is_new_char_json': json.dumps(is_new_char),
'questionmark': json.dumps(get_questionmark_URL(request)),
'is_new_char': is_new_char
}, char)
def infeasible(request, char_id=0):
char = get_object_or_404(Char, pk=char_id)
return set_response(
request, 'chardata/infeasible.html', {
'request':
request,
'user':
request.user,
'char_id':
char_id,
'mins_link':
reverse('chardata.min_stats_view.min_stats', args=(char_id, )),
'weights_link':
reverse('chardata.stats_weights_view.stats', args=(char_id, )),
'lock_link':
reverse('chardata.inclusions_view.inclusions', args=(char_id, )),
'exo_link':
reverse('chardata.options_view.options', args=(char_id, ))
}, char)
def wizard(request, char_id):
char = get_char_or_raise(request, char_id)
wizard_data = Data(char)
constant_data = ConstantData(char)
wizard_pic = 'chardata/designs/wizard/%s/myWizard%s%d.png' % (
char.char_class, char.char_class, 1 + (int(char_id) % 6))
return set_response(
request, 'chardata/wizard.html', {
'char_id':
char_id,
'wizard_pic':
wizard_pic,
'constant_data':
jsonpickle.encode(constant_data, unpicklable=False),
'wizard_data':
jsonpickle.encode(wizard_data, unpicklable=False),
'triangle_url':
jsonpickle.encode(get_triangle_URL(request), unpicklable=False)
}, char)
def load_projects_error(request, error):
chars = []
if request.user is not None and not request.user.is_anonymous():
chars = Char.objects.filter(owner=request.user)
chars = chars.exclude(deleted=True)
has_projects = False
if len(chars) > 0:
has_projects = True
if request.user.is_anonymous() and 'char_id' in request.session:
char = get_object_or_404(Char, pk=request.session['char_id'])
chars.append(char)
has_projects = True
return set_response(
request, 'chardata/load_projects.html', {
'chars': [WrappedChar(char) for char in chars],
'char_id': 0,
'has_projects': has_projects,
'needle': json.dumps(get_needle_URL(request)),
'error_msg': error
})
def recover_password(request, username, recover_token):
users = User.objects.filter(username=username)
if not users or len(users) != 1:
raise PermissionDenied
user = users[0]
current_password = user.password
correct_token = _generate_token_for_password_reset(username,
current_password)
if correct_token != recover_token:
raise PermissionDenied
username = user.username
new_password = User.objects.make_random_password()
user.set_password(
hashlib.sha256('dofusfashionista' + new_password).hexdigest())
user.save()
try:
send_mail(
_('Password for The Dofus Fashionista has been reset'),
_('Hello, {username}!\n'
'The following password has been generated for you:\n\n'
'{new_password}\n\n'
'Change it to a new one or just keep this email ;-)').format(
username=username, new_password=new_password),
'*****@*****.**', [user.email])
except (BadHeaderError, SMTPRecipientsRefused) as e:
raise e
return set_response(request, 'chardata/password_was_reset.html', {
'request': request,
'username': username,
'new_password': new_password
})
def nomessage(request):
return set_response(request, 'chardata/nomessage.html', {})
def faq(request, char_id=0):
return set_response(request, 'chardata/faq.html', {
'request': request,
'user': request.user,
'char_id': char_id
})
def check_your_email(request):
return set_response(request, 'chardata/check_your_email.html',
{'request': request})
def contact(request):
return set_response(request, 'chardata/contacts.html',
{'form': ContactForm()})
def thankyou(request):
return set_response(request, 'chardata/thankyou.html', {})
def recover_password_email_page(request):
return set_response(request, 'chardata/pw_recovery_email.html',
{'request': request})
def error(request, error, error_link, char_id, char):
return set_response(request, 'chardata/error.html', {
'char_id': char_id,
'error': error,
'error_link': error_link
}, char)
def license_page(request, char_id=0):
return set_response(request, 'chardata/license.html', {
'request': request,
'user': request.user,
'char_id': char_id
})
def manage_account(request):
return set_response(request,
'chardata/manage_account.html',
{'user_social_name': json.dumps(request.user.get_full_name())})
def contact(request, char_id=0):
return set_response(request, 'chardata/contact.html', {
'request': request,
'user': request.user,
'char_id': char_id
})
