private void CheckAndPopulateIfNeeded() { if (Initalized) { return; } var list = R.DbList().Run <List <string> >(_connection); if (!list.Contains(DatabaseName)) { R.DbCreate(DatabaseName).Run(_connection); } var tables = R.Db(DatabaseName).TableList().RunResult <List <string> >(_connection); foreach (var tableInfo in TableInfos) { if (!tables.Contains(tableInfo.TableName)) { R.Db(DatabaseName).TableCreate(tableInfo.TableName).Run(_connection); foreach (var secondaryIndex in tableInfo.SecondaryIndexes) { var secondaryIndexResult = R.Db(DatabaseName).Table(tableInfo.TableName).IndexCreate(secondaryIndex).Run(_connection); } } } Initalized = true; }
public IHttpActionResult PostNewUserModel(StudentViewModel studentViewModel) { if (!ModelState.IsValid) { return(BadRequest("Invalid data.")); } var conn = connection(); /*var newUserModel = new UserModel * { * UserId = userModel.UserId, * Name = userModel.Name, * UserName = userModel.UserName, * Bio = userModel.Bio, * ImageUrl = userModel.ImageUrl, * LastArtist = userModel.LastArtist, * LastSong = userModel.LastSong, * LastLocation_Lat = userModel.LastLocation_Lat, * LastLocation_Lng = userModel.LastLocation_Lng, * LastOnline = userModel.LastOnline * };*/ var newStudentViewModel = new StudentViewModel { FirstName = studentViewModel.FirstName, Id = studentViewModel.Id, LastName = studentViewModel.LastName }; R.Db("MusicAroundDB").Table("pkDeneme").Insert(newStudentViewModel).Run(conn); return(Ok()); }
public void Start() { bool firstCall = true; while (true) { var conn = _rethinkDbFactory.CreateConnection(); try { //var srv = conn.Server(); //_logger.LogDebug(902, $"Connected to RethinkDB server {srv.Name}"); var result = R.Db(_rethinkDbFactory.GetOptions().Database).TableList().RunAtom <List <string> >(conn); if (firstCall) { _logger.LogDebug(902, $"Connected to RethinkDB server {_rethinkDbFactory.GetOptions().Host}"); } firstCall = false; } catch (Exception ex) { _logger.LogDebug(1001, ex, $"RethinkDbKeepAlive error {ex.Message}. Connection open {conn.Open}."); conn.Reconnect(); } Thread.Sleep(TimeSpan.FromSeconds(60)); } }
public void OnGUI() { //var obj = new ShieldData() {ID = Guid.NewGuid(), Name = "Bar" , HeatPerformanceCurve = new []{float4(0,0,0,0), float4(1,1,1,1)}} as DatabaseEntry; //var obj = new GalaxyRequestMessage() as Message; var obj = new Gradient(); var times = Enumerable.Range(0, 5).Select(i => (float)i / 4).ToArray(); obj.alphaKeys = times.Select(f => new GradientAlphaKey(1, f)).ToArray(); obj.colorKeys = times.Select(f => new GradientColorKey(UnityEngine.Random.ColorHSV(), f)).ToArray(); // JsonSerializer serializer = new JsonSerializer(); // serializer.Converters.Add(new MathJsonConverter()); // serializer.Converters.Add(Converter.DateTimeConverter); // serializer.Converters.Add(Converter.BinaryConverter); // serializer.Converters.Add(Converter.GroupingConverter); // serializer.Converters.Add(Converter.PocoExprConverter); JsonConvert.DefaultSettings = () => new JsonSerializerSettings { Converters = new List <JsonConverter> { new MathJsonConverter(), Converter.DateTimeConverter, Converter.BinaryConverter, Converter.GroupingConverter, Converter.PocoExprConverter } }; Converter.Serializer.Converters.Add(new MathJsonConverter()); RegisterResolver.Register(); if (GUILayout.Button("Print MsgPack JSON")) { Debug.Log(MessagePackSerializer.SerializeToJson(obj)); } //var writer = new StringWriter(); if (GUILayout.Button("Print Newtonsoft JSON")) { //serializer.Serialize(writer, obj); Debug.Log(JsonConvert.SerializeObject(obj)); } if (GUILayout.Button("Create Database")) { R.DbCreate("Aetheria").Run(_connection); } if (GUILayout.Button("Create Table")) { R.Db("Aetheria").TableCreate("Items").Run(_connection); } if (GUILayout.Button("Send to RethinkDB")) { R.Db("Aetheria").Table("Items").Insert(obj).Run(_connection); } }
public void Send(string name, string message) { R.Db("test").Table("chat") .Insert(new ChatMessage { username = name, message = message, timestamp = DateTime.Now }).Run(conn); }
public async Task Send(string name, string message) { await R.Db("test").Table("chat") .Insert(new ChatMessage { username = name, message = message, timestamp = DateTime.Now }).RunResultAsync(conn); }
private void CreateDb() { var exists = R.DbList().Contains(db => db == _dbName).Run(_connection); if (!exists) { R.DbCreate(_dbName).Run(_connection); R.Db(_dbName).Wait_().Run(_connection); } }
private void InsertLog(RethinkDb.Driver.Net.Connection conn, string categoryName, string logLevel, int eventId, string eventName, string message, Exception exception) { string exceptionId = null; if (exception != null) { // insert exception var result = R.Db(_dbName).Table(ExceptionTable) .Insert(exception) .RunResult(conn); exceptionId = result.GeneratedKeys.First().ToString(); } var logEntry = new LogEntry { Application = _connectionFactory.GetOptions().Application, Category = categoryName, Event = eventName, EventId = eventId, ExceptionId = exceptionId, Host = Environment.MachineName, Level = logLevel, Message = message, Timestamp = DateTime.UtcNow }; R.Db(_dbName).Table(LogTable) .Insert(logEntry) .RunResult(conn); }
public static bool TryAuthentificate(string username, string password, out UserDTO user, bool isIRC = false) { Cursor <UserDTO> userCursor = R.Db(DB).Table("users").Filter(doc => doc["username"] == username).Run <UserDTO>(c); user = userCursor.FirstOrDefault(); if (user != null && user.password == password.ToUpper()) { return(true); } return(false); }
public void BeforeRunningTestSession() { var adminConn = QueryTestFixture.DefaultConnectionBuilder() .Connect(); R.Db("rethinkdb").Table("users").Insert( new { id = bogusUsername, password = bogusPassword } ).Run(adminConn); adminConn.Close(); }
private void insertButton_Click(object sender, EventArgs e) { try { var objData = new dto.User { Name = nameTextBox.Text, Surname = surnameTextBox.Text, Age = Int32.Parse(ageTextBox.Text) }; R.Db(this.dbName).Table(this.tableName).Insert(objData).Run(this.connection.getConnection()); }catch (FormatException) { MessageBox.Show("Format Error", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public dynamic Load(int limit) { var conn = _rethinkDbFactory.CreateConnection(); var logs = R.Db(_rethinkDbFactory.GetOptions().Database) .Table("Logs") .OrderBy()[new { index = R.Desc(nameof(LogEntry.Timestamp)) }] .Limit(limit) .RunCursor <LogEntry>(conn); var result = logs.ToList(); logs.Close(); return(result); }
public SearchModule() : base("/search") { Get("/", x => { var parameters = this.Bind <SearchParameters>(); if (parameters.IsEmpty()) { // no search parameters provided return(Response.AsJson(new ErrorResponse() { Code = 400, Message = "No search parameters provided, following available: " + string.Join(", ", typeof(SearchParameters).GetProperties().Select(prop => prop.Name.ToLower()).ToList()) })); } Cursor <Character> result = R.Db("Lolidex").Table("Characters").Filter(parameters.ToReQLHashMap()).Run <Character>(Program.Conn); List <Character> characters = new List <Character>(); // loop through the results and add them to a list foreach (Character character in result) { characters.Add(character); } return(Response.AsJson(new SearchResponse() { Results = characters.Count, Characters = characters })); }); }
public AutoCompleteModule() : base("/autocomplete") { Get("/", x => { var search = Request.Query["name"]; // if search query is empty then suggest nothing if (string.IsNullOrEmpty(search)) { return(Response.AsJson(new AutoCompleteResponse() { AutoComplete = new List <string>() })); } Cursor <string> result = R.Db("Lolidex").Table("Characters").Filter(row => row.G("Name").Match("(?i)^" + search)).G("Name").Limit(5).Run <string>(Program.Conn); List <string> autocomplete = new List <string>(); // loop through the results and add them to a list foreach (string name in result) { autocomplete.Add(name); } return(Response.AsJson(new AutoCompleteResponse() { AutoComplete = autocomplete })); }); }
public bool Any() { var empty = R.Db(DbName) .Table(TableName) .IsEmpty() .Run(Connection); return(!empty); }
/// <summary> /// Create the table if it does not exist /// </summary> /// <param name="configuration">The session store configuration</param> /// <exception cref="InvalidOperationException">If there is a problem creating the table</exception> private static async Task TableCheck(RethinkDbSessionConfiguration configuration) { var tables = await R.Db(configuration.Database).TableList().RunAtomAsync <List <string> >(configuration.Connection); if (!tables.Contains(configuration.Table)) { var result = await R.Db(configuration.Database).TableCreate(configuration.Table) .RunResultAsync(configuration.Connection); if (0 != result.Errors) { throw new InvalidOperationException(String.Format( "Could not create RethinkDB session store table {0}.{1}: {2}", configuration.Database, configuration.Table, result.FirstError)); } } }
/// <summary> /// Constructor for <see cref="RethinkDao{T,IdT}"/> /// </summary> /// <param name="conn">The connection</param> /// <param name="dbName">The database</param> /// <param name="tableName">The table</param> protected RethinkDao(IConnection conn, string dbName, string tableName) { this.conn = conn; this.DbName = dbName; this.TableName = tableName; this.Table = R.Db(dbName).Table(tableName); this.returnChanges = new { return_changes = true }; }
public bool IsTokenValid(string token) { if (String.IsNullOrEmpty(token)) { return(false); } return(R.Db("Lolidex").Table("Tokens").Filter(R.HashMap("Token", token)).Count().Eq(1).Run(Program.Conn)); }
public void CSharp7() { R.Db("Test") .Table("Foo") .Insert(new { someValue = "fff", someObject = new { someNested = 25, someNested2 = false }, someOtherProp = Guid.Parse("E111E216-EBD6-47CE-B2DE-CE5F60E2FA8F") }) .Filter(x => x["someRow"] == 25) .Filter(x => x["someOtherRow"].Gt(44)) .Delete() .Build(); }
//Login private void button1_Click(object sender, EventArgs e) { string username = textbox_username.Text; string password = textbox_password.Text; byte[] hash; using (SHA256CryptoServiceProvider sha256 = new SHA256CryptoServiceProvider()) { byte[] hashdata = sha256.ComputeHash(Encoding.UTF8.GetBytes(password)); hash = hashdata; } string result = System.Text.Encoding.UTF8.GetString(hash); try { List <Users> all_users = r.Db("chat").Table("users").OrderBy("Username").Run <List <Users> >(pool); bool cont = false; foreach (var us in all_users) { string use = us.Username; string pwd = us.Password; if (use.ToString().Equals(textbox_username.Text) && pwd.ToString().Equals(result)) { cont = true; Chat ga = new Chat(textbox_username.Text); this.Hide(); ga.ShowDialog(); this.Close(); break; } } if (cont == false) { MessageBox.Show("Dados incorretos ou não está Registado!"); } } catch (Exception ex) { Login_Load(sender, e); } }
private void Form1_Load(object sender, EventArgs e) { try { for (int i = 0; i < 10; i++) { //Stablish connection to RethinkDB Server that is running on Raspberry var conn = r.ConnectionPool().Seed(new[] { "192.168.0.184:28015", "192.168.1.202:28015", "192.168.1.189:28015" }); conn.PoolingStrategy(new EpsilonGreedyHostPool(new TimeSpan(0, 1, 0), EpsilonCalculator.Linear())).Discover(true); pool = conn.Connect(); Thread.Sleep(1000); } } catch (Exception ex) { MessageBox.Show("Impossible to Connect!"); } tb_mensagem.Text = ""; //Get all messages from RethinkDB List <Mensagem> all_messages = r.Db("chat").Table("chattable").OrderBy("Data").Run <List <Mensagem> >(pool); //Load all previous messages to the listbox of messages foreach (var message in all_messages) { //Create message Mensagem msg = new Mensagem(message.Id, message.Data, message.Username, message.Msg); //Adding Message to Listbox lb_chat.Items.Add(msg); } focus_last_message(); //Calling and running the task Task.Run(() => HandleUpdates(pool, lb_chat)); }
private RethinkDb.Driver.Ast.Db EnsureDatabaseExists(string dbName, Connection c) { List<string> dbs = R.DbList().Run<List<string>>(c); if (!dbs.Contains(dbName)) { logger.LogInformation("Db does not exist. Creating..."); R.DbCreate(dbName).Run(c); logger.LogInformation("Db created"); } var db = R.Db(dbName); return db; }
{ //shermaine calling restful api of ReThinkDB to connect to gamedatabase to update coins in real mmo game public bool Update(string GameUsername, int Gold) { try { RethinkDB R = new RethinkDB(); Connection conn = R.Connection() .Hostname("localhost") .Port(28015) .Db("mmorpg") //.User("admin", "admin") .Timeout(60) .Connect(); Console.WriteLine(R.Db("mmorpg").TableList().Run(conn)); var results = R.Table("users").Filter(g => g["username"].Eq(GameUsername)).Run(conn); string id = ""; foreach (var result in results) { id = result["id"]; } var results2 = R.Table("users").GetAll(id).G("stats").G("gold").Run(conn); string gold2 = ""; foreach (var resultd in results2) { gold2 = resultd.ToString(); } Console.WriteLine(id); int gold3 = Convert.ToInt32(gold2); if (id == "") { return(false); } R.Table("users").Get(id).Update(R.HashMap("stats", R.HashMap("gold", gold3 + Gold))).Run(conn); return(true); } catch (Exception e) { return(false); } }
public static void HandleUpdates() { var hub = GlobalHost.ConnectionManager.GetHubContext <ChatHub>(); var conn = R.Connection().Connect(); var feed = R.Db("test").Table("chat") .Changes().RunChanges <ChatMessage>(conn); foreach (var message in feed) { hub.Clients.All.onMessage( message.NewValue.username, message.NewValue.message, message.NewValue.timestamp); } }
private void RunChangefeed() { var hubContext = _signalManager.GetHubContext <LogHub>(); var feed = R.Db(_options.Database).Table("Logs") .Between(_lastLogTimestamp, R.Maxval())[new { index = nameof(LogEntry.Timestamp) }] .Changes().RunChanges <LogEntry>(_conn); foreach (var log in feed) { // push new value to SignalR hub hubContext.Clients.All.OnLog(log.NewValue); // start point on reconnect _lastLogTimestamp = log.NewValue.Timestamp; } }
/// <summary> /// Creates a new bucket. /// </summary> /// <param name="conn">A <see cref="Connection"/> or <see cref="ConnectionPool"/></param> /// <param name="databaseName">The database name to use. The database must exist.</param> /// <param name="bucketName">The bucket name to use.</param> /// <param name="config">Low level bucket configuration options.</param> public Bucket(IConnection conn, string databaseName, string bucketName = "fs", BucketConfig config = null) { this.conn = conn; this.databaseName = databaseName; this.db = R.Db(this.databaseName); config = config ?? new BucketConfig(); this.tableCreateOpts = config.TableCreateOptions; this.fileTableName = $"{bucketName}_{config.FileTableName}"; this.fileTable = this.db.Table(fileTableName); this.fileIndex = config.FileIndex; this.fileIndexPrefix = config.FileIndexPrefix; this.chunkTableName = $"{bucketName}_{config.ChunkTable}"; this.chunkTable = this.db.Table(chunkTableName); this.chunkIndexName = config.ChunkIndex; }
public void SeedDatabase() { // Create the database if it does not exist List <string> dbList = rethinkDB.DbList().Run <List <string> >(connection); if (dbList.Contains(this._dbName)) { rethinkDB.DbDrop(this._dbName).Run(connection); rethinkDB.DbCreate(this._dbName).Run(connection); } else if (!dbList.Contains(this._dbName)) { rethinkDB.DbCreate(this._dbName).Run(connection); } // Load the tables from the database List <string> tableList = rethinkDB.Db(this._dbName).TableList().Run <List <string> >(connection); List <string> createTables = new List <string>() { "Users", "UserSession", "SessionState", "PolicyHolders", "UserQuotation" }; // Create the tables if they do not exist foreach (var tableName in createTables) { // Check if the table exists in the database if (!tableList.Contains(tableName)) { rethinkDB.Db(this._dbName).TableCreate(tableName).Run(connection); } } }
public async Task <List <string> > GetAllTables(string database) { return(await R.Db(database).TableList().RunAsync <List <string> >(_connection)); }
protected void CreateDatabase(string dbName) { try { var exists = _rethinkDb.DbList().Contains(db => db == dbName).Run(_rethinkCon); if (!exists) { _rethinkDb.DbCreate(dbName).Run(_rethinkCon); _rethinkDb.Db(dbName).Wait_().Run(_rethinkCon); foreach (string tname in new List <string> { "RtBoardAnnotation", "RtLibraryThumb" }) { _rethinkDb.Db(dbName).TableCreate(tname).Run(_rethinkCon); _rethinkDb.Db(dbName).Table(tname).Wait_().Run(_rethinkCon); _rethinkDb.Db(dbName).Table(tname).IndexCreate("MeetingId").Run(_rethinkCon); _rethinkDb.Db(dbName).Table(tname).IndexWait("MeetingId").Run(_rethinkCon); } } } catch (Exception ex) { App.InsertException(ex); } }
public void AfterEachTest() { R.Db("rethinkdb").Table("_debug_scratch").Delete().Run(conn); conn.Close(false); }