public GetAccountListQueryHandler(IDocumentContext documentContext, ICoreConfiguration coreConfiguration, IMediator mediator, IMapper mapper)
{
_mediator = mediator;
_mapper = mapper;
_coreConfiguration = coreConfiguration;
_documentContext = documentContext;
}
public DocumentService(IDocumentContext documentContext, IUserManager <GearUser> userManager, IFileManager fileManager, IDataFilter dataFilter)
{
_documentContext = documentContext;
_userManager = userManager;
FileManager = fileManager;
DataFilter = dataFilter;
}
public DocumentNode MakeNode(IDocumentContext documentContext)
{
string[] names = Enum.GetNames(this.enumType.RuntimeType);
string str = names[DesignDataGenerator.random.Next(names.Length)];
return((DocumentNode)documentContext.CreateNode((ITypeId)this.enumType, (IDocumentNodeValue) new DocumentNodeStringValue(str)));
}
public object ConvertToWpf(IDocumentContext sourceDocumentContext, object obj)
{
if (PlatformConverter.IsPlatformValue(obj, this.StandaloneWpfDocumentContext))
{
return(obj);
}
if (obj != null)
{
ITypeId typeId = (ITypeId)sourceDocumentContext.TypeResolver.GetType(obj.GetType());
if (PlatformTypes.Style.IsAssignableFrom(typeId) || PlatformTypes.FrameworkTemplate.IsAssignableFrom(typeId))
{
return(Activator.CreateInstance(PlatformTypeHelper.ConvertTypeId(typeId, this.StandaloneWpfDocumentContext.TypeResolver.PlatformMetadata).RuntimeType));
}
if (PlatformTypes.CompositeTransform.IsAssignableFrom(typeId))
{
IPlatform platform = PlatformConverter.GetPlatform(sourceDocumentContext);
if (platform != null)
{
Transform transform = (Transform)platform.GeometryHelper.ConvertTransformToWpf(obj);
if (transform != null)
{
return((object)transform);
}
}
}
}
object obj1 = this.ConvertInternal(obj, sourceDocumentContext, this.StandaloneWpfDocumentContext, PlatformConverter.ConvertToType.InstanceValue);
FontFamily fontFamily = obj1 as FontFamily;
if (fontFamily != null && fontFamily.Source == PlatformConverter.portableUserInterfaceString)
{
return((object)PlatformConverter.PortableUserInterfaceFont);
}
return(obj1);
}
private void ApplyResourceOnExistingElement(SceneElement targetElement, IPropertyId targetProperty, ResourceEntryItem resource)
{
if (resource.Resource.KeyNode != null || targetProperty.Equals((object)BaseFrameworkElement.StyleProperty))
{
using (SceneEditTransaction editTransaction = this.ActiveDocument.CreateEditTransaction(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.PropertySetUndo, new object[1]
{
(object)targetProperty.Name
})))
{
if (resource.Resource.KeyNode != null)
{
IDocumentContext documentContext = this.ActiveSceneViewModel.Document.DocumentContext;
IProjectContext projectContext = this.ActiveSceneViewModel.Document.ProjectContext;
DocumentNode keyNode = resource.Resource.KeyNode.Clone(documentContext);
DocumentNode documentNode = !(projectContext.ResolveProperty(targetProperty) is DependencyPropertyReferenceStep) || !JoltHelper.TypeSupported((ITypeResolver)projectContext, PlatformTypes.DynamicResource) ? (DocumentNode)DocumentNodeUtilities.NewStaticResourceNode(documentContext, keyNode) : (DocumentNode)DocumentNodeUtilities.NewDynamicResourceNode(documentContext, keyNode);
targetElement.SetValue(targetProperty, (object)documentNode);
}
else if (targetProperty.Equals((object)BaseFrameworkElement.StyleProperty))
{
targetElement.ClearValue(targetProperty);
}
editTransaction.Commit();
}
}
ResourceManager resourceManager = this.ActiveSceneViewModel.DesignerContext.ResourceManager;
DocumentReference documentReference = resource.Container.DocumentReference;
if (resource.Resource.IsResourceReachable((SceneNode)targetElement) || !(documentReference != resourceManager.ActiveRootContainer.DocumentReference) || !(documentReference != resourceManager.TopLevelResourceContainer.DocumentReference))
{
return;
}
resourceManager.LinkToResource(resourceManager.TopLevelResourceContainer, documentReference);
}
public UpdateEmailCommandHandler(IMediator mediator, IDocumentContext documentContext, ICoreConfiguration coreConfiguration, IEmailService emailService)
{
_mediator = mediator;
_coreConfiguration = coreConfiguration;
_documentContext = documentContext;
_emailService = emailService;
}
public bool Resolve(IDocumentContext documentContext, EditDesignTimeResourceModelMode mode, string missingResourceName)
{
if (documentContext == null)
{
throw new ArgumentNullException("documentContext");
}
bool success = false;
UIThreadDispatcherHelper.Invoke(DispatcherPriority.ApplicationIdle, (Action)(() =>
{
EditDesignTimeResourceModel model = this.CreateModel(documentContext, mode, missingResourceName);
if (model == null || !model.CanResolveDesignTimeResources)
{
return;
}
if (mode != EditDesignTimeResourceModelMode.Manual)
{
bool?doNotAskAgain = model.DoNotAskAgain;
if ((doNotAskAgain.GetValueOrDefault() ? 0 : (doNotAskAgain.HasValue ? true : false)) == 0)
{
return;
}
}
bool?nullable = new EditDesignTimeResourcesDialog(model).ShowDialog();
success = nullable.GetValueOrDefault() && nullable.HasValue;
}));
return(success);
}
public static DocumentCompositeNode NewStaticResourceNode(IDocumentContext documentContext, DocumentNode keyNode)
{
DocumentCompositeNode documentCompositeNode = documentContext.CreateNode(documentContext.TypeResolver.ResolveType(PlatformTypes.StaticResource));
documentCompositeNode.Properties[KnownProperties.StaticResourceResourceKeyProperty] = keyNode;
return(documentCompositeNode);
}
private static object InstantiateConstructorArgument(IInstanceBuilderContext context, ViewNode viewNode, IParameter constructorArgument, IProperty constructorArgumentProperty, DocumentNode constructorArgumentNode)
{
object defaultValue;
if (constructorArgumentProperty != null)
{
return(InstanceBuilderOperations.UpdatePropertyWithoutApply(context, viewNode, constructorArgumentProperty, constructorArgumentNode).Instance);
}
if (constructorArgumentNode != null)
{
ViewNode viewNode1 = InstanceBuilderOperations.UpdateChildWithoutApply(context, viewNode, viewNode.Children.Count, DocumentNodeChangeAction.Add, constructorArgumentNode);
return(viewNode1.Instance);
}
IDocumentContext documentContext = viewNode.DocumentNode.Context;
Type targetType = viewNode.TargetType;
Type runtimeType = constructorArgument.ParameterType.RuntimeType;
ReferenceStep referenceStep = constructorArgumentProperty as ReferenceStep;
if (referenceStep == null || !referenceStep.HasDefaultValue(targetType))
{
bool flag = documentContext.TypeResolver.InTargetAssembly(constructorArgument.ParameterType);
defaultValue = InstanceBuilderOperations.InstantiateType(runtimeType, flag);
}
else
{
defaultValue = referenceStep.GetDefaultValue(targetType);
}
if (context.IsSerializationScope)
{
defaultValue = documentContext.CreateNode(runtimeType, defaultValue);
}
return(defaultValue);
}
private List <DocumentNode> GetSelectedItemsDocumentNodes()
{
List <DocumentNode> list = new List <DocumentNode>();
IDocumentContext documentContext = (IDocumentContext)null;
if (this.resourceManager.SelectedItems.Count <= 0)
{
return((List <DocumentNode>)null);
}
foreach (ResourceEntryBase resourceEntryBase in this.resourceManager.SelectedItems.Selection)
{
DocumentNode documentNode = resourceEntryBase.DocumentNode;
if (resourceEntryBase == this.activeDocumentWrapper && this.designerContext.ActiveDocument != null)
{
documentNode = this.designerContext.ActiveDocument.DocumentRoot.RootNode;
}
if (documentNode != null)
{
list.Add(documentNode);
if (documentContext == null)
{
documentContext = documentNode.Context;
}
else if (documentContext != documentNode.Context)
{
return((List <DocumentNode>)null);
}
}
}
return(list);
}
public AuthenticateUserCommandHandler(IMediator mediator, IDocumentContext documentContext, IRedisContext redisContext, ICoreConfiguration coreConfiguration)
{
_mediator = mediator;
_coreConfiguration = coreConfiguration;
_documentContext = documentContext;
_redisContext = redisContext;
}
public override SceneNode GenerateConverter()
{
IDocumentContext documentContext = this.valueConverter.DocumentContext;
DocumentNode keyNode = (DocumentNode)documentContext.CreateNode(this.DisplayName);
return(this.valueConverter.ViewModel.GetSceneNode((DocumentNode)DocumentNodeUtilities.NewStaticResourceNode(documentContext, keyNode)));
}
public static bool AreFontsEqual(FontFamily lhs, FontFamily rhs, IDocumentContext documentContext)
{
if (FontEmbedder.GetFontNameFromSource(lhs) == FontEmbedder.GetFontNameFromSource(rhs))
{
return(true);
}
bool flag1 = lhs == null || lhs.Source == null;
bool flag2 = rhs == null || rhs.Source == null;
if (flag1 && flag2)
{
return(true);
}
if (flag1 || flag2)
{
return(false);
}
if (lhs.Source == rhs.Source)
{
return(true);
}
string fontFamilyPath1 = FontEmbedder.GetFontFamilyPath(lhs.Source);
string fontFamilyPath2 = FontEmbedder.GetFontFamilyPath(rhs.Source);
bool flag3 = !string.IsNullOrEmpty(fontFamilyPath1);
bool flag4 = !string.IsNullOrEmpty(fontFamilyPath2);
if (!flag3 && !flag4 || (!flag3 || !flag4))
{
return(false);
}
return(FontEmbedder.GetFontNameFromSource(FontEmbedder.MakeDesignTimeFontFamily(lhs, documentContext)) == FontEmbedder.GetFontNameFromSource(FontEmbedder.MakeDesignTimeFontFamily(rhs, documentContext)));
}
public static DocumentCompositeNode CreateDataTemplateResource(SceneNode targetElement, IPropertyId templateProperty, string resourceNameBase, IList <DataSchemaNodePath> entries, DataViewCategory category, ITypeId dataTemplateType)
{
SceneViewModel viewModel = targetElement.ViewModel;
IPlatform platform = targetElement.Platform;
IDocumentContext documentContext = viewModel.Document.DocumentContext;
DocumentCompositeNode documentCompositeNode = DataViewFactory.GenerateDataView(platform, documentContext, entries, category);
if (documentCompositeNode == null)
{
return((DocumentCompositeNode)null);
}
DocumentCompositeNode node = documentContext.CreateNode(dataTemplateType);
node.Properties[(IPropertyId)node.Type.Metadata.DefaultContentProperty] = (DocumentNode)documentCompositeNode;
CreateResourceModel createResourceModel = new CreateResourceModel(viewModel, viewModel.DesignerContext.ResourceManager, node.Type.RuntimeType, (Type)null, (string)null, (SceneElement)null, (SceneNode)null, CreateResourceModel.ContextFlags.None);
createResourceModel.KeyString = resourceNameBase;
bool useStaticResource = !JoltHelper.TypeSupported((ITypeResolver)viewModel.ProjectContext, PlatformTypes.DynamicResource);
if (!useStaticResource && !PlatformTypes.FrameworkElement.IsAssignableFrom((ITypeId)targetElement.Type))
{
useStaticResource = true;
}
int index = useStaticResource ? createResourceModel.IndexInResourceSite(targetElement.DocumentNode) : -1;
DocumentCompositeNode resource = createResourceModel.CreateResource((DocumentNode)node, (IPropertyId)null, index);
if (templateProperty != null)
{
DocumentNode resourceReference = createResourceModel.CreateResourceReference(documentContext, resource, useStaticResource);
using (viewModel.AnimationEditor.DeferKeyFraming())
targetElement.SetValue(templateProperty, (object)resourceReference);
}
return((DocumentCompositeNode)resource.Properties[DictionaryEntryNode.ValueProperty]);
}
public static DocumentCompositeNode NewBindingNode(IDocumentContext documentContext, DocumentNode pathNode)
{
DocumentCompositeNode documentCompositeNode = DocumentNodeUtilities.NewBindingNode(documentContext);
documentCompositeNode.Properties[KnownProperties.BindingPathProperty] = pathNode;
return(documentCompositeNode);
}
public static ITypeId SniffRootNodeType(Stream stream, IDocumentContext documentContext, out string xamlClassAttribute)
{
xamlClassAttribute = (string)null;
try
{
ITypeResolver typeResolver = documentContext.TypeResolver;
using (XmlReader xmlReader = XmlReader.Create(stream))
{
ClrNamespaceUriParseCache documentNamespaces = new ClrNamespaceUriParseCache(typeResolver);
while (xmlReader.Read())
{
if (xmlReader.MoveToContent() == XmlNodeType.Element)
{
xamlClassAttribute = xmlReader.GetAttribute("Class", "http://schemas.microsoft.com/winfx/2006/xaml");
string str = xmlReader.LookupNamespace(xmlReader.Prefix);
if (!string.IsNullOrEmpty(str))
{
return((ITypeId)XamlTypeHelper.GetTypeId(typeResolver, documentNamespaces, XmlNamespace.ToNamespace(str, XmlNamespace.GetNamespaceCanonicalization(typeResolver)), xmlReader.LocalName, false, false));
}
}
}
}
}
catch (XmlException ex)
{
}
return((ITypeId)null);
}
public OrderController(IDocumentContext ctx)
{
_ctx = ctx;
//This list of items should obviously not be hardcoded, but rather come from API/Database
items = new List <Item>()
{
new Item()
{
_HId = 1, Text = "Pizza type 1", Price = 19.99
},
new Item()
{
_HId = 2, Text = "Pizza type 2", Price = 15.99
},
new Item()
{
_HId = 3, Text = "Pizza type 3", Price = 21.99
},
new Item()
{
_HId = 4, Text = "Pizza type 4", Price = 24.99
},
new Item()
{
_HId = 5, Text = "Pizza type 5", Price = 29.99
}
};
}
public ResetPasswordCommandHandler(IMediator mediator, ICoreConfiguration coreConfiguration, IRedisContext redisContext, IDocumentContext documentContext)
{
_mediator = mediator;
_coreConfiguration = coreConfiguration;
_redisContext = redisContext;
_documentContext = documentContext;
}
public static DocumentCompositeNode NewTemplateBindingNode(DocumentNode targetNode, IPropertyId sourceProperty, PropertyReference targetProperty)
{
DocumentCompositeNode documentCompositeNode = null;
IDocumentContext context = targetNode.Context;
if (!DocumentNodeUtilities.ShouldUseRelativeSourceTemplateBinding(targetNode, targetProperty))
{
IProperty property = targetNode.TypeResolver.ResolveProperty(sourceProperty);
DocumentNode documentNode = targetNode.Context.CreateNode(PlatformTypes.DependencyProperty, new DocumentNodeMemberValue(property));
documentCompositeNode = targetNode.Context.CreateNode(PlatformTypes.TemplateBinding);
documentCompositeNode.Properties[KnownProperties.TemplateBindingPropertyProperty] = documentNode;
}
else
{
DocumentCompositeNode documentCompositeNode1 = targetNode.Context.CreateNode(PlatformTypes.RelativeSource);
DocumentPrimitiveNode documentPrimitiveNode = targetNode.Context.CreateNode(PlatformTypes.RelativeSourceMode, new DocumentNodeStringValue("TemplatedParent"));
documentCompositeNode1.Properties[KnownProperties.RelativeSourceModeProperty] = documentPrimitiveNode;
IPlatformTypes platformMetadata = (IPlatformTypes)targetNode.PlatformMetadata;
object obj = platformMetadata.MakePropertyPath(sourceProperty.Name, new object[0]);
DocumentNode documentNode1 = targetNode.Context.CreateNode(obj.GetType(), obj);
documentCompositeNode = targetNode.Context.CreateNode(PlatformTypes.Binding);
documentCompositeNode.Properties[KnownProperties.BindingRelativeSourceProperty] = documentCompositeNode1;
documentCompositeNode.Properties[KnownProperties.BindingPathProperty] = documentNode1;
}
return(documentCompositeNode);
}
private static IPlatform GetPlatform(IDocumentContext documentContext)
{
if (documentContext == null)
{
return((IPlatform)null);
}
return(((IProjectContext)documentContext.TypeResolver).Platform);
}
public PageMetaStandardizer(IQueryDispatcher dispatcher, IDocumentContext context)
{
Guard.Against.Null(dispatcher, nameof(dispatcher));
Guard.Against.Null(context, nameof(context));
this.dispatcher = dispatcher;
this.context = context;
}
public CreateAccountCommandHandler(IMediator mediator, IDocumentContext documentContext, ICoreConfiguration coreConfiguration, IEmailService emailService, IMapper mapper)
{
_mediator = mediator;
_coreConfiguration = coreConfiguration;
_documentContext = documentContext;
_emailService = emailService;
_mapper = mapper;
}
public DocumentUnitsController(IDataUnitOfWork unitOfWork, ILogger logger, IMapper mapper, IDocumentContext <ModelDocument.Document, ModelDocument.ArchiveDocument> documentService)
: base(unitOfWork, logger, mapper)
{
_logger = logger;
_unitOfWork = unitOfWork;
_mapper = mapper;
_documentService = documentService;
}
public static FontFamily MakeDesignTimeFontReference(FontFamily fontFamily, IDocumentContext documentContext)
{
if (fontFamily.Source != null && fontFamily.Source.IndexOf('#') != -1)
{
return(FontEmbedder.MakeDesignTimeFontFamily(fontFamily, documentContext));
}
return(fontFamily);
}
public GetUserByEmailQueryHandler(IDocumentContext documentContext, ICoreConfiguration coreConfiguration, IMediator mediator)
{
_mediator = mediator;
_coreConfiguration = coreConfiguration;
_documentContext = documentContext;
//Log Activity, Check Authorization, Etc...
}
public GetAccountDetailsQueryHandler(IDocumentContext documentContext, ICoreConfiguration coreConfiguration, IMediator mediator, IMapper mapper)
{
_mediator = mediator;
_mapper = mapper;
_coreConfiguration = coreConfiguration;
_documentContext = documentContext;
//Log Activity, Check Authorization, Etc...
}
private DocumentCompositeNode CreatePropertyTrigger(IDocumentContext documentContext, IPropertyId propertyId, object value)
{
DocumentCompositeNode node = documentContext.CreateNode(typeof(Trigger));
IProperty property = documentContext.TypeResolver.ResolveProperty(propertyId);
node.Properties[TriggerNode.PropertyProperty] = (DocumentNode)documentContext.CreateNode(PlatformTypes.DependencyProperty, (IDocumentNodeValue) new DocumentNodeMemberValue((IMember)property));
node.Properties[TriggerNode.ValueProperty] = documentContext.CreateNode(value.GetType(), value);
return(node);
}
public FascicleDocumentService(IDataUnitOfWork unitOfWork, ILogger logger, IValidatorService validationService,
IFascicleRuleset fascicleRuleset, IMapperUnitOfWork mapperUnitOfWork, ISecurity security,
IDocumentContext <ModelDocuments.Document, ModelDocuments.ArchiveDocument> documentClient)
: base(unitOfWork, logger, validationService, fascicleRuleset, mapperUnitOfWork, security)
{
_unitOfWork = unitOfWork;
_logger = logger;
_documentClient = documentClient;
}
public static DocumentCompositeNode NewStaticNode(IDocumentContext documentContext, IMember memberId)
{
IPlatformMetadata platformMetadata = documentContext.TypeResolver.PlatformMetadata;
DocumentCompositeNode node = documentContext.CreateNode((ITypeId)documentContext.TypeResolver.ResolveType(platformMetadata.KnownTypes.StaticExtension));
DocumentNode documentNode = (DocumentNode)documentContext.CreateNode(memberId.MemberTypeId, (IDocumentNodeValue) new DocumentNodeMemberValue(memberId));
node.Properties[platformMetadata.KnownProperties.StaticExtensionMember] = documentNode;
return(node);
}
public DocumentPrimitiveNode(IDocumentContext context, ITypeId typeId, IDocumentNodeValue value)
: base(context, typeId)
{
if (value == null && !this.Type.SupportsNullValues)
{
throw new ArgumentException(ExceptionStringTable.DocumentNodeValueTypeValueIsNull);
}
this.value = value;
}
public void NotifyUnderReviewStatus(IDocumentContext documentContext)
{
Trace.WriteLine("incoming comment pending review notice");
}
