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 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)