How to reference Assemblies in the GAC

If you install assemblies in the GAC and then wonder why you don't see them enumerated in the Add Reference dialogs, or, if you are complaining that if you browse the assembly folder in the Windows directory, you can't see the assembly in order to add a reference to it, read on.

The Add Reference dialog box is path-based and does not enumerate the components from the GAC. The assembly folder under windows is a special folder view and so you cannot browse to an assembly from this folder and expect to be able to Add a reference to it in the normal way.

If you want to use an assembly from the GAC, you should drop your assemblies into a local folder, and then add a reference to the assembly from this folder. You may want to set the "Copy Local" property to False for that assembly if you do not want the assembly to be copied locally to your project folders. At runtime, the application will automatically use the assembly from the GAC.

How to make your custom assemblies appear in the Add Reference dialog:

To display your assembly in the Add Reference dialog box, you can add a registry key, such as the following, which points to the location of the assembly

[HKEY_CURRENT_USER\SOFTWARE\Microsoft\.NETFramework\AssemblyFolders\MyAssemblies]@="C:\\MyAssemblies" 
-- where "MyAssemblies" is the name of the folder in which the assemblies reside. 

NOTE: You can create the this registry entry under the HKEY_LOCAL_MACHINE hive. This will change the setting for all of the users on the system. If you create this registry entry under HKEY_CURRENT_USER, this entry will affect the setting for only the current user.

For more information about assemblies and the GAC, vist the following MSDN Web Page:

http://msdn.microsoft.com/library/en-us/cpguide/html/cpconglobalassemblycache.asp

GrantAccess Message

Grants a security principal (user or team) access to the specified entity instance.

Remarks

To use this message, pass an instance of the GrantAccessRequest class as the request parameter in the Execute method.

This action applies to all child instances of the target entity instance. For all child instances, if the caller does not have share privileges for those entity types, or share rights to the instances, the child instances are not shared. As a result, the owner of the instance, or a user who shares the instance with share rights, automatically has share rights to all child instances of the target entity instance. In this case, only the lack of privileges for a particular entity type prevents the child instances from being shared.

See Cascading Rules for a description of how actions on a parent instance affect child instances.

To perform this action, the caller must have access rights on the entity instance specified in the request class. For a list of required privileges, see GrantAccess Privileges.

  
//# The following code example shows how to use the GrantAccess message.
// Set up the CRM service.
CrmAuthenticationToken token = new CrmAuthenticationToken();
// You can use enums.cs from the SDK\Helpers folder to get the enumeration for Active Directory authentication.
token.AuthenticationType = 0; 
token.OrganizationName = "AdventureWorksCycle";
 
CrmService service = new CrmService();
service.Url = "http://:/mscrmservices/2007/crmservice.asmx";
service.CrmAuthenticationTokenValue = token;
service.Credentials = System.Net.CredentialCache.DefaultCredentials;

// Create the SecurityPrincipal Object
SecurityPrincipal principal = new SecurityPrincipal();
principal.Type = SecurityPrincipalType.User;

// PrincipalId is the Guid of the user to whom access is being granted
principal.PrincipalId = new Guid("7B222F98-F48A-4AED-9D09-77A19CB6EE82");

// Create the PrincipalAccess Object
PrincipalAccess principalAccess = new PrincipalAccess();

// Set the PrincipalAccess Object's Properties
principalAccess.Principal = principal;

// Gives the principal access to read
principalAccess.AccessMask = AccessRights.ReadAccess;

// Create the Target Object for the Request
TargetOwnedAccount target = new TargetOwnedAccount();

// EntityId is the Guid of the account access is being granted to
target.EntityId = new Guid("6A92D3AE-A9C9-4E44-9FA6-F3D5643753C1");

// Create the Request Object
GrantAccessRequest grant = new GrantAccessRequest();

// Set the Request Object's properties
grant.PrincipalAccess = principalAccess;
grant.Target = target;

// Execute the Request
GrantAccessResponse granted = (GrantAccessResponse)service.Execute(grant);
 

Return a Calculated Value

The following sample workflow activity demonstrates how to return a calculated value from an activity.

 
using System;
using System.Collections;
using System.Workflow.ComponentModel.Compiler;
using System.Workflow.ComponentModel.Serialization;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Design;
using System.Workflow.Runtime;
using System.Workflow.Activities;
using System.Workflow.Activities.Rules;
using System.Reflection;

using Microsoft.Crm.Workflow;
using Microsoft.Crm.Sdk;
using Microsoft.Crm.SdkTypeProxy;
using Microsoft.Crm.Sdk.Query;

namespace SampleWorkflows
{
    [CrmWorkflowActivity("Return a Calculated Value")]
    public class AddActivity : Activity
    {

        protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
        {
            result = new CrmNumber(a.Value + b.Value);
            return base.Execute(executionContext);
        }

        public static DependencyProperty aProperty =
           DependencyProperty.Register("a",
           typeof(CrmNumber),
           typeof(AddActivity));

        [CrmInput("a")]
        public CrmNumber a
        {
            get
            {
                return (CrmNumber)base.GetValue(aProperty);
            }
            set
            {
                base.SetValue(aProperty, value);
            }

        }

        public static DependencyProperty bProperty =
           DependencyProperty.Register("b",
           typeof(CrmNumber),
           typeof(AddActivity));

        [CrmInput("b")]
        public CrmNumber b
        {
            get
            {
                return (CrmNumber)base.GetValue(bProperty);
            }
            set
            {
                base.SetValue(bProperty, value);
            }

        }

        public static DependencyProperty resultProperty =
           DependencyProperty.Register("result",
           typeof(CrmNumber),
           typeof(AddActivity));

        [CrmOutput("result")]
        public CrmNumber result
        {
            get
            {
                return (CrmNumber)base.GetValue(resultProperty);
            }
            set
            {
                base.SetValue(resultProperty, value);
            }

        }
    }
}
 

ASHX file Handler

In ASP.NET, you probably spend most of your time creating .aspx files with .cs files as code behind or use .ascx files for your controls and .asmx files for web services.
A web handler file works just like an aspx file except you are one step back away from the messy browser level where HTML and C# mix. One reason you would write an .ashx file instead of an .aspx file is that your output is not going to a browser but to an xml-consuming client of some kind.

Working with .ashx keeps you away from all the browser technology you don't need in this case. Notice that you have to include the IsReusable property.

What does the code there do?

It defines two parts of the IHttpHandler interface. The important part is ProcessRequest(), which will be invoked whenever the Handler.ashx file is requested or pointed to.

      
<%@ WebHandler Language="C#" Class="Handler" %> 
using System;
using System.Web;
public class Handler : IHttpHandler
{
    public void ProcessRequest(HttpContext context)
    {
	context.Response.ContentType = "text/plain";
	context.Response.Write("Hello World");
    }
    public bool IsReusable
    {
        get{ return false; }
    }
} 

Using query strings:

Developers commonly need to use the QueryString collection on the Request. You can use the Request.QueryString in the Handler just like you would on any ASPX web form page.

      
<%@ WebHandler Language="C#" Class="QueryStringHandler" %> 
using System;
using System.Web;
public class QueryStringHandler : IHttpHandler
{
    public void ProcessRequest (HttpContext context) 
    {
       HttpResponse r = context.Response;
       r.ContentType = "image/png";
        string file = context.Request.QueryString["file"];
        if (file == "Arrow")
        {
           r.WriteFile("Arrow.gif");
        }
        else
        {
           r.WriteFile("Image.gif");
        }
    }
    public bool IsReusable 
    {
        get{ return false; }
    }
} 
     

Now Debug the application:

When you pass Fille='Arrow' in query string like as follows

http://localhost:1372/FileHandler/QueryStringHandler.ashx?file=Arrow You will get the folowing output:

Otherwise you will get following output:

http://localhost:1372/FileHandler/QueryStringHandler.ashx?file=Image

The above code receives requests and then returns a different file based on the QueryString collection value. It will return one of two images from the two query strings.

When we use Handler:

Here I want to propose some guidelines about when to use custom handlers and when to use ASPX web form pages.
Handlers are better for binary data, and web forms are best for rapid development.

Use web forms (ASPX) when you have:

• Simple HTML pages
  
• ASP.NET custom controls
  
• Simple dynamic pages

Use handlers (ASHX) when you have:

• Binary files
  
• Dynamic image views
  
• Performance-critical web pages
  
• XML files
  
• Minimal web pages

Use of CRM Types in Custom Workflow Activity

The following sample shows how to use each of the types found in Microsoft Dynamics CRM.

Input Parameter: Number

Example

public static DependencyProperty myNumberProperty = DependencyProperty.Register("myNumber", typeof(CrmNumber), typeof(CreateCustomEntity));

[CrmInput("My Integer")]
public CrmNumber myNumber
{
   get
   {
      return (CrmNumber)base.GetValue(myNumberProperty);
   }
   set
   {
      base.SetValue(myNumberProperty, value);
   }
}

Input Parameter: String

Example

public static DependencyProperty myStringProperty = DependencyProperty.Register("myString", typeof(System.String), typeof(CreateCustomEntity));

[CrmInput("My String")]
public string myString
{
   get
   {
      return (string)base.GetValue(myStringProperty);
   }
   set
   {
      base.SetValue(myStringProperty, value);
   }
}

Input Parameter: Boolean

Example

public static DependencyProperty myBooleanProperty = DependencyProperty.Register("myBoolean", typeof(CrmBoolean), typeof(CreateCustomEntity));

[CrmInput("My Boolean")]
public CrmBoolean myBoolean
{
   get
   {
      return (CrmBoolean)base.GetValue(myBooleanProperty);
   }
   set
   {
      base.SetValue(myBooleanProperty, value);
   }
}

Input Parameter: Lookup

Example

public static DependencyProperty myLookupProperty = DependencyProperty.Register("myLookup", typeof(Lookup), typeof(CreateCustomEntity));

[CrmInput("My Lookup")]
[CrmReferenceTarget("account")]
public Lookup myLookup
{
   get
   {
      return (Lookup)base.GetValue(myLookupProperty);
   }
   set
   {
      base.SetValue(myLookupProperty, value);
   }
}

Input Parameter: Picklist

Example

public static DependencyProperty myPicklistProperty = DependencyProperty.Register("myPicklist", typeof(Picklist), typeof(CreateCustomEntity));

[CrmInput("My Picklist")]
[CrmAttributeTarget("account", "industrycode")]
public Picklist myPicklist
{
   get
   {
      return (Picklist)base.GetValue(myPicklistProperty);
   }
   set
   {
      base.SetValue(myPicklistProperty, value);
   }
}

Input Parameter: DateTime

Example

public static DependencyProperty myDateTimeProperty = DependencyProperty.Register("myDateTime", typeof(CrmDateTime), typeof(CreateCustomEntity));

[CrmInput("My DateTime")]
public CrmDateTime myDateTime
{
   get
   {
      return (CrmDateTime)base.GetValue(myDateTimeProperty);
   }
   set
   {
      base.SetValue(myDateTimeProperty, value);
   }
}

Input Parameter: Decimal

Example

public static DependencyProperty myDecimalProperty = DependencyProperty.Register("myDecimal", typeof(CrmDecimal), typeof(CreateCustomEntity));

[CrmInput("My Decimal")]
public CrmDecimal myDecimal
{
   get
   {
      return (CrmDecimal)base.GetValue(myDecimalProperty);
   }
   set
   {
      base.SetValue(myDecimalProperty, value);
   }
}

Input Parameter: Money

Example

public static DependencyProperty myMoneyProperty = DependencyProperty.Register("myMoney", typeof(CrmMoney), typeof(CreateCustomEntity));

[CrmInput("My Money")]
public CrmMoney myMoney
{
   get
   {
      return (CrmMoney)base.GetValue(myMoneyProperty);
   }
   set
   {
      base.SetValue(myMoneyProperty, value);
   }
}

Input Parameter: Float

Example

public static DependencyProperty myFloatProperty = DependencyProperty.Register("myFloat", typeof(CrmFloat), typeof(CreateCustomEntity));

[CrmInput("My Float")]
public CrmFloat myFloat
{
   get
   {
      return (CrmFloat)base.GetValue(myFloatProperty);
   }
   set
   {
      base.SetValue(myFloatProperty, value);
   }
}

Input Parameter: Status

Example

public static DependencyProperty myStatusProperty = DependencyProperty.Register("myStatus", typeof(Status), typeof(CreateCustomEntity));

[CrmInput("My Status")]
[CrmAttributeTarget("account", "statuscode")]
public Status myStatus
{
   get
   {
      return (Status)base.GetValue(myStatusProperty);
   }
   set
   {
      base.SetValue(myStatusProperty, value);
   }
}

Output Parameter: Lookup

Example

public static DependencyProperty myOutLookupProperty = DependencyProperty.Register("myOutLookup", typeof(Lookup), typeof(CreateCustomEntity));

[CrmOutput("My Output Lookup")]
[CrmReferenceTarget("new_customentity")]
public Lookup myOutLookup
{
   get
   {
      return (Lookup)base.GetValue(myOutLookupProperty);
   }
   set
   {
      base.SetValue(myOutLookupProperty, value);
   }
}

Execute Method: Using Types

Example

protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
   
   IContextService contextService = (IContextService)executionContext.GetService(typeof(IContextService));
   IWorkflowContext context = contextService.Context;

   ICrmService crmService = (ICrmService)context.CreateCrmService();

   DynamicEntity de = new DynamicEntity("new_customentity");

   if (myBoolean != null)
   {
      de["new_boolean"] = myBoolean;
   }
   if (myDateTime != null)
   {
      de["new_datetime"] = myDateTime;
   }
   if (myDecimal != null)
   {
      de["new_decimal"] = myDecimal.Value.ToString();
   }
   if (myFloat != null)
   {
      de["new_float"] = myFloat;
   }

   if (myLookup != null)
   {
      de["new_lookup"] = myLookup;
   }
   if (myMoney != null)
   {
      de["new_money"] = myMoney;
   }
   if (myNumber != null)
   {
      de["new_number"] = myNumber;
   }
   if (myPicklist != null)
   {
      de["new_picklist"] = myPicklist;
   }
   if (myStatus != null)
   {
      de["new_status"] = myStatus.Value.ToString();
   }
   if (myString != null)
   {
      de["new_stringtext"] = myString;
      de["new_memo"] = myString;
   }

   de["new_activationid"] = new Lookup(EntityName.workflow.ToString(),context.ActivationId);

   myOutLookup = new Lookup("new_customentity", crmService.Create(de));
   return ActivityExecutionStatus.Closed;
}

Merge Two Records

  

using System;
using System.ServiceModel;
using Microsoft.Crm.Sdk.Messages;
using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Sdk.Client;
using Microsoft.Xrm.Sdk.Query;

namespace Microsoft.Crm.Sdk.Samples
{
    /// 

    /// This sample shows how to merge two entity records.
    /// 
    /// 
    /// At run-time, you will be given the option to delete all the
    /// database records created by this program.
    /// 
    public class Merge
    {
        #region Class Level Members
        private OrganizationServiceProxy _serviceProxy;
        private Guid _account1Id;
        private Guid _account2Id;
        #endregion

        /// 

        /// This method shows how to merge two entity records with the Merge message.
        /// 
        /// Contains server connection information.
        /// When True, the user will be prompted to delete
        /// all created entities.
        public void Run(ServerConnection.Configuration serverConfig,
           bool promptForDelete)
        {
            using (_serviceProxy = ServerConnection.GetOrganizationProxy(serverConfig))
            {
                // This statement is required to enable early-bound type support.
                _serviceProxy.EnableProxyTypes();

                //Create the Contact and Incident required for this sample.
                CreateRequiredRecords();
 
                // Create the target for the request.
			    EntityReference target = new EntityReference();

			    // Id is the GUID of the account that is being merged into.
                // LogicalName is the type of the entity being merged to, as a string
			    target.Id = _account1Id;
                target.LogicalName = Account.EntityLogicalName;

                // Create the request.
                MergeRequest merge = new MergeRequest();
                // SubordinateId is the GUID of the account merging.
                merge.SubordinateId = _account2Id;
                merge.Target = target;
                merge.PerformParentingChecks = false;

                Console.WriteLine("\nMerging account2 into account1 and adding " +
                    "\"test\" as Address 1 Line 1");

                // Create another account to hold new data to merge into the entity.
                // If you use the subordinate account object, its data will be merged.
                Account updateContent = new Account();
                updateContent.Address1_Line1 = "test";

                // Set the content you want updated on the merged account
                merge.UpdateContent = updateContent;

                // Execute the request.
                MergeResponse merged = (MergeResponse)_serviceProxy.Execute(merge);

                Account mergeeAccount = 
                    (Account)_serviceProxy.Retrieve(Account.EntityLogicalName, 
                    _account2Id, new ColumnSet(allColumns:true));

                if(mergeeAccount.Merged == true)
                {
                    Account mergedAccount =
                        (Account)_serviceProxy.Retrieve(Account.EntityLogicalName,
                        _account1Id, new ColumnSet(allColumns: true));

                    Console.WriteLine("\nAccounts merged successfully into account1");
                    Console.WriteLine("  Name: {0}", mergedAccount.Name);
                    Console.WriteLine("  Description: {0}", mergedAccount.Description);
                    Console.WriteLine("  Number of Employees: {0}", 
                        mergedAccount.NumberOfEmployees);
                    Console.WriteLine("  Address 1 Line 1: {0}", 
                        mergedAccount.Address1_Line1);
                }

                DeleteRequiredRecords(promptForDelete);
            }
        }

        /// 

        /// Creates any entity records that this sample requires.
        /// 
        public void CreateRequiredRecords()
        {
            // Create the first account, which will be merged into
            Account account1 = new Account();
            account1.Name = "Fourth Coffee";
            account1.Description = "Coffee House";

            _account1Id = _serviceProxy.Create(account1);
            Console.WriteLine("Account 1 created with GUID {{{0}}}", _account1Id);
            Console.WriteLine("  Name: {0}", account1.Name);
            Console.WriteLine("  Description: {0}", account1.Description);

            // Create the second account, which will be merged from
            Account account2 = new Account();

            account2.Name = "Fourth Coffee";
            account2.NumberOfEmployees = 55;

            _account2Id = _serviceProxy.Create(account2);
            Console.WriteLine("Account 2 created with GUID {{{0}}}", _account2Id);
            Console.WriteLine("  Name: {0}", account2.Name);
            Console.WriteLine("  Number of Employees: {0}", account2.NumberOfEmployees);
        }

        /// 

        /// Deletes any entity records that were created for this sample.
        /// Indicates whether to prompt the user 
        /// to delete the records created in this sample.
        /// 
        public void DeleteRequiredRecords(bool prompt)
        {
            bool deleteRecords = true;

            if (prompt)
            {
                Console.Write("\nDo you want these entity records deleted? (y/n) [y]: ");
                String answer = Console.ReadLine();
                Console.WriteLine();

                deleteRecords = (answer.StartsWith("y") || answer.StartsWith("Y") || 
                    answer == String.Empty);
            }

            if (deleteRecords)
            {
                _serviceProxy.Delete(Account.EntityLogicalName, _account1Id);
                _serviceProxy.Delete(Account.EntityLogicalName, _account2Id);
                Console.WriteLine("Entity records have been deleted.");
            }
        }

        #region Main method

        /// 

        /// Standard Main() method used by most SDK samples.
        /// 
        /// 
        static public void Main(string[] args)
        {
            try
            {
                // Obtain the target organization's Web address and client logon 
                // credentials from the user.
                ServerConnection serverConnect = new ServerConnection();
                ServerConnection.Configuration config = 
                    serverConnect.GetServerConfiguration();

                var app = new Merge();
                app.Run(config, true);
            }
            catch (FaultException ex)
            {
                Console.WriteLine("The application terminated with an error.");
                Console.WriteLine("Timestamp: {0}", ex.Detail.Timestamp);
                Console.WriteLine("Code: {0}", ex.Detail.ErrorCode);
                Console.WriteLine("Message: {0}", ex.Detail.Message);
                Console.WriteLine("Plugin Trace: {0}", ex.Detail.TraceText);
                Console.WriteLine("Inner Fault: {0}",
                    null == ex.Detail.InnerFault ? "No Inner Fault" : "Has Inner Fault");
            }
            catch (System.TimeoutException ex)
            {
                Console.WriteLine("The application terminated with an error.");
                Console.WriteLine("Message: {0}", ex.Message);
                Console.WriteLine("Stack Trace: {0}", ex.StackTrace);
                Console.WriteLine("Inner Fault: {0}",
                    null == ex.InnerException.Message ? "No Inner Fault" : ex.InnerException.Message);
            }
            catch (System.Exception ex)
            {
                Console.WriteLine("The application terminated with an error.");
                Console.WriteLine(ex.Message);

                // Display the details of the inner exception.
                if (ex.InnerException != null)
                {
                    Console.WriteLine(ex.InnerException.Message);

                    FaultException fe = 
                        ex.InnerException
                        as FaultException;
                    if (fe != null)
                    {
                        Console.WriteLine("Timestamp: {0}", fe.Detail.Timestamp);
                        Console.WriteLine("Code: {0}", fe.Detail.ErrorCode);
                        Console.WriteLine("Message: {0}", fe.Detail.Message);
                        Console.WriteLine("Plugin Trace: {0}", fe.Detail.TraceText);
                        Console.WriteLine("Inner Fault: {0}",
                            null == fe.Detail.InnerFault ? "No Inner Fault" : "Has Inner Fault");
                    }
                }
            }
            // Additional exceptions to catch: SecurityTokenValidationException, 
            // ExpiredSecurityTokenException, SecurityAccessDeniedException, 
            // MessageSecurityException, and SecurityNegotiationException.

            finally
            {
                Console.WriteLine("Press  to exit.");
                Console.ReadLine();
            }
        }
        #endregion Main method
    }
}

Get the Next Birthday

The following sample workflow activity returns the next birthday. Use this in a workflow that sends a birthday greeting to a customer. Note that this uses dynamic entity rather than strong types as is recommended for workflows and plug-ins.

    
using System;
using System.Collections;
using System.Workflow.ComponentModel.Compiler;
using System.Workflow.ComponentModel.Serialization;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Design;
using System.Workflow.Runtime;
using System.Workflow.Activities;
using System.Workflow.Activities.Rules;
using System.Reflection;
using Microsoft.Crm.Workflow;
using Microsoft.Crm.Sdk;
using Microsoft.Crm.SdkTypeProxy;
using Microsoft.Crm.Sdk.Query;

namespace SampleWorkflows
{
    /// 

    /// Activity will return the next upcoming birthday that has just passed
    /// 
    /// If this year's birthday has not yet occurred, it will return this year's birthday.
    /// Otherwise, it will return the birthday for next year.
    /// 
    /// A workflow can time-out when on this date.
    /// 
    [CrmWorkflowActivity("Get the Next Birthday", "Release Scenarios")]
    [PersistOnClose]
    public partial class UpdateNextBirthday : SequenceActivity
    {
        protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
        {
            IContextService contextService = (IContextService)executionContext.GetService(typeof(IContextService));
            IWorkflowContext context = contextService.Context;

            //Create a CRM Service.
            ICrmService crmService = context.CreateCrmService();

            //Retrieve the contact ID.
            Guid contactId = ((Lookup)base.GetValue(ContactProperty)).Value;

            //Retrieve the entity to determine what the birth date is.
            //Retrieve the Contact Entity
            DynamicEntity contactEntity;
            {
                //Create the target.
                TargetRetrieveDynamic retrieveTarget = new TargetRetrieveDynamic();
                retrieveTarget.EntityId = contactId;
                retrieveTarget.EntityName = EntityName.contact.ToString();

                //Create a request.
                RetrieveRequest retrieveRequest = new RetrieveRequest();
                retrieveRequest.ColumnSet = new ColumnSet(new string[] {"birthdate" });
                retrieveRequest.ReturnDynamicEntities = true;
                retrieveRequest.Target = retrieveTarget;

                //Execute the request.
                RetrieveResponse retrieveResponse = (RetrieveResponse)crmService.Execute(retrieveRequest);

                //Retrieve the Loan Application Entity.
                contactEntity = retrieveResponse.BusinessEntity as DynamicEntity;
            }            

            //Check to see if the current birthday is set. We don't want the activity to fail if the birth date is not set.
            CrmDateTime contactBirthDate = (CrmDateTime)contactEntity["birthdate"];
            if (contactBirthDate == null || (contactBirthDate.UniversalTime == null))
            {
                //Complete the execution of the activity.
                return base.Execute(executionContext);
            }

            //Calculate the next birth date. Encapsulate it in a method so that the method can be used in the test case for verification purposes.
            DateTime nextBirthdate = CalculateNextBirthday(contactBirthDate.UniversalTime);

            //Update the next birthday field on the entity.
            DynamicEntity updateEntity = new DynamicEntity(EntityName.contact.ToString());
            updateEntity["contactid"] = new Key(contactId);
            updateEntity["new_nextbirthday"] = CrmDateTime.FromUniversal(nextBirthdate);

            crmService.Update(updateEntity);

            CompositeActivity parentActivity = this.Parent;
            while (parentActivity.Parent != null)
            {
                parentActivity = parentActivity.Parent;
            }

            context.PopulateEntitiesFrom((CrmWorkflow)parentActivity, "primaryEntity");

            //Allow the base class to continue the execution.
            return ActivityExecutionStatus.Closed;
        }

        //Define the variables.
        public static DependencyProperty ContactProperty = DependencyProperty.Register("Contact", typeof(Lookup), typeof(UpdateNextBirthday));

        //Define the properties.
        [CrmInput("Update Next Birthdate for")]
        [ValidationOption(ValidationOption.Required)]
        [CrmReferenceTarget("contact")]
        public Lookup Contact
        {
            get
            {
                return (Lookup)base.GetValue(ContactProperty);
            }
            set
            {
                //Validate the argument.
                if (value == null || (value.IsNullSpecified && value.IsNull))
                {
                    throw new InvalidPluginExecutionException("Contact Lookup cannot be null or have IsNullSpecified = true");
                }
                else if (value.type != null && value.type != "contact")
                {
                    throw new InvalidPluginExecutionException("Contact Lookup must be a contact entity");
                }
                else if (value.Value == Guid.Empty)
                {
                    throw new InvalidPluginExecutionException("Contact Lookup must contain a valid Guid");
                }

                base.SetValue(ContactProperty, value);
            }
        }

        private DateTime CalculateNextBirthday(DateTime birthdate)
        {
            DateTime nextBirthday = new DateTime(birthdate.Year, birthdate.Month, birthdate.Day);

            //Check to see if this birthday occurred in a leap year.
            bool leapYearAdjust = false;
            if (nextBirthday.Month == 2 && nextBirthday.Day == 29)
            {
                //Verify that this year was a leap year.
                if (DateTime.IsLeapYear(nextBirthday.Year))
                {
                    //Check to see if the current year is a leap year.
                    if (!DateTime.IsLeapYear(DateTime.Now.Year))
                    {
                        //Push the date to March 1st so that the date arithmetic will function correctly.
                        nextBirthday = nextBirthday.AddDays(1);
                        leapYearAdjust = true;
                    }
                }
                else
                {
                    throw new InvalidPluginExecutionException("Invalid Birthdate specified", new ArgumentException("Birthdate"));
                }
            }

            //Calculate the year difference.
            nextBirthday = nextBirthday.AddYears(DateTime.Now.Year - nextBirthday.Year);

            //Check to see if the date was adjusted.
            if (leapYearAdjust && DateTime.IsLeapYear(nextBirthday.Year))
            {
                nextBirthday = nextBirthday.AddDays(-1);
            }

            return nextBirthday;
        }
    }
}
 

Calculate Distance

The following sample uses the MapPoint service to calculate the distance between two zip codes using a simple route. It has two input parameters for the start and end zip codes and one output parameter for the total distance calculated.

   
using System;
using System.Collections.Generic;
using System.Text;
using System.Workflow.Activities;
using System.Workflow.ComponentModel;
using System.Configuration;
using Microsoft.Crm.Sdk;
using Microsoft.Crm.Workflow;
using System.Net;
using System.Xml;

namespace CustomWorkflowActivity
{
    // Get more information about the mappoint assembly from http://staging.mappoint.net/standard-30/ 
    using net.mappoint.staging;

    [CrmWorkflowActivity("Calculate Distance", "Mappoint Utilities")]
    public class DistanceCalculator : SequenceActivity
    {
        protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
        {
            // Set the MapPoint ID and password you created with your Bing Developer/License Account.
            ICredentials creds = new NetworkCredential("MappointID", "MappointPassword");
            string DataSourceName = "MapPoint.NA";
            FindServiceSoap findService = new FindServiceSoap();
            findService.Credentials = creds;
            findService.PreAuthenticate = true;

            RouteServiceSoap routeService = new RouteServiceSoap();
            routeService.Credentials = creds;
            routeService.PreAuthenticate = true;
            routeService.UserInfoRouteHeaderValue = new UserInfoRouteHeader();
            routeService.UserInfoRouteHeaderValue.DefaultDistanceUnit = DistanceUnit.Mile;

            FindAddressSpecification addressSpecStart = new FindAddressSpecification();
            addressSpecStart.DataSourceName = DataSourceName;
            addressSpecStart.InputAddress = new Address();
            addressSpecStart.InputAddress.PostalCode = this.zipCodeStart;

            FindAddressSpecification addressSpecEnd = new FindAddressSpecification();
            addressSpecEnd.DataSourceName = DataSourceName;
            addressSpecEnd.InputAddress = new Address();
            addressSpecEnd.InputAddress.PostalCode = this.zipCodeEnd;

            FindResults resultsStart = findService.FindAddress(addressSpecStart);
            FindResults resultsEnd = findService.FindAddress(addressSpecEnd);

            LatLong startLatLong = resultsStart.Results[0].FoundLocation.LatLong;
            LatLong endLatLong = resultsEnd.Results[0].FoundLocation.LatLong;

            RouteSpecification routeSpec = new RouteSpecification();
            routeSpec.DataSourceName = DataSourceName;
            routeSpec.Segments = new SegmentSpecification[2];

            routeSpec.Segments[0] = new SegmentSpecification();
            routeSpec.Segments[0].Waypoint = new Waypoint();
            routeSpec.Segments[0].Waypoint.Location = resultsStart.Results[0].FoundLocation;

            routeSpec.Segments[1] = new SegmentSpecification();
            routeSpec.Segments[1].Waypoint = new Waypoint();
            routeSpec.Segments[1].Waypoint.Location = resultsEnd.Results[0].FoundLocation;


            Route route = routeService.CalculateSimpleRoute(new LatLong[] { startLatLong, endLatLong }, DataSourceName, SegmentPreference.Quickest);
            this.totalDistance = new CrmNumber((int)route.Itinerary.Distance);

            return ActivityExecutionStatus.Closed;
        }

        public static DependencyProperty zipCodeStartProperty = DependencyProperty.Register("zipCodeStart", typeof(string), typeof(DistanceCalculator));

        [CrmInput("Starting Zip Code")]
        public string zipCodeStart
        {
            get
            {
                return (string)base.GetValue(zipCodeStartProperty);
            }
            set
            {
                base.SetValue(zipCodeStartProperty, value);
            }
        }

        public static DependencyProperty zipCodeEndProperty = DependencyProperty.Register("zipCodeEnd", typeof(string), typeof(DistanceCalculator));

        [CrmInput("Ending Zip Code")]
        public string zipCodeEnd
        {
            get
            {
                return (string)base.GetValue(zipCodeEndProperty);
            }
            set
            {
                base.SetValue(zipCodeEndProperty, value);
            }
        }

        public static DependencyProperty totalDistanceProperty = DependencyProperty.Register("totalDistance", typeof(CrmNumber), typeof(DistanceCalculator));

        [CrmOutput("Total Distance")]
        public CrmNumber totalDistance
        {
            get
            {
                return (CrmNumber)base.GetValue(totalDistanceProperty);
            }
            set
            {
                base.SetValue(totalDistanceProperty, value);
            }

        }
    }

}
 

TEXT TO HTML REGEX METHOD

       
//TEXT TO HTML REGEX METHOD
public string TextToHtml(string inputtext ) 
{ 
inputtext = Regex.Replace(inputtext, "<", "<") ; 
inputtext = Regex.Replace(inputtext, ">", ">") ; 
inputtext = Regex.Replace(inputtext, @"http://(.\S+)", "$1") ; 
inputtext = Regex.Replace(inputtext, @"ftp://(.\S+)", "$1ftp://$1\">$1;") ; 
inputtext = Regex.Replace(inputtext, @"news://(.\S+)", "$1;") ; 
inputtext = Regex.Replace(inputtext, @"(\S+\@.*\..\S+)", "$1;") ; 
inputtext = Regex.Replace(inputtext, "\n", "
") ; 
inputtext = Regex.Replace(inputtext, @"\s\s", "  ") ; 
return inputtext ; 
} 
        

Assign a Record to a Team

This sample shows how to assign a record to a team using the AssignRequest message.

  


using System;
using System.ServiceModel;
using System.ServiceModel.Description;

// These namespaces are found in the Microsoft.Xrm.Sdk.dll assembly
// found in the SDK\bin folder.
using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Sdk.Query;
using Microsoft.Xrm.Sdk.Discovery;


using Microsoft.Xrm.Sdk.Client;
using Microsoft.Crm.Sdk.Messages;



namespace Microsoft.Crm.Sdk.Samples
{

    /// 

    /// Demonstrates how to assign a record to a team.
    /// If you want to run this sample repeatedly, you have the option to 
    /// delete all the records created at the end of execution.
    /// 
    public class AssignRecordToTeam
    {
        #region Class Level Members

        /// 

        /// Stores the organization service interface.
        /// 
        private OrganizationServiceProxy _serviceProxy;
        private IOrganizationService _service;

        // Define the IDs needed for this sample.
        public Guid _accountId;
        public Guid _teamId;        
        public Guid _roleId;

        #endregion Class Level Members

        #region How To Sample Code
        /// 

        /// Create and configure the organization service proxy.
        /// Create a team, an account and a role.
        /// Add read account privileges to the role.
        /// Assign the role to the team so that they can read the account.
        /// Assign the account to the team.
        /// Optionally delete the account, team and role records.
        /// The friendly name of 
        /// the target organization.
        /// The name of the discovery server.
        /// Indicates whether to prompt the user 
        /// to delete the records created in this sample.
        /// 
        public void Run(ServerConnection.Configuration serverConfig, bool promptForDelete)
        {
            try
            {
                // Connect to the Organization service. 
                // The using statement assures that the service proxy will be properly disposed.
                using (_serviceProxy = ServerConnection.GetOrganizationProxy(serverConfig))
                {
                    // This statement is required to enable early-bound type support.
                    _serviceProxy.EnableProxyTypes();

                    _service = (IOrganizationService)_serviceProxy;

                    // Call the method to create any data that this sample requires.
                    CreateRequiredRecords();

                    // Assign the account to a team.                
                    AssignRequest assignRequest = new AssignRequest()
                    {
                        Assignee = new EntityReference
                        {
                            LogicalName = Team.EntityLogicalName,
                            Id = _teamId
                        },

                        Target = new EntityReference(Account.EntityLogicalName, _accountId)
                    };

                    _service.Execute(assignRequest);

                    Console.WriteLine("The account is owned by the team.");

                    DeleteRequiredRecords(promptForDelete);
                }
            }

            // Catch any service fault exceptions that Microsoft Dynamics CRM throws.
            catch (FaultException)
            {
                // You can handle an exception here or pass it back to the calling method.
                throw;
            }
        }

        /// 

        /// This method creates any entity records that this sample requires.
        /// Create a team, an account and a role.
        /// Add read account privileges to the role.
        /// Assign the role to the team so that they can read the account.
        /// Assign the account to the team.
        /// 
        public void CreateRequiredRecords()
        {
            // Instantiate an account entity record and set its property values.
            // See the Entity Metadata topic in the SDK documentation to determine 
            // which attributes must be set for each entity.
            Account setupAccount = new Account
            {
                Name = "Example Account"
            };

            // Create the account record.
            _accountId = _service.Create(setupAccount);
            Console.WriteLine("Created {0}", setupAccount.Name);

            // Retrieve the default business unit needed to create the team and role.
            QueryExpression queryDefaultBusinessUnit = new QueryExpression
            {
                EntityName = BusinessUnit.EntityLogicalName,
                ColumnSet = new ColumnSet("businessunitid" ),
                Criteria = new FilterExpression()
            };

            queryDefaultBusinessUnit.Criteria.AddCondition("parentbusinessunitid", 
                ConditionOperator.Null);

            BusinessUnit defaultBusinessUnit = (BusinessUnit)_service.RetrieveMultiple(
                queryDefaultBusinessUnit).Entities[0];

            // Instantiate a team entity record and set its property values.
            // See the Entity Metadata topic in the SDK documentation to determine 
            // which attributes must be set for each entity.
            Team setupTeam = new Team
            {
                Name = "Example Team",
                BusinessUnitId = new EntityReference(BusinessUnit.EntityLogicalName,
                    defaultBusinessUnit.Id)
            };

            // Create a team record.
            _teamId = _service.Create(setupTeam);
            Console.WriteLine("Created {0}", setupTeam.Name);

            // Instantiate a role entity record and set its property values.
            // See the Entity Metadata topic in the SDK documentation to determine 
            // which attributes must be set for each entity.
            Role setupRole = new Role
            {
                Name = "Example Role",
                BusinessUnitId = new EntityReference(BusinessUnit.EntityLogicalName,
                    defaultBusinessUnit.Id)
            };

            // Create a role record. Typically you would use an existing role that has the
            // the correct privileges. For this sample we need to be sure the role has
            // at least the privilege to read account records.
            _roleId = _service.Create(setupRole);
            Console.WriteLine("Created {0}", setupRole.Name);

            // Create a query expression to find the prvReadAccountPrivilege.
            QueryExpression queryReadAccountPrivilege = new QueryExpression
            {
                EntityName = Privilege.EntityLogicalName,
                ColumnSet = new ColumnSet("privilegeid", "name"),
                Criteria = new FilterExpression()
            };
            queryReadAccountPrivilege.Criteria.AddCondition("name", 
                ConditionOperator.Equal, "prvReadAccount");

            // Retrieve the prvReadAccount privilege.
            Entity readAccountPrivilege = _service.RetrieveMultiple(
                queryReadAccountPrivilege)[0];
            Console.WriteLine("Retrieved {0}", readAccountPrivilege.Attributes["name"]);

            // Add the prvReadAccount privilege to the example roles to assure the
            // team can read accounts.
            AddPrivilegesRoleRequest addPrivilegesRequest = new AddPrivilegesRoleRequest
            {
                RoleId = _roleId,
                Privileges = new[] 
                {
                    // Grant prvReadAccount privilege.
                    new RolePrivilege
                    { 
                        PrivilegeId = readAccountPrivilege.Id 
                    }
                }
            };
            _service.Execute(addPrivilegesRequest);

            Console.WriteLine("Added privilege to role");

            // Add the role to the team.
            _service.Associate(
                       Team.EntityLogicalName,
                       _teamId,
                       new Relationship("teamroles_association"),
                       new EntityReferenceCollection() { new EntityReference(Role.EntityLogicalName, _roleId) });

            Console.WriteLine("Assigned team to role");

            // It takes some time for the privileges to propagate to the team. Delay the
            // application until the privilege has been assigned.
            bool teamLacksPrivilege = true;
            while (teamLacksPrivilege)
            {
                RetrieveTeamPrivilegesRequest retrieveTeamPrivilegesRequest = 
                    new RetrieveTeamPrivilegesRequest
                {
                    TeamId = _teamId
                };

                RetrieveTeamPrivilegesResponse retrieveTeamPrivilegesResponse =
                    (RetrieveTeamPrivilegesResponse)_service.Execute(
                    retrieveTeamPrivilegesRequest);

                foreach (RolePrivilege rp in 
                    retrieveTeamPrivilegesResponse.RolePrivileges)
                {
                    if (rp.PrivilegeId == readAccountPrivilege.Id)
                    {
                        teamLacksPrivilege = false;
                        break;
                    }
                    else
                    {
                        System.Threading.Thread.CurrentThread.Join(500);
                    }
                }
            }

            return;
        }

        /// 

        /// Deletes any entity records that were created for this sample.
        /// Indicates whether to prompt the user 
        /// to delete the records created in this sample.
        /// 
        public void DeleteRequiredRecords(bool prompt)
        {
            bool deleteRecords = true;

            if (prompt)
            {
                Console.WriteLine("\nDo you want these entity records deleted? (y/n)");
                String answer = Console.ReadLine();

                deleteRecords = (answer.StartsWith("y") || answer.StartsWith("Y"));
            }

            if (deleteRecords)
            {
                _service.Delete("account", _accountId);
                _service.Delete("team", _teamId);
                _service.Delete("role", _roleId);


                Console.WriteLine("Entity records have been deleted.");
            }
        }

        #endregion How To Sample Code

        #region Main
        /// 

        /// Main. Runs the sample and provides error output.
        /// Array of arguments to Main method.
        /// 
        static public void Main(string[] args)
        {
           
            try
            {
                // Obtain the target organization's Web address and client logon 
                // credentials from the user.
                ServerConnection serverConnect = new ServerConnection();
                ServerConnection.Configuration config = serverConnect.GetServerConfiguration();
                
                AssignRecordToTeam app = new AssignRecordToTeam();
                app.Run(config, true);
            }
            catch (FaultException ex)
            {
                Console.WriteLine("The application terminated with an error.");
                Console.WriteLine("Timestamp: {0}", ex.Detail.Timestamp);
                Console.WriteLine("Code: {0}", ex.Detail.ErrorCode);
                Console.WriteLine("Message: {0}", ex.Detail.Message);
                Console.WriteLine("Plugin Trace: {0}", ex.Detail.TraceText);
                Console.WriteLine("Inner Fault: {0}",
                    null == ex.Detail.InnerFault ? "No Inner Fault" : "Has Inner Fault");
            }
            catch (System.TimeoutException ex)
            {
                Console.WriteLine("The application terminated with an error.");
                Console.WriteLine("Message: {0}", ex.Message);
                Console.WriteLine("Stack Trace: {0}", ex.StackTrace);
                Console.WriteLine("Inner Fault: {0}",
                    null == ex.InnerException.Message ? "No Inner Fault" : ex.InnerException.Message);
            }
            catch (System.Exception ex)
            {
                Console.WriteLine("The application terminated with an error.");
                Console.WriteLine(ex.Message);

                // Display the details of the inner exception.
                if (ex.InnerException != null)
                {
                    Console.WriteLine(ex.InnerException.Message);

                    FaultException fe = 
                        ex.InnerException
                        as FaultException;
                    if (fe != null)
                    {
                        Console.WriteLine("Timestamp: {0}", fe.Detail.Timestamp);
                        Console.WriteLine("Code: {0}", fe.Detail.ErrorCode);
                        Console.WriteLine("Message: {0}", fe.Detail.Message);
                        Console.WriteLine("Plugin Trace: {0}", fe.Detail.TraceText);
                        Console.WriteLine("Inner Fault: {0}",
                            null == fe.Detail.InnerFault ? "No Inner Fault" : "Has Inner Fault");
                    }
                }
            }
            finally
            {
                
                Console.WriteLine("Press  to exit.");
                Console.ReadLine();
            }

        }
        #endregion Main

    }
}

Create a Task

The following sample workflow activity demonstrates how to create a task within an activity.

  
using System;
using System.Collections;
using System.Workflow.ComponentModel.Compiler;
using System.Workflow.ComponentModel.Serialization;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Design;
using System.Workflow.Runtime;
using System.Workflow.Activities;
using System.Workflow.Activities.Rules;
using System.Reflection;

using Microsoft.Crm.Workflow;
using Microsoft.Crm.Sdk;
using Microsoft.Crm.SdkTypeProxy;
using Microsoft.Crm.Sdk.Query;

namespace SampleWorkflows
{
    [CrmWorkflowActivity("Create a Task")]
    public class CustomActivity : Activity
    {
        protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
        {

            IContextService contextService = (IContextService)executionContext.GetService(typeof(IContextService));
            IWorkflowContext context = contextService.Context;

            ICrmService crmService = context.CreateCrmService();

            DynamicEntity entity = new DynamicEntity();
            entity.Name = EntityName.task.ToString();
            entity.Properties = new PropertyCollection();
            entity.Properties.Add(new StringProperty("subject", taskId.Value.ToString()));
            entity.Properties.Add(new KeyProperty("activityid", new Key(taskId.Value)));
            crmService.Create(entity);

            return base.Execute(executionContext);
        }

        public static DependencyProperty taskIdProperty =
           DependencyProperty.Register("taskId",
           typeof(Lookup),
           typeof(CustomActivity));

        [CrmInput("The id")]
        [CrmOutput("The output")]
        [CrmReferenceTarget("task")]
        public Lookup taskId
        {
            get
            {
                return (Lookup)base.GetValue(taskIdProperty);
            }
            set
            {
                base.SetValue(taskIdProperty, value);
            }

        }


    }
}

  

Defaulting the History ‘Filter on’ to ‘All’ on Dynamics CRM 4.0 Accounts and Contacts

// History Default Filter to All
var crmloadarea = loadArea;
loadArea = function (area) {
    crmloadarea(area);
    if (area != "areaActivityHistory") { return; } // only hook into the history iframe
 
    var frame = document.getElementById(area + "Frame");
    frame.onreadystatechange = function () {
        if (frame.readyState == "complete") {
            doc = frame.contentWindow.document;
            doc.all.actualend[0].value = "All"; // instead of 30 days
            doc.all.actualend[0].FireOnChange();
        }
    }
}

CRM 4.0 Form JS Library

Here are a set of functions to work with CRM 4.0 forms.

 
/* Jscript */

                    document = new Object();

// Field Object
document.getFieldObj = function(fname)
{
    var ret = document.getElementById(fname);
    return ret;
};
// FieldText
document.getDataValue = function(fname)
{
    var str = document.getFieldObj(fname);
    str = str.DataValue;
    return tmp;
};
document.getDefaultValue = function(fname)
{
    var obj = document.getFieldObj(fname);
    obj = obj.DefaultValue;
    return tmp;
};
document.lookupItem = function(fname)
{
    var obj = document.getFieldObj(fname);
    return (obj[0].name);
};
document.lookupGuid = function(fname)
{
    var obj = document.getFieldObj(fname);
    return (obj[0].id);
};
document.lookupTypename = function(fname)
{
    var obj = document.getFieldObj(fname);
    return (obj[0].typename);
};
document.setFocus = function(fname)
{
    var obj = document.getFieldObj(fname);
    obj.SetFocus();
};
document.onChange = function(fname)
{
    var obj = document.getFieldObj(fname);
    obj.FireOnChange();
};
document.getRequiredLevel = function(fname)
{
    var tmp = document.getFieldObj(fname);
    return tmp.RequiredLevel;
};
document.idDirty = function(fname)
{
    var tmp = document.getFieldObj(fname);
    if(tmp.IsDirty)
        return true;
    else
        return false;
};
document.disableField = function(fname)
{
    var str = document.getFieldObj(fname);
    str.disabled = true;
    return true;
}
document.forceSubmit = function(fname)
{
    var obj = document.getFieldObj(fname);
    obj.ForceSubmit;
}
document.getSelectedText = function(fname)
{
    var obj = document.getFieldObj(fname);
    return(obj.SelectedText);
}
document.getSelectedOption = function(fname)
{
    var obj = document.getFieldObj(fname);
    return(obj.GetSelectedOption);
}
document.getOptions = function(fname)
{
    var obj = document.getFieldObj(fname);
    return(obj.Options);
}
document.addOption = function(fname,text,datavalue)
{
    var obj = document.getFieldObj(fname);
    obj.AddOption(text,datavalue);
    return true;
}
document.delOption = function(fname,value)
{
    var obj = document.getFieldObj(fname);
    obj.DeleteOption(value);
    return true;
}
document.genSoap = function(fxml)
{
    var soap2 = "";
    soap2 += GenerateAuthenticationHeader();
    soap2 += "";
    soap2 += fxml;
    soap2 += "";
    return soap2;
}
document.ajaxRequest = function(genUrl)
{
    var xhr = new ActiveXObject("Msxml2.XMLHTTP");
    xhr.open("GET", genUrl, false);
    xhr.setRequestHeader("Content-Type", "text/xml; charset=utf-8");
    xhr.send(null);
    var resultSet = xhr.responsetext;
    return resultSet;
}

document.ajaxSoap = function (soap_msg) {
    // COUNTRY ISO CODE
    var XmlHttp = new ActiveXObject("Msxml2.XMLHTTP");
    XmlHttp.open("POST", "/mscrmservices/2007/CrmService.asmx", false);
    XmlHttp.setRequestHeader("Content-Type", "text/xml; charset=utf-8");
    XmlHttp.setRequestHeader("SOAPAction", "http://schemas.microsoft.com/crm/2007/WebServices/Fetch");
    XmlHttp.setRequestHeader("Content-Length", soap_msg.length);
    XmlHttp.send(soap_msg);
    var resultSet = XmlHttp.responseXML.text;
}