h4iku/coconut_java2006_preprocessed · Datasets at Hugging Face

protected File getXmlFileDirectory(final Project project)

protected File getXmlFileDirectory(final Document document)

protected File getXmlFileDirectory(final Project project) throws FileNotFoundException, IOException { logger.info("getXmlFileDirectory(Project)"); logger.debug(project); return getXmlFile(project).getParentFile(); }

logger.info("getXmlFileDirectory(Project)"); logger.debug(project); return getXmlFile(project).getParentFile();

logger.info("getXmlFileDirectory(Document)"); logger.debug(document); return getXmlFile(document).getParentFile();

protected File getXmlFileDirectory(final Project project) throws FileNotFoundException, IOException { logger.info("getXmlFileDirectory(Project)"); logger.debug(project); return getXmlFile(project).getParentFile(); }

protected File getXmlFile(final Project project)

protected File getXmlFile(final Document document)

protected File getXmlFile(final Project project) throws FileNotFoundException, IOException { logger.info("getXmlFile(Project)"); logger.debug(project); final File xmlFile = lookupXmlFile(project.getId()); if(null != xmlFile) { return xmlFile; } else { return xmlPathBuilder.getXmlFile(project, fillInStack(project)); } }

logger.info("getXmlFile(Project)"); logger.debug(project); final File xmlFile = lookupXmlFile(project.getId());

final File xmlFile = lookupXmlFile(document.getId());

protected File getXmlFile(final Project project) throws FileNotFoundException, IOException { logger.info("getXmlFile(Project)"); logger.debug(project); final File xmlFile = lookupXmlFile(project.getId()); if(null != xmlFile) { return xmlFile; } else { return xmlPathBuilder.getXmlFile(project, fillInStack(project)); } }

return xmlPathBuilder.getXmlFile(project, fillInStack(project));

return xmlPathBuilder.getXmlFile(document, fillInStack(document));

protected File getXmlFile(final Project project) throws FileNotFoundException, IOException { logger.info("getXmlFile(Project)"); logger.debug(project); final File xmlFile = lookupXmlFile(project.getId()); if(null != xmlFile) { return xmlFile; } else { return xmlPathBuilder.getXmlFile(project, fillInStack(project)); } }

protected void write(final Project project, final File xmlFile)

protected void write(final Document document, final File xmlFile)

protected void write(final Project project, final File xmlFile) throws FileNotFoundException, IOException { logger.info("write(Project,File)"); writeXmlFile(toXml(project), xmlFile); writeIndexXml(project); }

logger.info("write(Project,File)"); writeXmlFile(toXml(project), xmlFile); writeIndexXml(project);

logger.info("write(Document,File)"); writeXmlFile(toXml(document), xmlFile); writeIndexXml(document);

protected void write(final Project project, final File xmlFile) throws FileNotFoundException, IOException { logger.info("write(Project,File)"); writeXmlFile(toXml(project), xmlFile); writeIndexXml(project); }

private File lookupXmlFile(final UUID id) throws FileNotFoundException,

protected File lookupXmlFile(final UUID id) throws FileNotFoundException,

private File lookupXmlFile(final UUID id) throws FileNotFoundException, IOException { final IndexXmlIO indexXmlIO = new IndexXmlIO(workspace); return indexXmlIO.get().lookupXmlFile(id); }

reader.close();

try { datum.stream.close(); reader.close(); } catch (final IOException iox2) { fail(createFailMessage(iox2)); }

public void testReader() { final StreamReader reader = new StreamReader(datum.streamSession); try { reader.open(); reader.read(datum.streamId, datum.stream); } finally { reader.close(); } }

public StreamReader(final StreamSession session) { super(Type.DOWNSTREAM, session);

public StreamReader(final StreamMonitor monitor, final StreamSession session) { super(Type.DOWNSTREAM, monitor, session);

public StreamReader(final StreamSession session) { super(Type.DOWNSTREAM, session); }

infoText = "";

infoText = getString("Info.CREATE");

private void setInfoText(final HistoryItem historyItem) { final Object[] arguments; final String infoText; switch(historyItem.getEvent()) { case CLOSE: case CREATE: infoText = ""; break; case RECEIVE: case RECEIVE_KEY: final ReceiveHistoryItem rhi = (ReceiveHistoryItem) historyItem; arguments = new Object[] {ModelUtil.getName(rhi.getReceivedFrom())}; infoText = getString("Info.RECEIVED_FROM", arguments); break; case SEND: final SendHistoryItem shi = (SendHistoryItem) historyItem; String localKey; int i = 0; final StringBuffer buffer = new StringBuffer(); for(final User sentTo : shi.getSentTo()) { if(0 == i++) { localKey = "Info.SENT_TO_0"; } else { localKey = "Info.SENT_TO_N"; } buffer.append(getString(localKey, new Object[] {ModelUtil.getName(sentTo)})); } infoText = buffer.toString(); break; case SEND_KEY: final SendKeyHistoryItem skhi = (SendKeyHistoryItem) historyItem; infoText = getString("Info.SENT_TO_0", new Object[] {ModelUtil.getName(skhi.getSentTo())}); break; default: infoText = null; Assert.assertUnreachable("Unknown history item event: " + historyItem.getEvent()); } infoJLabel.setText(infoText); }

case RECEIVE_KEY:

private void setInfoText(final HistoryItem historyItem) { final Object[] arguments; final String infoText; switch(historyItem.getEvent()) { case CLOSE: case CREATE: infoText = ""; break; case RECEIVE: case RECEIVE_KEY: final ReceiveHistoryItem rhi = (ReceiveHistoryItem) historyItem; arguments = new Object[] {ModelUtil.getName(rhi.getReceivedFrom())}; infoText = getString("Info.RECEIVED_FROM", arguments); break; case SEND: final SendHistoryItem shi = (SendHistoryItem) historyItem; String localKey; int i = 0; final StringBuffer buffer = new StringBuffer(); for(final User sentTo : shi.getSentTo()) { if(0 == i++) { localKey = "Info.SENT_TO_0"; } else { localKey = "Info.SENT_TO_N"; } buffer.append(getString(localKey, new Object[] {ModelUtil.getName(sentTo)})); } infoText = buffer.toString(); break; case SEND_KEY: final SendKeyHistoryItem skhi = (SendKeyHistoryItem) historyItem; infoText = getString("Info.SENT_TO_0", new Object[] {ModelUtil.getName(skhi.getSentTo())}); break; default: infoText = null; Assert.assertUnreachable("Unknown history item event: " + historyItem.getEvent()); } infoJLabel.setText(infoText); }

infoText = getString("Info.RECEIVED_FROM", arguments);

infoText = getString("Info.RECEIVE", arguments); break; case RECEIVE_KEY: final ReceiveKeyHistoryItem rki = (ReceiveKeyHistoryItem) historyItem; arguments = new Object[] {ModelUtil.getName(rki.getReceivedFrom())}; infoText = getString("Info.RECEIVE_KEY", arguments); break; case REQUEST_KEY: final RequestKeyItem rki2 = (RequestKeyItem) historyItem; arguments = new Object[] { ModelUtil.getName(rki2.getRequestedBy()), ModelUtil.getName(rki2.getRequestedFrom()) }; infoText = getString("Info.REQUEST_KEY", arguments);

private void setInfoText(final HistoryItem historyItem) { final Object[] arguments; final String infoText; switch(historyItem.getEvent()) { case CLOSE: case CREATE: infoText = ""; break; case RECEIVE: case RECEIVE_KEY: final ReceiveHistoryItem rhi = (ReceiveHistoryItem) historyItem; arguments = new Object[] {ModelUtil.getName(rhi.getReceivedFrom())}; infoText = getString("Info.RECEIVED_FROM", arguments); break; case SEND: final SendHistoryItem shi = (SendHistoryItem) historyItem; String localKey; int i = 0; final StringBuffer buffer = new StringBuffer(); for(final User sentTo : shi.getSentTo()) { if(0 == i++) { localKey = "Info.SENT_TO_0"; } else { localKey = "Info.SENT_TO_N"; } buffer.append(getString(localKey, new Object[] {ModelUtil.getName(sentTo)})); } infoText = buffer.toString(); break; case SEND_KEY: final SendKeyHistoryItem skhi = (SendKeyHistoryItem) historyItem; infoText = getString("Info.SENT_TO_0", new Object[] {ModelUtil.getName(skhi.getSentTo())}); break; default: infoText = null; Assert.assertUnreachable("Unknown history item event: " + historyItem.getEvent()); } infoJLabel.setText(infoText); }

if(0 == i++) { localKey = "Info.SENT_TO_0"; } else { localKey = "Info.SENT_TO_N"; }

if(0 == i++) { localKey = "Info.SEND_0"; } else { localKey = "Info.SEND_N"; }

private void setInfoText(final HistoryItem historyItem) { final Object[] arguments; final String infoText; switch(historyItem.getEvent()) { case CLOSE: case CREATE: infoText = ""; break; case RECEIVE: case RECEIVE_KEY: final ReceiveHistoryItem rhi = (ReceiveHistoryItem) historyItem; arguments = new Object[] {ModelUtil.getName(rhi.getReceivedFrom())}; infoText = getString("Info.RECEIVED_FROM", arguments); break; case SEND: final SendHistoryItem shi = (SendHistoryItem) historyItem; String localKey; int i = 0; final StringBuffer buffer = new StringBuffer(); for(final User sentTo : shi.getSentTo()) { if(0 == i++) { localKey = "Info.SENT_TO_0"; } else { localKey = "Info.SENT_TO_N"; } buffer.append(getString(localKey, new Object[] {ModelUtil.getName(sentTo)})); } infoText = buffer.toString(); break; case SEND_KEY: final SendKeyHistoryItem skhi = (SendKeyHistoryItem) historyItem; infoText = getString("Info.SENT_TO_0", new Object[] {ModelUtil.getName(skhi.getSentTo())}); break; default: infoText = null; Assert.assertUnreachable("Unknown history item event: " + historyItem.getEvent()); } infoJLabel.setText(infoText); }

infoText = getString("Info.SENT_TO_0", new Object[] {ModelUtil.getName(skhi.getSentTo())});

infoText = getString("Info.SEND_KEY", new Object[] {ModelUtil.getName(skhi.getSentTo())});

private void setInfoText(final HistoryItem historyItem) { final Object[] arguments; final String infoText; switch(historyItem.getEvent()) { case CLOSE: case CREATE: infoText = ""; break; case RECEIVE: case RECEIVE_KEY: final ReceiveHistoryItem rhi = (ReceiveHistoryItem) historyItem; arguments = new Object[] {ModelUtil.getName(rhi.getReceivedFrom())}; infoText = getString("Info.RECEIVED_FROM", arguments); break; case SEND: final SendHistoryItem shi = (SendHistoryItem) historyItem; String localKey; int i = 0; final StringBuffer buffer = new StringBuffer(); for(final User sentTo : shi.getSentTo()) { if(0 == i++) { localKey = "Info.SENT_TO_0"; } else { localKey = "Info.SENT_TO_N"; } buffer.append(getString(localKey, new Object[] {ModelUtil.getName(sentTo)})); } infoText = buffer.toString(); break; case SEND_KEY: final SendKeyHistoryItem skhi = (SendKeyHistoryItem) historyItem; infoText = getString("Info.SENT_TO_0", new Object[] {ModelUtil.getName(skhi.getSentTo())}); break; default: infoText = null; Assert.assertUnreachable("Unknown history item event: " + historyItem.getEvent()); } infoJLabel.setText(infoText); }

NameComparator(final Boolean doCompareAscending) { super(doCompareAscending); }

NameComparator(final Boolean doCompareAscending) { super(doCompareAscending); this.comparator = new StringComparator(doCompareAscending); }

NameComparator(final Boolean doCompareAscending) { super(doCompareAscending); }

OrganizationComparator(final Boolean doCompareAscending) { super(doCompareAscending); }

OrganizationComparator(final Boolean doCompareAscending) { super(doCompareAscending); this.comparator = new StringComparator(doCompareAscending); }

OrganizationComparator(final Boolean doCompareAscending) { super(doCompareAscending); }

globalProperties.setProperty("log4j.logger.com.thinkparity.server", "ERROR, serverHTML"); globalProperties.setProperty("log4j.logger.com.thinkparity.server.ParityServer", "INFO"); globalProperties.setProperty("log4j.logger.com.thinkparity.server.handler", "INFO");

globalProperties.setProperty("log4j.logger.com.thinkparity.server", "INFO, serverHTML");

private void configureGlobal(final Properties globalProperties) { globalProperties.setProperty("log4j.logger.com.thinkparity.server", "ERROR, serverHTML"); globalProperties.setProperty("log4j.logger.com.thinkparity.server.ParityServer", "INFO"); globalProperties.setProperty("log4j.logger.com.thinkparity.server.handler", "INFO"); }

log4jProperties.setProperty("log4j.appender.serverHTML.MaxFileSize", "512MB");

log4jProperties.setProperty("log4j.appender.serverHTML.MaxFileSize", "512KB");

private void configureServerHTMLAppender( final Properties log4jProperties, final File log4jDirectory) { log4jProperties.setProperty("log4j.appender.serverHTML", "org.apache.log4j.RollingFileAppender"); log4jProperties.setProperty("log4j.appender.serverHTML.MaxFileSize", "512MB"); log4jProperties.setProperty("log4j.appender.serverHTML.layout", "org.apache.log4j.HTMLLayout"); log4jProperties.setProperty("log4j.appender.serverHTML.layout.locationInfo", "true"); log4jProperties.setProperty("log4j.appender.serverHTML.layout.title", "Parity Server"); final File serverHTMLFile = new File(log4jDirectory, "parity.server.log4j.html"); log4jProperties.setProperty("log4j.appender.serverHTML.File", serverHTMLFile.getAbsolutePath()); }

logger.info(getApiId("[CREATE DRAFT]")); logger.debug(containerId); assertOnline(getApiId("[CREATE DRAFT] [USER NOT ONLINE]"));

logApiId(); logVariable("containerId", containerId); assertOnline("USER NOT ONLINE");

ContainerDraft createDraft(final Long containerId) { logger.info(getApiId("[CREATE DRAFT]")); logger.debug(containerId); assertOnline(getApiId("[CREATE DRAFT] [USER NOT ONLINE]")); final Container container = read(containerId); if(!isDistributed(container.getId())) { createDistributed(container); } final ContainerVersion latestVersion = readLatestVersion(container.getId()); final List<Document> documents = readDocuments( latestVersion.getArtifactId(), latestVersion.getVersionId()); // create final ContainerDraft draft = new ContainerDraft(); draft.setOwner(localTeamMember(containerId)); draft.setContainerId(containerId); for(final Document document : documents) { draft.addDocument(document); draft.putState(document, ContainerDraft.ArtifactState.NONE); } containerIO.createDraft(draft); // remote create getInternalSessionModel().createDraft(container.getUniqueId()); // fire event final Container postCreation= read(containerId); final ContainerDraft postCreationDraft = readDraft(containerId); notifyDraftCreated(postCreation, postCreationDraft, localEventGenerator); return postCreationDraft; }

final TeamMember teamMember) {

final TeamMember owner) {

private ContainerDraft createFirstDraft(final Long containerId, final TeamMember teamMember) { final ContainerDraft draft = new ContainerDraft(); draft.setContainerId(containerId); draft.setOwner(teamMember); containerIO.createDraft(draft); // fire draft event final Container postCreation = read(containerId); final ContainerDraft postCreationDraft = readDraft(containerId); notifyDraftCreated(postCreation, postCreationDraft, localEventGenerator); return postCreationDraft; }

draft.setOwner(teamMember);

draft.setOwner(owner);

private ContainerDraft createFirstDraft(final Long containerId, final TeamMember teamMember) { final ContainerDraft draft = new ContainerDraft(); draft.setContainerId(containerId); draft.setOwner(teamMember); containerIO.createDraft(draft); // fire draft event final Container postCreation = read(containerId); final ContainerDraft postCreationDraft = readDraft(containerId); notifyDraftCreated(postCreation, postCreationDraft, localEventGenerator); return postCreationDraft; }

private void deleteLocal(final Long containerId) throws ParityException {

private void deleteLocal(final Long containerId) {

private void deleteLocal(final Long containerId) throws ParityException { // delete the draft final ContainerDraft draft = readDraft(containerId); if(null != draft) { for(final Artifact artifact : draft.getArtifacts()) { containerIO.deleteDraftArtifactRel(containerId, artifact.getId()); } containerIO.deleteDraft(containerId); } // delete the team final InternalArtifactModel artifactModel = getInternalArtifactModel(); artifactModel.deleteTeam(containerId); // delete the remote info artifactModel.deleteRemoteInfo(containerId); // delete the audit events getInternalAuditModel().delete(containerId); // delete versions final InternalDocumentModel documentModel = getInternalDocumentModel(); final List<ContainerVersion> versions = readVersions(containerId); List<Document> documents; for(final ContainerVersion version : versions) { // remove the version's artifact versions containerIO.removeVersions(containerId, version.getVersionId()); documents = containerIO.readDocuments(version.getArtifactId(), version.getVersionId()); for(final Document document : documents) { documentModel.delete(document.getId()); } // delete the version containerIO.deleteVersion(containerId, version.getVersionId()); } // delete the index indexor.delete(containerId); // delete the container containerIO.delete(containerId); }

void handleArtifactPublished(final JabberId publishedBy, final Calendar publishedOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) {

void handleArtifactPublished(final UUID uniqueId, final Long versionId, final String name, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes, final JabberId publishedBy, final Calendar publishedOn) {

void handleArtifactPublished(final JabberId publishedBy, final Calendar publishedOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("publishedBy", publishedBy); logVariable("publishedOn", publishedOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { // determine the existance of the container and the version. final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; final Long containerId; final Container container; final ContainerVersion version; if (doesExist) { containerId = artifactModel.readId(containerUniqueId); container = read(containerId); doesVersionExist = artifactModel.doesVersionExist(containerId, containerVersionId); if (doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(publishedBy.getUsername()); container.setCreatedOn(publishedOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); // create remote info artifactModel.createRemoteInfo(container.getId(), publishedBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentPublished(publishedBy, publishedOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("UNKNOWN ARTIFACT TYPE"); } containerIO.addVersion(version.getArtifactId(), version.getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion.getArtifactType()); final Container postPublish = read(container.getId()); final ContainerVersion postPublishVersion = readVersion(version.getArtifactId(), version.getVersionId()); notifyContainerPublished(postPublish, null, postPublishVersion, remoteEventGenerator); } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

logVariable("publishedBy", publishedBy); logVariable("publishedOn", publishedOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName);

logVariable("uniqueId", uniqueId); logVariable("versionId", versionId); logVariable("name", name);

void handleArtifactPublished(final JabberId publishedBy, final Calendar publishedOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("publishedBy", publishedBy); logVariable("publishedOn", publishedOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { // determine the existance of the container and the version. final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; final Long containerId; final Container container; final ContainerVersion version; if (doesExist) { containerId = artifactModel.readId(containerUniqueId); container = read(containerId); doesVersionExist = artifactModel.doesVersionExist(containerId, containerVersionId); if (doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(publishedBy.getUsername()); container.setCreatedOn(publishedOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); // create remote info artifactModel.createRemoteInfo(container.getId(), publishedBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentPublished(publishedBy, publishedOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("UNKNOWN ARTIFACT TYPE"); } containerIO.addVersion(version.getArtifactId(), version.getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion.getArtifactType()); final Container postPublish = read(container.getId()); final ContainerVersion postPublishVersion = readVersion(version.getArtifactId(), version.getVersionId()); notifyContainerPublished(postPublish, null, postPublishVersion, remoteEventGenerator); } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

final Boolean doesExist = artifactModel.doesExist(containerUniqueId);

final Boolean doesExist = artifactModel.doesExist(uniqueId);

void handleArtifactPublished(final JabberId publishedBy, final Calendar publishedOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("publishedBy", publishedBy); logVariable("publishedOn", publishedOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { // determine the existance of the container and the version. final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; final Long containerId; final Container container; final ContainerVersion version; if (doesExist) { containerId = artifactModel.readId(containerUniqueId); container = read(containerId); doesVersionExist = artifactModel.doesVersionExist(containerId, containerVersionId); if (doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(publishedBy.getUsername()); container.setCreatedOn(publishedOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); // create remote info artifactModel.createRemoteInfo(container.getId(), publishedBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentPublished(publishedBy, publishedOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("UNKNOWN ARTIFACT TYPE"); } containerIO.addVersion(version.getArtifactId(), version.getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion.getArtifactType()); final Container postPublish = read(container.getId()); final ContainerVersion postPublishVersion = readVersion(version.getArtifactId(), version.getVersionId()); notifyContainerPublished(postPublish, null, postPublishVersion, remoteEventGenerator); } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

containerId = artifactModel.readId(containerUniqueId);

containerId = artifactModel.readId(uniqueId);

void handleArtifactPublished(final JabberId publishedBy, final Calendar publishedOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("publishedBy", publishedBy); logVariable("publishedOn", publishedOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { // determine the existance of the container and the version. final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; final Long containerId; final Container container; final ContainerVersion version; if (doesExist) { containerId = artifactModel.readId(containerUniqueId); container = read(containerId); doesVersionExist = artifactModel.doesVersionExist(containerId, containerVersionId); if (doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(publishedBy.getUsername()); container.setCreatedOn(publishedOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); // create remote info artifactModel.createRemoteInfo(container.getId(), publishedBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentPublished(publishedBy, publishedOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("UNKNOWN ARTIFACT TYPE"); } containerIO.addVersion(version.getArtifactId(), version.getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion.getArtifactType()); final Container postPublish = read(container.getId()); final ContainerVersion postPublishVersion = readVersion(version.getArtifactId(), version.getVersionId()); notifyContainerPublished(postPublish, null, postPublishVersion, remoteEventGenerator); } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

doesVersionExist = artifactModel.doesVersionExist(containerId, containerVersionId);

doesVersionExist = artifactModel.doesVersionExist(containerId, versionId);

void handleArtifactPublished(final JabberId publishedBy, final Calendar publishedOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("publishedBy", publishedBy); logVariable("publishedOn", publishedOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { // determine the existance of the container and the version. final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; final Long containerId; final Container container; final ContainerVersion version; if (doesExist) { containerId = artifactModel.readId(containerUniqueId); container = read(containerId); doesVersionExist = artifactModel.doesVersionExist(containerId, containerVersionId); if (doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(publishedBy.getUsername()); container.setCreatedOn(publishedOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); // create remote info artifactModel.createRemoteInfo(container.getId(), publishedBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentPublished(publishedBy, publishedOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("UNKNOWN ARTIFACT TYPE"); } containerIO.addVersion(version.getArtifactId(), version.getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion.getArtifactType()); final Container postPublish = read(container.getId()); final ContainerVersion postPublishVersion = readVersion(version.getArtifactId(), version.getVersionId()); notifyContainerPublished(postPublish, null, postPublishVersion, remoteEventGenerator); } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

version = readVersion(container.getId(), containerVersionId);

version = readVersion(container.getId(), versionId);

void handleArtifactPublished(final JabberId publishedBy, final Calendar publishedOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("publishedBy", publishedBy); logVariable("publishedOn", publishedOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { // determine the existance of the container and the version. final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; final Long containerId; final Container container; final ContainerVersion version; if (doesExist) { containerId = artifactModel.readId(containerUniqueId); container = read(containerId); doesVersionExist = artifactModel.doesVersionExist(containerId, containerVersionId); if (doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(publishedBy.getUsername()); container.setCreatedOn(publishedOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); // create remote info artifactModel.createRemoteInfo(container.getId(), publishedBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentPublished(publishedBy, publishedOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("UNKNOWN ARTIFACT TYPE"); } containerIO.addVersion(version.getArtifactId(), version.getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion.getArtifactType()); final Container postPublish = read(container.getId()); final ContainerVersion postPublishVersion = readVersion(version.getArtifactId(), version.getVersionId()); notifyContainerPublished(postPublish, null, postPublishVersion, remoteEventGenerator); } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

containerVersionId, publishedBy, publishedOn);

versionId, publishedBy, publishedOn);

void handleArtifactPublished(final JabberId publishedBy, final Calendar publishedOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("publishedBy", publishedBy); logVariable("publishedOn", publishedOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { // determine the existance of the container and the version. final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; final Long containerId; final Container container; final ContainerVersion version; if (doesExist) { containerId = artifactModel.readId(containerUniqueId); container = read(containerId); doesVersionExist = artifactModel.doesVersionExist(containerId, containerVersionId); if (doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(publishedBy.getUsername()); container.setCreatedOn(publishedOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); // create remote info artifactModel.createRemoteInfo(container.getId(), publishedBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentPublished(publishedBy, publishedOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("UNKNOWN ARTIFACT TYPE"); } containerIO.addVersion(version.getArtifactId(), version.getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion.getArtifactType()); final Container postPublish = read(container.getId()); final ContainerVersion postPublishVersion = readVersion(version.getArtifactId(), version.getVersionId()); notifyContainerPublished(postPublish, null, postPublishVersion, remoteEventGenerator); } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

container.setName(containerName);

container.setName(name);

void handleArtifactPublished(final JabberId publishedBy, final Calendar publishedOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("publishedBy", publishedBy); logVariable("publishedOn", publishedOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { // determine the existance of the container and the version. final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; final Long containerId; final Container container; final ContainerVersion version; if (doesExist) { containerId = artifactModel.readId(containerUniqueId); container = read(containerId); doesVersionExist = artifactModel.doesVersionExist(containerId, containerVersionId); if (doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(publishedBy.getUsername()); container.setCreatedOn(publishedOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); // create remote info artifactModel.createRemoteInfo(container.getId(), publishedBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentPublished(publishedBy, publishedOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("UNKNOWN ARTIFACT TYPE"); } containerIO.addVersion(version.getArtifactId(), version.getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion.getArtifactType()); final Container postPublish = read(container.getId()); final ContainerVersion postPublishVersion = readVersion(version.getArtifactId(), version.getVersionId()); notifyContainerPublished(postPublish, null, postPublishVersion, remoteEventGenerator); } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

container.setUniqueId(containerUniqueId);

container.setUniqueId(uniqueId);

void handleArtifactPublished(final JabberId publishedBy, final Calendar publishedOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("publishedBy", publishedBy); logVariable("publishedOn", publishedOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { // determine the existance of the container and the version. final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; final Long containerId; final Container container; final ContainerVersion version; if (doesExist) { containerId = artifactModel.readId(containerUniqueId); container = read(containerId); doesVersionExist = artifactModel.doesVersionExist(containerId, containerVersionId); if (doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(publishedBy.getUsername()); container.setCreatedOn(publishedOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); // create remote info artifactModel.createRemoteInfo(container.getId(), publishedBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentPublished(publishedBy, publishedOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("UNKNOWN ARTIFACT TYPE"); } containerIO.addVersion(version.getArtifactId(), version.getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion.getArtifactType()); final Container postPublish = read(container.getId()); final ContainerVersion postPublishVersion = readVersion(version.getArtifactId(), version.getVersionId()); notifyContainerPublished(postPublish, null, postPublishVersion, remoteEventGenerator); } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

version = createVersion(container.getId(), containerVersionId,

version = createVersion(container.getId(), versionId,

void handleArtifactPublished(final JabberId publishedBy, final Calendar publishedOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("publishedBy", publishedBy); logVariable("publishedOn", publishedOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { // determine the existance of the container and the version. final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; final Long containerId; final Container container; final ContainerVersion version; if (doesExist) { containerId = artifactModel.readId(containerUniqueId); container = read(containerId); doesVersionExist = artifactModel.doesVersionExist(containerId, containerVersionId); if (doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(publishedBy.getUsername()); container.setCreatedOn(publishedOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); // create remote info artifactModel.createRemoteInfo(container.getId(), publishedBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentPublished(publishedBy, publishedOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("UNKNOWN ARTIFACT TYPE"); } containerIO.addVersion(version.getArtifactId(), version.getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion.getArtifactType()); final Container postPublish = read(container.getId()); final ContainerVersion postPublishVersion = readVersion(version.getArtifactId(), version.getVersionId()); notifyContainerPublished(postPublish, null, postPublishVersion, remoteEventGenerator); } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

artifactVersion = handleDocumentPublished(publishedBy, publishedOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes);

artifactVersion = handleDocumentPublished(artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes, publishedBy, publishedOn);

void handleArtifactPublished(final JabberId publishedBy, final Calendar publishedOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("publishedBy", publishedBy); logVariable("publishedOn", publishedOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { // determine the existance of the container and the version. final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; final Long containerId; final Container container; final ContainerVersion version; if (doesExist) { containerId = artifactModel.readId(containerUniqueId); container = read(containerId); doesVersionExist = artifactModel.doesVersionExist(containerId, containerVersionId); if (doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(publishedBy.getUsername()); container.setCreatedOn(publishedOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, publishedBy, publishedOn); // create remote info artifactModel.createRemoteInfo(container.getId(), publishedBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentPublished(publishedBy, publishedOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("UNKNOWN ARTIFACT TYPE"); } containerIO.addVersion(version.getArtifactId(), version.getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion.getArtifactType()); final Container postPublish = read(container.getId()); final ContainerVersion postPublishVersion = readVersion(version.getArtifactId(), version.getVersionId()); notifyContainerPublished(postPublish, null, postPublishVersion, remoteEventGenerator); } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

void handleArtifactSent(final JabberId sentBy, final Calendar sentOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId,

void handleArtifactSent(final UUID uniqueId, final Long versionId, final String name, final UUID artifactUniqueId,

void handleArtifactSent(final JabberId sentBy, final Calendar sentOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("sentBy", sentBy); logVariable("sentOn", sentOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Container container; final ContainerVersion version; final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; if(doesExist) { container = read(artifactModel.readId(containerUniqueId)); doesVersionExist = artifactModel.doesVersionExist(container.getId(), containerVersionId); if(doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(sentBy.getUsername()); container.setCreatedOn(sentOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); // create remote info artifactModel.createRemoteInfo(container.getId(), sentBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentSent(sentBy, sentOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("[UNSUPPORTED ARTIFACT TYPE]"); } // add to the version if(!doesVersionExist) { containerIO.addVersion(version.getArtifactId(), version .getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion .getArtifactType()); } } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

final byte[] artifactBytes) {

final byte[] artifactBytes, final JabberId sentBy, final Calendar sentOn) {

void handleArtifactSent(final JabberId sentBy, final Calendar sentOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("sentBy", sentBy); logVariable("sentOn", sentOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Container container; final ContainerVersion version; final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; if(doesExist) { container = read(artifactModel.readId(containerUniqueId)); doesVersionExist = artifactModel.doesVersionExist(container.getId(), containerVersionId); if(doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(sentBy.getUsername()); container.setCreatedOn(sentOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); // create remote info artifactModel.createRemoteInfo(container.getId(), sentBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentSent(sentBy, sentOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("[UNSUPPORTED ARTIFACT TYPE]"); } // add to the version if(!doesVersionExist) { containerIO.addVersion(version.getArtifactId(), version .getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion .getArtifactType()); } } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName);

logVariable("containerUniqueId", uniqueId); logVariable("containerVersionId", versionId); logVariable("containerName", name);

void handleArtifactSent(final JabberId sentBy, final Calendar sentOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("sentBy", sentBy); logVariable("sentOn", sentOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Container container; final ContainerVersion version; final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; if(doesExist) { container = read(artifactModel.readId(containerUniqueId)); doesVersionExist = artifactModel.doesVersionExist(container.getId(), containerVersionId); if(doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(sentBy.getUsername()); container.setCreatedOn(sentOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); // create remote info artifactModel.createRemoteInfo(container.getId(), sentBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentSent(sentBy, sentOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("[UNSUPPORTED ARTIFACT TYPE]"); } // add to the version if(!doesVersionExist) { containerIO.addVersion(version.getArtifactId(), version .getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion .getArtifactType()); } } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

final Boolean doesExist = artifactModel.doesExist(containerUniqueId);

final Boolean doesExist = artifactModel.doesExist(uniqueId);

void handleArtifactSent(final JabberId sentBy, final Calendar sentOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("sentBy", sentBy); logVariable("sentOn", sentOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Container container; final ContainerVersion version; final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; if(doesExist) { container = read(artifactModel.readId(containerUniqueId)); doesVersionExist = artifactModel.doesVersionExist(container.getId(), containerVersionId); if(doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(sentBy.getUsername()); container.setCreatedOn(sentOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); // create remote info artifactModel.createRemoteInfo(container.getId(), sentBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentSent(sentBy, sentOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("[UNSUPPORTED ARTIFACT TYPE]"); } // add to the version if(!doesVersionExist) { containerIO.addVersion(version.getArtifactId(), version .getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion .getArtifactType()); } } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

if(doesExist) { container = read(artifactModel.readId(containerUniqueId));

if (doesExist) { container = read(artifactModel.readId(uniqueId));

void handleArtifactSent(final JabberId sentBy, final Calendar sentOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("sentBy", sentBy); logVariable("sentOn", sentOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Container container; final ContainerVersion version; final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; if(doesExist) { container = read(artifactModel.readId(containerUniqueId)); doesVersionExist = artifactModel.doesVersionExist(container.getId(), containerVersionId); if(doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(sentBy.getUsername()); container.setCreatedOn(sentOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); // create remote info artifactModel.createRemoteInfo(container.getId(), sentBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentSent(sentBy, sentOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("[UNSUPPORTED ARTIFACT TYPE]"); } // add to the version if(!doesVersionExist) { containerIO.addVersion(version.getArtifactId(), version .getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion .getArtifactType()); } } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

artifactModel.doesVersionExist(container.getId(), containerVersionId); if(doesVersionExist) { version = readVersion(container.getId(), containerVersionId);

artifactModel.doesVersionExist(container.getId(), versionId); if (doesVersionExist) { version = readVersion(container.getId(), versionId); } else { version = createVersion(container.getId(), versionId, sentBy, sentOn);

void handleArtifactSent(final JabberId sentBy, final Calendar sentOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("sentBy", sentBy); logVariable("sentOn", sentOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Container container; final ContainerVersion version; final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; if(doesExist) { container = read(artifactModel.readId(containerUniqueId)); doesVersionExist = artifactModel.doesVersionExist(container.getId(), containerVersionId); if(doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(sentBy.getUsername()); container.setCreatedOn(sentOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); // create remote info artifactModel.createRemoteInfo(container.getId(), sentBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentSent(sentBy, sentOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("[UNSUPPORTED ARTIFACT TYPE]"); } // add to the version if(!doesVersionExist) { containerIO.addVersion(version.getArtifactId(), version .getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion .getArtifactType()); } } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

else { version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); } } else {

} else {

void handleArtifactSent(final JabberId sentBy, final Calendar sentOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("sentBy", sentBy); logVariable("sentOn", sentOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Container container; final ContainerVersion version; final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; if(doesExist) { container = read(artifactModel.readId(containerUniqueId)); doesVersionExist = artifactModel.doesVersionExist(container.getId(), containerVersionId); if(doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(sentBy.getUsername()); container.setCreatedOn(sentOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); // create remote info artifactModel.createRemoteInfo(container.getId(), sentBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentSent(sentBy, sentOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("[UNSUPPORTED ARTIFACT TYPE]"); } // add to the version if(!doesVersionExist) { containerIO.addVersion(version.getArtifactId(), version .getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion .getArtifactType()); } } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

container.setName(containerName);

container.setName(name);

void handleArtifactSent(final JabberId sentBy, final Calendar sentOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("sentBy", sentBy); logVariable("sentOn", sentOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Container container; final ContainerVersion version; final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; if(doesExist) { container = read(artifactModel.readId(containerUniqueId)); doesVersionExist = artifactModel.doesVersionExist(container.getId(), containerVersionId); if(doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(sentBy.getUsername()); container.setCreatedOn(sentOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); // create remote info artifactModel.createRemoteInfo(container.getId(), sentBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentSent(sentBy, sentOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("[UNSUPPORTED ARTIFACT TYPE]"); } // add to the version if(!doesVersionExist) { containerIO.addVersion(version.getArtifactId(), version .getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion .getArtifactType()); } } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

container.setUniqueId(containerUniqueId);

container.setUniqueId(uniqueId);

void handleArtifactSent(final JabberId sentBy, final Calendar sentOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("sentBy", sentBy); logVariable("sentOn", sentOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Container container; final ContainerVersion version; final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; if(doesExist) { container = read(artifactModel.readId(containerUniqueId)); doesVersionExist = artifactModel.doesVersionExist(container.getId(), containerVersionId); if(doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(sentBy.getUsername()); container.setCreatedOn(sentOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); // create remote info artifactModel.createRemoteInfo(container.getId(), sentBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentSent(sentBy, sentOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("[UNSUPPORTED ARTIFACT TYPE]"); } // add to the version if(!doesVersionExist) { containerIO.addVersion(version.getArtifactId(), version .getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion .getArtifactType()); } } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

version = createVersion(container.getId(), containerVersionId,

version = createVersion(container.getId(), versionId,

void handleArtifactSent(final JabberId sentBy, final Calendar sentOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("sentBy", sentBy); logVariable("sentOn", sentOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Container container; final ContainerVersion version; final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; if(doesExist) { container = read(artifactModel.readId(containerUniqueId)); doesVersionExist = artifactModel.doesVersionExist(container.getId(), containerVersionId); if(doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(sentBy.getUsername()); container.setCreatedOn(sentOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); // create remote info artifactModel.createRemoteInfo(container.getId(), sentBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentSent(sentBy, sentOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("[UNSUPPORTED ARTIFACT TYPE]"); } // add to the version if(!doesVersionExist) { containerIO.addVersion(version.getArtifactId(), version .getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion .getArtifactType()); } } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

throw Assert.createUnreachable("[UNSUPPORTED ARTIFACT TYPE]");

throw Assert.createUnreachable("UNSUPPORTED ARTIFACT TYPE");

void handleArtifactSent(final JabberId sentBy, final Calendar sentOn, final UUID containerUniqueId, final Long containerVersionId, final String containerName, final UUID artifactUniqueId, final Long artifactVersionId, final String artifactName, final ArtifactType artifactType, final String artifactChecksum, final byte[] artifactBytes) { logApiId(); logVariable("sentBy", sentBy); logVariable("sentOn", sentOn); logVariable("containerUniqueId", containerUniqueId); logVariable("containerVersionId", containerVersionId); logVariable("containerName", containerName); logVariable("artifactUniqueId", artifactUniqueId); logVariable("artifactVersionId", artifactVersionId); logVariable("artifactName", artifactName); logVariable("artifactType", artifactType); logVariable("artifactChecksum", artifactChecksum); logVariable("artifactBytes", artifactBytes); try { final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Container container; final ContainerVersion version; final Boolean doesExist = artifactModel.doesExist(containerUniqueId); final Boolean doesVersionExist; if(doesExist) { container = read(artifactModel.readId(containerUniqueId)); doesVersionExist = artifactModel.doesVersionExist(container.getId(), containerVersionId); if(doesVersionExist) { version = readVersion(container.getId(), containerVersionId); } else { version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); } } else { doesVersionExist = Boolean.FALSE; container = new Container(); container.setCreatedBy(sentBy.getUsername()); container.setCreatedOn(sentOn); container.setName(containerName); container.setState(ArtifactState.ACTIVE); container.setType(ArtifactType.CONTAINER); container.setUniqueId(containerUniqueId); container.setUpdatedBy(container.getCreatedBy()); container.setUpdatedOn(container.getCreatedOn()); // create containerIO.create(container); // create version version = createVersion(container.getId(), containerVersionId, sentBy, sentOn); // create remote info artifactModel.createRemoteInfo(container.getId(), sentBy, container.getCreatedOn()); // index indexor.create(container.getId(), container.getName()); } // handle the artifact by specific type final ArtifactVersion artifactVersion; switch(artifactType) { case DOCUMENT: artifactVersion = handleDocumentSent(sentBy, sentOn, artifactUniqueId, artifactVersionId, artifactName, artifactChecksum, artifactBytes); break; case CONTAINER: default: throw Assert.createUnreachable("[UNSUPPORTED ARTIFACT TYPE]"); } // add to the version if(!doesVersionExist) { containerIO.addVersion(version.getArtifactId(), version .getVersionId(), artifactVersion.getArtifactId(), artifactVersion.getVersionId(), artifactVersion .getArtifactType()); } } catch(final Throwable t) { throw translateError(getApiId("[HANDLE ARTIFACT SENT]"), t); } }

private DocumentVersion handleDocumentPublished(final JabberId publishedBy, final Calendar publishedOn, final UUID uniqueId, final Long versionId, final String name, final String checksum, final byte[] bytes) throws IOException {

private DocumentVersion handleDocumentPublished(final UUID uniqueId, final Long versionId, final String name, final String checksum, final byte[] bytes, final JabberId publishedBy, final Calendar publishedOn) throws IOException {

private DocumentVersion handleDocumentPublished(final JabberId publishedBy, final Calendar publishedOn, final UUID uniqueId, final Long versionId, final String name, final String checksum, final byte[] bytes) throws IOException { final InternalDocumentModel documentModel = getInternalDocumentModel(); final InputStream inputStream = new BufferedInputStream(new ByteArrayInputStream(bytes), IO.BUFFER_SIZE); try { final DocumentVersion version = documentModel.handleDocumentPublished(publishedBy, publishedOn, uniqueId, versionId, name, checksum, inputStream); return version; } finally { inputStream.close(); } }

final List<ContainerVersion> versions = readVersions(containerId); return 0 < versions.size();

return getInternalArtifactModel().doesVersionExist(containerId, Versioning.START);

private Boolean isDistributed(final Long containerId) { final List<ContainerVersion> versions = readVersions(containerId); return 0 < versions.size(); }

logVariable("userId", userId); logVariable("contactId", contactId);

logger.logVariable("userId", userId); logger.logVariable("contactId", contactId);

private void delete(final JabberId userId, final JabberId contactId) { logVariable("userId", userId); logVariable("contactId", contactId); getContactModel().delete(userId, contactId); }

switchFeed();

public RSS(String name, String hostname, Integer port) throws MalformedURLException { super("RSS." + name, hostname, port); poller = new Poller(1); }

String urlstring = airBrush.getParameterString("QueryString"); URL ret = null; try { ret = new URL(urlstring); } catch (MalformedURLException e) { throw new MalformedURLException("The QueryString parameter is not well formed (" + urlstring + ").");

final String paramname = "FeedURI"; if (airBrush.hasParameter(paramname)) { String urlstring = airBrush.getParameterString(paramname); URL ret = null; try { ret = new URL(urlstring); } catch (MalformedURLException e) { throw new MalformedURLException( "The " + paramname + " parameter is not well formed (" + urlstring + ")."); } return ret; } else { return null;

private URL getURL() throws MalformedURLException { String urlstring = airBrush.getParameterString("QueryString"); URL ret = null; try { ret = new URL(urlstring); } catch (MalformedURLException e) { throw new MalformedURLException("The QueryString parameter is not well formed (" + urlstring + ")."); } return ret; }

return ret;

private URL getURL() throws MalformedURLException { String urlstring = airBrush.getParameterString("QueryString"); URL ret = null; try { ret = new URL(urlstring); } catch (MalformedURLException e) { throw new MalformedURLException("The QueryString parameter is not well formed (" + urlstring + ")."); } return ret; }

final String host; host = "0.0.0.0";

final String host = "0.0.0.0";

StreamServer(final File workingDirectory, final Environment environment) { super(); this.fileServer = new StreamFileServer(this, workingDirectory); this.logger = new Log4JWrapper(); final String host; host = "0.0.0.0";//NetworkUtil.getIp(); //try { //} catch (final UnknownHostException uhx) { // throw new StreamException(uhx); //} final int port = environment.getStreamPort(); if (environment.isStreamTLSEnabled()) { logger.logInfo("Stream Server - {0}:{1} - Secure", host, port); this.socketServer = new SecureStreamSocketServer(this, host, port); } else { logger.logInfo("Stream Server - {0}:{1}", host, port); this.socketServer = new StreamSocketServer(this, host, port); } }

if (op.equals("Departamento RRHH"))

else if (op.equals("Departamento RRHH"))

public void procesarEvento() { ObjetoBean aviso= (ObjetoBean)this.getSesion().getAttribute("beanAvisos"); HashMap listaGrupos=(HashMap)this.getSesion().getAttribute("listagrupos"); //Esto no esta definido todavia String op = (String)this.getSesion().getAttribute("claveaviso"); //Integer pos = (Integer)this.getSesion().getAttribute("posCombo"); //int posi = pos.intValue(); ListaObjetoBean destino = (ListaObjetoBean)listaGrupos.get(op); GestorAvisos GA= new GestorAvisos(); CreadorBean creador = new CreadorBean(); ListaObjetoBean errores= new ListaObjetoBean(); if (!op.equals("")) { if (op.equals("Departamento Contable")) {//el aviso es para un grupo de contables(usuarios) errores=GA.avisoAGrupo(destino,aviso); } if (op.equals("Departamento RRHH")) {//el aviso es para un grupo de RRHH(usuarios) errores=GA.avisoAGrupo(destino,aviso); } else if (op.equals("Profesorado")) {//el aviso es para un grupo de profesores int tama=destino.tamanio(); ListaObjetoBean dest = new ListaObjetoBean(); for (int i=0;i<tama;i++) {//me creo una lista de usuarios a partir de la lista de profesores ObjetoBean usu=creador.crear(creador.Usuario); usu.cambiaValor(Constantes.ID_ISUSUARIO_DNI ,destino.dameObjeto(i).dameValor(Constantes.ID_ISPROFESOR_ISUSUARIO_DNI)); dest.insertar(i,usu); } errores=GA.avisoAGrupo(dest,aviso); } else {//el aviso es para un grupo de alumnos int tamanio=destino.tamanio(); ListaObjetoBean desti = new ListaObjetoBean(); for (int i=0;i<tamanio;i++) {//me creo una lista de usuarios a partir de la lista de profesores ObjetoBean usu=creador.crear(creador.Usuario); usu.cambiaValor(Constantes.ID_ISUSUARIO_DNI ,destino.dameObjeto(i).dameValor(Constantes.ID_ISALUMNO_ISUSUARIO_DNI)); desti.insertar(i,usu); } errores=GA.avisoAGrupo(desti,aviso); } if (!errores.esVacio()) {//tenemos errores al enviar el aviso this.setResuladooperacion("ERROR"); this.getSesion().setAttribute("error",errores); } else {//todo ha funcionado bien this.setResuladooperacion("OK"); this.getSesion().removeAttribute("error"); } } else //la pos es -1, es decir no hay ninguno elegido { ObjetoBean error = creador.crear(creador.Error); error.cambiaValor(Constantes.CAUSA,"Debe elegir algun destinatario"); ListaObjetoBean listaerr= new ListaObjetoBean(); listaerr.insertar(0,error); this.getSesion().setAttribute("error",listaerr); this.setResuladooperacion("ERROR"); } }

System.out.println("Entra en alumnos");

public void procesarEvento() { ObjetoBean aviso= (ObjetoBean)this.getSesion().getAttribute("beanAvisos"); HashMap listaGrupos=(HashMap)this.getSesion().getAttribute("listagrupos"); //Esto no esta definido todavia String op = (String)this.getSesion().getAttribute("claveaviso"); //Integer pos = (Integer)this.getSesion().getAttribute("posCombo"); //int posi = pos.intValue(); ListaObjetoBean destino = (ListaObjetoBean)listaGrupos.get(op); GestorAvisos GA= new GestorAvisos(); CreadorBean creador = new CreadorBean(); ListaObjetoBean errores= new ListaObjetoBean(); if (!op.equals("")) { if (op.equals("Departamento Contable")) {//el aviso es para un grupo de contables(usuarios) errores=GA.avisoAGrupo(destino,aviso); } if (op.equals("Departamento RRHH")) {//el aviso es para un grupo de RRHH(usuarios) errores=GA.avisoAGrupo(destino,aviso); } else if (op.equals("Profesorado")) {//el aviso es para un grupo de profesores int tama=destino.tamanio(); ListaObjetoBean dest = new ListaObjetoBean(); for (int i=0;i<tama;i++) {//me creo una lista de usuarios a partir de la lista de profesores ObjetoBean usu=creador.crear(creador.Usuario); usu.cambiaValor(Constantes.ID_ISUSUARIO_DNI ,destino.dameObjeto(i).dameValor(Constantes.ID_ISPROFESOR_ISUSUARIO_DNI)); dest.insertar(i,usu); } errores=GA.avisoAGrupo(dest,aviso); } else {//el aviso es para un grupo de alumnos int tamanio=destino.tamanio(); ListaObjetoBean desti = new ListaObjetoBean(); for (int i=0;i<tamanio;i++) {//me creo una lista de usuarios a partir de la lista de profesores ObjetoBean usu=creador.crear(creador.Usuario); usu.cambiaValor(Constantes.ID_ISUSUARIO_DNI ,destino.dameObjeto(i).dameValor(Constantes.ID_ISALUMNO_ISUSUARIO_DNI)); desti.insertar(i,usu); } errores=GA.avisoAGrupo(desti,aviso); } if (!errores.esVacio()) {//tenemos errores al enviar el aviso this.setResuladooperacion("ERROR"); this.getSesion().setAttribute("error",errores); } else {//todo ha funcionado bien this.setResuladooperacion("OK"); this.getSesion().removeAttribute("error"); } } else //la pos es -1, es decir no hay ninguno elegido { ObjetoBean error = creador.crear(creador.Error); error.cambiaValor(Constantes.CAUSA,"Debe elegir algun destinatario"); ListaObjetoBean listaerr= new ListaObjetoBean(); listaerr.insertar(0,error); this.getSesion().setAttribute("error",listaerr); this.setResuladooperacion("ERROR"); } }

catch(UnauthorizedException ux) {

catch(final UnauthorizedException ux) {

void requestKey(final UUID artifactUniqueId) throws ParityServerModelException { logger.info("requestKey(UUID)"); logger.debug(artifactUniqueId); try { final JID keyHolderJID = getKeyHolder(artifactUniqueId); final IQ iq = new IQKeyRequest(artifactUniqueId); iq.setTo(keyHolderJID); iq.setFrom(session.getJID()); send(keyHolderJID, iq); } catch(UnauthorizedException ux) { logger.error("requestKey(Artifact)", ux); throw ParityErrorTranslator.translate(ux); } catch(RuntimeException rx) { logger.error("requestKey(Artifact)", rx); throw ParityErrorTranslator.translate(rx); } }

catch(RuntimeException rx) {

catch(final RuntimeException rx) {

void requestKey(final UUID artifactUniqueId) throws ParityServerModelException { logger.info("requestKey(UUID)"); logger.debug(artifactUniqueId); try { final JID keyHolderJID = getKeyHolder(artifactUniqueId); final IQ iq = new IQKeyRequest(artifactUniqueId); iq.setTo(keyHolderJID); iq.setFrom(session.getJID()); send(keyHolderJID, iq); } catch(UnauthorizedException ux) { logger.error("requestKey(Artifact)", ux); throw ParityErrorTranslator.translate(ux); } catch(RuntimeException rx) { logger.error("requestKey(Artifact)", rx); throw ParityErrorTranslator.translate(rx); } }

public CodebaseTestCase() {super();}

public CodebaseTestCase(String arg0) { super(arg0); this.helper = new CodebaseTestHelper(); }

public CodebaseTestCase() {super();}

assertNull(NAME + " [EVENT CONTAINER IS NOT NULL]", e.getContainer());

assertNotNull(NAME + " EVENT CONTAINER IS NULL", e.getContainer());

public void containerDeleted(ContainerEvent e) { didNotify = Boolean.TRUE; assertTrue(NAME + " [EVENT GENERATED IS NOT LOCAL]", e.isLocal()); assertTrue(NAME + " [EVENT GENERATED IS REMOTE]", !e.isRemote()); assertNull(NAME + " [EVENT CONTAINER IS NOT NULL]", e.getContainer()); assertNull(NAME + " [EVENT DOCUMENT IS NOT NULL]", e.getDocument()); assertNull(NAME + " [EVENT DRAFT IS NOT NULL]", e.getDraft()); assertNull(NAME + " [EVENT TEAM MEMBER IS NOT NULL]", e.getTeamMember()); assertNull(NAME + " [EVENT VERSION NOT NULL]", e.getVersion()); }

public Preferences getPreferences() { return new PreferencesHelper(workspaceRoot).getPreferences(); }

public Preferences getPreferences() { return preferences; }

Workspace openWorkspace() { final URL workspaceRootURL = initRoot(); final File workspaceRoot = new File(workspaceRootURL.getFile()); return new Workspace() { /** * URL to the data directory within the workspace. */ final URL dataURL = initChild(workspaceRootURL, "data"); /** * URL to the log file directory within the workspace. */ final URL loggerURL = initChild(workspaceRootURL, "logs"); /** * @see com.thinkparity.model.parity.model.workspace.Workspace#getDataURL() */ public URL getDataURL() { return dataURL; } /** * @see com.thinkparity.model.parity.model.workspace.Workspace#getLoggerURL() */ public URL getLoggerURL() { return loggerURL; } /** * @see com.thinkparity.model.parity.model.workspace.Workspace#getPreferences() */ public Preferences getPreferences() { return new PreferencesHelper(workspaceRoot).getPreferences(); } /** * @see com.thinkparity.model.parity.model.workspace.Workspace#getWorkspaceURL() */ public URL getWorkspaceURL() { return workspaceRootURL; } }; }

public Preferences getPreferences() { return new PreferencesHelper(workspaceRoot).getPreferences(); }

public Preferences getPreferences() { return preferences; }

public Preferences getPreferences() { return new PreferencesHelper(workspaceRoot).getPreferences(); }

public void deleteTeamRel(final Long artifactId, final Long userId) throws HypersonicException {

public void deleteTeamRel(final Long artifactId) throws HypersonicException {

public void deleteTeamRel(final Long artifactId, final Long userId) throws HypersonicException { final Session session = openSession(); try { session.prepareStatement(SQL_DELETE_TEAM_REL_BY_ARTIFACT_BY_USER); session.setLong(1, artifactId); session.setLong(2, userId); if(1 != session.executeUpdate()) throw new HypersonicException("[LMODEL] [ARTIFACT] [IO] [DELETE TEAM REL]"); session.commit(); } catch(final HypersonicException hx) { session.rollback(); throw hx; } finally { session.close(); } }

session.prepareStatement(SQL_DELETE_TEAM_REL_BY_ARTIFACT_BY_USER);

final Integer rowCount = readTeamRelCount(session, artifactId); session.prepareStatement(SQL_DELETE_TEAM_REL_BY_ARTIFACT);

public void deleteTeamRel(final Long artifactId, final Long userId) throws HypersonicException { final Session session = openSession(); try { session.prepareStatement(SQL_DELETE_TEAM_REL_BY_ARTIFACT_BY_USER); session.setLong(1, artifactId); session.setLong(2, userId); if(1 != session.executeUpdate()) throw new HypersonicException("[LMODEL] [ARTIFACT] [IO] [DELETE TEAM REL]"); session.commit(); } catch(final HypersonicException hx) { session.rollback(); throw hx; } finally { session.close(); } }

session.setLong(2, userId); if(1 != session.executeUpdate())

if(rowCount != session.executeUpdate())

public void deleteTeamRel(final Long artifactId, final Long userId) throws HypersonicException { final Session session = openSession(); try { session.prepareStatement(SQL_DELETE_TEAM_REL_BY_ARTIFACT_BY_USER); session.setLong(1, artifactId); session.setLong(2, userId); if(1 != session.executeUpdate()) throw new HypersonicException("[LMODEL] [ARTIFACT] [IO] [DELETE TEAM REL]"); session.commit(); } catch(final HypersonicException hx) { session.rollback(); throw hx; } finally { session.close(); } }

case REACTIVATE: return extractReactivate(session);

private AuditEvent extract(final Session session) { final AuditEventType eventType = session.getAuditEventTypeFromInteger("ARTIFACT_AUDIT_TYPE_ID"); switch(eventType) { case ADD_TEAM_MEMBER: return extractAddTeamMember(session); case ADD_TEAM_MEMBER_CONFIRM: return extractAddTeamMemberConfirm(session); case ARCHIVE: return extractArchive(session); case CLOSE: return extractClose(session); case SEND_CONFIRM: return extractSendConfirm(session); case CREATE: return extractCreate(session); case CREATE_REMOTE: return extractCreateRemote(session); case KEY_RESPONSE_DENIED: return extractKeyResponseDenied(session); case KEY_REQUEST_DENIED: return extractKeyRequestDenied(session); case PUBLISH: return extractPublish(session); case RECEIVE: return extractReceive(session); case RECEIVE_KEY: return extractReceiveKey(session); case RENAME: return extractRename(session); case REQUEST_KEY: return extractRequestKey(session); case SEND: return extractSend(session); case SEND_KEY: return extractSendKey(session); default: throw Assert.createUnreachable("Unknown event type: " + eventType); } }

public User read(final Long userId) {

public User read(final JabberId jabberId) {

public User read(final Long userId) { final Session session = openSession(); try { session.prepareStatement(SQL_READ_BY_USER_ID); session.setLong(1, userId); session.executeQuery(); if(session.nextResult()) { return extractUser(session); } else { return null; } } catch(final HypersonicException hx) { session.rollback(); throw hx; } finally { session.close(); } }

session.prepareStatement(SQL_READ_BY_USER_ID); session.setLong(1, userId);

session.prepareStatement(SQL_READ_BY_JABBER_ID); session.setQualifiedUsername(1, jabberId);

public User read(final Long userId) { final Session session = openSession(); try { session.prepareStatement(SQL_READ_BY_USER_ID); session.setLong(1, userId); session.executeQuery(); if(session.nextResult()) { return extractUser(session); } else { return null; } } catch(final HypersonicException hx) { session.rollback(); throw hx; } finally { session.close(); } }

this.queueSize = 0;

XMPPSystem(final XMPPCore core) { super(core); this.queueLock = new Object(); this.queueSize = 0; }

logger.logVariable("queueSize", queueSize);

void processEventQueue(final JabberId userId) { logger.logApiId(); logger.logVariable("userId", userId); logger.logVariable("queueSize", queueSize); synchronized (queueLock) { final XMPPMethod processOfflineQueue = new XMPPMethod("system:readqueueevents"); processOfflineQueue.setParameter("userId", userId); final List<XMPPEvent> queue = execute(processOfflineQueue, Boolean.TRUE).readResultEvents("events"); queueSize = queue.size(); logger.logVariable("queueSize", queueSize); for (final XMPPEvent queueEvent : queue) { xmppCore.handleEvent(queueEvent); deleteQueueEvent(userId, queueEvent.getId()); logger.logVariable("queueSize", --queueSize); } } }

final XMPPMethod processOfflineQueue = new XMPPMethod("system:readqueueevents"); processOfflineQueue.setParameter("userId", userId);

final XMPPMethod readQueueEvents = new XMPPMethod("system:readqueueevents"); readQueueEvents.setParameter("userId", userId);

void processEventQueue(final JabberId userId) { logger.logApiId(); logger.logVariable("userId", userId); logger.logVariable("queueSize", queueSize); synchronized (queueLock) { final XMPPMethod processOfflineQueue = new XMPPMethod("system:readqueueevents"); processOfflineQueue.setParameter("userId", userId); final List<XMPPEvent> queue = execute(processOfflineQueue, Boolean.TRUE).readResultEvents("events"); queueSize = queue.size(); logger.logVariable("queueSize", queueSize); for (final XMPPEvent queueEvent : queue) { xmppCore.handleEvent(queueEvent); deleteQueueEvent(userId, queueEvent.getId()); logger.logVariable("queueSize", --queueSize); } } }

execute(processOfflineQueue, Boolean.TRUE).readResultEvents("events"); queueSize = queue.size(); logger.logVariable("queueSize", queueSize);

execute(readQueueEvents, Boolean.TRUE).readResultEvents("events");

void processEventQueue(final JabberId userId) { logger.logApiId(); logger.logVariable("userId", userId); logger.logVariable("queueSize", queueSize); synchronized (queueLock) { final XMPPMethod processOfflineQueue = new XMPPMethod("system:readqueueevents"); processOfflineQueue.setParameter("userId", userId); final List<XMPPEvent> queue = execute(processOfflineQueue, Boolean.TRUE).readResultEvents("events"); queueSize = queue.size(); logger.logVariable("queueSize", queueSize); for (final XMPPEvent queueEvent : queue) { xmppCore.handleEvent(queueEvent); deleteQueueEvent(userId, queueEvent.getId()); logger.logVariable("queueSize", --queueSize); } } }

logger.logVariable("queueSize", --queueSize);

void processEventQueue(final JabberId userId) { logger.logApiId(); logger.logVariable("userId", userId); logger.logVariable("queueSize", queueSize); synchronized (queueLock) { final XMPPMethod processOfflineQueue = new XMPPMethod("system:readqueueevents"); processOfflineQueue.setParameter("userId", userId); final List<XMPPEvent> queue = execute(processOfflineQueue, Boolean.TRUE).readResultEvents("events"); queueSize = queue.size(); logger.logVariable("queueSize", queueSize); for (final XMPPEvent queueEvent : queue) { xmppCore.handleEvent(queueEvent); deleteQueueEvent(userId, queueEvent.getId()); logger.logVariable("queueSize", --queueSize); } } }

processQueue();

try { processQueue(); } catch(final RuntimeException rx) { sysApp.logger.error("[BROWSER2] [APP] [SYS] [IMPL RUNNING]", rx); throw rx; }

public void run() { while(running) { sysApp.logger.info("[BROWSER2] [APP] [SYS] [IMPL] [RUNNING]"); try { synchronized(this) { wait(); } } catch(final InterruptedException ix) { sysApp.logger.info("[BROWSER2] [APP] [SYS] [IMPL] [INTERRUPTED]"); } processQueue(); } }

return readDocument(index.lookupXmlFile(id));

final File xmlFile = index.lookupXmlFile(id); if(null == xmlFile) { return null; } else { return readDocument(xmlFile); }

public Document get(final UUID id) throws FileNotFoundException, IOException { logger.info("get(UUID)"); logger.debug(id); final Index index = readIndex(getIndexXmlFile()); return readDocument(index.lookupXmlFile(id)); }

index.addLookup(document.getId(), targetDocumentXmlFile);

index.addXmlFileLookup(document.getId(), targetDocumentXmlFile);

protected void move(final Document document, final DocumentContent content, final Collection<DocumentVersion> versions, final File targetXmlFileDirectory) throws FileNotFoundException, IOException { final File documentXmlFile = getXmlFile(document); final File contentXmlFile = getXmlFile(document, content); final File[] versionXmlFiles = getXmlFiles(document, versions); final File targetDocumentXmlFile = new File(targetXmlFileDirectory, documentXmlFile.getName()); FileUtil.copy(documentXmlFile, targetDocumentXmlFile); Assert.assertTrue( "move(Document,DocumentContent,DocumentVersion,File)", documentXmlFile.delete()); FileUtil.copy(contentXmlFile, new File(targetXmlFileDirectory, contentXmlFile.getName())); Assert.assertTrue( "move(Document,DocumentContent,DocumentVersion,File)", contentXmlFile.delete()); for(File versionXmlFile : versionXmlFiles) { FileUtil.copy(versionXmlFile, new File(targetXmlFileDirectory, versionXmlFile.getName())); Assert.assertTrue( "move(Document,DocumentContent,DocumentVersion,File)", versionXmlFile.delete()); } final Index index = readIndex(getIndexXmlFile()); index.addLookup(document.getId(), targetDocumentXmlFile); write(index, getIndexXmlFile()); }

public static MappingDescriptor loadClassDescriptors(String xmlFile)

public static MappingDescriptor loadClassDescriptors(InputStream stream)

public static MappingDescriptor loadClassDescriptors(String xmlFile) { try { return loadClassDescriptors(new FileInputStream(xmlFile)); } catch (FileNotFoundException e) { throw new InitMapperException(e); } }

return loadClassDescriptors(new FileInputStream(xmlFile));

Digester digester = new Digester(); digester.setValidating(true); digester.addObjectCreate("graffito-jcr", MappingDescriptor.class); digester.addObjectCreate("graffito-jcr/class-descriptor", ClassDescriptor.class); digester.addSetProperties("graffito-jcr/class-descriptor", "className", "className"); digester.addSetProperties("graffito-jcr/class-descriptor", "jcrNodeType", "jcrNodeType"); digester.addSetProperties("graffito-jcr/class-descriptor", "jcrSuperTypes", "jcrSuperTypes"); digester.addSetNext("graffito-jcr/class-descriptor", "addClassDescriptor"); digester.addObjectCreate("graffito-jcr/class-descriptor/field-descriptor", FieldDescriptor.class); digester.addSetProperties("graffito-jcr/class-descriptor/field-descriptor", "fieldName", "fieldName"); digester.addSetProperties("graffito-jcr/class-descriptor/field-descriptor", "fieldType", "fieldType"); digester.addSetProperties("graffito-jcr/class-descriptor/field-descriptor", "jcrName", "jcrName"); digester.addSetProperties("graffito-jcr/class-descriptor/field-descriptor", "id", "id"); digester.addSetProperties("graffito-jcr/class-descriptor/field-descriptor", "path", "path"); digester.addSetProperties("graffito-jcr/class-descriptor/field-descriptor", "jcrType", "jcrType"); digester.addSetProperties("graffito-jcr/class-descriptor/field-descriptor", "jcrAutoCreated", "jcrAutoCreated"); digester.addSetProperties("graffito-jcr/class-descriptor/field-descriptor", "jcrMandatory", "jcrMandatory"); digester.addSetProperties("graffito-jcr/class-descriptor/field-descriptor", "jcrOnParentVersion", "jcrOnParentVersion"); digester.addSetProperties("graffito-jcr/class-descriptor/field-descriptor", "jcrProtected", "jcrProtected"); digester.addSetProperties("graffito-jcr/class-descriptor/field-descriptor", "jcrMultiple", "jcrMultiple"); digester.addSetNext("graffito-jcr/class-descriptor/field-descriptor", "addFieldDescriptor"); digester.addObjectCreate("graffito-jcr/class-descriptor/bean-descriptor", BeanDescriptor.class); digester.addSetProperties("graffito-jcr/class-descriptor/bean-descriptor", "fieldName", "fieldName"); digester.addSetProperties("graffito-jcr/class-descriptor/bean-descriptor", "jcrName", "jcrName"); digester.addSetProperties("graffito-jcr/class-descriptor/bean-descriptor", "proxy", "proxy"); digester.addSetProperties("graffito-jcr/class-descriptor/bean-descriptor", "jcrNodeType", "jcrNodeType"); digester.addSetProperties("graffito-jcr/class-descriptor/bean-descriptor", "jcrAutoCreated", "jcrAutoCreated"); digester.addSetProperties("graffito-jcr/class-descriptor/bean-descriptor", "jcrMandatory", "jcrMandatory"); digester.addSetProperties("graffito-jcr/class-descriptor/bean-descriptor", "jcrOnParentVersion", "jcrOnParentVersion"); digester.addSetProperties("graffito-jcr/class-descriptor/bean-descriptor", "jcrProtected", "jcrProtected"); digester.addSetProperties("graffito-jcr/class-descriptor/bean-descriptor", "jcrSameNameSiblings", "jcrSameNameSiblings"); digester.addSetNext("graffito-jcr/class-descriptor/bean-descriptor", "addBeanDescriptor"); digester.addObjectCreate("graffito-jcr/class-descriptor/collection-descriptor", CollectionDescriptor.class); digester.addSetProperties("graffito-jcr/class-descriptor/collection-descriptor", "fieldName", "fieldName"); digester.addSetProperties("graffito-jcr/class-descriptor/collection-descriptor", "jcrName", "jcrName"); digester.addSetProperties("graffito-jcr/class-descriptor/collection-descriptor", "proxy", "proxy"); digester.addSetProperties("graffito-jcr/class-descriptor/collection-descriptor", "elementClassName", "elementClassName"); digester.addSetProperties("graffito-jcr/class-descriptor/collection-descriptor", "collectionConverter", "collectionConverterClassName"); digester.addSetProperties("graffito-jcr/class-descriptor/collection-descriptor", "collectionClassName", "collectionClassName"); digester.addSetProperties("graffito-jcr/class-descriptor/collection-descriptor", "jcrNodeType", "jcrNodeType"); digester.addSetProperties("graffito-jcr/class-descriptor/collection-descriptor", "jcrAutoCreated", "jcrAutoCreated"); digester.addSetProperties("graffito-jcr/class-descriptor/collection-descriptor", "jcrMandatory", "jcrMandatory"); digester.addSetProperties("graffito-jcr/class-descriptor/collection-descriptor", "jcrOnParentVersion", "jcrOnParentVersion"); digester.addSetProperties("graffito-jcr/class-descriptor/collection-descriptor", "jcrProtected", "jcrProtected"); digester.addSetProperties("graffito-jcr/class-descriptor/collection-descriptor", "jcrSameNameSiblings", "jcrSameNameSiblings"); digester.addSetNext("graffito-jcr/class-descriptor/collection-descriptor", "addCollectionDescriptor"); MappingDescriptor mappingDescriptor = (MappingDescriptor) digester.parse(stream); return mappingDescriptor;

public static MappingDescriptor loadClassDescriptors(String xmlFile) { try { return loadClassDescriptors(new FileInputStream(xmlFile)); } catch (FileNotFoundException e) { throw new InitMapperException(e); } }

catch (FileNotFoundException e)

catch (Exception e)

public static MappingDescriptor loadClassDescriptors(String xmlFile) { try { return loadClassDescriptors(new FileInputStream(xmlFile)); } catch (FileNotFoundException e) { throw new InitMapperException(e); } }

throw new InitMapperException(e);

throw new InitMapperException("Impossible to read the xml mapping file", e);

public static MappingDescriptor loadClassDescriptors(String xmlFile) { try { return loadClassDescriptors(new FileInputStream(xmlFile)); } catch (FileNotFoundException e) { throw new InitMapperException(e); } }

public void teamMemberAdded(final DocumentEvent e) { if(e.isRemote()) { browser.fireDocumentTeamMemberAdded(e.getDocument().getId()); } }

private DocumentListener createDocumentListener() { return new DocumentAdapter() { public void confirmationReceived(final DocumentEvent e) { if(e.isRemote()) { browser.fireDocumentConfirmationReceived(e.getDocument().getId()); } } public void documentClosed(final DocumentEvent e) { if(e.isRemote()) { browser.getArtifactModel().removeFlagSeen(e.getDocument().getId()); browser.fireDocumentUpdated(e.getDocument().getId()); } } public void documentCreated(final DocumentEvent e) { if(e.isRemote()) { browser.fireDocumentCreated(e.getDocument().getId(), Boolean.TRUE); } } public void documentUpdated(final DocumentEvent e) { if(e.isRemote()) { browser.fireDocumentUpdated(e.getDocument().getId(), Boolean.TRUE); } } public void keyRequestAccepted(final DocumentEvent e) { if(e.isRemote()) { browser.fireDocumentUpdated(e.getDocument().getId(), e.isRemote()); } } public void keyRequestDeclined(final DocumentEvent e) { if(e.isRemote()) { browser.fireDocumentUpdated(e.getDocument().getId(), e.isRemote()); } } public void keyRequested(final DocumentEvent e) { if(e.isRemote()) { browser.fireDocumentUpdated(e.getDocument().getId(), e.isRemote()); } } }; }

final String resourcePath = properties.getProperty( MessageFormat.format("demo.scenario.{0}.ResourcePath", scenarioName), null);

final String resourcePath = MessageFormat.format("demo/{0}/resources", scenarioName.toLowerCase());

private void configureScenario(final List<Scenario> scenarios, final Environment environment, final Properties properties, final String scenarioName) { final String displayName = properties.getProperty( MessageFormat.format("demo.scenario.{0}.DisplayName", scenarioName), null); final String resourcePath = properties.getProperty( MessageFormat.format("demo.scenario.{0}.ResourcePath", scenarioName), null); final String scripts = properties.getProperty( MessageFormat.format("demo.scenario.{0}.Scripts", scenarioName), null); if (null == displayName || null == resourcePath || null == scripts) { logger.logWarning("Scenario {0} is not configured correctly.", scenarioName); } else { final Scenario scenario = new Scenario(); scenario.setDisplayName(displayName); scenario.setEnvironment(environment); scenario.setName(scenarioName); scenario.setResourcePath(resourcePath); final StringTokenizer tokenizer = new StringTokenizer(scripts, ","); while (tokenizer.hasMoreTokens()) { configureScenarioScript(scenario, properties, tokenizer.nextToken()); } scenarios.add(scenario); } }

final String scriptPath = properties.getProperty( MessageFormat.format("demo.scenario.{0}.{1}.ScriptPath", scenario.getName(), scriptName), null);

final String scriptPath = MessageFormat.format("demo/", "");

private void configureScenarioScript(final Scenario scenario, final Properties properties, final String scriptName) { final String scriptPath = properties.getProperty( MessageFormat.format("demo.scenario.{0}.{1}.ScriptPath", scenario.getName(), scriptName), null); final String username = properties.getProperty( MessageFormat.format("demo.scenario.{0}.{1}.Credentials.Username", scenario.getName(), scriptName), null); final String password = properties.getProperty( MessageFormat.format("demo.scenario.{0}.{1}.Credentials.Password", scenario.getName(), scriptName), null); if (null == scriptPath || null == username || null == password) { logger.logWarning("Demo script {0} for scenario {1} is not configured correctly.", scriptName, scenario.getName()); } else { final Credentials credentials = new Credentials(); credentials.setPassword(password); credentials.setUsername(username); scenario.addScript(new Script() { public String getName() { return scriptName; } public InputStream openStream() { return ResourceUtil.getInputStream(scriptPath); } }, credentials); } }

public InputStream openStream() {

public InputStream open() {

private void configureScenarioScript(final Scenario scenario, final Properties properties, final String scriptName) { final String scriptPath = properties.getProperty( MessageFormat.format("demo.scenario.{0}.{1}.ScriptPath", scenario.getName(), scriptName), null); final String username = properties.getProperty( MessageFormat.format("demo.scenario.{0}.{1}.Credentials.Username", scenario.getName(), scriptName), null); final String password = properties.getProperty( MessageFormat.format("demo.scenario.{0}.{1}.Credentials.Password", scenario.getName(), scriptName), null); if (null == scriptPath || null == username || null == password) { logger.logWarning("Demo script {0} for scenario {1} is not configured correctly.", scriptName, scenario.getName()); } else { final Credentials credentials = new Credentials(); credentials.setPassword(password); credentials.setUsername(username); scenario.addScript(new Script() { public String getName() { return scriptName; } public InputStream openStream() { return ResourceUtil.getInputStream(scriptPath); } }, credentials); } }

} public InputStream openResource(String name) { return ResourceUtil.getInputStream(new StringBuffer( scenario.getResourcePath()) .append("/").append(scriptPath).toString());

private void configureScenarioScript(final Scenario scenario, final Properties properties, final String scriptName) { final String scriptPath = properties.getProperty( MessageFormat.format("demo.scenario.{0}.{1}.ScriptPath", scenario.getName(), scriptName), null); final String username = properties.getProperty( MessageFormat.format("demo.scenario.{0}.{1}.Credentials.Username", scenario.getName(), scriptName), null); final String password = properties.getProperty( MessageFormat.format("demo.scenario.{0}.{1}.Credentials.Password", scenario.getName(), scriptName), null); if (null == scriptPath || null == username || null == password) { logger.logWarning("Demo script {0} for scenario {1} is not configured correctly.", scriptName, scenario.getName()); } else { final Credentials credentials = new Credentials(); credentials.setPassword(password); credentials.setUsername(username); scenario.addScript(new Script() { public String getName() { return scriptName; } public InputStream openStream() { return ResourceUtil.getInputStream(scriptPath); } }, credentials); } }

return localFileName(version);

return MessageFormat.format("{0}.{1}", FileUtil.getName(version.getName()), FileUtil.getExtension(version.getName()));

public String exportFileName(final DocumentVersion version) { return localFileName(version); }

this.imageCache = new MainCellImageCache();

public MainCellDocument(final Document d) { super(d.getCreatedBy(), d.getCreatedOn(), d.getDescription(), d.getFlags(), d.getUniqueId(), d.getName(), d.getUpdatedBy(), d.getUpdatedOn()); this.imageCache = new MainCellImageCache(); setId(d.getId()); setRemoteInfo(d.getRemoteInfo()); setState(d.getState()); this.keyRequests = new LinkedList<KeyRequest>(); }

this.seen = contains(ArtifactFlag.SEEN);

public MainCellDocument(final Document d) { super(d.getCreatedBy(), d.getCreatedOn(), d.getDescription(), d.getFlags(), d.getUniqueId(), d.getName(), d.getUpdatedBy(), d.getUpdatedOn()); this.imageCache = new MainCellImageCache(); setId(d.getId()); setRemoteInfo(d.getRemoteInfo()); setState(d.getState()); this.keyRequests = new LinkedList<KeyRequest>(); }

if(hasBeenSeen()) { return BrowserConstants.DefaultFont; }

if(isSeen()) { return BrowserConstants.DefaultFont; }

public Font getTextFont() { if(hasBeenSeen()) { return BrowserConstants.DefaultFont; } else { return BrowserConstants.DefaultFontBold; } }

listModel.remove(i); listModel.add(i, visiblePanels.get(i));

listModel.set(listModel.indexOf(visiblePanels.get(i)), visiblePanels.get(i));

public void synchronize() { debug(); visiblePanels.clear(); for (final TabPanel containerPanel : containerPanels) { visiblePanels.add(containerPanel); if (isExpanded(containerPanel)) { visiblePanels.add(versionsPanels.get(containerPanel)); } } // add visible cells not in the model for (int i = 0; i < visiblePanels.size(); i++) { if (listModel.contains(visiblePanels.get(i))) { listModel.remove(i); listModel.add(i, visiblePanels.get(i)); } else { listModel.add(i, visiblePanels.get(i)); } } // prune cells in the model no longer visible final TabPanel[] obsoletePanels = new TabPanel[listModel.size()]; listModel.copyInto(obsoletePanels); for (int i = 0; i < obsoletePanels.length; i++) { if (!visiblePanels.contains(obsoletePanels[i])) { listModel.removeElement(obsoletePanels[i]); } } debug(); }

final XMPPSession session = openSession();