public static void Start(SchemaBuilder sb) { if (sb.NotDefined(MethodInfo.GetCurrentMethod())) { AuthLogic.AssertStarted(sb); OperationLogic.AssertStarted(sb); OperationLogic.AllowOperation += OperationLogic_AllowOperation; cache = new AuthCache <RuleOperationEntity, OperationAllowedRule, OperationSymbol, OperationSymbol, OperationAllowed>(sb, s => s, s => s, merger: new OperationMerger(), invalidateWithTypes: true, coercer: OperationCoercer.Instance); AuthLogic.ExportToXml += exportAll => cache.ExportXml("Operations", "Operation", s => s.Key, b => b.ToString(), exportAll ? OperationLogic.RegisteredOperations.ToList() : null); AuthLogic.ImportFromXml += (x, roles, replacements) => { string replacementKey = "AuthRules:" + typeof(OperationSymbol).Name; replacements.AskForReplacements( x.Element("Operations").Elements("Role").SelectMany(r => r.Elements("Operation")).Select(p => p.Attribute("Resource").Value).ToHashSet(), SymbolLogic <OperationSymbol> .AllUniqueKeys(), replacementKey); return(cache.ImportXml(x, "Operations", "Operation", roles, s => SymbolLogic <OperationSymbol> .TryToSymbol(replacements.Apply(replacementKey, s)), EnumExtensions.ToEnum <OperationAllowed>)); }; } }
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm) { if (sb.NotDefined(MethodInfo.GetCurrentMethod())) { sb.Include <ProcessAlgorithmSymbol>() .WithQuery(dqm, () => pa => new { Entity = pa, pa.Id, pa.Key }); sb.Include <ProcessEntity>() .WithQuery(dqm, () => p => new { Entity = p, p.Id, p.Algorithm, p.Data, p.State, p.MachineName, p.ApplicationName, p.CreationDate, p.PlannedDate, p.CancelationDate, p.QueuedDate, p.ExecutionStart, p.ExecutionEnd, p.SuspendDate, p.ExceptionDate, }); sb.Include <ProcessExceptionLineEntity>() .WithQuery(dqm, () => p => new { Entity = p, p.Line, p.Process, p.Exception, }); PermissionAuthLogic.RegisterPermissions(ProcessPermission.ViewProcessPanel); SymbolLogic <ProcessAlgorithmSymbol> .Start(sb, dqm, () => registeredProcesses.Keys.ToHashSet()); OperationLogic.AssertStarted(sb); ProcessGraph.Register(); dqm.RegisterExpression((ProcessAlgorithmSymbol p) => p.Processes(), () => typeof(ProcessEntity).NicePluralName()); dqm.RegisterExpression((ProcessAlgorithmSymbol p) => p.LastProcess(), () => ProcessMessage.LastProcess.NiceToString()); dqm.RegisterExpression((IProcessDataEntity p) => p.Processes(), () => typeof(ProcessEntity).NicePluralName()); dqm.RegisterExpression((IProcessDataEntity p) => p.LastProcess(), () => ProcessMessage.LastProcess.NiceToString()); dqm.RegisterExpression((IProcessLineDataEntity p) => p.ExceptionLines(), () => ProcessMessage.ExceptionLines.NiceToString()); PropertyAuthLogic.AvoidAutomaticUpgradeCollection.Add(PropertyRoute.Construct((ProcessEntity p) => p.User)); ExceptionLogic.DeleteLogs += ExceptionLogic_DeleteLogs; } }
public static void Start(SchemaBuilder sb) { if (sb.NotDefined(MethodInfo.GetCurrentMethod())) { AuthLogic.AssertStarted(sb); OperationLogic.AssertStarted(sb); Implementations imp = sb.Settings.GetImplementations((ScheduledTaskEntity st) => st.Task); Implementations imp2 = sb.Settings.GetImplementations((ScheduledTaskLogEntity st) => st.Task); if (!imp2.Equals(imp2)) { throw new InvalidOperationException("Implementations of ScheduledTaskEntity.Task should be the same as in ScheduledTaskLogEntity.Task"); } PermissionAuthLogic.RegisterPermissions(SchedulerPermission.ViewSchedulerPanel); ExecuteTask.Register((ITaskEntity t, ScheduledTaskContext ctx) => { throw new NotImplementedException("SchedulerLogic.ExecuteTask not registered for {0}".FormatWith(t.GetType().Name)); }); SimpleTaskLogic.Start(sb); sb.Include <ScheduledTaskEntity>() .WithQuery(() => st => new { Entity = st, st.Id, st.Task, st.Rule, st.Suspended, st.MachineName, st.ApplicationName }); sb.Include <ScheduledTaskLogEntity>() .WithIndex(s => s.ScheduledTask, includeFields: s => s.StartTime) .WithQuery(() => cte => new { Entity = cte, cte.Id, cte.Task, cte.ScheduledTask, cte.StartTime, cte.EndTime, cte.ProductEntity, cte.MachineName, cte.User, cte.Exception, }); sb.Include <SchedulerTaskExceptionLineEntity>() .WithQuery(() => cte => new { Entity = cte, cte.Id, cte.ElementInfo, cte.Exception, cte.SchedulerTaskLog, }); new Graph <ScheduledTaskLogEntity> .Execute(ScheduledTaskLogOperation.CancelRunningTask) { CanExecute = e => RunningTasks.ContainsKey(e) ? null : SchedulerMessage.TaskIsNotRunning.NiceToString(), Execute = (e, _) => { RunningTasks[e].CancellationTokenSource.Cancel(); }, } .Register(); sb.Include <HolidayCalendarEntity>() .WithQuery(() => st => new { Entity = st, st.Id, st.Name, Holidays = st.Holidays.Count, }); QueryLogic.Expressions.Register((ITaskEntity ct) => ct.Executions(), () => ITaskMessage.Executions.NiceToString()); QueryLogic.Expressions.Register((ITaskEntity ct) => ct.LastExecution(), () => ITaskMessage.LastExecution.NiceToString()); QueryLogic.Expressions.Register((ScheduledTaskEntity ct) => ct.Executions(), () => ITaskMessage.Executions.NiceToString()); QueryLogic.Expressions.Register((ScheduledTaskLogEntity ct) => ct.ExceptionLines(), () => ITaskMessage.ExceptionLines.NiceToString()); new Graph <HolidayCalendarEntity> .Execute(HolidayCalendarOperation.Save) { CanBeNew = true, CanBeModified = true, Execute = (c, _) => { }, } .Register(); new Graph <HolidayCalendarEntity> .Delete(HolidayCalendarOperation.Delete) { Delete = (c, _) => { c.Delete(); }, } .Register(); new Graph <ScheduledTaskEntity> .Execute(ScheduledTaskOperation.Save) { CanBeNew = true, CanBeModified = true, Execute = (st, _) => { }, } .Register(); new Graph <ScheduledTaskEntity> .Delete(ScheduledTaskOperation.Delete) { Delete = (st, _) => { st.Executions().UnsafeUpdate().Set(l => l.ScheduledTask, l => null).Execute(); var rule = st.Rule; st.Delete(); rule.Delete(); }, } .Register(); new Graph <ScheduledTaskLogEntity> .ConstructFrom <ITaskEntity>(ITaskOperation.ExecuteSync) { Construct = (task, _) => ExecuteSync(task, null, UserHolder.Current) } .Register(); new Graph <ITaskEntity> .Execute(ITaskOperation.ExecuteAsync) { Execute = (task, _) => ExecuteAsync(task, null, UserHolder.Current) } .Register(); ScheduledTasksLazy = sb.GlobalLazy(() => Database.Query <ScheduledTaskEntity>().Where(a => !a.Suspended && (a.MachineName == ScheduledTaskEntity.None || a.MachineName == Environment.MachineName && a.ApplicationName == Schema.Current.ApplicationName)).ToList(), new InvalidateWith(typeof(ScheduledTaskEntity))); ScheduledTasksLazy.OnReset += ScheduledTasksLazy_OnReset; sb.Schema.EntityEvents <ScheduledTaskLogEntity>().PreUnsafeDelete += query => { query.SelectMany(e => e.ExceptionLines()).UnsafeDelete(); return(null); }; ExceptionLogic.DeleteLogs += ExceptionLogic_DeleteLogs; } }