JoaoJunior/formatted-java-preprocessed-code-APR

public 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) { synchronized(getImplLock()) { getImpl().handleArtifactPublished(publishedBy, publishedOn, containerUniqueId, containerVersionId, containerName, artifactUniqueId, artifactVersionId, artifactName, artifactType, artifactChecksum, artifactBytes); } }

public 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, final JabberId publishedBy, final Calendar publishedOn) { synchronized(getImplLock()) { getImpl().handleArtifactPublished(publishedBy, publishedOn, containerUniqueId, containerVersionId, containerName, artifactUniqueId, artifactVersionId, artifactName, artifactType, artifactChecksum, artifactBytes); } }

1,113,758

public 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) { synchronized(getImplLock()) { getImpl().handleArtifactPublished(publishedBy, publishedOn, containerUniqueId, containerVersionId, containerName, artifactUniqueId, artifactVersionId, artifactName, artifactType, artifactChecksum, artifactBytes); } }

1,113,759

public 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) { synchronized(getImplLock()) { getImpl().handleArtifactSent(sentBy, sentOn, containerUniqueId, containerVersionId, containerName, artifactUniqueId, artifactVersionId, artifactName, artifactType, artifactChecksum, artifactBytes); } }

1,113,760

public 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) { synchronized(getImplLock()) { getImpl().handleArtifactSent(sentBy, sentOn, containerUniqueId, containerVersionId, containerName, artifactUniqueId, artifactVersionId, artifactName, artifactType, artifactChecksum, artifactBytes); } }

public 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, final JabberId sentBy, final Calendar sentOn) { synchronized(getImplLock()) { getImpl().handleArtifactSent(sentBy, sentOn, containerUniqueId, containerVersionId, containerName, artifactUniqueId, artifactVersionId, artifactName, artifactType, artifactChecksum, artifactBytes); } }

1,113,761

public 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) { synchronized(getImplLock()) { getImpl().handleArtifactSent(sentBy, sentOn, containerUniqueId, containerVersionId, containerName, artifactUniqueId, artifactVersionId, artifactName, artifactType, artifactChecksum, artifactBytes); } }

1,113,762

private static void initLogging(final Workspace workspace) { final Properties log4j = ConfigFactory.newInstance("log4j.properties"); switch (Version.getMode()) { case DEVELOPMENT: log4j.setProperty("log4j.logger.com.thinkparity", "DEBUG,CONSOLE,FILE"); break; case DEMO: case PRODUCTION: log4j.setProperty("log4j.logger.com.thinkparity", "WARN,FILE"); break; case TESTING: log4j.setProperty("log4j.logger.com.thinkparity", "INFO,FILE"); break; default: Assert.assertUnreachable("UNKNOWN MODE"); } log4j.setProperty("log4j.appender.FILE.File", workspace.getLogFile().getAbsolutePath()); LogManager.resetConfiguration(); PropertyConfigurator.configure(log4j); new Log4JWrapper().logInfo("{0} - {1} - {2}", Version.getName(), Version.getMode(), Version.getBuildId()); }

1,113,764

public ContactTabAvatar() { super(AvatarId.TAB_CONTACT, new ContactTabModel()); model.setLocalization(getLocalization()); model.setSession(getSession()); setPopupDelegate(model.getPopupDelegate()); }

public ContactTabAvatar() { super(AvatarId.TAB_CONTACT, new ContactTabModel()); model.setLocalization(getLocalization()); model.setSession(getSession()); setSortByDelegate(model); }

1,113,765

protected void debugSql(final String sql) { final StringBuffer message = new StringBuffer("[SQL] ") .append(sql); logger.debug(message); }

1,113,766

protected static void assertEquals(final String assertion, final InputStream expected, final InputStream actual) throws IOException { final byte[] expectedBuffer = new byte[384]; final byte[] actualBuffer = new byte[expectedBuffer.length]; int offset = 0; int expectedRead = expected.read(expectedBuffer); int actualRead = actual.read(actualBuffer); while (-1 != expectedRead) { assertEquals("The number of bytes read at offset " + offset + " does not match expectation.", expectedRead, actualRead); for (int i = 0; i < expectedRead; i++) { assertEquals("The byte at location " + offset + ":" + i + " does not match expectation.", expectedBuffer[i], actualBuffer[i]); } offset += expectedRead; expectedRead = expected.read(expectedBuffer); actualRead = actual.read(actualBuffer); } }

1,113,767

public ArtifactReceipt getArtifactReceipt(final User user) { for (final User versionUser : versionUsers.keySet()) { if (versionUser.getId().equals(user.getId())) { return versionUsers.get(versionUser); } } return null; }

1,113,768

public Object getUserValueAt(final User user, final int columnIndex) { Object value; switch(columnIndex) { case 1: value = user.getName(); break; case 2: value = user.getTitle(); break; case 3: value = user.getOrganization(); break; case 4: if (user.getId().equals(publisher.getId())) { value = localization.getString("TeamMemberPublisher"); } else if (isVersionUser(user)) { ArtifactReceipt receipt = getArtifactReceipt(user); if ((null == receipt) || (!receipt.isSetReceivedOn())) { value = localization.getString("TeamMemberDidNotReceive"); } else { value = localization.getString("TeamMemberReceived", new Object[] {receipt.getReceivedOn().getTime()}); } } else if (teamMembers.contains(user)) { // Team members that didn't get sent this version if (publishType==PublishType.PUBLISH_VERSION) { value = localization.getString("TeamMemberNotSentToForward"); } else { value = localization.getString("TeamMemberNotSentToPublish"); } } else { // Will be true for non-team members, eg. contacts value = null; } break; default: value = null; break; } return value; }

public Object getUserValueAt(final User user, final int columnIndex) { Object value; switch(columnIndex) { case 1: value = user.getName(); break; case 2: value = user.getTitle(); break; case 3: value = user.getOrganization(); break; case 4: if ((null!=publisher) && (user.getId().equals(publisher.getId()))) { value = localization.getString("TeamMemberPublisher"); } else if (isVersionUser(user)) { ArtifactReceipt receipt = getArtifactReceipt(user); if ((null == receipt) || (!receipt.isSetReceivedOn())) { value = localization.getString("TeamMemberDidNotReceive"); } else { value = localization.getString("TeamMemberReceived", new Object[] {receipt.getReceivedOn().getTime()}); } } else if (teamMembers.contains(user)) { // Team members that didn't get sent this version if (publishType==PublishType.PUBLISH_VERSION) { value = localization.getString("TeamMemberNotSentToForward"); } else { value = localization.getString("TeamMemberNotSentToPublish"); } } else { // Will be true for non-team members, eg. contacts value = null; } break; default: value = null; break; } return value; }

1,113,769

public Boolean isVersionUser(final User user) { for (final User versionUser : versionUsers.keySet()) { if (versionUser.getId().equals(user.getId())) { return Boolean.TRUE; } } return Boolean.FALSE; }

1,113,770

private JMenuItem createJMenuItem(final String menuItemLocalKey, final ActionListener actionListener) { final JMenuItem jMenuItem = MenuItemFactory.create(getString(menuItemLocalKey), getMnemonic(menuItemLocalKey)); jMenuItem.addActionListener(actionListener); return jMenuItem; }

1,113,771

public void actionPerformed(final java.awt.event.ActionEvent e) { avatar.getController().displaySendVersion(getDocumentId(), getVersionId()); }

1,113,772

public void populatePopupMenu(final MouseEvent e, final JPopupMenu jPopupMenu) { if(isVersionAttached()) { jPopupMenu.add(getOpenVersionMenuItem()); jPopupMenu.add(getSendVersionMenuItem()); } }

public void populatePopupMenu(final MouseEvent e, final JPopupMenu jPopupMenu) { if(isVersionAttached()) { jPopupMenu.add(getOpenVersionMenuItem()); jPopupMenu.add(getSendVersionMenu()); } }

1,113,773

public void setAvatar(final Avatar avatar) { this.avatar = avatar; }

public void setAvatar(final HistoryItems avatar) { this.avatar = avatar; }

1,113,774

public void audit(final CloseEvent closeEvent) { synchronized(getImplLock()) { getImpl().audit(closeEvent); } }

1,113,775

private ProviderFactory() { super(); final ModelFactory modelFactory = ModelFactory.getInstance(); this.artifactModel = modelFactory.getArtifactModel(getClass()); this.dModel = modelFactory.getDocumentModel(getClass()); this.logger = ModelLoggerFactory.getLogger(getClass()); this.loggedInUser = JabberIdBuilder.parseUsername(preferences.getUsername()); this.sModel = modelFactory.getSessionModel(getClass()); this.systemMessageModel = modelFactory.getSystemMessageModel(getClass()); this.historyProvider = new HistoryProvider(loggedInUser, dModel, sModel); this.infoProvider = new InfoProvider(dModel, sModel); this.mainProvider = new MainProvider(artifactModel, dModel, sModel, systemMessageModel); this.manageContactsProvider = new ManageContactsProvider(sModel); this.sendArtifactProvider = new SendArtifactProvider(dModel, sModel, loggedInUser); this.sendVersionProvider = new SendVersionProvider(dModel, sModel, loggedInUser); }

private ProviderFactory() { super(); final ModelFactory modelFactory = ModelFactory.getInstance(); this.artifactModel = modelFactory.getArtifactModel(getClass()); this.dModel = modelFactory.getDocumentModel(getClass()); this.logger = ModelLoggerFactory.getLogger(getClass()); this.loggedInUser = JabberIdBuilder.parseUsername(preferences.getUsername()); this.sModel = modelFactory.getSessionModel(getClass()); this.systemMessageModel = modelFactory.getSystemMessageModel(getClass()); this.historyProvider = new HistoryProvider(loggedInUser, dModel, sModel); this.infoProvider = new InfoProvider(dModel, sModel); this.mainProvider = new MainProvider(artifactModel, dModel, sModel, systemMessageModel, loggedInUser); this.manageContactsProvider = new ManageContactsProvider(sModel); this.sendArtifactProvider = new SendArtifactProvider(dModel, sModel, loggedInUser); this.sendVersionProvider = new SendVersionProvider(dModel, sModel, loggedInUser); }

1,113,776

void handlePublished(final ContainerPublishedEvent event) { logger.logApiId(); logger.logVariable("event", event); try { final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Long containerId = artifactModel.readId(event.getUniqueId()); if (artifactModel.doesVersionExist(containerId, event.getVersionId())) { logger.logWarning("Container {0}:{1} already exists.", event .getUniqueId(), event.getVersionId()); } else { // add to local team final InternalUserModel userModel = getInternalUserModel(); final List<TeamMember> localTeam = artifactModel.readTeam2(containerId); final List<User> publishedToUsers = new ArrayList<User>(); for (final JabberId publishedToId : event.getPublishedTo()) { if (!contains(localTeam, publishedToId)) { artifactModel.addTeamMember(containerId, publishedToId); } publishedToUsers.add(userModel.read(publishedToId)); } // add the sender as well if (!contains(localTeam, event.getPublishedBy())) { artifactModel.addTeamMember(containerId, event.getPublishedBy()); } // delete draft final ContainerDraft draft = readDraft(containerId); if (null == draft) { logger.logWarning("Draft did not previously exist for {0}.", event.getName()); } else { for (final Artifact artifact : draft.getArtifacts()) { containerIO.deleteDraftArtifactRel(containerId, artifact.getId()); } containerIO.deleteDraft(containerId); } // create published to list containerIO.createPublishedTo(containerId, event.getVersionId(), publishedToUsers); // calculate differences final ContainerVersion version = readVersion(containerId, event.getVersionId()); final ContainerVersion previous = readPreviousVersion(containerId, event.getVersionId()); final ContainerVersion next = readNextVersion(containerId, event.getVersionId()); if (null == previous) { logger.logInfo("First version of {0}.", event.getName()); } else { containerIO.deleteDelta(containerId, previous.getVersionId(), version.getVersionId()); containerIO.createDelta(calculateDelta(read(containerId), previous, version)); } if (null == next) { logger.logInfo("Latest version of {0}.", event.getName()); } else { containerIO.deleteDelta(containerId, version.getVersionId(), next.getVersionId()); containerIO.createDelta(calculateDelta(read(containerId), version, next)); } // apply comment containerIO.updateComment(containerId, version.getVersionId(), event.getComment()); // send confirmation getSessionModel().confirmArtifactReceipt(localUserId(), event.getUniqueId(), event.getVersionId(), localUserId(), currentDateTime()); // audit\fire event final Container postPublish = read(containerId); final ContainerDraft postPublishDraft = readDraft(containerId); final ContainerVersion postPublishVersion = readVersion(containerId, event.getVersionId()); auditContainerPublished(postPublish, postPublishDraft, postPublishVersion, event.getPublishedBy(), event.getPublishedTo(), event.getPublishedOn()); notifyContainerPublished(postPublish, postPublishDraft, postPublishVersion, remoteEventGenerator); } } catch (final Throwable t) { throw translateError(t); } }

1,113,780

void handlePublished(final ContainerPublishedEvent event) { logger.logApiId(); logger.logVariable("event", event); try { final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Long containerId = artifactModel.readId(event.getUniqueId()); if (artifactModel.doesVersionExist(containerId, event.getVersionId())) { logger.logWarning("Container {0}:{1} already exists.", event .getUniqueId(), event.getVersionId()); } else { // add to local team final InternalUserModel userModel = getInternalUserModel(); final List<TeamMember> localTeam = artifactModel.readTeam2(containerId); final List<User> publishedToUsers = new ArrayList<User>(); for (final JabberId publishedToId : event.getPublishedTo()) { if (!contains(localTeam, publishedToId)) { artifactModel.addTeamMember(containerId, publishedToId); } publishedToUsers.add(userModel.read(publishedToId)); } // add the sender as well if (!contains(localTeam, event.getPublishedBy())) { artifactModel.addTeamMember(containerId, event.getPublishedBy()); } // delete draft final ContainerDraft draft = readDraft(containerId); if (null == draft) { logger.logWarning("Draft did not previously exist for {0}.", event.getName()); } else { for (final Artifact artifact : draft.getArtifacts()) { containerIO.deleteDraftArtifactRel(containerId, artifact.getId()); } containerIO.deleteDraft(containerId); } // create published to list containerIO.createPublishedTo(containerId, event.getVersionId(), publishedToUsers); // calculate differences final ContainerVersion version = readVersion(containerId, event.getVersionId()); final ContainerVersion previous = readPreviousVersion(containerId, event.getVersionId()); final ContainerVersion next = readNextVersion(containerId, event.getVersionId()); if (null == previous) { logger.logInfo("First version of {0}.", event.getName()); } else { containerIO.deleteDelta(containerId, previous.getVersionId(), version.getVersionId()); containerIO.createDelta(calculateDelta(read(containerId), previous, version)); } if (null == next) { logger.logInfo("Latest version of {0}.", event.getName()); } else { containerIO.deleteDelta(containerId, version.getVersionId(), next.getVersionId()); containerIO.createDelta(calculateDelta(read(containerId), version, next)); } // apply comment containerIO.updateComment(containerId, version.getVersionId(), event.getComment()); // send confirmation getSessionModel().confirmArtifactReceipt(localUserId(), event.getUniqueId(), event.getVersionId(), localUserId(), currentDateTime()); // audit\fire event final Container postPublish = read(containerId); final ContainerDraft postPublishDraft = readDraft(containerId); final ContainerVersion postPublishVersion = readVersion(containerId, event.getVersionId()); auditContainerPublished(postPublish, postPublishDraft, postPublishVersion, event.getPublishedBy(), event.getPublishedTo(), event.getPublishedOn()); notifyContainerPublished(postPublish, postPublishDraft, postPublishVersion, remoteEventGenerator); } } catch (final Throwable t) { throw translateError(t); } }

1,113,781

void handlePublished(final ContainerPublishedEvent event) { logger.logApiId(); logger.logVariable("event", event); try { final InternalArtifactModel artifactModel = getInternalArtifactModel(); final Long containerId = artifactModel.readId(event.getUniqueId()); if (artifactModel.doesVersionExist(containerId, event.getVersionId())) { logger.logWarning("Container {0}:{1} already exists.", event .getUniqueId(), event.getVersionId()); } else { // add to local team final InternalUserModel userModel = getInternalUserModel(); final List<TeamMember> localTeam = artifactModel.readTeam2(containerId); final List<User> publishedToUsers = new ArrayList<User>(); for (final JabberId publishedToId : event.getPublishedTo()) { if (!contains(localTeam, publishedToId)) { artifactModel.addTeamMember(containerId, publishedToId); } publishedToUsers.add(userModel.read(publishedToId)); } // add the sender as well if (!contains(localTeam, event.getPublishedBy())) { artifactModel.addTeamMember(containerId, event.getPublishedBy()); } // delete draft final ContainerDraft draft = readDraft(containerId); if (null == draft) { logger.logWarning("Draft did not previously exist for {0}.", event.getName()); } else { for (final Artifact artifact : draft.getArtifacts()) { containerIO.deleteDraftArtifactRel(containerId, artifact.getId()); } containerIO.deleteDraft(containerId); } // create published to list containerIO.createPublishedTo(containerId, event.getVersionId(), publishedToUsers); // calculate differences final ContainerVersion version = readVersion(containerId, event.getVersionId()); final ContainerVersion previous = readPreviousVersion(containerId, event.getVersionId()); final ContainerVersion next = readNextVersion(containerId, event.getVersionId()); if (null == previous) { logger.logInfo("First version of {0}.", event.getName()); } else { containerIO.deleteDelta(containerId, previous.getVersionId(), version.getVersionId()); containerIO.createDelta(calculateDelta(read(containerId), previous, version)); } if (null == next) { logger.logInfo("Latest version of {0}.", event.getName()); } else { containerIO.deleteDelta(containerId, version.getVersionId(), next.getVersionId()); containerIO.createDelta(calculateDelta(read(containerId), version, next)); } // apply comment containerIO.updateComment(containerId, version.getVersionId(), event.getComment()); // send confirmation getSessionModel().confirmArtifactReceipt(localUserId(), event.getUniqueId(), event.getVersionId(), localUserId(), currentDateTime()); // audit\fire event final Container postPublish = read(containerId); final ContainerDraft postPublishDraft = readDraft(containerId); final ContainerVersion postPublishVersion = readVersion(containerId, event.getVersionId()); auditContainerPublished(postPublish, postPublishDraft, postPublishVersion, event.getPublishedBy(), event.getPublishedTo(), event.getPublishedOn()); notifyContainerPublished(postPublish, postPublishDraft, postPublishVersion, remoteEventGenerator); } } catch (final Throwable t) { throw translateError(t); } }

1,113,782

public ServletOutputStream getOutputStream() { if (isWriterUsed) { throw new IllegalStateException("Unexpected internal error during import: " + "Target servlet called getOutputStream(), then getWriter()"); } isStreamUsed = true; bos = new ByteArrayOutputStream(); ServletOutputStream sos = new ServletOutputStream() { public void write(int b) throws IOException { bos.write(b); } }; return sos; }

public ServletOutputStream getOutputStream() { if (isWriterUsed) { throw new IllegalStateException("Unexpected internal error during import: " + "Target servlet called getOutputStream(), then getWriter()"); } isStreamUsed = true; if (bos == null) { bos = new ByteArrayOutputStream(); } ServletOutputStream sos = new ServletOutputStream() { public void write(int b) throws IOException { bos.write(b); } }; return sos; }

1,113,784

public PrintWriter getWriter() { if (isStreamUsed) { throw new IllegalStateException("Unexpected internal error during import: " + "Target servlet called getWriter(), then getOutputStream()"); } isWriterUsed = true; sw = new StringWriter(); return new PrintWriter(sw); }

public PrintWriter getWriter() { if (isStreamUsed) { throw new IllegalStateException("Unexpected internal error during import: " + "Target servlet called getWriter(), then getOutputStream()"); } isWriterUsed = true; if (sw == null) { sw = new StringWriter(); } return new PrintWriter(sw); }

1,113,785

private void initComponents() { javax.swing.JScrollPane contactsJScrollPane; javax.swing.JLabel eaJLabel; javax.swing.JButton inviteJButton; javax.swing.JButton searchJButton; eaJLabel = LabelFactory.create(getString("EmbeddedAssistance")); contactsJScrollPane = new javax.swing.JScrollPane(); contactsJList = ListFactory.create(); inviteJButton = ButtonFactory.create(getString("InviteButton")); searchJButton = ButtonFactory.create(getString("SearchButton")); removeJButton = ButtonFactory.create(getString("RemoveButton")); viewJButton = ButtonFactory.create(getString("ViewButton")); eaJLabel.setText("!Embedded Assistance!"); contactsModel = new DefaultListModel(); contactsJList.setModel(contactsModel); contactsJList.setCellRenderer(new ContactCellRenderer()); contactsJList.addListSelectionListener(new javax.swing.event.ListSelectionListener() { public void valueChanged(javax.swing.event.ListSelectionEvent e) { contactsJListValueChanged(e); } }); contactsJScrollPane.setViewportView(contactsJList); inviteJButton.setText("!Invite!"); inviteJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { inviteJButtonActionPerformed(e); } }); searchJButton.setText("!Search!"); searchJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { searchJButtonActionPerformed(e); } }); removeJButton.setText("!Remove!"); removeJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { removeJButtonActionPerformed(e); } }); viewJButton.setText("!View!"); viewJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { viewJButtonActionPerformed(e); } }); org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(this); this.setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(org.jdesktop.layout.GroupLayout.TRAILING, layout.createSequentialGroup() .addContainerGap() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.TRAILING) .add(org.jdesktop.layout.GroupLayout.LEADING, eaJLabel, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 398, Short.MAX_VALUE) .add(layout.createSequentialGroup() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(searchJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(inviteJButton)) .add(org.jdesktop.layout.GroupLayout.TRAILING, contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 313, Short.MAX_VALUE)) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(viewJButton) .add(removeJButton)))) .addContainerGap()) ); layout.setVerticalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .addContainerGap() .add(eaJLabel) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 146, Short.MAX_VALUE) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.BASELINE) .add(searchJButton) .add(inviteJButton))) .add(layout.createSequentialGroup() .add(viewJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(removeJButton))) .addContainerGap()) ); }// </editor-fold>//GEN-END:initComponents

private void initComponents() { javax.swing.JScrollPane contactsJScrollPane; javax.swing.JLabel eaJLabel; javax.swing.JButton inviteJButton; javax.swing.JButton searchJButton; eaJLabel = LabelFactory.create(getString("EmbeddedAssistance")); contactsJScrollPane = new javax.swing.JScrollPane(); contactsJList = ListFactory.create(); inviteJButton = ButtonFactory.create(getString("InviteButton")); searchJButton = ButtonFactory.create(getString("SearchButton")); removeJButton = ButtonFactory.create(getString("RemoveButton")); viewJButton = ButtonFactory.create(getString("ViewButton")); contactsModel = new DefaultListModel(); contactsJList.setModel(contactsModel); contactsJList.setCellRenderer(new ContactCellRenderer()); contactsJList.addListSelectionListener(new javax.swing.event.ListSelectionListener() { public void valueChanged(javax.swing.event.ListSelectionEvent e) { contactsJListValueChanged(e); } }); contactsJScrollPane.setViewportView(contactsJList); inviteJButton.setText("!Invite!"); inviteJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { inviteJButtonActionPerformed(e); } }); searchJButton.setText("!Search!"); searchJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { searchJButtonActionPerformed(e); } }); removeJButton.setText("!Remove!"); removeJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { removeJButtonActionPerformed(e); } }); viewJButton.setText("!View!"); viewJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { viewJButtonActionPerformed(e); } }); org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(this); this.setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(org.jdesktop.layout.GroupLayout.TRAILING, layout.createSequentialGroup() .addContainerGap() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.TRAILING) .add(org.jdesktop.layout.GroupLayout.LEADING, eaJLabel, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 398, Short.MAX_VALUE) .add(layout.createSequentialGroup() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(searchJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(inviteJButton)) .add(org.jdesktop.layout.GroupLayout.TRAILING, contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 313, Short.MAX_VALUE)) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(viewJButton) .add(removeJButton)))) .addContainerGap()) ); layout.setVerticalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .addContainerGap() .add(eaJLabel) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 146, Short.MAX_VALUE) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.BASELINE) .add(searchJButton) .add(inviteJButton))) .add(layout.createSequentialGroup() .add(viewJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(removeJButton))) .addContainerGap()) ); }// </editor-fold>//GEN-END:initComponents

1,113,786

private void initComponents() { javax.swing.JScrollPane contactsJScrollPane; javax.swing.JLabel eaJLabel; javax.swing.JButton inviteJButton; javax.swing.JButton searchJButton; eaJLabel = LabelFactory.create(getString("EmbeddedAssistance")); contactsJScrollPane = new javax.swing.JScrollPane(); contactsJList = ListFactory.create(); inviteJButton = ButtonFactory.create(getString("InviteButton")); searchJButton = ButtonFactory.create(getString("SearchButton")); removeJButton = ButtonFactory.create(getString("RemoveButton")); viewJButton = ButtonFactory.create(getString("ViewButton")); eaJLabel.setText("!Embedded Assistance!"); contactsModel = new DefaultListModel(); contactsJList.setModel(contactsModel); contactsJList.setCellRenderer(new ContactCellRenderer()); contactsJList.addListSelectionListener(new javax.swing.event.ListSelectionListener() { public void valueChanged(javax.swing.event.ListSelectionEvent e) { contactsJListValueChanged(e); } }); contactsJScrollPane.setViewportView(contactsJList); inviteJButton.setText("!Invite!"); inviteJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { inviteJButtonActionPerformed(e); } }); searchJButton.setText("!Search!"); searchJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { searchJButtonActionPerformed(e); } }); removeJButton.setText("!Remove!"); removeJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { removeJButtonActionPerformed(e); } }); viewJButton.setText("!View!"); viewJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { viewJButtonActionPerformed(e); } }); org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(this); this.setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(org.jdesktop.layout.GroupLayout.TRAILING, layout.createSequentialGroup() .addContainerGap() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.TRAILING) .add(org.jdesktop.layout.GroupLayout.LEADING, eaJLabel, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 398, Short.MAX_VALUE) .add(layout.createSequentialGroup() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(searchJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(inviteJButton)) .add(org.jdesktop.layout.GroupLayout.TRAILING, contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 313, Short.MAX_VALUE)) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(viewJButton) .add(removeJButton)))) .addContainerGap()) ); layout.setVerticalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .addContainerGap() .add(eaJLabel) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 146, Short.MAX_VALUE) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.BASELINE) .add(searchJButton) .add(inviteJButton))) .add(layout.createSequentialGroup() .add(viewJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(removeJButton))) .addContainerGap()) ); }// </editor-fold>//GEN-END:initComponents

private void initComponents() { javax.swing.JScrollPane contactsJScrollPane; javax.swing.JLabel eaJLabel; javax.swing.JButton inviteJButton; javax.swing.JButton searchJButton; eaJLabel = LabelFactory.create(getString("EmbeddedAssistance")); contactsJScrollPane = new javax.swing.JScrollPane(); contactsJList = ListFactory.create(); inviteJButton = ButtonFactory.create(getString("InviteButton")); searchJButton = ButtonFactory.create(getString("SearchButton")); removeJButton = ButtonFactory.create(getString("RemoveButton")); viewJButton = ButtonFactory.create(getString("ViewButton")); eaJLabel.setText("!Embedded Assistance!"); contactsModel = new DefaultListModel(); contactsJList.setModel(contactsModel); contactsJList.setCellRenderer(new ContactCellRenderer()); contactsJList.addListSelectionListener(new javax.swing.event.ListSelectionListener() { public void valueChanged(javax.swing.event.ListSelectionEvent e) { contactsJListValueChanged(e); } }); contactsJScrollPane.setViewportView(contactsJList); inviteJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { inviteJButtonActionPerformed(e); } }); searchJButton.setText("!Search!"); searchJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { searchJButtonActionPerformed(e); } }); removeJButton.setText("!Remove!"); removeJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { removeJButtonActionPerformed(e); } }); viewJButton.setText("!View!"); viewJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { viewJButtonActionPerformed(e); } }); org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(this); this.setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(org.jdesktop.layout.GroupLayout.TRAILING, layout.createSequentialGroup() .addContainerGap() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.TRAILING) .add(org.jdesktop.layout.GroupLayout.LEADING, eaJLabel, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 398, Short.MAX_VALUE) .add(layout.createSequentialGroup() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(searchJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(inviteJButton)) .add(org.jdesktop.layout.GroupLayout.TRAILING, contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 313, Short.MAX_VALUE)) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(viewJButton) .add(removeJButton)))) .addContainerGap()) ); layout.setVerticalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .addContainerGap() .add(eaJLabel) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 146, Short.MAX_VALUE) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.BASELINE) .add(searchJButton) .add(inviteJButton))) .add(layout.createSequentialGroup() .add(viewJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(removeJButton))) .addContainerGap()) ); }// </editor-fold>//GEN-END:initComponents

1,113,787

private void initComponents() { javax.swing.JScrollPane contactsJScrollPane; javax.swing.JLabel eaJLabel; javax.swing.JButton inviteJButton; javax.swing.JButton searchJButton; eaJLabel = LabelFactory.create(getString("EmbeddedAssistance")); contactsJScrollPane = new javax.swing.JScrollPane(); contactsJList = ListFactory.create(); inviteJButton = ButtonFactory.create(getString("InviteButton")); searchJButton = ButtonFactory.create(getString("SearchButton")); removeJButton = ButtonFactory.create(getString("RemoveButton")); viewJButton = ButtonFactory.create(getString("ViewButton")); eaJLabel.setText("!Embedded Assistance!"); contactsModel = new DefaultListModel(); contactsJList.setModel(contactsModel); contactsJList.setCellRenderer(new ContactCellRenderer()); contactsJList.addListSelectionListener(new javax.swing.event.ListSelectionListener() { public void valueChanged(javax.swing.event.ListSelectionEvent e) { contactsJListValueChanged(e); } }); contactsJScrollPane.setViewportView(contactsJList); inviteJButton.setText("!Invite!"); inviteJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { inviteJButtonActionPerformed(e); } }); searchJButton.setText("!Search!"); searchJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { searchJButtonActionPerformed(e); } }); removeJButton.setText("!Remove!"); removeJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { removeJButtonActionPerformed(e); } }); viewJButton.setText("!View!"); viewJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { viewJButtonActionPerformed(e); } }); org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(this); this.setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(org.jdesktop.layout.GroupLayout.TRAILING, layout.createSequentialGroup() .addContainerGap() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.TRAILING) .add(org.jdesktop.layout.GroupLayout.LEADING, eaJLabel, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 398, Short.MAX_VALUE) .add(layout.createSequentialGroup() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(searchJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(inviteJButton)) .add(org.jdesktop.layout.GroupLayout.TRAILING, contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 313, Short.MAX_VALUE)) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(viewJButton) .add(removeJButton)))) .addContainerGap()) ); layout.setVerticalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .addContainerGap() .add(eaJLabel) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 146, Short.MAX_VALUE) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.BASELINE) .add(searchJButton) .add(inviteJButton))) .add(layout.createSequentialGroup() .add(viewJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(removeJButton))) .addContainerGap()) ); }// </editor-fold>//GEN-END:initComponents

private void initComponents() { javax.swing.JScrollPane contactsJScrollPane; javax.swing.JLabel eaJLabel; javax.swing.JButton inviteJButton; javax.swing.JButton searchJButton; eaJLabel = LabelFactory.create(getString("EmbeddedAssistance")); contactsJScrollPane = new javax.swing.JScrollPane(); contactsJList = ListFactory.create(); inviteJButton = ButtonFactory.create(getString("InviteButton")); searchJButton = ButtonFactory.create(getString("SearchButton")); removeJButton = ButtonFactory.create(getString("RemoveButton")); viewJButton = ButtonFactory.create(getString("ViewButton")); eaJLabel.setText("!Embedded Assistance!"); contactsModel = new DefaultListModel(); contactsJList.setModel(contactsModel); contactsJList.setCellRenderer(new ContactCellRenderer()); contactsJList.addListSelectionListener(new javax.swing.event.ListSelectionListener() { public void valueChanged(javax.swing.event.ListSelectionEvent e) { contactsJListValueChanged(e); } }); contactsJScrollPane.setViewportView(contactsJList); inviteJButton.setText("!Invite!"); inviteJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { inviteJButtonActionPerformed(e); } }); searchJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { searchJButtonActionPerformed(e); } }); removeJButton.setText("!Remove!"); removeJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { removeJButtonActionPerformed(e); } }); viewJButton.setText("!View!"); viewJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { viewJButtonActionPerformed(e); } }); org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(this); this.setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(org.jdesktop.layout.GroupLayout.TRAILING, layout.createSequentialGroup() .addContainerGap() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.TRAILING) .add(org.jdesktop.layout.GroupLayout.LEADING, eaJLabel, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 398, Short.MAX_VALUE) .add(layout.createSequentialGroup() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(searchJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(inviteJButton)) .add(org.jdesktop.layout.GroupLayout.TRAILING, contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 313, Short.MAX_VALUE)) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(viewJButton) .add(removeJButton)))) .addContainerGap()) ); layout.setVerticalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .addContainerGap() .add(eaJLabel) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 146, Short.MAX_VALUE) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.BASELINE) .add(searchJButton) .add(inviteJButton))) .add(layout.createSequentialGroup() .add(viewJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(removeJButton))) .addContainerGap()) ); }// </editor-fold>//GEN-END:initComponents

1,113,788

private void initComponents() { javax.swing.JScrollPane contactsJScrollPane; javax.swing.JLabel eaJLabel; javax.swing.JButton inviteJButton; javax.swing.JButton searchJButton; eaJLabel = LabelFactory.create(getString("EmbeddedAssistance")); contactsJScrollPane = new javax.swing.JScrollPane(); contactsJList = ListFactory.create(); inviteJButton = ButtonFactory.create(getString("InviteButton")); searchJButton = ButtonFactory.create(getString("SearchButton")); removeJButton = ButtonFactory.create(getString("RemoveButton")); viewJButton = ButtonFactory.create(getString("ViewButton")); eaJLabel.setText("!Embedded Assistance!"); contactsModel = new DefaultListModel(); contactsJList.setModel(contactsModel); contactsJList.setCellRenderer(new ContactCellRenderer()); contactsJList.addListSelectionListener(new javax.swing.event.ListSelectionListener() { public void valueChanged(javax.swing.event.ListSelectionEvent e) { contactsJListValueChanged(e); } }); contactsJScrollPane.setViewportView(contactsJList); inviteJButton.setText("!Invite!"); inviteJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { inviteJButtonActionPerformed(e); } }); searchJButton.setText("!Search!"); searchJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { searchJButtonActionPerformed(e); } }); removeJButton.setText("!Remove!"); removeJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { removeJButtonActionPerformed(e); } }); viewJButton.setText("!View!"); viewJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { viewJButtonActionPerformed(e); } }); org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(this); this.setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(org.jdesktop.layout.GroupLayout.TRAILING, layout.createSequentialGroup() .addContainerGap() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.TRAILING) .add(org.jdesktop.layout.GroupLayout.LEADING, eaJLabel, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 398, Short.MAX_VALUE) .add(layout.createSequentialGroup() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(searchJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(inviteJButton)) .add(org.jdesktop.layout.GroupLayout.TRAILING, contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 313, Short.MAX_VALUE)) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(viewJButton) .add(removeJButton)))) .addContainerGap()) ); layout.setVerticalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .addContainerGap() .add(eaJLabel) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 146, Short.MAX_VALUE) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.BASELINE) .add(searchJButton) .add(inviteJButton))) .add(layout.createSequentialGroup() .add(viewJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(removeJButton))) .addContainerGap()) ); }// </editor-fold>//GEN-END:initComponents

private void initComponents() { javax.swing.JScrollPane contactsJScrollPane; javax.swing.JLabel eaJLabel; javax.swing.JButton inviteJButton; javax.swing.JButton searchJButton; eaJLabel = LabelFactory.create(getString("EmbeddedAssistance")); contactsJScrollPane = new javax.swing.JScrollPane(); contactsJList = ListFactory.create(); inviteJButton = ButtonFactory.create(getString("InviteButton")); searchJButton = ButtonFactory.create(getString("SearchButton")); removeJButton = ButtonFactory.create(getString("RemoveButton")); viewJButton = ButtonFactory.create(getString("ViewButton")); eaJLabel.setText("!Embedded Assistance!"); contactsModel = new DefaultListModel(); contactsJList.setModel(contactsModel); contactsJList.setCellRenderer(new ContactCellRenderer()); contactsJList.addListSelectionListener(new javax.swing.event.ListSelectionListener() { public void valueChanged(javax.swing.event.ListSelectionEvent e) { contactsJListValueChanged(e); } }); contactsJScrollPane.setViewportView(contactsJList); inviteJButton.setText("!Invite!"); inviteJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { inviteJButtonActionPerformed(e); } }); searchJButton.setText("!Search!"); searchJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { searchJButtonActionPerformed(e); } }); removeJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { removeJButtonActionPerformed(e); } }); viewJButton.setText("!View!"); viewJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { viewJButtonActionPerformed(e); } }); org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(this); this.setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(org.jdesktop.layout.GroupLayout.TRAILING, layout.createSequentialGroup() .addContainerGap() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.TRAILING) .add(org.jdesktop.layout.GroupLayout.LEADING, eaJLabel, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 398, Short.MAX_VALUE) .add(layout.createSequentialGroup() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(searchJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(inviteJButton)) .add(org.jdesktop.layout.GroupLayout.TRAILING, contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 313, Short.MAX_VALUE)) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(viewJButton) .add(removeJButton)))) .addContainerGap()) ); layout.setVerticalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .addContainerGap() .add(eaJLabel) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 146, Short.MAX_VALUE) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.BASELINE) .add(searchJButton) .add(inviteJButton))) .add(layout.createSequentialGroup() .add(viewJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(removeJButton))) .addContainerGap()) ); }// </editor-fold>//GEN-END:initComponents

1,113,789

private void initComponents() { javax.swing.JScrollPane contactsJScrollPane; javax.swing.JLabel eaJLabel; javax.swing.JButton inviteJButton; javax.swing.JButton searchJButton; eaJLabel = LabelFactory.create(getString("EmbeddedAssistance")); contactsJScrollPane = new javax.swing.JScrollPane(); contactsJList = ListFactory.create(); inviteJButton = ButtonFactory.create(getString("InviteButton")); searchJButton = ButtonFactory.create(getString("SearchButton")); removeJButton = ButtonFactory.create(getString("RemoveButton")); viewJButton = ButtonFactory.create(getString("ViewButton")); eaJLabel.setText("!Embedded Assistance!"); contactsModel = new DefaultListModel(); contactsJList.setModel(contactsModel); contactsJList.setCellRenderer(new ContactCellRenderer()); contactsJList.addListSelectionListener(new javax.swing.event.ListSelectionListener() { public void valueChanged(javax.swing.event.ListSelectionEvent e) { contactsJListValueChanged(e); } }); contactsJScrollPane.setViewportView(contactsJList); inviteJButton.setText("!Invite!"); inviteJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { inviteJButtonActionPerformed(e); } }); searchJButton.setText("!Search!"); searchJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { searchJButtonActionPerformed(e); } }); removeJButton.setText("!Remove!"); removeJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { removeJButtonActionPerformed(e); } }); viewJButton.setText("!View!"); viewJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { viewJButtonActionPerformed(e); } }); org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(this); this.setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(org.jdesktop.layout.GroupLayout.TRAILING, layout.createSequentialGroup() .addContainerGap() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.TRAILING) .add(org.jdesktop.layout.GroupLayout.LEADING, eaJLabel, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 398, Short.MAX_VALUE) .add(layout.createSequentialGroup() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(searchJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(inviteJButton)) .add(org.jdesktop.layout.GroupLayout.TRAILING, contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 313, Short.MAX_VALUE)) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(viewJButton) .add(removeJButton)))) .addContainerGap()) ); layout.setVerticalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .addContainerGap() .add(eaJLabel) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 146, Short.MAX_VALUE) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.BASELINE) .add(searchJButton) .add(inviteJButton))) .add(layout.createSequentialGroup() .add(viewJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(removeJButton))) .addContainerGap()) ); }// </editor-fold>//GEN-END:initComponents

private void initComponents() { javax.swing.JScrollPane contactsJScrollPane; javax.swing.JLabel eaJLabel; javax.swing.JButton inviteJButton; javax.swing.JButton searchJButton; eaJLabel = LabelFactory.create(getString("EmbeddedAssistance")); contactsJScrollPane = new javax.swing.JScrollPane(); contactsJList = ListFactory.create(); inviteJButton = ButtonFactory.create(getString("InviteButton")); searchJButton = ButtonFactory.create(getString("SearchButton")); removeJButton = ButtonFactory.create(getString("RemoveButton")); viewJButton = ButtonFactory.create(getString("ViewButton")); eaJLabel.setText("!Embedded Assistance!"); contactsModel = new DefaultListModel(); contactsJList.setModel(contactsModel); contactsJList.setCellRenderer(new ContactCellRenderer()); contactsJList.addListSelectionListener(new javax.swing.event.ListSelectionListener() { public void valueChanged(javax.swing.event.ListSelectionEvent e) { contactsJListValueChanged(e); } }); contactsJScrollPane.setViewportView(contactsJList); inviteJButton.setText("!Invite!"); inviteJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { inviteJButtonActionPerformed(e); } }); searchJButton.setText("!Search!"); searchJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { searchJButtonActionPerformed(e); } }); removeJButton.setText("!Remove!"); removeJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { removeJButtonActionPerformed(e); } }); viewJButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent e) { viewJButtonActionPerformed(e); } }); org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(this); this.setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(org.jdesktop.layout.GroupLayout.TRAILING, layout.createSequentialGroup() .addContainerGap() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.TRAILING) .add(org.jdesktop.layout.GroupLayout.LEADING, eaJLabel, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 398, Short.MAX_VALUE) .add(layout.createSequentialGroup() .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(searchJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(inviteJButton)) .add(org.jdesktop.layout.GroupLayout.TRAILING, contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 313, Short.MAX_VALUE)) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(viewJButton) .add(removeJButton)))) .addContainerGap()) ); layout.setVerticalGroup( layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .addContainerGap() .add(eaJLabel) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING) .add(layout.createSequentialGroup() .add(contactsJScrollPane, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 146, Short.MAX_VALUE) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.BASELINE) .add(searchJButton) .add(inviteJButton))) .add(layout.createSequentialGroup() .add(viewJButton) .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED) .add(removeJButton))) .addContainerGap()) ); }// </editor-fold>//GEN-END:initComponents

1,113,790

List<DocumentVersion> readArchiveDocumentVersions(final JabberId userId, final UUID uniqueId, final Long versionId, final UUID documentUniqueId) { logApiId(); logVariable("userId", userId); logVariable("uniqueId", uniqueId); logVariable("versionId", versionId); logVariable("documentUniqueId", documentUniqueId); try { assertIsAuthenticatedUser(userId); return getArchiveModel().getDocumentReader(userId, uniqueId, versionId) .readVersions(documentUniqueId); } catch (final Throwable t) { throw translateError(t); } }

1,113,791

List<DocumentVersion> readArchiveDocumentVersions(final JabberId userId, final UUID uniqueId, final Long versionId, final UUID documentUniqueId) { logApiId(); logVariable("userId", userId); logVariable("uniqueId", uniqueId); logVariable("versionId", versionId); logVariable("documentUniqueId", documentUniqueId); try { assertIsAuthenticatedUser(userId); return getArchiveModel().getDocumentReader(userId, uniqueId, versionId) .readVersions(documentUniqueId); } catch (final Throwable t) { throw translateError(t); } }

List<DocumentVersion> readArchiveDocumentVersions(final JabberId userId, final UUID uniqueId, final Long versionId, final UUID documentUniqueId) { logApiId(); logVariable("userId", userId); logVariable("uniqueId", uniqueId); logVariable("versionId", versionId); try { assertIsAuthenticatedUser(userId); return getArchiveModel().getDocumentReader(userId, uniqueId, versionId) .readVersions(documentUniqueId); } catch (final Throwable t) { throw translateError(t); } }

1,113,792

List<DocumentVersion> readArchiveDocumentVersions(final JabberId userId, final UUID uniqueId, final Long versionId, final UUID documentUniqueId) { logApiId(); logVariable("userId", userId); logVariable("uniqueId", uniqueId); logVariable("versionId", versionId); logVariable("documentUniqueId", documentUniqueId); try { assertIsAuthenticatedUser(userId); return getArchiveModel().getDocumentReader(userId, uniqueId, versionId) .readVersions(documentUniqueId); } catch (final Throwable t) { throw translateError(t); } }

List<DocumentVersion> readArchiveDocumentVersions(final JabberId userId, final UUID uniqueId, final Long versionId, final UUID documentUniqueId) { logApiId(); logVariable("userId", userId); logVariable("uniqueId", uniqueId); logVariable("versionId", versionId); logVariable("documentUniqueId", documentUniqueId); try { assertIsAuthenticatedUser(userId); return getArchiveModel().getDocumentReader(userId, uniqueId, versionId) .readVersions(null); } catch (final Throwable t) { throw translateError(t); } }

1,113,793

List<DocumentVersion> readBackupDocumentVersions(final JabberId userId, final UUID uniqueId, final Long versionId, final UUID documentUniqueId) { logApiId(); logVariable("userId", userId); logVariable("uniqueId", uniqueId); logVariable("versionId", versionId); logVariable("documentUniqueId", documentUniqueId); try { assertIsAuthenticatedUser(userId); return getBackupModel().getDocumentReader(userId, uniqueId, versionId) .readVersions(documentUniqueId); } catch (final Throwable t) { throw translateError(t); } }

1,113,794

List<DocumentVersion> readBackupDocumentVersions(final JabberId userId, final UUID uniqueId, final Long versionId, final UUID documentUniqueId) { logApiId(); logVariable("userId", userId); logVariable("uniqueId", uniqueId); logVariable("versionId", versionId); logVariable("documentUniqueId", documentUniqueId); try { assertIsAuthenticatedUser(userId); return getBackupModel().getDocumentReader(userId, uniqueId, versionId) .readVersions(documentUniqueId); } catch (final Throwable t) { throw translateError(t); } }

List<DocumentVersion> readBackupDocumentVersions(final JabberId userId, final UUID uniqueId, final Long versionId, final UUID documentUniqueId) { logApiId(); logVariable("userId", userId); logVariable("uniqueId", uniqueId); logVariable("versionId", versionId); try { assertIsAuthenticatedUser(userId); return getBackupModel().getDocumentReader(userId, uniqueId, versionId) .readVersions(documentUniqueId); } catch (final Throwable t) { throw translateError(t); } }

1,113,795

List<DocumentVersion> readBackupDocumentVersions(final JabberId userId, final UUID uniqueId, final Long versionId, final UUID documentUniqueId) { logApiId(); logVariable("userId", userId); logVariable("uniqueId", uniqueId); logVariable("versionId", versionId); logVariable("documentUniqueId", documentUniqueId); try { assertIsAuthenticatedUser(userId); return getBackupModel().getDocumentReader(userId, uniqueId, versionId) .readVersions(documentUniqueId); } catch (final Throwable t) { throw translateError(t); } }

List<DocumentVersion> readBackupDocumentVersions(final JabberId userId, final UUID uniqueId, final Long versionId, final UUID documentUniqueId) { logApiId(); logVariable("userId", userId); logVariable("uniqueId", uniqueId); logVariable("versionId", versionId); logVariable("documentUniqueId", documentUniqueId); try { assertIsAuthenticatedUser(userId); return getBackupModel().getDocumentReader(userId, uniqueId, versionId) .readVersions(null); } catch (final Throwable t) { throw translateError(t); } }

1,113,796

public void processPacket(final Packet packet) { logger.logInfo("Remote event {0}.", packet.getClass().getName()); try { eventHandler.handleEvent((U) packet); } catch (final Throwable t) { throw translateError(t); } }

public void processPacket(final Packet packet) { try { eventHandler.handleEvent((U) packet); } catch (final Throwable t) { throw translateError(t); } }

1,113,797

public Project get(final UUID id) throws FileNotFoundException, IOException { logger.info("get(UUID)"); logger.debug(id); final Index index = readIndex(getIndexXmlFile()); final File xmlFile = index.lookupXmlFile(id); if(null == xmlFile) { return null; } else { return readProject(xmlFile); } }

1,113,799

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

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

1,113,800

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

1,113,801

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 File getXmlFile(final Document document) 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)); } }

1,113,802

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)); } }

1,113,803

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 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(document, fillInStack(document)); } }

1,113,804

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

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

1,113,805

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

1,113,806

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

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

1,113,807

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

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

1,113,808

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

1,113,809

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); }

private void setInfoText(final HistoryItem historyItem) { final Object[] arguments; final String infoText; switch(historyItem.getEvent()) { case CLOSE: case CREATE: infoText = getString("Info.CREATE"); 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); }

1,113,810

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); }

private void setInfoText(final HistoryItem historyItem) { final Object[] arguments; final String infoText; switch(historyItem.getEvent()) { case CLOSE: case CREATE: infoText = ""; break; case RECEIVE: 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); }

1,113,811

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); }

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.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); 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); }

1,113,812

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); }

1,113,813

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); }

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.SEND_KEY", new Object[] {ModelUtil.getName(skhi.getSentTo())}); break; default: infoText = null; Assert.assertUnreachable("Unknown history item event: " + historyItem.getEvent()); } infoJLabel.setText(infoText); }

1,113,814

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

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

1,113,815

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

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

1,113,816

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"); }

1,113,817

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()); }

private void configureServerHTMLAppender( final Properties log4jProperties, final File log4jDirectory) { log4jProperties.setProperty("log4j.appender.serverHTML", "org.apache.log4j.RollingFileAppender"); log4jProperties.setProperty("log4j.appender.serverHTML.MaxFileSize", "512KB"); 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()); }

1,113,818

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; }

1,113,819

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 ContainerDraft createFirstDraft(final Long containerId, final TeamMember owner) { 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; }

1,113,820

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 ContainerDraft createFirstDraft(final Long containerId, final TeamMember teamMember) { final ContainerDraft draft = new ContainerDraft(); draft.setContainerId(containerId); draft.setOwner(owner); containerIO.createDraft(draft); // fire draft event final Container postCreation = read(containerId); final ContainerDraft postCreationDraft = readDraft(containerId); notifyDraftCreated(postCreation, postCreationDraft, localEventGenerator); return postCreationDraft; }

1,113,821

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); }

private void deleteLocal(final Long containerId) { // 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); }

1,113,822

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); } }

1,113,823

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); } }

1,113,824

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 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(uniqueId); 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); } }

1,113,825

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 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(uniqueId); 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); } }

1,113,826

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 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, versionId); 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); } }

1,113,827

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 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(), versionId); } 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); } }

1,113,828

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 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(), versionId, 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); } }

1,113,829

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 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(name); 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); } }

1,113,830

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 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(uniqueId); 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); } }

1,113,831

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 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(), versionId, 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); } }

1,113,832

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); } }

1,113,833

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); } }

1,113,834

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); } }

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, final JabberId sentBy, final Calendar sentOn) { 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); } }

1,113,835

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); } }

1,113,836

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); } }

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(uniqueId); 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); } }

1,113,837

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); } }

1,113,838

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); } }

1,113,839

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); } }

1,113,840

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); } }

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(name); 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); } }

1,113,841

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); } }

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(uniqueId); 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); } }

1,113,842

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); } }

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(), versionId, 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); } }

1,113,843

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); } }

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); } }

1,113,844

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(); } }

1,113,845

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

1,113,846

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

1,113,847

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; }

1,113,849

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; }

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 + ")."); } }

1,113,850

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); } }

1,113,851

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"); } }

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); } else 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"); } }

1,113,852

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); } }

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(final UnauthorizedException ux) { logger.error("requestKey(Artifact)", ux); throw ParityErrorTranslator.translate(ux); } catch(RuntimeException rx) { logger.error("requestKey(Artifact)", rx); throw ParityErrorTranslator.translate(rx); } }

1,113,854

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); } }

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(final RuntimeException rx) { logger.error("requestKey(Artifact)", rx); throw ParityErrorTranslator.translate(rx); } }

1,113,855

public CodebaseTestCase() {super();}

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

1,113,856

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 void containerDeleted(ContainerEvent e) { didNotify = Boolean.TRUE; assertTrue(NAME + " [EVENT GENERATED IS NOT LOCAL]", e.isLocal()); assertTrue(NAME + " [EVENT GENERATED IS REMOTE]", !e.isRemote()); assertNotNull(NAME + " EVENT CONTAINER IS 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()); }

1,113,857

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; } }; }

1,113,858

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

1,113,859

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(); } }

1,113,860

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(); } }

public void deleteTeamRel(final Long artifactId, final Long userId) throws HypersonicException { final Session session = openSession(); try { final Integer rowCount = readTeamRelCount(session, artifactId); session.prepareStatement(SQL_DELETE_TEAM_REL_BY_ARTIFACT); 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(); } }

1,113,861

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(); } }

1,113,862

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(); } }

public User read(final JabberId jabberId) { 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(); } }

1,113,864

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(); } }

1,113,865

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

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

1,113,866