def post(self, request, *args, **kwargs):
form = self.form_class(request.POST)
if form.is_valid():
instance = form.clean()
pnt = instance['query_point']
distance = instance['distance']
queryset = Observation.objects.filter(gispoint__distance_lte=(pnt, D(km=distance)))
# Measurements queryset
qs = Measurement.objects.filter(
interpolated=False,
observation__id__in = queryset
)
query_path = f'media/tmp/{id_generator()}.csv'
with open(query_path,'wb') as csv_file:
write_csv(qs, csv_file)
return render(request, self.template_name, {
'query': queryset,
'instance': instance,
'query_path': '/' + query_path
})
return render(request, self.template_name, {'form': form})
def make_file(session_id, query):
# делаем выборку из БД и сохраняем в csv
users_set = Users.objects.filter(query=query,
session_id=session_id).values(
'creation_date', 'username', 'name',
'location', 'friends', 'followers',
'description')
with open('users.csv', 'ab') as csv_file:
write_csv(users_set, csv_file)
tweets_set = Tweets.objects.filter(query=query,
session_id=session_id).values(
'tweet_date', 'tweet_username',
'tweet_text')
with open('tweets.csv', 'ab') as csv_file:
write_csv(tweets_set, csv_file)
name = datetime.now().strftime('%Y-%m-%d %H-%M-%S')
tweets_df = pandas.read_csv('tweets.csv')
user_info_df = pandas.read_csv('users.csv')
with pandas.ExcelWriter(name + '.xlsx') as writer:
tweets_df.to_excel(writer, sheet_name='tweets')
user_info_df.to_excel(writer, sheet_name='user_info')
with zipfile.ZipFile(name + '.zip', 'w') as zip:
zip.write(name + '.xlsx')
os.remove(name + '.xlsx')
os.remove('tweets.csv')
os.remove('users.csv')
def simple_async_csv(job_pk, qs):
job = ExportJob.objects.get(pk=job_pk)
file_obj = TemporaryFile()
write_csv(qs, file_obj)
job.complete_with(generate_filename(qs), File(file_obj))
job.save()
def simple_async_csv(job_pk, qs):
job = ExportJob.objects.get(pk=job_pk)
file_obj = TemporaryFile()
write_csv(qs, file_obj)
job.complete_with(generate_filename(qs), File(file_obj))
job.save()
def export_to_csv(modeladmin, request, queryset):
"""
add an action to export the queryset behind an admin summary page to csv
"""
field_names = []
if hasattr(queryset.model, 'csv_fields'):
field_names = queryset.model.csv_fields
csv_file_name = (f'{settings.EXPORT_CSV_MEDIA_ROOT}'
f'{timezone.localtime():%Y_%m_%d-%H_%M_%S}-'
f'{queryset.model._meta.verbose_name}.csv')
with open(csv_file_name, 'wb') as csv_file:
try:
write_csv(queryset.values(*field_names), csv_file)
except Exception as error:
modeladmin.message_user(
request, f'cannot export the data in the'
f' {queryset.model._meta.verbose_name} queryset to csv:'
f' {str(error)}',
level=messages.ERROR)
return
modeladmin.message_user(
request,
f'Data exported to {socket.getfqdn()}:/{csv_file_name}',
level=messages.INFO)
def dump_model(fq_name, fields, dump_id):
_, temp_file_path = tempfile.mkstemp()
Model = _model_from_fq_name(fq_name)
if fields is None:
queryset = Model.objects.all()
else:
queryset = Model.objects.all().values(*fields)
dt_format = get_dt_formatter()
field_serializer_map = {
field.name: dt_format for field in Model._meta.fields
if isinstance(field, (DateField, TimeField, DateTimeField))}
with open(temp_file_path, 'w') as f:
# We specify QUOTE_NONNUMERIC here but the current version of
# djqscsv coerces everything to a string. Overquoting is better
# than underquoting.
write_csv(queryset, f, quoting=csv.QUOTE_NONNUMERIC,
field_serializer_map=field_serializer_map)
model_name = Model.__name__.lower()
file_name = 'dump/{}/{}.csv'.format(dump_id, model_name)
with open(temp_file_path, 'r') as f:
destination_path = _storage.save(file_name, f)
os.remove(temp_file_path)
return [destination_path]
def handle(self, *args, **kwargs):
path = kwargs['file_location']
all_entries = Squirrel.objects.all()
with open(path, 'wb') as csv_file:
write_csv(all_entries, csv_file)
msg = f'You have successfully exported data to {path}.'
self.stdout.write(self.style.SUCCESS(msg))
def gerar_csv_completo_mp():
try:
queryset = Responsavel.objects.filter(enviado_para_mercado_pago=True)
queryset_to_csv = queryset.annotate(
get_celular=Concat('ddd_celular', V(' '), 'celular')).values(
'nome', 'alunos__nome', 'codigo_eol_aluno', 'cpf', 'email',
'get_celular', 'vinculo', 'data_nascimento', 'nome_mae',
'status', 'nao_possui_celular', 'nao_possui_email',
'responsavel_alterado')
qtd_linhas_qs = queryset_to_csv.count()
hoje = date.today()
nome_arquivo = f'responsavel_export_completo_ate_{hoje}.csv'
path = join(MEDIA_ROOT, nome_arquivo)
zip_obj = zipfile.ZipFile(path.replace('.csv', '.zip'), 'w')
log.info('Inicia geração de arquivo CSV.')
with open(path, 'wb') as csv_file:
write_csv(queryset_to_csv,
csv_file,
field_header_map={
'nome': 'nome_responsavel',
'alunos__nome': 'nome_aluno',
'get_celular': 'celular',
'nome_mae': 'nome_mae_responsavel'
},
use_verbose_names=False)
file = open(path)
reader = csv.reader(file)
qtd_linhas_arquivo = len(
list(reader)) - 1 # qtd de linhas menos o cabeçario
log.info(f'CSV gerado: Quantidade de linhas: {qtd_linhas_arquivo}')
log.info('Comprimindo arquivo')
zip_obj.write(path, basename(path))
if qtd_linhas_qs == qtd_linhas_arquivo and qtd_linhas_qs > 0:
log.info('Inicia envio de e-mail para o MP')
enviar_email_mp(
assunto=f'Lista completa novos beneficiarios - {hoje}',
mensagem=(f'E-mail automático. Não responda. ' +
f'Clique neste link para fazer download do csv: ' +
f'{url(nome_arquivo)}'),
csv=url(nome_arquivo))
else:
# TODO: Verificar uma forma de guardar essa informação no banco
log.info(
f'Divergencia no número de linhas da query ({qtd_linhas_qs}) com o número de '
f'linhas do arquivo gerado ({qtd_linhas_arquivo}) ou query sem registro. '
'Registros não foram atualizados e e-mail não foi enviado.')
except Exception as e:
log.error(
'Falha no processo de geração de arquivo e envio de e-mail: ' +
str(e))
def handle(self, *args, **options):
filename = options['filename'][0]
qset = Changeset.objects.filter(
harmful=True).select_related('user_detail').values(
'id', 'user', 'editor', 'powerfull_editor', 'comment',
'source', 'imagery_used', 'date', 'reasons', 'reasons__name',
'create', 'modify', 'delete', 'bbox', 'is_suspect', 'harmful',
'checked', 'check_user', 'check_date')
with open(filename, 'wb') as csv_file:
write_csv(qset, csv_file)
self.stdout.write('File {} created.'.format(filename))
def handle(self, *args, **options):
values = 'id fdid state name dist_model_score dist_model_score_quartile population ' \
'population_class risk_model_deaths risk_model_deaths_quartile risk_model_injuries ' \
'risk_model_injuries_quartile risk_model_fires risk_model_fires_quartile risk_model_fires_size0 ' \
'risk_model_fires_size0_quartile risk_model_fires_size1 risk_model_fires_size1_quartile ' \
'risk_model_fires_size2 risk_model_fires_size2_quartile ' \
'risk_model_size1_percent_size2_percent_sum_quartile risk_model_deaths_injuries_sum ' \
'risk_model_deaths_injuries_sum_quartile'.split()
field_map_header = {'risk_model_fires_size0': 'risk_model_fires_size1',
'risk_model_fires_size1': 'risk_model_fires_size2',
'risk_model_fires_size2': 'risk_model_fires_size3',
'risk_model_size1_percent_size2_percent_sum_quartile': 'risk_model_size2_percent_size3_percent_sum',
}
for clazz in range(0, 10):
djqscsv.write_csv(FireDepartment.objects.filter(archived=False, population_class=clazz).as_quartiles().values(*values), open('/tmp/population_class_{0}.csv'.format(clazz), 'wb'), use_verbose_names=False, field_header_map=field_map_header)
# by region
for region in ['West', 'South', 'Midwest', 'Northeast']:
djqscsv.write_csv(FireDepartment.objects.filter(archived=False, population_class__lte=8, region=region).as_quartiles().values(*values), open('/tmp/non_metropolitan_{0}.csv'.format(region), 'wb'), use_verbose_names=False, field_header_map=field_map_header)
for region in ['West', 'South', 'Midwest', 'Northeast']:
for clazz in range(0, 9):
djqscsv.write_csv(FireDepartment.objects.filter(archived=False, population_class=clazz, region=region).as_quartiles().values(*values), open('/tmp/{0}_population_class_{1}.csv'.format(region, clazz), 'wb'), use_verbose_names=False, field_header_map=field_map_header)
djqscsv.write_csv(FireDepartment.objects.filter(archived=False, population_class__in=[7, 8], region='Northeast').as_quartiles().values(*values), open('/tmp/{0}_population_class_7_8.csv'.format('Northeast', clazz), 'wb'), use_verbose_names=False, field_header_map=field_map_header)
def post(self, request, *args, **kwargs):
serializer = ExportsSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
data = serializer.data
workspace = data.get('workspace')
filename = data.get('filename')
qs = self.get_queryset(workspace)
if filename == 'False' or not filename:
return render_to_csv_response(qs)
else:
filename = utils.clean_path(filename)
with open(filename, 'wb') as csv_file:
write_csv(qs, csv_file)
return common.message(200, filename)
def write_file_csv(filename: str, records: QuerySet, zipfile: ZipFile) -> None:
"""
Writes records to a specified file in a zipfile.
:param filename: The filename to write to
:param records: The records to write
:param zipfile: The zipfile to write to
"""
if len(records) > 0:
csvfile = open('/issf/issf_prod/' + filename, 'wb+')
djqscsv.write_csv(records, csvfile, use_verbose_names=False)
csvfile.close()
zipfile.write(csvfile.name, os.path.basename(csvfile.name))
else:
return
def build_msg(self, order: Order, address: str) -> EmailMessage:
body_init = "New order has just been saved on store. Details in attached file\n"
body_addr = f"Address: {address}\n"
body_price = f"Amount to pay: {order.total_amount}\n"
msg = EmailMessage(
f"New Order {order.id}",
f"{body_init} Order Data:\n - {body_addr} - {body_price}",
"Bernini Store <*****@*****.**>",
["Orders <*****@*****.**>"])
products = order.products.all()
with open("products.csv", "wb") as attachment:
write_csv(products, attachment)
msg.attach_file("products.csv")
return msg
def get_report():
"""Generates a csv file that stores student name, creation date of
homework result and teacher name who created homework for all
completed homeworks.
"""
qs = HomeworkResult.objects.filter(done=True).values(
"author__first_name", "created", "homework__author__first_name")
headers = {
"author__first_name": "Student_name",
"created": "Creation_date",
"homework__author__first_name": "Teacher_name",
}
with open("report.csv", "wb") as csv_file:
write_csv(qs, csv_file, field_header_map=headers)
def cadastro_de_processos(request):
#Filtrando os processos por data de atualização
processos = Processos.objects.order_by('data_atualizacao')
#Verifica se o botão "cadastrar" foi apertado. Então salva os inputs do request, bem como os resultados
#dos métodos que estão na utils.py e salva na Model. Também salva em um .csv e depois renderiza com o template.
form = ProcessosForm(request.POST)
if request.method == 'POST' and 'run_script' in request.POST:
if form.is_valid():
classe = request.POST.get("classe", None)
numero = request.POST.get("numero", None)
descricao = request.POST.get("descricao", None)
emails = request.POST.get("emails", None)
incidente_id = get_incidente_id(classe, numero)
#verifica se o processo já está cadastrado no banco de dados:
try:
process_sel = Processos.objects.get(incidente_id = incidente_id)
except Processos.DoesNotExist:
data_atualizacao = get_data_atualizacao(incidente_id)
descricao_atualizacao = get_descricao_atualizacao(incidente_id)
url = "http://portal.stf.jus.br/processos/detalhe.asp?incidente=" + incidente_id
b4 = Processos(classe=str(classe), numero=str(numero), descricao=str(descricao), emails=str(emails), incidente_id=str(incidente_id), data_atualizacao = str(data_atualizacao), descricao_atualizacao = str(descricao_atualizacao), url = str(url))
b4.save()
#escrevendo uma linha em resultados.csv
fields=[classe, numero, incidente_id, descricao, data_atualizacao, descricao_atualizacao, emails, url]
with open(r'resultados.csv', 'a', encoding = 'utf-8') as f:
writer = csv.writer(f)
writer.writerow(fields)
('/cadastro_de_processos/')
messages.error(request, 'Processo já cadastrado.')
return redirect('/cadastro_de_processos/')
else:
form = ProcessosForm()
#salvando todos os querysets em um csv
qs = Processos.objects.all()
with open('lista_de_processos.csv', 'wb') as csv_file:
write_csv(qs, csv_file)
return render(request, 'consulta_a_processos/cadastro_de_processos.html')
def generate_task_csv(report, filename):
queryset = Task.objects.filter(entity=report.entity).filter(
is_deleted=False)
if report.employee:
queryset = queryset.filter(employee=report.employee)
ranged_queryset = queryset.filter(due_date__range=(report.start_date,
report.end_date))
ordered_queryset = ranged_queryset.order_by('status', 'due_date')
values_queryset = ordered_queryset.values(
'subject', 'lead__first_name', 'lead__last_name', 'lead__company_name',
'customer__first_name', 'customer__last_name', 'company__name',
'status', 'priority', 'due_date', 'deal__name',
'employee__user__first_name', 'description', 'created_at',
'notes__note')
field_header_map = {
'lead__first_name': 'lead first name',
'lead__last_name': 'lead last name',
'lead__company_name': 'lead company name',
'customer__first_name': 'customer last name',
'customer__last_name': 'customer last name',
'deal__name': 'deal name',
'employee__user__first_name': 'employee name',
'notes__note': 'note'
}
status_dict = {'O': 'Open', 'C': 'Closed', 'P': 'Progress', '': ''}
priority_dict = {'H': 'High', 'M': 'Medium', 'L': 'Low', '': ''}
WIB = Zone(WIB_ZONE, False, 'WIB')
field_serializer_map = {
'status': (lambda x: status_dict[x]),
'priority': (lambda x: priority_dict[x]),
'due_date': (lambda x: x.strftime('%d/%m/%Y')),
'created_at': (lambda x: x.now(WIB).strftime('%d/%m/%Y %H:%M:%S %Z'))
}
with open(filename, 'w') as csv_file:
write_csv(values_queryset,
csv_file,
field_header_map=field_header_map,
field_serializer_map=field_serializer_map)
def generate_lead_csv(report, filename):
queryset = Lead.objects.filter(entity=report.entity).filter(
is_deleted=False)
if report.employee:
queryset = queryset.filter(employee=report.employee)
ranged_queryset = queryset.filter(created_at__range=(report.start_date,
report.end_date))
ordered_queryset = ranged_queryset.order_by('status', 'lead_source')
values_queryset = ordered_queryset.values(
'first_name', 'last_name', 'status', 'lead_source', 'company_name',
'phone', 'mobile_phone', 'email', 'fax', 'position',
'employee__user__first_name', 'street', 'city', 'state', 'country',
'pos_code', 'description', 'created_at')
field_header_map = {'employee__user__first_name': 'employee name'}
status_dict = {'O': 'Open', 'C': 'Closed', 'CV': 'Converted', '': ''}
lead_source_dict = {
'OFA': 'Offline Ads',
'ONA': 'Online Ads',
'CC': 'Cold Call',
'IR': 'Internal Referral',
'ER': 'External Referral',
'P': 'Partner',
'S': 'Sales',
'TS': 'Trade Show',
'SR': 'Seminar',
'': ''
}
WIB = Zone(WIB_ZONE, False, 'WIB')
field_serializer_map = {
'status': (lambda x: status_dict[x]),
'lead_source': (lambda x: lead_source_dict[x]),
'created_at': (lambda x: x.now(WIB).strftime('%d/%m/%Y %H:%M:%S %Z'))
}
with open(filename, 'w') as csv_file:
write_csv(values_queryset,
csv_file,
field_header_map=field_header_map,
field_serializer_map=field_serializer_map)
def generate_deal_csv(report, filename):
queryset = Deal.objects.filter(entity=report.entity).filter(
is_deleted=False)
if report.employee:
queryset = queryset.filter(employee=report.employee)
ranged_queryset = queryset.filter(
expected_closing_date__range=(report.start_date, report.end_date))
ordered_queryset = ranged_queryset.order_by('status',
'expected_closing_date')
values_queryset = ordered_queryset.values(
'name', 'customer__first_name', 'customer__last_name', 'company__name',
'status', 'expected_closing_date', 'expected_revenue',
'employee__user__first_name', 'description', 'created_at')
field_header_map = {
'customer__first_name': 'customer first name',
'customer__last_name': 'customer last name',
'company__name': 'company name',
'employee__user__first_name': 'employee name'
}
status_dict = {
'O': 'Open',
'P': 'Progress',
'CW': 'Won',
'CL': 'Lost',
'': ''
}
WIB = Zone(WIB_ZONE, False, 'WIB')
field_serializer_map = {
'status': (lambda x: status_dict[x]),
'expected_closing_date': (lambda x: x.strftime('%d/%m/%Y')),
'created_at': (lambda x: x.now(WIB).strftime('%d/%m/%Y %H:%M:%S %Z'))
}
with open(filename, 'w') as csv_file:
write_csv(values_queryset,
csv_file,
field_header_map=field_header_map,
field_serializer_map=field_serializer_map)
def export_book_loan(self, data):
# getting report path declared in settings
base_path = EXPORT_REPORT_URL
# Initial file name
file_name = "export_book_loan_"
try:
# this if else block defines if the report will be for specific status of loan or for all
if data.get("status"):
queryset = BookLoan.objects.filter(status=data["status"])
file_name += str(data.get("status")) + "_"
else:
queryset = BookLoan.objects.all()
file_name += "all_"
# adding timestamp to file name to make unique file name
timestamp = round(datetime.datetime.now().timestamp())
file_name += str(timestamp) + ".csv"
file_path = base_path + file_name
with open(file_path[1:], 'wb') as csv_file:
write_csv(queryset, csv_file)
return {"file_path": file_path}
except:
return {"error": "Invalid Book Loan Data or file generation failed"}
def downloadDB(request): """ Download database contents as a zipped folder of CSVs """ #magically get a list of all models models = DBManager.get_model_list() home_dir = FileSystemManager.getHomeDir() file_list = [] for model in models: if model._meta.verbose_name == "intersection task": #it doesn't make sense to dump these continue #get all objects for this model queryset = DBManager.dump_model(model) #write 1 csv per model, temporarily to homedir with open(home_dir + "/" + model._meta.verbose_name+".csv", "wb") as file: djqscsv.write_csv(queryset, file, use_verbose_names=False) file_list.append(file.name) file.close() #make sure there isn't an old copy of this file laying around if os.path.exists(home_dir + "/db.zip"): os.remove(home_dir + "/db.zip") #create zip FileSystemManager.zip(file_list, "db.zip") #wrap up and respond with open(home_dir +"/db.zip") as file: wrapper = FileWrapper(file) response = HttpResponse(wrapper) response['Content-Type'] = "application/zip" response['Content-Disposition'] = 'attachment; filename=db.zip' #clean up for file in file_list: os.remove(file) return response
def export(filename, export_type, task_id=None):
""" export pillbox data in json and csv format """
acccepted_types = ['json', 'yaml', 'xml', 'csv']
if export_type in acccepted_types:
pills = PillBoxData.objects.all()
export_path = join(settings.MEDIA_ROOT, 'export')
check_create_folder(export_path)
export_file = join(export_path, '%s.%s' % (filename, export_type))
if exists(export_file):
i = 0
while exists(export_file):
i += 1
export_file = join(
export_path, '%s_%s.%s' % (filename, str(i), export_type))
e_file = open(export_file, 'w')
if export_type == 'csv':
write_csv(pills, e_file)
e_file.close()
else:
data = serializers.serialize(export_type, pills)
e_file.write(data)
e_file.close()
return 'export/' + ntpath.basename(e_file.name)
else:
raise Exception(
"Incorrect Export Type. Accepted types: 'json', 'yaml', 'xml', 'csv'"
)
def _prepare_csv(self):
"""
generate a comma-separated file with the values in the
:attr:`Email.data` if required via the :attr:`Email.add_csv` attribute
value
If the :attr:`data` is empty, the comma-separated file will not be
created.
The file will be named by linking the value of the :attr:`email subject
<p_soc_auto_base.models.Subscription.email_subject> attribute of the
:attr:`Email.subscription` instance member with a time stamp.
The file will be saved under the path described by
:attr:`p_soc_auto.settings.CSV_MEDIA_ROOT`.
"""
if not self.add_csv or not self.data:
return
filename = 'no_name'
if self.subscription_obj.email_subject:
filename = self.subscription_obj.email_subject.\
replace('in less than', 'soon').\
replace(' ', '_')
filename = '{}{:%Y_%m_%d-%H_%M_%S}_{}.csv'.format(
settings.CSV_MEDIA_ROOT, timezone.localtime(value=timezone.now()),
filename)
with open(filename, 'wb') as csv_file:
write_csv(self.data.values(*self.headers.keys()),
csv_file,
field_header_map=self.headers)
LOG.debug('attachment %s ready', filename)
self.csv_file = filename
def async_csv_export(job, model, query, display_filters):
instance = job.instance
if model == 'species':
initial_qs = (Species.objects.filter(instance=instance))
extra_select, values = extra_select_and_values_for_model(
instance, job, 'treemap_species', 'Species')
ordered_fields = values + extra_select.keys()
limited_qs = initial_qs.extra(select=extra_select)\
.values(*ordered_fields)
else:
# model == 'tree'
# TODO: if an anonymous job with the given query has been
# done since the last update to the audit records table,
# just return that job
# get the plots for the provided
# query and turn them into a tree queryset
initial_qs = Filter(query, display_filters, instance)\
.get_objects(Tree)
extra_select_tree, values_tree = extra_select_and_values_for_model(
instance, job, 'treemap_tree', 'Tree')
extra_select_plot, values_plot = extra_select_and_values_for_model(
instance, job, 'treemap_mapfeature', 'Plot', prefix='plot')
extra_select_sp, values_sp = extra_select_and_values_for_model(
instance, job, 'treemap_species', 'Species', prefix='species')
if 'plot__geom' in values_plot:
values_plot = [f for f in values_plot if f != 'plot__geom']
values_plot += ['plot__geom__x', 'plot__geom__y']
get_ll = 'ST_Transform(treemap_mapfeature.the_geom_webmercator, 4326)'
extra_select = {
'plot__geom__x': 'ST_X(%s)' % get_ll,
'plot__geom__y': 'ST_Y(%s)' % get_ll
}
extra_select.update(extra_select_tree)
extra_select.update(extra_select_plot)
extra_select.update(extra_select_sp)
ordered_fields = (sorted(values_tree) + sorted(values_plot) +
sorted(values_sp))
if ordered_fields:
limited_qs = initial_qs.extra(select=extra_select)\
.values(*ordered_fields)
else:
limited_qs = initial_qs.none()
if not initial_qs.exists():
job.status = ExportJob.EMPTY_QUERYSET_ERROR
# if the initial queryset was not empty but the limited queryset
# is empty, it means that there were no fields which the user
# was allowed to export.
elif not limited_qs.exists():
job.status = ExportJob.MODEL_PERMISSION_ERROR
else:
csv_file = TemporaryFile()
write_csv(limited_qs, csv_file, field_order=ordered_fields)
job.complete_with(generate_filename(limited_qs), File(csv_file))
job.save()
def simple_async_csv(job, qs):
file_obj = TemporaryFile()
write_csv(qs, file_obj)
job.complete_with(generate_filename(qs), File(file_obj))
job.save()
def async_csv_export(job, model, query, display_filters):
instance = job.instance
select = OrderedDict()
select_params = []
field_header_map = {}
field_serializer_map = {}
if model == 'species':
initial_qs = (Species.objects.
filter(instance=instance))
values = _values_for_model(instance, job, 'treemap_species',
'Species', select, select_params)
field_names = values + select.keys()
limited_qs = (initial_qs
.extra(select=select,
select_params=select_params)
.values(*field_names))
else:
# model == 'tree'
# TODO: if an anonymous job with the given query has been
# done since the last update to the audit records table,
# just return that job
# get the plots for the provided
# query and turn them into a tree queryset
initial_qs = Filter(query, display_filters, instance)\
.get_objects(Plot)
tree_fields = _values_for_model(
instance, job, 'treemap_tree', 'Tree',
select, select_params,
prefix='tree')
plot_fields = _values_for_model(
instance, job, 'treemap_mapfeature', 'Plot',
select, select_params)
species_fields = _values_for_model(
instance, job, 'treemap_species', 'Species',
select, select_params,
prefix='tree__species')
if 'geom' in plot_fields:
plot_fields = [f for f in plot_fields if f != 'geom']
plot_fields += ['geom__x', 'geom__y']
if tree_fields:
select['tree_present'] = "treemap_tree.id is not null"
plot_fields += ['tree_present']
get_ll = 'ST_Transform(treemap_mapfeature.the_geom_webmercator, 4326)'
select['geom__x'] = 'ST_X(%s)' % get_ll
select['geom__y'] = 'ST_Y(%s)' % get_ll
plot_fields += ['updated_by__username']
field_names = set(tree_fields + plot_fields + species_fields)
if field_names:
field_header_map = _csv_field_header_map(field_names)
field_serializer_map = _csv_field_serializer_map(instance,
field_names)
limited_qs = (initial_qs
.extra(select=select,
select_params=select_params)
.values(*field_header_map.keys()))
else:
limited_qs = initial_qs.none()
if not initial_qs.exists():
job.status = ExportJob.EMPTY_QUERYSET_ERROR
# if the initial queryset was not empty but the limited queryset
# is empty, it means that there were no fields which the user
# was allowed to export.
elif not limited_qs.exists():
job.status = ExportJob.MODEL_PERMISSION_ERROR
else:
csv_file = TemporaryFile()
write_csv(limited_qs, csv_file,
field_order=field_header_map.keys(),
field_header_map=field_header_map,
field_serializer_map=field_serializer_map)
filename = generate_filename(limited_qs).replace('plot', 'tree')
job.complete_with(filename, File(csv_file))
job.save()
def simple_async_csv(job, qs):
file_obj = TemporaryFile()
write_csv(qs, file_obj)
job.complete_with(generate_filename(qs), File(file_obj))
job.save()
from djqscsv import render_to_csv_response, write_csv
from mpa.models import Mpa
qs = Mpa.objects.filter(country='PLW')
with open('/Users/russmo/Desktop/palau_mpatlas_20141128.csv', 'w') as csv_file:
write_csv(qs, csv_file, use_verbose_names=False)
def daterange(request):
try:
print("TRYING")
datetime.datetime.strptime(request.POST['datepicker'], '%m/%d/%Y')
except:
return render(
request,
'vaccine/dashboard2.html',
{
# 'error_message': "Select date",
})
try:
print(request.POST['datepicker'])
one = request.POST['datepicker']
# print(request.POST['datepicker2'])
#two = request.POST['datepicker2']
one = datetime.datetime.strptime(one, '%m/%d/%Y')
# two = datetime.datetime.strptime(two,'%m/%d/%Y')
except (KeyError):
# # Redisplay the question voting form.
return render(request, 'vaccine/dashboard2.html', {
'error_message':
"Please select dates from the calendar options.",
})
print("no selection yet")
def filterData(dateStart, dateEnd):
filteredOnRange = Personmini.objects.filter(
datevaccinatednumone__range=[dateStart, dateEnd])
return filteredOnRange
def makeDate(datetimeobj):
x = str(datetimeobj.year) + '-'
if (len(str(datetimeobj.month)) == 1):
x = x + '0' + str(datetimeobj.month) + '-'
else:
x = x + str(datetimeobj.month) + '-'
if (len(str(datetimeobj.day)) == 1):
x = x + '0' + str(datetimeobj.day)
else:
x = x + str(datetimeobj.day)
return x
def filterDate(date):
# print(type(date))
print("filter Date")
print(makeDate(date))
x = makeDate(date)
# x = datetime.datetime.strptime(date, '%m/%d/%Y')
# filteredDate = Personmini.objects.filter(datevaccinatednumone__date=date.year)
# return filteredDate
filteredDate = Personmini.objects.filter(
datevaccinatednumone__startswith=x)
return filteredDate
# vaccinated_people = filterData(one, two)
# print(makeDate(one))
vaccinated_people = filterDate(one)
## ADD TABLE QUERIES AND MAKE CSV
print(vaccinated_people)
# error_message = " "
# context = {'error_message': error_message}
with open('vaccinated_data.csv', 'wb') as csv_file:
write_csv(vaccinated_people, csv_file)
return render_to_csv_response(vaccinated_people)
def csv_export(job_pk, model, query, display_filters):
job = ExportJob.objects.get(pk=job_pk)
instance = job.instance
if model == 'species':
initial_qs = (Species.objects.
filter(instance=instance))
extra_select, values = extra_select_and_values_for_model(
instance, job, 'treemap_species', 'species')
ordered_fields = values + extra_select.keys()
limited_qs = initial_qs.extra(select=extra_select)\
.values(*ordered_fields)
else:
# model == 'tree'
# TODO: if an anonymous job with the given query has been
# done since the last update to the audit records table,
# just return that job
# get the plots for the provided
# query and turn them into a tree queryset
initial_qs = Filter(query, display_filters, instance)\
.get_objects(Tree)
extra_select_tree, values_tree = extra_select_and_values_for_model(
instance, job, 'treemap_tree', 'Tree')
extra_select_plot, values_plot = extra_select_and_values_for_model(
instance, job, 'treemap_mapfeature', 'Plot',
prefix='plot')
extra_select_sp, values_sp = extra_select_and_values_for_model(
instance, job, 'treemap_species', 'Species',
prefix='species')
if 'plot__geom' in values_plot:
values_plot = [f for f in values_plot if f != 'plot__geom']
values_plot += ['plot__geom__x', 'plot__geom__y']
extra_select = {'plot__geom__x':
'ST_X(treemap_mapfeature.the_geom_webmercator)',
'plot__geom__y':
'ST_Y(treemap_mapfeature.the_geom_webmercator)'}
extra_select.update(extra_select_tree)
extra_select.update(extra_select_plot)
extra_select.update(extra_select_sp)
ordered_fields = (sorted(values_tree) +
sorted(values_plot) +
sorted(values_sp))
if ordered_fields:
limited_qs = initial_qs.extra(select=extra_select)\
.values(*ordered_fields)
else:
limited_qs = initial_qs.none()
if not initial_qs.exists():
job.status = ExportJob.EMPTY_QUERYSET_ERROR
# if the initial queryset was not empty but the limited queryset
# is empty, it means that there were no fields which the user
# was allowed to export.
elif not limited_qs.exists():
job.status = ExportJob.MODEL_PERMISSION_ERROR
else:
csv_file = TemporaryFile()
write_csv(limited_qs, csv_file, field_order=ordered_fields)
csv_name = generate_filename(limited_qs)
job.outfile.save(csv_name, File(csv_file))
job.status = ExportJob.COMPLETE
job.save()
def async_csv_export(job, model, query, display_filters):
instance = job.instance
select = OrderedDict()
select_params = []
field_header_map = {}
if model == 'species':
initial_qs = (Species.objects.filter(instance=instance))
values = _values_for_model(instance, job, 'treemap_species', 'Species',
select, select_params)
field_names = values + select.keys()
limited_qs = (initial_qs.extra(
select=select, select_params=select_params).values(*field_names))
else:
# model == 'tree'
# TODO: if an anonymous job with the given query has been
# done since the last update to the audit records table,
# just return that job
# get the plots for the provided
# query and turn them into a tree queryset
initial_qs = Filter(query, display_filters, instance)\
.get_objects(Plot)
tree_fields = _values_for_model(instance,
job,
'treemap_tree',
'Tree',
select,
select_params,
prefix='tree')
plot_fields = _values_for_model(instance, job, 'treemap_mapfeature',
'Plot', select, select_params)
species_fields = _values_for_model(instance,
job,
'treemap_species',
'Species',
select,
select_params,
prefix='tree__species')
if 'geom' in plot_fields:
plot_fields = [f for f in plot_fields if f != 'geom']
plot_fields += ['geom__x', 'geom__y']
if tree_fields:
select['tree_present'] = "treemap_tree.id is not null"
plot_fields += ['tree_present']
get_ll = 'ST_Transform(treemap_mapfeature.the_geom_webmercator, 4326)'
select['geom__x'] = 'ST_X(%s)' % get_ll
select['geom__y'] = 'ST_Y(%s)' % get_ll
field_names = set(tree_fields + plot_fields + species_fields)
if field_names:
field_header_map = _csv_field_header_map(field_names)
limited_qs = (initial_qs.extra(
select=select,
select_params=select_params).values(*field_header_map.keys()))
else:
limited_qs = initial_qs.none()
if not initial_qs.exists():
job.status = ExportJob.EMPTY_QUERYSET_ERROR
# if the initial queryset was not empty but the limited queryset
# is empty, it means that there were no fields which the user
# was allowed to export.
elif not limited_qs.exists():
job.status = ExportJob.MODEL_PERMISSION_ERROR
else:
csv_file = TemporaryFile()
write_csv(limited_qs,
csv_file,
field_order=field_header_map.keys(),
field_header_map=field_header_map)
filename = generate_filename(limited_qs).replace('plot', 'tree')
job.complete_with(filename, File(csv_file))
job.save()
def async_csv_export(job, model, query, display_filters):
instance = job.instance
select = OrderedDict()
select_params = []
if model == "species":
initial_qs = Species.objects.filter(instance=instance)
values = values_for_model(instance, job, "treemap_species", "Species", select, select_params)
ordered_fields = values + select.keys()
limited_qs = initial_qs.extra(select=select, select_params=select_params).values(*ordered_fields)
else:
# model == 'tree'
# TODO: if an anonymous job with the given query has been
# done since the last update to the audit records table,
# just return that job
# get the plots for the provided
# query and turn them into a tree queryset
initial_qs = Filter(query, display_filters, instance).get_objects(Tree)
values_tree = values_for_model(instance, job, "treemap_tree", "Tree", select, select_params)
values_plot = values_for_model(
instance, job, "treemap_mapfeature", "Plot", select, select_params, prefix="plot"
)
values_sp = values_for_model(
instance, job, "treemap_species", "Species", select, select_params, prefix="species"
)
if "plot__geom" in values_plot:
values_plot = [f for f in values_plot if f != "plot__geom"]
values_plot += ["plot__geom__x", "plot__geom__y"]
get_ll = "ST_Transform(treemap_mapfeature.the_geom_webmercator, 4326)"
select["plot__geom__x"] = "ST_X(%s)" % get_ll
select["plot__geom__y"] = "ST_Y(%s)" % get_ll
ordered_fields = sorted(values_tree) + sorted(values_plot) + sorted(values_sp)
if ordered_fields:
limited_qs = initial_qs.extra(select=select, select_params=select_params).values(*ordered_fields)
else:
limited_qs = initial_qs.none()
if not initial_qs.exists():
job.status = ExportJob.EMPTY_QUERYSET_ERROR
# if the initial queryset was not empty but the limited queryset
# is empty, it means that there were no fields which the user
# was allowed to export.
elif not limited_qs.exists():
job.status = ExportJob.MODEL_PERMISSION_ERROR
else:
csv_file = TemporaryFile()
write_csv(limited_qs, csv_file, field_order=ordered_fields)
job.complete_with(generate_filename(limited_qs), File(csv_file))
job.save()
