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);
}
