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