private async Task AddUrlAsync(string file, PageDefinition page, string canonicalUrl, DateTime?lastMod, PageDefinition.SiteMapPriorityEnum siteMapPriority, PageDefinition.ChangeFrequencyEnum changeFrequency)
{
if (!PagesFound.Contains(page.PageGuid)) // keep track of pages so we don't add it as a designed page in case it was dynamic
{
PagesFound.Add(page.PageGuid);
}
canonicalUrl = Manager.CurrentSite.MakeUrl(canonicalUrl, PagePageSecurity: page.PageSecurity);
if (!ValidForSiteMap(page))
{
return;
}
string cf = GetChangeFrequencyText(changeFrequency);
float prio = GetPriority(siteMapPriority);
var w3clastMod = lastMod != null?string.Format(" <lastmod>{0}</lastmod>\r\n", XmlConvert.ToString((DateTime)lastMod, XmlDateTimeSerializationMode.Utc)) : "";
#if MVC6
canonicalUrl = WebUtility.HtmlEncode(canonicalUrl);
#else
canonicalUrl = AntiXssEncoder.XmlEncode(canonicalUrl);
#endif
await FileSystem.FileSystemProvider.AppendAllTextAsync(file, string.Format(
" <url>\r\n" +
" <loc>{0}</loc>\r\n" +
"{1}" +
" <changefreq>{2}</changefreq>\r\n" +
" <priority>{3}</priority>\r\n" +
" </url>\r\n", canonicalUrl, w3clastMod, cf, prio)
);
}
private async Task AddUrlAsync(string file, PageDefinition page, BlogEntry blogEntry, string canonicalUrl, DateTime?lastMod)
{
if (!blogEntry.Published)
{
return;
}
if (blogEntry.DatePublished < DateTime.UtcNow.AddDays(-3))
{
return; // too old
}
canonicalUrl = Manager.CurrentSite.MakeUrl(canonicalUrl, PagePageSecurity: page.PageSecurity);
if (!ValidForNewsSiteMap(page))
{
return;
}
foreach (LanguageData lang in MultiString.Languages)
{
string blogTitle, kwds, publishDate, blogCategory, langId;
publishDate = XmlConvert.ToString(blogEntry.DatePublished, XmlDateTimeSerializationMode.Utc);
#if MVC6
canonicalUrl = WebUtility.HtmlEncode(canonicalUrl);
blogTitle = WebUtility.HtmlEncode(blogEntry.Title[lang.Id]);
kwds = WebUtility.HtmlEncode(blogEntry.Keywords[lang.Id]);
blogCategory = WebUtility.HtmlEncode((await blogEntry.GetCategoryAsync())[lang.Id]);
langId = WebUtility.HtmlEncode(lang.Id);
#else
canonicalUrl = AntiXssEncoder.XmlEncode(canonicalUrl);
blogTitle = AntiXssEncoder.XmlEncode(blogEntry.Title[lang.Id]);
kwds = AntiXssEncoder.XmlEncode(blogEntry.Keywords[lang.Id]);
blogCategory = AntiXssEncoder.XmlEncode((await blogEntry.GetCategoryAsync())[lang.Id]);
langId = AntiXssEncoder.XmlEncode(lang.Id);
#endif
await FileSystem.FileSystemProvider.AppendAllTextAsync(file, string.Format(
" <url>\r\n" +
" <loc>{0}</loc>\r\n" +
" <news:news>\r\n" +
" <news:publication>\r\n" +
" <news:name>{1}</news:name>\r\n" +
" <news:language>{2}</news:language>\r\n" +
" </news:publication>\r\n" +
" <news:genres>Blog</news:genres>\r\n" +
" <news:publication_date>{3}</news:publication_date>\r\n" +
" <news:title>{4}</news:title>\r\n" +
" <news:keywords>{5}</news:keywords>\r\n" +
" </news:news>\r\n" +
" </url>\r\n", canonicalUrl, blogCategory, langId, publishDate, blogTitle, kwds
));
}
}
public async Task <List <string> > TranslateAsync(string from, string to, List <string> strings)
{
if (strings.Count == 0)
{
return(new List <string>());
}
if (_token == null)
{
MSAuthentication auth = new MSAuthentication(_clientId);
_token = await auth.GetAccessTokenAsync();
}
string headerValue = "Bearer " + _token;
string uri = "http://api.microsofttranslator.com/v2/Http.svc/TranslateArray";
HtmlBuilder hb = new HtmlBuilder();
hb.Append("<TranslateArrayRequest>" +
"<AppId />" +
"<From>{0}</From>" +
"<Options>" +
"<Category xmlns=\"http://schemas.datacontract.org/2004/07/Microsoft.MT.Web.Service.V2\" />" +
"<ContentType xmlns=\"http://schemas.datacontract.org/2004/07/Microsoft.MT.Web.Service.V2\">text/plain</ContentType>" +
"<ReservedFlags xmlns=\"http://schemas.datacontract.org/2004/07/Microsoft.MT.Web.Service.V2\" />" +
"<State xmlns=\"http://schemas.datacontract.org/2004/07/Microsoft.MT.Web.Service.V2\" />" +
"<Uri xmlns=\"http://schemas.datacontract.org/2004/07/Microsoft.MT.Web.Service.V2\" />" +
"<User xmlns=\"http://schemas.datacontract.org/2004/07/Microsoft.MT.Web.Service.V2\" />" +
"</Options>" +
"<Texts>", from);
foreach (string s in strings)
{
string encoded;
#if MVC6
encoded = System.Net.WebUtility.HtmlEncode(s);
#else
encoded = AntiXssEncoder.XmlEncode(s);
#endif
hb.Append("<string xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/Arrays\">{0}</string>", encoded);
}
hb.Append("</Texts>" +
"<To>{0}</To>" +
"</TranslateArrayRequest>", to);
// create the request
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
request.Headers.Add("Authorization", headerValue);
request.ContentType = "text/xml";
request.Method = "POST";
using (System.IO.Stream stream = await request.GetRequestStreamAsync()) {
byte[] arrBytes = System.Text.Encoding.UTF8.GetBytes(hb.ToString());
await stream.WriteAsync(arrBytes, 0, arrBytes.Length);
}
// Get the response
List <string> newStrings = new List <string>();
WebResponse response = null;
using (response = await request.GetResponseAsync()) {
using (Stream stream = response.GetResponseStream()) {
using (StreamReader rdr = new StreamReader(stream, System.Text.Encoding.UTF8)) {
string strResponse = await rdr.ReadToEndAsync();
XDocument doc = XDocument.Parse(strResponse);
XNamespace ns = "http://schemas.datacontract.org/2004/07/Microsoft.MT.Web.Service.V2";
foreach (XElement xe in doc.Descendants(ns + "TranslateArrayResponse"))
{
foreach (var node in xe.Elements(ns + "TranslatedText"))
{
newStrings.Add(node.Value);
}
}
}
}
}
return(newStrings);
}
protected void btn_xml_Click(object sender, EventArgs e)
{
String s = this.txt_1.Text;
this.txt_2.Text = AntiXssEncoder.XmlEncode(s);
}
private void InitializeParameters(out string fetchXml, out QueryByAttribute query)
{
// merge the select parameters
IOrderedDictionary parameters = QueryParameters.GetValues(_context, _owner);
fetchXml = GetNonNullOrEmpty(
parameters[_fetchXmlParameterName] as string,
_owner.FetchXml);
if (!string.IsNullOrEmpty(fetchXml))
{
IOrderedDictionary selectParameters = SelectParameters.GetValues(_context, _owner);
// apply select parameters replacement to the FetchXml
foreach (DictionaryEntry entry in selectParameters)
{
if (entry.Key != null)
{
string key = entry.Key.ToString().Trim();
if (!key.StartsWith("@"))
{
key = "@" + key;
}
string value = "{0}".FormatWith(entry.Value);
if (Owner.EncodeParametersEnabled)
{
value = AntiXssEncoder.XmlEncode(value);
}
fetchXml = Regex.Replace(fetchXml, key, value, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
}
}
}
// process the QueryByAttribute
query = null;
if (_owner.QueryByAttribute != null && !string.IsNullOrEmpty(_owner.QueryByAttribute.EntityName))
{
IOrderedDictionary selectParameters = SelectParameters.GetValues(_context, _owner);
query = new QueryByAttribute();
query.EntityName = LookupParameter(selectParameters, _owner.QueryByAttribute.EntityName);
query.Attributes.AddRange(CopyParameters(selectParameters, _owner.QueryByAttribute.Attributes));
query.Values.AddRange(CopyParameters(selectParameters, _owner.QueryByAttribute.Values));
if (_owner.QueryByAttribute.ColumnSet != null && _owner.QueryByAttribute.ColumnSet.Count > 0)
{
// specify individual columns to load
query.ColumnSet = new ColumnSet(CopyParameters(selectParameters, _owner.QueryByAttribute.ColumnSet));
}
else
{
// default to all columns
query.ColumnSet = new ColumnSet(true);
}
if (_owner.QueryByAttribute.Orders != null && _owner.QueryByAttribute.Orders.Count > 0)
{
for (int i = 0; i < _owner.QueryByAttribute.Orders.Count; ++i)
{
OrderExpression order = new OrderExpression();
order.AttributeName = LookupParameter(selectParameters, _owner.QueryByAttribute.Orders[i].Value);
string orderText = LookupParameter(selectParameters, _owner.QueryByAttribute.Orders[i].Text);
if (orderText.StartsWith("desc", StringComparison.InvariantCultureIgnoreCase))
{
order.OrderType = OrderType.Descending;
}
query.Orders.Add(order);
}
}
// merge the select parameters
string entityName = parameters[_entityNameParameterName] as string;
if (!string.IsNullOrEmpty(entityName))
{
query.EntityName = entityName;
}
// comma delimited
string attributes = parameters[_attributesParameterName] as string;
if (!string.IsNullOrEmpty(attributes))
{
query.Attributes.Clear();
query.Attributes.AddRange(attributes.Split(','));
}
// comma delimited
string values = parameters[_valuesParameterName] as string;
if (!string.IsNullOrEmpty(values))
{
query.Values.Clear();
query.Values.AddRange(values.Split(','));
}
// comma delimited
string columnSet = parameters[_columnSetParameterName] as string;
if (!string.IsNullOrEmpty(columnSet))
{
if (string.Compare(columnSet, _allColumnsParameterValue, StringComparison.InvariantCultureIgnoreCase) == 0)
{
query.ColumnSet = new ColumnSet(true);
}
else
{
string[] parts = columnSet.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length > 0)
{
for (int i = 0; i < parts.Length; i++)
{
parts[i] = parts[i].Trim();
}
query.ColumnSet.AddColumns(parts);
}
else
{
query.ColumnSet = new ColumnSet(true);
}
}
}
// comma delimited
string orders = parameters[_ordersParameterName] as string;
if (!string.IsNullOrEmpty(orders))
{
QueryByAttribute queryByAttribute = query;
AppendSortExpressionToQuery(orders, order => queryByAttribute.Orders.Add(order));
query = queryByAttribute;
}
// all remaining parameters are treated as key/value pairs
Dictionary <string, object> extendedParameters = new Dictionary <string, object>();
if (query.Attributes != null)
{
for (int i = 0; i < query.Attributes.Count; ++i)
{
extendedParameters[query.Attributes[i]] = query.Values[i];
}
}
bool changed = false;
foreach (string key in parameters.Keys)
{
// ignore special parameters
if (!Array.Exists(_keywords, delegate(string value) { return(string.Compare(value, key, StringComparison.InvariantCultureIgnoreCase) == 0); }))
{
extendedParameters[key] = parameters[key];
changed = true;
}
}
if (changed)
{
query.Attributes.Clear();
query.Values.Clear();
int i = 0;
foreach (KeyValuePair <string, object> extendedParameter in extendedParameters)
{
query.Attributes[i] = extendedParameter.Key;
query.Values[i] = extendedParameter.Value;
++i;
}
}
}
}
