public AdncDbContext(DbContextOptions options, Operater operater, IEntityInfo entityInfo)
: base(options)
{
_operater = operater;
_entityInfo = entityInfo;
Database.AutoTransactionsEnabled = false;
//ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
}
/// <summary>
/// Reads column with specified <paramref name="columnName"/> from entity with <paramref name="entityName"/>, filtered with specified <paramref name="criteria"/>.
/// It's used to .Select() something.
/// </summary>
public override IEnumerable <object> ReadColumn(string columnName, IEntityInfo info, ICollection <IDataCriterion> criteria)
{
return(Read(info, criteria).Select(x => {
object value;
x.TryGet(columnName, out value);
return value;
}));
}
public ForeignKey(EntityInfoCollection entities, IEntityInfo entityLocal, PropertyInfo prop,
ForeignKeyAttribute foreignKeyAttribute)
: base(entityLocal, prop, foreignKeyAttribute)
{
_constraintName = new Lazy <string>(ComputeConstraintName);
Entities = entities;
ForeignType = foreignKeyAttribute.ForeignType;
}
protected override OracleParameter ParameterWith(IEntityInfo info, IDataCriterion criterion)
{
var oraInfo = (IAdoEntityInfo <OracleDbType>)info;
return(new OracleParameter(DatabaseSpecificNameOf(criterion), oraInfo.GetParameterDbType(criterion))
{
Value = criterion.Value
});
}
/// <summary>
/// Get <see cref="CommandBehavior"/> for command.
/// </summary>
/// <returns>Instance of CommandBehavior</returns>
protected virtual CommandBehavior GetBehaviorFor(IEntityInfo info)
{
if (info.Inclusions?.Any() != true)
{
return(CommandBehavior.SequentialAccess | CommandBehavior.SingleResult);
}
return(CommandBehavior.SequentialAccess);
}
public EntityViewModel(IWindowsManager windowsManager, IVirtualFileSystem fs, VirtualDirectory directory, bool isParentDirectory)
: base(windowsManager)
{
_entityInfo = isParentDirectory
? new ParentDirectoryInfo(directory, fs)
: new VirtualDirectoryInfo(directory, fs);
EditableName = Name;
}
public void SerializeInfo()
{
IEntityInfo info = new EntityInfo(EntityRace.Human, EntityOccupation.Barbarian, 365 * 25, "Grok");
IEntityInfo infoClone = Serializer.DeepClone(info);
Assert.AreEqual(info.Name, infoClone.Name);
Assert.AreEqual(info.Occupation, infoClone.Occupation);
Assert.AreEqual(info.Race, infoClone.Race);
}
protected override NpgsqlParameter ParameterWith(IEntityInfo info, IDataCriterion criterion)
{
var sqlInfo = (IAdoEntityInfo <SqlDbType>)info;
return(new NpgsqlParameter(DatabaseSpecificNameOf(criterion), sqlInfo.GetParameterDbType(criterion))
{
Value = criterion.Value
});
}
public DefaultEntitySerializer(IEntityInfo entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
Entity = entity;
}
public void Read_SkipsUnknownElements()
{
OsmXmlReader target = new OsmXmlReader(new MemoryStream(XmlTestData.osm_unknown_inner_element), new OsmXmlReaderSettings()
{
ReadMetadata = false
});
IEntityInfo result = target.Read();
Assert.NotNull(result as NodeInfo);
}
private Reference(IEntityInfo entityInfo, PropertyInfo prop, ReferenceAttribute referenceAttribute)
: base(entityInfo, prop, null)
{
_type = typeof(IList).IsAssignableFrom(prop.PropertyType)
? ReferenceType.OneToMany
: ReferenceType.ManyToOne;
ReferenceEntityType = referenceAttribute.ReferenceEntityType;
LocalReferenceField = referenceAttribute.LocalReferenceField;
ForeignReferenceField = referenceAttribute.ForeignReferenceField;
}
public void Read_SkipsUnknownElements()
{
OsmXmlReader target = new OsmXmlReader(TestDataReader.OpenXml("osm-unknown-inner-element.osm"), new OsmXmlReaderSettings()
{
ReadMetadata = false
});
IEntityInfo result = target.Read();
Assert.NotNull(result as NodeInfo);
}
private void CreateAndAddMergeResolution(IEntityInfo entityInfo, OperationTypes operationType, IEntity entity)
{
var resolution = MergeResolution.Create(entityInfo, operationType, entity);
if (resolution == null)
{
return;
}
MergeResolutionToApplies.Add(resolution);
}
/* public static bool GetCanView(string schema, string name)
* {
* var info = GetInfo(schema, name);
* return GetCanView(info);
* }
*
* public static bool GetCanAdd(string schema, string name)
* {
* var info = GetInfo(schema, name);
* return GetCanAdd(info);
* }
*
* public static bool GetCanModify(string schema, string name)
* {
* var info = GetInfo(schema, name);
* return GetCanModify(info);
* }
*
* public static bool GetCanRemove(string schema, string name)
* {
* var info = GetInfo(schema, name);
* return GetCanRemove(info);
* }*/
public static int GetMaxRows(IEntityInfo info)
{
if (info != null)
{
if (info.Max.HasValue)
{
return(info.Max.Value);
}
}
return(Configuration.Defaults.Max);
}
protected internal virtual string SelectQuery(IEntityInfo info, IEnumerable <IDataCriterion> criteria)
{
var builder = new StringBuilder("select * from ").Append(info.EntityName).Append(" where ");
foreach (var criterion in criteria)
{
builder.Append(criterion.Name).Append(" = ").Append(DatabaseSpecificNameOf(criterion.Name)).Append(" and ");
}
return(builder.Remove(builder.Length - 5, 5).ToString());
}
public static EntityChange Create(IEntityInfo entityInfo, IEntity entity)
{
var result = new EntityChange(entityInfo);
foreach (var field in entityInfo.Fields)
{
var entityField = new EntityField(field.FieldName, field.GetEntityValue(entity), field);
result.Fields.Add(entityField);
}
return(result);
}
void AddToInspector(string group, IEntityInfo entityInfo)
{
EntityInspector inspector;
if (!m_Holders.TryGetValue(group, out inspector))
{
inspector = new UnityEngine.GameObject(group).AddComponent <EntityInspector>();
m_Holders.Add(group, inspector);
}
inspector.Items.Add(entityInfo);
}
public static bool HasPermission(ClaimsPrincipal claimsPrincipal, IEntityInfo info, string permission, bool exact = false)
{
if (claimsPrincipal != null)
{
var prefix = info.Name.ToUpperInvariant();
return
(claimsPrincipal.IsInRole(prefix + "_" + permission.ToUpperInvariant()) ||
(!exact && claimsPrincipal.IsInRole(prefix + "_F")));
}
return(false);
}
public AdncDbContext([NotNull] DbContextOptions options, IOperater operater, [NotNull] IEntityInfo entityInfo, UnitOfWorkStatus unitOfWorkStatus)
: base(options)
{
_operater = operater;
_entityInfo = entityInfo;
_unitOfWorkStatus = unitOfWorkStatus;
//关闭DbContext默认事务
Database.AutoTransactionsEnabled = false;
//关闭查询跟踪
//ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
}
public static EntityChangeset Create(ISqlDataStore dataStore, IEntityInfo syncEntity, ISyncSessionInfo syncSessionInfo)
{
var entityName = syncEntity.GetNameInStore();
var result = new EntityChangeset(entityName)
{
_syncSession = syncSessionInfo
};
result.SetDatastore(dataStore);
return(result);
}
public static bool GetCanRemove(IEntityInfo info)
{
if (info == null)
{
return(false);
}
if (info.CanRemove.HasValue)
{
return(info.CanRemove.Value);
}
return(Configuration.Defaults.CanRemove);
}
public void ValidateTable(IEntityInfo entity)
{
var entityName = entity.GetNameInStore();
var connection = _datastore.GetConnection();
// first make sure the table exists
if (_datastore.TableExists(entityName))
{
return;
}
_datastore.CreateTable(connection, entity);
}
public IEnumerable <object> Read(IEntityInfo info, ICollection <IDataCriterion> criteria)
{
var collection = MongoDatabase().GetCollection <BsonDocument>(info.EntityName);
if (criteria.Count != 0)
{
return(collection.Find(new BsonDocument()).ToList().Select(x => BsonSerializer.Deserialize <object>(x)));
}
var filter = Builders <BsonDocument> .Filter.And(criteria.Select(x => x.Name == "Id" ? Builders <BsonDocument> .Filter.Eq("_id", x.Value) : Builders <BsonDocument> .Filter.Eq(x.Name, x.Value)));
return(collection.Find(filter).ToList().Select(x => BsonSerializer.Deserialize <object>(x)));
}
private void EnsureCompatibility(IDbConnection connection, IEntityInfo entity)
{
var tableName = entity.GetNameInStore();
if (!TableExists(tableName))
{
CreateTable(connection, entity);
}
else
{
ValidateTable(entity);
}
}
public static void SetInfo(IEntityInfo info)
{
var allEntities = Configuration.Entities;
var module = info.Module;
if (!allEntities.ContainsKey(module))
{
allEntities.TryAdd(module, new ConcurrentDictionary <string, IEntityInfo>());
}
;
allEntities[module][info.Entity] = info;
}
public void Read_ReturnsNullIfAllEntitiesHaveBeenRead()
{
PbfReader target = new PbfReader(TestDataReader.OpenPbf("pbf-n-node.pbf"), new OsmReaderSettings()
{
ReadMetadata = false
});
//read only entity
IEntityInfo read = target.Read();
// should return null
read = target.Read();
Assert.Null(read);
}
public void Read_ReturnsNullIfAllEntitiesHaveBeenRead()
{
PbfReader target = new PbfReader(new MemoryStream(PbfTestData.pbf_n_node), new OsmReaderSettings()
{
ReadMetadata = false
});
//read only entity
IEntityInfo read = target.Read();
// should return null
read = target.Read();
Assert.Null(read);
}
/// <summary>
/// 从指定上下文中获取数据审计信息
/// </summary>
/// <param name="context">数据上下文</param>
/// <returns>数据审计信息的集合</returns>
public virtual IEnumerable <AuditEntityEntry> GetAuditEntities(DbContext context)
{
List <AuditEntityEntry> result = new List <AuditEntityEntry>();
//当前操作的功能是否允许数据审计
IFunction function = _scopedDict?.Function;
if (function == null)
{
return(result);
}
if (!function.AuditEntityEnabled)
{
_logger.LogDebug($"提取数据审计：功能 {function} 未开启数据审计，取消操作");
return(result);
}
if (_entityInfoHandler == null)
{
return(result);
}
EntityState[] states = { EntityState.Added, EntityState.Modified, EntityState.Deleted };
List <EntityEntry> entries = context.ChangeTracker.Entries().Where(m => m.Entity != null && states.Contains(m.State)).ToList();
if (entries.Count == 0)
{
return(result);
}
foreach (EntityEntry entry in entries)
{
//当前操作的实体是否允许数据审计
IEntityInfo entityInfo = _entityInfoHandler.GetEntityInfo(entry.Entity.GetType());
if (entityInfo == null)
{
continue;
}
if (!entityInfo.AuditEnabled)
{
_logger.LogDebug($"提取数据审计：实体 {entityInfo} 未开启审计，跳过");
continue;
}
result.AddIfNotNull(GetAuditEntity(entry, entityInfo));
_logger.LogDebug($"提取数据审计：实体 {entityInfo} ");
}
return(result);
}
public IEntity Create(EntityProfile profile)
{
IEntityInfo info = GenerateEntityInfo(profile.Race, profile.Occupation);
IEntityStats stats = GetStatsPoints(profile.Occupation, profile.Level * 10);
IEntitySkills skills = new EntitySkills();
IInventory inventory = new Inventory(20); // smaller inventory for entity
IEntityAbility abilities = new EntityAbility(GeneralAbilities.All, ItemAbilities.None, EntityAbilities.ModifyInterationAbilities, EffectAbilities.ModifyMagicAbilities, AIAbilities.None);
Guid id = Guid.NewGuid();
IEntity entity = new Entity(id, info, skills, stats, inventory, abilities);
this.AddOccupation(entity, info.Occupation);
return(entity);
}
private static AuditEntity GetAuditEntity(EntityEntry entry, IEntityInfo entityInfo)
{
AuditEntity audit = new AuditEntity()
{
Name = entityInfo.Name, TypeName = entityInfo.TypeName, OperateType = OperateType.Insert
};
EntityProperty[] entityProperties = entityInfo.Properties;
foreach (IProperty property in entry.CurrentValues.Properties)
{
if (property.IsConcurrencyToken)
{
continue;
}
string name = property.Name;
if (property.IsPrimaryKey())
{
audit.EntityKey = entry.State == EntityState.Deleted
? entry.Property(property.Name).OriginalValue?.ToString()
: entry.Property(property.Name).CurrentValue?.ToString();
}
AuditEntityProperty auditProperty = new AuditEntityProperty()
{
FieldName = name,
DisplayName = entityProperties.First(m => m.Name == name).Display,
DataType = property.ClrType.ToString()
};
if (entry.State == EntityState.Added)
{
auditProperty.NewValue = entry.Property(property.Name).CurrentValue?.ToString();
}
else if (entry.State == EntityState.Deleted)
{
auditProperty.OriginalValue = entry.Property(property.Name).OriginalValue?.ToString();
}
else if (entry.State == EntityState.Modified)
{
string currentValue = entry.Property(property.Name).CurrentValue?.ToString();
string originalValue = entry.Property(property.Name).OriginalValue?.ToString();
if (currentValue != originalValue)
{
auditProperty.NewValue = currentValue;
auditProperty.OriginalValue = originalValue;
}
}
audit.Properties.Add(auditProperty);
}
return(audit);
}
// constructors
/// <summary>
/// Initializes an update request.
/// </summary>
/// <param name="edgemartUrl">Url of the Edgemart to be updated.</param>
/// <param name="originalObject">The original object to be updated.</param>
/// <param name="modifiedObject">The modified object.</param>
/// <param name="entityInfo">Entify Info.</param>
public Update(String edgemartUrl, IEntity originalObject, IEntity modifiedObject, IEntityInfo entityInfo)
{
if (String.IsNullOrEmpty(edgemartUrl))
{
throw new ArgumentNullException("edgemartUrl");
}
if (originalObject == null)
{
throw new ArgumentNullException("originalObject");
}
if (modifiedObject == null)
{
throw new ArgumentNullException("modifiedObject");
}
if (entityInfo == null)
{
throw new ArgumentNullException("entityInfo");
}
_edgeMartUrl = edgemartUrl;
_originalObject = originalObject;
_modifiedObject = modifiedObject;
_entityInfo = entityInfo;
}
/// <summary>
/// Writes specified entity data-transfer object in XML format to the underlaying stream.
/// </summary>
/// <param name="entity">Entity data-transfer object to write.</param>
public void Write(IEntityInfo info)
{
if (this.Settings.WriteMetadata) {
if (info.Metadata == null) {
throw new ArgumentException("Entity doesn't contain metadata object, but writer was created with WriteMetadata setting.");
}
}
if (_isInsideOsm == false) {
this.StartDocument();
}
switch (info.EntityType) {
case EntityType.Node: this.WriteNode((NodeInfo)info); break;
case EntityType.Way: this.WriteWay((WayInfo)info); break;
case EntityType.Relation: this.WriteRelation((RelationInfo)info); break;
}
}
private void TestPbfOutput(MemoryStream pbfStream, IEntityInfo expected)
{
if (pbfStream.CanSeek) {
pbfStream.Seek(0, SeekOrigin.Begin);
}
else {
pbfStream = new MemoryStream(pbfStream.GetBuffer());
}
PbfReader reader = new PbfReader(pbfStream, new OsmReaderSettings() { ReadMetadata = true });
IEntityInfo read = reader.Read();
switch (expected.EntityType) {
case EntityType.Node: this.CompareNodes(expected as NodeInfo, read as NodeInfo); break;
case EntityType.Way: this.CompareWays(expected as WayInfo, read as WayInfo); break;
case EntityType.Relation: this.CompareRelation(expected as RelationInfo, read as RelationInfo); break;
}
}
private void TestXmlOutput(MemoryStream xmlStream, IEntityInfo expected, bool readMetadata)
{
if (xmlStream.CanSeek) {
xmlStream.Seek(0, SeekOrigin.Begin);
}
else {
xmlStream = new MemoryStream(xmlStream.GetBuffer());
}
OsmXmlReader reader = new OsmXmlReader(xmlStream, new OsmXmlReaderSettings() { ReadMetadata = readMetadata });
IEntityInfo read = reader.Read();
switch (expected.EntityType) {
case EntityType.Node: this.CompareNodes(expected as NodeInfo, read as NodeInfo); break;
case EntityType.Way: this.CompareWays(expected as WayInfo, read as WayInfo); break;
case EntityType.Relation: this.CompareRelation(expected as RelationInfo, read as RelationInfo); break;
}
}
public void FixtureSetup()
{
_original = new FakeDimensionEntity
{
Key1 = "Key1Value",
Key2 = "Key2Value",
Dim1 = "Dim1Value",
Dim2 = "Dim2Value",
Dim3 = "Dim3Value"
};
_new = _original;
_entityInfo = _original.GetEntityProperties();
}
/// <summary>
/// Writes specified entity in PBF format to the underlaying stream.
/// </summary>
/// <param name="entity">Entity to write.</param>
/// <remarks>
/// PbfWriter uses internal buffers and writes entities to the output stream in blocks. To force PbfWriter to clear internal buffers and write data to the underlaying stream use Flush() function.
/// </remarks>
public void Write(IEntityInfo entity)
{
if (this.Settings.WriteMetadata) {
if (entity.Metadata == null) {
throw new ArgumentException("Entity doesn't contain metadata obejct, but writer was created with WriteMetadata setting.");
}
if (entity.Metadata.User == null) {
throw new ArgumentNullException("Entity.Metadata.User cannot be null.");
}
}
switch (entity.EntityType) {
case EntityType.Node: _nodesBuffer.Add(entity as NodeInfo); break;
case EntityType.Way: _wayBuffer.Add(entity as WayInfo); break;
case EntityType.Relation: _relationBuffer.Add(entity as RelationInfo); break;
}
if (_nodesBuffer.EstimatedMaxSize > MaxDataBlockSize) {
this.Flush(EntityType.Node);
}
if (_wayBuffer.EstimatedMaxSize > MaxDataBlockSize) {
this.Flush(EntityType.Way);
}
if (_relationBuffer.EstimatedMaxSize > MaxDataBlockSize) {
this.Flush(EntityType.Relation);
}
}
