def followees(request): user = request.user if user is None: raise HTTPForbidden if request.method == 'GET': followees = FollowRecordService.by_follower_id(user.id, request) return list_to_json(followees, 'followees') if request.method == 'POST': data = json.loads(json.dumps(request.json)) if 'followee_id' in data: follow = Follow(follower_id=user.id, followee_id=int(data['followee_id'])) with transaction.manager: zope.sqlalchemy.register(request.dbsession, transaction_manager=transaction.manager) request.dbsession.add(follow) responseCreated = HTTPCreated() responseCreated.body = "followed" return responseCreated if request.method == 'DELETE': data = json.loads(json.dumps(request.json)) if 'followee_id' in data: with transaction.manager: zope.sqlalchemy.register(request.dbsession, transaction_manager=transaction.manager) request.dbsession.query(Follow).filter_by(followee_id=int(data['followee_id'])).filter_by(follower_id=user.id).delete() transaction.commit() responseDeleted = HTTPOk() responseDeleted.body = "unfollowed" return responseDeleted
def process_batch(request, data, errors): nickname = request.headers.get('X-Nickname', u'') upload_items = flatten_items(data) errors = process_upload(nickname, upload_items) if errors is SENTINEL: return HTTPServiceUnavailable() if errors: get_stats_client().incr('geosubmit.upload.errors', len(errors)) result = HTTPOk() result.content_type = 'application/json' result.body = '{}' return result
def geosubmit_view(request, api_key): submitter = GeoSubmitter(request, api_key) # may raise HTTP error request_data = submitter.preprocess() try: submitter.insert_measures(request_data) except ConnectionError: # pragma: no cover return HTTPServiceUnavailable() try: submitter.submit(request_data) except ConnectionError: # pragma: no cover # secondary pipeline is considered non-essential for now pass result = HTTPOk() result.content_type = 'application/json' result.body = '{}' return result
def metadata(request): req = prepare_pyramid_request(request) auth = init_saml_auth(req) settings = auth.get_settings() metadata = settings.get_sp_metadata() errors = settings.validate_metadata(metadata) if len(errors) == 0: resp = HTTPOk(body=metadata, headers={'Content-Type': 'text/xml'}) else: resp = HTTPInternalServerError(body=', '.join(errors)) return resp
def confirm(self): json_body = self.request.json_body if 'token' not in json_body: msg = 'Token não informado' res = dumps(dict(error=dict(code=409, message=msg)), ensure_ascii=False) return HTTPConflict(body=res, content_type='application/json; charset=UTF-8') token = json_body['token'] token_data = confirm_token(request=self.request, token=token, audience='registro') if token_data: aud = token_data['aud'] email = token_data['email'] user = User.by_email(email) if self.current_user and aud == 'registro' and self.current_user.email == user.email: # usuário já registrado direcionado para home if self.current_user.register_confirm: msg = 'Usuário já está confirmado' res = dumps(dict(data=dict(code=200, message=msg)), ensure_ascii=False) return HTTPOk( body=res, content_type='application/json; charset=UTF-8') # registra usuário e direciona para home self.current_user.register_confirm = datetime.utcnow() msg = 'Usuário confirmado com sucesso' res = dumps(dict(data=dict(code=200, message=msg)), ensure_ascii=False) return HTTPOk(body=res, content_type='application/json; charset=UTF-8') # retorna token invalido msg = 'Token inválido' res = dumps(dict(error=dict(code=409, message=msg)), ensure_ascii=False) return HTTPConflict(body=res, content_type='application/json; charset=UTF-8')
def get_processes(request): """ List registered processes (GetCapabilities). Optionally list both local and provider processes. """ detail = asbool(request.params.get("detail", True)) try: # get local processes and filter according to schema validity # (previously deployed process schemas can become invalid because of modified schema definitions processes, invalid_processes = get_processes_filtered_by_valid_schemas( request) if invalid_processes: raise HTTPServiceUnavailable( "Previously deployed processes are causing invalid schema integrity errors. " "Manual cleanup of following processes is required: {}".format( invalid_processes)) response_body = { "processes": processes if detail else [get_any_id(p) for p in processes] } # if 'EMS' and '?providers=True', also fetch each provider's processes settings = get_settings(request) if get_weaver_configuration(settings) == WEAVER_CONFIGURATION_EMS: queries = parse_request_query(request) if "providers" in queries and asbool( queries["providers"][0]) is True: prov_url = "{host}/providers".format(host=request.host_url) providers_response = request_extra("GET", prov_url, settings=settings, headers=request.headers, cookies=request.cookies) providers = providers_response.json() response_body.update({"providers": providers}) for i, provider in enumerate(providers): provider_id = get_any_id(provider) proc_url = "{host}/providers/{prov}/processes".format( host=request.host_url, prov=provider_id) response = request_extra("GET", proc_url, settings=settings, headers=request.headers, cookies=request.cookies) processes = response.json().get("processes", []) response_body["providers"][i].update({ "processes": processes if detail else [get_any_id(p) for p in processes] }) return HTTPOk(json=response_body) except colander.Invalid as ex: raise HTTPBadRequest("Invalid schema: [{!s}]".format(ex))
def update_studio(request): """updates the studio """ studio_id = request.params.get('studio_id') studio = Studio.query.filter_by(id=studio_id).first() name = request.params.get('name', None) dwh = request.params.get('dwh', None) wh_mon_start = get_time(request, 'mon_start') wh_mon_end = get_time(request, 'mon_end') wh_tue_start = get_time(request, 'tue_start') wh_tue_end = get_time(request, 'tue_end') wh_wed_start = get_time(request, 'wed_start') wh_wed_end = get_time(request, 'wed_end') wh_thu_start = get_time(request, 'thu_start') wh_thu_end = get_time(request, 'thu_end') wh_fri_start = get_time(request, 'fri_start') wh_fri_end = get_time(request, 'fri_end') wh_sat_start = get_time(request, 'sat_start') wh_sat_end = get_time(request, 'sat_end') wh_sun_start = get_time(request, 'sun_start') wh_sun_end = get_time(request, 'sun_end') if studio and name and dwh: # update new studio studio.name=name studio.daily_working_hours=int(dwh) wh = WorkingHours() def set_wh_for_day(day, start, end): if start != end: wh[day] = [[start.seconds/60, end.seconds/60]] else: wh[day] = [] set_wh_for_day('mon', wh_mon_start, wh_mon_end) set_wh_for_day('tue', wh_tue_start, wh_tue_end) set_wh_for_day('wed', wh_wed_start, wh_wed_end) set_wh_for_day('thu', wh_thu_start, wh_thu_end) set_wh_for_day('fri', wh_fri_start, wh_fri_end) set_wh_for_day('sat', wh_sat_start, wh_sat_end) set_wh_for_day('sun', wh_sun_start, wh_sun_end) studio.working_hours = wh DBSession.add(studio) # Commit will be handled by the zope transaction extension return HTTPOk()
def process_update_request(request): if request.method == 'POST': try: response = process_gps_updates(request) return HTTPOk(body_template=response) except GpsUpdateError as e: logger.error("Gps update couldn't be processed: " + e.msg) if e.code == 403: return HTTPForbidden(detail=e.msg) return HTTPBadRequest(detail=e.msg) msg = "Gps update requested with wrong method." logger.warning(msg) return HTTPMethodNotAllowed(detail=msg)
def get_job_inputs(request): # type: (Request) -> HTTPException """ Retrieve the inputs of a job. """ job = get_job(request) inputs = dict(inputs=[ dict(id=get_any_id(_input), value=get_any_value(_input)) for _input in job.inputs ]) inputs.update({"links": job.links(request, self_link="inputs")}) inputs = sd.JobInputsSchema().deserialize(inputs) return HTTPOk(json=inputs)
def status(self): """ Get the status of a package deployment """ logger.debug("======= status =======") try: deployment_id = self.__get_deployment_id_in_request() if (not deployment_id): return self.index() result = get_status(deployment_id) logger.debug(result) if result['status'] == 200 and result['data']: detail = result['data'] status = '{0}'.format(detail['deploy_status']) dest_url = '{0}'.format(detail['destination']) contents = json.dumps(result['data'], sort_keys=True) response = HTTPOk() response.headers = { 'Content-Type': 'application/json; charset=UTF-8', 'Deployment-Status': status, 'Location': dest_url } response.body = contents return response elif result['status'] == 404: detail = 'No deployment found for {0}'.format(deployment_id) return HTTPNotFound(detail=detail) else: detail = 'Failed to get deployment status for {0}'.format( deployment_id) return HTTPInternalServerError(detail=detail) except Exception as e: tb_info = traceback.format_exc() msg = 'Exception on getting deployment status.\n'.format(tb_info) logger.exception(msg) return HTTPInternalServerError(detail=tb_info)
def create_shot(request): """runs when adding a new shot """ logged_in_user = get_logged_in_user(request) name = request.params.get('name') code = request.params.get('code') status_id = request.params.get('status_id') status = Status.query.filter_by(id=status_id).first() project_id = request.params.get('project_id') project = Project.query.filter_by(id=project_id).first() logger.debug('project_id : %s' % project_id) if name and code and status and project: # get descriptions description = request.params.get('description') sequence_id = request.params['sequence_id'] sequence = Sequence.query.filter_by(id=sequence_id).first() # get the status_list status_list = StatusList.query.filter_by( target_entity_type='Shot').first() # there should be a status_list # TODO: you should think about how much possible this is if status_list is None: return HTTPServerError(detail='No StatusList found') new_shot = Shot(name=name, code=code, description=description, sequence=sequence, status_list=status_list, status=status, created_by=logged_in_user, project=project) DBSession.add(new_shot) else: logger.debug('there are missing parameters') logger.debug('name : %s' % name) logger.debug('code : %s' % code) logger.debug('status : %s' % status) logger.debug('project : %s' % project) HTTPServerError() return HTTPOk()
def api_public_gateways(request): domain = request.registry.settings.get('net_domain', '') q = DBSession.query(Gateway) show_disabled = request.GET.get('show_disabled') country = request.GET.get('country') hostname = request.GET.get('hostname') if country: q = q.filter(Gateway.country == country) if hostname: if '-' in hostname: hn_country, hn_name = hostname.split('-', 1) q = q.filter(Gateway.country == hn_country) q = q.filter(Gateway.name == hn_name) elif country: q = q.filter(Gateway.name == hostname) else: return HTTPOk(body=json.dumps([]), content_type="application/json") if not show_disabled: q = q.filter(Gateway.enabled == True) def out(g): return { 'hostname': g.country + '-' + g.name, 'fqdn': g.country + '-' + g.name + '.' + domain, 'country': g.country, 'bandwidth': g.bps, 'ipv4': g.ipv4, 'ipv6': g.ipv6, 'enabled': g.enabled, } r = [out(g) for g in q.all()] return HTTPOk(body=json.dumps(r), content_type="application/json")
def __call__(self): if self.auth_user is None: return HTTPForbidden() new_obj = self.request.json key = getattr(self.context, self.context.__key__, None) result = self.context.update_from_external(new_obj, self.request) if result is not None: raise exception_response(422, body=str({'error': result})) if key is not None and ICollection.providedBy(self.context.__parent__): parent = self.context.__parent__ parent.pop(key) new_key = getattr(self.context, self.context.__key__) parent[new_key] = self.context return HTTPOk()
def api_conformance(request): # noqa: F811 # type: (Request) -> HTTPException """Weaver specification conformance information.""" # TODO: follow updates with https://github.com/geopython/pygeoapi/issues/198 conformance = {"conformsTo": [ "http://www.opengis.net/spec/wfs-1/3.0/req/core", "http://www.opengis.net/spec/wfs-1/3.0/req/oas30", # "http://www.opengis.net/spec/wfs-1/3.0/req/html", "http://www.opengis.net/spec/wfs-1/3.0/req/geojson", "http://www.opengis.net/spec/WPS/2.0/req/service/binding/rest-json/core", "http://www.opengis.net/spec/WPS/2.0/req/service/binding/rest-json/oas30", # "http://www.opengis.net/spec/WPS/2.0/req/service/binding/rest-json/html" ]} return HTTPOk(json=conformance)
def endereco_add(self): json_body = self.request.json_body """ A fim de evitar o carregamento de objeto Cliente + filhos e o uso de relationship com lazy load nos modelos cliente_id é obtido de cliHashid e adicionado ao objeto Endereco deserializado através de EnderecoSchema mais tarde """ cliente_hash_id = self.request.matchdict.get('cliHashid') cliente_id = get_decoded_id('clientes', cliente_hash_id, self.current_user.empresa_id) schema = EnderecoSchema(many=False, strict=True) schema.context['cliente_id'] = cliente_id schema.context['endereco'] = self.context try: endereco = schema.load(json_body) except ValidationError as err: errors = err.messages error_list = [] for k, v in errors.items(): error_list.append({'field': k, 'message': v}) msg = 'Dados inválidos' res = dumps(dict( error=dict( code=400, message=msg, errors=error_list)), ensure_ascii=False) return HTTPBadRequest(body=res, content_type='application/json; charset=UTF-8') # com a deserialização ok a inserção é permitida t = endereco.data t.cliente_id = cliente_id Session.add(t) Session.flush() Session.refresh(t) t.hash_id = generate_hash('enderecos', [self.current_user.empresa_id, t.id]) # objeto de retorno precisa ser serializado result = schema.dump(endereco.data) res = dumps(dict( data=dict( code=200, endereco=result.data)), ensure_ascii=False) return HTTPOk(body=res, content_type='application/json; charset=UTF-8')
class Team(ApiView): def get(self): team_id = self.request.matchdict.get('team_id') team = Team_m.query.get(team_id) if team: return team.to_dict() else: raise HTTPNotFound() @has_perm('can_edit_teams') def put(self): team_id = self.request.matchdict.get('team_id') team = Team_m.query.get(team_id) if not team: raise HTTPNotFound() try: json_team = self.request.json_body except ValueError: raise HTTPBadRequest('Expect json') team_schema = TeamUpdateSchema() try: team_des = team_schema.deserialize(json_team) except colander.Invalid, e: errors = e.asdict() raise HTTPBadRequest(errors) team.name = team_des.get('name') or team.name if 'users' in team_des: new_users = team_des['users'] old_users = DBSession.query(TeamMember.user_id).filter(TeamMember.team_id==team.id).all() users_delete = list(set(old_users) - set(new_users)) users_add = list(set(new_users) - set(old_users)) if users_delete: TeamMember.query.filter(TeamMember.team_id==team.id)\ .filter(TeamMember.user_id.in_(users_delete))\ .delete(synchronize_session=False) if users_add: DBSession.add_all([TeamMember(user_id=u_id, team_id=team.id) for u_id in users_add]) if team_des.get('swap_with_preview'): preview = Preview(self.request) if not preview.swap_avatar(type='teams', id=team.id): raise HTTPBadRequest('No preview to swap') return HTTPOk("OK")
def get_job_outputs(request): # type: (PyramidRequest) -> AnyResponseType """ Retrieve the output values resulting from a job execution. """ job = get_job(request) raise_job_dismissed(job, request) raise_job_bad_status(job, request) schema = get_schema_query(request.params.get("schema")) results, _ = get_results(job, request, schema=schema, link_references=False) outputs = {"outputs": results} outputs.update({"links": job.links(request, self_link="outputs")}) outputs = sd.JobOutputsBody().deserialize(outputs) return HTTPOk(json=outputs)
def get_local_process(request): """ Get a registered local process information (DescribeProcess). """ try: process = get_process(request=request) process["inputs"] = opensearch.replace_inputs_describe_process( process.inputs, process.payload) schema = request.params.get("schema") offering = process.offering(schema) return HTTPOk(json=offering) # FIXME: handle colander invalid directly in tween (https://github.com/crim-ca/weaver/issues/112) except colander.Invalid as ex: raise HTTPBadRequest("Invalid schema: [{!s}]\nValue: [{!s}]".format( ex, ex.value))
def update_deletions(context, request): """Receive a UID from the request vars and remove the associated object from the deleted feed. """ uid = request.POST.get('uid') if not uid: return solr_uri = request.registry.settings.get('push.solr_uri', None) if solr_uri is None: raise AttributeError(u'A push.solr_uri is required') from mysolr import Solr solr = Solr(solr_uri) logger.debug('Remove deleted status') remove_deleted_status(uid, context.shared, solr) return HTTPOk(body="Item no longer marked as deleted")
def filter_output(self, environ, start_response, status, headers, app_iter): if self.__detect_flex(environ): # All the fuzz is just for Flex/Flash clients. # Wrap start response to pass HTTP OK back to Flash. Also, we # need to have access to the status later. environ['flexfilter.status'] = status wrap_start_response = \ lambda status, headers: start_response(HTTPOk().status, headers) return Filter.filter_output(self, environ, wrap_start_response, status, headers, app_iter) else: #unfiltered response for non flash clients start_response(status, headers) return app_iter
def get_providers(request): """ Lists registered providers. """ detail = asbool(request.params.get("detail", True)) check = asbool(request.params.get("check", True)) ignore = asbool(request.params.get("ignore", True)) reachable_services = get_provider_services(request, check=check, ignore=ignore) providers = [] for service in reachable_services: summary = service.summary(request, fetch=check, ignore=ignore) if detail else service.name if summary: providers.append(summary) data = {"checked": check, "providers": providers} return HTTPOk(json=sd.ProvidersBodySchema().deserialize(data))
def process(context, request): """ Dispatches mapping pipeline for the target project """ source_project_name = request.matchdict['project'] target_project_name = 'drsc' jobid = six.text_type(str(uuid.uuid4())) tasks.apply_mappings.apply_async( args=[jobid, source_project_name, target_project_name], task_id=jobid ) return HTTPOk()
def delete(self): board_id = self.request.matchdict.get('board_id') board = m.SprintBoard.query.get(board_id) if not board: raise HTTPNotFound() can_delete = (board.user_id == self.request.user.id) if not can_delete: raise HTTPForbidden DBSession.delete(board) return HTTPOk('OK')
def add(context, request): db_session = request.db_session Form = build_add_form(context, request) form = Form(request.POST) if (request.method == 'POST' and check_csrf_token(request) and form.validate()): state = ( db_session.query(models.SpecimenState) .filter_by(name=u'pending-draw') .one()) patient = ( db_session.query(studies.Patient) .filter_by(pid=form.pid.data) .one()) cycle = db_session.query(studies.Cycle).get(form.cycle_id.data) type_ = \ db_session.query(models.SpecimenType) \ .get(form.specimen_type_id.data) try: visit = ( db_session.query(studies.Visit) .filter(studies.Visit.patient_id == patient.id) .filter(studies.Visit.cycles.any(id=form.cycle_id.data)) .one()) except (orm.exc.MultipleResultsFound, orm.exc.NoResultFound) as e: collect_date = None else: collect_date = visit.visit_date db_session.add(models.Specimen( patient=patient, cycle=cycle, specimen_type=type_, state=state, collect_date=collect_date, location=context, tubes=type_.default_tubes)) db_session.flush() request.session.flash( _(u'Specimen added for ${pid}', mapping={'pid': form.pid.data}), 'success') url = request.current_route_path(_route_name='lims.specimen') return HTTPOk(json={'__next__': url}) return { 'form': form }
def login(self): request = self.request json_body = self.request.json_body if 'username' not in json_body: msg = 'Username não informado' res = dumps(dict(error=dict(code=409, message=msg)), ensure_ascii=False) return HTTPConflict(body=res, content_type='application/json; charset=UTF-8') username = json_body['username'] if 'password' not in json_body: msg = 'Password não informado' res = dumps(dict(error=dict(code=409, message=msg)), ensure_ascii=False) return HTTPConflict(body=res, content_type='application/json; charset=UTF-8') password = json_body['password'] user = User.by_username_email(username) if user and user.password == password: headers = remember(request, user.username) msg = 'Login efetuado com sucesso' token_data = {'aud': 'idToken', 'username': user.username} token = generate_token(request=self.request, data=token_data) if user.register_confirm: confirmed = True else: confirmed = False res = dumps(dict(data=dict(code=200, message=msg, userId=user.username, idToken=token.decode('utf-8'), expiresIn=3600, emailConfirmed=confirmed, firstName=user.first_name, lastName=user.last_name)), ensure_ascii=False) return HTTPOk(headers=headers, body=res, content_type='application/json; charset=UTF-8') msg = 'Username ou senha inválidos' res = dumps(dict(error=dict(code=409, message=msg)), ensure_ascii=False) return HTTPConflict(body=res, content_type='application/json; charset=UTF-8')
def checkout_update(context, request): db_session = request.db_session vals = filter_aliquot(context, request, state='pending-checkout') available_locations = [ (l.id, l.title) for l in db_session.query(models.Location).order_by('title') ] class CheckoutForm(wtforms.Form): location_id = wtforms.SelectField( _('Lab Location'), description=_('The location of the aliquot'), choices=available_locations, coerce=int, validators=[wtforms.validators.DataRequired()]) sent_date = DateField(_(u'Sent Date'), description=_(u'Date sent for analysis.'), validators=[ wtforms.validators.Optional(), DateRange(min=date(1900, 1, 1)) ]) sent_name = wtforms.StringField( _(u'Sent Name '), description=_(u'The name of the aliquot\'s receiver.'), validators=[wtforms.validators.Optional()]) sent_notes = wtforms.TextAreaField( _(u'Sent Notes '), description=_(u'Notes about this aliquot\'s destination'), validators=[wtforms.validators.Optional()]) form = CheckoutForm(request.POST, location_id=context.id) if request.method == 'POST' and check_csrf_token(request): if 'save' in request.POST and form.validate(): for sample in vals['full_query']: apply_changes(form, sample) request.session.flash(_(u'Changed saved'), 'success') return HTTPOk( json={ '__next__': request.current_route_path(_route_name='lims.checkout') }) vals.update({'form': form}) return vals
def __call__(self): # If the request isn't an RSS feed, bail out if self.request.content_type not in ALLOWED_CONTENT: body_msg = ( "The content-type of the request must be one of the " "following: %s" ) % ", ".join(ALLOWED_CONTENT) return HTTPBadRequest(body=body_msg) # Create / update self._process_items() # Index in Solr self._update_index() # Return a 200 with details on what happened in the body self.messages.append("%s items created." % self.create_count) self.messages.append("%s items updated." % self.update_count) return HTTPOk(body=" ".join(self.messages))
def delete_json(context, request): check_csrf_token(request) dbsession = request.dbsession exists = ( dbsession.query(sa.literal(True)) .filter( dbsession.query(models.PatientReference) .filter_by(reference_type=context) .exists()) .scalar()) if exists: raise HTTPBadRequest( body=_(u'This reference number still has data associated with it')) dbsession.delete(context) dbsession.flush() return HTTPOk()
def get_job_inputs(request): # type: (PyramidRequest) -> AnyResponseType """ Retrieve the inputs values and outputs definitions of a job. """ job = get_job(request) schema = get_schema_query(request.params.get("schema"), strict=False) job_inputs = job.inputs job_outputs = job.outputs if schema: job_inputs = convert_input_values_schema(job_inputs, schema) job_outputs = convert_output_params_schema(job_outputs, schema) body = {"inputs": job_inputs, "outputs": job_outputs} body.update({"links": job.links(request, self_link="inputs")}) body = sd.JobInputsBody().deserialize(body) return HTTPOk(json=body)
def get_provider_processes(request): # type: (PyramidRequest) -> AnyViewResponse """ Retrieve available provider processes (GetCapabilities). """ detail = asbool(request.params.get("detail", True)) provider_id = request.matchdict.get("provider_id") store = get_db(request).get_store(StoreServices) service = store.fetch_by_name(provider_id) processes = service.processes(request) processes = [p.summary() if detail else p.id for p in processes] links = get_process_list_links(request, paging={}, total=None, provider=service) return HTTPOk(json={"processes": processes, "links": links})
def endereco_get(self): endereco = self.context schema = EnderecoSchema(many=False, strict=True) result = schema.dump(endereco) if endereco: res = dumps(dict( data=dict( code=200, endereco=result.data)), ensure_ascii=False) return HTTPOk(body=res, content_type='application/json; charset=UTF-8') msg = 'Nenhum registro encontrado' res = dumps(dict(error=dict(code=404, message=msg)), ensure_ascii=False) return HTTPNotFound(body=res, content_type='application/json; charset=UTF-8')
def registration(self): request = self.request nome = request.params.get('nome', None) cognome = request.params.get('cognome', None) password = request.params.get('password', None) username = request.params.get('username', None) logger.info('REGISTRATION INPUT sono: {nome}, {cognome}, {password}, {username}'.format(nome=nome, cognome=cognome, password=password, username=username)) if nome is not None and nome != '': if cognome is not None and cognome != '': if password is not None and password != '': if username is not None and username != '': # controller result = AuthenticationController.registration(request.dbsession, nome, cognome, password, username) logger.info('REGISTRATION OUTPUT é: {}'.format(json.dumps(result))) if result['code'] == self.success_request: logger.info('REGISTRATION COMPLETATA!') return HTTPOk(body='Registrazione completata con successo!') elif result['code'] == self.not_acceptable_request: logger.error('REGISTRATION FALLITA: {}'.format(result['message'])) return HTTPNotAcceptable(body=result['message']) elif result['code'] == self.conflict_request: logger.error('REGISTRATION FALLITA: {}'.format(result['message'])) return HTTPConflict(body=result['message']) else: logger.error('REGISTRATION FALLITA: errore inaspettato.') logger.error('{}'.format(result['message'])) return HTTPInternalServerError(body='Errore inaspettato. Ci scusiamo per il disagio!') else: logger.error('REGISTRATION FALLITA perché manca il parametro USERNAME') return HTTPNotAcceptable('Manca lo USERNAME! Controlla.') else: logger.error('REGISTRATION FALLITA perché manca il parametro PASSWORD') return HTTPNotAcceptable('Manca la PASSWORD! Controlla.') else: logger.error('REGISTRATION FALLITA perché manca il parametro COGNOME') return HTTPNotAcceptable('Manca il COGNOME! Controlla.') else: logger.error('REGISTRATION FALLITA perché manca il parametro NOME') return HTTPNotAcceptable('Manca il NOME! Controlla.')
def start(request): # # NIC の 情報を取得 # interface = 'lo0' if 'interface' in request.GET: interface = request.GET['interface'] # # NIC の 情報取得 # bacnet_address = None try: # # NIC から IPv4 アドレスの取得 # iface_data = netifaces.ifaddresses(interface) ipv4 = iface_data.get(netifaces.AF_INET) if not ipv4 == None: prefix = IPAddress(ipv4[0]['netmask']).netmask_bits() bacnet_address = '%s/%d' %(ipv4[0]['addr'], prefix) # # NIC の情報が見つからなかった場合の処理 # except ValueError: return HTTPBadRequest() # # BACnet アドレスが定義されていない場合 # if bacnet_address == None: return HTTPBadRequest() # # BACnet Daemon が 起動しているか確認 # if request.registry.bacnetd == None: # # BACnet Daemon の 起動 # request.registry.bacnetd = BACnetd(bacnet_address) request.registry.bacnetd.start() # # BACnet Daemon 起動結果を返す # return HTTPOk()
def success(self): response = HTTPOk() response.content_type = 'application/json' response.body = '{}' return response