static IDocument CreateDocument <TEntity>(IDocumentManagerService documentManagerService, object parameter, object parentViewModel)
{
if (documentManagerService == null)
{
return(null);
}
//BluePrints Customization Start
//var document = documentManagerService.CreateDocument(GetDocumentTypeName<TEntity>(), parameter, parentViewModel);
IDocument document;
var CustomDocumentTypeViewModel = parentViewModel as ISupportCustomDocumentTypeNameAndParameter;
if (CustomDocumentTypeViewModel != null && CustomDocumentTypeViewModel.IsCustomModeEnabled())
{
document = documentManagerService.CreateDocument(CustomDocumentTypeViewModel.GetCustomDocumentTypeName(), CustomDocumentTypeViewModel.GetCustomDocumentParameter(), parentViewModel);
document.Title = CustomDocumentTypeViewModel.GetCustomDocumentTitle();
}
else
{
document = documentManagerService.CreateDocument(GetDocumentTypeName <TEntity>(), parameter, parentViewModel);
}
//BluePrints Customization End
document.Id = "_" + Guid.NewGuid().ToString().Replace('-', '_');
//BluePrints Customization Start
document.DestroyOnClose = true;
//BluePrints Customization End
return(document);
}
static void VerifyService(IDocumentManagerService service)
{
if (service == null)
{
throw new ArgumentNullException("service");
}
}
/// <summary>
/// Searches for a document that contains a single object view model editing entity with a specified primary key.
/// </summary>
/// <param name="documentManagerService">An instance of the IDocumentManager interface used to find a document.</param>
/// <param name="primaryKey">An entity primary key.</param>
public static IDocument FindEntityDocument <TEntity, TPrimaryKey>(this IDocumentManagerService documentManagerService, TPrimaryKey primaryKey, string title = "")
{
if (documentManagerService == null)
{
return(null);
}
foreach (IDocument document in documentManagerService.Documents)
{
if (title != string.Empty)
{
if (document.Title == null)
{
return(null);
}
//BluePrints Customization Start
if (document.Title.ToString() == title)
{
return(document);
}
//BluePrints Customization End
}
else
{
ISingleObjectViewModel <TEntity, TPrimaryKey> entityViewModel = document.Content as ISingleObjectViewModel <TEntity, TPrimaryKey>;
if (entityViewModel != null && object.Equals(entityViewModel.PrimaryKey, primaryKey))
{
return(document);
}
}
}
return(null);
}
public void ActivateWhenDocumentShow()
{
EnqueueShowWindow();
IDocument document = null;
WindowedDocumentUIService service = CreateService();
Interaction.GetBehaviors(Window).Add(service);
IDocumentManagerService iService = service;
EnqueueCallback(() => {
document = iService.CreateDocument("View1",
ViewModelSource.Create(() => new UITestViewModel()
{
Title = "Title1", Parameter = 1
}));
document.Show();
});
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
Assert.AreEqual(iService.ActiveDocument, document);
Assert.IsNotNull(document.Content);
Assert.AreEqual(document.Content, ViewHelper.GetViewModelFromView(service.ActiveView));
Assert.AreEqual(document.Content, ((WindowedDocumentUIService.WindowDocument)document).Window.RealWindow.DataContext);
document.Close();
});
EnqueueTestComplete();
}
protected ReDeliveryViewModel(INextBOUnitOfWork UnitOfWork, IDocumentManagerService documentManager)
{
Documents = UnitOfWork.GetLastDocument();
FindDocumentssByDocNum(UnitOfWork);
unitOfWork = UnitOfWork;
DocumentManagerService = documentManager;
}
public void ClosingDocumentOnWindowClosingShouldntThrow()
{
Window.Show();
DispatcherHelper.DoEvents();
BindingTestClass testClass = new BindingTestClass();
WindowedDocumentUIService service = CreateService();
Interaction.GetBehaviors(Window).Add(service);
IDocumentManagerService iService = service;
IDocument document = null;
WindowedDocumentUIService.WindowDocument typedDocument = null;
var content = new TestDocumentContent();
document = iService.CreateDocument("View1", content);
typedDocument = (WindowedDocumentUIService.WindowDocument)document;
document.Show();
DispatcherHelper.DoEvents();
Window window = typedDocument.Window.RealWindow;
content.onClose = () => document.Close();
window.Close();
DispatcherHelper.DoEvents();
}
protected RouteTrackingCollectionViewModel(INextBOUnitOfWork UnitOfWork, IDocumentManagerService documentManager)
{
Locations = UnitOfWork.GetTaskLogLocations(61542);
GetPointAndShowInMap();
unitOfWork = UnitOfWork;
DocumentManagerService = documentManager;
}
void DoCloseTest(bool?allowClose, bool destroyOnClose, bool destroyed, Action <IDocument, bool> closeMethod)
{
Window.Show();
DispatcherHelper.DoEvents();
IDocumentManagerService service = null;
bool closeChecked = false;
bool destroyCalled = false;
IDocument document = null;
WindowedDocumentUIService windowedDocumentUIService = CreateService();
Interaction.GetBehaviors(Window).Add(windowedDocumentUIService);
service = windowedDocumentUIService;
TestDocumentContent viewModel = new TestDocumentContent(() => {
closeChecked = true;
return(allowClose != null && allowClose.Value);
}, () => {
destroyCalled = true;
});
document = service.CreateDocument("EmptyView", viewModel);
document.Show();
DispatcherHelper.DoEvents();
document.DestroyOnClose = destroyOnClose;
closeMethod(document, allowClose == null);
Assert.AreEqual(allowClose != null, closeChecked);
Assert.AreEqual(destroyed, destroyCalled);
Assert.AreEqual(!destroyed, service.Documents.Contains(document));
}
public void NullService_CreateDocumentIfNotExistsAndShow()
{
IDocumentManagerService service = null;
IDocument newDocument = null;
service.CreateDocumentIfNotExistsAndShow(ref newDocument, "Type", "X", "Y", "title");
}
public static IDocument FindDocument(this IDocumentManagerService service, object viewModel)
{
VerifyService(service);
return(service.Documents.FirstOrDefault(d => {
return d.Content == viewModel;
}));
}
public static IEnumerable <IDocument> GetDocumentsByParentViewModel(this IDocumentManagerService service, object parentViewModel)
{
VerifyService(service);
return(service.Documents.Where(d => {
var supportParentViewModel = d.Content as ISupportParentViewModel;
return supportParentViewModel != null && object.Equals(supportParentViewModel.ParentViewModel, parentViewModel);
}));
}
static IDocument CreateDocument <TEntity>(IDocumentManagerService documentManagerService, object parameter, object parentViewModel)
{
if (documentManagerService == null)
{
return(null);
}
return(documentManagerService.CreateDocument(typeof(TEntity).Name + "View", parameter, parentViewModel));
}
public BrowseEntitiesCommand(IDocumentManagerService documentManagerService, IEntityViewModelFactory entityViewModelFactory)
{
Contract.Requires(documentManagerService != null);
Contract.Requires(entityViewModelFactory != null);
_documentManagerService = documentManagerService;
_entityViewModelFactory = entityViewModelFactory;
}
public static IDocument FindDocumentById(IDocumentManagerService docManager, object id)
{
if (docManager != null && id != null)
{
return(docManager.FindDocumentById(id));
}
return(null);
}
public static IDocument FindDocument(this IDocumentManagerService service, object parameter, object parentViewModel)
{
VerifyService(service);
return(service.GetDocumentsByParentViewModel(parentViewModel).FirstOrDefault(d => {
var supportParameter = d.Content as ISupportParameter;
return supportParameter != null && object.Equals(supportParameter.Parameter, parameter);
}));
}
public static void CloseDocument(IDocumentManagerService documentManagerService, IDocumentContent documentContent, bool force)
{
IDocument document = documentManagerService.FindDocument(documentContent);
if (document != null)
{
document.Close(force);
}
}
/// <summary>
/// Creates and shows a document containing a single object view model for the existing entity.
/// </summary>
/// <param name="documentManagerService">An instance of the IDocumentManager interface used to create and show the document.</param>
/// <param name="parentViewModel">An object that is passed to the view model of the created view.</param>
/// <param name="primaryKey">An entity primary key.</param>
public static void ShowExistingEntityDocument <TEntity, TPrimaryKey>(this IDocumentManagerService documentManagerService, object parentViewModel, TPrimaryKey primaryKey)
{
IDocument document = FindEntityDocument <TEntity, TPrimaryKey>(documentManagerService, primaryKey) ?? CreateDocument <TEntity>(documentManagerService, primaryKey, parentViewModel);
if (document != null)
{
document.Show();
}
}
/// <summary>
/// Creates and shows a document containing a single object view model for new entity.
/// </summary>
/// <param name="documentManagerService">An instance of the IDocumentManager interface used to create and show the document.</param>
/// <param name="parentViewModel">An object that is passed to the view model of the created view.</param>
/// <param name="newEntityInitializer">An optional parameter that provides a function that initializes a new entity.</param>
public static void ShowNewEntityDocument <TEntity>(this IDocumentManagerService documentManagerService, object parentViewModel, Action <TEntity> newEntityInitializer = null)
{
IDocument document = CreateDocument <TEntity>(documentManagerService, newEntityInitializer != null ? newEntityInitializer : x => DefaultEntityInitializer(x), parentViewModel);
if (document != null)
{
document.Show();
}
}
public void NullService()
{
IDocumentManagerService service = null;
IDocument newDocument = null;
Assert.Throws <ArgumentNullException>(() => { service.CreateDocumentIfNotExistsAndShow(ref newDocument, "Type", "X", "Y", "title"); });
Assert.Throws <ArgumentNullException>(() => { service.CreateDocument(new TestViewModel()); });
Assert.Throws <ArgumentNullException>(() => { service.FindDocument("X", "Y"); });
Assert.Throws <ArgumentNullException>(() => { service.GetDocumentsByParentViewModel("X"); });
}
/// <summary>
/// Creates and shows a document containing a single object view model for the existing entity.
/// </summary>
/// <param name="documentManagerService">An instance of the IDocumentManager interface used to create and show the document.</param>
/// <param name="parentViewModel">An object that is passed to the view model of the created view.</param>
/// <param name="primaryKey">An entity primary key.</param>
public static IDocument ShowExistingEntityDocument <TEntity, TPrimaryKey>(this IDocumentManagerService documentManagerService, object parentViewModel, TPrimaryKey primaryKey, string title = "")
{
IDocument document = FindEntityDocument <TEntity, TPrimaryKey>(documentManagerService, primaryKey, title) ?? CreateDocument <TEntity>(documentManagerService, primaryKey, parentViewModel);
if (document != null)
{
document.Show();
}
return(document);
}
public static void CreateDocumentIfNotExistsAndShow(this IDocumentManagerService service, ref IDocument documentStorage, string documentType, object parameter, object parentViewModel, object title)
{
VerifyService(service);
if (documentStorage == null)
{
documentStorage = service.CreateDocument(documentType, parameter, parentViewModel);
documentStorage.Title = title;
}
documentStorage.Show();
}
public static IDocument ShowExistingEntityDocument <TEntity, TKey>(this IDocumentManagerService @this, object parentViewModel, TEntity entity, TKey key)
where TEntity : Entity
{
IDocument document = FindEntityDocument <TEntity, TKey>(@this, key) ?? CreateDocument <TEntity>(@this, entity, parentViewModel);
if (document != null)
{
document.Show();
}
return(null);
}
static IDocument CreateDocument <TEntity>(IDocumentManagerService documentManagerService, object parameter, object parentViewModel)
{
if (documentManagerService == null)
{
return(null);
}
var document = documentManagerService.CreateDocument(GetDocumentTypeName <TEntity>(), parameter, parentViewModel);
document.Id = "_" + Guid.NewGuid().ToString().Replace('-', '_');
document.DestroyOnClose = false;
return(document);
}
public static IDocument CreateDocument(this IDocumentManagerService service, string documentType, object parameter, object parentViewModel, bool useParameterAsViewModel)
{
VerifyService(service);
if (useParameterAsViewModel)
{
return(service.CreateDocument(documentType, parameter, null, parentViewModel));
}
else
{
return(service.CreateDocument(documentType, null, parameter, parameter));
}
}
public static IDocument FindDocumentByIdOrCreate(this IDocumentManagerService service, object id, Func <IDocumentManagerService, IDocument> createDocumentCallback)
{
VerifyService(service);
IDocument document = service.FindDocumentById(id);
if (document == null)
{
document = createDocumentCallback(service);
document.Id = id;
}
return(document);
}
public FileManagerService(
FileManagerContext context,
ILogger <FileManagerService> logger,
IHostingEnvironment appEnvironment,
IDocumentManagerService documentManagerService)
{
db = context;
_logger = logger;
_appEnvironment = appEnvironment;
_documentManagerService = documentManagerService;
InitializeFilesDirectory();
}
public DocumentModel(FileManagerContext context,
ILogger <DocumentModel> logger,
ISmartBreadcrumbService breadcrumbService,
IGetAccountDataService getAccountDataService,
IFileManagerService fileManagerService,
IDocumentManagerService documentManagerService)
{
db = context;
_logger = logger;
_breadcrumbService = breadcrumbService;
_getAccountDataService = getAccountDataService;
_fileManagerService = fileManagerService;
_documentManagerService = documentManagerService;
}
public void TwoWayBindingReadonlyProperty()
{
BindingTestClass testClass = new BindingTestClass();
WindowedDocumentUIService service = CreateService();
Interaction.GetBehaviors(Window).Add(service);
IDocumentManagerService iService = service;
BindingOperations.SetBinding(service, WindowedDocumentUIService.ActiveDocumentProperty,
new Binding()
{
Path = new PropertyPath(BindingTestClass.ReadonlyActiveDocumentProperty), Source = testClass, Mode = BindingMode.Default
});
}
public DocumentStatisticsModel(
//FileManagerContext context,
ILogger <DocumentStatisticsModel> logger,
//ISmartBreadcrumbService breadcrumbService,
IGetAccountDataService getAccountDataService,
//IFileManagerService fileManagerService,
IDocumentManagerService documentManagerService)
{
//db = context;
_logger = logger;
//_breadcrumbService = breadcrumbService;
_getAccountDataService = getAccountDataService;
//_fileManagerService = fileManagerService;
_documentManagerService = documentManagerService;
}
public void ActivateDocumentsWhenClosed()
{
EnqueueShowWindow();
List <IDocument> documents = new List <IDocument>();
WindowedDocumentUIService service = CreateService();
Interaction.GetBehaviors(Window).Add(service);
IDocumentManagerService iService = service;
int counter = 0;
EnqueueCallback(() => {
service.ActiveDocumentChanged += (s, e) => counter++;
for (int i = 0; i < 4; i++)
{
documents.Add(iService.CreateDocument("View" + i,
ViewModelSource.Create(() => new UITestViewModel()
{
Title = "Title" + i, Parameter = i
})));
documents[i].Show();
}
iService.ActiveDocument = documents[1];
});
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
counter = 0;
documents[1].Close();
});
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
Assert.AreEqual(2, counter);
Assert.AreEqual(iService.ActiveDocument, documents[3]);
iService.ActiveDocument = documents[3];
});
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
counter = 0;
documents[3].Close();
});
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
Assert.AreEqual(iService.ActiveDocument, documents[2]);
Assert.AreEqual(2, counter);
documents[0].Close();
documents[2].Close();
});
EnqueueTestComplete();
}
public static void CloseDocument(IDocumentManagerService documentManagerService, IDocumentContent documentContent, bool force) {
IDocument document = documentManagerService.FindDocument(documentContent);
if(document != null)
document.Close(force);
}
static void VerifyService(IDocumentManagerService service) {
if(service == null)
throw new ArgumentNullException("service");
}
