Dynamics CRM'in iş dünyasının parlayan yıldızı olan ve her türlü iş platfomunun temeline yerleştirebilecek bir mimaride olduğunu her fırsatta anlatmaya çalışıyorum. Bu mimari üzerinde bizim kod geliştirmemizi ve sistem ile entegre olmamızı sağlayan web servisleri ve dll'ler vasıtasıyla yazma ve okuma işlemlerimizi gerçekleştirmekteyiz. Bugün sizlere daha önceden eski versiyonlar için de bahsetmiş olduğum oluşturma,  güncelleme ve silme metodlarının yapısını tekrar anlatacağım ama sonunda bunları Process isimli bir class'da birleştirip tek bir yerden yönetilmelerini sağlayacağız.

CRM servis nesnesi bize kayıtlar üzerinde işlem yapma özelliği sağlamaktadır. Servis içinden yapmak istediğimiz harekete uygun metodu çağırmamız gerekmektedir.  Tabii burada unutulmaması gereken konu servisi çağıran kullanıcının çağrılan metodda işlem yapmaya yetkili olması gerekmektedir.

Create Metodu CRM 2011 içerisinde bir entity içerisinde yeni bir nesne oluşturmamıza olanak tanır. Metod parametre olarak entity türünden bir nesne alır ve yeni oluşturulmuş nesnenin GUID türünden değerini geri döndürür.

Aşağıdaki örnek bu metodun late-bound sınıfla kullanımını göstermektedir.

// Entity nesnesinin yeni bir instance’ini olusturuyoruz
Entity account = new Entity("account");
// Gerekli attribute’lara atama yapiyoruz.
account["name"] = "Örnek Firma";
// Örnek Firma adında bir firma karti olusturuyoruz.
_accountId = ioService.Create(account); 

Aşağıdaki örnek bu metodun early-bound sınıfla kullanımını göstermektedir.

Contact contact = new Contact()
{
    FirstName="Deneme",
    LastName="Kisisi",
    Address1_City="İstanbul",
};
Guid contactGuid =_service.Create(contact);

Update Metodu CRM 2011 içerisinde bir entity içerisinde bir nesneyi güncellememizi sağlar. Metod parametre olarak entity türünden bir nesne alır. Güncellenecek nesnenin id’si mutlaka parametre olarak verilmelidir.

Guid gContact = new Guid("7bE545CCD3-9A3A-E011-BA8B-78E7D1623F9D");
 
Contact contact = new Contact()
{
     ContactId = gContact,
     FirstName="Test",
     LastName="Kisisi",
     Address1_City="Ankara",
};
_service.Update(contact);

Delete Metodu CRM 2011 içerisinde Id’sini verdiğiniz bir nesneyi sistemden silmeye yarar. Metod parametre olarak silinecek nesnenin Id’si yanında bu nesnenin türünü ister.

Guid gContact = "7bE545CCD3-9A3A-E011-BA8B-78E7D1623F9D";
_service.delete("contact", gContact); 

Bir programcı olarak çok standart olan bu işlemleri isterseniz bir class mantığı altında birleştirelim. Bu sayede daha yönetilebilir bir CRUD (Create, Read, Update, Delete) yapısı oluşturabiliriz. Ben bu sınıf için Process adını kullandım ve Process sınıfı içerisinde şu anda Oluşturma, Güncelleme ve Silme işlerimi yapmaktayım. İlerleyen makalelerde Okuma yapılarını incelerken onları da bu sınıfa dâhil ederiz.

Burada öncelikle açıklamalıyım ki bir önceki makalede yer alan Singleton tasarım deseniyle CRM servisini oluşturma yazımdaki class’tan faydalanarak servisi çağırma işlemini gerçekleştirdim. O yazıyı okumak isterseniz buraya tıklayınız

Ek olarak hata olaylarını kontrol etmek için Result isimli bir class kullandım bu class’ın içeriği şu şekilde;

public class Result
    {
        public string Message { get; set; }
        public bool isError { get; set; }
        public Object BusinessObject { get; set; }
 
        public Result(string _Message, bool _isError, Object _BusinessObject)
        {
            Message = _Message;
            isError = _isError;
            BusinessObject = _BusinessObject;
        }
 
        public Result(string _Message, bool _isError)
        {
            Message = _Message;
            isError = _isError;
            BusinessObject = null;
        }
    }

Görüldüğü üzere çok basit bir class bize sonucun başarılı mı başarısız mı olduğunu döndürecek o kadar.

Bunun haricinde bir de Base isimli bir class’ım var ki Process sınıfını aslında bu class’dan türetmekteyim. Şu anda bu class’ı sadece ErrorNumber ve ErrorDetail gibi hata oluştuğunda bilgi almamızı sağlayacak iki property ile kullanmaktayım ama ileride farklı propertyler de eklenecek.

public class Base
{
    public int ErrorCode { get; set; }
    public string ErrorDetail { get; set; }
} 

Bu iki class’ımı açıkladıktan sonra asıl yapıda kullanacağımız metodlara gelelim. İlk önce create metodunu inceleyelim. Hatırlayacağınız üzere CRM servisinde Create metdonun Update metodundan tek farkı id’ye ihtiyaç duymamasıydı. Çünkü bu metod id’yi üretip bize geri döndürecek. Ben de kurguyu buna göre planladım.

public Result Create(Entity EntityForCreate)
       {
            try
            {
                Service service = Service.GetService();
 
                if (service == null)
                    throw new Exception("Service is null");
                if (service != null && service.ErrorCode > 0)
                    throw new Exception(service.ErrorDetail);
 
                Guid EntityID = service.OrganizationService.Create(EntityForCreate);
 
                DetailedLog.CreateLog("Entity Created! Type: " + EntityForCreate.LogicalName + ", ID : " + EntityID, 
                    System.Diagnostics.EventLogEntryType.Information);
 
                return new Result("", false, EntityID);
            }
            catch (Exception ex)
            {
                ErrorCode = 100;
                ErrorDetail = ExceptionHandler.HandleException(ex);
                DetailedLog.CreateLog(System.Reflection.Assembly.GetExecutingAssembly().GetName().Name
                    + " : " + System.Reflection.MethodBase.GetCurrentMethod().ToString()
                    + " : " + ErrorDetail, System.Diagnostics.EventLogEntryType.Error);
 
                return new Result(ErrorDetail, true);
            }
        }

Aslında yapı çok basit servis nesnemi çağırıyorum, servis oluşurken hata var mı diye bakıyorum eğer hata varsa hatayı fırlatıyorum. (bu noktada şunu belirtmeliyim ki catch bölümünde yer alan DetailLog ve ExceptionHandler benim daha önceden yazmış olduğum hata yönetimi ile ilgili class’lar catch bölümünü siz de istediğiniz gibi düzenleyebilirsiniz) Eğer hata yok ise OrganizationService metodumu kullanarak nesnemi oluşturuyorum. Bu noktada da bir hata yoksa servis bana oluşturduğu nesnenin id’sini döndürüyor yok eğer hata varsa zaten kod catch bloğuna düşüyor. İşte bu kadar.

Şimdi gelin diğer metodlara bir göz atalım;

public Result Update(Entity EntityForUpdate, Guid EntityID)
        {
            try
            {
                Service service = Service.GetService();
 
                if (service == null)
                    throw new Exception("Service is null");
                if (service != null && service.ErrorCode > 0)
                    throw new Exception(service.ErrorDetail);
 
                service.OrganizationService.Update(EntityForUpdate);
 
                DetailedLog.CreateLog("Entity Updated! Type: " + EntityForUpdate.LogicalName + ", ID : " + EntityID,
                    System.Diagnostics.EventLogEntryType.Information);
 
                return new Result("", false);
            }
            catch (Exception ex)
            {
                ErrorCode = 100;
                ErrorDetail = ExceptionHandler.HandleException(ex);
                DetailedLog.CreateLog(System.Reflection.Assembly.GetExecutingAssembly().GetName().Name
                    + " : " + System.Reflection.MethodBase.GetCurrentMethod().ToString()
                    + " : " + ErrorDetail, System.Diagnostics.EventLogEntryType.Error);
 
                return new Result(ErrorDetail, true);
            }
        }

Update metodu neredeyse Create metodunun aynısı tek fark daha önce de ifade ettiğim gibi güncellenecek nesnenin id’sini alması. Bunu almalı ki neyi güncellediğini bilebilsin. Aslında burada şöyle bir mantıksal kargaşa var update metodu ek olarak id’yi almamakta zaten sizin ona update edilmesi için vereceğiniz entity’nin Id alanına vermelisiniz. Benim burada ek olarak almamdaki amaç onu loglamak için.

Bir de Delete metoduna göz atalım;

public Result Delete(string EntityName, Guid EntityID)
        {
            try
            {
                Service service = Service.GetService();
 
                if (service == null)
                    throw new Exception("Service is null");
                if (service != null && service.ErrorCode > 0)
                    throw new Exception(service.ErrorDetail);
 
                service.OrganizationService.Delete(EntityName, EntityID);
 
                DetailedLog.CreateLog("Entity Created! Type: " + EntityName + ", ID : " + EntityID,
                    System.Diagnostics.EventLogEntryType.Information);
 
                return new Result("", false);
            }
            catch (Exception ex)
            {
                ErrorCode = 100;
                ErrorDetail = ExceptionHandler.HandleException(ex);
                DetailedLog.CreateLog(System.Reflection.Assembly.GetExecutingAssembly().GetName().Name
                    + " : " + System.Reflection.MethodBase.GetCurrentMethod().ToString()
                    + " : " + ErrorDetail, System.Diagnostics.EventLogEntryType.Error);
 
                return new Result(ErrorDetail, true, null);
            }
        }

Delete metodu entity’nin adını ve id’sini almakta. Bu iki veriyi de servise vermekteyiz.

Class’ın tamamına bakacak olursak;

public class Process : Base
    {
        public Result Create(Entity EntityForCreate)
        {
            try
            {
                Service service = Service.GetService();
 
                if (service == null)
                    throw new Exception("Service is null");
                if (service != null && service.ErrorCode > 0)
                    throw new Exception(service.ErrorDetail);
 
                Guid EntityID = service.OrganizationService.Create(EntityForCreate);
 
                DetailedLog.CreateLog("Entity Created! Type: " + EntityForCreate.LogicalName + ", ID : " + EntityID, 
                    System.Diagnostics.EventLogEntryType.Information);
 
                return new Result("", false, EntityID);
            }
            catch (Exception ex)
            {
                ErrorCode = 100;
                ErrorDetail = ExceptionHandler.HandleException(ex);
                DetailedLog.CreateLog(System.Reflection.Assembly.GetExecutingAssembly().GetName().Name
                    + " : " + System.Reflection.MethodBase.GetCurrentMethod().ToString()
                    + " : " + ErrorDetail, System.Diagnostics.EventLogEntryType.Error);
 
                return new Result(ErrorDetail, true);
            }
        }
 
        public Result Update(Entity EntityForUpdate, Guid EntityID)
        {
            try
            {
                Service service = Service.GetService();
 
                if (service == null)
                    throw new Exception("Service is null");
                if (service != null && service.ErrorCode > 0)
                    throw new Exception(service.ErrorDetail);
                
                service.OrganizationService.Update(EntityForUpdate);
 
                DetailedLog.CreateLog("Entity Updated! Type: " + EntityForUpdate.LogicalName + ", ID : " + EntityID,
                    System.Diagnostics.EventLogEntryType.Information);
 
                return new Result("", false);
            }
            catch (Exception ex)
            {
                ErrorCode = 100;
                ErrorDetail = ExceptionHandler.HandleException(ex);
                DetailedLog.CreateLog(System.Reflection.Assembly.GetExecutingAssembly().GetName().Name
                    + " : " + System.Reflection.MethodBase.GetCurrentMethod().ToString()
                    + " : " + ErrorDetail, System.Diagnostics.EventLogEntryType.Error);
 
                return new Result(ErrorDetail, true);
            }
        }
 
        public Result Delete(string EntityName, Guid EntityID)
        {
            try
            {
                Service service = Service.GetService();
 
                if (service == null)
                    throw new Exception("Service is null");
                if (service != null && service.ErrorCode > 0)
                    throw new Exception(service.ErrorDetail);
 
                service.OrganizationService.Delete(EntityName, EntityID);
 
                DetailedLog.CreateLog("Entity Created! Type: " + EntityName + ", ID : " + EntityID,
                    System.Diagnostics.EventLogEntryType.Information);
 
                return new Result("", false);
            }
            catch (Exception ex)
            {
                ErrorCode = 100;
                ErrorDetail = ExceptionHandler.HandleException(ex);
                DetailedLog.CreateLog(System.Reflection.Assembly.GetExecutingAssembly().GetName().Name
                    + " : " + System.Reflection.MethodBase.GetCurrentMethod().ToString()
                    + " : " + ErrorDetail, System.Diagnostics.EventLogEntryType.Error);
 
                return new Result(ErrorDetail, true, null);
            }
        }
    }

Class’ımızı bu şekilde oluşturduktan sonra gelin onu bir konsol uygulaması yardımıyla çağıralım ve iş başında görelim.

static void Main(string[] args)
        {
            try
            {
                Entity lead = new Entity("lead");
                lead.Attributes["subject"] = "Fuardan Gelenler";
                lead.Attributes["firstname"] = "Barış";
                lead.Attributes["lastname"] = "KANLICA";
                lead.Attributes["companyname"] = "Omerd Business Solutions";
 
                Process process = new Process();
                Result result = process.Create(lead);
                if (result.isError)
                    throw new Exception(result.Message);
 
                Console.WriteLine("Lead created : " + result.BusinessObject.ToString());
                Console.ReadLine();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error : " + ex.Message);
                Console.ReadLine();
            }
        }

Gördüğünüz üzere Entity nesnemi çağıyor ve ona lead adını veriyorum. İçerisi istediğim bilgiler ile dolduruyor ve Process class’ımın içindeki Create metodu vasıtasıyla CRM içerisinde oluşmasını sağlıyorum. İşte hepsi bu kadar :) 

Bütün bu işlemler sonunda tek bir noktadan yönetilebilir bir CRUD mimarisi yavaş yavaş ortaya çıkmakta. Sıra Okuma işlemlerinin detaylarına inmekte. Onu da artık başka bir makalede inceleyeceğiz.

Microsoft Dynamics CRM 2013 ve Microsoft Dynamics CRM Online güçlü ve gelişmiş bir iş platformu deneyimini kullanıcılarına sunmaktadır. Dynamics CRM içerisine entegre edilmiş gelişmiş uygulama altyapısı sayesinde sadece uygulamayı kullanmakla kalmıyor aynı zamanda onun istediğimiz yerlerini işimize uygun halde yeniden programlayarak hem kendi içinde hem de dış uygulamalarla konuşabilen kendi iş çözümümüzü oluşturabiliyoruz. Bu şekilde genişlemeye biz xRM adını vermekteyiz. Yani herşeyin yönetilebildiği bir platform.

Dynamics CRM Microsoft tarafından çeşitli zamanlarda çıkartılan çeşitli service pack ve rollup paketleriyle genişlemekte ve yeni özellikler kazandırılmaktadır.

Dynamics CRM mevcutta üç farklı çeşitte paketlenmektedir;

• Microsoft Dynamics CRM 2013 on-premises deployment
• Microsoft Dynamics CRM 2013 Internet-facing deployment (IFD)
• Microsoft Dynamics CRM Online

Bu üç çeşitte de aşağıdaki şekillerde son kullanıcı arabirimi sunmaktadır;

• Microsoft Dynamics CRM Web client
• Microsoft Dynamics CRM for Microsoft Office Outlook
• Microsoft Dynamics CRM for Microsoft Office Outlook with Offline Access
• Microsoft Dynamics CRM for phones and tablets

Yani siz Dynamics CRM’i şirketiniz için kullanmaya başladıktan sonra isterseniz Internet Explorer, Chrome, Safari gibi browserlardan sisteme girebilir isterseniz de cep telefonu ya da Outlook üzerinden de kullanabilirsiniz.

Oluşturduğunuz uygulamaları Dynamics CRM ile Web Servisleri aracılığıyla entegre edebilirsiniz. Bu web servisleri arka tarafta Dynamics CRM’in kalbi olan xRM platform katmanı ile iletişim halinde bulunmaktadır.

Bu katmanda güvenlik gibi genel kısımları içermektedir ve bir uygulamanın çalışması için gerekli olan yapı taşlarını içerir fakat kendisi ilgili nesnelerinin bir koleksiyonun başka bir şey değildir. Nesneler arasındaki iletişimi sağlar ve tekliften siparişe, siparişten faturaya gibi fiyatlandırma mantığı gibi daha genişletilebilir bir mantığı uygulamak için kullanılır.

XRM platformu ayrıca, güvenlik yoluyla verilere ve veritabanına erişimi denetler. Ayrıca iş akışı ve özel iş mantığı uygulamaları (plugins) için süreçlerinin tetiklenmesini denetler. Bu katman Microsoft Exchange Server üzerinden gelen ve giden e-posta işleme alır.

Bir önceki makalede FetchXML ile neler yapabileceğimize değindik. (Buraya tıklayarak o makaleye ulaşabilirsiniz) Eğer istersek FetchXML ile grouping ve aggregate işlemlerini de yapabilmekteyiz. FetchXML ile aşağıdaki işlemler desteklenmektedir;

·         sum

·         avg

·         min

·         max

·         count(*)

·         count(attribute name)

Aggregate yapabileceğimiz sorgu örneği standart olarak bildiğimiz fetchXML kurgusundan farklı değil burada sadece attribute kısmında aggregate ile ilgili keyword yer almakta. Aggregate=true diyerek bu şekilde bir sorgulama yapacağımızı sisteme söylüyoruz. Sonrasında ise sırasıyla hangi alan üzerinden işlem yapılacağını, alias yani etiketin ne olacağını ve aggregate türümüzün ne olacağını sisteme söylüyoruz.

<fetch distinct='false' mapping='logical' aggregate='true'>

  <entity name='opportunity'>

    <attribute name='name' alias='opportunity_count' aggregate='count'/>

  </entity>

</fetch>

Bu şekilde oluşturduğumuz bir sorgu ile aslında şunu demek istiyoruz : “select count('name') as opportunity_count from opportunity” yani standart bir count işleminden fazlası değil yaptığımız.

Bu fetchXML’i çalıştırmak için ise aşağıdaki gibi bir kod hazırladım;

string opportunity_count = @" <fetch distinct='false' mapping='logical' aggregate='true'>

                                                <entity name='opportunity'>

                                                    <attribute name='name' alias='opportunity_count' aggregate='count'/>

                                                </entity>

                                              </fetch>";

                EntityCollection opportunity_count_result = ServiseBaglan().RetrieveMultiple(new FetchExpression(opportunity_count));

                foreach (var c in opportunity_count_result.Entities)

                {

                    Int32 aggregate2 = (Int32)((AliasedValue)c["opportunity_count"]).Value;

                    System.Console.WriteLine("Count of all opportunities: " + aggregate2);

                }

Burada dikkat edilmesi gereken nokta geriye EntityCollection döndürmesi. Bir önceki makalemden hatırlarsanız normalde bu tarz sorgulama ile biz geriye account, contact gibi sitem içerisindeki nesnelerden oluşmuş bir dizi alıyoruz. FetchXML yapısı gereği tek bir metod kullanıyoruz ve bu metod sonucunda yukarıdaki örnekte olduğu gibi tek bir satır dahi dönecek olsa bile yine sonucu bir collection içerisinde almaktayız. Bu nedenle mecbur foreach içerisinde dönüyoruz ya da collection’un 0. üyesini alıyoruz. Ben örneğimde foreach ile collection içinde döndüm ve gördüğünüz gibi değeri aldım.

Yine bir önceki makalemde ileri düzey sorgular bölümünde anlattığım gibi eğer nesne üzerinden direkt bir değer döndürmeyeceksek sonuç her zaman AliasedValue olarak gelmekte. işte bu nedenden dolayı şu şekilde bir convert işlemi yapıyoruz;

Int32 aggregate2 = (Int32)((AliasedValue)c["opportunity_count"]).Value

Bu işlem sonucunda bu koddan aşağıdaki gibi çıktımızı alabiliyoruz.

Eğer distinct yapmak istersek de fetchXML içerisine yerleştireceğimiz bir distinct=”true” ifadesiyle ile sisteme bunu beliretebiliriz.

Aşağıda ise distinct yapılmış bir kod örneği bulunmakta;

<fetch distinct='false' mapping='logical' aggregate='true'>

  <entity name='opportunity'>

    <attribute name='name' alias='opportunity_distcount' aggregate='countcolumn' distinct='true'/>

  </entity>

</fetch>

Bu FetxhXML’i de aşağıdaki kodla çalıştırabiliriz.

                string opportunity_distcount = @"

                                           <fetch distinct='false' mapping='logical' aggregate='true'>

                                               <entity name='opportunity'>

                                                  <attribute name='name' alias='opportunity_distcount' aggregate='countcolumn' distinct='true'/>

                                               </entity>

                                           </fetch>";

                EntityCollection opportunity_distcount_result = ServiseBaglan().RetrieveMultiple(new FetchExpression(opportunity_distcount));

                foreach (var c in opportunity_distcount_result.Entities)

                {

                    Int32 aggregate4 = (Int32)((AliasedValue)c["opportunity_distcount"]).Value;

                    System.Console.WriteLine("Distinct name count of all opportunities: " + aggregate4);

                }

                Console.ReadLine();

Bu kod sonucunda da aşağıdaki gibi bir cevap alabiliriz sistemden;

Gelin olayı biraz renklendirelim. Bu sefer de bir sorgu içerisinde birden fazla aggregate seçeneğinin cevabını isteyelim. Böyle bir işlem için standart fetchXML’in içerisinde sırasıyla hangi özelliklerin bize geri döneceğini belirtiyoruz tabii unutulmaması gereken nokta ise hepsi için ayrı birer alias olması gerektiğidir.

<fetch distinct='false' mapping='logical' aggregate='true'>

  <entity name='opportunity'>

    <attribute name='opportunityid' alias='opportunity_count' aggregate='count'/>

    <attribute name='estimatedvalue' alias='estimatedvalue_sum' aggregate='sum'/>

    <attribute name='estimatedvalue' alias='estimatedvalue_avg' aggregate='avg'/>

  </entity>

</fetch>

Bu sorgu için ise aşağıdaki kodu hazırladım;

                string estimatedvalue_avg2 = @"

                                    <fetch distinct='false' mapping='logical' aggregate='true'>

                                        <entity name='opportunity'>

                                           <attribute name='opportunityid' alias='opportunity_count' aggregate='count'/>

                                           <attribute name='estimatedvalue' alias='estimatedvalue_sum' aggregate='sum'/>

                                           <attribute name='estimatedvalue' alias='estimatedvalue_avg' aggregate='avg'/>

                                        </entity>

                                    </fetch>";

                EntityCollection estimatedvalue_avg2_result = ServiseBaglan().RetrieveMultiple(new FetchExpression(estimatedvalue_avg2));

                foreach (var c in estimatedvalue_avg2_result.Entities)

                {

                    Int32 aggregate8a = (Int32)((AliasedValue)c["opportunity_count"]).Value;

                    System.Console.WriteLine("Count of all opportunities: " + aggregate8a);

                    decimal aggregate8b = ((Money)((AliasedValue)c["estimatedvalue_sum"]).Value).Value;

                    System.Console.WriteLine("Sum of estimated value of all opportunities: " + aggregate8b);

                    decimal aggregate8c = ((Money)((AliasedValue)c["estimatedvalue_avg"]).Value).Value;

                    System.Console.WriteLine("Average of estimated value of all opportunities: " + aggregate8c);

                }

                Console.ReadLine();

İşte bu şekilde aynı anda count, sum ve avg işlemlerini yapabilmekteyim. Sonuç ise aşağıdaki gibi;

Bu iki makalede FetchXML’ler üzerinde konuştuk. Umarım faydalı olmuştur.

Giriş
Bu yazı dizimizde sizlere Dynamics CRM’den veri çekmek için kullanabileceğiniz yapıları anlatacağım. FetchXML ile veri çekmek bence şu anda kullanılabilecek en pratik yöntem ama bunun haricinde .Net Language-Integrated Query(LINQ) ile early ve late binding türler üzerinden veri çekebileceğiniz gibi Dynamics CRM’in Query Expression mimarisini kullanarak da veri çekebilirsiniz.

Bu üçü haricinde OData ve Filtered View’ları kullanarak da veri çekebilirsiniz. OData(Open Data Protocol) Rest tabanlı servisler için protokol görevi gören bir veritabanı sorgulama yapısıdır. Filtered View’lar ise standart SQL ile SQL Server üzerinden direkt veri çekmek için kullanabileceğimiz yapılar ama Filtered View ve OData ile geriye CRM obje sınıflarıyla veri döndürememekteyiz. Yani SQL ile bir veri çektiğinizde DataSet ya da DataTable gibi yapılara veriyi çekebiliriz ama FetchXML ile CRM entity sınıfından geriye dönüş alırız bu yüzden kullanım açısından ilk yöntem daha kullanışlıdır.

LINQ ile veriler üzerinde işlem yapabilmek için Organization Service Context sınıfını türetip projeye eklemek gerekmektedir.

Benzerliklerini bir tablo üzerinde karşılaştırırsak;

Yetenekleri bakımından karşılaştırırsak;

FetchXML

FetchXML en güzel tarafı Dynamics CRM içerisinde Gelişmiş Ara (Advanced Find) ile oluşturduğumuz sorguların da bu şekilde sistemde kaydedilmesi. Ayrıca bu şekilde oluşturduğumuz sorguları da .xml olarak CRM’den alabiliyoruz böylece yazdığımız uygulama ya da rapor içerisinde de kullanabilmekteyiz. Böylece uzun uzun FecthXML hazırlamak yerine sistemin nimetlerinden yararlanarak sorgumuzu hazırlayabilmekteyiz. Bunun için gelişmiş bul içerisinde Fetch XML indir düğmesine tıklıyoruz.

CRM’de de bu kullanıcı sorguları userquery, organizasyon sorguları ise savedquery içerisinde saklanmaktadır.

IOrganizationService.RetrieveMultiple methodu ile FetchXML sorgulaması yapabilmekteyiz bunun için FetchXMLToQueryExpressionRequest mesajını kullanmak gerekmektedir. Ayrıca daha önce de belirttiğim gibi aggregations yani sum, max, min, count gibi matematiksel işlemleri de FetchXML ile yapabilmekteyiz.

Bu makaledeki örneklerde CRM Servisini çağırmak daha önceki Singleton Tasarım Deseni üzerinden geliştirdiğim servise bağlanma metodunu kullanıyorum. Sözünü ettiğim makaleye buradan ulaşabilirsiniz.  Bu noktayı siz de kendinize uygun olarak değiştirebilirsiniz.

Sorguyu Hazırlama

Bu noktada örnek bir fetchXML’i inceleyelim;

<fetch mapping='logical'>

  <entity name='account'>

    <all-attributes/>

  </entity>

</fetch>

FetchXML mutalaka “fetch” kelimeleri arasında yer almalı. Sonrasında ise “entity” kelimesi ile geri dönecek nesnenin türünü söylüyoruz. Sonrasında ise hangi alanların geri döneceğini ve nasıl koşullar olacağını belirtiyoruz. Tabii yukarıdaki örnekte bunlar yok “all-attributes” ile biz bütün alanları geri döndür diyoruz.

Size bu sorguyu SQL ile anlatmam gerekirse : “select * from account” şeklinde olacak. Şimdi işi biraz daha renklendirelim;

<fetch mapping='logical'>

  <entity name='contact'>

    <attribute name='fullname'/>

    <attribute name='createdon'/>

    <filter type='and'>

      <condition attribute='jobtitle' operator='eq' value='Purchasing Assistant'/>

    </filter>

  </entity>

</fetch>

Bu sorguda ise geriye contact yani ilgili kişi nesnesi geri dönecek ama sadece “fullname” ve “createdon” alanları ile. Ayrıca burada bir kriterimiz de var “jobtitle” alanı “Purchasing Assistant” olacak kayıtları alıyoruz. Yani yine SQL ile anlatırsam : “select fullname, createdon from contact where jobtitle='Purchasing Assistant'” Burada dikkat ettiyseniz operatör diye bir ifade yer almakta. Sorgulama yaparken değerlerin nasıl koşullarda alınması gerektiğini burada belirtiyoruz. Yani aşağıdaki tabloda da görebileceğiniz üzere sorgu ifadeleri kısmında "Koşul İfadesi" kısmında yazan değerler bizim normal sql cümlesinde kullandığımız ifadelere benzemektedir. Tek fark "=","<",">" gibi ifadelerin yerlerine "eq","gt","lt"gibi text bazlı ifadelerin gelmiş olmasıdır. 

Sorguyu Çalıştırma

Bu  sorguyu çalıştırcak metod ise RetrieveMultiple metodudur ve servisi örneklediğimizde karşımıza çaıkmaktadır. Bu metod makalenin başında bahsettiğim QueryExpression sınıfını da alarak işlem yapabilmektedir. Bu metodun bir de kardeşi vardır ve hazır yeri gelmişken bundan da bahsedeyim.

Retrieve Metodu ID’si verilen entity nesnesinin bildirdiğiniz sütünlarını bize geri döndürür.  Kullanımı çok basit olan bu metod geriye Entity türünden bir nesne döndürür. Bu nesne zaten bizim parametre olarak verdiğimiz nesne adının kendisidir ve bizim belirttiğimiz sutünları doldurarak getirir. Bu metod aslında sql cümlesi olarak bakarsak “ select alanisimleri from (nesne)entity where entityid = '...' ” işlemini yerine getirmektedir.

Aşağıdaki örnekle devam edelim;

Entity slead = servis.Retrieve("lead", new Guid("7bE545CCD3-9A3A-E011-BA8B-78E7D1623F9D"), new ColumnSet(new string [] { "fullname", "companyname" }));

foreach (var item in slead.Attributes)

{

    Console.WriteLine(item.Key + ":" + item.Value);

}

Eğer entity’nin bütün alanlarını geri döndürmek istiyorsak new ColumnSet(true) komutunu ColumnSet yerine vermemiz gerekmektedir. Yani eğer siz sorgulayacağımız nesnenin GUID türünden idsini biliyorsanız ve join gibi işlemlerle işiniz yoksa düz mantıkta bir sorgulama yapmak için bu metodu kullanabilirsiniz.

RetrieveMultiple Metodu ise gerçek anlamda karışık sorguları yapmamıza olanak tanır. Ama burada tamamen object oriented bir mimari söz konusudur yani temelde bir sorgulama cümlesi olmadan QueryExpression ya da QueryByAttribute sınıflarının örnekleri üzerinden sorgulama işlemi yapılmasına da olanak sağlar.

Bizim odak konumuz ise fetchXML olduğu için konuyu fazla dağıtmadan devam edelim.

Bu fetchXML sorgusunu çalıştırmak için ise şu şekilde bir kod yazdım;

string fetchXml = @"<fetch mapping='logical'>

                                 <entity name='contact'>

                                    <attribute name='fullname'/>

                                    <attribute name='createdon'/>

                                     <filter type='and'>

                                        <condition attribute='jobtitle' operator='eq' value='Purchasing Assistant'/>

                                     </filter>

                                 </entity>

                             </fetch>";

                EntityCollection contactlist = (EntityCollection)ServiseBaglan().RetrieveMultiple(new FetchExpression(fetchXml));

                foreach (var cnt in contactlist.Entities)

                {

                    Console.WriteLine(cnt.Attributes["fullname"].ToString() + ":" + cnt.Attributes["createdon"].ToString());

                }

                Console.ReadLine();

Sorgu Sonucu

İşte biraz önce bahsettiğim RetrieveMultiple metoduna fetchXML’i veriyorum. Dönüşte ise sistem bana EntityCollection içerisinde talep ettğim entity’i vermekte. Bu noktadan sonra foreach ile bütün kayıtar içinde dolaşabilir ve Attributes ile alanlara ulaşabilirim.

Bu kodu çalıştırınca da aşağıdaki gibi sonucu almaktayım;

İleri Seviye Sorgular

Yukarıda temel bilgileri verdikten sonra ileri seviye bilgilerle buradan devam edebiliriz.

<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'>

  <entity name='lead'>

    <attribute name='fullname' />

    <attribute name='createdon' />

    <filter type='and'>

      <condition attribute='ownerid' operator='eq-userid' />

      <condition attribute='statecode' operator='eq' value='0' />

    </filter>

  </entity>

</fetch>

Bu sorguda ise “lead” türünden nesneleri geri döndürmekteyiz. “fullname” ve “createdon” alanlarını istemekteyiz sorgu ile ama “ownerid” yani kayıtların sahibi “eq-userid” diyerek servise kim bağlandıysa onun kayıtları olacak ve durumları da aktif olacak.

Düz mantıktaki tek bir nesne üzerinden sorgular işte bu şekilde yapılmakta ama sistem bundan daha fazlasına izin verebilmekte yani biz eğer istersek inner ya da outer join yaparak başka nesneler ile de ilişki içerisindeki kayıtları da geriye döndürebiliriz. Aşağıdaki örnek üzerinden açıklamaya çalışayım;

<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'>

  <entity name='account'>

    <attribute name='name' />

    <attribute name='address1_city' />

    <attribute name='telephone1' />

    <order attribute='name' descending='true' />

    <filter type='and'>

      <condition attribute='name' operator='like' value='{0}%' />

    </filter>

    <link-entity name='contact' from='contactid' to='primarycontactid' alias='kisi'>

      <attribute name='emailaddress1' />

      <filter type='and'>

        <condition attribute='firstname' operator='like' value='{0}%' />

      </filter>

    </link-entity>

    <link-entity name='systemuser' from='systemuserid' to='createdby' visible='false' link-type='outer' alias='kullanici'>

      <attribute name='firstname' />

    </link-entity>

  </entity>

</fetch>

Burada temelde yine bir nesne üzerinde yani “account” nesnesi üzerinden hareket ediyor gibi gözüksek de “link-entity” düğümleriyle işi genişletiyoruz. Örnekte görebileceğiniz üzere “contact” ve “systemuser” nesneleri üzerinden de geriye alan döndürdüğümüz gibi bunlar üzerinden de sorgulama yapabilmekteyiz. “link-entity” içerisinde sisteme hangi nesne ile link yapacağımızı ve bu nesnelerin hangi alanlar üzerinde birbirleriyle ilişki içerisinde olduklarını söylemekteyiz. Ayrıca “alias” vererek de kodun ilerleyen kısımlarında buradan gelecek alanlar için bir tanımlayıcı da oluşturabilmekteyiz.

Burada ben “link-type” olarak “outer” kullandım ama siz isterseniz “inner join” yapmak için “inner” de kullanabilirsiniz.

Bu arada belirtmeliyim ki “order” komutu ile de belli bir alan üzerinden kayıtların “ascending” ya da “descending” olarak sıralanmasını da sağlayabilmekteyiz.

Örnekte ben firma adı ve kişi adı için konsoldan parametre almaktayım bu yüzden orada “{0}” ifadesini görmektesiniz.

Bu sorguyu daha raht anlamanız için SQL cümlesine çevirecek olursam;

select name, address1_city, telephone1, kisi.emailaddress1, kullanici.firstname from account inner join contact kisi on kisi.contactid = account.primarycontactid

inner join systemuser kullanici on kullanici.systemuserid = account.createdby

where account.name like '%%' and kisi.firstname like '%%'

order by account.name desc

Böyle bir sorgu yazmamız gerekirdi. Bu kodu çalıştıracak örnek uygulama ise şu şekilde;

string fetch = @"

                                   <fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'>

                                  <entity name='account'>

                                    <attribute name='name' />

                                    <attribute name='address1_city' />

                                    <attribute name='telephone1' />

                                    <order attribute='name' descending='true' />

                                    <filter type='and'>

                                      <condition attribute='name' operator='like' value='{0}%' />

                                    </filter>

                                    <link-entity name='contact' from='contactid' to='primarycontactid' alias='kisi'>

                                      <attribute name='emailaddress1' />

                                      <filter type='and'>

                                        <condition attribute='firstname' operator='like' value='{0}%' />

                                      </filter>

                                    </link-entity>

                                    <link-entity name='systemuser' from='systemuserid' to='createdby' visible='false' link-type='outer' alias='kullanici'>

                                      <attribute name='firstname' />

                                    </link-entity>

                                  </entity>

                                </fetch>";

                Console.WriteLine("bir karakter yazın:");

                fetch = string.Format(fetch, Console.ReadLine());

                EntityCollection groupby1_result = ServiseBaglan().RetrieveMultiple(new FetchExpression(fetch));

                foreach (var c in groupby1_result.Entities)

                {

                    Console.WriteLine("ad:" + c["name"].ToString());

                    Console.WriteLine("sehir:" + c["address1_city"].ToString());

                    Console.WriteLine("telefon:" + c["telephone1"].ToString());

                    Console.WriteLine("kisi eposta:" + ((AliasedValue)c["kisi.emailaddress1"]).Value.ToString());

                    Console.WriteLine("kullanici:" + ((AliasedValue)c["kullanici.firstname"]).Value.ToString());

                    Console.WriteLine("\n");

                }

                Console.ReadLine();

Burada bir noktanın üzerinde durmamız gerekmekte. Kişi ve Kullanıcı üzerindeki alanlardan veri alabilmek için “kisi” ve “kullanici” isimli alias’ları kullanmıştık. İşte bu alanlardan veri okuyacağımız zaman şu şekilde bir kullanıma ihtiyacımız bulunmakta;

((AliasedValue)c["kullanici.firstname"]).Value.ToString()

Yani gelen değeri önce “AliasedValue”’e parse etmemiz sonrasında ise “Value” üzerinden değerini almalıyız.

Çıktımız ise şu şekilde. Yani adı “a” ile başlayan bir firma ve ona adı “a” ile başlayan birinci ilgili kişi kaydı olarak eklenmiş bir kayıt bulunmakta.

Eğer XSD dosyalarını okumayı biliyorsanız fetchXML üzerinde nereye hangi değerlerin nasıl gelebileceğini anlayabilirsiniz. Ayrıca bunu dosya haline getirerek Visual Studio’ya tanıtırsanız fetchXML yazarken denetleme yaparak size hataları da gösterecektir. Ama şu anda en güzel fetchXML oluşturma yöntemi daha önce de belirttiğim gibi Gelişmiş Ara aracını kullanmaktır.

<?xml version="1.0" encoding="utf-8" ?>

<xs:schema id="fetch" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema"

xmlns:mstns="http://tempuri.org/fetch/unique">

  <xs:annotation>

    <xs:documentation>Schema name: fetch-schema</xs:documentation>

  </xs:annotation>

  <!--

condition element - used for capturing entity and link-entity

"where" clause criteria

-->

  <!-- [XDR-XSD] "value" element  -->

  <xs:element name="value" type="xs:string"></xs:element>

  <!-- [XDR-XSD] "condition" element  -->

  <xs:element name="condition">

    <xs:complexType>

      <xs:choice minOccurs="0" maxOccurs="unbounded">

        <!-- -->

        <!--

The attribute "value" is used for all operators that compare to a single value (for example, eq).

The element "value" is used for operators that compare to multiple values (for example, in).

Some operators require neither the attribute "value" or the element "value" (for example, null).

-->

        <xs:element name="value" minOccurs="0" maxOccurs="unbounded">

          <xs:complexType>

            <xs:simpleContent>

              <xs:extension base="xs:string">

                <xs:attribute name="uiname" type="xs:string" />

                <xs:attribute name="uitype" type="xs:string" />

              </xs:extension>

            </xs:simpleContent>

          </xs:complexType>

        </xs:element>

      </xs:choice>

      <!-- -->

      <xs:attribute name="column" type="xs:string" />

      <xs:attribute name="attribute" type="xs:string"></xs:attribute>

      <xs:attribute name="entityname" type="xs:string"></xs:attribute>

      <xs:attribute name="operator" use="required" type="operator"></xs:attribute>

      <!--

The attribute "value" is used for all operators that compare to a single value (for example, eq).

The element "value" is used for operators that compare to multiple values (for example, in).

Some operators require neither the attribute "value" or the element "value" (for example, null).

-->

      <xs:attribute name="value" type="xs:string"></xs:attribute>

      <xs:attribute name="aggregate" type="AggregateType"></xs:attribute>

      <xs:attribute name="alias" type="xs:string"></xs:attribute>

      <xs:attribute name="uiname" />

      <xs:attribute name="uitype" />

      <xs:attribute name="uihidden" type="TrueFalse01Type" />

    </xs:complexType>

  </xs:element>

  <!--

filter element - used for constructing complex conditionals

 legal on entity and link-entity

-->

  <!-- [XDR-XSD] "filter" element  -->

  <xs:element name="filter">

    <xs:complexType>

      <xs:choice minOccurs="0" maxOccurs="unbounded">

        <!-- -->

        <xs:element ref="condition" minOccurs="0" maxOccurs="500" />

        <xs:element ref="filter" minOccurs="0" maxOccurs="unbounded" />

      </xs:choice>

      <!-- -->

      <xs:attribute name="type" default="and">

        <xs:simpleType>

          <xs:restriction base="xs:NMTOKEN">

            <xs:enumeration value="and" />

            <xs:enumeration value="or" />

          </xs:restriction>

        </xs:simpleType>

      </xs:attribute>

      <xs:attribute name="isquickfindfields" type="xs:boolean" />

    </xs:complexType>

  </xs:element>

  <!--

attribute elements - used for selecting attributes from the

 surrounding entity / link-entity, these

 values are returned as part of the fetch

-->

  <!-- [XDR-XSD] "all-attributes" element  -->

  <xs:element name="all-attributes">

    <xs:complexType></xs:complexType>

  </xs:element>

  <!-- [XDR-XSD] "attribute" element  -->

  <xs:complexType name="FetchAttributeType">

    <xs:attribute name="name" use="required" type="xs:string"></xs:attribute>

    <xs:attribute name="build" type="build"></xs:attribute>

    <xs:attribute name="addedby" type="xs:string" />

    <xs:attribute name="alias" type="xs:string"></xs:attribute>

    <xs:attribute name="aggregate" type="AggregateType"></xs:attribute>

    <xs:attribute name="groupby" type="FetchBoolType"></xs:attribute>

    <xs:attribute name="dategrouping" type="DateGroupingType"></xs:attribute>

    <xs:attribute name="usertimezone" type="FetchBoolType"></xs:attribute>

  </xs:complexType>

  <!--

order element - used to specify a sort order

-->

  <!-- [XDR-XSD] "order" element  -->

  <xs:complexType name="FetchOrderType">

    <xs:choice minOccurs="0" maxOccurs="unbounded">

      <!-- -->

    </xs:choice>

    <!-- -->

    <xs:attribute name="attribute" type="xs:string"></xs:attribute>

    <xs:attribute name="alias" type="xs:string"></xs:attribute>

    <xs:attribute name="descending" default="false" type="xs:boolean"></xs:attribute>

  </xs:complexType>

  <!--

link-entity element - used for joining one entity to its "parent"

-->

  <!-- [XDR-XSD] "link-entity" element  -->

  <xs:complexType name="FetchLinkEntityType">

    <xs:choice minOccurs="0" maxOccurs="unbounded">

      <!-- -->

      <xs:element ref="all-attributes" minOccurs="0" />

      <xs:element name="attribute" type="FetchAttributeType" minOccurs="0" maxOccurs="unbounded" />

      <xs:element name="order" type="FetchOrderType" minOccurs="0" maxOccurs="1" />

      <xs:element ref="filter" minOccurs="0" />

      <xs:element name="link-entity" type="FetchLinkEntityType" />

    </xs:choice>

    <!-- -->

    <xs:attribute name="name" use="required" type="xs:string"></xs:attribute>

    <xs:attribute name="to" type="xs:string"></xs:attribute>

    <xs:attribute name="from" type="xs:string"></xs:attribute>

    <xs:attribute name="alias" type="xs:string"></xs:attribute>

    <xs:attribute name="link-type" type="xs:string"></xs:attribute>

    <xs:attribute name="visible" type="xs:boolean"></xs:attribute>

    <xs:attribute name="intersect" type="xs:boolean"></xs:attribute>

  </xs:complexType>

  <!--

entity element - used for specifying the root element for a fetch, only

 one root entity is allowed in a given fetch, all others

 are dependent on this entity and are marked as

 link-entity

-->

  <!-- [XDR-XSD] "entity" element  -->

  <xs:complexType name="FetchEntityType">

    <xs:choice minOccurs="0" maxOccurs="unbounded">

      <!-- -->

      <xs:element ref="all-attributes" minOccurs="0" />

      <xs:element name="attribute" type="FetchAttributeType" minOccurs="0" maxOccurs="unbounded" />

      <xs:element name="order" type="FetchOrderType" minOccurs="0" maxOccurs="unbounded" />

      <xs:element name="link-entity" type="FetchLinkEntityType" />

      <xs:element ref="filter" minOccurs="0" />

    </xs:choice>

    <!-- -->

    <xs:attribute name="name" use="required" type="xs:string"></xs:attribute>

  </xs:complexType>

  <!--

fetch element - root element for the query

-->

  <!-- [XDR-XSD] "fetch" element  -->

  <xs:element name="fetch" type="FetchType"/>

  <xs:complexType name="FetchType">

    <xs:choice minOccurs="0" maxOccurs="unbounded">

      <!-- -->

      <xs:element name="entity" type="FetchEntityType" />

      <!-- This is for the Reports view only -->

      <xs:element name="order" type="FetchOrderType" minOccurs="1" maxOccurs="1" />

    </xs:choice>

    <!-- -->

    <xs:attribute name="version"/>

    <xs:attribute name="count" type="xs:integer"/>

    <xs:attribute name="page" type="xs:integer"/>

    <xs:attribute name="paging-cookie" type="xs:string"/>

    <xs:attribute name="utc-offset" type="IntOrEmpty"/>

    <xs:attribute name="aggregate" type="xs:boolean"/>

    <xs:attribute name="distinct" type="xs:boolean"/>

    <xs:attribute name="top