PartTemplate work

src/Domain.LinnApps/Parts/PartTemplate.cs

@@ -12,6 +12,10 @@ public class PartTemplate
 
         public int? NextNumber { get; set; }
 
+        public string AllowVariants { get; set; }
+
+        public string Variants { get; set; }
+
         public string AccountingCompany { get; set; }
 
         public string ProductCode { get; set; }
@@ -22,6 +26,8 @@ public class PartTemplate
 
         public string BomType { get; set; }
 
+        public string RmFg { get; set; }
+
         public string AssemblyTechnology { get; set; }
 
         public string AllowPartCreation { get; set; }

src/Facade/ResourceBuilders/PartTemplateResourceBuilder.cs

@@ -15,10 +15,13 @@ public PartTemplateResource Build(PartTemplate model)
                            HasDataSheet = model.HasDataSheet,
                            HasNumberSequence = model.HasNumberSequence,
                            NextNumber = model.NextNumber,
+                           AllowVariants = model.AllowVariants,
+                           Variants = model.Variants,
                            AccountingCompany = model.AccountingCompany,
                            ProductCode = model.ProductCode,
                            StockControlled = model.StockControlled,
                            LinnProduced = model.LinnProduced,
+                           RmFg = model.RmFg,
                            BomType = model.BomType,
                            AssemblyTechnology = model.AssemblyTechnology,
                            AllowPartCreation = model.AllowPartCreation,

src/Facade/Services/PartTemplateService.cs

@@ -17,12 +17,47 @@ public PartTemplateService(IRepository<PartTemplate, string> repository, ITransa
 
         protected override PartTemplate CreateFromResource(PartTemplateResource resource)
         {
-            throw new NotImplementedException();
+            var partTemplate = new PartTemplate
+            {
+                PartRoot = resource.PartRoot,
+                Description = resource.Description,
+                HasDataSheet = resource.HasDataSheet,
+                HasNumberSequence = resource.HasNumberSequence,
+                NextNumber = resource.NextNumber,
+                AllowVariants = resource.AllowVariants,
+                Variants = resource.Variants,
+                AccountingCompany = resource.AccountingCompany,
+                ProductCode = resource.ProductCode,
+                StockControlled = resource.StockControlled,
+                LinnProduced = resource.LinnProduced,
+                BomType = resource.BomType,
+                RmFg = resource.RmFg,
+                AssemblyTechnology = resource.AssemblyTechnology,
+                AllowPartCreation = resource.AllowPartCreation,
+                ParetoCode = resource.ParetoCode
+            };
+
+            return partTemplate;
         }
 
         protected override void UpdateFromResource(PartTemplate entity, PartTemplateResource updateResource)
         {
-            throw new NotImplementedException();
+            entity.PartRoot = updateResource.PartRoot;
+            entity.Description = updateResource.Description;
+            entity.HasDataSheet = updateResource.HasDataSheet;
+            entity.HasNumberSequence = updateResource.HasNumberSequence;
+            entity.NextNumber = updateResource.NextNumber;
+            entity.AllowVariants = updateResource.AllowVariants;
+            entity.Variants = updateResource.Variants;
+            entity.AccountingCompany = updateResource.AccountingCompany;
+            entity.ProductCode = updateResource.ProductCode;
+            entity.StockControlled = updateResource.StockControlled;
+            entity.LinnProduced = updateResource.LinnProduced;
+            entity.BomType = updateResource.BomType;
+            entity.RmFg = updateResource.RmFg;
+            entity.AssemblyTechnology = updateResource.AssemblyTechnology;
+            entity.AllowPartCreation = updateResource.AllowPartCreation;
+            entity.ParetoCode = updateResource.ParetoCode;
         }
 
         protected override Expression<Func<PartTemplate, bool>> SearchExpression(string searchTerm)

src/Persistence.LinnApps/Repositories/PartTemplateRepository.cs

@@ -35,7 +35,7 @@ public IQueryable<PartTemplate> FindAll()
 
         public void Add(PartTemplate entity)
         {
-            throw new NotImplementedException();
+            this.serviceDbContext.PartTemplates.Add(entity);
         }
 
         public void Remove(PartTemplate entity)

src/Persistence.LinnApps/ServiceDbContext.cs

@@ -686,11 +686,14 @@ private void BuildPartTemplates(ModelBuilder builder)
             e.Property(p => p.StockControlled).HasColumnName("STOCK_CONTROLLED").HasMaxLength(1);
             e.Property(p => p.LinnProduced).HasColumnName("LINN_PRODUCED").HasMaxLength(1);
             e.Property(p => p.BomType).HasColumnName("BOM_TYPE").HasMaxLength(1);
+            e.Property(p => p.RmFg).HasColumnName("RM_FG").HasMaxLength(1);
             e.Property(p => p.ParetoCode).HasColumnName("PARETO_CODE").HasMaxLength(2);
             e.Property(p => p.AssemblyTechnology).HasColumnName("ASSEMBLY_TECHNOLOGY");
             e.Property(p => p.HasDataSheet).HasColumnName("HAS_DATASHEET").HasMaxLength(1);
             e.Property(p => p.HasNumberSequence).HasColumnName("NUMBER_SEQUENCE").HasMaxLength(1);
             e.Property(p => p.NextNumber).HasColumnName("NEXT_NUMBER");
+            e.Property(p => p.AllowVariants).HasColumnName("ALLOW_VARIANTS").HasMaxLength(1);
+            e.Property(p => p.Variants).HasColumnName("VARIANTS").HasMaxLength(255);
             e.Property(p => p.ProductCode).HasColumnName("PRODUCT_CODE").HasMaxLength(10);
             e.Property(p => p.AllowPartCreation).HasColumnName("ALLOW_PART_CREATION").HasMaxLength(1);
             e.Property(p => p.AccountingCompany).HasColumnName("ACCOUNTING_COMPANY");

src/Resources/Parts/PartTemplateResource.cs

@@ -12,6 +12,10 @@ public class PartTemplateResource
 
         public int? NextNumber { get; set; }
 
+        public string AllowVariants { get; set; }
+
+        public string Variants { get; set; }
+
         public string AccountingCompany { get; set; }
 
         public string ProductCode { get; set; }
@@ -22,6 +26,8 @@ public class PartTemplateResource
 
         public string BomType { get; set; }
 
+        public string RmFg { get; set; }
+
         public string AssemblyTechnology { get; set; }
 
         public string AllowPartCreation { get; set; }

src/Service.Host/client/src/actions/index.js

@@ -20,6 +20,8 @@ export const rootProductsActionTypes = makeActionTypes(itemTypes.rootProducts.ac
 
 export const partCategoriesActionTypes = makeActionTypes(itemTypes.partCategories.actionType);
 
+export const partTemplateActionTypes = makeActionTypes(itemTypes.partTemplate.actionType);
+
 export const partTemplatesActionTypes = makeActionTypes(itemTypes.partTemplates.actionType);
 
 export const partLiveTestActionTypes = makeActionTypes(itemTypes.partLiveTest.actionType);

src/Service.Host/client/src/actions/partTemplateActions.js

@@ -0,0 +1,12 @@
+import { UpdateApiActions } from '@linn-it/linn-form-components-library';
+import { partTemplateActionTypes as actionTypes } from './index';
+import * as itemTypes from '../itemTypes';
+import config from '../config';
+
+export default new UpdateApiActions(
+    itemTypes.partTemplate.item,
+    itemTypes.partTemplate.actionType,
+    itemTypes.partTemplate.uri,
+    actionTypes,
+    config.appRoot
+);

src/Service.Host/client/src/containers/parts/Part.js

@@ -20,8 +20,10 @@ import partCategoriesSelectors from '../../selectors/partCategoriesSelectors';
 import sernosSequencesSelectors from '../../selectors/sernosSequencesSelectors';
 import suppliersSelectors from '../../selectors/suppliersSelectors';
 import unitsOfMeasureSelectors from '../../selectors/unitsOfMeasureSelectors';
+import partTemplateActions from '../../actions/partTemplateActions';
 import partTemplatesActions from '../../actions/partTemplatesActions';
 import partTemplateSelectors from '../../selectors/partTemplatesSelectors';
+import partTemplatesSelectors from '../../selectors/partTemplatesSelectors';
 import { getPrivileges, getUserName, getUserNumber } from '../../selectors/userSelectors';
 import * as itemTypes from '../../itemTypes';
 import partLiveTestSelectors from '../../selectors/partLiveTestSelectors';
@@ -49,7 +51,7 @@ const mapStateToProps = (state, { match, location }) => ({
     userName: getUserName(state),
     userNumber: getUserNumber(state),
     templateName: queryString.parse(location?.search)?.template,
-    partTemplates: partTemplateSelectors.getItems(state),
+    partTemplates: partTemplatesSelectors.getItems(state),
     liveTest: creating(match) ? null : partLiveTestSelectors.getItem(state),
     partsSearchResults: partsSelectors.getSearchItems(state),
     previousPaths: getPreviousPaths(state)

src/Service.Host/client/src/containers/parts/Parts.js

@@ -6,13 +6,16 @@ import partsSelectors from '../../selectors/partsSelectors';
 import { getPrivileges } from '../../selectors/userSelectors';
 import partTemplatesActions from '../../actions/partTemplatesActions';
 import partTemplatesSelectors from '../../selectors/partTemplatesSelectors';
+import partTemplateActions from '../../actions/partTemplatesActions';
+import partTemplateSelectors from '../../selectors/partTemplatesSelectors';
 
 const mapStateToProps = (state, { match }) => ({
     linkToSources: match?.url?.endsWith('/sources'),
     items: partsSelectors.getSearchItems(state),
     loading: partsSelectors.getSearchLoading(state),
     privileges: getPrivileges(state),
-    partTemplates: partTemplatesSelectors.getItems(state)
+    partTemplates: partTemplatesSelectors.getItems(state),
+    partTemplate: partTemplateSelectors.getItem(state)
 });
 
 const initialise = () => dispatch => {

src/Service.Host/client/src/itemTypes.js

@@ -24,6 +24,12 @@ export const partCategories = new ItemType(
     '/inventory/part-categories'
 );
 
+export const partTemplate = new ItemType(
+    'partTemplate',
+    'PART_TEMPLATE',
+    '/inventory/part-templates'
+);
+
 export const partTemplates = new ItemType(
     'partTemplates',
     'PART_TEMPLATES',

src/Service.Host/client/src/reducers/index.js

@@ -12,6 +12,7 @@ import accountingCompanies from './accountingCompanies';
 import nominal from './nominal';
 import parts from './parts/parts';
 import part from './parts/part';
+import partTemplate from './parts/partTemplate';
 import partTemplates from './parts/partTemplates';
 import partLiveTest from './parts/partLiveTest';
 import partCategories from './partCategories';
@@ -202,6 +203,7 @@ const rootReducer = history =>
         partLiveTest,
         parts,
         partStorageTypes,
+        partTemplate,
         partTemplates,
         pickItemsAllocation,
         ports,

src/Service.Host/client/src/reducers/parts/partTemplate.js

@@ -0,0 +1,14 @@
+import { collectionStoreFactory } from '@linn-it/linn-form-components-library';
+import { partTemplateActionTypes as actionTypes } from '../../actions';
+import * as itemTypes from '../../itemTypes';
+
+const defaultState = {
+    loading: false,
+    items: []
+};
+
+export default collectionStoreFactory(
+    itemTypes.partTemplate.actionType,
+    actionTypes,
+    defaultState
+);

src/Service.Host/client/src/selectors/partTemplateSelectors.js

@@ -0,0 +1,4 @@
+import { ItemSelectors } from '@linn-it/linn-form-components-library';
+import * as itemTypes from '../itemTypes';
+
+export default new ItemSelectors(itemTypes.partTemplate.item);

src/Service/Modules/PartsModule.cs

@@ -99,6 +99,9 @@ public PartsModule(
 
             this.partTemplateService = partTemplateService;
             this.Get("/inventory/part-templates", _ => this.GetPartTemplates());
+            this.Get("/inventory/part-templates/{id}", parameters => this.GetPartTemplate(parameters.id));
+            this.Put("/inventory/part-templates/{id}", parameters => this.UpdatePartTemplate(parameters.id));
+            this.Post("/inventory/part-templates", parameters => this.AddPartTemplate());
 
             this.productAnalysisCodeService = productAnalysisCodeService;
             this.Get("inventory/product-analysis-codes", _ => this.GetProductAnalysisCodes());
@@ -230,6 +233,33 @@ private object GetPartCategories()
                 .WithMediaRangeModel("text/html", ApplicationSettings.Get);
         }
 
+        private object AddPartTemplate()
+        {
+            this.RequiresAuthentication();
+            var resource = this.Bind<PartTemplateResource>();
+            var result = this.partTemplateService.Add(resource);
+            return this.Negotiate.WithStatusCode(HttpStatusCode.Created)
+                .WithModel(result)
+                .WithMediaRangeModel("text/html", ApplicationSettings.Get)
+                .WithView("Index");
+        }
+
+        private object GetPartTemplate(string id)
+        {
+            var result = this.partTemplateService.GetById(id);
+            return this.Negotiate.WithModel(result)
+                .WithMediaRangeModel("text/html", ApplicationSettings.Get);
+        }
+
+        private object UpdatePartTemplate(string id)
+        {
+            this.RequiresAuthentication();
+            var resource = this.Bind<PartTemplateResource>();
+            var result = this.partTemplateService.Update(id, resource);
+            return this.Negotiate.WithModel(result)
+                .WithMediaRangeModel("text/html", ApplicationSettings.Get);
+        }
+
         private object GetPartTemplates()
         {
             var result = this.partTemplateService.GetAll();

src/Service/ResponseProcessors/PartTemplateResponseProcessor.cs

@@ -0,0 +1,15 @@
+namespace Linn.Stores.Service.ResponseProcessors
+{
+    using System.Collections.Generic;
+    using Linn.Common.Facade;
+    using Linn.Common.Nancy.Facade;
+    using Linn.Stores.Domain.LinnApps.Parts;
+
+    public class PartTemplateResponseProcessor : JsonResponseProcessor<PartTemplate>
+    {
+        public PartTemplateResponseProcessor(IResourceBuilder<PartTemplate> resourceBuilder)
+            : base(resourceBuilder, "linnapps-part-templates", 1)
+        {
+        }
+    }
+}

tests/Integration/Service.Tests/PartsModuleSpecs/ContextBase.cs

@@ -184,6 +184,7 @@ public void EstablishContext()
                         with.ResponseProcessor<AssemblyTechnologiesResponseProcessor>();
                         with.ResponseProcessor<DecrementRulesResponseProcessor>();
                         with.ResponseProcessor<ProductAnalysisCodesResponseProcessor>();
+                        with.ResponseProcessor<PartTemplateResponseProcessor>();
                         with.ResponseProcessor<PartTemplatesResponseProcessor>();
                         with.ResponseProcessor<PartLiveTestResponseProcessor>();
                         with.ResponseProcessor<MechPartSourceResponseProcessor>();

tests/Integration/Service.Tests/PartsModuleSpecs/WhenGettingPartTemplateById .cs

@@ -0,0 +1,59 @@
+namespace Linn.Stores.Service.Tests.PartsModuleSpecs
+{
+    using System.Collections.Generic;
+    using System.Linq;
+
+    using FluentAssertions;
+
+    using Linn.Common.Facade;
+    using Linn.Stores.Domain.LinnApps.Parts;
+    using Linn.Stores.Resources.Parts;
+
+    using Nancy;
+    using Nancy.Testing;
+
+    using NSubstitute;
+
+    using NUnit.Framework;
+
+    public class WhenGettingPartTemplatesById : ContextBase
+    {
+        [SetUp]
+        public void SetUp()
+        {
+            var a = new PartTemplate
+                        {
+                            PartRoot = "PARTTEMP"
+                        };
+
+            this.PartTemplateService.GetById(a.PartRoot)
+                .Returns(new SuccessResult<PartTemplate>(a));
+
+            this.Response = this.Browser.Get(
+                "/inventory/part-templates/PARTTEMP",
+                with =>
+                    {
+                        with.Header("Accept", "application/json");
+                    }).Result;
+        }
+
+        [Test]
+        public void ShouldReturnOk()
+        {
+            this.Response.StatusCode.Should().Be(HttpStatusCode.OK);
+        }
+
+        [Test]
+        public void ShouldCallService()
+        {
+            this.PartTemplateService.Received().GetById("PARTTEMP");
+        }
+
+        [Test]
+        public void ShouldReturnResource()
+        {
+            var resource = this.Response.Body.DeserializeJson<PartTemplateResource>();
+            resource.PartRoot.Should().Be("PARTTEMP");
+        }
+    }
+}