/// <summary>
/// Executes save of entity on database
/// </summary>
/// <param name="entity">Entity to save</param>
public void Save(TEntity entity)
{
//Se non è passato un dato valido, emetto eccezione
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
//Utilizzo l'helper per il salvataggio
RepositoryHelper.Save(entity, DataSession, s =>
{
//Se l'entità ha un identificatore nullo, aggiungo
if (entity.GetId() == null)
{
//Eseguo l'assegnazione dell'identificatore primario
AssignPrimaryIdentifier(entity);
//Inserisco ed esco
Collection.InsertOne(entity);
return;
}
//In caso contrario, compongo il filtro per individuare
//univocamente l'entità in modo che possa essere rimpiazzata
FieldDefinition <TEntity, object> idFieldDefinition = new StringFieldDefinition <TEntity, object>("Id");
var uniqueFilter = Builders <TEntity> .Filter.Eq(idFieldDefinition, entity.GetId());
//Eseguo il replace
Collection.FindOneAndReplace(uniqueFilter, entity);
});
}
/// <summary>
/// Get maximum value on entity
/// </summary>
/// <typeparam name="TOutput">Type of output</typeparam>
/// <param name="fieldName">Field name</param>
/// <returns>Returns value</returns>
protected TOutput Max <TOutput>(string fieldName)
{
//Validazione argomenti
if (string.IsNullOrEmpty(fieldName))
{
throw new ArgumentNullException(nameof(fieldName));
}
//Definizione del campo su cui lavorare
var idFieldDefinition = new StringFieldDefinition <TEntity, object>(fieldName);
//Recupero il primo elemento con valore massimo
var elementWithMaxValue = Collection
.Find(Builders <TEntity> .Filter.Empty)
.Sort(Builders <TEntity> .Sort.Descending(idFieldDefinition))
.Limit(1)
.FirstOrDefault();
//Se l'elemento non esiste, ritorno il default
if (elementWithMaxValue == null)
{
return(default(TOutput));
}
//Recupero il valore della proprietà
return((TOutput)elementWithMaxValue.GetId());
}
public void MigrateIdentity(string fromVersion, string toVersion)
{
if (!ValidateMigrationOperation("Migrate Identity", fromVersion, toVersion))
{
return;
}
//creating collection
var db = _mongoClient.GetDatabase(_config.DataBase);
db.CreateCollection(IdentityMongodbSchema.Collection);
//creating index
var fieldDef = new StringFieldDefinition <BsonDocument>(IdentityMongodbSchema.IdentityNameProp);
var indexDef = Builders <BsonDocument> .IndexKeys.Ascending(fieldDef);
var indexOpt = new CreateIndexOptions <BsonDocument>()
{
Unique = true,
Name = IdentityMongodbSchema.IdentityNameIndex
};
db.GetCollection <BsonDocument>(IdentityMongodbSchema.Collection)
.Indexes
.CreateOne(indexDef, indexOpt);
}
public bool Execute(IMongoDatabase database, MongoStorageOptions storageOptions, IMongoMigrationContext migrationContext)
{
var name = $@"{storageOptions.Prefix}.signal";
database.DropCollection(name);
var cosmosStorageOptions = storageOptions as CosmosStorageOptions;
if (cosmosStorageOptions != null)
{
database.CreateCollection(name);
var collection = database.GetCollection <BsonDocument>(name);
var options = new CreateIndexOptions {
ExpireAfter = TimeSpan.FromHours(cosmosStorageOptions.CosmosHourlyTtl)
};
var field = new StringFieldDefinition <BsonDocument>("_ts");
var indexDefinition = new IndexKeysDefinitionBuilder <BsonDocument>().Ascending(field);
collection.Indexes.CreateOne(indexDefinition, options);
}
var createOptions = new CreateCollectionOptions
{
Capped = true,
MaxSize = 1000000,
MaxDocuments = 1000
};
database.CreateCollection(name, createOptions);
return(true);
}
private static void ApplyPredicate <TEntity, TForeign>(AggregateQueryable <TEntity> aggregateQueryable, Expression predicate, string asFieldName)
{
if (predicate == null)
{
return;
}
var foreignType = typeof(TForeign);
var isEnumerable = typeof(TForeign).IsEnumerable();
if (isEnumerable)
{
foreignType = foreignType.GetElementTypeOf();
}
//lamb = Expression.Lambda(methodCall.Arguments[0], Expression.Parameter(typeof(TEntity), "p"));
var filterDefinitionBuilder = new FilterDefinitionBuilder <TEntity>();
var param1Type = typeof(FieldDefinition <TEntity>);
var param2Type = typeof(FilterDefinition <>).MakeGenericType(foreignType);
var method = filterDefinitionBuilder.GetType()
.GetGenericMethod(nameof(filterDefinitionBuilder.ElemMatch), BindingFlags.Public | BindingFlags.Instance,
new[] { foreignType }, new[] { param1Type, param2Type }, typeof(FilterDefinition <TEntity>));
var expressionFilterDefinition = Activator.CreateInstance(typeof(ExpressionFilterDefinition <>).MakeGenericType(foreignType), predicate);
var asField = new StringFieldDefinition <TEntity>(asFieldName);
var elmMatch = (FilterDefinition <TEntity>)method.Invoke(filterDefinitionBuilder, new object[] { asField, expressionFilterDefinition });
//Filter ($match) elements of TForeign using predicate
aggregateQueryable.AggregateFluent = aggregateQueryable.AggregateFluent.Match(elmMatch);
}
public void Should_resolve_array_name_with_positional_operator_with_multiple_dots()
{
var subject = new StringFieldDefinition <Person, string>("Pets.$.Name.Last");
var renderedField = subject.Render(BsonSerializer.SerializerRegistry.GetSerializer <Person>(), BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("pets.$.name.ln");
renderedField.FieldSerializer.Should().BeOfType <StringSerializer>();
}
public void Should_resolve_a_nested_field()
{
var subject = new StringFieldDefinition<Person, string>("Name.First");
var renderedField = subject.Render(BsonSerializer.SerializerRegistry.GetSerializer<Person>(), BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("name.fn");
renderedField.FieldSerializer.Should().BeOfType<StringSerializer>();
}
protected void CreateIndex(string fieldName, CreateIndexOptions options)
{
var field = new StringFieldDefinition <TModel>(fieldName);
var indexDef = new IndexKeysDefinitionBuilder <TModel>().Ascending(field);
var indexModel = new CreateIndexModel <TModel>(indexDef, options);
_collection.Indexes.CreateOne(indexModel);
}
public void Should_resolve_from_a_BsonDocumentSerializer_with_dots()
{
var subject = new StringFieldDefinition<BsonDocument, BsonValue>("test.one.two.three");
var renderedField = subject.Render(BsonDocumentSerializer.Instance, BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("test.one.two.three");
renderedField.FieldSerializer.Should().BeOfType<BsonValueSerializer>();
}
public void Should_resolve_top_level_field()
{
var subject = new StringFieldDefinition<Person, Name>("Name");
var renderedField = subject.Render(BsonSerializer.SerializerRegistry.GetSerializer<Person>(), BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("name");
renderedField.FieldSerializer.Should().BeOfType<BsonClassMapSerializer<Name>>();
}
public void Should_resolve_from_a_BsonDocumentSerializer_with_dots()
{
var subject = new StringFieldDefinition <BsonDocument, BsonValue>("test.one.two.three");
var renderedField = subject.Render(BsonDocumentSerializer.Instance, BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("test.one.two.three");
renderedField.FieldSerializer.Should().BeOfType <BsonValueSerializer>();
}
public void Should_resolve_from_a_non_IBsonDocumentSerializer()
{
var subject = new StringFieldDefinition<string, string>("test");
var renderedField = subject.Render(new StringSerializer(), BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("test");
renderedField.FieldSerializer.Should().BeOfType<StringSerializer>();
}
public void Should_resolve_from_a_non_IBsonDocumentSerializer()
{
var subject = new StringFieldDefinition <string, string>("test");
var renderedField = subject.Render(new StringSerializer(), BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("test");
renderedField.FieldSerializer.Should().BeOfType <StringSerializer>();
}
public void Should_resolve_top_level_field()
{
var subject = new StringFieldDefinition <Person, Name>("Name");
var renderedField = subject.Render(BsonSerializer.SerializerRegistry.GetSerializer <Person>(), BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("name");
renderedField.FieldSerializer.Should().BeOfType <BsonClassMapSerializer <Name> >();
}
public void Should_resolve_a_nested_field_that_does_not_exist()
{
var subject = new StringFieldDefinition <Person, string>("Name.NoExisty");
var renderedField = subject.Render(BsonSerializer.SerializerRegistry.GetSerializer <Person>(), BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("name.NoExisty");
renderedField.FieldSerializer.Should().BeOfType <StringSerializer>();
}
public void Should_resolve_array_name()
{
var subject = new StringFieldDefinition <Person, string>("Pets.Type");
var renderedField = subject.Render(BsonSerializer.SerializerRegistry.GetSerializer <Person>(), BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("pets.type");
renderedField.FieldSerializer.Should().BeOfType <StringSerializer>();
}
internal FilterDefinition <T> GetFilterDefinition <TKey>(TKey key)
{
if (string.IsNullOrEmpty(BsonIdName))
{
throw new ArgumentException($"'{nameof(BsonIdName)}' cannot be null or empty", nameof(BsonIdName));
}
StringFieldDefinition <T, TKey> field = new StringFieldDefinition <T, TKey>(BsonIdName);
return(Builders <T> .Filter.Eq <TKey>(field, key));
}
public bool CurrencyCode(StringFieldDefinition <TModel> def)
{
IEnumerable <WorkingReport> reports = def.ValidateAdditional?.Invoke(Models, Params);
if (reports != null && reports.Any())
{
Reports.AddRange(reports);
return(false);
}
return(true);
}
public void Should_resolve_an_array_field_with_field_name()
{
FieldDefinition <Person, IEnumerable <Gender> > subject = new StringFieldDefinition <Person, IEnumerable <Gender> >("Genders");
var renderedField = subject.Render(BsonSerializer.SerializerRegistry.GetSerializer <Person>(), BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("gs");
renderedField.UnderlyingSerializer.Should().BeOfType <ImpliedImplementationInterfaceSerializer <IEnumerable <Gender>, List <Gender> > >();
renderedField.FieldSerializer.Should().BeSameAs(renderedField.UnderlyingSerializer);
renderedField.ValueSerializer.Should().BeSameAs(renderedField.FieldSerializer);
}
/// <summary>初回パスワード</summary>
public bool InitialPassword(StringFieldDefinition <TModel> def)
{
var reports = def.ValidateAdditional?.Invoke(Models, Params); // -> PB0301.ImportData
if (reports != null && reports.Any())
{
Reports.AddRange(reports);
return(false);
}
return(true);
}
public void Should_resolve_an_array_field_with_field_name_and_scalar_value_and_scalar_value_is_allowed()
{
FieldDefinition <Person, Gender> subject = new StringFieldDefinition <Person, Gender>("Genders");
var renderedField = subject.Render(BsonSerializer.SerializerRegistry.GetSerializer <Person>(), BsonSerializer.SerializerRegistry, allowScalarValueForArrayField: true);
renderedField.FieldName.Should().Be("gs");
renderedField.UnderlyingSerializer.Should().BeOfType <ImpliedImplementationInterfaceSerializer <IEnumerable <Gender>, List <Gender> > >();
renderedField.FieldSerializer.Should().BeNull();
renderedField.ValueSerializer.Should().BeOfType <EnumSerializer <Gender> >();
}
private async void AddUniqueIndex(string property)
{
var options = new CreateIndexOptions()
{
Unique = true
};
var field = new StringFieldDefinition <EngineeringTeamEntity>(property);
var indexDefinition = new IndexKeysDefinitionBuilder <EngineeringTeamEntity>().Ascending(field);
CreateIndexModel <EngineeringTeamEntity> _Index = new CreateIndexModel <EngineeringTeamEntity>(indexDefinition, options);
await _TeamsCollection.Indexes.CreateOneAsync(_Index);
}
public void Should_resolve_a_nested_field()
{
var subject = new StringFieldDefinition <Person, string>("Name.First");
var renderedField = subject.Render(BsonSerializer.SerializerRegistry.GetSerializer <Person>(), BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("name.fn");
renderedField.UnderlyingSerializer.Should().BeOfType <StringSerializer>();
renderedField.FieldSerializer.Should().BeSameAs(renderedField.UnderlyingSerializer);
renderedField.ValueSerializer.Should().BeSameAs(renderedField.FieldSerializer);
}
public static void CreateIndex(string collectionId, string indexName)
{
var options = new CreateIndexOptions()
{
Unique = false
};
var field = new StringFieldDefinition <T>(indexName);
var indexDefinition = new IndexKeysDefinitionBuilder <T>().Ascending(field);
database.GetCollection <T>(collectionId).Indexes.CreateOneAsync(indexDefinition, options).Wait();
}
public void Should_resolve_array_name_with_positional_operator()
{
var subject = new StringFieldDefinition <Person, string>("Pets.$.Type");
var renderedField = subject.Render(BsonSerializer.SerializerRegistry.GetSerializer <Person>(), BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("pets.$.type");
renderedField.UnderlyingSerializer.Should().BeOfType <StringSerializer>();
renderedField.FieldSerializer.Should().BeSameAs(renderedField.UnderlyingSerializer);
renderedField.ValueSerializer.Should().BeSameAs(renderedField.FieldSerializer);
}
public void Should_resolve_from_a_BsonDocumentSerializer()
{
var subject = new StringFieldDefinition <BsonDocument, BsonValue>("test");
var renderedField = subject.Render(BsonDocumentSerializer.Instance, BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("test");
renderedField.UnderlyingSerializer.Should().BeNull();
renderedField.FieldSerializer.Should().BeNull();
renderedField.ValueSerializer.Should().BeOfType <BsonValueSerializer>();
}
public void Should_resolve_array_name_with_multiple_dots()
{
var subject = new StringFieldDefinition <Person, string>("Pets.Name.First");
var renderedField = subject.Render(BsonSerializer.SerializerRegistry.GetSerializer <Person>(), BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("pets.name.fn");
renderedField.UnderlyingSerializer.Should().BeOfType <StringSerializer>();
renderedField.FieldSerializer.Should().BeSameAs(renderedField.UnderlyingSerializer);
renderedField.ValueSerializer.Should().BeSameAs(renderedField.FieldSerializer);
}
public UserDAO()
{
_collection = conn.getDatabase().GetCollection <UserModel>("DBUsermigration");
var options = new CreateIndexOptions()
{
Unique = true
};
var field = new StringFieldDefinition <UserModel>("mail");
var indexDefinition = new IndexKeysDefinitionBuilder <UserModel>().Ascending(field);
_collection.Indexes.CreateOneAsync(indexDefinition, options);
}
private void AddUniqueIndex(string property)
{
var options = new CreateIndexOptions()
{
Unique = true
};
var field = new StringFieldDefinition <AirplaneEntity>(property);
var indexDefinition = new IndexKeysDefinitionBuilder <AirplaneEntity>().Ascending(field);
CreateIndexModel <AirplaneEntity> _Index = new CreateIndexModel <AirplaneEntity>(indexDefinition, options);
_AirplanesCollection.Indexes.CreateOne(_Index);
}
private void _createUsernameUniqueIndex()
{
var options = new CreateIndexOptions()
{
Unique = true
};
var field = new StringFieldDefinition <User>("Username");
var indexDefinition = new IndexKeysDefinitionBuilder <User>().Ascending(field);
var createIndexModel = new CreateIndexModel <User>(indexDefinition, options);
usersCol.Indexes.CreateOne(createIndexModel);
}
protected static CreateIndexModel <T> CreateUniqueField(string fieldName)
{
var options = new CreateIndexOptions()
{
Unique = true
};
var field = new StringFieldDefinition <T>(fieldName);
var indexDefinition = new IndexKeysDefinitionBuilder <T>().Ascending(field);
var indexModel = new CreateIndexModel <T>(indexDefinition, options);
return(indexModel);
}
protected void btnCreateIndex_Click(object sender, EventArgs e)
{
var options = new CreateIndexOptions()
{
Unique = false, Background = true
};
var field1 = new StringFieldDefinition <LogEntity>("AppId");
var indexDefinition1 = new IndexKeysDefinitionBuilder <LogEntity>().Ascending(field1);
MongoDataBase.GetCollection <LogEntity>().Indexes.CreateOneAsync(indexDefinition1, options);
var field2 = new StringFieldDefinition <LogEntity>("Level");
var indexDefinition2 = new IndexKeysDefinitionBuilder <LogEntity>().Ascending(field2);
MongoDataBase.GetCollection <LogEntity>().Indexes.CreateOneAsync(indexDefinition2, options);
var field3 = new StringFieldDefinition <LogEntity>("Time");
var indexDefinition3 = new IndexKeysDefinitionBuilder <LogEntity>().Descending(field3);
MongoDataBase.GetCollection <LogEntity>().Indexes.CreateOneAsync(indexDefinition3, options);
var field4 = new StringFieldDefinition <LogTag>("Tag");
var indexDefinition4 = new IndexKeysDefinitionBuilder <LogTag>().Ascending(field4);
MongoDataBase.GetCollection <LogTag>().Indexes.CreateOneAsync(indexDefinition4, options);
var field5 = new StringFieldDefinition <LogTag>("Time");
var indexDefinition5 = new IndexKeysDefinitionBuilder <LogTag>().Descending(field5);
MongoDataBase.GetCollection <LogTag>().Indexes.CreateOneAsync(indexDefinition5, options);
var field8 = new StringFieldDefinition <LogTag>("LogId");
var indexDefinition8 = new IndexKeysDefinitionBuilder <LogTag>().Ascending(field8);
MongoDataBase.GetCollection <LogTag>().Indexes.CreateOneAsync(indexDefinition8, options);
var field6 = new StringFieldDefinition <LogStatistics>("Time");
var indexDefinition6 = new IndexKeysDefinitionBuilder <LogStatistics>().Descending(field6);
MongoDataBase.GetCollection <LogStatistics>().Indexes.CreateOneAsync(indexDefinition6, options);
var field7 = new StringFieldDefinition <LogStatistics>("AppId");
var indexDefinition7 = new IndexKeysDefinitionBuilder <LogStatistics>().Ascending(field7);
MongoDataBase.GetCollection <LogStatistics>().Indexes.CreateOneAsync(indexDefinition7, options);
Response.Write("Create Index Success");
}
public object distinct(object field, object query, object options)
{
DistinctOptions distinctOptions = new DistinctOptions();
var fieldDefinition = new StringFieldDefinition <BsonDocument, object>(field.ToStringOrDefault());
var cursor = this._collection.Distinct(
fieldDefinition,
query.ToBsonDocument(),
distinctOptions);
return(new MongoEvaluatedCursor <object>(cursor));
}
public bool NameForBankBranchMaster(StringFieldDefinition <TModel> def)
{
//return true;
IEnumerable <WorkingReport> reports = def.ValidateAdditional?.Invoke(Models, Params);
if (reports != null && reports.Any())
{
Reports.AddRange(reports);
return(false);
}
return(true);
}
public void Should_resolve_array_name_with_a_multi_digit_indexer()
{
var subject = new StringFieldDefinition<Person, string>("Pets.42.Type");
var renderedField = subject.Render(BsonSerializer.SerializerRegistry.GetSerializer<Person>(), BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("pets.42.type");
renderedField.FieldSerializer.Should().BeOfType<StringSerializer>();
}
public void Should_resolve_array_name_with_positional_operator_with_multiple_dots()
{
var subject = new StringFieldDefinition<Person, string>("Pets.$.Name.Last");
var renderedField = subject.Render(BsonSerializer.SerializerRegistry.GetSerializer<Person>(), BsonSerializer.SerializerRegistry);
renderedField.FieldName.Should().Be("pets.$.name.ln");
renderedField.FieldSerializer.Should().BeOfType<StringSerializer>();
}
