public CodeOutput GeneratePoco(Table table)
{
var filename = table.NameHumanCaseWithSuffix() + Settings.FileExtension;
if (!CanWritePoco())
{
FileManagementService.DeleteFile(filename);
return(null);
}
var isEfCore3Plus = Settings.IsEfCore3Plus();
var data = new PocoModel
{
UseHasNoKey = isEfCore3Plus && table.IsView && !table.HasPrimaryKey,
HasNoPrimaryKey = !table.HasPrimaryKey,
Name = table.DbName,
NameHumanCaseWithSuffix = table.NameHumanCaseWithSuffix(),
ClassModifier = Settings.EntityClassesModifiers,
ClassComment = table.WriteComments(),
ExtendedComments = table.WriteExtendedComments(),
ClassAttributes = table.WriteClassAttributes(),
BaseClasses = table.BaseClasses,
InsideClassBody = table.WriteInsideClassBody(),
Columns = table.Columns
.Where(x => !x.Hidden && !x.ExistsInBaseClass)
.OrderBy(x => x.Ordinal)
.Select((col, index) => new PocoColumnModel
{
AddNewLineBefore = index > 0 && (((Settings.IncludeExtendedPropertyComments == CommentsStyle.InSummaryBlock || Settings.IncludeComments == CommentsStyle.InSummaryBlock) && !string.IsNullOrEmpty(col.SummaryComments)) || (col.Attributes != null && col.Attributes.Any())),
HasSummaryComments = (Settings.IncludeExtendedPropertyComments == CommentsStyle.InSummaryBlock || Settings.IncludeComments == CommentsStyle.InSummaryBlock) && !string.IsNullOrEmpty(col.SummaryComments),
SummaryComments = !string.IsNullOrEmpty(col.SummaryComments) ? SecurityElement.Escape(col.SummaryComments) : null,
Attributes = col.Attributes,
OverrideModifier = col.OverrideModifier,
WrapIfNullable = col.WrapIfNullable(),
NameHumanCase = col.NameHumanCase,
PrivateSetterForComputedColumns = Settings.UsePrivateSetterForComputedColumns && col.IsComputed ? "private " : string.Empty,
PropertyInitialisers = Settings.UsePropertyInitialisers ? (string.IsNullOrWhiteSpace(col.Default) ? string.Empty : string.Format(" = {0};", col.Default)) : string.Empty,
InlineComments = col.InlineComments
})
.ToList(),
HasReverseNavigation = table.ReverseNavigationProperty.Count > 0,
ReverseNavigationProperty = table.ReverseNavigationProperty
.OrderBy(x => x.Definition)
.Select(x => new PocoReverseNavigationPropertyModel
{
ReverseNavHasComment = Settings.IncludeComments != CommentsStyle.None && !string.IsNullOrEmpty(x.Comments),
ReverseNavComment = Settings.IncludeComments != CommentsStyle.None ? x.Comments : string.Empty,
AdditionalReverseNavigationsDataAnnotations = Settings.AdditionalReverseNavigationsDataAnnotations,
AdditionalDataAnnotations = x.AdditionalDataAnnotations,
Definition = x.Definition
})
.ToList(),
HasForeignKey = table.HasForeignKey,
ForeignKeyTitleComment = Settings.IncludeComments != CommentsStyle.None && table.Columns.SelectMany(x => x.EntityFk).Any() ? " // Foreign keys" + Environment.NewLine : string.Empty,
ForeignKeys = table.Columns
.SelectMany(x => x.EntityFk)
.OrderBy(o => o.Definition)
.Select(x => new PocoForeignKeyModel
{
HasFkComment = Settings.IncludeComments != CommentsStyle.None && !string.IsNullOrEmpty(x.Comments),
FkComment = x.Comments,
AdditionalForeignKeysDataAnnotations = Settings.AdditionalForeignKeysDataAnnotations,
AdditionalDataAnnotations = x.AdditionalDataAnnotations,
Definition = x.Definition
})
.ToList(),
CreateConstructor = !Settings.UsePropertyInitialisers &&
(
table.Columns.Any(c => c.Default != string.Empty && !c.Hidden) ||
table.ReverseNavigationCtor.Any() ||
Settings.EntityClassesArePartial()
),
ColumnsWithDefaults = table.Columns
.Where(c => c.Default != string.Empty && !c.Hidden && Settings.IncludeColumnsWithDefaults)
.OrderBy(x => x.Ordinal)
.Select(x => new PocoColumnsWithDefaultsModel {
NameHumanCase = x.NameHumanCase, Default = x.Default
})
.ToList(),
ReverseNavigationCtor = table.ReverseNavigationCtor,
EntityClassesArePartial = Settings.EntityClassesArePartial()
};
var co = new CodeOutput(table.DbName, filename, null, _globalUsings);
co.AddUsings(_template.PocoUsings(data));
co.AddCode(Template.Transform(_template.Poco(), data));
return(co);
}
public static void WriteObject(object value, string name, TextWriter output, bool addSchemaDeclaration = true, IDictionary <string, string> attributes = null, Type objectType = null)
{
if (value != null)
{
objectType = objectType ?? value.GetType();
var typeCode = Type.GetTypeCode(objectType);
if (typeCode != TypeCode.DBNull)
{
string xmlValue = null;
switch (typeCode)
{
case TypeCode.Boolean:
xmlValue = XmlConvert.ToString((bool)value);
break;
case TypeCode.String:
xmlValue = SecurityElement.Escape((string)value);
break;
case TypeCode.DateTime:
xmlValue = XmlConvert.ToString((DateTime)value, XmlDateTimeSerializationMode.Utc);
break;
case TypeCode.Byte:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.Char:
case TypeCode.Single:
case TypeCode.Double:
case TypeCode.Decimal:
xmlValue = Convert.ToString(value);
break;
default:
if (objectType == typeof(byte[]))
{
xmlValue = Convert.ToBase64String((byte[])value);
}
else if (objectType == typeof(DateTimeOffset))
{
xmlValue = XmlConvert.ToString((DateTimeOffset)value);
}
else if (objectType == typeof(TimeSpan))
{
xmlValue = XmlConvert.ToString((TimeSpan)value);
}
else if (objectType == typeof(Guid))
{
xmlValue = ((Guid)value).ToString("D");
}
else
{
var list = value as IList;
if (list != null)
{
WriteStartElement(name, output, false, null);
var items = list.Cast <object>().ToArray();
if (items.Length > 0 && (items[0] is IDataEntity || !Reflector.IsSimpleType(items[0].GetType())))
{
var args = list.GetType().GetGenericArguments();
var isPolymorphicList = args.Length == 1 && args[0].IsAbstract && !args[0].IsInterface;
for (var i = 0; i < items.Length; i++)
{
var elementType = items[i].GetType();
var serializer = CreateDelegate(elementType, isPolymorphicList);
serializer(items[i], output, false);
}
}
else
{
WriteList(list, true, output);
}
WriteEndElement(name, output);
}
else
{
var serializer = CreateDelegate(objectType);
serializer(value, output, addSchemaDeclaration);
}
}
break;
}
if (xmlValue != null)
{
WriteElement(name, xmlValue, output, false, null);
}
}
}
}
private static XmlObjectSerializer GenerateDelegate(string key, Type objectType, bool isPolymorphic)
{
var method = new DynamicMethod("XmlSerialize_" + key, null, new[] { typeof(object), typeof(TextWriter), typeof(bool) }, typeof(XmlSerializationWriter).Module);
var il = method.GetILGenerator();
var writeObject = typeof(XmlSerializationWriter).GetMethod("WriteObject");
var writeStart = typeof(XmlSerializationWriter).GetMethod("WriteStartElement");
var writeEnd = typeof(XmlSerializationWriter).GetMethod("WriteEndElement");
var getXmlValue = typeof(XmlSerializationWriter).GetMethod("GetXmlValue");
var getTypeFromHandle = typeof(Type).GetMethod("GetTypeFromHandle");
var interfaceType = objectType;
if (Reflector.IsEmitted(objectType))
{
interfaceType = Reflector.GetInterface(objectType) ?? objectType;
}
var properties = Reflector.GetPropertyMap(interfaceType).Where(p => p.Key.CanRead && p.Key.CanWrite && p.Key.Name != "Indexer" && !p.Key.GetCustomAttributes(typeof(DoNotSerializeAttribute), false).Any())
.Partition(p => (p.Value.IsSimpleType || (p.Value.IsSimpleList && p.Value.ElementType == typeof(byte))) && p.Key.GetCustomAttributes(typeof(XmlAttributeAttribute), false).Any());
var elementName = Xml.GetElementNameFromType(interfaceType);
if (properties.Item1.Any() || isPolymorphic)
{
var attributeSetType = typeof(Dictionary <string, string>);
var addItem = attributeSetType.GetMethod("Add");
il.DeclareLocal(attributeSetType);
il.Emit(OpCodes.Newobj, attributeSetType.GetConstructor(Type.EmptyTypes));
il.Emit(OpCodes.Stloc_0);
if (isPolymorphic)
{
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ldstr, "_.type");
il.Emit(OpCodes.Ldstr, SecurityElement.Escape(string.Format("{0},{1}", objectType.FullName, objectType.Assembly.GetName().Name)));
il.EmitCall(OpCodes.Callvirt, addItem, null);
}
foreach (var property in properties.Item1)
{
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ldstr, property.Value.PropertyName);
il.Emit(OpCodes.Ldarg_0);
il.EmitCastToReference(interfaceType);
il.EmitCall(OpCodes.Callvirt, property.Key.GetGetMethod(), null);
il.BoxIfNeeded(property.Value.PropertyType);
il.Emit(OpCodes.Ldtoken, property.Value.PropertyType);
il.Emit(OpCodes.Call, getTypeFromHandle);
il.Emit(OpCodes.Call, getXmlValue);
il.EmitCall(OpCodes.Callvirt, addItem, null);
}
}
il.Emit(OpCodes.Ldstr, elementName);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldarg_2);
il.Emit(properties.Item1.Any() || isPolymorphic ? OpCodes.Ldloc_0 : OpCodes.Ldnull);
il.Emit(OpCodes.Call, writeStart);
foreach (var property in properties.Item2)
{
// Write property value
il.Emit(OpCodes.Ldarg_0);
il.EmitCastToReference(interfaceType);
il.EmitCall(OpCodes.Callvirt, property.Key.GetGetMethod(), null);
il.BoxIfNeeded(property.Key.PropertyType);
il.Emit(OpCodes.Ldstr, Xml.GetElementName(property.Key, property.Value.IsSimpleList));
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(properties.Item1.Any() || isPolymorphic ? OpCodes.Ldloc_0 : OpCodes.Ldnull);
il.Emit(OpCodes.Ldtoken, property.Value.PropertyType);
il.Emit(OpCodes.Call, getTypeFromHandle);
il.Emit(OpCodes.Call, writeObject);
}
il.Emit(OpCodes.Ldstr, elementName);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, writeEnd);
il.Emit(OpCodes.Ret);
var serializer = (XmlObjectSerializer)method.CreateDelegate(typeof(XmlObjectSerializer));
return(serializer);
}
public static string EscapeString(this string value)
{
return(SecurityElement.Escape(value));
}
/// <summary>
/// Encodes problematic XML characters
/// </summary>
internal static string Escape(this string value)
{
return(SecurityElement.Escape(value));
}
public ActionResult Export(int?school, int?yearList, RegistrationStatus?status, int?classyear)
{
var results = repository.GetRegistration(school, status, yearList, classyear);
var currentYear = DateTime.Now.Year;
var ms = new MemoryStream();
using (var fs =
new FileStream(
AppDomain.CurrentDomain.BaseDirectory + "/Content/templates/EnrolmentTemplate.xls",
FileMode.Open, FileAccess.Read, FileShare.Read))
{
var templateWorkbook = new HSSFWorkbook(fs, true);
var rowcount = 2; // skips header
foreach (var entry in results.OrderBy(x => x.user.name))
{
var sheet = templateWorkbook.GetSheetAt(0);
var row = sheet.CreateRow(rowcount);
var col = 0;
row.CreateCell(col++).SetCellValue(rowcount - 1);
if (entry.enrollingYear.HasValue)
{
row.CreateCell(col++).SetCellValue(entry.enrollingYear.Value);
}
else
{
col++;
}
if (entry.user.dob.HasValue)
{
row.CreateCell(col++).SetCellValue(entry.user.dob.Value.ToShortDateString());
}
else
{
col++;
}
row.CreateCell(col++).SetCellValue(entry.user.gender.Substring(0, 1));
row.CreateCell(col++).SetCellValue(SecurityElement.Escape(entry.user.ToName()));
row.CreateCell(col++).SetCellValue(entry.status);
row.CreateCell(col++).SetCellValue(entry.school.name);
row.CreateCell(col++).SetCellValue(entry.school_year.name);
row.CreateCell(col++).SetCellValue(SecurityElement.Escape(entry.previous_school));
row.CreateCell(col++).SetCellValue(SecurityElement.Escape(entry.previous_class));
row.CreateCell(col++).SetCellValue(SecurityElement.Escape(entry.leaving_reason));
// disability
var disabilityString = new StringBuilder();
if (entry.isHandicap.HasValue && entry.isHandicap.Value)
{
disabilityString.Append("HANDICAP ");
}
if (entry.hasLearningProblem.HasValue && entry.hasLearningProblem.Value)
{
disabilityString.Append("LEARNING_PROBLEM ");
}
disabilityString.Append(entry.disability_details);
row.CreateCell(col++).SetCellValue(SecurityElement.Escape(disabilityString.ToString()));
// address of student (applicant)
row.CreateCell(col++).SetCellValue(SecurityElement.Escape(entry.user.address));
// siblings
var siblingsList = new List <string>();
if (entry.user.students_guardians.Count == 0)
{
row.CreateCell(col++).SetCellValue("No Guardians");
}
else if (entry.user.students_guardians.First().user1.students_guardians1.Count == 0)
{
row.CreateCell(col++).SetCellValue("No siblings");
}
else
{
var siblings = entry.user.students_guardians.First().user1.students_guardians1.Select(x => x.user);
foreach (var sibling in siblings)
{
var sclass =
sibling.classes_students_allocateds.Where(x => x.year == currentYear).SingleOrDefault();
if (sclass != null)
{
siblingsList.Add(string.Format("{0} ({1}) ", sibling.ToName(), sclass.school_class.name));
}
}
row.CreateCell(col++).SetCellValue(string.Join(", ", siblingsList.ToArray()));
}
var father = entry.user.ToParent(GuardianType.FATHER);
if (father != null)
{
row.CreateCell(col++).SetCellValue(father.ToName());
row.CreateCell(col++).SetCellValue(father.ToContactString());
}
else
{
col++;
col++;
}
var mother = entry.user.ToParent(GuardianType.MOTHER);
if (mother != null)
{
row.CreateCell(col++).SetCellValue(mother.ToName());
row.CreateCell(col++).SetCellValue(mother.ToContactString());
}
else
{
col++;
col++;
}
var guardian = entry.user.ToParent(GuardianType.GUARDIAN);
if (guardian != null)
{
row.CreateCell(col++).SetCellValue(guardian.ToName());
row.CreateCell(col++).SetCellValue(guardian.ToContactString());
}
else
{
col++;
col++;
}
rowcount++;
}
templateWorkbook.Write(ms);
}
// return created file path);
return(File(ms.ToArray(), "application/vnd.ms-excel", string.Format("Enrolment_{0}.xls", DateTime.Now.ToShortDateString().Replace("/", ""))));
}
/// <summary>
/// Parses a data element
/// </summary>
/// <param name="parseTree">The data element grammar.</param>
/// <param name="value">The data element line.</param>
/// <param name="interchangeContext"></param>
/// <returns>The parsed XML.</returns>
private static XElement ParseElement(ParseTree parseTree, string value, InterchangeContext interchangeContext)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (!parseTree.IsComplex && !parseTree.IsSimple)
{
throw new Exception("Not a data element.");
}
XNamespace ns = interchangeContext.TargetNamespace;
var result = new XElement(ns + parseTree.Name);
if (parseTree.IsComplex)
{
if (value == string.Empty)
{
// Only deal with blank values for envelope headers
if (parseTree.IsEnvelope)
{
foreach (var dataElement in parseTree.Children)
{
var element = new XElement(ns + dataElement.Name);
element.SetValue(string.Empty);
result.Add(element);
}
}
}
else
{
// Get the simple data elements
var componentDataElements =
EdiHelper.GetEdiComponentDataElements(value, interchangeContext).ToList();
// Index the composite data elements from the class definition
var indexedGrammar =
parseTree.Children.Select((g, p) => new { Grammar = g, Position = p }).ToList();
// Index the composite data elements from the EDI string
var indexedValues = componentDataElements.Select((v, p) => new { Value = v, Position = p }).ToList();
// This will try to parse the EDI string into the class definition
// Load a parse tree against each value
// If there are more values in the EDI string than in the class definition - they will be ignored
// If there are less values in the EDI string than in the class definition - it will throw an exception
var indexedList = from ig in indexedGrammar
from iv in indexedValues
where ig.Position == iv.Position
select new { ig.Position, iv.Value };
// Index the list so we can position each element
//var indexed = componentDataElements.Select((a, i) => new {Item = a, Position = i}).ToList();
foreach (var dataElement in indexedList)
{
// Skip blank data elements otherwise this will produce blank XML nodes
if (string.IsNullOrEmpty(dataElement.Value))
{
if (!parseTree.IsEnvelope)
{
continue;
}
}
// Handle the repetitions
// If the children the EDI string are more than the class definition,
// Then the extra ones are considered repetitions of the last child in the class definition
var objectToParse = dataElement.Position >= parseTree.Children.Count
? parseTree.Children.Last()
: parseTree.Children[dataElement.Position];
var element = new XElement(ns + objectToParse.Name);
// Set the value and escape to prevent faulty XML
element.SetValue(SecurityElement.Escape(dataElement.Value) ?? string.Empty);
result.Add(element);
}
}
}
else
{
// Prevent faulty XML
result.SetValue(SecurityElement.Escape(value) ?? string.Empty);
}
return(result);
}
/// <summary>
/// Converts the data from raw format (*.nz.tar.gz) to json files consumable by LEAN
/// </summary>
/// <param name="startDate">Starting date to start process files</param>
/// <param name="endDate">Ending date to stop processing files</param>
public void Process(DateTime startDate, DateTime endDate)
{
Parallel.ForEach(
Directory.GetFiles(RawSource, "*.nc.tar.gz", SearchOption.AllDirectories).ToList(),
rawFile =>
{
// GetFileNameWithoutExtension only strips the first extension from the name.
var fileDate = Path.GetFileName(rawFile).Split('.')[0];
var extractDataPath = Path.Combine(RawSource, fileDate);
DateTime currentDate;
if (!DateTime.TryParseExact(fileDate, "yyyyMMdd", CultureInfo.InvariantCulture, DateTimeStyles.None, out currentDate))
{
throw new Exception($"Unable to parse date from file {rawFile}. Filename we attempted to parse: {fileDate}");
}
// Only process files within start and end bounds
if (currentDate < startDate || currentDate > endDate)
{
return;
}
using (var data = File.OpenRead(rawFile))
{
using (var archive = TarArchive.CreateInputTarArchive(new GZipInputStream(data)))
{
Directory.CreateDirectory(extractDataPath);
archive.ExtractContents(extractDataPath);
Log.Trace($"SECDataConverter.Process(): Extracted SEC data to path {extractDataPath}");
}
}
// For the meantime, let's only process .nc files, and deal with correction files later.
Parallel.ForEach(
Directory.GetFiles(extractDataPath, "*.nc", SearchOption.AllDirectories),
rawReportFilePath =>
{
// Avoid processing files greater than MaxFileSize megabytes
if (MaxFileSize < new FileInfo(rawReportFilePath).Length)
{
Log.Trace($"SECDataConverter.Process(): File {rawReportFilePath} is too large to process. Continuing...");
return;
}
var factory = new SECReportFactory();
var xmlText = new StringBuilder();
// We need to escape any nested XML to ensure our deserialization happens smoothly
var parsingText = false;
foreach (var line in File.ReadLines(rawReportFilePath))
{
var newTextLine = line;
var currentTagName = GetTagNameFromLine(newTextLine);
// This tag is present rarely in SEC reports, but is unclosed without value when encountered.
// Verified by searching with ripgrep for "CONFIRMING-COPY"
if (currentTagName == "CONFIRMING-COPY")
{
return;
}
// Don't encode the closing tag
if (currentTagName == "/TEXT")
{
parsingText = false;
}
// To ensure that we can serialize/deserialize data with hours, minutes, seconds
if (currentTagName == "FILING-DATE" || currentTagName == "PERIOD" ||
currentTagName == "DATE-OF-FILING-CHANGE" || currentTagName == "DATE-CHANGED")
{
newTextLine = $"{newTextLine.TrimEnd()} 00:00:00";
}
// Encode all contents inside tags to prevent errors in XML parsing.
// The json deserializer will convert these values back to their original form
if (!parsingText && HasValue(newTextLine))
{
newTextLine =
$"<{currentTagName}>{SecurityElement.Escape(GetTagValueFromLine(newTextLine))}</{currentTagName}>";
}
// Escape all contents inside TEXT tags
else if (parsingText)
{
newTextLine = SecurityElement.Escape(newTextLine);
}
// Don't encode the opening tag
if (currentTagName == "TEXT")
{
parsingText = true;
}
xmlText.AppendLine(newTextLine);
}
ISECReport report;
try
{
report = factory.CreateSECReport(xmlText.ToString());
}
catch (DataException e)
{
Log.Trace($"SECDataConverter.Process(): {e.Message}");
return;
}
catch (XmlException e)
{
Log.Error(e, $"SECDataConverter.Process(): Failed to parse XML from file path: {rawReportFilePath}");
return;
}
// First filer listed in SEC report is usually the company listed on stock exchanges
var companyCik = report.Report.Filers.First().CompanyData.Cik;
// Some companies can operate under two tickers, but have the same CIK.
// Don't bother continuing if we don't find any tickers for the given CIK
List <string> tickers;
if (!CikTicker.TryGetValue(companyCik, out tickers))
{
return;
}
try
{
// There can potentially not be an index file present for the given CIK
GetPublicationDate(report, companyCik);
}
catch (Exception e)
{
Log.Error(e, $"Index file not found for company {companyCik}");
}
// Default to company CIK if no known ticker is found.
// If we don't find a known equity in our list, the equity is probably not worth our time
foreach (var ticker in tickers.Where(KnownEquities.Contains))
{
var tickerReports = Reports.GetOrAdd(
ticker,
_ => new ConcurrentDictionary <DateTime, List <ISECReport> >()
);
var reports = tickerReports.GetOrAdd(
report.Report.FilingDate.Date,
_ => new List <ISECReport>()
);
reports.Add(report);
}
}
);
Parallel.ForEach(Reports.Keys, ticker =>
{
List <ISECReport> reports;
if (!Reports[ticker].TryRemove(currentDate, out reports))
{
return;
}
WriteReport(reports, ticker);
}
);
// This will clean up after ourselves without having to pay
// the expense of deleting every single file inside the raw_data folder
Directory.Delete(extractDataPath, true);
}
);
}
static void HtmlGenerateParams(BBCodeParser rules, StringBuilder SB, IReadOnlyList <CmdletObject> cmdlets, CmdletObject cmdlet)
{
SB.Append("<h2><strong>Parameters</strong></h2>" + n);
foreach (ParameterDescription param in cmdlet.Parameters)
{
SB.Append("<h3><strong>-" + SecurityElement.Escape(param.Name) + "</strong> <em style=\"font-weight: 100;\"><" + SecurityElement.Escape(param.Type) + "></em></h3>" + n);
if (!String.IsNullOrEmpty(param.Description))
{
String str = rules.ToHtml(GenerateHtmlLink(param.Description, cmdlets));
SB.Append("<p style=\"margin-left: 40px; text-align: left;\">" + str + "</p>" + n);
}
SB.Append("<table border=\"1\" style=\"margin-left: 40px;\">" + n);
SB.Append(" <tbody>" + n);
SB.Append(" <tr>"+ n);
SB.Append(" <td>Required?</td>"+ n);
SB.Append(" <td>"+ Convert.ToString(param.Mandatory) + "</td>" + n);
SB.Append(" </tr>"+ n);
SB.Append(" <tr>"+ n);
SB.Append(" <td>Position?</td>"+ n);
SB.Append(" <td>"+ param.Position + "</td>" + n);
SB.Append(" </tr>"+ n);
SB.Append(" <tr>"+ n);
SB.Append(" <td>Default value</td>"+ n);
if (String.IsNullOrEmpty(param.DefaultValue))
{
SB.Append(" <td> </td>"+ n);
}
else
{
SB.Append(" <td>"+ param.DefaultValue + "</td>" + n);
}
SB.Append(" </tr>"+ n);
SB.Append(" <tr>"+ n);
SB.Append(" <td>Accept pipeline input?</td>"+ n);
if (param.Pipeline || param.PipelinePropertyName)
{
SB.Append(" <td>true");
if (param.Pipeline && !param.PipelinePropertyName)
{
SB.Append(" (ByValue)");
}
else if (param.Pipeline && param.PipelinePropertyName)
{
SB.Append(" (ByValue, ByPropertyName)");
}
else
{
SB.Append(" (ByPropertyName)");
}
SB.Append("</td>" + n);
}
else
{
SB.Append(" <td>false</td>"+ n);
}
SB.Append(" </tr>"+ n);
SB.Append(" <tr>"+ n);
SB.Append(" <td>Accept wildcard characters?</td>"+ n);
SB.Append(" <td>"+ Convert.ToString(param.Globbing) + "</td>" + n);
SB.Append(" </tr>"+ n);
SB.Append(" </tbody>" + n);
SB.Append("</table>" + n);
}
// Common parameters
SB.Append("<h3><CommonParameters></h3>" + n);
SB.Append("<p style=\"margin-left: 40px;\">This cmdlet supports the common parameters: Verbose, Debug,<br />" + n);
SB.Append("ErrorAction, ErrorVariable, InformationAction, InformationVariable,<br />" + n);
SB.Append("WarningAction, WarningVariable, OutBuffer, PipelineVariable and OutVariable.<br />" + n);
SB.Append("For more information, see about_CommonParameters (<a href=\"http://go.microsoft.com/fwlink/?LinkID=113216\">http://go.microsoft.com/fwlink/?LinkID=113216</a>).</p>" + n);
}
public ActionResult ExportStats(Schools school, UserGroup ugroup, int year)
{
var stats = new ClassStatistics {
school = school, usergroup = ugroup, year = year
};
stats.CalculateStats(repository);
var ms = new MemoryStream();
using (var fs =
new FileStream(
AppDomain.CurrentDomain.BaseDirectory + "/Content/templates/NPOITemplate.xls",
FileMode.Open, FileAccess.Read, FileShare.Read))
{
var templateWorkbook = new HSSFWorkbook(fs, true);
var sheet = templateWorkbook.CreateSheet(school.ToString());
// create fonts
var boldStyle = templateWorkbook.CreateCellStyle();
var boldFont = templateWorkbook.CreateFont();
boldFont.Boldweight = (short)FontBoldWeight.BOLD;
boldStyle.SetFont(boldFont);
var rowcount = 0;
var row = sheet.CreateRow(rowcount++);
var colcount = 0;
// show general stats first
row.CreateCell(colcount).SetCellValue(SecurityElement.Escape("Malaysian"));
colcount += 2;
row.CreateCell(colcount).SetCellValue(SecurityElement.Escape("Foreigners"));
colcount += 2;
row.CreateCell(colcount).SetCellValue(SecurityElement.Escape("SubTotal"));
colcount += 2;
row.CreateCell(colcount).SetCellValue(SecurityElement.Escape("Total"));
row = sheet.CreateRow(rowcount++);
for (int i = 0; i < 3; i++)
{
row.CreateCell(i * 2).SetCellValue(SecurityElement.Escape("M"));
row.CreateCell(i * 2 + 1).SetCellValue(SecurityElement.Escape("F"));
}
row = sheet.CreateRow(rowcount++);
row.CreateCell(0, CellType.NUMERIC).SetCellValue(stats.msian_male);
row.CreateCell(1, CellType.NUMERIC).SetCellValue(stats.msian_female);
row.CreateCell(2, CellType.NUMERIC).SetCellValue(stats.foreign_male);
row.CreateCell(3, CellType.NUMERIC).SetCellValue(stats.foreign_female);
row.CreateCell(4, CellType.NUMERIC).SetCellValue(stats.msian_male + stats.foreign_male);
row.CreateCell(5, CellType.NUMERIC).SetCellValue(stats.msian_female + stats.foreign_female);
row.CreateCell(6, CellType.NUMERIC).SetCellValue(stats.msian_male + stats.foreign_male + stats.msian_female + stats.foreign_female);
foreach (var entry in stats.collections)
{
// class row
row = sheet.CreateRow(rowcount++);
row.CreateCell(0).SetCellValue(SecurityElement.Escape(entry.name));
row.GetCell(0).CellStyle = boldStyle;
// header row1
row = sheet.CreateRow(rowcount++);
colcount = 0;
foreach (var race in entry.GetList())
{
row.CreateCell(colcount).SetCellValue(SecurityElement.Escape(race.name));
colcount += 2;
}
row.CreateCell(colcount).SetCellValue(SecurityElement.Escape("Total"));
// header row2
row = sheet.CreateRow(rowcount++);
for (int i = 0; i < entry.GetList().Count(); i++)
{
row.CreateCell(i * 2).SetCellValue(SecurityElement.Escape("M"));
row.CreateCell(i * 2 + 1).SetCellValue(SecurityElement.Escape("F"));
}
// stats row
row = sheet.CreateRow(rowcount++);
colcount = 0;
foreach (var race in entry.GetList())
{
row.CreateCell(colcount++).SetCellValue(race.male);
row.CreateCell(colcount++).SetCellValue(race.female);
}
row.CreateCell(colcount).SetCellValue(entry.GetList().Sum(x => x.male + x.female));
}
// delete first sheet
templateWorkbook.RemoveSheetAt(0);
templateWorkbook.Write(ms);
}
// return created file path);
return(File(ms.ToArray(), "application/vnd.ms-excel", string.Format("Statistics_{0}_{1}.xls", ugroup, school)));
}
/// <summary>
/// Saves the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
public void Save(BaseItem item, CancellationToken cancellationToken)
{
var series = (Series)item;
var builder = new StringBuilder();
builder.Append("<Series>");
var tvdb = item.GetProviderId(MetadataProviders.Tvdb);
if (!string.IsNullOrEmpty(tvdb))
{
builder.Append("<id>" + SecurityElement.Escape(tvdb) + "</id>");
}
if (!string.IsNullOrEmpty(item.Name))
{
builder.Append("<SeriesName>" + SecurityElement.Escape(item.Name) + "</SeriesName>");
}
if (series.Status.HasValue)
{
builder.Append("<Status>" + SecurityElement.Escape(series.Status.Value.ToString()) + "</Status>");
}
if (series.Studios.Count > 0)
{
builder.Append("<Network>" + SecurityElement.Escape(item.Studios[0]) + "</Network>");
}
if (!string.IsNullOrEmpty(series.AirTime))
{
builder.Append("<Airs_Time>" + SecurityElement.Escape(series.AirTime) + "</Airs_Time>");
}
if (series.AirDays != null)
{
if (series.AirDays.Count == 7)
{
builder.Append("<Airs_DayOfWeek>" + SecurityElement.Escape("Daily") + "</Airs_DayOfWeek>");
}
else if (series.AirDays.Count > 0)
{
builder.Append("<Airs_DayOfWeek>" + SecurityElement.Escape(series.AirDays[0].ToString()) + "</Airs_DayOfWeek>");
}
}
if (series.PremiereDate.HasValue)
{
builder.Append("<FirstAired>" + SecurityElement.Escape(series.PremiereDate.Value.ToString("yyyy-MM-dd")) + "</FirstAired>");
}
XmlSaverHelpers.AddCommonNodes(item, builder);
builder.Append("</Series>");
var xmlFilePath = GetSavePath(item);
XmlSaverHelpers.Save(builder, xmlFilePath, new[]
{
"id",
"SeriesName",
"Status",
"Network",
"Airs_Time",
"Airs_DayOfWeek",
"FirstAired"
});
// Set last refreshed so that the provider doesn't trigger after the file save
SeriesProviderFromXml.Current.SetLastRefreshed(item, DateTime.UtcNow);
}
protected PSObject InsertEntity(string tableName, string partitionKey, string rowKey, PSObject obj, string author, string email, bool update, bool merge, bool excludeTableInfo)
{
return(Retry <PSObject>(delegate()
{
HttpWebResponse response;
try
{
// Create properties list. Use reflection to retrieve properties from the object.
StringBuilder properties = new StringBuilder();
properties.Append(string.Format("<d:{0}>{1}</d:{0}>\n", "PartitionKey", partitionKey));
properties.Append(string.Format("<d:{0}>{1}</d:{0}>\n", "RowKey", rowKey));
string lastTypeName = obj.TypeNames.Last();
if (lastTypeName != "System.Object" && lastTypeName != "System.Management.Automation.PSObject")
{
properties.Append(string.Format("<d:psTypeName>{0}</d:psTypeName>\n", SecurityElement.Escape(lastTypeName)));
}
foreach (PSPropertyInfo p in obj.Properties)
{
try
{
string valueToInsert = p.Value.ToString();
properties.Append(string.Format("<d:{0}>{1}</d:{0}>\n", p.Name, SecurityElement.Escape(valueToInsert)));
}
catch
{
}
}
string now = DateTime.UtcNow.ToString("o", System.Globalization.CultureInfo.InvariantCulture);
string id = String.Empty;
if (update || merge)
{
id = String.Format("http://{0}.table.core.windows.net/{1}(PartitionKey='{2}',RowKey='{3}')", StorageAccount, tableName, partitionKey, rowKey);
}
string requestBody = String.Format("<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\"?>" +
"<entry xmlns:d=\"http://schemas.microsoft.com/ado/2007/08/dataservices\"" +
" xmlns:m=\"http://schemas.microsoft.com/ado/2007/08/dataservices/metadata\"" +
" xmlns=\"http://www.w3.org/2005/Atom\"> " +
" <title /> " +
" <updated>{0}</updated> " +
" <author>" +
" <name/> " +
" </author> " +
" <id>{1}</id> " +
" <content type=\"application/xml\">" +
" <m:properties>" +
"{2}" +
" </m:properties>" +
" </content> " +
"</entry>",
now,
id,
properties);
if (!String.IsNullOrEmpty(author))
{
if (!String.IsNullOrEmpty(email))
{
requestBody.Replace("<name/>", ("<name>" + SecurityElement.Escape(author) + "</name><email>" + SecurityElement.Escape(email) + "</email>"));
}
else
{
requestBody.Replace("<name/>", ("<name>" + SecurityElement.Escape(author) + "</name>"));
}
}
if (merge)
{
string resource = String.Format(tableName + "(PartitionKey='{0}',RowKey='{1}')", partitionKey, rowKey);
SortedList <string, string> headers = new SortedList <string, string>();
headers.Add("If-Match", "*");
response = CreateRESTRequest("MERGE", resource, requestBody, headers, String.Empty, String.Empty).GetResponse() as HttpWebResponse;
}
else if (update)
{
string resource = String.Format(tableName + "(PartitionKey='{0}',RowKey='{1}')", partitionKey, rowKey);
SortedList <string, string> headers = new SortedList <string, string>();
headers.Add("If-Match", "*");
response = CreateRESTRequest("PUT", resource, requestBody, headers, String.Empty, String.Empty).GetResponse() as HttpWebResponse;
}
else
{
response = CreateRESTRequest("POST", tableName, requestBody, null, String.Empty, String.Empty).GetResponse() as HttpWebResponse;
}
if (response.StatusCode == HttpStatusCode.Created)
{
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
string result = reader.ReadToEnd();
XNamespace ns = "http://www.w3.org/2005/Atom";
XNamespace d = "http://schemas.microsoft.com/ado/2007/08/dataservices";
XNamespace m = "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata";
return RecreateObject(result, !excludeTableInfo, tableName).First();
}
}
response.Close();
return null;
}
catch (WebException ex)
{
if (ex.Status == WebExceptionStatus.ProtocolError &&
ex.Response != null)
{
WriteError(
new ErrorRecord(
new InvalidOperationException(
((ex.Response as HttpWebResponse).StatusCode.ToString()) + "-- Table: " + tableName + "Partition: " + partitionKey + "Row: " + rowKey),
"SetAzureTableCommand.WebError." + ((int)(ex.Response as HttpWebResponse).StatusCode).ToString(),
ErrorCategory.InvalidOperation,
this)
);
}
return null;
}
}));
}
// Convert this permissions object into an XML value.
public override SecurityElement ToXml()
{
SecurityElement element;
SecurityElement child;
SecurityElement uri;
element = new SecurityElement("IPermission");
element.AddAttribute
("class",
SecurityElement.Escape(typeof(WebPermission).
AssemblyQualifiedName));
element.AddAttribute("version", "1");
if (state == PermissionState.Unrestricted)
{
element.AddAttribute("Unrestricted", "true");
}
else
{
if (connectList.Count > 0)
{
child = new SecurityElement("ConnectAccess");
element.AddChild(child);
foreach (Object p1 in connectList)
{
uri = new SecurityElement("URI");
child.AddChild(uri);
#if !ECMA_COMPAT
if (p1 is Regex)
{
uri.AddAttribute
("uri",
SecurityElement.Escape(p1.ToString()));
}
else
#endif
{
uri.AddAttribute
("uri",
SecurityElement.Escape
(RegexEscape(p1.ToString())));
}
}
}
if (acceptList.Count > 0)
{
child = new SecurityElement("AcceptAccess");
element.AddChild(child);
foreach (Object p2 in acceptList)
{
uri = new SecurityElement("URI");
child.AddChild(uri);
#if !ECMA_COMPAT
if (p2 is Regex)
{
uri.AddAttribute
("uri",
SecurityElement.Escape(p2.ToString()));
}
else
#endif
{
uri.AddAttribute
("uri",
SecurityElement.Escape
(RegexEscape(p2.ToString())));
}
}
}
}
return(element);
}
public void Escape()
{
Assert.Equal("foo<>"'& bar",
SecurityElement.Escape("foo<>\"'& bar"));
Assert.Null(SecurityElement.Escape(null));
}
//http://developer.marklogic.com/pipermail/general/2015-August/017790.html
//https://msdn.microsoft.com/pl-pl/library/system.security.securityelement.escape(v=vs.110).aspx
private static string EscapeXml(string content)
{
return(SecurityElement.Escape(content));
}
private void PutDataToConcretePresentationTable(PresentationInfo presInfo)
{
if (presInfo == null)
{
throw new ArgumentNullException("presInfo");
}
#region Создаю конкретную таблицу, если она еще не создана
try
{
MySqlCommand command = _MySqlConnection.CreateCommand();
command.CommandText = String.Format(@"CREATE TABLE IF NOT EXISTS `{0}`
(
`id` MEDIUMINT NOT NULL AUTO_INCREMENT,
`url_news` VARCHAR(200) NOT NULL,
`title` VARCHAR(200) NULL,
`nazvanie` VARCHAR(200) NOT NULL,
`slider` TEXT NULL,
`url_dowload` TEXT(1000) NOT NULL,
`size` FLOAT NOT NULL,
`content` TEXT NULL,
`iframe` INT NOT NULL,
`random` TEXT NULL,
`poxpres` TEXT NULL,
PRIMARY KEY (id)
) CHARSET={1}", SecurityElement.Escape(presInfo.Categorie.ToString()), TABLE_CHARSET);
command.ExecuteNonQuery();
}
catch (Exception ex)
{
throw new Exception(String.Format("Во время создания таблицы '{0}' произошла ошибка: {1}", presInfo.NameAsTranslit, ex.Message));
}
#endregion
try
{
MySqlCommand command = _MySqlConnection.CreateCommand();
command.CommandText = String.Format(new System.Globalization.CultureInfo("en-GB"), @"
INSERT INTO `{8}` (`url_news`, `title`, `nazvanie`, `slider`, `url_dowload`, `size`, `content`, `iframe`)
VALUES ('{0}', '{1}', '{2}', '{3}', '{4}', {5:0.00}, '{6}', '{7}')
", SecurityElement.Escape(presInfo.UrlNews), SecurityElement.Escape(presInfo.Title), SecurityElement.Escape(presInfo.Name), SecurityElement.Escape(FormatIframeBDColumn(presInfo)),
SecurityElement.Escape(presInfo.UrlDownload), Convert.ToSingle(presInfo.FileSize / 1024 / 1024, System.Globalization.CultureInfo.InvariantCulture),
SecurityElement.Escape(FormContentDbColumn(presInfo)), presInfo.DbId, SecurityElement.Escape(presInfo.Categorie.ToString()));
command.ExecuteNonQuery();
}
catch (Exception ex)
{
throw new Exception(String.Format("Во время заполнения таблицы 'main' презентацией '{0}' произошла ошибка: {1}", presInfo.Name, ex.Message));
}
}
public override TaskStatus Run()
{
Info("Retrieving post history...");
Status status = Status.Success;
RedditClient reddit;
try
{
reddit = new RedditClient(AppId, RefreshToken);
InfoFormat("Username: {0}", reddit.Account.Me.Name);
InfoFormat("Cake Day: {0}", reddit.Account.Me.Created.ToString("D"));
Info("Authentication succeeded.");
}
catch (ThreadAbortException)
{
throw;
}
catch (Exception e)
{
ErrorFormat("Authentication failed: {0}", e.Message);
return(new TaskStatus(Status.Error));
}
try
{
// Retrieve the authenticated user's recent post history.
// Change "new" to "newForced" if you don't want older stickied profile posts to appear first.
var posts = reddit.Account.Me.GetPostHistory(sort: "new", limit: MaxResults, show: "all");
var xdoc = new XDocument(new XElement("Posts"));
foreach (var post in posts)
{
var xpost = new XElement("Post", new XAttribute("id", SecurityElement.Escape(post.Id)), new XAttribute("subreddit", SecurityElement.Escape(post.Subreddit)), new XAttribute("title", SecurityElement.Escape(post.Title)), new XAttribute("upvotes", post.UpVotes), new XAttribute("downvotes", post.DownVotes));
xdoc.Root.Add(xpost);
}
var xmlPath = Path.Combine(Workflow.WorkflowTempFolder,
string.Format("{0}_{1:yyyy-MM-dd-HH-mm-ss-fff}.xml", "RedditListPosts", DateTime.Now));
xdoc.Save(xmlPath);
Files.Add(new FileInf(xmlPath, Id));
InfoFormat("Post history written in {0}", xmlPath);
}
catch (ThreadAbortException)
{
throw;
}
catch (Exception e)
{
ErrorFormat("An error occured while retrieving post history: {0}", e.Message);
status = Status.Error;
}
Info("Task finished.");
return(new TaskStatus(status));
}
private void PutDataToMainTable(PresentationInfo presInfo)
{
if (presInfo == null)
{
throw new ArgumentNullException("presInfo");
}
#region Создание таблицы main, если это необходимо
try
{
{
MySqlCommand command = _MySqlConnection.CreateCommand();
command.CommandText = String.Format(@"CREATE TABLE IF NOT EXISTS `{0}`
(
`id` MEDIUMINT NOT NULL,
`url_news` VARCHAR(300) NOT NULL,
`nazvanie` VARCHAR(300) NULL,
`category` VARCHAR(300) NOT NULL,
`iframe` MEDIUMTEXT NULL,
`url_dowload` TEXT(1000) NOT NULL,
`lastSmallImageIndex` INT NULL,
UNIQUE KEY (lastSmallImageIndex, id)
) CHARSET={1}", SecurityElement.Escape(_MAIN_TABLE_NAME), TABLE_CHARSET);
command.ExecuteNonQuery();
}
}
catch (Exception ex)
{
throw new Exception(String.Format("Во время создания таблицы 'main' произошла ошибка: {1}", ex.Message));
}
#endregion
#region Получаю данные из таблицы, необходимые для доформирования информации о презентации
#region Получаю информацию о предыдущей презентации
try
{
MySqlCommand command = _MySqlConnection.CreateCommand();
command.CommandText = String.Format("SELECT * FROM `{0}` ORDER BY id DESC LIMIT 1", _MAIN_TABLE_NAME);
var reader = command.ExecuteReader();
int lastPresentationId = 0,
lastSmallImageIndex = 0,
lastAverageImageIndex = 0,
lastBigImageIndex = 0;
if (reader.HasRows)
{
reader.Read();
Int32.TryParse(reader.GetString("lastSmallImageIndex"), out lastSmallImageIndex);
Int32.TryParse(reader.GetString("id"), out lastPresentationId);
}
reader.Close();
presInfo.DbId = ++lastPresentationId;
presInfo.SlidersInfo.ForEach(info =>
{
if (!String.IsNullOrEmpty(info.ImageNameClientBig))
{
info.ImageNameServerBig = ++lastBigImageIndex + ".jpg";
}
if (!String.IsNullOrEmpty(info.ImageNameClientAverage))
{
info.ImageNameServerAverage = ++lastAverageImageIndex + ".jpg";
}
if (!String.IsNullOrEmpty(info.ImageNameClientSmall))
{
info.ImageNameServerSmall = ++lastSmallImageIndex + ".png";
}
});
presInfo.LastImageSmallIndex = lastSmallImageIndex;
}
catch (Exception ex)
{
throw new Exception(String.Format("При получении данных из таблицы {0}, необходимых для формирования информации по экспорту новой презентации, произошла ошибка: {1}", _MAIN_TABLE_NAME, ex.Message));
}
#endregion
#region Формирую уникальный url_news
try
{
int coincidenceCount = 0;
string newNameAsTranslit;
bool isNeedNextLoop = true;
do
{
if (coincidenceCount == 0)
{
newNameAsTranslit = presInfo.NameAsTranslit;
}
else
{
newNameAsTranslit = presInfo.NameAsTranslit + coincidenceCount;
}
MySqlCommand command = _MySqlConnection.CreateCommand();
command.CommandText = String.Format("SELECT id FROM {0} WHERE url_news='{1}'", _MAIN_TABLE_NAME, newNameAsTranslit);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
coincidenceCount++;
}
else
{
isNeedNextLoop = false;
}
}
} while (isNeedNextLoop);
presInfo.NameAsTranslit = newNameAsTranslit;
}
catch (Exception ex)
{
throw new Exception(String.Format("При формировании уникального url_new произошла ошибка: {0}", ex.Message));
}
#endregion
#endregion
try
{
MySqlCommand command = _MySqlConnection.CreateCommand();
command.CommandText = String.Format(@"INSERT INTO `{7}` (`id`, `url_news`, `nazvanie`, `category`, `iframe`, `url_dowload`, `lastSmallImageIndex`) VALUES ({0}, '{1}', '{2}', '{3}', '{4}', '{5}', '{6}')",
presInfo.DbId, SecurityElement.Escape(presInfo.UrlNews), SecurityElement.Escape(presInfo.Name), SecurityElement.Escape(presInfo.Categorie.ToString().Unidecode()),
SecurityElement.Escape(FormatIframeBDColumn(presInfo)), SecurityElement.Escape(presInfo.UrlDownload), presInfo.LastImageSmallIndex, SecurityElement.Escape(_MAIN_TABLE_NAME));
command.ExecuteNonQuery();
}
catch (Exception ex)
{
throw new Exception(String.Format("Во время заполнения таблицы 'main' презентацией '{0}' произошла ошибка: {1}", presInfo.Name, ex.Message));
}
}
public static string XmlEncode(this string @string)
{
return(SecurityElement.Escape(@string));
}
public static String XmlDataEscape(String value)
{
return(SecurityElement.Escape(value));
}
[System.Security.SecurityCritical] // auto-generated
internal SecurityElement ToXml(PolicyLevel level, String policyClassName)
{
if (m_membershipCondition == null && m_element != null)
{
ParseMembershipCondition();
}
if (m_children == null)
{
ParseChildren();
}
if (m_policy == null && m_element != null)
{
ParsePolicy();
}
SecurityElement e = new SecurityElement("CodeGroup");
System.Security.Util.XMLUtil.AddClassAttribute(e, this.GetType(), policyClassName);
// If you hit this assert then most likely you are trying to change the name of this class.
// This is ok as long as you change the hard coded string above and change the assert below.
Contract.Assert(this.GetType().FullName.Equals(policyClassName), "Incorrect class name passed in! Was: " + policyClassName + " Should be " + this.GetType().FullName);
e.AddAttribute("version", "1");
e.AddChild(m_membershipCondition.ToXml(level));
// Grab the inerts of the policy statement's xml and just stick it
// into the code group xml directly. We do this to hide the policy statement from
// users in the config file.
if (m_policy != null)
{
PermissionSet permSet = m_policy.GetPermissionSetNoCopy();
NamedPermissionSet namedPermSet = permSet as NamedPermissionSet;
if (namedPermSet != null && level != null && level.GetNamedPermissionSetInternal(namedPermSet.Name) != null)
{
e.AddAttribute("PermissionSetName", namedPermSet.Name);
}
else
{
if (!permSet.IsEmpty())
{
e.AddChild(permSet.ToXml());
}
}
if (m_policy.Attributes != PolicyStatementAttribute.Nothing)
{
e.AddAttribute("Attributes", XMLUtil.BitFieldEnumToString(typeof(PolicyStatementAttribute), m_policy.Attributes));
}
}
if (m_children.Count > 0)
{
lock (this)
{
IEnumerator enumerator = m_children.GetEnumerator();
while (enumerator.MoveNext())
{
e.AddChild(((CodeGroup)enumerator.Current).ToXml(level));
}
}
}
if (m_name != null)
{
e.AddAttribute("Name", SecurityElement.Escape(m_name));
}
if (m_description != null)
{
e.AddAttribute("Description", SecurityElement.Escape(m_description));
}
CreateXml(e, level);
return(e);
}
void Save()
{
if (IsMarkedForDeletion)
{
return;
}
SecurityElement se = new SecurityElement("values");
lock (values){
if (!File.Exists(file) && values.Count == 0)
{
return;
}
// With SecurityElement.Text = value, and SecurityElement.AddAttribute(key, value)
// the values must be escaped prior to being assigned.
foreach (DictionaryEntry de in values)
{
object val = de.Value;
SecurityElement value = new SecurityElement("value");
value.AddAttribute("name", SecurityElement.Escape((string)de.Key));
if (val is string)
{
value.AddAttribute("type", "string");
value.Text = SecurityElement.Escape((string)val);
}
else if (val is int)
{
value.AddAttribute("type", "int");
value.Text = val.ToString();
}
else if (val is long)
{
value.AddAttribute("type", "qword");
value.Text = val.ToString();
}
else if (val is byte [])
{
value.AddAttribute("type", "bytearray");
value.Text = Convert.ToBase64String((byte[])val);
}
else if (val is ExpandString)
{
value.AddAttribute("type", "expand");
value.Text = SecurityElement.Escape(val.ToString());
}
else if (val is string [])
{
value.AddAttribute("type", "string-array");
foreach (string ss in (string[])val)
{
SecurityElement str = new SecurityElement("string");
str.Text = SecurityElement.Escape(ss);
value.AddChild(str);
}
}
se.AddChild(value);
}
}
using (FileStream fs = File.Create(file)){
StreamWriter sw = new StreamWriter(fs);
sw.Write(se.ToString());
sw.Flush();
}
}
/// <summary>
/// Replaces invalid XML characters in a string with their valid XML equivalent.
/// </summary>
/// <param name="str">The string within which to escape invalid characters.</param>
/// <returns>The input string with invalid characters replaced.</returns>
public static string ConvertInvalidXMLCharacters(string str)
{
return(SecurityElement.Escape(str));
}
public void OnChars(string ch)
{
current.Text = SecurityElement.Escape(ch);
}
public static void PrintBadge(Badge badge, bool backOnly = false)
{
var labelData = Encoding.ASCII.GetString(Properties.Resources.BadgeFront);
var label = DYMO.Label.Framework.Label.OpenXml(labelData);
var builder = new LabelSetBuilder();
var record = builder.AddRecord();
if (!backOnly)
{
record.AddTextMarkup("BadgeName", "<font family=\"Arial\" size=\"32\">" + SecurityElement.Escape(badge.BadgeName) + "</font>");
record.AddTextMarkup("BadgeNumber", "<font family=\"Lucida Console\" size=\"22\">" + badge.BadgeNumber + "</font>");
label.Print(Framework.GetLabelWriterPrinters().First(), null, builder.Xml);
}
if (badge.BadgeTypeID == 2)
{
labelData = Encoding.ASCII.GetString(Properties.Resources.BadgeBackKid);
label = DYMO.Label.Framework.Label.OpenXml(labelData);
builder = new LabelSetBuilder();
record = builder.AddRecord();
record.AddTextMarkup("RealName", "<font family=\"Arial\" size=\"18\">" + SecurityElement.Escape(badge.Name) + "</font>");
record.AddTextMarkup("ParentName", "<font family=\"Arial\" size=\"18\">" + SecurityElement.Escape(badge.ParentName) +
" " + SecurityElement.Escape(badge.ParentContact) + "</font>");
record.AddTextMarkup("BadgeType", "<font family=\"Arial\" size=\"18\">" + SecurityElement.Escape(badge.Description) + "</font>");
record.AddTextMarkup("BadgeNumber", "<font family=\"Lucida Console\" size=\"22\">" + badge.BadgeNumber + "</font>");
label.Print(Framework.GetLabelWriterPrinters().First(), null, builder.Xml);
}
else
{
labelData = Encoding.ASCII.GetString(Properties.Resources.BadgeBack);
label = DYMO.Label.Framework.Label.OpenXml(labelData);
builder = new LabelSetBuilder();
record = builder.AddRecord();
record.AddTextMarkup("RealName", "<font family=\"Arial\" size=\"24\">" + SecurityElement.Escape(badge.Name) + "</font>");
record.AddTextMarkup("BadgeType", "<font family=\"Arial\" size=\"24\">" + SecurityElement.Escape(badge.Description) + "</font>");
record.AddTextMarkup("BadgeNumber", "<font family=\"Lucida Console\" size=\"22\">" + badge.BadgeNumber + "</font>");
label.Print(Framework.GetLabelWriterPrinters().First(), null, builder.Xml);
}
}
public void Save(BaseItem item, CancellationToken cancellationToken)
{
var builder = new StringBuilder();
builder.Append("<tvshow>");
var task = XmlSaverHelpers.AddCommonNodes(item, builder, _libraryManager);
Task.WaitAll(task);
var tvdb = item.GetProviderId(MetadataProviders.Tvdb);
if (!string.IsNullOrEmpty(tvdb))
{
builder.Append("<id>" + SecurityElement.Escape(tvdb) + "</id>");
builder.AppendFormat("<episodeguide><url cache=\"{0}.xml\">http://www.thetvdb.com/api/1D62F2F90030C444/series/{0}/all/{1}.zip</url></episodeguide>",
tvdb,
string.IsNullOrEmpty(_config.Configuration.PreferredMetadataLanguage) ? "en" : _config.Configuration.PreferredMetadataLanguage);
}
var imdb = item.GetProviderId(MetadataProviders.Imdb);
if (!string.IsNullOrEmpty(imdb))
{
builder.Append("<imdb_id>" + SecurityElement.Escape(imdb) + "</imdb_id>");
}
builder.Append("<season>-1</season>");
builder.Append("<episode>-1</episode>");
var series = (Series)item;
if (series.Status.HasValue)
{
builder.Append("<status>" + SecurityElement.Escape(series.Status.Value.ToString()) + "</status>");
}
if (series.Studios.Count > 0)
{
builder.Append("<studio>" + SecurityElement.Escape(item.Studios[0]) + "</studio>");
}
if (!string.IsNullOrEmpty(series.AirTime))
{
builder.Append("<airs_time>" + SecurityElement.Escape(series.AirTime) + "</airs_time>");
}
if (series.AirDays.Count == 7)
{
builder.Append("<airs_dayofweek>" + SecurityElement.Escape("Daily") + "</airs_dayofweek>");
}
else if (series.AirDays.Count > 0)
{
builder.Append("<airs_dayofweek>" + SecurityElement.Escape(series.AirDays[0].ToString()) + "</airs_dayofweek>");
}
builder.Append("</tvshow>");
var xmlFilePath = GetSavePath(item);
XmlSaverHelpers.Save(builder, xmlFilePath, new[]
{
"id",
"imdb_id",
"season",
"episode",
"status",
"studio",
"airs_time",
"airs_dayofweek",
"episodeguide"
});
}
public static string GetXmlValue(object value, Type objectType)
{
string xmlValue = null;
if (value != null)
{
var typeCode = Type.GetTypeCode(objectType);
if (typeCode != TypeCode.DBNull)
{
switch (typeCode)
{
case TypeCode.Boolean:
xmlValue = XmlConvert.ToString((bool)value);
break;
case TypeCode.String:
xmlValue = SecurityElement.Escape((string)value);
break;
case TypeCode.DateTime:
xmlValue = XmlConvert.ToString((DateTime)value, XmlDateTimeSerializationMode.Utc);
break;
case TypeCode.Byte:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.Char:
case TypeCode.Single:
case TypeCode.Double:
case TypeCode.Decimal:
xmlValue = Convert.ToString(value);
break;
default:
if (objectType == typeof(byte[]))
{
xmlValue = Convert.ToBase64String((byte[])value);
}
else if (objectType == typeof(DateTimeOffset))
{
xmlValue = XmlConvert.ToString((DateTimeOffset)value);
}
else if (objectType == typeof(TimeSpan))
{
xmlValue = XmlConvert.ToString((TimeSpan)value);
}
else if (objectType == typeof(Guid))
{
xmlValue = ((Guid)value).ToString("D");
}
break;
}
}
}
return(xmlValue);
}
/// <summary>
/// Adds the common nodes.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="builder">The builder.</param>
public static void AddCommonNodes(BaseItem item, ILibraryManager libraryManager, StringBuilder builder)
{
if (!string.IsNullOrEmpty(item.OfficialRating))
{
builder.Append("<ContentRating>" + SecurityElement.Escape(item.OfficialRating) + "</ContentRating>");
}
if (!string.IsNullOrEmpty(item.OfficialRatingDescription))
{
builder.Append("<MPAADescription>" + SecurityElement.Escape(item.OfficialRatingDescription) + "</MPAADescription>");
}
builder.Append("<Added>" + SecurityElement.Escape(item.DateCreated.ToLocalTime().ToString("G")) + "</Added>");
builder.Append("<LockData>" + item.IsLocked.ToString().ToLower() + "</LockData>");
if (item.LockedFields.Count > 0)
{
builder.Append("<LockedFields>" + string.Join("|", item.LockedFields.Select(i => i.ToString()).ToArray()) + "</LockedFields>");
}
if (!string.IsNullOrEmpty(item.DisplayMediaType))
{
builder.Append("<Type>" + SecurityElement.Escape(item.DisplayMediaType) + "</Type>");
}
var hasCriticRating = item as IHasCriticRating;
if (hasCriticRating != null)
{
if (hasCriticRating.CriticRating.HasValue)
{
builder.Append("<CriticRating>" + SecurityElement.Escape(hasCriticRating.CriticRating.Value.ToString(UsCulture)) + "</CriticRating>");
}
if (!string.IsNullOrEmpty(hasCriticRating.CriticRatingSummary))
{
builder.Append("<CriticRatingSummary><![CDATA[" + hasCriticRating.CriticRatingSummary + "]]></CriticRatingSummary>");
}
}
if (!string.IsNullOrEmpty(item.Overview))
{
builder.Append("<Overview><![CDATA[" + item.Overview + "]]></Overview>");
}
var hasOriginalTitle = item as IHasOriginalTitle;
if (hasOriginalTitle != null)
{
if (!string.IsNullOrEmpty(hasOriginalTitle.OriginalTitle))
{
builder.Append("<OriginalTitle>" + SecurityElement.Escape(hasOriginalTitle.OriginalTitle) + "</OriginalTitle>");
}
}
var hasShortOverview = item as IHasShortOverview;
if (hasShortOverview != null)
{
if (!string.IsNullOrEmpty(hasShortOverview.ShortOverview))
{
builder.Append("<ShortOverview><![CDATA[" + hasShortOverview.ShortOverview + "]]></ShortOverview>");
}
}
if (!string.IsNullOrEmpty(item.CustomRating))
{
builder.Append("<CustomRating>" + SecurityElement.Escape(item.CustomRating) + "</CustomRating>");
}
if (!string.IsNullOrEmpty(item.Name) && !(item is Episode))
{
builder.Append("<LocalTitle>" + SecurityElement.Escape(item.Name) + "</LocalTitle>");
}
if (!string.IsNullOrEmpty(item.ForcedSortName))
{
builder.Append("<SortTitle>" + SecurityElement.Escape(item.ForcedSortName) + "</SortTitle>");
}
if (item.PremiereDate.HasValue)
{
if (item is Person)
{
builder.Append("<BirthDate>" + SecurityElement.Escape(item.PremiereDate.Value.ToLocalTime().ToString("yyyy-MM-dd")) + "</BirthDate>");
}
else if (!(item is Episode))
{
builder.Append("<PremiereDate>" + SecurityElement.Escape(item.PremiereDate.Value.ToLocalTime().ToString("yyyy-MM-dd")) + "</PremiereDate>");
}
}
if (item.EndDate.HasValue)
{
if (item is Person)
{
builder.Append("<DeathDate>" + SecurityElement.Escape(item.EndDate.Value.ToString("yyyy-MM-dd")) + "</DeathDate>");
}
else if (!(item is Episode))
{
builder.Append("<EndDate>" + SecurityElement.Escape(item.EndDate.Value.ToString("yyyy-MM-dd")) + "</EndDate>");
}
}
var hasTrailers = item as IHasTrailers;
if (hasTrailers != null)
{
if (hasTrailers.RemoteTrailers.Count > 0)
{
builder.Append("<Trailers>");
foreach (var trailer in hasTrailers.RemoteTrailers)
{
builder.Append("<Trailer>" + SecurityElement.Escape(trailer.Url) + "</Trailer>");
}
builder.Append("</Trailers>");
}
}
var hasDisplayOrder = item as IHasDisplayOrder;
if (hasDisplayOrder != null && !string.IsNullOrEmpty(hasDisplayOrder.DisplayOrder))
{
builder.Append("<DisplayOrder>" + SecurityElement.Escape(hasDisplayOrder.DisplayOrder) + "</DisplayOrder>");
}
var hasMetascore = item as IHasMetascore;
if (hasMetascore != null && hasMetascore.Metascore.HasValue)
{
builder.Append("<Metascore>" + SecurityElement.Escape(hasMetascore.Metascore.Value.ToString(UsCulture)) + "</Metascore>");
}
var hasAwards = item as IHasAwards;
if (hasAwards != null && !string.IsNullOrEmpty(hasAwards.AwardSummary))
{
builder.Append("<AwardSummary>" + SecurityElement.Escape(hasAwards.AwardSummary) + "</AwardSummary>");
}
var hasBudget = item as IHasBudget;
if (hasBudget != null)
{
if (hasBudget.Budget.HasValue)
{
builder.Append("<Budget>" + SecurityElement.Escape(hasBudget.Budget.Value.ToString(UsCulture)) + "</Budget>");
}
if (hasBudget.Revenue.HasValue)
{
builder.Append("<Revenue>" + SecurityElement.Escape(hasBudget.Revenue.Value.ToString(UsCulture)) + "</Revenue>");
}
}
if (item.CommunityRating.HasValue)
{
builder.Append("<Rating>" + SecurityElement.Escape(item.CommunityRating.Value.ToString(UsCulture)) + "</Rating>");
}
if (item.VoteCount.HasValue)
{
builder.Append("<VoteCount>" + SecurityElement.Escape(item.VoteCount.Value.ToString(UsCulture)) + "</VoteCount>");
}
if (item.ProductionYear.HasValue && !(item is Person))
{
builder.Append("<ProductionYear>" + SecurityElement.Escape(item.ProductionYear.Value.ToString(UsCulture)) + "</ProductionYear>");
}
if (!string.IsNullOrEmpty(item.HomePageUrl))
{
builder.Append("<Website>" + SecurityElement.Escape(item.HomePageUrl) + "</Website>");
}
var hasAspectRatio = item as IHasAspectRatio;
if (hasAspectRatio != null)
{
if (!string.IsNullOrEmpty(hasAspectRatio.AspectRatio))
{
builder.Append("<AspectRatio>" + SecurityElement.Escape(hasAspectRatio.AspectRatio) + "</AspectRatio>");
}
}
if (!string.IsNullOrEmpty(item.PreferredMetadataLanguage))
{
builder.Append("<Language>" + SecurityElement.Escape(item.PreferredMetadataLanguage) + "</Language>");
}
if (!string.IsNullOrEmpty(item.PreferredMetadataCountryCode))
{
builder.Append("<CountryCode>" + SecurityElement.Escape(item.PreferredMetadataCountryCode) + "</CountryCode>");
}
// Use original runtime here, actual file runtime later in MediaInfo
var runTimeTicks = item.RunTimeTicks;
if (runTimeTicks.HasValue)
{
var timespan = TimeSpan.FromTicks(runTimeTicks.Value);
builder.Append("<RunningTime>" + Convert.ToInt32(timespan.TotalMinutes).ToString(UsCulture) + "</RunningTime>");
}
var imdb = item.GetProviderId(MetadataProviders.Imdb);
if (!string.IsNullOrEmpty(imdb))
{
builder.Append("<IMDB>" + SecurityElement.Escape(imdb) + "</IMDB>");
}
var tmdb = item.GetProviderId(MetadataProviders.Tmdb);
if (!string.IsNullOrEmpty(tmdb))
{
builder.Append("<TMDbId>" + SecurityElement.Escape(tmdb) + "</TMDbId>");
}
if (!(item is Series))
{
var tvdb = item.GetProviderId(MetadataProviders.Tvdb);
if (!string.IsNullOrEmpty(tvdb))
{
builder.Append("<TvDbId>" + SecurityElement.Escape(tvdb) + "</TvDbId>");
}
}
var externalId = item.GetProviderId(MetadataProviders.Tvcom);
if (!string.IsNullOrEmpty(externalId))
{
builder.Append("<TVcomId>" + SecurityElement.Escape(externalId) + "</TVcomId>");
}
externalId = item.GetProviderId(MetadataProviders.RottenTomatoes);
if (!string.IsNullOrEmpty(externalId))
{
builder.Append("<RottenTomatoesId>" + SecurityElement.Escape(externalId) + "</RottenTomatoesId>");
}
externalId = item.GetProviderId(MetadataProviders.Zap2It);
if (!string.IsNullOrEmpty(externalId))
{
builder.Append("<Zap2ItId>" + SecurityElement.Escape(externalId) + "</Zap2ItId>");
}
externalId = item.GetProviderId(MetadataProviders.MusicBrainzAlbum);
if (!string.IsNullOrEmpty(externalId))
{
builder.Append("<MusicBrainzAlbumId>" + SecurityElement.Escape(externalId) + "</MusicBrainzAlbumId>");
}
externalId = item.GetProviderId(MetadataProviders.MusicBrainzAlbumArtist);
if (!string.IsNullOrEmpty(externalId))
{
builder.Append("<MusicBrainzAlbumArtistId>" + SecurityElement.Escape(externalId) + "</MusicBrainzAlbumArtistId>");
}
externalId = item.GetProviderId(MetadataProviders.MusicBrainzArtist);
if (!string.IsNullOrEmpty(externalId))
{
builder.Append("<MusicBrainzArtistId>" + SecurityElement.Escape(externalId) + "</MusicBrainzArtistId>");
}
externalId = item.GetProviderId(MetadataProviders.MusicBrainzReleaseGroup);
if (!string.IsNullOrEmpty(externalId))
{
builder.Append("<MusicBrainzReleaseGroupId>" + SecurityElement.Escape(externalId) + "</MusicBrainzReleaseGroupId>");
}
externalId = item.GetProviderId(MetadataProviders.Gamesdb);
if (!string.IsNullOrEmpty(externalId))
{
builder.Append("<GamesDbId>" + SecurityElement.Escape(externalId) + "</GamesDbId>");
}
externalId = item.GetProviderId(MetadataProviders.TmdbCollection);
if (!string.IsNullOrEmpty(externalId))
{
builder.Append("<TMDbCollectionId>" + SecurityElement.Escape(externalId) + "</TMDbCollectionId>");
}
externalId = item.GetProviderId(MetadataProviders.AudioDbArtist);
if (!string.IsNullOrEmpty(externalId))
{
builder.Append("<AudioDbArtistId>" + SecurityElement.Escape(externalId) + "</AudioDbArtistId>");
}
externalId = item.GetProviderId(MetadataProviders.AudioDbAlbum);
if (!string.IsNullOrEmpty(externalId))
{
builder.Append("<AudioDbAlbumId>" + SecurityElement.Escape(externalId) + "</AudioDbAlbumId>");
}
externalId = item.GetProviderId(MetadataProviders.TvRage);
if (!string.IsNullOrEmpty(externalId))
{
builder.Append("<TVRageId>" + SecurityElement.Escape(externalId) + "</TVRageId>");
}
if (!string.IsNullOrWhiteSpace(item.Tagline))
{
builder.Append("<Taglines>");
builder.Append("<Tagline>" + SecurityElement.Escape(item.Tagline) + "</Tagline>");
builder.Append("</Taglines>");
}
if (item.Genres.Count > 0)
{
builder.Append("<Genres>");
foreach (var genre in item.Genres)
{
builder.Append("<Genre>" + SecurityElement.Escape(genre) + "</Genre>");
}
builder.Append("</Genres>");
}
if (item.Studios.Count > 0)
{
builder.Append("<Studios>");
foreach (var studio in item.Studios)
{
builder.Append("<Studio>" + SecurityElement.Escape(studio) + "</Studio>");
}
builder.Append("</Studios>");
}
if (item.Tags.Count > 0)
{
builder.Append("<Tags>");
foreach (var tag in item.Tags)
{
builder.Append("<Tag>" + SecurityElement.Escape(tag) + "</Tag>");
}
builder.Append("</Tags>");
}
if (item.Keywords.Count > 0)
{
builder.Append("<PlotKeywords>");
foreach (var tag in item.Keywords)
{
builder.Append("<PlotKeyword>" + SecurityElement.Escape(tag) + "</PlotKeyword>");
}
builder.Append("</PlotKeywords>");
}
var people = libraryManager.GetPeople(item);
if (people.Count > 0)
{
builder.Append("<Persons>");
foreach (var person in people)
{
builder.Append("<Person>");
builder.Append("<Name>" + SecurityElement.Escape(person.Name) + "</Name>");
builder.Append("<Type>" + SecurityElement.Escape(person.Type) + "</Type>");
builder.Append("<Role>" + SecurityElement.Escape(person.Role) + "</Role>");
if (person.SortOrder.HasValue)
{
builder.Append("<SortOrder>" + SecurityElement.Escape(person.SortOrder.Value.ToString(UsCulture)) + "</SortOrder>");
}
builder.Append("</Person>");
}
builder.Append("</Persons>");
}
var boxset = item as BoxSet;
if (boxset != null)
{
AddLinkedChildren(boxset, builder, "CollectionItems", "CollectionItem");
}
var playlist = item as Playlist;
if (playlist != null)
{
AddLinkedChildren(playlist, builder, "PlaylistItems", "PlaylistItem");
}
var hasShares = item as IHasShares;
if (hasShares != null)
{
AddShares(hasShares, builder);
}
}
//? - not clear if it is suitable for any request
static string get_CiscoIPPhoneResponse(params ResponseItem[] ris)
{
//XmlDocument xd = new XmlDocument();
//XmlNode xn = xd.CreateNode()
//xd.AppendChild()
StringBuilder sb = new StringBuilder();
sb.Append("<CiscoIPPhoneResponse>");
sb.Append("<test>" + HttpService.Name + ":" + HttpService.Port + "</test>");
foreach (ResponseItem ri in ris)
{
sb.Append("<ResponseItem Status=\"" + ri.Status + "\" Data=\"" + SecurityElement.Escape(ri.Data) + "\" URL=\"" + SecurityElement.Escape(ri.Url) + "\"/>");
}
sb.Append("</CiscoIPPhoneResponse>");
return(sb.ToString());
}
protected virtual string ProcessCommonWebpartProperties(string webPartXml, WebPartDefinitionBase definition)
{
var xml = WebpartXmlExtensions.LoadWebpartXmlDocument(webPartXml)
.SetTitle(definition.Title)
.SetID(definition.Id);
if (definition.Width.HasValue)
{
xml.SetWidth(definition.Width.Value);
}
if (definition.Height.HasValue)
{
xml.SetHeight(definition.Height.Value);
}
if (!string.IsNullOrEmpty(definition.Description))
{
xml.SetDescription(definition.Description);
}
if (!string.IsNullOrEmpty(definition.ImportErrorMessage))
{
xml.SetImportErrorMessage(definition.ImportErrorMessage);
}
if (!string.IsNullOrEmpty(definition.TitleUrl))
{
xml.SetTitleUrl(definition.TitleUrl);
}
if (!string.IsNullOrEmpty(definition.TitleIconImageUrl))
{
xml.SetTitleIconImageUrl(definition.TitleIconImageUrl);
}
if (!string.IsNullOrEmpty(definition.ChromeState))
{
xml.SetChromeState(definition.ChromeState);
}
if (!string.IsNullOrEmpty(definition.ChromeType))
{
var chromeType = string.Empty;
if (xml.IsV3version())
{
chromeType = WebPartChromeTypesConvertService.NormilizeValueToPartChromeTypes(definition.ChromeType);
}
else if (xml.IsV2version())
{
chromeType = WebPartChromeTypesConvertService.NormilizeValueToFrameTypes(definition.ChromeType);
}
// SetChromeType() sets correct XML props depending on V2/V3 web part XML
xml.SetChromeType(chromeType);
}
if (!string.IsNullOrEmpty(definition.ExportMode))
{
xml.SetExportMode(definition.ExportMode);
}
if (definition.ParameterBindings != null && definition.ParameterBindings.Count > 0)
{
var parameterBinder = new WebPartParameterBindingsOptions();
foreach (var binding in definition.ParameterBindings)
{
parameterBinder.AddParameterBinding(binding.Name, binding.Location);
}
var parameterBindingValue = SecurityElement.Escape(parameterBinder.ParameterBinding);
xml.SetOrUpdateProperty("ParameterBindings", parameterBindingValue);
}
return(xml.ToString());
}
