/// <summary>
/// Invokes search process.
/// </summary>
/// <param name="schemaName">Schema name.</param>
/// <returns>Instance <see cref="DuplicatesSearchResponse"/> results for search process execution.</returns>
public virtual DuplicatesSearchResponse FindEntityDuplicatesAsync(string schemaName)
{
DuplicatesSearchResponse result = new DuplicatesSearchResponse()
{
Message = GetLczStringValue("CommonErrorMessage")
};
if (!Locker.CanExecute(DeduplicationConsts.SearchOperationId, schemaName))
{
result.Message = GetLczStringValue("InProgressMessage");
return(result);
}
string jobName = string.Format(JobNamePattern, schemaName);
string processName = "DeduplicationActionProcess";
var parameters = new Dictionary <string, object>()
{
{ "SchemaName", schemaName },
{ "OperationId", DeduplicationConsts.SearchOperationId }
};
AppScheduler.ScheduleImmediateProcessJob(jobName, QuartzJobGroup, processName,
_userConnection.Workspace.Name, _userConnection.CurrentUser.Name, parameters);
result.Success = true;
result.Message = GetLczStringValue("SuccessMessage");
return(result);
}
private bool ScriptTask1Execute(ProcessExecutingContext context)
{
var UserConnection = Get <UserConnection> ("UserConnection");
string userName = "******";//(string)Terrasoft.Core.Configuration.SysSettings.GetValue(UserConnection, "SheduleUserName")"";
//delete previous job
Scheduler.AppScheduler.RemoveJob(
"UsrStartUnloadFromFTPJobName",
"UsrStartUnloadFromFTPProcessGroup"
);
// Создание задания для запуска процесса.
IJobDetail job = AppScheduler.CreateProcessJob("UsrStartUnloadFromFTPJobName", "UsrStartUnloadFromFTPProcessGroup",
"UsrStartUnloadFromFTP",
UserConnection.Workspace.Name, userName);
// Создание Cron-триггера, соответствующего графику запуска задания.
//ITrigger trigger = new CronTriggerImpl("SxAmortizationPaymentTrigger", "UsrDailyRecalcOpportunityProcessGroup", "0 15 10 * * ?");
//каждый день в 07:30
ITrigger trigger = new CronTriggerImpl("UsrStartUnloadFromFTPProcessTrigger", "UsrStartUnloadFromFTPProcessGroup", "0 0/5 * * * ?");
// Добавление задания и триггера в планировщик.
AppScheduler.Instance.ScheduleJob(job, trigger);
return(true);
}
public string SetContactIntegrationShedule()
{
string result;
try
{
UserConnection.DBSecurityEngine.CheckCanExecuteOperation("CanManageAdministration");
object interval = null;
bool hasOldInterval = Terrasoft.Core.Configuration.SysSettings.TryGetValue(UserConnection,
"LDAPSynchInterval", out interval);
if (hasOldInterval && (int)interval != 0)
{
AppScheduler.ScheduleMinutelyProcessJob("NavAdProcessJob", "NavProcess", "NavAdStarterProcess",
UserConnection.Workspace.Name, UserConnection.CurrentUser.Name, (int)interval * 60);
global::Common.Logging.ILog _logger = global::Common.Logging.LogManager.GetLogger("ContactProcessLog");
_logger.Info("������������� ������������� ��������� ������ " + (int)interval + " �����");
}
result = "Ok";
}
catch (Exception ex)
{
result = ex.ToString();
}
return(result);
}
/// <summary>
/// Removes job.
/// </summary>
/// <typeparam name="TJob">Job type.</typeparam>
protected void RemoveJob <TJob>()
where TJob : IJobExecutor
{
string className = typeof(TJob).AssemblyQualifiedName;
AppScheduler.RemoveJob(className, JobGroupName);
}
/// <summary>
/// Invokes merge process
/// </summary>
/// <param name="schemaName">Schema name.</param>
/// <param name="groupId">Identifier of the group of search results</param>
/// <param name="deduplicateRecordIds">Unique identifiers.</param>
/// <param name="resolvedConflicts">Config for resolving conflicts.</param>
/// <returns>Instance <see cref="DuplicatesMergeResponse"/> results for merge process execution.</returns>
public virtual DuplicatesMergeResponse MergeEntityDuplicatesAsync(string schemaName, int groupId,
List <Guid> duplicateRecordIds, Dictionary <string, string> resolvedConflicts = null)
{
DuplicatesMergeResponse result = new DuplicatesMergeResponse();
if (!Locker.CanExecute(DeduplicationConsts.SearchOperationId, schemaName))
{
return(result);
}
ValidateDuplicatesResponse response = MergeHandler.ValidateDuplicates(schemaName, duplicateRecordIds, resolvedConflicts);
if (response.ConflictsExists)
{
result.Conflicts = response.Conflicts;
return(result);
}
MergeHandler.ExcludeSearchResultGroup(schemaName, groupId);
string jobName = string.Format(MergeDuplicatesJobNamePattern, schemaName, Guid.NewGuid());
var parameters = new Dictionary <string, object>()
{
{ "SchemaName", schemaName },
{ "OperationId", DeduplicationConsts.MergeOperationId },
{ "DuplicateGroupId", groupId },
{ "DuplicateRecordIds", duplicateRecordIds },
{ "ResolvedConflicts", resolvedConflicts }
};
AppScheduler.ScheduleImmediateProcessJob(jobName, "Dedublication", MergeDuplicatesProcessName,
_userConnection.Workspace.Name, _userConnection.CurrentUser.Name, parameters);
result.Success = true;
return(result);
}
/// <inheritdoc cref="IBulkDeduplicationScheduler.ScheduleSearchJob"/>
public void ScheduleSearchJob(DuplicatesScheduledSearchParameter duplicatesScheduledSearchParameter)
{
var schemaName = duplicatesScheduledSearchParameter.SearchSchemaName;
var cronExpression = duplicatesScheduledSearchParameter.GetCronExpression();
var jobName = string.Format(ScheduledSearchDuplicatesJobNamePattern, schemaName);
var jobParameters = new Dictionary <string, object> {
{ "SchemaName", schemaName },
};
var jobDetail = AppScheduler.CreateProcessJob(
jobName,
ScheduledSearchDuplicatesJobGroup,
ScheduledSearchDuplicatesJobProcessName,
_userConnection.Workspace.Name,
_userConnection.CurrentUser.Name,
jobParameters);
var cronTrigger = new CronTriggerImpl {
Name = jobName,
Group = ScheduledSearchDuplicatesJobGroup,
TimeZone = TimeZoneInfo.Utc,
CronExpression = new CronExpression(cronExpression),
MisfireInstruction = MisfireInstruction.CronTrigger.DoNothing
};
AppScheduler.Instance.ScheduleJob(jobDetail, cronTrigger);
}
/// <summary>
/// Schedule next job for the specified campaign.
/// </summary>
/// <param name="schema">The <see cref="Terrasoft.Core.Campaign.CampaignSchema"/> object for wich Job plans.</param>
/// <param name="fireTimeConfig">Fire time config for job.</param>
public void ScheduleJob(CoreCampaignSchema schema, CampaignFireTimeConfig fireTimeConfig)
{
try {
schema.CheckArgumentNull(nameof(schema));
fireTimeConfig.CheckArgumentNull(nameof(fireTimeConfig));
Guid campaignId = schema.EntityId;
var campaignJobName = GetCampaignJobName(campaignId, fireTimeConfig.Time);
var sysUserConnection = _userConnection.AppConnection.SystemUserConnection;
var parameters = new Dictionary <string, object> {
{ "CampaignSchemaUId", schema.UId },
{ "ScheduledUtcFireTime", fireTimeConfig.Time },
{ "SchemaGeneratorStrategy", fireTimeConfig.ExecutionStrategy },
{ "ScheduledAction", (int)fireTimeConfig.ScheduledAction }
};
IJobDetail job = AppScheduler.CreateClassJob <CampaignJobExecutor>(campaignJobName,
CampaignConsts.CampaignJobGroupName, sysUserConnection, parameters);
ITrigger trigger = new SimpleTriggerImpl(campaignJobName + "Trigger",
CampaignConsts.CampaignJobGroupName, fireTimeConfig.Time)
{
MisfireInstruction = MisfireInstruction.IgnoreMisfirePolicy
};
AppScheduler.Instance.ScheduleJob(job, trigger);
LogScheduledJob(schema.EntityId, fireTimeConfig);
} catch (Exception ex) {
string message = CampaignHelper.GetLczStringValue(nameof(CampaignJobDispatcher), "ScheduleException");
Logger.ErrorFormat(message, ex, schema == null ? Guid.Empty : schema.EntityId);
throw;
}
}
private void CreateImmediateSyncJob(UserConnection userConnection, string jobName, string syncJobGroupName,
string syncProcessName, string schedulerName = null)
{
var scheduler = AppScheduler.GetSchedulerOrDefault(schedulerName);
AppScheduler.ScheduleImmediateProcessJob(jobName, syncJobGroupName, syncProcessName,
userConnection.Workspace.Name, userConnection.CurrentUser.Name, scheduler: scheduler);
}
/// <summary>
/// Creates the immediately job.
/// </summary>
/// <param name="userConnection">Instance of user connection.</param>
/// <param name="jobName">Name of the job.</param>
/// <param name="jobGroupName">Name of the group.</param>
/// <param name="processName">Name of the process.</param>
/// <param name="parameters">Process parameters.</param>
public static void CreateImmediatelyJob(UserConnection userConnection, string jobName, string jobGroupName,
string processName, IDictionary <string, object> parameters)
{
string jobExecutorName = GetJobExecutorUserName(userConnection);
AppScheduler.ScheduleImmediateProcessJob(jobName, jobGroupName,
processName, userConnection.Workspace.Name, jobExecutorName, parameters);
}
protected override bool InternalExecute(ProcessExecutingContext context)
{
string jobProcessName = (SchemaName == "Account") ? "StartGlobalAccountDuplicatesSearch" : "StartGlobalContactDuplicatesSearch";
AppScheduler.ScheduleImmediateProcessJob("DuplicatesSearchJob", "DuplicatesSearchGroup",
jobProcessName, UserConnection.Workspace.Name, UserConnection.CurrentUser.Name);
return(true);
}
public virtual bool ScriptTask1Execute(ProcessExecutingContext context)
{
string jobProcessName = "CompletenessRenew";
AppScheduler.ScheduleImmediateProcessJob("CompletenessRenewJob", "CompletenessRenewGroup",
jobProcessName, UserConnection.Workspace.Name, UserConnection.CurrentUser.Name);
return(true);
}
private void ScheduleImmediateJob(string jobName, Guid entityId)
{
string jobExecutorName = GetJobExecutorName();
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("ApplicationUrl", ApplicationUrl);
parameters.Add("BulkEmailId", entityId.ToString());
AppScheduler.ScheduleImmediateProcessJob(jobName, JobGroupName, SendProcessName,
UserConnection.Workspace.Name, jobExecutorName, parameters);
}
/// <summary>
/// Delete QRTZ job for given campaign
/// </summary>
/// <param name="campaignId">Unique identifier of campaign.</param>
private static void RemoveActualizeStepsCampaignJob(Guid campaignId)
{
string curCampaignJobName = ActualizeStepsCamapignJobName + campaignId;
IJobDetail jobDetail = FindJob(curCampaignJobName, CampaignJobGroupName);
if (jobDetail != null)
{
AppScheduler.RemoveJob(curCampaignJobName, CampaignJobGroupName);
}
}
public void OnAppStart(AppEventContext context)
{
UserConnection userConnection = GetUserConnection(context);
IJobDetail job = CreateJob(userConnection);
if (AppScheduler.DoesJobExist(job.Key.Name, job.Key.Group))
{
AppScheduler.RemoveJob(job.Key.Name, job.Key.Group);
}
AppScheduler.Instance.ScheduleJob(job, GetJobTrigger(userConnection));
}
/// <summary>
/// Schedules immediate job for sending email.
/// </summary>
/// <param name="activityId"></param>
public virtual void SendAsync(Guid activityId)
{
SysUserInfo currentUser = UserConnection.CurrentUser;
string jobGroup = string.Concat("AsyncEmailSender", "_", Guid.NewGuid());
var parameters = new Dictionary <string, object> {
{ "activityId", activityId }
};
AppScheduler.ScheduleImmediateJob <AsyncEmailSenderExecutor>(jobGroup, UserConnection.Workspace.Name,
currentUser.Name, parameters);
}
/// <summary>
/// Creates job to monitor fails.
/// <param name="userConnection">The user connection.</param>
/// </summary>
public void CreateJob(UserConnection userConnection)
{
SysUserInfo currentUser = userConnection.CurrentUser;
int periodInMinutes = (int)SysSettingsCore.GetValue(userConnection, "BulkEmailFailoverJobInterval");
string jobGroupName = "Mailing";
bool isSystemUser = true;
var misfirePolicy = AppSchedulerMisfireInstruction.RescheduleNowWithRemainingRepeatCount;
AppScheduler.ScheduleMinutelyJob <BulkEmailFailoverHandler>(jobGroupName, userConnection.Workspace.Name,
currentUser.Name, periodInMinutes, null, isSystemUser, misfirePolicy);
}
private void RecalculateFact(Guid forecastId, List <Guid> periodIds)
{
IDictionary <string, object> parameters = new Dictionary <string, object> {
{ "ForecastId", forecastId },
{ "PeriodIds", periodIds }
};
var jobGroup = $"{typeof(ForecastCalculator).Name}_{forecastId}";
AppScheduler.RemoveJob(typeof(ForecastCalculator).AssemblyQualifiedName, jobGroup);
AppScheduler.TriggerJob <ForecastCalculator>(jobGroup, UserConnection.Workspace.Name,
UserConnection.CurrentUser.Name, parameters);
}
/// <summary>
/// ######### ####### ######## ##### ## ###### ###### ########.
/// </summary>
/// <param name="userConnection">######### ################# ###########.</param>
/// <param name="leadStepId">Id #### "####### ###".</param>
/// <param name="targetInfoCollection">############ ### Id ###### # Id ######## ######### ########.</param>
public static void CreateCampaignLead(UserConnection userConnection, Guid leadStepId, IEnumerable <KeyValuePair <Guid, Guid> > targetInfoCollection)
{
string syncJobName = string.Format(CampaignLeadCreatorJobNamePattern, Guid.NewGuid());
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ "LeadStepId", leadStepId },
{ "TargetInfoCollection", targetInfoCollection }
};
AppScheduler.ScheduleImmediateProcessJob(syncJobName, "Campaign", "CampaignCreateLeadProcess",
userConnection.Workspace.Name, userConnection.CurrentUser.Name, parameters);
}
/// <summary>
/// Runs logstash configs generator.
/// </summary>
private void RunGlobalSearchConfigJob()
{
if (UserConnection.GetIsFeatureEnabled("GlobalSearch"))
{
_log.Info("Prepare GlobalSearchConfigsJob");
SysUserInfo currentUser = UserConnection.CurrentUser;
string workspaceName = UserConnection.Workspace.Name;
RemoveJobs();
AppScheduler.TriggerJob <LogstashConfigsJob>(JobGroupName, workspaceName, currentUser.Name, null, true);
_log.Info("GlobalSearchConfigsJob started successfully");
}
}
/// <summary>
/// Schedules a minutely job.
/// </summary>
/// <typeparam name="TJob">Job type.</typeparam>
/// <param name="periodInMinutes">Period in minutes.</param>
protected virtual void ScheduleJob <TJob>(int periodInMinutes)
where TJob : IJobExecutor
{
SysUserInfo currentUser = UserConnection.CurrentUser;
string className = typeof(TJob).AssemblyQualifiedName;
if (!AppScheduler.DoesJobExist(className, JobGroupName))
{
AppScheduler.ScheduleMinutelyJob <TJob>(JobGroupName, UserConnection.Workspace.Name,
currentUser.Name, periodInMinutes, null, true);
}
}
private void CreateSyncJob(UserConnection userConnection, string jobName, string syncJobGroupName,
string syncProcessName, int periodInMinutes, bool recreate, string schedulerName = null)
{
var scheduler = AppScheduler.GetSchedulerOrDefault(schedulerName);
AppScheduler.RemoveJob(jobName, syncJobGroupName, scheduler);
if (periodInMinutes < 0 || !recreate)
{
return;
}
AppScheduler.ScheduleMinutelyProcessJob(jobName, syncJobGroupName, syncProcessName,
userConnection.Workspace.Name, userConnection.CurrentUser.Name, periodInMinutes, scheduler: scheduler);
}
private void UpdateCountersStart()
{
SysUserInfo currentUser = UserConnection.CurrentUser;
string shedulerJobName = string.Format("RemindingCountersJob_{0}", currentUser.Id);
string shedulerJobGroupName = "RemindingCountersGroup";
string jobProcessName = "GetRemindingCounters";
var jobParameters = new Dictionary <string, object> {
{ "TimeZoneId", currentUser.TimeZoneId }
};
AppScheduler.ScheduleMinutelyProcessJob(shedulerJobName, shedulerJobGroupName, jobProcessName,
UserConnection.Workspace.Name, currentUser.Name, PERIOD_OF_EXECUTE_JOB, jobParameters);
}
private void ScheduleRemindingJob()
{
SysUserInfo currentUser = UserConnection.CurrentUser;
string jobGroupName = "RemindingGroup";
string jobName = typeof(RemindingJob).FullName;
if (AppScheduler.DoesJobExist(jobName, jobGroupName))
{
DeleteOldJobs(jobGroupName);
}
AppScheduler.ScheduleMinutelyJob <RemindingJob>(jobGroupName, UserConnection.Workspace.Name, currentUser.Name,
GetNotificatonJobInterval(), isSystemUser: true);
}
/// <summary>
/// Creates and schedules a job for certificates actualization.
/// </summary>
/// <param name="context">Execution context.</param>
public override void OnAppStart(AppEventContext context) {
InitializeData(context);
string processJob = GetProcessJobName();
string processJobGroup = GetProcessJobGroupName();
string processTrigger = GetProcessTriggerName();
IJobDetail job = AppScheduler.CreateClassJob(CLASS_NAME, processJobGroup,
UserConnection.Workspace.Name, UserConnection.CurrentUser.Name);
ITrigger trigger = new CronTriggerImpl(processTrigger, processJobGroup, _cronTigger);
if (AppScheduler.DoesJobExist(processJob, processJobGroup)) {
AppScheduler.RemoveJob(processJob, processJobGroup);
}
AppScheduler.Instance.ScheduleJob(job, trigger);
}
private SearchStatus searchStart(string entitySchemaName)
{
searchUpdate(entitySchemaName, "Finished");
string jobProcessName = string.Format("StartGlobal{0}DuplicatesSearch", entitySchemaName);
AppScheduler.ScheduleImmediateProcessJob("DuplicatesSearchJob", "DuplicatesSearchGroup",
jobProcessName, UserConnection.Workspace.Name, UserConnection.CurrentUser.Name);
SearchStatus responce = new SearchStatus();
responce.ChangeOn = DateTime.Now;
responce.Code = "InProgress";
responce.Percent = 0;
return(responce);
}
public override BaseJobData RunOnEveryDay(DateTime dateTime)
{
ITrigger trigger = TriggerBuilder.Create()
.WithDailyTimeIntervalSchedule(
interval => interval
.WithIntervalInHours(24)
.OnEveryDay()
.StartingDailyAt(TimeOfDay.HourAndMinuteOfDay(dateTime.Hour, dateTime.Minute))
).Build();
var job = AppScheduler.CreateProcessJob(JobName, JobGroup, ProcessName,
WorkspaceName, UserName, Parameters);
AppScheduler.Instance.ScheduleJob(job, trigger);
return(this);
}
/// <summary>
/// Creates synchronization job.
/// </summary>
/// <param name="userConnection">User connection.</param>
/// <param name="periodInMinutes">Synchronization interval.</param>
/// <param name="parameters">Synchronization parameters.</param>
public void CreateSyncJob(UserConnection userConnection, int periodInMinutes,
IDictionary <string, object> parameters = null)
{
if (periodInMinutes <= 0)
{
throw new ArgumentOutOfRangeException("periodInMinutes");
}
RemoveSyncJob(userConnection, parameters);
string syncJobName = GetSyncJobName(userConnection, parameters);
_log.ErrorFormat("ScheduleMinutelyJob called: CurrentUser {0}, SyncJobName {1}",
userConnection.CurrentUser.Name, syncJobName);
AppScheduler.ScheduleMinutelyJob(syncJobName, SyncJobGroupName, SyncProcessName,
userConnection.Workspace.Name, userConnection.CurrentUser.Name, periodInMinutes, parameters);
}
private void ScheduleNotificationsJob(UserConnection userConnection)
{
SysUserInfo currentUser = userConnection.CurrentUser;
string jobGroupName = "NotificationsCountersGroup";
string oldJobGroupName = "RemindingCountersGroup";
DeleteOldJobs(oldJobGroupName);
var jobParameters = new Dictionary <string, object> {
{ "TimeZoneId", currentUser.TimeZoneId },
{ "type", "All" },
{ "typeParameter", "" }
};
AppScheduler.ScheduleMinutelyJob <NotificationsJob>(jobGroupName, userConnection.Workspace.Name,
currentUser.Name, GetNotificatonJobInterval(userConnection), jobParameters, true);
}
/// <summary>
/// Creates job to handle broken trigger emails.
/// <param name="userConnection">The user connection.</param>
/// </summary>
public void CreateJob(UserConnection userConnection)
{
var periodInMinutes = (int)CoreSysSettings.GetValue(userConnection, "TriggerEmailFailoverJobInterval");
if (periodInMinutes <= 0)
{
return;
}
string userName = userConnection.CurrentUser.Name;
string workspaceName = userConnection.Workspace.Name;
string jobGroupName = MailingSchedulerUtilities.BulkEmailJobGroupName;
AppScheduler.ScheduleMinutelyJob <TriggerEmailFailoverHandler>(jobGroupName, workspaceName, userName,
periodInMinutes, parameters: null, isSystemUser: true,
misfireInstruction: AppSchedulerMisfireInstruction.RescheduleNowWithRemainingRepeatCount);
}
/// <summary>
/// Creates the immediately job.
/// </summary>
/// <param name="userConnection">Instance of user connection.</param>
/// <param name="jobName">Name of the job.</param>
/// <param name="jobGroupName">Name of the group.</param>
/// <param name="processName">Name of the process.</param>
/// <param name="parameters">Process parameters.</param>
/// <param name="isSystemUser">Executes job with the system user rights.</param>
public static void CreateImmediatelyJob(UserConnection userConnection, string jobName, string jobGroupName,
string processName, IDictionary <string, object> parameters, bool isSystemUser)
{
string jobExecutorName = GetJobExecutorUserName(userConnection);
AppScheduler.RemoveJob(jobName, jobGroupName);
IJobDetail job = AppScheduler.CreateProcessJob(jobName, jobGroupName, processName,
userConnection.Workspace.Name, jobExecutorName, parameters, isSystemUser);
ITrigger trigger = new SimpleTriggerImpl(jobName + "Trigger", jobGroupName,
DateTime.UtcNow, null, 0, TimeSpan.Zero)
{
MisfireInstruction = MisfireInstruction.IgnoreMisfirePolicy
};
AppScheduler.Instance.ScheduleJob(job, trigger);
}
