public HttpResponseMessage Export(int id)
{
var contentType = Services.ContentTypeService.Get(id);
if (contentType == null)
{
throw new NullReferenceException("No content type found with id " + id);
}
var serializer = new EntityXmlSerializer();
var xml = serializer.Serialize(
Services.DataTypeService,
Services.ContentTypeService,
contentType);
var response = new HttpResponseMessage
{
Content = new StringContent(xml.ToDataString())
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = $"{contentType.Alias}.udt"
},
ContentType = new MediaTypeHeaderValue("application/octet-stream")
}
}
};
// Set custom header so umbRequestHelper.downloadFile can save the correct filename
response.Headers.Add("x-filename", $"{contentType.Alias}.udt");
return(response);
}
/// <summary>
/// 设定查询的总记录数，从消息头
/// </summary>
/// <param name="info"></param>
/// <param name="isOverwrite"></param>
public static void AppendMessageHeaderResponse(ResponseHeaderInfo info, bool isOverwrite)
{
EntityXmlSerializer <ResponseHeaderInfo> se = new EntityXmlSerializer <ResponseHeaderInfo>();
string dstr = se.SingleSerializer(info, string.Empty);
AppendMessageHeader(SOD.QUERY_RESPONSE_INFO, dstr, isOverwrite);
}
public XmlNode ToXml(XmlDocument doc)
{
var serializer = new EntityXmlSerializer();
var serialized = serializer.Serialize(TemplateEntity);
return(serialized.GetXmlNode(doc));
}
/// <summary>
/// 得到服务端加载的ResponseHeaderInfo
/// </summary>
/// <returns></returns>
public static ResponseHeaderInfo GetResponseHeaderInfo()
{
if (OperationContext.Current == null)
{
return(null);
}
try
{
string header = SOD.QUERY_RESPONSE_INFO;
string ctxt = string.Empty;
var re = OperationContext.Current.OutgoingMessageHeaders.FindHeader(header, SOD.MESSAGE_HEADER_NAME_SPACE);
if (re >= 0)
{
ctxt = OperationContext.Current.OutgoingMessageHeaders.GetHeader <string>(header, SOD.MESSAGE_HEADER_NAME_SPACE);
}
if (!string.IsNullOrEmpty(ctxt))
{
EntityXmlSerializer <ResponseHeaderInfo> ser = new EntityXmlSerializer <ResponseHeaderInfo>();
return(ser.SingleDeSerializer(ctxt, string.Empty));
}
}
catch (Exception ex)
{
MB.Util.TraceEx.Write("在获取当前用户的查询QueryBehavior 出错" + ex.Message, Util.APPMessageType.SysWarning);
}
return(null);
}
public XmlNode ToXml(XmlDocument xd)
{
var serializer = new EntityXmlSerializer();
var xml = serializer.Serialize(ApplicationContext.Current.Services.DataTypeService, this._property);
return(xml.GetXmlNode(xd));
}
/// <summary>
/// Get an xmlrepresentation of the macro, used for exporting the macro to a package for distribution
/// </summary>
/// <param name="xd">Current xmldocument context</param>
/// <returns>An xmlrepresentation of the macro</returns>
public XmlNode ToXml(XmlDocument xd)
{
var serializer = new EntityXmlSerializer();
var xml = serializer.Serialize(MacroEntity);
return(xml.GetXmlNode(xd));
}
private void createTemplateXml(string module, string name, TemplateInfo templateInfo)
{
List <TemplateInfo> templateInfos = getTemplateInfos(module);
TemplateInfo isContainTemplateInfo = new TemplateInfo(name);
if (templateInfos.Contains(isContainTemplateInfo))
{
templateInfos.Remove(isContainTemplateInfo);
}
templateInfo.Name = name;
if (templateInfos.Count >= ChartViewStatic.MAX_TEMPLATE_NUM)
{
templateInfos.RemoveAt(templateInfos.Count - 1);
}
templateInfos.Add(templateInfo);
string fullFileName = getFullTemplateFileName(module);
EntityXmlSerializer <TemplateInfo> entityXmlSerializer = new EntityXmlSerializer <TemplateInfo>();
string xml = entityXmlSerializer.Serializer(templateInfos);
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(xml);
xmlDocument.Save(fullFileName);
}
public XmlElement ToXml(XmlDocument xd)
{
var serializer = new EntityXmlSerializer();
var xml = serializer.Serialize(ApplicationContext.Current.Services.DataTypeService, DataTypeItem);
return((XmlElement)xml.GetXmlNode(xd));
}
/// <summary>
/// 获取当前查询对象的行为信息,这个信息永远都是从WCF消息头里面加载出来的
/// add by aifang 2012-08-13 获取动态列头信息
/// </summary>
/// <returns></returns>
public static QueryBehavior GetQueryBehavior(string messageHeaderKey)
{
string ctxt = string.Empty;
if (OperationContext.Current != null)
{
try
{
string header = SOD.QUERY_BEHAVIOR_MESSAGE_HEADER;
if (!string.IsNullOrEmpty(messageHeaderKey))
{
header += "_" + messageHeaderKey;
}
ctxt = GetMessageHeaderContext(header);
if (!string.IsNullOrEmpty(ctxt))
{
EntityXmlSerializer <QueryBehavior> ser = new EntityXmlSerializer <QueryBehavior>();
return(ser.SingleDeSerializer(ctxt, string.Empty));
}
}
catch (Exception ex)
{
MB.Util.TraceEx.Write("在获取当前用户的查询QueryBehavior 出错" + ex.Message, Util.APPMessageType.SysWarning);
}
}
return(null);
}
public XmlElement ToXml(XmlDocument xd)
{
var exporter = new EntityXmlSerializer();
var xml = exporter.Serialize(ApplicationContext.Current.Services.DataTypeService, ContentType);
//convert the Linq to Xml structure to the old .net xml structure
var xNode = xml.GetXmlNode();
var doc = (XmlElement)xd.ImportNode(xNode, true);
return(doc);
}
/// <summary>
/// 追加当前登录用户的信息到消息头上。
/// </summary>
public static void AppendUserLoginInfo()
{
if (AppEnvironmentSetting.Instance.CurrentLoginUserInfo == null)
{
return;
}
EntityXmlSerializer <SysLoginUserInfo> se = new EntityXmlSerializer <SysLoginUserInfo>();
string dstr = se.SingleSerializer(AppEnvironmentSetting.Instance.CurrentLoginUserInfo, string.Empty);
AppendMessageHeader(SOD.CURRENT_USER_IDENTITY, dstr);
}
/// <summary>
/// 追加当前查询的行为信息
/// </summary>
/// <param name="queryBehavior"></param>
public static void AppendQueryBehavior(QueryBehavior queryBehavior, string messageKey)
{
EntityXmlSerializer <QueryBehavior> se = new EntityXmlSerializer <QueryBehavior>();
string dstr = se.SingleSerializer(queryBehavior, string.Empty);
string queryBehavuorMessageHeader = SOD.QUERY_BEHAVIOR_MESSAGE_HEADER;
if (!string.IsNullOrEmpty(messageKey))
{
queryBehavuorMessageHeader = queryBehavuorMessageHeader + "_" + messageKey;
}
AppendMessageHeader(queryBehavuorMessageHeader, dstr);
}
public XmlNode ToXml(XmlDocument xd)
{
var serializer = new EntityXmlSerializer();
var xml = serializer.Serialize(_dictionaryItem);
var xmlNode = xml.GetXmlNode(xd);
if (this.hasChildren)
{
foreach (var di in this.Children)
{
xmlNode.AppendChild(di.ToXml(xd));
}
}
return(xmlNode);
}
public void AfterReceiveReply(ref System.ServiceModel.Channels.Message reply, object correlationState)
{
string ctxt = string.Empty;
var re = reply.Headers.FindHeader(SOD.QUERY_RESPONSE_INFO, SOD.MESSAGE_HEADER_NAME_SPACE);
if (re >= 0)
{
ctxt = reply.Headers.GetHeader <string>(SOD.QUERY_RESPONSE_INFO, SOD.MESSAGE_HEADER_NAME_SPACE);
EntityXmlSerializer <ResponseHeaderInfo> se = new EntityXmlSerializer <ResponseHeaderInfo>();
ResponseHeaderInfo responseHeaderInfo = se.SingleDeSerializer(ctxt, string.Empty);
QueryBehaviorScope.ResponseInfo = responseHeaderInfo;
}
else
{
QueryBehaviorScope.ResponseInfo = null;
}
}
/// <summary>
/// Converts a macro to a package xml node
/// </summary>
/// <param name="macroId">The macro id.</param>
/// <param name="appendFile">if set to <c>true</c> [append file].</param>
/// <param name="packageDirectory">The package directory.</param>
/// <param name="doc">The doc.</param>
/// <returns></returns>
public static XmlNode Macro(int macroId, bool appendFile, string packageDirectory, XmlDocument doc)
{
var mcr = Current.Services.MacroService.GetById(macroId);
if (appendFile)
{
if (!string.IsNullOrEmpty(mcr.MacroSource))
{
AppendFileToManifest(mcr.MacroSource, packageDirectory, doc);
}
}
var serializer = new EntityXmlSerializer();
var xml = serializer.Serialize(mcr);
return(xml.GetXmlNode(doc));
}
private IEnumerable <XElement> GetSerializedContent(IEnumerable <IContent> content)
{
var serializer = new EntityXmlSerializer();
foreach (var c in content)
{
var xml = serializer.Serialize(
_contentService,
_dataTypeService,
_userService,
c);
//add a custom 'icon' attribute
xml.Add(new XAttribute("icon", c.ContentType.Icon));
yield return(xml);
}
}
private void deleteTemplateXml(string module, string name)
{
List <TemplateInfo> templateInfos = getTemplateInfos(module);
TemplateInfo isContainTemplateInfo = new TemplateInfo(name);
if (templateInfos.Contains(isContainTemplateInfo))
{
templateInfos.Remove(isContainTemplateInfo);
}
string fullFileName = getFullTemplateFileName(module);
EntityXmlSerializer <TemplateInfo> entityXmlSerializer = new EntityXmlSerializer <TemplateInfo>();
string xml = entityXmlSerializer.Serializer(templateInfos);
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(xml);
xmlDocument.Save(fullFileName);
}
public XPathNavigator CreateNodeNavigator(int id, bool preview)
{
var provider = Core.Security.MembershipProviderExtensions.GetMembersMembershipProvider();
if (provider.IsUmbracoMembershipProvider() == false)
{
throw new NotSupportedException("Cannot access this method unless the Umbraco membership provider is active");
}
var result = _memberService.GetById(id);
if (result == null)
{
return(null);
}
var s = EntityXmlSerializer.Serialize(_dataTypeService, _localizationService, result);
var n = s.GetXmlNode();
return(n.CreateNavigator());
}
private IEnumerable <XElement> GetSerializedMedia(IEnumerable <IMedia> media)
{
var serializer = new EntityXmlSerializer();
foreach (var m in media)
{
var xml = serializer.Serialize(
_mediaService,
_dataTypeService,
_userService,
m);
//add a custom 'icon' attribute
if (m.ContentType.Icon.IsNullOrWhiteSpace() == false)
{
xml.Add(new XAttribute("icon", m.ContentType.Icon));
}
yield return(xml);
}
}
/// <summary>
/// 获取当前查询的ResponseInfo
/// </summary>
/// <returns></returns>
public static ResponseHeaderInfo GetMessageHeaderResponseInfo()
{
string ctxt = string.Empty;
if (OperationContext.Current != null)
{
try
{
ctxt = GetMessageHeaderContext(SOD.QUERY_RESPONSE_INFO);
if (!string.IsNullOrEmpty(ctxt))
{
EntityXmlSerializer <ResponseHeaderInfo> ser = new EntityXmlSerializer <ResponseHeaderInfo>();
return(ser.SingleDeSerializer(ctxt, string.Empty));
}
}
catch (Exception ex)
{
MB.Util.TraceEx.Write("在获取当前查询的ResponseInfo 出错" + ex.Message, Util.APPMessageType.SysWarning);
}
}
return(ResponseHeaderInfo.DefaultResponseInfo);
}
/// <summary>
/// 由于动态列的情况下，某些列并不是从数据库取出来的，
/// 需要中间层开发人员自己定义哪些列一定要在SQL中而哪些列不能包括在SQL中
/// 该方法用于重新设定当前WCF上下文中InComingMessage中的消息头QueryBehavior的Columns中的值
/// </summary>
/// <returns></returns>
public static void SetQueryBehaviorColoums(string messageHeaderKey, string columns)
{
if (OperationContext.Current == null ||
OperationContext.Current.IncomingMessageVersion == MessageVersion.None ||
OperationContext.Current.IncomingMessageVersion.Envelope == EnvelopeVersion.None)
{
return;
}
string headerKey = SOD.QUERY_BEHAVIOR_MESSAGE_HEADER;
if (!string.IsNullOrEmpty(messageHeaderKey))
{
headerKey += "_" + messageHeaderKey;
}
QueryBehavior queryBehavior = GetQueryBehavior(messageHeaderKey);
if (queryBehavior != null)
{
queryBehavior.Columns = columns;
EntityXmlSerializer <QueryBehavior> se = new EntityXmlSerializer <QueryBehavior>();
string dstr = se.SingleSerializer(queryBehavior, string.Empty);
MessageHeader <string> mh = new MessageHeader <string>(dstr);
MessageHeader header = mh.GetUntypedHeader(headerKey, SOD.MESSAGE_HEADER_NAME_SPACE);
int re = OperationContext.Current.IncomingMessageHeaders.FindHeader(headerKey, SOD.MESSAGE_HEADER_NAME_SPACE);
if (re < 0)
{
OperationContext.Current.IncomingMessageHeaders.Add(header);
}
else
{
OperationContext.Current.IncomingMessageHeaders.RemoveAt(re);
OperationContext.Current.IncomingMessageHeaders.Add(header);
}
}
}
/// <summary>
/// 获取当前登录的用户信息。
/// </summary>
/// <returns></returns>
public static SysLoginUserInfo GetCurrentLoginUser()
{
string ctxt = string.Empty;
if (OperationContext.Current != null)
{
try
{
ctxt = GetMessageHeaderContext(SOD.CURRENT_USER_IDENTITY);
if (!string.IsNullOrEmpty(ctxt))
{
EntityXmlSerializer <SysLoginUserInfo> ser = new EntityXmlSerializer <SysLoginUserInfo>();
return(ser.SingleDeSerializer(ctxt, string.Empty));
}
}
catch (Exception ex)
{
MB.Util.TraceEx.Write("在获取当前登录用户信息时出错！" + ex.Message, Util.APPMessageType.SysWarning);
}
}
return(null);
}
private StringBuilder createCredential()
{
string baseAddress = "Http://" + txtServerIP.Text;
if (numPort.Value > 0 && numPort.Value != 80)
{
baseAddress += ":" + numPort.Value.ToString();
}
WcfCredentialInfo credential = new WcfCredentialInfo(baseAddress, txtUserName.Text, txtPassword.Text, true);
credential.EndpointFormatString = txtFormatString.Text;
credential.ReplaceRelativePathLastDot = chkReplaceLastDot.Checked;
if (cobHostType.Text == "IIS")
{
credential.HostType = WcfServiceHostType.IIS;
}
else
{
credential.HostType = WcfServiceHostType.WS;
}
if (!string.IsNullOrEmpty(txtDomain.Text))
{
credential.Domain = txtDomain.Text;
}
credential.AppendDetails = _CredentialDataHelper.CredentialToString();
StringBuilder s = new StringBuilder();
EntityXmlSerializer <WcfCredentialInfo> ser = new EntityXmlSerializer <WcfCredentialInfo>();
s.Append(ser.SingleSerializer(credential, string.Empty));
return(s);
}
private void Page_Load(object sender, System.EventArgs e)
{
int documentTypeId = Request.GetItemAs <int>("nodeID");
if (documentTypeId > 0)
{
var contentType = Services.ContentTypeService.GetContentType(documentTypeId);
if (contentType == null)
{
throw new NullReferenceException("No content type found with id " + documentTypeId);
}
Response.AddHeader("Content-Disposition", "attachment;filename=" + contentType.Alias + ".udt");
Response.ContentType = "application/octet-stream";
var serializer = new EntityXmlSerializer();
var xml = serializer.Serialize(
Services.DataTypeService,
Services.ContentTypeService,
contentType);
xml.Save(Response.OutputStream);
}
}
public object BeforeSendRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel)
{
QueryBehavior queryBehavior = QueryBehaviorScope.CurQueryBehavior;
if (queryBehavior != null)
{
EntityXmlSerializer <QueryBehavior> se = new EntityXmlSerializer <QueryBehavior>();
string dstr = se.SingleSerializer(queryBehavior, string.Empty);
MessageHeader <string> mh = new MessageHeader <string>(dstr);
string name = SOD.QUERY_BEHAVIOR_MESSAGE_HEADER;
if (!string.IsNullOrEmpty(QueryBehaviorScope.MessageHeaderKey))
{
name += "_" + QueryBehaviorScope.MessageHeaderKey;
}
MessageHeader header = mh.GetUntypedHeader(name, SOD.MESSAGE_HEADER_NAME_SPACE);
int ret = request.Headers.FindHeader(name, SOD.MESSAGE_HEADER_NAME_SPACE);
if (ret < 0)
{
request.Headers.Add(header);
}
}
return(null);
}
/// <summary>
/// 获取当前查询的行为信息
/// </summary>
/// <returns></returns>
public static QueryBehavior GetQueryBehavior()
{
string ctxt = string.Empty;
if (OperationContext.Current != null)
{
try
{
ctxt = GetMessageHeaderContext(SOD.QUERY_BEHAVIOR_MESSAGE_HEADER);
if (!string.IsNullOrEmpty(ctxt))
{
EntityXmlSerializer <QueryBehavior> ser = new EntityXmlSerializer <QueryBehavior>();
return(ser.SingleDeSerializer(ctxt, string.Empty));
}
}
catch (Exception ex)
{
MB.Util.TraceEx.Write("在获取当前用户的查询QueryBehavior 出错" + ex.Message, Util.APPMessageType.SysWarning);
}
}
//没有找到query behavior则返回默认的query behavior
//发现很多项目在使用过程中，需要直接查出大于2W条的记录，所以更新回原来不做限制的处理
return(null);
}
private IEnumerable <XElement> GetSerializedMembers(IEnumerable <IMember> members)
{
var serializer = new EntityXmlSerializer();
return(members.Select(member => serializer.Serialize(_dataTypeService, member)));
}
/// <summary>
/// A Helper methods to return the children for media whther it is based on examine or xml
/// </summary>
/// <param name="parentId"></param>
/// <param name="xpath"></param>
/// <returns></returns>
private IEnumerable <IPublishedContent> GetChildrenMedia(int parentId, XPathNavigator xpath = null)
{
// if there *is* a navigator, directly look it up
if (xpath != null)
{
return(ToIPublishedContent(parentId, xpath));
}
// otherwise, try examine first, then re-look it up
var searchProvider = GetSearchProviderSafe();
if (searchProvider != null)
{
try
{
//first check in Examine as this is WAY faster
var criteria = searchProvider.CreateQuery("media");
var filter = criteria.ParentId(parentId).Not().Field(UmbracoExamineIndex.IndexPathFieldName, "-1,-21,".MultipleCharacterWildcard())
.OrderBy(new SortableField("sortOrder", SortType.Int));
//the above filter will create a query like this, NOTE: That since the use of the wildcard, it automatically escapes it in Lucene.
//+(+parentId:3113 -__Path:-1,-21,*) +__IndexType:media
// sort with the Sort field (updated for 8.0)
var results = filter.Execute();
if (results.Any())
{
// var medias = results.Select(ConvertFromSearchResult);
var medias = results.Select(x =>
{
int nid;
if (int.TryParse(x["__NodeId"], out nid) == false && int.TryParse(x["NodeId"], out nid) == false)
{
throw new Exception("Failed to extract NodeId from search result.");
}
var cacheValues = GetCacheValues(nid, id => ConvertFromSearchResult(x));
return(CreateFromCacheValues(cacheValues));
});
return(medias);
}
//if there's no result then return null. Previously we defaulted back to library.GetMedia below
//but this will always get called for when we are getting descendents since many items won't have
//children and then we are hitting the database again!
//So instead we're going to rely on Examine to have the correct results like it should.
return(Enumerable.Empty <IPublishedContent>());
}
catch (FileNotFoundException)
{
//Currently examine is throwing FileNotFound exceptions when we have a loadbalanced filestore and a node is published in umbraco
//See this thread: http://examine.cdodeplex.com/discussions/264341
//Catch the exception here for the time being, and just fallback to GetMedia
}
}
// falling back to get media
// was library.GetMedia which had its own cache, but MediaService *also* caches
// so, library.GetMedia is gone and now we directly work with MediaService
// (code below copied from what library was doing)
var media = Current.Services.MediaService.GetById(parentId);
if (media == null)
{
return(Enumerable.Empty <IPublishedContent>());
}
var serialized = EntityXmlSerializer.Serialize(
Current.Services.MediaService,
Current.Services.DataTypeService,
Current.Services.UserService,
Current.Services.LocalizationService,
Current.UrlSegmentProviders,
media,
true);
var mediaIterator = serialized.CreateNavigator().Select("/");
return(mediaIterator.Current == null
? Enumerable.Empty <IPublishedContent>()
: ToIPublishedContent(parentId, mediaIterator.Current));
}
public void Publish()
{
var package = this;
var pack = package.Data;
var outInt = 0;
//Path checking...
var localPath = IOHelper.MapPath(SystemDirectories.Media + "/" + pack.Folder);
if (Directory.Exists(localPath) == false)
{
Directory.CreateDirectory(localPath);
}
//Init package file...
CreatePackageManifest();
//Info section..
AppendElement(PackagerUtility.PackageInfo(pack, _packageManifest));
//Documents and tags...
var contentNodeId = 0;
if (string.IsNullOrEmpty(pack.ContentNodeId) == false && int.TryParse(pack.ContentNodeId, out contentNodeId))
{
if (contentNodeId > 0)
{
//Create the Documents/DocumentSet node
XmlNode documents = _packageManifest.CreateElement("Documents");
XmlNode documentSet = _packageManifest.CreateElement("DocumentSet");
XmlAttribute importMode = _packageManifest.CreateAttribute("importMode", "");
importMode.Value = "root";
documentSet.Attributes.Append(importMode);
documents.AppendChild(documentSet);
//load content from umbraco.
//var umbDocument = new Document(contentNodeId);
//var x = umbDocument.ToXml(_packageManifest, pack.ContentLoadChildNodes);
var udoc = Current.Services.ContentService.GetById(contentNodeId);
var xe = pack.ContentLoadChildNodes ? udoc.ToDeepXml(Current.Services.PackagingService) : udoc.ToXml(Current.Services.PackagingService);
var x = xe.GetXmlNode(_packageManifest);
documentSet.AppendChild(x);
AppendElement(documents);
////Create the TagProperties node - this is used to store a definition for all
//// document properties that are tags, this ensures that we can re-import tags properly
//XmlNode tagProps = _packageManifest.CreateElement("TagProperties");
////before we try to populate this, we'll do a quick lookup to see if any of the documents
//// being exported contain published tags.
//var allExportedIds = documents.SelectNodes("//@id").Cast<XmlNode>()
// .Select(x => x.Value.TryConvertTo<int>())
// .Where(x => x.Success)
// .Select(x => x.Result)
// .ToArray();
//var allContentTags = new List<ITag>();
//foreach (var exportedId in allExportedIds)
//{
// allContentTags.AddRange(
// Current.Services.TagService.GetTagsForEntity(exportedId));
//}
////This is pretty round-about but it works. Essentially we need to get the properties that are tagged
//// but to do that we need to lookup by a tag (string)
//var allTaggedEntities = new List<TaggedEntity>();
//foreach (var group in allContentTags.Select(x => x.Group).Distinct())
//{
// allTaggedEntities.AddRange(
// Current.Services.TagService.GetTaggedContentByTagGroup(group));
//}
////Now, we have all property Ids/Aliases and their referenced document Ids and tags
//var allExportedTaggedEntities = allTaggedEntities.Where(x => allExportedIds.Contains(x.EntityId))
// .DistinctBy(x => x.EntityId)
// .OrderBy(x => x.EntityId);
//foreach (var taggedEntity in allExportedTaggedEntities)
//{
// foreach (var taggedProperty in taggedEntity.TaggedProperties.Where(x => x.Tags.Any()))
// {
// XmlNode tagProp = _packageManifest.CreateElement("TagProperty");
// var docId = _packageManifest.CreateAttribute("docId", "");
// docId.Value = taggedEntity.EntityId.ToString(CultureInfo.InvariantCulture);
// tagProp.Attributes.Append(docId);
// var propertyAlias = _packageManifest.CreateAttribute("propertyAlias", "");
// propertyAlias.Value = taggedProperty.PropertyTypeAlias;
// tagProp.Attributes.Append(propertyAlias);
// var group = _packageManifest.CreateAttribute("group", "");
// group.Value = taggedProperty.Tags.First().Group;
// tagProp.Attributes.Append(group);
// tagProp.AppendChild(_packageManifest.CreateCDataSection(
// JsonConvert.SerializeObject(taggedProperty.Tags.Select(x => x.Text).ToArray())));
// tagProps.AppendChild(tagProp);
// }
//}
//AppendElement(tagProps);
}
}
//Document types..
var dtl = new List <IContentType>();
var docTypes = _packageManifest.CreateElement("DocumentTypes");
foreach (var dtId in pack.Documenttypes)
{
if (int.TryParse(dtId, out outInt))
{
var docT = Current.Services.ContentTypeService.Get(outInt);
//DocumentType docT = new DocumentType(outInt);
AddDocumentType(docT, ref dtl);
}
}
var exporter = new EntityXmlSerializer();
foreach (var d in dtl)
{
var xml = exporter.Serialize(Current.Services.DataTypeService, Current.Services.ContentTypeService, d);
var xNode = xml.GetXmlNode();
var n = (XmlElement)_packageManifest.ImportNode(xNode, true);
docTypes.AppendChild(n);
}
AppendElement(docTypes);
//Templates
var templates = _packageManifest.CreateElement("Templates");
foreach (var templateId in pack.Templates)
{
if (int.TryParse(templateId, out outInt))
{
var t = Current.Services.FileService.GetTemplate(outInt);
var serializer = new EntityXmlSerializer();
var serialized = serializer.Serialize(t);
var n = serialized.GetXmlNode(_packageManifest);
templates.AppendChild(n);
}
}
AppendElement(templates);
//Stylesheets
var stylesheets = _packageManifest.CreateElement("Stylesheets");
foreach (var stylesheetName in pack.Stylesheets)
{
if (stylesheetName.IsNullOrWhiteSpace())
{
continue;
}
var stylesheetXmlNode = PackagerUtility.Stylesheet(stylesheetName, true, _packageManifest);
if (stylesheetXmlNode != null)
{
stylesheets.AppendChild(stylesheetXmlNode);
}
}
AppendElement(stylesheets);
//Macros
var macros = _packageManifest.CreateElement("Macros");
foreach (var macroId in pack.Macros)
{
if (int.TryParse(macroId, out outInt))
{
macros.AppendChild(PackagerUtility.Macro(int.Parse(macroId), true, localPath, _packageManifest));
}
}
AppendElement(macros);
//Dictionary Items
var dictionaryItems = _packageManifest.CreateElement("DictionaryItems");
foreach (var dictionaryId in pack.DictionaryItems)
{
if (int.TryParse(dictionaryId, out outInt))
{
var di = Current.Services.LocalizationService.GetDictionaryItemById(outInt);
var entitySerializer = new EntityXmlSerializer();
var xmlNode = entitySerializer.Serialize(di).GetXmlNode(_packageManifest);
dictionaryItems.AppendChild(xmlNode);
}
}
AppendElement(dictionaryItems);
//Languages
var languages = _packageManifest.CreateElement("Languages");
foreach (var langId in pack.Languages)
{
if (int.TryParse(langId, out outInt))
{
var lang = Current.Services.LocalizationService.GetLanguageById(outInt);
var serializer = new EntityXmlSerializer();
var xml = serializer.Serialize(lang);
var n = xml.GetXmlNode(_packageManifest);
languages.AppendChild(n);
}
}
AppendElement(languages);
//TODO: Fix this! ... actually once we use the new packager we don't need to
////Datatypes
//var dataTypes = _packageManifest.CreateElement("DataTypes");
//foreach (var dtId in pack.DataTypes)
//{
// if (int.TryParse(dtId, out outInt))
// {
// datatype.DataTypeDefinition dtd = new datatype.DataTypeDefinition(outInt);
// dataTypes.AppendChild(dtd.ToXml(_packageManifest));
// }
//}
//AppendElement(dataTypes);
//Files
foreach (var fileName in pack.Files)
{
PackagerUtility.AppendFileToManifest(fileName, localPath, _packageManifest);
}
//Load control on install...
if (string.IsNullOrEmpty(pack.LoadControl) == false)
{
XmlNode control = _packageManifest.CreateElement("control");
control.InnerText = pack.LoadControl;
PackagerUtility.AppendFileToManifest(pack.LoadControl, localPath, _packageManifest);
AppendElement(control);
}
//Actions
if (string.IsNullOrEmpty(pack.Actions) == false)
{
try
{
var xdActions = new XmlDocument();
xdActions.LoadXml("<Actions>" + pack.Actions + "</Actions>");
var actions = xdActions.DocumentElement.SelectSingleNode(".");
if (actions != null)
{
actions = _packageManifest.ImportNode(actions, true).Clone();
AppendElement(actions);
}
}
catch { }
}
var manifestFileName = localPath + "/package.xml";
if (File.Exists(manifestFileName))
{
File.Delete(manifestFileName);
}
_packageManifest.Save(manifestFileName);
_packageManifest = null;
//string packPath = Settings.PackagerRoot.Replace(System.IO.Path.DirectorySeparatorChar.ToString(), "/") + "/" + pack.Name.Replace(' ', '_') + "_" + pack.Version.Replace(' ', '_') + "." + Settings.PackageFileExtension;
// check if there's a packages directory below media
var packagesDirectory = SystemDirectories.Media + "/created-packages";
if (Directory.Exists(IOHelper.MapPath(packagesDirectory)) == false)
{
Directory.CreateDirectory(IOHelper.MapPath(packagesDirectory));
}
var packPath = packagesDirectory + "/" + (pack.Name + "_" + pack.Version).Replace(' ', '_') + "." + Settings.PackageFileExtension;
PackagerUtility.ZipPackage(localPath, IOHelper.MapPath(packPath));
pack.PackagePath = packPath;
if (pack.PackageGuid.Trim() == "")
{
pack.PackageGuid = Guid.NewGuid().ToString();
}
package.Save();
//Clean up..
File.Delete(localPath + "/package.xml");
Directory.Delete(localPath, true);
}
/// <summary>
/// Creates the xml representation for the <see cref="Property"/> object
/// </summary>
/// <param name="property"><see cref="Property"/> to generate xml for</param>
/// <returns>Xml of the property and its value</returns>
public static XElement ToXml(this Property property)
{
var xmlSerializer = new EntityXmlSerializer();
return(xmlSerializer.Serialize(ApplicationContext.Current.Services.DataTypeService, property));
}
