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);
}
