public void DeleteMapping(string platform, int index)
        {
            MappingInputToOutput map = FORIS.Interbilling.NTS.Mediation.Configurations.Configuration.GetNotCashedConfiguration <MappingInputToOutput>();
            string selectedFileType  = platform;
            var    fieldMappings     = map.Mappings.Find(p => p.FileType == selectedFileType).FieldMappings;

            string[] inputFields     = fieldMappings[index].InputField.ToArray();
            var      transf          = fieldMappings[index].TransformationList;
            string   input           = "";
            string   transformations = "";

            foreach (string i in inputFields)
            {
                input += i;
            }
            foreach (var t in transf)
            {
                transformations += t.Parameter + "(" + t.Parameter + ")";
            }

            string logString = "FileType:" + selectedFileType + "|" +
                               "InputFields:" + input + "|" +
                               "Transformations:" + transformations + "|" +
                               "OutputFied:" + fieldMappings[index].OutputField;

            WriteLog("DELETE", "MED Configuration", "MappingInputToOutput", System.Security.Principal.WindowsIdentity.GetCurrent().Name, logString, "");

            fieldMappings.RemoveAt(index);

            FORIS.Interbilling.NTS.Mediation.Configurations.Configuration.SaveConfiguration(map.GetType(), map);
        }
        public List <MappingGetReq> GetMappings(string platform)
        {
            DataTable dtMapper = new DataTable();

            dtMapper.Columns.Add("InputField");
            dtMapper.Columns.Add("Transformation");
            dtMapper.Columns.Add("OutputField");

            MappingInputToOutput map = FORIS.Interbilling.NTS.Mediation.Configurations.Configuration.GetNotCashedConfiguration <MappingInputToOutput>();
            bool exist = map.Mappings.Exists(p => p.FileType == platform);
            List <FieldMapping> mappings = new List <FieldMapping>();

            if (exist)
            {
                mappings = map.Mappings.Find(p => p.FileType == platform).FieldMappings;
            }

            List <MappingGetReq> mapList = new List <MappingGetReq>();

            foreach (var m in mappings)
            {
                MappingGetReq obj                  = new MappingGetReq();
                string        inputString          = "";
                string        transformationString = "";

                foreach (string i in m.InputField)
                {
                    inputString += i + ";";
                }
                foreach (var t in m.TransformationList)
                {
                    transformationString += t.TransformationName + "(" + t.Parameter + ");";
                }
                obj.InputField     = inputString.Remove(inputString.Length - 1, 1);
                obj.Transformation = transformationString.Remove(transformationString.Length - 1, 1);
                obj.OutputField    = m.OutputField;
                mapList.Add(obj);
            }
            return(mapList);
        }
        public void Map(string platform, string inputField, string transform, string outputField)
        {
            MappingInputToOutput map = FORIS.Interbilling.NTS.Mediation.Configurations.Configuration.GetNotCashedConfiguration <MappingInputToOutput>();
            bool exist = map.Mappings.Exists(p => p.FileType == platform);
            List <FieldMapping> mappings;

            if (exist)
            {
                mappings = map.Mappings.Find(p => p.FileType == platform).FieldMappings;
            }
            else
            {
                mappings = new List <FieldMapping>();
            }

            FieldMapping fieldMap = new FieldMapping();

            List <string> inputList = new List <string>();

            string[] inp = inputField.Remove(inputField.Length - 1).Split(';');
            foreach (string i in inp)
            {
                if (i == "None")
                {
                    inputList.Add("");
                }
                else
                {
                    inputList.Add(i);
                }
            }
            fieldMap.InputField = inputList;

            List <Transformation> transList = new List <Transformation>();

            string[] tran = transform.Remove(transform.Length - 1).Split(';');
            foreach (string s in tran)
            {
                Transformation transformation = new Transformation();
                string[]       tranParam      = s.Remove(s.Length - 1, 1).Split('(');
                if (tranParam.Length > 1)
                {
                    transformation.Parameter = tranParam[1];
                }
                else
                {
                    transformation.Parameter = "";
                }
                if (tranParam[0] != "None")
                {
                    transformation.TransformationName = tranParam[0];
                }
                else
                {
                    transformation.TransformationName = "";
                }
                transList.Add(transformation);
            }
            fieldMap.TransformationList = transList;

            fieldMap.OutputField = outputField;
            mappings.Add(fieldMap);
            if (!exist)
            {
                Mapping mapping = new Mapping();
                mapping.FieldMappings = mappings;
                mapping.FileType      = platform;
                map.Mappings.Add(mapping);
            }

            string logString = "FileType:" + platform + "|" +
                               "InputFields:" + inputList + "|" +
                               "Transformation:" + transList + "|" +
                               "OutputField:" + outputField;

            WriteLog("INSERT", "MED Configuration", "MappingInputToOutput", System.Security.Principal.WindowsIdentity.GetCurrent().Name, logString, "");
            FORIS.Interbilling.NTS.Mediation.Configurations.Configuration.SaveConfiguration(map.GetType(), map);
        }