public async Task <ChadderError> CreateDevice()
{
var keypair = await KeyFactory.GenerateBook();
var pbk = await keypair.GetPublicBook();
var request = new CreateDeviceParameter()
{
Name = GetDeviceName(),
PublicKey = pbk.Serialize(),
Type = GetDeviceType(),
NotificationHandle = NotificationHandle
};
var response = await Session.PostRequestAPI <BasicResponse <string> >(Urls.CreateDevice, request);
if (response.Error == ChadderError.OK)
{
var mainDB = await ChadderSQLMainDB.GetDatabase(InstanceId);
db.LocalDevice = new ChadderLocalDeviceInfo()
{
DeviceId = response.Extra,
PrivateKeyBookData = keypair.Serialize()
};
await mainDB.InsertAsync(db.LocalDevice);
}
return(response.Error);
}
public async Task <ChadderError> Login(string username, string password)
{
if (await DeviceExists() == false)
{
var temp = await CreateDevice();
if (temp != ChadderError.OK)
{
return(temp);
}
}
password = await SharedUtil.GetPasswordHash(password);
var devicePair = await KeyFactory.RefreshBook(db.LocalDevice.PrivateKeyBook);
var devicePublic = await devicePair.GetPublicBook();
var request = new LoginParameter()
{
Username = username,
Password = password,
DeviceId = db.LocalDevice.DeviceId,
PublicKey = devicePublic.Serialize(),
RefreshToken = await CryptoHelper.CreateRandomData(32)
};
await request.Sign(db.LocalDevice.PrivateKeyBook.GetMaster());
var response = await Session.PostRequestAPI <BasicResponse <string> >(Urls.Login, request);
if (response.Error == ChadderError.OK)
{
var key = await CryptoHelper.CreateRandomData(32);
sqlDB = await ChadderSQLUserDB.GetNewUserDatabase(response.Extra, key, InstanceId);
db.LocalUser = new ChadderLocalUserInfo()
{
UserId = response.Extra,
Name = username,
RefreshToken = request.RefreshToken
};
await sqlDB.InsertAsync(db.LocalUser);
var keyPackage = new PlainBinary(key);
var record = new ChadderLocalUserRecord()
{
UserId = response.Extra,
Name = username,
DatabaseKey = keyPackage.Serialize()
};
var mainDB = await ChadderSQLMainDB.GetDatabase(InstanceId);
await mainDB.InsertAsync(record);
IsOnline = true;
await FinishLoading();
}
return(response.Error);
}
public async void User()
{
var i = 321;
var pwd = ChadderSQLMainDB.getDefaulPassword();
var pwd2 = ChadderSQLMainDB.getDefaulPassword();
pwd2[0] = 123;
var username = "******";
if (File.Exists(ChadderSQLDatabase.GetFilePath(username, i)))
{
File.Delete(ChadderSQLDatabase.GetFilePath(username, i));
}
var db2 = new ChadderLib.SQL.Legacy.SQLDatabase(ChadderSQLDatabase.GetFilePath(username, i), pwd);
db2.CreateTable <ChadderMessage>();
var db = await ChadderSQLDatabase.GetUserDatabase(username, pwd, i);
db.Close();
db = null;
Assert.Throws(typeof(SQLite.SQLiteException), async() =>
{
db = await ChadderSQLDatabase.GetUserDatabase(username, pwd2, i);
});
Assert.Null(db);
db = await ChadderSQLDatabase.GetUserDatabase(username, pwd, i);
Assert.NotNull(db);
db.Close();
db = null;
}
public async Task <ChadderError> UpdateNotificationHandleParameter(string handle)
{
NotificationHandle = handle;
if (await DeviceExists() && db.LocalDevice.NotificationHandle != handle)
{
var request = new UpdateNotificationHandleParameter()
{
DeviceId = db.LocalDevice.DeviceId,
Handle = handle
};
await request.Sign(db.LocalDevice.PrivateKeyBook.GetMaster());
var result = await Session.PostRequestAPI <BasicResponse>(Urls.UpdateNotification, request);
if (result.Error == ChadderError.OK)
{
db.LocalDevice.NotificationHandle = handle;
var mainDB = await ChadderSQLMainDB.GetDatabase(InstanceId);
await mainDB.UpdateAsync(db.LocalDevice);
}
return(result.Error);
}
return(ChadderError.OK);
}
public async void Main()
{
var i = 999999;
if (File.Exists(ChadderSQLMainDB.GetFilePath(i)))
{
File.Delete(ChadderSQLMainDB.GetFilePath(i));
}
var db = await ChadderSQLMainDB.GetDatabase(i);
var acc = new ChadderAccount();
acc.username = "******";
acc.sessionCookie = null;
acc.lastUpdateProcessed = 123;
acc.dbKey = Encoding.UTF8.GetBytes("Test");
acc.dbKeyType = KEY_TYPE.MASTER_KEY;
await db.SaveItem(acc);
var acc2 = await db.GetDefaultAccount();
Assert.Null(acc2);
acc.sessionCookie = "LoL";
await db.SaveItem(acc);
acc2 = await db.GetDefaultAccount();
Assert.NotNull(acc2);
Assert.AreEqual(acc2.username, acc.username);
Assert.AreEqual(acc2.sessionCookie, acc.sessionCookie);
Assert.AreEqual(acc2.lastUpdateProcessed, acc.lastUpdateProcessed);
Assert.AreEqual(acc2.dbKey, acc.dbKey);
Assert.AreEqual(acc2.dbKeyType, acc.dbKeyType);
db.Close();
db = await ChadderSQLMainDB.GetDatabase(i);
acc2 = await db.GetDefaultAccount();
Assert.NotNull(acc2);
Assert.AreEqual(acc2.username, acc.username);
Assert.AreEqual(acc2.sessionCookie, acc.sessionCookie);
Assert.AreEqual(acc2.lastUpdateProcessed, acc.lastUpdateProcessed);
Assert.AreEqual(acc2.dbKey, acc.dbKey);
Assert.AreEqual(acc2.dbKeyType, acc.dbKeyType);
acc2 = await db.GetAccount(acc.username.ToLower());
Assert.NotNull(acc2);
Assert.AreEqual(acc2.username, acc.username);
Assert.AreEqual(acc2.sessionCookie, acc.sessionCookie);
Assert.AreEqual(acc2.lastUpdateProcessed, acc.lastUpdateProcessed);
Assert.AreEqual(acc2.dbKey, acc.dbKey);
Assert.AreEqual(acc2.dbKeyType, acc.dbKeyType);
await db.clearData(i);
}
public async Task <bool> DeviceExists()
{
if (db.LocalDevice == null)
{
var mainDB = await ChadderSQLMainDB.GetDatabase(InstanceId);
db.LocalDevice = await mainDB.GetDevice();
}
return(db.LocalDevice != null);
}
public void Initialize()
{
Insight.Instance = new TestInsight();
int i = 0;
while (i < 10) // Will always delete the first 10 databases no matter what
{
while (ChadderSQLMainDB.Exists(i++).Result)
{
ChadderSQLMainDB.clearData(i - 1).Wait();
}
}
}
public async Task TestSplashScreen()
{
await ChadderSQLMainDB.clearData(0);
var random = new Random();
var source1 = CreateSource(0);
var name = string.Format("AutoTest{0}", random.Next());
Assert.AreEqual(ChadderError.OK, await source1.CreateUser(name));
var source2 = CreateSource(0);
var defUser = await source2.GetDefaultUser();
Assert.IsNotNull(defUser);
Assert.AreEqual(defUser.UserId, source1.db.LocalUser.UserId);
Assert.AreEqual(ChadderError.OK, await source2.StartUser(defUser));
Assert.AreEqual(ChadderError.OK, await source2.LoadUser(null));
}
public async Task <ChadderError> DeleteDevice()
{
if (await DeviceExists() == false)
{
return(ChadderError.OK);
}
var request = new DeleteDeviceParameter()
{
DeviceId = db.LocalDevice.DeviceId
};
await request.Sign(db.LocalDevice.PrivateKeyBook.GetMaster());
var result = await Session.PostRequestAPI <BasicResponse>(Urls.DeleteDevice, request);
if (result.Error == ChadderError.OK)
{
await ChadderSQLMainDB.clearData(InstanceId);
}
return(result.Error);
}
public async Task MainSqlDatabase()
{
var factory = new Chadder.Data.Keys.ECDSASimpleFactory();
var deviceInfo = new ChadderLocalDeviceInfo()
{
DeviceId = Guid.NewGuid().ToString(),
NotificationHandle = Guid.NewGuid().ToString(),
PrivateKeyBookData = (await factory.GenerateBook()).Serialize()
};
var user = new ChadderLocalUserRecord()
{
Name = "Test name",
UserId = Guid.NewGuid().ToString(),
DatabaseKey = await CryptoHelper.CreateRandomData(32)
};
using (var mainSql = await ChadderSQLMainDB.GetDatabase(0))
{
await mainSql.InsertAsync(deviceInfo);
await mainSql.InsertAsync(user);
}
using (var mainSql = await ChadderSQLMainDB.GetDatabase(0))
{
var device2 = await mainSql.GetDevice();
Assert.AreEqual(deviceInfo.DeviceId, device2.DeviceId);
Assert.AreEqual(deviceInfo.NotificationHandle, device2.NotificationHandle);
Assert.IsTrue(deviceInfo.PrivateKeyBookData.SequenceEqual(device2.PrivateKeyBookData));
var user2 = await mainSql.Table <ChadderLocalUserRecord>().FirstOrDefaultAsync();
Assert.AreEqual(user.Name, user2.Name);
Assert.AreEqual(user.UserId, user2.UserId);
Assert.IsTrue(user.DatabaseKey.SequenceEqual(user2.DatabaseKey));
}
await ChadderSQLMainDB.clearData(0);
System.IO.File.Delete(ChadderSQLMainDB.GetFilePath(0));
Assert.IsFalse(System.IO.File.Exists(ChadderSQLMainDB.GetFilePath(0)));
}
public async Task <ChadderError> Logout()
{
var result = await Session.PostRequestAPI <BasicResponse>(Urls.Logout);
if (result.Error == ChadderError.OK)
{
Insight.Track("Successfull Logout");
}
else
{
Insight.Track("Logout Failed");
}
Session.Token = null;
Connection.Disconnect();
IsOnline = false;
sqlDB.Dispose();
sqlDB = null;
var mainDb = await ChadderSQLMainDB.GetDatabase(InstanceId);
await mainDb.DeleteUser(db.LocalUser.UserId);
db = new ChadderDatabase(this);
return(ChadderError.OK);
}
public async Task <ChadderLocalUserRecord> GetDefaultUser()
{
var mainDB = await ChadderSQLMainDB.GetDatabase(InstanceId);
return(await mainDB.Table <ChadderLocalUserRecord>().FirstOrDefaultAsync());
}