/// <summary>
/// Разрешение типа на основе его описания в синтаксическом дереве
/// </summary>
/// <param name="service">Контекст разрешения типа</param>
public override Type Resolve(TypeResolutionService service)
{
var typeName = BuildTypeFullName(service.Symbol);
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
var assembly = assemblies.FirstOrDefault(x => x.GetName().Name == service.Symbol.ContainingAssembly.Name);
if (assembly == null)
{
return null;
}
return assembly.GetType(typeName, true);
}
public override Type Resolve(TypeResolutionService service)
{
var named = service.Symbol as INamedTypeSymbol;
var unboundType = service.Resolve(named.ConstructUnboundGenericType());
var arguments = named.TypeArguments.Select(service.Resolve).ToArray();
if (arguments.Length != named.Arity)
{
throw new Exception("Не удалось разрешить все типы аргументов обобщенного типа");
}
return unboundType.MakeGenericType(arguments);
}
public override void CMD_list(Arguments args, Guid rootId)
{
types = new List <DynamicModuleType>();
// Top root: display the types
if (rootId == Guid.Empty)
{
Site site = svc.Get_Site();
var multisiteContext = SystemManager.CurrentContext as MultisiteContext;
var theSite = multisiteContext.GetSiteById(site.Id);
var dynTypes = ModuleBuilderManager.GetManager().Provider.GetDynamicModuleTypes();
HashSet <Guid> typeIds = new HashSet <Guid>();
// Dynamic Modules
foreach (var datalink in site.SiteDataSourceLinks.Where(dsl => !dsl.DataSourceName.StartsWith("Telerik.Sitefinity.")))
{
foreach (var dynType in dynTypes.Where(mt => mt.ModuleName == datalink.DataSourceName))
{
if (typeIds.Contains(dynType.Id))
{
continue;
}
types.Add(dynType);
typeIds.Add(dynType.Id);
}
/* types.Add(dynType);
* Type type = TypeResolutionService.ResolveType(dynType.GetFullTypeName());
* types.Add(type);
* }*/
}
return;
}
// Inside a specific type: display the items
var dynType2 = ModuleBuilderManager.GetManager().Provider.GetDynamicModuleType(rootId);
Type type2 = TypeResolutionService.ResolveType(dynType2.GetFullTypeName());
var dynamicContentManager = DynamicModuleManager.GetManager(svc.Get_Provider());
dynamicContentManager.Provider.SuppressSecurityChecks = false;
items = dynamicContentManager.GetDataItems(type2).Where(n => n.Visible && n.Status == ContentLifecycleStatus.Live).ToList();
}
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);
}
/// <summary>
/// This is the default Action.
/// </summary>
public ActionResult Index()
{
var model = new AuthorsWidgetModel();
//GET AUTHORS
var providerName = String.Empty;
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
Type authorType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Authors.Author");
// This is how we get the collection of Author items
var myCollection = dynamicModuleManager.GetDataItems(authorType).Where(i => i.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Live).Take(4);
// At this point myCollection contains the items from type authorType
model.AvatarEnabled = this.EnableAvatar;
model.Authors = myCollection.Select(i => AuthorViewModel.GetAuthorViewModel(i)).ToList();
return(View("Default", model));
}
// Demonstrates how Destino content items can be retrieved through filtering
public DynamicContent RetrieveDestinoThroughFiltering(string destinoUrl)
{
// Set the provider name for the DynamicModuleManager here. All available providers are listed in
// Administration -> Settings -> Advanced -> DynamicModules -> Providers
var providerName = String.Empty;
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
Type destinoType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Viagens.Destino");
// This is how we get the destino items through filtering
var myFilteredCollection = dynamicModuleManager.GetDataItems(destinoType)
.SingleOrDefault(d => d.UrlName == destinoUrl && d.Status == ContentLifecycleStatus.Live && d.Visible);
// At this point myFilteredCollection contains the items that match the lambda expression passed to the Where extension method
// If you want only the first matching element you can freely get it by ".First()" extension method like this:
// var myFirstFilteredItem = myFilteredCollection.First();
return(myFilteredCollection);
}
/// <summary>
/// Delete a country item by title.
/// </summary>
/// <param name="countryName">The title of the item.</param>
public void DeleteCountry(string countryName)
{
var providerName = string.Empty;
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
providerName = "dynamicContentProvider";
}
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
Type countryType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Booking.Country");
DynamicContent countryItem = dynamicModuleManager.GetDataItems(countryType).Where("Title = \"" + countryName + "\"").First();
dynamicModuleManager.DeleteDataItem(countryItem);
dynamicModuleManager.SaveChanges();
}
public IEnumerable <WebinarViewModel> GetContentList()
{
Type webinarType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Webinars.Webinar");
var dynamicModuleManager = DynamicModuleManager.GetManager();
var webinars = dynamicModuleManager.GetDataItems(webinarType).Where(d => d.Status == ContentLifecycleStatus.Live)
.Select(w => new WebinarViewModel()
{
Title = w.GetValue <string>("Title"),
Description = w.GetString("Description").Value,
StartDate = w.GetValue <DateTime?>("Start") ?? DateTime.UtcNow,
EndDate = w.GetValue <DateTime?>("End") ?? DateTime.UtcNow
});
return(webinars.AsEnumerable());
}
public void Populate(string itemType)
{
var dynamicModuleManager = DynamicModuleManager.GetManager();
Type referenceType = TypeResolutionService.ResolveType(itemType);
var query = dynamicModuleManager.GetDataItems(referenceType).Where(s => s.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Live);
Guid itemId;
if (!string.IsNullOrWhiteSpace(this.SelectedItemId) && Guid.TryParse(this.SelectedItemId, out itemId))
{
this.Item = query.SingleOrDefault(n => n.Id == itemId);
}
else
{
this.Item = query.FirstOrDefault();
}
}
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();
}
/// <summary>
/// Gets an dynamic item from page url. This method automatically updates the opengraph model.
/// </summary>
/// <param name="pageUrl">The page url (Without host and single segment</param>
/// <param name="finalCurrentModuleType">The used type</param>
/// <returns></returns>
private bool GetDynamicItemFromPageUrl(string pageUrl, OpengraphModuleConfig ogConfigElement)
{
Type itemsType = null;
//Try catched this to avoid errors for build in modules
try {
bool returnStatement = false;
//Remove white spaces
ogConfigElement.ModuleType = ogConfigElement.ModuleType.Replace(" ", "");
//Check for multiple types
if (ogConfigElement.ModuleType.Contains(seperator))
{
//Loop all given types
foreach (string stringType in ogConfigElement.ModuleType.Split(seperator))
{
itemsType = TypeResolutionService.ResolveType(stringType);
returnStatement = GetDataItemByType(itemsType, ogConfigElement, pageUrl);
if (returnStatement)
{
return(returnStatement);
}
}
}
else
{
//Only one type, get it.
itemsType = TypeResolutionService.ResolveType(ogConfigElement.ModuleType);
returnStatement = GetDataItemByType(itemsType, ogConfigElement, pageUrl);
if (returnStatement)
{
return(returnStatement);
}
}
return(returnStatement);
}
catch (Exception e)
{
_logiszLogger.LogException(ModuleName, e);
return(false);
}
}
public void DynamicWidgetsDesignerContent_VerifyAllFunctionality()
{
this.pageOperations = new PagesOperations();
string testName = System.Reflection.MethodInfo.GetCurrentMethod().Name;
string pageNamePrefix = testName + "DynamicPage";
string pageTitlePrefix = testName + "Dynamic Page";
string urlNamePrefix = testName + "dynamic-page";
int index = 1;
string url = UrlPath.ResolveAbsoluteUrl("~/" + urlNamePrefix + index);
var dynamicCollection = ServerOperationsFeather.DynamicModulePressArticle().RetrieveCollectionOfPressArticles();
try
{
for (int i = 0; i < this.dynamicTitles.Length; i++)
{
ServerOperationsFeather.DynamicModulePressArticle().CreatePressArticleItem(this.dynamicTitles[i], this.dynamicUrls[i]);
}
dynamicCollection = ServerOperationsFeather.DynamicModulePressArticle().RetrieveCollectionOfPressArticles();
var mvcProxy = new MvcWidgetProxy();
mvcProxy.ControllerName = typeof(DynamicContentController).FullName;
var dynamicController = new DynamicContentController();
dynamicController.Model.ContentType = TypeResolutionService.ResolveType(ResolveType);
dynamicController.Model.SelectionMode = SelectionMode.AllItems;
mvcProxy.Settings = new ControllerSettings(dynamicController);
mvcProxy.WidgetName = WidgetName;
this.pageOperations.CreatePageWithControl(mvcProxy, pageNamePrefix, pageTitlePrefix, urlNamePrefix, index);
string responseContent = PageInvoker.ExecuteWebRequest(url);
for (int i = 0; i < this.dynamicTitles.Length; i++)
{
Assert.IsTrue(responseContent.Contains(this.dynamicTitles[i]), "The dynamic item with this title was not found!");
}
}
finally
{
this.pageOperations.DeletePages();
ServerOperationsFeather.DynamicModulePressArticle().DeleteDynamicItems(dynamicCollection);
Telerik.Sitefinity.TestUtilities.CommonOperations.ServerOperations.Taxonomies().DeleteTags(this.tagTitle);
}
}
/// <summary>
/// Gets the template.
/// </summary>
/// <param name="isVirtualPath">The is virtual path.</param>
/// <param name="isHtmlTemplate">The is HTML template.</param>
/// <param name="layout">The layout.</param>
/// <returns></returns>
protected virtual ITemplate GetTemplate(bool isVirtualPath, bool isHtmlTemplate, string layout)
{
if (isVirtualPath && isHtmlTemplate)
{
if (!HostingEnvironment.VirtualPathProvider.FileExists(layout))
{
throw new ArgumentException(Res.Get <InfrastructureResources>("CannotFindTemplateMvcForm", layout));
}
using (var reader = new StreamReader(HostingEnvironment.VirtualPathProvider.GetFile(layout).Open()))
{
layout = reader.ReadToEnd();
}
}
else if (isVirtualPath)
{
return(ControlUtilities.GetTemplate(layout, null, null, null));
}
else if (layout != null && layout.EndsWith(".ascx", StringComparison.Ordinal))
{
Type assemblyInfo;
if (string.IsNullOrEmpty(this.AssemblyInfo))
{
assemblyInfo = Config.Get <ControlsConfig>().ResourcesAssemblyInfo;
}
else
{
assemblyInfo = TypeResolutionService.ResolveType(this.AssemblyInfo, true);
}
return(ControlUtilities.GetTemplate(null, layout, assemblyInfo, null));
}
// Add sf_cols wrapper for back end pages and email campaigns.
var currentNode = SiteMapBase.GetActualCurrentNode();
var rootNode = currentNode != null ? currentNode.RootNode as PageSiteNode : null;
var ensureSfColsWrapper = this.IsBackend() || rootNode == null || rootNode.Id == NewslettersModule.standardCampaignRootNodeId ||
System.Web.HttpContext.Current.Items[SiteMapBase.CurrentNodeKey] == null;
layout = this.ProcessLayoutString(layout, ensureSfColsWrapper);
return(ControlUtilities.GetTemplate(null, layout.GetHashCode().ToString(System.Globalization.CultureInfo.InvariantCulture), null, layout));
}
private MvcWidgetProxy CreateMvcWidget(string resolveType, string widgetName, string relatedFieldName = null, string relatedItemType = null, RelationDirection relationTypeToDisplay = RelationDirection.Child)
{
var mvcProxy = new MvcWidgetProxy();
mvcProxy.ControllerName = typeof(DynamicContentController).FullName;
var dynamicController = new DynamicContentController();
dynamicController.Model.ContentType = TypeResolutionService.ResolveType(resolveType);
dynamicController.Model.RelatedFieldName = relatedFieldName;
dynamicController.Model.RelatedItemType = relatedItemType;
dynamicController.Model.RelationTypeToDisplay = relationTypeToDisplay;
dynamicController.Model.RelatedItemProviderName = FeatherWidgets.TestUtilities.CommonOperations.DynamicModulesOperations.ProviderName;
dynamicController.Model.ProviderName = FeatherWidgets.TestUtilities.CommonOperations.DynamicModulesOperations.ProviderName;
mvcProxy.Settings = new ControllerSettings(dynamicController);
mvcProxy.WidgetName = widgetName;
return(mvcProxy);
}
public void DynamicWidgets_ContentLocationService_SingleItemSelectedFromWidget()
{
int expectedLocationsCount;
try
{
for (int i = 1; i <= 3; i++)
{
ServerOperationsFeather.DynamicModuleBooking().CreateCountry(CountryName + i.ToString(CultureInfo.InvariantCulture));
}
Type countryType = TypeResolutionService.ResolveType(ResolveTypeCountry);
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager();
var countryItemId = dynamicModuleManager.GetDataItems(countryType).Where("Title = \"" + CountryName + "1\"").First().Id;
string[] itemIds = new string[] { countryItemId.ToString() };
var pageId = ServerOperations.Pages().CreatePage(PageName);
var countriesWidget = this.CreateMvcWidget(ResolveTypeCountry, WidgetNameCountries, itemIds);
var controls = new List <System.Web.UI.Control>();
controls.Add(countriesWidget);
PageContentGenerator.AddControlsToPage(pageId, controls);
var locationsService = SystemManager.GetContentLocationService();
var dynamicItemLocations = locationsService.GetItemLocations(countryType, dynamicModuleManager.Provider.Name, countryItemId);
expectedLocationsCount = 1;
Assert.AreEqual(expectedLocationsCount, dynamicItemLocations.Count(), "Unexpected locations count");
}
finally
{
ServerOperations.Pages().DeleteAllPages();
for (int i = 1; i <= 3; i++)
{
ServerOperationsFeather.DynamicModuleBooking().DeleteCountry(CountryName + i.ToString(CultureInfo.InvariantCulture));
}
}
}
private IEnumerable <SocSkillMatrixContentItem> GetSocSkillMatrixRelatedItems(DynamicContent childLiveItem, List <Guid> parentItemLinks, DynamicModuleManager dynamicModuleManager, string parentName)
{
var relatedSocSkillMatrixContentItems = new List <SocSkillMatrixContentItem>();
var parentType = TypeResolutionService.ResolveType(ParentType);
var socSkillsMatrixContent = new SocSkillMatrixContentItem
{
Id = dynamicContentExtensions.GetFieldValue <Guid>(childLiveItem, Constants.OriginalContentId),
Title = dynamicContentExtensions.GetFieldValue <Lstring>(childLiveItem, nameof(SocSkillMatrixContentItem.Title)),
Contextualised = dynamicContentExtensions.GetFieldValue <Lstring>(childLiveItem, nameof(SocSkillMatrixContentItem.Contextualised)),
ONetAttributeType = dynamicContentExtensions.GetFieldValue <Lstring>(childLiveItem, nameof(SocSkillMatrixContentItem.ONetAttributeType)),
ONetRank = dynamicContentExtensions.GetFieldValue <decimal?>(childLiveItem, nameof(SocSkillMatrixContentItem.ONetRank)).GetValueOrDefault(0),
Rank = dynamicContentExtensions.GetFieldValue <decimal?>(childLiveItem, nameof(SocSkillMatrixContentItem.Rank)).GetValueOrDefault(0),
RelatedSkill = GetRelatedSkillsData(childLiveItem, nameof(SocSkillMatrixContentItem.RelatedSkill)),
RelatedSOC = GetRelatedSocsData(childLiveItem, nameof(SocSkillMatrixContentItem.RelatedSOC))
};
if (SkillsMatrixParentItems != null)
{
foreach (var contentId in SkillsMatrixParentItems)
{
var parentItem = dynamicModuleManager.GetDataItem(parentType, contentId);
if ((parentItem.ApprovalWorkflowState == Constants.WorkflowStatusPublished || parentItem.ApprovalWorkflowState == Constants.WorkflowStatusDraft) && !parentItem.IsDeleted)
{
relatedSocSkillMatrixContentItems.Add(new SocSkillMatrixContentItem
{
Id = dynamicContentExtensions.GetFieldValue <Guid>(childLiveItem, Constants.OriginalContentId),
Title = socSkillsMatrixContent.Title,
Contextualised = socSkillsMatrixContent.Contextualised,
ONetAttributeType = socSkillsMatrixContent.ONetAttributeType,
ONetRank = socSkillsMatrixContent.ONetRank,
Rank = socSkillsMatrixContent.Rank,
RelatedSkill = socSkillsMatrixContent.RelatedSkill,
RelatedSOC = socSkillsMatrixContent.RelatedSOC,
JobProfileId = dynamicContentExtensions.GetFieldValue <Guid>(parentItem, nameof(SocCodeContentItem.Id)),
JobProfileTitle = dynamicContentExtensions.GetFieldValue <Lstring>(parentItem, nameof(SocCodeContentItem.Title))
});
}
}
}
return(relatedSocSkillMatrixContentItems);
}
private void GetIndividualClassificationsForSocCodeData(DynamicModuleManager manager, Type dynamicType, FlatTaxon taxon, string relatedPropertyName)
{
IOrganizableProvider contentProvider = manager.Provider as IOrganizableProvider;
int?totalCount = -1;
var socCodeIds = contentProvider.GetItemsByTaxon(taxon.Id, false, relatedPropertyName, dynamicType, null, null, 0, 0, ref totalCount)
.Cast <DynamicContent>()
.Select(p => p.Id)
.ToList();
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(Constants.DynamicProvider);
var classificationData = new List <SOCCodeClassificationItem>();
var contentLinksManager = ContentLinksManager.GetManager();
var parentType = TypeResolutionService.ResolveType(ParentType);
foreach (var socCodeDataId in socCodeIds)
{
//Get JobProfile Item
var relatedSocData = dynamicModuleManager.GetDataItem(dynamicType, socCodeDataId);
if (relatedSocData.Status.ToString() == Constants.ItemStatusMaster)
{
var socCodeClassificationItem = new SOCCodeClassificationItem
{
SOCCodeClassificationId = dynamicContentExtensions.GetFieldValue <Guid>(relatedSocData, nameof(SOCCodeClassificationItem.Id)),
SOCCode = dynamicContentExtensions.GetFieldValue <Lstring>(relatedSocData, nameof(SOCCodeClassificationItem.SOCCode)),
Id = taxon.Id,
Title = taxon.Title,
Url = taxon.UrlName,
Description = taxon.Description
};
var jobProfileId = contentLinksManager.GetContentLinks()
.Where(c => c.ParentItemType == ParentType && c.ChildItemId == dynamicContentExtensions.GetFieldValue <Guid>(relatedSocData, nameof(SOCCodeClassificationItem.Id)))
.Select(c => c.ParentItemId).FirstOrDefault();
var jobProfileItem = dynamicModuleManager.GetDataItem(parentType, jobProfileId);
socCodeClassificationItem.JobProfileId = jobProfileItem.Id;
socCodeClassificationItem.JobProfileTitle = dynamicContentExtensions.GetFieldValue <Lstring>(jobProfileItem, nameof(SOCCodeClassificationItem.Title));
classificationData.Add(socCodeClassificationItem);
}
}
serviceBusMessageProcessor.SendOtherRelatedTypeMessages(classificationData, taxon.FlatTaxonomy.Name.Trim(), GetActionType(taxon.Status.ToString()));
}
/// <summary>
/// –азрешение типа на основе его описани¤ в синтаксическом дереве
/// </summary>
/// <param name="service"> онтекст разрешени¤ типа</param>
public override Type Resolve(TypeResolutionService service)
{
var properties = new Dictionary<string, Type>();
foreach (var member in service.Symbol.GetMembers())
{
var property = member as IPropertySymbol;
if (property == null)
{
continue;
}
var propertyType = service.Resolve(property.Type);
var propertyName = property.Name;
properties[propertyName] = propertyType;
}
return AnonymousTypeBuilder.Build(properties);
}
private string GetTemplate(out string fileName)
{
// Path is always relative to package root folder.
// WARNING: if we were to copy our files and zip them, this may not work.
TypeResolutionService resolver = GetService(typeof(ITypeResolutionService))
as TypeResolutionService;
if (resolver == null)
{
throw new ArgumentNullException("TypeResolutionService");
}
if (resolver.BasePath == null)
{
throw new ArgumentNullException("TypeResolutionService.BasePath");
}
fileName = new FileInfo(Path.Combine(
resolver.BasePath, Template)).FullName;
return(new StreamReader(fileName).ReadToEnd());
}
public void DynamicWidgetsAllTypes_VerifyAllFieldsOnTheFrontendWhereSomeFieldsAreEmpty()
{
this.pageOperations = new PagesOperations();
string testName = System.Reflection.MethodInfo.GetCurrentMethod().Name;
string pageNamePrefix = testName + "DynamicPage";
string pageTitlePrefix = testName + "Dynamic Page";
string urlNamePrefix = testName + "dynamic-page";
int index = 1;
string url = UrlPath.ResolveAbsoluteUrl("~/" + urlNamePrefix + index);
var dynamicCollection = ServerOperationsFeather.DynamicModuleAllTypes().RetrieveCollectionOfAllFields();
try
{
ServerOperationsFeather.DynamicModuleAllTypes().CreateFieldWithTitle(this.dynamicTitles, this.dynamicUrls);
dynamicCollection = ServerOperationsFeather.DynamicModuleAllTypes().RetrieveCollectionOfAllFields();
var mvcProxy = new MvcWidgetProxy();
mvcProxy.ControllerName = typeof(DynamicContentController).FullName;
var dynamicController = new DynamicContentController();
dynamicController.Model.ContentType = TypeResolutionService.ResolveType(ResolveType);
dynamicController.Model.SelectionMode = SelectionMode.AllItems;
dynamicController.Model.ProviderName = FeatherWidgets.TestUtilities.CommonOperations.DynamicModulesOperations.ProviderName;
mvcProxy.Settings = new ControllerSettings(dynamicController);
mvcProxy.WidgetName = WidgetName;
this.pageOperations.CreatePageWithControl(mvcProxy, pageNamePrefix, pageTitlePrefix, urlNamePrefix, index);
string responseContent = PageInvoker.ExecuteWebRequest(url);
Assert.IsTrue(responseContent.Contains(this.dynamicTitles), "The dynamic item with this title was not found!");
string detailNewsUrl = url + dynamicCollection[0].ItemDefaultUrl;
string detailResponseContent = PageInvoker.ExecuteWebRequest(detailNewsUrl);
Assert.IsTrue(detailResponseContent.Contains(this.dynamicTitles), "The title was not found!");
}
finally
{
this.pageOperations.DeletePages();
ServerOperationsFeather.DynamicModulePressArticle().DeleteDynamicItems(dynamicCollection);
}
}
public override void CMD_provider(Arguments args, Guid rootId)
{
List <string> providers = new List <string>();
var dynTypes = ModuleBuilderManager.GetManager().Provider.GetDynamicModuleTypes();
MultisiteManager msManager = MultisiteManager.GetManager();
var links = msManager.GetSiteDataSourceLinks();
foreach (var datalink in links.Where(l => !l.DataSourceName.StartsWith("Telerik.Sitefinity.")))
{
if (dynTypes.Where(mt => mt.ModuleName == datalink.DataSourceName).FirstOrDefault() != null)
{
providers.Add(ProviderName(datalink.ProviderName));
}
}
// Displays the list of providers
if (args.Count == 0)
{
string currentProvider = ProviderName(svc.Get_Provider());
summary = string.Join("\n", providers.Select(provider => provider + (provider == currentProvider ? " <=" : "")));
return;
}
// Selects a provider
string newProvider = providers.Where(provider => provider.ToLower() == args.FirstKey).FirstOrDefault();
if (newProvider == null)
{
svc.Set_Error("Invalid provider: " + args.FirstKey);
return;
}
if (rootId != Guid.Empty)
{
var dynType = ModuleBuilderManager.GetManager().Provider.GetDynamicModuleType(rootId);
Type type = TypeResolutionService.ResolveType(dynType.GetFullTypeName());
svc.Set_Path(newProvider + " - " + type.FullName.Substring(38));
}
newProvider = newProvider == "Default" ? "OpenAccessProvider" : newProvider;
svc.Set_Provider(newProvider);
}
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 static void RegisterAmazonService(string typeName)
{
try
{
var serviceType = TypeResolutionService.ResolveType(typeName, false);
if (serviceType != null)
{
var service = Activator.CreateInstance(serviceType);
if (service != null)
{
ServiceBus.UnregisterService <ISearchService>();
ServiceBus.RegisterService <ISearchService>(service);
}
}
}
catch (Exception ex)
{
Log.Write(ex.InnerException.Message);
}
}
private void OnPet_Updated(object sender, Telerik.Sitefinity.Data.ExecutingEventArgs e)
{
if (e.CommandName == "CommitTransaction" || e.CommandName == "FlushTransaction")
{
var provider = sender as DynamicModuleDataProvider;
var dirtyItems = provider.GetDirtyItems();
if (dirtyItems.Count != 0)
{
PetHelper petHelper = new PetHelper();
foreach (var item in dirtyItems)
{
if (item.GetType() == TypeResolutionService.ResolveType(petHelper.PetTypeString))
{
petHelper.FlushCache();
}
}
}
}
}
internal static void RegisterSearchService(string typeName, params object[] constructorArgs)
{
try
{
var serviceType = TypeResolutionService.ResolveType(typeName, false);
if (serviceType != null)
{
var service = Activator.CreateInstance(serviceType, constructorArgs);
if (service != null)
{
ServiceBus.UnregisterService <ISearchService>();
ServiceBus.RegisterService <ISearchService>(service);
}
}
}
catch (Exception ex)
{
Log.Write(ex.InnerException.Message);
}
}
public List <DynamicContent> RetrieveCollectionOfAllFields()
{
// Set the provider name for the DynamicModuleManager here. All available providers are listed in
// Administration -> Settings -> Advanced -> DynamicModules -> Providers
var providerName = string.Empty;
if (ServerOperations.MultiSite().CheckIsMultisiteMode())
{
providerName = "dynamicContentProvider";
}
DynamicModuleManager dynamicModuleManager = DynamicModuleManager.GetManager(providerName);
Type pressArticleType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.AllTypesModule.Alltypes");
// This is how we get the collection of Press Article items
var myCollection = dynamicModuleManager.GetDataItems(pressArticleType).ToList();
//// At this point myCollection contains the items from type pressArticleType
return(myCollection);
}
public void TestAssemblyLoad1()
{
AddTempFiles(1);
using (StreamWriter sw = new StreamWriter((string)CodeFiles[0]))
{
sw.WriteLine(@"
public class Test
{
}" );
}
Compile(0);
TypeResolutionService trs = new TypeResolutionService(Path.GetTempPath());
Assembly asm = trs.GetAssembly(Common.ReflectionHelper.ParseAssemblyName(
Path.GetFileNameWithoutExtension((string)AsmFiles[0])));
Assert.IsNotNull(asm);
}
public ConferenceModel GetConferenceModelById(Guid id, string provider)
{
if (id == Guid.Empty)
{
return(null);
}
// Construct the cache key
string cacheKey = CacheUtilities.BuildCacheKey(ConferenceSubControl.cacheKey, id.ToString());
var model = (ConferenceModel)CacheUtilities.CacheManagerGlobal[cacheKey];
if (model == null)
{
lock (this.nodeDataLock)
{
model = (ConferenceModel)CacheUtilities.CacheManagerGlobal[cacheKey];
if (model == null)
{
// Get the conference item
DynamicModuleManager manager = DynamicModuleManager.GetManager(provider);
Type latestHotTopicsType = TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.Conferences.Conference");
DynamicContent conference = manager.GetDataItem(latestHotTopicsType, id);
// Build the Model
model = this.PopulateModel(conference);
// Add the model in the cache
CacheUtilities.CacheManagerGlobal.Add(
cacheKey,
model,
CacheItemPriority.Normal,
null,
// Add cache dependency for automatic invalidation
new DataItemCacheDependency(typeof(DynamicContent), id),
// Configure sliding time
new SlidingTime(TimeSpan.FromMinutes(20)));
}
}
}
return(model);
}
private IEnumerable <SkillContentItem> GetRelatedSkillTypeItems(DynamicContent childItem, List <Guid> parentItemLinks, DynamicModuleManager dynamicModuleManager, string parentName)
{
//When you update a skill get all the socskill matrixes that have this skill
var relatedContentItems = new List <SkillContentItem>();
var socSkillsMatrixType = TypeResolutionService.ResolveType(SocSkillsMatrixType);
var parentType = TypeResolutionService.ResolveType(ParentType);
dynamicModuleManager = DynamicModuleManager.GetManager(Constants.DynamicProvider);
var contentLinksManager = ContentLinksManager.GetManager();
foreach (var contentId in parentItemLinks)
{
var parentItem = dynamicModuleManager.GetDataItem(socSkillsMatrixType, contentId);
if ((parentItem.ApprovalWorkflowState == Constants.WorkflowStatusPublished || parentItem.ApprovalWorkflowState == Constants.WorkflowStatusDraft) && !parentItem.IsDeleted)
{
var jobProfileId = contentLinksManager.GetContentLinks()
.Where(c => c.ParentItemType == ParentType && c.ChildItemId == parentItem.Id)
.Select(c => c.ParentItemId).FirstOrDefault();
if (jobProfileId != Guid.Empty)
{
var jobProfileItem = dynamicModuleManager.GetDataItem(parentType, jobProfileId);
if (jobProfileItem.ApprovalWorkflowState == Constants.WorkflowStatusPublished && !jobProfileItem.IsDeleted)
{
relatedContentItems.Add(new SkillContentItem
{
JobProfileId = dynamicContentExtensions.GetFieldValue <Guid>(jobProfileItem, nameof(SkillContentItem.Id)),
JobProfileTitle = dynamicContentExtensions.GetFieldValue <Lstring>(jobProfileItem, nameof(SkillContentItem.Title)),
Id = dynamicContentExtensions.GetFieldValue <Guid>(childItem, nameof(SkillContentItem.Id)),
Title = dynamicContentExtensions.GetFieldValue <Lstring>(childItem, nameof(SkillContentItem.Title)),
ONetElementId = dynamicContentExtensions.GetFieldValue <Lstring>(childItem, nameof(SkillContentItem.ONetElementId)),
SocSkillMatrixId = dynamicContentExtensions.GetFieldValue <Guid>(parentItem, nameof(SkillContentItem.Id)),
SocSkillMatrixTitle = dynamicContentExtensions.GetFieldValue <Lstring>(parentItem, nameof(SkillContentItem.Title)),
Description = dynamicContentExtensions.GetFieldValue <Lstring>(childItem, nameof(SkillContentItem.Description))
});
}
}
}
}
return(relatedContentItems);
}
public bool DeleteVacanciesPermanently(int itemCount)
{
var lastDeleteCall = false;
using (var recycleBinItemsManager = RecycleBinManagerFactory.GetManager())
{
SystemManager.RunWithElevatedPrivilege(d =>
{
var recycleBinItems = recycleBinItemsManager
.GetRecycleBinItems()
.Where(di => di.DeletedItemTypeName.Equals(ApprenticeVacancyDeleteTypeName))
.Take(itemCount)
.ToList();
lastDeleteCall = itemCount > recycleBinItems.Count;
var providerName = DynamicModuleManager.GetDefaultProviderName(DynamicTypes.JobProfileModuleName);
var dynamicModuleContentType = TypeResolutionService.ResolveType(ApprenticeVacancyDeleteTypeName);
using (var dynamicModuleManager = DynamicModuleManager.GetManager(providerName))
{
foreach (var recycleBinItem in recycleBinItems)
{
try
{
var dataItem = dynamicModuleManager.GetItem(dynamicModuleContentType, recycleBinItem.DeletedItemId) as IRecyclableDataItem;
dynamicModuleManager.RecycleBin.PermanentlyDeleteFromRecycleBin(dataItem);
}
catch (ItemNotFoundException exception)
{
recycleBinItemsManager.Delete(recycleBinItem);
applicationLogger.Info($"Could not delete item : {recycleBinItem.DeletedItemTitle}, failed with error {exception.Message}");
recycleBinItemsManager.SaveChanges();
}
}
dynamicModuleManager.SaveChanges();
}
});
}
return(lastDeleteCall);
}
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();
}
/// <inheritdoc />
public override void AppendPersonalizationProperties(StringBuilder output, ControlData controlData, Type controlType, Guid pageDataId, out bool appendAllProperties)
{
if (typeof(MvcProxyBase).IsAssignableFrom(controlType))
{
appendAllProperties = true;
var controllerName = controlData.Properties.Where(p => p.Name == "ControllerName" && p.Value != null)
.Select(p => p.Value).FirstOrDefault();
if (!controllerName.IsNullOrEmpty())
{
controlType = TypeResolutionService.ResolveType(controllerName, throwOnError: false);
}
output.Append(string.Format(" ControlDataId=\"{0}\" ControlTypeName=\"{1}\" PageDataId=\"{2}\"", controlData.Id, controlType.FullName, pageDataId));
}
else
{
base.AppendPersonalizationProperties(output, controlData, controlType, pageDataId, out appendAllProperties);
}
}
public static string GetWebResourceUrl(ScriptRef scriptReference)
{
var config = Config.Get <PagesConfig>().ScriptManager;
var scriptConfig = config.ScriptReferences[scriptReference.ToString()];
string resourceUrl = string.Empty;
if (config.EnableCdn || (scriptConfig.EnableCdn.HasValue && scriptConfig.EnableCdn.Value))
{
resourceUrl = scriptConfig.Path;
}
else
{
var page = HttpContext.Current.Handler.GetPageHandler() ?? new PageProxy(null);
resourceUrl = page.ClientScript.GetWebResourceUrl(
TypeResolutionService.ResolveType("Telerik.Sitefinity.Resources.Reference"),
scriptConfig.Name);
}
return(resourceUrl);
}
public Microsoft.Practices.RecipeFramework.GuidancePackage InitGuidancePackage(string packageXmlFilename)
{
string basePath = Directory.GetParent(packageXmlFilename).FullName + "\\";
XmlReader configReader = XmlReader.Create(packageXmlFilename);
//Microsoft.Practices.RecipeFramework.Configuration.GuidancePackage curentConfig = Microsoft.Practices.RecipeFramework.GuidancePackage.ReadConfiguration(configReader);
//Microsoft.Practices.RecipeFramework.GuidancePackage curentGPckg = new Microsoft.Practices.RecipeFramework.GuidancePackage(curentConfig, basePath);
Microsoft.Practices.RecipeFramework.GuidancePackage curentGPckg = new Microsoft.Practices.RecipeFramework.GuidancePackage(configReader);
System.IServiceProvider sp = VsIdeTestHostContext.ServiceProvider;
TypeResolutionService _trs = new TypeResolutionService(basePath);
TestValueGatheringService _tvs = new TestValueGatheringService();
TestPersistenceService _tps = new TestPersistenceService();
DTE test = GetDTE();
testContextInstance.WriteLine("Mode: " + test.Mode);
//curentGPckg.SetupTemporaryService(typeof(EnvDTE.DTE), GetDTE());
//curentGPckg.AddService(typeof(ITypeResolutionService), _trs);
curentGPckg.AddService(typeof(EnvDTE.DTE), GetDTE());
curentGPckg.AddService(typeof(IValueGatheringService), _tvs);
curentGPckg.AddService(typeof(IPersistenceService), _tps);
//curentGPckg.AddService(typeof(Microsoft.VisualStudio.OLE.Interop.IOleComponentManager), sp.GetService(typeof(Microsoft.VisualStudio.OLE.Interop.IOleComponentManager)));
curentGPckg.Site = new Microsoft.Practices.ComponentModel.Site(sp, new Microsoft.Practices.RecipeFramework.RecipeManager(), "SharePointSoftwareFactory");
//curentGPckg.Site = (en)sp.GetService(typeof(ISite));
configReader.Close();
testContextInstance.WriteLine("Site: " + curentGPckg.Site.GetType().ToString());
//testContextInstance.WriteLine("Container: " + curentGPckg.Site.Container.GetType().ToString());
//testContextInstance.WriteLine("Component: " + curentGPckg.Site.Component.GetType().ToString());
return curentGPckg;
}
/// <summary>
/// Определение возможноси разрешить тип
/// </summary>
/// <param name="service"></param>
/// <returns></returns>
public override bool CanResolve(TypeResolutionService service)
{
return service.Symbol is IArrayTypeSymbol;
}
/// <summary>
/// Разрешение типа на основе его описания в синтаксическом дереве
/// </summary>
/// <param name="service">Контекст разрешения типа</param>
public override Type Resolve(TypeResolutionService service)
{
var arrayType = service.Symbol as IArrayTypeSymbol;
var itemType = service.Resolve(arrayType.ElementType);
return itemType.MakeArrayType();
}
/// <summary> /// Определение возможноси разрешить тип /// </summary> /// <param name="service"></param> /// <returns></returns> public abstract bool CanResolve(TypeResolutionService service);
/// <summary> /// Разрешение типа на основе его описания в синтаксическом дереве /// </summary> /// <param name="service">Контекст разрешения типа</param> public abstract Type Resolve(TypeResolutionService service);
void UnloadDesigner()
{
LoggingService.Debug("FormsDesigner unloading, setting ActiveDesignSurface to null");
designSurfaceManager.ActiveDesignSurface = null;
bool savedIsDirty = (this.DesignerCodeFile == null) ? false : this.DesignerCodeFile.IsDirty;
this.UserContent = this.pleaseWaitLabel;
if (this.DesignerCodeFile != null) {
this.DesignerCodeFile.IsDirty = savedIsDirty;
}
if (designSurface != null) {
designSurface.Loading -= this.DesignerLoading;
designSurface.Loaded -= this.DesignerLoaded;
designSurface.Flushed -= this.DesignerFlushed;
designSurface.Unloading -= this.DesignerUnloading;
IComponentChangeService componentChangeService = designSurface.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
if (componentChangeService != null) {
componentChangeService.ComponentChanged -= ComponentChanged;
componentChangeService.ComponentAdded -= ComponentListChanged;
componentChangeService.ComponentRemoved -= ComponentListChanged;
componentChangeService.ComponentRename -= ComponentListChanged;
}
if (this.Host != null) {
this.Host.TransactionClosed -= TransactionClose;
}
ISelectionService selectionService = designSurface.GetService(typeof(ISelectionService)) as ISelectionService;
if (selectionService != null) {
selectionService.SelectionChanged -= SelectionChangedHandler;
}
designSurface.Unloaded += delegate {
ServiceContainer serviceContainer = designSurface.GetService(typeof(ServiceContainer)) as ServiceContainer;
if (serviceContainer != null) {
// Workaround for .NET bug: .NET unregisters the designer host only if no component throws an exception,
// but then in a finally block assumes that the designer host is already unloaded.
// Thus we would get the confusing "InvalidOperationException: The container cannot be disposed at design time"
// when any component throws an exception.
// See http://community.sharpdevelop.net/forums/p/10928/35288.aspx
// Reproducible with a custom control that has a designer that crashes on unloading
// e.g. http://www.codeproject.com/KB/toolbars/WinFormsRibbon.aspx
// We work around this problem by unregistering the designer host manually.
try {
var services = (Dictionary<Type, object>)typeof(ServiceContainer).InvokeMember(
"Services",
BindingFlags.Instance | BindingFlags.GetProperty | BindingFlags.NonPublic,
null, serviceContainer, null);
foreach (var pair in services.ToArray()) {
if (pair.Value is IDesignerHost) {
serviceContainer.GetType().InvokeMember(
"RemoveFixedService",
BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.NonPublic,
null, serviceContainer, new object[] { pair.Key });
}
}
} catch (Exception ex) {
LoggingService.Error(ex);
}
}
};
try {
designSurface.Dispose();
} catch (ExceptionCollection exceptions) {
foreach (Exception ex in exceptions.Exceptions) {
LoggingService.Error(ex);
}
} finally {
designSurface = null;
}
}
this.typeResolutionService = null;
this.loader = null;
UpdatePropertyPad();
foreach (KeyValuePair<Type, TypeDescriptionProvider> entry in this.addedTypeDescriptionProviders) {
TypeDescriptor.RemoveProvider(entry.Value, entry.Key);
}
this.addedTypeDescriptionProviders.Clear();
}
void LoadDesigner()
{
LoggingService.Info("Form Designer: BEGIN INITIALIZE");
DefaultServiceContainer serviceContainer = new DefaultServiceContainer();
serviceContainer.AddService(typeof(System.Windows.Forms.Design.IUIService), new UIService());
serviceContainer.AddService(typeof(System.Drawing.Design.IToolboxService), ToolboxProvider.ToolboxService);
serviceContainer.AddService(typeof(IHelpService), new HelpService());
serviceContainer.AddService(typeof(System.Drawing.Design.IPropertyValueUIService), new PropertyValueUIService());
serviceContainer.AddService(typeof(System.ComponentModel.Design.IResourceService), new DesignerResourceService(this.resourceStore));
AmbientProperties ambientProperties = new AmbientProperties();
serviceContainer.AddService(typeof(AmbientProperties), ambientProperties);
this.typeResolutionService = new TypeResolutionService(this.PrimaryFileName);
serviceContainer.AddService(typeof(ITypeResolutionService), this.typeResolutionService);
serviceContainer.AddService(typeof(DesignerOptionService), new SharpDevelopDesignerOptionService());
serviceContainer.AddService(typeof(ITypeDiscoveryService), new TypeDiscoveryService());
serviceContainer.AddService(typeof(MemberRelationshipService), new DefaultMemberRelationshipService());
serviceContainer.AddService(typeof(ProjectResourceService), CreateProjectResourceService());
// Provide the ImageResourceEditor for all Image and Icon properties
this.addedTypeDescriptionProviders.Add(typeof(Image), TypeDescriptor.AddAttributes(typeof(Image), new EditorAttribute(typeof(ImageResourceEditor), typeof(System.Drawing.Design.UITypeEditor))));
this.addedTypeDescriptionProviders.Add(typeof(Icon), TypeDescriptor.AddAttributes(typeof(Icon), new EditorAttribute(typeof(ImageResourceEditor), typeof(System.Drawing.Design.UITypeEditor))));
// if (generator.CodeDomProvider != null) {
// serviceContainer.AddService(typeof(System.CodeDom.Compiler.CodeDomProvider), generator.CodeDomProvider);
// }
designSurface = CreateDesignSurface(serviceContainer);
designSurface.Loading += this.DesignerLoading;
designSurface.Loaded += this.DesignerLoaded;
designSurface.Flushed += this.DesignerFlushed;
designSurface.Unloading += this.DesignerUnloading;
serviceContainer.AddService(typeof(System.ComponentModel.Design.IMenuCommandService), new ICSharpCode.FormsDesigner.Services.MenuCommandService(this, designSurface));
this.loader = loaderProvider.CreateLoader(this);
designSurface.BeginLoad(this.loader);
if (!designSurface.IsLoaded) {
throw new FormsDesignerLoadException(FormatLoadErrors(designSurface));
}
undoEngine = new FormsDesignerUndoEngine(Host);
serviceContainer.AddService(typeof(UndoEngine), undoEngine);
IComponentChangeService componentChangeService = (IComponentChangeService)designSurface.GetService(typeof(IComponentChangeService));
componentChangeService.ComponentChanged += ComponentChanged;
componentChangeService.ComponentAdded += ComponentListChanged;
componentChangeService.ComponentRemoved += ComponentListChanged;
componentChangeService.ComponentRename += ComponentListChanged;
this.Host.TransactionClosed += TransactionClose;
ISelectionService selectionService = (ISelectionService)designSurface.GetService(typeof(ISelectionService));
selectionService.SelectionChanged += SelectionChangedHandler;
if (IsTabOrderMode) { // fixes SD2-1015
tabOrderMode = false; // let ShowTabOrder call the designer command again
ShowTabOrder();
}
UpdatePropertyPad();
hasUnmergedChanges = false;
LoggingService.Info("Form Designer: END INITIALIZE");
}
/// <summary>
/// Register the needed services
/// </summary>
/// <param name="services"></param>
/// <param name="project"></param>
private static void RegisterNeededServices(ServiceCollection services, IProject project)
{
ServiceCollection rootServices = ApplicationContext.Current.RootWorkItem.Services;
rootServices.Add<IProjectContextService>(new SimpleProjectContextService(project));
rootServices.AddNew<ProjectLocalizationService>();
rootServices.Add<IPortalDeploymentService>(new PortalDeploymentService());
ITypeResolutionService resService = new TypeResolutionService();
services.Add(typeof(ITypeResolutionService), resService);
services.Add(typeof(ITypeDiscoveryService), resService);
}
/// <summary>
/// Определение возможноси разрешить тип
/// </summary>
/// <param name="service"></param>
/// <returns></returns>
public override bool CanResolve(TypeResolutionService service)
{
return service.Symbol.ContainingAssembly != null;
}
/// <summary>
/// Определение возможноси разрешить тип
/// </summary>
/// <param name="service"></param>
/// <returns></returns>
public override bool CanResolve(TypeResolutionService service)
{
var named = service.Symbol as INamedTypeSymbol;
return named != null && named.Arity > 0 && named.IsGenericType && !named.IsUnboundGenericType;
}
/// <summary>
/// ќпределение возможноси разрешить тип
/// </summary>
/// <param name="service"></param>
/// <returns></returns>
public override bool CanResolve(TypeResolutionService service)
{
return service.Symbol.IsAnonymousType;
}
