static IList ReadTable(this TextScanner scanner, FileSection section)
{
var list = section.CreateList();
scanner.SkipWhiteSpace();
if (!scanner.TryGetColumns(section))
{
return(list);
}
while (scanner.Read())
{
scanner.SkipWhiteSpace();
if (!scanner.TryGetRows(section, out var values))
{
return(list);
}
var row = section.CreateObject();
foreach (var x in section.Schema.Fields.Zip(values, (f, v) => new { Field = f, Value = v }))
{
x.Field[row] = FieldConverter.Convert(x.Field.Type, x.Value);
}
list.Add(row);
}
return(list);
}
public void ReturnFieldInfo()
{
var fieldConverter = new FieldConverter();
var fields = "~~~\n" +
"44\n" +
"*...\n" +
"....\n" +
".*..\n" +
"....\n" +
"~~~\n";
var actual = fieldConverter.ConvertFrom(fields);
var expected = new Field()
{
NoOfRows = 4,
NoOfColumns = 4,
Value = "*..." +
"...." +
".*.." +
"...."
};
Assert.AreEqual(expected.NoOfRows, actual.NoOfRows);
Assert.AreEqual(expected.NoOfColumns, actual.NoOfColumns);
Assert.AreEqual(expected.Value, actual.Value);
}
public void ConvertSDKToSDK()
{
sdkField1 = CreateTypicalSDKField();
converter = new FieldConverter(sdkField1);
sdkField2 = converter.ToSDKField();
Assert.IsNotNull(sdkField2);
Assert.AreEqual(sdkField2, sdkField1);
}
public void ConvertAPIToAPI()
{
apiField1 = CreateTypicalAPIField();
converter = new FieldConverter(apiField1);
apiField2 = converter.ToAPIField();
Assert.IsNotNull(apiField2);
Assert.AreEqual(apiField2, apiField1);
}
/// <summary>
/// Sets value from given object
/// </summary>
/// <param name="value">String value</param>
internal override void SetValue(string value)
{
try
{
Value = FieldConverter.GetValue(value);
}
catch
{
}
}
public ConvertData(IUrlGenerator urlGenerator, IJsonSerializer jsonSerializer,
IAssetRepository assetRepository, IContentRepository contentRepository)
{
this.urlGenerator = urlGenerator;
this.jsonSerializer = jsonSerializer;
this.assetRepository = assetRepository;
this.contentRepository = contentRepository;
excludedChangedField = FieldConverters.ExcludeChangedTypes(jsonSerializer);
excludedHiddenField = FieldConverters.ExcludeHidden;
}
static void Main(string[] args)
{
try
{
byte[] b1 = SQLCLRFunctions.GetHiCodeComputedValue(2010, "", "", false);
Console.WriteLine(FieldConverter.ConvertBytesToString(b1));
}
finally
{
Console.WriteLine("Press any key to close");
Console.ReadKey();
}
}
private Price DecodePrice(XElement itemElement, string storeId)
{
string itemCode = DecodeItemCode(itemElement);
float itemPrice = FieldConverter.DecodeItemFieldFloat(itemElement, "itemprice");
DateTime updateTime = FieldConverter.DecodeItemFieldDateTime(itemElement, "priceupdatedate");
bool allowDiscount = FieldConverter.DecodeItemFieldBool(itemElement, "allowdiscount");
return(new Price()
{
StoreId = storeId,
ItemCode = itemCode,
PriceValue = itemPrice,
UpdateTime = updateTime,
AllowDiscount = allowDiscount
});
}
public ApplicationFormContractResolver(
ConfigurationConverter configurationConverter,
FieldConverter fieldConverter,
ValidatorConverter validatorConverter,
FieldAnnotationConverter fieldAnnotationConverter,
BlockConverter blockConverter)
{
typeConverterMappings = new Dictionary <Type, JsonConverter>
{
{ typeof(FormConfiguration), configurationConverter },
{ typeof(FieldBase), fieldConverter },
{ typeof(ValidatorBase), validatorConverter },
{ typeof(FieldAnnotationBase), fieldAnnotationConverter },
{ typeof(BlockBase), blockConverter }
};
}
public ConvertData(IUrlGenerator urlGenerator, IJsonSerializer jsonSerializer,
IAssetRepository assetRepository, IContentRepository contentRepository)
{
Guard.NotNull(urlGenerator, nameof(urlGenerator));
Guard.NotNull(jsonSerializer, nameof(jsonSerializer));
Guard.NotNull(assetRepository, nameof(assetRepository));
Guard.NotNull(contentRepository, nameof(contentRepository));
this.urlGenerator = urlGenerator;
this.assetRepository = assetRepository;
this.contentRepository = contentRepository;
excludedChangedField = FieldConverters.ExcludeChangedTypes(jsonSerializer);
excludedChangedValue = FieldConverters.ForValues(ValueConverters.ForNested(ValueConverters.ExcludeChangedTypes(jsonSerializer)));
excludedHiddenField = FieldConverters.ExcludeHidden;
excludedHiddenValue = FieldConverters.ForValues(ValueConverters.ForNested(ValueConverters.ExcludeHidden));
}
static void ReadProperties(this TextScanner scanner, IReadOnlyList <FileField> fields, object target)
{
void ReadField(int index)
{
scanner.SkipWhiteSpace();
if (!scanner.Content)
{
return;
}
if (fields.Take(index).Any(f => scanner.TryGetProperty(f, out var value)))
{
return;
}
for (int i = index; i < fields.Count; i++)
{
var field = fields[i];
if (scanner.TryGetProperty(field, out var value))
{
field[target] = FieldConverter.Convert(field.Type, value);
if (scanner.Read())
{
ReadField(i + 1);
}
return;
}
}
if (scanner.Read())
{
if (!fields.Take(index).Any(f => scanner.TryGetProperty(f, out var value)))
{
ReadField(index);
}
}
}
ReadField(0);
}
public ObjectConverter(List <TableColumn> Columns, string PrimaryKey)
{
this.PrimaryKey = PrimaryKey;
foreach (var item in Columns.OrderBy(o => o.relativePosition))
{
var type = Helper.TypeHelper.GetType(item.DataType);
if (type != null)
{
FieldConverter converter = new FieldConverter();
converter.IsIncremental = item.IsIncremental;
converter.ClrType = type;
converter.FieldName = item.Name;
converter.FieldNameHash = ObjectHelper.GetHashCode(item.Name);
converter.Length = item.Length;
converter.RelativePosition = item.relativePosition;
if (item.isComplex)
{
Serializer.Simple.SimpleConverter simple = new Serializer.Simple.SimpleConverter(type);
converter.ToBytes = simple.ToBytes;
converter.FromBytes = simple.FromBytes;
converter.IsComplex = true;
converter.Length = int.MaxValue;
converter.RelativePosition = int.MaxValue;
}
else
{
converter.ToBytes = ConverterHelper.GetToBytes(type);
converter.FromBytes = ConverterHelper.GetFromBytes(type);
}
this.Fields.Add(converter);
}
}
}
/// <summary>
/// This function is the callback used to execute the command when the menu item is clicked.
/// See the constructor to see how the menu item is associated with this function using
/// OleMenuCommandService service and MenuCommand class.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event args.</param>
private void Execute(object sender, EventArgs e)
{
ThreadHelper.ThrowIfNotOnUIThread();
try
{
var txtxMgr = (IVsTextManager)GetService <SVsTextManager>();
IVsUIShell uiShell = (IVsUIShell)GetService <SVsUIShell>();
IntPtr mainWnd;
uiShell.GetDialogOwnerHwnd(out mainWnd);
var dialog = new Window1();
var helper = new WindowInteropHelper(dialog)
{
Owner = mainWnd
};
dialog.ShowDialog();
if (dialog.SelectedOperation == Window1.Operation.AutoFull)
{
var plugin = new AutoPropertyConverter(txtxMgr);
plugin.Execute();
}
else if (dialog.SelectedOperation == Window1.Operation.Encapsulate)
{
var plugin = new FieldConverter(txtxMgr);
plugin.Execute();
}
}
catch (Exception ex)
{
VsShellUtilities.ShowMessageBox(
this.package,
ex.Message,
"PropMan",
OLEMSGICON.OLEMSGICON_INFO,
OLEMSGBUTTON.OLEMSGBUTTON_OK,
OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST);
}
}
private float DecodeQuantity(XElement itemElement)
{
return(FieldConverter.DecodeItemFieldFloat(itemElement, "quantity"));
}
internal Field Build(object value, string field, FieldConverter fieldConverter)
{
var key = fieldConverter.Convert(field);
return new Field(key, value != null ? value.ToString() : "");
}
public void ConvertNullAPIToAPI()
{
apiField1 = null;
converter = new FieldConverter(apiField1);
Assert.IsNull(converter.ToAPIField());
}
public void ConvertNullSDKToSDK()
{
sdkField1 = null;
converter = new FieldConverter(sdkField1);
Assert.IsNull(converter.ToSDKField());
}
private string DecodeManufacturerItemDescription(XElement itemElement)
{
return(FieldConverter.DecodeItemField(itemElement, "manufactureritemdescription"));
}
private string DecodeManufacturerCountry(XElement itemElement)
{
return(FieldConverter.DecodeItemField(itemElement, "manufacturercountry"));
}
private string DecodeManufacturerName(XElement itemElement)
{
return(FieldConverter.DecodeItemField(itemElement, "manufacturername"));
}
private string DecodeItemName(XElement itemElement)
{
return(FieldConverter.DecodeItemField(itemElement, "itemname"));
}
private bool DecodeIsWeighted(XElement itemElement)
{
return(FieldConverter.DecodeItemFieldBool(itemElement, "isweighted"));
}
private string DecodeUnitQty(XElement itemElement)
{
return(FieldConverter.DecodeItemField(itemElement, "unitqty"));
}
private int DecodeQtyInPackage(XElement itemElement)
{
return(FieldConverter.DecodeItemFieldInt(itemElement, "qtyinpackage"));
}
private int DecodeItemType(XElement itemElement)
{
return(FieldConverter.DecodeItemFieldInt(itemElement, "itemtype"));
}
private string DecodeUnitOfMeasure(XElement itemElement)
{
return(FieldConverter.DecodeItemField(itemElement, "unitofmeasure"));
}
