public override void OnRegister(DynamicModuleManager mgr)
{
}
private void RepublishDynamicContent(string provider, Type dynamicContentType)
{
var dynamicContentManager = DynamicModuleManager.GetManager(provider);
dynamicContentManager.Provider.SuppressSecurityChecks = false;
var dynamicContentItems = dynamicContentManager.GetDataItems(dynamicContentType).Where(n => n.Visible && n.Status == ContentLifecycleStatus.Live).ToList();
var count = 0;
foreach (var dynamicContentItem in dynamicContentItems)
{
var master = dynamicContentManager.Lifecycle.GetMaster(dynamicContentItem);
var temp = dynamicContentManager.Lifecycle.CheckOut(master) as IDynamicFieldsContainer;
temp.SetValue("Title", temp.GetValue("Title").ToString().Trim());
master = dynamicContentManager.Lifecycle.CheckIn(temp as ILifecycleDataItem);
dynamicContentManager.Lifecycle.Publish(master);
count++;
if (count % 200 == 0)
{
dynamicContentManager.SaveChanges();
}
}
dynamicContentManager.SaveChanges();
dynamicContentManager.Provider.SuppressSecurityChecks = true;
}
private void CreateItems()
{
var child1Type = TypeResolutionService.ResolveType(DynamicWidgetsHierarchicalContentTests.Child1TypeName);
var rootContentType = TypeResolutionService.ResolveType(DynamicWidgetsHierarchicalContentTests.RootContentTypeName);
var dynamicModuleManager = DynamicModuleManager.GetManager();
var child1 = dynamicModuleManager.CreateDataItem(child1Type);
child1.SetValue("Title", "Child1 title");
child1.UrlName = "Child1-title";
var child2 = dynamicModuleManager.CreateDataItem(child1Type);
child2.SetValue("Title", "Child2 title");
child2.UrlName = "Child2-title";
var rootContentItem = dynamicModuleManager.CreateDataItem(rootContentType);
rootContentItem.SetValue("Title", "Some Title");
rootContentItem.UrlName = "SomeUrlName";
rootContentItem.AddChildItem(child1);
rootContentItem.AddChildItem(child2);
dynamicModuleManager.SaveChanges();
}
/// <summary>
/// Gets the document URL per issue.
/// </summary>
/// <returns></returns>
public static string GetDocumentUrlFromContext()
{
var query = HttpContext.Current.Request.Url.Query;
var queryIdValue = HttpUtility.ParseQueryString(query).Get("issue");
if (!string.IsNullOrEmpty(queryIdValue))
{
var issueId = Guid.Parse(queryIdValue);
var dynamicManager = DynamicModuleManager.GetManager();
var issue = dynamicManager.GetDataItem(IssueViewModel.IssueType, issueId);
if (issue != null)
{
var document = issue.GetRelatedItems <Document>("IssueDocument").FirstOrDefault();
if (document != null)
{
return(document.MediaUrl);
}
}
}
return(string.Empty);
}
private static List <DynamicContent> GetQueryableContent(string type)
{
try
{
var dynamicModuleManager = DynamicModuleManager.GetManager();
var objectType = TypeResolutionService.ResolveType(type);
// Fetch a collection of "live" and "visible" content items.
var content = dynamicModuleManager.GetDataItems(objectType)
.Where(i => i.Status == ContentLifecycleStatus.Live && i.Visible);
var res = new List <DynamicContent>();
foreach (var status in content)
{
if (status.GetUIStatus(CultureInfo.CurrentCulture).Equals(ContentUIStatus.Published))
{
res.Add(status);
}
}
return(res);
}
catch (Exception ex)
{
return(null);
}
}
/// <summary>
/// Creates a new country item.
/// </summary>
/// <param name="title">The title of the country.</param>
public Guid CreateCountry(string title)
{
var providerName = string.Empty;
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
providerName = "dynamicContentProvider";
}
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
Type countryType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Booking.Country");
DynamicContent countryItem = dynamicModuleManager.CreateDataItem(countryType);
countryItem.SetValue("Title", title);
countryItem.SetString("UrlName", Regex.Replace(title.ToLower(), urlNameCharsToReplace, urlNameReplaceString));
countryItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
countryItem.SetValue("PublicationDate", DateTime.Now);
countryItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Published");
dynamicModuleManager.Lifecycle.Publish(countryItem);
dynamicModuleManager.SaveChanges();
return(countryItem.Id);
}
/// <summary>
/// Creates a new hotel item.
/// </summary>
/// <param name="parentId">The id of the city.</param>
/// <param name="title">The title of the hotel.</param>
public void CreateHotel(Guid parentId, string title)
{
var providerName = string.Empty;
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
providerName = "dynamicContentProvider";
}
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
Type hotelType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Booking.Hotel");
DynamicContent hotelItem = dynamicModuleManager.CreateDataItem(hotelType);
hotelItem.SetValue("Title", title);
hotelItem.SetString("UrlName", Regex.Replace(title.ToLower(), urlNameCharsToReplace, urlNameReplaceString));
hotelItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
hotelItem.SetValue("PublicationDate", DateTime.Now);
hotelItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Published");
Type cityType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Booking.City");
DynamicContent parent = dynamicModuleManager.GetDataItems(cityType)
.First(i => i.Id == parentId && i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master);
hotelItem.SetParent(parent.Id, cityType.FullName);
dynamicModuleManager.Lifecycle.Publish(hotelItem);
dynamicModuleManager.SaveChanges();
}
/// <summary>
/// A DynamicContent extension method that gets the parent of this item.
/// Since Sitefinity broke SystemParentItem.
/// </summary>
/// <param name="dataItem">The data item.</param>
/// <returns>
/// The parent.
/// </returns>
public static DynamicContent GetParent(this DynamicContent dataItem)
{
return(dataItem.SystemParentId != Guid.Empty && !string.IsNullOrEmpty(dataItem.SystemParentType)
? DynamicModuleManager.GetManager().GetDataItem(
TypeResolutionService.ResolveType(dataItem.SystemParentType), dataItem.SystemParentId)
: null);
}
public void CreateFieldWithTitle(string title, string dynamicurl)
{
// Set the provider name for the DynamicModuleManager here. All available providers are listed in
// Administration -> Settings -> Advanced -> DynamicModules -> Providers
var providerName = string.Empty;
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
providerName = "dynamicContentProvider";
}
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
Type allTypes = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.AllTypesModule.Alltypes");
Telerik.Sitefinity.DynamicModules.Model.DynamicContent allTypesItem = dynamicModuleManager.CreateDataItem(allTypes);
// This is how values for the properties are set
allTypesItem.SetValue("Title", title);
Address address = new Address();
allTypesItem.SetValue("Address", address);
allTypesItem.SetString("UrlName", dynamicurl);
allTypesItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
allTypesItem.SetValue("PublicationDate", DateTime.Now);
allTypesItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Published");
dynamicModuleManager.Lifecycle.Publish(allTypesItem);
// You need to call SaveChanges() in order for the items to be actually persisted to data store
dynamicModuleManager.SaveChanges();
}
/// <summary>
/// Gets the name of the default provider for the particular manager.
/// </summary>
/// <param name="helper">The helper.</param>
/// <param name="manager">The manager.</param>
/// <param name="dynamicModuleName">Name of the dynamic module.</param>
/// <returns></returns>
public static string DefaultProviderName(this HtmlHelper helper, IManager manager, string dynamicModuleName = "")
{
var defaultProviderName = String.Empty;
if (manager is IProviderResolver)
{
if (manager is DynamicModuleManager)
{
if (!dynamicModuleName.IsNullOrEmpty())
{
defaultProviderName = DynamicModuleManager.GetDefaultProviderName(dynamicModuleName);
}
}
else
{
defaultProviderName = ((IProviderResolver)manager).GetDefaultContextProvider().Name;
}
}
else if (manager != null)
{
defaultProviderName = manager.Provider.Name;
}
return(defaultProviderName);
}
/// <summary>
/// Removes relation between DynamicModel item and relatedItem by field name
/// </summary>
/// <param name="item">Current Dynamic Content Object</param>
/// <param name="relatedItem">Related Dynamic Content Object</param>
/// <param name="fieldName">Name of the string field</param>
public static void DeleteRelation(this DynamicModel item, DynamicModel relatedItem, string fieldName)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
else if (relatedItem == null)
{
throw new ArgumentException("relatedItem");
}
if (fieldName != null)
{
var sfContent = item.ToSitefinityModel();
var sfRelatedContent = relatedItem.ToSitefinityModel(false);
if (sfContent.DoesFieldExist(fieldName))
{
DynamicModuleManager manager = DynamicModuleManager.GetManager();
sfContent.DeleteRelation(sfRelatedContent, fieldName);
manager.Lifecycle.Publish(sfContent);
manager.SaveChanges();
}
}
}
public DynamicContent GetTorrent(DynamicModuleManager dynamicModuleManager, Type torrentType, string urlName)
{
var torrent = this.RetrieveCollectionOfTorrents(dynamicModuleManager, torrentType)
.SingleOrDefault(t => t.UrlName == urlName);
return(torrent);
}
private void GetIndividualClassifications(DynamicModuleManager manager, Type dynamicType, FlatTaxon taxon, string relatedPropertyName)
{
IOrganizableProvider contentProvider = manager.Provider as IOrganizableProvider;
int?totalCount = -1;
var jobProfileIds = contentProvider.GetItemsByTaxon(taxon.Id, false, relatedPropertyName, dynamicType, null, null, 0, 0, ref totalCount)
.Cast <DynamicContent>()
.Select(p => p.Id)
.ToList();
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(Constants.DynamicProvider);
var classificationData = new List <ClassificationItem>();
foreach (var jobProfileId in jobProfileIds)
{
//Get JobProfile Item
var relatedJobprofile = dynamicModuleManager.GetDataItem(dynamicType, jobProfileId);
if (relatedJobprofile.Status.ToString() == Constants.ItemStatusMaster)
{
classificationData.Add(new ClassificationItem
{
JobProfileId = dynamicContentExtensions.GetFieldValue <Guid>(relatedJobprofile, nameof(ClassificationItem.Id)),
JobProfileTitle = dynamicContentExtensions.GetFieldValue <Lstring>(relatedJobprofile, nameof(ClassificationItem.Title)),
Id = taxon.Id,
Title = taxon.Title,
Url = taxon.UrlName,
Description = taxon.Description
});
}
}
serviceBusMessageProcessor.SendOtherRelatedTypeMessages(classificationData, taxon.FlatTaxonomy.Name.Trim(), GetActionType(taxon.Status.ToString()));
}
void BindStores()
{
var manager = DynamicModuleManager.GetManager();
Type storeType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Stores.Store");
var stores = manager.GetDataItems(storeType)
.Where(s => s.Status == ContentLifecycleStatus.Live);
var radius = double.Parse(ddlDistance.SelectedValue);
var userLocation = GetCoordinate(txtSourceZip.Text.Trim());
var itemFilter = new ItemFilter {
ContentType = storeType.ToString()
};
IEnumerable <IGeoLocation> geolocations;
stores = (manager as IGeoLocationManager).FilterByGeoLocation(stores, userLocation.Latitude, userLocation.Longitude, radius, out geolocations, itemFilter: itemFilter);
var sortedStores = (manager as IGeoLocationManager).SortByDistance(stores, geolocations, userLocation.Latitude, userLocation.Longitude, DistanceSorting.Asc);
DynamicContent firstStore = sortedStores.FirstOrDefault();
if (firstStore != null)
{
var address = firstStore.GetAddressFields().First().Value;
litDefaultLat.Text = String.Format("{0}", address.Latitude);
litDefaultLong.Text = String.Format("{0}", address.Longitude);
}
listStores.DataSource = sortedStores;
listStores.DataBind();
lblStoreCount.Text = sortedStores.Count().ToString();
}
private void SaveBugWorker(object[] args)
{
var bugModel = args.SingleOrDefault(o => o.GetType() == typeof(BugModel)) as BugModel;
var liveProjectId = new Guid(args.SingleOrDefault(o => o.GetType() == typeof(Guid)).ToString());
if (bugModel == null || liveProjectId == Guid.Empty)
{
return;
}
var dynamicModuleManager = DynamicModuleManager.GetManager();
Guid masterProjectId = dynamicModuleManager.GetDataItem(BugController.projectType, liveProjectId).OriginalContentId;
var newBug = dynamicModuleManager.CreateDataItem(BugController.bugType);
newBug.SetValue("Title", bugModel.Title);
newBug.UrlName = Regex.Replace(bugModel.Title.ToLower(), @"[^\w\-\!\$\'\(\)\=\@\d_]+", "-");
newBug.SetValue("Description", bugModel.Description);
newBug.SetValue("Priority", bugModel.Priority);
newBug.SetValue("SystemParentId", masterProjectId);
newBug.ApprovalWorkflowState = "Published";
dynamicModuleManager.SaveChanges();
dynamicModuleManager.Lifecycle.Publish(newBug);
dynamicModuleManager.SaveChanges();
}
private IEnumerable <FrameworkSkillItem> GetRelatedSkillsData(DynamicContent jobProfileContent, DynamicContent content, string relatedField)
{
var relatedSkillsData = new List <FrameworkSkillItem>();
if (jobProfileContent.ApprovalWorkflowState == Constants.WorkflowStatusDraft && content.GetType().Name == Constants.SOCSkillsMatrix)
{
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(Constants.DynamicProvider);
var liveItem = dynamicModuleManager.Lifecycle.GetLive(content);
content = dynamicModuleManager.GetDataItem(content.GetType(), liveItem.Id);
}
var relatedItems = dynamicContentExtensions.GetRelatedItems(content, relatedField);
if (relatedItems != null)
{
foreach (var relatedItem in relatedItems)
{
relatedSkillsData.Add(new FrameworkSkillItem
{
Id = dynamicContentExtensions.GetFieldValue <Guid>(relatedItem, relatedItem.GetContentItemIdKey()),
Title = dynamicContentExtensions.GetFieldValue <Lstring>(relatedItem, nameof(FrameworkSkillItem.Title)),
Description = dynamicContentExtensions.GetFieldValue <Lstring>(relatedItem, nameof(FrameworkSkillItem.Description)),
ONetElementId = dynamicContentExtensions.GetFieldValue <Lstring>(relatedItem, nameof(FrameworkSkillItem.ONetElementId))
});
}
}
return(relatedSkillsData);
}
private string _GetHtmlEmailContent()
{
string htmlEmailContent;
if (string.IsNullOrEmpty(this.EmailTemplateId))
{
htmlEmailContent = _GetDefaultHtmlEmailContent();
}
else
{
var dynamicModuleManager = DynamicModuleManager.GetManager(_emailTemplateProvider);
var emailTemplateType = TypeResolutionService.ResolveType(_itemType);
var emailTemplateItem = dynamicModuleManager.GetDataItem(emailTemplateType, new Guid(this.EmailTemplateId.ToUpper()));
if (emailTemplateItem == null)
{
htmlEmailContent = _GetDefaultHtmlEmailContent();
}
else
{
htmlEmailContent = emailTemplateItem.GetValue("htmlEmailContent").ToString();
}
}
return(htmlEmailContent);
}
/// <summary>
/// Resolves the name of the provider used by the manager which is responsible for the content type that is filtering the shown taxa.
/// Returns the default provider name for the manager if ContentProviderName is not set.
/// </summary>
/// <returns></returns>
protected virtual string GetContentProviderName()
{
string providerName = String.Empty;
if (String.IsNullOrWhiteSpace(this.ContentProviderName))
{
if (!string.IsNullOrEmpty(this.ContentTypeName))
{
var manager = (IProviderResolver)ManagerBase.GetMappedManager(this.ContentType);
return(manager.GetDefaultContextProvider().Name);
}
else if (!String.IsNullOrEmpty(this.DynamicContentTypeName))
{
var moduleBuilderProvider = ModuleBuilderManager.GetManager().Provider;
DynamicModuleType dynamicContentType = moduleBuilderProvider.GetDynamicModuleTypes()
.FirstOrDefault(t => t.TypeName == this.ContentType.Name && t.TypeNamespace == this.ContentType.Namespace);
if (dynamicContentType != null)
{
DynamicModuleManager.GetDefaultProviderName(dynamicContentType.ModuleName);
}
}
}
else
{
providerName = this.ContentProviderName;
}
return(providerName);
}
public void DynamicWidgets_ContentLocationService_VerifyDynamicItemLocationOnMoreThanOnePage()
{
int expectedLocationsCount;
var page2Name = PageName + "2";
try
{
var countryId = ServerOperationsFeather.DynamicModuleBooking().CreateCountry(CountryName);
Type countryType = TypeResolutionService.ResolveType(ResolveTypeCountry);
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager();
var page1Id = ServerOperations.Pages().CreatePage(PageName);
var page2Id = ServerOperations.Pages().CreatePage(page2Name);
var countriesWidget = this.CreateMvcWidget(ResolveTypeCountry, WidgetNameCountries);
var controls = new List <System.Web.UI.Control>();
controls.Add(countriesWidget);
PageContentGenerator.AddControlsToPage(page1Id, controls);
PageContentGenerator.AddControlsToPage(page2Id, controls);
var locationsService = SystemManager.GetContentLocationService();
var dynamicItemLocations = locationsService.GetItemLocations(countryType, dynamicModuleManager.Provider.Name, countryId);
expectedLocationsCount = 2;
Assert.AreEqual(expectedLocationsCount, dynamicItemLocations.Count(), "Unexpected locations count");
}
finally
{
ServerOperations.Pages().DeleteAllPages();
ServerOperationsFeather.DynamicModuleBooking().DeleteCountry(CountryName);
}
}
public void CreateItem(string title, string[] relatedColors)
{
var providerName = string.Empty;
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
providerName = "dynamicContentProvider";
}
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
Type itemType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Module2.Item");
DynamicContent itemItem = dynamicModuleManager.CreateDataItem(itemType);
itemItem.SetValue("Title", title);
DynamicModuleManager relatedColorManager = DynamicModuleManager.GetManager(providerName);
var relatedColorType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Module1.Color");
foreach (var relatedColor in relatedColors)
{
var relatedColorItem = relatedColorManager.GetDataItems(relatedColorType).Where("Status = Master AND Title = \"" + relatedColor + "\"").First();
itemItem.CreateRelation(relatedColorItem, "RelatedColor");
dynamicModuleManager.SaveChanges();
}
itemItem.SetString("UrlName", Regex.Replace(title.ToLower(), urlNameCharsToReplace, urlNameReplaceString));
itemItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
itemItem.SetValue("PublicationDate", DateTime.Now);
itemItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Published");
dynamicModuleManager.Lifecycle.Publish(itemItem);
dynamicModuleManager.SaveChanges();
}
public static DynamicContent GetFeaturedArticleNavigation()
{
var taxonomyManager = TaxonomyManager.GetManager();
var tagsTaxonomy = taxonomyManager.GetTaxonomies <FlatTaxonomy>().FirstOrDefault(s => s.Name == "Tags");
var taxa = tagsTaxonomy.Taxa.Where(c => c.Title == "Featured").FirstOrDefault();
if (taxa != null)
{
var itemType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Articles.Article");
var multisiteContext = SystemManager.CurrentContext as MultisiteContext;
var providerName = multisiteContext.CurrentSite.GetProviders("Articles").Select(p => p.ProviderName).FirstOrDefault();
var transactionName = Guid.NewGuid();
var dynamicModuleManager = DynamicModuleManager.GetManager(providerName, transactionName.ToString());
var offices = dynamicModuleManager.GetDataItems(itemType).Where(o => o.Status == ContentLifecycleStatus.Live && o.Visible &&
o.GetValue <TrackedList <Guid> >("Tags").Contains(taxa.Id));
var cultureInfo = Thread.CurrentThread.CurrentUICulture;
if (!cultureInfo.IsNeutralCulture)
{
offices.Where(o => o.PublishedTranslations.Contains(cultureInfo.Name));
}
return(offices.OrderByDescending(a => a.GetValue <DateTime>("PublicationDate")).FirstOrDefault());
}
return(null);
}
// Creates a new bug item
private void CreateBugItem(DynamicModuleManager dynamicModuleManager, Type bugType, string transactionName)
{
DynamicContent bugItem = dynamicModuleManager.CreateDataItem(bugType);
// This is how values for the properties are set
bugItem.SetValue("Title", "Some Title");
bugItem.SetValue("Description", "Some Description");
// Set the selected value
bugItem.SetValue("Priority", "Option2");
bugItem.SetString("UrlName", "SomeUrlName");
bugItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
bugItem.SetValue("PublicationDate", DateTime.UtcNow);
bugItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Draft");
// Create a version and commit the transaction in order changes to be persisted to data store
var versionManager = VersionManager.GetManager(null, transactionName);
versionManager.CreateVersion(bugItem, false);
TransactionManager.CommitTransaction(transactionName);
}
public void CreatePressArticleWithCustomTaxonomy(string title, string url, string taxonomyName, IEnumerable <string> taxonNames, bool isHierarchicalTaxonomy = false)
{
// Set the provider name for the DynamicModuleManager here. All available providers are listed in
// Administration -> Settings -> Advanced -> DynamicModules -> Providers
var providerName = string.Empty;
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
providerName = "dynamicContentProvider";
}
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
Type pressArticleType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.PressRelease.PressArticle");
Telerik.Sitefinity.DynamicModules.Model.DynamicContent pressArticleItem = dynamicModuleManager.CreateDataItem(pressArticleType);
// This is how values for the properties are set
pressArticleItem.SetValue("Title", title);
pressArticleItem.SetValue("PublishedBy", "Some PublishedBy");
pressArticleItem.SetValue("Guid", Guid.NewGuid());
this.AddCustomTaxonomy(taxonNames, taxonomyName, pressArticleItem, isHierarchicalTaxonomy);
pressArticleItem.SetString("UrlName", url);
pressArticleItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
pressArticleItem.SetValue("PublicationDate", DateTime.Now);
pressArticleItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Published");
dynamicModuleManager.Lifecycle.Publish(pressArticleItem);
// You need to call SaveChanges() in order for the items to be actually persisted to data store
dynamicModuleManager.SaveChanges();
}
/// <summary>
/// Adapts item T into a DynamicContent item containing fields/values found in item T. This will also create
/// any relational data found in the item.
/// </summary>
/// <typeparam name="T">A subclass of SitefinityContent.</typeparam>
/// <param name="item">The item being adapted into a DynamicContent data item.</param>
/// <param name="properties">The property info of item T.</param>
/// <param name="providerName">The provider name used when retrieving the DynamicModuleManager.</param>
/// <returns></returns>
public static DynamicContent SetDataItemProperties <T>(this T item, PropertyInfo[] properties, string providerName) where T : SitefinityContent
{
SitefinityMetadataAttribute metadataAttribute = (SitefinityMetadataAttribute)item.GetType().GetCustomAttribute(typeof(SitefinityMetadataAttribute));
if (metadataAttribute == null)
{
throw new Exception($"Could not cast attribute to {nameof(SitefinityMetadataAttribute)}");
}
var dynamicContentType = metadataAttribute.DynamicContentType;
if (dynamicContentType == null)
{
return(null);
}
var resolvedDynamicContentType = TypeResolutionService.ResolveType(dynamicContentType);
var dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
var dataItem = dynamicModuleManager.CreateDataItem(resolvedDynamicContentType);
properties.ToList().ForEach(property => SetPropertyInDataItem(
item,
metadataAttribute,
ref dataItem,
property,
providerName
));
return(dataItem);
}
public void SaveBugWorker(object[] args)
{
BugModel bug = args.SingleOrDefault(o => o.GetType() == typeof(BugModel)) as BugModel;
Guid liveProjectId = new Guid(args.SingleOrDefault(o => o.GetType() == typeof(Guid)).ToString());
if (bug == null)
{
return;
}
if (liveProjectId == Guid.Empty)
{
return;
}
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager();
Guid masterProjectId = dynamicModuleManager.GetDataItem(this.projectType, liveProjectId).OriginalContentId;
var newBug = dynamicModuleManager.CreateDataItem(this.bugType);
newBug.SetValue("Title", bug.Title);
newBug.UrlName = Regex.Replace(bug.Title.ToLower(), @"[^\w\-\!\$\'\(\)\=\@\d_]+", "-");
newBug.SetValue("Description", bug.Description);
newBug.SetValue("Priority", bug.Priority);
newBug.SetValue("SystemParentId", masterProjectId);
newBug.ApprovalWorkflowState = "Draft";
dynamicModuleManager.SaveChanges();
}
public static List <DynamicContent> GetCurrentSiteItems(string dynamicType, string dataSource)
{
Type itemType = TypeResolutionService.ResolveType(dynamicType);
var managerArticle = TaxonomyManager.GetManager();
MultisiteContext multisiteContext = SystemManager.CurrentContext as MultisiteContext;
var providerName = multisiteContext.CurrentSite.GetProviders(dataSource).Select(p => p.ProviderName);
// Set a transaction name
var transactionName = Guid.NewGuid(); // I often using Guid.NewGuid()
// Set the culture name for the multilingual fields
var cultureName = "";
Thread.CurrentThread.CurrentUICulture = new CultureInfo(cultureName);
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName.FirstOrDefault(), transactionName.ToString());
Type type = TypeResolutionService.ResolveType(dynamicType);
// This is how we get the consultant items through filtering
var myFilteredCollection = dynamicModuleManager.GetDataItems(type).Where(c => c.Status == ContentLifecycleStatus.Live & c.Visible);
return(myFilteredCollection.ToList());
}
public bool TryMapRouteParameters(string[] urlParams, RequestContext requestContext)
{
if (urlParams == null)
{
throw new ArgumentNullException("urlParams");
}
if (requestContext == null)
{
throw new ArgumentNullException("requestContext");
}
if (urlParams.Length == 0)
{
return(false);
}
var manager = DynamicModuleManager.GetManager(this.Model.ProviderName);
if (this.Model.ParentFilterMode == ParentFilterMode.CurrentlyOpen && !this.Model.CurrentlyOpenParentType.IsNullOrEmpty())
{
if (this.Model.CurrentlyOpenParentType != DynamicContentController.AnyParentValue)
{
var parentType = TypeResolutionService.ResolveType(this.Model.CurrentlyOpenParentType, throwOnError: false);
if (parentType == null)
{
return(false);
}
return(this.TryMapSuccessorsRouteData(urlParams, requestContext, manager, parentType));
}
else
{
var dynamicType = this.GetDynamicContentType();
var currentParentType = dynamicType != null ? dynamicType.ParentModuleType : null;
bool isParentResolved = false;
while (currentParentType != null && isParentResolved == false)
{
var parentType = TypeResolutionService.ResolveType(currentParentType.GetFullTypeName(), throwOnError: false);
if (parentType != null)
{
isParentResolved = this.TryMapSuccessorsRouteData(urlParams, requestContext, manager, parentType);
}
currentParentType = currentParentType.ParentModuleType;
}
return(isParentResolved);
}
}
if (!this.Model.RelatedItemType.IsNullOrEmpty() && !this.Model.RelatedFieldName.IsNullOrEmpty())
{
return(this.TryMapRelatedDataRouteData(urlParams, requestContext));
}
return(false);
}
private static IQueryable <DynamicContent> GetArticles()
{
return(DynamicModuleManager.GetManager()
.GetDataItems(JXTNext.Sitefinity.Common.Constants.DynamicTypeConstants.Article.ResolvedType)
.Where(i => i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Live &&
i.Visible)
.Cast <DynamicContent>());
}
public void DeleteAllDynamicItemsInProvider(string providerName = "")
{
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
Type contenttypeType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.PressRelease.PressArticle");
dynamicModuleManager.DeleteDataItems(contenttypeType);
dynamicModuleManager.SaveChanges();
}
public CallVideoService(string Url)
{
this.ServiceUri = new Uri(Url);
var providerName = "OpenAccessProvider";
dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
dynamicModuleManager.Provider.SuppressSecurityChecks = true;
syncedVideoType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.SyncedVideos.SyncedVideo");
}
public OfficeModel()
{
if (this.ProviderName == null)
{
var dynamicType = ModuleBuilderManager.GetActiveTypes().FirstOrDefault(t => t.FullTypeName == this.OfficeType.FullName);
this.ProviderName = DynamicModuleManager.GetDefaultProviderName(dynamicType.ModuleName);
}
}
private IList <DynamicContent> PopulateAuthors()
{
var manager = DynamicModuleManager.GetManager();
var authorType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Authors.Author");
var authors = manager.GetDataItems(authorType).Where(a => a.Status == ContentLifecycleStatus.Live);
return(authors.ToList());
}
// Constructor.
// Properties must be set at creation time.
internal StateManager(Properties properties, bool debugStartedAtRoot, DynamicModuleManager dynamicModuleManager)
{
this.properties = properties;
this.debugStartedAtRoot = debugStartedAtRoot;
this.threads = new List<LogicalThread>();
if (dynamicModuleManager == null)
{
dynamicModuleManager = new DynamicModuleManager(this.properties.ModuleNamePrefix);
}
this.dynamicModuleManager = dynamicModuleManager;
}
public override void ExecuteTask()
{
//If no url is provided, die
if (webVidConfig.FeedUri.IsNullOrWhitespace())
return;
#region Execute Task
{
Type syncedVideoType;
var providerName = "OpenAccessProvider";
dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
syncedVideoType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.SyncedVideos.SyncedVideo");
List<google.Video> videos;
DateTime lastRan;
CallVideoService callService = new CallVideoService(webVidConfig.FeedUri);
DateTime.TryParse(webVidConfig.LastRuntime, out lastRan);
videos = callService.GetVideos().ToList();
foreach (google.Video vid in videos)
{
var myVideo = dynamicModuleManager.GetDataItems(syncedVideoType).Where(i => i.GetValue<string>("YouTubeVidId") == vid.VideoId && i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master).FirstOrDefault();
// if lastRan is set and (vid.YouTubeEntry.Published.Ticks > lastRan.Ticks || vid.YouTubeEntry.Updated.Ticks > lastRan.Ticks)
if (webVidConfig.LastRuntime.IsNullOrWhitespace() || vid.YouTubeEntry.Published.Ticks > lastRan.Ticks || vid.YouTubeEntry.Updated.Ticks > lastRan.Ticks)
callService.createUpdateVideo(myVideo, vid);
}
}
#endregion
#region Rescheduling task
{
//Update Configuration Time
ConfigManager manager = ConfigManager.GetManager();
manager.Provider.SuppressSecurityChecks = true;
WebVideoSyncConfig config = manager.GetSection<WebVideoSyncConfig>();
config.LastRuntime = DateTime.UtcNow.ToString();
manager.SaveSection(config);
manager.Provider.SuppressSecurityChecks = false;
//Reschedule Task
SchedulingManager schedulingManager = SchedulingManager.GetManager();
ScheduledVideoSync newTask = new ScheduledVideoSync();
schedulingManager.AddTask(newTask);
schedulingManager.SaveChanges();
}
#endregion
}
private bool TryMapSuccessorsRouteData(string[] urlParams, RequestContext requestContext, DynamicModuleManager manager, Type parentType)
{
string redirectUrl;
var item = manager.Provider.GetItemFromUrl(parentType, RouteHelper.GetUrlParameterString(urlParams), out redirectUrl);
if (item != null)
{
requestContext.RouteData.Values["action"] = "Successors";
requestContext.RouteData.Values["parentItem"] = item;
if (this.Request["page"] != null)
requestContext.RouteData.Values["page"] = int.Parse(this.Request["page"]);
return true;
}
if (urlParams.Length > 1)
{
this.TryMapSuccessorsRouteData(urlParams.Take(urlParams.Length - 1).ToArray(), requestContext, manager, parentType);
}
return false;
}
public virtual void OnRegisterModule(IDynamicModule module , DynamicModuleManager mgr)
{
}
public virtual void OnWillRegisterDynamicModule(DynamicModuleManager mgr)
{
}
private void SetupModuleManager()
{
this.ModuleManager = new DynamicModuleManager();
//register common modules
var uiModule = new UIModuleManager();
ModuleManager.Register(uiModule);
UIManager = uiModule;
}
public DynamicContentViewDetailCustom(DynamicModuleManager dynamicModuleManager = null)
: base(dynamicModuleManager)
{
}
public virtual void OnRegister(DynamicModuleManager mgr)
{
}
public virtual void OnAllModuleInitDone(DynamicModuleManager mgr)
{
}
