Ejemplo n.º 1
0
 public void GetPartSuffixQuadDigitTest()
 {
     // smallest 4 digit edge case
     suffix = PartSuffixGenerator.IndexToSuffix(17576);
     Assert.AreEqual("BAAA", suffix);
     // largest 4 digit edge case
     suffix = PartSuffixGenerator.IndexToSuffix(456975);
     Assert.AreEqual("ZZZZ", suffix);
 }
Ejemplo n.º 2
0
        public void SuffixToIndexDoubleCharTest()
        {
            var result = PartSuffixGenerator.SuffixToIndex("BA");

            Assert.AreEqual(26, result);
            result = PartSuffixGenerator.SuffixToIndex("BB");
            Assert.AreEqual(27, result);
            result = PartSuffixGenerator.SuffixToIndex("ZZ");
            Assert.AreEqual(675, result);
        }
Ejemplo n.º 3
0
        public void SuffixToIndexSingleCharTest()
        {
            var result = PartSuffixGenerator.SuffixToIndex("A");

            Assert.AreEqual(0, result);
            result = PartSuffixGenerator.SuffixToIndex("B");
            Assert.AreEqual(1, result);
            result = PartSuffixGenerator.SuffixToIndex("Z");
            Assert.AreEqual(25, result);
        }
Ejemplo n.º 4
0
 public void GetPartSuffixTripleDigitTest()
 {
     // smallest 3 digit edge case
     suffix = PartSuffixGenerator.IndexToSuffix(676);
     Assert.AreEqual("BAA", suffix);
     suffix = PartSuffixGenerator.IndexToSuffix(677);
     Assert.AreEqual("BAB", suffix);
     // largest 3 digit edge case
     suffix = PartSuffixGenerator.IndexToSuffix(17575);
     Assert.AreEqual("ZZZ", suffix);
 }
Ejemplo n.º 5
0
 public void GetPartSuffixSingleDigit()
 {
     // smallest 1 digit valid edge case
     suffix = PartSuffixGenerator.IndexToSuffix(0);
     Assert.AreEqual("A", suffix);
     suffix = PartSuffixGenerator.IndexToSuffix(1);
     Assert.AreEqual("B", suffix);
     // largest 1 digit edge case
     suffix = PartSuffixGenerator.IndexToSuffix(25);
     Assert.AreEqual("Z", suffix);
 }
Ejemplo n.º 6
0
 public void GetPartSuffixDoubleDigitTest()
 {
     // smallest 2 digit edge case
     suffix = PartSuffixGenerator.IndexToSuffix(26);
     Assert.AreEqual("BA", suffix);
     suffix = PartSuffixGenerator.IndexToSuffix(27);
     Assert.AreEqual("BB", suffix);
     suffix = PartSuffixGenerator.IndexToSuffix(51);
     Assert.AreEqual("BZ", suffix);
     suffix = PartSuffixGenerator.IndexToSuffix(52);
     Assert.AreEqual("CA", suffix);
     suffix = PartSuffixGenerator.IndexToSuffix(53);
     Assert.AreEqual("CB", suffix);
     suffix = PartSuffixGenerator.IndexToSuffix(77);
     Assert.AreEqual("CZ", suffix);
     // larges 2 digit suffix
     suffix = PartSuffixGenerator.IndexToSuffix(675);
     Assert.AreEqual("ZZ", suffix);
 }
        public async Task <IActionResult> Initialize(WorkType workType, Guid id, [Bind("WorkItemId,WorkItem,StaticPartInfoId,NumPartsForWork,StartDate,CompleteDate,ProcessSheetNotesFile,WorkId")] WorkItemViewModel vm)
        {
            if (id != vm.WorkItemId)
            {
                return(NotFound());
            }
            ViewBag.WorkType = workType;

            var resultList = await _repo.GetPartsForWorksWithPartInfo(vm.StaticPartInfoId);

            var count = resultList.Count();
            int max   = 0;

            foreach (PartForWork pForWork in resultList)
            {
                var temp = PartSuffixGenerator.SuffixToIndex(pForWork.Suffix);
                if (temp > max)
                {
                    max = temp;
                }
            }

            if (ModelState.IsValid)
            {
                var workItem = await _repo.GetWorkItem(vm.WorkItemId);

                workItem.StaticPartInfoId = vm.StaticPartInfoId;

                workItem.StartDate   = vm.StartDate;
                workItem.InvoiceDate = vm.CompleteDate;

                workItem.IsInitialized = true;

                // look to see if this part/job already exists. If so, name suffix from that point
                var existingBatch = await _repo.GetExistingPartBatch((Guid)workItem.WorkId);

                var initCount = vm.NumPartsForWork;
                vm.NumPartsForWork += existingBatch.Count();

                // update the number of parts in each PartForJob
                foreach (PartForWork part in existingBatch)
                {
                    vm.NumPartsForWork += existingBatch.Count();
                }

                if (workItem.ProcessSheetNotesFile != null)
                {
                    workItem.ProcessSheetNotesPdfBytes = await FileURL.GetFileBytes(workItem.ProcessSheetNotesFile);
                }


                // create each part for the part batch
                for (int i = count; i < initCount + count; i++)
                {
                    try
                    {
                        var tempPartForWork = new PartForWork {
                            PartForWorkId = Guid.NewGuid(), WorkItemId = workItem.WorkItemId,
                        };
                        tempPartForWork.Suffix        = Utility.PartSuffixGenerator.IndexToSuffix(i);
                        tempPartForWork.PartForWorkId = Guid.NewGuid();
                        SetUIDs();
                        await _repo.AddPartForWork(tempPartForWork);
                    }
                    catch (Exception ex) { ex.ToString(); continue; }
                }
                await _repo.UpdateWorkItem(workItem);

                return(RedirectToAction("Index", "WorkItems", new { workType = workType, workId = workItem.WorkId }));
            }
            return(View(vm));
        }
Ejemplo n.º 8
0
 public void GetPartSuffixInvalidTest()
 {
     // null when invalid integer as param
     Assert.IsNull(PartSuffixGenerator.IndexToSuffix(-1));
 }