public SpecialFaultCodesDetails GetSpecialFaultCodesDetailsById(long id)
        {
            SpecialFaultCodesDetails details = null;

            details = _SpecialFaultCodesRepository.GetSpecialFaultCodesDetailsById(id);
            return(details);
        }
        public SpecialFaultCodesDetails GetSpecialFaultCodesDetailsById(long id)
        {
            SpecialFaultCodesDetails details = new SpecialFaultCodesDetails();
            string spName = MIDDerivationLibrary.Models.Constants.spGetSpecialFaultCodesDetailsById;
            List <SqlParameter> allParams = new List <SqlParameter>()
            {
                new SqlParameter($"@{MIDDerivationLibrary.Models.Constants.Id}", id)
            };

            DataSet result = sqlRepository.ExecuteQuery(spName, allParams);

            if (result != null && result.Tables[0].Rows.Count > 0)
            {
                details = result.Tables[0].AsEnumerable().Select(dataRow => new SpecialFaultCodesDetails
                {
                    id = dataRow.Field <long>("id"),
                    specialfaultcodetype = dataRow.Field <string>("specialfaultcodetype"),
                    specialcode          = dataRow.Field <string>("specialcode"),
                    specialmultiple      = dataRow.Field <int?>("specialmultiple"),
                    componentType        = dataRow.Field <string>("componentType"),
                    componentTypeSub1    = dataRow.Field <string>("componentTypeSub1"),
                    componentTypeSub2    = dataRow.Field <string>("componentTypeSub2")
                }).FirstOrDefault();
            }
            return(details);
        }
        public ActionResult GetSpecialFaultCodesDetailsById(long id)
        {
            try
            {
                if (id <= 0)
                {
                    return(BadRequest(new ApiBadRequestResponse()));
                }
                else
                {
                    bool isExist = _service.CheckIsSpecialFaultCodesDetailsExist(id);
                    if (isExist == false)
                    {
                        return(StatusCode(StatusCodes.Status404NotFound, new ApiResponse(404, Constants.recordNotFound)));
                    }

                    SpecialFaultCodesDetails details = _service.GetSpecialFaultCodesDetailsById(id);

                    if (details != null)
                    {
                        return(Ok(new ApiOkResponse(details)));
                    }
                    else
                    {
                        return(StatusCode(StatusCodes.Status500InternalServerError, new ApiResponse(500, null)));
                    }
                }
            }
            catch (Exception ex)
            {
                ex.ToString();
                return(StatusCode(StatusCodes.Status500InternalServerError, new ApiResponse(500, null)));
            }
        }
        public bool CheckIsSpecialFaultCodesDetailsExist(string xmlContent)
        {
            bool flag = false;
            SpecialFaultCodesDetails details = null;

            details = _SpecialFaultCodesRepository.GetSpecialFaultCodesDetails(xmlContent);
            if (details != null && details.id > 0)
            {
                flag = true;
            }

            return(flag);
        }
        public bool CheckIsSpecialFaultCodesDetailsExist(long id)
        {
            bool flag = true;
            SpecialFaultCodesDetails details = null;

            details = _SpecialFaultCodesRepository.GetSpecialFaultCodesDetailsById(id);
            if (details != null && details.id == 0)
            {
                flag = false;
            }

            return(flag);
        }
        public ActionResult UpdateSpecialFaultCodesDetails(SpecialFaultCodesDetails model)
        {
            long id = 0;
            ModelStateDictionary ModelState = new ModelStateDictionary();

            SpecialFaultCodeValidationHelper.ValidateSpecialFaultCodeInput(ref ModelState, ref model);

            if (model.id == 0)
            {
                ModelState.AddModelError(nameof(SpecialFaultCodesDetails.id), Constants.idValidationMessage);
            }

            if (ModelState.IsValid)
            {
                try
                {
                    string   xmlString = XmlHelper.ConvertObjectToXML(model);
                    XElement xElement  = XElement.Parse(xmlString);

                    bool isExist = _service.CheckIsSpecialFaultCodesDetailsExist(xmlString);

                    if (isExist == true)
                    {
                        return(StatusCode(StatusCodes.Status409Conflict, new ApiResponse(404, Constants.recordExist)));
                    }
                    else
                    {
                        id = _service.AddOrUpdateSpecialFaultCodesDetails(xElement.ToString());
                        if (id > 0)
                        {
                            return(Ok(new ApiOkResponse(id, Constants.recordSaved)));
                        }
                        else
                        {
                            return(StatusCode(StatusCodes.Status500InternalServerError, new ApiResponse(500, null)));
                        }
                    }
                }
                catch (Exception ex)
                {
                    ex.ToString();
                    return(StatusCode(StatusCodes.Status500InternalServerError, new ApiResponse(500, null)));
                }
            }
            else
            {
                return(BadRequest(new ApiBadRequestResponse(ModelState)));
            }
        }
        public static void ValidateSpecialFaultCodeInput(ref ModelStateDictionary modelState, ref SpecialFaultCodesDetails model)
        {
            //Validations for Special Fault Codes
            if (model != null)
            {
                //specialfaultcodetype
                if (string.IsNullOrEmpty(model.specialfaultcodetype))
                {
                    modelState.AddModelError(nameof(SpecialFaultCodesDetails.specialfaultcodetype), Constants.specialFaultCodeTypeRequired);
                }

                //specialmultiple
                if (model.specialmultiple == null)
                {
                    modelState.AddModelError(nameof(SpecialFaultCodesDetails.specialmultiple), Constants.specialMultipleRequired);
                }

                //specialcode
                if (string.IsNullOrEmpty(model.specialcode))
                {
                    modelState.AddModelError(nameof(SpecialFaultCodesDetails.specialcode), Constants.specialCodeRequired);
                }
            }
        }