public synchronized void setBytesReceived(long bytesReceived) {
deadBytesReceived = bytesReceived;
for (int i = 0; i < processors.size(); i++) {
RequestInfo rp = processors.get(i);
rp.setBytesReceived(bytesReceived);
}
}
public synchronized void setProcessingTime(long totalTime) {
deadProcessingTime = totalTime;
for (int i = 0; i < processors.size(); i++) {
RequestInfo rp = processors.get(i);
rp.setProcessingTime(totalTime);
}
}
public synchronized void setErrorCount(int errorCount) {
deadErrorCount = errorCount;
for (int i = 0; i < processors.size(); i++) {
RequestInfo rp = processors.get(i);
rp.setErrorCount(errorCount);
}
}
public synchronized void setRequestCount(int requestCount) {
deadRequestCount = requestCount;
for (int i = 0; i < processors.size(); i++) {
RequestInfo rp = processors.get(i);
rp.setRequestCount(requestCount);
}
}
protected void register(AbstractProcessor<S> processor) {
if (getProtocol().getDomain() != null) {
synchronized (this) {
try {
long count = registerCount.incrementAndGet();
RequestInfo rp = processor.getRequest().getRequestProcessor();
rp.setGlobalProcessor(global);
ObjectName rpName =
new ObjectName(
getProtocol().getDomain()
+ ":type=RequestProcessor,worker="
+ getProtocol().getName()
+ ",name="
+ getProtocol().getProtocolName()
+ "Request"
+ count);
if (getLog().isDebugEnabled()) {
getLog().debug("Register " + rpName);
}
Registry.getRegistry(null, null).registerComponent(rp, rpName, null);
rp.setRpName(rpName);
} catch (Exception e) {
getLog().warn("Error registering request");
}
}
}
}
public synchronized void setBytesSent(long bytesSent) {
deadBytesSent = bytesSent;
for (int i = 0; i < processors.size(); i++) {
RequestInfo rp = processors.get(i);
rp.setBytesSent(bytesSent);
}
}
// Used to reset the times
public synchronized void setMaxTime(long maxTime) {
deadMaxTime = maxTime;
for (int i = 0; i < processors.size(); i++) {
RequestInfo rp = processors.get(i);
rp.setMaxTime(maxTime);
}
}
public synchronized long getBytesSent() {
long bytes = deadBytesSent;
for (int i = 0; i < processors.size(); i++) {
RequestInfo rp = processors.get(i);
bytes += rp.getBytesSent();
}
return bytes;
}
public synchronized long getMaxTime() {
long maxTime = deadMaxTime;
for (int i = 0; i < processors.size(); i++) {
RequestInfo rp = processors.get(i);
if (maxTime < rp.getMaxTime()) maxTime = rp.getMaxTime();
}
return maxTime;
}
public synchronized long getProcessingTime() {
long time = deadProcessingTime;
for (int i = 0; i < processors.size(); i++) {
RequestInfo rp = processors.get(i);
time += rp.getProcessingTime();
}
return time;
}
public synchronized int getRequestCount() {
int requestCount = deadRequestCount;
for (int i = 0; i < processors.size(); i++) {
RequestInfo rp = processors.get(i);
requestCount += rp.getRequestCount();
}
return requestCount;
}
private static void setRequestHeaders(HttpConnection connection, RequestInfo requestInfo)
throws IOException {
if (requestInfo == null) {
return;
}
String requestHeader;
for (int i = 0; (requestHeader = requestInfo.headerName(i)) != null; ++i) {
connection.setRequestProperty(requestHeader, requestInfo.headerValue(i));
}
}
private PersistenceManager doJob(PersistenceManager pm, Object req) {
JSONObject response = null;
if (req instanceof AccessLog) {
executeInsert(pm, (AccessLog) req);
return pm;
}
RequestInfo requestInfo = (RequestInfo) req;
switch (requestInfo.type) {
case TYPE_QUERY_DELTE:
requestInfo.ids = queryAccessLog(pm, requestInfo.query);
case TYPE_LIST_DELTE:
response = new JSONObject();
response.element("command", "listDelete");
response.element("result", "success");
executeDelete(pm, requestInfo.ids);
break;
case TYPE_QUERY_EXPORT:
requestInfo.ids = queryAccessLog(pm, requestInfo.query);
case TYPE_LIST_EXPORT:
try {
File exportFile = executeExport(pm, requestInfo.ids);
Blob exportBlob = Blob.create(exportFile, true);
requestInfo.peer.download(exportBlob);
} catch (IOException e) {
response = new JSONObject();
response.element("command", "listExport");
response.element("result", "fail");
logger.warn("failt to export", e);
} catch (Throwable t) {
response = new JSONObject();
response.element("command", "listExport");
response.element("result", "fail");
logger.error("failt to export", t);
}
break;
case TYPE_IMPORT:
try {
pm = null;
executeImport(requestInfo.importBlob, requestInfo.peer);
} catch (IOException e) {
logger.warn("failt to import", e);
response = new JSONObject();
response.element("command", "import");
response.element("result", "fail");
}
break;
}
if (requestInfo.peer != null && response != null) {
requestInfo.peer.message(response);
}
return pm;
}
@Override
protected boolean handlePut(RequestInfo requestInfo) throws ServletException {
String gitSegment = requestInfo.gitSegment;
HttpServletRequest request = requestInfo.request;
HttpServletResponse response = requestInfo.response;
Repository db = requestInfo.db;
String filePath = requestInfo.relativePath;
JSONObject toPut = requestInfo.getJSONRequest();
try {
boolean isRoot = "".equals(filePath); // $NON-NLS-1$
String tagName = toPut.getString(ProtocolConstants.KEY_NAME);
if (tagName != null) {
return tag(request, response, db, gitSegment, tagName, isRoot);
}
return false;
} catch (Exception e) {
return statusHandler.handleRequest(
request,
response,
new ServerStatus(
IStatus.ERROR,
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"An error occured when tagging.",
e));
}
}
private static void genCode(ArrayList<RequestInfo> infos) {
StringBuilder sb = new StringBuilder();
for (RequestInfo info : infos) {
// /**
// * Search - 搜索 石种
// */
// public static final String SEARCH_STONE = "/search/stone";
// url地址后缀
String urlEnd = info.getUrlEnd();
// 替换/为_同时转大写
String name = info.getUrlEnd().replace("/", "_").toUpperCase(Locale.CHINA).substring(1);
sb.append(StringUtils.formatSingleLine(1, "/**"));
sb.append(StringUtils.formatSingleLine(1, " * " + info.getDes()));
sb.append(StringUtils.formatSingleLine(1, " */"));
sb.append(
StringUtils.formatSingleLine(
1, "public static final String " + name + " = \"" + urlEnd + "\";"));
sb.append("\n");
// HashMap<String, Object> postParams = new HashMap<String, Object>();
// postParams.put("page", page);
// postParams.put("keyword", searchKey);
sb.append(
StringUtils.formatSingleLine(
2, "HashMap<String, Object> postParams = new HashMap<String, Object>();"));
for (RequestParam param : info.getParams()) {
sb.append(
StringUtils.formatSingleLine(
2,
"postParams.put(\""
+ param.getName()
+ "\", "
+ param.getName()
+ ");"
+ " // "
+ param.getDes()));
}
System.out.println("----------------------");
}
System.out.println(sb.toString());
}
public void run() {
while (running) {
RequestInfo r = queue.get();
BufferedWriter bw = null;
try {
File file = getFile();
bw = new BufferedWriter(new FileWriter(file, true));
bw.write(r.toString());
bw.newLine();
// bw.flush();
} catch (Throwable e) {
outFile = null;
e.printStackTrace();
} finally {
FileUtil.close(bw);
}
}
}
@Override
public void service(final WebdavRequest request, final WebdavResponse response)
throws WebdavException, IOException {
logger.debug("Setting request in RequestInfo: {}", requestInfo);
// final String mount = request.getParameter( RequestInfo.MOUNT_POINT );
requestInfo.setRequest(request);
super.service(request, response);
}
public synchronized void removeRequestProcessor(RequestInfo rp) {
if (rp != null) {
if (deadMaxTime < rp.getMaxTime()) deadMaxTime = rp.getMaxTime();
deadProcessingTime += rp.getProcessingTime();
deadRequestCount += rp.getRequestCount();
deadErrorCount += rp.getErrorCount();
deadBytesReceived += rp.getBytesReceived();
deadBytesSent += rp.getBytesSent();
processors.remove(rp);
}
}
protected void unregister(Processor<S> processor) {
if (getProtocol().getDomain() != null) {
synchronized (this) {
try {
Request r = processor.getRequest();
if (r == null) {
// Probably an UpgradeProcessor
return;
}
RequestInfo rp = r.getRequestProcessor();
rp.setGlobalProcessor(null);
ObjectName rpName = rp.getRpName();
if (getLog().isDebugEnabled()) {
getLog().debug("Unregister " + rpName);
}
Registry.getRegistry(null, null).unregisterComponent(rpName);
rp.setRpName(null);
} catch (Exception e) {
getLog().warn("Error unregistering request", e);
}
}
}
}
public void sendRecoverVerifyMail(
RequestInfo reqInfo, String email, AccessToken at, AppUtil appUtils)
throws IOException, TemplateException {
Template tpl = wcfmcfg.getTemplate("account/recoverpwdmail.ftl");
StringWriter sw = new StringWriter();
Map<String, Object> dataModel = appUtils.createDataModel(reqInfo, reqInfo.isSsl());
String returnTo = at.getReturnTo();
String fireHost = returnTo.split(",")[0];
dataModel.put("appHost", fireHost);
dataModel.put("token", at);
tpl.process(dataModel, sw);
awsSesSerivce.sendEmail(true, "*****@*****.**", "M3958重置密码", sw.toString(), email);
}
private void selectPage(RequestInfo requestInfo) {
String path = requestInfo.getPath();
if (path.equals("/hello")) {
sleep();
requestInfo.writeResponse(Pages.getHelloPage());
} else if (path.equals("/status")) {
requestInfo.writeResponse(Pages.getStatisticsPage());
} else if (path.equals("/redirect") && requestInfo.getUrl() != null) {
requestInfo.redirect(requestInfo.getUrl());
} else {
requestInfo.writeResponse(Pages.getNotFoundPage());
}
}
@Override
protected boolean handlePost(RequestInfo requestInfo) throws ServletException {
JSONObject requestPayload = requestInfo.getJSONRequest();
HttpServletRequest request = requestInfo.request;
HttpServletResponse response = requestInfo.response;
Repository db = requestInfo.db;
String indexMessage = requestPayload.optString(GitConstants.KEY_STASH_INDEX_MESSAGE);
String workingDirectoryMessage =
requestPayload.optString(GitConstants.KEY_STASH_WORKING_DIRECTORY_MESSAGE);
boolean includeUntracked =
requestPayload.optBoolean(GitConstants.KEY_STASH_INCLUDE_UNTRACKED, false);
try {
Git git = new Git(db);
StashCreateCommand stashCreate = git.stashCreate();
stashCreate.setPerson(new PersonIdent(db));
stashCreate.setIncludeUntracked(includeUntracked);
if (!indexMessage.isEmpty()) stashCreate.setIndexMessage(indexMessage);
if (!workingDirectoryMessage.isEmpty())
stashCreate.setWorkingDirectoryMessage(workingDirectoryMessage);
stashCreate.call();
return true;
} catch (Exception ex) {
String msg = "An error occured for stash command.";
return statusHandler.handleRequest(
request,
response,
new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, msg, ex));
}
}
protected static void setUserAgent(HttpURLConnection connection, RequestInfo info) {
connection.setRequestProperty(
REQUEST_USER_AGENT_FIELD, info.get(RequestInfo.KEY_HTTP_USER_AGENT));
}
@Override
protected boolean handlePost(RequestInfo requestInfo) throws ServletException {
String gitSegment = requestInfo.gitSegment;
HttpServletRequest request = requestInfo.request;
HttpServletResponse response = requestInfo.response;
Repository db = requestInfo.db;
String pattern = requestInfo.relativePath;
JSONObject requestObject = requestInfo.getJSONRequest();
try {
String commitToMerge = requestObject.optString(GitConstants.KEY_MERGE, null);
if (commitToMerge != null) {
boolean squash = requestObject.optBoolean(GitConstants.KEY_SQUASH, false);
return merge(request, response, db, commitToMerge, squash);
}
String commitToRebase = requestObject.optString(GitConstants.KEY_REBASE, null);
String rebaseOperation = requestObject.optString(GitConstants.KEY_OPERATION, null);
if (commitToRebase != null) {
return rebase(request, response, db, commitToRebase, rebaseOperation);
}
String commitToCherryPick = requestObject.optString(GitConstants.KEY_CHERRY_PICK, null);
if (commitToCherryPick != null) {
return cherryPick(request, response, db, commitToCherryPick);
}
String commitToRevert = requestObject.optString(GitConstants.KEY_REVERT, null);
if (commitToRevert != null) {
return revert(request, response, db, commitToRevert);
}
String newCommit = requestObject.optString(GitConstants.KEY_COMMIT_NEW, null);
if (newCommit != null) return identifyNewCommitResource(request, response, db, newCommit);
String reviewReqLogin = requestObject.optString(GitConstants.KEY_REVIEW_REQ_NOTIFY_LOGIN);
if (reviewReqLogin != null && reviewReqLogin.length() != 0) {
String reviewReqUrl = requestObject.optString(GitConstants.KEY_REVIEW_REQ_URL);
String ReviewReqCommit = requestObject.optString(GitConstants.KEY_REVIEW_REQ_COMMIT);
String ReviewReqAuthorName =
requestObject.optString(GitConstants.KEY_REVIEW_REQ_AUTHOR_NAME);
String ReviewMessage = requestObject.optString(GitConstants.KEY_REVIEW_REQ_MESSAGE);
return sendNotification(
request,
response,
db,
reviewReqLogin,
ReviewReqCommit,
reviewReqUrl,
ReviewReqAuthorName,
ReviewMessage);
}
ObjectId refId = db.resolve(gitSegment);
if (refId == null || !Constants.HEAD.equals(gitSegment)) {
String msg = NLS.bind("Commit failed. Ref must be HEAD and is {0}", gitSegment);
return statusHandler.handleRequest(
request,
response,
new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_BAD_REQUEST, msg, null));
}
String message = requestObject.optString(GitConstants.KEY_COMMIT_MESSAGE, null);
if (message == null || message.isEmpty()) {
return statusHandler.handleRequest(
request,
response,
new ServerStatus(
IStatus.ERROR,
HttpServletResponse.SC_BAD_REQUEST,
"Missing commit message.",
null));
}
Git git = new Git(db);
CommitCommand cc = git.commit();
Config config = git.getRepository().getConfig();
boolean amend =
Boolean.parseBoolean(requestObject.optString(GitConstants.KEY_COMMIT_AMEND, null));
boolean insertChangeId =
GitUtils.isGerrit(config)
|| Boolean.parseBoolean(requestObject.optString(GitConstants.KEY_CHANGE_ID, null));
String committerName = requestObject.optString(GitConstants.KEY_COMMITTER_NAME, null);
String committerEmail = requestObject.optString(GitConstants.KEY_COMMITTER_EMAIL, null);
String authorName = requestObject.optString(GitConstants.KEY_AUTHOR_NAME, null);
String authorEmail = requestObject.optString(GitConstants.KEY_AUTHOR_EMAIL, null);
// workaround of a bug in JGit which causes invalid
// support of null values of author/committer name/email, see bug 352984
PersonIdent defPersonIdent = new PersonIdent(db);
if (committerName == null) committerName = defPersonIdent.getName();
if (committerEmail == null) committerEmail = defPersonIdent.getEmailAddress();
if (authorName == null) authorName = committerName;
if (authorEmail == null) authorEmail = committerEmail;
cc.setCommitter(committerName, committerEmail);
cc.setAuthor(authorName, authorEmail);
if (insertChangeId) cc.setInsertChangeId(true);
// support for committing by path: "git commit -o path"
if (!pattern.isEmpty()) {
cc.setOnly(pattern);
}
try {
// "git commit [--amend] -m '{message}' [-a|{path}]"
RevCommit lastCommit = cc.setAmend(amend).setMessage(message).call();
URI cloneLocation =
BaseToCloneConverter.getCloneLocation(
getURI(request), BaseToCloneConverter.COMMIT_REFRANGE);
Commit commit = new Commit(cloneLocation, db, lastCommit, pattern);
JSONObject result = commit.toJSON();
OrionServlet.writeJSONResponse(
request, response, result, JsonURIUnqualificationStrategy.ALL_NO_GIT);
return true;
} catch (GitAPIException e) {
return statusHandler.handleRequest(
request,
response,
new ServerStatus(
IStatus.ERROR,
HttpServletResponse.SC_BAD_REQUEST,
"An error occured when commiting.",
e));
} catch (UnmergedPathException e) {
return statusHandler.handleRequest(
request,
response,
new ServerStatus(
IStatus.ERROR,
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"An internal error occured when commiting.",
e));
}
} catch (Exception e) {
return statusHandler.handleRequest(
request,
response,
new ServerStatus(
IStatus.ERROR,
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"An error occured when requesting a commit info.",
e));
}
}
public static void main(String args[]) {
String project_id = args[0];
String dest_project_id = args[1];
String co_user_id = args[2];
String co_admin_id = args[3];
String request_fields = args[4];
LinkedList<String> req_field_names = new LinkedList<String>();
// initialize logging and email handling
long current_time_stamp = Calendar.getInstance(TimeZone.getTimeZone("UTC")).getTimeInMillis();
String human_date = df.format(Calendar.getInstance().getTime());
boolean email_errors = Configuration.instance().getProperty("errors").contains("email");
boolean log_errors = Configuration.instance().getProperty("errors").contains("log");
boolean email_warnings =
Configuration.instance().getProperty("redaction_warnings").contains("email");
boolean log_warnings =
Configuration.instance().getProperty("redaction_warnings").contains("log");
boolean email_redaction = Configuration.instance().getProperty("redaction").contains("email");
boolean log_redaction = Configuration.instance().getProperty("redaction").contains("log");
if (log_errors) {
Globals.application_log.enableFlags("e");
} else Globals.application_log.disableFlags("e");
if (log_redaction) {
Globals.application_log.enableFlags("r");
} else Globals.application_log.disableFlags("r");
if (log_warnings) {
Globals.application_log.enableFlags("w");
} else Globals.application_log.disableFlags("w");
try {
// load schemas and extractors
DICOMExtractor dext = DICOMExtractor.instance();
dext.initialize();
XNATExtractor xext = XNATExtractor.instance();
xext.initialize();
LinkedList<String> complete_field_names = new LinkedList<String>();
for (String f : DICOMSchema.instance().getMappedFields()) {
if (!complete_field_names.contains(f)) complete_field_names.add(f);
}
for (String f : XNATSchema.instance().getMappedFields()) {
if (!complete_field_names.contains(f)) complete_field_names.add(f);
}
for (String item : request_fields.split(",")) {
if (!item.trim().equals(""))
req_field_names.add(XNATSchema.instance().getXnatFieldName("xnat:" + item.trim()));
}
// load redaction rules
// load checkout ruleset and checkout system
CheckoutRuleset cr = new CheckoutRuleset();
cr.setFields(Configuration.instance().getProperty("filter_fields").split(","));
cr.loadRuleSet(Configuration.instance().getProperty("checkout_rules"));
Checkout.instance().initialize();
XNATRestAPI api = XNATRestAPI.instance();
// download project and subject ids
XNATProject project = new XNATProject();
project.setID(project_id);
Checkout.instance().downloadProjectXML(project);
// ***Possibly Canceled Feature*** upload new project -Matt
// Get target project
XNATProject target = new XNATProject();
target.setID(dest_project_id);
api.retreiveProject(target);
// init DB manager
DBManager db =
new DBManager(
Configuration.instance().getProperty("database_hostname"),
Configuration.instance().getProperty("database_name"),
Configuration.instance().getProperty("database_user"),
Configuration.instance().getProperty("database_pass"));
// init a new request
Date dt = new Date();
// leave affected subjectids blank for now
System.out.println("check out field " + request_fields);
RequestInfo r_info =
new RequestInfo(co_user_id, dt.toString(), co_admin_id, "", req_field_names);
BigDecimal requestId = db.getNextRequestID();
r_info.setRequestid(requestId);
HashMap<String, HashMap<String, String>> overallCheckoutInfo =
db.getUserCheckOutInfo(co_user_id);
// for each user in the project
for (String subject_id : project.subject_ids) {
// download subject information and redact
Checkout.instance().downloadSubjectXML(project, subject_id);
Checkout.instance().downloadSubjectFiles(project, subject_id);
// redact XNATSubject demographics
XNATSubject subject = project.subjects.get(subject_id);
HashMap<String, String> xnat_demographics =
XNATExtractor.instance().extractNameValuePairs(subject.getXML(), true);
HashMap<String, LinkedList<String>> dicom_demographics =
new HashMap<String, LinkedList<String>>();
for (String experiment_id : subject.experiment_ids) {
for (String scan_id : subject.scan_ids.get(experiment_id)) {
// redact DICOMFiles
XNATScan scan = subject.scans.get(scan_id);
for (String file : scan.localFiles) {
String input = scan.tmp_folder + "/" + file;
File f = new File(input);
if (f.isFile() && f.getName().endsWith("dcm")) {
System.out.println("Processing: " + input);
DicomObject obj = dext.loadDicom(input);
HashMap<String, String> hs = dext.extractNameValuePairs(obj, req_field_names);
// Store hs data in dicom map
for (String key : hs.keySet()) {
String val = hs.get(key);
if (!dicom_demographics.containsKey(key))
dicom_demographics.put(key, new LinkedList<String>());
if (!dicom_demographics.get(key).contains(val))
dicom_demographics.get(key).add(val);
}
File dir = new File(scan.tmp_folder + "/redacted");
if (!dir.exists()) {
dir.mkdirs();
}
String nfilename = scan.tmp_folder + "/redacted/" + file;
dext.writeDicom(nfilename, obj);
// DicomObject obj2_test = dext.loadDicom(nfilename);
// hs = dext.extractNameValuePairs(obj2_test, ruleset);
}
}
}
}
HashMap<String, String> combined_demographics = new HashMap<String, String>();
for (String key : xnat_demographics.keySet()) {
combined_demographics.put(key, xnat_demographics.get(key));
}
for (String key : dicom_demographics.keySet()) {
if (!combined_demographics.containsKey(key)) {
combined_demographics.put(key, dicom_demographics.get(key).getFirst());
}
}
// download checkout user information from our database -Liang
String uniSubjectid = null;
if (db.lookupSubjectid(subject_id) != null)
uniSubjectid = db.lookupSubjectid(subject_id).toString();
HashMap<String, String> subjectCheckoutInfo = null;
if (uniSubjectid != null) subjectCheckoutInfo = overallCheckoutInfo.get(uniSubjectid);
// populate map of checkout fields -Liang
HashMap<String, String> requesting_user_data = subjectCheckoutInfo;
HashMap<String, String> filter_data = new HashMap<String, String>();
int checkoutCount = 0;
for (String field : complete_field_names) {
String requestName = "request_" + field;
filter_data.put(requestName, "0");
}
if (subjectCheckoutInfo != null) {
for (String key : subjectCheckoutInfo.keySet()) {
if (subjectCheckoutInfo.get(key).equals(new String("1"))) {
checkoutCount++;
String requestName = "request_" + key;
filter_data.put(requestName, "1");
}
}
for (String key : requesting_user_data.keySet()) {
if (requesting_user_data.get(key).equals(new String("1"))) {
String requestName = "request_" + key;
filter_data.put(requestName, "1");
}
}
}
for (String fieldName : req_field_names) {
String key = "request_" + fieldName;
if (!filter_data.get(key).equals(new String("1"))) {
filter_data.remove(key);
filter_data.put(key, "1");
checkoutCount++;
}
}
String phi_checked = "phi_checked_out";
filter_data.put(phi_checked, Integer.toString(checkoutCount));
System.out.println("Check out map for subject " + subject_id);
for (String key : filter_data.keySet()) {
System.out.println(key + " | " + filter_data.get(key));
}
// Using the above data, along with req_field_names and insert resulting data into the
// filter_data hashmap
// example:
// user has already checked out Age previously, and is requesting to check out Race now
// filter_data looks like this:
// phi_checked_out 2
// request_PatientAge 1
// request_PatientRace 1
// request_... 0
// ... 0
//
//
// run permissions checks against checkout ruleset information
subject.passed = cr.filter(filter_data);
// upload redacted information to database -Liang
// PatientAge = [31, 32]
// subject_id, field, values
// update information about checked out PHI to database -Liang
// don't forget to store the destination ids for tracking our redacted data:
// subject.destination_id
// xnat_demographics and dicom_demographics applies to the current subject object
// upload subject information -Matt
if (subject.passed) {
// Create a subject info for passed subject
if (combined_demographics.containsKey("PatientBirthdate")
&& combined_demographics.containsKey("PatientName")) {
String req_ID = requestId.toPlainString() + ";";
SubjectInfo s_info =
new SubjectInfo(
null,
SubjectInfo.transphiData(combined_demographics),
project_id,
req_ID,
combined_demographics.get("PatientName"),
combined_demographics.get("PatientBirthdate"));
// System.out.println("phi = "+combined_demographics.toString()+" request id =
// "+requestId.toPlainString());
BigDecimal db_subjectid = db.insertSubjectInfo(s_info);
db.insertSubjectidMap(db_subjectid, subject_id);
subject.setNewLabel(db_subjectid.toString());
// System.out.println("new id "+db_subjectid);
if (db_subjectid != null) {
String newAffectedIDs = r_info.getaffectedsubjectstext() + db_subjectid + ";";
r_info.setaffectedsubjects(newAffectedIDs);
}
} else {
subject.setNewLabel("unknown_" + (uk_id++));
}
// reinsert requested, authorized information into XNAT and DICOM -Matt
for (String field : request_fields.split(",")) {
if (combined_demographics.containsKey(
XNATSchema.instance().getXnatFieldName("xnat:" + field))) {
System.out.println(
"Reinserting: "
+ "xnat:"
+ field
+ " value "
+ combined_demographics.get(
XNATSchema.instance().getXnatFieldName("xnat:" + field)));
xext.insertData(
subject.getXML(),
"xnat:" + field,
combined_demographics.get(
XNATSchema.instance().getXnatFieldName("xnat:" + field)));
}
}
String response = api.postSubject(target);
subject.setDestinationID(response.substring(response.lastIndexOf('/') + 1));
if (!api.putSubject(target, subject)) {
throw new PipelineServiceException("Unable to upload subject: " + subject.getID());
}
// upload experiment information -Matt
for (String eid : subject.experiment_ids) {
XNATExperiment experiment = project.experiments.get(eid);
response = api.postExperiment(target, subject, experiment);
experiment.setDestinationID(response.substring(response.lastIndexOf('/') + 1));
// upload scans -Matt
for (String scan_id : subject.scan_ids.get(eid)) {
XNATScan scan = subject.scans.get(scan_id);
response = api.postScan(target, subject, experiment, scan);
scan.setDestinationID(response.substring(response.lastIndexOf('/') + 1));
// upload DICOM files -Matt
api.uploadDICOMFiles(target, subject, experiment, scan);
}
}
} else {
System.out.println("Subject: " + subject.getID() + " filtered");
}
}
db.insertRequestInfo(r_info);
} catch (PipelineServiceException pse) {
pse.printStackTrace();
if (email_errors) {
String error_text =
"["
+ human_date
+ "]: Pipeline Service Exception encountered in XNATRedaction engine, contact your system administrator";
// upload error message to database
}
Globals.application_log.write(
"e", "Pipeline Service Exception Encountered: " + pse.getMessage());
Globals.application_log.write("e", Globals.stackTraceConvert(pse));
} catch (CompileException ce) {
ce.printStackTrace();
if (email_errors) {
String error_text =
"["
+ human_date
+ "]: Compiler Exception encountered in XNATRedaction engine, contact systema administrator";
// upload error message to database
}
Globals.application_log.write("e", "Compiler Exception Encountered: " + ce.getMessage());
Globals.application_log.write("e", Globals.stackTraceConvert(ce));
}
}
@Override
protected boolean handlePut(RequestInfo requestInfo) throws ServletException {
JSONObject requestPayload = requestInfo.getJSONRequest();
HttpServletRequest request = requestInfo.request;
HttpServletResponse response = requestInfo.response;
Repository db = requestInfo.db;
/* gitapi/stash/<stashRev>/file/(...) */
String stashRev = requestInfo.gitSegment;
boolean applyIndex = requestPayload.optBoolean(GitConstants.KEY_STASH_APPLY_INDEX, true);
boolean applyUntracked =
requestPayload.optBoolean(GitConstants.KEY_STASH_APPLY_UNTRACKED, true);
try {
Git git = new Git(db);
/* check for empty stash */
if (isStashEmpty(git)) {
String msg = "Failed to apply stashed changes due to an empty stash.";
return statusHandler.handleRequest(
request,
response,
new ServerStatus(IStatus.WARNING, HttpServletResponse.SC_BAD_REQUEST, msg, null));
}
StashApplyCommand applyCommand = new StashApplyCommand(db);
if (stashRev != null) {
StashRef stashRef = getStashRef(git, stashRev);
if (stashRef == null) {
String msg = NLS.bind("Invalid stash reference {0}.", stashRev);
return statusHandler.handleRequest(
request,
response,
new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_BAD_REQUEST, msg, null));
}
applyCommand.setStashRef(stashRef.getStringRef());
applyCommand.setApplyUntracked(applyUntracked);
applyCommand.setApplyIndex(applyIndex);
applyCommand.call();
} else {
/* git stash pop */
applyCommand.setApplyUntracked(applyUntracked);
applyCommand.setApplyIndex(applyIndex);
applyCommand.call();
StashDropCommand dropCommand = git.stashDrop();
dropCommand.setAll(false);
dropCommand.call();
}
return true;
} catch (Exception ex) {
String msg = "An error occured for stash command.";
return statusHandler.handleRequest(
request,
response,
new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, msg, ex));
}
}
public static ArrayList<RequestInfo> parseApiDoc(String path) {
File file = new File(path);
String response = FileUtils.readToString(file, "UTF-8");
Document parse = Jsoup.parse(response);
// 接口类型总称 api-Search
String mainName = parse.getElementsByTag("section").get(0).attr("id");
// System.out.println("-> type = " + mainName);
// System.out.println();
ArrayList<RequestInfo> requestInfos = new ArrayList<RequestInfo>();
// 全部类型接口
for (Element e : parse.getAllElements()) {
String attrId = e.attr("id");
// div的标签,且id名前缀为mainName
// 为类型下单个接口 api-Search-PostSearchCompany
if (e.tagName().equals("div") && attrId.startsWith(mainName)) {
RequestInfo requestInfo = new RequestInfo();
// System.out.println("---> name = " + attrId);
requestInfo.setName(attrId);
// method post/get
String method = e.getElementsByTag("pre").get(0).attr("data-type");
// System.out.println("-----> method = " + method);
requestInfo.setMethod(method);
// url
String url = e.getElementsByAttributeValue("class", "pln").get(0).text();
// System.out.println("-----> url = " + url);
requestInfo.setUrl(url);
// des
String des = e.getElementsByAttributeValue("class", "pull-left").get(0).text();
// System.out.println("-----> des = " + des);
requestInfo.setDes(des);
// post params
Element ePostParams = e.getElementsByTag("table").get(0);
ArrayList<RequestParam> params = new ArrayList<RequestParam>();
for (Element ePostParam : ePostParams.getElementsByTag("tr")) {
// param 字段
Elements eColumn = ePostParam.getElementsByTag("td");
if (eColumn.size() == 0) {
continue;
}
// 标签"选项"
// String label = ePostParam.getElementsByAttributeValue("class", "label
// label-optional")
// .get(0).text();
String label = "选项";
// 第一个字段为参数名
String paramName = eColumn.get(0).text();
// 去除标签
paramName = paramName.replace(label, "").trim();
// 第二个字段为参数类型
// 可能类型为 String Number Float
String paramType = eColumn.get(1).text();
// 第三个字段为参数描述
String paramDes = eColumn.get(2).text();
// System.out.println("-----> param = " + paramName + " ... "
// + paramType + " ... " + paramDes);
RequestParam param = new RequestParam(paramName, paramType, paramDes);
params.add(param);
}
requestInfo.setParams(params);
requestInfos.add(requestInfo);
// System.out.println();
}
}
return requestInfos;
}
public boolean isProcessing() {
return reqProcessorMX.getStage() == org.apache.coyote.Constants.STAGE_SERVICE;
}
// -------------------- Info --------------------
public void updateCounters() {
reqProcessorMX.updateCounters();
}
