Interacting with Xero OAuth integration using C#

This article mainly introduces the integration process with xero OAuth. The integration process with other third-party OAuth will be similar in the future. In addition, since the official documentation of xero is very limited, it is necessary to summarize it.
Xero is a financial system that can be used to replace the implementation of the product billing module.
www.xero.com

Understand OAuth:

##http://www.ruanyifeng.com /blog/2014/05/oauth_2_0.html

http://baike.baidu.com/view/6619164.htm

##To sum up, for SystemA users To access the resources of systemB, the user of sysB can specify which parts (modules) in SysB are exposed to SysA for access, and will also give sysA a token and certificate. Every time sysA accesses sysB, it needs to bring the token and certificate.
1. Install nuget pkg:


2. Create a wapper to encapsulate the interactive process

Prerequisites:
1. The certificate needs to be installed
2. Key/secret has been obtained

public class XeroApiAdapter
    {
        private readonly IXeroApiParameter _parameter;
        private const string PARTNER_URL = "https://api-partner.network.xero.com";
        private const string BASE_URL = "https://api.xero.com";


        public XeroCoreApi CoreApi { get; private set; }


        private readonly X509Certificate2 _signingCertificate;
        private readonly X509Certificate2 _partnerCertificate;


        /// <summary>
        /// 
        /// </summary>
        /// <param name="parameter"></param>
        public XeroApiAdapter(IXeroApiParameter parameter)
        {
            _signingCertificate = XeroOAuthSettings.Fetch.SigningCertificate.SelectedCertificate;
            if (_signingCertificate == null)
            {
                throw new Exception("Signing certificate must be defined");
            }


            _partnerCertificate = XeroOAuthSettings.Fetch.PartnerCertificate.SelectedCertificate;
            if (_partnerCertificate == null)
            {
                throw new Exception("partner certificate must be defined");
            }


            _parameter = parameter;
            var user = new ApiUser { OrganisationId = parameter.NetworkId, Name = parameter.NetworkId };




            CoreApi = new XeroCoreApi(PARTNER_URL,
            new RuPartnerAuthethicator(PARTNER_URL, BASE_URL, XeroTokenServices.Do,
                _signingCertificate, _partnerCertificate),
            new Consumer(parameter.ConsumerKey, parameter.ConsumerSecret), user,
            new DefaultMapper(), new DefaultMapper());
        }


        public PartnerMvcAuthenticator MvcAuthenticator(string callBack)
        {
            return new PartnerMvcAuthenticator(PARTNER_URL, BASE_URL, callBack, XeroTokenServices.Do,
                _signingCertificate, _partnerCertificate,
                new Consumer(_parameter.ConsumerKey, _parameter.ConsumerSecret),
                XeroRequestTokenServices.Do);
        }




        
    }

RuPartnerAuthethicator.cs (mainly used for over write xero de AuthorizeUser function, the browser will be opened by default):

public class RuPartnerAuthethicator : PartnerAuthenticator
    {
        public RuPartnerAuthethicator(string baseUri, string authorizeUri, ITokenStore store, string signingCertificatePath, string certificatePath, string password) : base(baseUri, authorizeUri, "", store, signingCertificatePath, certificatePath, password)
        {
        }


        public RuPartnerAuthethicator(string baseUri, string authorizeUri, ITokenStore store, X509Certificate2 signingCertificate, X509Certificate2 certificate) : base(baseUri, authorizeUri, "", store, signingCertificate, certificate)
        {
        }


        protected override string AuthorizeUser(IToken token)
        {
            throw new XeroRenewAccessTokenException("Please renew access token");
        }
    }

3. Implement the IToken interface, which is divided into Request Token and Access Token. That is, request token and access token. Access token needs to be persisted, and request token can be stored in memory.

 public class XeroTokenServices : MongoService, ITokenStore
    {
        public static XeroTokenServices Do
        {
            get
            {
                return new XeroTokenServices();
            }


        }


        private XeroTokenServices()
        {


        }


        private MongoCollection<MDXeroToken> XeroTokenStore
        {
            get
            {
                return Connection.GetMongoCollection<MDXeroToken>("XeroTokenStore");
            }
        }


        public void Add(IToken token)
        {
            //Lets delete first as we are not sure if Xero have a delete
            Delete(token);


            XeroTokenStore.Save(new MDXeroToken(token));
        }


        public void Delete(IToken token)
        {
            XeroTokenStore.Remove(Query<MDXeroToken>.EQ(x => x.UserId, token.UserId));
        }


        public IToken Find(string user)
        {
            var token = XeroTokenStore.FindOne(Query<MDXeroToken>.EQ(x => x.UserId, user));
            
            return token;
        }


        public void ClearTokenForNetwork(string id)
        {
            XeroTokenStore.Remove(Query<MDXeroToken>.EQ(x => x.UserId, id));
        }
    }


    public class XeroRequestTokenServices : MongoService, ITokenStore
    {
        public static XeroRequestTokenServices Do
        {
            get { return new XeroRequestTokenServices(); }
        }


        private XeroRequestTokenServices()
        {


        }


        private MongoCollection<MDXeroToken> XeroTokenStore
        {
            get
            {
                return Connection.GetMongoCollection<MDXeroToken>("XeroRequestTokenStore");
            }
        }




        public void Add(IToken token)
        {
            //Lets delete first as we are not sure if Xero have a delete
            Delete(token);


            XeroTokenStore.Save(new MDXeroToken(token));
        }


        public void Delete(IToken token)
        {
            XeroTokenStore.Remove(Query<MDXeroToken>.EQ(x => x.UserId, token.UserId));
        }


        public IToken Find(string user)
        {
            return XeroTokenStore.FindOne(Query<MDXeroToken>.EQ(x => x.UserId, user));
        }




        public void ClearTokenForNetwork(string id)
        {
            XeroTokenStore.Remove(Query<MDXeroToken>.EQ(x => x.UserId, id));
        }
    }

4. Specify the callback function and configure the callback domain in xero

4.1 Add Application

4.2 Configure call back domain, generate key, secret

##4.3 Call back function:

public ActionResult Authorize(string oauth_token, string oauth_verifier, string org, string redirect)
        {
            var network = NetworksManagment.Do.GetNetwork(Tenant.NetworkId);


            var xeroApi = new XeroApiAdapter(new XeroApiParam(network));


            var authenthicator = xeroApi.MvcAuthenticator("");


            try
            {
                // - call XeroTokenServices.Add and store the token in MDXeroToken
                var token = authenthicator.RetrieveAndStoreAccessToken(network.Id, oauth_token, oauth_verifier, org);


                var organization = xeroApi.CoreApi.Organisation;


                ...


                TempData.AddNotification(NotifcationType.Success, "Xero connected successfully");


            }
            catch (Exception ex)
            {
                TempData.AddNotification("Error connecting to Xero", ex);
            }


            if (string.IsNullOrEmpty(redirect))
            {
                return RedirectToAction("Index");
            }
            
            return Redirect(redirect);
        }

xero official git ：

https://github.com/XeroAPI/Xero-Net

The above is the content of interactive integration with Xero OAuth using C#. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!