public async Task <IHttpActionResult> InvokeClientAPI(object paramObj, string uri, string transactionType)
        {
            HttpResponseMessage response = new HttpResponseMessage();

            try
            {
                var client = new HttpClient();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));

                switch (transactionType)
                {
                case "JE":    //JE
                    response = await client.PostAsJsonAsync(uri, (oJournal)paramObj);

                    if (response.IsSuccessStatusCode)
                    {
                        logger.LogJournalTransaction((oJournal)paramObj, true, "A", HttpContext.Current.Request.UserHostAddress);
                    }
                    else
                    {
                        throw new HttpResponseException(response);
                    }
                    break;

                case "AP INV":    //AP
                case "AR INV":    //AR
                    response = await client.PostAsJsonAsync(uri, paramObj);

                    if (response.IsSuccessStatusCode)
                    {
                        logger.LogInvoiceTransaction((oInvoice)paramObj, true, "A", HttpContext.Current.Request.UserHostAddress);
                    }
                    break;

                case "GI":    //GI
                case "GR":    //GR
                    response = await client.PostAsJsonAsync(uri, paramObj);

                    if (response.IsSuccessStatusCode)
                    {
                        logger.LogInventoryTransaction((oInventoryTransaction)paramObj, true, "A", HttpContext.Current.Request.UserHostAddress);
                    }
                    break;

                case "ITM":    //ITM
                    response = await client.PostAsJsonAsync(uri, paramObj);

                    if (response.IsSuccessStatusCode)
                    {
                        logger.LogItemTransaction((oItem)paramObj, true, "A", HttpContext.Current.Request.UserHostAddress);
                    }
                    break;

                case "BP":    //BP
                    response = await client.PostAsJsonAsync(uri, paramObj);

                    if (response.IsSuccessStatusCode)
                    {
                        logger.LogBPTransaction((oBusinessPartner)paramObj, true, "A", HttpContext.Current.Request.UserHostAddress);
                    }
                    break;

                case "GL":    //GL
                    response = await client.PostAsJsonAsync(uri, paramObj);

                    if (response.IsSuccessStatusCode)
                    {
                        logger.LogGlTransaction((oGlAccount)paramObj, true, "A", HttpContext.Current.Request.UserHostAddress);
                    }
                    break;
                }
            }
            catch (HttpResponseException ex)
            {
                ErrorLog err    = null;
                ErrorLog errLog = new ErrorLog();
                switch (transactionType)
                {
                case "JE":
                    err = new ErrorLog {
                        ErrorCode  = (int)HttpStatusCode.BadRequest,
                        Message    = ex.Message,
                        StackTrace = ex.StackTrace
                    };

                    errLog = ErrorLogger.Log(err);

                    logger.LogJournalTransaction((oJournal)paramObj, false, "A", HttpContext.Current.Request.UserHostAddress, errLog);
                    break;

                case "AR INV":
                case "AP INV":
                    err = new ErrorLog
                    {
                        ErrorCode  = (int)HttpStatusCode.BadRequest,
                        Message    = ex.Message,
                        StackTrace = ex.StackTrace
                    };

                    errLog = ErrorLogger.Log(err);

                    logger.LogInvoiceTransaction((oInvoice)paramObj, false, "A", HttpContext.Current.Request.UserHostAddress, errLog);
                    break;

                case "GI":    //GI
                case "GR":    //GR
                    err = new ErrorLog
                    {
                        ErrorCode  = (int)HttpStatusCode.BadRequest,
                        Message    = ex.Message,
                        StackTrace = ex.StackTrace
                    };

                    errLog = ErrorLogger.Log(err);
                    logger.LogInventoryTransaction((oInventoryTransaction)paramObj, false, "A", HttpContext.Current.Request.UserHostAddress, errLog);
                    break;

                case "ITM":    //ITM
                    err = new ErrorLog
                    {
                        ErrorCode  = (int)HttpStatusCode.BadRequest,
                        Message    = ex.Message,
                        StackTrace = ex.StackTrace
                    };

                    errLog = ErrorLogger.Log(err);
                    logger.LogItemTransaction((oItem)paramObj, false, "A", HttpContext.Current.Request.UserHostAddress, errLog);
                    break;

                case "BP":    //BP
                    err = new ErrorLog
                    {
                        ErrorCode  = (int)HttpStatusCode.BadRequest,
                        Message    = ex.Message,
                        StackTrace = ex.StackTrace
                    };

                    errLog = ErrorLogger.Log(err);
                    logger.LogBPTransaction((oBusinessPartner)paramObj, false, "A", HttpContext.Current.Request.UserHostAddress, errLog);
                    break;

                case "GL":    //GL
                    err = new ErrorLog
                    {
                        ErrorCode  = (int)HttpStatusCode.BadRequest,
                        Message    = ex.Message,
                        StackTrace = ex.StackTrace
                    };

                    errLog = ErrorLogger.Log(err);
                    logger.LogGlTransaction((oGlAccount)paramObj, false, "A", HttpContext.Current.Request.UserHostAddress, errLog);
                    break;
                }
                throw new HttpResponseException(HttpStatusCode.BadRequest);
            }
            return(Ok());
        }
        public async Task <IHttpActionResult> AddBusinessPartner(oBusinessPartner businessPartner)
        {
            try
            {
                if (!GlobalInstance.Instance.IsConnected)
                {
                    GlobalInstance.Instance.InitializeSboComObject();
                }
                var bp = await repo.GetByCardCode(businessPartner.CardCode);

                string validationStr = ModelValidator.ValidateModel(businessPartner);

                if (!string.IsNullOrEmpty(validationStr))
                {
                    errMsg = string.Format(validationStr);
                    var resp = new HttpResponseMessage(HttpStatusCode.Conflict);
                    resp.Content      = new StringContent(errMsg);
                    resp.ReasonPhrase = "Object property validation error";
                    var err = ErrorLogger.Log(new ErrorLog
                    {
                        ErrorCode  = (int)HttpStatusCode.Conflict,
                        Message    = errMsg,
                        StackTrace = Environment.StackTrace
                    });

                    transactionLogger.LogBPTransaction(businessPartner, false, "A", this.Request.Headers.Host, err);
                    throw new HttpResponseException(resp);
                }

                if (businessPartner != null)
                {
                    errMsg = string.Format("Business partner {0} already exist.", businessPartner.CardCode);
                    var resp = new HttpResponseMessage(HttpStatusCode.Conflict);
                    resp.Content      = new StringContent(errMsg);
                    resp.ReasonPhrase = "Object already exist.";
                    var err = ErrorLogger.Log(new ErrorLog
                    {
                        ErrorCode  = (int)HttpStatusCode.Conflict,
                        Message    = errMsg,
                        StackTrace = Environment.StackTrace
                    });

                    transactionLogger.LogBPTransaction(businessPartner, false, "A", this.Request.Headers.Host, err);
                    throw new HttpResponseException(resp);
                }

                if (repo.Add(businessPartner) < 0)
                {
                    errMsg = GlobalInstance.Instance.SBOErrorMessage;
                    var resp = new HttpResponseMessage(HttpStatusCode.Conflict);
                    resp.Content      = new StringContent(errMsg);
                    resp.ReasonPhrase = "SBO Error";
                    var err = ErrorLogger.Log(new ErrorLog
                    {
                        ErrorCode  = (int)HttpStatusCode.Conflict,
                        Message    = errMsg,
                        StackTrace = Environment.StackTrace
                    });

                    transactionLogger.LogBPTransaction(businessPartner, true, "A", this.Request.Headers.Host, err);
                    throw new HttpResponseException(resp);
                }

                transactionLogger.LogBPTransaction(businessPartner, true, "A", this.Request.Headers.Host);
                return(Ok(string.Format("Business partner {0} succesfully added.", businessPartner.CardCode)));
            }
            catch (HttpResponseException ex)
            {
                throw new HttpResponseException(HttpStatusCode.BadRequest);
            }
        }