def get_sharing_link(request, char_id): char = get_char_or_raise(request, char_id) char.link_shared = True char.save() return HttpResponseText(generate_link(char))
def _post(request, char_id): char = get_char_or_raise(request, char_id) for element_name, abr in STATS_NAMES: basestats_list = CharBaseStats.objects.filter(char=char, stat=element_name) if len(basestats_list) == 0: basestats = CharBaseStats() else: basestats = basestats_list[0] basestats.char = char basestats.stat = element_name basestats.total_value = ( safe_int(request.POST.get('points_%s' % abr, 0), 0) + safe_int(request.POST.get('scrolled_%s' % abr, 0), 0)) basestats.scrolled_value = safe_int( request.POST.get('scrolled_%s' % abr, 0), 0) assert 0 <= basestats.total_value and basestats.total_value <= 3000 assert 0 <= basestats.scrolled_value and basestats.scrolled_value <= 101 basestats.save() allow_point_distribution = request.POST.get('choose_stats', False) char.allow_points_distribution = allow_point_distribution char.save() return char
def hide_sharing_link(request, char_id): char = get_char_or_raise(request, char_id) char.link_shared = False char.save() return HttpResponseText('hid')
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 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 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 stats_post(request, char_id): char = get_char_or_raise(request, char_id) stats_weight = {} for stat in get_structure().get_stats_list(): stats_weight[stat.key] = safe_int( request.POST.get('weight_%s' % stat.key, 0), 0) set_stats_weights(char, stats_weight) return HttpResponseJson(json.dumps(get_stats_weights(char)))
def delete_projects(request): projects_json = request.POST.get('projects', None) projects = json.loads(projects_json) for proj_id in projects: char = get_char_or_raise(request, proj_id) char.deleted = True char.save() if 'char_id' in request.session: del request.session['char_id'] return HttpResponseText('ok')
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 exclusions_post(request, char_id): char = get_char_or_raise(request, char_id) exclusions_string = request.POST.get('exclusions', None) if exclusions_string is None: raise ValidationError('Exclusions list not received.') exclusions = json.loads(exclusions_string) actual_exclusions = [int(iditem) for iditem in exclusions] set_exclusions_list_and_check_inclusions(char, actual_exclusions) return HttpResponseJson(json.dumps(get_all_exclusions_ids(char)))
def remove_item(request, char_id): char = get_char_or_raise(request, char_id) slot = request.POST.get('slot', None) assert slot in SLOTS result = get_solution(char) result.switch_item(None, slot) set_solution(char, result) remove_cache_for_char(char_id) return HttpResponseText('ok')
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 solution(request, char_id, empty=False): char = get_char_or_raise(request, char_id) solution = get_solution(char) if solution is None: if not empty: return fashion(request, char_id) else: input_ = {} input_['options'] = get_options(request, char_id) input_['base_stats_by_attr'] = get_base_stats_by_attr(request, char_id) input_['char_level'] = char.level set_minimal_solution(char, ModelResultMinimal.generate_empty_solution(input_)) return _solution(request, char_id, 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 get_options(request, char_id): char = get_char_or_raise(request, char_id) options = {} if char.options: options = pickle.loads(char.options) model_options = { 'ap_exo': options.get('ap_exo', False), 'range_exo': options.get('range_exo', False), 'mp_exo': options.get('mp_exo', False), 'dofus': options.get('dofus', True), 'dragoturkey': options.get('dragoturkey', True), 'seemyool': options.get('seemyool', True), 'rhineetle': options.get('rhineetle', True) } return model_options
def inclusions_post(request, char_id): char = get_char_or_raise(request, char_id) inclusions = {} for slot in SLOTS: inclusions[slot] = request.POST.get(slot, '') set_inclusions_dict_and_check_exclusions(char, inclusions) inclusions = get_inclusions_dict(char) for slot in SLOTS: inclusions.setdefault(slot, '') return HttpResponseJson(json.dumps(inclusions))
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 save_project(request, char_id=0): char = get_char_or_raise(request, char_id) state = _get_state_from_post(request) remove_invalid_inclusions(char, state['char_level']) _save_state_to_char(state, char) # TODO: Make clear we are resetting weights and mins. set_char_aspects(char, state['char_build_aspects_set'], request.POST.get('reapply') == 'reapply') char.save() if char_id > 0: remove_cache_for_char(char_id) return HttpResponseJson(json.dumps(_get_state_from_char(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 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 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 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 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 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 spells(request, char_id=0): char = get_char_or_raise(request, char_id) return _spells(request, char, False, char_id)
def get_items_to_exchange(request, char_id): char = get_char_or_raise(request, char_id) slot = request.POST.get('slot', None) page = int(request.POST.get('page', 1)) search_term = request.POST.get('search_term', None) order_by_stats = request.POST.get('order_by_stat', True) assert slot in SLOTS assert int(page) >= 0 structure = get_structure() item_type = structure.get_type_id_by_name(SLOT_NAME_TO_TYPE.get(slot)) cache_key = ('%s-%s-%s-%s' % (char_id, item_type, search_term, order_by_stats)) cache_key = re.sub(r"\s+", '_', cache_key) items_to_exchange = cache.get(cache_key) if items_to_exchange == None: if slot == 'weapon' and order_by_stats == 'false': items_to_exchange = _order_by_hits(structure.get_type_name_by_id(item_type), char, search_term) else: items_to_exchange = _order_items(structure.get_type_name_by_id(item_type), char, search_term) cache.set(cache_key, items_to_exchange, 300) max_page = math.ceil(len(items_to_exchange) / 10.0) items_to_return = items_to_exchange[(page - 1) * 10 : page * 10] violations = {} differences = {} itemResults = [] weapon_info = {} 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) result_item.set_slot(slot) evolve_result_item(result_item) itemResults.append(result_item) vlist = [] for vio in check_if_violates(or_item, slot, char): vlist.append(vio) violations[or_item.name] = vlist differences[or_item.name] = _get_difference(or_item, slot, char) if slot == 'weapon': weapon_info[or_item.name] = _get_weapon_info(or_item, char) else: result_item = ModelResultItem(item) result_item.set_slot(slot) evolve_result_item(result_item) itemResults.append(result_item) vlist = [] for vio in check_if_violates(item, slot, char): vlist.append(vio) violations[item.name] = vlist differences[item.name] = _get_difference(item, slot, char) if slot == 'weapon': weapon_info[item.name] = _get_weapon_info(item, char) response = {'items': itemResults, 'violations': violations, 'page': page, 'max_page': max_page, 'weapon_info': weapon_info, 'differences': differences} json_response = jsonpickle.encode(response, unpicklable=False) return HttpResponseJson(json_response)
def get_resetted_sliders(request, char_id): char = get_char_or_raise(request, char_id) reapply_weights(char) all_sliders = get_wizard_sliders(char) all_sliders_json = jsonpickle.encode(all_sliders) return HttpResponseJson(all_sliders_json)
def fashion(request, char_id, spells=False): char = get_char_or_raise(request, char_id) remove_cache_for_char(char_id) if char.stats_weight: weights = get_stats_weights(char) load_error = True for _, value in weights.iteritems(): if value != 0: load_error = False break else: load_error = True if load_error: return error( request, 'characteristics weights', reverse('chardata.stats_weights_view.stats', args=(char_id, )), char_id, char) min_stats = get_min_stats_digested(char) model_options = get_options(request, char_id) inclusions_dic = get_inclusions_dict(char) exclusions = get_all_exclusions_ids(char) base_stats_by_attr = get_base_stats_by_attr(request, char_id) if char.allow_points_distribution: stat_points_to_distribute = 5 * (char.level - 1) else: stat_points_to_distribute = 0 # TODO: Sanity check input. model_input = ModelInput(char.level, base_stats_by_attr, min_stats, inclusions_dic, set(exclusions), weights, model_options, char.char_class, stat_points_to_distribute) solved_status = None stats = None result = None memoized_result = MEMORY.get(model_input) if memoized_result is not None: solved_status, stats, result = memoized_result else: model = borrow_model() model.setup(model_input) model.run(2) solved_status = model.get_solved_status() if solved_status == 'Optimal': stats = model.get_stats() result = model.get_result_minimal() return_model(model) MEMORY.put(model_input, (model.get_solved_status(), stats, result)) if result is None: return HttpResponseRedirect( reverse('chardata.views.infeasible', args=(char.id, ))) if char.allow_points_distribution: set_stats(char, stats) set_minimal_solution(char, result) if spells: return HttpResponseRedirect( reverse('chardata.spells_view.spells', args=(char.id, ))) return HttpResponseRedirect( reverse('chardata.solution_view.solution', args=(char.id, )))