Esempio n. 1
0
        protected override void ValidateRules(BrokenRules Verify)
        {
            Verify.IsNotNull(m_shopfloorline, "SflRequired", "Shopfloorline is required.", "Shopfloorline");
            Verify.IsNotNull(m_recDomain, "RecDomainRequired", "Rec domain is required.", "RecDomain");
            Verify.IsNotNull(m_organization, "OrgRequired", "Supplier is required.", "Organization");
            Verify.IsTrue(m_returnType != ReturnType.NotDefined, "ReturnTypeRequired", "Return Type is required.", "ReturnType");
            Verify.IsFalse(
                m_shopfloorline != null && m_shopfloorline.IsProgramRequired && string.IsNullOrEmpty(m_program),
                "ProgramRequired", "Program is required.", "Program");

            if (this.Order.OrderType == OrderType.ReturnNReplace && !Order.IsTemplate)
            {
                Verify.IsTrue(LineItems.Count > 0, "RnRLineItemsReq", "Purchase order line items are required for a return n replace order.", "CartItems");
            }

            foreach (PurchaseLineItem purchaseLineItem in LineItems)
            {
                if (!purchaseLineItem.IsDeleted)
                {
                    Verify.IsTrue(purchaseLineItem.Error.Length == 0,
                                  Guid.NewGuid().ToString(),
                                  purchaseLineItem.Error,
                                  "PartId");
                }
            }
        }
Esempio n. 2
0
        protected override void ValidateRules(BrokenRules Verify)
        {
            if (IsDeleted)
            {
                return;
            }

            Verify.IsNotNull(m_part,
                             "INVALIDLINEITEM",
                             "Invalid Part Number " + m_partNumber,
                             "PartId");

            Verify.IsNotNull(m_identType,
                             "IdentTypeReq",
                             "Ident Type is required.",
                             "IdentType");

            if (m_identType != null)
            {
                Verify.IsFalse(m_identType.Name == "Nonserialized" & m_serviceRoute != null,
                               "serializedRouteReq",
                               "Service routes are not valid for non-serialized product",
                               "IdentType");

                Verify.IsFalse(m_purchaseOrder.ReturnType == ReturnType.Service &&
                               m_identType.Name == "Serialized" &&
                               m_serviceRoute == null,
                               "ServiceRouteRequired",
                               "Service Route is required for part number: " + m_part.PartNumber,
                               "ServiceRoute");
            }
        }
Esempio n. 3
0
        protected override void ValidateRules(BrokenRules Verify)
        {
            if (IsLoading)
            {
                return;
            }

            Verify.IsTrue(m_name.Length > 0, "NameRequired", "Name is required", "Name");
            Verify.IsNotNull(m_shopfloorline, "sflReq", "Shopfloorline is required.", "Shopfloorline");
            Verify.IsNotNull(FirstStation(), "firstStationReq", "A first station is required.", "FirstStation");
        }
Esempio n. 4
0
        protected override void ValidateRules(BrokenRules Verify)
        {
            base.ValidateRules(Verify);

            Verify.IsNotEmpty(Label,
                              "AddrLabelRequired",
                              "Addresses require a label.",
                              "Label");

            Verify.IsNotEmpty(Street,
                              "AddrLineRequired",
                              "No street information on address.",
                              "Street");

            Verify.IsNotEmpty(City,
                              "AddrCityRequired",
                              "Address city is required.",
                              "City");

            //Verify.IsNotEmpty(State,
            //    "AddrStateRequired",
            //    "Address state/provence is required.",
            //    "State");

            Verify.IsNotNull(Country,
                             "AddrCountryRequired",
                             "Address country is required.",
                             "Country");
        }
Esempio n. 5
0
        protected override void ValidateRules(BrokenRules Verify)
        {
            base.ValidateRules(Verify);

            Verify.IsNotNull(m_stockLot, "SPLITLOTEMTYLOT",
                             "Lot is required.", "StockLot");

            Verify.IsNotNull(m_reason, "SPLITLOTEMPTYREASON",
                             "Reason is required.", "Reason");

            if (m_stockLot != null)
            {
                Verify.IsTrue(
                    (m_quantity > 0) && (m_quantity < m_stockLot.Quantity),
                    "SPLITLOTINVALQUANT",
                    "Invalid quantity", "Quantity");
            }
        }
Esempio n. 6
0
        protected override void ValidateRules(BrokenRules Verify)
        {
            Verify.IsNotNull(
                PartNumber,
                "BADPARTNO",
                "Invalid or no part number specified.",
                "PartNumber");

            Verify.IsNotNull(
                Type,
                "BADPARTTYPE",
                "Invalid or no type selected.",
                "Type");

            Verify.IsNotNull(
                IdentType,
                "BADPARTIDENT",
                "Invalid or no part identifier type selected.",
                "IdentType");
        }
Esempio n. 7
0
        protected override void ValidateRules(BrokenRules Verify)
        {
            if (!IsDeleted)
            {
                if (Verify.Count > 0)
                {
                    Verify.Clear();
                }
                return;
            }

            Verify.IsNotNull(m_taskType, "TaskTypeReq", "Task type is required", "TaskType");
            Verify.IsNotEmpty(m_displayPrompt, "DisplayPromptReq", "Display prompt is required", "DisplayPrompt");
        }
Esempio n. 8
0
        protected override void ValidateRules(BrokenRules Verify)
        {
            Verify.IsNotNull(m_organization,
                             "SONoCustomer", "No customer selected.", "Organization");

            Verify.IsFalse(
                HasDuplicateSOItems(),
                "SODupCartItems",
                "There are duplicate items in the cart.",
                "CartItems");

            Verify.IsNotEmpty(SalesRep,
                              "SONoSalesRep", "No sales rep selected.", "SalesRep");

            Verify.IsNotNull(m_shopfloorline,
                             "SflReq", "Sales Order shopfloorline is required.", "Shopfloorline");

            Verify.IsNotEmpty(m_shipToAddress, "ShipToReq", "Ship To Address is required", "ShipToAddress");


            if (this.Order.OrderType == OrderType.ReturnNReplace && !Order.IsTemplate)
            {
                Verify.IsTrue(CartItems.Count > 0, "RnRLineItemsReq", "Sales order line items are required for a return n replace order.", "CartItems");
            }


            foreach (SalesLineItem salesLineItem in CartItems)
            {
                if (!salesLineItem.IsDeleted)
                {
                    Verify.IsTrue(salesLineItem.Error.Length == 0,
                                  Guid.NewGuid().ToString(),
                                  salesLineItem.Error,
                                  "PartId");
                }
            }
        }
Esempio n. 9
0
        protected override void ValidateRules(BrokenRules Verify)
        {
            if (!IsDeleted)
            {
                Verify.IsNotNull(m_part,
                                 "INVALIDLINEITEM",
                                 "Invalid Part Number ",
                                 "PartId");
            }

            if (!IsDeleted)
            {
                if (m_part != null)
                {
                    Verify.IsTrue(m_part.IsShippable,
                                  "SOINOSHIPPART", "Part is not shippable.", "PartId");
                }
            }
        }
Esempio n. 10
0
 protected override void ValidateRules(BrokenRules Verify)
 {
     Verify.IsNotNull(m_part, "ValidPartReq", "Part number is not valid", "PartNumber");
 }
Esempio n. 11
0
 protected override void ValidateRules(BrokenRules Verify)
 {
     Verify.IsNotNull(m_shopfloorline, "ShopfloorlineReq", "Shopfloorline Required.", "Shopfloorline");
     Verify.IsNotNull(m_partModel, "PartModelReq", "Part Model is required.", "PartModel");
     Verify.IsFalse(string.IsNullOrEmpty(m_description), "ConfigurationDescriptionReq", "Configuration Description is required", "ConfigurationDescription");
 }
Esempio n. 12
0
 protected override void ValidateRules(BrokenRules Verify)
 {
     Verify.IsNotNull(m_failCode, "FailCodeRequired",
                      "Fail code is required", "FailCode");
 }
Esempio n. 13
0
 protected override void ValidateRules(BrokenRules Verify)
 {
     Verify.IsNotNull(m_part, "PartIsRequired", "A valid part number is required", "Part");
     Verify.IsTrue(m_qty > 0, "QtyGreaterThanZero", "Qty must be greater than zero", "Qty");
 }
Esempio n. 14
0
 protected override void ValidateRules(BrokenRules Verify)
 {
     Verify.IsNotEmpty(m_code, "CodeReq", "Code is required.", "Code");
     Verify.IsNotNull(m_category, "CatReq", "Category is required.", "Category");
 }
Esempio n. 15
0
 protected override void ValidateRules(BrokenRules Verify)
 {
     Verify.IsNotNull(m_category, "CategoryRequired", "Category is required.", "Category");
 }