public void TestIndentedTwoElements() {
     BsonDocument document = new BsonDocument() { { "a", "x" }, { "b", "y" } };
     var settings = new JsonWriterSettings { Indent = true };
     string json = document.ToJson(settings);
     string expected = "{\r\n  \"a\" : \"x\",\r\n  \"b\" : \"y\"\r\n}";
     Assert.AreEqual(expected, json);
 }

 public void TestInt64TenGen() {
     var document = new BsonDocument { { "a", 1L } };
     var settings = new JsonWriterSettings { OutputMode = JsonOutputMode.TenGen };
     var json = document.ToJson(settings);
     var expected = "{ 'a' : NumberLong(1) }".Replace("'", "\"");
     Assert.AreEqual(expected, json);
 }

 public void TestIndentedEmptyDocument() {
     BsonDocument document = new BsonDocument();
     var settings = new JsonWriterSettings { Indent = true };
     string json = document.ToJson(settings);
     string expected = "{ }";
     Assert.AreEqual(expected, json);
 }

 public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
 {
     //value = ObjectId.GenerateNewId();
     var jsonWriterSettings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };
     JObject b = JObject.Parse(value.ToJson(jsonWriterSettings));
     serializer.Serialize(writer, b);
 }

 /// <summary>
 ///     导出到JSON
 /// </summary>
 /// <param name="dataList"></param>
 /// <param name="filename"></param>
 /// <param name="settings"></param>
 private static void ExportToJson(List<BsonDocument> dataList, string filename, JsonWriterSettings settings)
 {
     var file = new FileStream(filename, FileMode.Create);
     var sw = new StreamWriter(file);
     sw.Write(dataList.ToJson(settings));
     sw.Flush();
 }

        public static void TraceHtmlReader_v2(string file, string traceFile, bool disableScriptTreatment = false, bool useReadAttributeValue_v2 = false)
        {
            try
            {
                __srTraceHtmlReader = zFile.CreateText(traceFile);
                __traceJsonSettings = new JsonWriterSettings();
                __traceJsonSettings.Indent = true;

                using (StreamReader sr = zfile.OpenText(file))
                {
                    HtmlReader_v2 htmlReader = new HtmlReader_v2(sr);
                    htmlReader.Trace = TraceHtmlReader;
                    htmlReader.DisableScriptTreatment = disableScriptTreatment;
                    htmlReader.UseReadAttributeValue_v2 = useReadAttributeValue_v2;
                    htmlReader.ReadAll();
                }
            }
            finally
            {
                if (__srTraceHtmlReader != null)
                {
                    __srTraceHtmlReader.Close();
                    __srTraceHtmlReader = null;
                }
                __traceJsonSettings = null;
            }

        }

 public void TestIndentedOneElement() {
     BsonDocument document = new BsonDocument() { { "name", "value" } };
     var settings = new JsonWriterSettings { Indent = true };
     string json = document.ToJson(settings);
     string expected = "{\r\n  \"name\" : \"value\"\r\n}";
     Assert.AreEqual(expected, json);
 }

 // constructors
 /// <summary>
 /// Initializes a new instance of the JsonWriter class.
 /// </summary>
 /// <param name="writer">A TextWriter.</param>
 /// <param name="settings">Optional JsonWriter settings.</param>
 public JsonWriter(TextWriter writer, JsonWriterSettings settings)
     : base(settings)
 {
     _textWriter = writer;
     _jsonWriterSettings = settings; // already frozen by base class
     _context = new JsonWriterContext(null, ContextType.TopLevel, "");
     State = BsonWriterState.Initial;
 }

 /// <summary>
 /// Initializes a new instance of the JsonWriter class.
 /// </summary>
 /// <param name="writer">A TextWriter.</param>
 /// <param name="settings">Optional JsonWriter settings.</param>
 public JsonWriter(
     TextWriter writer,
     JsonWriterSettings settings
 ) {
     this.textWriter = writer;
     this.settings = settings.Freeze();
     context = new JsonWriterContext(null, ContextType.TopLevel, "");
     state = BsonWriterState.Initial;
 }

 public JsonTraceDataWriter(string file, FileOption option, Encoding encoding = null, JsonWriterSettings settings = null)
 {
     file = file.zRootPath(zapp.GetAppDirectory());
     if (option == FileOption.IndexedFile)
         file = zfile.GetNewIndexedFileName(zPath.GetDirectoryName(file), zPath.GetFileName(file));
     //_streamWriter = zFile.CreateText(file);
     Open(file, encoding, option != FileOption.RazFile);
     _closeStreamWriter = true;
     InitSettings(settings);
 }

        // GET api/values/5
        public string Get(string id)
        {
            rvService svc = new rvService(getMongoDB());
            DataTableParamModel para = new DataTableParamModel();
            para.sDate =Convert.ToDateTime(id);
            var jsonWriterSettings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };

            string rtn = svc.Read(para).ToJson(jsonWriterSettings);
            //rtn = "{\"data\":" + rtn + "}";
            return rtn;
        }

        // GET api/Categories/5
        public async Task<string> GetAsync(string id)
        {
            MongoHelper<PaymentType> paymentTypeHelper = new MongoHelper<PaymentType>();
            var jsonWriterSettings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };

            PaymentType paymentType = await paymentTypeHelper.Collection
                .Find(p => p.Id.Equals(ObjectId.Parse(id))) // TODO filter by userId
                .FirstAsync();

            return paymentType.ToJson(jsonWriterSettings);

        }

        // GET api/Categories/5
        public async Task<string> GetAsync(string id)
        {
            MongoHelper<Category> categoryHelper = new MongoHelper<Category>();
            var jsonWriterSettings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };
            
            Category cat = await categoryHelper.Collection
                .Find(c => c.Id.Equals(ObjectId.Parse(id))) // TODO filter by userId
                .FirstAsync(); 

            return cat.ToJson(jsonWriterSettings);
            
        }

        /// <summary>
        /// Initializes a new instance of the JsonWriter class.
        /// </summary>
        /// <param name="writer">A TextWriter.</param>
        /// <param name="settings">Optional JsonWriter settings.</param>
        public JsonWriter(TextWriter writer, JsonWriterSettings settings)
            : base(settings)
        {
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }

            _textWriter = writer;
            _jsonWriterSettings = settings; // already frozen by base class
            _context = new JsonWriterContext(null, ContextType.TopLevel, "");
            State = BsonWriterState.Initial;
        }

 //Retourne les indices d'un pays donné trié par un champ par exemple le prix, le volume, market cap etc...
 public Dictionary<string, int> aggregateCountryNumberOfIndustrySortedDesc(string _country)
 {
     Dictionary<string, int> dictionnary = new Dictionary<string, int>();
     var aggregate = collection.Aggregate()
                               .Match(new BsonDocument { { "Country", _country } })
                               .Group(new BsonDocument { { "_id", new BsonDocument { { "Industry", "$Industry" } } }, { "number", new BsonDocument { { "$sum", 1 } } } })
                               .Sort(new BsonDocument { { "number", -1 } }).ToListAsync().Result;
     var jsonSettings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };
     foreach (BsonDocument bsd in aggregate)
     {
         dictionnary.Add(bsd.GetValue("_id").ToBsonDocument().GetValue("Industry").ToString(),Convert.ToInt32(bsd.GetValue("number")));
     }
     return dictionnary;
 }

 //Retourne les indices d'un pays donné trié par un champ par exemple le prix, le volume, market cap etc...
 public List<Stockobject> aggregateCountrySorted(string _country, string _sortBy, bool _asc)
 {
     int i = 0;
     if (_asc) i = 1;
     else i = -1;
     List<Stockobject> list = new List<Stockobject>();
     var aggregate = collection.Aggregate()
                               .Match(new BsonDocument { { "Country", _country } })
                               .Sort(new BsonDocument { { _sortBy, i } }).ToListAsync().Result;
     var jsonSettings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };
     foreach (BsonDocument bsd in aggregate)
     {
         list.Add(BsonSerializer.Deserialize<Stockobject>(bsd.ToJson()));
     }
     return list;
 }

        // GET api/ExpenseApi
        public async Task<IEnumerable<string>> GetAsync()
        {            
            MongoHelper<Expense> expenseHelper = new MongoHelper<Expense>();
                
            IList<string> returnList = new List<string>();
            var jsonWriterSettings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };
            await expenseHelper.Collection.Find(e => e.Value > 0) // TODO filter by userId
                .ForEachAsync(expenseDocument => 
                {
                    string docJson = expenseDocument.ToJson(jsonWriterSettings);
                    returnList.Add(docJson);
                }
            );                    

            return returnList.ToArray();
        }

 public void TestDateTime()
 {
     DateTime jan_1_2010 = new DateTime(2010, 1, 1);
     double expectedValue = (jan_1_2010.ToUniversalTime() - BsonConstants.UnixEpoch).TotalMilliseconds;
     BsonDocument document = new BsonDocument() {
         { "date", jan_1_2010 }
     };
     var settings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };
     string json = document.ToJson(settings);
     string expected = "{ \"date\" : { \"$date\" : # } }".Replace("#", expectedValue.ToString());
     Assert.AreEqual(expected, json);
     settings = new JsonWriterSettings { OutputMode = JsonOutputMode.JavaScript };
     json = document.ToJson(settings);
     expected = "{ \"date\" : Date(#) }".Replace("#", expectedValue.ToString());
     Assert.AreEqual(expected, json);
 }

        // GET api/CategoryApi
        public async Task<IEnumerable<string>> GetAsync()
        {
            MongoHelper<Category> categoryHelper = new MongoHelper<Category>();
                
            IList<string> returnList = new List<string>();
            var jsonWriterSettings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };
            await categoryHelper.Collection.Find(e => e.Name != null) // TODO filter by userId
                .ForEachAsync(categoryDocument => 
                {
                    string docJson = categoryDocument.ToJson(jsonWriterSettings);
                    returnList.Add(docJson);
                }
            );

            return returnList.ToArray();
        }

        // GET: api/UserProfiles
        public async Task<HttpResponseMessage> Get(
            [FromUri] string repository,
            [FromUri] string display_name,
            [FromUri] string month
            )
        {
            EasyAnalysis.Framework.ConnectionStringProviders.IConnectionStringProvider mongoDBCSProvider =
                   EasyAnalysis.Framework.ConnectionStringProviders.ConnectionStringProvider.CreateConnectionStringProvider(EasyAnalysis.Framework.ConnectionStringProviders.ConnectionStringProvider.ConnectionStringProviderType.MongoDBConnectionStringProvider);
            var client = new MongoClient(mongoDBCSProvider.GetConnectionString(repository));

            var database = client.GetDatabase(repository);

            var userProfiles = database.GetCollection<BsonDocument>("asker_activities");

            var builder = Builders<BsonDocument>.Filter;

            FilterDefinition<BsonDocument> filter = "{}";

            if (!string.IsNullOrEmpty(display_name))
            {
                filter = filter & builder.Regex("display_name", BsonRegularExpression.Create(new Regex("^" + display_name, RegexOptions.IgnoreCase)));
            }

            if (!string.IsNullOrEmpty(month))
            {
                filter = filter & builder.Eq("month", month);
            }

            var result = await userProfiles
                .Find(filter)
                .Sort("{ total: -1 }")
                .ToListAsync();

            var response = Request.CreateResponse();

            response.StatusCode = HttpStatusCode.OK;

            var jsonWriterSettings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };

            response.Content = new StringContent(result.ToJson(jsonWriterSettings), Encoding.UTF8, "application/json");

            return response;
        }