public virtual void testCreateDeploymentPa()
{
// given
EmbeddedProcessApplication application = new EmbeddedProcessApplication();
// when
IDeployment deployment = repositoryService.CreateDeployment(application.Reference).Name(DEPLOYMENT_NAME).AddModelInstance(RESOURCE_NAME, createProcessWithServiceTask(PROCESS_KEY)).Deploy();
// then
IUserOperationLogEntry userOperationLogEntry = historyService.CreateUserOperationLogQuery().First();
Assert.NotNull(userOperationLogEntry);
Assert.AreEqual(EntityTypes.Deployment, userOperationLogEntry.EntityType);
Assert.AreEqual(deployment.Id, userOperationLogEntry.DeploymentId);
Assert.AreEqual(UserOperationLogEntryFields.OperationTypeCreate, userOperationLogEntry.OperationType);
Assert.AreEqual("duplicateFilterEnabled", userOperationLogEntry.Property);
Assert.IsNull(userOperationLogEntry.OrgValue);
Assert.IsFalse(Convert.ToBoolean(userOperationLogEntry.NewValue));
Assert.AreEqual(USER_ID, userOperationLogEntry.UserId);
Assert.IsNull(userOperationLogEntry.JobDefinitionId);
Assert.IsNull(userOperationLogEntry.ProcessInstanceId);
Assert.IsNull(userOperationLogEntry.ProcessDefinitionId);
Assert.IsNull(userOperationLogEntry.ProcessDefinitionKey);
Assert.IsNull(userOperationLogEntry.CaseInstanceId);
Assert.IsNull(userOperationLogEntry.CaseDefinitionId);
}
public virtual void testSetJobPriority()
{
// given a job
runtimeService.StartProcessInstanceByKey("asyncTaskProcess");
IJob job = managementService.CreateJobQuery().First();
// when I set a job priority
managementService.SetJobPriority(job.Id, 42);
// then an op log entry is written
IUserOperationLogEntry userOperationLogEntry = historyService.CreateUserOperationLogQuery().First();
Assert.NotNull(userOperationLogEntry);
Assert.AreEqual(EntityTypes.Job, userOperationLogEntry.EntityType);
Assert.AreEqual(job.Id, userOperationLogEntry.JobId);
Assert.AreEqual(UserOperationLogEntryFields.OperationTypeSetPriority, userOperationLogEntry.OperationType);
Assert.AreEqual("priority", userOperationLogEntry.Property);
Assert.AreEqual("42", userOperationLogEntry.NewValue);
Assert.AreEqual("0", userOperationLogEntry.OrgValue);
Assert.AreEqual(USER_ID, userOperationLogEntry.UserId);
Assert.AreEqual(job.JobDefinitionId, userOperationLogEntry.JobDefinitionId);
Assert.AreEqual(job.ProcessInstanceId, userOperationLogEntry.ProcessInstanceId);
Assert.AreEqual(job.ProcessDefinitionId, userOperationLogEntry.ProcessDefinitionId);
Assert.AreEqual(job.ProcessDefinitionKey, userOperationLogEntry.ProcessDefinitionKey);
Assert.AreEqual(DeploymentId, userOperationLogEntry.DeploymentId);
}
public virtual void testCompositeBeanInteraction()
{
// given: a manually created task
task = taskService.NewTask();
// then: save the task without any property change
taskService.SaveTask(task);
// expect: no entry
IQueryable <IUserOperationLogEntry> query = queryOperationDetails(UserOperationLogEntryFields.OperationTypeCreate);
IUserOperationLogEntry create = query.First();
Assert.NotNull(create);
Assert.AreEqual(EntityTypes.Task, create.EntityType);
Assert.IsNull(create.OrgValue);
Assert.IsNull(create.NewValue);
Assert.IsNull(create.Property);
task.Assignee = "icke";
task.Name = "to do";
// then: save the task again
taskService.SaveTask(task);
// expect: two update entries with the same operation id
IList <IUserOperationLogEntry> entries = queryOperationDetails(UserOperationLogEntryFields.OperationTypeUpdate)
.ToList();
Assert.AreEqual(2, entries.Count);
Assert.AreEqual(entries[0].OperationId, entries[1].OperationId);
}
public virtual void testSetOverridingPriority()
{
// given a job definition
IJobDefinition jobDefinition = managementService.CreateJobDefinitionQuery().First();
// when I set a job priority
managementService.SetOverridingJobPriorityForJobDefinition(jobDefinition.Id, 42);
// then an op log entry is written
IUserOperationLogEntry userOperationLogEntry = historyService.CreateUserOperationLogQuery().First();
Assert.NotNull(userOperationLogEntry);
Assert.AreEqual(EntityTypes.JobDefinition, userOperationLogEntry.EntityType);
Assert.AreEqual(jobDefinition.Id, userOperationLogEntry.JobDefinitionId);
Assert.AreEqual(UserOperationLogEntryFields.OperationTypeSetPriority, userOperationLogEntry.OperationType);
Assert.AreEqual("overridingPriority", userOperationLogEntry.Property);
Assert.AreEqual("42", userOperationLogEntry.NewValue);
Assert.AreEqual(null, userOperationLogEntry.OrgValue);
Assert.AreEqual(USER_ID, userOperationLogEntry.UserId);
Assert.AreEqual(jobDefinition.ProcessDefinitionId, userOperationLogEntry.ProcessDefinitionId);
Assert.AreEqual(jobDefinition.ProcessDefinitionKey, userOperationLogEntry.ProcessDefinitionKey);
Assert.AreEqual(DeploymentId, userOperationLogEntry.DeploymentId);
}
public virtual void testClearOverridingPriority()
{
// given a job definition
IJobDefinition jobDefinition = managementService.CreateJobDefinitionQuery().First();
// with an overriding priority
ClockUtil.CurrentTime = DateTime.Now; // new DateTime(DateTimeHelperClass.CurrentUnixTimeMillis());
managementService.SetOverridingJobPriorityForJobDefinition(jobDefinition.Id, 42);
// when I clear that priority
ClockUtil.CurrentTime = DateTime.Now; // new DateTime(DateTimeHelperClass.CurrentUnixTimeMillis() + 10000);
managementService.ClearOverridingJobPriorityForJobDefinition(jobDefinition.Id);
// then this is accessible via the op log
IUserOperationLogEntry userOperationLogEntry = historyService.CreateUserOperationLogQuery() /*.OrderByTimestamp()*//*.Desc()*//*.ListPage(0, 1)*/.First();
Assert.NotNull(userOperationLogEntry);
Assert.AreEqual(EntityTypes.JobDefinition, userOperationLogEntry.EntityType);
Assert.AreEqual(jobDefinition.Id, userOperationLogEntry.JobDefinitionId);
Assert.AreEqual(UserOperationLogEntryFields.OperationTypeSetPriority, userOperationLogEntry.OperationType);
Assert.AreEqual("overridingPriority", userOperationLogEntry.Property);
Assert.IsNull(userOperationLogEntry.NewValue);
Assert.AreEqual("42", userOperationLogEntry.OrgValue);
Assert.AreEqual(USER_ID, userOperationLogEntry.UserId);
Assert.AreEqual(jobDefinition.ProcessDefinitionId, userOperationLogEntry.ProcessDefinitionId);
Assert.AreEqual(jobDefinition.ProcessDefinitionKey, userOperationLogEntry.ProcessDefinitionKey);
Assert.AreEqual(DeploymentId, userOperationLogEntry.DeploymentId);
}
public virtual void testDeleteDeploymentCascading()
{
// given
IDeployment deployment = repositoryService.CreateDeployment().Name(DEPLOYMENT_NAME).AddModelInstance(RESOURCE_NAME, createProcessWithServiceTask(PROCESS_KEY)).Deploy();
IQueryable <IUserOperationLogEntry> query = historyService.CreateUserOperationLogQuery(c => c.OperationType == UserOperationLogEntryFields.OperationTypeDelete);
// when
repositoryService.DeleteDeployment(deployment.Id, true);
// then
Assert.AreEqual(1, query.Count());
IUserOperationLogEntry log = query.First();
Assert.NotNull(log);
Assert.AreEqual(EntityTypes.Deployment, log.EntityType);
Assert.AreEqual(deployment.Id, log.DeploymentId);
Assert.AreEqual(UserOperationLogEntryFields.OperationTypeDelete, log.OperationType);
Assert.AreEqual("cascade", log.Property);
Assert.IsNull(log.OrgValue);
Assert.True(Convert.ToBoolean(log.NewValue));
Assert.AreEqual(USER_ID, log.UserId);
Assert.IsNull(log.JobDefinitionId);
Assert.IsNull(log.ProcessInstanceId);
Assert.IsNull(log.ProcessDefinitionId);
Assert.IsNull(log.ProcessDefinitionKey);
Assert.IsNull(log.CaseInstanceId);
Assert.IsNull(log.CaseDefinitionId);
}
public virtual void testResetChange()
{
// given: a single task
task = taskService.NewTask();
taskService.SaveTask(task);
// then: change the name
string name = "a task";
task.Name = name;
taskService.SaveTask(task);
IUserOperationLogEntry update = queryOperationDetails(UserOperationLogEntryFields.OperationTypeUpdate).First();
Assert.IsNull(update.OrgValue);
Assert.AreEqual(name, update.NewValue);
// then: change the name some times and set it back to the original value
task.Name = "to do 1";
task.Name = "to do 2";
task.Name = name;
taskService.SaveTask(task);
// expect: there is no additional change tracked
update = queryOperationDetails(UserOperationLogEntryFields.OperationTypeUpdate).First();
Assert.IsNull(update.OrgValue);
Assert.AreEqual(name, update.NewValue);
}
public virtual void testOnlyTaskCompletionIsLogged()
{
// given
string ProcessInstanceId = runtimeService.StartProcessInstanceByKey("process").Id;
string taskId = taskService.CreateTaskQuery().First().Id;
// when
taskService.Complete(taskId);
// then
Assert.True((bool)runtimeService.GetVariable(ProcessInstanceId, "taskListenerCalled"));
Assert.True((bool)runtimeService.GetVariable(ProcessInstanceId, "serviceTaskCalled"));
IQueryable <IUserOperationLogEntry> query = historyService.CreateUserOperationLogQuery();
Assert.AreEqual(1, query.Count());
IUserOperationLogEntry log = query.First();
Assert.AreEqual("process", log.ProcessDefinitionKey);
Assert.AreEqual(ProcessInstanceId, log.ProcessInstanceId);
Assert.AreEqual(DeploymentId, log.DeploymentId);
Assert.AreEqual(taskId, log.TaskId);
Assert.AreEqual(UserOperationLogEntryFields.OperationTypeComplete, log.OperationType);
}
public virtual void testCompleteCaseExecution()
{
// given
//string caseDefinitionId = repositoryService.CreateCaseDefinitionQuery().First().Id;
//string caseInstanceId = caseService.WithCaseDefinition(caseDefinitionId).Create().Id;
//string humanTaskId = caseService.CreateCaseExecutionQuery(c=>c.ActivityId == "PI_HumanTask_1").First().Id;
// when
//caseService.WithCaseExecution(humanTaskId).Complete();
// then
IQueryable <IUserOperationLogEntry> query = queryOperationDetails(UserOperationLogEntryFields.OperationTypeComplete);
Assert.AreEqual(1, query.Count());
IUserOperationLogEntry entry = query.First();
Assert.NotNull(entry);
//Assert.AreEqual(caseDefinitionId, entry.CaseDefinitionId);
//Assert.AreEqual(caseInstanceId, entry.CaseInstanceId);
//Assert.AreEqual(humanTaskId, entry.CaseExecutionId);
Assert.AreEqual(DeploymentId, entry.DeploymentId);
Assert.IsFalse(Convert.ToBoolean(entry.OrgValue));
Assert.True(Convert.ToBoolean(entry.NewValue));
Assert.AreEqual(Permissions.Delete, entry.Property);
}
public virtual void CheckDeleteUserOperationLog(IUserOperationLogEntry entry)
{
if (entry != null)
{
var processDefinitionKey = entry.ProcessDefinitionKey;
if (!ReferenceEquals(processDefinitionKey, null))
{
AuthorizationManager.CheckAuthorization(Permissions.DeleteHistory, Resources.ProcessDefinition, processDefinitionKey);
}
}
}
public virtual void testSetDateProperty()
{
// given: a single task
task = taskService.NewTask();
DateTime now = ClockUtil.CurrentTime;
task.DueDate = now;
taskService.SaveTask(task);
IUserOperationLogEntry logEntry = historyService.CreateUserOperationLogQuery().First();
Assert.AreEqual(now.Ticks.ToString(), logEntry.NewValue);
}
public virtual object Execute(CommandContext commandContext)
{
EnsureUtil.EnsureNotNull(typeof(NotValidException), "entryId", EntryId);
IUserOperationLogEntry entry = commandContext.OperationLogManager.FindOperationLogById(EntryId);
foreach (var checker in commandContext.ProcessEngineConfiguration.CommandCheckers)
{
checker.CheckDeleteUserOperationLog(entry);
}
commandContext.OperationLogManager.DeleteOperationLogEntryById(EntryId);
return(null);
}
public virtual void testMultipleValueChange()
{
// given: a single task
task = taskService.NewTask();
taskService.SaveTask(task);
// then: change a property twice
task.Name = "a task";
task.Name = "to do";
taskService.SaveTask(task);
IUserOperationLogEntry update = queryOperationDetails(UserOperationLogEntryFields.OperationTypeUpdate).First();
Assert.IsNull(update.OrgValue);
Assert.AreEqual("to do", update.NewValue);
}
public virtual void testDeleteOpLogEntry()
{
// given
startTestProcess();
// an op log instance is created
taskService.ResolveTask(task.Id);
IUserOperationLogEntry opLogEntry = historyService.CreateUserOperationLogQuery().First();
// when the op log instance is deleted
historyService.DeleteUserOperationLogEntry(opLogEntry.Id);
// then it should be removed from the database
Assert.AreEqual(0, historyService.CreateUserOperationLogQuery().Count());
}
public virtual void testCaseInstanceId()
{
// create new task
task = taskService.NewTask();
taskService.SaveTask(task);
IQueryable <IUserOperationLogEntry> query = queryOperationDetails(UserOperationLogEntryFields.OperationTypeUpdate);
Assert.AreEqual(0, query.Count());
// set case instance id and save task
task.CaseInstanceId = "aCaseInstanceId";
taskService.SaveTask(task);
Assert.AreEqual(1, query.Count());
IUserOperationLogEntry entry = query.First();
Assert.NotNull(entry);
Assert.IsNull(entry.OrgValue);
Assert.AreEqual("aCaseInstanceId", entry.NewValue);
Assert.AreEqual(TaskEntity.CASE_INSTANCE_ID, entry.Property);
// change case instance id and save task
task.CaseInstanceId = "anotherCaseInstanceId";
taskService.SaveTask(task);
Assert.AreEqual(2, query.Count());
IList <IUserOperationLogEntry> entries = query.ToList();
Assert.AreEqual(2, entries.Count);
foreach (IUserOperationLogEntry currentEntry in entries)
{
if (!currentEntry.Id.Equals(entry.Id))
{
Assert.AreEqual("aCaseInstanceId", currentEntry.OrgValue);
Assert.AreEqual("anotherCaseInstanceId", currentEntry.NewValue);
Assert.AreEqual(TaskEntity.CASE_INSTANCE_ID, currentEntry.Property);
}
}
}
public virtual void testCreateAndCompleteTask()
{
startTestProcess();
// expect: no entry for the task creation by process engine
IQueryable <IUserOperationLogEntry> query = historyService.CreateUserOperationLogQuery();
Assert.AreEqual(0, query.Count());
completeTestProcess();
// expect: one entry for the task completion
query = queryOperationDetails(UserOperationLogEntryFields.OperationTypeComplete);
Assert.AreEqual(1, query.Count());
IUserOperationLogEntry complete = query.First();
Assert.AreEqual(Permissions.Delete, complete.Property);
Assert.True(bool.Parse(complete.NewValue));
}
public virtual void testSetOverridingPriorityCascadeToJobs()
{
// given a job definition and job
runtimeService.StartProcessInstanceByKey("asyncTaskProcess");
IJobDefinition jobDefinition = managementService.CreateJobDefinitionQuery().First();
IJob job = managementService.CreateJobQuery().First();
// when I set an overriding priority with cascade=true
managementService.SetOverridingJobPriorityForJobDefinition(jobDefinition.Id, 42, true);
// then there are two op log entries
Assert.AreEqual(2, historyService.CreateUserOperationLogQuery().Count());
// (1): One for the job definition priority
IUserOperationLogEntry jobDefOpLogEntry = historyService.CreateUserOperationLogQuery(c => c.EntityType == EntityTypes.JobDefinition).First();
Assert.NotNull(jobDefOpLogEntry);
// (2): and another one for the job priorities
IUserOperationLogEntry jobOpLogEntry = historyService.CreateUserOperationLogQuery(c => c.EntityType == EntityTypes.Job).First();
Assert.NotNull(jobOpLogEntry);
Assert.AreEqual("both entries should be part of the same operation", jobDefOpLogEntry.OperationId, jobOpLogEntry.OperationId);
Assert.AreEqual(EntityTypes.Job, jobOpLogEntry.EntityType);
Assert.IsNull("id should null because it is a bulk update operation", jobOpLogEntry.JobId);
Assert.AreEqual(UserOperationLogEntryFields.OperationTypeSetPriority, jobOpLogEntry.OperationType);
Assert.AreEqual("priority", jobOpLogEntry.Property);
Assert.AreEqual("42", jobOpLogEntry.NewValue);
Assert.IsNull("Original Value should be null because it is not known for bulk operations", jobOpLogEntry.OrgValue);
Assert.AreEqual(USER_ID, jobOpLogEntry.UserId);
// these properties should be there to narrow down the bulk update (like a SQL WHERE clasue)
Assert.AreEqual(job.JobDefinitionId, jobOpLogEntry.JobDefinitionId);
Assert.IsNull("an unspecified set of process instances was affected by the operation", jobOpLogEntry.ProcessInstanceId);
Assert.AreEqual(job.ProcessDefinitionId, jobOpLogEntry.ProcessDefinitionId);
Assert.AreEqual(job.ProcessDefinitionKey, jobOpLogEntry.ProcessDefinitionKey);
Assert.AreEqual(DeploymentId, jobOpLogEntry.DeploymentId);
}
public virtual void testAssignTask()
{
startTestProcess();
// then: assign the task
taskService.SetAssignee(task.Id, "icke");
// expect: one entry for the task assignment
IQueryable <IUserOperationLogEntry> query = queryOperationDetails(UserOperationLogEntryFields.OperationTypeAssign);
Assert.AreEqual(1, query.Count());
// Assert: details
IUserOperationLogEntry assign = query.First();
Assert.AreEqual(TaskEntity.ASSIGNEE, assign.Property);
Assert.AreEqual("icke", assign.NewValue);
completeTestProcess();
}
public virtual void testChangeTaskOwner()
{
startTestProcess();
// then: change the task owner
taskService.SetOwner(task.Id, "icke");
// expect: one entry for the owner change
IQueryable <IUserOperationLogEntry> query = queryOperationDetails(UserOperationLogEntryFields.OperationTypeSetOwner);
Assert.AreEqual(1, query.Count());
// Assert: details
IUserOperationLogEntry change = query.First();
Assert.AreEqual(TaskEntity.OWNER, change.Property);
Assert.AreEqual("icke", change.NewValue);
completeTestProcess();
}
public virtual void testClaimTask()
{
startTestProcess();
// then: claim a new the task
taskService.Claim(task.Id, "icke");
// expect: one entry for the claim
IQueryable <IUserOperationLogEntry> query = queryOperationDetails(UserOperationLogEntryFields.OperationTypeClaim);
Assert.AreEqual(1, query.Count());
// Assert: details
IUserOperationLogEntry claim = query.First();
Assert.AreEqual(TaskEntity.ASSIGNEE, claim.Property);
Assert.AreEqual("icke", claim.NewValue);
completeTestProcess();
}
public virtual void testDeleteTask()
{
// given: a single task
task = taskService.NewTask();
taskService.SaveTask(task);
// then: Delete the task
taskService.DeleteTask(task.Id, "duplicated");
// expect: one entry for the deletion
IQueryable <IUserOperationLogEntry> query = queryOperationDetails(UserOperationLogEntryFields.OperationTypeDelete);
Assert.AreEqual(1, query.Count());
// Assert: details
IUserOperationLogEntry Delete = query.First();
Assert.AreEqual(Permissions.Delete, Delete.Property);
Assert.IsFalse(bool.Parse(Delete.OrgValue));
Assert.True(bool.Parse(Delete.NewValue));
}
public virtual void testSetPriority()
{
startTestProcess();
// then: set the priority of the task to 10
taskService.SetPriority(task.Id, 10);
// expect: one entry for the priority update
IQueryable <IUserOperationLogEntry> query = queryOperationDetails(UserOperationLogEntryFields.OperationTypeSetPriority);
Assert.AreEqual(1, query.Count());
// Assert: correct priority set
IUserOperationLogEntry userOperationLogEntry = query.First();
Assert.AreEqual(TaskEntity.PRIORITY, userOperationLogEntry.Property);
// note: 50 is the default task priority
Assert.AreEqual(50, int.Parse(userOperationLogEntry.OrgValue));
Assert.AreEqual(10, int.Parse(userOperationLogEntry.NewValue));
// move clock by 5 minutes
DateTime date = DateTimeUtil.Now().AddMinutes(5);
ClockUtil.CurrentTime = date;
// then: set priority again
taskService.SetPriority(task.Id, 75);
// expect: one entry for the priority update
query = queryOperationDetails(UserOperationLogEntryFields.OperationTypeSetPriority);
Assert.AreEqual(2, query.Count());
// Assert: correct priority set
//userOperationLogEntry = query/*.OrderByTimestamp()*//*.Asc()*/.ToList()[1];
Assert.AreEqual(TaskEntity.PRIORITY, userOperationLogEntry.Property);
Assert.AreEqual(10, int.Parse(userOperationLogEntry.OrgValue));
Assert.AreEqual(75, int.Parse(userOperationLogEntry.NewValue));
}
public virtual void CheckDeleteUserOperationLog(IUserOperationLogEntry entry)
{
// tenant check is not available for user operation log
}
