def check_user_valid(**kwargs): password = kwargs.pop('password', None) public_key = kwargs.pop('public_key', None) email = kwargs.pop('email', None) username = kwargs.pop('username', None) if username: user = get_object_or_none(User, username=username) elif email: user = get_object_or_none(User, email=email) else: user = None if user is None: return None, _('User not exist') elif not user.is_valid: return None, _('Disabled or expired') if password and authenticate(username=username, password=password): return user, '' if public_key and user.public_key: public_key_saved = user.public_key.split() if len(public_key_saved) == 1: if public_key == public_key_saved[0]: return user, '' elif len(public_key_saved) > 1: if public_key == public_key_saved[1]: return user, '' return None, _('Password or SSH public key invalid')
def filter_user(self, queryset): user_id = self.request.query_params.get('user_id') username = self.request.query_params.get('username') if user_id: user = get_object_or_none(User, pk=user_id) elif username: user = get_object_or_none(User, username=username) else: return queryset if not user: return queryset.none()
def filter_system_user(self, queryset): system_user_id = self.request.query_params.get('system_user_id') system_user_name = self.request.query_params.get('system_user') if system_user_id: system_user = get_object_or_none(SystemUser, pk=system_user_id) elif system_user_name: system_user = get_object_or_none(SystemUser, name=system_user_name) else: return queryset if not system_user: return queryset.none() queryset = queryset.filter(system_users=system_user) return queryset
def filter_user_group(self, queryset): user_group_id = self.request.query_params.get('user_group_id') user_group_name = self.request.query_params.get('user_group') if user_group_id: group = get_object_or_none(UserGroup, pk=user_group_id) elif user_group_name: group = get_object_or_none(UserGroup, name=user_group_name) else: return queryset if not group: return queryset.none() queryset = queryset.filter(user_groups=group) return queryset
def filter_node(self, queryset): node_id = self.request.query_params.get('node_id') node_name = self.request.query_params.get('node') if node_id: node = get_object_or_none(Node, pk=node_id) elif node_name: node = get_object_or_none(Node, name=node_name) else: return queryset if not node: return queryset.none() nodes = node.get_ancestor(with_self=True) queryset = queryset.filter(nodes__in=nodes) return queryset
def pre_run_task_signal_handler(sender, task_id=None, task=None, **kwargs): time.sleep(0.1) for i in range(5): if cache.get(task_id, False): break else: time.sleep(0.1) continue t = get_object_or_none(CeleryTask, id=task_id) if t is None: logger.warn("Not get the task: {}".format(task_id)) return now = datetime.datetime.now().strftime("%Y-%m-%d") log_path = os.path.join(now, task_id + '.log') full_path = os.path.join(CeleryTask.LOG_DIR, log_path) if not os.path.exists(os.path.dirname(full_path)): os.makedirs(os.path.dirname(full_path)) with transaction.atomic(): t.date_start = timezone.now() t.status = CeleryTask.RUNNING t.log_path = log_path t.save() f = open(full_path, 'w') tee = TeeObj(f) sys.stdout = tee task.log_f = tee
def authenticate_credentials(request, access_key_id, request_signature): access_key = get_object_or_none(AccessKey, id=access_key_id) request_date = get_request_date_header(request) if access_key is None or not access_key.user: raise exceptions.AuthenticationFailed(_('Invalid signature.')) access_key_secret = access_key.secret try: request_unix_time = http_to_unixtime(request_date) except ValueError: raise exceptions.AuthenticationFailed( _('HTTP header: Date not provide ' 'or not %a, %d %b %Y %H:%M:%S GMT')) if int(time.time()) - request_unix_time > 15 * 60: raise exceptions.AuthenticationFailed( _('Expired, more than 15 minutes')) signature = make_signature(access_key_secret, request_date) if not signature == request_signature: raise exceptions.AuthenticationFailed(_('Invalid signature.')) if not access_key.user.is_active: raise exceptions.AuthenticationFailed(_('User disabled.')) return access_key.user, None
def create(self, request, *args, **kwargs): name = request.data.get('name') remote_ip = request.META.get('REMOTE_ADDR') x_real_ip = request.META.get('X-Real-IP') remote_addr = x_real_ip or remote_ip terminal = get_object_or_none(Terminal, name=name, is_deleted=False) if terminal: msg = 'Terminal name %s already used' % name return Response({'msg': msg}, status=409) serializer = self.serializer_class(data={ 'name': name, 'remote_addr': remote_addr }) if serializer.is_valid(): terminal = serializer.save() # App should use id, token get access key, if accepted token = uuid.uuid4().hex cache.set(token, str(terminal.id), 3600) data = {"id": str(terminal.id), "token": token, "msg": "Need accept"} return Response(data, status=201) else: data = serializer.errors logger.error("Register terminal error: {}".format(data)) return Response(data, status=400)
def resultados(request, rubro_id=None): """ Resultados de la búsqueda de proyectos """ rubro = get_object_or_none(Rubro, id=rubro_id) if request.method == "POST": form = BusquedaForm(request.POST) if form.is_valid(): resultado = form.save() request.session["resultado"] = resultado else: form = BusquedaForm() if "resultado" in request.session: resultado = request.session["resultado"] else: resultado = Proyecto.accepted.all() if rubro: resultado = resultado.filter(rubro=rubro) return direct_response(request, 'proyectos/resultados.html', {'resultado': get_paginated(request, resultado, 3), 'resultados_sp': resultado, 'form': form, 'cliente': Cliente.get_authenticated(request), 'rubros': Rubro.objects.all(), 'rubro_activo': rubro, 'rango_venta': Proyecto.get_rango_precio(u"V"), 'rango_renta': Proyecto.get_rango_precio(u"R"),})
def get_form(self, form_class=None): form = super().get_form(form_class=form_class) domain_id = self.kwargs.get("pk") domain = get_object_or_none(Domain, id=domain_id) if domain: form['domain'].initial = domain return form
def set_assets_node(self, assets): if not isinstance(assets, list): assets = [assets] node = Node.root() node_id = self.request.query_params.get('node_id') if node_id: node = get_object_or_none(Node, pk=node_id) node.assets.add(*assets)
def authenticate_credentials(self, token): user_id = cache.get(token) user = get_object_or_none(self.model, id=user_id) if not user: msg = _('Invalid token or cache refreshed.') raise exceptions.AuthenticationFailed(msg) return user, None
def get_form(self, form_class=None): form = super().get_form(form_class=form_class) node_id = self.request.GET.get("node_id") if node_id: node = get_object_or_none(Node, id=node_id) else: node = Node.root() form["nodes"].initial = node return form
def put(self, request, *args, **kwargs): instance = self.get_object() nodes_id = request.data.get("nodes") children = [get_object_or_none(Node, id=pk) for pk in nodes_id] for node in children: if not node: continue node.parent = instance return Response("OK")
def get_ticket(self): from tickets.models import Ticket ticket_id = self.request.session.get("auth_ticket_id") logger.debug('Login confirm ticket id: {}'.format(ticket_id)) if not ticket_id: ticket = None else: ticket = get_object_or_none(Ticket, pk=ticket_id) return ticket
def get_user_or_pre_auth_user(request): user = request.user if user.is_authenticated: return user pre_auth_user_id = request.session.get('user_id') user = None if pre_auth_user_id: user = get_object_or_none(User, pk=pre_auth_user_id) return user
def authenticate_credentials(self, token): model = get_user_model() user_id = cache.get(token) user = get_object_or_none(model, id=user_id) if not user: msg = _('Invalid token or cache refreshed.') raise exceptions.AuthenticationFailed(msg) return user, None
def filter_user(self, queryset): user_id = self.request.query_params.get('user_id') username = self.request.query_params.get('username') if user_id: user = get_object_or_none(User, pk=user_id) elif username: user = get_object_or_none(User, username=username) else: return queryset if not user: return queryset.none() if not self.is_query_all(): queryset = queryset.filter(users=user) return queryset groups = user.groups.all() queryset = queryset.filter(Q(users=user) | Q(user_groups__in=groups)).distinct() return queryset
def sync_oss_list_info_manual(): logger.info('ready to sync aly cloud oss list') ali_util = AliCloudUtil() created, updated, failed = [], [], [] node = Node.root() Oss.objects.all().update(status='Destory') for info in ali_util.get_oss_instances(): logger.info(json.dumps(info)) oss = get_object_or_none(Oss, instance_id=info.get('instance_id')) if not oss: try: with transaction.atomic(): oss = Oss.objects.create(**info) # need to add auto join node node = auto_allocate_asset_node(info.get('instance_name'), 'oss') oss.nodes.set([node]) created.append(info['instance_name']) except Exception as e: failed.append('%s: %s' % (info['instance_name'], str(e))) else: for k, v in info.items(): if v != '': setattr(oss, k, v) try: if not oss.nodes.exclude(key='1').first(): logger.info('update node for root node oss') node = auto_allocate_asset_node(info.get('instance_name'), 'oss') oss.nodes.set([node]) oss.save() updated.append(info['instance_name']) except Exception as e: failed.append('%s: %s' % (info['instance_name'], str(e))) data = { 'created': created, 'created_info': 'Created {}'.format(len(created)), 'updated': updated, 'updated_info': 'Updated {}'.format(len(updated)), 'failed': failed, 'failed_info': 'Failed {}'.format(len(failed)), 'valid': True, 'msg': 'Created: {}. Updated: {}, Error: {}'.format(len(created), len(updated), len(failed)) } logger.info('sync finish') logger.info(json.dumps(data)) return data
def post(self, request): email = request.POST.get('email') user = get_object_or_none(User, email=email) if not user: return self.get(request, errors=_('邮箱地址错误, ' '请重新输入')) else: send_reset_password_mail(user) return HttpResponseRedirect( reverse('users:forgot-password-sendmail-success'))
def set_assets_hardware_info(result, **kwargs): """ Using ops task run result, to update asset info @shared_task must be exit, because we using it as a task callback, is must be a celery task also :param result: :param kwargs: {task_name: ""} :return: """ result_raw = result[0] assets_updated = [] for hostname, info in result_raw.get('ok', {}).items(): info = info.get('setup', {}).get('ansible_facts', {}) if not info: logger.error("Get asset info failed: {}".format(hostname)) continue asset = get_object_or_none(Asset, hostname=hostname) if not asset: continue ___vendor = info.get('ansible_system_vendor', 'Unknown') ___model = info.get('ansible_product_name', 'Unknown') ___sn = info.get('ansible_product_serial', 'Unknown') for ___cpu_model in info.get('ansible_processor', []): if ___cpu_model.endswith('GHz') or ___cpu_model.startswith( "Intel"): break else: ___cpu_model = 'Unknown' ___cpu_model = ___cpu_model[:64] ___cpu_count = info.get('ansible_processor_count', 0) ___cpu_cores = info.get('ansible_processor_cores', None) or len( info.get('ansible_processor', [])) ___memory = '%s %s' % capacity_convert('{} MB'.format( info.get('ansible_memtotal_mb'))) disk_info = {} for dev, dev_info in info.get('ansible_devices', {}).items(): if disk_pattern.match(dev) and dev_info['removable'] == '0': disk_info[dev] = dev_info['size'] ___disk_total = '%s %s' % sum_capacity(disk_info.values()) ___disk_info = json.dumps(disk_info) ___platform = info.get('ansible_system', 'Unknown') ___os = info.get('ansible_distribution', 'Unknown') ___os_version = info.get('ansible_distribution_version', 'Unknown') ___os_arch = info.get('ansible_architecture', 'Unknown') ___hostname_raw = info.get('ansible_hostname', 'Unknown') for k, v in locals().items(): if k.startswith('___'): setattr(asset, k.strip('_'), v) asset.save() assets_updated.append(asset) return assets_updated
def run_command_execution(cid, **kwargs): execution = get_object_or_none(CommandExecution, id=cid) if execution: try: execution.run() except SoftTimeLimitExceeded: print("HLLL") else: logger.error("Not found the execution id: {}".format(cid))
def get_form(self, form_class=None): form = super().get_form(form_class=form_class) node_id = self.request.GET.get("node_id") if node_id: node = get_object_or_none(Node, id=node_id) else: node = Node.org_root() form.add_nodes_initial(node) return form
def start_deploy_execution(eid, **kwargs): change_to_root() execution = get_object_or_none(DeployExecution, id=eid) if execution: execution.project.change_to() return execution.start else: msg = "No execution found: {}".format(eid) return {"error": msg}
def get_context_data(self, **kwargs): table = get_object_or_none( Table, id=self.request.META.get("PATH_INFO").split('/')[-4]) context = { 'app': _('Transfer'), 'action': table.__str__() + '-创建字段' if table else '创建字段', } kwargs.update(context) return super().get_context_data(**kwargs)
def form_valid(self, form): f = form.cleaned_data['file'] det_result = chardet.detect(f.read()) f.seek(0) # reset file seek index data = f.read().decode(det_result['encoding']).strip( codecs.BOM_UTF8.decode()) csv_file = StringIO(data) reader = csv.reader(csv_file) csv_data = [row for row in reader] # header_ = csv_data[0] database_fields = [ 'name', 'asset', 'dev', 'opr', 'bus', 'user_owner', 'user_share', 'comment' ] created = [] # updated = {'database': [], 'table': [], 'field': []} # failed = {'database': [], 'table': [], 'field': []} for row in csv_data[1:]: if set(row) == {''}: continue elif len(row) < len(database_fields): row.extend([''] * (len(database_fields) - len(row))) database_dict = dict( zip(database_fields, row[:len(database_fields)])) database_dict.update({ 'modifier': self.request.user.username or 'Admin', 'asset': get_object_or_none(Asset, ip=database_dict['asset']) }) if not database_dict['name']: continue database, _created = Database.objects.update_or_create( name=database_dict['name'], asset=database_dict['asset'], defaults=database_dict) if _created: created.append(database_dict['name']) data = { 'created': '\n'.join([(item + ': ' + ','.join(created)) for item in created]), 'created_info': 'Created database:{}'.format(len(created)), # 'updated': updated, # 'updated_info': 'Updated {}'.format(len(updated)), # 'failed': failed, # 'failed_info': 'Failed {}'.format(len(failed)), 'valid': True, 'msg': 'Created database:{}'.format(len(created)), } return self.render_json_response(data)
def get_asset_users(self): username = self.request.GET.get('username') asset_id = self.request.GET.get('asset_id') prefer = self.request.GET.get("prefer") asset = get_object_or_none(Asset, pk=asset_id) manager = AssetUserManager() asset_users = manager.filter(username=username, assets=[asset], prefer=prefer) return asset_users
def get_place_or_default(profile, place_id=None): """ Uses get() to return a place by its id. If profile doesn't have this place, it will return Profile's default place. profile must be a Profile. place_id is optional. """ place_member = get_object_or_none( PlaceMember, member_id=profile.id, place_id=place_id ) or get_object_or_none( PlaceMember, member_id=profile.id, is_the_default_one=True ) return place_member.place if place_member else None
def set_assets_node(self, assets): if not isinstance(assets, list): assets = [assets] node_id = self.request.query_params.get('node_id') if not node_id: return node = get_object_or_none(Node, pk=node_id) if not node: return node.assets.add(*assets)
def execute_playbook(tid, **kwargs): change_to_root() playbook = get_object_or_none(Playbook, id=tid) if playbook: set_current_project(playbook.project) return playbook.execute() else: msg = "No playbook found: {}".format(tid) logger.error(msg) return {"error": msg}
def execute_adhoc(tid, **kwargs): change_to_root() adhoc = get_object_or_none(AdHoc, id=tid) if adhoc: set_current_project(adhoc.project) return adhoc.execute() else: msg = "No adhoc found: {}".format(tid) logger.error(msg) return {"error": msg}
def _check_unauthenticated_user_can_bind(self): session_user = None if not self.request.session.is_empty(): user_id = self.request.session.get('user_id') session_user = get_object_or_none(User, pk=user_id) if session_user: if all((is_auth_password_time_valid(self.request.session), session_user.mfa_enabled, not session_user.otp_secret_key)): return True return False
def post(self, request): email = request.POST.get('email') user = get_object_or_none(User, email=email) if not user: return self.get( request, errors=_('Email address invalid, please input again')) else: send_reset_password_mail(user) return HttpResponseRedirect( reverse_lazy('users:forgot-password-sendmail-success'))
def ensure_key(self): key = self.request.query_params.get('key', None) id = self.request.query_params.get('id', None) if key is not None: return key node = get_object_or_none(Node, id=id) if node: return node.key
def post(self, request): email = request.POST.get('email') user = get_object_or_none(User, email=email) if not user: return self.get(request, errors=_('Email address invalid, ' 'please input again')) else: send_reset_password_mail(user) return HttpResponseRedirect( reverse('users:forgot-password-sendmail-success'))
def authenticate_credentials(token): user_id = cache.get(token) user = get_object_or_none(User, id=user_id) if not user: msg = _('Invalid token or cache refreshed.') raise exceptions.AuthenticationFailed(msg) refresh_token(token, user) # 最终返回用户 或者None return user, None
def patch(self, request, *args, **kwargs): asset_group = self.get_object() assets = asset_group.assets.all() system_user_id = self.request.data['system_user'] system_user = get_object_or_none(SystemUser, id=system_user_id) if not assets or not system_user: return Response('Invalid system user id or asset group id', status=404) task = push_users.delay([asset._to_secret_json() for asset in assets], system_user._to_secret_json()) return Response(task.id)
def start_adhoc_execution(eid, **kwargs): change_to_root() execution = get_object_or_none(AdHocExecution, id=eid) if execution: set_current_project(execution.project) return execution.start() else: msg = "No execution found: {}".format(eid) logger.error(msg) return {"error": msg}
def get_queryset(cls, user_id=None, user_group_id=None, system_user_id=None, asset_id=None, application_id=None, org_id=None): user_groups = [] user = get_object_or_none(User, pk=user_id) if user: user_groups.extend(list(user.groups.all())) user_group = get_object_or_none(UserGroup, pk=user_group_id) if user_group: org_id = user_group.org_id user_groups.append(user_group) system_user = get_object_or_none(SystemUser, pk=system_user_id) asset = get_object_or_none(Asset, pk=asset_id) application = get_object_or_none(Application, pk=application_id) q = Q() if user: q |= Q(users=user) if user_groups: q |= Q(user_groups__in=set(user_groups)) if system_user: org_id = system_user.org_id q |= Q(system_users=system_user) if asset: org_id = asset.org_id q |= Q(assets=asset) if application: org_id = application.org_id q |= Q(applications=application) if q: cmd_filters = CommandFilter.objects.filter(q).filter( is_active=True) if org_id: cmd_filters = cmd_filters.filter(org_id=org_id) rule_ids = cmd_filters.values_list('rules', flat=True) rules = cls.objects.filter(id__in=rule_ids) else: rules = cls.objects.none() return rules
def post(self, request, *args, **kwargs): validated_session = [] for session_id in request.data: session = get_object_or_none(Session, id=session_id) if session and not session.is_finished: validated_session.append(session_id) self.model.objects.create( name="kill_session", args=session.id, terminal=session.terminal, ) return Response({"ok": validated_session})
def get_object(self): username = self.request.GET.get('username') asset_id = self.request.GET.get('asset_id') asset = get_object_or_none(Asset, pk=asset_id) try: instance = AssetUserManager.get(username, asset) except Exception as e: logger.error(e, exc_info=True) return None else: return instance
def get_request_user(self): request = self.context.get('request') if request.user and request.user.is_authenticated: user = request.user else: user_id = request.session.get('user_id') user = get_object_or_none(User, pk=user_id) if not user: raise serializers.ValidationError( "user id {} not exist".format(user_id)) return user
def set_assets_hardware_info(result, **kwargs): """ Using ops task run result, to update asset info @shared_task must be exit, because we using it as a task callback, is must be a celery task also :param result: :param kwargs: {task_name: ""} :return: """ result_raw = result[0] assets_updated = [] for hostname, info in result_raw.get('ok', {}).items(): info = info.get('setup', {}).get('ansible_facts', {}) if not info: logger.error("Get asset info failed: {}".format(hostname)) continue asset = get_object_or_none(Asset, hostname=hostname) if not asset: continue ___vendor = info.get('ansible_system_vendor', 'Unknown') ___model = info.get('ansible_product_name', 'Unknown') ___sn = info.get('ansible_product_serial', 'Unknown') for ___cpu_model in info.get('ansible_processor', []): if ___cpu_model.endswith('GHz') or ___cpu_model.startswith("Intel"): break else: ___cpu_model = 'Unknown' ___cpu_model = ___cpu_model[:64] ___cpu_count = info.get('ansible_processor_count', 0) ___cpu_cores = info.get('ansible_processor_cores', None) or len(info.get('ansible_processor', [])) ___memory = '%s %s' % capacity_convert('{} MB'.format(info.get('ansible_memtotal_mb'))) disk_info = {} for dev, dev_info in info.get('ansible_devices', {}).items(): if disk_pattern.match(dev) and dev_info['removable'] == '0': disk_info[dev] = dev_info['size'] ___disk_total = '%s %s' % sum_capacity(disk_info.values()) ___disk_info = json.dumps(disk_info) ___platform = info.get('ansible_system', 'Unknown') ___os = info.get('ansible_distribution', 'Unknown') ___os_version = info.get('ansible_distribution_version', 'Unknown') ___os_arch = info.get('ansible_architecture', 'Unknown') ___hostname_raw = info.get('ansible_hostname', 'Unknown') for k, v in locals().items(): if k.startswith('___'): setattr(asset, k.strip('_'), v) asset.save() assets_updated.append(asset) return assets_updated
def filter_user(self, queryset): user_id = self.request.query_params.get('user_id') username = self.request.query_params.get('username') query_group = self.request.query_params.get('all') if user_id: user = get_object_or_none(User, pk=user_id) elif username: user = get_object_or_none(User, username=username) else: return queryset if not user: return queryset.none() kwargs = {} args = [] if query_group: groups = user.groups.all() args.append(Q(users=user) | Q(user_groups__in=groups)) else: kwargs["users"] = user return queryset.filter(*args, **kwargs).distinct()
def resend_email_token(request): email_verify = get_object_or_none(EmailVerify, pk=request.user) if email_verify: if email_verify.was_verified_email(): return redirect('user:info') email_token = email_verify.token else: email_token = get_random_string(32) EmailVerify(user = request.user, token = email_token).save() send_mail_verification_code(request.user.email, email_token) return redirect('user:info')
def post_run_task_signal_handler(sender, task_id=None, task=None, **kwargs): t = get_object_or_none(CeleryTask, id=task_id) if t is None: logger.warn("Not get the task: {}".format(task_id)) return with transaction.atomic(): t.status = CeleryTask.FINISHED t.date_finished = timezone.now() t.save() task.log_f.flush() sys.stdout = task.log_f.origin_stdout task.log_f.close()
def get_queryset(self): queryset = [] asset_group_id = self.kwargs.get('pk', -1) user = self.request.user asset_group = get_object_or_none(AssetGroup, id=asset_group_id) if user and asset_group: assets = get_user_granted_assets(user) for asset in asset_group.assets.all(): if asset in assets: asset.system_users_granted = assets[asset] queryset.append(asset) return queryset
def post(self, request): email = request.POST.get('email') user = get_object_or_none(User, email=email) if not user: error = _('Email address invalid, please input again') return self.get(request, errors=error) elif not user.can_update_password(): error = _('User auth from {}, go there change password'.format(user.source)) return self.get(request, errors=error) else: send_reset_password_mail(user) return HttpResponseRedirect( reverse('users:forgot-password-sendmail-success'))
def run_ansible_task(tid, callback=None, **kwargs): """ :param tid: is the tasks serialized data :param callback: callback function name :return: """ task = get_object_or_none(Task, id=tid) if task: result = task.run() if callback is not None: subtask(callback).delay(result, task_name=task.name) return result else: logger.error("No task found")
def post(self, request, *args, **kwargs): try: assets_id = json.loads(request.body).get('assets_id', []) assets_node_id = json.loads(request.body).get('node_id', None) except ValueError: return HttpResponse('Json object not valid', status=400) if not assets_id and assets_node_id: assets_node = get_object_or_none(Node, id=assets_node_id) assets = assets_node.get_all_assets() for asset in assets: assets_id.append(asset.id) spm = uuid.uuid4().hex cache.set(spm, assets_id, 300) url = reverse_lazy('assets:asset-export') + '?spm=%s' % spm return JsonResponse({'redirect': url})
def create_or_update_session(self, session_data): session_data["terminal"] = self.request.user.terminal.id _id = session_data["id"] session = get_object_or_none(Session, id=_id) if session: serializer = SessionSerializer( data=session_data, instance=session ) else: serializer = SessionSerializer(data=session_data) if serializer.is_valid(): session = serializer.save() return session else: msg = "session data is not valid {}: {}".format( serializer.errors, str(serializer.data) ) logger.error(msg) return None
def save(self, *args, **kwargs): """ Método para guardar un servicio, cuando este es moderado se manda el correo electrónico de confirmación """ if self.estado == u"A": admin = get_object_or_none(AdministradorServicio, servicio=self) if admin: sendHtmlMail("*****@*****.**", _(u"Confirm registration in MP100"), "ser_confirmacion_mail_%s.html" % admin.idioma, {"nombre": self.nombre, "clave": admin.clave_activacion, "sitio": Site.objects.get_current(), "email": admin.user.email}, admin.user.email, path="servicios/email_templates/") super(Servicio, self).save(*args, **kwargs) if self.estado == u"R": Servicio.objects.get(id=self.id).delete()
def sync_node(src, target, cut=False): assets = src.get_assets() # 同步本节点资产 for asset in assets: if cut: src.assets.remove(asset) asset.org_id = target.org_id asset.save() new_asset = asset else: new_asset = get_object_or_none(Asset, hostname=asset.hostname, org_id=target.org_id) if new_asset is None: asset.id = None asset.org_id = target.org_id asset.save() new_asset = asset target.assets.add(new_asset) # 同步子节点资产 for child in src.get_children(): node_new = target.create_child(child.value) node_new.org_id = target.org_id node_new.save() sync_node(child, node_new)
def form_valid(self, form): f = form.cleaned_data['file'] det_result = chardet.detect(f.read()) f.seek(0) # reset file seek index data = f.read().decode(det_result['encoding']).strip(codecs.BOM_UTF8.decode()) csv_file = StringIO(data) reader = csv.reader(csv_file) csv_data = [row for row in reader] header_ = csv_data[0] fields = [ User._meta.get_field(name) for name in [ 'id', 'name', 'username', 'email', 'role', 'wechat', 'phone', 'is_active', 'comment', ] ] mapping_reverse = {field.verbose_name: field.name for field in fields} mapping_reverse[_('User groups')] = 'groups' attr = [mapping_reverse.get(n, None) for n in header_] if None in attr: data = {'valid': False, 'msg': 'Must be same format as ' 'template or export file'} return self.render_json_response(data) created, updated, failed = [], [], [] for row in csv_data[1:]: if set(row) == {''}: continue user_dict = dict(zip(attr, row)) id_ = user_dict.pop('id') for k, v in user_dict.items(): if k in ['is_active']: if v.lower() == 'false': v = False else: v = bool(v) elif k == 'groups': groups_name = v.split(',') v = UserGroup.objects.filter(name__in=groups_name) else: continue user_dict[k] = v user = get_object_or_none(User, id=id_) if id_ and is_uuid(id_) else None if not user: try: with transaction.atomic(): groups = user_dict.pop('groups') user = User.objects.create(**user_dict) user.groups.set(groups) created.append(user_dict['username']) post_user_create.send(self.__class__, user=user) except Exception as e: failed.append('%s: %s' % (user_dict['username'], str(e))) else: for k, v in user_dict.items(): if k == 'groups': user.groups.set(v) continue if v: setattr(user, k, v) try: user.save() updated.append(user_dict['username']) except Exception as e: failed.append('%s: %s' % (user_dict['username'], str(e))) data = { 'created': created, 'created_info': 'Created {}'.format(len(created)), 'updated': updated, 'updated_info': 'Updated {}'.format(len(updated)), 'failed': failed, 'failed_info': 'Failed {}'.format(len(failed)), 'valid': True, 'msg': 'Created: {}. Updated: {}, Error: {}'.format( len(created), len(updated), len(failed)) } return self.render_json_response(data)
def get_system_user_by_name(name): system_user = get_object_or_none(SystemUser, name=name) return system_user
def form_valid(self, form): node_id = self.request.GET.get("node_id") node = get_object_or_none(Node, id=node_id) if node_id else Node.root() f = form.cleaned_data['file'] det_result = chardet.detect(f.read()) f.seek(0) # reset file seek index file_data = f.read().decode(det_result['encoding']).strip(codecs.BOM_UTF8.decode()) csv_file = StringIO(file_data) reader = csv.reader(csv_file) csv_data = [row for row in reader] fields = [ field for field in Asset._meta.fields if field.name not in [ 'date_created' ] ] header_ = csv_data[0] mapping_reverse = {field.verbose_name: field.name for field in fields} attr = [mapping_reverse.get(n, None) for n in header_] if None in attr: data = {'valid': False, 'msg': 'Must be same format as ' 'template or export file'} return self.render_json_response(data) created, updated, failed = [], [], [] assets = [] for row in csv_data[1:]: if set(row) == {''}: continue asset_dict_raw = dict(zip(attr, row)) asset_dict = dict() for k, v in asset_dict_raw.items(): v = v.strip() if k == 'is_active': v = False if v in ['False', 0, 'false'] else True elif k == 'admin_user': v = get_object_or_none(AdminUser, name=v) elif k in ['port', 'cpu_count', 'cpu_cores']: try: v = int(v) except ValueError: v = '' elif k == 'domain': v = get_object_or_none(Domain, name=v) if v != '': asset_dict[k] = v asset = get_object_or_none(Asset, id=asset_dict.pop('id', 0)) if not asset: try: if len(Asset.objects.filter(hostname=asset_dict.get('hostname'))): raise Exception(_('already exists')) with transaction.atomic(): asset = Asset.objects.create(**asset_dict) if node: asset.nodes.set([node]) created.append(asset_dict['hostname']) assets.append(asset) except Exception as e: failed.append('%s: %s' % (asset_dict['hostname'], str(e))) else: for k, v in asset_dict.items(): if v != '': setattr(asset, k, v) try: asset.save() updated.append(asset_dict['hostname']) except Exception as e: failed.append('%s: %s' % (asset_dict['hostname'], str(e))) data = { 'created': created, 'created_info': 'Created {}'.format(len(created)), 'updated': updated, 'updated_info': 'Updated {}'.format(len(updated)), 'failed': failed, 'failed_info': 'Failed {}'.format(len(failed)), 'valid': True, 'msg': 'Created: {}. Updated: {}, Error: {}'.format( len(created), len(updated), len(failed)) } return self.render_json_response(data)