signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def datetime_value_renderer(value, **options): | datetime_format = options.get('<STR_LIT>', '<STR_LIT>')<EOL>return formats.date_format(timezone.localtime(value), datetime_format)<EOL> | Render datetime value with django formats, default is SHORT_DATETIME_FORMAT | f12928:m0 |
def number_value_renderer(value, **options): | return format_decimal(value, locale=utils.get_current_locale())<EOL> | Format decimal value, with current locale | f12928:m1 |
def price_value_renderer(value, currency=None, **options): | if not currency:<EOL><INDENT>currency = getattr(settings, '<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>return format_currency(value, currency, locale=utils.get_current_locale())<EOL> | Format price value, with current locale and CURRENCY in settings | f12928:m2 |
def related_field_renderer(value, **options): | return '<STR_LIT:U+002CU+0020>'.join(str(obj) for obj in value.all())<EOL> | Render list of related items | f12928:m3 |
def __init__(self, renderers=None): | self.renderers = renderers if renderers else {}<EOL> | Init Renderer | f12928:c0:m0 |
def register(self, type, renderer): | self.renderers[type] = renderer<EOL> | Register render function for value or field type | f12928:c0:m1 |
def render_value(self, value, **options): | renderer = self.renderers.get(type(value), lambda value, **options: value)<EOL>return renderer(value, **options)<EOL> | Render value | f12928:c0:m2 |
def render_field(self, obj, field_name, **options): | try:<EOL><INDENT>field = obj._meta.get_field(field_name)<EOL><DEDENT>except FieldDoesNotExist:<EOL><INDENT>return getattr(obj, field_name, '<STR_LIT>')<EOL><DEDENT>if hasattr(field, '<STR_LIT>') and getattr(field, '<STR_LIT>'):<EOL><INDENT>return getattr(obj, '<STR_LIT>'.format(field_name))()<EOL><DEDENT>value = getattr(obj, field_name, '<STR_LIT>')<EOL>renderer = self.renderers.get(type(field))<EOL>if renderer:<EOL><INDENT>return renderer(value, **options)<EOL><DEDENT>if isinstance(value, models.BaseModel):<EOL><INDENT>value = str(value)<EOL><DEDENT>return self.render_value(value, **options)<EOL> | Render field | f12928:c0:m3 |
def __init__(self): | quickstart_path = os.path.realpath(__file__)<EOL>self.project_path = os.path.join(os.path.dirname(quickstart_path), '<STR_LIT>')<EOL>"""<STR_LIT>"""<EOL>self.app_path = os.path.join(os.path.dirname(quickstart_path), '<STR_LIT>')<EOL>"""<STR_LIT>"""<EOL> | Set project template paths | f12934:c0:m0 |
def create_project(self, project_path): | shutil.copytree(self.project_path, project_path)<EOL>self.update_file(project_path, '<STR_LIT>', {<EOL>'<STR_LIT>': trionyx.__version__<EOL>})<EOL>self.update_file(project_path, '<STR_LIT>', {<EOL>'<STR_LIT>': utils.random_string(<NUM_LIT:32>)<EOL>})<EOL> | Create Trionyx project in given path
:param str path: path to create project in.
:raises FileExistsError: | f12934:c0:m1 |
def create_app(self, apps_path, name): | app_path = os.path.join(apps_path, name.lower())<EOL>shutil.copytree(self.app_path, app_path)<EOL>self.update_file(app_path, '<STR_LIT>', {<EOL>'<STR_LIT:name>': name.lower()<EOL>})<EOL>self.update_file(app_path, '<STR_LIT>', {<EOL>'<STR_LIT:name>': name.lower(),<EOL>'<STR_LIT>': name.capitalize()<EOL>})<EOL> | Create Trionyx app in given path
:param str path: path to create app in.
:param str name: name of app
:raises FileExistsError: | f12934:c0:m2 |
def update_file(self, project_path, file_path, variables): | update_file = os.path.join(project_path, file_path)<EOL>with open(update_file, '<STR_LIT:rb>') as _file:<EOL><INDENT>file_content = _file.read().decode('<STR_LIT:utf-8>')<EOL><DEDENT>for key, value in variables.items():<EOL><INDENT>file_content = file_content.replace('<STR_LIT>'.format(key), value)<EOL><DEDENT>with open(update_file, '<STR_LIT>', encoding='<STR_LIT:utf-8>') as _file:<EOL><INDENT>_file.writelines(file_content)<EOL><DEDENT> | Update given file with given variables, variables in file must be inclosed with [[]].
For example you want to replace a variable secret_key, in the file its [[secret_key]].
:param str project_path:
:param str file_path:
:param dict variables: | f12934:c0:m3 |
@register.simple_tag<EOL>def active_menu_item(request, item): | if item.is_active(request.path):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>'<EOL> | Check if given menu item is active | f12944:m0 |
@register.simple_tag(takes_context=True)<EOL>def render_component(context, component): | return component.render(context.flatten(), context.get('<STR_LIT>'))<EOL> | Render given component | f12944:m1 |
def auto_register_search_models(): | for config in models_config.get_all_configs():<EOL><INDENT>if config.disable_search_index:<EOL><INDENT>continue<EOL><DEDENT>search.register(<EOL>config.model.objects.get_queryset(),<EOL>ModelSearchAdapter,<EOL>fields=config.search_fields,<EOL>exclude=config.search_exclude_fields,<EOL>)<EOL><DEDENT> | Auto register all search models | f12947:m0 |
def get_title(self, obj): | search_title = self.get_model_config_value(obj, '<STR_LIT>')<EOL>if not search_title:<EOL><INDENT>return super().get_title(obj)<EOL><DEDENT>return search_title.format(**obj.__dict__)<EOL> | Set search entry title for object | f12947:c0:m0 |
def get_description(self, obj): | search_description = self.get_model_config_value(obj, '<STR_LIT>')<EOL>if not search_description:<EOL><INDENT>return super().get_description(obj)<EOL><DEDENT>return search_description.format(**obj.__dict__)<EOL> | Set search entry description for object | f12947:c0:m1 |
def get_model_config_value(self, obj, name): | config = models_config.get_config(obj)<EOL>return getattr(config, name)<EOL> | Get config value for given model | f12947:c0:m2 |
def process_request(self, request): | assert hasattr(request, '<STR_LIT:user>')<EOL>if not request.user.is_authenticated():<EOL><INDENT>path = request.path_info.lstrip('<STR_LIT:/>')<EOL>if not any(m.match(path) for m in EXEMPT_URLS):<EOL><INDENT>return HttpResponseRedirect(reverse(settings.LOGIN_URL))<EOL><DEDENT><DEDENT> | Check if user is logged in | f12948:c0:m0 |
def get_model_config(self, model): | return models_config.get_config(model)<EOL> | Get model config for given model | f12949:c0:m0 |
def ready(self): | models_config.auto_load_configs()<EOL>self.auto_load_app_modules(['<STR_LIT>', '<STR_LIT>'])<EOL>app_menu.auto_load_model_menu()<EOL>auto_register_search_models()<EOL>tabs.auto_generate_missing_tabs()<EOL> | Auto load Trionyx | f12949:c1:m0 |
def auto_load_app_modules(self, modules): | for app in apps.get_app_configs():<EOL><INDENT>for module in modules:<EOL><INDENT>try:<EOL><INDENT>import_module('<STR_LIT>'.format(app.module.__package__, module))<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT> | Auto load app modules | f12949:c1:m1 |
def __init__(self, *args, **kwargs): | super().__init__(*args, **kwargs)<EOL>self.helper = FormHelper()<EOL>self.helper.layout = Layout(<EOL>'<STR_LIT:email>',<EOL>Div(<EOL>Fieldset(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>css_class="<STR_LIT>",<EOL>),<EOL>Div(<EOL>'<STR_LIT>',<EOL>css_class="<STR_LIT>",<EOL>),<EOL>css_class="<STR_LIT>"<EOL>),<EOL>Fieldset(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>),<EOL>)<EOL> | Init user form | f12950:c0:m0 |
def clean_new_password2(self): | password1 = self.cleaned_data.get('<STR_LIT>')<EOL>password2 = self.cleaned_data.get('<STR_LIT>')<EOL>if password1 or password2:<EOL><INDENT>if password1 != password2:<EOL><INDENT>raise forms.ValidationError(<EOL>self.error_messages['<STR_LIT>'],<EOL>code='<STR_LIT>',<EOL>)<EOL><DEDENT>password_validation.validate_password(password2, self.instance)<EOL><DEDENT>return password2<EOL> | Validate password when set | f12950:c0:m1 |
def save(self, commit=True): | user = super().save(commit=False)<EOL>password = self.cleaned_data["<STR_LIT>"]<EOL>if password:<EOL><INDENT>user.set_password(password)<EOL><DEDENT>if commit:<EOL><INDENT>user.save()<EOL><DEDENT>return user<EOL> | Save user | f12950:c0:m2 |
def __init__(self, field, **kwargs): | if not self.locale:<EOL><INDENT>self.locale = get_current_locale()<EOL><DEDENT>for key in self.valid_options:<EOL><INDENT>value = kwargs.pop(key, getattr(self, key))<EOL>if isinstance(value, bool):<EOL><INDENT>value = str(value).lower()<EOL><DEDENT>kwargs['<STR_LIT>'.format(key)] = str(value)<EOL><DEDENT>if '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>kwargs['<STR_LIT>'] = '<STR_LIT>'.format(kwargs.get('<STR_LIT>', '<STR_LIT>')).strip()<EOL>super().__init__(field, **kwargs)<EOL> | Init DateTimePicker | f12952:c0:m0 |
def trionyx(request): | return {<EOL>'<STR_LIT>': settings.TX_APP_NAME,<EOL>'<STR_LIT>': settings.TX_LOGO_NAME_START,<EOL>'<STR_LIT>': settings.TX_LOGO_NAME_END,<EOL>'<STR_LIT>': settings.TX_LOGO_NAME_SMALL_START,<EOL>'<STR_LIT>': settings.TX_LOGO_NAME_SMALL_END,<EOL>'<STR_LIT>': app_menu.get_menu_items(),<EOL>}<EOL> | Add trionyx context data | f12955:m0 |
def add_arguments(self, parser): | parser.add_argument('<STR_LIT:name>', type=str)<EOL> | Add name argument | f12956:c0:m0 |
def handle(self, *args, **options): | quickstart = Quickstart()<EOL>try:<EOL><INDENT>quickstart.create_app(os.path.join(settings.BASE_DIR, '<STR_LIT>'), options.get('<STR_LIT:name>'))<EOL>self.stdout.write(<EOL>self.style.SUCCESS("<STR_LIT>".format(<EOL>name=options.get('<STR_LIT:name>')<EOL>))<EOL>)<EOL><DEDENT>except FileExistsError as e:<EOL><INDENT>print(e)<EOL>raise CommandError("<STR_LIT>")<EOL><DEDENT> | Create new app | f12956:c0:m1 |
def _create_user(self, email, password, is_superuser, **extra_fields): | now = timezone.now()<EOL>if not email:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>email = self.normalize_email(email)<EOL>user = self.model(<EOL>email=email,<EOL>password=password,<EOL>is_active=True,<EOL>is_superuser=is_superuser, last_login=now,<EOL>date_joined=now,<EOL>**extra_fields)<EOL>user.set_password(password)<EOL>user.save(using=self._db)<EOL>return user<EOL> | Create new user | f12959:c0:m0 |
def create_user(self, email, password=None, **extra_fields): | return self._create_user(email, password, False, **extra_fields)<EOL> | Create standard user | f12959:c0:m1 |
def create_superuser(self, email, password=None, **extra_fields): | return self._create_user(email, password, True, **extra_fields)<EOL> | Create super user | f12959:c0:m2 |
def get_queryset(self): | return super().get_queryset().filter(is_active=True)<EOL> | Get queryset default filter inactive users | f12959:c0:m3 |
def get_full_name(self): | if self.first_name and self.last_name:<EOL><INDENT>return "<STR_LIT>".format(self.first_name, self.last_name)<EOL><DEDENT>return self.email<EOL> | Get full username if no name is set email is given | f12959:c1:m0 |
def get_short_name(self): | if self.first_name:<EOL><INDENT>return self.first_name<EOL><DEDENT>return self.email<EOL> | Get short name if no name is set email is given | f12959:c1:m1 |
def __str__(self): | return self.email<EOL> | User representation | f12959:c1:m2 |
def set_attribute(self, code, value): | attr, _ = self.get_or_create(code=code)<EOL>attr.value = value<EOL>attr.save()<EOL> | Set attribute for user | f12959:c2:m0 |
def get_attribute(self, code, default=None): | try:<EOL><INDENT>return self.get(code=code).value<EOL><DEDENT>except models.ObjectDoesNotExist:<EOL><INDENT>return default<EOL><DEDENT> | Get attribute for user | f12959:c2:m1 |
def __str__(self): | return self.code<EOL> | User Attribute representation | f12959:c3:m0 |
@tabs.register('<STR_LIT>')<EOL>def account_overview(object): | return Layout(<EOL>Container(<EOL>Row(<EOL>Column2(<EOL>Panel(<EOL>'<STR_LIT>',<EOL>Img(src="<STR_LIT>".format(settings.MEDIA_URL, object.avatar)),<EOL>collapse=True,<EOL>),<EOL>),<EOL>Column10(<EOL>Panel(<EOL>'<STR_LIT>',<EOL>DescriptionList(<EOL>'<STR_LIT:email>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>),<EOL>)<EOL>),<EOL>)<EOL>)<EOL>)<EOL> | Create layout for user profile | f12960:m0 |
def logout(request): | django_logout(request)<EOL>return redirect('<STR_LIT:/>')<EOL> | Trionyx logout view | f12961:m0 |
def get(self, request, *args, **kwargs): | kwargs['<STR_LIT>'] = request.user.id<EOL>self.kwargs['<STR_LIT>'] = request.user.id<EOL>return super().get(request, *args, **kwargs)<EOL> | Add user id to kwargs | f12961:c1:m0 |
def post(self, request, *args, **kwargs): | kwargs['<STR_LIT>'] = request.user.id<EOL>self.kwargs['<STR_LIT>'] = request.user.id<EOL>return super().post(request, *args, **kwargs)<EOL> | Add user id to kwargs | f12961:c1:m1 |
def get_success_url(self): | return reverse('<STR_LIT>')<EOL> | Set success url to account page | f12961:c1:m2 |
def get(self, request, *args, **kwargs): | kwargs['<STR_LIT>'] = request.user.id<EOL>self.kwargs['<STR_LIT>'] = request.user.id<EOL>return super().get(request, *args, **kwargs)<EOL> | Add user id to kwargs | f12961:c2:m0 |
def get_edit_url(self): | return reverse('<STR_LIT>')<EOL> | Get user edit url | f12961:c2:m1 |
def get_delete_url(self): | return None<EOL> | Hide delete url | f12961:c2:m2 |
def get_back_url(self): | return None<EOL> | Hide back url | f12961:c2:m3 |
def media_nginx_accel(request, path): | response = HttpResponse(status=<NUM_LIT:200>)<EOL>response['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>response['<STR_LIT>'] = '<STR_LIT>' + request.path<EOL>return response<EOL> | location /protected/ {
internal;
root <complete path to project root dir>;
} | f12963:m0 |
def get_model_class(self): | if getattr(self, '<STR_LIT>', None):<EOL><INDENT>return self.model<EOL><DEDENT>elif getattr(self, '<STR_LIT:object>', None):<EOL><INDENT>return self.object.__class__<EOL><DEDENT>elif '<STR_LIT>' in self.kwargs and '<STR_LIT>' in self.kwargs:<EOL><INDENT>return apps.get_model(self.kwargs.get('<STR_LIT>'), self.kwargs.get('<STR_LIT>'))<EOL><DEDENT>elif hasattr(self, '<STR_LIT>'):<EOL><INDENT>return self.get_queryset().model<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT> | Get model class | f12963:c0:m0 |
def get_model_config(self): | if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>setattr(self, '<STR_LIT>', models_config.get_config(self.get_model_class()))<EOL><DEDENT>return getattr(self, '<STR_LIT>', None)<EOL> | Get Trionyx model config | f12963:c0:m1 |
def dispatch(self, request, *args, **kwargs): | if False: <EOL><INDENT>raise PermissionDenied<EOL><DEDENT>return super().dispatch(request, *args, **kwargs)<EOL> | Validate if user can use view | f12963:c1:m0 |
def get_and_save_value(self, name, default=None): | if getattr(self, name, None):<EOL><INDENT>return getattr(self, name)<EOL><DEDENT>value = self.get_session_value(name, default)<EOL>value = self.request.POST.get(name, value)<EOL>self.save_value(name, value)<EOL>return value<EOL> | Get value from request/session and save value to session | f12963:c2:m0 |
def get_session_value(self, name, default=None): | session_name = '<STR_LIT>'.format(self.kwargs.get('<STR_LIT>'), self.kwargs.get('<STR_LIT>'), name)<EOL>return self.request.session.get(session_name, default)<EOL> | Get value from session | f12963:c2:m1 |
def save_value(self, name, value): | session_name = '<STR_LIT>'.format(self.kwargs.get('<STR_LIT>'), self.kwargs.get('<STR_LIT>'), name)<EOL>self.request.session[session_name] = value<EOL>setattr(self, name, value)<EOL>return value<EOL> | Save value to session | f12963:c2:m2 |
def get_title(self): | if self.title:<EOL><INDENT>return self.title<EOL><DEDENT>return self.get_model_class()._meta.verbose_name_plural<EOL> | Get page title | f12963:c3:m0 |
def get_ajax_url(self): | if self.ajax_url:<EOL><INDENT>return self.ajax_url<EOL><DEDENT>return reverse('<STR_LIT>', kwargs=self.kwargs)<EOL> | Get ajax url | f12963:c3:m1 |
def get_download_url(self): | if self.download_url:<EOL><INDENT>return self.download_url<EOL><DEDENT>return reverse('<STR_LIT>', kwargs=self.kwargs)<EOL> | Get ajax url | f12963:c3:m2 |
def get_create_url(self): | return reverse('<STR_LIT>', kwargs=self.kwargs)<EOL> | Get create url | f12963:c3:m3 |
def get_context_data(self, **kwargs): | context = super().get_context_data(**kwargs)<EOL>context.update({<EOL>'<STR_LIT:title>': self.get_title(),<EOL>'<STR_LIT>': self.get_ajax_url(),<EOL>'<STR_LIT>': self.get_download_url(),<EOL>'<STR_LIT>': self.get_create_url(),<EOL>})<EOL>return context<EOL> | Add context data to view | f12963:c3:m4 |
def get_page(self, paginator): | page = int(self.get_and_save_value('<STR_LIT>', <NUM_LIT:1>))<EOL>if page < <NUM_LIT:1>:<EOL><INDENT>return self.save_value('<STR_LIT>', <NUM_LIT:1>)<EOL><DEDENT>if page > paginator.num_pages:<EOL><INDENT>return self.save_value('<STR_LIT>', paginator.num_pages)<EOL><DEDENT>return page<EOL> | Get current page or page in session | f12963:c4:m0 |
def get_page_size(self): | return self.get_and_save_value('<STR_LIT>', <NUM_LIT:10>)<EOL> | Get current page size or page size in session | f12963:c4:m1 |
def get_sort(self): | return self.get_and_save_value('<STR_LIT>', '<STR_LIT>')<EOL> | Get current sort or sort in session | f12963:c4:m2 |
def get_search(self): | old_search = self.get_session_value('<STR_LIT>', '<STR_LIT>')<EOL>search = self.get_and_save_value('<STR_LIT>', '<STR_LIT>')<EOL>if old_search != search:<EOL><INDENT>self.page = <NUM_LIT:1><EOL>self.get_session_value('<STR_LIT>', self.page)<EOL><DEDENT>return search<EOL> | Get current search or search from session, reset page if search is changed | f12963:c4:m3 |
def get_all_fields(self): | return {<EOL>name: {<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT:label>': field['<STR_LIT:label>'],<EOL>}<EOL>for name, field in self.get_model_config().get_list_fields().items()<EOL>}<EOL> | Get all aviable fields | f12963:c4:m4 |
def get_current_fields(self): | if hasattr(self, '<STR_LIT>') and self.current_fields:<EOL><INDENT>return self.current_fields<EOL><DEDENT>field_attribute = '<STR_LIT>'.format(self.kwargs.get('<STR_LIT>'), self.kwargs.get('<STR_LIT>'))<EOL>current_fields = self.request.user.attributes.get_attribute(field_attribute, [])<EOL>request_fields = self.request.POST.get('<STR_LIT>', None)<EOL>if request_fields and '<STR_LIT:U+002C>'.join(current_fields) != request_fields:<EOL><INDENT>current_fields = request_fields.split('<STR_LIT:U+002C>')<EOL>self.request.user.attributes.set_attribute(field_attribute, current_fields)<EOL><DEDENT>elif request_fields:<EOL><INDENT>current_fields = request_fields.split('<STR_LIT:U+002C>')<EOL><DEDENT>if not current_fields:<EOL><INDENT>config = self.get_model_config()<EOL>current_fields = config.list_default_fields if config.list_default_fields else ['<STR_LIT>', '<STR_LIT:id>']<EOL><DEDENT>self.current_fields = current_fields<EOL>return current_fields<EOL> | Get current list to be used | f12963:c4:m5 |
def get_paginator(self): | return Paginator(self.get_queryset(), self.get_page_size())<EOL> | Get paginator | f12963:c4:m6 |
def get_queryset(self): | query = self.search_queryset()<EOL>return query.order_by(self.get_sort())<EOL> | Get qeuryset for model | f12963:c4:m7 |
def search_queryset(self): | queryset = self.get_model_class().objects.get_queryset()<EOL>if self.get_model_config().list_select_related:<EOL><INDENT>queryset = queryset.select_related(*self.get_model_config().list_select_related)<EOL><DEDENT>return watson.filter(queryset, self.get_search(), ranking=False)<EOL> | Get search query set | f12963:c4:m8 |
def __init__(self, *args, **kwargs): | super().__init__(*args, **kwargs)<EOL>self.page = None<EOL>self.page_size = None<EOL>self.sort = None<EOL>self.fields = None<EOL> | Init ListJsendView | f12963:c5:m0 |
def handle_request(self, request, *args, **kwargs): | paginator = self.get_paginator()<EOL>search = self.get_search()<EOL>page = self.get_page(paginator)<EOL>items = self.get_items(paginator, page)<EOL>return {<EOL>'<STR_LIT>': search,<EOL>'<STR_LIT>': page,<EOL>'<STR_LIT>': self.get_page_size(),<EOL>'<STR_LIT>': paginator.num_pages,<EOL>'<STR_LIT>': self.get_sort(),<EOL>'<STR_LIT>': self.get_current_fields(),<EOL>'<STR_LIT>': self.get_all_fields(),<EOL>'<STR_LIT>': items,<EOL>}<EOL> | Give back list items + config | f12963:c5:m1 |
def get_items(self, paginator, current_page): | fields = self.get_model_config().get_list_fields()<EOL>page = paginator.page(current_page)<EOL>items = []<EOL>for item in page:<EOL><INDENT>items.append({<EOL>'<STR_LIT:id>': item.id,<EOL>'<STR_LIT:url>': item.get_absolute_url(),<EOL>'<STR_LIT>': [<EOL>fields[field]['<STR_LIT>'](item, field)<EOL>for field in self.get_current_fields()<EOL>]<EOL>})<EOL><DEDENT>return items<EOL> | Get list items for current page | f12963:c5:m2 |
def post(self, request, app, model, **kwargs): | return self.csv_response()<EOL> | Handle post request | f12963:c6:m0 |
def items(self): | query = self.get_queryset()<EOL>fields = self.get_model_config().get_list_fields()<EOL>for item in query.iterator():<EOL><INDENT>row = OrderedDict()<EOL>for field_name in self.get_current_fields():<EOL><INDENT>field = fields.get(field_name)<EOL>if not field_name:<EOL><INDENT>row[field_name] = '<STR_LIT>'<EOL><DEDENT>if hasattr(item, field['<STR_LIT>']):<EOL><INDENT>row[field_name] = getattr(item, field['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>row[field_name] = '<STR_LIT>' <EOL><DEDENT><DEDENT>yield row<EOL><DEDENT> | Get all list items | f12963:c6:m1 |
def csv_response(self): | def stream():<EOL><INDENT>"""<STR_LIT>"""<EOL>stream_file = io.StringIO()<EOL>csvwriter = csv.writer(stream_file, delimiter='<STR_LIT:U+002C>', quotechar='<STR_LIT:">')<EOL>csvwriter.writerow(self.get_current_fields())<EOL>for index, item in enumerate(self.items()):<EOL><INDENT>csvwriter.writerow([value for index, value in item.items()])<EOL>stream_file.seek(<NUM_LIT:0>)<EOL>data = stream_file.read()<EOL>stream_file.seek(<NUM_LIT:0>)<EOL>stream_file.truncate()<EOL>yield data<EOL><DEDENT><DEDENT>response = StreamingHttpResponse(stream(), content_type="<STR_LIT>")<EOL>response["<STR_LIT>"] = "<STR_LIT>".format(self.get_model_config().model_name.lower())<EOL>return response<EOL> | Get csv response | f12963:c6:m2 |
def get_queryset(self): | if self.queryset is None and not self.model:<EOL><INDENT>try:<EOL><INDENT>ModelClass = apps.get_model(self.kwargs.get('<STR_LIT>'), self.kwargs.get('<STR_LIT>'))<EOL>return ModelClass._default_manager.all()<EOL><DEDENT>except LookupError:<EOL><INDENT>raise Http404()<EOL><DEDENT><DEDENT>return super().get_queryset()<EOL> | Get queryset based on url params(<app>, <mode>) if model is not set on class | f12963:c7:m0 |
def get_context_data(self, **kwargs): | context = super().get_context_data(**kwargs)<EOL>tabs = self.get_active_tabs()<EOL>context.update({<EOL>'<STR_LIT>': tabs,<EOL>'<STR_LIT>': tabs[<NUM_LIT:0>].code if tabs else '<STR_LIT>',<EOL>'<STR_LIT>': self.get_app_label(),<EOL>'<STR_LIT>': self.get_model_name(),<EOL>'<STR_LIT>': self.get_model_alias(),<EOL>'<STR_LIT>': self.object._meta.verbose_name.title(),<EOL>'<STR_LIT>': self.get_back_url(),<EOL>'<STR_LIT>': self.get_edit_url(),<EOL>'<STR_LIT>': self.get_delete_url(),<EOL>'<STR_LIT:title>': self.title,<EOL>})<EOL>return context<EOL> | Add context data to view | f12963:c7:m1 |
def get_back_url(self): | return reverse('<STR_LIT>', kwargs={<EOL>'<STR_LIT>': self.get_app_label(),<EOL>'<STR_LIT>': self.get_model_name(),<EOL>})<EOL> | Get back url | f12963:c7:m2 |
def get_delete_url(self): | return reverse('<STR_LIT>', kwargs={<EOL>'<STR_LIT>': self.get_app_label(),<EOL>'<STR_LIT>': self.get_model_name(),<EOL>'<STR_LIT>': self.object.id<EOL>})<EOL> | Get model object delete url | f12963:c7:m3 |
def get_edit_url(self): | return reverse('<STR_LIT>', kwargs={<EOL>'<STR_LIT>': self.get_app_label(),<EOL>'<STR_LIT>': self.get_model_name(),<EOL>'<STR_LIT>': self.object.id<EOL>})<EOL> | Get model object edit url | f12963:c7:m4 |
def get_model_alias(self): | if self.model_alias:<EOL><INDENT>return self.model_alias<EOL><DEDENT>return '<STR_LIT>'.format(self.get_app_label(), self.get_model_name())<EOL> | Get model alias | f12963:c7:m5 |
def get_app_label(self): | return self.object._meta.app_label<EOL> | Get model app label | f12963:c7:m6 |
def get_model_name(self): | return self.object._meta.model_name<EOL> | Get model name | f12963:c7:m7 |
def get_active_tabs(self): | return list(tabs.get_tabs(self.get_model_alias(), self.object))<EOL> | Get all active tabs | f12963:c7:m8 |
def dispatch(self, request, *args, **kwargs): | if False: <EOL><INDENT>raise PermissionDenied<EOL><DEDENT>return super().dispatch(request, *args, **kwargs)<EOL> | Validate if user can use view | f12963:c7:m9 |
def handle_request(self, request, app, model, pk): | ModelClass = self.get_model_class()<EOL>object = ModelClass.objects.get(id=pk)<EOL>tab_code = request.GET.get('<STR_LIT>')<EOL>model_alias = request.GET.get('<STR_LIT>')<EOL>model_alias = model_alias if model_alias else '<STR_LIT>'.format(app, model)<EOL>item = tabs.get_tab(model_alias, object, tab_code)<EOL>return item.get_layout(object).render(request)<EOL> | Render and return tab | f12963:c8:m0 |
def get_queryset(self): | if self.queryset is None and not self.model:<EOL><INDENT>try:<EOL><INDENT>return self.get_model_class()._default_manager.all()<EOL><DEDENT>except LookupError:<EOL><INDENT>raise Http404()<EOL><DEDENT><DEDENT>return super().get_queryset()<EOL> | Get queryset based on url params(<app>, <mode>) if model is not set on class | f12963:c9:m0 |
def get_form_class(self): | if self.form_class:<EOL><INDENT>return self.form_class<EOL><DEDENT>return self.get_model_config().get_edit_form()<EOL> | Get form class for model | f12963:c9:m1 |
def get_form(self, form_class=None): | form = super().get_form(form_class)<EOL>if not getattr(form, '<STR_LIT>', None):<EOL><INDENT>form.helper = FormHelper()<EOL>form.helper.form_tag = False<EOL><DEDENT>else:<EOL><INDENT>form.helper.form_tag = False<EOL><DEDENT>return form<EOL> | Get form for model | f12963:c9:m2 |
def get_context_data(self, **kwargs): | context = super().get_context_data(**kwargs)<EOL>context.update({<EOL>'<STR_LIT:title>': self.title,<EOL>'<STR_LIT>': self.submit_value,<EOL>'<STR_LIT>': self.cancel_url,<EOL>})<EOL>return context<EOL> | Add context data to view | f12963:c9:m3 |
def form_valid(self, form): | response = super().form_valid(form)<EOL>messages.success(self.request, "<STR_LIT>".format(self.object))<EOL>return response<EOL> | Add success message | f12963:c9:m4 |
def get_queryset(self): | if self.queryset is None and not self.model:<EOL><INDENT>try:<EOL><INDENT>return self.get_model_class()._default_manager.all()<EOL><DEDENT>except LookupError:<EOL><INDENT>raise Http404()<EOL><DEDENT><DEDENT>return super().get_queryset()<EOL> | Get queryset based on url params(<app>, <mode>) if model is not set on class | f12963:c10:m0 |
def get_form_class(self): | if self.form_class:<EOL><INDENT>return self.form_class<EOL><DEDENT>return self.get_model_config().get_create_form()<EOL> | Get form class for model | f12963:c10:m1 |
def get_form(self, form_class=None): | form = super().get_form(form_class)<EOL>if not getattr(form, '<STR_LIT>', None):<EOL><INDENT>form.helper = FormHelper()<EOL>form.helper.form_tag = False<EOL><DEDENT>else:<EOL><INDENT>form.helper.form_tag = False<EOL><DEDENT>return form<EOL> | Get form for model | f12963:c10:m2 |
def get_cancel_url(self): | if self.cancel_url:<EOL><INDENT>return self.cancel_url<EOL><DEDENT>ModelClass = self.get_model_class()<EOL>return reverse('<STR_LIT>', kwargs={<EOL>'<STR_LIT>': ModelClass._meta.app_label,<EOL>'<STR_LIT>': ModelClass._meta.model_name,<EOL>})<EOL> | Get cancel url | f12963:c10:m3 |
def get_context_data(self, **kwargs): | context = super().get_context_data(**kwargs)<EOL>context.update({<EOL>'<STR_LIT:title>': self.title,<EOL>'<STR_LIT>': self.submit_value,<EOL>'<STR_LIT>': self.get_cancel_url(),<EOL>'<STR_LIT>': self.get_model_class()._meta.verbose_name<EOL>})<EOL>return context<EOL> | Add context data to view | f12963:c10:m4 |
def form_valid(self, form): | response = super().form_valid(form)<EOL>messages.success(self.request, "<STR_LIT>".format(self.object))<EOL>return response<EOL> | Add success message | f12963:c10:m5 |
def get_queryset(self): | if self.queryset is None and not self.model:<EOL><INDENT>try:<EOL><INDENT>return self.get_model_class()._default_manager.all()<EOL><DEDENT>except LookupError:<EOL><INDENT>raise Http404()<EOL><DEDENT><DEDENT>return super().get_queryset()<EOL> | Get queryset based on url params(<app>, <mode>) if model is not set on class | f12963:c11:m0 |
def get_context_data(self, **kwargs): | context = super().get_context_data(**kwargs)<EOL>context.update({<EOL>'<STR_LIT:title>': self.title,<EOL>'<STR_LIT>': self.submit_value,<EOL>'<STR_LIT>': self.cancel_url<EOL>})<EOL>return context<EOL> | Add context data to view | f12963:c11:m1 |
def get_success_url(self): | messages.success(self.request, "<STR_LIT>".format(self.object))<EOL>if self.success_url:<EOL><INDENT>return reverse(self.success_url)<EOL><DEDENT>if '<STR_LIT>' in self.kwargs and '<STR_LIT>' in self.kwargs:<EOL><INDENT>return reverse('<STR_LIT>', kwargs={<EOL>'<STR_LIT>': self.kwargs.get('<STR_LIT>'),<EOL>'<STR_LIT>': self.kwargs.get('<STR_LIT>'),<EOL>})<EOL><DEDENT>return '<STR_LIT:/>'<EOL> | Get success url | f12963:c11:m2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.