/// <summary>
/// Creates a document object from the specified document contract.
/// </summary>
/// <param name="context"></param>
/// <param name="contract"></param>
/// <returns></returns>
public static TestDocument Create(DocumentLibraryContext context, DocumentContract contract)
{
TestDocument document = new TestDocument()
{
TestDocumentId = SequentialGuid.NewGuid(),
Application = contract.Application,
AppVersion = contract.AppVersion,
Author = contract.Author,
AuthorType = contract.AuthorType,
ColorMode = contract.ColorMode,
DefectId = contract.DefectId,
FileName = contract.FileName,
FileSize = contract.FileSize,
FileType = contract.FileType,
Notes = contract.Notes,
Orientation = contract.Orientation,
Pages = contract.Pages,
SubmitDate = contract.SubmitDate,
Submitter = contract.Submitter,
Tag = contract.Tag,
Vertical = contract.Vertical,
};
TestDocumentExtension extension = context.TestDocumentExtensions.FirstOrDefault(x => x.Extension.Equals(contract.Extension));
document.TestDocumentExtension = extension;
return(document);
}
public ManifestDocumentAgent(Guid scenarioId)
{
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
// Retrieve document usage data for all enabled activities in the specified session
var activities = (from documentUsage in context.VirtualResourceMetadataDocumentUsages
let data = documentUsage.DocumentSelectionData
let metadata = documentUsage.VirtualResourceMetadata
let resource = metadata.VirtualResource
where resource.EnterpriseScenarioId == scenarioId &&
resource.Enabled == true &&
metadata.Enabled == true &&
data != null
select new { Id = metadata.VirtualResourceMetadataId, Documents = data }).ToList();
foreach (var activity in activities)
{
DocumentSelectionData documentSelectionData = GetSelectionData(activity.Documents);
_activityDocuments.Add(activity.Id, GetDocuments(documentSelectionData));
}
}
var documentIds = _activityDocuments.Values.SelectMany(n => n).Distinct().ToList();
using (DocumentLibraryContext context = DbConnect.DocumentLibraryContext())
{
var documents = context.TestDocuments.Where(n => documentIds.Contains(n.TestDocumentId)).ToDocumentCollection();
_documents.AddRange(documents);
}
}
public GenericRepository(DocumentLibraryContext context)
{
_context = context ?? throw new ArgumentException(
"An instance of DbContext is required to use this repository.", nameof(context));
DbSet = context.Set <T>();
}
public void LogComponents(string sessionId)
{
var documentIds = _activityDocuments.Values.SelectMany(n => n).Distinct().ToList();
using (DocumentLibraryContext context = DbConnect.DocumentLibraryContext())
{
foreach (var doc in context.TestDocuments.Where(n => documentIds.Contains(n.TestDocumentId)))
{
SessionDocumentLogger logger = new SessionDocumentLogger
{
SessionDocumentId = SequentialGuid.NewGuid(),
SessionId = sessionId,
DocumentId = doc.TestDocumentId,
FileName = doc.FileName,
Extension = doc.Extension,
FileType = doc.FileType,
FileSizeKilobytes = doc.FileSize,
Pages = (short)doc.Pages,
ColorMode = doc.ColorMode,
Orientation = doc.Orientation,
DefectId = doc.DefectId,
Tag = doc.Tag
};
ExecutionServices.DataLogger.AsInternal().SubmitAsync(logger);
}
}
}
/// <summary>
/// Saves documents from the specified composite contract to the Document Library.
/// </summary>
/// <param name="composite">The EnterpriseScenarioCompositeContract.</param>
/// <returns>true if the operation completed successfully.</returns>
public static bool ProcessCompositeContractFile(EnterpriseScenarioCompositeContract composite)
{
using (DocumentLibraryContext context = DbConnect.DocumentLibraryContext())
{
bool changesMade = false;
foreach (DocumentContract documentContract in composite.Documents)
{
if (CanInsertDocument(documentContract, context))
{
TestDocument documentEntity = ContractFactory.Create(context, documentContract);
WriteDocumentToServer(documentEntity, GlobalSettings.Items[Setting.DocumentLibraryServer], documentContract.Data);
context.TestDocuments.Add(documentEntity);
changesMade = true;
}
}
if (changesMade)
{
context.SaveChanges();
}
}
return(true);
}
private static DocumentIdCollection GetDocumentsFromSet(string documentSetName)
{
using (DocumentLibraryContext context = DbConnect.DocumentLibraryContext())
{
var documentSet = context.TestDocumentSets.Include(n => n.TestDocumentSetItems).FirstOrDefault(n => n.Name == documentSetName);
return(new DocumentIdCollection(documentSet.TestDocumentSetItems.OrderBy(n => n.SortOrder).Select(n => n.TestDocumentId)));
}
}
public DocumentEditForm(TestDocument document, DocumentLibraryContext context)
{
InitializeComponent();
UserInterfaceStyler.Configure(this, FormStyle.FixedDialog);
ShowIcon = true;
_document = document;
_context = context;
_error.BlinkStyle = ErrorBlinkStyle.NeverBlink;
}
/// <summary>
/// Initializes a new instance of the <see cref="DocumentListForm"/> class.
/// </summary>
public DocumentListForm()
{
InitializeComponent();
UserInterfaceStyler.Configure(this, FormStyle.SizeableDialog);
ShowIcon = true;
UserInterfaceStyler.Configure(radGridViewDocuments, GridViewStyle.ReadOnly);
_context = DbConnect.DocumentLibraryContext();
_documents = new SortableBindingList <TestDocument>();
}
public static DocumentLibraryContext BuildDbContext(
IConfigurationRoot config, string connectionStringName, IUserService userService)
{
string documentLibraryConnectionString = config.GetConnectionString(connectionStringName);
var optionsBuilder = new DbContextOptionsBuilder <DocumentLibraryContext>();
optionsBuilder
.UseSqlServer(documentLibraryConnectionString);
var documentLibraryContext =
new DocumentLibraryContext(optionsBuilder.Options, userService);
return(documentLibraryContext);
}
/// <summary>
/// Scans the Test Document Library for the documents contained in this ScenarioContract.
/// </summary>
public void ScanTestDocuments()
{
List <string> databaseFiles = null;
using (DocumentLibraryContext context = DbConnect.DocumentLibraryContext())
{
databaseFiles = context.TestDocuments.Select(x => x.TestDocumentExtension.Location + @"\" + x.FileName).ToList();
}
var missingDocuments = TestDocuments.Where(x => !databaseFiles.Any(y => x.Original.Equals(y))).Distinct();
foreach (var document in missingDocuments)
{
document.ResolutionRequired = true;
}
}
/// <summary>
/// Creates composite contract data for the specified scenario.
/// Scenario data + Printer data + Document data.
/// </summary>
/// <param name="scenario"></param>
/// <param name="includePrinters">When true, causes all print device data to be serialized as part of the export process.</param>
/// <param name="includeDocuments">When true, causes the documents to be serialized as part of the export process</param>
/// <returns></returns>
public static EnterpriseScenarioCompositeContract Create(EnterpriseScenario scenario, bool includePrinters, bool includeDocuments)
{
var scenarioContract = Create(scenario);
var contract = new EnterpriseScenarioCompositeContract(scenarioContract);
if (includePrinters)
{
using (var context = DbConnect.AssetInventoryContext())
{
foreach (var printer in contract.Scenario.AllAssets.Where(x => x.AssetType == "Printer"))
{
var asset = context.Assets.OfType <Printer>().FirstOrDefault(x => x.AssetId.Equals(printer.AssetId));
if (asset != null)
{
contract.Printers.Add(Create <PrinterContract>(asset));
UpdateStatus("Exporting {0}".FormatWith(printer.AssetId));
}
else
{
TraceFactory.Logger.Error("Asset Id {0} was NULL".FormatWith(printer.AssetId));
UpdateStatus("Missing {0}".FormatWith(printer.AssetId));
}
}
}
}
if (includeDocuments)
{
using (DocumentLibraryContext context = DbConnect.DocumentLibraryContext())
{
foreach (var documentContract in contract.Scenario.TestDocuments)
{
string fileName = Path.GetFileName(documentContract.Original);
TestDocument document = context.TestDocuments.Include(n => n.TestDocumentExtension).FirstOrDefault(x => x.FileName.Equals(fileName));
if (document != null)
{
contract.Documents.Load(document, includeDocuments);
UpdateStatus("Exporting {0}".FormatWith(fileName));
}
}
}
}
return(contract);
}
private static IEnumerable <string> ValidateUsages(EnterpriseScenario scenario)
{
List <VirtualResourceMetadata> metadatas = scenario.VirtualResources.SelectMany(v => v.VirtualResourceMetadataSet).ToList();
AssetInventoryContext assetContext = DbConnect.AssetInventoryContext();
DocumentLibraryContext docContext = DbConnect.DocumentLibraryContext();
try
{
StringBuilder message = new StringBuilder();
foreach (VirtualResourceMetadata metadata in metadatas)
{
message.Clear();
if (!ValidatePrintQueueUsage(metadata.PrintQueueUsage, assetContext))
{
message.Append(metadata.Name);
message.Append(" has no Print Queue definition");
}
if (!ValidateDocumentUsage(metadata.DocumentUsage, docContext))
{
message.Append(message.Length == 0 ? $"{metadata.Name} has no " : " or ");
message.Append("documents selected");
}
if (message.Length > 0)
{
message.Append(".");
yield return(message.ToString());
}
}
}
finally
{
assetContext.Dispose();
docContext.Dispose();
}
}
public GenreRepository(DocumentLibraryContext context, IMapper mapper) : base(context)
{
_context = context;
_mapper = mapper;
}
public static void Seed(IConfigurationRoot config, string connectionStringName, IUserService userService)
{
DocumentLibraryContext dbContext =
BuildDbContext(config, connectionStringName, userService);
dbContext.Database.EnsureCreated();
if (dbContext.Books.Any())
{
return;
}
;
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(dbContext),
null,
null,
null,
null);
SeedRole(roleManager, UserRoles.Admin);
SeedRole(roleManager, UserRoles.StandardUser);
var adminUser = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "John",
LastName = "Doe"
};
string adminUserPassword = "******";
var standardUser = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Richard",
LastName = "Roe"
};
string standardUserPassword = "******";
var optionsInstance = new IdentityOptions
{
Password =
{
RequireDigit = true
}
};
IOptions <IdentityOptions> optionParameter = Options.Create(optionsInstance);
var userManager = new UserManager <ApplicationUser>(
new UserStore <ApplicationUser>(dbContext),
optionParameter,
new PasswordHasher <ApplicationUser>(),
null,
null,
null,
null,
null,
null);
SeedUser(userManager, adminUser, adminUserPassword, UserRoles.Admin);
SeedUser(userManager, standardUser, standardUserPassword, UserRoles.StandardUser);
var sciFiGenre = new Genre
{
Name = "Sci-Fi"
};
var fictionGenre = new Genre
{
Name = "Fiction"
};
var popularScience = new Genre
{
Name = "Popular science"
};
var tragedy = new Genre
{
Name = "Tragedy"
};
var books = new List <Book>
{
new Book
{
Name = "Space Odyssey",
Description = "One of the best sci-fi books in the world",
Genre = sciFiGenre,
Keywords = new List <Keyword>
{
new Keyword {
Name = "adventure"
},
new Keyword {
Name = "space"
},
new Keyword {
Name = "artificial intelligence"
},
new Keyword {
Name = "astronaut"
}
},
PublicationDate = new DateTime(1968, 8, 23),
BookCheckouts = new List <BookCheckout>
{
new BookCheckout
{
ApplicationUser = standardUser,
AvailabilityDate = DateTime.Now.AddDays(5)
}
}
},
new Book
{
Name = "Gone with the wind",
Description = "One of the top fiction books of the 20th century",
Genre = fictionGenre,
Keywords = new List <Keyword>
{
new Keyword {
Name = "crime"
},
new Keyword {
Name = "drama"
}
},
PublicationDate = new DateTime(1936, 6, 30)
},
new Book
{
Name = "Brief history of time",
Genre = popularScience,
Keywords = new List <Keyword>
{
new Keyword {
Name = "science"
},
new Keyword {
Name = "theoretical physics"
},
new Keyword {
Name = "quantum mechanics"
}
},
PublicationDate = new DateTime(1988, 7, 29)
},
new Book
{
Name = "The Great Gatsby",
Description = "The Great Gatsby provides a critical social history of Prohibition-era America during the Jazz Age",
Genre = tragedy,
Keywords = new List <Keyword>
{
new Keyword {
Name = "tragedy"
},
new Keyword {
Name = "jazz era"
}
},
PublicationDate = new DateTime(1925, 11, 16)
}
};
dbContext.Books.AddRange(books);
dbContext.SaveChanges();
}
private static bool ValidateDocumentUsage(VirtualResourceMetadataDocumentUsage docUsage, DocumentLibraryContext context)
{
bool result = true;
if (docUsage != null)
{
DocumentSelectionData docSelection = Serializer.Deserialize <DocumentSelectionData>(XElement.Parse(docUsage.DocumentSelectionData));
foreach (Guid docId in docSelection.SelectedDocuments)
{
result &= context.TestDocuments.Any(d => d.TestDocumentId == docId);
}
}
return(result);
}
/// <summary>
/// Can insert the document if:
/// 1. DocumentContract.Data is not empty AND
/// 2. A document with the same file name doesn't already exist in the database.
/// </summary>
/// <param name="contract">The DocumentContract.</param>
/// <param name="context">The document Database context.</param>
/// <returns></returns>
private static bool CanInsertDocument(DocumentContract contract, DocumentLibraryContext context)
{
return(!string.IsNullOrEmpty(contract.Data) &&
!context.TestDocuments.Any(x => x.FileName.Equals(contract.FileName, StringComparison.OrdinalIgnoreCase)));
}
