internal static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include<ChartScriptEntity>();
dqm.RegisterQuery(typeof(ChartScriptEntity), () =>
from uq in Database.Query<ChartScriptEntity>()
select new
{
Entity = uq,
uq.Id,
uq.Name,
uq.GroupBy,
uq.Columns.Count,
uq.Icon,
});
Scripts = sb.GlobalLazy(() =>
{
var result = Database.Query<ChartScriptEntity>().ToDictionary(a => a.Name);
foreach (var e in result.Values)
if (e.Icon != null)
e.Icon.Retrieve();
return result;
}, new InvalidateWith(typeof(ChartScriptEntity)));
RegisterOperations();
}
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
IsStarted = true;
AuthLogic.AssertStarted(sb);
sb.Include<UserTicketEntity>();
dqm.RegisterQuery(typeof(UserTicketEntity), () =>
from ut in Database.Query<UserTicketEntity>()
select new
{
Entity = ut,
ut.Id,
ut.User,
ut.Ticket,
ut.ConnectionDate,
ut.Device,
});
dqm.RegisterExpression((UserEntity u) => u.UserTickets(), () => typeof(UserTicketEntity).NicePluralName());
sb.Schema.EntityEvents<UserEntity>().Saving += UserTicketLogic_Saving;
}
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
PermissionAuthLogic.RegisterPermissions(MapPermission.ViewMap);
}
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm, HashSet<Type> registerExpression)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include<ViewLogEntity>();
dqm.RegisterQuery(typeof(ViewLogEntity), () =>
from e in Database.Query<ViewLogEntity>()
select new
{
Entity = e,
e.Id,
e.Target,
e.ViewAction,
e.User,
e.Duration,
e.StartDate,
e.EndDate,
});
ExceptionLogic.DeleteLogs += ExceptionLogic_DeleteLogs;
var exp = Signum.Utilities.ExpressionTrees.Linq.Expr((Entity entity) => entity.ViewLogs());
foreach (var t in registerExpression)
{
dqm.RegisterExpression(new ExtensionInfo(t, exp, exp.Body.Type, "ViewLogs", () => typeof(ViewLogEntity).NicePluralName()));
}
DynamicQueryManager.Current.QueryExecuted += Current_QueryExecuted;
sb.Schema.Table<TypeEntity>().PreDeleteSqlSync += Type_PreDeleteSqlSync;
}
}
public static void Start(string connectionString)
{
DBMS dbms = DBMS.SqlServer2008;
SchemaBuilder sb = new SchemaBuilder(dbms);
DynamicQueryManager dqm = new DynamicQueryManager();
if (dbms == DBMS.SqlCompact)
Connector.Default = new SqlCeConnector(@"Data Source=C:\BaseDatos.sdf", sb.Schema, dqm);
else
Connector.Default = new SqlConnector(connectionString, sb.Schema, dqm);
sb.Schema.Version = typeof(Starter).Assembly.GetName().Version;
sb.Schema.Settings.OverrideAttributes((OperationLogDN ol) => ol.User, new ImplementedByAttribute());
sb.Schema.Settings.OverrideAttributes((ExceptionDN e) => e.User, new ImplementedByAttribute());
Validator.PropertyValidator((OperationLogDN e) => e.User).Validators.Clear();
TypeLogic.Start(sb, dqm);
OperationLogic.Start(sb, dqm);
ExceptionLogic.Start(sb, dqm);
MusicLogic.Start(sb, dqm);
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include<SmtpConfigurationEntity>();
dqm.RegisterQuery(typeof(SmtpConfigurationEntity), () =>
from s in Database.Query<SmtpConfigurationEntity>()
select new
{
Entity = s,
s.Id,
s.DeliveryMethod,
s.Network.Host,
s.Network.Username,
s.PickupDirectoryLocation
});
SmtpConfigCache = sb.GlobalLazy(() => Database.Query<SmtpConfigurationEntity>().ToDictionary(a => a.ToLite()),
new InvalidateWith(typeof(SmtpConfigurationEntity)));
new Graph<SmtpConfigurationEntity>.Execute(SmtpConfigurationOperation.Save)
{
AllowsNew = true,
Lite = false,
Execute = (sc, _) => { },
}.Register();
}
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include<DynamicValidationEntity>()
.WithSave(DynamicValidationOperation.Save)
.WithQuery(dqm, e => new
{
Entity = e,
e.Id,
e.Name,
e.EntityType,
e.PropertyRoute,
e.Eval,
});
DynamicValidations = sb.GlobalLazy(() =>
Database.Query<DynamicValidationEntity>()
.Select(dv => new DynamicValidationPair { Validation = dv, PropertyRoute = dv.PropertyRoute.ToPropertyRoute() })
.GroupToDictionary(a => a.PropertyRoute.PropertyInfo),
new InvalidateWith(typeof(DynamicValidationEntity)));
sb.Schema.Initializing += () => { initialized = true; };
Validator.GlobalValidation += DynamicValidation;
}
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include<ExceptionEntity>();
dqm.RegisterQuery(typeof(ExceptionEntity),()=>
from r in Database.Query<ExceptionEntity>()
select new
{
Entity = r,
r.Id,
r.CreationDate,
r.ExceptionType,
ExcepcionMessage = r.ExceptionMessage,
r.StackTraceHash,
});
dqm.RegisterQuery(typeof(ExceptionEntity), ()=>
from r in Database.Query<ExceptionEntity>()
select new
{
Entity = r,
r.Id,
r.CreationDate,
r.ExceptionType,
ExcepcionMessage = r.ExceptionMessage,
r.StackTraceHash,
});
DefaultEnvironment = "Default";
}
}
public override Schema GetOrCreateSchema()
{
SchemaBuilder sb = new SchemaBuilder(SchemaGuid);
sb.SetSchemaName(SchemaName);
sb.AddSimpleField("someBool", typeof(bool));
return sb.Finish();
}
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
// QueryManagers = queryManagers;
sb.Schema.Initializing += () =>
{
queryNamesLazy.Load();
queryNameToEntityLazy.Load();
};
sb.Include<QueryEntity>();
sb.Schema.Synchronizing += SynchronizeQueries;
sb.Schema.Generating += Schema_Generating;
queryNamesLazy = sb.GlobalLazy(()=>CreateQueryNames(), new InvalidateWith(typeof(QueryEntity)));
queryNameToEntityLazy = sb.GlobalLazy(() =>
EnumerableExtensions.JoinStrict(
Database.Query<QueryEntity>().ToList(),
QueryNames,
q => q.Key,
kvp => kvp.Key,
(q, kvp) => KVP.Create(kvp.Value, q),
"caching QueryEntity. Consider synchronize").ToDictionary(),
new InvalidateWith(typeof(QueryEntity)));
}
}
// Create a data structure, attach it to a wall, populate it with data, and retrieve the data back from the wall
public void CreateSchemeAndStoreData(FamilySymbol titleblock)
{
SchemaBuilder schemaBuilder = new SchemaBuilder(new Guid("1a68d420-96dd-44aa-a1de-000774a6104b"));
schemaBuilder.SetReadAccessLevel(AccessLevel.Public); // allow anyone to read the object
schemaBuilder.SetSchemaName("TitleBlockSettings");
// create a field to store data
FieldBuilder fieldBuilder_titleblockName = schemaBuilder.AddSimpleField("titleblockName", typeof(string));
FieldBuilder fieldBuilder_cellSizeDistance_X = schemaBuilder.AddSimpleField("cellSizeDistance_X", typeof(string));
//fieldBuilder_cellSizeDistance_X.SetUnitType(UnitType.UT_Length);
FieldBuilder fieldBuilder_lowerGap_X = schemaBuilder.AddSimpleField("lowerGap_X", typeof(string));
//fieldBuilder_lowerGap_X.SetUnitType(UnitType.UT_Length);
FieldBuilder fieldBuilder_additionalEdge_X = schemaBuilder.AddSimpleField("additionalEdge_X", typeof(string));
//fieldBuilder_additionalEdge_X.SetUnitType(UnitType.UT_Length);
FieldBuilder fieldBuilder_fineTune_X = schemaBuilder.AddSimpleField("fineTune_X", typeof(string));
//fieldBuilder_fineTune_X.SetUnitType(UnitType.UT_Length);
FieldBuilder fieldBuilder_cellSizeDistance_Y = schemaBuilder.AddSimpleField("cellSizeDistance_Y", typeof(string));
//fieldBuilder_cellSizeDistance_Y.SetUnitType(UnitType.UT_Length);
FieldBuilder fieldBuilder_lowerGap_Y = schemaBuilder.AddSimpleField("lowerGap_Y", typeof(string));
//fieldBuilder_lowerGap_Y.SetUnitType(UnitType.UT_Length);
FieldBuilder fieldBuilder_additionalEdge_Y = schemaBuilder.AddSimpleField("additionalEdge_Y", typeof(string));
//fieldBuilder_additionalEdge_Y.SetUnitType(UnitType.UT_Length);
FieldBuilder fieldBuilder_fineTune_Y = schemaBuilder.AddSimpleField("fineTune_Y", typeof(string));
//fieldBuilder_fineTune_Y.SetUnitType(UnitType.UT_Length);
FieldBuilder fieldBuilder_cellGrid_Length = schemaBuilder.AddSimpleField("cellGrid_Length", typeof(string));
FieldBuilder fieldBuilder_cellGrid_Height = schemaBuilder.AddSimpleField("cellGrid_Height", typeof(string));
//fieldBuilder.SetDocumentation("store length of cell size in X direction.");
Schema schema = schemaBuilder.Finish(); // register the Schema object
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm, bool excelReport)
{
if (excelReport)
{
QueryLogic.Start(sb);
sb.Include<ExcelReportEntity>();
dqm.RegisterQuery(typeof(ExcelReportEntity), () =>
from s in Database.Query<ExcelReportEntity>()
select new
{
Entity = s,
s.Id,
s.Query,
s.File.FileName,
s.DisplayName,
});
new Graph<ExcelReportEntity>.Execute(ExcelReportOperation.Save)
{
AllowsNew = true,
Lite = false,
Execute = (er, _) => { }
}.Register();
new Graph<ExcelReportEntity>.Delete(ExcelReportOperation.Delete)
{
Lite = true,
Delete = (er, _) => { er.Delete(); }
}.Register();
}
}
public static void Start(string connectionString)
{
SchemaBuilder sb = new SchemaBuilder();
DynamicQueryManager dqm = new DynamicQueryManager();
//Connector.Default = new SqlCeConnector(@"Data Source=C:\BaseDatos.sdf", sb.Schema, dqm);
Connector.Default = new SqlConnector(connectionString, sb.Schema, dqm, SqlServerVersion.SqlServer2008);
sb.Schema.Version = typeof(MusicStarter).Assembly.GetName().Version;
sb.Schema.Settings.FieldAttributes((OperationLogEntity ol) => ol.User).Add(new ImplementedByAttribute());
sb.Schema.Settings.FieldAttributes((ExceptionEntity e) => e.User).Add(new ImplementedByAttribute());
Validator.PropertyValidator((OperationLogEntity e) => e.User).Validators.Clear();
TypeLogic.Start(sb, dqm);
OperationLogic.Start(sb, dqm);
ExceptionLogic.Start(sb, dqm);
MusicLogic.Start(sb, dqm);
sb.Schema.OnSchemaCompleted();
}
public override Schema GetOrCreateSchema()
{
SchemaBuilder sb = new SchemaBuilder(SchemaGuid);
sb.SetSchemaName(SchemaName);
sb.AddArrayField("someStringArray", typeof(string));
return sb.Finish();
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
AuthLogic.AssertStarted(sb);
sb.Include<SessionLogEntity>();
PermissionAuthLogic.RegisterPermissions(SessionLogPermission.TrackSession);
dqm.RegisterQuery(typeof(SessionLogEntity), () =>
from sl in Database.Query<SessionLogEntity>()
select new
{
Entity = sl,
sl.Id,
sl.User,
sl.SessionStart,
sl.SessionEnd,
sl.SessionTimeOut
});
ExceptionLogic.DeleteLogs += ExceptionLogic_DeleteLogs;
}
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
FileTypeLogic.Start(sb, dqm);
sb.Include<FilePathEntity>();
sb.Schema.EntityEvents<FilePathEntity>().Retrieved += FilePathLogic_Retrieved;
sb.Schema.EntityEvents<FilePathEntity>().PreSaving += FilePath_PreSaving;
sb.Schema.EntityEvents<FilePathEntity>().PreUnsafeDelete += new PreUnsafeDeleteHandler<FilePathEntity>(FilePathLogic_PreUnsafeDelete);
dqm.RegisterQuery(typeof(FilePathEntity), () =>
from p in Database.Query<FilePathEntity>()
select new
{
Entity = p,
p.Id,
p.FileName,
p.FileType,
p.Sufix
});
new Graph<FilePathEntity>.Execute(FilePathOperation.Save)
{
AllowsNew = true,
Lite = false,
Execute = (fp, _) =>
{
if (!fp.IsNew)
{
var ofp = fp.ToLite().Retrieve();
if (fp.FileName != ofp.FileName || fp.Sufix != ofp.Sufix || fp.FullPhysicalPath != ofp.FullPhysicalPath)
{
using (Transaction tr = new Transaction())
{
var preSufix = ofp.Sufix.Substring(0, ofp.Sufix.Length - ofp.FileName.Length);
fp.Sufix = Path.Combine(preSufix, fp.FileName);
fp.Save();
System.IO.File.Move(ofp.FullPhysicalPath, fp.FullPhysicalPath);
tr.Commit();
}
}
}
}
}.Register();
OperationLogic.SetProtectedSave<FilePathEntity>(false);
sb.AddUniqueIndex<FilePathEntity>(f => new { f.Sufix, f.FileType }); //With mixins, add AttachToUniqueIndexes to field
dqm.RegisterExpression((FilePathEntity fp) => fp.WebImage(), () => typeof(WebImage).NiceName(), "Image");
dqm.RegisterExpression((FilePathEntity fp) => fp.WebDownload(), () => typeof(WebDownload).NiceName(), "Download");
}
}
public override Schema GetSchema()
{
var schema = base.GetSchema();
var schemaBuilder = new SchemaBuilder();
schema.CombineWith(new Schema(schemaBuilder.Inject(@"<Attribute Name=""" + ClassTypeToInstantiate + @""" RefNodeName=""/Application/BOModel/Class""/>", ModelElement.ListView)));
schema.CombineWith(new Schema(schemaBuilder.Inject(@"<Attribute Name=""" + ClassTypeToInstantiate + @""" RefNodeName=""/Application/BOModel/Class""/>", ModelElement.DetailView)));
return schema;
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include<PasswordExpiresIntervalEntity>();
dqm.RegisterQuery(typeof(PasswordExpiresIntervalEntity), ()=>
from e in Database.Query<PasswordExpiresIntervalEntity>()
select new
{
Entity = e,
e.Id,
e.Enabled,
e.Days,
e.DaysWarning
});
new Graph<PasswordExpiresIntervalEntity>.Execute(PasswordExpiresIntervalOperation.Save)
{
AllowsNew = true,
Lite = false,
Execute = (pei, _) => { },
}.Register();
AuthLogic.UserLogingIn += (u =>
{
if (u.PasswordNeverExpires)
return;
var ivp = Database.Query<PasswordExpiresIntervalEntity>().Where(p => p.Enabled).FirstOrDefault();
if (ivp == null)
return;
if (TimeZoneManager.Now > u.PasswordSetDate.AddDays((double)ivp.Days))
throw new PasswordExpiredException(AuthMessage.ExpiredPassword.NiceToString());
});
AuthLogic.LoginMessage += (() =>
{
UserEntity u = UserEntity.Current;
if (u.PasswordNeverExpires)
return null;
PasswordExpiresIntervalEntity ivp = null;
using (AuthLogic.Disable())
ivp = Database.Query<PasswordExpiresIntervalEntity>().Where(p => p.Enabled).FirstOrDefault();
if (ivp == null)
return null;
if (TimeZoneManager.Now > u.PasswordSetDate.AddDays((double)ivp.Days).AddDays((double)-ivp.DaysWarning))
return AuthMessage.YourPasswordIsNearExpiration.NiceToString();
return null;
});
}
}
public void Generates_Create_Schema_Statement()
{
var builder = new SchemaBuilder("[procName]");
var script = builder.GetScript();
const string expected =
@"CREATE SCHEMA [procName]";
Assert.IsTrue(script.IndexOf(expected) >= 0);
}
public void Generates_Extended_Property_String()
{
var builder = new SchemaBuilder("procName");
var script = builder.GetScript();
const string expected =
@"EXECUTE sp_addextendedproperty @name = 'tSQLt.TestClass', @value = 1, @level0type = 'SCHEMA', @level0name = 'procName'";
Assert.IsTrue(script.IndexOf(expected) >= 0, script);
}
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include<PropertyRouteEntity>();
sb.AddUniqueIndex<PropertyRouteEntity>(p => new { p.Path, p.RootType });
sb.Schema.Synchronizing += SyncronizeProperties;
}
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include<EmailPackageEntity>();
dqm.RegisterExpression((EmailPackageEntity ep) => ep.Messages(), () => EmailMessageMessage.Messages.NiceToString());
dqm.RegisterExpression((EmailPackageEntity ep) => ep.RemainingMessages(), () => EmailMessageMessage.RemainingMessages.NiceToString());
dqm.RegisterExpression((EmailPackageEntity ep) => ep.ExceptionMessages(), () => EmailMessageMessage.ExceptionMessages.NiceToString());
ProcessLogic.AssertStarted(sb);
ProcessLogic.Register(EmailMessageProcess.CreateEmailsSendAsync, new CreateEmailsSendAsyncProcessAlgorithm());
ProcessLogic.Register(EmailMessageProcess.SendEmails, new SendEmailProcessAlgorithm());
new Graph<ProcessEntity>.ConstructFromMany<EmailMessageEntity>(EmailMessageOperation.ReSendEmails)
{
Construct = (messages, args) =>
{
EmailPackageEntity emailPackage = new EmailPackageEntity()
{
Name = args.TryGetArgC<string>()
}.Save();
foreach (var m in messages.Select(m => m.RetrieveAndForget()))
{
new EmailMessageEntity()
{
Package = emailPackage.ToLite(),
From = m.From,
Recipients = m.Recipients.ToMList(),
Target = m.Target,
Body = m.Body,
IsBodyHtml = m.IsBodyHtml,
Subject = m.Subject,
Template = m.Template,
EditableMessage = m.EditableMessage,
State = EmailMessageState.RecruitedForSending
}.Save();
}
return ProcessLogic.Create(EmailMessageProcess.SendEmails, emailPackage);
}
}.Register();
dqm.RegisterQuery(typeof(EmailPackageEntity), () =>
from e in Database.Query<EmailPackageEntity>()
select new
{
Entity = e,
e.Id,
e.Name,
});
}
}
private Schema GetStorageSchema()
{
var bld = new SchemaBuilder(_schemaGuid);
bld.SetSchemaName("BimLibraryData");
bld.SetWriteAccessLevel(AccessLevel.Public);
bld.SetReadAccessLevel(AccessLevel.Public);
//bld.SetVendorId("ADSK");
bld.SetDocumentation("This schema stores project specific application data of Czech BIM Library.");
bld.AddSimpleField(FieldNameData, typeof(String)).SetDocumentation("Data field");
return bld.Finish();
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
sb.Include<ExcelAttachmentEntity>();
dqm.RegisterQuery(typeof(ExcelAttachmentEntity), () =>
from s in Database.Query<ExcelAttachmentEntity>()
select new
{
Entity = s,
s.Id,
s.FileName,
s.UserQuery,
s.Related,
});
EmailTemplateLogic.FillAttachmentTokens.Register((ExcelAttachmentEntity uqe, EmailTemplateLogic.FillAttachmentTokenContext ctx) =>
{
if (uqe.FileName != null)
EmailTemplateParser.Parse(uqe.FileName, ctx.QueryDescription, ctx.ModelType).FillQueryTokens(ctx.QueryTokens);
if (uqe.Title != null)
EmailTemplateParser.Parse(uqe.Title, ctx.QueryDescription, ctx.ModelType).FillQueryTokens(ctx.QueryTokens);
});
Validator.PropertyValidator((ExcelAttachmentEntity e) => e.FileName).StaticPropertyValidation = ExcelAttachmentFileName_StaticPropertyValidation;
Validator.PropertyValidator((ExcelAttachmentEntity e) => e.Title).StaticPropertyValidation = ExcelAttachmentTitle_StaticPropertyValidation;
EmailTemplateLogic.GenerateAttachment.Register((ExcelAttachmentEntity uqe, EmailTemplateLogic.GenerateAttachmentContext ctx) =>
{
var finalEntity = uqe.Related?.Retrieve() ?? (Entity)ctx.Entity;
using (finalEntity == null ? null : CurrentEntityConverter.SetCurrentEntity(finalEntity))
using (CultureInfoUtils.ChangeBothCultures(ctx.Culture))
{
QueryRequest request = UserQueryLogic.ToQueryRequest(uqe.UserQuery.Retrieve());
var title = GetTemplateString(uqe.Title, ref uqe.TitleNode, ctx);
var fileName = GetTemplateString(uqe.FileName, ref uqe.FileNameNode, ctx);
var bytes = ExcelLogic.ExecutePlainExcel(request, title);
return new List<EmailAttachmentEntity>
{
new EmailAttachmentEntity
{
File = Files.EmbeddedFilePathLogic.SaveFile(new Entities.Files.EmbeddedFilePathEntity(EmailFileType.Attachment, fileName, bytes)),
Type = EmailAttachmentType.Attachment,
}
};
}
});
}
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include<PropertyRouteEntity>()
.WithUniqueIndex(p => new { p.Path, p.RootType });
sb.Schema.Synchronizing += SynchronizeProperties;
Properties = sb.GlobalLazy(() => Database.Query<PropertyRouteEntity>().AgGroupToDictionary(a => a.RootType, gr => gr.ToDictionary(a => a.Path)),
new InvalidateWith(typeof(PropertyRouteEntity)), Schema.Current.InvalidateMetadata);
}
}
public override void Up()
{
var builder = new SchemaBuilder(Schema);
builder.AddTable("Usuario",
Columns.PrimaryKey<int>("Id"),
Columns.Simple<string>("Nome", 100),
Columns.Simple<string>("Login", 20),
Columns.Simple<string>("Senha", 50),
Columns.Simple<int>("IsAtivo"),
Columns.Simple<int>("Perfil")
);
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm, bool timeTracker, bool heavyProfiler, bool overrideSessionTimeout)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
if (timeTracker)
PermissionAuthLogic.RegisterPermissions(ProfilerPermission.ViewTimeTracker);
if (heavyProfiler)
PermissionAuthLogic.RegisterPermissions(ProfilerPermission.ViewHeavyProfiler);
if (overrideSessionTimeout)
PermissionAuthLogic.RegisterPermissions(ProfilerPermission.OverrideSessionTimeout);
}
}
/// <summary>
/// the IFC File Header
/// </summary>
public IFCFileHeader()
{
if (m_schema == null)
{
m_schema = Schema.Lookup(s_schemaId);
}
if (m_schema == null)
{
SchemaBuilder fileHeaderBuilder = new SchemaBuilder(s_schemaId);
fileHeaderBuilder.SetSchemaName("IFCFileHeader");
fileHeaderBuilder.AddMapField(s_FileHeaderMapField, typeof(String), typeof(String));
m_schema = fileHeaderBuilder.Finish();
}
}
/// <summary>
/// IFC address initialization
/// </summary>
public IFCAddress()
{
if (m_schema == null)
{
m_schema = Schema.Lookup(s_schemaId);
}
if (m_schema == null)
{
SchemaBuilder addressBuilder = new SchemaBuilder(s_schemaId);
addressBuilder.SetSchemaName("IFCAddress");
addressBuilder.AddMapField(s_addressMapField, typeof(String), typeof(String));
m_schema = addressBuilder.Finish();
}
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
QueryLogic.Start(sb);
PermissionAuthLogic.RegisterPermissions(UserQueryPermission.ViewUserQuery);
UserAssetsImporter.RegisterName<UserQueryEntity>("UserQuery");
sb.Schema.Synchronizing += Schema_Synchronizing;
sb.Include<UserQueryEntity>();
dqm.RegisterQuery(typeof(UserQueryEntity), () =>
from uq in Database.Query<UserQueryEntity>()
select new
{
Entity = uq,
uq.Query,
uq.Id,
uq.DisplayName,
uq.EntityType,
});
sb.Schema.EntityEvents<UserQueryEntity>().Retrieved += UserQueryLogic_Retrieved;
new Graph<UserQueryEntity>.Execute(UserQueryOperation.Save)
{
AllowsNew = true,
Lite = false,
Execute = (uq, _) => { }
}.Register();
new Graph<UserQueryEntity>.Delete(UserQueryOperation.Delete)
{
Lite = true,
Delete = (uq, _) => uq.Delete()
}.Register();
UserQueries = sb.GlobalLazy(() => Database.Query<UserQueryEntity>().ToDictionary(a => a.ToLite()),
new InvalidateWith(typeof(UserQueryEntity)));
UserQueriesByQuery = sb.GlobalLazy(() => UserQueries.Value.Values.Where(a => a.EntityType == null).GroupToDictionary(a => a.Query.ToQueryName(), a => a.ToLite()),
new InvalidateWith(typeof(UserQueryEntity)));
UserQueriesByType = sb.GlobalLazy(() => UserQueries.Value.Values.Where(a => a.EntityType != null).GroupToDictionary(a => TypeLogic.IdToType.GetOrThrow(a.EntityType.Id), a => a.ToLite()),
new InvalidateWith(typeof(UserQueryEntity)));
}
}
public int UpdateFrom1()
{
SchemaBuilder.AlterTable("GoogleAnalyticsSettingsPartRecord",
table => table.AddColumn <bool>("AnonymizeIp"));
return(2);
}
public void FailsWhereWrongParameterType()
{
var ex = Assert.Throws <EntityGraphQLCompilerException>(() => EqlCompiler.Compile("people.where(name)", SchemaBuilder.FromObject <TestSchema>(), null, new DefaultMethodProvider(), null));
Assert.Equal("Method 'where' expects parameter that evaluates to a 'System.Boolean' result but found result type 'System.String'", ex.Message);
}
public void Run(RegressionEnvironment env)
{
string epl = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedStartValueEvent>() +
" create schema StartValueEvent as (dummy string);\n";
epl += eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedTestForwardEvent>() +
" create schema TestForwardEvent as (prop1 string);\n";
epl += eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedTestInputEvent>() +
" create schema TestInputEvent as (dummy string);\n";
epl += "insert into TestForwardEvent select'V1' as prop1 from TestInputEvent;\n";
epl += eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedNamedWin>() +
" create window NamedWin#unique(prop1) (prop1 string, prop2 string);\n";
epl += "insert into NamedWin select 'V1' as prop1, 'O1' as prop2 from StartValueEvent;\n";
epl += "on TestForwardEvent update NamedWin as work set prop2 = 'U1' where work.prop1 = 'V1';\n";
epl += "@Name('select') select irstream prop1, prop2 from NamedWin;\n";
env.CompileDeployWBusPublicType(epl, new RegressionPath()).AddListener("select");
var fields = new[] {"prop1", "prop2"};
if (eventRepresentationEnum.IsObjectArrayEvent()) {
env.SendEventObjectArray(new object[] {"dummyValue"}, "StartValueEvent");
}
else if (eventRepresentationEnum.IsMapEvent()) {
env.SendEventMap(new Dictionary<string, object>(), "StartValueEvent");
}
else if (eventRepresentationEnum.IsAvroEvent()) {
env.EventService.SendEventAvro(
new GenericRecord(
SchemaBuilder.Record("soemthing")),
"StartValueEvent");
}
else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) {
env.EventService.SendEventJson("{}", "StartValueEvent");
}
else {
Assert.Fail();
}
EPAssertionUtil.AssertProps(
env.Listener("select").AssertOneGetNewAndReset(),
fields,
new object[] {"V1", "O1"});
if (eventRepresentationEnum.IsObjectArrayEvent()) {
env.SendEventObjectArray(new object[] {"dummyValue"}, "TestInputEvent");
}
else if (eventRepresentationEnum.IsMapEvent()) {
env.SendEventMap(new Dictionary<string, object>(), "TestInputEvent");
}
else if (eventRepresentationEnum.IsAvroEvent()) {
env.EventService.SendEventAvro(
new GenericRecord(
SchemaBuilder.Record("soemthing")),
"TestInputEvent");
}
else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) {
env.EventService.SendEventJson("{}", "TestInputEvent");
}
else {
Assert.Fail();
}
EPAssertionUtil.AssertProps(
env.Listener("select").LastOldData[0],
fields,
new object[] {"V1", "O1"});
EPAssertionUtil.AssertProps(
env.Listener("select").GetAndResetLastNewData()[0],
fields,
new object[] {"V1", "U1"});
env.UndeployAll();
}
private static void MergeComplexType(ISchema right, SchemaBuilder builder, ComplexType rightType)
{
if (builder.TryGetType <ComplexType>(rightType.Name, out var leftType))
{
var rightTypeFields = right.GetFields(rightType.Name);
foreach (var rightTypeField in rightTypeFields)
{
builder.Connections(connect =>
{
if (connect.TryGetField(leftType, rightTypeField.Key, out _))
{
return;
}
connect.Include(leftType, new[] { rightTypeField });
var resolver = right.GetResolver(rightType.Name, rightTypeField.Key);
if (resolver != null)
{
connect.GetOrAddResolver(leftType, rightTypeField.Key)
.Run(resolver);
}
var subscriber = right.GetSubscriber(rightType.Name, rightTypeField.Key);
if (subscriber != null)
{
connect.GetOrAddSubscriber(leftType, rightTypeField.Key)
.Run(subscriber);
}
});
}
}
else
{
builder
.Include(rightType)
.Connections(connect =>
{
var fields = right.GetFields(rightType.Name).ToList();
connect.Include(rightType, fields);
foreach (var rightTypeField in fields)
{
var resolver = right.GetResolver(rightType.Name, rightTypeField.Key);
if (resolver != null)
{
connect.GetOrAddResolver(rightType, rightTypeField.Key)
.Run(resolver);
}
var subscriber = right.GetSubscriber(rightType.Name, rightTypeField.Key);
if (subscriber != null)
{
connect.GetOrAddSubscriber(rightType, rightTypeField.Key)
.Run(subscriber);
}
}
});
}
}
public ServiceCollectionExtensionGenerator(SchemaBuilder schema, string schemaName)
{
_schema = schema;
_schemaName = schemaName;
}
protected override void ProcessRecord()
{
base.ProcessRecord();
WriteObject($"{Ansi.Color.Foreground.LightCyan}** GENERATE model **{Ansi.Color.Foreground.Default}");
if (!Model.Exists)
{
WriteObject($"{Ansi.Color.Foreground.LightRed}Model file {Model?.FullName} not found.{Ansi.Color.Foreground.Default}");
return;
}
WriteObject($"Loading model: {Model.FullName}");
string modelBim = File.ReadAllText(Model.FullName);
TabModel.Database database = TabModel.JsonSerializer.DeserializeDatabase(modelBim);
// Create the schema
if (!SchemaBuilder.CheckModel(
database.Model,
out List <TabModel.Table> unsupportedTables,
out List <TabModel.Measure> unsupportedMeasures,
out List <TabModel.Relationship> unsupportedRelationships))
{
if (unsupportedMeasures.Count > 0)
{
WriteObject($"{Ansi.Color.Foreground.LightYellow}Removing {unsupportedMeasures.Count} unsupported measures.{Ansi.Color.Foreground.Default}");
foreach (TabModel.Measure m in unsupportedMeasures)
{
WriteObject($" {Ansi.Color.Foreground.Yellow}{m.Name}{Ansi.Color.Foreground.Default}");
m.Table.Measures.Remove(m);
}
}
if (unsupportedRelationships.Count > 0)
{
WriteObject($"{Ansi.Color.Foreground.LightYellow}Removing {unsupportedRelationships.Count} unsupported relationships.{Ansi.Color.Foreground.Default}");
foreach (TabModel.Relationship r in unsupportedRelationships)
{
string relationshipDescription = (r is TabModel.SingleColumnRelationship sr)
? $"*** SKIP *** '{sr.FromTable.Name}'[{sr.FromColumn.Name}]{sr.CardinalityText()}'{sr.ToTable.Name}'[{sr.ToColumn.Name}] ({sr.CrossFilteringBehavior})"
: $"*** SKIP *** '{r.FromTable.Name}'-->'{r.ToTable.Name}' ({r.CrossFilteringBehavior})";
WriteObject($" {Ansi.Color.Foreground.Yellow}{relationshipDescription}{Ansi.Color.Foreground.Default}");
database.Model.Relationships.Remove(r);
}
}
if (unsupportedTables.Count > 0)
{
WriteObject($"{Ansi.Color.Foreground.LightYellow}Removing {unsupportedTables.Count} unsupported tables.{Ansi.Color.Foreground.Default}");
foreach (TabModel.Table t in unsupportedTables)
{
WriteObject($" {Ansi.Color.Foreground.Yellow}{t.Name}{Ansi.Color.Foreground.Default}");
database.Model.Tables.Remove(t);
}
}
WriteObject($"{Ansi.Color.Foreground.LightCyan}Prepared model compatible with Push Dataset.{Ansi.Color.Foreground.Default}");
}
else
{
WriteObject($"{Ansi.Color.Foreground.LightGreen}Copying model compatible with Push Dataset.{Ansi.Color.Foreground.Default}");
}
string modelCompatibleBim = TabModel.JsonSerializer.SerializeDatabase(database);
WriteObject($"Saving model: {Out.FullName}");
File.WriteAllText(Out.FullName, modelCompatibleBim);
}
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;
}
}
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include <ProcessAlgorithmSymbol>()
.WithQuery(() => pa => new
{
Entity = pa,
pa.Id,
pa.Key
});
sb.Include <ProcessEntity>()
.WithQuery(() => 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(() => p => new
{
Entity = p,
p.Process,
p.Line,
p.ElementInfo,
p.Exception,
});
PermissionAuthLogic.RegisterPermissions(ProcessPermission.ViewProcessPanel);
SymbolLogic <ProcessAlgorithmSymbol> .Start(sb, () => registeredProcesses.Keys.ToHashSet());
OperationLogic.AssertStarted(sb);
ProcessGraph.Register();
QueryLogic.Expressions.Register((ProcessAlgorithmSymbol p) => p.Processes(), () => typeof(ProcessEntity).NicePluralName());
QueryLogic.Expressions.Register((ProcessAlgorithmSymbol p) => p.LastProcess(), () => ProcessMessage.LastProcess.NiceToString());
QueryLogic.Expressions.Register((IProcessDataEntity p) => p.Processes(), () => typeof(ProcessEntity).NicePluralName());
QueryLogic.Expressions.Register((IProcessDataEntity p) => p.LastProcess(), () => ProcessMessage.LastProcess.NiceToString());
QueryLogic.Expressions.Register((ProcessEntity p) => p.ExceptionLines(), () => ProcessMessage.ExceptionLines.NiceToString());
QueryLogic.Expressions.Register((IProcessLineDataEntity p) => p.ExceptionLines(), () => ProcessMessage.ExceptionLines.NiceToString());
PropertyAuthLogic.SetMaxAutomaticUpgrade(PropertyRoute.Construct((ProcessEntity p) => p.User), PropertyAllowed.Read);
ExceptionLogic.DeleteLogs += ExceptionLogic_DeleteLogs;
}
}
private string GetFullTableName(AuditEvent auditEvent)
{
return(SchemaBuilder != null
? string.Format("[{0}].[{1}]", SchemaBuilder.Invoke(auditEvent), TableNameBuilder.Invoke(auditEvent))
: string.Format("[{0}]", TableNameBuilder.Invoke(auditEvent)));
}
public static void AssertStarted(SchemaBuilder sb)
{
sb.AssertDefined(ReflectionTools.GetMethodInfo(() => ProcessLogic.Start(null !)));
}
private void RunAssertionVariantStream(EventRepresentationChoice eventRepresentationEnum)
{
_epService.EPAdministrator.Configuration.AddEventType(
"SupportBean", typeof(SupportBean));
_epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " create schema EventOne as (key string)");
_epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " create schema EventTwo as (key string)");
_epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " create schema S0 as "
+ typeof(SupportBean_S0).FullName);
_epService.EPAdministrator.CreateEPL(
eventRepresentationEnum.GetAnnotationText()
+ " create variant schema VarSchema as *");
_epService.EPAdministrator.CreateEPL(
"insert into VarSchema select * from EventOne");
_epService.EPAdministrator.CreateEPL(
"insert into VarSchema select * from EventTwo");
_epService.EPAdministrator.CreateEPL(
"insert into VarSchema select * from S0");
_epService.EPAdministrator.CreateEPL(
"insert into VarSchema select * from SupportBean");
String stmtText = "select Typeof(A) as t0 from VarSchema as A";
EPStatement stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.Events += _listener.Update;
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(new Object[] { "value" }, "EventOne");
}
else if (eventRepresentationEnum.IsMapEvent())
{
_epService.EPRuntime.SendEvent(
Collections.SingletonMap <string, object>("key", "value"), "EventOne");
}
else if (eventRepresentationEnum.IsAvroEvent())
{
var record = new GenericRecord(SchemaBuilder.Record("EventOne", TypeBuilder.RequiredString("key")));
record.Put("key", "value");
_epService.EPRuntime.SendEventAvro(record, "EventOne");
}
else
{
Assert.Fail();
}
Assert.AreEqual("EventOne", _listener.AssertOneGetNewAndReset().Get("t0"));
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(new Object[] { "value" }, "EventTwo");
}
else if (eventRepresentationEnum.IsMapEvent())
{
_epService.EPRuntime.SendEvent(
Collections.SingletonMap <string, object>("key", "value"), "EventTwo");
}
else if (eventRepresentationEnum.IsAvroEvent())
{
var record = new GenericRecord(SchemaBuilder.Record("EventTwo", TypeBuilder.RequiredString("key")));
record.Put("key", "value");
_epService.EPRuntime.SendEventAvro(record, "EventTwo");
}
else
{
Assert.Fail();
}
Assert.AreEqual("EventTwo", _listener.AssertOneGetNewAndReset().Get("t0"));
_epService.EPRuntime.SendEvent(new SupportBean_S0(1));
Assert.AreEqual("S0", _listener.AssertOneGetNewAndReset().Get("t0"));
_epService.EPRuntime.SendEvent(new SupportBean());
Assert.AreEqual("SupportBean", _listener.AssertOneGetNewAndReset().Get("t0"));
stmt.Dispose();
_listener.Reset();
stmt = _epService.EPAdministrator.CreateEPL(
"select * from VarSchema Match_recognize(\n"
+ " measures A as a, B as b\n" + " pattern (A B)\n"
+ " define A as Typeof(A) = \"EventOne\",\n"
+ " B as Typeof(B) = \"EventTwo\"\n" + " )");
stmt.Events += _listener.Update;
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(new Object[] { "value" }, "EventOne");
_epService.EPRuntime.SendEvent(new Object[] { "value" }, "EventTwo");
}
else if (eventRepresentationEnum.IsMapEvent())
{
_epService.EPRuntime.SendEvent(
Collections.SingletonMap <string, object>("key", "value"), "EventOne");
_epService.EPRuntime.SendEvent(
Collections.SingletonMap <string, object>("key", "value"), "EventTwo");
}
else if (eventRepresentationEnum.IsAvroEvent())
{
var schema = SchemaBuilder.Record("EventTwo", TypeBuilder.RequiredString("key"));
var eventOne = new GenericRecord(schema);
eventOne.Put("key", "value");
var eventTwo = new GenericRecord(schema);
eventTwo.Put("key", "value");
_epService.EPRuntime.SendEventAvro(eventOne, "EventOne");
_epService.EPRuntime.SendEventAvro(eventTwo, "EventTwo");
}
else
{
Assert.Fail();
}
Assert.IsTrue(_listener.GetAndClearIsInvoked());
_listener.Reset();
_epService.Initialize();
}
protected IRequestExecutor CreateSchema <TEntity, T>(
TEntity[] entities,
FilterConvention?convention = null,
bool withPaging = false,
Action <ISchemaBuilder>?configure = null,
Action <ModelBuilder>?onModelCreating = null)
where TEntity : class
where T : FilterInputType <TEntity>
{
convention ??= new FilterConvention(x => x.AddDefaults().BindRuntimeType <TEntity, T>());
Func <IResolverContext, IEnumerable <TEntity> >?resolver =
BuildResolver(onModelCreating, entities);
ISchemaBuilder builder = SchemaBuilder.New()
.AddConvention <IFilterConvention>(convention)
.AddFiltering()
.AddQueryType(
c =>
{
ApplyConfigurationToField <TEntity, T>(
c.Name("Query").Field("root").Resolver(resolver),
withPaging);
ApplyConfigurationToField <TEntity, T>(
c.Name("Query")
.Field("rootExecutable")
.Resolver(
ctx => resolver(ctx).AsExecutable()),
withPaging);
});
configure?.Invoke(builder);
ISchema schema = builder.Create();
return(new ServiceCollection()
.Configure <RequestExecutorSetup>(
Schema.DefaultName,
o => o.Schema = schema)
.AddGraphQL()
.UseRequest(
next => async context =>
{
await next(context);
if (context.Result is IReadOnlyQueryResult result &&
context.ContextData.TryGetValue("sql", out var queryString))
{
context.Result =
QueryResultBuilder
.FromResult(result)
.SetContextData("sql", queryString)
.Create();
}
})
.UseDefaultPipeline()
.Services
.BuildServiceProvider()
.GetRequiredService <IRequestExecutorResolver>()
.GetRequestExecutorAsync()
.Result);
}
private static Schema BuildSchema(IEnumerable <Type> types, ITypeMapper typeMapper)
{
return(SchemaBuilder.BuildSchema(types, typeMapper));
}
// This method gets called by the runtime.
// Use this method to add services to the container.
// For more information on how to configure your application,
// visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddCors();
// configure jwt authentication
services
.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
options.RequireHttpsMetadata = false;
options.SaveToken = true;
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(SharedSecret),
ValidateIssuer = false,
ValidateAudience = false
};
options.Events = new JwtBearerEvents
{
OnMessageReceived = context =>
{
if (context.HttpContext.Request.Query.ContainsKey("token"))
{
context.Token = context.HttpContext.Request.Query["token"];
}
return(Task.CompletedTask);
}
};
});
var databaseUrl = Configuration["DATABASE_URL"];
var databaseUri = new Uri(databaseUrl);
var userInfo = databaseUri.UserInfo.Split(':');
var builder = new NpgsqlConnectionStringBuilder
{
Host = databaseUri.Host,
Port = databaseUri.Port,
Username = userInfo[0],
Password = userInfo[1],
Database = databaseUri.LocalPath.TrimStart('/'),
SslMode = SslMode.Prefer,
TrustServerCertificate = true
};
var redisConfigurationOptions = new ConfigurationOptions
{
AllowAdmin = false,
Ssl = false,
Password = "******",
EndPoints =
{
{ "ec2-3-86-75-248.compute-1.amazonaws.com", 20849 }
}
};
var conn = ConnectionMultiplexer.Connect(redisConfigurationOptions);
// Adds GraphQL Schema
services
.AddEntityFrameworkNpgsql()
.AddDbContext <SlackCloneDbContext>((sp, opt) =>
opt.UseNpgsql(builder.ToString())
.UseInternalServiceProvider(sp))
//.AddInMemorySubscriptions()
.AddRedisSubscriptions(conn)
.AddGraphQL(sp =>
SchemaBuilder.New()
.AddServices(sp)
.AddQueryType(d => d.Name("Query"))
.AddType <UserQueries>()
.AddType <ChannelQueries>()
.AddMutationType(d => d.Name("Mutation"))
.AddType <UserMutations>()
.AddType <ChannelMutations>()
.AddSubscriptionType(d => d.Name("Subscription"))
.AddType <UserSubscriptions>()
.AddType <ChannelSubscriptions>()
.AddAuthorizeDirectiveType()
.Create());
services.AddQueryRequestInterceptor((context, builder, ct) =>
{
if (context.User.Identity.IsAuthenticated)
{
builder.AddProperty(
"currentUserEmail",
context.User.FindFirst(ClaimTypes.Email).Value);
}
return(Task.CompletedTask);
});
}
public static void Start(SchemaBuilder sb, Func <WorkflowConfigurationEmbedded> getConfiguration)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
PermissionAuthLogic.RegisterPermissions(WorkflowPermission.ViewWorkflowPanel);
PermissionAuthLogic.RegisterPermissions(WorkflowPermission.ViewCaseFlow);
WorkflowLogic.getConfiguration = getConfiguration;
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.NiceToString());
sb.AddIndex((WorkflowEntity wf) => wf.ExpirationDate);
DynamicCode.GetCustomErrors += GetCustomErrors;
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 = 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 int UpdateFrom4()
{
SchemaBuilder.AlterTable("GoogleAnalyticsSettingsPartRecord",
table => table.AddColumn <bool>("UseGA4", c => c.NotNull().WithDefault(false)));
return(5);
}
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include <ProductEntity>()
.WithSave(ProductOperation.Save)
.WithQuery(() => p => new
{
Entity = p,
p.Id,
p.ProductName,
p.Supplier,
p.Category,
p.QuantityPerUnit,
p.UnitPrice,
p.UnitsInStock,
p.Discontinued
});
sb.AddUniqueIndexMList((ProductEntity pe) => pe.AdditionalInformation, mle => new { mle.Parent, mle.Element.Key });
QueryLogic.Expressions.RegisterDictionary((ProductEntity p) => p.AdditionalInformation, ai => ai.Key, ai => ai.Value);
ActiveProducts = sb.GlobalLazy(() =>
Database.Query <ProductEntity>()
.Where(a => !a.Discontinued)
.Select(p => new { Category = p.Category.Entity, Product = p })
.GroupToDictionary(a => a.Category !, a => a.Product !), /*CSBUG*/
new InvalidateWith(typeof(ProductEntity)));
QueryLogic.Queries.Register(ProductQuery.CurrentProducts, () =>
from p in Database.Query <ProductEntity>()
where !p.Discontinued
select new
{
Entity = p,
p.Id,
p.ProductName,
p.Supplier,
p.Category,
p.QuantityPerUnit,
p.UnitPrice,
p.UnitsInStock,
});
sb.Include <SupplierEntity>()
.WithSave(SupplierOperation.Save)
.WithQuery(() => s => new
{
Entity = s,
s.Id,
s.CompanyName,
s.ContactName,
s.Phone,
s.Fax,
s.HomePage,
s.Address
});
sb.Include <CategoryEntity>()
.WithSave(CategoryOperation.Save)
.WithQuery(() => s => new
{
Entity = s,
s.Id,
s.CategoryName,
s.Description,
s.Picture
});
}
}
public static void Start(SchemaBuilder sb, bool packages, bool packageOperations)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
ProcessLogic.AssertStarted(sb);
sb.Settings.AssertImplementedBy((ProcessExceptionLineEntity pel) => pel.Line, typeof(PackageLineEntity));
sb.Include <PackageLineEntity>()
.WithQuery(() => pl => new
{
Entity = pl,
pl.Package,
pl.Id,
pl.Target,
pl.Result,
pl.FinishTime,
});
QueryLogic.Queries.Register(PackageQuery.PackageLineLastProcess, () =>
from pl in Database.Query <PackageLineEntity>()
let p = pl.Package.Entity.LastProcess()
select new
{
Entity = pl,
pl.Package,
pl.Id,
pl.Target,
pl.Result,
pl.FinishTime,
LastProcess = p,
Exception = pl.Exception(p),
});
QueryLogic.Expressions.Register((PackageEntity p) => p.Lines(), ProcessMessage.Lines);
if (packages)
{
sb.Settings.AssertImplementedBy((PackageLineEntity pl) => pl.Package, typeof(PackageEntity));
sb.Settings.AssertImplementedBy((ProcessEntity pe) => pe.Data, typeof(PackageEntity));
sb.Include <PackageEntity>()
.WithQuery(() => pk => new
{
Entity = pk,
pk.Id,
pk.Name,
});
QueryLogic.Queries.Register(PackageQuery.PackageLastProcess, () =>
from pk in Database.Query <PackageEntity>()
let pe = pk.LastProcess()
select new
{
Entity = pk,
pk.Id,
pk.Name,
NumLines = pk.Lines().Count(),
LastProcess = pe,
NumErrors = pk.Lines().Count(l => l.Exception(pe) != null),
});
ExceptionLogic.DeleteLogs += ExceptionLogic_DeletePackages <PackageEntity>;
}
if (packageOperations)
{
sb.Settings.AssertImplementedBy((PackageLineEntity pl) => pl.Package, typeof(PackageOperationEntity));
sb.Settings.AssertImplementedBy((ProcessEntity pe) => pe.Data, typeof(PackageOperationEntity));
sb.Include <PackageOperationEntity>()
.WithQuery(() => pk => new
{
Entity = pk,
pk.Id,
pk.Name,
pk.Operation,
});
QueryLogic.Queries.Register(PackageQuery.PackageOperationLastProcess, () =>
from p in Database.Query <PackageOperationEntity>()
let pe = p.LastProcess()
select new
{
Entity = p,
p.Id,
p.Name,
p.Operation,
NumLines = p.Lines().Count(),
LastProcess = pe,
NumErrors = p.Lines().Count(l => l.Exception(pe) != null),
});
ProcessLogic.Register(PackageOperationProcess.PackageOperation, new PackageOperationAlgorithm());
ExceptionLogic.DeleteLogs += ExceptionLogic_DeletePackages <PackageOperationEntity>;
}
}
}
public int UpdateFrom5()
{
SchemaBuilder.AlterTable("GoogleAnalyticsSettingsPartRecord",
table => table.AddColumn <string>("CookieLevel"));
return(6);
}
/// <summary>
/// This executes whenever this module is activated.
/// </summary>
public int Create()
{
// Creating table ActivityPartRecord
SchemaBuilder.CreateTable("ActivityPartRecord", table => table
.ContentPartRecord()
.Column <DateTime>("DateTimeStart")
.Column <DateTime>("DateTimeEnd")
.Column <bool>("AllDay")
.Column <bool>("Repeat")
.Column <string>("RepeatType", column => column.WithLength(1))
.Column <int>("RepeatValue")
.Column <string>("RepeatDetails")
.Column <bool>("RepeatEnd")
.Column <DateTime>("RepeatEndDate")
);
//Creating the ActivityPart
ContentDefinitionManager.AlterPartDefinition(
typeof(ActivityPart).Name,
part => part
.Attachable()
.WithDescription("Used by the Event content type. Contains the data telling when an event must be displayed.")
);
//Creating the fields for the content type Event
ContentDefinitionManager.AlterPartDefinition(
"CalendarEvent",
part => part
.WithField("Gallery",
field => field
.OfType("MediaLibraryPickerField")
.WithDisplayName("Gallery"))
.WithField("Relatedevents",
field => field
.OfType("ContentPickerField")
.WithDisplayName("Related events"))
);
//Creating the content type Event
ContentDefinitionManager.AlterTypeDefinition(
"CalendarEvent",
type => type
.WithPart("TitlePart")
.WithPart("AutoroutePart")
.WithPart("CommonPart")
.WithPart("BodyPart")
.WithPart("CalendarEvent")
.WithPart("LocalizationPart")
.WithPart("ActivityPart")
.Creatable()
);
//Creating the table CalendarPartRecord
SchemaBuilder.CreateTable("CalendarPartRecord", table => table
.ContentPartRecord()
.Column <int>("QueryPartRecord_Id")
.Column <int>("LayoutRecord_Id")
.Column <int>("ItemsPerPage")
.Column <string>("PagerSuffix", column => column.WithLength(255))
.Column <bool>("DisplayPager")
);
//Creating the CalendarPart
ContentDefinitionManager.AlterPartDefinition(
typeof(CalendarPart).Name,
part => part
.Attachable()
.WithDescription("Used by the Calendar content type. Contains the source query that retrieves the events and some information about how to display them.")
);
//Creating the content type Calendar
ContentDefinitionManager.AlterTypeDefinition(
"Calendar",
type => type
.WithPart("TitlePart")
.WithPart("AutoroutePart")
.WithPart("CommonPart")
.WithPart("BodyPart")
.WithPart("LocalizationPart")
.WithPart("CalendarPart")
.Creatable()
);
//Creating the Calendar widget
ContentDefinitionManager.AlterTypeDefinition("CalendarWidget",
cfg => cfg
.WithPart("WidgetPart")
.WithPart("CommonPart")
.WithPart("IdentityPart")
.WithPart("CalendarPart")
.WithSetting("Stereotype", "Widget")
);
return(1);
}
private void RunAssertionDispatchBackQueue(EPServiceProvider epService, EventRepresentationChoice eventRepresentationEnum)
{
epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema StartValueEvent as (dummy string)");
epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema TestForwardEvent as (prop1 string)");
epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema TestInputEvent as (dummy string)");
epService.EPAdministrator.CreateEPL("insert into TestForwardEvent select'V1' as prop1 from TestInputEvent");
epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create window NamedWin#unique(prop1) (prop1 string, prop2 string)");
epService.EPAdministrator.CreateEPL("insert into NamedWin select 'V1' as prop1, 'O1' as prop2 from StartValueEvent");
epService.EPAdministrator.CreateEPL("on TestForwardEvent update NamedWin as work set prop2 = 'U1' where work.prop1 = 'V1'");
string[] fields = "prop1,prop2".Split(',');
string eplSelect = "select irstream prop1, prop2 from NamedWin";
var listener = new SupportUpdateListener();
epService.EPAdministrator.CreateEPL(eplSelect).Events += listener.Update;
if (eventRepresentationEnum.IsObjectArrayEvent())
{
epService.EPRuntime.SendEvent(new object[] { "dummyValue" }, "StartValueEvent");
}
else if (eventRepresentationEnum.IsMapEvent())
{
epService.EPRuntime.SendEvent(new Dictionary <string, object>(), "StartValueEvent");
}
else if (eventRepresentationEnum.IsAvroEvent())
{
epService.EPRuntime.SendEventAvro(new GenericRecord(
SchemaBuilder.Record("soemthing")), "StartValueEvent");
}
else
{
Assert.Fail();
}
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "V1", "O1" });
if (eventRepresentationEnum.IsObjectArrayEvent())
{
epService.EPRuntime.SendEvent(new object[] { "dummyValue" }, "TestInputEvent");
}
else if (eventRepresentationEnum.IsMapEvent())
{
epService.EPRuntime.SendEvent(new Dictionary <string, object>(), "TestInputEvent");
}
else if (eventRepresentationEnum.IsAvroEvent())
{
epService.EPRuntime.SendEventAvro(new GenericRecord(
SchemaBuilder.Record("soemthing")), "TestInputEvent");
}
else
{
Assert.Fail();
}
EPAssertionUtil.AssertProps(listener.LastOldData[0], fields, new object[] { "V1", "O1" });
EPAssertionUtil.AssertProps(listener.GetAndResetLastNewData()[0], fields, new object[] { "V1", "U1" });
epService.EPAdministrator.DestroyAllStatements();
foreach (string name in "StartValueEvent,TestForwardEvent,TestInputEvent,NamedWin".Split(','))
{
epService.EPAdministrator.Configuration.RemoveEventType(name, true);
}
}
private void TryAssertionSchemaCopyProperties(EPServiceProvider epService, EventRepresentationChoice eventRepresentationEnum)
{
epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema BaseOne (prop1 string, prop2 int)");
epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema BaseTwo (prop3 long)");
// test define and send
epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema E1 () copyfrom BaseOne");
var stmtOne = epService.EPAdministrator.CreateEPL("select * from E1");
var listener = new SupportUpdateListener();
stmtOne.Events += listener.Update;
Assert.IsTrue(eventRepresentationEnum.MatchesClass(stmtOne.EventType.UnderlyingType));
Assert.AreEqual(typeof(string), stmtOne.EventType.GetPropertyType("prop1"));
Assert.AreEqual(typeof(int?), stmtOne.EventType.GetPropertyType("prop2").GetBoxedType());
if (eventRepresentationEnum.IsObjectArrayEvent())
{
epService.EPRuntime.SendEvent(new object[] { "v1", 2 }, "E1");
}
else if (eventRepresentationEnum.IsMapEvent())
{
IDictionary <string, object> @event = new LinkedHashMap <string, object>();
@event.Put("prop1", "v1");
@event.Put("prop2", 2);
epService.EPRuntime.SendEvent(@event, "E1");
}
else if (eventRepresentationEnum.IsAvroEvent())
{
var @event = new GenericRecord(SchemaBuilder.Record("name",
RequiredString("prop1"), RequiredInt("prop2")));
@event.Put("prop1", "v1");
@event.Put("prop2", 2);
epService.EPRuntime.SendEventAvro(@event, "E1");
}
else
{
Assert.Fail();
}
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), "prop1,prop2".Split(','), new object[] { "v1", 2 });
// test two copy-from types
epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema E2 () copyfrom BaseOne, BaseTwo");
var stmtTwo = epService.EPAdministrator.CreateEPL("select * from E2");
Assert.AreEqual(typeof(string), stmtTwo.EventType.GetPropertyType("prop1"));
Assert.AreEqual(typeof(int?), stmtTwo.EventType.GetPropertyType("prop2").GetBoxedType());
Assert.AreEqual(typeof(long?), stmtTwo.EventType.GetPropertyType("prop3").GetBoxedType());
// test API-defined type
if (eventRepresentationEnum.IsMapEvent() ||
eventRepresentationEnum.IsObjectArrayEvent())
{
var def = new Dictionary <string, object>();
def.Put("a", "string");
def.Put("b", typeof(string));
def.Put("c", "BaseOne");
def.Put("d", "BaseTwo[]");
epService.EPAdministrator.Configuration.AddEventType("MyType", def);
}
else
{
epService.EPAdministrator.CreateEPL("create avro schema MyType(a string, b string, c BaseOne, d BaseTwo[])");
}
epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema E3(e long, f BaseOne) copyfrom MyType");
var stmtThree = epService.EPAdministrator.CreateEPL("select * from E3");
Assert.AreEqual(typeof(string), stmtThree.EventType.GetPropertyType("a"));
Assert.AreEqual(typeof(string), stmtThree.EventType.GetPropertyType("b"));
if (eventRepresentationEnum.IsObjectArrayEvent())
{
Assert.AreEqual(typeof(object[]), stmtThree.EventType.GetPropertyType("c"));
Assert.AreEqual(typeof(object[][]), stmtThree.EventType.GetPropertyType("d"));
Assert.AreEqual(typeof(object[]), stmtThree.EventType.GetPropertyType("f"));
}
else if (eventRepresentationEnum.IsMapEvent())
{
Assert.AreEqual(typeof(Map), stmtThree.EventType.GetPropertyType("c"));
Assert.AreEqual(typeof(Map[]), stmtThree.EventType.GetPropertyType("d"));
Assert.AreEqual(typeof(Map), stmtThree.EventType.GetPropertyType("f"));
}
else if (eventRepresentationEnum.IsAvroEvent())
{
Assert.AreEqual(typeof(GenericRecord), stmtThree.EventType.GetPropertyType("c"));
Assert.AreEqual(typeof(GenericRecord[]), stmtThree.EventType.GetPropertyType("d"));
Assert.AreEqual(typeof(GenericRecord), stmtThree.EventType.GetPropertyType("f"));
}
else
{
Assert.Fail();
}
Assert.AreEqual(typeof(long?), stmtThree.EventType.GetPropertyType("e").GetBoxedType());
// invalid tests
TryInvalid(epService, eventRepresentationEnum.GetAnnotationText() + " create schema E4(a long) copyFrom MyType",
"Error starting statement: Type by name 'MyType' contributes property 'a' defined as 'System.String' which overides the same property of type '" + Name.Clean <long>(false) + "' [");
TryInvalid(epService, eventRepresentationEnum.GetAnnotationText() + " create schema E4(c BaseTwo) copyFrom MyType",
"Error starting statement: Property by name 'c' is defined twice by adding type 'MyType' [");
TryInvalid(epService, eventRepresentationEnum.GetAnnotationText() + " create schema E4(c BaseTwo) copyFrom XYZ",
"Error starting statement: Type by name 'XYZ' could not be located [");
TryInvalid(epService, eventRepresentationEnum.GetAnnotationText() + " create schema E4 as " + typeof(SupportBean).FullName + " copyFrom XYZ",
"Error starting statement: Copy-from types are not allowed with class-provided types [");
TryInvalid(epService, eventRepresentationEnum.GetAnnotationText() + " create variant schema E4(c BaseTwo) copyFrom XYZ",
"Error starting statement: Copy-from types are not allowed with variant types [");
// test SODA
var createEPL = eventRepresentationEnum.GetAnnotationText() + " create schema EX as () copyFrom BaseOne, BaseTwo";
var model = epService.EPAdministrator.CompileEPL(createEPL);
Assert.AreEqual(createEPL.Trim(), model.ToEPL());
var stmt = epService.EPAdministrator.Create(model);
Assert.AreEqual(createEPL.Trim(), stmt.Text);
epService.EPAdministrator.DestroyAllStatements();
foreach (var name in "BaseOne,BaseTwo,E1,E2,E3,MyType".Split(','))
{
epService.EPAdministrator.Configuration.RemoveEventType(name, true);
}
}
public SubscriptionsFacts()
{
// schema
var builder = new SchemaBuilder();
builder.Object("Message", out var messageType)
.Connections(connect => connect
.Field(messageType, "content", ScalarType.String));
var messageListType = new List(messageType);
builder.Query(out var query)
.Connections(connect => connect
.Field(query, "messages", messageListType));
builder.Subscription(out var subscription)
.Connections(connect => connect
.Field(subscription, "messageAdded", messageType));
var schema = builder.Build();
// data
var messages = new List <Message>();
_messagesChannel = new EventChannel <Message>();
// resolvers
ValueTask <IResolveResult> GetMessagesAsync(ResolverContext context)
{
return(ResolveSync.As(messages));
}
ValueTask <ISubscribeResult> OnMessageAdded(ResolverContext context, CancellationToken unsubscribe)
{
return(ResolveSync.Subscribe(_messagesChannel, unsubscribe));
}
ValueTask <IResolveResult> ResolveMessage(ResolverContext context)
{
return(ResolveSync.As(context.ObjectValue));
}
var resolvers = new ResolverMap
{
["Query"] = new FieldResolverMap
{
{ "messages", GetMessagesAsync }
},
["Subscription"] = new FieldResolverMap
{
{ "messageAdded", OnMessageAdded, ResolveMessage }
},
["Message"] = new FieldResolverMap
{
{ "content", Resolve.PropertyOf <Message>(r => r.Content) }
}
};
// make executable
_executable = SchemaTools.MakeExecutableSchema(
schema,
resolvers,
resolvers);
}
/// <summary>
/// Updates the setups to save into the document.
/// </summary>
public void UpdateSavedConfigurations()
{
// delete the old schema and the DataStorage.
if (m_schema == null)
{
m_schema = Schema.Lookup(s_schemaId);
}
if (m_schema != null)
{
IList <DataStorage> oldSavedConfigurations = GetSavedConfigurations(m_schema);
if (oldSavedConfigurations.Count > 0)
{
Transaction deleteTransaction = new Transaction(IFCCommandOverrideApplication.TheDocument,
Properties.Resources.DeleteOldSetups);
try
{
deleteTransaction.Start();
List <ElementId> dataStorageToDelete = new List <ElementId>();
foreach (DataStorage dataStorage in oldSavedConfigurations)
{
dataStorageToDelete.Add(dataStorage.Id);
}
IFCCommandOverrideApplication.TheDocument.Delete(dataStorageToDelete);
deleteTransaction.Commit();
}
catch (System.Exception)
{
if (deleteTransaction.HasStarted())
{
deleteTransaction.RollBack();
}
}
}
}
// update the configurations to new map schema.
if (m_mapSchema == null)
{
m_mapSchema = Schema.Lookup(s_mapSchemaId);
}
// Are there any setups to save or resave?
List <IFCExportConfiguration> setupsToSave = new List <IFCExportConfiguration>();
foreach (IFCExportConfiguration configuration in m_configurations.Values)
{
if (configuration.IsBuiltIn)
{
continue;
}
// Store in-session settings in the cached in-session configuration
if (configuration.IsInSession)
{
IFCExportConfiguration.SetInSession(configuration);
continue;
}
setupsToSave.Add(configuration);
}
// If there are no setups to save, and if the schema is not present (which means there are no
// previously existing setups which might have been deleted) we can skip the rest of this method.
if (setupsToSave.Count <= 0 && m_mapSchema == null)
{
return;
}
if (m_mapSchema == null)
{
SchemaBuilder builder = new SchemaBuilder(s_mapSchemaId);
builder.SetSchemaName("IFCExportConfigurationMap");
builder.AddMapField(s_configMapField, typeof(String), typeof(String));
m_mapSchema = builder.Finish();
}
// Overwrite all saved configs with the new list
Transaction transaction = new Transaction(IFCCommandOverrideApplication.TheDocument, Properties.Resources.UpdateExportSetups);
try
{
transaction.Start();
IList <DataStorage> savedConfigurations = GetSavedConfigurations(m_mapSchema);
int savedConfigurationCount = savedConfigurations.Count <DataStorage>();
int savedConfigurationIndex = 0;
foreach (IFCExportConfiguration configuration in setupsToSave)
{
DataStorage configStorage;
if (savedConfigurationIndex >= savedConfigurationCount)
{
configStorage = DataStorage.Create(IFCCommandOverrideApplication.TheDocument);
}
else
{
configStorage = savedConfigurations[savedConfigurationIndex];
savedConfigurationIndex++;
}
Entity mapEntity = new Entity(m_mapSchema);
IDictionary <string, string> mapData = new Dictionary <string, string>();
mapData.Add(s_setupName, configuration.Name);
mapData.Add(s_setupDescription, configuration.Description);
mapData.Add(s_setupVersion, configuration.IFCVersion.ToString());
mapData.Add(s_setupFileFormat, configuration.IFCFileType.ToString());
mapData.Add(s_setupSpaceBoundaries, configuration.SpaceBoundaries.ToString());
mapData.Add(s_setupQTO, configuration.ExportBaseQuantities.ToString());
mapData.Add(s_setupCurrentView, configuration.VisibleElementsOfCurrentView.ToString());
mapData.Add(s_splitWallsAndColumns, configuration.SplitWallsAndColumns.ToString());
mapData.Add(s_setupExport2D, configuration.Export2DElements.ToString());
mapData.Add(s_setupExportRevitProps, configuration.ExportInternalRevitPropertySets.ToString());
mapData.Add(s_setupExportIFCCommonProperty, configuration.ExportIFCCommonPropertySets.ToString());
mapData.Add(s_setupUse2DForRoomVolume, configuration.Use2DRoomBoundaryForVolume.ToString());
mapData.Add(s_setupUseFamilyAndTypeName, configuration.UseFamilyAndTypeNameForReference.ToString());
mapData.Add(s_setupExportPartsAsBuildingElements, configuration.ExportPartsAsBuildingElements.ToString());
mapData.Add(s_setupExportBoundingBox, configuration.ExportBoundingBox.ToString());
mapData.Add(s_setupExportSolidModelRep, configuration.ExportSolidModelRep.ToString());
mapData.Add(s_setupExportSchedulesAsPsets, configuration.ExportSchedulesAsPsets.ToString());
mapData.Add(s_setupExportUserDefinedPsets, configuration.ExportUserDefinedPsets.ToString());
mapData.Add(s_setupExportUserDefinedPsetsFileName, configuration.ExportUserDefinedPsetsFileName);
mapData.Add(s_setupExportLinkedFiles, configuration.ExportLinkedFiles.ToString());
mapData.Add(s_setupIncludeSiteElevation, configuration.IncludeSiteElevation.ToString());
mapData.Add(s_setupUseCoarseTessellation, configuration.UseCoarseTessellation.ToString());
mapData.Add(s_setupStoreIFCGUID, configuration.StoreIFCGUID.ToString());
mapData.Add(s_setupActivePhase, configuration.ActivePhaseId.ToString());
mapEntity.Set <IDictionary <string, String> >(s_configMapField, mapData);
configStorage.SetEntity(mapEntity);
}
List <ElementId> elementsToDelete = new List <ElementId>();
for (; savedConfigurationIndex < savedConfigurationCount; savedConfigurationIndex++)
{
DataStorage configStorage = savedConfigurations[savedConfigurationIndex];
elementsToDelete.Add(configStorage.Id);
}
if (elementsToDelete.Count > 0)
{
IFCCommandOverrideApplication.TheDocument.Delete(elementsToDelete);
}
transaction.Commit();
}
catch (System.Exception)
{
if (transaction.HasStarted())
{
transaction.RollBack();
}
}
}
public SdlReader(TypeSystemDocument document, SchemaBuilder?builder = null)
{
_document = document;
_builder = builder ?? new SchemaBuilder();
}
public override void Configure(IFunctionsHostBuilder builder)
{
builder.Services.AddDbContext <BloggingContext>(opt => opt.UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=Blogging;Integrated Security=True"));
builder.Services.AddSingleton(SchemaBuilder.FromObject <BloggingContext>());
}
public void CompilesFirst()
{
var exp = EqlCompiler.Compile(@"people.first(guid = ""6492f5fe-0869-4279-88df-7f82f8e87a67"")", SchemaBuilder.FromObject <TestSchema>(), null, new DefaultMethodProvider(), null);
var result = exp.Execute(new TestSchema()) as Person;
Assert.Equal(new Guid("6492f5fe-0869-4279-88df-7f82f8e87a67"), result.Guid);
}
public void FailsWhereNoParameter()
{
var ex = Assert.Throws <EntityGraphQLCompilerException>(() => EqlCompiler.Compile("people.where()", SchemaBuilder.FromObject <TestSchema>(), null, new DefaultMethodProvider(), null));
Assert.Equal("Method 'where' expects 1 argument(s) but 0 were supplied", ex.Message);
}
public static void AssertStarted(SchemaBuilder sb)
{
sb.AssertDefined(ReflectionTools.GetMethodInfo(() => Start(null, null)));
}
private string SetupInternal(SetupContext context)
{
string executionId;
Logger.Information("Running setup for tenant '{0}'.", _shellSettings.Name);
// The vanilla Orchard distibution has the following features enabled.
string[] hardcoded =
{
// Framework
"Orchard.Framework",
// Core
"Common", "Containers", "Contents", "Dashboard", "Feeds", "Navigation", "Scheduling", "Settings", "Shapes", "Title",
// Modules
"Orchard.Pages", "Orchard.ContentPicker", "Orchard.Themes", "Orchard.Users", "Orchard.Roles", "Orchard.Modules",
"PackagingServices","Orchard.Packaging", "Gallery", "Orchard.Recipes"
};
context.EnabledFeatures = hardcoded.Union(context.EnabledFeatures ?? Enumerable.Empty <string>()).Distinct().ToList();
// Set shell state to "Initializing" so that subsequent HTTP requests are responded to with "Service Unavailable" while Orchard is setting up.
_shellSettings.State = TenantState.Initializing;
var shellSettings = new ShellSettings(_shellSettings);
if (String.IsNullOrEmpty(shellSettings.DataProvider))
{
shellSettings.DataProvider = context.DatabaseProvider;
shellSettings.DataConnectionString = context.DatabaseConnectionString;
shellSettings.DataTablePrefix = context.DatabaseTablePrefix;
}
shellSettings.EncryptionAlgorithm = "AES";
// Randomly generated key.
shellSettings.EncryptionKey = SymmetricAlgorithm.Create(shellSettings.EncryptionAlgorithm).Key.ToHexString();
shellSettings.HashAlgorithm = "HMACSHA256";
// Randomly generated key.
shellSettings.HashKey = HMAC.Create(shellSettings.HashAlgorithm).Key.ToHexString();
var shellDescriptor = new ShellDescriptor {
Features = context.EnabledFeatures.Select(name => new ShellFeature {
Name = name
})
};
var shellBlueprint = _compositionStrategy.Compose(shellSettings, shellDescriptor);
// Initialize database explicitly, and store shell descriptor.
using (var bootstrapLifetimeScope = _shellContainerFactory.CreateContainer(shellSettings, shellBlueprint)) {
using (var environment = bootstrapLifetimeScope.CreateWorkContextScope()) {
// Check if the database is already created (in case an exception occured in the second phase).
var schemaBuilder = new SchemaBuilder(environment.Resolve <IDataMigrationInterpreter>());
var installationPresent = true;
try {
var tablePrefix = String.IsNullOrEmpty(shellSettings.DataTablePrefix) ? "" : shellSettings.DataTablePrefix + "_";
schemaBuilder.ExecuteSql("SELECT * FROM " + tablePrefix + "Settings_ShellDescriptorRecord");
}
catch {
installationPresent = false;
}
if (installationPresent)
{
throw new OrchardException(T("A previous Orchard installation was detected in this database with this table prefix."));
}
// Workaround to avoid some Transaction issue for PostgreSQL.
environment.Resolve <ITransactionManager>().RequireNew();
schemaBuilder.CreateTable("Orchard_Framework_DataMigrationRecord", table => table
.Column <int>("Id", column => column.PrimaryKey().Identity())
.Column <string>("DataMigrationClass")
.Column <int>("Version"));
schemaBuilder.AlterTable("Orchard_Framework_DataMigrationRecord",
table => table.AddUniqueConstraint("UC_DMR_DataMigrationClass_Version", "DataMigrationClass", "Version"));
var dataMigrationManager = environment.Resolve <IDataMigrationManager>();
dataMigrationManager.Update("Settings");
foreach (var feature in context.EnabledFeatures)
{
dataMigrationManager.Update(feature);
}
environment.Resolve <IShellDescriptorManager>().UpdateShellDescriptor(
0,
shellDescriptor.Features,
shellDescriptor.Parameters);
}
}
// In effect "pump messages" see PostMessage circa 1980.
while (_processingEngine.AreTasksPending())
{
_processingEngine.ExecuteNextTask();
}
// Creating a standalone environment.
// in theory this environment can be used to resolve any normal components by interface, and those
// components will exist entirely in isolation - no crossover between the safemode container currently in effect.
using (var environment = _orchardHost.CreateStandaloneEnvironment(shellSettings)) {
try {
executionId = CreateTenantData(context, environment);
}
catch {
environment.Resolve <ITransactionManager>().Cancel();
throw;
}
}
_shellSettingsManager.SaveSettings(shellSettings);
return(executionId);
}