public static string IdToTenantPartitionId(this string id) { var idList = id.Split(':'); if (id.StartsWith("tenant:")) { return(Tenant.PartitionIdFormat()); } else if (id.StartsWith("track:")) { return(Track.PartitionIdFormat(new Track.IdKey { TenantName = idList[1], TrackName = idList[2] })); } else if (id.StartsWith("party:")) { return(DataDocument.PartitionIdFormat(new Track.IdKey { TenantName = idList[2], TrackName = idList[3] })); } else { return(DataDocument.PartitionIdFormat(new Track.IdKey { TenantName = idList[1], TrackName = idList[2] })); } }
public InMemoryDataRepositoryService() { var config = Catalog.Factory.Resolve <IConfig>(SpecialFactoryContexts.Routed); _summaryMetadataSource = config.Get <IMetadataProvider <TSummaryType, TSummaryMetadataType> >( DataRepositoryServiceLocalConfig.SummaryMetadataProvider); _itemMetadataSource = config.Get <IMetadataProvider <TDataType, TItemMetadataType> >( DataRepositoryServiceLocalConfig.ItemMetadataProvider); _summarizer = config.Get <ISummarizer <TDataType, TSummaryType> >(DataRepositoryServiceLocalConfig.Summarizer); if (config.SettingExists(DataRepositoryServiceLocalConfig.ContextFilter)) { _contextFilter = config.Get <IContextFilter>(DataRepositoryServiceLocalConfig.ContextFilter); } IEnumerable <TDataType> initialData = null; if (config.SettingExists(InMemoryDataRepositoryServiceLocalConfig.OptionalInitialData)) { initialData = config.Get <IEnumerable <TDataType> >(InMemoryDataRepositoryServiceLocalConfig.OptionalInitialData); } if (null != initialData) { initialData.ForEach(d => _data.TryAdd(DataDocument.GetDocumentId(d), d)); } }
public void CreateNewBatch(IList <TDataType> documents) { foreach (var d in documents) { DataDocument.NixId(d); } StoreDocuments(documents); }
public void TestSyncPut() { DataDocument doc = new DataDocument(); doc.Set("field1", "value1"); redis.PutSync("unit-test", "1", doc, TimeSpan.FromSeconds(600)); Assert.AreEqual(doc.GetFirstValueAsString("field1"), (redis.GetSync("unit-test", "1")).GetFirstValueAsString("field1")); }
public void TestDocumentGetByFieldsSync() { DataDocument doc = new DataDocument(); doc.Set("field1", "value1"); redis.PutSync("unit-test-hash", "1", doc); Assert.AreEqual(doc.GetFirstValueAsString("field1"), (redis.GetSync("unit-test-hash", "1", new string[] { "field1" })).GetFirstValueAsString("field1")); }
public async Task TestDocumentGetByFields() { DataDocument doc = new DataDocument(); doc.Set("field1", "value1"); await redis.Put("unit-test-hash", "1", doc); Assert.AreEqual(doc.GetFirstValueAsString("field1"), (await redis.Get("unit-test-hash", "1", new string[] { "field1" })).GetFirstValueAsString("field1")); }
public async Task <Track> GetTrackByNameAsync(Track.IdKey idKey, bool requered = true) { if (idKey == null) { new ArgumentNullException(nameof(idKey)); } return(await ReadDocumentAsync <Track>(await Track.IdFormat(idKey), DataDocument.PartitionIdFormat(idKey), requered)); }
public async Task <UpParty> GetUpPartyByNameAsync(Party.IdKey idKey, bool required = true) { if (idKey == null) { new ArgumentNullException(nameof(idKey)); } return(await ReadItemAsync <UpParty>(await UpParty.IdFormatAsync(idKey), DataDocument.PartitionIdFormat(idKey), required)); }
public async Task TestDocumentPut() { DataDocument doc = new DataDocument(); doc.Set("field1", "value1"); await redis.Put("unit-test", "1", doc, TimeSpan.FromSeconds(600)); Assert.AreEqual(doc.GetFirstValueAsString("field1"), (await redis.Get("unit-test", "1")).GetFirstValueAsString("field1")); }
public void CreateNewBatch(IList <TDataType> documents) { using (var trx = _client.BeginTransaction()) { var tbl = _client.OpenTable <TDataType>(_tableId); documents.ForEach(doc => tbl.AddNew(DataDocument.GetDocumentId(doc), doc)); _client.Commit(); } }
public virtual HttpResponseMessage PostNew(TDataType document) { _dataRepository.CreateNew(document); var response = Request.CreateResponse <TDataType>(HttpStatusCode.Created, document); string uri = Url.Link("DefaultApi", new { id = DataDocument.GetDocumentId(document) }); response.Headers.Location = new Uri(uri); return(response); }
public ActionResult RawData(RawDataDocument document) { if (ModelState.IsValid) { document.DateStored = DateTime.Now; if (document.Public) { document.DataDocuments = new List <DataDocument>(); if (document.File != null && string.IsNullOrWhiteSpace(document.Data)) { document.Data = ""; using (StreamReader reader = new StreamReader(document.File.InputStream)) { document.Header = reader.ReadLine() + Environment.NewLine; while (!reader.EndOfStream) { document.Data += reader.ReadLine() + Environment.NewLine; } } } string[] hs = document.Header.Split(document.Separator.ToCharArray()); string[] ds = document.Data.Split(new[] { '\r', '\n' }); foreach (var d in ds) { string[] s = d.Split(document.Separator.ToCharArray()); for (int i = 0; i < hs.Length; i++) { DataDocument dataDocument = new DataDocument(); //if (i != document.TimeColumn) if (s.Length == hs.Length) { dataDocument.Row = s[document.RowColumn]; dataDocument.Value = s[i]; dataDocument.Column = hs[i]; document.DataDocuments.Add(dataDocument); } } } Saver.Save(document); ViewBag.ModelStatus = "Success"; return(View("RawData")); } else { ViewBag.ModelStatus = "You cannot upload data that is not public"; } } else { ViewBag.ModelStatus = "Something went wrong"; } return(View("RawData", document)); }
public string CreateNew(TDataType document) { using (var trx = _client.BeginTransaction()) { var tbl = _client.OpenTable <TDataType>(_tableId); tbl.AddNew(DataDocument.GetDocumentId(document), document); _client.Commit(); } return(DataDocument.GetDocumentId(document)); }
public IList <TItemPackageType> Load(IList <string> id) { var retval = new List <TItemPackageType>(); var items = from dt in _data.Values where id.Contains(DataDocument.GetDocumentId(dt)) select dt; retval.AddRange( items.Select(i => new TItemPackageType { Item = i, Metadata = _itemMetadataSource.Metadata })); return(retval); }
public void Store(TDataType document) { var key = DataDocument.GetDocumentId(document); if (!_data.ContainsKey(key)) { _data.TryAdd(key, document); } else { _data[DataDocument.GetDocumentId(document)] = document; } }
public LanguageData(string strLanguage) { string strFilePath = Path.Combine(Application.StartupPath, "lang", strLanguage + ".xml"); if (File.Exists(strFilePath)) { XmlDocument objLanguageDocument = new XmlDocument(); objLanguageDocument.Load(strFilePath); if (objLanguageDocument != null) { foreach (XmlNode objNode in objLanguageDocument.SelectNodes("/chummer/strings/string")) { // Look for the English version of the found string. If it has been found, replace the English contents with the contents from this file. // If the string was not found, then someone has inserted a Key that should not exist and is ignored. string strKey = objNode["key"]?.InnerText; string strText = objNode["text"]?.InnerText; if (!string.IsNullOrEmpty(strKey) && !string.IsNullOrEmpty(strText)) { if (TranslatedStrings.ContainsKey(strKey)) { TranslatedStrings[strKey] = strText.Replace("\\n", "\n"); } else { TranslatedStrings.Add(strKey, strText.Replace("\\n", "\n")); } } } } else { IsLoaded = false; } } else { IsLoaded = false; } // Check to see if the data translation file for the selected language exists. string strDataPath = Path.Combine(Application.StartupPath, "lang", strLanguage + "_data.xml"); if (File.Exists(strDataPath)) { DataDocument.Load(strDataPath); } else { IsLoaded = false; } }
public static GodisnjiIzvjestaj LoadFromGFI(Stream stream) { AnnualReports.Reader.Reader.Init(); var reader = new AnnualReports.Reader.Reader(); DataDocument document = reader.Read(stream); GodisnjiIzvjestaj izvjestaj = OsnovniPodaciLoader.Load(document.Sheets["osnovnipodaci"]); izvjestaj.Bilanca = BilancaLoader.Load(izvjestaj.Godina, document.Sheets["bilanca"]); izvjestaj.RDG = RDGLoader.Load(izvjestaj.Godina, document.Sheets["rdg"]); return(izvjestaj); }
public IList <TItemPackageType> Load(IList <TSummaryType> proxies) { var retval = new List <TItemPackageType>(); var ids = from p in proxies select _summarizer.Identify(p); var items = from dt in _data.Values where ids.Contains(DataDocument.GetDocumentId(dt)) select dt; retval.AddRange( items.Select(i => new TItemPackageType { Item = i, Metadata = _itemMetadataSource.Metadata })); return(retval); }
public void Update(TDataType document) { var id = DataDocument.GetDocumentId(document); using (var dc = DocumentStoreLocator.ContextualResolve()) { var existing = dc.Load <TDataType>(id); if (null == existing) { throw new InstanceNotFoundException(); } _updateAssignment(existing, document); dc.SaveChanges(); } }
public void BatchUpdate(IList <TDataType> documents) { using (var dc = DocumentStoreLocator.ContextualResolve()) { var existing = dc.Load <TDataType>(documents.Select(DataDocument.GetDocumentId)); foreach (var item in existing) { var update = documents.First(d => DataDocument.GetDocumentId(d) == DataDocument.GetDocumentId(item)); if (null == update) { throw new InstanceNotFoundException(); } _updateAssignment(item, update); } dc.SaveChanges(); } }
private License GetLicense(DataDocument idlicence, string name, DataDocument idCard, string photo) { if (idCard != null) { var licence = new License { Name = name, NumberID = idCard.Number, Berlaku = idCard.Berlaku.Value, Hingga = idCard.Hingga.Value, Number = idCard.Number, }; licence.Photo = string.IsNullOrEmpty(photo) ? null : ImageSource.FromUri(new Uri(Helper.Url + "/" + photo)); return(licence); } return(new License()); }
public async Task <T> DeleteAsync <T>(Track.IdKey idKey, Expression <Func <T, bool> > whereQuery) where T : IDataDocument { if (idKey == null) { new ArgumentNullException(nameof(idKey)); } await idKey.ValidateObjectAsync(); var partitionId = DataDocument.PartitionIdFormat(idKey); var query = GetQueryAsync <T>(partitionId).Where(whereQuery).AsDocumentQuery(); double totalRU = 0; try { var response = await query.ExecuteNextAsync <T>(); totalRU += response.RequestCharge; var item = response.FirstOrDefault(); if (item != null) { var requestOptions = new RequestOptions { PartitionKey = new PartitionKey(partitionId) }; var deleteResponse = await client.DeleteDocumentAsync(GetDocumentLink <T>(item.Id), requestOptions); totalRU += deleteResponse.RequestCharge; } await item.ValidateObjectAsync(); return(item); } catch (Exception ex) { throw new CosmosDataException(partitionId, ex); } finally { var scopedLogger = httpContextAccessor.HttpContext.RequestServices.GetService <TelemetryScopedLogger>(); scopedLogger.ScopeMetric($"CosmosDB RU, tenant - delete type '{typeof(T)}'.", totalRU); } }
public void Update(TDataType document) { TDataType oldData; if (!_data.TryGetValue(DataDocument.GetDocumentId(document), out oldData)) { throw new InstanceNotFoundException(); } if (DataDocument.HasEtag <TDataType>()) { if (DataDocument.GetDocumentEtag(oldData) != DataDocument.GetDocumentEtag(document)) { throw new DBConcurrencyException(); } } DataDocument.SetDocumentEtagNew(document); _data[DataDocument.GetDocumentId(document)] = document; }
public void Store(TDataType document) { using (var trx = _client.BeginTransaction()) { var tbl = _client.OpenTable <TDataType>(_tableId); var readData = tbl.Fetch(new string[] { DataDocument.GetDocumentId(document) }); if (readData.Any()) { InternalUpdate(document, tbl); } else { tbl.AddNew(DataDocument.GetDocumentId(document), document); } _client.Commit(); } }
public async Task TestCities() { DataDocument rochester = new DataDocument(); rochester.Set("population", 208880); DataDocument syracuse = new DataDocument(); syracuse.Set("population", 142749); DataDocument buffalo = new DataDocument(); buffalo.Set("population", 256902); DataDocument binghamton = new DataDocument(); binghamton.Set("population", 45672); DataDocument boston = new DataDocument(); boston.Set("population", 694583); KeyValuePair <Location, DataDocument>[] pairs = new KeyValuePair <Location, DataDocument>[] { new KeyValuePair <Location, DataDocument>(new string[] { "United States", "NY", "Rochester" }, rochester), new KeyValuePair <Location, DataDocument>(new string[] { "United States", "NY", "Syracuse" }, syracuse), new KeyValuePair <Location, DataDocument>(new string[] { "United States", "NY", "Buffalo" }, buffalo), new KeyValuePair <Location, DataDocument>(new string[] { "United States", "NY", "Binghamton" }, binghamton), new KeyValuePair <Location, DataDocument>(new string[] { "United States", "MA", "Boston" }, boston) }; await redis.Put("cities-test", pairs); var usDocs = await redis.Find("cities-test", new string[] { "United States", "*", "*" }).ToArrayAsync(); Assert.AreEqual(5, usDocs.Length); var nyDocs = await redis.Find("cities-test", new string[] { "United States", "NY", "*" }).ToArrayAsync(); Assert.AreEqual(4, nyDocs.Length); var maDocs = await redis.Find("cities-test", new string[] { "United States", "MA", "*" }).ToArrayAsync(); Assert.AreEqual(1, maDocs.Length); }
public async Task TestGrid() { DataDocument doc1 = new DataDocument(); doc1.Set("score", 95); DataDocument doc2 = new DataDocument(); doc2.Set("score", 87); DataDocument doc3 = new DataDocument(); doc3.Set("score", 81); DataDocument doc4 = new DataDocument(); doc4.Set("score", 71); DataDocument doc5 = new DataDocument(); doc5.Set("score", 99); DataDocument doc6 = new DataDocument(); doc6.Set("score", 16); KeyValuePair <Location, DataDocument>[] pairs = new KeyValuePair <Location, DataDocument>[] { new KeyValuePair <Location, DataDocument>(new int[] { 0, 0 }, doc1), new KeyValuePair <Location, DataDocument>(new int[] { 0, 1 }, doc2), new KeyValuePair <Location, DataDocument>(new int[] { 0, 2 }, doc3), new KeyValuePair <Location, DataDocument>(new int[] { 1, 0 }, doc4), new KeyValuePair <Location, DataDocument>(new int[] { 1, 1 }, doc5), new KeyValuePair <Location, DataDocument>(new int[] { 1, 2 }, doc6), }; await redis.Put("grid-test", pairs); var firstRowDocs = await redis.Find("grid-test", new string[] { "0", "*" }).ToArrayAsync(); Assert.AreEqual(3, firstRowDocs.Length); var secondRowDocs = await redis.Find("grid-test", new string[] { "1", "*" }).ToArrayAsync(); Assert.AreEqual(3, secondRowDocs.Length); }
private string PartitionIdFormat <T>(Track.IdKey idKey) where T : IDataDocument { if (typeof(T).Equals(typeof(Tenant))) { return(Tenant.PartitionIdFormat()); } else if (typeof(T).Equals(typeof(Track))) { if (idKey == null) { new ArgumentNullException(nameof(idKey)); } return(Track.PartitionIdFormat(idKey)); } else { if (idKey == null) { new ArgumentNullException(nameof(idKey)); } return(DataDocument.PartitionIdFormat(idKey)); } }
private static void InternalUpdate(TDataType document, IStructuredDataDictionary <TDataType> tbl) { var fetchedData = tbl.Fetch(new string[] { DataDocument.GetDocumentId(document) }); if (!fetchedData.Any()) { throw new InstanceNotFoundException(); } var oldData = fetchedData.First().Data; var eTag = fetchedData.First().ETag; if (DataDocument.HasEtag <TDataType>()) { eTag = DataDocument.GetDocumentEtag(document); if (DataDocument.GetDocumentEtag(oldData) != eTag) { throw new DBConcurrencyException(); } } tbl.Update(DataDocument.GetDocumentId(document), document, eTag); }
public void Delete(TDataType document) { var id = DataDocument.GetDocumentId(document); IdDelete(id); }
public void ParseData(Schema schema) { data = DataDocument.ToData(schema, ReferencedIdsDeleted); }