/// <summary>
/// Get Permissions
/// </summary>
/// <param name="userPermissionTable">user Permission table data</param>
/// <returns>Users permissions</returns>
public static List <ScreenAndPermissions> GetUserPermissionFromDataTable(DataTable userPermissionTable, string sessionUserId)
{
return(userPermissionTable.AsEnumerable()
.Select(result => new ScreenAndPermissions
{
ScreeenId = result.Field <int?>("screenId"),
ScreeenName = result.Field <string>("ScreenName"),
IsRead = result.Field <bool>("isRead"),
IsWrite = result.Field <bool>("isWrite"),
IsDelete = result.Field <bool>("canDelete"),
LinkIcon = result.Field <string>("linkIcon"),
LinkOrder = TypeConversionHelper.GetDefaultValueIfNull <int>(result.Field <int?>("linkOrder")),
ParentScreenId = TypeConversionHelper.GetDefaultValueIfNull <int>(result.Field <int?>("parentScreenId")),
SelectedLinkIconInSelectList = GetIconList <FontIcons>().Select(results => new SelectListItem
{
Text = results.Text,
Value = results.Value,
Selected = results.Value.Equals(result.Field <string>("linkIcon"), StringComparison.InvariantCultureIgnoreCase)
}),
SelectedParentScreenInSelectList = GetScreenList(sessionUserId).Select(results => new SelectListItem
{
Text = results.Text,
Value = results.Value,
Selected = results.Value.Equals(TypeConversionHelper.GetDefaultValueIfNull <string>(result.Field <int?>("parentScreenId")), StringComparison.InvariantCultureIgnoreCase)
}),
}).ToList());
}
static bool TypesAreStructurallyCompatible(TypeConversionHelper typeConverterHelper, ITypeSymbol contractType, ITypeSymbol inputType,
string path, ICollection <string> incompatibleProperties)
{
if (SymbolEqualityComparer.Default.Equals(inputType, contractType))
{
return(true);
}
List <IPropertySymbol> contractProperties = contractType.GetContractProperties();
List <IPropertySymbol> inputProperties = GetInputProperties(inputType);
var result = true;
foreach (var inputProperty in inputProperties)
{
var contractProperty = contractProperties.FirstOrDefault(m => m.Name == inputProperty.Name);
var propertyPath = Append(path, inputProperty.Name);
if (contractProperty == null)
{
if (!IsHeaderProperty(typeConverterHelper, inputProperty))
{
incompatibleProperties.Add(propertyPath);
result = false;
}
}
else if (!PropertyTypesAreStructurallyCompatible(typeConverterHelper, contractProperty, inputProperty, propertyPath, incompatibleProperties))
{
result = false;
}
}
return(result);
}
public void UpdateWithGetPreviousWorksAsExpected()
{
// --- Arrange
var db = new SqlDatabase(DB_CONN);
db.Execute(@"create table sample(Id int not null, Name varchar(50) null, Version rowversion not null)");
var record = new SampleRecordWithVersion {
Id = 1, Name = "First"
};
db.Insert(record);
// --- Act
record.Name = "NewFirst";
var prevRecord = db.UpdateAndGetPrevious(record);
// --- Assert
var current = db.FirstOrDefault <SampleRecordWithVersion>("where Id = @0", record.Id);
current.ShouldNotBeNull();
prevRecord.Id.ShouldEqual(record.Id);
prevRecord.Name.ShouldEqual("First");
current.Name.ShouldEqual("NewFirst");
TypeConversionHelper.ByteArrayToString(prevRecord.Version)
.ShouldNotEqual(TypeConversionHelper.ByteArrayToString(current.Version));
}
public async Task UpdateWithGetCurrentAsyncWorksAsExpected()
{
// --- Arrange
var db = new SqlDatabase(DB_CONN);
await db.ExecuteAsync(@"create table sample(Id int not null, Name varchar(50) null, Version rowversion not null)");
var record = new SampleRecordWithVersion {
Id = 1, Name = "First"
};
await db.InsertAsync(record);
// --- Act
record.Name = "NewFirst";
var currentRecord = await db.UpdateAndGetCurrentAsync(record);
// --- Assert
var back = await db.FirstOrDefaultAsync <SampleRecordWithVersion>("where Id = @0", record.Id);
back.ShouldNotBeNull();
currentRecord.Id.ShouldEqual(record.Id);
currentRecord.Name.ShouldEqual("NewFirst");
back.Name.ShouldEqual("NewFirst");
TypeConversionHelper.ByteArrayToString(currentRecord.Version)
.ShouldEqual(TypeConversionHelper.ByteArrayToString(back.Version));
}
public void ByteArrayToStringWorksAsExpected()
{
// --- Arrange
var byteArr = new byte[] { 0xAE, 0x23, 0x1F };
// --- Act/Assert
TypeConversionHelper.ByteArrayToString(byteArr).ShouldEqual("0xAE231F");
}
/// <summary>
/// Get Available Budget Category
/// </summary>
/// <param name="budgetRepository">Budget Repository</param>
/// <returns>Category List</returns>
internal static IEnumerable <SelectListItem> GetAvailableBudgetCategory(IBudgetRepository budgetRepository)
{
return(budgetRepository.GetAvailableBudgetCategory().Tables[0].AsEnumerable().Select(result => new SelectListItem
{
Text = result.Field <string>("CategoryName"),
Value = TypeConversionHelper.GetDefaultValueIfNull <string>(result.Field <int>("CategoryId"))
}));
}
/// <summary>
/// Reload Model on model state error
/// </summary>
/// <param name="transactionViewModel">The transaction view model.</param>
/// <param name="expenseRepository">The expense repository.</param>
/// <returns>Model with expense and users.</returns>
internal static TransactionViewModel ReloadModelOnError(TransactionViewModel transactionViewModel, IExpenseRepository expenseRepository)
{
transactionViewModel.Expenses = expenseRepository.GetAllMyExpenses().Tables[0].AsEnumerable().Select(expenses => new SelectListItem
{
Text = expenses.Field <string>("Description"),
Value = TypeConversionHelper.GetDefaultValueIfNull <string>(expenses.Field <int>("ExpenseId"))
});
transactionViewModel.UsersInExpense = new List <SelectListItem>().AsEnumerable();
return(transactionViewModel);
}
/// <summary>
/// Tries to convert the value to the property type.
/// </summary>
/// <param name="memberExpression">The member expression</param>
/// <param name="value">The value</param>
/// <param name="culture">The culture</param>
/// <returns>The value or the converted value</returns>
public object TryConvert(MemberExpression memberExpression, object value, CultureInfo culture)
{
if (value == null)
{
return(value);
}
var propertyType = ((PropertyInfo)memberExpression.Member).PropertyType;
return(TypeConversionHelper.TryConvert(propertyType, value, culture));
}
internal LLVMValueRef ProcessStore(FunctionContext funcContext, LLVMValueRef lval, LLVMValueRef rval)
{
var lvalType = lval.TypeOf();
var rvalType = rval.TypeOf();
if (!lvalType.Equals(LLVM.GetElementType(rvalType)))
{
lval = TypeConversionHelper.AutoCast(funcContext.Builder, lval, rvalType.GetElementType());
}
Context.CLRLogger.Debug(lval.ToString());
Context.CLRLogger.Debug(rval.ToString());
return(LLVM.BuildStore(funcContext.Builder, lval, rval));
}
/// <summary>
/// Load Lookup data
/// </summary>
/// <typeparam name="TInput1">Input Type 1</typeparam>
/// <typeparam name="TInput2">Input Type 2</typeparam>
/// <param name="dropDownLookUpTable">Input Table</param>
/// <param name="field1">Table Column 1</param>
/// <param name="field2">Table Column 2</param>
/// <param name="selectedItem">Selected Item</param>
/// <returns>Selected List Item</returns>
public static IEnumerable <SelectListItem> LoadLookUps <TInput1, TInput2>(this DataTable dropDownLookUpTable, string field1 = "Text", string field2 = "Value", string selectedItem = "")
{
if (dropDownLookUpTable == null)
{
return(new List <SelectListItem>().AsEnumerable());
}
return(dropDownLookUpTable.AsEnumerable().Select(results => new SelectListItem
{
Text = TypeConversionHelper.GetDefaultValueIfNull <string>(results.Field <TInput1>(field1)),
Value = TypeConversionHelper.GetDefaultValueIfNull <string>(results.Field <TInput2>(field2)),
Selected = TypeConversionHelper.GetDefaultValueIfNull <string>(results.Field <TInput2>(field2)).Equals(selectedItem),
}));
}
public void Converts_With_ConvertChangeType()
{
// numbers
Assert.AreEqual((int)10, TypeConversionHelper.ConvertWithChangeType(typeof(int), "10", CultureInfo.InvariantCulture));
Assert.AreEqual((short)10, TypeConversionHelper.ConvertWithChangeType(typeof(short), "10", CultureInfo.InvariantCulture));
Assert.AreEqual((uint)10, TypeConversionHelper.ConvertWithChangeType(typeof(uint), "10", CultureInfo.InvariantCulture));
Assert.AreEqual((double)10.5, TypeConversionHelper.ConvertWithChangeType(typeof(double), "10.5", CultureInfo.InvariantCulture));
// bool
Assert.AreEqual(true, TypeConversionHelper.ConvertWithChangeType(typeof(bool), "true", CultureInfo.InvariantCulture));
Assert.AreEqual(true, TypeConversionHelper.ConvertWithChangeType(typeof(bool), "true", CultureInfo.InvariantCulture));
// Fails on enum, nullables, uri, timespan, brush, ...
// enum
//Assert.AreEqual(MyEnum.Two, TypeConversionHelper.ConvertWithChangeType(typeof(MyEnum), "1", CultureInfo.InvariantCulture));
//Assert.AreEqual(MyEnum.Two, TypeConversionHelper.ConvertWithChangeType(typeof(MyEnum), "Two", CultureInfo.InvariantCulture));
// nullables
//Assert.AreEqual((int?)10, TypeConversionHelper.ConvertWithChangeType(typeof(int?), "10", CultureInfo.InvariantCulture));
//Assert.AreEqual(true, TypeConversionHelper.ConvertWithChangeType(typeof(bool?), "true", CultureInfo.InvariantCulture));
//Assert.AreEqual(MyEnum.Two, TypeConversionHelper.ConvertWithChangeType(typeof(MyEnum?), "1", CultureInfo.InvariantCulture));
//Assert.AreEqual(MyEnum.Two, TypeConversionHelper.ConvertWithChangeType(typeof(MyEnum?), "Two", CultureInfo.InvariantCulture));
// dattetime
var date = new DateTime(2019, 07, 18);
var dateAsString = date.ToString(CultureInfo.InvariantCulture); // 18/07/2019 00:00:00 => invariant 07/18/2019 00:00:00
Assert.AreEqual(date, TypeConversionHelper.ConvertWithChangeType(typeof(DateTime), dateAsString, CultureInfo.InvariantCulture));
var dateAsStringFr = date.ToString(CultureInfo.GetCultureInfo("fr")); // 18/07/2019 00:00:00
Assert.AreEqual(date, TypeConversionHelper.ConvertWithChangeType(typeof(DateTime), dateAsStringFr, CultureInfo.GetCultureInfo("fr")));
// uri
// Assert.AreEqual(new Uri("http://mysite.com/"), TypeConversionHelper.ConvertWithChangeType(typeof(Uri), "http://mysite.com/", CultureInfo.GetCultureInfo("fr")));
// guid
//var guid = Guid.NewGuid();
//Assert.AreEqual(guid, TypeConversionHelper.ConvertWithChangeType(typeof(Guid), guid.ToString(), CultureInfo.InvariantCulture));
// timespan
//var ts = new TimeSpan(10, 32, 28);
//Assert.AreEqual(ts, TypeConversionHelper.ConvertWithChangeType(typeof(TimeSpan), ts.ToString(), CultureInfo.InvariantCulture));
// char
Assert.AreEqual('c', TypeConversionHelper.ConvertWithChangeType(typeof(char), "c", CultureInfo.InvariantCulture));
// byte[]
// Assert.AreEqual(new byte[] { 1, 2, 3, 4 }, TypeConversionHelper.ConvertWithChangeType(typeof(byte[]), "\"AQIDBA==\"", CultureInfo.InvariantCulture));
// brush
//Assert.AreEqual("#FFFF0000", TypeConversionHelper.ConvertWithChangeType(typeof(Brush), "Red", CultureInfo.InvariantCulture).ToString());
}
// <summary>
// Get the list of application users
// </summary>
// <returns>Dictionary object of user list</returns>
public Dictionary <string, string> GetAllApplicationUsers()
{
object[] objUserParameter = new object[1];
objUserParameter[0] = userSession.CompanyId;
Dictionary <string, string> userList = new Dictionary <string, string>();
SqlDataReader userListReader = DataLibrary.ExecuteReaderSql(ref objUserParameter, "bspGetApplicationUsers");
while (userListReader.Read())
{
userList.Add(TypeConversionHelper.GetDefaultValueIfNull <string>(userListReader["UserId"]), TypeConversionHelper.GetDefaultValueIfNull <string>(userListReader["DisplayName"]));
}
return(userList);
}
public ActionResult Create()
{
TransactionViewModel transactionViewModel = new TransactionViewModel
{
Expenses = this.expenseRepository.GetAllMyExpenses().Tables[0].AsEnumerable().Select(expenses => new SelectListItem
{
Text = expenses.Field <string>("Description"),
Value = TypeConversionHelper.GetDefaultValueIfNull <string>(expenses.Field <int>("ExpenseId"))
}),
UsersInExpense = new List <SelectListItem>().AsEnumerable(),
};
return(View("Create", transactionViewModel));
}
/// <summary>
/// Gets the Text Box with action permissions
/// </summary>
/// <typeparam name="TModel">Model type</typeparam>
/// <typeparam name="TProperty">Property type</typeparam>
/// <param name="htmlHelper">Html helper</param>
/// <param name="expression">Expression</param>
/// <param name="htmlAttributes">Html attributes</param>
/// <returns>Html string</returns>
public static MvcHtmlString TextBoxWithPermissionFor <TModel, TProperty>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TProperty> > expression, object htmlAttributes)
{
var isWritableSession = HttpContext.Current.Session["IsWritable"];
bool isWritable = isWritableSession != null?TypeConversionHelper.GetDefaultValueIfNull <bool>(isWritableSession) : false;
if (isWritable)
{
return(System.Web.Mvc.Html.InputExtensions.TextBoxFor <TModel, TProperty>(htmlHelper, expression,
htmlAttributes: htmlAttributes));
}
ModelMetadata fieldmetadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
return(new MvcHtmlString(Convert.ToString(fieldmetadata.Model)));
}
public void CanConvertToStringWorksAsExpected()
{
// --- Arrange
TypeConverter conv1;
TypeConverter conv2;
// --- Act
var canConvert1 = TypeConversionHelper.CanConvertToString(new MyType(), out conv1);
var canConvert2 = TypeConversionHelper.CanConvertToString(123, out conv2);
// --- Assert
canConvert1.ShouldBeTrue();
conv1.ShouldNotBeNull();
canConvert2.ShouldBeTrue();
conv2.ShouldNotBeNull();
}
/// <summary>
/// Load Lookup data
/// </summary>
/// <typeparam name="TInput1">Input Type 1</typeparam>
/// <typeparam name="TInput2">Input Type 2</typeparam>
/// <param name="dropDownLookUpTable">Input Table</param>
/// <param name="selectedItem">Selected Item</param>
/// <returns>Selected List Item</returns>
public static IEnumerable <SelectListItem> LoadLookUps <TInput1, TInput2>(this DataTable dropDownLookUpTable, string selectedItem)
{
string field1 = "Text";
string field2 = "Value";
if (dropDownLookUpTable == null)
{
return(new List <SelectListItem>().AsEnumerable());
}
return(dropDownLookUpTable.AsEnumerable().Select(results => new SelectListItem
{
Text = TypeConversionHelper.GetDefaultValueIfNull <string>(results.Field <TInput1>(field1)),
Value = TypeConversionHelper.GetDefaultValueIfNull <string>(results.Field <TInput2>(field2)),
Selected = TypeConversionHelper.GetDefaultValueIfNull <string>(results.Field <TInput2>(field2)).Equals(selectedItem, System.StringComparison.InvariantCultureIgnoreCase),
}));
}
/// <summary>
/// Initializes the primary key value with the specified elements
/// </summary>
public PrimaryKeyValue(IEnumerable <object> pkValues)
{
// --- Obtain the primary key elements
KeyElement = new ReadOnlyCollection <object>(
pkValues.ToList());
// --- Create the primary key string
var sb = new StringBuilder();
foreach (var element in KeyElement)
{
var byteArrElement = element as byte[];
sb.AppendFormat("[{0}]", byteArrElement == null
? element.ToString()
: TypeConversionHelper.ByteArrayToString(byteArrElement));
}
KeyString = sb.ToString();
}
static bool?EnumerableTypesAreStructurallyCompatible(TypeConversionHelper typeConverterHelper, IPropertySymbol contractProperty, IPropertySymbol inputProperty,
string path, ICollection <string> incompatibleProperties)
{
if (contractProperty.Type.IsImmutableArray(out var contractElementType) ||
contractProperty.Type.IsList(out contractElementType) ||
contractProperty.Type.IsArray(out contractElementType) ||
contractProperty.Type.IsCollection(out contractElementType))
{
if (inputProperty.Type.IsImmutableArray(out var inputElementType) ||
inputProperty.Type.IsList(out inputElementType) ||
inputProperty.Type.IsArray(out inputElementType) ||
inputProperty.Type.IsCollection(out inputElementType))
{
if (!ElementTypesAreStructurallyCompatible(typeConverterHelper, contractElementType, inputElementType, path, incompatibleProperties))
{
return(false);
}
}
/// <summary>
/// Gets the dropdown list with action permission
/// </summary>
/// <typeparam name="TModel">Model type.</typeparam>
/// <typeparam name="TProperty">Property type.</typeparam>
/// <param name="htmlHelper">Html helper</param>
/// <param name="optionLabel">Option label</param>
/// <param name="expression">Expression to evaluate.</param>
/// <param name="selectList">Select list</param>
/// <param name="selectedItem">Selected item.</param>
/// <param name="iconClass">Icon class</param>
/// <param name="htmlAttributes">Html attributes.</param>
/// <returns>Dropdown list</returns>
public static MvcHtmlString DropDownListWithPermission <TModel, TProperty>(this HtmlHelper <TModel> htmlHelper, string optionLabel, Expression <Func <TModel, TProperty> > expression, IEnumerable <SelectListItem> selectList, string selectedItem, string iconClass, object htmlAttributes)
{
var isWritableSession = HttpContext.Current.Session["IsWritable"];
bool isWritable = isWritableSession != null?TypeConversionHelper.GetDefaultValueIfNull <bool>(isWritableSession) : false;
if (isWritable)
{
return(SelectExtensions.DropDownListFor(htmlHelper, expression, selectList, optionLabel, htmlAttributes));
}
StringBuilder outputHtmlString = new StringBuilder();
if (!string.IsNullOrWhiteSpace(iconClass))
{
outputHtmlString.AppendLine("<i class='" + HttpUtility.HtmlEncode(iconClass) + "'></i>");
}
outputHtmlString.AppendLine(selectedItem);
return(new MvcHtmlString(outputHtmlString.ToString()));
}
/// <summary>
/// Load Look ups to dictionary
/// </summary>
/// <typeparam name="TInput1">Input Type 1</typeparam>
/// <typeparam name="TInput2">Input Type 2</typeparam>
/// <param name="dropDownLookUpTable">Input Table</param>
/// <param name="field1">Table Column 1</param>
/// <param name="field2">Table Column 2</param>
/// <param name="selectedItem">Selected Item</param>
/// <returns>Look up data as dictionary object</returns>
public static Dictionary <TInput1, TInput2> LoadLookUpsDictionary <TInput1, TInput2>(this DataTable dropDownLookUpTable, string field1 = "Text", string field2 = "Value", string selectedItem = "")
{
if (dropDownLookUpTable == null)
{
return(new Dictionary <TInput1, TInput2>());
}
DataTableReader lookUpDictionaryReader = dropDownLookUpTable.CreateDataReader();
Dictionary <TInput1, TInput2> lookUpDictionary = new Dictionary <TInput1, TInput2>();
while (lookUpDictionaryReader.Read())
{
lookUpDictionary.Add(TypeConversionHelper.GetDefaultValueIfNull <TInput1>(lookUpDictionaryReader[field1]), TypeConversionHelper.GetDefaultValueIfNull <TInput2>(lookUpDictionaryReader[field2]));
}
// return dropDownLookUpTable.AsEnumerable().ToDictionary<DataRow, TInput1, TInput2>(row => row.Field<TInput1>(field1),
// row => row.Field<TInput2>(field2));
return(lookUpDictionary);
}
static bool PropertyTypesAreStructurallyCompatible(TypeConversionHelper typeConverterHelper, IPropertySymbol contractProperty, IPropertySymbol inputProperty,
string path, ICollection <string> incompatibleProperties)
{
if (typeConverterHelper.CanConvert(contractProperty.Type, inputProperty.Type))
{
return(true);
}
var result = AnonymousTypeAndInterfaceAreStructurallyCompatible(typeConverterHelper, contractProperty, inputProperty, path, incompatibleProperties)
?? EnumerableTypesAreStructurallyCompatible(typeConverterHelper, contractProperty, inputProperty, path, incompatibleProperties)
?? DictionaryTypesAreStructurallyCompatible(typeConverterHelper, contractProperty, inputProperty, path, incompatibleProperties);
if (result.HasValue)
{
return(result.Value);
}
incompatibleProperties.Add(path);
return(false);
}
/// <summary>
/// Check is user has access to screen
/// </summary>
/// <param name="userId">Currently logged in user's Id </param>
/// <param name="screenParameters">Screen url parameters</param>
/// <returns>True if user has access else false</returns>
public bool CheckIsUserHasAccessOnScreen(string userId, SharedAssembly.ScreenRoute screenParameters)
{
object[] objAppScreens = new object[5];
objAppScreens[0] = userId;
objAppScreens[1] = screenParameters.ActionName;
objAppScreens[2] = screenParameters.ControllerName;
objAppScreens[3] = screenParameters.AreaName;
objAppScreens[4] = userSession.CompanyId;
bool isReadable = false;
SqlDataReader userPermissionReader = DataLibrary.ExecuteReaderSql(ref objAppScreens, "bspIsUserHasAccess");
while (userPermissionReader.Read())
{
isReadable = TypeConversionHelper.GetDefaultValueIfNull <bool>(userPermissionReader["isRead"]);
permissionHelper.SetPermission(isReadable,
TypeConversionHelper.GetDefaultValueIfNull <bool>(userPermissionReader["isWrite"]),
TypeConversionHelper.GetDefaultValueIfNull <bool>(userPermissionReader["isDelete"]));
}
return(isReadable);
}
public void Can_Converts_With_ConvertChangeType()
{
// https://referencesource.microsoft.com/#mscorlib/system/convert.cs,fc990bd1275d43d6
// numbers
Assert.AreEqual(true, TypeConversionHelper.CanConvertWithChangeType(typeof(int)));
Assert.AreEqual(true, TypeConversionHelper.CanConvertWithChangeType(typeof(short)));
Assert.AreEqual(true, TypeConversionHelper.CanConvertWithChangeType(typeof(uint)));
Assert.AreEqual(true, TypeConversionHelper.CanConvertWithChangeType(typeof(double)));
Assert.AreEqual(true, TypeConversionHelper.CanConvertWithChangeType(typeof(byte)));
Assert.AreEqual(true, TypeConversionHelper.CanConvertWithChangeType(typeof(sbyte)));
// bool
Assert.AreEqual(true, TypeConversionHelper.CanConvertWithChangeType(typeof(bool)));
// Fails on enum, nullables, uri, timespan, brush, ...
// enum
Assert.AreEqual(false, TypeConversionHelper.CanConvertWithChangeType(typeof(MyEnum)));
// nullables
Assert.AreEqual(false, TypeConversionHelper.CanConvertWithChangeType(typeof(int?)));
Assert.AreEqual(false, TypeConversionHelper.CanConvertWithChangeType(typeof(short?)));
Assert.AreEqual(false, TypeConversionHelper.CanConvertWithChangeType(typeof(bool?)));
// dattetime
Assert.AreEqual(true, TypeConversionHelper.CanConvertWithChangeType(typeof(DateTime)));
// uri
Assert.AreEqual(false, TypeConversionHelper.CanConvertWithChangeType(typeof(Uri)));
// Assert.AreEqual(new Uri("http://mysite.com/"), TypeConversionHelper.ConvertWithChangeType(typeof(Uri), "http://mysite.com/", CultureInfo.GetCultureInfo("fr")));
// guid
Assert.AreEqual(false, TypeConversionHelper.CanConvertWithChangeType(typeof(Guid)));
// timespan
//var ts = new TimeSpan(10, 32, 28);
//Assert.AreEqual(ts, TypeConversionHelper.ConvertWithChangeType(typeof(TimeSpan), ts.ToString(), CultureInfo.InvariantCulture));
// char
Assert.AreEqual(true, TypeConversionHelper.CanConvertWithChangeType(typeof(char)));
Assert.AreEqual(false, TypeConversionHelper.CanConvertWithChangeType(typeof(Brush)));
}
public static object ReadAttribute(long locationId, string attributeName)
{
long attributeId = -1;
long typeId = -1;
object result;
try
{
attributeId = H5A.open(locationId, attributeName);
if (H5I.is_valid(attributeId) <= 0)
{
throw new Exception(ErrorMessage.IOHelper_CouldNotOpenAttribute);
}
typeId = H5A.get_type(attributeId);
// invoke HdfHelper.Read
result = GeneralHelper.InvokeGenericMethod(typeof(IOHelper), null, nameof(IOHelper.Read),
BindingFlags.Public | BindingFlags.Static,
TypeConversionHelper.GetTypeFromHdfTypeId(typeId),
new object[] { attributeId, DataContainerType.Attribute, Type.Missing });
}
finally
{
if (H5I.is_valid(typeId) > 0)
{
H5T.close(typeId);
}
if (H5I.is_valid(attributeId) > 0)
{
H5A.close(attributeId);
}
}
return(result);
}
static bool?AnonymousTypeAndInterfaceAreStructurallyCompatible(TypeConversionHelper typeConverterHelper, IPropertySymbol contractProperty, IPropertySymbol inputProperty,
string path, ICollection <string> incompatibleProperties)
{
if (inputProperty.Type.IsAnonymousType)
{
if (contractProperty.Type.TypeKind.IsClassOrInterface())
{
if (!TypesAreStructurallyCompatible(typeConverterHelper, contractProperty.Type,
inputProperty.Type, path, incompatibleProperties))
{
return(false);
}
}
else
{
incompatibleProperties.Add(path);
return(false);
}
return(true);
}
return(null);
}
/// <summary>
/// Executes the action.
/// </summary>
protected override void Invoke()
{
if (TargetObject == null)
{
throw new ArgumentException("No TargetObject provided");
}
if (PropertyPath == null)
{
throw new ArgumentException("No PropertyPath provided");
}
if (this.property == null)
{
this.property = ResolveProperty();
}
var value = TypeConversionHelper.TryConvert(property.PropertyType, Value, Culture);
var owner = PropertyPathHelper.GetOwner(TargetObject, PropertyPath);
if (owner != null) // a sub property can be null if not instantied
{
property.SetValue(owner, value);
}
}
/// <summary>
/// Is Readable
/// </summary>
/// <param name="htmlhelper">Html helper</param>
/// <returns>Is Readable or not</returns>
public static bool IsDeletable(this HtmlHelper htmlhelper)
{
var isDeletableSession = HttpContext.Current.Session["IsDeletable"];
return(isDeletableSession != null?TypeConversionHelper.GetDefaultValueIfNull <bool>(isDeletableSession) : false);
}
public Task <string> GetData(DateTime dateTimeBegin, DateTime dateTimeEnd, string sampleRateDescription, FileFormat fileFormat, FileGranularity fileGranularity, Dictionary <string, Dictionary <string, List <string> > > campaignInfoSet)
{
long fileId = -1;
long datasetId = -1;
ulong start;
ulong stride;
ulong block;
ulong count;
ulong segmentLength;
ulong segmentSize;
ulong bytesPerRow;
double sampleRate;
DateTime epochStart;
DateTime epochEnd;
string zipFilePath;
// task
return(Task.Run(() =>
{
this.CheckState();
if (!campaignInfoSet.Any())
{
return string.Empty;
}
// zip file
zipFilePath = Path.Combine(_options.SupportDirectoryPath, "EXPORT", $"OneDAS_{ dateTimeBegin.ToString("yyyy-MM-ddTHH-mm") }_{ sampleRateDescription }_{ Guid.NewGuid().ToString() }.zip");
// sampleRate
sampleRate = sampleRateDescription.ToSampleRate();
// epoch & hyperslab
epochStart = new DateTime(2000, 01, 01);
epochEnd = new DateTime(2030, 01, 01);
if (!(epochStart <= dateTimeBegin && dateTimeBegin <= dateTimeEnd && dateTimeEnd <= epochEnd))
{
throw new Exception("requirement >> epochStart <= dateTimeBegin && dateTimeBegin <= dateTimeEnd && dateTimeBegin <= epochEnd << is not matched");
}
start = (ulong)(Math.Floor((dateTimeBegin - epochStart).TotalSeconds * sampleRate));
stride = 1;
block = (ulong)(Math.Ceiling((dateTimeEnd - dateTimeBegin).TotalSeconds * sampleRate));
count = 1;
try
{
// open file
fileId = H5F.open(_options.VdsFilePath, H5F.ACC_RDONLY);
// byte count
bytesPerRow = 0;
foreach (var campaignInfo in campaignInfoSet)
{
foreach (var variableInfo in campaignInfo.Value)
{
foreach (string datasetInfo in variableInfo.Value)
{
try
{
datasetId = H5D.open(fileId, $"{ campaignInfo.Key }/{ variableInfo.Key }/{ datasetInfo }");
bytesPerRow += (ulong)OneDasUtilities.SizeOf(TypeConversionHelper.GetTypeFromHdfTypeId(H5D.get_type(datasetId)));
}
finally
{
if (H5I.is_valid(datasetId) > 0)
{
H5D.close(datasetId);
}
}
}
}
}
this.GetClient().SendByteCount(bytesPerRow * block);
segmentSize = (50 * 1024 * 1024) / bytesPerRow * bytesPerRow;
segmentLength = segmentSize / bytesPerRow;
// ensure that dataset length is multiple of 1 minute
if ((segmentLength / sampleRate) % 60 != 0)
{
segmentLength = (ulong)((ulong)(segmentLength / sampleRate / 60) * 60 * sampleRate);
}
// start
_stateManager.SetState(this.Context.ConnectionId, HdfExplorerState.Loading);
using (ZipArchive zipArchive = ZipFile.Open(zipFilePath, ZipArchiveMode.Create))
{
foreach (var campaignInfo in campaignInfoSet)
{
HdfDataLoader hdfDataLoader;
hdfDataLoader = new HdfDataLoader(_stateManager.GetToken(this.Context.ConnectionId));
hdfDataLoader.ProgressUpdated += this.OnProgressUpdated;
if (!hdfDataLoader.WriteZipFileCampaignEntry(zipArchive, fileGranularity, fileFormat, new ZipSettings(dateTimeBegin, campaignInfo, fileId, sampleRate, start, stride, block, count, segmentLength)))
{
return string.Empty;
}
}
}
}
catch (Exception ex)
{
this.WriteLogEntry(ex.Message, true);
throw;
}
finally
{
_stateManager.SetState(this.Context.ConnectionId, HdfExplorerState.Idle);
if (H5I.is_valid(fileId) > 0)
{
H5F.close(fileId);
}
}
this.WriteLogEntry($"{ this.Context.GetHttpContext().Connection.RemoteIpAddress } requested data: { dateTimeBegin.ToString("yyyy-MM-dd HH:mm:ss") } to { dateTimeEnd.ToString("yyyy-MM-dd HH:mm:ss") }", false);
return $"download/{ Path.GetFileName(zipFilePath) }";
}, _stateManager.GetToken(this.Context.ConnectionId)));
}
public override BuildResult Build(Instruction instruction, FunctionContext funcContext)
{
if (instruction.OpCode == OpCodes.Clt)
{
var rval = funcContext.BuilderStack.Pop().ValRef.Value;
var lval = funcContext.BuilderStack.Pop().ValRef.Value;
var rvalType = rval.TypeOf();
var lvalType = lval.TypeOf();
if (!rvalType.Equals(lvalType))
{
rval = TypeConversionHelper.AutoCast(funcContext.Builder, rval, lvalType);
}
LLVMValueRef cmp;
if (lvalType.TypeKind == LLVMTypeKind.LLVMIntegerTypeKind)
{
cmp = LLVM.BuildICmp(funcContext.Builder, LLVMIntPredicate.LLVMIntSLT, lval, rval, "clt");
}
else if (lvalType.TypeKind == LLVMTypeKind.LLVMFloatTypeKind)
{
cmp = LLVM.BuildFCmp(funcContext.Builder, LLVMRealPredicate.LLVMRealOLT, lval, rval, "clt");
}
else if (lvalType.TypeKind == LLVMTypeKind.LLVMDoubleTypeKind)
{
cmp = LLVM.BuildFCmp(funcContext.Builder, LLVMRealPredicate.LLVMRealOLT, lval, rval, "clt");
}
else
{
throw new NotImplementedException(
$"No comparision supported for those types: {lval} < {rval}");
}
funcContext.BuilderStack.Push(new BuilderStackItem(MiniBCL.Int32Type, cmp));
return(new BuildResult(true));
}
if (instruction.OpCode == OpCodes.Cgt)
{
var rval = funcContext.BuilderStack.Pop().ValRef.Value;
var lval = funcContext.BuilderStack.Pop().ValRef.Value;
var rvalType = rval.TypeOf();
var lvalType = lval.TypeOf();
if (!rvalType.Equals(lvalType))
{
rval = TypeConversionHelper.AutoCast(funcContext.Builder, rval, lvalType);
}
LLVMValueRef cmp;
if (lvalType.TypeKind == LLVMTypeKind.LLVMIntegerTypeKind)
{
cmp = LLVM.BuildICmp(funcContext.Builder, LLVMIntPredicate.LLVMIntSGT, lval, rval, "cgt");
}
else if (lvalType.TypeKind == LLVMTypeKind.LLVMFloatTypeKind)
{
cmp = LLVM.BuildFCmp(funcContext.Builder, LLVMRealPredicate.LLVMRealOGT, lval, rval, "cgt");
}
else if (lvalType.TypeKind == LLVMTypeKind.LLVMDoubleTypeKind)
{
cmp = LLVM.BuildFCmp(funcContext.Builder, LLVMRealPredicate.LLVMRealUGT, lval, rval, "cgt");
}
else
{
throw new NotImplementedException(
$"No comparision supported for those types: {lval} < {rval}");
}
funcContext.BuilderStack.Push(new BuilderStackItem(MiniBCL.Int32Type, cmp));
return(new BuildResult(true));
}
if (instruction.OpCode == OpCodes.Ceq)
{
var rval = funcContext.BuilderStack.Pop().ValRef.Value;
var lval = funcContext.BuilderStack.Pop().ValRef.Value;
var rvalType = rval.TypeOf();
var lvalType = lval.TypeOf();
if (!rvalType.Equals(lvalType))
{
rval = TypeConversionHelper.AutoCast(funcContext.Builder, rval, lvalType);
}
LLVMValueRef cmp;
if (lvalType.TypeKind == LLVMTypeKind.LLVMIntegerTypeKind)
{
cmp = LLVM.BuildICmp(funcContext.Builder, LLVMIntPredicate.LLVMIntEQ, lval, rval, "ceq");
}
else if (lvalType.TypeKind == LLVMTypeKind.LLVMFloatTypeKind)
{
cmp = LLVM.BuildFCmp(funcContext.Builder, LLVMRealPredicate.LLVMRealOEQ, lval, rval, "ceq");
}
else if (lvalType.TypeKind == LLVMTypeKind.LLVMDoubleTypeKind)
{
cmp = LLVM.BuildFCmp(funcContext.Builder, LLVMRealPredicate.LLVMRealOEQ, lval, rval, "ceq");
}
else
{
throw new NotImplementedException(
$"No comparision supported for those types: {lval} == {rval}");
}
funcContext.BuilderStack.Push(new BuilderStackItem(MiniBCL.Int32Type, cmp));
return(new BuildResult(true));
}
return(new BuildResult(false));
}
static bool TypesAreStructurallyCompatible(TypeConversionHelper typeConverterHelper, ITypeSymbol contractType, ITypeSymbol inputType,
string path, ICollection <string> incompatibleProperties)
{
if (SymbolEqualityComparer.Default.Equals(inputType, contractType))
{
return(true);
}
List <IPropertySymbol> contractProperties = contractType.GetContractProperties();
List <IPropertySymbol> inputProperties = GetInputProperties(inputType);
var result = true;
foreach (var inputProperty in inputProperties)
{
var contractProperty = contractProperties.FirstOrDefault(m => m.Name == inputProperty.Name);
if (contractProperty == null)
{
if (!IsHeaderProperty(typeConverterHelper, inputProperty))
{
incompatibleProperties.Add(Append(path, inputProperty.Name));
result = false;
}
}
else if (!typeConverterHelper.CanConvert(contractProperty.Type, inputProperty.Type))
{
if (inputProperty.Type.IsAnonymousType)
{
if (contractProperty.Type.TypeKind.IsClassOrInterface())
{
if (!TypesAreStructurallyCompatible(typeConverterHelper, contractProperty.Type,
inputProperty.Type, Append(path, inputProperty.Name), incompatibleProperties))
{
result = false;
}
}
else
{
incompatibleProperties.Add(Append(path, inputProperty.Name));
result = false;
}
}
else if (contractProperty.Type.IsImmutableArray(out var contractElementType) ||
contractProperty.Type.IsList(out contractElementType) ||
contractProperty.Type.IsArray(out contractElementType) ||
contractProperty.Type.IsCollection(out contractElementType))
{
if (inputProperty.Type.IsImmutableArray(out var inputElementType) ||
inputProperty.Type.IsList(out inputElementType) ||
inputProperty.Type.IsArray(out inputElementType) ||
inputProperty.Type.IsCollection(out inputElementType))
{
if (!typeConverterHelper.CanConvert(contractElementType, inputElementType))
{
if (contractElementType.TypeKind.IsClassOrInterface())
{
if (!TypesAreStructurallyCompatible(typeConverterHelper, contractElementType,
inputElementType, Append(path, inputProperty.Name), incompatibleProperties))
{
result = false;
}
}
else
{
incompatibleProperties.Add(Append(path, inputProperty.Name));
result = false;
}
}
}
// a single element will be added to a list in the message contract
else if (!typeConverterHelper.CanConvert(contractElementType, inputProperty.Type))
{
incompatibleProperties.Add(Append(path, inputProperty.Name));
result = false;
}
}
