public async Task SimpleAuthTest()
{
var database = new Butterfly.Core.Database.Memory.MemoryDatabase();
//var database = new Butterfly.MySql.MySqlDatabase("Server=127.0.0.1;Uid=test;Pwd=test!123;Database=butterfly_auth_test");
await TruncateData(database);
await database.CreateFromResourceFileAsync(Assembly.GetExecutingAssembly(), "Butterfly.Core.Auth.Test.db.sql");
database.SetDefaultValue("id", tableName => Guid.NewGuid().ToString());
database.SetDefaultValue("created_at", tableName => DateTime.Now.ToUnixTimestamp());
database.SetDefaultValue("updated_at", tableName => DateTime.Now.ToUnixTimestamp());
database.AddInputPreprocessor(BaseDatabase.RemapTypeInputPreprocessor <DateTime>(dateTime => dateTime.ToUnixTimestamp()));
AuthManager authManager = new AuthManager(database, onForgotPassword: user => {
logger.Debug($"onForgotPassword():user={user}");
return(Task.FromResult(0));
});
UserRefToken registerAuthToken = await authManager.RegisterAsync(new {
username = "******",
first_name = "John",
last_name = "Smith",
email = "*****@*****.**",
password = "******"
});
AuthToken authToken = await authManager.AuthenticateAsync(UserRefTokenAuthenticator.AUTH_TYPE, registerAuthToken.id);
await authManager.ForgotPasswordAsync("johnsmith");
await Task.Delay(30000);
}
public async Task Parse()
{
IDatabase database = new Butterfly.Core.Database.Memory.MemoryDatabase();
await database.CreateFromResourceFileAsync(Assembly.GetExecutingAssembly(), "Butterfly.Core.Test.db.sql");
var tableRefs = StatementFromRef.ParseFromRefs(database, "employee_contact ec INNER JOIN employee e ON ec.employee_id=e.id AND 1=2 left JOIN department d on e.department_id=d.id and 1=2");
Assert.AreEqual(3, tableRefs.Length);
Assert.AreEqual(tableRefs[0].table.Name, "employee_contact");
Assert.AreEqual(tableRefs[0].tableAlias, "ec");
Assert.AreEqual(tableRefs[1].table.Name, "employee");
Assert.AreEqual(tableRefs[1].tableAlias, "e");
Assert.AreEqual(tableRefs[2].table.Name, "department");
Assert.AreEqual(tableRefs[2].tableAlias, "d");
var selectStatement = new SelectStatement(database, "SELECT * FROM employee_contact WHERE contact_id=@contactId ORDER BY seq");
Assert.AreEqual("*", selectStatement.selectClause);
Assert.AreEqual("employee_contact", selectStatement.fromClause);
Assert.AreEqual("contact_id=@contactId", selectStatement.whereClause);
Assert.AreEqual("seq", selectStatement.orderByClause);
var selectStatement2 = new SelectStatement(database, @"SELECT ec.id
FROM employee_contact ec
INNER JOIN employee e ON ec.employee_id=e.id
WHERE contact_id=@contactId ORDER BY seq");
Assert.AreEqual("ec.id", selectStatement2.selectClause);
}
public static async Task SendPhoneNotifyMessage(INotifyMessageSender notifyMessageSender)
{
IDatabase database = new Butterfly.Core.Database.Memory.MemoryDatabase();
await database.CreateFromResourceFileAsync(Assembly.GetExecutingAssembly(), "Butterfly.Notify.Test.db.sql");
database.SetDefaultValue("id", tableName => Guid.NewGuid().ToString());
database.SetDefaultValue("created_at", tableName => DateTime.Now);
var notifyMessageManager = new NotifyManager(database, phoneNotifyMessageSender: notifyMessageSender);
notifyMessageManager.Start();
var notifyMessage = new NotifyMessage("+1 316 712 7412", "+1 316 555 1212", null, "Just testing", null);
using (ITransaction transaction = await database.BeginTransactionAsync()) {
await notifyMessageManager.Queue(transaction, notifyMessage);
}
await Task.Delay(200000);
}
static void Main(string[] args)
{
using (var ctx =
new Butterfly.EmbedIO.EmbedIOContext("http://+:8000/")) {
// Create database
var database = new Butterfly.Core.Database.Memory.MemoryDatabase();
database.CreateFromSqlAsync(@"CREATE TABLE contact (
id VARCHAR(50) NOT NULL,
first_name VARCHAR(40) NOT NULL,
last_name VARCHAR(40) NOT NULL,
PRIMARY KEY(id)
);").Wait();
database.SetDefaultValue("id",
table => $"{table.Abbreviate()}_{Guid.NewGuid().ToString()}"
);
// Define the Web API
ctx.WebApi.OnPost("/api/contact/insert", async(req, res) => {
var record = await req.ParseAsJsonAsync <Dict>();
await database.InsertAndCommitAsync <string>("contact", record);
});
ctx.WebApi.OnPost("/api/contact/update", async(req, res) => {
var record = await req.ParseAsJsonAsync <Dict>();
await database.UpdateAndCommitAsync("contact", record);
});
ctx.WebApi.OnPost("/api/contact/delete", async(req, res) => {
var id = await req.ParseAsJsonAsync <string>();
await database.DeleteAndCommitAsync("contact", id);
});
// Define the Subscription API
ctx.SubscriptionApi.OnSubscribe(
"all-contacts",
(vars, channel) => database.CreateAndStartDynamicViewAsync(
"SELECT * FROM contact",
dataEventTransaction => channel.Queue(dataEventTransaction)
)
);
// Start the web server and wait
ctx.Start();
Console.ReadLine();
}
}
// Using async Task Main() requires adding <LangVersion>latest</LangVersion> to .csproj file
static async Task Main(string[] args)
{
logger.Info("Main()");
using (var embedIOContext = new Butterfly.EmbedIO.EmbedIOContext("http://+:8000/")) {
// Create a MemoryDatabase (no persistence, limited features)
var database = new Butterfly.Core.Database.Memory.MemoryDatabase();
await database.CreateFromSqlAsync(@"CREATE TABLE todo (
id VARCHAR(50) NOT NULL,
name VARCHAR(40) NOT NULL,
PRIMARY KEY(id)
);");
database.SetDefaultValue("id", tableName => $"{tableName.Abbreviate()}_{Guid.NewGuid().ToString()}");
// Listen for API requests
embedIOContext.WebApi.OnPost("/api/todo/insert", async(req, res) => {
logger.Info("/api/todo/insert");
var todo = await req.ParseAsJsonAsync <Dict>();
await database.InsertAndCommitAsync <string>("todo", todo);
});
embedIOContext.WebApi.OnPost("/api/todo/delete", async(req, res) => {
logger.Info("/api/todo/delete");
var id = await req.ParseAsJsonAsync <string>();
await database.DeleteAndCommitAsync("todo", id);
});
// Listen for subscribe requests...
// - The handler must return an IDisposable object (gets disposed when the channel is unsubscribed)
// - The handler can push data to the client by calling channel.Queue()
embedIOContext.SubscriptionApi.OnSubscribe("todos", (vars, channel) => {
string clientName = vars?.GetAs("clientName", "");
logger.Info($"OnSubscribe():todos,clientName={clientName}");
return(database.CreateAndStartDynamicViewAsync("todo", dataEventTransaction => {
var eventTypes = string.Join(",", dataEventTransaction.dataEvents.Select(x => x.dataEventType.ToString()));
logger.Info($"clientName={clientName},eventTypes={eventTypes}");
channel.Queue(dataEventTransaction);
}));
});
embedIOContext.Start();
Console.ReadLine();
}
}
public static async Task SendEmailNotifyMessage(INotifyMessageSender notifyMessageSender)
{
IDatabase database = new Butterfly.Core.Database.Memory.MemoryDatabase();
await database.CreateFromResourceFileAsync(Assembly.GetExecutingAssembly(), "Butterfly.Notify.Test.db.sql");
database.SetDefaultValue("id", tableName => Guid.NewGuid().ToString());
database.SetDefaultValue("created_at", tableName => DateTime.Now);
var notifyMessageManager = new NotifyManager(database, emailNotifyMessageSender: notifyMessageSender);
notifyMessageManager.Start();
var notifyMessage = new NotifyMessage("*****@*****.**", "*****@*****.**", "Test SES", "Just testing", null);
using (ITransaction transaction = await database.BeginTransactionAsync()) {
await notifyMessageManager.Queue(transaction, notifyMessage);
await transaction.CommitAsync();
}
await Task.Delay(200000);
}
// Using async Task Main() requires adding <LangVersion>latest</LangVersion> to .csproj file
static async Task Main(string[] args)
{
const int port = 8000;
var wwwPath = args.Length > 0 ? args[0] : "../../../www";
using (var embedIOContext = new Butterfly.EmbedIO.EmbedIOContext($"http://+:{port}/", wwwPath)) {
// Create a MemoryDatabase (no persistence, limited features)
var database = new Butterfly.Core.Database.Memory.MemoryDatabase();
await database.CreateFromSqlAsync(@"CREATE TABLE message (
id INT NOT NULL AUTO_INCREMENT,
text VARCHAR(40) NOT NULL,
PRIMARY KEY (id)
);");
// Listen for API requests
embedIOContext.WebApi.OnPost("/api/message/insert", async(req, res) => {
var text = await req.ParseAsJsonAsync <dynamic>();
await database.InsertAndCommitAsync <long>("message", new {
text
});
});
// Listen for subscribe requests...
// - The handler must return an IDisposable object (gets disposed when the channel is unsubscribed)
// - The handler can push data to the client by calling channel.Queue()
embedIOContext.SubscriptionApi.OnSubscribe("my-channel", (vars, channel) => {
return(database.CreateAndStartDynamicViewAsync("message", dataEventTransaction => channel.Queue(dataEventTransaction)));
});
embedIOContext.Start();
Console.WriteLine($"Opening http://localhost:{port}/ in a browser...");
ProcessX.OpenBrowser($"http://localhost:{port}/");
Console.ReadLine();
}
}
public async Task DataMemoryDatabase()
{
IDatabase database = new Butterfly.Core.Database.Memory.MemoryDatabase();
await TestDatabase(database);
}
