/// <summary>
/// Creates trees of view models that represents the hierarchy of the given taxa.
/// A method delegate for creating a taxon view model should be provided.
/// If the method returns null, the taxon won't be included in the tree.
/// The taxa hierarchy is traversed in a breadth-first manner so the ordering of the taxa in each level is preserved.
/// </summary>
/// <param name="taxa">The taxa.</param>
/// <param name="viewModelBuilder">A method that creates a taxon view model by given taxon.
/// If null is returned, the taxon won't be included in the tree.</param>
/// <param name="sort">The sort.</param>
/// <param name="manager">The taxonomy manager that will be used to retrieve the children.</param>
/// <param name="taxaCountLimit">The maximum number of taxa that will be included in the tree.</param>
/// <returns></returns>
public static IList<TaxonViewModel> BuildTaxaTree(
IQueryable<Taxon> taxa,
Func<ITaxon, TaxonViewModel> viewModelBuilder,
Func<IQueryable<Taxon>, IQueryable<Taxon>> sort,
TaxonomyManager manager,
int taxaCountLimit)
{
var sortedTaxa = sort.Invoke(taxa);
var trees = new List<TaxonViewModel>();
var currentTaxaCount = 0;
foreach (var taxon in sortedTaxa)
{
var subTree = TaxaViewModelTreeBuilder.BuildTaxaTreeBfs(taxon, viewModelBuilder, sort, manager, taxaCountLimit, ref currentTaxaCount);
if (subTree != null)
{
trees.Add(subTree);
}
if (taxaCountLimit > 0 && currentTaxaCount >= taxaCountLimit)
{
break;
}
}
return trees;
}
private void GetAllTaxonNamesForDataItem(List<string> taxonNames)
{
//get all tags for a data item
var taxaIds = base.DataItem.GetValue<TrackedList<Guid>>("permissions");
TaxonomyManager taxaManager = new TaxonomyManager();
foreach (var taxaId in taxaIds)
{
var taxa = taxaManager.GetTaxa<Taxon>().Where(t => t.Id == taxaId).Single();
taxonNames.Add(taxa.Name.ToLower());
}
}
private static TaxonViewModel BuildTaxaTreeBfs(
Taxon taxon,
Func<ITaxon, TaxonViewModel> viewModelBuilder,
Func<IQueryable<Taxon>, IQueryable<Taxon>> sort,
TaxonomyManager manager,
int taxaCountLimit,
ref int currentTaxaCount)
{
var queue = new Queue<TaxonData>();
TaxonViewModel rootViewModel = null;
queue.Enqueue(new TaxonData() { Taxon = taxon });
while (queue.Count > 0)
{
var currentNode = queue.Dequeue();
var currentViewModel = viewModelBuilder.Invoke(currentNode.Taxon);
if (currentViewModel != null)
{
// If this is the first created view model, set it to be the root one.
if (rootViewModel == null) rootViewModel = currentViewModel;
if (currentNode.LastKnownParent != null)
{
currentNode.LastKnownParent.SubTaxa.Add(currentViewModel);
}
currentTaxaCount++;
if (taxaCountLimit > 0 && currentTaxaCount == taxaCountLimit)
{
return rootViewModel;
}
}
// If the current taxon is included in the tree, it should be the parent of the inner taxa.
var lastKnownParent = currentViewModel ?? currentNode.LastKnownParent;
var subTaxa = manager.GetTaxa<Taxon>().Where(t => t.Parent.Id == currentNode.Taxon.Id);
var sortedSubtaxa = sort.Invoke(subTaxa);
foreach (var childTaxon in sortedSubtaxa)
{
queue.Enqueue(new TaxonData()
{
LastKnownParent = lastKnownParent,
Taxon = childTaxon
});
}
}
return rootViewModel;
}
private static void AddTaxaToProduct(ProductItem productItem, TaxonomyManager taxManager, string taxaName, string taxonName)
{
var taxon = taxManager.GetTaxa<FlatTaxon>().SingleOrDefault(t => t.Name == taxonName);
// Check if a tag with the same name is already added
var tagExists = productItem.Organizer.TaxonExists(taxaName, taxon.Id);
if (!tagExists)
{
// Add the tag and save the changes
productItem.Organizer.AddTaxa(taxaName, taxon.Id);
}
}
private static Taxon GetTagIfItExsistsOrCreateOneIfItDoesnt(string tagName, FlatTaxonomy tags, TaxonomyManager taxonomyManager)
{
Taxon tag = tags.Taxa.Where(t => t.Title.ToLower() == tagName.ToLower()).FirstOrDefault();
if (tag == null)
{
tag = taxonomyManager.CreateTaxon<FlatTaxon>();
SetTagProperties(tag, tagName);
tag.Taxonomy = tags;
taxonomyManager.SaveChanges();
}
return tag;
}
private static Taxon GetDepartmentIfItExsistsOrCreateOneIfItDoesnt(string departmentName, HierarchicalTaxonomy departments, TaxonomyManager taxonomyManager)
{
Taxon department = departments.Taxa.Where(t => t.Title.ToLower() == departmentName.ToLower()).FirstOrDefault();
if (department == null)
{
department = taxonomyManager.CreateTaxon<HierarchicalTaxon>();
SetDepartmentProperties(department, departmentName);
department.Taxonomy = departments;
taxonomyManager.SaveChanges();
}
return department;
}
private void RepublishTaxonItems(string taxonomyName, bool isFlat)
{
var taxonomyManager = TaxonomyManager.GetManager();
taxonomyManager.Provider.SuppressSecurityChecks = false;
if (isFlat)
{
var taxonomies = taxonomyManager.GetTaxa <FlatTaxon>().Where(t => t.Taxonomy.Name == taxonomyName).ToList();
var count = 0;
foreach (var taxonomy in taxonomies)
{
taxonomy.Title = taxonomy.Title.Trim();
count++;
if (count % 200 == 0)
{
taxonomyManager.SaveChanges();
}
}
taxonomyManager.SaveChanges();
taxonomyManager.Provider.SuppressSecurityChecks = true;
}
else
{
var taxonomies = taxonomyManager.GetTaxa <HierarchicalTaxon>().Where(t => t.Taxonomy.Name == taxonomyName).ToList();
var count = 0;
foreach (var taxonomy in taxonomies)
{
taxonomy.Title = taxonomy.Title.Trim();
count++;
if (count % 200 == 0)
{
taxonomyManager.SaveChanges();
}
}
taxonomyManager.SaveChanges();
taxonomyManager.Provider.SuppressSecurityChecks = true;
}
}
protected void NewsExport_Click(object sender, EventArgs e)
{
StringBuilder newsItems = new StringBuilder();
NewsManager man = NewsManager.GetManager();
var tagString = string.Empty;
List <string> tags = null;
TaxonomyManager tMan = TaxonomyManager.GetManager();
foreach (var newsItem in man.GetNewsItems().Where(i => i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master))
{
tags = newsItem.GetValue <TrackedList <Guid> >("Tags").ToList().Select(i => tMan.GetTaxon(i).Title.Value).ToList();
newsItems.AppendLine(String.Format("{0}|{1}|{2}", newsItem.Title, String.Join(",", tags), newsItem.Content.Value.Replace("\n", "")));
}
var file = new StreamWriter(ServerPath + "\\news.txt");
file.Write(newsItems);
file.Close();
}
public void NewsWidget_SelectByTagNewsFunctionalityAndNoLimit()
{
var newsController = new NewsController();
newsController.Model.DisplayMode = ListDisplayMode.All;
newsController.Model.ItemsPerPage = 1;
string tagTitle = "Tag1";
string newsTitle = "News ";
try
{
Guid taxonId = this.serverOperationsTaxonomies.CreateFlatTaxon(Telerik.Sitefinity.TestUtilities.CommonOperations.TaxonomiesConstants.TagsTaxonomyId, tagTitle);
Guid newsId0 = this.serverOperationsNews.CreatePublishedNewsItem(newsTitle + 0);
this.serverOperationsNews.AssignTaxonToNewsItem(newsId0, "Tags", taxonId);
Guid newsId1 = this.serverOperationsNews.CreatePublishedNewsItem(newsTitle + 1);
this.serverOperationsNews.AssignTaxonToNewsItem(newsId1, "Tags", taxonId);
this.serverOperationsNews.CreatePublishedNewsItem(newsTitle + 2);
ITaxon tagTaxonomy = TaxonomyManager.GetManager().GetTaxon(taxonId);
var items = newsController.Model.CreateListViewModel(tagTaxonomy, 1).Items.ToArray();
Assert.IsTrue(items.Length.Equals(2), "The count of news items is not correct - no limit");
Assert.IsTrue(items[0].Fields.Title.Equals(newsTitle + 1, StringComparison.CurrentCulture), "The news with this title was found!");
Assert.IsTrue(items[1].Fields.Title.Equals(newsTitle + 0, StringComparison.CurrentCulture), "The news with this title was found!");
newsController.Model.DisplayMode = ListDisplayMode.Paging;
newsController.Model.ItemsPerPage = 20;
items = newsController.Model.CreateListViewModel(null, 1).Items.ToArray();
Assert.IsTrue(items.Length.Equals(3), "The count of news items is not correct - all items");
Assert.IsTrue(items[0].Fields.Title.Equals(newsTitle + 2, StringComparison.CurrentCulture), "The news with this title was found!");
Assert.IsTrue(items[1].Fields.Title.Equals(newsTitle + 1, StringComparison.CurrentCulture), "The news with this title was found!");
Assert.IsTrue(items[2].Fields.Title.Equals(newsTitle + 0, StringComparison.CurrentCulture), "The news with this title was found!");
}
finally
{
this.serverOperationsTaxonomies.DeleteTags(tagTitle);
}
}
public void CreateFields()
{
Web web = ClientContext.Web;
FieldCollection webFieldCollection = web.Fields;
ClientContext.Load(webFieldCollection);
ClientContext.ExecuteQuery();
var termStoreId = new TaxonomyManager(null).GetTermStoreId(ClientContext);
foreach (ShField field in Fields)
{
var existingField = webFieldCollection.SingleOrDefault(item => item.InternalName == field.InternalName);
if (existingField == null)
{
//Creating new field
Log.Debug("Attempting to create field " + field.DisplayName);
if (field.Type.StartsWith("TaxonomyFieldType"))
{
field.SspId = termStoreId;
DeleteHiddenFieldForTaxonomyField(webFieldCollection, field.ID);
CreateTaxonomyField(field, webFieldCollection);
}
else
{
CreateField(field, webFieldCollection);
}
}
else
{
Log.DebugFormat("Field '{0}' exists, checking for changes to field", field.DisplayName);
//Updating existing field
if (field.Type.StartsWith("TaxonomyFieldType"))
{
UpdateTaxonomyField(field, existingField);
}
else
{
UpdateExistingField(field, existingField);
}
}
}
}
public static String GetCategoryTitle(Object _cats)
{
Telerik.OpenAccess.TrackedList <System.Guid> cats = (Telerik.OpenAccess.TrackedList <System.Guid>)_cats;
string[] ignoreCats = new string[]
{
"Chartered Accountants Ireland",
"Accountancy Ireland",
"RTP News",
"CPD",
"Public Sector",
"enews",
"Education",
"Overseas Member",
"RTP",
"RTPeNews",
"Student News",
"Tax Representations"
};
if (cats.Count == 0)
{
return("");
}
var foundTaxon = "";
for (var i = 0; i < cats.Count; i++)
{
Guid firstCat = cats[i];
var taxonomyManager = TaxonomyManager.GetManager();
var taxon = taxonomyManager.GetTaxa <HierarchicalTaxon>().Where(t => t.Id.Equals(firstCat)).SingleOrDefault();
if (taxon != null && !ignoreCats.Contains(taxon.Title.ToString()))
{
foundTaxon = taxon.Title;
break;
}
}
return(foundTaxon);
}
private void CreateLocation(LocationsManager mgr, string Title, string Address, string City, string Region, string PostalCode, string Country, string Continent)
{
var location = mgr.CreateLocation();
location.Title = Title;
location.Address = Address;
location.City = City;
location.Region = Region;
location.PostalCode = PostalCode;
location.Country = Country;
location.Content = Content;
location.UrlName = Title.ToLower().Replace(" ", "-");
// add taxonomy and save
var taxonomyMgr = TaxonomyManager.GetManager();
var taxon = taxonomyMgr.GetTaxa <HierarchicalTaxon>().Where(t => t.Name == Continent).Select(t => t.Id).ToArray();
location.Organizer.AddTaxa("Category", taxon);
mgr.RecompileItemUrls <LocationItem>(location);
}
private IEnumerable <Classification> MapClassificationData(TrackedList <Guid> classifications)
{
var classificationData = new List <Classification>();
TaxonomyManager taxonomyManager = TaxonomyManager.GetManager();
if (classifications != null)
{
foreach (var cat in classifications)
{
classificationData.Add(new Classification
{
Id = taxonomyManager.GetTaxon(cat).Id,
Title = taxonomyManager.GetTaxon(cat).Title,
Url = taxonomyManager.GetTaxon(cat).UrlName
});
}
}
return(classificationData);
}
public virtual IList <FlatTaxon> GetFlatTaxons(string fieldName)
{
var cahcedResultKey = this.FieldCacheKey("GetFlatTaxonNames", fieldName);
object cachedResult;
if (this.cachedFieldValues.TryGetValue(cahcedResultKey, out cachedResult))
{
return(cachedResult as IList <FlatTaxon>);
}
var taxonIds = this.Fields.GetMemberValue(fieldName) as IList <Guid>;
TaxonomyManager manager = TaxonomyManager.GetManager();
var taxonNames = manager.GetTaxa <FlatTaxon>()
.Where(t => taxonIds.Contains(t.Id) && t.Taxonomy.Name == fieldName).ToList();
this.cachedFieldValues[cahcedResultKey] = taxonNames;
return(taxonNames);
}
public void NewsWidget_SelectByCategoryNewsFunctionality()
{
int newsCount = 4;
string newsTitle = "Title";
string categoryTitle = "Category ";
var newsController = new NewsController();
string[] categoryTitles = new string[newsCount + 1];
try
{
this.serverOperationsTaxonomies.CreateCategory(categoryTitle + "0");
for (int i = 0; i <= newsCount; i++)
{
categoryTitles[i] = categoryTitle + i;
this.serverOperationsTaxonomies.CreateCategory(categoryTitle + (i + 1), categoryTitle + i);
ServerOperationsFeather.NewsOperations().CreatePublishedNewsItem(NewsTitle + i, "Content", "AuthorName", "SourceName", new List <string> {
categoryTitle + i
}, null, null);
}
TaxonomyManager taxonomyManager = TaxonomyManager.GetManager();
for (int i = 0; i < newsCount; i++)
{
var category = taxonomyManager.GetTaxa <HierarchicalTaxon>().SingleOrDefault(t => t.Title == categoryTitle + i);
ITaxon taxonomy = taxonomyManager.GetTaxon(category.Id);
var items = newsController.Model.CreateListViewModel(taxonomy, 1).Items.ToArray();
for (int j = 0; j < items.Length; j++)
{
Assert.IsTrue(items[j].Fields.Title.Equals(newsTitle + i, StringComparison.CurrentCulture), "The news with this title was not found!");
}
}
}
finally
{
this.serverOperationsTaxonomies.DeleteCategories(categoryTitles);
}
}
private void AssignTaxonomiesToImages(List <Guid> listOfIds)
{
ServerOperations.Taxonomies().CreateCategory(CategoryTitle + "0");
var taxonomyManager = TaxonomyManager.GetManager();
for (int i = 1; i < 5; i++)
{
ServerOperations.Taxonomies().CreateCategory(CategoryTitle + i, CategoryTitle + (i - 1));
var category = taxonomyManager.GetTaxa <HierarchicalTaxon>().Single(t => t.Title == CategoryTitle + i);
ServerOperations.Taxonomies().CreateTag(TagTitle + i);
var tag = taxonomyManager.GetTaxa <FlatTaxon>().Single(t => t.Title == TagTitle + i);
ServerOperations.Documents().AssignTaxonToDocument(listOfIds[i - 1], "Category", category.Id);
ServerOperations.Documents().AssignTaxonToDocument(listOfIds[i - 1], "Tags", tag.Id);
}
var category3 = taxonomyManager.GetTaxa <HierarchicalTaxon>().Single(t => t.Title == CategoryTitle + 3);
var tag3 = taxonomyManager.GetTaxa <FlatTaxon>().Single(t => t.Title == TagTitle + 3);
ServerOperations.Documents().AssignTaxonToDocument(listOfIds[0], "Category", category3.Id);
ServerOperations.Documents().AssignTaxonToDocument(listOfIds[0], "Tags", tag3.Id);
}
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);
}
private void migrateTags(Entry post, BlogPost blogPost, BlogsManager blogsManager)
{
TaxonomyManager taxonomyManager = new TaxonomyManager();
var tax = taxonomyManager.GetTaxonomies<FlatTaxonomy>().Where(t => t.Name == "Tags").SingleOrDefault();
foreach (Category tag in post.Categories.Where(c => c.CategoryType == CategoryType.Unknown))
{
var taxon = taxonomyManager.GetTaxa<FlatTaxon>().Where(t => t.Title == tag.Term).FirstOrDefault();
if (taxon == null)
{
taxon = taxonomyManager.CreateTaxon<FlatTaxon>();
taxon.Name = tag.Term;
taxon.Title = tag.Term;
tax.Taxa.Add(taxon);
taxonomyManager.SaveChanges();
}
blogPost.Organizer.AddTaxa("Tags", taxon.Id);
blogsManager.SaveChanges();
}
}
public void Categories_VerifyTaxaFromContentItemIsRetrieved()
{
var item = NewsManager.GetManager().GetNewsItems().FirstOrDefault();
var model = new HierarchicalTaxonomyModel();
model.ContentId = item.Id;
var viewModel = model.CreateViewModel();
var itemTaxa = (IList <Guid>)item.GetValue("Category");
Assert.AreEqual(itemTaxa.Count, viewModel.Taxa.Count);
var taxonomyManager = TaxonomyManager.GetManager();
for (var i = 0; i < itemTaxa.Count; i++)
{
var taxon = taxonomyManager.GetTaxa <HierarchicalTaxon>().FirstOrDefault(t => t.Id == itemTaxa[i]);
Assert.AreEqual(taxon.Title.ToString(), viewModel.Taxa[i].Title);
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="sfContent">The sf content.</param>
public DepartmentModel(HierarchicalTaxon sfContent)
{
var manager = TaxonomyManager.GetManager();
Id = sfContent.Id;
Title = sfContent.Title;
Description = sfContent.Description;
FullUrl = sfContent.FullUrl;
Ordinal = sfContent.Ordinal;
RenderAsLink = sfContent.RenderAsLink;
ShowInNavigation = sfContent.ShowInNavigation;
TaxonName = sfContent.Taxonomy.TaxonName;
Slug = sfContent.UrlName;
LastModified = sfContent.LastModified;
//STORE PARENT DETAILS IF APPLICABLE
if (sfContent.Parent != null)
{
Parent = new ParentModel
{
Id = sfContent.Parent.Id,
Title = sfContent.Parent.Title,
Description = sfContent.Parent.Description,
Ordinal = sfContent.Parent.Ordinal,
Slug = sfContent.Parent.UrlName
};
}
//BUILD CHILDREN CATEGORIES
Subtaxa = new List <DepartmentModel>();
sfContent.Subtaxa.ToList().ForEach(c =>
Subtaxa.Add(new DepartmentModel(c)));
//GET NUMBER OF ITEMS IN CATEGORY
Count = (int)manager.GetTaxonItemsCount(sfContent.Id, ContentLifecycleStatus.Live);
// Store original content
OriginalContent = sfContent;
}
public void CreateProduct()
{
ProductsManager productsManager = ProductsManager.GetManager();
var productItem = productsManager.CreateProduct(ProductsIntegrationTests.productItemId);
productItem.Title = "Test Product";
productItem.Content = "<h1>Simple content goes here ...</h1>";
var taxManager = TaxonomyManager.GetManager();
AddTaxaToProduct(productItem, taxManager, "Colors", ProductsIntegrationTests.colorName);
productItem.WhatIsInTheBox = "Summary goes here...";
productItem.QuantityInStock = 1;
productItem.Price = 10;
AddImageToProductItem(productItem);
productsManager.SaveChanges();
var contextBag = new Dictionary <string, string>();
contextBag.Add("ContentType", productItem.GetType().FullName);
string workflowOperation = "Publish";
WorkflowManager.MessageWorkflow(
productItem.Id,
productItem.GetType(),
"OpenAccessDataProvider",
workflowOperation,
false,
contextBag);
var product = productsManager.GetProduct(ProductsIntegrationTests.productItemId);
Assert.IsNotNull(product);
Assert.IsNotNull(product.GetValue("Colors"));
}
/// <summary>
/// Gets the taxons.
/// </summary>
/// <param name="content">The content.</param>
/// <param name="taxonomyField">The taxonomy field.</param>
/// <returns>
/// The taxa.
/// </returns>
public static List <TaxonModel> GetTaxa(this IDynamicFieldsContainer content, string taxonomyField)
{
var taxonomyManager = TaxonomyManager.GetManager();
var list = new List <TaxonModel>();
//POPULATE CATEGORIES IF APPLICABLE
if (content.DoesFieldExist(taxonomyField))
{
var ids = content.GetValue <TrackedList <Guid> >(taxonomyField);
if (ids.Any())
{
//BUILD COLLECTION OF TAXONS
foreach (Guid item in ids)
{
list.Add(new TaxonModel(taxonomyManager.GetTaxon(item)));
}
}
}
//RETURN CONSTRUCTED LIST
return(list);
}
/// <summary>
/// Gets the or create template category identifier.
/// </summary>
/// <param name="templateCategoryName">The template category name.</param>
/// <param name="createIfNotExist">if set to <c>true</c> [create if not exist].</param>
/// <returns>The id of the category.</returns>
public virtual Guid GetOrCreateTemplateCategoryId(string templateCategoryName, bool createIfNotExist = true)
{
var taxonomyManager = TaxonomyManager.GetManager();
var pageTemplatesTaxonomy = taxonomyManager.GetTaxonomy <HierarchicalTaxonomy>(SiteInitializer.PageTemplatesTaxonomyId);
var templateCategory = pageTemplatesTaxonomy.Taxa.SingleOrDefault(t => t.Name.Equals(templateCategoryName, StringComparison.OrdinalIgnoreCase));
if (templateCategory == null && createIfNotExist)
{
templateCategory = taxonomyManager.CreateTaxon <HierarchicalTaxon>();
templateCategory.Name = templateCategoryName;
templateCategory.UrlName = templateCategoryName;
templateCategory.RenderAsLink = false;
templateCategory.Title = templateCategoryName;
templateCategory.Description = string.Format("Represents category for {0} page templates.", templateCategoryName);
pageTemplatesTaxonomy.Taxa.Add(templateCategory);
taxonomyManager.SaveChanges();
}
return(templateCategory.Id);
}
private void migrateTags(Entry post, BlogPost blogPost, BlogsManager blogsManager)
{
TaxonomyManager taxonomyManager = new TaxonomyManager();
var tax = taxonomyManager.GetTaxonomies <FlatTaxonomy>().Where(t => t.Name == "Tags").SingleOrDefault();
foreach (Category tag in post.Categories.Where(c => c.CategoryType == CategoryType.Unknown))
{
var taxon = taxonomyManager.GetTaxa <FlatTaxon>().Where(t => t.Title == tag.Term).FirstOrDefault();
if (taxon == null)
{
taxon = taxonomyManager.CreateTaxon <FlatTaxon>();
taxon.Name = tag.Term;
taxon.Title = tag.Term;
tax.Taxa.Add(taxon);
taxonomyManager.SaveChanges();
}
blogPost.Organizer.AddTaxa("Tags", taxon.Id);
blogsManager.SaveChanges();
}
}
public ActionResult Index()
{
List <PopularToursItemModel> popularToursItemModel = new List <PopularToursItemModel>();
var manager = DynamicModuleManager.GetManager();
Type Tour = TypeResolutionService.ResolveType(DynamicContentConstants.DynamicContent.Types.Tour);
TaxonomyManager taxaManager = TaxonomyManager.GetManager();
var adventuresTaxa = taxaManager.GetTaxa <FlatTaxon>().Where(t => t.Taxonomy.Name == DynamicContentConstants.DynamicContent.Tours.Adventures).ToList();
var difficultiesTaxa = taxaManager.GetTaxa <FlatTaxon>().Where(t => t.Taxonomy.Name == DynamicContentConstants.DynamicContent.Tours.Difficulties).ToList();
//get the selected items
var items = manager.GetDataItems(Tour).Where(item => item.Status == ContentLifecycleStatus.Live && item.Visible).ToList();
foreach (var item in items)
{
var image = item.GetRelatedItems(DynamicContentConstants.DynamicContent.Tours.ThumbnailImage).FirstOrDefault() as Image;
var adventureTaxaTitles = item.GetAssociatedTagNamesForContentItem(DynamicContentConstants.DynamicContent.Tours.Adventures, adventuresTaxa);
var difficultyTaxaTitles = item.GetAssociatedTagNamesForContentItem(DynamicContentConstants.DynamicContent.Tours.Difficulties, difficultiesTaxa);
var accomodationChoiceFields = item.GetValue <IEnumerable <ChoiceOption> >(DynamicContentConstants.DynamicContent.Tours.Accomodation).ToList();
var model = new PopularToursItemModel
{
Title = item.GetString(DynamicContentConstants.DynamicContent.Tours.Title),
Description = item.GetString(DynamicContentConstants.DynamicContent.Tours.Description),
NoOfDays = Convert.ToString(item.GetValue(DynamicContentConstants.DynamicContent.Tours.NoOfDays)),
SizeOfTour = Convert.ToString(item.GetValue(DynamicContentConstants.DynamicContent.Tours.SizeOfTour)),
NoOfTourGuides = Convert.ToString(item.GetValue(DynamicContentConstants.DynamicContent.Tours.NoOfTourGuides)),
Price = Convert.ToString(item.GetValue(DynamicContentConstants.DynamicContent.Tours.Price)),
AdventureTags = adventureTaxaTitles.Any() ? string.Join(",", adventureTaxaTitles) : string.Empty,
DifficultyTags = difficultyTaxaTitles.Any() ? string.Join(",", difficultyTaxaTitles) : string.Empty,
Accomodation = accomodationChoiceFields.Any() ? string.Join(",", accomodationChoiceFields) : string.Empty,
ImageUrl = image != null ? image.MediaUrl : string.Empty
};
popularToursItemModel.Add(model);
}
model.toursItemModel = popularToursItemModel;
return(View("Tours" + this._template, model));
}
public void NewsWidget_SelectByTagNewsFunctionality()
{
int newsCount = 2;
Guid[] taxonId = new Guid[newsCount];
Guid[] newsId = new Guid[newsCount];
string newsTitle = "News ";
string tagTitle = "Tag ";
var newsController = new NewsController();
string[] tagTitles = new string[newsCount];
try
{
for (int i = 0; i < newsCount; i++)
{
taxonId[i] = this.serverOperationsTaxonomies.CreateFlatTaxon(Telerik.Sitefinity.TestUtilities.CommonOperations.TaxonomiesConstants.TagsTaxonomyId, tagTitle + i);
tagTitles[i] = tagTitle + i;
newsId[i] = this.serverOperationsNews.CreatePublishedNewsItem(newsTitle + i);
this.serverOperationsNews.AssignTaxonToNewsItem(newsId[i], "Tags", taxonId[i]);
}
for (int i = 0; i < newsCount; i++)
{
ITaxon taxonomy = TaxonomyManager.GetManager().GetTaxon(taxonId[i]);
var items = newsController.Model.CreateListViewModel(taxonomy, 1).Items.ToArray();
for (int j = 0; j < items.Length; j++)
{
Assert.IsTrue(items[j].Fields.Title.Equals(newsTitle + i, StringComparison.CurrentCulture), "The news with this title was not found!");
}
}
}
finally
{
this.serverOperationsTaxonomies.DeleteTags(tagTitles);
}
}
/// <summary>
/// Creates news item with tag.
/// </summary>
/// <param name="newsTitle">The news title.</param>
public void AddCustomTaxonomyToNews(Guid newsItemId, string taxonomyName, IEnumerable <string> taxonNames)
{
var newsManager = Telerik.Sitefinity.Modules.News.NewsManager.GetManager();
NewsItem newsItem = newsManager.GetNewsItem(newsItemId);
if (newsItem == null)
{
throw new ItemNotFoundException(string.Format(CultureInfo.CurrentCulture, "News item with id {0} was not found.", newsItemId));
}
TaxonomyManager taxonomyManager = TaxonomyManager.GetManager();
foreach (var taxonName in taxonNames)
{
var taxon = taxonomyManager.GetTaxa <FlatTaxon>().Where(t => t.Title == taxonName).FirstOrDefault();
if (taxon != null)
{
newsItem.Organizer.AddTaxa(taxonomyName, taxon.Id);
}
}
newsManager.SaveChanges();
}
public static IQueryable <DynamicContent> GetContentByFlatTaxonomyTerm(String contentType, String term, String fieldName)
{
var providerName = String.Empty;
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
Type resourceType = TypeResolutionService.ResolveType(contentType);
// This is how we get the resource items through filtering
var manager = TaxonomyManager.GetManager();
//Get the GUID of the desired category
var category = manager.GetTaxa <FlatTaxon>().Where(t => t.Name.ToLower() == term).SingleOrDefault();
if (category == null)
{
throw new InvalidProgramException("No category found");
}
var categoryId = category.Id;
return(dynamicModuleManager.GetDataItems(resourceType)
.Where(d => d.GetValue <TrackedList <Guid> >(fieldName).Contains(categoryId) &&
d.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Live));
}
public void SetUp()
{
Guid pageId = ServerOperations.Pages().CreatePage(PageName);
ServerOperationsFeather.DynamicModules().EnsureModuleIsImported(ModuleName, ModuleResource);
ServerOperations.Taxonomies().CreateCategory(this.taxonTitleDynamic + "0");
ServerOperations.Taxonomies().CreateCategory(this.taxonTitleNews + "0");
for (int i = 1; i < 4; i++)
{
ServerOperations.Taxonomies().CreateCategory(this.taxonTitleDynamic + i, this.taxonTitleDynamic + (i - 1));
ServerOperations.Taxonomies().CreateCategory(this.taxonTitleNews + i, this.taxonTitleNews + (i - 1));
var category = TaxonomyManager.GetManager().GetTaxa <HierarchicalTaxon>().SingleOrDefault(t => t.Title == this.taxonTitleDynamic + i);
ServerOperationsFeather.DynamicModulePressArticle().CreatePressArticle(ItemsTitle + (i - 1), ItemsTitle + i + "Url", Guid.Empty, category.Id);
ServerOperationsFeather.NewsOperations().CreatePublishedNewsItem(NewsTitle + i, NewsContent, AuthorName, SourceName, new List <string> {
this.taxonTitleNews + i
}, null, null);
}
ServerOperationsFeather.Pages().AddDynamicWidgetToPage(pageId, "Telerik.Sitefinity.DynamicTypes.Model.PressRelease.PressArticle", "PressArticle", "Press Articles MVC");
ServerOperationsFeather.Pages().AddNewsWidgetToPage(pageId);
ServerOperationsFeather.Pages().AddCategoriesWidgetToPage(pageId);
}
public void EditTag(string oldTitle, string newTitle)
{
var manager = TaxonomyManager.GetManager();
var tag = manager.GetTaxonomies <FlatTaxonomy>().Where(t => t.Name == "Tags").SingleOrDefault();
if (tag != null)
{
FlatTaxon taxon = manager.GetTaxa <FlatTaxon>().Where(t => t.Title == oldTitle).SingleOrDefault();
if (taxon != null)
{
//// Code below is commented, because code below is not editing the title, which is relevant for UI tests
taxon.Title = newTitle;
//// taxon.Title = new Lstring(newTitle, CultureInfo.InvariantCulture);
//// taxon.Name = Regex.Replace(newTitle, " ", string.Empty);
taxon.UrlName = Regex.Replace(newTitle.ToLower(CultureInfo.CurrentCulture), ArrangementConstants.UrlNameCharsToReplace, ArrangementConstants.UrlNameReplaceString);
taxon.Taxonomy = tag;
manager.SaveChanges();
}
}
}
private List <BlendedListItem> GetNewsBlendedForUrl(List <Type> dynamicContent, string url)
{
List <BlendedListItem> newsBlend = new List <BlendedListItem>();
if (dynamicContent.Any())
{
var dynamicModuleManager = DynamicModuleManager.GetManager();
var taxonomyManager = TaxonomyManager.GetManager();
log.Info("contYpe:{0}".Fmt(dynamicContent.Count));
foreach (Type contentType in dynamicContent)
{
log.Info("type of:{0} with url{1}".Fmt(contentType, url));
DynamicContent content = dynamicModuleManager.GetDataItems(contentType).FirstOrDefault(bp => bp.UrlName == url);
if (content != null)
{
log.Info("dyn content url is:{0} from {1}".Fmt(content.UrlName, url));
DynamicContent liveContent = dynamicModuleManager.Lifecycle.GetLive(content) as DynamicContent;
if (liveContent != null)
{
List <Guid> categories = liveContent.GetValue <IList <Guid> >("Category").ToList();
Guid[] contentCategories = new Guid[0];
int hitCount = 0;
contentCategories =
categories.Where(c => taxonomyManager.GetTaxon <HierarchicalTaxon>(c) != null)
.Select(m => m)
.ToArray();
//var resultContent = BlendedNewsHelper.GetNewsItems(Providers, _searchIndex, out hitCount, contentCategories, null, 0, this.NumberOfPosts + 10);
var resultContent = BlendedNewsHelper.GetNewsDocs(Providers, _searchIndex, out hitCount, contentCategories, null, 0, this.NumberOfPosts + 10);
List <BlendedListItem> newsResult = SetBlendedListItems(resultContent);
return(newsResult);
}
}
}
}
return(newsBlend);
}
public void CreateSiteColumns()
{
Web web = ClientContext.Web;
FieldCollection webFieldCollection = web.Fields;
ClientContext.Load(webFieldCollection);
ClientContext.ExecuteQuery();
var termStoreId = new TaxonomyManager(null).GetTermStoreId(ClientContext);
foreach (GtField field in Fields.Where(field => !webFieldCollection.Any(item => item.InternalName == field.InternalName)))
{
if (field.Type.StartsWith("TaxonomyFieldType"))
{
field.SspId = termStoreId;
DeleteHiddenFieldForTaxonomyField(webFieldCollection, field.ID);
CreateTaxonomyField(field, webFieldCollection);
}
else
{
CreateField(field, webFieldCollection);
}
}
}
public static string GetTaxonomyNameFromID(long taxID)
{
//CustomPropertyObjectData customData = customObject.GetItem(taxID, 1033, EkEnumeration.CustomPropertyObjectType.TaxonomyNode, 1);
//if (customData.Items.Count > 0)
//{
// return customData.Items[0].PropertyValue.ToString();
//}
//else
//{
string taxName = string.Empty;
TaxonomyManager taxonomyManager = new TaxonomyManager();
TaxonomyData taxonomyData = taxonomyManager.GetItem(taxID);
if (taxonomyData != null)
{
taxName = taxonomyData.Name;
}
return taxName;
// }
}
//***********Helper Methods***********//
//************************************//
//************************************//
#region SetBlendedListItems
private List <BlendedListItem> SetBlendedListItems(IResultSet results)
{
log.Info("Begin SetBlendedListItems.");
var resultSet = new List <BlendedListItem>();
var taxonomyManager = TaxonomyManager.GetManager();
log.Debug("Iterating through the results.");
foreach (IDocument result in results)
{
log.Trace("Getting a new instance of BlendedListItem.");
var newsResult = new BlendedListItem();
log.Trace(() => String.Join("\n", result.Fields.Select(f => f.Name + ": " + f.Value)));
if (result.Fields.Any(x => x.Name == "Title"))
{
newsResult.Title = result.GetValue("Title").ToString();
log.Trace("Title Set.");
}
if (result.Fields.Any(x => x.Name == "LocationStreet"))
{
newsResult.LocationStreet = result.GetValue("LocationStreet").ToString();
log.Trace("LocationStreet Set.");
}
if (result.Fields.Any(x => x.Name == "LocationState"))
{
newsResult.LocationState = result.GetValue("LocationState").ToString();
log.Trace("LocationState Set.");
}
if (result.Fields.Any(x => x.Name == "LocationCity"))
{
newsResult.LocationCity = result.GetValue("LocationCity").ToString();
log.Trace("LocationCity Set.");
}
if (result.Fields.Any(x => x.Name == "Summary"))
{
newsResult.Summary = result.GetValue("Summary").ToString();
log.Trace("Summary Set.");
}
if (result.Fields.Any(x => x.Name == "Content"))
{
newsResult.Content = result.GetValue("Content").ToString();
log.Trace("Content Set.");
}
var featured = result.GetValue("FeaturedRank").ToString() == "1" ? true : false;
newsResult.Featured = featured;
if (result.Fields.Any(x => x.Name == "Link"))
{
newsResult.Link = result.GetValue("Link").ToString();
log.Trace("Link Set.");
}
if (result.Fields.Any(x => x.Name == "EventStart"))
{
try
{
DateTime dp = DateTime.MinValue;
//newsResult.EventStartDate = DateTime.ParseExact(result.GetValue("EventStart").ToString(), "MM/dd/yyyy HH:mm:ss", CultureInfo.InvariantCulture);
DateTime.TryParseExact(result.GetValue("EventStart").ToString(), "MM/dd/yyyy HH:mm:ss", new CultureInfo("en-US"), DateTimeStyles.None, out dp);
newsResult.EventStartDate = dp;
//log.Trace("EventStart Set.");
}
catch (Exception ex)
{
log.Error("Source: {0}", ex.Source);
log.Error("Stack Trace: {0}", ex.StackTrace);
log.Error("Message: {0}", ex.Message);
}
}
if (result.Fields.Any(x => x.Name == "EventEnd"))
{
try
{
/*newsResult.EventEndDate = DateTime.ParseExact(result.GetValue("EventStart").ToString(), "MM/dd/yyyy HH:mm:ss", CultureInfo.InvariantCulture);
* log.Trace("EventStart Set.");*/
DateTime dp = DateTime.MinValue;
DateTime.TryParseExact(result.GetValue("EventEnd").ToString(), "MM/dd/yyyy HH:mm:ss", new CultureInfo("en-US"), DateTimeStyles.None, out dp);
newsResult.EventEndDate = dp;
}
catch (Exception ex)
{
log.Error("Source: {0}", ex.Source);
log.Error("Stack Trace: {0}", ex.StackTrace);
log.Error("Message: {0}", ex.Message);
}
}
if (result.Fields.Any(x => x.Name == "PublishDate"))
{
try
{
/*newsResult.PublicationDate = DateTime.ParseExact(result.GetValue("PublishDate").ToString(), "MM/dd/yyyy HH:mm:ss", CultureInfo.InvariantCulture);
* log.Trace("PublishDate Set.");*/
DateTime dp = DateTime.MinValue;
DateTime.TryParseExact(result.GetValue("PublishDate").ToString(), "MM/dd/yyyy HH:mm:ss", new CultureInfo("en-US"), DateTimeStyles.None, out dp);
newsResult.PublicationDate = dp;
}
catch (Exception ex)
{
log.Error("Source: {0}", ex.Source);
log.Error("Stack Trace: {0}", ex.StackTrace);
log.Error("Message: {0}", ex.Message);
}
}
if (result.Fields.Any(x => x.Name == "CategoryIds"))
{
newsResult.Categories = new List <CategoryPair>();
var categoryIds = result.GetValue("CategoryIds").ToString().Split(',').ToList();
foreach (var categoryItem in categoryIds)
{
try
{
if (!categoryItem.IsNullOrWhitespace())
{
var categoryPair = new CategoryPair();
if (categoryItem.IsGuid())
{
categoryPair.Guid = categoryItem;
var taxon = taxonomyManager.GetTaxon(Guid.Parse(categoryItem));
categoryPair.Name = taxon.Title.Value;
newsResult.Categories.Add(categoryPair);
}
}
}
catch (Exception ex)
{
log.Error("Source: {0}", ex.Source);
log.Error("Stack Trace: {0}", ex.StackTrace);
log.Error("Message: {0}", ex.Message);
}
}
//newsResult.Categories = result.GetValue("CategoryList").ToString().Split(',').Select(x => x.Trim()).ToList();
//log.Trace("CategoryList Set.");
}
if (result.Fields.Any(x => x.Name == "ResourceTypesIds"))
{
newsResult.ResourceTypes = new List <CategoryPair>();
var resourceTypesIds = result.GetValue("ResourceTypesIds").ToString().Split(',').ToList();
foreach (var resourceTypeItem in resourceTypesIds)
{
try
{
if (!resourceTypeItem.IsNullOrWhitespace())
{
var categoryPair = new CategoryPair();
if (resourceTypeItem.IsGuid())
{
categoryPair.Guid = resourceTypeItem;
var taxon = taxonomyManager.GetTaxon(Guid.Parse(resourceTypeItem));
categoryPair.Name = taxon.Title.Value;
newsResult.Categories.Add(categoryPair);
}
}
}
catch (Exception ex)
{
log.Error("Source: {0}", ex.Source);
log.Error("Stack Trace: {0}", ex.StackTrace);
log.Error("Message: {0}", ex.Message);
}
}
//newsResult.ResourceTypes = result.GetValue("ResourceTypesList").ToString().Split(',').Select(x => x.Trim()).ToList();
//log.Trace("ResourceTypesList Set.");
}
if (result.Fields.Any(x => x.Name == "OrganizationalAuthorsIds"))
{
newsResult.OrganizationalAuthors = new List <CategoryPair>();
var organizationalAuthorIds = result.GetValue("OrganizationalAuthorsIds").ToString().Split(',').ToList();
foreach (var organizationalAuthorItem in organizationalAuthorIds)
{
try
{
if (!organizationalAuthorItem.IsNullOrWhitespace())
{
var categoryPair = new CategoryPair();
if (organizationalAuthorItem.IsGuid())
{
categoryPair.Guid = organizationalAuthorItem;
var taxon = taxonomyManager.GetTaxon(Guid.Parse(organizationalAuthorItem));
categoryPair.Name = taxon.Title.Value;
newsResult.Categories.Add(categoryPair);
}
}
}
catch (Exception ex)
{
log.Error("Source: {0}", ex.Source);
log.Error("Stack Trace: {0}", ex.StackTrace);
log.Error("Message: {0}", ex.Message);
}
}
//newsResult.OrganizationalAuthors = result.GetValue("OrganizationalAuthorsList").ToString().Split(',').Select(x => x.Trim()).ToList();
//log.Trace("OrganizationalAuthorsList Set.");
}
if (result.Fields.Any(x => x.Name == "DefaultLinkBase"))
{
newsResult.DefaultLinkBase = result.GetValue("DefaultLinkBase").ToString();
log.Trace("DefaultLinkBase Set.");
}
if (result.Fields.Any(x => x.Name == "Selfpaced"))
{
var selfPaced = result.GetValue("Selfpaced").ToString();
if (!selfPaced.IsNullOrWhitespace())
{
newsResult.SelfPaced = bool.Parse(result.GetValue("Selfpaced").ToString());
log.Trace("SelfPaced Set.");
}
}
if (result.Fields.Any(x => x.Name == "DisplayDate"))
{
newsResult.DisplayDate = result.GetValue("DisplayDate").ToString();
log.Trace("DisplayDate Set.");
}
if (result.Fields.Any(x => x.Name == "DateField"))
{
try
{
/*newsResult.DateField = DateTime.ParseExact(result.GetValue("DateField").ToString(), "MM/dd/yyyy HH:mm:ss", CultureInfo.InvariantCulture);
* log.Trace("DateField Set.");*/
DateTime dp = DateTime.MinValue;
DateTime.TryParseExact(result.GetValue("DateField").ToString(), "MM/dd/yyyy HH:mm:ss", new CultureInfo("en-US"), DateTimeStyles.None, out dp);
newsResult.DateField = dp;
}
catch (Exception ex)
{
log.Error("Source: {0}", ex.Source);
log.Error("Stack Trace: {0}", ex.StackTrace);
log.Error("Message: {0}", ex.Message);
}
}
if (result.Fields.Any(x => x.Name == "ContentTypeDescription"))
{
newsResult.ContentType = result.GetValue("ContentTypeDescription").ToString();
log.Trace("ContentTypeDescription Set.");
}
if (result.Fields.Any(x => x.Name == "ImageUrl"))
{
newsResult.Image = result.GetValue("ImageUrl").ToString();
log.Trace("Image Set.");
}
if (result.Fields.Any(x => x.Name == "Protected"))
{
newsResult.Protected = result.GetValue("Protected") == "1";
log.Trace("Protected Set.");
}
if (string.IsNullOrWhiteSpace(newsResult.Summary) && !string.IsNullOrWhiteSpace(newsResult.Content))
{
log.Trace("The summary field is empty and the content has a value, so we will make a summary.");
newsResult.Summary = SummaryParser.GetSummary(newsResult.Content, new SummarySettings(SummaryMode.Words, 40, true));
log.Trace("Summary made and set.");
}
resultSet.Add(newsResult);
log.Trace("result added to the resturn set.");
}
log.Info("Finishing SetBlendedListItems.");
return(resultSet);
}
public static Facade CreateFacade(String connectionString)
{
var infoCopier = new InfoCopier();
var countryRepositoryStorage = new InMemoryStorage <CountryRepository>();
var countrySerializer = new CountryToJsonSerializer();
var countryManager = new CountryManager(countryRepositoryStorage);
var basketRenderer = new BasketRenderer();
var securityRepositoryCache = new InMemoryStorage <SecurityRepository>();
var calculationRequester = new CalculationRequester();
var monitor = new Monitor();
var securitySerializer = new SecurityToJsonSerializer(countrySerializer);
var securityManager = new SecurityManager(securityRepositoryCache, monitor);
IDataManagerFactory dataManagerFactory = new FakeDataManagerFactory();
var connectionFactory = new SqlConnectionFactory(connectionString);
var portfolioRepositoryCache = new InMemoryStorage <PortfolioRepository>();
var portfolioSerialzer = new TopDown.Core.ManagingPortfolios.PortfolioToJsonSerializer(securitySerializer);
var portfolioManager = new TopDown.Core.ManagingPortfolios.PortfolioManager(
portfolioRepositoryCache,
portfolioSerialzer
);
var targetingTypeManager = new TargetingTypeManager(
new TopDown.Core.ManagingTargetingTypes.InfoDeserializer(),
new InMemoryStorage <TargetingTypeRepository>(),
new InMemoryStorage <TargetingTypeGroupRepository>()
);
var taxonomyManager = new TaxonomyManager(
new InMemoryStorage <TaxonomyRepository>(),
new TopDown.Core.ManagingTaxonomies.InfoDeserializer(
new TopDown.Core.ManagingTaxonomies.XmlDeserializer()
)
);
var basketRepositoryStorage = new InMemoryStorage <BasketRepository>();
var basketManager = new BasketManager(
basketRepositoryStorage,
new TopDown.Core.ManagingBaskets.XmlDeserializer(),
new BasketSecurityRelationshipInvestigator()
);
var benchmarkRepositoryStorage = new InMemoryStorage <BenchmarkRepository>();
var benchmarkManager = new BenchmarkManager(benchmarkRepositoryStorage);
var portfolioSecurityTargetRepositoryCache = new InMemoryStorage <TopDown.Core.ManagingPst.PortfolioSecurityTargetRepository>();
var portfolioSecurityTargetRepositoryManager = new TopDown.Core.ManagingPst.RepositoryManager(
infoCopier,
portfolioSecurityTargetRepositoryCache
);
var bpstCache = new InMemoryStorage <TopDown.Core.ManagingBpst.BasketSecurityPortfolioTargetRepository>();
var bpstManager = new TopDown.Core.ManagingBpst.BasketSecurityPortfolioTargetRepositoryManager(bpstCache);
var ttgbsbvrCache = new InMemoryStorage <TopDown.Core.ManagingBpst.TargetingTypeGroupBasketSecurityBaseValueRepository>();
var ttgbsbvrManager = new TopDown.Core.ManagingBpst.TargetingTypeGroupBasketSecurityBaseValueRepositoryManager(ttgbsbvrCache);
var issuerRepositoryStorage = new InMemoryStorage <IssuerRepository>();
var issuerManager = new IssuerManager(monitor, issuerRepositoryStorage);
var repositoryManager = new TopDown.Core.RepositoryManager(
monitor,
basketManager,
targetingTypeManager,
countryManager,
taxonomyManager,
securityManager,
portfolioManager,
benchmarkManager,
portfolioSecurityTargetRepositoryManager,
bpstManager,
ttgbsbvrManager,
issuerManager
);
repositoryManager.DropEverything();
var validationSerializer = new TopDown.Core.ValidationIssueToJsonSerializer();
var expressionSerializer = new ExpressionToJsonSerializer(validationSerializer);
var expressionDeserializer = new ExpressionFromJsonDeserializer();
var defaultBreakdownValues = TopDown.Core.ManagingBpt.DefaultValues.CreateDefaultValues();
var picker = new ExpressionPicker();
var commonParts = new CommonParts();
var overlayModelBuilder = new TopDown.Core.Overlaying.ModelBuilder(null, commonParts);
var overlayManager = new OverlayManager(overlayModelBuilder);
var bptModelBuilder = new TopDown.Core.ManagingBpt.ModelBuilder(
picker,
commonParts,
defaultBreakdownValues,
overlayModelBuilder
);
var globeTraverser = new GlobeTraverser();
var taxonomyTraverser = new TaxonomyTraverser();
var taxonomyToModelTransformer = new TaxonomyToModelTransformer(picker, bptModelBuilder, globeTraverser);
var countriesDetector = new MissingCountriesDetector(
new UnknownCountryIsoCodesDetector(),
new TopDown.Core.ManagingTaxonomies.CountryIsoCodesExtractor(taxonomyTraverser),
new TopDown.Core.Overlaying.CombinedCountryIsoCodesExtractor(new TopDown.Core.Overlaying.CountryIsoCodesExtractor()),
new TopDown.Core.ManagingBenchmarks.CountryIsoCodesExtractor()
);
var modelToTaxonomyTransformer = new ModelToTaxonomyTransformer();
var bptModelApplier = new TopDown.Core.ManagingBpt.ModelApplier(
new TopDown.Core.ManagingBpt.ChangingBt.ChangesetApplier(dataManagerFactory, modelToTaxonomyTransformer),
new TopDown.Core.ManagingBpt.ChangingBt.ModelToChangesetTransformer(globeTraverser),
new TopDown.Core.ManagingBpt.ChangingPsto.ChangesetApplier(),
new TopDown.Core.ManagingBpt.ChangingPsto.ModelToChangesetTransformer(),
new TopDown.Core.ManagingBpt.ChangingTtbbv.ChangesetApplier(),
new TopDown.Core.ManagingBpt.ChangingTtbbv.ModelToChangesetTransformer(globeTraverser),
new TopDown.Core.ManagingBpt.ChangingTtbpt.ChangesetApplier(),
new TopDown.Core.ManagingBpt.ChangingTtbpt.ModelToChangesetTransformer(globeTraverser),
new TopDown.Core.ManagingBpt.ModelValidator(globeTraverser),
dataManagerFactory,
calculationRequester
);
var targetsFlattener = new TargetsFlattener(infoCopier);
var bptChangeDetector = new TopDown.Core.ManagingBpt.ModelChangeDetector(
new TopDown.Core.ManagingBpt.ModelExpressionTraverser(globeTraverser)
);
var bptManager = new TopDown.Core.ManagingBpt.ModelManager(
globeTraverser,
bptModelBuilder,
taxonomyToModelTransformer,
new BaseValueInitializer(globeTraverser),
new BenchmarkValueInitializer(globeTraverser),
new OverlayInitializer(globeTraverser, targetsFlattener),
new PortfolioAdjustmentInitializer(globeTraverser),
new TopDown.Core.ManagingBpt.ModelToJsonSerializer(expressionSerializer, portfolioSerialzer),
new TopDown.Core.ManagingBpt.ModelFromJsonDeserializer(
picker,
bptModelBuilder,
globeTraverser,
expressionDeserializer
),
repositoryManager,
overlayManager,
countriesDetector,
bptModelApplier,
bptChangeDetector
);
var pstModelToChangeMapper = new TopDown.Core.ManagingPst.ModelToChangesetTransformer();
var pstChangeApplier = new TopDown.Core.ManagingPst.ChangesetApplier();
var pstModelBuilder = new TopDown.Core.ManagingPst.ModelBuilder(null, commonParts);
var pstModelValidator = new TopDown.Core.ManagingPst.ModelValidator();
var pstManager = new PstManager(
pstChangeApplier,
pstModelValidator,
pstModelToChangeMapper,
new TopDown.Core.ManagingPst.ModelFromJsonDeserializer(
pstModelBuilder,
expressionDeserializer
),
pstModelBuilder,
portfolioSecurityTargetRepositoryManager,
new TopDown.Core.ManagingPst.ModelChangeDetector(
new TopDown.Core.ManagingPst.ModelExpressionTraverser()
),
dataManagerFactory,
calculationRequester,
new TopDown.Core.ManagingPst.ModelToJsonSerializer(expressionSerializer, securitySerializer)
);
var portfiolioPickerManager = new ProtfolioPickerManager(
new TopDown.Core.Gadgets.PortfolioPicker.ModelToJsonSerializer()
);
var basketPickerManager = new TopDown.Core.Gadgets.BasketPicker.ModelManager(
new TopDown.Core.Gadgets.BasketPicker.ModelBuilder(
new BasketExtractor(taxonomyTraverser),
new BasketRenderer()
),
new TopDown.Core.Gadgets.BasketPicker.ModelToJsonSerializer()
);
var bpstModelBuilder = new TopDown.Core.ManagingBpst.ModelBuilder(
TopDown.Core.ManagingBpst.DefaultValues.CreateDefaultValues(),
commonParts
);
var bpstBenchmarkInitializer = new TopDown.Core.ManagingBpst.BenchmarkInitializer();
var bpstModelValidator = new TopDown.Core.ManagingBpst.ModelValidator();
var bpstModelManager = new TopDown.Core.ManagingBpst.ModelManager(
new TopDown.Core.ManagingBpst.ModelToJsonSerializer(expressionSerializer, securitySerializer),
bpstModelBuilder,
new TopDown.Core.ManagingBpst.ModelFromJsonDeserializer(
expressionDeserializer,
bpstModelBuilder,
bpstBenchmarkInitializer
),
new TopDown.Core.ManagingBpst.ModelApplier(
dataManagerFactory,
new TopDown.Core.ManagingBpst.ChangingTtgbsbv.ChangesetApplier(),
new TopDown.Core.ManagingBpst.ChangingTtgbsbv.ModelToChangesetTransformer(),
new TopDown.Core.ManagingBpst.ChangingBpst.PortfolioTargetChangesetApplier(),
new TopDown.Core.ManagingBpst.ChangingBpst.ModelToChangesetTransformter(),
calculationRequester,
bpstModelValidator,
repositoryManager
),
bpstModelValidator,
bpstBenchmarkInitializer,
new TopDown.Core.ManagingBpst.ModelChangeDetector(new TopDown.Core.ManagingBpst.ModelExpressionTraverser()),
repositoryManager
);
var validationManager = new ValidationManager(validationSerializer);
var hopper = new TopDown.Core.ManagingCalculations.Hopper(
repositoryManager,
bptManager,
bpstModelManager,
basketRenderer
);
//var fileManager = new TopDown.Core.ManagingCalculations.TradingTargetsFileManager(repositoryManager, dataManagerFactory, connectionFactory);
var commentManager = new Core.ManagingComments.CommentManager();
var facade = new Facade(
connectionFactory,
dataManagerFactory,
repositoryManager,
bptManager,
picker,
commonParts,
pstManager,
basketManager,
portfiolioPickerManager,
basketPickerManager,
bpstModelManager,
portfolioManager,
hopper,
commentManager
);
return(facade);
}
/// <summary>
/// Adds a custom field to Press article
/// </summary>
/// <param name="fieldname">Name of the field</param>
/// <param name="isHierarchicalTaxonomy">is hierarchical taxonomy</param>
public void AddCustomTaxonomyToContext(string fieldname, bool isHierarchicalTaxonomy)
{
Type pressArticleType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.PressRelease.PressArticle");
if (pressArticleType == null)
{
throw new ArgumentException("PressArticle type can't be resolved.");
}
var context = new CustomFieldsContext(pressArticleType);
TaxonomyManager manager = TaxonomyManager.GetManager();
Guid taxonomyId;
if (isHierarchicalTaxonomy == true)
{
var taxonomy = manager.GetTaxonomies <HierarchicalTaxonomy>().Where(t => t.Title == fieldname).SingleOrDefault();
if (taxonomy != null)
{
taxonomyId = taxonomy.Id;
}
else
{
throw new ArgumentException("The taxonomy '" + fieldname + "' does not exist in the system");
}
}
else
{
var taxonomy = manager.GetTaxonomies <FlatTaxonomy>().Where(t => t.Title == fieldname).SingleOrDefault();
if (taxonomy != null)
{
taxonomyId = taxonomy.Id;
}
else
{
throw new ArgumentException("The taxonomy '" + fieldname + "' does not exist in the system");
}
}
UserFriendlyDataType userFriendlyDataType = UserFriendlyDataType.Classification;
var field = new WcfField()
{
Name = fieldname,
ContentType = "Telerik.Sitefinity.DynamicTypes.Model.PressRelease.PressArticle",
FieldTypeKey = userFriendlyDataType.ToString(),
IsCustom = true,
// Field definition
Definition = new WcfFieldDefinition()
{
Title = fieldname,
FieldName = fieldname.ToLower(),
FieldType = isHierarchicalTaxonomy ? typeof(HierarchicalTaxonField).FullName : typeof(FlatTaxonField).FullName,
TaxonomyId = taxonomyId.ToString(),
AllowMultipleSelection = true,
}
};
var fields = new Dictionary <string, WcfField>();
fields.Add(field.FieldTypeKey, field);
context.AddOrUpdateCustomFields(fields, pressArticleType.Name);
context.SaveChanges();
}
public TaxonomiesService()
{
manager = TaxonomyManager.GetManager();
}
/// <summary>
/// Restricts search results to a set of taxonomies.
/// ORs a set of taxonomies together, then ANDs the result expression to the <see cref="SearchCriteria">search criteria</see> <see cref="SearchCriteria.ExpressionTree">expression tree</see>.
/// </summary>
/// <param name="criteria">The criteria to extend.</param>
/// <param name="taxonomyManager">A <see cref="TaxonomyManager"/> instance from qhich to query the taxonomies.</param>
/// <param name="taxonomyIds">The set of taxonomy IDs to restrict results to.</param>
/// <returns>The updated criteria.</returns>
public static T AndTaxonomy <T>(this T criteria, TaxonomyManager taxonomyManager, params long[] taxonomyIds)
where T : SearchCriteria
{
return(criteria.And(ExpressionFactory.Create(taxonomyManager, taxonomyIds)));
}
/// <summary>
/// Creates the taxon.
/// </summary>
/// <param name="taxonomyId">The taxonomy id.</param>
/// <param name="taxonTitle">The taxon title.</param>
/// <returns></returns>
private Guid CreateTaxon(Guid taxonomyId, string taxonTitle)
{
var taxonomyManager = new TaxonomyManager();
var taxon = taxonomyManager.CreateTaxon<FlatTaxon>();
taxon.Taxonomy = taxonomyManager.GetTaxonomy<FlatTaxonomy>(taxonomyId);
taxon.Title = taxonTitle;
taxon.UrlName = new Lstring(Regex.Replace(taxonTitle, ArrangementConstants.UrlNameCharsToReplace, ArrangementConstants.UrlNameReplaceString).ToLower());
taxonomyManager.SaveChanges();
return taxon.Id;
}
