import restx.security.PermitAll; //导入依赖的package包/类
@PermitAll
@PUT("/projects/{projectName}/resolve")
public Project resolve(String projectName) {

    checkNotNull(projectName); // TODO ça ne peut pas arriver
    Project project = projectRepository.findByName(projectName);
    if (project == null) {
        return null;
    }

    LOGGER.debug("Try to resolve the project {}", project.getName());

    project = dependenciesService.resolve(project);

    projectRepository.update(project);

    return project;
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@DELETE("/{workspace}/devices/{id}")
@PermitAll
public static Device deleteDevice(int workspace, int id) {

	Workspace ws = WorkspaceManager.get(workspace);
	Device device = ws.deleteDevice(id);
	ws.save();
	return device;
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@POST("/{workspace}/devices")
@PermitAll
public static Device postDevice(int workspace, Device msg) {
	Workspace ws = WorkspaceManager.get(workspace);
	Device device = ws.addDevice(msg);
	ws.save();
	return device;
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@PUT("/{workspace}/devices/{id}")
@PermitAll
public Device putDevice(int workspace, int id, Device msg) {
	Workspace ws = WorkspaceManager.get(workspace);
	Device device = ws.updateDevice(id, msg);
	ws.save();
	return device;
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@POST("/coap")
@PermitAll
public CoapResponseJson runRequest(CoapRequest req) {
	CoapClient c = new CoapClient();
	c.setURI(req.getUri());
	if (req.getMethod().toUpperCase().equals("PUT")) {
		return new CoapResponseJson(c.put(req.getReqBody(), MediaTypeRegistry.TEXT_PLAIN));
	} else if (req.getMethod().toUpperCase().equals("POST")) {
		return new CoapResponseJson(c.post(req.getReqBody(), MediaTypeRegistry.TEXT_PLAIN));
	}
	return new CoapResponseJson(c.get());
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@PUT("/{workspace}/question/{id}")
@PermitAll
public Question putQuestion(int workspace, String id, Question q) {
	List<Question> questions = questions(workspace);
	for (Question question : questions) {
		if (question.getId().equals(q.getId())) {
			question.setAnswer(q.getAnswer());
			question.setAnswerId(q.getAnswerId());
			WorkspaceManager.get(workspace).addAnswer(question.sendResponse());
			return q;
		}
	}
	return q;
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@POST("/{workspace}/copy")
@PermitAll
public static WorkspaceInfo copyWorkspace(int workspace, WorkspaceInfo body) {
	Backup b = WorkspaceManager.get(workspace).getBackup();
	WorkspaceInfo ws = WorkspaceManager.getInstance().createWorkspace(body);
	WorkspaceManager.get(ws.getId()).loadBackup(b);
	return ws;
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@POST("/{workspace}/queries")
@PermitAll
public static Query postQuery(int workspace, Query msg) {
	Workspace ws = WorkspaceManager.get(workspace);
	Query query = ws.addQuery(msg);
	ws.save();
	return query;
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@DELETE("/{workspace}/queries/{id}")
@PermitAll
public Query deleteQuery(int workspace, int id) {
	Workspace ws = WorkspaceManager.get(workspace);
	Query query = ws.deleteQuery(id);
	ws.save();
	return query;
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@PUT("/{workspace}/queries/{id}")
@PermitAll
public Query putQuery(int workspace, int id,
					  Query msg
) {
	Workspace ws = WorkspaceManager.get(workspace);
	Query query = ws.updateQuery(id, msg);
	ws.save();
	return query;
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@POST("/{workspace}/plan")
@PermitAll
public QueryResult plan(int workspace, Query query) {
	String result = null;

	try {
		result = WorkspaceManager.get(workspace).planMashup(query.getQuery(), query.getInput());
	} catch (Exception ex) {
		String error = "";
		ArrayList<SemanticsErrors> errquery = N3Linter.lint(query.getQuery());
		ArrayList<SemanticsErrors> errinput = N3Linter.lint(query.getInput());
		if (!errquery.isEmpty()) {

			error += "Query:\n" + toString(errquery) + "\n";
		}
		if (!errinput.isEmpty()) {
			error += "Input:\n" + toString(errinput) + "\n";
		}
		if (ex.getMessage() != null) {
			error = ex.getMessage() + "\n\n" + error;
		}

		return new QueryResult(error, errquery, errinput);
	}

	return new QueryResult(result, null, null);
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@POST("/{workspace}/all")
@PermitAll
public Backup postBackup(int workspace, Backup backup) {
	Workspace ws = WorkspaceManager.get(workspace);
	ws.loadBackup(backup);
	return backup;
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@GET("/{workspace}/load/{file}")
@PermitAll
public Backup loadFile(int workspace, String file) {

	ObjectMapper mapper = new ObjectMapper();
	try {
		Backup backup = mapper.readValue(IOUtils.toString(getClass().getResourceAsStream("/" + file + ".json")), Backup.class);
		return postBackup(workspace, backup);
	} catch (IOException e) {
		e.printStackTrace();
	}
	return null;
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@GET("/usecases")
@PermitAll
public ArrayList<UseCase> useCases() {
	ArrayList<UseCase> usecases = new ArrayList<UseCase>();
	usecases.add(new UseCase("Empty configuration", "empty"));
	usecases.add(new UseCase("Thermostat with semantic questions", "thermostat"));
	usecases.add(new UseCase("Thermostat", "thermostat_no_question"));
	usecases.add(new UseCase("Moving Robots", "bots"));
	usecases.add(new UseCase("Smart Home", "smarthome"));
	usecases.add(new UseCase("DEMO Queries", "demo_queries"));
	return usecases;
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@PermitAll
@GET("/simulate")
public ReactorResult simulate(ReactorDefinition definition) {
  SimulatorServer.validateReactorDefinition(definition);

  BigReactorSimulator simulator = new BigReactorSimulator(
      definition.isActivelyCooled(),
      SimulatorServer.MAX_NUMBER_OF_TICKS
  );
  FakeReactorWorld fakeReactorWorld = FakeReactorWorld.makeReactor(
      definition.getLayout(),
      definition.getxSize(),
      definition.getzSize(),
      definition.getHeight(),
      definition.getControlRodInsertion()
  );
  ReactorResult rawResult = simulator.simulate(fakeReactorWorld);

  return new ReactorResult()
      .setCoolantTemperature(rawResult.coolantTemperature)
      .setFuelConsumption(rawResult.fuelConsumption)
      // for display purposes
      .setFuelFertility(rawResult.fuelFertility * 100)
      .setFuelHeat(rawResult.fuelHeat)
      .setOutput(rawResult.output)
      .setReactorDefinition(definition)
      .setReactorHeat(rawResult.reactorHeat);
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@PermitAll
@GET("/optimize_insertion")
public Short optimizeInsertion(ReactorDefinition definition) {
  SimulatorServer.validateReactorDefinition(definition);

  BigReactorSimulator simulator = new BigReactorSimulator(
      definition.isActivelyCooled(),
      SimulatorServer.MAX_NUMBER_OF_TICKS
  );

  return new LinearControlRodOptimizer(
      ResultMetrics.efficiency(),
      simulator
  ).optimizeInsertion(definition);
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@POST("/texquery")
@PermitAll
public MathRequest texquery( MathRequest q ) {
	if( q.getType() == null ||  "".equals( q.getType()) ){
		q.setType( "tex" );
	}
	return q.run();
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@POST("/xquery")
@PermitAll
public MathRequest xquery( MathRequest q ) {
	if( q.getType() == null ||  "".equals( q.getType()) ){
		q.setType( "xquery" );
	}
	return q.run();
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@POST("/AnalyzeWikiText")
@PermitAll
public WikiDocumentOutput AnalyeWikiText(WikiTextRequest input) {
	try {
		return finder.outDocFromText(config, input.wikitext);
	} catch (Exception e) {
		e.printStackTrace();
		return new WikiDocumentOutput(false);
	}
}
 

import restx.security.PermitAll; //导入依赖的package包/类
@GET("/domains")
@PermitAll
public Iterable<WineDomain> getAllDomains(Optional<String> aoc) {
    if (aoc.isPresent()) {
        return domainRepository.getDomainsByAOC(aoc.get());
    }
    return domainRepository.getAllDomains();
}