/// <summary> /// Get the Layout information for a supplied Template and Metadata. /// The Metadata is used to lookup identifier information. /// </summary> private TemplateLayout GetTemplateLayout(Template template, DataEntryContract dataEntryContract, string implementation) { // Create the Template Layout // This information can be used to create a new Template in a Different System that structurally matches the original. var templateLayout = new TemplateLayout() { ApiVersion = template.ApiVersion, Description = template.Description, Implementation = implementation, IsSupplement = template.IsSupplement, ModuleType = template.ModuleType, Name = template.Name, Sections = new List <SectionLayout>(), ValidationEnabled = template.ValidationEnabled, IsDefault = false // This Value is not part of the actual Layout. This is a placeholder for data that is managed elsewhere. }; // Create Scaffolding for Each Section foreach (var section in template.Sections) { // Get the Section Metadata var dataEntrySection = dataEntryContract.GetSection(section.DataEntrySectionId); templateLayout.Sections.Add(GetSectionLayout(section, dataEntrySection)); } return(templateLayout); }
/// <summary> /// Load the Layout Information to an Existing Template Instance. /// </summary> /// <param name="layout">The Layout Information to apply.</param> /// <param name="template">The Template Instance to apply the layout to.</param> /// <param name="dataEntryContract">Local Metadata for the Template.</param> private void LoadLayout(TemplateLayout layout, Template template, DataEntryContract dataEntryContract) { // Load the Template Information template.Description = layout.Description; template.IsSupplement = layout.IsSupplement; template.ValidationEnabled = layout.ValidationEnabled; // Apply the Section Layouts foreach (var sectionLayout in layout.Sections) { // Lookup the Section Information var sectionMetadata = dataEntryContract.GetSection(sectionLayout.DataEntrySectionName); var section = template.GetSection(sectionMetadata.Id); // If the Section does not exist in the Template, create a new section // using the layout information and add it to the Template. if (section == null) { // Create a new section using the layout section = template.CreateSection(sectionMetadata.Id, sectionLayout.Label); template.Sections.Add(section); } // Apply the Layout to the Section ApplySectionLayout(sectionLayout, section, sectionMetadata); } }
public static Template Create(Agency agency, DataEntryContract contract) { var template = agency.CreateTemplate(contract.ModuleType, contract.Name); template.Description = contract.Description; BuildSections(template, contract); return(template); }
/// <summary> /// Loads the information in a DataEntryContract into a Template. /// This assumes the template does not already contain information for the contract. /// Remember to Reset the Template Layout First! /// </summary> public void LoadFromMeta(Template template, DataEntryContract dataEntryContract) { foreach (var dataEntrySection in dataEntryContract.Sections.OrderBy(x => x.OrderBy)) { var section = template.CreateSection(dataEntrySection.Id, dataEntrySection.Label); LoadFromMeta(section, dataEntrySection); } }
private DataEntryContract CreateDataEntryContract(ModuleType moduleType) { var dataEntryContract = new DataEntryContract { ModuleType = moduleType }; return(dataEntryContract); }
private static void BuildSections(Template template, DataEntryContract contract) { foreach (var dataEntrySection in contract.Sections.OrderBy(x => x.OrderBy)) { var section = template.CreateSection(dataEntrySection.Name, dataEntrySection.SectionType); section.OrderBy = dataEntrySection.OrderBy; section.Description = dataEntrySection.Description; BuildFields(section, dataEntrySection); } }
public void MetadataQueryService_GetDataEntryContractForCitation() { var metadataQueryService = GetDependency <IDataEntryMetadataQueryService>(); Assert.IsInstanceOfType(metadataQueryService, typeof(IDataEntryMetadataQueryService)); DataEntryContract dataEntryContract = metadataQueryService.GetDataEntryContract(ModuleType.Citation); Assert.IsNotNull(dataEntryContract); Assert.AreEqual(ModuleType.Citation, dataEntryContract.ModuleType); Assert.IsInstanceOfType(dataEntryContract, typeof(DataEntryContract)); }
public void GetMetaData_PasswordController_MoqTest() { mockIDataEntryMetadataQueryService.Setup(x => x.GetDataEntryContract(It.IsAny <ModuleType>())) .Returns(dataEntryContract); var controller = new TemplateMetaController(mockIDataEntryMetadataQueryService.Object, mockIDataEntryMetadataCommandService.Object); DataEntryContract actionResult = controller.GetMetaData(It.IsAny <ModuleType>()); Assert.AreEqual(dataEntryContract.Id, actionResult.Id); Assert.AreEqual(dataEntryContract.ModuleType, actionResult.ModuleType); Assert.AreEqual(dataEntryContract.TypeName, actionResult.TypeName); Assert.IsNull(actionResult.Sections); }
public void CreateCustomField() { var dataEntryContractList = new List <DataEntryContract>(); var dataEntryContractDetails = new DataEntryContract(); dataEntryContractDetails.ModuleType = ModuleType.Arrest; dataEntryContractList.Add(dataEntryContractDetails); _metadataUnitOfWork.Setup(mock => mock.GetEntityQuery <DataEntryContract>(TrackingMode.Automatic)).Returns(dataEntryContractList.AsQueryable()); var dataEntryContract = _dataEntryMetadataQueryService.GetDataEntryContract(ModuleType.Arrest); dataEntryContract.Should().NotBeNull(); dataEntryContract.Should().BeOfType(typeof(DTO.DataEntryContract)); dataEntryContract.ModuleType.Should().Be(dataEntryContractDetails.ModuleType); _metadataUnitOfWork.VerifyAll(); }
private static void ProcessDataContractSections(DataEntryContract contract, Type type, string implementation) { foreach (var property in type.GetProperties()) { // Get the type of the Section var sectionType = PropertyTypeIsCollectionOfSections(property) ? GenericParameterType(property.PropertyType) : property.PropertyType; // Get the Section Attribute from the Property Type var sectionAttribute = GetSectionAttribute(sectionType); // Only Process Section Types if (sectionAttribute == null) { continue; } // Get the Section Attribute var sectionAttr = GetSectionAttribute(sectionType); // If the property is not a section continue if (sectionAttr == null) { continue; } // Create a DataEntrySection var dataEntrySection = new DataEntrySection() { OrderBy = contract.Sections.Count, Name = property.Name, Path = property.Name.ToPascalCase(), Label = GetLabel(property) ?? property.Name.ToEnglish(), Description = GetDescription(sectionType), IsCollection = IsCollection(property.PropertyType), PropertyName = property.Name, SectionType = sectionAttr.SectionType, TypeName = sectionType.FullName }; // Add the section to the contract contract.Sections.Add(dataEntrySection); // Process the properties on the Section's Type. ProcessSectionProperties(dataEntrySection, sectionType, null, null, implementation); } }
private static void ProcessSectionProperty(DataEntryContract contract, PropertyInfo property, Type sectionType, SectionAttribute sectionAttribute) { // Create the Section Metadata var sectionContract = new DataEntrySection() { OrderBy = contract.Sections.Count, Name = property.Name, Path = property.Name.ToPascalCase(), Label = GetLabel(property) ?? MakeEnglish(property.Name), Description = GetDescription(sectionType), AllowMultiple = IsCollection(property.PropertyType), PropertyName = property.Name, SectionType = sectionAttribute.SectionType, TypeName = sectionType.FullName }; // Process the Field Metadata ProcessSectionFields(sectionContract, sectionAttribute, sectionType); contract.Sections.Add(sectionContract); }
private static void ProcessContractSections(DataEntryContract contract, Type contractType) { foreach (var property in contractType.GetProperties()) { // Get the type of the Section var sectionType = PropertyTypeIsCollectionOfSections(property) ? GenericParameterType(property.PropertyType) : property.PropertyType; // Get the Section Attribute from the Property Type var sectionAttribute = GetSectionAttribute(sectionType); // Only Process Section Types if (sectionAttribute == null) { continue; } // Process the Section ProcessSectionProperty(contract, property, sectionType, sectionAttribute); } }
public static DataEntryContract GetContractInfo(Type type) { // Make sure the Contract is Annotated var contractAttribute = type.GetCustomAttribute <DataEntryContractAttribute>(); if (contractAttribute == null) { return(null); } // Process the Contract Information var contract = new DataEntryContract(GetId(type)) { Name = string.Concat("TriTech ", contractAttribute.ModuleType.GetDescription(), " Default"), Description = GetDescription(type), ModuleType = contractAttribute.ModuleType, DataEntryType = contractAttribute.DataEntryType, TypeName = type.FullName }; ProcessContractSections(contract, type); return(contract); }
private void UpdateMetadata(DataEntryContract source, DataEntryContract destination) { // Update the Contract Information destination.DataEntryType = source.DataEntryType; destination.Description = source.Description; destination.Name = source.Name; destination.TypeName = source.TypeName; // Update any matching sections var sectionsToUpdate = source.Sections.Where(x => destination.Sections.Any(y => y.Path == x.Path)).ToList(); sectionsToUpdate.ForEach(sourceSection => { var destinationSection = destination.Sections.First(x => x.Path == sourceSection.Path); UpdateMetadata(sourceSection, destinationSection); }); // Find Sections that Need to be Added var sectionsToAdd = source.Sections.Where(x => destination.Sections.All(y => y.Path != x.Path)).ToList(); // Add the New Section Metadata sectionsToAdd.ForEach(destination.Sections.Add); }
public static DataEntryContract GetContractInfo(Type type, string implementation = StateImplementations.Generic) { if (type == null) { return(null); } // Make sure the Contract is Annotated as a Data Entry Contract var dataEntryContractAttr = type.GetCustomAttribute <DataEntryContractAttribute>(); if (dataEntryContractAttr == null) { return(null); } // Create the DataEntryContract var dataEntryContract = new DataEntryContract(GetId(type)) { // Default Name Name = GetContractNameForModule(dataEntryContractAttr.ModuleType), // Description Description = GetDescription(type), // Module Type ModuleType = dataEntryContractAttr.ModuleType, // Report/Summary DataEntryType = dataEntryContractAttr.DataEntryType, // Type Name TypeName = type.FullName }; // Process the Properties of the type attributed as Sections. ProcessDataContractSections(dataEntryContract, type, implementation); // Return the DataEntryContract return(dataEntryContract); }