private static synchronized void retrieveTestAccountsForAppIfNeeded() {
if (appTestAccounts != null) {
return;
}
appTestAccounts = new HashMap<String, TestAccount>();
// The data we need is split across two different FQL tables. We construct two queries, submit
// them
// together (the second one refers to the first one), then cross-reference the results.
// Get the test accounts for this app.
String testAccountQuery =
String.format(
"SELECT id,access_token FROM test_account WHERE app_id = %s", testApplicationId);
// Get the user names for those accounts.
String userQuery = "SELECT uid,name FROM user WHERE uid IN (SELECT id FROM #test_accounts)";
Bundle parameters = new Bundle();
// Build a JSON string that contains our queries and pass it as the 'q' parameter of the query.
JSONObject multiquery;
try {
multiquery = new JSONObject();
multiquery.put("test_accounts", testAccountQuery);
multiquery.put("users", userQuery);
} catch (JSONException exception) {
throw new FacebookException(exception);
}
parameters.putString("q", multiquery.toString());
// We need to authenticate as this app.
parameters.putString("access_token", getAppAccessToken());
Request request = new Request(null, "fql", parameters, null);
Response response = request.executeAndWait();
if (response.getError() != null) {
throw response.getError().getException();
}
FqlResponse fqlResponse = response.getGraphObjectAs(FqlResponse.class);
GraphObjectList<FqlResult> fqlResults = fqlResponse.getData();
if (fqlResults == null || fqlResults.size() != 2) {
throw new FacebookException("Unexpected number of results from FQL query");
}
// We get back two sets of results. The first is from the test_accounts query, the second from
// the users query.
Collection<TestAccount> testAccounts =
fqlResults.get(0).getFqlResultSet().castToListOf(TestAccount.class);
Collection<UserAccount> userAccounts =
fqlResults.get(1).getFqlResultSet().castToListOf(UserAccount.class);
// Use both sets of results to populate our static array of accounts.
populateTestAccounts(testAccounts, userAccounts);
return;
}
private Request createRequest(
Location location,
int radiusInMeters,
int resultsLimit,
String searchText,
Set<String> extraFields,
Session session) {
Request request =
Request.newPlacesSearchRequest(
session, location, radiusInMeters, resultsLimit, searchText, null);
Set<String> fields = new HashSet<String>(extraFields);
String[] requiredFields = new String[] {ID, NAME, LOCATION, CATEGORY, WERE_HERE_COUNT};
fields.addAll(Arrays.asList(requiredFields));
String pictureField = adapter.getPictureFieldSpecifier();
if (pictureField != null) {
fields.add(pictureField);
}
Bundle parameters = request.getParameters();
parameters.putString("fields", TextUtils.join(",", fields));
request.setParameters(parameters);
return request;
}
/**
* maintains a list of last <i>committedLog</i> or so committed requests. This is used for fast
* follower synchronization.
*
* @param request committed request
*/
public void addCommittedProposal(Request request) {
WriteLock wl = logLock.writeLock();
try {
wl.lock();
if (committedLog.size() > commitLogCount) {
committedLog.removeFirst();
minCommittedLog = committedLog.getFirst().packet.getZxid();
}
if (committedLog.isEmpty()) {
minCommittedLog = request.zxid;
maxCommittedLog = request.zxid;
}
ByteArrayOutputStream baos = new ByteArrayOutputStream();
BinaryOutputArchive boa = BinaryOutputArchive.getArchive(baos);
try {
request.getHdr().serialize(boa, "hdr");
if (request.getTxn() != null) {
request.getTxn().serialize(boa, "txn");
}
baos.close();
} catch (IOException e) {
LOG.error("This really should be impossible", e);
}
QuorumPacket pp = new QuorumPacket(Leader.PROPOSAL, request.zxid, baos.toByteArray(), null);
Proposal p = new Proposal();
p.packet = pp;
p.request = request;
committedLog.add(p);
maxCommittedLog = p.packet.getZxid();
} finally {
wl.unlock();
}
}
@Override
public DbFuture<PreparedUpdate> prepareUpdate(String sql) {
checkClosed();
final Request request = requestCreator.executePrepareUpdate(sql);
queRequest(request);
return (DbFuture<PreparedUpdate>) request.getToComplete();
}
private void onOK() {
if (!isValidInput()) {
return;
}
dispose();
String firstName = firstNameField.getText().trim();
String lastName = lastNameField.getText().trim();
String emailAddress = emailAddressField.getText().trim();
SexOfPerson sexOfPerson;
if (femaleRadioButton.isSelected()) {
sexOfPerson = SexOfPerson.FEMALE;
} else {
sexOfPerson = SexOfPerson.MALE;
}
String country = (String) countryComboBox.getSelectedObject();
Integer birthdayYear = (Integer) birthdayYearComboBox.getSelectedItem();
Month birthdayMonth = (Month) birthdayMonthComboBox.getSelectedItem();
Integer birthdayDay = (Integer) birthdayDayComboBox.getSelectedItem();
char[] passwordArr = passwordField.getPassword();
String password = new String(passwordArr);
Arrays.fill(passwordArr, (char) 0);
Image profilePicture = null;
if (imageFromFileRadioButton.isSelected()) {
if (fileSelector.getFilePath() != null) {
profilePicture = new FileImage(fileSelector.getFilePath());
}
}
Request request =
new CreateUserRequest(
communicator.getHttpClient(),
frame,
firstName,
lastName,
emailAddress,
sexOfPerson,
country,
birthdayYear,
birthdayMonth,
birthdayDay,
password,
profilePicture) {
@Override
protected void onCreateUser(String status, Person person) {
if (status.equals("INVALID_PROFILE_PICTURE")) {
communicator.promptForCreateAccount("Invalid profile picture");
} else if (status.equals("ERROR_CREATING_USER")) {
communicator.promptForCreateAccount("Error creating user");
} else if (status.equals("CONNECTION_ERROR")) {
communicator.promptForCreateAccount("Error connecting to Modeling Commons");
} else if (status.equals("SUCCESS")) {
communicator.setPerson(person);
communicator.promptForUpload();
} else {
communicator.promptForCreateAccount("Unknown server error");
}
}
};
request.execute();
}
/**
* Validates a specified template.
*
* @param validateTemplateRequest The input for <a>ValidateTemplate</a> action.
* @return Result of the ValidateTemplate operation returned by the service.
* @sample AmazonCloudFormation.ValidateTemplate
*/
@Override
public ValidateTemplateResult validateTemplate(ValidateTemplateRequest validateTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(validateTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<ValidateTemplateRequest> request = null;
Response<ValidateTemplateResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request =
new ValidateTemplateRequestMarshaller()
.marshall(super.beforeMarshalling(validateTemplateRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler<ValidateTemplateResult> responseHandler =
new StaxResponseHandler<ValidateTemplateResult>(
new ValidateTemplateResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
public static void zhongbiao(Long id) {
Toubiao toubiao = Toubiao.findById(id);
toubiao.status = "1";
toubiao.save();
Request request = toubiao.request;
request.status = 1;
request.zb = true;
request.save();
List<Toubiao> toubiaos = Toubiao.find("request.id=? and id!=?", request.id, id).fetch();
for (Toubiao tb : toubiaos) {
tb.status = "2";
tb.save();
}
Config config = Config.find("1=1").first();
String message = "";
SendMessage m = new SendMessage();
message = "您已中标" + toubiao.request.name + "项目，请按时发货";
if (config.msg_request_invite != null && !"".equals(config.msg_request_invite)) {
message = config.msg_request_notification.replace("{request}", toubiao.request.name);
}
Profile p = toubiao.profile;
if (p.contact_phone != null && !"".equals(p.contact_phone))
m.sendSms(p.contact_phone, message, "0000003");
if (p.contact_email != null && !"".equals(p.contact_email))
m.sendMail(p.contact_email, "[" + Messages.get("application.name") + "]中标通知", message);
redirect("/admin/requests");
}
public static void logout(final Callback<Boolean> callback) {
HashMap<String, String> parameter = new HashMap<>();
parameter.put("token", getTokenAsString());
Request<Boolean> request =
new Request<>(
HttpVerb.POST,
serverUrl + "/public/logout",
Boolean.class,
parameter,
new Callback<Boolean>() {
@Override
public void onCompletion(Boolean input) {
if (input) {
token = null;
}
callback.onCompletion(input);
}
@Override
public void onError(String message) {
token = null;
callback.onError(message);
}
});
request.execute();
}
public static void register(
String mail,
String password,
String name,
String studentenNumber,
final Callback<Boolean> callback) {
HashMap<String, String> parameter = new HashMap<>();
parameter.put("email", mail);
parameter.put("password", password);
parameter.put("name", name);
parameter.put("studentnumber", studentenNumber);
Request<Boolean> request =
new Request<>(
HttpVerb.POST,
serverUrl + "/public/register",
Boolean.class,
parameter,
new Callback<Boolean>() {
@Override
public void onCompletion(Boolean input) {
callback.onCompletion(input);
}
@Override
public void onError(String message) {
callback.onError(message);
}
});
request.execute();
}
public static void reserveGadget(Gadget toReserve, final Callback<Boolean> callback) {
if (token == null) {
throw new IllegalStateException("Not logged in");
}
HashMap<String, String> parameter = new HashMap<>();
parameter.put("token", getTokenAsString());
parameter.put("gadgetId", toReserve.getInventoryNumber());
Request<Boolean> request =
new Request<>(
HttpVerb.POST,
serverUrl + "/public/reservations",
new TypeToken<Boolean>() {}.getType(),
parameter,
new Callback<Boolean>() {
@Override
public void onCompletion(Boolean success) {
callback.onCompletion(success);
}
@Override
public void onError(String message) {
callback.onError(message);
}
});
request.execute();
}
public static void deleteReservation(Reservation toDelete, final Callback<Boolean> callback) {
if (token == null) {
throw new IllegalStateException("Not logged in");
}
HashMap<String, String> parameter = new HashMap<>();
parameter.put("token", getTokenAsString());
parameter.put("id", toDelete.getReservationId());
Request<Boolean> request =
new Request<>(
HttpVerb.DELETE,
serverUrl + "/public/reservations",
Boolean.class,
parameter,
new Callback<Boolean>() {
@Override
public void onCompletion(Boolean input) {
callback.onCompletion(input);
}
@Override
public void onError(String message) {
callback.onError(message);
}
});
request.execute();
}
// Ensures that reply field is non-null
//
private void build() throws IOException {
Request.Action action = request.action();
if ((action != Request.Action.GET) && (action != Request.Action.HEAD)) {
reply = new Reply(Reply.Code.METHOD_NOT_ALLOWED, new StringContent(request.toString()));
}
reply = new Reply(Reply.Code.OK, new FileContent(request.uri()), action);
}
/**
* Writes an array of bytes on the stream. This method may not be used until this stream has been
* passed to one of the methods in HTTPConnection (i.e. until it has been associated with a
* request).
*
* @param buf an array containing the data to write
* @param off the offset of the data whithin the buffer
* @param len the number bytes (starting at <var>off</var>) to write
* @exception IOException if any exception is thrown by the socket, or if writing <var>len</var>
* bytes would cause more bytes to be written than this stream is willing to accept.
* @exception IllegalAccessError if this stream has not been associated with a request yet
*/
public synchronized void write(byte[] buf, int off, int len)
throws IOException, IllegalAccessError {
if (req == null) throw new IllegalAccessError("Stream not associated with a request");
if (ignore) return;
if (length != -1 && rcvd + len > length) {
IOException ioe =
new IOException("Tried to write too many bytes (" + (rcvd + len) + " > " + length + ")");
req.getConnection().closeDemux(ioe, false);
req.getConnection().outputFinished();
throw ioe;
}
try {
if (bos != null) bos.write(buf, off, len);
else if (length != -1) os.write(buf, off, len);
else os.write(Codecs.chunkedEncode(buf, off, len, null, false));
} catch (IOException ioe) {
req.getConnection().closeDemux(ioe, true);
req.getConnection().outputFinished();
throw ioe;
}
rcvd += len;
}
public void handleRequest(Request request) {
if (request.getValue() >= 0) {
System.out.println("Zero values are handled by HandlerThree:");
System.out.println(
"HandlerThree.HandleRequest : " + request.getDescription() + request.getValue());
}
}
private <X, Y extends AmazonWebServiceRequest> Response<X> invoke(
Request<Y> request,
HttpResponseHandler<AmazonWebServiceResponse<X>> responseHandler,
ExecutionContext executionContext) {
request.setEndpoint(endpoint);
request.setTimeOffset(timeOffset);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
AWSCredentials credentials;
awsRequestMetrics.startEvent(Field.CredentialsRequestTime);
try {
credentials = awsCredentialsProvider.getCredentials();
} finally {
awsRequestMetrics.endEvent(Field.CredentialsRequestTime);
}
AmazonWebServiceRequest originalRequest = request.getOriginalRequest();
if (originalRequest != null && originalRequest.getRequestCredentials() != null) {
credentials = originalRequest.getRequestCredentials();
}
executionContext.setCredentials(credentials);
DefaultErrorResponseHandler errorResponseHandler =
new DefaultErrorResponseHandler(exceptionUnmarshallers);
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
/**
* this action allows you to give the path of a track on disk, and it will be resolved to the
* tracks internal ID. this can then be used normally for playing music. the path coming in is
* assumed to have forward slashes to delimit path components, but this needs to be converted to
* whatever the actual path separator is for the current system BEFORE we try and query the
* database, otherwise, well, it just won't work.
*
* <p>NB! ATM, this feature is only here for the the folder browsing stuff, so if that's not
* turned on this this won't work.
*/
protected void resolvePath() throws BadRequestException, SQLException, IOException {
// check folder browsing is enabled
Utils.checkFeatureEnabled(getProperties(), "browse.folders.enabled");
ResultSet rs = null;
PreparedStatement st = null;
try {
final Database db = getDatabase();
final Locale locale = getLocale();
final Request req = getRequest();
final String path = convertPath(req.getArgument("path"));
final String sql = Track.getSelectFromSql() + " where t.path = ? ";
st = db.prepare(sql);
st.setString(1, path);
rs = st.executeQuery();
if (!rs.next())
throw new BadRequestException(locale.getString("www.error.trackNotFound"), 404);
final Track track = Track.createFromResultSet(rs);
final TResolvePath tpl = new TResolvePath();
tpl.setTrack(track);
getResponse().showJson(tpl.makeRenderer());
} finally {
Utils.close(rs);
Utils.close(st);
}
}
/**
* Sends a signal to the specified resource with a success or failure status. You can use the
* SignalResource API in conjunction with a creation policy or update policy. AWS CloudFormation
* doesn't proceed with a stack creation or update until resources receive the required number of
* signals or the timeout period is exceeded. The SignalResource API is useful in cases where you
* want to send signals from anywhere other than an Amazon EC2 instance.
*
* @param signalResourceRequest The input for the <a>SignalResource</a> action.
* @sample AmazonCloudFormation.SignalResource
*/
@Override
public void signalResource(SignalResourceRequest signalResourceRequest) {
ExecutionContext executionContext = createExecutionContext(signalResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<SignalResourceRequest> request = null;
Response<Void> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request =
new SignalResourceRequestMarshaller()
.marshall(super.beforeMarshalling(signalResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler<Void> responseHandler = new StaxResponseHandler<Void>(null);
invoke(request, responseHandler, executionContext);
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* saves a playlist to the database for the current user. outputs a single integer which is the
* playlist ID if all goes well, otherwise you'll get a description of the problem.
*
* @throws IOException
*/
protected void savePlaylist() throws IOException, SQLException, BadRequestException {
final Request req = getRequest();
final User user = getUser();
final Locale locale = getLocale();
final String name = req.getUrlParam(2).trim();
final String[] args = req.getPlayParams(2);
String result = locale.getString("www.json.error.unknown");
// make sure data is ok first
if (name.equals("")) result = locale.getString("www.json.error.noName");
else if (args.length == 0) result = locale.getString("www.json.error.noArguments");
else if (user == null) result = locale.getString("www.json.error.notLoggedIn");
else {
final Database db = getDatabase();
final List<Track> vTracks = Track.getTracksFromPlayArgs(db, args);
final Track[] tracks = new Track[vTracks.size()];
for (int i = 0; i < vTracks.size(); i++) tracks[i] = vTracks.get(i);
result = Integer.toString(cm.savePlaylist(name, tracks, user));
}
final TString tpl = new TString();
tpl.setResult(result);
getResponse().showJson(tpl.makeRenderer());
}
/**
* Aborts the connection in response to an error.
*
* @param e The error that caused the connection to be aborted. Never null.
*/
@java.lang.SuppressWarnings("ToArrayCallWithZeroLengthArrayArgument")
@SuppressWarnings(
"ITA_INEFFICIENT_TO_ARRAY") // intentionally; race condition on listeners otherwise
protected void terminate(IOException e) {
try {
synchronized (this) {
if (e == null) throw new IllegalArgumentException();
outClosed = inClosed = e;
try {
transport.closeRead();
} catch (IOException x) {
logger.log(Level.WARNING, "Failed to close down the reader side of the transport", x);
}
try {
synchronized (pendingCalls) {
for (Request<?, ?> req : pendingCalls.values()) req.abort(e);
pendingCalls.clear();
}
synchronized (executingCalls) {
for (Request<?, ?> r : executingCalls.values()) {
java.util.concurrent.Future<?> f = r.future;
if (f != null) f.cancel(true);
}
executingCalls.clear();
}
} finally {
notifyAll();
}
} // JENKINS-14909: leave synch block
} finally {
if (e instanceof OrderlyShutdown) e = null;
for (Listener l : listeners.toArray(new Listener[0])) l.onClosed(this, e);
}
}
/**
* given some url arguments (ar123, al456, etc...) queries for the tracks that belong to these
* items
*
* @throws java.io.IOException
* @throws java.sql.SQLException
* @throws com.pugh.sockso.web.BadRequestException
*/
protected void tracks() throws IOException, SQLException, BadRequestException {
final Request req = getRequest();
final List<Track> tracks = Track.getTracksFromPlayArgs(getDatabase(), req.getPlayParams(true));
showTracks(tracks);
}
@Override
public DbFuture<Result> executeUpdate(String sql) {
checkClosed();
final Request request = requestCreator.executeUpdate(sql);
queRequest(request);
return (DbFuture) request.getToComplete();
}
@Override
public void checkRecycled(org.apache.coyote.Request req, org.apache.coyote.Response res) {
Request request = (Request) req.getNote(ADAPTER_NOTES);
Response response = (Response) res.getNote(ADAPTER_NOTES);
String messageKey = null;
if (request != null && request.getHost() != null) {
messageKey = "coyoteAdapter.checkRecycled.request";
} else if (response != null && response.getContentWritten() != 0) {
messageKey = "coyoteAdapter.checkRecycled.response";
}
if (messageKey != null) {
// Log this request, as it has probably skipped the access log.
// The log() method will take care of recycling.
log(req, res, 0L);
if (connector.getState().isAvailable()) {
if (log.isInfoEnabled()) {
log.info(sm.getString(messageKey), new RecycleRequiredException());
}
} else {
// There may be some aborted requests.
// When connector shuts down, the request and response will not
// be reused, so there is no issue to warn about here.
if (log.isDebugEnabled()) {
log.debug(sm.getString(messageKey), new RecycleRequiredException());
}
}
}
}
public void forceQueRequest(Request request) {
synchronized (lock) {
if (blockingRequest == null) {
requestQueue.add(request);
channel.writeAndFlush(request.getRequest());
if (request.isBlocking()) {
blockingRequest = new BlockingRequestInProgress(request);
request
.getToComplete()
.addListener(
new DbListener<Object>() {
@Override
public void onCompletion(DbFuture<Object> future) {
blockingRequest.continueWithRequests();
}
});
}
} else {
if (blockingRequest.unblockBy(request)) {
requestQueue.add(request);
channel.writeAndFlush(request.getRequest());
} else {
blockingRequest.add(request);
}
}
}
}
public IRequestHandler mapRequest(final Request request) {
final Url url = this.decryptUrl(request, request.getUrl());
if (url == null) {
return this.wrappedMapper.mapRequest(request);
}
return this.wrappedMapper.mapRequest(request.cloneWithUrl(url));
}
@Override
public void messageReceived(Request request, final TransportChannel channel) throws Exception {
// we just send back a response, no need to fork a listener
request.listenerThreaded(false);
// we don't spawn, so if we get a request with no threading, change it to single threaded
if (request.operationThreading() == BroadcastOperationThreading.NO_THREADS) {
request.operationThreading(BroadcastOperationThreading.SINGLE_THREAD);
}
execute(
request,
new ActionListener<Response>() {
@Override
public void onResponse(Response response) {
try {
channel.sendResponse(response);
} catch (Throwable e) {
onFailure(e);
}
}
@Override
public void onFailure(Throwable e) {
try {
channel.sendResponse(e);
} catch (Exception e1) {
logger.warn("Failed to send response", e1);
}
}
});
}
private void fetchUserInfo() {
if (fetchUserInfo) {
final Session currentSession = sessionTracker.getOpenSession();
if (currentSession != null) {
if (currentSession != userInfoSession) {
Request request =
Request.newMeRequest(
currentSession,
new Request.GraphUserCallback() {
@Override
public void onCompleted(GraphUser me, Response response) {
if (currentSession == sessionTracker.getOpenSession()) {
user = me;
if (userInfoChangedCallback != null) {
userInfoChangedCallback.onUserInfoFetched(user);
}
}
if (response.getError() != null) {
handleError(response.getError().getException());
}
}
});
Request.executeBatchAsync(request);
userInfoSession = currentSession;
}
} else {
user = null;
if (userInfoChangedCallback != null) {
userInfoChangedCallback.onUserInfoFetched(user);
}
}
}
}
public static final void main(String[] args) {
try {
// load up the knowledge base
KnowledgeBase kbase = readKnowledgeBase();
StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
KnowledgeRuntimeLogger logger =
KnowledgeRuntimeLoggerFactory.newThreadedFileLogger(ksession, "test", 1000);
ksession.getWorkItemManager().registerWorkItemHandler("Human Task", new WSHumanTaskHandler());
// start a new process instance by setup of a Person and Request.
Person person = new Person("erics", "Eric D. Schabell");
person.setAge(43);
Request request = new Request("1");
request.setPersonId("erics");
request.setAmount(1999);
ksession.insert(person);
// put them in the Map to be passed to the startProcess.
Map<String, Object> params = new HashMap<String, Object>();
params.put("person", person);
params.put("request", request);
// Fire it up!
WorkflowProcessInstance processInstance =
(WorkflowProcessInstance) ksession.startProcess("org.jbpm.demo.rulenode", params);
ksession.insert(processInstance);
ksession.fireAllRules();
// Finished, clean up the logger.
System.out.println("Process Ended.");
logger.close();
} catch (Throwable t) {
t.printStackTrace();
}
}
public static void checkmtime(Request req, long mtime) {
/* Since the HTTP time format is (reasonably enough) precise
* only to seconds, any extra milliseconds must be trimmed
* off, or the mtime will almost certainly not match. */
final Date mdate = new Date((mtime / 1000) * 1000);
String ims = req.inheaders().get("If-Modified-Since");
if (ims != null) {
Date cldate;
try {
cldate = Http.parsedate(ims);
} catch (java.text.ParseException e) {
throw (new ClientError("The If-Modified-Since header is not parseable."));
}
if (mdate.compareTo(cldate) <= 0) {
throw (new RequestRestart() {
public void respond(Request req) {
req.status(304);
req.outheaders().put("Content-Length", "0");
req.outheaders().put("Last-Modified", Http.fmtdate(mdate));
}
});
}
}
req.outheaders().put("Last-Modified", Http.fmtdate(mdate));
}
/*
* An analysis, experiment, or data track can be part of many topics. This convenience method
* allows the caller to send in the list of parent topics and it will generate XML nodes showing the
* topic with its contents. This methods is used the GetAnalysis, GetRequest, and GetDataTrack to
* fill in the XML structure for "related" topics.
*/
public static void appendParentTopicsXML(
SecurityAdvisor secAdvisor, Element parentNode, Set topics)
throws UnknownPermissionException {
for (Topic topic : (Set<Topic>) topics) {
Element topicNode = new Element("Topic");
topicNode.setAttribute("idTopic", topic.getIdTopic().toString());
topicNode.setAttribute(
"label",
(secAdvisor.canRead(topic)
? (topic.getName() != null ? topic.getName() : "")
: "(Not authorized)"));
topicNode.setAttribute("codeVisibility", topic.getCodeVisibility());
parentNode.addContent(topicNode);
for (Request r : (Set<Request>) topic.getRequests()) {
Element rNode = new Element("Request");
r.appendBasicXML(secAdvisor, topicNode);
}
for (Analysis a : (Set<Analysis>) topic.getAnalyses()) {
Element aNode = new Element("Analysis");
a.appendBasicXML(secAdvisor, topicNode);
}
for (DataTrack dt : (Set<DataTrack>) topic.getDataTracks()) {
Element dtNode = new Element("DataTrack");
dt.appendBasicXML(secAdvisor, topicNode);
}
}
}
public <T> Request<T> add(Request<T> request) {
request.setRequestQueue(this);
// 给request编序号
request.setSequence(getSequenceNumber());
mNetworkQueue.add(request);
return request;
}
