private PreassignedWorkflow GetPreassignedContentWorkflow(ILanguageVariant languageVariant)
{
using (new LanguageContext(languageVariant))
{
return(LoadPreassignedContentWorkflow());
}
}
/// <summary>
/// Set the text content of a text element. This method exists, because it needs a different RQL element layout than all other queries.
/// </summary>
/// <param name="projectGuid"> Guid of the project containing the element </param>
/// <param name="languageVariant"> Language variant for setting the text in </param>
/// <param name="textElementGuid"> Guid of the text element </param>
/// <param name="typeString"> texttype value </param>
/// <param name="content"> new value </param>
/// <returns> Guid of the text element </returns>
public Guid SetTextContent(Guid projectGuid, ILanguageVariant languageVariant, Guid textElementGuid,
string typeString, string content)
{
const string SAVE_TEXT_CONTENT =
@"<IODATA loginguid=""{0}"" format=""1"" sessionkey=""{1}""><PROJECT><TEXT action=""save"" guid=""{2}"" texttype=""{3}"" >{4}</TEXT></PROJECT></IODATA>";
SelectProject(projectGuid);
languageVariant.Select();
string rqlResult =
SendRQLToServer(string.Format(SAVE_TEXT_CONTENT, _loginGuidStr, _sessionKeyStr,
textElementGuid == Guid.Empty ? "" : textElementGuid.ToRQLString(),
typeString, HttpUtility.HtmlEncode(content)));
//in version 11.2 the server returns <guid>\r\n, but we are only interested in the guid -> Trim()
string resultGuidStr = XElement.Load(new StringReader(rqlResult)).Value.Trim();
//result guid is empty, if the value was set to the same value it had before
if (string.IsNullOrEmpty(resultGuidStr))
{
return(textElementGuid);
}
Guid newGuid;
if (!Guid.TryParse(resultGuidStr, out newGuid) ||
(textElementGuid != Guid.Empty && textElementGuid != newGuid))
{
throw new SmartAPIException(ServerLogin, "Could not set text for: {0}".RQLFormat(textElementGuid));
}
return(newGuid);
}
/// <summary>
/// Create an element out of its XML representation (uses the attribute "elttype") to determine the element type and create the appropriate object.
/// </summary>
/// <param name="project"> Project containing the element </param>
/// <param name="elementGuid"> Guid of the element </param>
/// <param name="languageVariant">The language variant of the page element</param>
/// <exception cref="ArgumentException">if the "elttype" attribute of the XML node contains an unknown value</exception>
public static IPageElement CreateElement(IProject project, Guid elementGuid, ILanguageVariant languageVariant)
{
using (new LanguageContext(languageVariant))
{
XmlDocument xmlDoc = project.ExecuteRQL(string.Format(RETRIEVE_PAGE_ELEMENT, elementGuid.ToRQLString()));
var xmlNode = (XmlElement)xmlDoc.GetElementsByTagName("ELT")[0];
return(CreateElement(project, xmlNode));
}
}
public void Remove(IProjectVariant projectVariant, ILanguageVariant languageVariant)
{
var entry =
this.FirstOrDefault(x => x.ProjectVariant.Guid == projectVariant.Guid && x.LanguageVariant.Guid == languageVariant.Guid);
if (entry != null)
{
entry.Delete();
}
}
/// <summary>
/// Get the text content of a text element. This method exists, because it needs a different RQL element layout than all other queries.
/// </summary>
/// <param name="projectGuid"> Guid of the project containing the element </param>
/// <param name="lang"> Language variant to get the text from </param>
/// <param name="elementGuid"> Guid of the text element </param>
/// <param name="typeString"> texttype value </param>
/// <returns> text content of the element </returns>
public string GetTextContent(Guid projectGuid, ILanguageVariant lang, Guid elementGuid, string typeString)
{
const string LOAD_TEXT_CONTENT =
@"<IODATA loginguid=""{0}"" format=""1"" sessionkey=""{1}""><PROJECT><TEXT action=""load"" guid=""{2}"" texttype=""{3}""/></PROJECT></IODATA>";
SelectProject(projectGuid);
lang.Select();
return
(SendRQLToServer(string.Format(LOAD_TEXT_CONTENT, _loginGuidStr, _sessionKeyStr,
elementGuid.ToRQLString(), typeString)));
}
public void Add(IProjectVariant projectVariant, ILanguageVariant languageVariant)
{
const string ADD =
@"<PROJECT><EXPORTSETTING action=""save"" guid=""{0}"" projectvariantguid=""{1}"" languagevariantguid=""{2}"" copyguid="""" /></PROJECT>";
var doc = Project.ExecuteRQL(ADD.RQLFormat(PublicationPackage, projectVariant, languageVariant.Guid.ToRQLString()));
//TODO check answer?
InvalidateCache();
}
public string ConvertFrom(IProjectObject parent, XmlElement element, RedDotAttribute attribute)
{
ILanguageVariant lang = parent.Project.LanguageVariants.Current;
if (!element.IsAttributeSet(parent, attribute.ElementName))
{
return(string.Empty);
}
Guid guid = element.GetGuid(attribute.ElementName);
return(parent.Project.GetTextContent(guid, lang, ((int)Type).ToString(CultureInfo.InvariantCulture)));
}
public bool TryGetByGuid(Guid pageGuid, ILanguageVariant languageVariant, out IPage page)
{
try
{
page = GetByGuid(pageGuid, languageVariant);
return(true);
}
catch (SmartAPIException)
{
page = null;
return(false);
}
}
private IndexedRDList <int, IPage> GetPagesForLanguageVariant(string language)
{
ILanguageVariant languageVariant = _project.LanguageVariants[language];
using (new LanguageContext(languageVariant))
{
return(_pagesByLanguage.GetOrAdd(
language,
() => new IndexedRDList <int, IPage>(
() =>
{
using (new LanguageContext(languageVariant))
{
return GetPages();
}
},
x => x.Id,
Caching.Enabled)));
}
}
public IPreassignedWorkflow GetContentWorkflowFor(ILanguageVariant languageVariant)
{
IPreassignedWorkflow workflow;
if (!_preassignedContentWorkflows.TryGetValue(languageVariant, out workflow))
{
workflow = GetPreassignedContentWorkflow(languageVariant);
if (workflow == null)
{
_preassignedContentWorkflows[languageVariant] = null;
return(null);
}
foreach (var curLanguage in workflow.LanguageVariantsPreassignedTo)
{
_preassignedContentWorkflows[curLanguage] = workflow;
}
}
return(workflow);
}
/// <summary>
/// Copy selected elements from this content class to another target content class.
/// </summary>
/// <param name="targetCC"> Target content class to copy the elements to </param>
/// <param name="elementNames"> Names of the elements to copy </param>
public void CopyElementsToContentClass(IContentClass targetCC, params string[] elementNames)
{
if (elementNames == null || elementNames.Length == 0)
{
return;
}
var createdElements = new Dictionary <string, IContentClassElement>();
using (new LanguageContext(Project))
{
var assign = new AttributeAssignment();
foreach (var languageVariant in Project.LanguageVariants)
{
ILanguageVariant targetLanguageVariant =
targetCC.Project.LanguageVariants[languageVariant.Abbreviation];
foreach (var curElementName in elementNames)
{
IContentClassElement curTargetContentClassElement;
languageVariant.Select();
var curSourceContentClassElement = Elements[curElementName];
if (createdElements.TryGetValue(curElementName, out curTargetContentClassElement))
{
targetLanguageVariant.Select();
assign.AssignAllRedDotAttributesForLanguage(curSourceContentClassElement,
curTargetContentClassElement,
targetLanguageVariant.Abbreviation);
curTargetContentClassElement.CommitInCurrentLanguage();
}
else
{
targetLanguageVariant.Select();
curTargetContentClassElement = curSourceContentClassElement.CopyToContentClass(targetCC);
createdElements.Add(curElementName, curTargetContentClassElement);
}
}
}
}
}
protected PageElement(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid)
{
LanguageVariant = languageVariant;
}
private PreassignedWorkflow GetPreassignedContentWorkflow(ILanguageVariant languageVariant)
{
using (new LanguageContext(languageVariant))
{
return LoadPreassignedContentWorkflow();
}
}
public ListEntry(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
IIndexedRDList <string, IPage> ILanguageDependentReadValue <IIndexedRDList <string, IPage> > .this[ILanguageVariant languageVariant]
{
get
{
return(_startPagesByLanguageVariant.GetOrAdd(languageVariant, () => GetStartPages(languageVariant)));//startPageGuids == null ? new IndexedRDList<string, IPage>(()=>new List<IPage>(), x=>x.Headline, Caching.Enabled) : _startPagesByLanguageVariant.GetOrAdd(languageVariant, ()=>GetStartPages(languageVariant));
}
}
private List <IPage> Refreshed(ILanguageVariant languageVariant)
{
Refresh();
return(_startPageGuids.Select(x => _project.Pages.GetByGuid(x, languageVariant)).ToList());
}
protected StandardField(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
protected AbstractMultiLinkElement(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
Connections = new MultiLinkConnections(this, Caching.Enabled);
}
public IPreassignedWorkflow GetContentWorkflowFor(ILanguageVariant languageVariant)
{
return _workflowAssignments.GetContentWorkflowFor(languageVariant);
}
public ListEntry(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
internal AnchorAsImage(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
public Background(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
public Container(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
public IPageElement CreateElement(IProject project, Guid elementGuid, ILanguageVariant languageVariant)
{
return PageElement.CreateElement(project, elementGuid, languageVariant);
}
/// <summary>
/// Create an element out of its XML representation (uses the attribute "elttype") to determine the element type and create the appropriate object.
/// </summary>
/// <param name="project"> Project containing the element </param>
/// <param name="elementGuid"> Guid of the element </param>
/// <param name="languageVariant">The language variant of the page element</param>
/// <exception cref="ArgumentException">if the "elttype" attribute of the XML node contains an unknown value</exception>
public static IPageElement CreateElement(IProject project, Guid elementGuid, ILanguageVariant languageVariant)
{
using (new LanguageContext(languageVariant))
{
XmlDocument xmlDoc = project.ExecuteRQL(string.Format(RETRIEVE_PAGE_ELEMENT, elementGuid.ToRQLString()));
var xmlNode = (XmlElement) xmlDoc.GetElementsByTagName("ELT")[0];
return CreateElement(project, xmlNode);
}
}
public Media(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
protected AbstractMultiLinkElement(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
Connections = new MultiLinkConnections(this, Caching.Enabled);
}
protected Text(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
public TextAscii(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
public IPage GetByGuid(Guid pageGuid, ILanguageVariant languageVariant)
{
return(new Page(_project, pageGuid, languageVariant).Refreshed());
}
public SiteMap(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
internal Page(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid)
{
_lang = languageVariant;
InitProperties();
}
public IPreassignedWorkflow GetContentWorkflowFor(ILanguageVariant languageVariant)
{
return(_workflowAssignments.GetContentWorkflowFor(languageVariant));
}
private IIndexedRDList <string, IPage> GetStartPages(ILanguageVariant languageVariant)
{
return(new IndexedRDList <string, IPage>(() => Refreshed(languageVariant), x => x.Headline, Caching.Enabled));
}
protected AbstractValueElement(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
public IPreassignedWorkflow GetContentWorkflowFor(ILanguageVariant languageVariant)
{
IPreassignedWorkflow workflow;
if (!_preassignedContentWorkflows.TryGetValue(languageVariant, out workflow))
{
workflow = GetPreassignedContentWorkflow(languageVariant);
if (workflow == null)
{
_preassignedContentWorkflows[languageVariant] = null;
return null;
}
foreach (var curLanguage in workflow.LanguageVariantsPreassignedTo)
{
_preassignedContentWorkflows[curLanguage] = workflow;
}
}
return workflow;
}
/// <summary>
/// Get the text content of a text element. This method exists, because it needs a different RQL element layout than all other queries.
/// </summary>
/// <param name="projectGuid"> Guid of the project containing the element </param>
/// <param name="lang"> Language variant to get the text from </param>
/// <param name="elementGuid"> Guid of the text element </param>
/// <param name="typeString"> texttype value </param>
/// <returns> text content of the element </returns>
public string GetTextContent(Guid projectGuid, ILanguageVariant lang, Guid elementGuid, string typeString)
{
const string LOAD_TEXT_CONTENT =
@"<IODATA loginguid=""{0}"" format=""1"" sessionkey=""{1}""><PROJECT><TEXT action=""load"" guid=""{2}"" texttype=""{3}""/></PROJECT></IODATA>";
SelectProject(projectGuid);
lang.Select();
return
SendRQLToServer(string.Format(LOAD_TEXT_CONTENT, _loginGuidStr, _sessionKeyStr,
elementGuid.ToRQLString(), typeString));
}
protected AbstractKeywordAssignableMultiLinkElement(IProject project, Guid guid,
ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
Init();
}
protected AbstractLinkElement(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
Connections = new LinkConnections(this, Caching.Enabled);
ReferencedFrom = new RDList<ILinkElement>(GetReferencingLinks, Caching.Enabled);
}
public Area(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
public ProjectContent(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
public HitList(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
/// <summary>
/// Selects a language variant and restores the previously selected language variant on dispose.
/// </summary>
/// <param name="lang"> </param>
public LanguageContext(ILanguageVariant lang)
{
_origLang = lang.Project.LanguageVariants.Current;
lang.Select();
}
public T this[ILanguageVariant languageVariant]
{
get { return(this[languageVariant.Abbreviation]); }
}
/// <summary>
/// Just restores the language context on dispose. Does not set a specific language variant on construction.
/// </summary>
public LanguageContext(IProject project)
{
_origLang = project.LanguageVariants.Current;
}
public AnchorAsText(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
/// <see cref="CMS.Session.SetTextContent" />
public Guid SetTextContent(Guid textElementGuid, ILanguageVariant languageVariant, string typeString, string content)
{
return(Session.SetTextContent(Guid, languageVariant, textElementGuid, typeString, content));
}
/// <summary>
/// Selects a language variant and restores the previously selected language variant on dispose.
/// </summary>
/// <param name="lang"> </param>
public LanguageContext(ILanguageVariant lang)
{
_origLang = lang.Project.LanguageVariants.Current;
lang.Select();
}
/// <summary>
/// Just restores the language context on dispose. Does not set a specific language variant on construction.
/// </summary>
public LanguageContext(IProject project)
{
_origLang = project.LanguageVariants.Current;
}
public StandardFieldDate(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
public HitList(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
/// <summary>
/// Set the text content of a text element. This method exists, because it needs a different RQL element layout than all other queries.
/// </summary>
/// <param name="projectGuid"> Guid of the project containing the element </param>
/// <param name="languageVariant"> Language variant for setting the text in </param>
/// <param name="textElementGuid"> Guid of the text element </param>
/// <param name="typeString"> texttype value </param>
/// <param name="content"> new value </param>
/// <returns> Guid of the text element </returns>
public Guid SetTextContent(Guid projectGuid, ILanguageVariant languageVariant, Guid textElementGuid,
string typeString, string content)
{
const string SAVE_TEXT_CONTENT =
@"<IODATA loginguid=""{0}"" format=""1"" sessionkey=""{1}""><PROJECT><TEXT action=""save"" guid=""{2}"" texttype=""{3}"" >{4}</TEXT></PROJECT></IODATA>";
SelectProject(projectGuid);
languageVariant.Select();
string rqlResult =
SendRQLToServer(string.Format(SAVE_TEXT_CONTENT, _loginGuidStr, _sessionKeyStr,
textElementGuid == Guid.Empty ? "" : textElementGuid.ToRQLString(),
typeString, HttpUtility.HtmlEncode(content)));
//in version 11.2 the server returns <guid>\r\n, but we are only interested in the guid -> Trim()
string resultGuidStr = XElement.Load(new StringReader(rqlResult)).Value.Trim();
//result guid is empty, if the value was set to the same value it had before
if (string.IsNullOrEmpty(resultGuidStr))
{
return textElementGuid;
}
Guid newGuid;
if (!Guid.TryParse(resultGuidStr, out newGuid) ||
(textElementGuid != Guid.Empty && textElementGuid != newGuid))
{
throw new SmartAPIException(ServerLogin, "Could not set text for: {0}".RQLFormat(textElementGuid));
}
return newGuid;
}
public SiteMap(IProject project, Guid guid, ILanguageVariant languageVariant)
: base(project, guid, languageVariant)
{
}
