private static async Task <PropertyListSetup> ReadPropertyListSetupAsync(Package package, Type model, string file)
{
using (ICacheDataProvider cacheDP = YetaWF.Core.IO.Caching.GetStaticSmallObjectCacheProvider()) {
// Check cache first
GetObjectInfo <PropertyListSetup> info = await cacheDP.GetAsync <PropertyListSetup>(file);
if (info.Success)
{
return(info.Data);
}
// Load the file
if (YetaWFManager.DiagnosticsMode) // to avoid exception spam
{
if (!await FileSystem.FileSystemProvider.FileExistsAsync(file))
{
PropertyListSetup setup = new PropertyListSetup {
ExplicitDefinitions = false,
};
await cacheDP.AddAsync <PropertyListSetup>(file, setup);// failure also saved in cache
return(setup);
}
}
string text;
try {
text = await FileSystem.FileSystemProvider.ReadAllTextAsync(file);
} catch (Exception) {
PropertyListSetup setup = new PropertyListSetup {
ExplicitDefinitions = false,
};
await cacheDP.AddAsync <PropertyListSetup>(file, setup);// failure also saved in cache
return(setup);
}
{
PropertyListSetup setup = Utility.JsonDeserialize <PropertyListSetup>(text);
setup.ExplicitDefinitions = true;
// save in cache
await cacheDP.AddAsync <PropertyListSetup>(file, setup);
return(setup);
}
}
}
private async Task <HelpFileInfo> TryHelpFileAsync(string url, bool useCache)
{
string file = Utility.UrlToPhysical(url);
using (ICacheDataProvider cacheDP = YetaWF.Core.IO.Caching.GetStaticSmallObjectCacheProvider()) {
// Check cache first
GetObjectInfo <HelpFileInfo> cache = await cacheDP.GetAsync <HelpFileInfo>(file);
if (cache.Success)
{
return(cache.Data);
}
// read file
if (!await FileSystem.FileSystemProvider.FileExistsAsync(file))
{
HelpFileInfo noInfo = new HelpFileInfo {
Contents = null,
Exists = false,
};
await cacheDP.AddAsync <HelpFileInfo>(file, noInfo);// failure also saved in cache
return(noInfo);
}
string contents = await FileSystem.FileSystemProvider.ReadAllTextAsync(file);
HelpFileInfo info = new HelpFileInfo {
Contents = contents,
Exists = true,
};
// save in cache
if (contents.Length < MAXSIZE && useCache)
{
await cacheDP.AddAsync <HelpFileInfo>(file, info);
}
return(info);
}
}
internal async Task <DesignedPagesDictionaryByUrl> GetDesignedPagesWithoutLockAsync()
{
if (!await DataProvider.IsInstalledAsync())
{
return(new DesignedPagesDictionaryByUrl());// don't save this, it's not permanent
}
using (ICacheDataProvider staticCacheDP = YetaWF.Core.IO.Caching.GetStaticCacheProvider()) {
DesignedPagesDictionaryByUrl data;
GetObjectInfo <DesignedPagesDictionaryByUrl> info = await staticCacheDP.GetAsync <DesignedPagesDictionaryByUrl>(DESIGNEDPAGESKEY);
if (!info.Success)
{
data = await DataProviderIOMode.GetDesignedPagesAsync();
await staticCacheDP.AddAsync(DESIGNEDPAGESKEY, data);
}
else
{
data = info.Data;
}
return(data);
}
}
public async Task <GetObjectInfo <TYPE> > GetAsync <TYPE>(string key)
{
key = KeyPrefix + key;
// get locally cached version
GetObjectInfo <LocalSharedCacheObject> localInfo;
using (ICacheDataProvider localCacheDP = YetaWF.Core.IO.Caching.GetLocalCacheProvider()) {
localInfo = await localCacheDP.GetAsync <LocalSharedCacheObject>(key);
if (!localInfo.Success)
{
// no locally cached data
localInfo = new GetObjectInfo <LocalSharedCacheObject> {
Data = new LocalSharedCacheObject {
Created = DateTime.MinValue,
Key = key,
Value = null,
},
Success = false,
};
}
// get shared cached version
IDatabase db = Redis.GetDatabase();
long? val;
if (YetaWFManager.IsSync())
{
val = (long?)db.StringGet(GetVersionKey(key));
}
else
{
val = (long?)await db.StringGetAsync(GetVersionKey(key));
}
if (val != null)
{
DateTime sharedCacheCreated = new DateTime((long)val);
if (sharedCacheCreated != localInfo.Data.Created)
{
// shared cached version is different, retrieve and save locally
byte[] sharedCacheData;
if (YetaWFManager.IsSync())
{
sharedCacheData = db.StringGet(GetDataKey(key));
}
else
{
sharedCacheData = await db.StringGetAsync(GetDataKey(key));
}
if (sharedCacheData == null) // this shouldn't happen, we just got the shared version
// return the local data instead
{
}
else
{
LocalSharedCacheObject localCacheObj = new LocalSharedCacheObject {
Created = sharedCacheCreated,
Key = key,
Value = sharedCacheData,
};
await localCacheDP.AddAsync(key, localCacheObj); // save as locally cached version
return(new GetObjectInfo <TYPE> {
Success = true,
Data = new GeneralFormatter().Deserialize <TYPE>(sharedCacheData),
});
}
}
else
{
// shared version same as local version
}
}
else
{
// there is no shared version
}
// return the local data
if (localInfo.Success)
{
return(new GetObjectInfo <TYPE> {
Success = true,
Data = new GeneralFormatter().Deserialize <TYPE>(localInfo.Data.Value),
});
}
else
{
return(new GetObjectInfo <TYPE> {
Success = false,
});
}
}
}
public async Task <GetObjectInfo <TYPE> > GetAsync <TYPE>(string key)
{
// get locally cached version
GetObjectInfo <LocalSharedCacheObject> localInfo;
using (ICacheDataProvider localCacheDP = YetaWF.Core.IO.Caching.GetLocalCacheProvider()) {
localInfo = await localCacheDP.GetAsync <LocalSharedCacheObject>(key);
if (!localInfo.Success)
{
// no locally cached data
localInfo = new GetObjectInfo <LocalSharedCacheObject> {
Data = new LocalSharedCacheObject {
Created = DateTime.MinValue,
Key = key,
Value = null,
},
Success = false,
};
}
// get shared cached version
SharedCacheVersion sharedInfo = await SharedCacheVersionPostgreSQLDataProvider.SharedCacheVersionDP.GetVersionAsync(key);
if (sharedInfo != null)
{
if (sharedInfo.Created != localInfo.Data.Created)
{
// shared cached version is different, retrieve and save locally
SharedCacheObject sharedCacheObj = await DataProvider.GetAsync(key);
if (sharedCacheObj == null) // this shouldn't happen, we just got the shared version
// return the local data instead
{
}
else
{
LocalSharedCacheObject localCacheObj = new LocalSharedCacheObject {
Created = sharedCacheObj.Created,
Key = sharedCacheObj.Key,
Value = sharedCacheObj.Value,
};
await localCacheDP.AddAsync(key, localCacheObj); // save as locally cached version
return(new GetObjectInfo <TYPE> {
Success = true,
Data = new GeneralFormatter().Deserialize <TYPE>(sharedCacheObj.Value),
});
}
}
else
{
// shared version same as local version
}
}
else
{
// there is no shared version
}
// return the local data
if (localInfo.Success)
{
return(new GetObjectInfo <TYPE> {
Success = true,
Data = new GeneralFormatter().Deserialize <TYPE>(localInfo.Data.Value),
});
}
else
{
return(new GetObjectInfo <TYPE> {
Success = false,
});
}
}
}
private static async Task <ReadGridDictionaryInfo> ReadGridDictionaryAsync(Package package, Type recordType, string file)
{
using (ICacheDataProvider cacheDP = YetaWF.Core.IO.Caching.GetStaticSmallObjectCacheProvider()) {
// Check cache first
GetObjectInfo <ReadGridDictionaryInfo> info = await cacheDP.GetAsync <ReadGridDictionaryInfo>(file);
if (info.Success)
{
return(info.Data);
}
// Load the file
Dictionary <string, GridColumnInfo> dict = new Dictionary <string, GridColumnInfo>();
if (YetaWFManager.DiagnosticsMode) // to avoid exception spam
{
if (!await FileSystem.FileSystemProvider.FileExistsAsync(file))
{
ReadGridDictionaryInfo dictInfo = new ReadGridDictionaryInfo {
ColumnInfo = dict,
SortColumn = null,
SortBy = GridDefinition.SortBy.NotSpecified,
Success = false,
};
await cacheDP.AddAsync <ReadGridDictionaryInfo>(file, dictInfo);// failure also saved in cache
return(dictInfo);
}
}
List <string> lines;
try {
lines = await FileSystem.FileSystemProvider.ReadAllLinesAsync(file);
} catch (Exception) {
ReadGridDictionaryInfo dictInfo = new ReadGridDictionaryInfo {
ColumnInfo = dict,
SortColumn = null,
SortBy = GridDefinition.SortBy.NotSpecified,
Success = false,
};
await cacheDP.AddAsync <ReadGridDictionaryInfo>(file, dictInfo);// failure also saved in cache
return(dictInfo);
}
// Parse the file
string sortCol = null;
GridDefinition.SortBy sortDir = GridDefinition.SortBy.NotSpecified;
Config config = null;
foreach (string line in lines)
{
string[] parts = line.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
GridColumnInfo gridCol = new GridColumnInfo();
int len = parts.Length;
if (len > 0)
{
bool add = true;
string name = parts[0];
if (name == "Config")
{
if (config != null)
{
throw new InternalError($"Only one Config statement can be used in {file}");
}
string rest = string.Join(" ", parts.Skip(1));
config = Utility.JsonDeserialize <Config>(rest);
continue;
}
for (int i = 1; i < len; ++i)
{
string part = GetPart(parts[i], package, recordType, file, name);
if (string.Compare(part, "sort", true) == 0)
{
gridCol.Sortable = true;
}
else if (string.Compare(part, "locked", true) == 0)
{
gridCol.Locked = true;
}
else if (string.Compare(part, "left", true) == 0)
{
gridCol.Alignment = GridHAlignmentEnum.Left;
}
else if (string.Compare(part, "center", true) == 0)
{
gridCol.Alignment = GridHAlignmentEnum.Center;
}
else if (string.Compare(part, "right", true) == 0)
{
gridCol.Alignment = GridHAlignmentEnum.Right;
}
else if (string.Compare(part, "hidden", true) == 0)
{
gridCol.Hidden = true;
}
else if (string.Compare(part, "onlysubmitwhenchecked", true) == 0)
{
gridCol.OnlySubmitWhenChecked = true;
}
else if (string.Compare(part, "icons", true) == 0)
{
int n = GetNextNumber(parts, i, part, file, name);
if (n < 1)
{
throw new InternalError("Icons must be >= 1 for column {0} in {1}", name, file);
}
gridCol.Icons = n;
gridCol.Alignment = GridHAlignmentEnum.Center;// default is centered
++i;
}
else if (string.Compare(part, "defaultSort", true) == 0)
{
sortCol = name;
part = GetNextPart(parts, i, part, file, name);
if (part == "asc")
{
sortDir = GridDefinition.SortBy.Ascending;
}
else if (part == "desc")
{
sortDir = GridDefinition.SortBy.Descending;
}
else
{
throw new InternalError("Missing Asc/Desc following defaultSort for column {1} in {2}", part, name, file);
}
++i;
}
else if (string.Compare(part, "internal", true) == 0)
{
bool showInternals = UserSettings.GetProperty <bool>("ShowInternals");
if (!showInternals)
{
add = false;
break;
}
}
else if (string.Compare(part, "filter", true) == 0)
{
if (gridCol.FilterOptions.Count > 0)
{
throw new InternalError("Multiple filter options in {0} for {1}", file, name);
}
gridCol.FilterOptions = GetAllFilterOptions();
}
else if (part.StartsWith("filter(", StringComparison.InvariantCultureIgnoreCase))
{
if (gridCol.FilterOptions.Count > 0)
{
throw new InternalError("Multiple filter options in {0} for {1}", file, name);
}
gridCol.FilterOptions = GetFilterOptions(part.Substring(6), file, name);
}
else if (part.EndsWith("pix", StringComparison.InvariantCultureIgnoreCase))
{
if (gridCol.ChWidth != 0)
{
throw new InternalError("Can't use character width and pixel width at the same time in {0} for {1}", file, name);
}
part = part.Substring(0, part.Length - 3);
int n = GetNumber(part, file, name);
gridCol.PixWidth = n;
}
else
{
if (gridCol.PixWidth != 0)
{
throw new InternalError("Can't use character width and pixel width at the same time in {0} for {1}", file, name);
}
int n = GetNumber(part, file, name);
gridCol.ChWidth = n;
}
}
if (add)
{
try {
dict.Add(name, gridCol);
} catch (Exception exc) {
throw new InternalError("Can't add {1} in {0} - {2}", file, name, ErrorHandling.FormatExceptionMessage(exc));
}
}
}
}
{
ReadGridDictionaryInfo dictInfo = new ReadGridDictionaryInfo {
ColumnInfo = dict,
SortBy = sortDir,
SortColumn = sortCol,
Success = true,
SaveColumnWidths = config != null ? config.SaveWidths : null,
SaveColumnFilters = config != null ? config.SaveFilters : null,
InitialPageSize = config != null ? config?.InitialPageSize : null,
PageSizes = config?.PageSizes,
ShowHeader = config?.ShowHeader,
ShowFilter = config?.ShowFilter,
ShowPager = config?.ShowPager,
SizeStyle = config?.SizeStyle,
};
// save in cache
await cacheDP.AddAsync <ReadGridDictionaryInfo>(file, dictInfo);
return(dictInfo);
}
}
}
