public static void Init(TestContext context)
{
Property.BuildILPropertyGetters(new PropertyReference(typeof(UIMTestObject), "StringProperty"),
new PropertyReference(typeof(UIMTestObject), "StringProperty"),
new PropertyReference(typeof(UIMTestObject), "Referenced"));
UnifiedSystem.AllowReferences = true;
UnifiedSystem.AllowIndexes = true;
UnifiedSystem.CreateReferenceIndexes = true;
MongoProvider provider = new MongoProvider(new MongoSettings("127.0.0.1", "LogicReincDataTests"));
UIMTestObject.SetProvider(provider);
UIMTestObject2.SetProvider(provider);
if (InitialSet)
{
for (int i = 0; i < 10000; i++)
{
new UIMTestObject()
{
IntegerProperty = i,
StringProperty = (i % 2 == 0) ? "SomeString" : "Testing",
}.Insert();
}
}
}
public IActionResult Login(string user, string password)
{
if (string.IsNullOrWhiteSpace(user) || string.IsNullOrWhiteSpace(password))
{
return(StatusCode(400, Common.Constantes.Mensagens.Alertas.SENHA_USUARIO_OBRIGATORIO));
}
var provider = new MongoProvider();
var database = provider.GetApplicationDatabase(provider.InitializeDatabase(Database.ConnectionString));
var collection = database.GetCollection <BsonDocument>("users", null);
//var builder = Builders<BsonDocument>.Filter;
var filter = Builders <BsonDocument> .Filter.Eq("user", user);
var userObject = collection.Find(filter).FirstOrDefault();
if (userObject == null)
{
return(StatusCode(400, Common.Constantes.Mensagens.Alertas.SENHA_USUARIO_OBRIGATORIO));
}
if (userObject["password"] != password)
{
return(StatusCode(StatusCodes.Status401Unauthorized, Common.Constantes.Mensagens.Alertas.LOGIN_INVALIDO));
}
return(Ok(Common.Constantes.Mensagens.LOGIN_SUCESSO));
}
public static DbContextOptionsBuilder UseMongo(this DbContextOptionsBuilder options, string connectUrl, string databaseName)
{
Check.NotNull(connectUrl, nameof(connectUrl));
var mongo = new MongoProvider(connectUrl, databaseName);
((IDbContextOptionsBuilderInfrastructure)options).AddOrUpdateExtension(mongo);
return(options);
}
public void SetUp()
{
mongoProvider = new MongoProvider("mongodb://localhost:27017", "Student");
groupRepository = new GroupRepository(mongoProvider);
subjectRepository = new SubjectRepository(mongoProvider);
topicRepository = new TopicRepository(mongoProvider);
teacherRepository = new TeacherRepository(mongoProvider);
}
/// <summary>
/// Constructs the Context with the Database Options values provided
/// </summary>
/// <param name="options">The connection string and name of the Database to use</param>
public ContextProvider(IDatabaseOptions options)
{
// Create the (Singleton) Client, Database and then return the Context ready for use
Context = MongoProvider
.CreateMongoClient(options.ConnectionString)
.GetDatabase(options.DatabaseName)
.GetCollection <T>(Pluralizer.Pluralize(typeof(T).Name));
}
public void ProcessRequest(HttpContext context)
{
//context.Response.ContentType = "text/plain";
//context.Response.Write("Hello World");
try
{
HttpPostedFile postedFile = context.Request.Files[0];
if (postedFile.ContentLength == 0)
{
throw new Exception("Empty file received");
}
// cannot restrict accept type on client
//if (postedFile.ContentType == "image/png")
// throw new Exception("PNG files not allowed");
var csvBody = string.Empty;
using (BinaryReader b = new BinaryReader(postedFile.InputStream))
{
byte[] binData = b.ReadBytes(postedFile.ContentLength);
csvBody = Encoding.UTF8.GetString(binData);
}
var memoryStream = new MemoryStream();
var streamWriter = new StreamWriter(memoryStream);
streamWriter.Write(csvBody);
streamWriter.Flush();
memoryStream.Position = 0;
string fn = System.IO.Path.GetFileName(postedFile.FileName);
MongoProvider.ImportData(fn, memoryStream);
//context.Response.Write(postedFile.ContentType);
//// to save in 'App_Data':
//// string path =
//// HttpContext.Current.Server.MapPath("~/App_Data/");
//postedFile.SaveAs("C:\\Data\\Junk\\Uploads2\\" + fn);
//context.Response.Write("Server received " + fn); //
context.Response.Write(
JsonConvert.SerializeObject(
new {
success = true
})
);
}
catch (Exception ex)
{
context.Response.Write("Error occurred on server " +
ex.Message);
}
} // ProcessRequest
private static void ExportXmlTradersToMongo(ICollection <Trader> traders)
{
var mongoProvider = new MongoProvider(
System.Configuration.ConfigurationManager.ConnectionStrings["MolybdenumDb"].ConnectionString,
System.Configuration.ConfigurationManager.ConnectionStrings["MolybdenumDb"].Name);
var mongoDatabase = mongoProvider.GetDatabase();
var mongoExporter = new MongoExporter();
mongoExporter.ExportTraders(mongoDatabase, traders);
}
public ViewModel()
{
UploadNewInfoButton = new ActionCommand(UploadNewInfo);
filmprovider = new MongoProvider<Film>("localhost",27017);
filmprovider.Intialize();
filmprovider.SaveElement(new Film() { Name = "Hateful Eight", Regisseur = "Tarantino", Pfad = "noch nicht da" });
filmprovider.SaveElement(new Film() { Name = "Herr der Ringe", Regisseur = "Peter Jackson", Pfad = "Auf der Festplatte ;)" });
filmprovider.SaveElement(new Film() { Name = "Star Wars", Regisseur = "JJ Abrams", Pfad = "Auch auf der FP" });
Filme = new ObservableCollection<Film>(filmprovider.GetElements());
}
public void ShouldDropAndCreate()
{
// Arrange
using (MongoProvider provider = new MongoProvider(ConfigSettings.MongoConnectionString))
{
// Act
provider.DropAndCreate(typeof(Shipper));
// Assert
Assert.IsTrue(provider.CollectionExists(typeof(Shipper)));
}
}
public void ShouldThrowArgumentNullExceptionForNullConnectionString()
{
// Act
try
{
using (MongoProvider provider = new MongoProvider(null))
{
// Assert
Assert.Fail("Should not allow empty connection strings");
}
}
catch (ArgumentNullException)
{
Assert.Pass();
}
}
public void ShouldClearAllCollections()
{
// Arrange
using (MongoProvider provider = new MongoProvider(ConfigSettings.MongoConnectionString))
{
Shipper shipper = DataProvider.PreInsertArrange(provider);
shipper = provider.Insert<Shipper>(shipper);
// Act
provider.DeleteAll<Shipper>();
// Assert
Assert.AreEqual(provider.Select<Shipper>().Count, 0);
Assert.AreEqual(provider.Select<ShipperContact>().Count, 0);
}
}
private static SpacemanLoader GetLoader()
{
var config = new ConfigurationBuilder()
.AddJsonFile("LoadConfig.json")
.AddUserSecrets <Program>()
.Build();
var serviceConfig = new SpacemanServiceOptions();
config.Bind("SpacemanService", serviceConfig);
var db = new MongoProvider(serviceConfig);
var playerService = new PlayerService(db);
var locationService = new LocationService(db);
System.Console.WriteLine("Loader ready.");
return(new SpacemanLoader(playerService, locationService));
}
public IActionResult Token([FromBody] AuthRequest user)
{
if (!ModelState.IsValid)
{
return(BadRequest("Token failed to generate"));
}
//Get our bitch ass user from :b:ongo
var provider = new MongoProvider();
var database = provider.GetApplicationDatabase(provider.InitializeDatabase(Database.ConnectionString));
var collection = database.GetCollection <BsonDocument>("users", null);
//var builder = Builders<BsonDocument>.Filter;
var filter = Builders <BsonDocument> .Filter.Eq("Email", user.User);
var userObject = collection.Find(filter).FirstOrDefault();
if (userObject == null)
{
return(Unauthorized());
}
//Add Claims
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.UniqueName, "data"),
new Claim(JwtRegisteredClaimNames.Sub, "data"),
new Claim(JwtRegisteredClaimNames.Email, "data"),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
};
var truestKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["TokenAuthentication:SecretKey"]));
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("rlyaKithdrYVl6Z80ODU350md")); //Secrets
var creds = new SigningCredentials(truestKey, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(userObject["Email"].AsString,
_configuration["TokenAuthentication:Issuer"],
claims,
expires: DateTime.Now.AddMinutes(30),
signingCredentials: creds);
return(Ok(new
{
access_token = new JwtSecurityTokenHandler().WriteToken(token),
expires_in = DateTime.Now.AddMinutes(30),
token_type = "bearer"
}));
}
private static void ImportDataFromMongo()
{
var dbContext = new ChemicalsDbContext();
var mongoProvider = new MongoProvider(
System.Configuration.ConfigurationManager.ConnectionStrings["MolybdenumDb"].ConnectionString,
System.Configuration.ConfigurationManager.ConnectionStrings["MolybdenumDb"].Name);
var mongoDatabase = mongoProvider.GetDatabase();
var mongoImporter = new MongoImporter();
var products = mongoImporter.GetAllProducts(mongoDatabase, "Products");
foreach (var product in products)
{
dbContext.Products.Add(product);
}
dbContext.SaveChanges();
Console.WriteLine("The data was successfully imported to the SQL Server.");
}
public async Task Seed(StateExecutionConfiguration stateExecutionConfiguration)
{
IDataProvider provider;
if (_configuration.Destination == DestinationOption.mg)
{
provider = new MongoProvider(_configuration);
}
else
{
provider = new FileProvider(_configuration);
}
if (provider.ActionWhenAborted != null)
{
stateExecutionConfiguration.ExecutionActionsAfterAbort = provider.ActionWhenAborted;
}
Console.WriteLine($"Seed start: {DateTime.Now}");
await provider.WriteAsync();
Console.WriteLine("Press any key to Exit.");
}
public Mongo2GoProvider(INdmMongoConfig config, ILogManager logManager)
{
_runner = MongoDbRunner.Start();
config.ConnectionString = _runner.ConnectionString;
_mongoProvider = new MongoProvider(config, logManager);
}
PreInitAsync(IConfigProvider configProvider, IDbProvider dbProvider, string baseDbPath,
IBlockTree blockTree, ITxPool txPool, ISpecProvider specProvider,
IReceiptStorage receiptStorage, IWallet wallet, IFilterStore filterStore, IFilterManager filterManager,
ITimestamper timestamper, IEthereumEcdsa ecdsa, IRpcModuleProvider rpcModuleProvider,
IKeyStore keyStore, IJsonSerializer jsonSerializer, ICryptoRandom cryptoRandom, IEnode enode,
INdmConsumerChannelManager consumerChannelManager, INdmDataPublisher dataPublisher,
IGrpcServer grpcServer, bool enableUnsecuredDevWallet, IWebSocketsManager webSocketsManager,
ILogManager logManager, IBlockProcessor blockProcessor)
{
if (!(configProvider.GetConfig<INdmConfig>() is NdmConfig defaultConfig))
{
return default;
}
if (!defaultConfig.Enabled)
{
return default;
}
if (defaultConfig.StoreConfigInDatabase && string.IsNullOrWhiteSpace(defaultConfig.Id))
{
throw new ArgumentException("NDM config stored in database requires an id.", nameof(defaultConfig.Id));
}
IMongoProvider mongoProvider = null;
IConfigRepository configRepository = null;
IEthRequestRepository ethRequestRepository = null;
switch (defaultConfig.Persistence?.ToLowerInvariant())
{
case "mongo":
mongoProvider = new MongoProvider(configProvider.GetConfig<INdmMongoConfig>(), logManager);
var database = mongoProvider.GetDatabase();
configRepository = new ConfigMongoRepository(database);
ethRequestRepository = new EthRequestMongoRepository(database);
break;
default:
configRepository = new ConfigRocksRepository(dbProvider.ConfigsDb, new NdmConfigDecoder());
ethRequestRepository = new EthRequestRocksRepository(dbProvider.EthRequestsDb,
new EthRequestDecoder());
break;
}
var configManager = new ConfigManager(defaultConfig, configRepository);
var ndmConfig = await configManager.GetAsync(defaultConfig.Id);
if (ndmConfig is null)
{
ndmConfig = defaultConfig;
if (defaultConfig.StoreConfigInDatabase)
{
await configManager.UpdateAsync(ndmConfig);
}
}
var webSocketsModule = webSocketsManager.GetModule("ndm");
var notifier = new NdmNotifier(webSocketsModule);
var ethRequestService = new EthRequestService(ndmConfig.FaucetHost, logManager);
var services = _ndmModule.Init(new NdmRequiredServices(configProvider, configManager, ndmConfig,
baseDbPath, dbProvider, mongoProvider, logManager, blockTree, txPool, specProvider, receiptStorage,
filterStore, filterManager, wallet, timestamper, ecdsa, keyStore, rpcModuleProvider, jsonSerializer,
cryptoRandom, enode, consumerChannelManager, dataPublisher, grpcServer, ethRequestService, notifier,
enableUnsecuredDevWallet, blockProcessor));
var faucetAddress = string.IsNullOrWhiteSpace(ndmConfig.FaucetAddress)
? null
: new Address(ndmConfig.FaucetAddress);
var faucet = new NdmFaucet(services.CreatedServices.BlockchainBridge, ethRequestRepository, faucetAddress,
ndmConfig.FaucetWeiRequestMaxValue, ndmConfig.FaucetEthDailyRequestsTotalValue, ndmConfig.FaucetEnabled,
timestamper, wallet, logManager);
var consumerAddress = string.IsNullOrWhiteSpace(ndmConfig.ConsumerAddress)
? Address.Zero
: new Address(ndmConfig.ConsumerAddress);
var providerAddress = string.IsNullOrWhiteSpace(ndmConfig.ProviderAddress)
? Address.Zero
: new Address(ndmConfig.ProviderAddress);
var consumers = _ndmConsumersModule.Init(services);
return (ndmConfig, services, faucet, consumers.AccountService, consumers.ConsumerService, consumerAddress,
providerAddress);
}
public void ShouldClearLookup()
{
// Arrange
using (MongoProvider provider = new MongoProvider(ConfigSettings.MongoConnectionString))
{
Shipper shipper = DataProvider.PreInsertArrange(provider);
// Act
provider.DeleteAll<ShipperType>();
// Assert
Assert.AreEqual(provider.Select<ShipperType>().Count, 0);
}
}
public DataAccess()
{
_Provider = new MongoProvider();
}
public List <HcmTemp> GetDataByLogId(string logId)
{
return(MongoProvider.GetDataByLogId(logId));
}
private static void ImportDataFromMongo()
{
var dbContext = new ChemicalsDbContext();
var mongoProvider = new MongoProvider(
System.Configuration.ConfigurationManager.ConnectionStrings["MolybdenumDb"].ConnectionString,
System.Configuration.ConfigurationManager.ConnectionStrings["MolybdenumDb"].Name);
var mongoDatabase = mongoProvider.GetDatabase();
var mongoImporter = new MongoImporter();
var products = mongoImporter.GetAllProducts(mongoDatabase, "Products");
foreach (var product in products)
{
dbContext.Products.Add(product);
}
dbContext.SaveChanges();
Console.WriteLine("The data was successfully imported to the SQL Server.");
}
public HcmShape GetHCMBound()
{
return(MongoProvider.GetHCMBound());
}
public QueryResult GetTempData(DateTime startTime, DateTime endTime, int start, int limit)
{
return(MongoProvider.GetTempData(startTime, endTime, start, limit));
}
public void InsertTemp()
{
MongoProvider.InsertData();
}
public List <HcmTemp> GetTempData(DateTime startTime, DateTime endTime)
{
return(MongoProvider.GetTempData(startTime, endTime));
}
public MemberQueryReader(MongoProvider provider) : base(provider)
{
}
public void Smoke_test()
{
MongoProvider mongoProvider = new MongoProvider(new NdmMongoConfig {
ConnectionString = "mongodb://mongodb0.example.com:27017/admin"
}, LimboLogs.Instance);
}
/// <summary>
/// 注入Mongo
/// </summary>
public ApiLogFilter(MongoProvider mongoProvider, IHttpContextAccessor httpContextAccessor)
{
this._mongoProvider = mongoProvider;
_httpContextAccessor = httpContextAccessor;
}
public PlayerService(MongoProvider db)
{
_db = db;
}
private static void ExportXmlTradersToMongo(ICollection<Trader> traders)
{
var mongoProvider = new MongoProvider(
System.Configuration.ConfigurationManager.ConnectionStrings["MolybdenumDb"].ConnectionString,
System.Configuration.ConfigurationManager.ConnectionStrings["MolybdenumDb"].Name);
var mongoDatabase = mongoProvider.GetDatabase();
var mongoExporter = new MongoExporter();
mongoExporter.ExportTraders(mongoDatabase, traders);
}
public List <HcmShape> GetAllDistrictPoint()
{
return(MongoProvider.GetAllDistrictPoint());
}
public void ShouldUpdateShipper()
{
// Arrange
using (MongoProvider provider = new MongoProvider(ConfigSettings.MongoConnectionString))
{
Shipper shipper = DataProvider.PreInsertArrange(provider);
provider.Insert<Shipper>(shipper);
shipper.CompanyName += " Changed";
shipper.ShipperContacts[0].EmailAddress += shipper.ShipperContacts[0].EmailAddress + " Changed";
// Act
provider.Update<Shipper>(shipper);
// Assert
Shipper updatedShipper = provider.SelectById<Shipper>(shipper.Id);
Assert.AreEqual(shipper.CompanyName, updatedShipper.CompanyName);
Assert.AreEqual(shipper.ShipperContacts[0].EmailAddress, updatedShipper.ShipperContacts[0].EmailAddress);
}
}
public List <DataHistoryLog> GetAllDataImportLog()
{
return(MongoProvider.GetAllDataHistoryLog());
}
public LocationService(MongoProvider db)
{
_db = db;
}
public bool DeleteDataByIds(string[] IDs)
{
return(MongoProvider.DeleteDataByIds(IDs));
}
public void ShouldDeleteAll()
{
// Arrange
using (MongoProvider provider = new MongoProvider(ConfigSettings.MongoConnectionString))
{
Shipper shipper = DataProvider.PreInsertArrange(provider);
provider.Insert<Shipper>(shipper);
// Act
provider.DeleteAll<Shipper>();
// Assert
Assert.IsNull(provider.SelectById<Shipper>(shipper.Id));
Assert.IsNull(provider.SelectById<Shipper>(shipper.ShipperContacts[0].Id));
}
}
public WeatherForecastController(ILogger <WeatherForecastController> logger, RedisProvider redisProvider, MongoProvider mongoProvider)
{
_logger = logger;
_redisProvider = redisProvider;
_mongoProvider = mongoProvider;
}
public void ShouldInsertShipper()
{
// Arrange
using (MongoProvider provider = new MongoProvider(ConfigSettings.MongoConnectionString))
{
Shipper shipper = DataProvider.PreInsertArrange(provider);
// Act
shipper = provider.Insert<Shipper>(shipper);
// Assert
Assert.IsNotNull(provider.SelectById<Shipper>(shipper.Id));
}
}
public List <HcmTemp> ImportData()
{
return(MongoProvider.ImportData());
}
public void ShouldSelectShipperAndTreeWithExpression()
{
// Arrange
using (MongoProvider provider = new MongoProvider(ConfigSettings.MongoConnectionString))
{
Shipper shipper = DataProvider.PreInsertArrange(provider);
shipper = provider.Insert<Shipper>(shipper);
// Act
Shipper savedTree = provider.Select<Shipper>(x => x.Id == shipper.Id).First();
// Assert
Assert.IsNotNull(savedTree);
Assert.AreEqual(savedTree.ShipperContacts.Count, 1);
Assert.IsNotNull(savedTree.ShipperContacts[0]);
}
}
public MemberUpdatedCommand(MongoProvider provider) : base(provider)
{
}
public MongoRepository(MongoProvider provider)
{
this.provider = provider;
}
