public ActionResult ByPVBase(PVService service, string pvId, string callback,
DataFormat format = DataFormat.Auto)
{
var song = Service.GetSongWithPV(s => new EntryBaseContract(s), service, pvId);
return Object(song, format, callback);
}
public ActionResult ByPV(PVService service, string pvId, ContentLanguagePreference? lang, string callback,
DataFormat format = DataFormat.Auto)
{
var song = Service.GetSongWithPV(s => new SongForApiContract(s, lang ?? ContentLanguagePreference.Default), service, pvId);
return Object(song, format, callback);
}
public ActionResult OEmbed(string url, int maxwidth = 570, int maxheight = 400, DataFormat format = DataFormat.Json)
{
if (string.IsNullOrEmpty(url))
return HttpStatusCodeResult(HttpStatusCode.BadRequest, "URL not specified");
var route = new RouteInfo(new Uri(url), AppConfig.HostAddress).RouteData;
var controller = route.Values["controller"].ToString().ToLowerInvariant();
if (controller != "song" && controller != "s") {
return HttpStatusCodeResult(HttpStatusCode.BadRequest, "Only song embeds are supported");
}
int id;
if (controller == "s") {
var match = Regex.Match(route.Values["action"].ToString(), @"(\d+)");
id = int.Parse(match.Groups[1].Value);
}
else {
id = int.Parse(route.Values["id"].ToString());
}
var song = Services.Songs.GetSong(id);
var html = string.Format("<iframe src=\"{0}\" width=\"{1}\" height=\"{2}\"></iframe>",
VocaUriBuilder.CreateAbsolute(Url.Action("EmbedSong", new {songId = id})), maxwidth, maxheight);
return Object(new SongOEmbedResponse(song, maxwidth, maxheight, html), format);
}
private WireType GetWireType(TypeCode code, DataFormat format, ref Type type, out int modelKey)
{
modelKey = -1;
if (type.IsEnum) return WireType.None;
switch (code)
{
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
case TypeCode.Boolean:
case TypeCode.SByte:
case TypeCode.Byte:
case TypeCode.Char:
return WireType.Variant;
case TypeCode.Double:
return WireType.Fixed64;
case TypeCode.Single:
return WireType.Fixed32;
case TypeCode.String:
case TypeCode.DateTime:
case TypeCode.Decimal:
return WireType.String;
}
if (type == typeof(byte[]) || type == typeof(TimeSpan)
|| type == typeof(Guid) || type == typeof(Uri)) return WireType.String;
if ((modelKey = GetKey(ref type)) >= 0)
{
return WireType.String;
}
return WireType.None;
}
public RawTexture()
{
Width = 0;
Height = 0;
Data = new byte[0];
Format = DataFormat.Invalid;
}
public RawTexture(int width, int height, DataFormat format, byte[] data)
: this(width, height, format)
{
if (data.Length != Data.Length)
throw new ArgumentException("Provided Data is of invalid Size", nameof(data));
Buffer.BlockCopy(data, 0, Data, 0, data.Length);
}
Serialization(DataFormat dataFormat, string streamName)
{
Dbg.Assert(!string.IsNullOrEmpty(streamName), "stream needs a name");
format = dataFormat;
this.streamName = streamName;
}
public RawTexture(int width, int height, DataFormat format)
{
Width = width;
Height = height;
var tgtSize = (int) format * width * height;
Format = format;
Data = new byte[tgtSize];
}
public static string Run(string data, DataFormat inputFormat, DataFormat outputFormat, Operation operation)
{
if (string.IsNullOrEmpty(data)) return string.Empty;
var bytes = GetBytes(data, inputFormat);
var result = Process(bytes, operation);
return GetString(result, outputFormat);
}
/// <summary>
/// 实例化RESTfulInvocationHandler
/// </summary>
/// <param name="attribute"></param>
/// <param name="token"></param>
/// <param name="foramt"></param>
public RESTfulInvocationHandler(string url, PublishKindAttribute attribute, Token token, DataFormat foramt, int timeout)
{
this.format = foramt;
this.attribute = attribute;
this.token = token;
this.url = url;
this.timeout = timeout;
}
/// <summary>
/// Uploads an activity.
/// </summary>
/// <param name="file">The path to the activity file on your local hard disk.</param>
/// <param name="dataFormat">The format of the file.</param>
/// <param name="activityType">The type of the activity.</param>
/// <returns>The status of the upload.</returns>
public async Task<UploadStatus> UploadActivityAsync(StorageFile file, DataFormat dataFormat, ActivityType activityType = ActivityType.Ride)
{
String format = String.Empty;
switch (dataFormat)
{
case DataFormat.Fit:
format = "fit";
break;
case DataFormat.FitGZipped:
format = "fit.gz";
break;
case DataFormat.Gpx:
format = "gpx";
break;
case DataFormat.GpxGZipped:
format = "gpx.gz";
break;
case DataFormat.Tcx:
format = "tcx";
break;
case DataFormat.TcxGZipped:
format = "tcx.gz";
break;
}
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", String.Format("Bearer {0}", Authentication.AccessToken));
MultipartFormDataContent content = new MultipartFormDataContent();
byte[] fileBytes = null;
using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync())
{
fileBytes = new byte[stream.Size];
using (DataReader reader = new DataReader(stream))
{
await reader.LoadAsync((uint)stream.Size);
reader.ReadBytes(fileBytes);
}
}
var byteArrayContent = new ByteArrayContent(fileBytes);
content.Add(byteArrayContent, "file", file.Name);
HttpResponseMessage result = await client.PostAsync(
String.Format("https://www.strava.com/api/v3/uploads?data_type={0}&activity_type={1}",
format,
activityType.ToString().ToLower()),
content);
String json = await result.Content.ReadAsStringAsync();
return Unmarshaller<UploadStatus>.Unmarshal(json);
}
public ActionResult Index(string query, DiscType discType = DiscType.Unknown,
int start = 0, bool getTotalCount = false, AlbumSortRule sort = AlbumSortRule.Name,
NameMatchMode nameMatchMode = NameMatchMode.Exact, DataFormat format = DataFormat.Auto)
{
var queryParams = new AlbumQueryParams(query, discType, start, maxResults, false, getTotalCount, nameMatchMode, sort);
var entries = Service.Find(a => new AlbumForApiContract(a, LoginManager.LanguagePreference), queryParams);
return Object(entries, format);
}
/// <summary>
/// Creates a new <see cref="ConfigurationCell"/> from specified parameters.
/// </summary>
/// <param name="parent">The reference to parent <see cref="ConfigurationFrame"/> of this <see cref="ConfigurationCell"/>.</param>
/// <param name="idCode">The numeric ID code for this <see cref="ConfigurationCell"/>.</param>
/// <param name="isVirtual">Assigns flag that determines if this <see cref="ConfigurationCell"/> is virtual.</param>
public ConfigurationCell(ConfigurationFrame parent, ushort idCode, bool isVirtual)
: base(parent, idCode, int.MaxValue, int.MaxValue, int.MaxValue)
{
m_signalReferences = new Dictionary<SignalType, string[]>();
m_analogDataFormat = DataFormat.FloatingPoint;
m_frequencyDataFormat = DataFormat.FloatingPoint;
m_phasorDataFormat = DataFormat.FloatingPoint;
m_phasorCoordinateFormat = CoordinateFormat.Polar;
m_isVirtual = isVirtual;
}
public ActionResult ByPVBase(PVService? service, string pvId, string callback,
DataFormat format = DataFormat.Auto)
{
if (service == null)
return HttpStatusCodeResult(HttpStatusCode.BadRequest, "Service not specified or invalid");
var song = Service.GetSongWithPV(s => new EntryBaseContract(s), service.Value, pvId);
return Object(song, format, callback);
}
public ActionResult Tracks(int id = invalidId, DataFormat format = DataFormat.Auto,
ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
if (id == invalidId)
return NoId();
var tracks = Service.GetAlbum(id, a => a.Songs.Select(s => new SongInAlbumContract(s, lang)).ToArray());
return Object(tracks, format);
}
// constructor for reading an IDX file
public IDX(Stream in_stream, bool in_writing=false)
{
_idx_stream = in_stream;
// verify we can actually use this stream
Debug.Assert(_idx_stream.CanRead && _idx_stream.CanSeek);
_writing = in_writing;
if (_writing)
{
// just verify stream is writeable
Debug.Assert(_idx_stream.CanWrite == true);
}
// get our endianness
_idx_endianness = (Endianness)(255 * ReadUInt8() + ReadUInt8());
Debug.Assert(_idx_endianness == Endianness.BigEndian || _idx_endianness == Endianness.LittleEndian);
// get data format
_data_format = (DataFormat)ReadUInt8();
// number of dimensions
byte dimensions = ReadUInt8();
Debug.Assert(dimensions > 0);
// get number of rows
_rows = ReadUInt32();
// calculate length of each row
_row_length = 1;
for (int k = 1; k < dimensions; k++)
{
_row_length *= ReadUInt32();
}
_row_length_bytes = _row_length;
switch (_data_format)
{
case DataFormat.UInt8:
case DataFormat.SInt8:
_row_length_bytes *= 1;
break;
case DataFormat.SInt16:
_row_length_bytes *= 2;
break;
case DataFormat.SInt32:
case DataFormat.Single:
_row_length_bytes *= 4;
break;
case DataFormat.Double:
_row_length_bytes *= 8;
break;
}
// get size of the header
_header_size = (uint)_idx_stream.Position;
}
/// <summary>
/// Creates a new <see cref="ConfigurationCell"/> from specified parameters.
/// </summary>
/// <param name="parent">The reference to parent <see cref="ConfigurationFrame"/> of this <see cref="ConfigurationCell"/>.</param>
/// <param name="idCode">The numeric ID code for this <see cref="ConfigurationCell"/>.</param>
public ConfigurationCell(ConfigurationFrame parent, ushort idCode)
: base(parent, idCode, int.MaxValue, int.MaxValue, int.MaxValue)
{
// Create a cached signal reference dictionary for generated signal references
m_generatedSignalReferenceCache = new string[Enum.GetValues(typeof(SignalKind)).Length][];
m_analogDataFormat = DataFormat.FloatingPoint;
m_frequencyDataFormat = DataFormat.FloatingPoint;
m_phasorDataFormat = DataFormat.FloatingPoint;
m_phasorCoordinateFormat = CoordinateFormat.Polar;
}
public ActionResult Versions(DataFormat format = DataFormat.Auto)
{
var versions = queries
.HandleQuery(ctx => ctx.Query()
.Where(a => !a.Deleted)
.Select(a => new { a.Id, a.Version })
.ToArray()
.Select(v => new EntryIdAndVersionContract(v.Id, v.Version))
.ToArray());
return ObjectLowercase(versions, format);
}
/// <summary>
/// Raises the <see cref="E:System.Windows.Forms.UserControl.Load"/> event.
/// </summary>
/// <param name="e">An <see cref="T:System.EventArgs"/> that contains the event data.</param>
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
foreach (var key in controlMapping.Keys)
{
var format = key;
var rb = controlMapping[format];
rb.Checked = format == DataFormat;
rb.CheckedChanged += (s, _) => DataFormat = format;
}
}
public ActionResult ParsePVUrl(string pvUrl, string callback, DataFormat format = DataFormat.Auto)
{
var result = VideoServiceHelper.ParseByUrl(pvUrl, true);
if (!result.IsOk) {
return Json(new GenericResponse<string>(false, result.Exception.Message));
}
var contract = new PVContract(result, PVType.Original);
return Object(contract, format, callback);
}
/// <summary>
/// Creates a new ValueMember instance
/// </summary>
internal ValueMember(RuntimeTypeModel model, int fieldNumber, Type memberType, Type itemType, Type defaultType, DataFormat dataFormat)
{
if (memberType == null) throw new ArgumentNullException("memberType");
if (model == null) throw new ArgumentNullException("model");
this.fieldNumber = fieldNumber;
this.memberType = memberType;
this.itemType = itemType;
this.defaultType = defaultType;
this.model = model;
this.dataFormat = dataFormat;
}
public ActionResult Details(int id = invalidId,
bool includeAlbums = true, bool includeArtists = true, bool includeNames = true, bool includePVs = false, bool includeTags = true, bool includeWebLinks = false,
string callback = null, DataFormat format = DataFormat.Auto,
ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
if (id == invalidId)
return NoId();
var song = Service.GetSongWithMergeRecord(id, (s, m) => new SongForApiContract(s, m, lang, includeAlbums, includeArtists, includeNames, includePVs, includeTags, true, includeWebLinks));
return Object(song, format, callback);
}
public ActionResult Details(int id = invalidId,
bool includeArtists = true, bool includeNames = true, bool includePVs = false, bool includeTags = true, bool includeWebLinks = false,
DataFormat format = DataFormat.Auto,
ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
if (id == invalidId)
return NoId();
var album = Service.GetAlbumWithMergeRecord(id, (a, m) => new AlbumForApiContract(a, m, lang, includeArtists, includeNames, includePVs, includeTags, includeWebLinks));
return Object(album, format);
}
public ActionResult Index(string query, DiscType discType = DiscType.Unknown,
int start = 0, bool getTotalCount = false, AlbumSortRule sort = AlbumSortRule.Name,
NameMatchMode nameMatchMode = NameMatchMode.Exact,
bool includeArtists = true, bool includeNames = true, bool includePVs = false, bool includeTags = true, bool includeWebLinks = false,
DataFormat format = DataFormat.Auto,
ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
var queryParams = new AlbumQueryParams(query, discType, start, maxResults, false, getTotalCount, nameMatchMode, sort);
var entries = Service.Find(a => new AlbumForApiContract(a, null, lang, includeArtists, includeNames, includePVs, includeTags, includeWebLinks), queryParams);
return Object(entries, format);
}
public ActionResult ByPV(PVService? service, string pvId, ContentLanguagePreference? lang, string callback,
bool includeAlbums = true, bool includeArtists = true, bool includeNames = true, bool includePVs = false,
bool includeTags = true, bool includeWebLinks = false,
DataFormat format = DataFormat.Auto)
{
if (service == null)
return HttpStatusCodeResult(HttpStatusCode.BadRequest, "Service not specified or invalid");
var song = Service.GetSongWithPV(s => new SongForApiContract(s, null, lang ?? ContentLanguagePreference.Default,
includeAlbums, includeArtists, includeNames, includePVs, includeTags, true, includeWebLinks), service.Value, pvId);
return Object(song, format, callback);
}
public static RestRequest CreateRequest(Method method, string resource, DataFormat format = DataFormat.Json)
{
var request = new RestRequest
{
Resource = resource,
Method = method,
RequestFormat = format
};
var basicAuthCred = Convert.ToBase64String(Encoding.Default.GetBytes($":{Constants.Keys.Api}"));
request.AddHeader("Authorization", $"Basic {basicAuthCred}");
request.AddHeader("Accept-Version", Constants.ApiVersionHeader);
return request;
}
public string getExtension(DataFormat dataFormat)
{
switch (dataFormat)
{
case DataFormat.IFC:
return ".ifc";
case DataFormat.gbXML:
return ".xml";
case DataFormat.RVT:
return ".rvt";
case DataFormat.IDF:
return ".idf";
default:
return "";
}
}
/// <summary>
/// Used to make search Request to Amazon Cloud Search
/// </summary>
/// <param name="SearchUri"></param>
/// <param name="searchQuery"></param>
/// <param name="returnFields"></param>
/// <param name="pageSize"></param>
/// <param name="start"></param>
/// <returns>Response Status</returns>
public string SearchRequest(string apiEndPoint, string apiVersion,
string searchQuery, string searchOption,
string returnFields, string sortByScore, DataFormat format)
{
// Buid search url
string SearchUrl = "http://search-" + apiEndPoint
+ "/" + apiVersion
+ "/search?" + searchQuery
+ "&" + searchOption
+ "&return=" + returnFields
+ "&sort=" + sortByScore
+ "&size=9999";
// Check type of format
if (format == DataFormat.Xml)
SearchUrl = SearchUrl + "&results-type=xml";
string responseFromServer = string.Empty;
// Create a request for the URL.
WebRequest request = WebRequest.Create(SearchUrl);
// If required by the server, set the credentials.
request.Credentials = CredentialCache.DefaultNetworkCredentials;
request.ContentType = "application/json";
request.Timeout = 10000;
// Get the response.
WebResponse response = request.GetResponse();
// Get the stream containing content returned by the server.
Stream dataStream = response.GetResponseStream();
// Open the stream using a StreamReader for easy access.
StreamReader reader = new StreamReader(dataStream);
// Read the content.
responseFromServer = reader.ReadToEnd();
// Clean up the streams and the response.
reader.Close();
response.Close();
// Returns response from the server
return responseFromServer;
}
public bool convert(DataFormat inFormat, DataFormat outFormat, string inFile, string outFile)
{
bool result;
if (inFormat == DataFormat.IFC && outFormat == DataFormat.gbXML)
{
lock (Program.revitLock)
{
result = ifc2gbXML.Convert(inFile, outFile);
}
return result;
}
if (inFormat == DataFormat.gbXML && outFormat == DataFormat.IDF)
{
lock (Program.designBuilderLock)
{
result = gbXML2idf.Convert(inFile, outFile);
}
return result;
}
if (inFormat == DataFormat.IFC && outFormat == DataFormat.RVT)
{
lock (Program.revitLock)
{
result = ifc2rvt.Convert(inFile, outFile);
}
return result;
}
if(inFormat== DataFormat.RVT && outFormat == DataFormat.IFC)
{
lock(Program.revitLock)
{
result = rvt2ifc.Convert(inFile, outFile);
}
return result;
}
if(inFormat == DataFormat.RVT && outFormat == DataFormat.gbXML)
{
lock(Program.revitLock)
{
result = rvt2gbXML.Convert(inFile, outFile);
}
return result;
}
return false;
}
/// <summary>
/// Uploads an activity.
/// </summary>
/// <param name="filePath">The path to the activity file on your local hard disk.</param>
/// <param name="dataFormat">The format of the file.</param>
/// <param name="activityType">The type of the activity.</param>
/// <returns>The status of the upload.</returns>
public async Task<UploadStatus> UploadActivityAsync(String filePath, DataFormat dataFormat, ActivityType activityType = ActivityType.Ride)
{
String format = String.Empty;
switch (dataFormat)
{
case DataFormat.Fit:
format = "fit";
break;
case DataFormat.FitGZipped:
format = "fit.gz";
break;
case DataFormat.Gpx:
format = "gpx";
break;
case DataFormat.GpxGZipped:
format = "gpx.gz";
break;
case DataFormat.Tcx:
format = "tcx";
break;
case DataFormat.TcxGZipped:
format = "tcx.gz";
break;
}
FileInfo info = new FileInfo(filePath);
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", String.Format("Bearer {0}", Authentication.AccessToken));
MultipartFormDataContent content = new MultipartFormDataContent();
content.Add(new ByteArrayContent(File.ReadAllBytes(info.FullName)), "file", info.Name);
HttpResponseMessage result = await client.PostAsync(
String.Format("https://www.strava.com/api/v3/uploads?data_type={0}&activity_type={1}",
format,
activityType.ToString().ToLower()),
content);
String json = await result.Content.ReadAsStringAsync();
return Unmarshaller<UploadStatus>.Unmarshal(json);
}
/// <summary>
/// 构造函数 -- 封装数据
/// </summary>
/// <param name="eField">字段标签</param>
/// <param name="eFormat">格式标签</param>
/// <param name="pContent">数据</param>
internal CustomData(DataField eField, DataFormat eFormat, object pContent)
{
this._eField = eField;
this._eFormat = eFormat;
this._pContent = pContent;
}
/// <summary>
/// Set the DataFormat of the IRestRequest.
/// </summary>
/// <param name="dataFormat"></param>
/// <returns></returns>
public IRequestBuilder SetFormat(DataFormat dataFormat)
{
_dataFormat = dataFormat;
return(this);
}
public ActionResult OEmbedResponsive(string url, int maxwidth = 570, int maxheight = 400, DataFormat format = DataFormat.Json)
{
return(OEmbed(url, maxwidth, maxheight, format, true));
}
public DataConversion(DataFormat source, DataFormat target)
{
Source = source;
Target = target;
}
/// <summary>
/// Sets the data format which will be used for the drag and drop actions.
/// </summary>
public static void SetDataFormat(UIElement source, DataFormat value)
{
source.SetValue(DataFormatProperty, value);
}
public Writer(Uri dependencyServiceUri, AtlasConfiguration atlasConfiguration, DataFormat dataFormat,
string group, IOutputTopic topic, bool enableCache = true)
{
var httpDependencyClient =
new HttpDependencyClient(dependencyServiceUri, group,
enableCache); // DependencyClient stores the Data format, Atlas Configuration
var dataFormatClient = new DataFormatClient(httpDependencyClient);
var atlasConfigurationClient = new AtlasConfigurationClient(httpDependencyClient);
var atlasConfigurationId =
atlasConfigurationClient
.PutAndIdentifyAtlasConfiguration(atlasConfiguration); // Uniq ID created for the AtlasConfiguration
var dataFormatId =
dataFormatClient.PutAndIdentifyDataFormat(dataFormat); // Uniq ID created for the Data Format
TopicName = topic.TopicName;
//Init Session
session = new SessionTelemetryDataOutput(topic, dataFormatId, dataFormatClient);
session.SessionOutput.AddSessionDependency(DependencyTypes.DataFormat, dataFormatId);
session.SessionOutput.AddSessionDependency(DependencyTypes.AtlasConfiguration, atlasConfigurationId);
SessionOutput = session.SessionOutput;
}
/// <summary>
/// 使用指定的数据解析来实例化对象
/// </summary>
/// <param name="dataFormat">数据规则</param>
public ReverseWordTransform(DataFormat dataFormat) : base(dataFormat)
{
}
/// <summary>
/// 使用指定的数据解析来实例化对象
/// </summary>
/// <param name="dataFormat">数据规则</param>
public ByteTransformBase(DataFormat dataFormat)
{
this.DataFormat = dataFormat;
}
/// <summary>
/// 将单个数据表保存到Excel
/// </summary>
/// <param name="dataTable">数据表</param>
/// <param name="fileName">文件名</param>
public static void ExportExcel(DataTable dataTable, string fileName = null)
{
HSSFWorkbook workBook = new HSSFWorkbook();
Sheet sheet = workBook.CreateSheet("Sheet1");
Font font = workBook.CreateFont();
font.Boldweight = 700;
CellStyle style = workBook.CreateCellStyle();
style.Alignment = HorizontalAlignment.CENTER;
style.SetFont(font);
int rownum = 0;
Row row = sheet.CreateRow(rownum++);
Cell cell;
for (int i = 0; i < dataTable.Columns.Count; i++)
{
cell = row.CreateCell(i);
cell.SetCellValue(dataTable.Columns[i].ColumnName);
cell.CellStyle = style;
}
CellStyle dateStyle = workBook.CreateCellStyle();
DataFormat format = workBook.CreateDataFormat();
dateStyle.DataFormat = format.GetFormat("yyyy-MM-dd HH:mm:ss");
foreach (DataRow dataRow in dataTable.Rows)
{
row = sheet.CreateRow(rownum++);
for (int i = 0; i < dataTable.Columns.Count; i++)
{
cell = row.CreateCell(i);
string strValue = dataRow[i].ToString();
if (string.IsNullOrWhiteSpace(strValue))
{
cell.SetCellValue("");
}
else
{
switch (dataTable.Columns[i].DataType.ToString())
{
case "System.DateTime":
DateTime dateTime;
DateTime.TryParse(strValue, out dateTime);
cell.SetCellValue(dateTime);
cell.CellStyle = dateStyle;
break;
case "System.Boolean":
bool bValue;
bool.TryParse(strValue, out bValue);
cell.SetCellValue(bValue);
break;
case "System.Int16":
case "System.Int32":
case "System.Int64":
case "System.Byte":
int iValue = 0;
int.TryParse(strValue, out iValue);
cell.SetCellValue(iValue);
break;
case "System.Decimal":
case "System.Double":
double dValue = 0;
double.TryParse(strValue, out dValue);
cell.SetCellValue(dValue);
break;
default:
cell.SetCellValue(strValue);
break;
}
}
}
}
for (int i = 0; i < dataTable.Columns.Count; i++)
{
sheet.AutoSizeColumn(i);
}
workBook.Write(HttpContext.Current.Response.OutputStream);
workBook.Dispose();
HttpContext.Current.Response.ContentType = "application/vnd.ms-excel";
if (string.IsNullOrEmpty(fileName))
{
fileName = DateTime.Now.ToString("yyyyMMddHHmmss");
}
HttpContext.Current.Response.AppendHeader("Content-Disposition", "Attachment; FileName=" + GetToExcelName(fileName) + ".xls");
HttpContext.Current.Response.ContentEncoding = System.Text.Encoding.UTF8;
HttpContext.Current.Response.Flush();
HttpContext.Current.Response.End();
}
internal static IProtoSerializer TryGetCoreSerializer(RuntimeTypeModel model, DataFormat dataFormat, Type type, out WireType defaultWireType,
bool asReference, bool dynamicType, bool overwriteList, bool allowComplexTypes)
{
#if !NO_GENERICS
{
Type tmp = Helpers.GetUnderlyingType(type);
if (tmp != null)
{
type = tmp;
}
}
#endif
if (Helpers.IsEnum(type))
{
if (allowComplexTypes && model != null)
{
// need to do this before checking the typecode; an int enum will report Int32 etc
defaultWireType = WireType.Variant;
return(new EnumSerializer(type, model.GetEnumMap(type)));
}
else
{ // enum is fine for adding as a meta-type
defaultWireType = WireType.None;
return(null);
}
}
ProtoTypeCode code = Helpers.GetTypeCode(type);
switch (code)
{
case ProtoTypeCode.Int32:
defaultWireType = GetIntWireType(dataFormat, 32);
return(new Int32Serializer(model));
case ProtoTypeCode.UInt32:
defaultWireType = GetIntWireType(dataFormat, 32);
return(new UInt32Serializer(model));
case ProtoTypeCode.Int64:
defaultWireType = GetIntWireType(dataFormat, 64);
return(new Int64Serializer(model));
case ProtoTypeCode.UInt64:
defaultWireType = GetIntWireType(dataFormat, 64);
return(new UInt64Serializer(model));
case ProtoTypeCode.String:
defaultWireType = WireType.String;
if (asReference)
{
return(new NetObjectSerializer(model, model.MapType(typeof(string)), 0, BclHelpers.NetObjectOptions.AsReference));
}
return(new StringSerializer(model));
case ProtoTypeCode.Single:
defaultWireType = WireType.Fixed32;
return(new SingleSerializer(model));
case ProtoTypeCode.Double:
defaultWireType = WireType.Fixed64;
return(new DoubleSerializer(model));
case ProtoTypeCode.Boolean:
defaultWireType = WireType.Variant;
return(new BooleanSerializer(model));
case ProtoTypeCode.DateTime:
defaultWireType = GetDateTimeWireType(dataFormat);
return(new DateTimeSerializer(model));
case ProtoTypeCode.Decimal:
defaultWireType = WireType.String;
return(new DecimalSerializer(model));
case ProtoTypeCode.Byte:
defaultWireType = GetIntWireType(dataFormat, 32);
return(new ByteSerializer(model));
case ProtoTypeCode.SByte:
defaultWireType = GetIntWireType(dataFormat, 32);
return(new SByteSerializer(model));
case ProtoTypeCode.Char:
defaultWireType = WireType.Variant;
return(new CharSerializer(model));
case ProtoTypeCode.Int16:
defaultWireType = GetIntWireType(dataFormat, 32);
return(new Int16Serializer(model));
case ProtoTypeCode.UInt16:
defaultWireType = GetIntWireType(dataFormat, 32);
return(new UInt16Serializer(model));
case ProtoTypeCode.TimeSpan:
defaultWireType = GetDateTimeWireType(dataFormat);
return(new TimeSpanSerializer(model));
case ProtoTypeCode.Guid:
defaultWireType = WireType.String;
return(new GuidSerializer(model));
case ProtoTypeCode.Uri:
defaultWireType = WireType.String;
return(new StringSerializer(model));
case ProtoTypeCode.ByteArray:
defaultWireType = WireType.String;
return(new BlobSerializer(model, overwriteList));
case ProtoTypeCode.Type:
defaultWireType = WireType.String;
return(new SystemTypeSerializer(model));
}
IProtoSerializer parseable = model.AllowParseableTypes ? ParseableSerializer.TryCreate(type, model) : null;
if (parseable != null)
{
defaultWireType = WireType.String;
return(parseable);
}
if (allowComplexTypes && model != null)
{
int key = model.GetKey(type, false, true);
if (asReference || dynamicType)
{
defaultWireType = dataFormat == DataFormat.Group ? WireType.StartGroup : WireType.String;
BclHelpers.NetObjectOptions options = BclHelpers.NetObjectOptions.None;
if (asReference)
{
options |= BclHelpers.NetObjectOptions.AsReference;
}
if (dynamicType)
{
options |= BclHelpers.NetObjectOptions.DynamicType;
}
if (key >= 0)
{ // exists
if (asReference && Helpers.IsValueType(type))
{
string message = "AsReference cannot be used with value-types";
if (type.Name == "KeyValuePair`2")
{
message += "; please see http://stackoverflow.com/q/14436606/";
}
else
{
message += ": " + type.FullName;
}
throw new InvalidOperationException(message);
}
MetaType meta = model[type];
if (asReference && meta.IsAutoTuple)
{
options |= BclHelpers.NetObjectOptions.LateSet;
}
if (meta.UseConstructor)
{
options |= BclHelpers.NetObjectOptions.UseConstructor;
}
}
return(new NetObjectSerializer(model, type, key, options));
}
if (key >= 0)
{
defaultWireType = dataFormat == DataFormat.Group ? WireType.StartGroup : WireType.String;
return(new SubItemSerializer(type, key, model[type], true));
}
}
defaultWireType = WireType.None;
return(null);
}
/// <summary>
/// Returns the current state of the registration, including completion
/// and satisfaction type data. Amount of detail depends on format parameter.
/// </summary>
/// <param name="registrationId">Unique Identifier for the registration</param>
/// <param name="instanceId">Integer value (as string) of the registration instance to retrieve.</param>
/// <param name="resultsFormat">Degree of detail to return</param>
/// <returns>Registration data in XML Format</returns>
public string GetRegistrationResult(string registrationId, string instanceId, RegistrationResultsFormat resultsFormat, DataFormat dataFormat)
{
ServiceRequest request = new ServiceRequest(configuration);
request.Parameters.Add("regid", registrationId);
request.Parameters.Add("instanceid", instanceId);
request.Parameters.Add("resultsformat", Enum.GetName(resultsFormat.GetType(), resultsFormat).ToLower());
if (dataFormat == DataFormat.JSON)
{
request.Parameters.Add("dataformat", "json");
}
XmlDocument response = request.CallService("rustici.registration.getRegistrationResult");
// Return the subset of the xml starting with the top <summary>
return(response.ChildNodes[1].InnerXml);
}
public NewtonsoftJsonRestRequest(Uri resource, Method method = Method.GET, DataFormat dataFormat = DataFormat.Xml) : base(resource, method, dataFormat)
{
InitSerializer();
}
private static bool EncryptDecrypt(
DataType startType, DataType interType, DataType endType,
DataFormat startFormat, DataFormat interFormat, DataFormat endFormat,
string password,
int saltLength, int keyIterations, int keySize,
int messageLength
)
{
if ((interType == DataType.Console && interFormat == DataFormat.Raw) || (endType == DataType.Console && endFormat == DataFormat.Raw))
{
return(false);
}
string startInputArg;
string startOutputArg = string.Empty;
byte[] originalClearMessage;
if (startType == DataType.Console)
{
do
{
originalClearMessage = GenerateRandom(messageLength, true);
if (startFormat == DataFormat.Base64)
{
startInputArg = Convert.ToBase64String(originalClearMessage);
}
else if (startFormat == DataFormat.Hexa)
{
startInputArg = ToHexString(originalClearMessage);
}
else
{
startInputArg = Encoding.ASCII.GetString(originalClearMessage);
}
} while (startInputArg.StartsWith("-"));
}
else
{
originalClearMessage = GenerateRandom(messageLength, false);
string startFilename = Utils.EnsureFilename("tests/clear.bin");
#if IN_MEMORY
if (InMemoryFile.Exists(startFilename))
{
InMemoryFile.Delete(startFilename);
}
if (startFormat == DataFormat.Base64)
{
InMemoryFile.WriteAllText(startFilename, Convert.ToBase64String(originalClearMessage));
}
else if (startFormat == DataFormat.Hexa)
{
InMemoryFile.WriteAllText(startFilename, ToHexString(originalClearMessage));
}
else
{
InMemoryFile.WriteAllBytes(startFilename, originalClearMessage);
}
#else
if (File.Exists(startFilename))
{
File.Delete(startFilename);
}
if (startFormat == DataFormat.Base64)
{
File.WriteAllText(startFilename, Convert.ToBase64String(originalClearMessage));
}
else if (startFormat == DataFormat.Hexa)
{
File.WriteAllText(startFilename, ToHexString(originalClearMessage));
}
else
{
File.WriteAllBytes(startFilename, originalClearMessage);
}
#endif
startInputArg = startFilename;
}
StringBuilder interStringBuilder = null;
if (interType == DataType.Console)
{
interStringBuilder = new StringBuilder();
Console.SetOut(new StringWriter(interStringBuilder));
}
else
{
string interFilename = Utils.EnsureFilename("tests/encrypted.aes");
#if IN_MEMORY
if (InMemoryFile.Exists(interFilename))
{
InMemoryFile.Delete(interFilename);
}
#else
if (File.Exists(interFilename))
{
File.Delete(interFilename);
}
#endif
startOutputArg = interFilename;
}
var startArgs = new string[]
{
"-e",
"--input-type", startType.ToString().ToLowerInvariant(),
"--input-format", startFormat.ToString().ToUpperInvariant(),
"--output-type", interType.ToString().ToLowerInvariant(),
"--output-format", interFormat.ToString().ToLowerInvariant(),
"--password", password,
"--key-salt-length", saltLength.ToString(),
"--key-iterations", keyIterations.ToString(),
"--key-size", keySize.ToString(),
"--skip-bytes", "0",
startInputArg,
startOutputArg
};
new Aes.Program().Run(startArgs);
// ==================================================
string endInputArg;
string endOutputArg = string.Empty;
if (interType == DataType.Console)
{
endInputArg = ConsoleOutStream.TrimConsoleDataMarkers(interStringBuilder.ToString());
}
else
{
endInputArg = Utils.EnsureFilename("tests/encrypted.aes");
}
StringBuilder endStringBuilder = null;
if (endType == DataType.Console)
{
endStringBuilder = new StringBuilder();
Console.SetOut(new StringWriter(endStringBuilder));
}
else
{
string endFilename = Utils.EnsureFilename("tests/decrypted.bin");
#if IN_MEMORY
if (InMemoryFile.Exists(endFilename))
{
InMemoryFile.Delete(endFilename);
}
#else
if (File.Exists(endFilename))
{
File.Delete(endFilename);
}
#endif
endOutputArg = endFilename;
}
var endArgs = new string[]
{
"-d",
"--input-type", interType.ToString().ToLowerInvariant(),
"--input-format", interFormat.ToString().ToUpperInvariant(),
"--output-type", endType.ToString().ToLowerInvariant(),
"--output-format", endFormat.ToString().ToLowerInvariant(),
"--password", password,
"--key-salt-length", saltLength.ToString(),
"--key-iterations", keyIterations.ToString(),
"--key-size", keySize.ToString(),
"--skip-bytes", "0",
endInputArg,
endOutputArg
};
new Aes.Program().Run(endArgs);
byte[] resultMessage = null;
if (endType == DataType.Console)
{
resultMessage = Encoding.ASCII.GetBytes(ConsoleOutStream.TrimConsoleDataMarkers(endStringBuilder.ToString()));
}
else
{
#if IN_MEMORY
resultMessage = InMemoryFile.ReadAllBytes(Utils.EnsureFilename("tests/decrypted.bin"));
#else
resultMessage = File.ReadAllBytes(Utils.EnsureFilename("tests/decrypted.bin"));
#endif
}
if (endFormat == DataFormat.Base64)
{
resultMessage = Convert.FromBase64String(Encoding.ASCII.GetString(resultMessage));
}
else if (endFormat == DataFormat.Hexa)
{
resultMessage = FromHexStringAsBytes(resultMessage);
}
string info = $"{startType} {interType} {endType}, {startFormat} {interFormat} {endFormat}, {password}, {saltLength}, {keyIterations}, {keySize}, {messageLength}";
if (originalClearMessage.Length != resultMessage.Length)
{
throw new Exception($"Length mismatch. [{info}]");
}
for (int i = 0; i < originalClearMessage.Length; i++)
{
if (originalClearMessage[i] != resultMessage[i])
{
throw new Exception($"Data mismatch at position '{i}'. [{info}]");
}
}
return(true);
}
/// <summary>
/// Converts the specified DigitalRune <see cref="DataFormat"/> to the XNA
/// <see cref="SurfaceFormat"/>.
/// </summary>
/// <param name="format">The <see cref="DataFormat"/>.</param>
/// <returns>The <see cref="SurfaceFormat"/>.</returns>
/// <exception cref="NotSupportedException">
/// The format is not supported in XNA or MonoGame.
/// </exception>
public static SurfaceFormat ToSurfaceFormat(this DataFormat format)
{
// Use same order as in MonoGame/SurfaceFormat.cs and keep in sync.
// sRGB formats are treaded as non-sRGB formats.
switch (format)
{
case DataFormat.R8G8B8A8_UNORM:
case DataFormat.R8G8B8A8_UNORM_SRGB:
return(SurfaceFormat.Color);
case DataFormat.B5G6R5_UNORM:
return(SurfaceFormat.Bgr565);
case DataFormat.B5G5R5A1_UNORM:
return(SurfaceFormat.Bgra5551);
case DataFormat.B4G4R4A4_UNORM:
return(SurfaceFormat.Bgra4444);
case DataFormat.BC1_UNORM:
case DataFormat.BC1_UNORM_SRGB:
return(SurfaceFormat.Dxt1);
case DataFormat.BC2_UNORM:
case DataFormat.BC2_UNORM_SRGB:
return(SurfaceFormat.Dxt3);
case DataFormat.BC3_UNORM:
case DataFormat.BC3_UNORM_SRGB:
return(SurfaceFormat.Dxt5);
case DataFormat.R8G8_SNORM:
return(SurfaceFormat.NormalizedByte2);
case DataFormat.R8G8B8A8_SNORM:
return(SurfaceFormat.NormalizedByte4);
case DataFormat.R10G10B10A2_UNORM:
return(SurfaceFormat.Rgba1010102);
case DataFormat.R16G16_UNORM:
return(SurfaceFormat.Rg32);
case DataFormat.R16G16B16A16_UNORM:
return(SurfaceFormat.Rgba64);
case DataFormat.A8_UNORM:
case DataFormat.R8_UNORM:
return(SurfaceFormat.Alpha8);
case DataFormat.R32_FLOAT:
return(SurfaceFormat.Single);
case DataFormat.R32G32_FLOAT:
return(SurfaceFormat.Vector2);
case DataFormat.R32G32B32A32_FLOAT:
return(SurfaceFormat.Vector4);
case DataFormat.R16_FLOAT:
return(SurfaceFormat.HalfSingle);
case DataFormat.R16G16_FLOAT:
return(SurfaceFormat.HalfVector2);
case DataFormat.R16G16B16A16_FLOAT:
return(SurfaceFormat.HalfVector4);
//return SurfaceFormat.HdrBlendable; // Only needed as render target format.
case DataFormat.B8G8R8X8_UNORM:
return(SurfaceFormat.Bgr32);
case DataFormat.B8G8R8A8_UNORM:
return(SurfaceFormat.Bgra32);
case DataFormat.PVRTCI_2bpp_RGB:
return(SurfaceFormat.RgbPvrtc2Bpp);
case DataFormat.PVRTCI_4bpp_RGB:
return(SurfaceFormat.RgbPvrtc4Bpp);
case DataFormat.PVRTCI_2bpp_RGBA:
return(SurfaceFormat.RgbaPvrtc2Bpp);
case DataFormat.PVRTCI_4bpp_RGBA:
return(SurfaceFormat.RgbaPvrtc4Bpp);
case DataFormat.ETC1:
return(SurfaceFormat.RgbEtc1);
//case DataFormat.ATC_RGB: Not supported in MonoGame.
case DataFormat.ATC_RGBA_EXPLICIT_ALPHA:
return(SurfaceFormat.RgbaAtcExplicitAlpha);
case DataFormat.ATC_RGBA_INTERPOLATED_ALPHA:
return(SurfaceFormat.RgbaAtcInterpolatedAlpha);
default:
string message = string.Format(CultureInfo.InvariantCulture, "The texture format {0} is not supported in MonoGame.", format);
throw new NotSupportedException(message);
// Not supported:
// SurfaceFormat.Dxt1a = 70
}
}
/// <summary>
/// Creates a new ValueMember instance
/// </summary>
public ValueMember(RuntimeTypeModel model, Type parentType, int fieldNumber, MemberInfo member, Type memberType, Type itemType, Type defaultType, DataFormat dataFormat, object defaultValue)
: this(model, fieldNumber, memberType, itemType, defaultType, dataFormat)
{
if (parentType == null)
{
throw new ArgumentNullException(nameof(parentType));
}
if (fieldNumber < 1 && !parentType.IsEnum)
{
throw new ArgumentOutOfRangeException(nameof(fieldNumber));
}
Member = member ?? throw new ArgumentNullException(nameof(member));
ParentType = parentType;
if (fieldNumber < 1 && !parentType.IsEnum)
{
throw new ArgumentOutOfRangeException(nameof(fieldNumber));
}
if (defaultValue != null && (defaultValue.GetType() != memberType))
{
defaultValue = ParseDefaultValue(memberType, defaultValue);
}
_defaultValue = defaultValue;
MetaType type = model.FindWithoutAdd(memberType);
#if FEAT_DYNAMIC_REF
if (type != null)
{
AsReference = type.AsReferenceDefault;
}
else
{ // we need to scan the hard way; can't risk recursion by fully walking it
AsReference = MetaType.GetAsReferenceDefault(memberType);
}
#endif
}
/// <summary>
/// Creates a new ValueMember instance
/// </summary>
internal ValueMember(RuntimeTypeModel model, int fieldNumber, Type overrideType, Type memberType, Type itemType, Type defaultType, DataFormat dataFormat)
{
if (memberType == null)
{
throw new ArgumentNullException("memberType");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
this.fieldNumber = fieldNumber;
this.overrideType = overrideType;
this.memberType = memberType;
this.itemType = itemType;
this.defaultType = defaultType;
this.model = model;
this.dataFormat = dataFormat;
}
private static async Task <CityData> FormatResult(CityData _CityData, DataFormat _DataFormat)
{
var loader = new ResourceLoader();
var dateTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
var _Visibility = Convert.ToDouble(_CityData.Current.visibility) / 1000;
_CityData.Current.Date = dateTime.AddSeconds(_CityData.Current.dt).ToLocalTime().ToString("ddd, dd MMM");
if (_DataFormat.TimeFormat == "24h")
{
_CityData.Current.SunriseSunset = dateTime.AddSeconds(_CityData.Current.sys.sunrise).ToLocalTime().ToString("H:mm") + "/" + dateTime.AddSeconds(_CityData.Current.sys.sunset).ToLocalTime().ToString("H:mm");
}
else
{
_CityData.Current.SunriseSunset = dateTime.AddSeconds(_CityData.Current.sys.sunrise).ToLocalTime().ToString("h:mmtt") + "/" + dateTime.AddSeconds(_CityData.Current.sys.sunset).ToLocalTime().ToString("h:mmtt");
}
if (_DataFormat.UnitsFormat == "metric")
{
_CityData.Current.wind.speed = _CityData.Current.wind.speed + loader.GetString("MeterSec");
_CityData.Current.visibility = _Visibility + loader.GetString("Kilometer");
}
else
{
_CityData.Current.wind.speed = _CityData.Current.wind.speed + loader.GetString("MileHour");
_CityData.Current.visibility = Math.Round(_Visibility * 0.62, 0) + loader.GetString("Mile");
}
StorageFolder _assets = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFolderAsync("Assets");
StorageFolder _icons = await _assets.GetFolderAsync("Icons");
_CityData.Current.main.temp = Math.Round(_CityData.Current.main.temp, 0);
_CityData.Current.main.pressure = _CityData.Current.main.pressure + loader.GetString("PressureUnit");
_CityData.Current.weather[0].description = char.ToUpper(_CityData.Current.weather[0].description[0]) + _CityData.Current.weather[0].description.Substring(1);
if (await _icons.TryGetItemAsync(_CityData.Current.weather[0].icon + ".png") != null)
{
_CityData.Current.Image = "ms-appx:///Assets/Icons/" + _CityData.Current.weather[0].icon + ".png";
}
else
{
_CityData.Current.Image = "ms-appx:///Assets/Icons/02n.png";
}
foreach (var item in _CityData.Hourly.list)
{
item.Date = dateTime.AddSeconds(item.dt).ToLocalTime().ToString("ddd, H:mm");
if (await _icons.TryGetItemAsync(item.weather[0].icon + ".png") != null)
{
item.Image = "ms-appx:///Assets/Icons/" + item.weather[0].icon + ".png";
}
else
{
item.Image = "ms-appx:///Assets/Icons/02n.png";
}
item.main.temp = Math.Round(item.main.temp, 1);
item.weather[0].description = char.ToUpper(item.weather[0].description[0]) + item.weather[0].description.Substring(1);
}
foreach (var item in _CityData.DailyForecast.list)
{
item.temp.min = Math.Round(item.temp.min, 0);
item.temp.max = Math.Round(item.temp.max, 0);
item.Day = dateTime.AddSeconds(item.dt).ToLocalTime().ToString("ddd");
if (await _icons.TryGetItemAsync(item.weather[0].icon + ".png") != null)
{
item.Image = "ms-appx:///Assets/Icons/" + item.weather[0].icon + ".png";
}
else
{
item.Image = "ms-appx:///Assets/Icons/02n.png";
}
item.weather[0].description = char.ToUpper(item.weather[0].description[0]) + item.weather[0].description.Substring(1);
}
return(_CityData);
}
/// <summary>
/// Imports timecard data from the given string; raises ProgressUpdated event as timecards are imported
/// </summary>
/// <param name="content">The data to be imported, in given format</param>
/// <param name="format">Enum value corresponding to CSV, TSV, JSON, or XML format</param>
/// <returns>String containing error message (if any) encountered during import</returns>
public string Import(string content, DataFormat format)
{
string[] lines;
Dictionary <string, int> columnMap;
var allowedColumnNames = new List <string> {
"date", "code", "description", "time", "isaftermidnight"
};
var report = new StringBuilder();
var repo = _factory.Resolve <IRepository>();
switch (format)
{
case DataFormat.CSV:
case DataFormat.TSV:
var separator = (format == DataFormat.CSV ? ',' : '\t');
lines = content.Replace("\r", string.Empty).Split('\n');
if (lines.Length < 1)
{
report.AppendLine("Content contains no lines of text");
break;
}
columnMap = ParseColumnMap(lines[0], separator, allowedColumnNames);
var someFieldsAreMissing = false;
for (var i = 0; i < allowedColumnNames.Count - 1; ++i)
{
if (!columnMap.ContainsKey(allowedColumnNames[i]))
{
report.AppendLine($"Content missing column name '{allowedColumnNames[i]}' on first line");
someFieldsAreMissing = true;
}
}
if (someFieldsAreMissing)
{
break;
}
// parse and store, raising event for progress
Timecard tc = null;
var lastDateString = "zzzz";
for (var i = 1; i < lines.Length; ++i)
{
var eventArgs = new ProgressUpdateEventArgs(i + 1, lines.Length);
OnProgressUpdated(eventArgs);
if (eventArgs.Cancel)
{
report.AppendLine("Import was canceled by the user");
break;
}
if (string.IsNullOrWhiteSpace(lines[i]))
{
continue;
}
var tokens = Split(lines[i], separator);
if (tokens[columnMap["date"]] != lastDateString)
{
lastDateString = tokens[columnMap["date"]];
if (tc != null)
{
repo.SaveTimecard(tc);
}
tc = new Timecard();
tc.Activities.DataImportMode = true;
if (DateTime.TryParse(StripQuotes(lastDateString), out DateTime newDate))
{
tc.Date = newDate;
}
else
{
report.AppendLine($"Could not parse value {lastDateString} as date on line {i + 1}");
break;
}
}
var activity = new Activity
{
Code = StripQuotes(tokens[columnMap["code"]]),
Description = StripQuotes(tokens[columnMap["description"]]),
Time = StripQuotes(tokens[columnMap["time"]])
};
if (columnMap.ContainsKey("isaftermidnight"))
{
if (Boolean.TryParse(StripQuotes(tokens[columnMap["isaftermidnight"]]), out bool newIsAfterMidnight))
{
activity.IsAfterMidnight = newIsAfterMidnight;
}
else
{
report.AppendLine(
$"Could not parse value {tokens[columnMap["isaftermidnight"]]} as boolean on line {i + 1}");
break;
}
}
else
{
activity.IsAfterMidnight = false;
}
tc.Activities.Add(activity);
}
if (tc != null && tc.IsDirty)
{
repo.SaveTimecard(tc);
}
break;
case DataFormat.JSON:
List <Timecard> tcList;
try
{
// all the parsing work is assumed to be done by the JsonConvert class
tcList = JsonConvert.DeserializeObject <List <Timecard> >(content);
}
catch (Exception ex)
{
report.AppendLine($"Error occurred while parsing JSON data: {ex.Message}");
break;
}
for (var i = 0; i < tcList.Count; ++i)
{
var eventArgs = new ProgressUpdateEventArgs(i + 1, tcList.Count);
OnProgressUpdated(eventArgs);
if (eventArgs.Cancel)
{
report.AppendLine("Import was canceled by the user");
break;
}
repo.SaveTimecard(tcList[i]);
}
break;
case DataFormat.XML:
var xdoc = new XmlDocument();
try
{
xdoc.LoadXml(content);
}
catch (Exception ex)
{
report.AppendLine($"Error occurred while parsing XML data: {ex.Message}");
break;
}
var root = xdoc.SelectSingleNode("/Timecards");
if (root?.Name != "Timecards")
{
report.AppendLine("Root node in XML data not named \"Timecards\"");
break;
}
if (root.HasChildNodes)
{
for (var i = 0; i < root.ChildNodes.Count; i++)
{
var eventArgs = new ProgressUpdateEventArgs(i + 1, root.ChildNodes.Count);
OnProgressUpdated(eventArgs);
if (eventArgs.Cancel)
{
report.AppendLine("Import was canceled by the user");
break;
}
var tcNode = root.ChildNodes[i];
if (tcNode.Name != "Timecard")
{
report.AppendLine("Expected parent node in XML data not named \"Timecard\"");
break;
}
var tcAttributes = tcNode.Attributes;
var tcAttrDate = tcAttributes["Date"];
if (tcAttrDate == null)
{
report.AppendLine($"Timecard node {i} missing Date attribute");
break;
}
tc = new Timecard();
tc.Activities.DataImportMode = true;
if (DateTime.TryParse(tcAttributes["Date"].Value, out DateTime newDate))
{
tc.Date = newDate;
}
else
{
report.AppendLine(
$"Timecard node {i} Date attribute value \"{tcAttributes["Date"].Value}\" could not be parsed");
break;
}
if (tcNode.HasChildNodes)
{
var acCollNode = tcNode.ChildNodes[0];
if (acCollNode.HasChildNodes)
{
for (var j = 0; j < acCollNode.ChildNodes.Count; ++j)
{
var acNode = acCollNode.ChildNodes[j];
var activity = new Activity
{
Code = $"{acNode.Attributes["Code"]?.Value}",
Description = $"{acNode.Attributes["Description"]?.Value}",
Time = $"{acNode.Attributes["Time"]?.Value}"
};
if (Boolean.TryParse($"{ acNode.Attributes["IsAfterMidnight"]?.Value}",
out bool newIsAfterMidnight))
{
activity.IsAfterMidnight = newIsAfterMidnight;
}
tc.Activities.Add(activity);
}
}
}
repo.SaveTimecard(tc);
}
}
break;
default:
throw new Exception("Unhandled data format encountered");
}
return(report.ToString());
}
public Deserializer(DataFormat format)
{
dataFormat = format;
}
/// <summary>
/// Creates a new ValueMember instance
/// </summary>
public ValueMember(RuntimeTypeModel model, Type parentType, int fieldNumber, MemberInfo member, Type overrideType, Type memberType, Type itemType, Type defaultType, DataFormat dataFormat, object defaultValue)
: this(model, fieldNumber, overrideType, memberType, itemType, defaultType, dataFormat)
{
if (member == null)
{
throw new ArgumentNullException("member");
}
if (parentType == null)
{
throw new ArgumentNullException("parentType");
}
if (fieldNumber < 1 && !Helpers.IsEnum(parentType))
{
throw new ArgumentOutOfRangeException("fieldNumber");
}
this.member = member;
this.parentType = parentType;
if (fieldNumber < 1 && !Helpers.IsEnum(parentType))
{
throw new ArgumentOutOfRangeException("fieldNumber");
}
//#if WINRT
if (defaultValue != null && model.MapType(defaultValue.GetType()) != memberType)
//#else
// if (defaultValue != null && !memberType.IsInstanceOfType(defaultValue))
//#endif
{
defaultValue = ParseDefaultValue(memberType, defaultValue);
}
this.defaultValue = defaultValue;
MetaType type = model.FindWithoutAdd(memberType);
if (type != null)
{
this.asReference = type.AsReferenceDefault;
}
else
{ // we need to scan the hard way; can't risk recursion by fully walking it
this.asReference = MetaType.GetAsReferenceDefault(model, memberType);
}
}
private ContentType(string name, DataFormat format)
{
Name = name;
Format = format;
}
private static void CreateHttpContentTestInput(DataFormat inputFormat, DataFormat outputFormat, Random rndGen, out HttpMethod method, out HttpContent content, out JObject expectedResult, out Dictionary <string, string> headers, out Dictionary <string, string> query, out HttpStatusCode expectedStatus)
{
method = CreateHttpMethod(rndGen);
content = null;
expectedResult = new JObject();
expectedResult.Add("method", method.Method);
expectedResult.Add("user", new JObject(new JProperty("level", "anonymous")));
JToken body = null;
string textBody = null;
if (method.Method != "GET" && method.Method != "DELETE")
{
body = CreateJson(rndGen);
if (outputFormat == DataFormat.Xml || inputFormat == DataFormat.Xml)
{
// to prevent non-XML names from interfering with checks
body = SanitizeJsonXml(body);
}
switch (inputFormat)
{
case DataFormat.Json:
// JSON
content = new StringContent(body.ToString(), Encoding.UTF8, "application/json");
break;
case DataFormat.Xml:
textBody = JsonToXml(body);
content = new StringContent(textBody, Encoding.UTF8, "text/xml");
break;
default:
textBody = body.ToString().Replace("{", "<").Replace("}", ">").Replace("[", "__[__").Replace("]", "__]__");
content = new StringContent(textBody, Encoding.UTF8, "text/plain");
break;
}
}
if (body != null)
{
if (inputFormat == DataFormat.Json)
{
expectedResult.Add("body", body);
}
else
{
expectedResult.Add("body", textBody);
}
}
headers = new Dictionary <string, string>();
var choice = rndGen.Next(5);
for (int j = 0; j < choice; j++)
{
string name = "x-test-zumo-" + j;
string value = CreateString(rndGen, 1, 10, Letters);
headers.Add(name, value);
}
query = CreateQueryParams(rndGen) ?? new Dictionary <string, string>();
if (query.Count > 0)
{
JObject outputQuery = new JObject();
expectedResult.Add("query", outputQuery);
foreach (var kvp in query)
{
outputQuery.Add(kvp.Key, kvp.Value);
}
}
query.Add("format", outputFormat.ToString().ToLowerInvariant());
expectedStatus = HttpStatusCode.OK;
if (rndGen.Next(4) == 0)
{
// non-200 responses
int[] options = new[] { 400, 404, 500, 201 };
int status = options[rndGen.Next(options.Length)];
expectedStatus = (HttpStatusCode)status;
query.Add("status", status.ToString(CultureInfo.InvariantCulture));
}
}
/// <summary>
/// Exports timecard data in given date range to a string in the given format
/// </summary>
/// <param name="startDate">Low end of date range</param>
/// <param name="endDate">High end of date range</param>
/// <param name="format">Enum value corresponding to CSV, TSV, JSON, or XML format</param>
/// <returns>String of data encoded in given format</returns>
public string Export(DateTime?startDate, DateTime?endDate, DataFormat format)
{
var repo = _factory.Resolve <IRepository>();
// retrieve the timecards to be exported
var tcList = repo.GetTimecards(startDate, endDate);
using (var sw = new StringWriter())
{
// transform the data
switch (format)
{
case DataFormat.CSV:
sw.WriteLine("Date,Code,Description,Time,IsAfterMidnight");
foreach (var tc in tcList)
{
foreach (var ac in tc.Activities)
{
sw.WriteLine($"\"{tc.Date:yyyy-MM-dd}\",\"{ac.Code}\",\"{ac.Description}\",\"{ac.Time}\",{ac.IsAfterMidnight}");
}
}
break;
case DataFormat.TSV:
sw.WriteLine("Date\tCode\tDescription\tTime\tIsAfterMidnight");
foreach (var tc in tcList)
{
foreach (var ac in tc.Activities)
{
sw.WriteLine($"{tc.Date:yyyy-MM-dd}\t{ac.Code}\t{ac.Description}\t{ac.Time}\t{ac.IsAfterMidnight}");
}
}
break;
case DataFormat.JSON:
var jsonSettings = new JsonSerializerSettings
{
DateFormatString = "yyyy-MM-dd",
Formatting = Newtonsoft.Json.Formatting.Indented,
};
sw.WriteLine(JsonConvert.SerializeObject(tcList, jsonSettings));
break;
case DataFormat.XML:
XmlAttribute attr;
var xdoc = new XmlDocument();
var rootNode = xdoc.CreateElement("Timecards");
xdoc.AppendChild(rootNode);
foreach (var tc in tcList)
{
var tcNode = xdoc.CreateElement("Timecard");
attr = xdoc.CreateAttribute("Date");
attr.Value = tc.Date.ToString("yyyy-MM-dd");
tcNode.Attributes.Append(attr);
var acsNode = xdoc.CreateElement("Activities");
foreach (var ac in tc.Activities)
{
var acNode = xdoc.CreateElement("Activity");
acNode
.AddAttribute("Code", ac.Code)
.AddAttribute("Description", ac.Description)
.AddAttribute("Time", ac.Time)
.AddAttribute("IsAfterMidnight", ac.IsAfterMidnight.ToString());
acsNode.AppendChild(acNode);
}
tcNode.AppendChild(acsNode);
rootNode.AppendChild(tcNode);
}
xdoc.Save(sw);
break;
default:
throw new Exception("Unhandled data format encountered");
}
return(sw.ToString());
}
}
protected override void OnBeforeInit(int tag, ref DataFormat format)
{
innerProperty = PropertyFactory.CreatePassThru <TValue>(tag, ref format);
base.OnBeforeInit(tag, ref format);
}
/// <summary>
/// Creates a new ValueMember instance
/// </summary>
internal ValueMember(RuntimeTypeModel model, int fieldNumber, Type memberType, Type itemType, Type defaultType, DataFormat dataFormat)
{
FieldNumber = fieldNumber;
MemberType = memberType ?? throw new ArgumentNullException(nameof(memberType));
ItemType = itemType;
if (defaultType == null && itemType != null)
{ // reasonable default
defaultType = memberType;
}
DefaultType = defaultType;
this.model = model ?? throw new ArgumentNullException(nameof(model));
this.dataFormat = dataFormat;
}
public List <SalesReturnVoucherModel> GetAllSalesReturn()
{
List <SalesReturnVoucherModel> lstSR = new List <SalesReturnVoucherModel>();
SalesReturnVoucherModel objsales;
string Query = "SELECT * FROM Trans_SalesReturn";
System.Data.IDataReader dr = _dbHelper.ExecuteDataReader(Query, _dbHelper.GetConnObject());
while (dr.Read())
{
objsales = new SalesReturnVoucherModel();
objsales.SR_Id = DataFormat.GetInteger(dr["SR_Id"]);
objsales.Series = dr["Series"].ToString();
objsales.SR_Date = DataFormat.GetDateTime(dr["SR_Date"]);
objsales.Voucher_Number = DataFormat.GetInteger(dr["VoucherNo"]);
objsales.SalesType = dr["SalesType"].ToString();
objsales.Party = dr["Party"].ToString();
objsales.MatCenter = dr["MatCentre"].ToString();
objsales.Narration = dr["Narration"].ToString();
//objsales. = Convert.ToDecimal(dr["TotalQty"]);
//objsales.TotalAmount = Convert.ToDecimal(dr["TotalAmount"]);
//objsales.BSTotalAmount = Convert.ToDecimal(dr["BSTotalAmount"]);
//SELECT Sales Items
string itemQuery = "SELECT * FROM Trans_SalesReturn_Item WHERE SR_Id=" + objsales.SR_Id;
System.Data.IDataReader drItem = _dbHelper.ExecuteDataReader(itemQuery, _dbHelper.GetConnObject());
objsales.Item_Voucher = new List <Item_VoucherModel>();
Item_VoucherModel objItemModel;
while (drItem.Read())
{
objItemModel = new Item_VoucherModel();
objItemModel.ParentId = DataFormat.GetInteger(drItem["TransSRId"]);
objItemModel.Item_ID = DataFormat.GetInteger(drItem["ItemId"]);
objItemModel.Item = drItem["Item"].ToString();
objItemModel.Price = Convert.ToDecimal(drItem["Price"]);
objItemModel.Qty = Convert.ToDecimal(drItem["Qty"]);
objItemModel.Unit = drItem["Unit"].ToString();
objItemModel.Amount = Convert.ToDecimal(drItem["Amount"]);
objItemModel.TotalQty = Convert.ToDecimal(drItem["TotalQty"]);
objItemModel.TotalAmount = Convert.ToDecimal(drItem["TotalAmount"]);
objsales.Item_Voucher.Add(objItemModel);
}
//SELECT Bill Sundry Voucher items
string bsQuery = "SELECT * FROM Trans_SalesReturn_BS WHERE TransSRId=" + objsales.SR_Id;
System.Data.IDataReader drBS = _dbHelper.ExecuteDataReader(bsQuery, _dbHelper.GetConnObject());
objsales.BillSundry_Voucher = new List <BillSundry_VoucherModel>();
BillSundry_VoucherModel objBSModel;
while (drBS.Read())
{
objBSModel = new BillSundry_VoucherModel();
objBSModel.ParentId = DataFormat.GetInteger(drBS["TransSRId"]);
objBSModel.BSId = DataFormat.GetInteger(drBS["BSId"]);
objBSModel.BillSundry = drBS["BillSundry"].ToString();
objBSModel.Percentage = Convert.ToDecimal(drBS["Percentage"]);
objBSModel.Amount = Convert.ToDecimal(drBS["Amount"]);
objBSModel.TotalAmount = Convert.ToDecimal(drBS["TotalAmount"]);
objsales.BillSundry_Voucher.Add(objBSModel);
}
lstSR.Add(objsales);
}
return(lstSR);
}
private async Task customApiDataTest(DataFormat inputFormat, DataFormat outputFormat, Random seedGenerator)
{
for (int i = 0; i < 10; i++)
{
int seed = seedGenerator.Next();
Random rndGen = new Random(seed);
JToken body = CreateJson(rndGen);
Dictionary <string, string> headers = new Dictionary <string, string>()
{
{ "aa", "" }
};
CreateHttpContentTestInput(inputFormat, outputFormat, rndGen, out HttpMethod method, out HttpContent content,
out JObject expectedResult, out headers, out Dictionary <string, string> query, out HttpStatusCode expectedStatus);
using (HttpResponseMessage response = await InvokeApiAsync(AppApiName, content, method, headers, query))
{
ValidateResponseHeader(expectedStatus, headers, response);
string responseContent = null;
if (response.Content != null)
{
responseContent = await response.Content.ReadAsStringAsync();
}
JToken jsonResponse = null;
if (outputFormat == DataFormat.Json)
{
jsonResponse = JToken.Parse(responseContent);
}
else if (outputFormat == DataFormat.Other)
{
string decodedContent = responseContent
.Replace("__{__", "{")
.Replace("__}__", "}")
.Replace("__[__", "[")
.Replace("__]__", "]");
jsonResponse = JToken.Parse(decodedContent);
}
bool contentIsExpected = false;
List <string> errors = new List <string>();
switch (outputFormat)
{
case DataFormat.Json:
case DataFormat.Other:
contentIsExpected = CompareJson(expectedResult, jsonResponse, errors);
break;
case DataFormat.Xml:
string expectedResultContent = JsonToXml(expectedResult);
// Normalize CRLF
expectedResultContent = expectedResultContent.Replace("\r\n", "\n");
responseContent = responseContent.Replace("\r\n", "\n");
Assert.Equal(expectedResultContent, responseContent);
break;
}
}
}
}
public ActionResult OEmbed(string url, int maxwidth = 570, int maxheight = 400, DataFormat format = DataFormat.Json, bool responsiveWrapper = false)
{
if (string.IsNullOrEmpty(url))
{
return(HttpStatusCodeResult(HttpStatusCode.BadRequest, "URL must be specified"));
}
var entryId = entryUrlParser.Parse(url);
if (entryId.IsEmpty)
{
return(HttpStatusCodeResult(HttpStatusCode.BadRequest, "Invalid URL"));
}
if (entryId.EntryType != EntryType.Song)
{
return(HttpStatusCodeResult(HttpStatusCode.BadRequest, "Only song embeds are supported"));
}
var id = entryId.Id;
var song = songService.GetSongForApi(entryId.Id, SongOptionalFields.ThumbUrl);
var src = VocaUriBuilder.CreateAbsolute(Url.Action("EmbedSong", new { songId = id })).ToString();
string html;
if (responsiveWrapper)
{
html = RenderPartialViewToString("OEmbedResponsive", new OEmbedParams {
Width = maxwidth, Height = maxheight, Src = src
});
}
else
{
html = string.Format("<iframe src=\"{0}\" width=\"{1}\" height=\"{2}\"></iframe>", src, maxwidth, maxheight);
}
return(Object(new SongOEmbedResponse(song, maxwidth, maxheight, html), format));
}
public virtual string DataPath(DataFormat dataFormat)
{
var extension = dataFormat.ToString().ToLower();
return(ex.GetDataPath(ext: extension, searchext: extension));
}
/// <summary>
/// Responsible for deciding how to encode/decode a given data-type; maybe
/// not the most elegant solution, but it is simple and quick.
/// </summary>
private static Property <T> CreateProperty <T>(Type type, ref DataFormat format, MemberSerializationOptions options)
{
if (type.IsEnum)
{
if (format != DataFormat.Default && Attribute.IsDefined(type, typeof(FlagsAttribute)))
{
type = Enum.GetUnderlyingType(type);
}
else
{
format = DataFormat.TwosComplement;
return(PropertyUtil <T> .CreateTypedProperty("CreatePropertyEnum", type));
}
}
if (type == typeof(int))
{
switch (format)
{
case DataFormat.Default:
case DataFormat.TwosComplement:
format = DataFormat.TwosComplement;
return(new PropertyInt32Variant <T>());
case DataFormat.ZigZag:
return(new PropertyInt32ZigZag <T>());
case DataFormat.FixedSize:
return(new PropertyInt32Fixed <T>());
}
}
if (type == typeof(short))
{
switch (format)
{
case DataFormat.Default:
case DataFormat.TwosComplement:
format = DataFormat.TwosComplement;
return(new PropertyInt16Variant <T>());
case DataFormat.ZigZag:
return(new PropertyInt16ZigZag <T>());
}
}
if (type == typeof(long))
{
switch (format)
{
case DataFormat.Default:
case DataFormat.TwosComplement:
format = DataFormat.TwosComplement;
return(new PropertyInt64Variant <T>());
case DataFormat.ZigZag:
return(new PropertyInt64ZigZag <T>());
case DataFormat.FixedSize:
return(new PropertyInt64Fixed <T>());
}
}
if (type == typeof(uint))
{
switch (format)
{
case DataFormat.Default:
case DataFormat.TwosComplement:
format = DataFormat.TwosComplement;
return(new PropertyUInt32Variant <T>());
case DataFormat.FixedSize:
return(new PropertyUInt32Fixed <T>());
}
}
if (type == typeof(ulong))
{
switch (format)
{
case DataFormat.Default:
case DataFormat.TwosComplement:
format = DataFormat.TwosComplement;
return(new PropertyUInt64Variant <T>());
case DataFormat.FixedSize:
return(new PropertyUInt64Fixed <T>());
}
}
if (type == typeof(ushort))
{
switch (format)
{
case DataFormat.Default:
case DataFormat.TwosComplement:
format = DataFormat.TwosComplement;
return(new PropertyUInt16Variant <T>());
}
}
if (type == typeof(byte[]))
{
format = DataFormat.Default; return(new PropertyBlob <T>());
}
if (type == typeof(byte))
{
format = DataFormat.TwosComplement; return(new PropertyByte <T>());
}
if (type == typeof(sbyte))
{
format = DataFormat.ZigZag; return(new PropertySByte <T>());
}
if (type == typeof(char))
{
format = DataFormat.TwosComplement; return(new PropertyChar <T>());
}
if (type == typeof(bool))
{
format = DataFormat.TwosComplement; return(new PropertyBoolean <T>());
}
if (type == typeof(string))
{
format = DataFormat.Default; return(new PropertyString <T>());
}
if (type == typeof(float))
{
format = DataFormat.FixedSize; return(new PropertySingle <T>());
}
if (type == typeof(double))
{
format = DataFormat.FixedSize; return(new PropertyDouble <T>());
}
if (type == typeof(Uri))
{
format = DataFormat.Default; return(new PropertyUri <T>());
}
if (type == typeof(Guid))
{
switch (format)
{
case DataFormat.Group: return(new PropertyGuidGroup <T>());
case DataFormat.Default: return(new PropertyGuidString <T>());
}
}
if (type == typeof(TimeSpan))
{
switch (format)
{
case DataFormat.Group: return(new PropertyTimeSpanGroup <T>());
case DataFormat.Default: return(new PropertyTimeSpanString <T>());
case DataFormat.FixedSize: return(new PropertyTimeSpanFixed <T>());
}
}
if (type == typeof(DateTime))
{
switch (format)
{
case DataFormat.Group: return(new PropertyDateTimeGroup <T>());
case DataFormat.Default: return(new PropertyDateTimeString <T>());
case DataFormat.FixedSize: return(new PropertyDateTimeFixed <T>());
}
}
if (type == typeof(decimal))
{
switch (format)
{
case DataFormat.Group: return(new PropertyDecimalGroup <T>());
case DataFormat.Default: return(new PropertyDecimalString <T>());
}
}
if (Serializer.IsEntityType(type))
{
Type baseType = type;
while (Serializer.IsEntityType(baseType.BaseType))
{
baseType = baseType.BaseType;
}
switch (format)
{
case DataFormat.Default: return(PropertyUtil <T> .CreateTypedProperty("CreatePropertyMessageString", type, baseType, baseType));
case DataFormat.Group: return(PropertyUtil <T> .CreateTypedProperty("CreatePropertyMessageGroup", type, baseType, baseType));
}
}
if (type.IsValueType && type.IsGenericType && type.GetGenericTypeDefinition() == typeof(KeyValuePair <,>))
{
return(PropertyUtil <T> .CreateTypedProperty("CreatePropertyPairString", type.GetGenericArguments()));
}
bool isEnumerableOnly;
Type listItemType = GetListType(type, out isEnumerableOnly);
if (type.IsArray)
{
// verify that we can handle it
if (type.GetArrayRank() != 1)
{
throw new NotSupportedException("Only 1-dimensional arrays can be used; consider an array/list of a class-type instead");
}
}
if (listItemType != null && listItemType != typeof(byte[]))
{
bool dummy;
if (GetListType(listItemType, out dummy) != null)
{
throw new NotSupportedException("Nested (jagged) arrays/lists are not supported (except for byte[]); consider an array/list of a class-type with an inner array/list instead");
}
}
if (type == typeof(byte[]))
{ // want to treat byte[] as a special case
listItemType = null;
}
if (type.IsArray && listItemType != null) // second check is for byte[]
{
return(PropertyUtil <T> .CreateTypedProperty(
(PropertyFactory.HasOption(options, MemberSerializationOptions.Packed)
? "CreatePropertyPackedArray" : "CreatePropertyArray"), listItemType));
}
if (listItemType != null)
{
if (isEnumerableOnly)
{
if (GetAddMethod(type, listItemType) != null)
{
return(PropertyUtil <T> .CreateTypedProperty(
(PropertyFactory.HasOption(options, MemberSerializationOptions.Packed)
? "CreatePropertyPackedEnumerable" : "CreatePropertyEnumerable"), type, listItemType));
}
}
else
{
return(PropertyUtil <T> .CreateTypedProperty(
(PropertyFactory.HasOption(options, MemberSerializationOptions.Packed)
? "CreatePropertyPackedList" : "CreatePropertyList"), type, listItemType));
}
}
Type nullType = Nullable.GetUnderlyingType(type);
if (nullType != null)
{
return(PropertyUtil <T> .CreateTypedProperty("CreatePropertyNullable", nullType));
}
if (format == DataFormat.Default && GetParseMethod(type) != null)
{
return(PropertyUtil <T> .CreateTypedProperty("CreatePropertyParseable", type));
}
throw Serializer.ThrowNoEncoder(format, type);
}
