public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include <EmailMasterTemplateEntity>()
.WithQuery(() => t => new
{
Entity = t,
t.Id,
t.Name,
});
EmailMasterTemplateGraph.Register();
Validator.PropertyValidator <EmailMasterTemplateEntity>(et => et.Messages).StaticPropertyValidation += (et, pi) =>
{
var dc = EmailLogic.Configuration.DefaultCulture;
if (!et.Messages.Any(m => dc.Name.StartsWith(m.CultureInfo.Name)))
{
return(EmailTemplateMessage.ThereMustBeAMessageFor0.NiceToString().FormatWith(CultureInfoLogic.EntityToCultureInfo.Value.Keys.Where(c => dc.Name.StartsWith(c.EnglishName)).CommaOr(a => a.EnglishName)));
}
return(null);
};
UserAssetsImporter.Register <EmailMasterTemplateEntity>("EmailMasterTemplate", EmailMasterTemplateOperation.Save);
}
}
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Schema.Generating += Schema_Generating;
sb.Schema.Synchronizing += Schema_Synchronizing;
sb.Include <EmailModelEntity>()
.WithQuery(() => se => new
{
Entity = se,
se.Id,
se.FullClassName,
});
UserAssetsImporter.Register <EmailTemplateEntity>("EmailTemplate", EmailTemplateOperation.Save);
new Graph <EmailTemplateEntity> .ConstructFrom <EmailModelEntity>(EmailTemplateOperation.CreateEmailTemplateFromModel)
{
Construct = (se, _) => CreateDefaultTemplateInternal(se)
}
.Register();
EmailModelToTemplates = sb.GlobalLazy(() => (
from et in Database.Query <EmailTemplateEntity>()
where et.Model != null
select new { se = et.Model, et })
.GroupToDictionary(pair => pair.se !.ToLite(), pair => pair.et !), /*CSBUG*/
new InvalidateWith(typeof(EmailModelEntity), typeof(EmailTemplateEntity)));
typeToEntity = sb.GlobalLazy(() =>
{
var dbModels = Database.RetrieveAll <EmailModelEntity>();
return(EnumerableExtensions.JoinRelaxed(
dbModels,
registeredModels.Keys,
entity => entity.FullClassName,
type => type.FullName !,
(entity, type) => KeyValuePair.Create(type, entity),
"caching " + nameof(EmailModelEntity))
.ToDictionary());
}, new InvalidateWith(typeof(EmailModelEntity)));
sb.Schema.Initializing += () => typeToEntity.Load();
entityToType = sb.GlobalLazy(() => typeToEntity.Value.Inverse(),
new InvalidateWith(typeof(EmailModelEntity)));
}
}
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include <JoyrideEntity>()
.WithSave(JoyrideOperation.Save)
.WithQuery(() => e => new
{
Entity = e,
e.Id,
e.Name,
e.Culture
});
sb.Include <JoyrideStepEntity>()
.WithSave(JoyrideStepOperation.Save)
.WithQuery(() => e => new
{
Entity = e,
e.Id,
e.Title,
e.Culture,
e.Selector,
e.Type,
e.Position,
});
sb.Include <JoyrideStepStyleEntity>()
.WithSave(JoyrideStepStyleOperation.Save)
.WithQuery(() => e => new
{
Entity = e,
e.Id,
e.Name
});
UserAssetsImporter.Register <JoyrideEntity>("Joyride", JoyrideOperation.Save);
UserAssetsImporter.Register <JoyrideStepEntity>("JoyrideStep", JoyrideStepOperation.Save);
UserAssetsImporter.Register <JoyrideStepStyleEntity>("JoyrideStepStyle", JoyrideStepStyleOperation.Save);
}
}
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
UserAssetsImporter.Register <UserChartEntity>("UserChart", UserChartOperation.Save);
sb.Schema.Synchronizing += Schema_Synchronizing;
sb.Include <UserChartEntity>()
.WithSave(UserChartOperation.Save)
.WithDelete(UserChartOperation.Delete)
.WithQuery(() => uq => new
{
Entity = uq,
uq.Id,
uq.Query,
uq.EntityType,
uq.DisplayName,
uq.ChartScript,
uq.Owner,
});
sb.Schema.EntityEvents <UserChartEntity>().Retrieved += ChartLogic_Retrieved;
sb.Schema.Table <QueryEntity>().PreDeleteSqlSync += e =>
Administrator.UnsafeDeletePreCommand(Database.Query <UserChartEntity>().Where(a => a.Query.Is(e)));
UserCharts = sb.GlobalLazy(() => Database.Query <UserChartEntity>().ToDictionary(a => a.ToLite()),
new InvalidateWith(typeof(UserChartEntity)));
UserChartsByQuery = sb.GlobalLazy(() => UserCharts.Value.Values.Where(a => a.EntityType == null).SelectCatch(uc => KeyValuePair.Create(uc.Query.ToQueryName(), uc.ToLite())).GroupToDictionary(),
new InvalidateWith(typeof(UserChartEntity)));
UserChartsByTypeForQuickLinks = sb.GlobalLazy(() => UserCharts.Value.Values.Where(a => a.EntityType != null && !a.HideQuickLink)
.SelectCatch(a => KeyValuePair.Create(TypeLogic.IdToType.GetOrThrow(a.EntityType !.Id), a.ToLite()))
.GroupToDictionary(),
new InvalidateWith(typeof(UserChartEntity)));
}
}
public static void Start(SchemaBuilder sb, Func <WorkflowConfigurationEmbedded> getConfiguration)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
PermissionAuthLogic.RegisterPermissions(WorkflowPermission.ViewWorkflowPanel);
PermissionAuthLogic.RegisterPermissions(WorkflowPermission.ViewCaseFlow);
PermissionAuthLogic.RegisterPermissions(WorkflowPermission.WorkflowToolbarMenu);
WorkflowLogic.getConfiguration = getConfiguration;
UserAssetsImporter.Register <WorkflowEntity>("Workflow", WorkflowOperation.Save);
UserAssetsImporter.Register <WorkflowScriptEntity>("WorkflowScript", WorkflowScriptOperation.Save);
UserAssetsImporter.Register <WorkflowTimerConditionEntity>("WorkflowTimerCondition", WorkflowTimerConditionOperation.Save);
UserAssetsImporter.Register <WorkflowConditionEntity>("WorkflowCondition", WorkflowConditionOperation.Save);
UserAssetsImporter.Register <WorkflowActionEntity>("WorkflowAction", WorkflowActionOperation.Save);
UserAssetsImporter.Register <WorkflowScriptRetryStrategyEntity>("WorkflowScriptRetryStrategy", WorkflowScriptRetryStrategyOperation.Save);
sb.Include <WorkflowEntity>()
.WithConstruct(WorkflowOperation.Create)
.WithQuery(() => DynamicQueryCore.Auto(
from e in Database.Query <WorkflowEntity>()
select new
{
Entity = e,
e.Id,
e.Name,
e.MainEntityType,
HasExpired = e.HasExpired(),
e.ExpirationDate,
})
.ColumnDisplayName(a => a.HasExpired, () => WorkflowMessage.HasExpired.NiceToString()))
.WithExpressionFrom((CaseActivityEntity ca) => ca.Workflow());
WorkflowGraph.Register();
QueryLogic.Expressions.Register((WorkflowEntity wf) => wf.WorkflowStartEvent());
QueryLogic.Expressions.Register((WorkflowEntity wf) => wf.HasExpired(), WorkflowMessage.HasExpired);
sb.AddIndex((WorkflowEntity wf) => wf.ExpirationDate);
DynamicCode.GetCustomErrors += GetCustomErrors;
Workflows = sb.GlobalLazy(() => Database.Query <WorkflowEntity>().ToDictionary(a => a.ToLite()),
new InvalidateWith(typeof(WorkflowEntity)));
sb.Include <WorkflowPoolEntity>()
.WithUniqueIndex(wp => new { wp.Workflow, wp.Name })
.WithSave(WorkflowPoolOperation.Save)
.WithDelete(WorkflowPoolOperation.Delete)
.WithExpressionFrom((WorkflowEntity p) => p.WorkflowPools())
.WithQuery(() => e => new
{
Entity = e,
e.Id,
e.Name,
e.BpmnElementId,
e.Workflow,
});
sb.Include <WorkflowLaneEntity>()
.WithUniqueIndex(wp => new { wp.Pool, wp.Name })
.WithSave(WorkflowLaneOperation.Save)
.WithDelete(WorkflowLaneOperation.Delete)
.WithExpressionFrom((WorkflowPoolEntity p) => p.WorkflowLanes())
.WithQuery(() => e => new
{
Entity = e,
e.Id,
e.Name,
e.BpmnElementId,
e.Pool,
e.Pool.Workflow,
});
sb.Include <WorkflowActivityEntity>()
.WithUniqueIndex(w => new { w.Lane, w.Name })
.WithSave(WorkflowActivityOperation.Save)
.WithDelete(WorkflowActivityOperation.Delete)
.WithExpressionFrom((WorkflowEntity p) => p.WorkflowActivities())
.WithExpressionFrom((WorkflowLaneEntity p) => p.WorkflowActivities())
.WithVirtualMList(wa => wa.BoundaryTimers, e => e.BoundaryOf, WorkflowEventOperation.Save, WorkflowEventOperation.Delete)
.WithQuery(() => e => new
{
Entity = e,
e.Id,
e.Name,
e.BpmnElementId,
e.Comments,
e.Lane,
e.Lane.Pool.Workflow,
});
sb.Include <WorkflowEventEntity>()
.WithExpressionFrom((WorkflowEntity p) => p.WorkflowEvents())
.WithExpressionFrom((WorkflowLaneEntity p) => p.WorkflowEvents())
.WithQuery(() => e => new
{
Entity = e,
e.Id,
e.Type,
e.Name,
e.BpmnElementId,
e.Lane,
e.Lane.Pool.Workflow,
});
new Graph <WorkflowEventEntity> .Execute(WorkflowEventOperation.Save)
{
CanBeNew = true,
CanBeModified = true,
Execute = (e, _) =>
{
if (e.Timer == null && e.Type.IsTimer())
{
throw new InvalidOperationException(ValidationMessage._0IsMandatoryWhen1IsSetTo2.NiceToString(e.NicePropertyName(a => a.Timer), e.NicePropertyName(a => a.Type), e.Type.NiceToString()));
}
if (e.Timer != null && !e.Type.IsTimer())
{
throw new InvalidOperationException(ValidationMessage._0ShouldBeNullWhen1IsSetTo2.NiceToString(e.NicePropertyName(a => a.Timer), e.NicePropertyName(a => a.Type), e.Type.NiceToString()));
}
if (e.BoundaryOf == null && e.Type.IsBoundaryTimer())
{
throw new InvalidOperationException(ValidationMessage._0IsMandatoryWhen1IsSetTo2.NiceToString(e.NicePropertyName(a => a.BoundaryOf), e.NicePropertyName(a => a.Type), e.Type.NiceToString()));
}
if (e.BoundaryOf != null && !e.Type.IsBoundaryTimer())
{
throw new InvalidOperationException(ValidationMessage._0ShouldBeNullWhen1IsSetTo2.NiceToString(e.NicePropertyName(a => a.BoundaryOf), e.NicePropertyName(a => a.Type), e.Type.NiceToString()));
}
e.Save();
},
}
.Register();
new Graph <WorkflowEventEntity> .Delete(WorkflowEventOperation.Delete)
{
Delete = (e, _) =>
{
if (e.Type.IsScheduledStart())
{
var scheduled = e.ScheduledTask();
if (scheduled != null)
{
WorkflowEventTaskLogic.DeleteWorkflowEventScheduledTask(scheduled);
}
}
e.Delete();
},
}
.Register();
sb.Include <WorkflowGatewayEntity>()
.WithSave(WorkflowGatewayOperation.Save)
.WithDelete(WorkflowGatewayOperation.Delete)
.WithExpressionFrom((WorkflowEntity p) => p.WorkflowGateways())
.WithExpressionFrom((WorkflowLaneEntity p) => p.WorkflowGateways())
.WithQuery(() => e => new
{
Entity = e,
e.Id,
e.Type,
e.Name,
e.BpmnElementId,
e.Lane,
e.Lane.Pool.Workflow,
});
sb.Include <WorkflowConnectionEntity>()
.WithSave(WorkflowConnectionOperation.Save)
.WithDelete(WorkflowConnectionOperation.Delete)
.WithExpressionFrom((WorkflowEntity p) => p.WorkflowConnections())
.WithExpressionFrom((WorkflowEntity p) => p.WorkflowMessageConnections(), null !)
.WithExpressionFrom((WorkflowPoolEntity p) => p.WorkflowConnections())
.WithExpressionFrom((IWorkflowNodeEntity p) => p.NextConnections(), null !)
.WithExpressionFrom((IWorkflowNodeEntity p) => p.PreviousConnections(), null !)
.WithQuery(() => e => new
{
Entity = e,
e.Id,
e.Name,
e.BpmnElementId,
e.From,
e.To,
});
WorkflowEventTaskEntity.GetWorkflowEntity = lite => WorkflowGraphLazy.Value.GetOrThrow(lite).Workflow;
WorkflowGraphLazy = sb.GlobalLazy(() =>
{
using (new EntityCache())
{
var events = Database.RetrieveAll <WorkflowEventEntity>().GroupToDictionary(a => a.Lane.Pool.Workflow.ToLite());
var gateways = Database.RetrieveAll <WorkflowGatewayEntity>().GroupToDictionary(a => a.Lane.Pool.Workflow.ToLite());
var activities = Database.RetrieveAll <WorkflowActivityEntity>().GroupToDictionary(a => a.Lane.Pool.Workflow.ToLite());
var connections = Database.RetrieveAll <WorkflowConnectionEntity>().GroupToDictionary(a => a.From.Lane.Pool.Workflow.ToLite());
var result = Database.RetrieveAll <WorkflowEntity>().ToDictionary(workflow => workflow.ToLite(), workflow =>
{
var w = workflow.ToLite();
var nodeGraph = new WorkflowNodeGraph
{
Workflow = workflow,
Events = events.TryGetC(w).EmptyIfNull().ToDictionary(e => e.ToLite()),
Gateways = gateways.TryGetC(w).EmptyIfNull().ToDictionary(g => g.ToLite()),
Activities = activities.TryGetC(w).EmptyIfNull().ToDictionary(a => a.ToLite()),
Connections = connections.TryGetC(w).EmptyIfNull().ToDictionary(c => c.ToLite()),
};
nodeGraph.FillGraphs();
return(nodeGraph);
});
return(result);
}
}, new InvalidateWith(typeof(WorkflowConnectionEntity)));
WorkflowGraphLazy.OnReset += (e, args) => DynamicCode.OnInvalidated?.Invoke();
Validator.PropertyValidator((WorkflowConnectionEntity c) => c.Condition).StaticPropertyValidation = (e, pi) =>
{
if (e.Condition != null && e.From != null)
{
var conditionType = (e.Condition.EntityOrNull ?? Conditions.Value.GetOrThrow(e.Condition)).MainEntityType;
var workflowType = e.From.Lane.Pool.Workflow.MainEntityType;
if (!conditionType.Is(workflowType))
{
return(WorkflowMessage.Condition0IsDefinedFor1Not2.NiceToString(conditionType, workflowType));
}
}
return(null);
};
StartWorkflowConditions(sb);
StartWorkflowTimerConditions(sb);
StartWorkflowActions(sb);
StartWorkflowScript(sb);
}
}
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);
QueryLogic.Expressions.Register((ITaskEntity ct) => ct.LastExecution(), ITaskMessage.LastExecution);
QueryLogic.Expressions.Register((ScheduledTaskEntity ct) => ct.Executions(), ITaskMessage.Executions);
QueryLogic.Expressions.Register((ScheduledTaskLogEntity ct) => ct.ExceptionLines(), ITaskMessage.ExceptionLines);
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);
};
UserAssetsImporter.Register <ScheduleRuleMinutelyEntity>("ScheduleRuleMinutely", e => e.Save());
UserAssetsImporter.Register <ScheduleRuleMonthsEntity>("ScheduleRuleMonths", e => e.Save());
UserAssetsImporter.Register <ScheduleRuleWeekDaysEntity>("ScheduleRuleWeekDays", e => e.Save());
UserAssetsImporter.Register <HolidayCalendarEntity>("HolidayCalendar", HolidayCalendarOperation.Save);
ExceptionLogic.DeleteLogs += ExceptionLogic_DeleteLogs;
}
}
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include <ToolbarEntity>()
.WithSave(ToolbarOperation.Save)
.WithDelete(ToolbarOperation.Delete)
.WithQuery(() => e => new
{
Entity = e,
e.Id,
e.Name,
e.Owner,
e.Priority
});
sb.Include <ToolbarMenuEntity>()
.WithSave(ToolbarMenuOperation.Save)
.WithDelete(ToolbarMenuOperation.Delete)
.WithQuery(() => e => new
{
Entity = e,
e.Id,
e.Name
});
UserAssetsImporter.Register <ToolbarEntity>("Toolbar", ToolbarOperation.Save);
UserAssetsImporter.Register <ToolbarMenuEntity>("ToolbarMenu", ToolbarMenuOperation.Save);
RegisterDelete <UserQueryEntity>(sb);
RegisterDelete <UserChartEntity>(sb);
RegisterDelete <QueryEntity>(sb);
RegisterDelete <DashboardEntity>(sb);
RegisterDelete <ToolbarMenuEntity>(sb);
RegisterDelete <WorkflowEntity>(sb);
RegisterContentConfig <ToolbarMenuEntity>(
lite => true,
lite => TranslatedInstanceLogic.TranslatedField(ToolbarMenus.Value.GetOrCreate(lite), a => a.Name));
RegisterContentConfig <UserQueryEntity>(
lite => { var uq = UserQueryLogic.UserQueries.Value.GetOrCreate(lite); return(InMemoryFilter(uq) && QueryLogic.Queries.QueryAllowed(uq.Query.ToQueryName(), true)); },
lite => TranslatedInstanceLogic.TranslatedField(UserQueryLogic.UserQueries.Value.GetOrCreate(lite), a => a.DisplayName));
RegisterContentConfig <UserChartEntity>(
lite => { var uc = UserChartLogic.UserCharts.Value.GetOrCreate(lite); return(InMemoryFilter(uc) && QueryLogic.Queries.QueryAllowed(uc.Query.ToQueryName(), true)); },
lite => TranslatedInstanceLogic.TranslatedField(UserChartLogic.UserCharts.Value.GetOrCreate(lite), a => a.DisplayName));
RegisterContentConfig <QueryEntity>(
lite => IsQueryAllowed(lite),
lite => QueryUtils.GetNiceName(QueryLogic.QueryNames.GetOrThrow(lite.ToString() !)));
RegisterContentConfig <DashboardEntity>(
lite => InMemoryFilter(DashboardLogic.Dashboards.Value.GetOrCreate(lite)),
lite => TranslatedInstanceLogic.TranslatedField(DashboardLogic.Dashboards.Value.GetOrCreate(lite), a => a.DisplayName));
RegisterContentConfig <PermissionSymbol>(
lite => PermissionAuthLogic.IsAuthorized(SymbolLogic <PermissionSymbol> .ToSymbol(lite.ToString() !)),
lite => SymbolLogic <PermissionSymbol> .ToSymbol(lite.ToString() !).NiceToString());
RegisterContentConfig <WorkflowEntity>(
lite => { var wf = WorkflowLogic.WorkflowGraphLazy.Value.GetOrCreate(lite); return(InMemoryFilter(wf.Workflow) && wf.IsStartCurrentUser()); },
lite => TranslatedInstanceLogic.TranslatedField(WorkflowLogic.WorkflowGraphLazy.Value.GetOrCreate(lite).Workflow, a => a.Name));
// { typeof(QueryEntity), a => IsQueryAllowed((Lite<QueryEntity>)a) },
//{ typeof(PermissionSymbol), a => PermissionAuthLogic.IsAuthorized((PermissionSymbol)a.RetrieveAndRemember()) },
//{ typeof(UserQueryEntity), a => ,
//{ typeof(UserChartEntity), a => { var uc = UserChartLogic.UserCharts.Value.GetOrCreate((Lite<UserChartEntity>)a); return InMemoryFilter(uc) && QueryLogic.Queries.QueryAllowed(uc.Query.ToQueryName(), true); } },
//{ typeof(DashboardEntity), a => InMemoryFilter(DashboardLogic.Dashboards.Value.GetOrCreate((Lite<DashboardEntity>)a)) },
//{ typeof(WorkflowEntity), a => { var wf = WorkflowLogic.WorkflowGraphLazy.Value.GetOrCreate((Lite<WorkflowEntity>)a); return InMemoryFilter(wf.Workflow) && wf.IsStartCurrentUser(); } },
Toolbars = sb.GlobalLazy(() => Database.Query <ToolbarEntity>().ToDictionary(a => a.ToLite()),
new InvalidateWith(typeof(ToolbarEntity)));
ToolbarMenus = sb.GlobalLazy(() => Database.Query <ToolbarMenuEntity>().ToDictionary(a => a.ToLite()),
new InvalidateWith(typeof(ToolbarMenuEntity)));
}
}
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
PermissionAuthLogic.RegisterPermissions(DashboardPermission.ViewDashboard);
UserAssetsImporter.Register <DashboardEntity>("Dashboard", DashboardOperation.Save);
UserAssetsImporter.PartNames.AddRange(new Dictionary <string, Type>
{
{ "UserChartPart", typeof(UserChartPartEntity) },
{ "CombinedUserChartPart", typeof(CombinedUserChartPartEntity) },
{ "UserQueryPart", typeof(UserQueryPartEntity) },
{ "LinkListPart", typeof(LinkListPartEntity) },
{ "ValueUserQueryListPart", typeof(ValueUserQueryListPartEntity) },
{ "UserTreePart", typeof(UserTreePartEntity) },
});
sb.Include <DashboardEntity>()
.WithQuery(() => cp => new
{
Entity = cp,
cp.Id,
cp.DisplayName,
cp.EntityType,
cp.Owner,
cp.DashboardPriority,
});
if (sb.Settings.ImplementedBy((DashboardEntity cp) => cp.Parts.First().Content, typeof(UserQueryPartEntity)))
{
sb.Schema.EntityEvents <UserQueryEntity>().PreUnsafeDelete += query =>
{
Database.MListQuery((DashboardEntity cp) => cp.Parts).Where(mle => query.Contains(((UserQueryPartEntity)mle.Element.Content).UserQuery)).UnsafeDeleteMList();
Database.Query <UserQueryPartEntity>().Where(uqp => query.Contains(uqp.UserQuery)).UnsafeDelete();
return(null);
};
sb.Schema.Table <UserQueryEntity>().PreDeleteSqlSync += arg =>
{
var uq = (UserQueryEntity)arg;
var parts = Administrator.UnsafeDeletePreCommandMList((DashboardEntity cp) => cp.Parts, Database.MListQuery((DashboardEntity cp) => cp.Parts)
.Where(mle => ((UserQueryPartEntity)mle.Element.Content).UserQuery == uq));
var parts2 = Administrator.UnsafeDeletePreCommand(Database.Query <UserQueryPartEntity>()
.Where(mle => mle.UserQuery == uq));
return(SqlPreCommand.Combine(Spacing.Simple, parts, parts2));
};
}
if (sb.Settings.ImplementedBy((DashboardEntity cp) => cp.Parts.First().Content, typeof(UserChartPartEntity)))
{
sb.Schema.EntityEvents <UserChartEntity>().PreUnsafeDelete += query =>
{
Database.MListQuery((DashboardEntity cp) => cp.Parts).Where(mle => query.Contains(((UserChartPartEntity)mle.Element.Content).UserChart)).UnsafeDeleteMList();
Database.Query <UserChartPartEntity>().Where(uqp => query.Contains(uqp.UserChart)).UnsafeDelete();
Database.MListQuery((DashboardEntity cp) => cp.Parts).Where(mle => ((CombinedUserChartPartEntity)mle.Element.Content).UserCharts.Any(uc => query.Contains(uc))).UnsafeDeleteMList();
Database.Query <CombinedUserChartPartEntity>().Where(cuqp => cuqp.UserCharts.Any(uc => query.Contains(uc))).UnsafeDelete();
return(null);
};
sb.Schema.Table <UserChartEntity>().PreDeleteSqlSync += arg =>
{
var uc = (UserChartEntity)arg;
var mlistElems = Administrator.UnsafeDeletePreCommandMList((DashboardEntity cp) => cp.Parts, Database.MListQuery((DashboardEntity cp) => cp.Parts)
.Where(mle => ((UserChartPartEntity)mle.Element.Content).UserChart == uc));
var parts = Administrator.UnsafeDeletePreCommand(Database.Query <UserChartPartEntity>()
.Where(mle => mle.UserChart == uc));
var mlistElems2 = Administrator.UnsafeDeletePreCommandMList((DashboardEntity cp) => cp.Parts, Database.MListQuery((DashboardEntity cp) => cp.Parts)
.Where(mle => ((CombinedUserChartPartEntity)mle.Element.Content).UserCharts.Contains(uc)));
var parts2 = Administrator.UnsafeDeletePreCommand(Database.Query <CombinedUserChartPartEntity>()
.Where(mle => mle.UserCharts.Contains(uc)));
return(SqlPreCommand.Combine(Spacing.Simple, mlistElems, parts, mlistElems2, parts2));
};
}
DashboardGraph.Register();
Dashboards = sb.GlobalLazy(() => Database.Query <DashboardEntity>().ToDictionary(a => a.ToLite()),
new InvalidateWith(typeof(DashboardEntity)));
DashboardsByType = sb.GlobalLazy(() => Dashboards.Value.Values.Where(a => a.EntityType != null)
.SelectCatch(d => KeyValuePair.Create(TypeLogic.IdToType.GetOrThrow(d.EntityType !.Id), d.ToLite()))
.GroupToDictionary(),
new InvalidateWith(typeof(DashboardEntity)));
}
}
