public static void runTestLifeCycle(
AsyncTaskService client, Map<String, User> users, Map<String, Group> groups) {
Map<String, Object> vars = fillVariables(users, groups);
// One potential owner, should go straight to state Reserved
String str =
"(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { workItemId = 1 } ), ";
str +=
"peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba']], }),";
// str += "descriptions = [ new I18NText( 'en-UK', 'This is my description')], ";
// str += "subjects = [ new I18NText( 'en-UK', 'This is my subject')], ";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = (Task) eval(new StringReader(str), vars);
client.addTask(task, null, addTaskResponseHandler);
long taskId = addTaskResponseHandler.getTaskId();
EventKey key = new TaskEventKey(TaskCompletedEvent.class, taskId);
BlockingEventResponseHandler handler = new BlockingEventResponseHandler();
client.registerForEvent(key, false, handler);
BlockingTaskSummaryResponseHandler taskSummaryResponseHandler =
new BlockingTaskSummaryResponseHandler();
client.getTasksAssignedAsPotentialOwner(
users.get("bobba").getId(), "en-UK", taskSummaryResponseHandler);
List<TaskSummary> tasks = taskSummaryResponseHandler.getResults();
assertEquals(1, tasks.size());
assertEquals(Status.Reserved, tasks.get(0).getStatus());
BlockingTaskOperationResponseHandler responseHandler =
new BlockingTaskOperationResponseHandler();
client.start(taskId, users.get("bobba").getId(), responseHandler);
taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
client.getTasksAssignedAsPotentialOwner(
users.get("bobba").getId(), "en-UK", taskSummaryResponseHandler);
tasks = taskSummaryResponseHandler.getResults();
assertEquals(1, tasks.size());
assertEquals(Status.InProgress, tasks.get(0).getStatus());
responseHandler = new BlockingTaskOperationResponseHandler();
client.complete(taskId, users.get("bobba").getId(), null, responseHandler);
taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
client.getTasksAssignedAsPotentialOwner(
users.get("bobba").getId(), "en-UK", taskSummaryResponseHandler);
tasks = taskSummaryResponseHandler.getResults();
assertEquals(0, tasks.size());
Payload payload = handler.getPayload();
TaskCompletedEvent event = (TaskCompletedEvent) payload.get();
assertNotNull(event);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask(taskId, getTaskResponseHandler);
Task task1 = getTaskResponseHandler.getTask();
assertEquals(Status.Completed, task1.getTaskData().getStatus());
}
/**
* Tests two consecutive connections to see how it works.
*
* @throws Exception
*/
public void testDoubleUsage() throws Exception {
while (!server.isRunning()) {
Thread.sleep(100); // waits until the server finishes the startup
}
AsyncTaskService client = createTaskClient();
client.connect();
Task task = new Task();
List<I18NText> names1 = new ArrayList<I18NText>();
I18NText text1 = new I18NText("en-UK", "tarea1");
names1.add(text1);
task.setNames(names1);
TaskData taskData = new TaskData();
taskData.setStatus(Status.Created);
taskData.setCreatedBy(new User("usr0"));
taskData.setActualOwner(new User("usr0"));
task.setTaskData(taskData);
ContentData data = new ContentData();
BlockingAddTaskResponseHandler addTaskHandler = new BlockingAddTaskResponseHandler();
client.addTask(task, data, addTaskHandler);
long taskId = addTaskHandler.getTaskId();
client.disconnect();
client.connect();
assertTrue("taskId debe ser un valor mayor a cero", taskId > 0);
Task task2 = new Task();
List<I18NText> names2 = new ArrayList<I18NText>();
I18NText text2 = new I18NText("en-UK", "tarea1");
names2.add(text2);
task2.setNames(names2);
TaskData taskData2 = new TaskData();
taskData2.setStatus(Status.Created);
taskData2.setCreatedBy(new User("usr0"));
taskData2.setActualOwner(new User("usr0"));
task2.setTaskData(taskData2);
ContentData data2 = new ContentData();
BlockingAddTaskResponseHandler addTaskHandler2 = new BlockingAddTaskResponseHandler();
client.addTask(task2, data2, addTaskHandler2);
long taskId2 = addTaskHandler2.getTaskId();
assertTrue("taskId2 debe ser un valor mayor a cero", taskId2 > 0);
assertNotSame("taskId y taskId2 deben ser distintos", taskId, taskId2);
client.disconnect();
}
public void testAddRemoveComment() {
Map vars = new HashMap();
vars.put("users", users);
vars.put("groups", groups);
vars.put("now", new Date());
String str =
"(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { createdOn = now, activationTime = now}), ";
str += "deadlines = new Deadlines(),";
str += "delegation = new Delegation(),";
str += "peopleAssignments = new PeopleAssignments(),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = (Task) eval(new StringReader(str), vars);
client.addTask(task, null, addTaskResponseHandler);
long taskId = addTaskResponseHandler.getTaskId();
Comment comment = new Comment();
Date addedAt = new Date(System.currentTimeMillis());
comment.setAddedAt(addedAt);
comment.setAddedBy(users.get("luke"));
comment.setText("This is my comment1!!!!!");
BlockingAddCommentResponseHandler addCommentResponseHandler =
new BlockingAddCommentResponseHandler();
client.addComment(taskId, comment, addCommentResponseHandler);
assertTrue(addCommentResponseHandler.getCommentId() != comment.getId());
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask(taskId, getTaskResponseHandler);
Task task1 = getTaskResponseHandler.getTask();
assertNotSame(task, task1);
assertFalse(task.equals(task1));
List<Comment> comments1 = task1.getTaskData().getComments();
assertEquals(1, comments1.size());
Comment returnedComment = comments1.get(0);
assertEquals("This is my comment1!!!!!", returnedComment.getText());
assertEquals(addedAt, returnedComment.getAddedAt());
assertEquals(users.get("luke"), returnedComment.getAddedBy());
assertEquals((long) addCommentResponseHandler.getCommentId(), (long) returnedComment.getId());
// Make the same as the returned tasks, so we can test equals
task.getTaskData().setComments(comments1);
task.getTaskData().setStatus(Status.Created);
assertEquals(task, task1);
// test we can have multiple comments
comment = new Comment();
addedAt = new Date(System.currentTimeMillis());
comment.setAddedAt(addedAt);
comment.setAddedBy(users.get("tony"));
comment.setText("This is my comment2!!!!!");
addCommentResponseHandler = new BlockingAddCommentResponseHandler();
client.addComment(taskId, comment, addCommentResponseHandler);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask(taskId, getTaskResponseHandler);
task1 = getTaskResponseHandler.getTask();
List<Comment> comments2 = task1.getTaskData().getComments();
assertEquals(2, comments2.size());
// make two collections the same and compare
comments1.add(comment);
assertTrue(CollectionUtils.equals(comments1, comments2));
BlockingDeleteCommentResponseHandler deleteCommentResponseHandler =
new BlockingDeleteCommentResponseHandler();
client.deleteComment(
taskId, addCommentResponseHandler.getCommentId(), deleteCommentResponseHandler);
deleteCommentResponseHandler.waitTillDone(3000);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask(taskId, getTaskResponseHandler);
task1 = getTaskResponseHandler.getTask();
comments2 = task1.getTaskData().getComments();
assertEquals(1, comments2.size());
assertEquals("This is my comment1!!!!!", comments2.get(0).getText());
}
public void testAddRemoveAttachment() throws Exception {
Map vars = new HashMap();
vars.put("users", users);
vars.put("groups", groups);
vars.put("now", new Date());
String str =
"(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { createdOn = now, activationTime = now}), ";
str += "deadlines = new Deadlines(),";
str += "delegation = new Delegation(),";
str += "peopleAssignments = new PeopleAssignments(),";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = (Task) eval(new StringReader(str), vars);
client.addTask(task, null, addTaskResponseHandler);
long taskId = addTaskResponseHandler.getTaskId();
Attachment attachment = new Attachment();
Date attachedAt = new Date(System.currentTimeMillis());
attachment.setAttachedAt(attachedAt);
attachment.setAttachedBy(users.get("luke"));
attachment.setName("file1.txt");
attachment.setAccessType(AccessType.Inline);
attachment.setContentType("txt");
byte[] bytes = "Ths is my attachment text1".getBytes();
Content content = new Content();
content.setContent(bytes);
BlockingAddAttachmentResponseHandler addAttachmentResponseHandler =
new BlockingAddAttachmentResponseHandler();
client.addAttachment(taskId, attachment, content, addAttachmentResponseHandler);
assertTrue(addAttachmentResponseHandler.getAttachmentId() != attachment.getId());
assertTrue(addAttachmentResponseHandler.getContentId() != attachment.getAttachmentContentId());
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask(taskId, getTaskResponseHandler);
Task task1 = getTaskResponseHandler.getTask();
assertNotSame(task, task1);
assertFalse(task.equals(task1));
List<Attachment> attachments1 = task1.getTaskData().getAttachments();
assertEquals(1, attachments1.size());
Attachment returnedAttachment = attachments1.get(0);
assertEquals(attachedAt, returnedAttachment.getAttachedAt());
assertEquals(users.get("luke"), returnedAttachment.getAttachedBy());
assertEquals(AccessType.Inline, returnedAttachment.getAccessType());
assertEquals("txt", returnedAttachment.getContentType());
assertEquals("file1.txt", returnedAttachment.getName());
assertEquals(bytes.length, returnedAttachment.getSize());
assertEquals(
(long) addAttachmentResponseHandler.getAttachmentId(), (long) returnedAttachment.getId());
assertEquals(
(long) addAttachmentResponseHandler.getContentId(),
(long) returnedAttachment.getAttachmentContentId());
// Make the same as the returned tasks, so we can test equals
task.getTaskData().setAttachments(attachments1);
task.getTaskData().setStatus(Status.Created);
assertEquals(task, task1);
BlockingGetContentResponseHandler getResponseHandler = new BlockingGetContentResponseHandler();
client.getContent(returnedAttachment.getAttachmentContentId(), getResponseHandler);
content = getResponseHandler.getContent();
assertEquals("Ths is my attachment text1", new String(content.getContent()));
// test we can have multiple attachments
attachment = new Attachment();
attachedAt = new Date(System.currentTimeMillis());
attachment.setAttachedAt(attachedAt);
attachment.setAttachedBy(users.get("tony"));
attachment.setName("file2.txt");
attachment.setAccessType(AccessType.Inline);
attachment.setContentType("txt");
bytes = "Ths is my attachment text2".getBytes();
content = new Content();
content.setContent(bytes);
addAttachmentResponseHandler = new BlockingAddAttachmentResponseHandler();
client.addAttachment(taskId, attachment, content, addAttachmentResponseHandler);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask(taskId, getTaskResponseHandler);
task1 = getTaskResponseHandler.getTask();
assertNotSame(task, task1);
assertFalse(task.equals(task1));
List<Attachment> attachments2 = task1.getTaskData().getAttachments();
assertEquals(2, attachments2.size());
getResponseHandler = new BlockingGetContentResponseHandler();
client.getContent(addAttachmentResponseHandler.getContentId(), getResponseHandler);
content = getResponseHandler.getContent();
assertEquals("Ths is my attachment text2", new String(content.getContent()));
// make two collections the same and compare
attachment.setSize(26);
attachment.setAttachmentContentId(addAttachmentResponseHandler.getContentId());
attachments1.add(attachment);
assertTrue(CollectionUtils.equals(attachments2, attachments1));
BlockingDeleteAttachmentResponseHandler deleteCommentResponseHandler =
new BlockingDeleteAttachmentResponseHandler();
client.deleteAttachment(
taskId,
addAttachmentResponseHandler.getAttachmentId(),
addAttachmentResponseHandler.getContentId(),
deleteCommentResponseHandler);
deleteCommentResponseHandler.waitTillDone(3000);
Thread.sleep(3000);
getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask(taskId, getTaskResponseHandler);
task1 = getTaskResponseHandler.getTask();
attachments2 = task1.getTaskData().getAttachments();
assertEquals(1, attachments2.size());
assertEquals("file1.txt", attachments2.get(0).getName());
}
public static void runTestLifeCycleMultipleTasks(
AsyncTaskService client, Map<String, User> users, Map<String, Group> groups) {
Map<String, Object> vars = fillVariables(users, groups);
// One potential owner, should go straight to state Reserved
String str =
"(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { workItemId = 1 } ), ";
str +=
"peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba']], }),";
str += "descriptions = [ new I18NText( 'en-UK', 'This is my description')], ";
str += "subjects = [ new I18NText( 'en-UK', 'This is my subject')], ";
str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
// First task
// In own scope to make sure that no objects in scope can be used in second task
long taskId = 0;
BlockingEventResponseHandler handler = new BlockingEventResponseHandler();
{
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = (Task) eval(new StringReader(str), vars);
client.addTask(task, null, addTaskResponseHandler);
taskId = addTaskResponseHandler.getTaskId();
assertTrue(taskId != 0);
EventKey key = new TaskEventKey(TaskCompletedEvent.class, taskId);
client.registerForEvent(key, false, handler);
BlockingTaskSummaryResponseHandler taskSummaryResponseHandler =
new BlockingTaskSummaryResponseHandler();
client.getTasksAssignedAsPotentialOwner(
users.get("bobba").getId(), "en-UK", taskSummaryResponseHandler);
List<TaskSummary> tasks = taskSummaryResponseHandler.getResults();
assertEquals(1, tasks.size());
assertEquals(Status.Reserved, tasks.get(0).getStatus());
BlockingTaskOperationResponseHandler responseHandler =
new BlockingTaskOperationResponseHandler();
client.start(taskId, users.get("bobba").getId(), responseHandler);
taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
client.getTasksAssignedAsPotentialOwner(
users.get("bobba").getId(), "en-UK", taskSummaryResponseHandler);
tasks = taskSummaryResponseHandler.getResults();
assertEquals(1, tasks.size());
assertEquals(Status.InProgress, tasks.get(0).getStatus());
}
// Second task
// In own scope to make sure that no objects in scope can be used elsewhere
long taskId2 = 0;
BlockingEventResponseHandler handler2 = new BlockingEventResponseHandler();
{
BlockingAddTaskResponseHandler addTaskResponseHandler2 = new BlockingAddTaskResponseHandler();
Task task2 = (Task) eval(new StringReader(str), vars);
client.addTask(task2, null, addTaskResponseHandler2);
taskId2 = addTaskResponseHandler2.getTaskId();
assertTrue(taskId2 != 0);
assertTrue("Tasks should have different ids.", taskId != taskId2);
EventKey key2 = new TaskEventKey(TaskCompletedEvent.class, taskId2);
client.registerForEvent(key2, false, handler2);
BlockingTaskSummaryResponseHandler taskSummaryResponseHandler =
new BlockingTaskSummaryResponseHandler();
client.getTasksAssignedAsPotentialOwner(
users.get("bobba").getId(), "en-UK", taskSummaryResponseHandler);
List<TaskSummary> tasks = taskSummaryResponseHandler.getResults();
assertEquals(2, tasks.size());
BlockingTaskOperationResponseHandler responseHandler =
new BlockingTaskOperationResponseHandler();
client.complete(taskId, users.get("bobba").getId(), null, responseHandler);
responseHandler = new BlockingTaskOperationResponseHandler();
client.start(taskId2, users.get("bobba").getId(), responseHandler);
taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
client.getTasksAssignedAsPotentialOwner(
users.get("bobba").getId(), "en-UK", taskSummaryResponseHandler);
tasks = taskSummaryResponseHandler.getResults();
assertEquals(1, tasks.size());
}
Payload payload = handler.getPayload();
TaskCompletedEvent event = (TaskCompletedEvent) payload.get();
assertNotNull(event);
BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
client.getTask(taskId, getTaskResponseHandler);
Task task = getTaskResponseHandler.getTask();
assertEquals(Status.Completed, task.getTaskData().getStatus());
BlockingTaskOperationResponseHandler responseHandler =
new BlockingTaskOperationResponseHandler();
client.complete(taskId2, users.get("bobba").getId(), null, responseHandler);
payload = handler2.getPayload();
event = (TaskCompletedEvent) payload.get();
assertNotNull(event);
BlockingGetTaskResponseHandler getTaskResponseHandler2 = new BlockingGetTaskResponseHandler();
client.getTask(taskId2, getTaskResponseHandler2);
Task task2 = getTaskResponseHandler2.getTask();
assertEquals(Status.Completed, task2.getTaskData().getStatus());
}
public void testDelayedEmailNotificationOnDeadline() throws Exception {
Map vars = new HashMap();
vars.put("users", users);
vars.put("groups", groups);
vars.put("now", new Date());
DefaultEscalatedDeadlineHandler notificationHandler =
new DefaultEscalatedDeadlineHandler(getConf());
WorkItemManager manager = new DefaultWorkItemManager(null);
notificationHandler.setManager(manager);
MockUserInfo userInfo = new MockUserInfo();
userInfo.getEmails().put(users.get("tony"), emailAddressTony);
userInfo.getEmails().put(users.get("darth"), emailAddressDarth);
userInfo.getLanguages().put(users.get("tony"), "en-UK");
userInfo.getLanguages().put(users.get("darth"), "en-UK");
notificationHandler.setUserInfo(userInfo);
taskService.setEscalatedDeadlineHandler(notificationHandler);
Reader reader =
new InputStreamReader(
getClass().getResourceAsStream(MvelFilePath.DeadlineWithNotification));
Task task = (Task) eval(reader, vars);
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
client.addTask(task, null, addTaskResponseHandler);
long taskId = addTaskResponseHandler.getTaskId();
Content content = new Content();
content.setContent("['subject' : 'My Subject', 'body' : 'My Body']".getBytes());
BlockingSetContentResponseHandler setContentResponseHandler =
new BlockingSetContentResponseHandler();
client.setDocumentContent(taskId, content, setContentResponseHandler);
long contentId = setContentResponseHandler.getContentId();
BlockingGetContentResponseHandler getResponseHandler = new BlockingGetContentResponseHandler();
client.getContent(contentId, getResponseHandler);
content = getResponseHandler.getContent();
assertEquals(
"['subject' : 'My Subject', 'body' : 'My Body']", new String(content.getContent()));
// emails should not be set yet
assertEquals(0, getWiser().getMessages().size());
Thread.sleep(100);
// nor yet
assertEquals(0, getWiser().getMessages().size());
long time = 0;
while (getWiser().getMessages().size() != 2 && time < 15000) {
Thread.sleep(500);
time += 500;
}
// 1 email with two recipients should now exist
assertEquals(2, getWiser().getMessages().size());
List<String> list = new ArrayList<String>(2);
list.add(getWiser().getMessages().get(0).getEnvelopeReceiver());
list.add(getWiser().getMessages().get(1).getEnvelopeReceiver());
assertTrue(list.contains(emailAddressTony));
assertTrue(list.contains(emailAddressDarth));
MimeMessage msg = ((WiserMessage) getWiser().getMessages().get(0)).getMimeMessage();
assertEquals("My Body", msg.getContent());
assertEquals("My Subject", msg.getSubject());
assertEquals("*****@*****.**", ((InternetAddress) msg.getFrom()[0]).getAddress());
assertEquals("*****@*****.**", ((InternetAddress) msg.getReplyTo()[0]).getAddress());
boolean tonyMatched = false;
boolean darthMatched = false;
for (int i = 0; i < msg.getRecipients(RecipientType.TO).length; ++i) {
String emailAddress = ((InternetAddress) msg.getRecipients(RecipientType.TO)[i]).getAddress();
if ("*****@*****.**".equals(emailAddress)) {
tonyMatched = true;
} else if ("*****@*****.**".equals(emailAddress)) {
darthMatched = true;
}
}
assertTrue("Could not find tony in recipients list.", tonyMatched);
assertTrue("Could not find darth in recipients list.", darthMatched);
}
public void testDelayedReassignmentOnDeadline() throws Exception {
Map vars = new HashMap();
vars.put("users", users);
vars.put("groups", groups);
vars.put("now", new Date());
DefaultEscalatedDeadlineHandler notificationHandler =
new DefaultEscalatedDeadlineHandler(getConf());
WorkItemManager manager = new DefaultWorkItemManager(null);
notificationHandler.setManager(manager);
MockUserInfo userInfo = new MockUserInfo();
userInfo.getEmails().put(users.get("tony"), "*****@*****.**");
userInfo.getEmails().put(users.get("luke"), "*****@*****.**");
userInfo.getEmails().put(users.get("bobba"), "*****@*****.**");
userInfo.getEmails().put(users.get("jabba"), "*****@*****.**");
userInfo.getLanguages().put(users.get("tony"), "en-UK");
userInfo.getLanguages().put(users.get("luke"), "en-UK");
userInfo.getLanguages().put(users.get("bobba"), "en-UK");
userInfo.getLanguages().put(users.get("jabba"), "en-UK");
notificationHandler.setUserInfo(userInfo);
taskService.setEscalatedDeadlineHandler(notificationHandler);
Reader reader =
new InputStreamReader(
getClass().getResourceAsStream(MvelFilePath.DeadlineWithReassignment));
BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
Task task = (Task) eval(reader, vars);
client.addTask(task, null, addTaskResponseHandler);
long taskId = addTaskResponseHandler.getTaskId();
// Shouldn't have re-assigned yet
Thread.sleep(1000);
BlockingGetTaskResponseHandler getTaskHandler = new BlockingGetTaskResponseHandler();
client.getTask(taskId, getTaskHandler);
task = getTaskHandler.getTask();
List<OrganizationalEntity> potentialOwners = task.getPeopleAssignments().getPotentialOwners();
List<String> ids = new ArrayList<String>(potentialOwners.size());
for (OrganizationalEntity entity : potentialOwners) {
ids.add(entity.getId());
}
assertTrue(ids.contains(users.get("tony").getId()));
assertTrue(ids.contains(users.get("luke").getId()));
// should have re-assigned by now
long time = 0;
while (getWiser().getMessages().size() != 2 && time < 15000) {
Thread.sleep(500);
time += 500;
}
getTaskHandler = new BlockingGetTaskResponseHandler();
client.getTask(taskId, getTaskHandler);
task = getTaskHandler.getTask();
assertEquals(Status.Ready, task.getTaskData().getStatus());
potentialOwners = task.getPeopleAssignments().getPotentialOwners();
System.out.println(potentialOwners);
ids = new ArrayList<String>(potentialOwners.size());
for (OrganizationalEntity entity : potentialOwners) {
ids.add(entity.getId());
}
assertTrue(ids.contains(users.get("bobba").getId()));
assertTrue(ids.contains(users.get("jabba").getId()));
}
