/// <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();
}
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();
}
public void RestartApplication()
{
ServerOperations.SystemManager().RestartApplication(false);
WaitUtils.WaitForSitefinityToStart(HttpContext.Current.Request.Url
.GetLeftPart(UriPartial.Authority) + (HostingEnvironment.ApplicationVirtualPath.TrimEnd('/') ?? string.Empty));
ServerOperations.MultiSite().AssignModuleToCurrentSite(ModuleName);
}
public void SetUp()
{
AuthenticationHelper.AuthenticateUser(AdminUserName, AdminPass, true);
ServerOperations.Comments().RequireAuthentication(ThreadType, true);
ServerOperations.Configuration().EnableRatings(true);
ServerOperations.News().CreatePublishedNewsItemLiveId(NewsTitle, NewsContent, NewsAuthor, NewsSource);
Guid templateId = Telerik.Sitefinity.TestUtilities.CommonOperations.ServerOperations.Templates().GetTemplateIdByTitle(PageTemplateName);
Guid pageId = Telerik.Sitefinity.TestUtilities.CommonOperations.ServerOperations.Pages().CreatePage(PageName, templateId);
pageId = ServerOperations.Pages().GetPageNodeId(pageId);
ServerOperationsFeather.Pages().AddNewsWidgetToPage(pageId, "Contentplaceholder1");
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
Guid pageId2 = Guid.NewGuid();
ServerOperations.Multilingual().Pages().CreatePageMultilingual(pageId2, PageTitleLogin, true, "en");
ServerOperations.Widgets().AddControlToPage(pageId2, ControlTypes.LoginWidget, "Body", "Login");
ServerOperations.MultiSite().AddPublicLoginPageToSite(pageId2);
}
else
{
Guid pageIdLogIn = Guid.NewGuid();
ServerOperations.Pages().CreateTestPage(pageIdLogIn, PageTitleLogin);
ServerOperations.Widgets().AddControlToPage(pageIdLogIn, ControlTypes.LoginWidget, "Body", "Login");
ServerOperations.Comments().SetDefaultLoginPageUrl(LoginURL);
}
}
/// <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);
}
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 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();
}
public void ImportNewPackage()
{
ServerOperations.ModuleBuilder().DeleteDirectory(this.tempFolderPath);
ServerOperationsFeather.DynamicModules().ExtractStructureZip(PackageResourceEdited, InstallationPath);
ServerOperations.SystemManager().RestartApplication(false);
WaitUtils.WaitForSitefinityToStart(HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Authority) + (HostingEnvironment.ApplicationVirtualPath.TrimEnd('/') ?? string.Empty));
ServerOperations.MultiSite().AssignModuleToCurrentSite(ModuleName);
}
public void ServerSetUp()
{
ServerOperations.Pages().CreatePage(PageName);
ServerOperationsFeather.DynamicModules().ExtractStructureZip(PackageResource, InstallationPath);
ServerOperations.SystemManager().RestartApplication(false);
WaitUtils.WaitForSitefinityToStart(HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Authority) + (HostingEnvironment.ApplicationVirtualPath.TrimEnd('/') ?? string.Empty));
ServerOperations.MultiSite().AssignModuleToCurrentSite(ModuleName);
}
/// <summary>
/// Imports a dynamic module.
/// </summary>
/// <param name="moduleResource">The dynamic module resource file.</param>
public void EnsureModuleIsImported(string moduleName, string moduleResource)
{
string providerName = string.Empty;
string transactionName = "Module Installations";
if (!ServerOperations.ModuleBuilder().IsModulePresent(moduleName))
{
var assembly = this.GetTestUtilitiesAssembly();
Stream moduleStream = assembly.GetManifestResourceStream(moduleResource);
using (Stream stream = moduleStream)
{
ServerOperations.ModuleBuilder().ImportModule(stream);
ServerOperations.ModuleBuilder().ActivateModule(moduleName, providerName, transactionName);
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
var providerNames = DynamicModuleManager.GetManager().AllProviders.Select(p => p.ProviderName);
bool isCreated = providerNames.Contains("dynamicContentProvider");
if (!isCreated)
{
ServerOperations.MultiSite().CreateDynamicContentProvider("dynamicContentProvider");
}
ServerOperations.SystemManager().RestartApplication(false);
ServerOperations.MultiSite().AssignModuleToCurrentSite(moduleName);
}
else
{
ServerOperations.SystemManager().RestartApplication(false);
}
}
}
else if (!ServerOperations.ModuleBuilder().IsModuleActive(moduleName))
{
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
var providerNames = DynamicModuleManager.GetManager().AllProviders.Select(p => p.ProviderName);
bool isCreated = providerNames.Contains("dynamicContentProvider");
if (!isCreated)
{
ServerOperations.MultiSite().CreateDynamicContentProvider("dynamicContentProvider");
}
ServerOperations.SystemManager().RestartApplication(false);
ServerOperations.MultiSite().AssignModuleToCurrentSite(moduleName);
}
else
{
ServerOperations.SystemManager().RestartApplication(false);
WaitUtils.WaitForSitefinityToStart(SystemManager.CurrentHttpContext.Request.Url.GetLeftPart(UriPartial.Authority) + (HostingEnvironment.ApplicationVirtualPath.TrimEnd('/') ?? string.Empty));
}
}
}
/// <summary>
/// Imports a dynamic module.
/// </summary>
/// <param name="moduleResource">The dynamic module resource file.</param>
public void EnsureModuleIsImported(string moduleName, string moduleResource)
{
string providerName = string.Empty;
string transactionName = "Module Installations";
if (!ServerOperations.ModuleBuilder().IsModulePresent(moduleName))
{
var assembly = this.GetTestUtilitiesAssembly();
Stream moduleStream = assembly.GetManifestResourceStream(moduleResource);
using (Stream stream = moduleStream)
{
ServerOperations.ModuleBuilder().ImportModule(stream);
ServerOperations.ModuleBuilder().ActivateModule(moduleName, providerName, transactionName);
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
var providerNames = DynamicModuleManager.GetManager().AllProviders.Select(p => p.ProviderName);
bool isCreated = providerNames.Contains("dynamicContentProvider");
if (!isCreated)
{
ServerOperations.MultiSite().CreateDynamicContentProvider("dynamicContentProvider");
}
ServerOperations.SystemManager().RestartApplication(false);
ServerOperations.MultiSite().AssignModuleToCurrentSite(moduleName);
}
else
{
ServerOperations.SystemManager().RestartApplication(false);
}
}
}
else if (!ServerOperations.ModuleBuilder().IsModuleActive(moduleName))
{
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
var providerNames = DynamicModuleManager.GetManager().AllProviders.Select(p => p.ProviderName);
bool isCreated = providerNames.Contains("dynamicContentProvider");
if (!isCreated)
{
ServerOperations.MultiSite().CreateDynamicContentProvider("dynamicContentProvider");
}
ServerOperations.SystemManager().RestartApplication(false);
ServerOperations.MultiSite().AssignModuleToCurrentSite(moduleName);
}
else
{
ServerOperations.SystemManager().RestartApplication(false);
}
}
}
public void TearDown()
{
ServerOperations.Pages().DeleteAllPages();
var providerName = string.Empty;
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
providerName = "dynamicContentProvider";
}
ServerOperationsFeather.DynamicModulePressArticle().DeleteAllDynamicItemsInProvider(providerName);
}
public void TearDown()
{
var providerName = string.Empty;
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
providerName = "dynamicContentProvider";
}
ServerOperationsFeather.DynamicModulePressArticle().DeleteAllDynamicItemsInProvider(providerName);
ServerOperations.Pages().DeleteAllPages();
ServerOperations.Configuration().RemoveOpenAccessDynamicModuleProvider(ProviderName);
ServerOperations.SystemManager().RestartApplication(false);
}
public void TearDown()
{
AuthenticationHelper.AuthenticateUser(AdminUserName, AdminPass, true);
ServerOperations.Pages().DeleteAllPages();
ServerOperations.Taxonomies().ClearAllCategories(TaxonomiesConstants.CategoriesTaxonomyId);
var providerName = string.Empty;
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
providerName = "dynamicContentProvider";
}
ServerOperationsFeather.DynamicModulePressArticle().DeleteAllDynamicItemsInProvider(providerName);
}
public void TearDown()
{
AuthenticationHelper.AuthenticateUser(this.AdminEmail, this.AdminPass, true);
ServerOperations.Pages().DeleteAllPages();
var providerName = string.Empty;
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
providerName = "dynamicContentProvider";
}
ServerOperationsFeather.DynamicModulePressArticle().DeleteAllDynamicItemsInProvider(providerName);
}
/// <summary>
/// Demonstrates how pressArticleItem is unpublished
/// </summary>
/// <param name="pressArticleItem">The press article item.</param>
public void UNPublishPressArticle(ILifecycleDataItem pressArticleItem)
{
var providerName = string.Empty;
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
providerName = "dynamicContentProvider";
}
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
var liveDynamicItem = dynamicModuleManager.Lifecycle.GetLive(pressArticleItem);
dynamicModuleManager.Lifecycle.Unpublish(liveDynamicItem);
dynamicModuleManager.SaveChanges();
}
public void TearDown()
{
ServerOperations.Pages().DeleteAllPages();
ServerOperationsFeather.DynamicModulePressArticle().RemoveCustomFieldFromContext(CustomFlatTaxonomyName);
ServerOperations.Taxonomies().DeleteFlatTaxonomy(CustomFlatTaxonomyName);
var providerName = string.Empty;
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
providerName = "dynamicContentProvider";
}
ServerOperationsFeather.DynamicModulePressArticle().DeleteAllDynamicItemsInProvider(providerName);
}
public List <DynamicContent> RetrieveCollectionOfPressArticles(string providerName)
{
if (ServerOperations.MultiSite().CheckIsMultisiteMode() && providerName == null)
{
providerName = "dynamicContentProvider";
}
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
Type pressArticleType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.PressRelease.PressArticle");
// This is how we get the collection of Press Article items
var myCollection = dynamicModuleManager.GetDataItems(pressArticleType).ToList();
//// At this point myCollection contains the items from type pressArticleType
return(myCollection);
}
/// <summary>
/// Delete a country item by title.
/// </summary>
/// <param name="countryName">The title of the item.</param>
public void DeleteCountry(string countryName)
{
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.GetDataItems(countryType).Where("Title = \"" + countryName + "\"").First();
dynamicModuleManager.DeleteDataItem(countryItem);
dynamicModuleManager.SaveChanges();
}
public void CreatePressArticle(string title, string url, Guid tag, Guid category, string publishedBy, string providerName)
{
if (ServerOperations.MultiSite().CheckIsMultisiteMode() && providerName == null)
{
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("Guid", Guid.NewGuid());
if (publishedBy.IsNullOrEmpty())
{
pressArticleItem.SetValue("PublishedBy", "Some PublishedBy");
}
else
{
pressArticleItem.SetValue("PublishedBy", publishedBy);
}
if (tag != null && tag != Guid.Empty)
{
pressArticleItem.Organizer.AddTaxa("Tags", tag);
}
if (category != null && category != Guid.Empty)
{
pressArticleItem.Organizer.AddTaxa("Category", category);
}
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();
}
public void TearDown()
{
ServerOperations.Pages().DeleteAllPages();
var providerName = string.Empty;
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
providerName = "dynamicContentProvider";
}
ServerOperationsFeather.DynamicModulePressArticle().DeleteAllDynamicItemsInProvider(providerName);
for (int i = 0; i < 4; i++)
{
ServerOperations.Taxonomies().DeleteCategories(this.taxonTitleDynamic + i, this.taxonTitleNews + i);
}
ServerOperations.News().DeleteAllNews();
}
public void PublishPressArticleWithSpecificDate(DynamicContent pressArticleItem, DateTime specificDate)
{
// 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);
////We can set a date and time in the future, for the item to be published
dynamicModuleManager.Lifecycle.PublishWithSpecificDate(pressArticleItem, specificDate);
// You need to call SaveChanges() in order for the items to be actually persisted to data store
dynamicModuleManager.SaveChanges();
}
public void DeleteDynamicItems(List <DynamicContent> itemsToDelete, string providerName)
{
if (ServerOperations.MultiSite().CheckIsMultisiteMode() && providerName == null)
{
providerName = "dynamicContentProvider";
}
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
var currentItems = itemsToDelete.Select(i => dynamicModuleManager.GetDataItem(i.GetType(), i.Id)).ToArray();
for (int i = 0; i < currentItems.Length; i++)
{
//// This is how you delete the pressArticleItem
dynamicModuleManager.DeleteDataItem(currentItems[i]);
}
// You need to call SaveChanges() in order for the items to be actually persisted to data store
dynamicModuleManager.SaveChanges();
}
public List <DynamicContent> RetrieveCollectionOfAllFields()
{
// 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.AllTypesModule.Alltypes");
// This is how we get the collection of Press Article items
var myCollection = dynamicModuleManager.GetDataItems(pressArticleType).ToList();
//// At this point myCollection contains the items from type pressArticleType
return(myCollection);
}
public void EditPressArticleTitle(DynamicContent pressArticleItem, string newTitle)
{
// 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);
pressArticleItem.SetValue("Title", newTitle);
dynamicModuleManager.Lifecycle.Publish(pressArticleItem);
// You need to call SaveChanges() in order for the items to be actually persisted to data store
dynamicModuleManager.SaveChanges();
}
public DynamicContent CreatePressArticleItem(string title, string url)
{
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());
TaxonomyManager taxonomyManager = TaxonomyManager.GetManager();
var tag = taxonomyManager.GetTaxa <FlatTaxon>().Where(t => t.Taxonomy.Name == "Tags").FirstOrDefault();
if (tag != null)
{
pressArticleItem.Organizer.AddTaxa("Tags", tag.Id);
}
pressArticleItem.SetString("UrlName", url);
pressArticleItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
pressArticleItem.SetValue("PublicationDate", DateTime.Now);
pressArticleItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Published");
dynamicModuleManager.Lifecycle.Publish(pressArticleItem);
dynamicModuleManager.RecompileDataItemsUrls(pressArticleType);
// You need to call SaveChanges() in order for the items to be actually persisted to data store
dynamicModuleManager.SaveChanges();
return(pressArticleItem);
}
public void AddDynamicWidgetToPage(Guid pageId, string type, string widgetName, string widgetCaption, string placeholder = "Body")
{
using (var mvcProxy = new MvcWidgetProxy())
{
PageManager pageManager = PageManager.GetManager();
pageManager.Provider.SuppressSecurityChecks = true;
var pageDataId = pageManager.GetPageNode(pageId).PageId;
var page = pageManager.EditPage(pageDataId, CultureInfo.CurrentUICulture);
mvcProxy.ControllerName = typeof(DynamicContentController).FullName;
var dynamicController = new DynamicContentController();
dynamicController.Model.ContentType = TypeResolutionService.ResolveType(type);
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
dynamicController.Model.ProviderName = "dynamicContentProvider";
}
mvcProxy.Settings = new ControllerSettings(dynamicController);
mvcProxy.WidgetName = widgetName;
this.CreateControl(pageManager, page, mvcProxy, widgetCaption, placeholder);
}
}
public void CreateAlltypes()
{
// 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 alltypesType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.AllTypesModule.Alltypes");
DynamicContent alltypesItem = dynamicModuleManager.CreateDataItem(alltypesType);
//// This is how values for the properties are set
alltypesItem.SetValue("Title", "Some Title");
alltypesItem.SetValue("LongText", "Some LongText");
alltypesItem.SetValue("ShortText", "Some ShortText");
//// Set the selected value
alltypesItem.SetValue("Choices", new string[] { "1" });
//// Set the selected value
alltypesItem.SetValue("ChoicesRadioButtons", "2");
//// Set the selected value
alltypesItem.SetValue("ChoicesDropDown", "3");
alltypesItem.SetValue("YesNo", true);
alltypesItem.SetValue("DateTime", DateTime.Now);
alltypesItem.SetValue("Number", 25);
TaxonomyManager taxonomyManager = TaxonomyManager.GetManager();
var category = taxonomyManager.GetTaxa <HierarchicalTaxon>().Where(t => t.Taxonomy.Name == "Categories").FirstOrDefault();
if (category != null)
{
alltypesItem.Organizer.AddTaxa("Category", category.Id);
}
var tag = taxonomyManager.GetTaxa <FlatTaxon>().Where(t => t.Taxonomy.Name == "Tags").FirstOrDefault();
if (tag != null)
{
alltypesItem.Organizer.AddTaxa("Tags", tag.Id);
}
Address address = new Address();
CountryElement addressCountry = Config.Get <LocationsConfig>().Countries.Values.First(x => x.Name == "United States");
address.CountryCode = addressCountry.IsoCode;
address.StateCode = addressCountry.StatesProvinces.Values.First().Abbreviation;
address.City = "Some City";
address.Street = "Some Street";
address.Zip = "12345";
alltypesItem.SetValue("Address", address);
alltypesItem.SetString("UrlName", "SomeUrlName");
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();
}
public void DeleteSite()
{
ServerOperations.MultiSite().DeleteSite(SiteName);
}
public void IsMultisiteMode()
{
var isMultisiteMode = ServerOperations.MultiSite().CheckIsMultisiteMode();
ServerArrangementContext.GetCurrent().Values.Add("isMultisiteMode", isMultisiteMode.ToString());
}
