/// <summary> /// Handles the Click event of the DeleteConnectionOpportunity control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="Rock.Web.UI.Controls.RowEventArgs" /> instance containing the event data.</param> protected void DeleteConnectionOpportunity_Click(object sender, Rock.Web.UI.Controls.RowEventArgs e) { using (RockContext rockContext = new RockContext()) { ConnectionOpportunityService connectionOpportunityService = new ConnectionOpportunityService(rockContext); ConnectionOpportunity connectionOpportunity = connectionOpportunityService.Get(e.RowKeyId); if (connectionOpportunity != null) { if (_canEdit) { string errorMessage; if (!connectionOpportunityService.CanDelete(connectionOpportunity, out errorMessage)) { mdGridWarning.Show(errorMessage, ModalAlertType.Information); return; } int connectionTypeId = connectionOpportunity.ConnectionTypeId; connectionOpportunityService.Delete(connectionOpportunity); rockContext.SaveChanges(); ConnectionWorkflowService.FlushCachedTriggers(); } else { mdGridWarning.Show("You are not authorized to delete this calendar item", ModalAlertType.Warning); } } } BindConnectionOpportunitiesGrid(); }
/// <summary> /// Handles the Delete event of the gConnectionType control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="RowEventArgs" /> instance containing the event data.</param> protected void gConnectionType_Delete(object sender, RowEventArgs e) { using (var rockContext = new RockContext()) { ConnectionWorkflowService connectionWorkflowService = new ConnectionWorkflowService(rockContext); ConnectionTypeService connectionTypeService = new ConnectionTypeService(rockContext); AuthService authService = new AuthService(rockContext); ConnectionType connectionType = connectionTypeService.Get(e.RowKeyId); if (connectionType != null) { if (!connectionType.IsAuthorized(Authorization.ADMINISTRATE, this.CurrentPerson)) { mdGridWarning.Show("You are not authorized to delete this connection type.", ModalAlertType.Information); return; } // var connectionOppotunityies = new Service<ConnectionOpportunity>( rockContext ).Queryable().All( a => a.ConnectionTypeId == connectionType.Id ); var connectionOpportunities = connectionType.ConnectionOpportunities.ToList(); ConnectionOpportunityService connectionOpportunityService = new ConnectionOpportunityService(rockContext); ConnectionRequestActivityService connectionRequestActivityService = new ConnectionRequestActivityService(rockContext); foreach (var connectionOpportunity in connectionOpportunities) { var connectionRequestActivities = new Service <ConnectionRequestActivity>(rockContext).Queryable().Where(a => a.ConnectionOpportunityId == connectionOpportunity.Id).ToList(); foreach (var connectionRequestActivity in connectionRequestActivities) { connectionRequestActivityService.Delete(connectionRequestActivity); } rockContext.SaveChanges(); string errorMessageConnectionOpportunity; if (!connectionOpportunityService.CanDelete(connectionOpportunity, out errorMessageConnectionOpportunity)) { mdGridWarning.Show(errorMessageConnectionOpportunity, ModalAlertType.Information); return; } connectionOpportunityService.Delete(connectionOpportunity); } rockContext.SaveChanges(); string errorMessage; if (!connectionTypeService.CanDelete(connectionType, out errorMessage)) { mdGridWarning.Show(errorMessage, ModalAlertType.Information); return; } connectionTypeService.Delete(connectionType); rockContext.SaveChanges(); ConnectionWorkflowService.RemoveCachedTriggers(); } } BindGrid(); }
/// <summary> /// Execute method to check for any workflows to launch. /// </summary> public void Execute() { // Verify that valid ids were saved if (ConnectionRequestId.HasValue) { // Get all the connectionWorkflows from cache var cachedWorkflows = ConnectionWorkflowService.GetCachedTriggers(); // If any connectionWorkflows exist if (cachedWorkflows != null && cachedWorkflows.Any()) { // Get the connectionWorkflows associated to the connection var workflows = cachedWorkflows .Where(w => w.TriggerType == ConnectionWorkflowTriggerType.ActivityAdded && ( (w.ConnectionOpportunityId.HasValue && w.ConnectionOpportunityId.Value == ConnectionOpportunityId.Value) || (w.ConnectionTypeId.HasValue) ) ) .ToList(); if (workflows.Any()) { using (var rockContext = new RockContext()) { // Get the current txn's connection type id var ConnectionTypeId = new ConnectionOpportunityService(rockContext) .Queryable().AsNoTracking() .Where(o => o.Id == ConnectionOpportunityId.Value) .Select(o => o.ConnectionTypeId) .FirstOrDefault(); // Further filter the connection type connectionWorkflows by the connection type id workflows = workflows .Where(w => (w.ConnectionOpportunityId.HasValue && w.ConnectionOpportunityId.Value == ConnectionOpportunityId.Value) || (w.ConnectionTypeId.HasValue && w.ConnectionTypeId.Value == ConnectionTypeId)) .ToList(); // Loop through connectionWorkflows and lauch appropriate workflow foreach (var connectionWorkflow in workflows) { if (QualifiersMatch(rockContext, connectionWorkflow, ConnectionActivityTypeId)) { LaunchWorkflow(rockContext, connectionWorkflow, "Activity Added"); } } } } } } }
/// <summary> /// Job that will run quick SQL queries on a schedule. /// /// Called by the <see cref="IScheduler" /> when a /// <see cref="ITrigger" /> fires that is associated with /// the <see cref="IJob" />. /// </summary> public virtual void Execute(IJobExecutionContext context) { _httpContext = HttpContext.Current; // Get all the workflows from cache var cachedWorkflows = ConnectionWorkflowService.GetCachedTriggers(); var futureFollowupDateWorkflows = new List <ConnectionWorkflow>(); if (cachedWorkflows != null && cachedWorkflows.Any()) { futureFollowupDateWorkflows = cachedWorkflows .Where(w => w.TriggerType == ConnectionWorkflowTriggerType.FutureFollowupDateReached ) .ToList(); } var futureFollowupWorkflowResult = TriggerFutureFollowupWorkFlow(context, futureFollowupDateWorkflows); context.UpdateLastStatusMessage($@"Future follow-up Workflow Triggered: {futureFollowupWorkflowResult}"); }
/// <summary> /// Executes this instance. /// </summary> /// <param name="message"></param> public override void Execute(Message message) { if (!(message.ConnectionOpportunityId.HasValue && message.PersonId.HasValue)) { return; } // Get all the workflows from cache var cachedWorkflows = ConnectionWorkflowService.GetCachedTriggers(); if (cachedWorkflows == null || !cachedWorkflows.Any()) { return; } var workflows = cachedWorkflows .Where(w => w.TriggerType != ConnectionWorkflowTriggerType.ActivityAdded && w.TriggerType != ConnectionWorkflowTriggerType.Manual && ( (w.ConnectionOpportunityId.HasValue && w.ConnectionOpportunityId.Value == message.ConnectionOpportunityId.Value) || w.ConnectionTypeId.HasValue )) .ToList(); if (workflows.Any()) { using (var rockContext = new RockContext()) { // Get the current txn's connection type id if (!message.ConnectionTypeId.HasValue) { message.ConnectionTypeId = new ConnectionOpportunityService(rockContext) .Queryable().AsNoTracking() .Where(o => o.Id == message.ConnectionOpportunityId.Value) .Select(o => o.ConnectionTypeId) .FirstOrDefault(); } // Further filter the connection type workflows by the connection type id workflows = workflows .Where(w => (w.ConnectionOpportunityId.HasValue && w.ConnectionOpportunityId.Value == message.ConnectionOpportunityId.Value) || (message.ConnectionTypeId.HasValue && w.ConnectionTypeId.HasValue && w.ConnectionTypeId.Value == message.ConnectionTypeId.Value)) .ToList(); // Loop through connectionWorkflows and launch appropriate workflow foreach (var connectionWorkflow in workflows) { switch (connectionWorkflow.TriggerType) { case ConnectionWorkflowTriggerType.RequestStarted: { if (message.State == EntityContextState.Added) { LaunchWorkflow(rockContext, connectionWorkflow, "Request Started", message); } break; } case ConnectionWorkflowTriggerType.RequestAssigned: { if (message.ConnectorPersonAliasId.HasValue && !message.ConnectorPersonAliasId.Equals(message.PreviousConnectorPersonAliasId)) { LaunchWorkflow(rockContext, connectionWorkflow, "Request Assigned", message); } break; } case ConnectionWorkflowTriggerType.RequestConnected: { if (message.State == EntityContextState.Modified && message.PreviousConnectionState != ConnectionState.Connected && message.ConnectionState == ConnectionState.Connected) { LaunchWorkflow(rockContext, connectionWorkflow, "Request Completed", message); } break; } case ConnectionWorkflowTriggerType.RequestTransferred: { if (message.State == EntityContextState.Modified && !message.PreviousConnectionOpportunityId.Equals(message.ConnectionOpportunityId)) { LaunchWorkflow(rockContext, connectionWorkflow, "Request Transferred", message); } break; } case ConnectionWorkflowTriggerType.PlacementGroupAssigned: { if (message.State == EntityContextState.Modified && !message.PreviousAssignedGroupId.HasValue && message.AssignedGroupId.HasValue) { LaunchWorkflow(rockContext, connectionWorkflow, "Group Assigned", message); } break; } case ConnectionWorkflowTriggerType.StatusChanged: { if (message.State == EntityContextState.Modified && QualifiersMatch(rockContext, connectionWorkflow, message.PreviousConnectionStatusId, message.ConnectionStatusId)) { LaunchWorkflow(rockContext, connectionWorkflow, "Status Changed", message); } break; } case ConnectionWorkflowTriggerType.StateChanged: { if (message.State == EntityContextState.Modified && QualifiersMatch(rockContext, connectionWorkflow, message.PreviousConnectionState, message.ConnectionState)) { LaunchWorkflow(rockContext, connectionWorkflow, "State Changed", message); } break; } } } } } }
/// <summary> /// Execute method to check for any workflows to launch. /// </summary> public void Execute() { // Verify that valid ids were saved if (ConnectionOpportunityId.HasValue && PersonId.HasValue) { // Get all the workflows from cache var cachedWorkflows = ConnectionWorkflowService.GetCachedTriggers(); // If any workflows exist if (cachedWorkflows != null && cachedWorkflows.Any()) { // Get the workflows associated to the connection var connectionOpportunityWorkflows = cachedWorkflows .Where(w => w.TriggerType != ConnectionWorkflowTriggerType.ActivityAdded && w.ConnectionOpportunityId.HasValue && w.ConnectionOpportunityId.Value == ConnectionOpportunityId.Value) .ToList(); // Get any workflows associated to a connection type ( if any are found, will then filter by connection type ) var connectionTypeWorkflows = cachedWorkflows .Where(w => w.TriggerType != ConnectionWorkflowTriggerType.ActivityAdded && w.ConnectionTypeId.HasValue) .ToList(); if (connectionOpportunityWorkflows.Any() || connectionTypeWorkflows.Any()) { using (var rockContext = new RockContext()) { // If there were any connection type workflows, will now need to read the opportunity's connection type id // and then further filter these workflows by the current txn's connection type if (connectionTypeWorkflows.Any()) { // Get the current txn's connection type id if (!ConnectionTypeId.HasValue) { ConnectionTypeId = new ConnectionOpportunityService(rockContext) .Queryable().AsNoTracking() .Where(o => o.Id == ConnectionOpportunityId.Value) .Select(o => o.ConnectionTypeId) .FirstOrDefault(); } // Further filter the connection type workflows by the connection type id connectionTypeWorkflows = connectionTypeWorkflows .Where(t => t.ConnectionTypeId.HasValue && t.ConnectionTypeId.Equals(ConnectionTypeId)) .ToList(); } // Combine connection opportunity and connection type trigers var connectionWorkflows = connectionOpportunityWorkflows.Union(connectionTypeWorkflows).ToList(); // If any connectionWorkflows were found if (connectionWorkflows.Any()) { // Loop through connectionWorkflows and lauch appropriate workflow foreach (var connectionWorkflow in connectionWorkflows) { switch (connectionWorkflow.TriggerType) { case ConnectionWorkflowTriggerType.RequestStarted: { if (State == EntityState.Added && QualifiersMatch(rockContext, connectionWorkflow, ConnectionState, ConnectionState, ConnectionStatusId, ConnectionStatusId, AssignedGroupId)) { LaunchWorkflow(rockContext, connectionWorkflow, "Request Started"); } break; } case ConnectionWorkflowTriggerType.RequestConnected: { if (State == EntityState.Modified && ConnectionState == global::ConnectionState.Inactive) { LaunchWorkflow(rockContext, connectionWorkflow, "Request Completed"); } break; } case ConnectionWorkflowTriggerType.StatusChanged: { if (State == EntityState.Modified && QualifiersMatch(rockContext, connectionWorkflow, PreviousConnectionStatusId, ConnectionStatusId)) { LaunchWorkflow(rockContext, connectionWorkflow, "Status Changed"); } break; } case ConnectionWorkflowTriggerType.StateChanged: { if (State == EntityState.Modified && QualifiersMatch(rockContext, connectionWorkflow, PreviousConnectionState, ConnectionState)) { LaunchWorkflow(rockContext, connectionWorkflow, "State Changed"); } break; } case ConnectionWorkflowTriggerType.PlacementGroupAssigned: { if (State == EntityState.Modified && QualifiersMatch(rockContext, connectionWorkflow, AssignedGroupId)) { LaunchWorkflow(rockContext, connectionWorkflow, "Group Assigned"); } break; } } } } } } } } }
/// <summary> /// Execute method to check for any workflows to launch. /// </summary> public void Execute() { // Verify that valid ids were saved if (ConnectionRequestId.HasValue) { // Get all the connectionWorkflows from cache var cachedWorkflows = ConnectionWorkflowService.GetCachedTriggers(); // If any connectionWorkflows exist if (cachedWorkflows != null && cachedWorkflows.Any()) { // Get the connectionWorkflows associated to the connection var connectionOpportunityWorkflows = cachedWorkflows .Where(w => w.TriggerType == ConnectionWorkflowTriggerType.ActivityAdded && w.ConnectionOpportunityId.HasValue && w.ConnectionOpportunityId.Value == ConnectionOpportunityId.Value) .ToList(); // Get any connectionWorkflows associated to a connection type ( if any are found, will then filter by connection type ) var connectionTypeWorkflows = cachedWorkflows .Where(w => w.TriggerType == ConnectionWorkflowTriggerType.ActivityAdded && w.ConnectionTypeId.HasValue) .ToList(); if (connectionOpportunityWorkflows.Any() || connectionTypeWorkflows.Any()) { using (var rockContext = new RockContext()) { // If there were any connection type connectionWorkflows, will now need to read the opportunity's connection type id // and then further filter these connectionWorkflows by the current txn's connection type if (connectionTypeWorkflows.Any()) { // Get the current txn's connection type id var ConnectionTypeId = new ConnectionOpportunityService(rockContext) .Queryable().AsNoTracking() .Where(o => o.Id == ConnectionOpportunityId.Value) .Select(o => o.ConnectionTypeId) .FirstOrDefault(); // Further filter the connection type connectionWorkflows by the connection type id connectionTypeWorkflows = connectionTypeWorkflows .Where(t => t.ConnectionTypeId.HasValue && t.ConnectionTypeId.Equals(ConnectionTypeId)) .ToList(); } // Combine connection opportunity and connection type trigers var connectionWorkflows = connectionOpportunityWorkflows.Union(connectionTypeWorkflows).ToList(); // If any connectionWorkflows were found if (connectionWorkflows.Any()) { // Loop through connectionWorkflows and lauch appropriate workflow foreach (var connectionWorkflow in connectionWorkflows) { if (QualifiersMatch(rockContext, connectionWorkflow, ConnectionActivityTypeId)) { LaunchWorkflow(rockContext, connectionWorkflow, "Activity Added"); } } } } } } } }