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)
{
}
