/// <summary>
        /// Checks mandatory fields
        /// </summary>
        /// <returns></returns>
        private bool CheckMandatory()
        {
            if (SelectionDatatypeValueText_txt.Text == string.Empty)
            {
                messageData = new MessageData("mmce00002", Properties.Resources.mmce00002, SelectionDatatypeValueText_lbl.Text);
                popUpMessage.Warning(messageData, Text);

                SelectionDatatypeValueText_txt.Focus();

                return(false);
            }

            //if (InspectionItem_cmb.Text == string.Empty || InspectionItem_cmb.SelectedIndex < 0)
            //{
            //    messageData = new MessageData("mmce00002", Properties.Resources.mmce00002, InspectionItem_lbl.Text);
            //    popUpMessage.Warning(messageData, Text);

            //    InspectionItem_cmb.Focus();

            //    return false;
            //}

            if (InspectionItemDisplayOrder_txt.Text == string.Empty)
            {
                messageData = new MessageData("mmce00002", Properties.Resources.mmce00002, InspectionItemDisplayOrder_lbl.Text);
                popUpMessage.Warning(messageData, Text);

                InspectionItemDisplayOrder_txt.Focus();

                return(false);
            }

            return(true);
        }
示例#2
0
        /// <summary>
        /// Checks mandatory fields
        /// </summary>
        /// <returns></returns>
        private bool CheckMandatory()
        {
            if (InspectionItemName_txt.Text == string.Empty)
            {
                messageData = new MessageData("mmce00002", Properties.Resources.mmce00002, InspectionItemName_lbl.Text);
                popUpMessage.Warning(messageData, Text);

                InspectionItemName_txt.Focus();

                return(false);
            }
            if (InspectionItemDataType_cmb.SelectedIndex < 0)
            {
                messageData = new MessageData("mmce00002", Properties.Resources.mmce00002, InspectionItemDataType_lbl.Text);
                popUpMessage.Warning(messageData, Text);

                InspectionItemDataType_cmb.Focus();

                return(false);
            }
            if (mode.Equals(CommonConstants.MODE_UPDATE) && !InspectionItemDataType_cmb.SelectedValue.Equals(updateData.InspectionItemDataType))
            {
                if (CheckInspectionSpecificationRecord())
                {
                    messageData = new MessageData("mmci00029", Properties.Resources.mmci00029);
                    popUpMessage.Warning(messageData, Text);

                    InspectionItemDataType_cmb.Focus();
                    return(false);
                }
            }

            if (InspectionItemDisplayOrder_txt.Text == string.Empty)
            {
                messageData = new MessageData("mmce00002", Properties.Resources.mmce00002, InspectionItemDisplayOrder_lbl.Text);
                popUpMessage.Warning(messageData, Text);

                InspectionItemDisplayOrder_txt.Focus();

                return(false);
            }

            if (InspectionItemDataType_cmb.SelectedIndex > -1 &&
                InspectionItemDataType_cmb.SelectedValue.ToString() == GlobalMasterDataTypeEnum.DATATYPE_SELECTION.GetValue().ToString() && !isNewValue)
            {
                if (mode == CommonConstants.MODE_UPDATE)
                {
                    return(true);
                }
                messageData = new MessageData("mmce00002", Properties.Resources.mmce00002, Value_btn.Text);
                popUpMessage.Warning(messageData, Text);

                Value_btn.Focus();

                return(false);
            }
            return(true);
        }
        /// <summary>
        /// inserts new record
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Ok_btn_Click(object sender, EventArgs e)
        {
            InspectionItemSelectionDatatypeValueVo inVo = new InspectionItemSelectionDatatypeValueVo();
            var sch = StringCheckHelper.GetInstance();

            if (CheckMandatory() == true)
            {
                inVo.InspectionItemSelectionDatatypeValueText = SelectionDatatypeValueText_txt.Text.Trim();

                inVo.DisplayOrder = Convert.ToInt32(InspectionItemDisplayOrder_txt.Text);

                if (InspectionItem_cmb.SelectedValue != null && InspectionItem_cmb.SelectedIndex >= 0)
                {
                    inVo.InspectionItemId = Convert.ToInt32(InspectionItem_cmb.SelectedValue.ToString());
                }

                if (updateData != null)
                {
                    inVo.InspectionItemId = updateData.InspectionItemId;
                }

                if (mode.Equals(CommonConstants.MODE_UPDATE))
                {
                    inVo.InspectionItemSelectionDatatypeValueId = updateData.InspectionItemSelectionDatatypeValueId;
                }

                inVo.Mode = mode;

                try
                {
                    if (string.Equals(mode, CommonConstants.MODE_ADD) || string.Equals(mode, CommonConstants.MODE_SELECT))
                    {
                        InspectionItemSelectionDatatypeValueVo checkVo = DuplicateCheck(inVo);
                        if (checkVo != null && checkVo.AffectedCount > 0)
                        {
                            messageData = new MessageData("mmce00001", Properties.Resources.mmce00001, SelectionDatatypeValueText_lbl.Text + " : " + SelectionDatatypeValueText_txt.Text);
                            popUpMessage.Information(messageData, Text);

                            return;
                        }

                        InspectionItemSelectionDatatypeValueVo checkDisplayVo = DuplicateDisplayCheck(inVo);
                        if (checkDisplayVo != null && checkDisplayVo.AffectedCount > 0)
                        {
                            messageData = new MessageData("mmce00001", Properties.Resources.mmce00001, InspectionItemDisplayOrder_lbl.Text + " : " + InspectionItemDisplayOrder_txt.Text);
                            logger.Info(messageData);
                            popUpMessage.Information(messageData, Text);
                            InspectionItemDisplayOrder_txt.Focus();
                            return;
                        }

                        inVo.InspectionItemSelectionDatatypeValueCode = InspectionItemCode
                                                                        + GlobalMasterDataTypeEnum.CODE_SEPARATOR.GetValue()
                                                                        + GlobalMasterDataTypeEnum.SELECTION_VALUE_CODE.GetValue() + GlobalMasterDataTypeEnum.CODE_SEPARATOR.GetValue() + RunningNumber;

                        UpdateResultVo outVo = (UpdateResultVo)base.InvokeCbm(new AddInspectionItemSelectionDatatypeValueCbm(), inVo, false);

                        IntSuccess = outVo.AffectedCount;
                    }
                    else if (mode.Equals(CommonConstants.MODE_UPDATE))
                    {
                        if (SelectionDatatypeValueText_txt.Text == updateData.InspectionItemSelectionDatatypeValueText && updateData.DisplayOrder == Convert.ToInt32(InspectionItemDisplayOrder_txt.Text))
                        {
                            return;
                        }
                        if (updateData.InspectionItemSelectionDatatypeValueText != SelectionDatatypeValueText_txt.Text)
                        {
                            InspectionItemSelectionDatatypeValueVo checkVo = DuplicateCheck(inVo);
                            if (checkVo != null && checkVo.AffectedCount > 0)
                            {
                                messageData = new MessageData("mmce00001", Properties.Resources.mmce00001, SelectionDatatypeValueText_lbl.Text + " : " + SelectionDatatypeValueText_txt.Text);
                                popUpMessage.Information(messageData, Text);

                                return;
                            }
                        }

                        if (updateData.DisplayOrder != Convert.ToInt32(InspectionItemDisplayOrder_txt.Text))
                        {
                            InspectionItemSelectionDatatypeValueVo checkDisplayVo = DuplicateDisplayCheck(inVo);
                            if (checkDisplayVo != null && checkDisplayVo.AffectedCount > 0)
                            {
                                messageData = new MessageData("mmce00001", Properties.Resources.mmce00001, InspectionItemDisplayOrder_lbl.Text + " : " + InspectionItemDisplayOrder_txt.Text);
                                logger.Info(messageData);
                                popUpMessage.Information(messageData, Text);
                                InspectionItemDisplayOrder_txt.Focus();
                                return;
                            }
                        }

                        if (updateData == null)
                        {
                            UpdateResultVo outResultVo = (UpdateResultVo)base.InvokeCbm(new UpdateInspectionItemSelectionDatatypeValueCbm(), inVo, false);
                            if (outResultVo == null)
                            {
                                return;
                            }
                            IntSuccess = outResultVo.AffectedCount;
                        }
                        else
                        {
                            string message = string.Format(Properties.Resources.mmci00037, "Inspection Item Selection Datatype Value", SelectionDatatypeValueText_txt.Text);
                            StartProgress(message);

                            ValueObjectList <ValueObject> inVoList     = new ValueObjectList <ValueObject>();
                            InspectionFormatVo            passformatVo = FormFormatVo(updateData.InspectionItemId);
                            if (passformatVo == null || passformatVo.InspectionFormatId == 0)
                            {
                                return;
                            }

                            inVoList.add(passformatVo);
                            inVoList.add(null);
                            inVoList.add(null);
                            inVoList.add(inVo);
                            inVoList.add(null);
                            inVoList.add(null);
                            inVoList.add(null);

                            InspectionReturnVo outVo = null;

                            try
                            {
                                outVo = (InspectionReturnVo)base.InvokeCbm(new UpdateAllInspectionFunctionMasterMntCbm(), inVoList, false);
                            }
                            catch (Framework.ApplicationException exception)
                            {
                                popUpMessage.ApplicationError(exception.GetMessageData(), Text);
                                logger.Error(exception.GetMessageData());
                                return;
                            }
                            finally
                            {
                                CompleteProgress();
                            }
                            if (outVo != null && outVo.AffectedCount > 0)
                            {
                                IntSuccess       = outVo.AffectedCount;
                                InspectionItemId = outVo.InspectionItemId;

                                InspectionFormatProcessBuzzLogic getprocessid = new InspectionFormatProcessBuzzLogic();
                                InspectionReturnVo invo = new InspectionReturnVo();
                                invo.InspectionItemId = outVo.InspectionItemId;
                                InspectionReturnVo getInspectionVo = getprocessid.RefreshAllFormGrid(invo);
                                if (getInspectionVo != null && getInspectionVo.InspectionProcessId > 0)
                                {
                                    InspectionProcessId = getInspectionVo.InspectionProcessId;
                                }
                            }
                        }
                        //UpdateInspectionItemSelectionDatatypeValueVo = new InspectionItemSelectionDatatypeValueVo();

                        //UpdateInspectionItemSelectionDatatypeValueVo = inVo;
                        //this.Close();
                    }
                }
                catch (Framework.ApplicationException exception)
                {
                    popUpMessage.ApplicationError(exception.GetMessageData(), Text);
                    logger.Error(exception.GetMessageData());
                    return;
                }

                if ((IntSuccess > 0))
                {
                    //messageData = new MessageData("mmci00001", Properties.Resources.mmci00001, null);
                    //logger.Info(messageData);
                    //popUpMessage.Information(messageData, Text);
                    this.Close();
                }
            }
        }
示例#4
0
        /// <summary>
        /// update data to db
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Ok_btn_Click(object sender, EventArgs e)
        {
            var sch = StringCheckHelper.GetInstance();

            InspectionItemVo inVo = new InspectionItemVo();

            if (CheckMandatory())
            {
                inVo.InspectionItemName = InspectionItemName_txt.Text.Trim();

                if (ParentItemCode_cmb.SelectedIndex > -1)
                {
                    inVo.ParentInspectionItemId = Convert.ToInt32(ParentItemCode_cmb.SelectedValue.ToString());
                }
                //if (InspectionProcess_cmb.SelectedIndex > -1)
                //{
                //    inVo.InspectionProcessId = Convert.ToInt32(InspectionProcess_cmb.SelectedValue);
                //}

                inVo.InspectionProcessId = updateData.InspectionProcessId;

                inVo.InspectionItemMandatory = Convert.ToInt32(InspectionItemMandatory_chk.Checked);

                inVo.InspectionEmployeeMandatory = Convert.ToInt32(InspectionEmployeeMandatory_chk.Checked);

                inVo.InspectionMachineMandatory = Convert.ToInt32(InspectionMachineMandatory_chk.Checked);

                inVo.InspectionItemDataType = Convert.ToInt32(InspectionItemDataType_cmb.SelectedValue);

                inVo.DisplayOrder = Convert.ToInt32(InspectionItemDisplayOrder_txt.Text);

                if (!string.IsNullOrEmpty(ResultItemDecimalDigits_txt.Text))
                {
                    inVo.InspectionResultItemDecimalDigits = Convert.ToInt32(ResultItemDecimalDigits_txt.Text);
                }

                if (string.Equals(mode, CommonConstants.MODE_ADD))
                {
                    InspectionItemVo checkVo = DuplicateCheck(inVo);
                    if (checkVo != null && checkVo.AffectedCount > 0)
                    {
                        messageData = new MessageData("mmce00001", Properties.Resources.mmce00001, InspectionItemName_lbl.Text + " : " + InspectionItemName_txt.Text);
                        popUpMessage.Information(messageData, Text);

                        return;
                    }

                    InspectionItemVo checkDisplayVo = DuplicateDisplayCheck(inVo);
                    if (checkDisplayVo != null && checkDisplayVo.AffectedCount > 0)
                    {
                        messageData = new MessageData("mmce00001", Properties.Resources.mmce00001, InspectionItemDisplayOrder_lbl.Text + " : " + InspectionItemDisplayOrder_txt.Text);
                        logger.Info(messageData);
                        popUpMessage.Information(messageData, Text);
                        InspectionItemDisplayOrder_txt.Focus();
                        return;
                    }
                }
                else if (string.Equals(mode, CommonConstants.MODE_UPDATE))
                {
                    if (updateData.InspectionItemName != InspectionItemName_txt.Text)
                    {
                        InspectionItemVo checkVo = DuplicateCheck(inVo);
                        if (checkVo != null && checkVo.AffectedCount > 0)
                        {
                            messageData = new MessageData("mmce00001", Properties.Resources.mmce00001, InspectionItemName_lbl.Text + " : " + InspectionItemName_txt.Text);
                            popUpMessage.Information(messageData, Text);

                            return;
                        }
                    }

                    if (updateData.DisplayOrder != Convert.ToInt32(InspectionItemDisplayOrder_txt.Text))
                    {
                        InspectionItemVo checkDisplayVo = DuplicateDisplayCheck(inVo);
                        if (checkDisplayVo != null && checkDisplayVo.AffectedCount > 0)
                        {
                            messageData = new MessageData("mmce00001", Properties.Resources.mmce00001, InspectionItemDisplayOrder_lbl.Text + " : " + InspectionItemDisplayOrder_txt.Text);
                            logger.Info(messageData);
                            popUpMessage.Information(messageData, Text);
                            InspectionItemDisplayOrder_txt.Focus();
                            return;
                        }
                    }
                }
                if (string.Equals(mode, CommonConstants.MODE_ADD))
                {
                    inVo.InspectionItemCode = InspectionItemCode;

                    if (InspectionItemCopyId == 0)
                    {
                        InspectionItemVo outVo = null;
                        try
                        {
                            outVo = (InspectionItemVo)base.InvokeCbm(new AddInspectionItemMasterMntCbm(), inVo, false);
                        }
                        catch (Framework.ApplicationException exception)
                        {
                            popUpMessage.ApplicationError(exception.GetMessageData(), Text);
                            logger.Error(exception.GetMessageData());
                            return;
                        }
                        if (outVo == null && outVo.InspectionItemId == 0)
                        {
                            return;
                        }

                        IntSuccess = outVo.InspectionItemId;

                        //
                        if (InspectionItemDataType_cmb.SelectedIndex > -1 &&
                            InspectionItemDataType_cmb.SelectedValue.ToString() == GlobalMasterDataTypeEnum.DATATYPE_SELECTION.GetValue().ToString())
                        {
                            InspectionItemSelectionDatatypeValueVo inspectionItemSelectionDatatypeValueVo = new InspectionItemSelectionDatatypeValueVo();
                            inspectionItemSelectionDatatypeValueVo.InspectionItemCode = InspectionItemCode;
                            inspectionItemSelectionDatatypeValueVo.InspectionItemId   = outVo.InspectionItemId;
                            try
                            {
                                UpdateResultVo updateResultVo = (UpdateResultVo)base.InvokeCbm(new UpdateInspectionItemIdForSelectionValueCbm(), inspectionItemSelectionDatatypeValueVo, false);
                            }
                            catch (Framework.ApplicationException exception)
                            {
                                popUpMessage.ApplicationError(exception.GetMessageData(), Text);
                                logger.Error(exception.GetMessageData());
                                return;
                            }
                        }
                    }
                    else
                    {
                        inVo.InspectionItemIdCopy = InspectionItemCopyId;
                        //InspectionFormatVo getformatvo = inspectionFormatOutVo.GetList().Where(t => t.InspectionFormatId == inVo.InspectionFormatId).FirstOrDefault();
                        //if (getformatvo == null) return;

                        if (!CheckDataExist(InspectionItemCopyId))
                        {
                            messageData = new MessageData("mmci00048", Properties.Resources.mmci00048.ToString(), CopyItem_txt.Text);
                            logger.Info(messageData);
                            DialogResult dialogResult = popUpMessage.ConfirmationOkCancel(messageData, Text);
                            if (dialogResult != DialogResult.OK)
                            {
                                return;
                            }
                        }

                        string message = string.Format(Properties.Resources.mmci00045, CopyItem_txt.Text);
                        base.StartProgress(message);

                        inVo.InspectionProcessCode = updateData.InspectionProcessCode; // getformatvo.InspectionFormatCode;
                        //inVo.SequenceNo = RunningNumber;

                        ValueObjectList <ValueObject> inVoList = new ValueObjectList <ValueObject>();
                        inVoList.add(null);
                        inVoList.add(null);
                        inVoList.add(inVo);
                        inVoList.add(null);
                        inVoList.add(null);
                        inVoList.add(null);
                        inVoList.add(null);
                        InspectionReturnVo OutVo = null;
                        try
                        {
                            OutVo = (InspectionReturnVo)base.InvokeCbm(new CopyInspectionItemFromItemAllCbm(), inVoList, false);
                        }
                        catch (Framework.ApplicationException exception)
                        {
                            popUpMessage.ApplicationError(exception.GetMessageData(), Text);
                            logger.Error(exception.GetMessageData());
                            return;
                        }
                        finally
                        {
                            CompleteProgress();
                        }
                        if (OutVo != null && OutVo.AffectedCount > 0)
                        {
                            IntSuccess      = OutVo.InspectionItemId;
                            ReturnProcessId = OutVo.InspectionProcessId;
                            is_Copied       = true;
                        }
                    }
                }
                else if (string.Equals(mode, CommonConstants.MODE_UPDATE))
                {
                    inVo.InspectionItemId = updateData.InspectionItemId;

                    string message = string.Format(Properties.Resources.mmci00037, "Inspection Item", InspectionItemName_txt.Text);
                    StartProgress(message);

                    ValueObjectList <ValueObject> inVoList     = new ValueObjectList <ValueObject>();
                    InspectionFormatVo            passformatVo = FormFormatVo(updateData.InspectionItemId);
                    if (passformatVo == null || passformatVo.InspectionFormatId == 0)
                    {
                        return;
                    }

                    inVoList.add(passformatVo);
                    inVoList.add(null);
                    inVoList.add(inVo);
                    inVoList.add(null);
                    inVoList.add(null);
                    inVoList.add(null);
                    inVoList.add(null);

                    InspectionReturnVo outVo = null;

                    try
                    {
                        outVo = (InspectionReturnVo)base.InvokeCbm(new UpdateAllInspectionFunctionMasterMntCbm(), inVoList, false);
                    }
                    catch (Framework.ApplicationException exception)
                    {
                        popUpMessage.ApplicationError(exception.GetMessageData(), Text);
                        logger.Error(exception.GetMessageData());
                        return;
                    }
                    finally
                    {
                        CompleteProgress();
                    }
                    if (outVo != null && outVo.AffectedCount > 0)
                    {
                        IntSuccess      = outVo.InspectionItemId;
                        ReturnProcessId = outVo.InspectionProcessId;
                    }

                    //InspectionItemVo outVo = (InspectionItemVo)base.InvokeCbm(new UpdateInspectionItemMasterMntCbm(), inVo, false);
                }

                if (IntSuccess > 0)
                {
                    this.Close();
                }
            }
        }