public void Process() { using(SpreadsheetDocument spreadsheetDocument = SpreadsheetDocument.Create(@"D:\product.xlsx", SpreadsheetDocumentType.Workbook)) { var excelExportContext = new ExportContext(spreadsheetDocument); uint rowNo = 0; foreach(var product in _products) { rowNo++; if(product.Price > 44) { product.MapColumn<Product>(x => x.Description, "F"); product.MapStyle<Product>(x => x.Name, new CellFill(hexColor: "FFFF0000")); } if(product.Price < 33) { product.MapStyle<Product>(x => x.Code, new CellBorder(left: true, right: true)); } excelExportContext.RenderEntity(product, rowNo); } excelExportContext.SaveChanges(); } }
protected override void ExportData(System.Xml.XmlWriter writer, ExportContext context) { object data = GetData(); var stringData = data as string; if (stringData != null) { writer.WriteString(stringData); return; } var listData = data as List<string>; if (listData != null) { string output = String.Join(";", listData.ToArray()); writer.WriteString(output); return; } var enumerableData = data as IEnumerable; if (enumerableData != null) { var sb = new StringBuilder(); foreach (var item in enumerableData) { if (sb.Length != 0) sb.Append(";"); sb.Append(Convert.ToString(item, CultureInfo.InvariantCulture)); } writer.WriteString(sb.ToString()); return; } throw ExportNotImplementedException(data); }
protected override void ExportData(System.Xml.XmlWriter writer, ExportContext context) { var data = GetData(); var node = data as Node; if (node != null) { writer.WriteStartElement("Path"); writer.WriteString(node.Path); if (context != null) context.AddReference(node.Path); writer.WriteEndElement(); return; } var nodes = data as IEnumerable; if (nodes != null) { foreach (Node item in nodes) { writer.WriteStartElement("Path"); writer.WriteString(item.Path); if (context != null) context.AddReference(item.Path); writer.WriteEndElement(); } return; } throw ExportNotImplementedException(GetData()); }
// TODO: sort out argument order, etc, with superclass public GenericExportingReflectiveTypeData( ExportContext ctx, Type fullType, TypeData baseType, TypeData[] args) : base(fullType, ctx) { _baseType = baseType; _args = args; }
public static string CreateFromDataContractSerializer(Type type, MemberInfo[] pathToMember, StringBuilder rootElementXpath, out XmlNamespaceManager namespaces) { ExportContext context; if (type == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("type")); } if (pathToMember == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("pathToMember")); } DataContract dataContract = DataContract.GetDataContract(type); if (rootElementXpath == null) { context = new ExportContext(dataContract); } else { context = new ExportContext(rootElementXpath); } for (int i = 0; i < pathToMember.Length; i++) { dataContract = ProcessDataContract(dataContract, context, pathToMember[i]); } namespaces = context.Namespaces; return context.XPath; }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { Debug.Assert(value != null); Debug.Assert(writer != null); ExportTime((DateTime) value, writer); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(value != null); Debug.Assert(writer != null); if (_properties.Count == 0) { writer.WriteString(value.ToString()); } else { writer.WriteStartObject(); foreach (PropertyDescriptor property in _properties) { object propertyValue = property.GetValue(value); if (!JsonNull.LogicallyEquals(propertyValue)) { writer.WriteMember(property.Name); context.Export(propertyValue, writer); } } writer.WriteEndObject(); } }
// Here you can provide your own root element Xpath which will replace the Xpath of the top level element public static string CreateFromDataContractSerializer(Type type, MemberInfo[] pathToMember, StringBuilder rootElementXpath, out XmlNamespaceManager namespaces) { if (type == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("type")); } if (pathToMember == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("pathToMember")); } DataContract currentContract = DataContract.GetDataContract(type); ExportContext context; if (rootElementXpath == null) { context = new ExportContext(currentContract); } else { // use the provided xpath for top level element context = new ExportContext(rootElementXpath); } for (int pathToMemberIndex = 0; pathToMemberIndex < pathToMember.Length; pathToMemberIndex++) { currentContract = ProcessDataContract(currentContract, context, pathToMember[pathToMemberIndex]); } namespaces = context.Namespaces; return context.XPath; }
private static void ExportDataSet(ExportContext context, DataSet dataSet, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(dataSet != null); Debug.Assert(writer != null); writer.WriteStartObject(); foreach (DataTable table in dataSet.Tables) { writer.WriteMember(table.TableName); // // If there is an exporter (perhaps an override) for the // DataTable in effect then use it. Otherwise our // DataTableExporter. // IExporter tableExporter = context.FindExporter(table.GetType()); if (tableExporter != null) tableExporter.Export(context, table, writer); else DataTableExporter.ExportTable(context, table, writer); } writer.WriteEndObject(); }
public string Export(IEnumerable<string> contentTypes, IEnumerable<ContentItem> contentItems, ExportOptions exportOptions) { var exportDocument = CreateExportRoot(); var context = new ExportContext { Document = exportDocument, ContentTypes = contentTypes, ExportOptions = exportOptions }; _exportEventHandlers.Invoke(x => x.Exporting(context), Logger); if (exportOptions.ExportMetadata && (!exportOptions.ExportData || contentItems.Any())) { exportDocument.Element("Orchard").Add(ExportMetadata(contentTypes)); } if (exportOptions.ExportSiteSettings) { exportDocument.Element("Orchard").Add(ExportSiteSettings()); } if (exportOptions.ExportData && contentItems.Any()) { exportDocument.Element("Orchard").Add(ExportData(contentTypes, contentItems, exportOptions.ImportBatchSize)); } _exportEventHandlers.Invoke(x => x.Exported(context), Logger); return WriteExportFile(exportDocument.ToString()); }
private static void ResolveFluentMethod(ExportContext context) { if (string.IsNullOrEmpty(_parameters.ConfigurationMethod)) return; var methodPath = _parameters.ConfigurationMethod; var path = new Stack<string>(methodPath.Split('.')); var method = path.Pop(); var fullQualifiedType = string.Join(".", path.Reverse()); foreach (var sourceAssembly in context.SourceAssemblies) { var type = sourceAssembly.GetType(fullQualifiedType, false); if (type != null) { var constrMethod = type.GetMethod(method); if (constrMethod != null && constrMethod.IsStatic) { var pars = constrMethod.GetParameters(); if (pars.Length == 1 && pars[0].ParameterType == typeof(ConfigurationBuilder)) { context.ConfigurationMethod = builder => constrMethod.Invoke(null, new object[] { builder }); break; } } } } }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(value != null); Debug.Assert(writer != null); ExportCollection(context, (NameValueCollection) value, writer); }
internal static void ExportTable(ExportContext context, DataTable table, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(table != null); Debug.Assert(writer != null); DataViewExporter.ExportView(context, table.DefaultView, writer); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(value != null); Debug.Assert(writer != null); ExportControl((Control) value, writer); }
static DataContract ProcessDataContract(DataContract contract, ExportContext context, MemberInfo memberNode) { if (contract is ClassDataContract) { return ProcessClassDataContract((ClassDataContract)contract, context, memberNode); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.QueryGeneratorPathToMemberNotFound))); }
protected override void ExportData(System.Xml.XmlWriter writer, ExportContext context) { //-- For exmple: // <Url authType="Forms">localhost:1315/</Url> // <Url authType="Windows">name.server.xy</Url> writer.WriteRaw(GetRawXml()); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(value != null); Debug.Assert(writer != null); writer.WriteNumber(((JsonNumber) value).ToString()); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(value != null); Debug.Assert(writer != null); writer.WriteBoolean((bool) value); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(value != null); Debug.Assert(writer != null); ((IJsonExportable) value).Export(context, writer); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { if (context == null) throw new ArgumentNullException("context"); if (value == null) throw new ArgumentNullException("value"); if (writer == null) throw new ArgumentNullException("writer"); ExportTime((DateTime) value, writer); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(value != null); Debug.Assert(writer != null); writer.WriteFromReader(((JsonBuffer) value).CreateReader()); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(value != null); Debug.Assert(writer != null); ExportRecord(context, (DbDataRecord) value, writer); }
protected override void ExportData(System.Xml.XmlWriter writer, ExportContext context) { var data = GetData() as PasswordData; if(data == null) return; if(String.IsNullOrEmpty(data.Hash)) return; writer.WriteElementString("Hash", data.Hash); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { if (context == null) throw new ArgumentNullException("context"); if (writer == null) throw new ArgumentNullException("writer"); writer.WriteStartArray(); _exporter(context, value, writer); writer.WriteEndArray(); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(value != null); Debug.Assert(writer != null); byte[] bytes = (byte[]) value; writer.WriteString(Convert.ToBase64String(bytes)); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { if (context == null) throw new ArgumentNullException("context"); if (writer == null) throw new ArgumentNullException("writer"); writer.WriteStartObject(); ExportMembers(context, (ExpandoObject) value, writer); writer.WriteEndObject(); }
internal static CompositionContainer InitializeConfiguration(ExportContext context) { var cat1 = PluginCatalog.Create(context); if (cat1 == null) return null; var ecat = new EnvironmentCatalog(cat1, Environments); var cont = new CompositionContainer(ecat); CompositionServices.Initialize(cont); return cont; }
public override void Build(BuildContext context) { var exportContext = new ExportContext { Document = context.RecipeDocument, ExportOptions = new ExportOptions { CustomSteps = CustomSteps } }; _exportEventHandlers.Invoke(x => x.Exporting(exportContext), Logger); _exportEventHandlers.Invoke(x => x.Exported(exportContext), Logger); }
public ITypeExporter Bind(ExportContext context, Type type) { if (context == null) throw new ArgumentNullException("context"); if (type == null) throw new ArgumentNullException("type"); return typeof(NameValueCollection).IsAssignableFrom(type) ? new NameValueCollectionExporter(type) : null; }
public ITypeExporter Bind(ExportContext context, Type type) { if (context == null) throw new ArgumentNullException("context"); if (type == null) throw new ArgumentNullException("type"); return typeof(DataTable).IsAssignableFrom(type) ? new DataTableExporter(type) : null; }
public HtmlMarkdownVisitor(ExportContext context, StringBuilder buffer, bool isJumbo) { _context = context; _buffer = buffer; _isJumbo = isJumbo; }
// ------------------------------------------------------------------------------------------ // // Recording Control. // ------------------------------------------------------------------------------------------ // public void StartRecording() { if (IsRecording) { return; } if (!m_exportRoot) { Debug.LogError("ExportRoot not assigned."); return; } if (m_usdScene != null) { m_usdScene.Close(); m_usdScene = null; } try { if (string.IsNullOrEmpty(m_usdFile)) { m_usdScene = Scene.Create(); } else { m_usdScene = Scene.Create(m_usdFile); } // USD operates on frames, so the frame rate is required for playback. // We could also set this to 1 to indicate that the TimeCode is in seconds. Application.targetFrameRate = (int)m_frameRate; // This forces Unity to use a fixed time step, resulting in evenly spaced // time samples in USD. Unfortunately, non-integer frame rates are not supported. // When non-integer frame rates are needed, time can be manually paused and // and advanced Time.captureFramerate = Application.targetFrameRate; // Set the frame rate in USD as well. // // This both set the "time samples per second" and the playback rate. // Setting times samples per second allows the authoring code to express samples as integer // values, avoiding floating point error; so by setting FrameRate = 60, the samples written // at time=0 through time=59 represent the first second of playback. // // Stage.TimeCodesPerSecond is set implicitly to 1 / FrameRate. m_usdScene.FrameRate = Application.targetFrameRate; // When authoring in terms of seconds, at any frame rate the samles written at // time = 0.0 through time = 1.0 represent the first second of playback. The framerate // above will only be used as a target frame rate. if (m_timeUnits == TimeCode.Seconds) { m_usdScene.Stage.SetTimeCodesPerSecond(1); } m_usdScene.StartTime = 0; m_usdScene.EndTime = m_frameCount; // For simplicity in this example, adding game objects while recording is not supported. m_context = new ExportContext(); m_context.scene = m_usdScene; m_context.basisTransform = m_convertHandedness; // Do this last, in case an exception is thrown above. IsRecording = true; // Set the start frame and add one because the button event fires after update, so the first // frame update sees while recording is (frameCount + 1). m_startFrame = Time.frameCount + 1; m_startTime = Time.timeSinceLevelLoad; } catch { if (m_usdScene != null) { m_usdScene.Close(); m_usdScene = null; } throw; } }
public ExportProductBillRepository(ExportContext context) : base(context) { }
public TypingsExportVisitor(TextWriter writer, ExportContext exportContext) : base(writer, exportContext) { }
public NullableTypeTypeScriptExportVisitor(TextWriter writer, ExportContext exportContext) : base(writer, exportContext) { typeChangingVisitor = new TypeChangingVisitor(exportContext, new NullableTypeChanger()); }
public TypeScriptExportVisitor(TextWriter writer, ExportContext exportContext) : base(writer, exportContext) { Context = WriterContext.None; }
protected override void ExportData(System.Xml.XmlWriter writer, ExportContext context) { writer.WriteString(GetXmlData()); }
void IJsonExportable.Export(ExportContext context, JsonWriter writer) { Export(context, writer); }
protected abstract void ExportValue(ExportContext context, object value, JsonWriter writer);
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { //writer.WriteString(((DateTime)value).ToString("yyyy-MM-dd hh:mm:ss")); writer.WriteString(((DateTime)value).ToString("s")); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { writer.WriteString((bool)value ? "1" : "0"); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { writer.WriteString(values[(int)value]); }
protected GenericConfigurationBuilderBase(TypeBlueprint blueprint, ExportContext context) { _blueprint = blueprint; Context = context; }
public CsvMessageWriter(Stream stream, ExportContext context) : base(stream, context) { _writer = new StreamWriter(stream); }
protected override void ExportData(System.Xml.XmlWriter writer, ExportContext context) { writer.WriteRaw(GetRawXml()); }
public PostambleTemplateContext(ExportContext exportContext, long messagesWritten) { ExportContext = exportContext; MessagesWritten = messagesWritten; }
public void Exported(ExportContext context) { }
internal ReferenceInspector(ExportContext context, HashSet <Type> allExportedTypes) { _context = context; _allExportedTypes = allExportedTypes; }
public PreambleTemplateContext(ExportContext exportContext, string themeName) { ExportContext = exportContext; ThemeName = themeName; }
public ExportListDetailRepository(ExportContext context) : base(context) { }
internal TypeConfigurationBuilder(ExportContext context) { _blueprint = context.Project.Blueprint(typeof(TType)); Context = context; }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { }
public AttributedGeneratorProvidingTypeGenerators(ExportContext exportContext, bool provideGeneratorsForParameters = true, bool lazy = true) : base(exportContext, provideGeneratorsForParameters, lazy) { }
public CustomVisitor(TextWriter writer, ExportContext exportContext) : base(writer, exportContext) { }
private static DataContract ProcessClassDataContract(ClassDataContract contract, ExportContext context, MemberInfo memberNode) { string prefix = context.SetNamespace(contract.Namespace.Value); if (contract.Members != null) { foreach (DataMember member in contract.Members) { if (member.MemberInfo == memberNode) { context.WriteChildToContext(member, prefix); return(member.MemberTypeContract); } } } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(System.Runtime.Serialization.SR.GetString("QueryGeneratorPathToMemberNotFound"))); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { base.ExportValue(ForceNullContext ? null : context, value, ForceNullWriter ? null : writer); }
public UserRepository(ExportContext context) : base(context) { }
public PlainTextMarkdownVisitor(ExportContext context, StringBuilder buffer) { _context = context; _buffer = buffer; }
public MessageGroupTemplateContext(ExportContext exportContext, MessageGroup messageGroup) { ExportContext = exportContext; MessageGroup = messageGroup; }
public BrandRepository(ExportContext context) : base(context) { }