static void Main(string[] args)
{
var orig = @"C:\Temp\service.c.db";
var docs = JsonSerializer.DeserializeArray("").Select(x => x.AsDocument);
var report = LiteEngine.Recovery(orig);
Console.WriteLine("Recovery Report:\n" + report);
//using (var db = new LiteEngine(@"C:\Temp\SessionDatabase-recovery.ldb"))
//{
// // reading all database
// foreach (var col in db.GetCollectionNames())
// {
// Console.WriteLine("Collection: " + col);
//
//
// foreach (var doc in db.Find(col, Query.All("Token.LastUsedOn")).Take(10))
// {
// Console.WriteLine(JsonSerializer.Serialize(doc, true));
// // ok
// }
// }
//}
Console.WriteLine("End.");
Console.ReadKey();
}
/// <summary>
/// Return fixed 1000 Person instances
/// </summary>
public static IEnumerable <Person> Person()
{
using (var stream = typeof(DataGen).Assembly.GetManifestResourceStream("LiteDB.Tests.Utils.Json.person.json"))
{
var reader = new StreamReader(stream);
var docs = JsonSerializer.DeserializeArray(reader).Select(x => x.AsDocument);
var id = 0;
foreach (var doc in docs)
{
yield return(new Person
{
Id = ++id,
Name = doc["name"],
Age = doc["age"],
Phones = doc["phone"].AsString.Split("-"),
Email = doc["email"],
Date = doc["date"],
Active = doc["active"],
Address = new Address
{
Street = doc["street"],
City = doc["city"],
State = doc["state"]
}
});
}
}
}
//Load local data
private void metroButton4_Click(object sender, EventArgs e)
{
openLoadDef.FileName = "";
openLoadDef.ShowDialog();
string errordef = openLoadDef.FileName;
if (errordef != "")
{
List <LiteDB.BsonDocument> docs = new List <LiteDB.BsonDocument>();
StreamReader r = new StreamReader(errordef);
var json = r.ReadToEnd();
var jsonObj = JsonSerializer.DeserializeArray(json);
using (var db = new LiteDatabase("ErrorMsg.db"))
try
{
{
db.DropCollection("ErrorMsg");
var ErrO = db.GetCollection <ErrorMsg>("ErrorMsg");
docs = jsonObj.Select(x => x.AsDocument).ToList();
db.GetCollection("ErrorMsg").InsertBulk(docs);
ErrO.EnsureIndex("_id");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
finally
{
json = null;
jsonObj = null;
}
}
MessageBox.Show("Error Definations Updated :) ");
}
public void Import(string json)
{
var dataValues = JsonSerializer.DeserializeArray(json);
db.Engine.Delete("layoutprefs", Query.All());
db.Engine.InsertBulk("layoutprefs", dataValues.Select(x => x.AsDocument));
}
private static void InitDB()
{
string dbFile = $"{AppDomain.CurrentDomain.BaseDirectory}\\App_Data\\Initech.db";
File.Delete(dbFile);
using (var db = new LiteDatabase(dbFile))
{
using (var sr = new StreamReader($"{AppDomain.CurrentDomain.BaseDirectory}\\App_Data\\agents.json"))
{
var agentDocs = JsonSerializer.DeserializeArray(sr).Select(x => x.AsDocument);
db.GetCollection("Agents").InsertBulk(agentDocs);
}
var agents = db.GetCollection <Agent>("Agents");
agents.EnsureIndex("_id", unique: true);
Console.WriteLine(agents.FindAll().Count() + " Agents inserted");
using (var sr = new StreamReader($"{AppDomain.CurrentDomain.BaseDirectory}\\App_Data\\customers.json"))
{
var customerDocs = JsonSerializer.DeserializeArray(sr).Select(x => x.AsDocument);
db.GetCollection("Customers").InsertBulk(customerDocs);
}
var customers = db.GetCollection <Customer>("Customers");
customers.EnsureIndex("_id", unique: true);
customers.EnsureIndex("agent_id", unique: false);
Console.WriteLine(customers.FindAll().Count() + " Customers inserted");
}
}
public object SetValue(string value, Type type = null)
{
if (string.IsNullOrEmpty(value))
{
return(new List <T> ());
}
var rr = JsonSerializer.DeserializeArray(value, typeof(T));
return(rr);
}
public void Array()
{
List <dynamic> arr = _sut.DeserializeArray("[1,'ted',null,true,[]]");
Assert.That(arr.Count, Is.EqualTo(5));
Assert.That(arr[0], Is.EqualTo(1));
Assert.That(arr[1], Is.EqualTo("ted"));
Assert.That(arr[2], Is.Null);
Assert.That(arr[3], Is.True);
Assert.That(arr[4], Is.Not.Null);
}
public BsonValue Execute(DbEngine engine, StringScanner s)
{
var col = this.ReadCollection(engine, s);
var filename = s.Scan(@".*");
using (var sr = new StreamReader(filename, Encoding.UTF8))
{
var docs = JsonSerializer.DeserializeArray(sr);
return(engine.Insert(col, docs.Select(x => x.AsDocument)));
}
}
public async Task <HttpRequest[]> RetrieveRecordedRequestsAsync(HttpRequest httpRequest)
{
var response = await SendRequestAsync(new HttpRequestMessage()
.WithMethod(HttpMethod.Put)
.WithUri(ServerAddress(FullPath(RetrieveEndpoint)))
.WithBody(_httpRequestSerializer.Serialize(httpRequest, string.Empty),
Encoding.UTF8));
var body = await response.Content.ReadAsStringAsync();
return(_httpRequestSerializer.DeserializeArray(body, new HttpRequest[0]));
}
public void Execute(LiteEngine engine, StringScanner s, Display display, InputCommand input, Env env)
{
var col = this.ReadCollection(engine, s);
var filename = s.Scan(@".*");
using (var sr = new StreamReader(new FileStream(filename, System.IO.FileMode.Open)))
{
var docs = JsonSerializer.DeserializeArray(sr);
display.WriteResult(engine.Insert(col, docs.Select(x => x.AsDocument)));
}
}
public IEnumerable <BsonValue> Execute(StringScanner s, LiteEngine engine)
{
var col = this.ReadCollection(engine, s);
var filename = s.Scan(@".*");
using (var sr = new StreamReader(new FileStream(filename, System.IO.FileMode.Open)))
{
var docs = JsonSerializer.DeserializeArray(sr);
yield return(engine.InsertBulk(col, docs.Select(x => x.AsDocument)));
}
}
public BsonValue Execute(LiteDatabase db, StringScanner s)
{
var col = this.ReadCollection(db, s);
var filename = s.Scan(@".*");
using (var sr = new StreamReader(filename, Encoding.UTF8))
{
var docs = JsonSerializer.DeserializeArray(sr);
return(col.InsertBulk(docs.Select(x => x.AsDocument)));
}
}
/// <summary>
/// Return fixed 29353 Zips instances
/// </summary>
public static IEnumerable <Zip> Zip()
{
using (var stream = typeof(DataGen).Assembly.GetManifestResourceStream("LiteDB.Tests.Utils.Json.zip.json"))
{
var reader = new StreamReader(stream);
var s = reader.ReadToEnd();
return(JsonSerializer.DeserializeArray(s)
.Select(x => x.AsDocument)
.Select(x => BsonMapper.Global.ToObject <Zip>(x)));
}
}
public virtual object FromJsonValue(Type type, JsonValue value, Type parentType)
{
if ((value is JsonPrimitive))
{
var result = value.ToString();
if (string.IsNullOrEmpty(result))
{
return(new List <T> ());
}
return(new List <T> ());
}
var rr = JsonSerializer.DeserializeArray(value as JsonArray, typeof(T));
return(rr);
}
static void ConvertParametersType(ParameterInfo[] ParameterInfos, object[] parameters)
{
if (parameters.Length != ParameterInfos.Length)
{
throw new Exception("参数个数不正确,需要" + ParameterInfos.Length + ",发送了" + parameters.Length);
}
for (int i = 0; i < ParameterInfos.Length; i++)
{
try{
var ParameterInfo = ParameterInfos[i];
object parameter = parameters[i];
if (parameters[i] != null && !parameters[i].GetType().IsSubclassOf(ParameterInfo.ParameterType))
{
if (ParameterInfo.ParameterType == parameter.GetType())
{
}
else if (parameter is JsonObject)
{
parameter = JsonSerializer.DeserializeObject((parameter as JsonObject), ParameterInfo.ParameterType);
parameters[i] = parameter;
}
else if (parameter is JsonArray)
{
parameter = JsonSerializer.DeserializeArray((parameter as JsonArray), ParameterInfo.ParameterType.GetGenericArguments()[0]);
parameters[i] = parameter;
}
else if (ParameterInfo.ParameterType.IsPrimitive)
{
var pType = parameter.GetType();
if (pType != ParameterInfo.ParameterType)
{
parameters[i] = Convert.ChangeType(parameter, ParameterInfo.ParameterType);
}
}
else if (ParameterInfo.ParameterType.IsEnum)
{
parameters[i] = Enum.Parse(ParameterInfo.ParameterType, parameters[i].ToString());
}
}
}catch (Exception e)
{
Logger.Error.Write("[{0}][{1}]", e.Message, e.StackTrace);
}
}
}
public IEnumerable <T> GetDocumentCollection <T>(string nameSpace, params string[] files)
{
var documents = new List <T>();
var assembly = typeof(DocumentRepository).GetTypeInfo().Assembly;
var mapper = BsonMapper.Global;
foreach (var file in files)
{
using (var stream = assembly.GetManifestResourceStream($"{nameSpace}.{file}"))
using (var reader = new StreamReader(stream))
{
var array = JsonSerializer.DeserializeArray(reader).Select(x => mapper.ToObject <T>(x.AsDocument));
documents.AddRange(array);
}
}
return(documents);
}
public object FromJsonValue(Type type, JsonValue value, Type parentType)
{
var array = JsonSerializer.DeserializeArray <TElement> ((JsonArray)value);
if (array == null)
{
return(null);
}
if (type == array.GetType())
{
return(array);
}
var list = (ICollection <TElement>)Activator.CreateInstance(type);
foreach (var item in array)
{
list.Add(item);
}
return(list);
}
