def process_import(self, request, *args, **kwargs): ''' Perform the actuall import action (after the user has confirmed he wishes to import) ''' opts = self.get_model()._meta resource = self.get_import_resource()() confirm_form = ConfirmImportForm(request.POST) if confirm_form.is_valid(): import_formats = self.get_import_formats() input_format = import_formats[ int(confirm_form.cleaned_data['input_format']) ]() import_file = open(confirm_form.cleaned_data['import_file_name'], input_format.get_read_mode()) data = import_file.read() if not input_format.is_binary() and self.from_encoding: data = unicode(data, self.from_encoding).encode('utf-8') dataset = input_format.create_dataset(data) resource.import_data(dataset, dry_run=False, raise_errors=True) success_message = 'Import finished' messages.success(request, success_message) import_file.close() url = reverse('%s_%s_list' % (opts.app_label.lower(), opts.object_name.lower())) return HttpResponseRedirect(url)
def process_import(self, request, *args, **kwargs): ''' Perform the actual import action (after the user has confirmed he wishes to import) ''' opts = self.model._meta resource = self.get_import_resource_class()() total_imports = 0 total_updates = 0 confirm_form = ConfirmImportForm(request.POST) if confirm_form.is_valid(): import_formats = self.get_import_formats() input_format = import_formats[ int(confirm_form.cleaned_data['input_format']) ]() tmp_storage = self.get_tmp_storage_class()(name=confirm_form.cleaned_data['import_file_name']) data = tmp_storage.read(input_format.get_read_mode()) if not input_format.is_binary() and self.from_encoding: data = force_text(data, self.from_encoding) dataset = input_format.create_dataset(data) result = resource.import_data(dataset, dry_run=False, raise_errors=True, file_name=confirm_form.cleaned_data['original_file_name'], user=request.user) if not self.get_skip_admin_log(): # Add imported objects to LogEntry logentry_map = { RowResult.IMPORT_TYPE_NEW: ADDITION, RowResult.IMPORT_TYPE_UPDATE: CHANGE, RowResult.IMPORT_TYPE_DELETE: DELETION, } content_type_id = ContentType.objects.get_for_model(self.model).pk for row in result: if row.import_type != row.IMPORT_TYPE_SKIP: LogEntry.objects.log_action( user_id=request.user.pk, content_type_id=content_type_id, object_id=row.object_id, object_repr=row.object_repr, action_flag=logentry_map[row.import_type], change_message="%s through import_export" % row.import_type, ) if row.import_type == row.IMPORT_TYPE_NEW: total_imports += 1 elif row.import_type == row.IMPORT_TYPE_UPDATE: total_updates += 1 success_message = u'Import finished, with {} new {}{} and ' \ u'{} updated {}{}.'.format(total_imports, opts.model_name, pluralize(total_imports), total_updates, opts.model_name, pluralize(total_updates)) messages.success(request, success_message) tmp_storage.remove() url = reverse('admin:%s_%s_changelist' % self.get_model_info(), current_app=self.admin_site.name) return HttpResponseRedirect(url)
def post(self, *args, **kwargs): ''' Perform the actual import action (after the user has confirmed he wishes to import) ''' opts = self.model._meta resource = self.get_import_resource_class()() confirm_form = ConfirmImportForm(self.request.POST) if confirm_form.is_valid(): import_formats = self.get_import_formats() input_format = import_formats[int( confirm_form.cleaned_data['input_format'])]() import_file_name = os.path.join( tempfile.gettempdir(), confirm_form.cleaned_data['import_file_name']) import_file = open(import_file_name, input_format.get_read_mode()) data = import_file.read() if not input_format.is_binary() and self.from_encoding: data = force_text(data, self.from_encoding) dataset = input_format.create_dataset(data) result = resource.import_data(dataset, dry_run=False, raise_errors=True) import_file.close() #redirect to reporst visualization view #return redirect(reverse('presale_splash', kwargs=redirect_kwargs)) else: print(confirm_form.errors)
def process_import(self, request, *args, **kwargs): """ Perform the actuall import action (after the user has confirmed he wishes to import) """ opts = self.model._meta resource = self.get_resource_class()() confirm_form = ConfirmImportForm(request.POST) if confirm_form.is_valid(): import_formats = self.get_import_formats() input_format = import_formats[int(confirm_form.cleaned_data["input_format"])]() import_file = open(confirm_form.cleaned_data["import_file_name"], input_format.get_read_mode()) data = import_file.read() data = data.replace(";", ",") if not input_format.is_binary() and self.from_encoding: data = unicode(data, self.from_encoding).encode("utf-8") dataset = input_format.create_dataset(data) resource.import_data(dataset, dry_run=False, raise_errors=True) success_message = _("Import finished") messages.success(request, success_message) import_file.close() url = reverse( "admin:%s_%s_changelist" % (opts.app_label, opts.module_name), current_app=self.admin_site.name ) return HttpResponseRedirect(url)
def post(self, *args, **kwargs): ''' Perform the actual import action (after the user has confirmed he wishes to import) ''' opts = self.model._meta resource = self.get_import_resource_class()() confirm_form = ConfirmImportForm(self.request.POST) if confirm_form.is_valid(): import_formats = self.get_import_formats() input_format = import_formats[ int(confirm_form.cleaned_data['input_format']) ]() import_file_name = os.path.join( tempfile.gettempdir(), confirm_form.cleaned_data['import_file_name'] ) import_file = open(import_file_name, input_format.get_read_mode()) data = import_file.read() if not input_format.is_binary() and self.from_encoding: data = force_text(data, self.from_encoding) dataset = input_format.create_dataset(data) result = resource.import_data(dataset, dry_run=False, raise_errors=True) # Add imported objects to LogEntry ADDITION = 1 CHANGE = 2 DELETION = 3 logentry_map = { RowResult.IMPORT_TYPE_NEW: ADDITION, RowResult.IMPORT_TYPE_UPDATE: CHANGE, RowResult.IMPORT_TYPE_DELETE: DELETION, } content_type_id = ContentType.objects.get_for_model(self.model).pk ''' for row in result: LogEntry.objects.log_action( user_id=request.user.pk, content_type_id=content_type_id, object_id=row.object_id, object_repr=row.object_repr, action_flag=logentry_map[row.import_type], change_message="%s through import_export" % row.import_type, ) ''' success_message = 'Import finished' # messages.success(self.request, success_message) import_file.close() # url = reverse('%s_list' % (str(opts.app_label).lower())) url = reverse('admin:admin_user_index') return HttpResponseRedirect(url) else: print(confirm_form.clean_import_file_name()) print(confirm_form) url = reverse('admin:admin_team_index') return HttpResponseRedirect(url)
def post(self, request, *args, **kwargs): """ Perform the actual import action (after the user has confirmed he wishes to import) """ resource = self.get_import_resource_class()(**self.get_import_resource_kwargs(request, *args, **kwargs)) confirm_form = ConfirmImportForm(request.POST) if confirm_form.is_valid(): import_formats = self.get_import_formats() input_format = import_formats[ int(confirm_form.cleaned_data['input_format']) ]() tmp_storage = self.get_tmp_storage_class()(name=confirm_form.cleaned_data['import_file_name']) data = tmp_storage.read(input_format.get_read_mode()) if not input_format.is_binary() and self.from_encoding: data = force_text(data, self.from_encoding) dataset = input_format.create_dataset(data) result = resource.import_data(dataset, dry_run=False, raise_errors=True, file_name=confirm_form.cleaned_data['original_file_name'], user=request.user) if not self.get_skip_admin_log(): # Add imported objects to LogEntry logentry_map = { RowResult.IMPORT_TYPE_NEW: ADDITION, RowResult.IMPORT_TYPE_UPDATE: CHANGE, RowResult.IMPORT_TYPE_DELETE: DELETION, } content_type_id = ContentType.objects.get_for_model(self.model).pk for row in result: if row.import_type != row.IMPORT_TYPE_ERROR and row.import_type != row.IMPORT_TYPE_SKIP: LogEntry.objects.log_action( user_id=request.user.pk, content_type_id=content_type_id, object_id=row.object_id, object_repr=row.object_repr, action_flag=logentry_map[row.import_type], change_message="%s through import_export" % row.import_type, ) success_message = str(_(u'Import finished')) + ' , ' + str(_(u'Add')) + ' : %d' % result.totals[ RowResult.IMPORT_TYPE_NEW] + ' , ' + str(_(u'Update')) + ' : %d' % result.totals[ RowResult.IMPORT_TYPE_UPDATE] messages.success(request, success_message) tmp_storage.remove() post_import.send(sender=None, model=self.model) model_info = (self.opts.app_label, self.opts.model_name) url = reverse('xadmin:%s_%s_changelist' % model_info, current_app=self.admin_site.name) return HttpResponseRedirect(url)
def historian_importer(request, resource, dataset, template): context = {} if request.POST: result = resource.import_data(dataset, dry_run=True, raise_errors=False, file_name=tmp_storage.name, user=request.user) context['result'] = result if not result.has_errors(): tmp_storage = TempFolderStorage() input_format = JSON tmp_storage.save( dataset.export('json').encode(), input_format.get_read_mode) context['confirm_form'] = ConfirmImportForm( initial={ 'import_file_name': tmp_storage.name, 'original_file_name': tmp_storage.name, 'input_format': input_format }) context['fields'] = [ f.column_name for f in resource.get_user_visible_fields() ] return TemplateResponse(request, [template], context)
def process_import(self, request): confirm_form = ConfirmImportForm(request.POST) if confirm_form.is_valid(): import_formats = self.formats input_format = import_formats[int( confirm_form.cleaned_data['input_format'])]() tmp_storage = TempFolderStorage( name=confirm_form.cleaned_data['import_file_name']) dataset = self.make_dataset(tmp_storage, input_format) self.process_dataset( dataset, confirm_form.cleaned_data['original_file_name'], request) tmp_storage.remove() return redirect(self.success_url) else: pass # TODO: handle errors
def import_action(self, request, form): school = get_school(request.session) resource = self.resource_class(school=school, user=request.user) import_formats = self.formats context = {} input_format = import_formats[int(form.cleaned_data['input_format'])]() import_file = form.cleaned_data['import_file'] # first always write the uploaded file to disk as it may be a # memory file or else based on settings upload handlers tmp_storage = self.write_to_tmp_storage(import_file, input_format) # then read the file, using the proper format-specific mode # warning, big files may exceed memory try: dataset = self.make_dataset(tmp_storage, input_format) except UnicodeDecodeError as e: return HttpResponse( (u"<h1>Imported file has a wrong encoding: %s</h1>" % e)) result = resource.import_data(dataset, dry_run=True, raise_errors=False, file_name=import_file.name, user=request.user) context['result'] = result context['model'] = self.model.__name__ if not result.has_errors(): context['confirm_form'] = ConfirmImportForm( initial={ 'import_file_name': tmp_storage.name, 'original_file_name': import_file.name, 'input_format': form.cleaned_data['input_format'], }) return TemplateResponse(request, 'confirm_import.html', context)
def historian_processor(request, resource, redirect_url): confirm_form = ConfirmImportForm(request.POST) if confirm_form.is_valid(): input_format = JSON tmp_storage = TempFolderStorage( name=confirm_form.cleaned_data['import_file_name']) data = tmp_storage.read(input_format.get_read_mode()) dataset = input_format.create_dataset(data) resource.import_data( dataset, dry_run=False, raise_errors=True, file_name=confirm_form.cleaned_data['original_file_name'], user=request.user) tmp_storage.remove() return HttpResponseRedirect(reverse_lazy(redirect_url))
def get(self, *args, **kwargs): ''' Perform a dry_run of the import to make sure the import will not result in errors. If there where no error, save the user uploaded file to a local temp file that will be used by 'process_import' for the actual import. ''' resource = self.get_import_resource_class()() context = {} import_formats = self.get_import_formats() form = ImportForm(import_formats, self.request.POST or None, self.request.FILES or None) if self.request.POST and form.is_valid(): input_format = import_formats[int( form.cleaned_data['input_format'])]() import_file = form.cleaned_data['import_file'] # first always write the uploaded file to disk as it may be a # memory file or else based on settings upload handlers with tempfile.NamedTemporaryFile(delete=False) as uploaded_file: for chunk in import_file.chunks(): uploaded_file.write(chunk) # then read the file, using the proper format-specific mode with open(uploaded_file.name, input_format.get_read_mode()) as uploaded_import_file: # warning, big files may exceed memory data = uploaded_import_file.read() if not input_format.is_binary() and self.from_encoding: data = force_text(data, self.from_encoding) dataset = input_format.create_dataset(data) result = resource.import_data(dataset, dry_run=True, raise_errors=True) context['result'] = result if not result.has_errors(): context['confirm_form'] = ConfirmImportForm( initial={ 'import_file_name': os.path.basename( uploaded_file.name), 'original_file_name': uploaded_file.name, 'input_format': form.cleaned_data['input_format'], }) else: print("RESULT: {}".format(result)) context['form'] = form context['opts'] = self.model._meta context['fields'] = [f.column_name for f in resource.get_fields()] context.update(self.kwargs) return TemplateResponse(self.request, [self.import_template_name], context)
def process_import(self, request, *args, **kwargs): """ Perform the actual import action (after the user has confirmed the import) """ if not self.has_import_permission(request): raise PermissionDenied confirm_form = ConfirmImportForm(request.POST) if confirm_form.is_valid(): ori_file_name = confirm_form.cleaned_data['original_file_name'] tmp_storage = self.get_tmp_storage_class()(name=ori_file_name) tmp_file_name = confirm_form.cleaned_data['import_file_name'] tmp_path = os.path.join( os.path.dirname(tmp_storage.get_full_path()), tmp_file_name, ) taskrecord = TaskRecord(event_type='upload', input_name=ori_file_name, input_path=tmp_path, stage=taskStages.pending.value) taskrecord.save() with transaction.atomic(): result = call_delay_task(csv_importer, kwargs={'record_id': taskrecord.pk}) taskrecord.task_id = result.id taskrecord.save() # data = tmp_storage.read(input_format.get_read_mode()) # if not input_format.is_binary() and self.from_encoding: # data = force_text(data, self.from_encoding) # dataset = input_format.create_dataset(data) # result = self.process_dataset(dataset, confirm_form, request, # *args, **kwargs) # tmp_storage.remove() # return self.process_result(result, request) return self.process_result([], request)
def processor(request, resource, template, redirect_url_name): from_encoding = "utf-8" confirm_form = ConfirmImportForm(request.POST) if confirm_form.is_valid(): import_formats = [f for f in DEFAULT_FORMATS if f().can_import()] input_format = import_formats[int( confirm_form.cleaned_data['input_format'])]() tmp_storage = TempFolderStorage( name=confirm_form.cleaned_data['import_file_name']) data = tmp_storage.read(input_format.get_read_mode()) if not input_format.is_binary() and from_encoding: data = force_text(data, from_encoding) dataset = input_format.create_dataset(data) resource.import_data( dataset, dry_run=False, raise_errors=True, file_name=confirm_form.cleaned_data['original_file_name'], user=request.user) tmp_storage.remove() return HttpResponseRedirect(reverse_lazy(redirect_url_name))
def process_import(self, request, *args, **kwargs): ''' Perform the actuall import action (after the user has confirmed he wishes to import) ''' opts = self.model._meta resource = self.get_resource_class()() confirm_form = ConfirmImportForm(request.POST) if confirm_form.is_valid(): import_formats = self.get_import_formats() input_format = import_formats[ int(confirm_form.cleaned_data['input_format']) ]() import_file = open(confirm_form.cleaned_data['import_file_name'], input_format.get_read_mode()) data = import_file.read() data = data.replace(';',',') if not input_format.is_binary() and self.from_encoding: try: data = unicode(data, self.from_encoding).encode('utf-8') except: typeManager = TypeManager() data = typeManager.force_unicode(data, strings_only=True).encode('utf-8') dataset = input_format.create_dataset(data) resource.import_data(dataset, dry_run=False, raise_errors=False) success_message = _('Import finished') messages.success(request, success_message) import_file.close() url = reverse('admin:%s_%s_changelist' % (opts.app_label, opts.module_name), current_app=self.admin_site.name) return HttpResponseRedirect(url)
def import_action(self, request, *args, **kwargs): #只有超级用户和老师不能使用导入功能 try: current_group_set = Group.objects.get(user=request.user) except: return False if current_group_set.name == "老师": raise Exception("您不能使用导入功能") resource = self.get_import_resource_class()(**self.get_import_resource_kwargs(request, *args, **kwargs)) context = self.get_import_context_data() import_formats = self.get_import_formats() form_type = self.get_import_form() form = form_type(import_formats, request.POST or None, request.FILES or None) if request.POST and form.is_valid(): input_format = import_formats[ int(form.cleaned_data['input_format']) ]() import_file = form.cleaned_data['import_file'] # first always write the uploaded file to disk as it may be a # memory file or else based on settings upload handlers tmp_storage = self.write_to_tmp_storage(import_file, input_format) # then read the file, using the proper format-specific mode # warning, big files may exceed memory try: data = tmp_storage.read(input_format.get_read_mode()) if not input_format.is_binary() and self.from_encoding: data = force_text(data, self.from_encoding) dataset = input_format.create_dataset(data) except UnicodeDecodeError as e: return HttpResponse(_(u"<h1>Imported file has a wrong encoding: %s</h1>" % e)) except Exception as e: return HttpResponse( _(u"<h1>%s encountered while trying to read file: %s</h1>" % (type(e).__name__, import_file.name))) result = resource.import_data(dataset, dry_run=True, raise_errors=False, file_name=import_file.name, user=request.user) context['result'] = result if not result.has_errors(): context['confirm_form'] = ConfirmImportForm(initial={ 'import_file_name': tmp_storage.name, 'original_file_name': import_file.name, 'input_format': form.cleaned_data['input_format'], }) context.update(self.admin_site.each_context(request)) context['title'] = _("Import") context['form'] = form context['opts'] = self.model._meta context['fields'] = [f.column_name for f in resource.get_user_visible_fields()] request.current_app = self.admin_site.name return TemplateResponse(request, [self.import_template_name], context)
def get_or_post(self, *args, **kwargs): """ Perform a dry_run of the import to make sure the import will not result in errors. If there where no error, save the user uploaded file to a local temp file that will be used by 'process_import' for the actual import. """ context = self.get_context_data(**kwargs) import_formats = self.get_import_formats() form_kwargs = kwargs form = ImportForm(import_formats, self.request.POST or None, self.request.FILES or None, **form_kwargs) if self.request.POST and form.is_valid(): input_format = import_formats[int( form.cleaned_data['input_format'])]() import_file = form.cleaned_data['import_file'] # first always write the uploaded file to disk as it may be a # memory file or else based on settings upload handlers with tempfile.NamedTemporaryFile(delete=False) as uploaded_file: for chunk in import_file.chunks(): uploaded_file.write(chunk) # then read the file, using the proper format-specific mode with open(uploaded_file.name, input_format.get_read_mode()) as uploaded_import_file: # warning, big files may exceed memory data = uploaded_import_file.read() if not input_format.is_binary() and self.from_encoding: data = force_text(data, self.from_encoding) dataset = input_format.create_dataset(data) # logger.info(dataset) resource = self.get_import_resource_class()() imp_kwargs = self.get_import_data_kwargs(self.request, form=form, *args, **kwargs) result = resource.import_data(dataset, dry_run=True, raise_errors=False, user=self.request.user, request=self.request, **imp_kwargs) # logger.info(result.__dict__) # for row in result.rows: # logger.info(row.__dict__) # for row in result.invalid_rows: # logger.info(row.__dict__) context['result'] = result if not result.has_errors() and not result.has_validation_errors(): initial = { 'import_file_name': os.path.basename(uploaded_file.name), 'original_file_name': import_file.name, 'input_format': form.cleaned_data['input_format'], } context['confirm_form'] = ConfirmImportForm(initial=initial) else: resource = self.get_import_resource_class()() # set up context context['title'] = _("Import") context['form'] = form context['opts'] = self.model._meta context['fields'] = [f.column_name for f in resource.get_fields()] context['process_import_url'] = self.process_import_url context['import_breadcrumbs'] = self.import_breadcrumbs return super().render_to_response(context)
def import_action(self, request, *args, **kwargs): ''' Perform a dry_run of the import to make sure the import will not result in errors. If there where no error, save the user uploaded file to a local temp file that will be used by 'process_import' for the actual import. ''' if not self.has_import_permission(request): raise PermissionDenied resource = self.get_import_resource_class()( **self.get_import_resource_kwargs(request, *args, **kwargs)) context = self.get_import_context_data() import_formats = self.get_import_formats() fixed_file = BytesIO() if request.FILES.get('import_file'): lines = request.FILES.get('import_file').read() if lines: formated = defaultdict(int) for line in lines.decode('utf-8').split("\n"): line = line.strip() if len(line): split_line = line.split(",") sku = split_line[0] qty = split_line[1] formated[sku] += int(qty) for k, v in formated.items(): fixed_file.write(str.encode(f"{k},{v}" + "\r\n")) fixed_file.seek(0, os.SEEK_END) size = fixed_file.tell() request.FILES['import_file'] = InMemoryUploadedFile( fixed_file, 'import_file', 'file.csv', 'text/csv', size, None) form_type = self.get_import_form() form = form_type(import_formats, request.POST or None, request.FILES or None) if request.POST and form.is_valid(): input_format = import_formats[int( form.cleaned_data['input_format'])]() import_file = form.cleaned_data['import_file'] # first always write the uploaded file to disk as it may be a # memory file or else based on settings upload handlers tmp_storage = self.write_to_tmp_storage(import_file, input_format) # then read the file, using the proper format-specific mode # warning, big files may exceed memory try: data = tmp_storage.read(input_format.get_read_mode()) if not input_format.is_binary() and self.from_encoding: data = force_text(data, self.from_encoding) dataset = input_format.create_dataset(data) except UnicodeDecodeError as e: return HttpResponse( _(u"<h1>Imported file has a wrong encoding: %s</h1>" % e)) except Exception as e: return HttpResponse( _(u"<h1>%s encountered while trying to read file: %s</h1>" % (type(e).__name__, import_file.name))) result = resource.import_data(dataset, dry_run=True, raise_errors=False, file_name=import_file.name, user=request.user) context['result'] = result if not result.has_errors() and not result.has_validation_errors(): context['confirm_form'] = ConfirmImportForm( initial={ 'import_file_name': tmp_storage.name, 'original_file_name': import_file.name, 'input_format': form.cleaned_data['input_format'], }) context.update(self.admin_site.each_context(request)) context['title'] = _("Import") context['form'] = form context['opts'] = self.model._meta context['fields'] = [ f.column_name for f in resource.get_user_visible_fields() ] request.current_app = self.admin_site.name return TemplateResponse(request, [self.import_template_name], context)
def post(self, request, *args, **kwargs): """ Perform a dry_run of the import to make sure the import will not result in errors. If there where no error, save the user uploaded file to a local temp file that will be used by 'process_import' for the actual import. """ if not (self.has_change_permission() and self.has_add_permission()): raise PermissionDenied resource = self.get_import_resource_class()( **self.get_import_resource_kwargs(request, *args, **kwargs)) context = super(ImportView, self).get_context() import_formats = self.get_import_formats() form = ImportForm(import_formats, request.POST or None, request.FILES or None) if request.POST and form.is_valid(): input_format = import_formats[int( form.cleaned_data['input_format'])]() import_file = form.cleaned_data['import_file'] # first always write the uploaded file to disk as it may be a # memory file or else based on settings upload handlers tmp_storage = self.get_tmp_storage_class()() data = bytes() for chunk in import_file.chunks(): data += chunk tmp_storage.save(data, input_format.get_read_mode()) # then read the file, using the proper format-specific mode # warning, big files may exceed memory try: data = tmp_storage.read(input_format.get_read_mode()) if not input_format.is_binary() and self.from_encoding: data = force_text(data, self.from_encoding) dataset = input_format.create_dataset(data) except UnicodeDecodeError as e: return HttpResponse( _(u"<h1>Imported file has a wrong encoding: %s</h1>" % e)) except Exception as e: return HttpResponse( _(u"<h1>%s encountered while trying to read file: %s</h1>" % (type(e).__name__, import_file.name))) result = resource.import_data(dataset, dry_run=True, raise_errors=False, file_name=import_file.name, user=request.user) context['result'] = result if not result.has_errors(): context['confirm_form'] = ConfirmImportForm( initial={ 'import_file_name': tmp_storage.name, 'original_file_name': import_file.name, 'input_format': form.cleaned_data['input_format'], }) context['title'] = _("Import") + ' ' + self.opts.verbose_name context['form'] = form context['opts'] = self.model._meta context['fields'] = [ f.column_name for f in resource.get_user_visible_fields() ] request.current_app = self.admin_site.name return TemplateResponse(request, [self.import_template_name], context)
def importer(request, resource, template): ''' Perform a dry_run of the import to make sure the import will not result in errors. If there where no error, save the user uploaded file to a local temp file that will be used by 'process_import' for the actual import. ''' from_encoding = "utf-8" context = {} import_formats = [f for f in DEFAULT_FORMATS if f().can_import()] form = ImportForm(import_formats, request.POST or None, request.FILES or None) if request.POST and form.is_valid(): input_format = import_formats[int(form.cleaned_data['input_format'])]() import_file = form.cleaned_data['import_file'] tmp_storage = TempFolderStorage() try: #save data = bytes() for chunk in import_file.chunks(): data += chunk tmp_storage.save(data, input_format.get_read_mode()) #read data = tmp_storage.read(input_format.get_read_mode()) #decoding if not input_format.is_binary() and from_encoding: data = force_text(data, from_encoding) #dataset dataset = input_format.create_dataset(data) except UnicodeDecodeError as e: return HttpResponse( _(u"<h1>Imported file has a wrong encoding: %s</h1>" % e)) except Exception as e: return HttpResponse( _(u"<h1>%s encountered while trying to load or the read file: %s</h1>" % (type(e).__name__, import_file.name))) print(dataset) result = resource.import_data(dataset, dry_run=True, raise_errors=False, file_name=import_file.name, user=request.user) context['result'] = result if not result.has_errors(): context['confirm_form'] = ConfirmImportForm( initial={ 'import_file_name': tmp_storage.name, 'original_file_name': import_file.name, 'input_format': form.cleaned_data['input_format'] }) context['form'] = form context['fields'] = [ f.column_name for f in resource.get_user_visible_fields() ] return TemplateResponse(request, [template], context)