def get(self, request, ftid):
footprint = get_object_or_404(Footprints, id=ftid)
try:
floors = Floors.objects.filter(footprint=footprint)
except:
raise CommandError(
'No Floors registered for this footprint. Kindly register and try again'
)
else:
fls = []
for floor in floors:
fls.append({
'name': floor.floor_name,
'no': floor.floor_no,
'rooms': Rooms.objects.filter(floor=floor).count()
})
return JsonResponse({'objs': fls})
def handle(self, app_label=None, revision=None, **kwargs):
appconfig = self.lookup_app(app_label)
if ":" in revision:
raise CommandError("Range revision is not allowed")
self.stdout.write(
self.style.SUCCESS("Stamping revision for %s on database %s" %
(appconfig.name, appconfig.db.alias)))
with alembic.context.EnvironmentContext(
appconfig.config,
appconfig.script,
fn=partial(self.stamp, appconfig=appconfig, revision=revision),
destination_rev=revision,
) as context:
self.run_env(context, appconfig)
def handle(self, *args, **options):
if settings.DEBUG:
self.stdout.write('Start parsing')
country_parser = CountryParser()
country_parser.get_countries()
country_parser.get_alternate_names()
country_parser.get_alternate_locale_names('ru')
city_parser = CityParser()
city_parser.get_cities()
city_parser.get_alternate_names()
city_parser.get_alternate_locale_names('ru')
self.stdout.write('Successful parsing!')
else:
raise CommandError('ERROR: Please set debug mode')
def handle_one_table(self, table_name):
if table_name not in self.tables_to_export:
raise CommandError('table "%s" is not supported' % table_name)
count = 0
with closing(connection.cursor()) as cursor:
cursor.execute('SELECT COUNT(*) FROM ' + table_name)
count, = cursor.fetchone()
print('processing %s' % table_name, ',', count, 'items')
sql = 'SELECT * FROM ' + table_name
filename_csv = settings.MEDIA_ROOT + '/raw/' + table_name + '.csv'
for offset in range(0, count, self.BATCH_SIZE):
with closing(connection.cursor()) as cursor:
cursor.execute(sql + ' LIMIT ' + str(self.BATCH_SIZE) +
' OFFSET ' + str(offset))
self.dump_cursor(cursor, filename_csv, append=(offset > 0))
def handle(self, *args, **options):
options.setdefault('interactive', False)
database = options.get('database')
email = options.get('email')
password = options.get('password')
if not password or not email:
raise CommandError("--email and --password are required options")
user_data = {
'email': email,
'password': password,
}
exists = self.UserModel._default_manager.db_manager(database).filter(email=email).exists()
if not exists:
self.UserModel._default_manager.db_manager(database).create_superuser(**user_data)
def handle(self, *args, **options):
if not Option.objects.exists():
Option.objects.create(name="site_name", value='TdxStock')
Option.objects.create(name="site_host", value='localhost')
Option.objects.create(name="site_description", value='沪深股票分析')
options = [
Option(name=name, value=None) for name in [
'site_seo_description', 'site_keywords',
'open_site_comment', 'beian_code', 'gongan_beian_code',
'show_gongan_code'
]
]
Option.objects.bulk_create(options)
self.stdout.write(self.style.SUCCESS('填充 options 表成功'))
else:
raise CommandError('options 表中已经有数据')
def execute_deposits(cls):
pending_deposits = Transaction.objects.filter(
kind=Transaction.KIND.deposit,
status=Transaction.STATUS.pending_user_transfer_start,
)
try:
ready_transactions = rdi.poll_pending_deposits(pending_deposits)
except NotImplementedError as e:
raise CommandError(e)
for transaction in ready_transactions:
try:
success = execute_deposit(transaction)
except ValueError as e:
logger.error(f"poll_pending_transactions: {str(e)}")
continue
if success:
rdi.after_deposit(transaction)
def select_resources(resources, selected_resources):
ret = []
for res_id in selected_resources:
for res in resources:
try:
if int(res_id) == res.id:
break
except ValueError:
pass
if res_id == res.principal_email:
break
if res_id == res.resource.id:
break
else:
raise CommandError('Resource with ID "%s" not found' % res_id)
ret.append(res)
return ret
def render_field_variations(kwargs):
kwargs["storage"] = get_storage_class(kwargs["storage"])()
ignore_missing = kwargs.pop("ignore_missing")
do_render = kwargs.pop("do_render")
try:
if callable(do_render):
kwargs.pop("field_class")
do_render = do_render(**kwargs)
if do_render:
render_variations(**kwargs)
except FileNotFoundError as e:
if not ignore_missing:
print(ignore_missing)
raise CommandError(
"Source file was not found, terminating. "
"Use -i/--ignore-missing to skip this error.") from e
return kwargs["file_name"]
def create_tables( # noqa:C901
command: BaseCommand, datasets: Iterable[Dataset], allow_unmanaged=False
): # noqa:C901
"""Create tables for all updated datasets.
This is a separate function to allow easy reuse.
"""
errors = 0
command.stdout.write("Creating tables")
# First create all models. This allows Django to resolve model relations.
models = []
for dataset in datasets:
models.extend(schema_models_factory(dataset.schema, base_app_name="dso_api.dynamic_api"))
# Create all tables
with connection.schema_editor() as schema_editor:
for model in models:
# Only create tables if migration is allowed
# - router allows it (not some external database)
# - model is managed (not by default)
# - user overrides this (e.g. developer)
db_table_name = model._meta.db_table
router_allows = router.allow_migrate_model(model._meta.app_label, model)
if not router_allows:
command.stdout.write(
f" Skipping externally managed table: {db_table_name}"
)
continue
if not allow_unmanaged and not model._meta.can_migrate(connection):
command.stderr.write(
f" Skipping non-managed model: {model._meta.db_table}"
)
continue
try:
command.stdout.write(f"* Creating table {model._meta.db_table}")
with transaction.atomic():
schema_editor.create_model(model)
except (DatabaseError, ValueError) as e:
command.stderr.write(f" Tables not created: {e}")
if not re.search(r'relation "[^"]+" already exists', str(e)):
errors += 1
if errors:
raise CommandError("Not all tables could be created")
def handle(self, **options):
from django.utils import translation
translation.activate(settings.LANGUAGE_CODE)
self.backends = options.get('using')
if not self.backends:
self.backends = list(haystack_connections.connections_info.keys())
alias_mappings = []
# Use a timestamped index instead of the default in settings.
for backend_name in self.backends:
connection = haystack_connections[backend_name]
backend = connection.get_backend()
record_count = self.get_record_count(backend.conn,
backend.index_name)
alias, index_name = self.prepare_backend_index(backend)
alias_mappings.append((backend, index_name, alias, record_count))
# Set the alias (from settings) to the timestamped catalog.
run_attempts = 0
indexes_pending = {key: '' for key in [x[1] for x in alias_mappings]}
while indexes_pending and run_attempts < 2:
run_attempts += 1
super(Command, self).handle(**options)
for backend, index, alias, record_count in alias_mappings:
# Run a sanity check to ensure we aren't drastically changing the
# index, which could be indicative of a bug.
if index in indexes_pending and not options.get(
'disable_change_limit', False):
record_count_is_sane, index_info_string = self.sanity_check_new_index(
backend.conn, index, record_count)
if record_count_is_sane:
self.set_alias(backend, alias, index)
indexes_pending.pop(index, None)
else:
indexes_pending[index] = index_info_string
else:
self.set_alias(backend, alias, index)
indexes_pending.pop(index, None)
if indexes_pending:
raise CommandError(
'Sanity check failed for new index(es): {}'.format(
indexes_pending))
def handle(self, *args, **options):
course_ids_file = options['course_ids_file']
batch_limit = options['batch_limit']
if course_ids_file:
if not os.path.exists(course_ids_file):
raise CommandError('Pass the correct absolute path to course ids file as --course_ids_file argument.')
total_courses, failed_courses = self._generate_enrollment_codes_from_file(course_ids_file)
else:
total_courses, failed_courses = self._generate_enrollment_codes_from_db(batch_limit)
if failed_courses:
logger.error('Completed enrollment codes generation. %d of %d failed.', len(failed_courses), total_courses)
logger.error('\n'.join(['Failed courses:'] + failed_courses))
else:
logger.info('Successfully generated enrollment codes for the batch of %s courses.', total_courses)
def handle(self, *args, **options):
programs_config = ProgramsApiConfig.current()
self.client = Client.objects.get(name=programs_config.OAUTH2_CLIENT_NAME)
if self.client.user is None:
msg = (
'No user is associated with the {} OAuth2 client. '
'A service user is necessary to make requests to the Programs API. '
'No tasks have been enqueued. '
'Associate a user with the client and try again.'
).format(programs_config.OAUTH2_CLIENT_NAME)
raise CommandError(msg)
self._load_run_modes()
logger.info('Looking for users who may be eligible for a program certificate.')
self._load_usernames()
if options.get('commit'):
logger.info('Enqueuing program certification tasks for %d candidates.', len(self.usernames))
else:
logger.info(
'Found %d candidates. To enqueue program certification tasks, pass the -c or --commit flags.',
len(self.usernames)
)
return
succeeded, failed = 0, 0
for username in self.usernames:
try:
award_program_certificates.delay(username)
except: # pylint: disable=bare-except
failed += 1
logger.exception('Failed to enqueue task for user [%s]', username)
else:
succeeded += 1
logger.debug('Successfully enqueued task for user [%s]', username)
logger.info(
'Done. Successfully enqueued tasks for %d candidates. '
'Failed to enqueue tasks for %d candidates.',
succeeded,
failed
)
def handle(self, *args, **options):
# Get the backend to use
channel_backend = channel_backends[DEFAULT_CHANNEL_BACKEND]
auto_import_consumers()
if channel_backend.local_only:
raise CommandError(
"You have a process-local channel backend configured, and so cannot run separate interface servers.\n"
"Configure a network-based backend in CHANNEL_BACKENDS to use this command."
)
# Run the interface
port = options.get("port", None) or 9000
self.stdout.write(
"Running Twisted/Autobahn WebSocket interface server")
self.stdout.write(" Channel backend: %s" % channel_backend)
self.stdout.write(" Listening on: ws://0.0.0.0:%i" % port)
WebsocketTwistedInterface(channel_backend=channel_backend,
port=port).run()
def handle(self, files, migrate=False, num_workers=10, **options):
set_max_connections(num_workers)
blob_db = get_blob_db()
if not isinstance(blob_db, MigratingBlobDB):
raise CommandError(
"Expected to find migrating blob db backend (got %r)" %
blob_db)
old_db = blob_db.old_db
new_db = blob_db.new_db
ignored = 0
try:
pool = Pool(size=num_workers)
for filepath in files:
print("Processing {}".format(filepath))
with open(filepath, encoding='utf-8') as fh:
for line in fh:
if not line:
continue
try:
rec = json.loads(line)
except ValueError:
ignored += 1
print(("Ignore {}", line))
continue
pool.spawn(process, rec, old_db, new_db, migrate)
print("CTRL+C to abort")
while not pool.join(timeout=10):
print("waiting for {} workers to finish...".format(len(pool)))
except KeyboardInterrupt:
pass
if ignored:
print("Ignored {} malformed records".format(ignored))
for type_code, stats in sorted(Stats.items.items()):
try:
group = BLOB_MIXIN_MODELS[type_code].__name__
except KeyError:
group = CODES.name_of(type_code, "type_code %s" % type_code)
total = stats.new + stats.old + stats.noref + stats.lost
print("{}: checked {} records".format(group, total))
print(" Found in new db: {}".format(stats.new))
print(" Found in old db: {}".format(stats.old))
print(" Not referenced: {}".format(stats.noref))
print(" Not found: {}".format(stats.lost))
def handle(self, *args: Any, **kwargs: str) -> None:
if settings.WARN_NO_EMAIL:
raise CommandError("Outgoing email not yet configured, see\n "
"https://zulip.readthedocs.io/en/latest/production/email.html")
message = ("Success! If you receive this message, you've "
"successfully configured sending email from your "
"Zulip server. Remember that you need to restart "
"the Zulip server with /home/zulip/deployments/current/scripts/restart-server "
"after changing the settings in /etc/zulip before your changes will take effect.")
send_mail("Zulip email test", message, FromAddress.SUPPORT, kwargs['email'])
send_mail("Zulip noreply email test", message, FromAddress.tokenized_no_reply_address(), kwargs['email'])
if kwargs['managers']:
mail_managers("Zulip manager email test", "This email was sent to the site managers.")
if kwargs['admins']:
mail_admins("Zulip admins email test", "This email was sent to the site admins.")
def run_django_distill(self):
"""Outputs static files into the output dir."""
if not os.path.isdir(settings.STATIC_ROOT):
e = "Static source directory does not exist, run collectstatic"
raise CommandError(e)
output_dir = self.output_dir
if os.path.isdir(output_dir):
rmtree(output_dir)
os.makedirs(output_dir)
self.stdout.write(f"\n{self.output_dir}")
save_url_as_static_file(output_dir, "/status/", "status/index.html")
tbranches = TranslationBranch.objects.filter(complete=False)
for tbranch_id in tbranches.values_list("id", flat=True):
save_url_as_static_file(
output_dir,
f"/status/{tbranch_id}/",
f"status/{tbranch_id}.html",
)
legalcodes = LegalCode.objects.validgroups()
for group in legalcodes.keys():
self.stdout.write(f"\n{self.output_dir}")
for legalcode in legalcodes[group]:
# deed
filepath, symlinks = legalcode.get_file_and_links("deed")
save_url_as_static_file(
output_dir,
legalcode.deed_url,
filepath,
)
for symlink in symlinks:
relative_symlink(output_dir, filepath, symlink)
# legalcode
filepath, symlinks = legalcode.get_file_and_links("legalcode")
save_url_as_static_file(
output_dir,
legalcode.license_url,
filepath,
)
for symlink in symlinks:
relative_symlink(output_dir, filepath, symlink)
self.stdout.write(f"\n{self.output_dir}")
save_url_as_static_file(output_dir, reverse("metadata"),
"licenses/metadata.yaml")
def handle(self, *args, **options):
site_id = options.get('site_id')
site_domain = options.get('site_domain')
site_name = options.get('site_name')
enable_facebook_sharing = options.get('enable_facebook_sharing')
facebook_app_id = options.get('facebook_app_id')
if enable_facebook_sharing and not facebook_app_id:
raise CommandError(
'A Facebook app ID must be supplied to enable Facebook sharing'
)
try:
site = Site.objects.get(id=site_id)
except Site.DoesNotExist:
site, site_created = Site.objects.get_or_create(domain=site_domain)
if site_created:
logger.info('Created Site [%d] with domain [%s]', site.id,
site.domain)
site.domain = site_domain
site.name = site_name
site.save()
SiteConfiguration.objects.update_or_create(
site=site,
defaults={
'platform_name': options.get('platform_name'),
'lms_url_root': options.get('lms_url_root'),
'catalog_api_url': options.get('catalog_api_url'),
'tos_url': options.get('tos_url'),
'privacy_policy_url': options.get('privacy_policy_url'),
'homepage_url': options.get('homepage_url'),
'company_name': options.get('company_name'),
'certificate_help_url': options.get('certificate_help_url'),
'records_help_url': options.get('records_help_url'),
'twitter_username': options.get('twitter_username'),
'enable_linkedin_sharing':
options.get('enable_linkedin_sharing'),
'enable_twitter_sharing':
options.get('enable_twitter_sharing'),
'enable_facebook_sharing': enable_facebook_sharing,
'facebook_app_id': facebook_app_id,
'segment_key': options.get('segment_key'),
'theme_name': options.get('theme_name').lower(),
})
def get_dmd_data_path(self):
"""Return path to most recent directory of unzipped dm+d data, without
the trailing slash.
It expects to find this at data/dmd/[datestamp]/nhsbsa_dmd_[release].
"""
# The extra slash ('') at the end of glob_pattern is to ensure we don't
# capture any .zip files.
glob_pattern = os.path.join(settings.PIPELINE_DATA_BASEDIR, "dmd", "*",
"nhsbsa_dmd_*", "")
paths = sorted(glob.glob(glob_pattern))
if not paths:
raise CommandError("No dmd data found")
# Remove the extra slash.
return paths[-1][:-1]
def handle(self, *args, **options):
package = options['app_name']
models_names = list(a.name for a in pyclbr.readmodule(package + '.models').values())
package_dir = os.path.join(os.getcwd(), package)
admin_skeleton = open(os.path.join(akoikelov.djazz.__path__[0], 'conf', ) + '/tpl/admin.py-tpl').read()
admin_file_resource = open(package_dir + '/admin.py', 'a')
if not os.path.exists(package_dir):
raise CommandError('Given package %s doesn\'t exist!' % package)
for m in models_names:
generator = AdminGenerator(m, admin_file_resource, admin_skeleton, package)
generator.generate()
admin_file_resource.close()
self.stdout.write(self.style.SUCCESS('Admin classes for models %s successfully generated!' % models_names))
def _report(self, allowed_checksums):
if allowed_checksums:
allowed_checksums = allowed_checksums.split(",")
if "sha256" not in allowed_checksums:
raise CommandError(_("Checksums must contain sha256"))
else:
allowed_checksums = settings.ALLOWED_CONTENT_CHECKSUMS
forbidden_checksums = set(
constants.ALL_KNOWN_CONTENT_CHECKSUMS).difference(
allowed_checksums)
self.stderr.write(
_("Warning: the handle-artifact-checksums report is in "
"tech preview and may change in the future."))
self._show_on_demand_content(forbidden_checksums)
self._show_immediate_content(forbidden_checksums)
def handle(self, check_app_name=None, **options):
runner = simple.DjangoTestSuiteRunner(verbosity=0)
err_msg = "Failed to migrate %s; see output for hints at missing dependencies:\n"
hacks.patch_flush_during_test_db_creation()
failures = 0
if check_app_name is None:
app_names = settings.INSTALLED_APPS
else:
app_names = [check_app_name]
for app_name in app_names:
app_label = app_name.split(".")[-1]
if app_name == 'south':
continue
try:
Migrations(app_name)
except (NoMigrations, ImproperlyConfigured):
continue
app = loading.get_app(app_label)
verbosity = int(options.get('verbosity', 1))
if verbosity >= 1:
self.stderr.write("processing %s\n" % app_name)
old_config = runner.setup_databases()
try:
call_command('migrate',
app_label,
noinput=True,
verbosity=verbosity)
for model in loading.get_models(app):
dummy = model._default_manager.exists()
except (KeyboardInterrupt, SystemExit):
raise
except Exception as e:
failures += 1
if verbosity >= 1:
self.stderr.write(err_msg % app_name)
self.stderr.write("%s\n" % e)
finally:
runner.teardown_databases(old_config)
if failures > 0:
raise CommandError("Missing depends_on found in %s app(s)." %
failures)
self.stderr.write("No missing depends_on found.\n")
def handle(self, *args, **options):
super(Command, self).handle(*args, **options)
both_list_and_endpoints = options.get("doc_id") is not None and (
options.get("start_id") is not None
or options.get("end_id") is not None
or options.get("filed_after") is not None
)
no_option = not any(
[
options.get("doc_id") is None,
options.get("start_id") is None,
options.get("end_id") is None,
options.get("filed_after") is None,
options.get("all") is False,
]
)
if both_list_and_endpoints or no_option:
raise CommandError(
"Please specify either a list of documents, a "
"range of ids, a range of dates, or "
"everything."
)
self.index = options["index"]
# Use query chaining to build the query
query = Opinion.objects.all().order_by("pk")
if options.get("doc_id"):
query = query.filter(pk__in=options["doc_id"])
if options.get("end_id"):
query = query.filter(pk__lte=options["end_id"])
if options.get("start_id"):
query = query.filter(pk__gte=options["start_id"])
if options.get("filed_after"):
query = query.filter(
cluster__date_filed__gte=options["filed_after"]
)
if options.get("all"):
query = Opinion.objects.all()
self.count = query.count()
self.average_per_s = 0
self.timings = []
opinion_pks = query.values_list("pk", flat=True).iterator()
self.update_documents(opinion_pks, options["queue"])
self.add_to_solr(options["queue"])
def _update(self, models, options):
"""
Update indices with sanity check.
Will be created a new index and populate with data.
The index will be masked with previous one to prevent missing data.
"""
alias_mappings = []
for document in registry.get_documents(models):
# pylint: disable=protected-access
index = document._index
record_count = self.get_record_count(document)
alias, new_index_name = self.prepare_backend_index(index)
alias_mappings.append(AliasMapper(document, index, new_index_name, alias, record_count))
# Set the alias (from settings) to the timestamped catalog.
run_attempts = 0
indexes_pending = {key: '' for key in [x.new_index_name for x in alias_mappings]}
conn = get_connection()
while indexes_pending and run_attempts < 1: # Only try once, as retries gave buggy results. See VAN-391
run_attempts += 1
self._populate(models, options)
for doc, __, new_index_name, alias, record_count in alias_mappings:
# Run a sanity check to ensure we aren't drastically changing the
# index, which could be indicative of a bug.
if new_index_name in indexes_pending and not options.get('disable_change_limit', False):
record_count_is_sane, index_info_string = self.sanity_check_new_index(
run_attempts, doc, new_index_name, record_count
)
if record_count_is_sane:
ElasticsearchUtils.set_alias(conn, alias, new_index_name)
indexes_pending.pop(new_index_name, None)
else:
indexes_pending[new_index_name] = index_info_string
else:
ElasticsearchUtils.set_alias(conn, alias, new_index_name)
indexes_pending.pop(new_index_name, None)
for index_alias_mapper in alias_mappings:
index_alias_mapper.registered_index._name = index_alias_mapper.alias # pylint: disable=protected-access
if indexes_pending:
raise CommandError('Sanity check failed for the new index(es): {}'.format(indexes_pending))
return True
def handle(self, *args, **options):
freeze_name = options["freeze"]
dummy = options["dummy"]
if not dummy:
self.prepare_harvest(freeze_name)
harvest_queryset = EdurepHarvest.objects.filter(
freeze__name=freeze_name, stage=HarvestStages.NEW)
if not harvest_queryset.exists():
raise EdurepHarvest.DoesNotExist(
f"There are no NEW EdurepHarvest objects for '{freeze_name}'")
self.header("EDUREP SEEDS HARVEST", options)
# Calling the Edurep OAI-PMH interface and get the Edurep meta data about learning materials
self.info("Fetching metadata for sources ...")
send_config = create_config("http_resource", {
"resource": "edurep.EdurepOAIPMH",
"continuation_limit": 1000,
})
current_time = now()
successes = defaultdict(int)
fails = defaultdict(int)
for harvest in self.progress(harvest_queryset,
total=harvest_queryset.count()):
set_specification = harvest.source.collection_name
scc, err = send(set_specification,
f"{harvest.latest_update_at:%Y-%m-%d}",
config=send_config,
method="get")
if len(err):
raise CommandError(
"Failed to harvest seeds from Edurep OAI-PMH")
successes[set_specification] += len(scc)
fails[set_specification] += len(err)
if not dummy:
harvest.harvested_at = current_time
harvest.save()
self.info('Failed OAI-PMH calls: ', fails)
self.info('Successful OAI-PMH calls: ', successes)
success_count = sum(successes.values())
fail_count = sum(fails.values())
return f'OAI-PMH: {success_count}/{success_count+fail_count}'
def handle(self, *args, **options):
try:
parent_network = ipaddress.ip_network(
options.get('parent_network'))
dc_name = options.get('dc_name')
server_room_name = options.get('server_room_name')
network_address = parent_network.network_address
dns_1 = ipaddress.ip_address(options.get('dns_1'))
dns_2 = ipaddress.ip_address(options.get('dns_2'))
number_of_subnets = int(options.get('number_of_subnets'))
region = options.get('region')
configuration_path = options.get('configuration_path')
except ValueError as e:
raise CommandError(e)
self._validate_network(parent_network, number_of_subnets)
self._validate_configuration_path(configuration_path)
self.create_users(region)
self.create_configuration_path(configuration_path)
TransitionsCommand.create_data_center_asset_transitions()
NetworkCommand.create_network(dc_name=dc_name,
dns1_address=dns_1,
dns2_address=dns_2,
gateway_address=network_address + 1,
network=parent_network,
server_room_name=server_room_name)
for _ in range(0, number_of_subnets):
network = ipaddress.ip_network('{}/{}'.format(network_address, 24))
NetworkCommand.create_network(dc_name=dc_name,
dns1_address=dns_1,
dns2_address=dns_2,
gateway_address=network_address + 1,
network=network,
server_room_name=server_room_name,
create_rack=True)
network_address += 256
for name in ["A", "B", "C"]:
ServerModelCommand.create_model(model_name="Model {}".format(name))
ServerModelCommand.create_model(
model_name="Blade server model {}".format(name), is_blade=True)
call_command('sitetree_resync_apps')
def handle(self, *args, **options):
after = date_argument(options['after'])
before = date_argument(options['before'])
if after and before and before <= after:
raise CommandError('"--before" must be after "--after"')
record_type = options['type']
serialiser: Serialiser = Serialiser.serialisers[record_type]()
with open(options['path'], 'wt') as jsonl_file:
records = serialiser.get_modified_records(after, before)
for record in records:
jsonl_file.write(
json.dumps(serialiser.serialise(record),
default=str,
ensure_ascii=False))
jsonl_file.write('\n')
def handle(self, *args, **options):
try:
n_params_func = inspect.signature(load_data).parameters
params = {
k: v
for k, v in options.items() if k in n_params_func and v
}
LOGGER_INFO.debug(params)
load_data(**params)
except Exception:
LOGGER.exception(f'Error al ejecutar el {self.nom_proc}')
raise CommandError(f'El {self.nom_proc} no se ha podido efectuar')
else:
LOGGER_INFO.info(
msg_info :=
f'{self.nom_proc.capitalize()} efectuado correctamente')
self.stdout.write(self.style.SUCCESS(msg_info))
def handle(self, export_file, config_file, domain, user_id, **options):
start = datetime.utcnow()
if '@' in user_id:
user = WebUser.get_by_username(user_id)
else:
user = WebUser.get(user_id)
if not user.is_member_of(domain):
raise CommandError("%s can't access %s" % (user, domain))
with open(config_file, 'r', encoding='utf-8') as f:
config = ImporterConfig.from_json(f.read())
config.couch_user_id = user._id
with get_spreadsheet(export_file) as spreadsheet:
print(json.dumps(do_import(spreadsheet, config, domain),
default=json_handler))
print('finished in %s seconds' % (datetime.utcnow() - start).seconds)
def handle(self, *args, **options):
username = options.get('username')
password = options.get('password')
email = options.get('email')
database = DEFAULT_DB_ALIAS
if not password or not username:
raise CommandError("--username and --password are required")
data = {'username': username,'password': password,'email': email}
try:
self.UserModel._default_manager.db_manager(database).create_superuser(**data)
except django.db.utils.IntegrityError:
user = self.UserModel._default_manager.db_manager(database).get(username=username)
user.set_password(password)
if email:
user.email = email
user.save()
