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 the user
uploaded file to a local temp file that will be used by
'process_import' for the actual import.
'''
resource = self.get_resource_class()()
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
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()
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')
try:
dataset = input_format.create_dataset(data)
except:
pass
result = resource.import_data(dataset, dry_run=True,
raise_errors=False)
context['result'] = result
if not result.has_errors():
context['confirm_form'] = ConfirmImportForm(initial={
'import_file_name': uploaded_file.name,
'input_format': form.cleaned_data['input_format'],
})
context['form'] = form
context['opts'] = self.model._meta
context['fields'] = [f.column_name for f in resource.get_fields()]
return TemplateResponse(request, [self.import_template_name],
context, current_app=self.admin_site.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)
