WEB Servisi Çağrıları

Form Üzerinden Web Servis Çağırısı

Kodlama bölümüne geçmeden önce Web servis girdilerini form üzerindenyapabiliriz.

function personelDoldur() {
    
    const bolgeAdi = PwForm.get("BOLGE_ADI");      // input Parametresi
    const calismaYeri =PwForm.get("CALISMA_YERI"); // input Parametresi
    
    const inputs = [{ ParamName: 'bolgeAdi', ParamValue: bolgeAdi },
        { ParamName: 'CalismaYeri', ParamValue: calismaYeri }];  

    const serviceName = "YENI";  // "http://argusdev.g-gsoft.com:125/Service.asmx?wsdl" //Servis Url'i de kullanılabilir
    const functionName = "PersonelListesi";    //  Serviste çağırlacak fonksiyon ismi
    
    var hdr = [     //Tabloda gösterilecek alanların Başlıklarının Belirlenmesi
        { field: 'Personel_Ad', title: 'Personel Adı' },
        { field: 'Personel_Soyad', title: 'Personel Soyadı' },
        { field: 'Personel_No', title: 'Personel No' },
        { field: 'Gorev_Adi', title: 'Gorev Adı' }
    ];
     
             PwForm.webService(serviceName, functionName, inputs).then(result => {  // servise verilecek parametlerin girilmesi
             PwForm.fillGrid('PERSONELLER', result, hdr);                           // Gelen verilerin Tabloya Bind edilmesi
     });
    
 }

personelDoldur fonksiyonu içerisinde Fonksiyonun inputlarını hangi tip alanlarından alacağını belirliyoruz. Ardından Web servis tanımlarında tanımladığımız servis ismini ve hangi fonksiyonu kullanmak istiyorsak fonksiyonu seçiyoruz. webservice metoduna ilgili parametreleri verip result’ı belirlediğimiz veri tablosuna bind ediyoruz.

İstersek result’ı listeye yada for ile dönerek  İstenilen tip alanlarına set edebiliriz.

Makro Adımında Servis Çağırma

try{
    LoadObject();
    string Message = "";
    List<Param> webInputs = new List<Param>();
    webInputs.Add(new Param() { ParamName = "bolgeAdi", ParamValue =    FormData.Get("BOLGE_ADI").ToString() });
    webInputs.Add(new Param() { ParamName = "CalismaYeri", ParamValue = FormData.Get("CALISMA_YERI").ToString() });

    dynamic ServiceResult = JsonConvert.DeserializeObject(CallMvc("YENI", "PersonelListesi", webInputs, ref Message));
    if (ServiceResult == null)
        throw new Exception(Message);
    Log("ServiceResult:" + ServiceResult);
    foreach (var a in ServiceResult)
    {
        var row = FormData.getNewRow("PERSONELLER");
        row.Set("PERSONEL_ADI", (string)a.Personel_Ad);
        row.Set("PERSONEL_SOYADI", (string)a.Personel_Soyad);
        row.Set("PERSONEL_NUMARASI", (string)a.Personel_No);
        row.Set("GOREV_ISMI", (string)a.Gorev_Adi);
        FormData.AddRepRow("PERSONELLER", row);
    }   
    SaveObject();
}
catch (Exception ex)
{
    throw new Exception(ex.Message);
}

Metod tanımında web servisi nasıl kullanırım?

using Paperwork.Library;
using Paperwork.Methods;
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Web.Script.Serialization;
namespace mtdTemplateCodes
{
    public class UpdateCustList: PWMethod
    { 
        public override int Execute(Dictionary<string, object> paramList)
        {
            base.Execute(paramList);
            try
            {
                Log("UpdateCustList started.");
                ConnectServer();
                InternalExecute();
                Log("UpdateCustList finished");
            }
            catch (Exception ex)
            {
                Log("TestDefault Ex :" + ex.ToString());
            }
            finally
            {
                try
                {
                    DisConnectServer();
                }
                catch (Exception exx)
                {
                    Log(exx.ToString());
                }
            }
            return 0;
        }

        private void InternalExecute()
        {
            var serviceName = "SERVICE_NAME";
            var methodName = "Method Name";
            var prms =new  List<Param>();
            ins.Add(new Param() { ParamName=getParam("PARAM_NAME"), ParamValue=getParam("PARAM_VALUE")});
            var req = CallService(serviceName, methodName,prms);//Servis metodu için gerekli parametreler ile servis çağrılır.
            if (req.ErrorCode != 0)
                throw new Exception(req.Message);
            else
               {
                var dd = (dynamic)new JavaScriptSerializer().DeserializeObject(req.Result);
                if(dd["Success"])
                {
                    string lst_name = "LIST_NAME"; // Sistemde kayıtlı liste adı
                    List<a_ListDef> getalllists = server.rPreset.Lists(lst_name);
                    if (getalllists.Count == 0)
                        throw new Exception("List didnt find!");
                    var delRes = server.rLookup.DeleteAllListItems(getalllists[0].Id);// liste verileri sıfırlanır.
                    if (delRes.ErrorCode != 0)
                        throw new Exception(delRes.Message);

                    for (int i = 0; i < dd["Result"].Length; i++)//Sistem listesi verileri servisten  gelen veri ile güncellenir.
                    {
                        ListLookup item = new ListLookup();
                        item.Key1 = dd["Result"][i]["ObjectId"].ToString();
                        item.Key2 = dd["Result"][i]["Name"].ToString();
                        var addRes = server.rLookup.AddListItem(getalllists[0].Id, item);
                        if (addRes.ErrorCode != 0)
                            throw new Exception(addRes.Message);
                    }
                }
            }

        }

        public a_GenericResult CallService(string serviceName, string MethodName, List<Param> inputs)
        {
            var result = new a_GenericResult();
            var json = new JavaScriptSerializer().Serialize(new { clientId = server.roComps.fChannel.ClientGuid, serviceName, MethodName, inputs });
            try
            {
                string url = string.Format("http{0}://{1}/Workflow/ExecuteService",getParam("IS_SECURE"),getParam("HOST"));
                result.Result = doRequest(url, json, 60);
            }
            catch (Exception ex)
            {
                result.ErrorCode = -1;
                result.Message = ex.Message;
            }
            return result;
        }
        private string doRequest(string url, string _data, int timeout)
        {
            var httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
            CookieContainer cookies = new CookieContainer();
            httpWebRequest.CookieContainer = cookies;
            httpWebRequest.ContentType = "application/json";
            httpWebRequest.Method = "POST";
            httpWebRequest.Timeout = timeout * 1000;
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;

            using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
            {
                streamWriter.Write(_data);
                streamWriter.Flush();
            }

            HttpWebResponse httpResponse = null;
            try
            {
                httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
                if (httpResponse.StatusCode == HttpStatusCode.OK)
                {
                    using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
                    {
                        return streamReader.ReadToEnd();
                    }
                }
                else
                    throw new Exception("Session could not be found");
            }
            finally
            {
                if (httpResponse != null)
                    httpResponse.Dispose();
                httpResponse = null;
            }
        }

        public class Param
        {
            public string ParamName { get; set; }
            public string ParamValue { get; set; }
        }
    }
}

Metot yazarken dikkat edilmesi gereken hususlar;

System.Web.Extensions dll’ini Paperwork/Bin/Libs içerisine eklemek ve bunu Web Servis tanımlarında

Dış kaynak bölümünde 

C:\Paperwork\Bin\Libs\System.Web.Extensions.dll;

şeklinde tanımlamak gerekebilir.