public void CreateCountryWithFestivalAndCity()
{
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager();
Type countryType = TypeResolutionService.ResolveType(HierarchicalDynamicContentTests.CountryType);
DynamicContent countryItem = dynamicModuleManager.CreateDataItem(countryType, HierarchicalDynamicContentTests.CountryId, dynamicModuleManager.Provider.ApplicationName);
countryItem.SetValue("Name", "Test country");
countryItem.SetValue("Description", "Test Description");
countryItem.SetString("UrlName", "TestUrlName");
countryItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
countryItem.SetValue("PublicationDate", DateTime.Now);
countryItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Draft");
Type cityType = TypeResolutionService.ResolveType(HierarchicalDynamicContentTests.CityType);
DynamicContent cityItem = dynamicModuleManager.CreateDataItem(cityType, HierarchicalDynamicContentTests.CityId, dynamicModuleManager.Provider.ApplicationName);
cityItem.SetValue("Name", "Test Name");
cityItem.SetValue("History", "Test History");
cityItem.SetString("UrlName", "TestUrlName");
cityItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
cityItem.SetValue("PublicationDate", DateTime.Now);
cityItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Draft");
countryItem.AddChildItem(cityItem);
Type festivalType = TypeResolutionService.ResolveType(HierarchicalDynamicContentTests.FestivalType);
DynamicContent festivalItem = dynamicModuleManager.CreateDataItem(festivalType, HierarchicalDynamicContentTests.FestivalId, dynamicModuleManager.Provider.ApplicationName);
festivalItem.SetValue("Name", "Test Name");
festivalItem.SetValue("Description", "Test Description");
festivalItem.SetValue("From", DateTime.Now);
festivalItem.SetValue("To", DateTime.Now);
festivalItem.SetString("UrlName", "TestUrlName");
festivalItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
festivalItem.SetValue("PublicationDate", DateTime.Now);
festivalItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Draft");
countryItem.AddChildItem(festivalItem);
dynamicModuleManager.SaveChanges();
var actualCountry = dynamicModuleManager.GetDataItem(countryType, countryItem.Id);
Assert.IsNotNull(actualCountry);
var cityCount = DynamicContentExtensions.GetChildItemsCount(actualCountry, HierarchicalDynamicContentTests.CityType);
var festivalCount = DynamicContentExtensions.GetChildItemsCount(actualCountry, HierarchicalDynamicContentTests.FestivalType);
Assert.AreEqual(cityCount, 1);
Assert.AreEqual(festivalCount, 1);
}
/// <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();
}
// 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 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 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>
/// 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 string CreateOffice()
{
string result = "Office created successfully";
try
{
// Set a transaction name and get the version manager
var transactionName = "someTransactionName";
var versionManager = VersionManager.GetManager(null, transactionName);
// Set the culture name for the multilingual fields
var cultureName = "en";
Thread.CurrentThread.CurrentUICulture = new CultureInfo(cultureName);
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(this.ProviderName, transactionName);
DynamicContent officeItem = dynamicModuleManager.CreateDataItem(this.OfficeType);
// This is how values for the properties are set
officeItem.SetString("Title", "New York", cultureName);
officeItem.SetString("Info", LOREM_IPSUM, cultureName);
Address address = new Address();
CountryElement addressCountry = Telerik.Sitefinity.Configuration.Config.Get <LocationsConfig>().Countries.Values.First(x => x.Name == "United States");
address.CountryCode = addressCountry.IsoCode;
address.StateCode = addressCountry.StatesProvinces.Values.First().Abbreviation;
address.City = "New York City";
address.Street = "Baker Street";
address.Zip = "12345";
officeItem.SetValue("Address", address);
// Get related item manager
LibrariesManager pictureManager = LibrariesManager.GetManager("OpenAccessDataProvider");
var pictureItem = pictureManager.GetImages().FirstOrDefault(i => i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master && i.Title.Contains("New York"));
if (pictureItem != null)
{
// This is how we relate an item
officeItem.CreateRelation(pictureItem, "Picture");
}
officeItem.SetString("UrlName", "new-york", cultureName);
officeItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
officeItem.SetValue("PublicationDate", DateTime.UtcNow);
officeItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Draft", new CultureInfo(cultureName));
// Create a version and commit the transaction in order changes to be persisted to data store
versionManager.CreateVersion(officeItem, false);
TransactionManager.CommitTransaction(transactionName);
}
catch (Exception ex)
{
return(ex.Message.ToString());
}
return(result);
}
public void CreateCityWithTenHotelsAndTenRestaurant()
{
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager();
Type cityType = TypeResolutionService.ResolveType(HierarchicalDynamicContentTests.CityType);
DynamicContent cityItem = dynamicModuleManager.CreateDataItem(cityType, HierarchicalDynamicContentTests.CityId, dynamicModuleManager.Provider.ApplicationName);
cityItem.SetValue("Name", "Test Name");
cityItem.SetValue("History", "Test History");
cityItem.SetString("UrlName", "TestUrlName");
cityItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
cityItem.SetValue("PublicationDate", DateTime.Now);
cityItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Draft");
Type hotelType = TypeResolutionService.ResolveType(HierarchicalDynamicContentTests.HotelType);
for (int i = 0; i < 10; i++)
{
DynamicContent hotelItem = dynamicModuleManager.CreateDataItem(hotelType);
hotelItem.SetValue("Name", "Test Name " + i);
hotelItem.SetValue("Overview", "Test Overview " + i);
cityItem.AddChildItem(hotelItem);
}
Type restaurantType = TypeResolutionService.ResolveType(HierarchicalDynamicContentTests.RestaurantType);
for (int i = 0; i < 10; i++)
{
DynamicContent restaurantItem = dynamicModuleManager.CreateDataItem(restaurantType);
restaurantItem.SetValue("Name", "Test Name " + i);
restaurantItem.SetValue("Description", "Test Description " + i);
cityItem.AddChildItem(restaurantItem);
}
dynamicModuleManager.SaveChanges();
var actualCity = dynamicModuleManager.GetDataItem(cityType, cityItem.Id);
Assert.IsNotNull(actualCity);
var hotelCount = DynamicContentExtensions.GetChildItemsCount(actualCity, HierarchicalDynamicContentTests.HotelType);
var restaurantCount = DynamicContentExtensions.GetChildItemsCount(actualCity, HierarchicalDynamicContentTests.RestaurantType);
Assert.AreEqual(hotelCount, 10);
Assert.AreEqual(restaurantCount, 10);
}
public void CreateFestival()
{
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager();
Type festivalType = TypeResolutionService.ResolveType(HierarchicalDynamicContentTests.FestivalType);
DynamicContent festivalItem = dynamicModuleManager.CreateDataItem(festivalType, HierarchicalDynamicContentTests.FestivalId, dynamicModuleManager.Provider.ApplicationName);
festivalItem.SetValue("Name", "Test Name");
festivalItem.SetValue("Description", "Test Description");
festivalItem.SetValue("From", DateTime.Now);
festivalItem.SetValue("To", DateTime.Now);
LibrariesManager mainPictureManager = LibrariesManager.GetManager();
var mainPictureItem = mainPictureManager.GetImages().FirstOrDefault(i => i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master);
if (mainPictureItem != null)
{
festivalItem.CreateRelation(mainPictureItem, "MainPicture");
}
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 = "Test City";
address.Street = "Test Street";
address.Zip = "12345";
address.Latitude = 0.00;
address.Longitude = 0.00;
address.MapZoomLevel = 8;
festivalItem.SetValue("Address", address);
festivalItem.SetString("UrlName", "TestUrlName");
festivalItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
festivalItem.SetValue("PublicationDate", DateTime.Now);
festivalItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Draft");
dynamicModuleManager.SaveChanges();
var actualFestival = dynamicModuleManager.GetDataItem(festivalType, festivalItem.Id);
Assert.IsNotNull(actualFestival);
Assert.AreEqual(festivalItem.GetValue("Name").ToString(), actualFestival.GetValue("Name").ToString());
Assert.AreEqual(festivalItem.GetValue("Description").ToString(), actualFestival.GetValue("Description").ToString());
Assert.AreEqual(festivalItem.GetValue("From"), actualFestival.GetValue("From"));
Assert.AreEqual(festivalItem.GetValue("To"), actualFestival.GetValue("To"));
Assert.AreEqual(festivalItem.GetValue("MainPicture"), actualFestival.GetValue("MainPicture"));
Assert.AreEqual(festivalItem.GetValue("Address"), actualFestival.GetValue("Address"));
Assert.AreEqual(festivalItem.GetValue("UrlName").ToString(), actualFestival.GetValue("UrlName").ToString());
Assert.AreEqual(festivalItem.GetValue("Owner"), actualFestival.GetValue("Owner"));
Assert.AreEqual(festivalItem.GetValue("PublicationDate"), actualFestival.GetValue("PublicationDate"));
}
public void CreateStore(string storeName, string street, string zip, string city, string countryCode, string stateCode, double latitude, double longitude, int mapZoomLevel, string urlName, string phone, string imageTitle)
{
// Set the provider name for the DynamicModuleManager here. All available providers are listed in
// Administration -> Settings -> Advanced -> DynamicModules -> Providers
var providerName = String.Empty;
// Set the culture name for the multilingual fields
var cultureName = "en";
Thread.CurrentThread.CurrentUICulture = new CultureInfo(cultureName);
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
Type shopType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Stores.Store");
DynamicContent shopItem = dynamicModuleManager.CreateDataItem(shopType);
// This is how values for the properties are set
shopItem.SetString("Title", storeName, cultureName);
LibrariesManager libraryManager = LibrariesManager.GetManager();
var image = libraryManager.GetImages().FirstOrDefault(i => i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Live && i.Title == imageTitle);
if (image != null)
{
shopItem.AddImage("StoreImage", image.Id);
}
Telerik.Sitefinity.GeoLocations.Model.Address myAddress = new Telerik.Sitefinity.GeoLocations.Model.Address();
myAddress.City = city;
myAddress.CountryCode = countryCode;
myAddress.StateCode = stateCode;
myAddress.MapZoomLevel = mapZoomLevel;
myAddress.Latitude = latitude;
myAddress.Longitude = longitude;
myAddress.Street = street;
myAddress.Zip = zip;
shopItem.SetValue("Address", myAddress);
shopItem.SetString("UrlName", urlName, cultureName);
shopItem.SetString("Phone", phone, cultureName);
shopItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
shopItem.SetValue("PublicationDate", DateTime.Now);
ILifecycleDataItem publishedFrontendContentItem = dynamicModuleManager.Lifecycle.Publish(shopItem);
shopItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Published");
dynamicModuleManager.SaveChanges();
}
public void CreateCity()
{
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager();
Type cityType = TypeResolutionService.ResolveType(HierarchicalDynamicContentTests.CityType);
DynamicContent cityItem = dynamicModuleManager.CreateDataItem(cityType, HierarchicalDynamicContentTests.CityId, dynamicModuleManager.Provider.ApplicationName);
cityItem.SetValue("Name", "Test Name");
cityItem.SetValue("History", "Test History");
Address location = new Address();
CountryElement locationCountry = Config.Get <LocationsConfig>().Countries.Values.First(x => x.Name == "United States");
location.CountryCode = locationCountry.IsoCode;
location.StateCode = locationCountry.StatesProvinces.Values.First().Abbreviation;
location.City = "Test City";
location.Street = "Test Street";
location.Zip = "12345";
location.Latitude = 0.00;
location.Longitude = 0.00;
location.MapZoomLevel = 8;
cityItem.SetValue("Location", location);
LibrariesManager mainPictureManager = LibrariesManager.GetManager();
var mainPictureItem = mainPictureManager.GetImages().FirstOrDefault(i => i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master);
if (mainPictureItem != null)
{
cityItem.CreateRelation(mainPictureItem, "MainPicture");
}
cityItem.SetString("UrlName", "TestUrlName");
cityItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
cityItem.SetValue("PublicationDate", DateTime.Now);
cityItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Draft");
dynamicModuleManager.SaveChanges();
var actualCity = dynamicModuleManager.GetDataItem(cityType, cityItem.Id);
Assert.IsNotNull(actualCity);
Assert.AreEqual(cityItem.GetValue("Name").ToString(), actualCity.GetValue("Name").ToString());
Assert.AreEqual(cityItem.GetValue("History").ToString(), actualCity.GetValue("History").ToString());
Assert.AreEqual(cityItem.GetValue("Location"), actualCity.GetValue("Location"));
Assert.AreEqual(cityItem.GetValue("MainPicture"), actualCity.GetValue("MainPicture"));
Assert.AreEqual(cityItem.GetValue("UrlName").ToString(), actualCity.GetValue("UrlName").ToString());
Assert.AreEqual(cityItem.GetValue("Owner"), actualCity.GetValue("Owner"));
Assert.AreEqual(cityItem.GetValue("PublicationDate"), actualCity.GetValue("PublicationDate"));
}
public static void CreateStory(SuccessStoryWidgetViewModel successStoryWidgetViewModel)
{
var transactionName = "Submit";
var providerName = "OpenAccessDataProvider";
var versionManager = VersionManager.GetManager(providerName, transactionName);
var dynamicModuleProviderName = "OpenAccessProvider";
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(dynamicModuleProviderName, transactionName);
using (new ElevatedModeRegion(dynamicModuleManager)) //ElevatedModeRegion is set to override access restrictions for given users
{
Type successStoryType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.SuccessStories.SuccessStory");
DynamicContent successStoryItem = dynamicModuleManager.CreateDataItem(successStoryType);
successStoryItem.SetValue("Title", successStoryWidgetViewModel.Title);
successStoryItem.SetValue("Description", successStoryWidgetViewModel.Description);
successStoryItem.SetValue("SummaryDescription", successStoryWidgetViewModel.SummaryDescription);
successStoryItem.SetValue("ProductsUsed", successStoryWidgetViewModel.ProductsUsed);
successStoryItem.SetValue("Company", successStoryWidgetViewModel.Company);
successStoryItem.SetValue("CompanyWebsite", successStoryWidgetViewModel.CompanyWebsite);
successStoryItem.SetValue("Industry", successStoryWidgetViewModel.Industry);
// Get related item manager
LibrariesManager thumbnailManager = LibrariesManager.GetManager();
var thumbnailItem = thumbnailManager.GetImages().FirstOrDefault(i => i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master);
if (thumbnailItem != null)
{
// This is how we relate an item
successStoryItem.CreateRelation(thumbnailItem, "Thumbnail");
}
//Trimming spaces from the Title, then setting it to Lowercase with the .ToLower() method, so it can be used as a unique URL for a newly submitted Success Story
var urlName = successStoryWidgetViewModel.Title;
var urlNameNoSpaces = urlName.Replace(" ", "");
successStoryItem.SetString("UrlName", urlNameNoSpaces.ToLower());
successStoryItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
successStoryItem.SetValue("PublicationDate", DateTime.UtcNow);
successStoryItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Draft");
versionManager.CreateVersion(successStoryItem, true);
TransactionManager.CommitTransaction(transactionName);
}
}
public ActionResult CreateBug(BugsModel bug)
{
DynamicContent masterProject = DynamicModuleManager.GetDataItem(projectsType, bug.SystemParentId);
var newBug = dynamicModuleManager.CreateDataItem(bugType);
newBug.SetValue("Title", bug.Title);
newBug.UrlName = Regex.Replace(bug.Title.ToLower(), @"[^\w\-\!\$\'\(\)\=\@\d_]+", "-");
newBug.SetValue("Description", bug.Description);
newBug.SetValue("SystemParentId", masterProject.OriginalContentId);
newBug.ApprovalWorkflowState = "Published";
DynamicModuleManager.Lifecycle.Publish(newBug);
DynamicModuleManager.SaveChanges();
return(RedirectToAction("Detail", new { urlName = masterProject.UrlName }));
}
public void CreateCountry()
{
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager();
Type countryType = TypeResolutionService.ResolveType(HierarchicalDynamicContentTests.CountryType);
DynamicContent countryItem = dynamicModuleManager.CreateDataItem(countryType, HierarchicalDynamicContentTests.CountryId, dynamicModuleManager.Provider.ApplicationName);
countryItem.SetValue("Name", "Test country");
countryItem.SetValue("Description", "Test Description");
Address location = new Address();
location.Latitude = 0.00;
location.Longitude = 0.00;
location.MapZoomLevel = 8;
countryItem.SetValue("Location", location);
LibrariesManager mainPictureManager = LibrariesManager.GetManager();
var mainPictureItem = mainPictureManager.GetImages().FirstOrDefault(i => i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master);
if (mainPictureItem != null)
{
countryItem.CreateRelation(mainPictureItem, "MainPicture");
}
countryItem.SetString("UrlName", "TestUrlName");
countryItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
countryItem.SetValue("PublicationDate", DateTime.Now);
countryItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Draft");
dynamicModuleManager.SaveChanges();
var actualCountry = dynamicModuleManager.GetDataItem(countryType, countryItem.Id);
Assert.IsNotNull(actualCountry);
Assert.AreEqual(countryItem.GetValue("Name").ToString(), actualCountry.GetValue("Name").ToString());
Assert.AreEqual(countryItem.GetValue("Description").ToString(), actualCountry.GetValue("Description").ToString());
Assert.AreEqual(countryItem.GetValue("Location"), actualCountry.GetValue("Location"));
Assert.AreEqual(countryItem.GetValue("MainPicture"), actualCountry.GetValue("MainPicture"));
Assert.AreEqual(countryItem.GetValue("UrlName").ToString(), actualCountry.GetValue("UrlName").ToString());
Assert.AreEqual(countryItem.GetValue("Owner"), actualCountry.GetValue("Owner"));
Assert.AreEqual(countryItem.GetValue("PublicationDate"), actualCountry.GetValue("PublicationDate"));
}
private void CreateAuthor(string[] values)
{
// Set the provider name for the DynamicModuleManager here. All available providers are listed in
// Administration -> Settings -> Advanced -> DynamicModules -> Providers
var providerName = String.Empty;
string name = values[6],
bio = values[8],
jobTitle = values[7];
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
//Suppress permission checks to ensure code runs even by unauthorized users
dynamicModuleManager.Provider.SuppressSecurityChecks = true;
Type authorType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Authors.Author");
DynamicContent authorItem = dynamicModuleManager.CreateDataItem(authorType);
// This is how values for the properties are set
authorItem.SetValue("Name", name);
authorItem.SetValue("Bio", bio);
authorItem.SetValue("JobTitle", jobTitle);
LibrariesManager avatarManager = LibrariesManager.GetManager();
var avatarItem = avatarManager.GetImages().FirstOrDefault(i => i.Title == imageTitle && i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master);
if (avatarItem == null)
{
CreateImage();
avatarItem = avatarManager.GetImages().FirstOrDefault(i => i.Title == imageTitle && i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master);
}
// This is how we relate an item
authorItem.CreateRelation(avatarItem, "Avatar");
authorItem.SetString("UrlName", "SomeUrlName");
authorItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
authorItem.SetValue("PublicationDate", DateTime.Now);
authorItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Draft");
// You need to call SaveChanges() in order for the items to be actually persisted to data store
dynamicModuleManager.SaveChanges();
}
protected void submit_Click(object sender, EventArgs e)
{
// Get the fields value of the form
var title = this.TitleBox.Text;
var name = this.NameBox.Text;
var number = this.NumberBox.Text;
this.FormPanel.Visible = false;
this.TitleBox.Text = "";
this.NameBox.Text = "";
this.NumberBox.Text = "";
this.ApprovalLbl.Text = "The Form has been sent for approval";
// Create new Dynamic Item
var providerName = String.Empty;
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
Type testType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Test.Test");
DynamicContent testItem = dynamicModuleManager.CreateDataItem(testType);
// Set the values in the new Dynamic Item fields
testItem.SetValue("Title", title);
testItem.SetValue("Name", name);
testItem.SetValue("TelephoneNumber", number);
var urlName = Regex.Replace(title, @"[\\~#%&*{}/:<>?|""@ ]", "-").ToLower();
testItem.SetString("UrlName", urlName);
// FIRST Check-out the Item
dynamicModuleManager.Lifecycle.CheckOut(testItem);
// THEN Save the changes
dynamicModuleManager.SaveChanges();
// Send the Item for approval
var bag = new Dictionary <string, string>();
bag.Add("ContentType", testItem.GetType().FullName);
WorkflowManager.MessageWorkflow(testItem.Id, testItem.GetType(),
dynamicModuleManager.Provider.ToString(), "SendForApproval", false, bag);
}
public void Upload(TorrentUploaderWidgetModel torrent)
{
string torrentExtention = Path.GetExtension(torrent.TorrentFile.FileName);
string torrentTitle = Path.GetFileNameWithoutExtension(torrent.TorrentFile.FileName);
Guid torrentFileId = this._documentService.UploadTorrentFile(torrentTitle, torrent.TorrentFile.InputStream, torrent.TorrentFile.FileName, torrentExtention, TORRENT_FILE_LIBRARY);
string imageExtention = Path.GetExtension(torrent.CoverImage.FileName);
string imageTitle = Path.GetFileNameWithoutExtension(torrent.CoverImage.FileName);
Guid torrentImageId = this._imageService.Upload(imageTitle, torrent.CoverImage.InputStream, torrent.CoverImage.FileName, imageExtention, TORRENT_COVER_IMAGE_ALBUM);
// Set the provider name for the DynamicModuleManager here. All available providers are listed in
// Administration -> Settings -> Advanced -> DynamicModules -> Providers
var providerName = String.Empty;
// Set a transaction name and get the version manager
var transactionName = "someTransactionName";
var versionManager = VersionManager.GetManager(null, transactionName);
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName, transactionName);
Type torrentType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Torrents.Torrent");
DynamicContent torrentItem = dynamicModuleManager.CreateDataItem(torrentType);
// This is how values for the properties are set
torrentItem.SetValue("Title", torrent.Title);
torrentItem.SetValue("Description", torrent.Description);
LibrariesManager torrentFileManager = LibrariesManager.GetManager();
var torrentFileItem = torrentFileManager.GetDocuments().FirstOrDefault(i => i.Id == torrentFileId && i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master);
if (torrentFileItem != null)
{
torrentItem.CreateRelation(torrentFileItem, "TorrentFile");
}
LibrariesManager imageManager = LibrariesManager.GetManager();
var imageItem = imageManager.GetImages().FirstOrDefault(i => i.Id == torrentImageId && i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master);
if (imageItem != null)
{
torrentItem.CreateRelation(imageItem, "Image");
}
torrentItem.SetString("UrlName", Guid.NewGuid().ToString());
torrentItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
torrentItem.SetValue("PublicationDate", DateTime.UtcNow);
// Create a version and commit the transaction in order changes to be persisted to data store
torrentItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Draft");
// Create a version and commit the transaction in order changes to be persisted to data store
versionManager.CreateVersion(torrentItem, false);
// We can now call the following to publish the item
ILifecycleDataItem publishedTorrentItem = dynamicModuleManager.Lifecycle.Publish(torrentItem);
// You need to set appropriate workflow status
torrentItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Published");
// Create a version and commit the transaction in order changes to be persisted to data store
versionManager.CreateVersion(torrentItem, true);
TransactionManager.CommitTransaction(transactionName);
}
public string CreateSuccessStory(SuccessStoryViewModel submittedStory, string domain)
{
var message = String.Empty;
try
{
var providerName = String.Empty;
var transactionName = $"storyTransaction_{DateTime.Now}";
var versionManager = VersionManager.GetManager(null, transactionName);
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName, transactionName);
Type successStoryType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.SuccessStories.SuccessStory");
DynamicContent successStoryItem = dynamicModuleManager.CreateDataItem(successStoryType);
successStoryItem.SetValue("Title", submittedStory.Title);
successStoryItem.SetValue("Description", submittedStory.Description);
successStoryItem.SetValue("SummaryDescription", submittedStory.SummaryDescription);
successStoryItem.SetValue("ProductsUsed", submittedStory.ProductsUsed);
successStoryItem.SetValue("Company", submittedStory.Company);
successStoryItem.SetValue("CompanyWebsite", submittedStory.CompanyWebsite);
successStoryItem.SetValue("Industry", submittedStory.Industry);
LibrariesManager thumbnailManager = LibrariesManager.GetManager();
if (submittedStory.Thumbnail != null)
{
var fileStream = submittedStory.Thumbnail.InputStream;
var imgId = Guid.NewGuid();
CreateImageWithNativeAPI(imgId, submittedStory.Title, fileStream, submittedStory.Thumbnail.FileName, Path.GetExtension(submittedStory.Thumbnail.FileName));
var thumbnailItem = thumbnailManager.GetImage(imgId);
if (thumbnailItem != null)
{
successStoryItem.CreateRelation(thumbnailItem, "Thumbnail");
}
}
successStoryItem.SetString("UrlName", $"{submittedStory.Title}-{submittedStory.Company}");
successStoryItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
successStoryItem.SetValue("PublicationDate", DateTime.UtcNow);
successStoryItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Draft");
versionManager.CreateVersion(successStoryItem, false);
ILifecycleDataItem publishedCarItem = dynamicModuleManager.Lifecycle.Publish(successStoryItem);
successStoryItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Published");
versionManager.CreateVersion(successStoryItem, true);
TransactionManager.CommitTransaction(transactionName);
message = $"A new Success Story has been submitted. Take a look <a style=\"font-weight:bold;color:blue;\" href=\"{domain}/success-story-details{successStoryItem.ItemDefaultUrl.Value}\">here</a>";
}
catch (Exception ex)
{
Elmah.ErrorSignal.FromCurrentContext().Raise(ex);
}
return(message);
}
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 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 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 CreateHotel()
{
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager();
Type hotelType = TypeResolutionService.ResolveType(HierarchicalDynamicContentTests.HotelType);
DynamicContent hotelItem = dynamicModuleManager.CreateDataItem(hotelType, HierarchicalDynamicContentTests.HotelId, dynamicModuleManager.Provider.ApplicationName);
hotelItem.SetValue("Name", "Test Name");
hotelItem.SetValue("Overview", "Test Overview");
hotelItem.SetValue("Checkin", "Test Checkin");
hotelItem.SetValue("Checkout", "Test Checkout");
hotelItem.SetValue("FoodAndDrink", new string[] { "Option2" });
hotelItem.SetValue("Activities", new string[] { "Option2" });
hotelItem.SetValue("Rating", 25);
TaxonomyManager taxonomyManager = TaxonomyManager.GetManager();
var Tag = taxonomyManager.GetTaxa <FlatTaxon>().Where(t => t.Taxonomy.Name == "Tags").FirstOrDefault();
if (Tag != null)
{
hotelItem.Organizer.AddTaxa("Tags", Tag.Id);
}
Address location = new Address();
CountryElement locationCountry = Config.Get <LocationsConfig>().Countries.Values.First(x => x.Name == "United States");
location.CountryCode = locationCountry.IsoCode;
location.StateCode = locationCountry.StatesProvinces.Values.First().Abbreviation;
location.City = "Test City";
location.Street = "Test Street";
location.Zip = "12345";
location.Latitude = 0.00;
location.Longitude = 0.00;
location.MapZoomLevel = 8;
hotelItem.SetValue("Location", location);
LibrariesManager mainPictureManager = LibrariesManager.GetManager();
var mainPictureItem = mainPictureManager.GetImages().FirstOrDefault(i => i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master);
if (mainPictureItem != null)
{
hotelItem.CreateRelation(mainPictureItem, "MainPicture");
}
hotelItem.SetString("UrlName", "TestUrlName");
hotelItem.SetValue("Owner", SecurityManager.GetCurrentUserId());
hotelItem.SetValue("PublicationDate", DateTime.Now);
hotelItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Draft");
dynamicModuleManager.SaveChanges();
var actualHotel = dynamicModuleManager.GetDataItem(hotelType, hotelItem.Id);
Assert.IsNotNull(actualHotel);
Assert.AreEqual(hotelItem.GetValue("Name").ToString(), actualHotel.GetValue("Name").ToString());
Assert.AreEqual(hotelItem.GetValue("Overview").ToString(), actualHotel.GetValue("Overview").ToString());
Assert.AreEqual(hotelItem.GetValue("Checkin").ToString(), actualHotel.GetValue("Checkin").ToString());
Assert.AreEqual(hotelItem.GetValue("Checkout").ToString(), actualHotel.GetValue("Checkout").ToString());
Assert.AreEqual(hotelItem.GetValue("FoodAndDrink").ToString(), actualHotel.GetValue("FoodAndDrink").ToString());
Assert.AreEqual(hotelItem.GetValue("Activities").ToString(), actualHotel.GetValue("Activities").ToString());
Assert.AreEqual(hotelItem.GetValue("Rating"), actualHotel.GetValue("Rating"));
Assert.AreEqual(hotelItem.GetValue("MainPicture"), actualHotel.GetValue("MainPicture"));
Assert.AreEqual(hotelItem.GetValue("Location"), actualHotel.GetValue("Location"));
Assert.AreEqual(hotelItem.GetValue("UrlName").ToString(), actualHotel.GetValue("UrlName").ToString());
Assert.AreEqual(hotelItem.GetValue("Owner"), actualHotel.GetValue("Owner"));
Assert.AreEqual(hotelItem.GetValue("PublicationDate"), actualHotel.GetValue("PublicationDate"));
}
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();
}
internal static void CreatePost(SocialPost item, Taxon taxa)
{
try
{
var providerName = DynamicModuleManager.GetDefaultProviderName("Telerik.Sitefinity.DynamicTypes.Model.UserGeneratedContent.SocialPost");
// Set a transaction name and get the version manager
var transactionName = new Guid().ToString();
var versionManager = VersionManager.GetManager(null, transactionName);
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName, transactionName);
Type postType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.UserGeneratedContent.SocialPost");
var itemFilter = String.Format("NetworkUrl = \"{0}\"", item.url);
var checkItem = dynamicModuleManager.GetDataItems(postType).Where(itemFilter);
if (checkItem.Count() > 0 || item.image.IsNullOrWhitespace())
{
return;
}
dynamicModuleManager.Provider.SuppressSecurityChecks = true;
DynamicContent socialPostItem = dynamicModuleManager.CreateDataItem(postType);
// This is how values for the properties are set
//postItem.SetValue("Title", String.Format("{0}: {1}", item.User.Username, item.Id));
socialPostItem.SetValue("Title", item.image);
socialPostItem.SetValue("Text", item.text);
socialPostItem.SetValue("Network", item.network);
socialPostItem.SetValue("NetworkUrl", item.url);
socialPostItem.Organizer.AddTaxa("searchhashtags", taxa.Id);
socialPostItem.SetValue("SearchId", item.id);
socialPostItem.SetValue("SocialUser", JsonConvert.SerializeObject(item.user, Formatting.Indented));
socialPostItem.SetValue("ImageUrl", item.image);
socialPostItem.SetValue("Highlight", false);
socialPostItem.SetValue("Type", item.type);
var posted = DateTime.UtcNow;
DateTime.TryParseExact(item.posted.Replace("+00000", "").Trim(), "yyyy-MM-dd hh:mm:ss", CultureInfo.CurrentCulture, DateTimeStyles.None, out posted);
//DateTime.TryParseExact(item.posted.Replace("+00000","").Trim(), "yyyy-MM-dd hh:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out posted);
if (posted < DateTime.UtcNow.AddYears(-1))
{
posted = DateTime.UtcNow;
}
socialPostItem.SetValue("Posted", posted);
socialPostItem.SetString("UrlName", Guid.NewGuid().ToString());
socialPostItem.SetValue("PublicationDate", DateTime.UtcNow);
socialPostItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "AwaitingApproval");
// Create a version and commit the transaction in order changes to be persisted to data store
versionManager.CreateVersion(socialPostItem, false);
TransactionManager.CommitTransaction(transactionName);
dynamicModuleManager.Provider.SuppressSecurityChecks = false;
}
catch (Exception)
{
return;
}
}
public void CreateTorrentWithPublish(CreateTorrentDto createTorrentDto)
{
// Set the provider name for the DynamicModuleManager here. All available providers are listed in
// Administration -> Settings -> Advanced -> DynamicModules -> Providers
var providerName = "OpenAccessProvider";
// Set a transaction name and get the version manager
var transactionName = "someTransactionName";
var versionManager = VersionManager.GetManager(null, transactionName);
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName, transactionName);
Type torrentType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Torrents.Torrent");
DynamicContent torrentItem = dynamicModuleManager.CreateDataItem(torrentType);
// This is how values for the properties are set
torrentItem.SetValue("AdditionalInfo", createTorrentDto.AdditionalInfo);
torrentItem.SetValue("Description", createTorrentDto.Description);
torrentItem.SetValue("Title", createTorrentDto.Title);
torrentItem.SetValue("CreationDate", DateTime.Now);
List <Guid> taxonIds = _taxonomyService.GetTaxonIdsByTaxonomy(createTorrentDto.Genres, Constants.GenresTaxonomyName);
if (taxonIds.Any())
{
torrentItem.Organizer.AddTaxa(Constants.GenresTaxonomyName, taxonIds.ToArray());
}
Image imageFileItem = _imageService.CreateImageWithNativeAPI(createTorrentDto.ImageDto);
if (imageFileItem != null)
{
// This is how we relate an item
torrentItem.CreateRelation(imageFileItem, "ImageFile");
}
Document torrentFileItem = _documentService.CreateDocumentNativeAPI(createTorrentDto.DocumentDto);
if (torrentFileItem != null)
{
// This is how we relate an item
torrentItem.CreateRelation(torrentFileItem, "TorrentFile");
}
torrentItem.SetString("UrlName", $"{createTorrentDto.Title}{torrentItem.Id}");
torrentItem.SetValue("Owner", ClaimsManager.GetCurrentIdentity().UserId);
torrentItem.SetValue("PublicationDate", DateTime.UtcNow);
torrentItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Draft");
// Create a version and commit the transaction in order changes to be persisted to data store
versionManager.CreateVersion(torrentItem, false);
// We can now call the following to publish the item
ILifecycleDataItem publishedTorrentItem = dynamicModuleManager.Lifecycle.Publish(torrentItem);
// You need to set appropriate workflow status
torrentItem.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName, "Published");
// Create a version and commit the transaction in order changes to be persisted to data store
versionManager.CreateVersion(torrentItem, true);
// Now the item is published and can be seen in the page
// Commit the transaction in order for the items to be actually persisted to data store
TransactionManager.CommitTransaction(transactionName);
}
public DynamicContent Create()
{
return(dynamicModuleManager.CreateDataItem(dynamicModuleContentType));
}
