Ejemplo n.º 1
0
        private IResult ResolveOpenDefectsForAttribute(LotAttribute lotAttribute, IAttributeValueParameters attributeValue)
        {
            var unresolvedDefects = _parameters.LotAttributeDefects.GetUnresolvedDefects(lotAttribute.AttributeShortName).ToList();

            if (!unresolvedDefects.Any())
            {
                return(new SuccessResult());
            }

            if (attributeValue.Resolution == null)
            {
                return(new InvalidResult(string.Format(UserMessages.AttributeDefectRequiresResolution, lotAttribute.AttributeShortName)));
            }

            if (!lotAttribute.IsValidResolution(attributeValue.Resolution.ResolutionType))
            {
                return(new InvalidResult(string.Format(UserMessages.InvalidDefectResolutionType, attributeValue.Resolution.ResolutionType, lotAttribute.AttributeName.DefectType)));
            }

            IResult result;

            if (attributeValue.Resolution.ResolutionType == ResolutionTypeEnum.Treated && !ValidateTreatmentResolution(_parameters, lotAttribute, out result))
            {
                return(result);
            }

            return(ResolveDefects(unresolvedDefects, _parameters, attributeValue.Resolution, _lotUnitOfWork));
        }
        private IResult UpdateLotAttribute(LotAttribute lotAttribute, IAttributeValueParameters attributeValue)
        {
            var range = _parameters.ChileProductAttributeRanges.FirstOrDefault(r => r.AttributeShortName == lotAttribute.AttributeShortName);

            if (range != null)
            {
                if (range.ValueOutOfRange(attributeValue.NewValue.Value))
                {
                    var updateLotDefectsResult = UpdateOrCreateLotDefects(lotAttribute, attributeValue, range);
                    if (!updateLotDefectsResult.Success)
                    {
                        return(updateLotDefectsResult);
                    }
                }
                else
                {
                    var resolveOpenDefectsResult = ResolveOpenDefectsForAttribute(lotAttribute, attributeValue);
                    if (!resolveOpenDefectsResult.Success)
                    {
                        return(resolveOpenDefectsResult);
                    }
                }
            }

            lotAttribute.EmployeeId     = _parameters.Employee.EmployeeId;
            lotAttribute.TimeStamp      = _parameters.TimeStamp;
            lotAttribute.AttributeValue = attributeValue.NewValue.Value;
            lotAttribute.AttributeDate  = attributeValue.AttributeDate;
            lotAttribute.Computed       = false;

            return(new SuccessResult());
        }
        private IResult UpdateOrCreateLotDefects(LotAttribute lotAttribute, IAttributeValueParameters attributeValue, ChileProductAttributeRange range)
        {
            var unresolvedDefects = _parameters.LotAttributeDefects.Where(d => d.AttributeShortName == lotAttribute.AttributeShortName && d.LotDefect.Resolution == null).ToList();

            if (unresolvedDefects.Any())
            {
                unresolvedDefects.ForEach(d =>
                {
                    d.OriginalAttributeValue    = attributeValue.NewValue.Value;
                    d.OriginalAttributeMinLimit = range.RangeMin;
                    d.OriginalAttributeMaxLimit = range.RangeMax;
                });
            }
            else
            {
                int defectId;
                lock (LotDefectLock)
                {
                    defectId = new EFUnitOfWorkHelper(_lotUnitOfWork).GetNextSequence <LotDefect>(d => d.LotDateCreated == _parameters.Lot.LotDateCreated && d.LotDateSequence == _parameters.Lot.LotDateSequence && d.LotTypeId == _parameters.Lot.LotTypeId, d => d.DefectId);
                }

                var lotDefect = _lotUnitOfWork.LotDefectRepository.Add(new LotDefect
                {
                    LotDateCreated  = _parameters.Lot.LotDateCreated,
                    LotDateSequence = _parameters.Lot.LotDateSequence,
                    LotTypeId       = _parameters.Lot.LotTypeId,
                    DefectId        = defectId,
                    DefectType      = lotAttribute.AttributeName.DefectType,
                    Description     = lotAttribute.AttributeName.Name,
                });
                _lotUnitOfWork.LotAttributeDefectRepository.Add(new LotAttributeDefect
                {
                    LotDateCreated     = lotDefect.LotDateCreated,
                    LotDateSequence    = lotDefect.LotDateSequence,
                    LotTypeId          = lotDefect.LotTypeId,
                    DefectId           = lotDefect.DefectId,
                    AttributeShortName = lotAttribute.AttributeShortName,

                    OriginalAttributeValue    = attributeValue.NewValue.Value,
                    OriginalAttributeMinLimit = range.RangeMin,
                    OriginalAttributeMaxLimit = range.RangeMax,
                    AttributeName             = lotAttribute.AttributeName,
                });
            }

            return(new SuccessResult());
        }
Ejemplo n.º 4
0
        private IResult UpdateLotAttribute(LotAttribute lotAttribute, IAttributeValueParameters attributeValue, out bool inSpec)
        {
            var range = _parameters.ProductAttributeRanges.FirstOrDefault(r => r.AttributeNameKey_ShortName == lotAttribute.AttributeShortName);

            inSpec = !range.ValueOutOfRange(attributeValue.AttributeInfo.Value);
            if (!inSpec)
            {
                var updateLotDefectsResult = UpdateOrCreateLotDefects(lotAttribute, attributeValue, range);
                if (!updateLotDefectsResult.Success)
                {
                    return(updateLotDefectsResult);
                }
            }

            lotAttribute.EmployeeId     = _parameters.Employee.EmployeeId;
            lotAttribute.TimeStamp      = _parameters.TimeStamp;
            lotAttribute.AttributeValue = attributeValue.AttributeInfo.Value;
            lotAttribute.AttributeDate  = attributeValue.AttributeInfo.Date;
            lotAttribute.Computed       = false;

            return(new SuccessResult());
        }
Ejemplo n.º 5
0
 public AttributeValueParameters(IAttributeValueParameters parameters)
 {
     AttributeInfo = parameters.AttributeInfo;
     Resolution    = parameters.Resolution;
 }
Ejemplo n.º 6
0
        private IResult UpdateOrCreateLotAttribute(ILotKey chileLotKey, AttributeNameKey attributeNameKey, IAttributeValueParameters newAttribute, ref List <LotAttribute> unaccountedAttributes)
        {
            var existingAttribute = false;
            var lotAttribute      = unaccountedAttributes.FirstOrDefault(a => a.AttributeName != null && attributeNameKey.FindByPredicate.Invoke(a.AttributeName));

            if (lotAttribute != null)
            {
                existingAttribute = true;
                unaccountedAttributes.Remove(lotAttribute);
            }
            else
            {
                var attributeName = _parameters.AttributeNames.FirstOrDefault(a => attributeNameKey.FindByPredicate.Invoke(a));
                if (attributeName == null)
                {
                    return(new InvalidResult(string.Format(UserMessages.AttributeNameNotFound, attributeNameKey.KeyValue)));
                }

                lotAttribute = _lotUnitOfWork.LotAttributeRepository.Add(new LotAttribute
                {
                    LotDateCreated  = chileLotKey.LotKey_DateCreated,
                    LotDateSequence = chileLotKey.LotKey_DateSequence,
                    LotTypeId       = chileLotKey.LotKey_LotTypeId,

                    AttributeShortName = attributeNameKey.AttributeNameKey_ShortName,
                    AttributeName      = attributeName
                });
            }

            var newValueInSpec = false;

            if (!existingAttribute ||
                (Math.Abs(lotAttribute.AttributeValue - newAttribute.AttributeInfo.Value) > EPSILON) ||
                lotAttribute.AttributeDate != newAttribute.AttributeInfo.Date)
            {
                var updateResult = UpdateLotAttribute(lotAttribute, newAttribute, out newValueInSpec);
                if (!updateResult.Success)
                {
                    return(updateResult);
                }
            }

            if (newValueInSpec || newAttribute.Resolution != null)
            {
                var resolveOpenDefectsResult = ResolveOpenDefectsForAttribute(lotAttribute, newAttribute);
                if (!resolveOpenDefectsResult.Success)
                {
                    return(resolveOpenDefectsResult);
                }
            }

            return(new SuccessResult());
        }
Ejemplo n.º 7
0
        private IResult RemoveLotAttributeIfExists(AttributeNameKey attributeNameKey, IAttributeValueParameters attributeValue, ref List <LotAttribute> unaccountedAttributes)
        {
            var lotAttribute = unaccountedAttributes.FirstOrDefault(a => a.AttributeName != null && attributeNameKey.FindByPredicate.Invoke(a.AttributeName));

            if (lotAttribute != null)
            {
                var resolveOpenDefectsResult = ResolveOpenDefectsForAttribute(lotAttribute, attributeValue);
                if (!resolveOpenDefectsResult.Success)
                {
                    return(resolveOpenDefectsResult);
                }

                unaccountedAttributes.Remove(lotAttribute);
                _lotUnitOfWork.LotAttributeRepository.Remove(lotAttribute);
            }

            return(new SuccessResult());
        }
        private static IResult ResolveDefects(IEnumerable <LotAttributeDefect> unresolvedDefects, Parameters parameters, IAttributeValueParameters attributeValue, ILotUnitOfWork unitOfWork)
        {
            var createResolutionCommand = new CreateLotDefectResolutionCommand(unitOfWork);
            var resolutionResult        = unresolvedDefects.Select(
                unresolvedDefect => createResolutionCommand.Execute(new CreateLotDefectResolutionParameters
            {
                LotDefect      = unresolvedDefect.LotDefect,
                Employee       = parameters.Employee,
                TimeStamp      = parameters.TimeStamp,
                ResolutionType = attributeValue.Resolution.ResolutionType,
                Description    = attributeValue.Resolution.Description
            }))
                                          .FirstOrDefault(r => !r.Success);

            return(resolutionResult as IResult ?? new SuccessResult());
        }