creating requirement in RRC using c#.net into JKE Banking(Requirements Management) - Project Area

hello , i am not able to create the Workitem, there is no error , but the Workitem is not created ,

my code looks like this

using System;
using System.IO;
using System.Net;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Xml;


namespace JazzConsoleApplication
{
    class Program
    {
        private const string AUTH_MSG_KEY = "X-com-ibm-team-repository-web-auth-msg";
        private const string AUTH_REQUIRED_MSG = "authrequired";
        private const string BASIC_AUTHENTICATION_TYPE = "Basic";

        static void Main(string[] args)
        {
            string repository = "host";
            string username = "username";
            string password = "*****";

            //modify only if proxy requires authentication
            string proxyUsername = "proxyUsername";
            string proxyPassword = "proxyPassword";

            try
            {
                ServicePointManager.Expect100Continue = false;
                ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(Callback);

#if NET_45      // TLS 1.1/1.2 supported in .NET Framework 4.5 and later
                ServicePointManager.SecurityProtocol = ServicePointManager.SecurityProtocol | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
#endif

                SecurityContext context = SecurityContext.CreateSecurityContext(username, password, proxyUsername, proxyPassword);

                Console.WriteLine("Initializing repository...");
                HttpWebResponse initResponse = SendRequest(repository, "/process/project-areas/_1TRdAE6hEeiiuJY3p316gA", context);
                string authMsg = initResponse.Headers[AUTH_MSG_KEY];
                if (authMsg == AUTH_REQUIRED_MSG)
                {
                    Console.WriteLine("Performing Security Check...");
                    HttpWebResponse authResponse = SendRequest(repository, string.Format("/j_security_check?j_username={0}&j_password={1}", username, password), context);
                    authMsg = authResponse.Headers[AUTH_MSG_KEY];
                    if (!string.IsNullOrEmpty(authMsg))
                    {
                        Console.WriteLine("Web Authentication Message: " + authMsg);
                        Exit();
                        return;
                    }


                    //Create WorkItem Task

                    CookieContainer cookies = new CookieContainer();
                    XmlDocument newdoc = new XmlDocument();
                    newdoc.XmlResolver = null;
                    newdoc.Load(@"C:\Users\AMC4KOR\Desktop\New folder\CUrl\new.xml");
                    string content = newdoc.InnerXml;
                    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(repository + "/oslc/contexts/_1TRdAE6hEeiiuJY3p316gA/workitems/task");
                    request.Method = "POST";
                    request.CookieContainer = cookies;
                    request.AllowAutoRedirect = false;

                    if (string.IsNullOrEmpty(username))
                    {
                        request.Credentials = CredentialCache.DefaultNetworkCredentials;
                    }
                    else
                    {
                        request.Credentials = new NetworkCredential(username, password);
                    }

                    byte[] byteArray = Encoding.UTF8.GetBytes(content);
                    request.ContentType = "application/x-oslc-cm-change-request+xml";
                    request.ContentLength = byteArray.Length;
                    request.Headers.Set("OSLC-Core-Version", "3.0");
                    request.Accept = "text/xml";//"application/rdf+xml";
                    request.Timeout = 300000;

                    Stream dataStream = request.GetRequestStream();
                    dataStream.Write(byteArray, 0, byteArray.Length);
                    dataStream.Close();
                   
                    //request.

                  

                }
                //Create WorkItem Story



                //Console.WriteLine("Getting Project Areas...");
                //SendRequest(repository, "/process/project-areas/_1TRdAE6hEeiiuJY3p316gA", context);
            }

            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }

            Exit();
        }

        static bool Callback(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
        {
            //trust all certificates
            return true;
        }

        class SecurityContext
        {
            internal static SecurityContext CreateSecurityContext(string username, string password, string proxyUsername, string proxyPassword)
            {
                NetworkCredential credential = new NetworkCredential(username, password);

                WebHeaderCollection authHeader = new WebHeaderCollection();
                byte[] credBuf = new UTF8Encoding().GetBytes(username + ":" + password);
                authHeader.Add(HttpRequestHeader.Authorization, BASIC_AUTHENTICATION_TYPE + " " + Convert.ToBase64String(credBuf));

                CookieContainer cookie = new CookieContainer();

                NetworkCredential proxyCredential = new NetworkCredential(proxyUsername, proxyPassword);

                return new SecurityContext(credential, authHeader, cookie, proxyCredential);
            }

            internal NetworkCredential Credential;
            internal WebHeaderCollection AuthHeader;
            internal CookieContainer Cookie;
            internal NetworkCredential ProxyCredential;

            SecurityContext(NetworkCredential credential, WebHeaderCollection authHeader, CookieContainer cookie, NetworkCredential proxyCredential)
            {
                this.Credential = credential;
                this.AuthHeader = authHeader;
                this.Cookie = cookie;
                this.ProxyCredential = proxyCredential;
            }
        }

      


        static HttpWebResponse SendRequest(string repository, string service, SecurityContext context)
        {
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(repository + service);
            request.AllowAutoRedirect = true;
            request.KeepAlive = true;
            request.Timeout = 480000;
            request.Credentials = context.Credential;
            request.Headers.Add(context.AuthHeader);
            request.CookieContainer = context.Cookie;
            Console.Write("Request Uri:--------------------------------------------------------------------");
            Console.WriteLine(request.RequestUri);
            Console.Write("Request Headers:----------------------------------------------------------------");
            Console.Write(request.Headers);



          
            //request.ContentType = "application/rdf+xml";
            //request.ContentLength = byteArray.Length;
            //request.Headers.Set("OSLC-Core-Version", "3.0");
            //request.Accept = "application/rdf+xml";
            //request.Timeout = 300000;

            //Stream dataStream = request.GetRequestStream();
            //dataStream.Write(byteArray, 0, byteArray.Length);
            //dataStream.Close();

            IWebProxy proxy = WebRequest.DefaultWebProxy;
           
            Uri proxyUri = proxy.GetProxy(request.RequestUri);
            Console.Write("Proxy Uri:----------------------------------------------------------------------");
            Console.WriteLine(proxyUri);
            bool isBypassed = proxy.IsBypassed(request.RequestUri);
            Console.Write("Is Bypassed:--------------------------------------------------------------------");
            Console.WriteLine(isBypassed);

            if (!isBypassed)
                proxy.Credentials = context.ProxyCredential;

            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            Console.Write("Response Headers:---------------------------------------------------------------");
            Console.Write(response.Headers);
            Console.Write("Response:-----------------------------------------------------------------------");
            Console.WriteLine(ReadResponse(response));
            Console.WriteLine();
            return response;
        }

        static string ReadResponse(HttpWebResponse response)
        {
            StreamReader reader = new StreamReader(response.GetResponseStream());
            return reader.ReadToEnd();
        }

        static void Exit()
        {
            Console.Write("Press any key to exit...");
            Console.ReadKey();
        }
    }
}

There is no additional information to create the workitem, using c# language ,

Is the above code is applicable for RTC ( rational team concert) ? or only for  the RRC ?

can anyone help resolving it .

Thanks in advance