Microsoft.Legal.MatterCenter.ValidationFunctions.IsMatterValid C# (CSharp) Method

IsMatterValid() public method

public IsMatterValid ( MatterInformationVM matterInformation, int methodNumber, MatterConfigurations matterConfigurations ) : GenericResponseVM
matterInformation Microsoft.Legal.MatterCenter.Models.MatterInformationVM
methodNumber int
matterConfigurations Microsoft.Legal.MatterCenter.Models.MatterConfigurations
return Microsoft.Legal.MatterCenter.Models.GenericResponseVM
        public GenericResponseVM IsMatterValid(MatterInformationVM matterInformation, int methodNumber, MatterConfigurations matterConfigurations)
        {
            GenericResponseVM genericResponse = null;
            var matterDetails = matterInformation.MatterDetails;
            if (int.Parse(ServiceConstants.ProvisionMatterCreateMatter, CultureInfo.InvariantCulture) <= methodNumber && 
                int.Parse(ServiceConstants.EditMatterPermission, CultureInfo.InvariantCulture) >= methodNumber && 
                !spList.CheckPermissionOnList(matterSettings.ProvisionMatterAppURL, matterSettings.SendMailListName, PermissionKind.EditListItems))
            {
                genericResponse = new GenericResponseVM();
                //return string.Format(CultureInfo.InvariantCulture, ConstantStrings.ServiceResponse, ServiceConstantStrings.IncorrectInputUserAccessCode, ServiceConstantStrings.IncorrectInputUserAccessMessage);
                genericResponse.Code = errorSettings.IncorrectInputUserAccessCode;
                genericResponse.Value = errorSettings.IncorrectInputUserAccessMessage;
            }
            else
            {
                
                if (matterInformation.Client!=null)
                {
                    genericResponse = new GenericResponseVM();
                    genericResponse = ValidateClientInformation(matterInformation.Client, methodNumber);
                    if (genericResponse!=null)
                    {
                        return genericResponse;
                    }
                }
                if (matterInformation.Matter!=null)
                {
                    genericResponse = MatterMetadataValidation(matterInformation.Matter, matterInformation.Client, 
                        methodNumber, matterConfigurations);
                    if (genericResponse!=null)
                    {
                        return genericResponse;
                    }
                    if (int.Parse(ServiceConstants.EditMatterPermission, CultureInfo.InvariantCulture) == methodNumber)
                    {
                        genericResponse = RoleCheck(matterInformation.Matter);
                        if (genericResponse!=null)
                        {
                            return genericResponse;
                        }
                    }
                    if (matterInformation.Matter.Permissions!=null)
                    {
                        bool isFullControlPresent = ValidateFullControlPermission(matterInformation.Matter);
                        if (!isFullControlPresent)
                        {                            
                            return GenericResponse(errorSettings.IncorrectInputUserAccessCode, errorSettings.ErrorEditMatterMandatoryPermission);
                        }
                    }
                }
                if (null != matterDetails && !(int.Parse(ServiceConstants.EditMatterPermission, CultureInfo.InvariantCulture) == methodNumber))
                {
                    if (string.IsNullOrWhiteSpace(matterDetails.PracticeGroup))
                    {                        
                        return GenericResponse(errorSettings.IncorrectInputPracticeGroupCode, errorSettings.IncorrectInputPracticeGroupMessage);
                    }
                    if (string.IsNullOrWhiteSpace(matterDetails.AreaOfLaw))
                    {
                        
                        return GenericResponse(errorSettings.IncorrectInputAreaOfLawCode, errorSettings.IncorrectInputAreaOfLawMessage);
                    }
                    if (string.IsNullOrWhiteSpace(matterDetails.SubareaOfLaw))
                    {                        
                        return GenericResponse(errorSettings.IncorrectInputSubareaOfLawCode, errorSettings.IncorrectInputSubareaOfLawMessage);
                    }
                    try
                    {
                        if (string.IsNullOrWhiteSpace(matterDetails.ResponsibleAttorney))
                        {                            
                            return GenericResponse(errorSettings.IncorrectInputResponsibleAttorneyCode, errorSettings.IncorrectInputResponsibleAttorneyMessage);
                        }
                        else
                        {
                            IList<string> userNames = matterDetails.ResponsibleAttorney.Split(';').ToList<string>();
                            matterRespository.ResolveUserNames(matterInformation.Client, userNames).FirstOrDefault();
                        }
                    }
                    catch (Exception)
                    {                        
                        return GenericResponse(errorSettings.IncorrectInputResponsibleAttorneyCode, errorSettings.IncorrectInputResponsibleAttorneyMessage);
                    }
                }
            }
            return genericResponse;
        }