locked
Recalculate function RRS feed

  • Question

  • Hello, 

    Can we select multiple records in home grid of goal and run Recalculate function?

    If so, let me know the process.

    Tuesday, May 6, 2014 3:16 PM

All replies

  • standard button does not support this but you can always add your custom button and perform this operation easily...

    we have done this in the past and following pseudo code used for this..(note this takes grid control as parameter and done calculation for one record but you can easily extend this to loop through each selected record and call relevant function)..

    one reason it is not advisable to do this because each recalculation can take some time to perform this operation..

    hope this helps..

    recalculateGoalAndRefreshGridNEW =
    function (gridControl, records) {
    
        if (confirm('Data roll up might take some time. Click OK to continue.')) {
            //recalculateGoalNEW(records[0].Id, gridControl);
            MPFUNCRequest(records[0].Id, gridControl);
    
        }
    };
    
    recalculateGoalNEW = function (recordId, gridControl) {
    
       
    
        var request = "" +
    " <s:Envelope xmlns:s='http://schemas.xmlsoap.org/soap/envelope/'> " + 
    "  <s:Body>  " +
    "    <Execute xmlns='http://schemas.microsoft.com/xrm/2011/Contracts/Services' xmlns:i='http://www.w3.org/2001/XMLSchema-instance'> " +
    "      <request i:type='b:RecalculateRequest' xmlns:a='http://schemas.microsoft.com/xrm/2011/Contracts' xmlns:b='http://schemas.microsoft.com/crm/2011/Contracts'> " +
    "        <a:Parameters xmlns:c='http://schemas.datacontract.org/2004/07/System.Collections.Generic'> " +
    "          <a:KeyValuePairOfstringanyType> " +
    "            <c:key>Target</c:key> " +
    "            <c:value i:type='a:EntityReference'> " +
    "              <a:Id>" + recordId + "/a:Id> " +
    "              <a:LogicalName>goal</a:LogicalName> " +
    "              <a:Name i:nil='true' /> " +
    "            </c:value> " +
    "          </a:KeyValuePairOfstringanyType> " +
    "        </a:Parameters> " +
    "        <a:RequestId i:nil='true' /> " +
    "        <a:RequestName>Recalculate</a:RequestName> " +
    "      </request> " +
    "    </Execute> " +
    "  </s:Body> " +
    " </s:Envelope> " +
    "";
    
    
    
        var xhr = new XMLHttpRequest();
        //xhr.open('POST', '/XRMServices/2011/Organization.svc/web', true);
        
        xhr.open('POST', _getServerUrl() , true);
    
        
        xhr.setRequestHeader('Accept', 'application/xml, text/xml, */*');
        xhr.setRequestHeader('Content-Type', 'text/xml; charset=utf-8');
        xhr.setRequestHeader('SOAPAction', 'http://schemas.microsoft.com/xrm/2011/Contracts/Services/IOrganizationService/Execute');
    
        var successCallback = null;
        var errorCallback = null;
    
        xhr.onreadystatechange = function () { SetStateResponse(gridControl, xhr, successCallback, errorCallback); };
        xhr.send(request);
    
        //alert('finished processing, please refresh the grid');
        //gridControl.refresh();
    
    };
    
    
    
    
    
    _getServerUrl = function () {    
    
        ///<summary>
        /// Returns the URL for the SOAP endpoint using the context information available in the form
        /// or HTML Web resource.
        ///</summary>
        var ServicePath = "/XRMServices/2011/Organization.svc/web";
        var serverUrl = "";
        if (typeof GetGlobalContext == "function") {
            var context = GetGlobalContext();
            serverUrl = context.getServerUrl();
        }
        else {
            if (typeof Xrm.Page.context == "object") {
                serverUrl = Xrm.Page.context.getServerUrl();
            }
            else
            { throw new Error("Unable to access the server URL"); }
        }
        if (serverUrl.match(/\/$/)) {
            serverUrl = serverUrl.substring(0, serverUrl.length - 1);
        }
        return serverUrl + ServicePath;
    };
    
    
    
    MPFUNCRequest = function (recordId, gridControl) {
        var requestMain = ""
        requestMain += "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\">";
        requestMain += "  <s:Body>";
        requestMain += "    <Execute xmlns=\"http://schemas.microsoft.com/xrm/2011/Contracts/Services\" xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\">";
        requestMain += "      <request i:type=\"b:RecalculateRequest\" xmlns:a=\"http://schemas.microsoft.com/xrm/2011/Contracts\" xmlns:b=\"http://schemas.microsoft.com/crm/2011/Contracts\">";
        requestMain += "        <a:Parameters xmlns:c=\"http://schemas.datacontract.org/2004/07/System.Collections.Generic\">";
        requestMain += "          <a:KeyValuePairOfstringanyType>";
        requestMain += "            <c:key>Target</c:key>";
        requestMain += "            <c:value i:type=\"a:EntityReference\">";
        requestMain += "              <a:Id>" + recordId + "</a:Id>";
        requestMain += "              <a:LogicalName>goal</a:LogicalName>";
        requestMain += "              <a:Name i:nil=\"true\" />";
        requestMain += "            </c:value>";
        requestMain += "          </a:KeyValuePairOfstringanyType>";
        requestMain += "        </a:Parameters>";
        requestMain += "        <a:RequestId i:nil=\"true\" />";
        requestMain += "        <a:RequestName>Recalculate</a:RequestName>";
        requestMain += "      </request>";
        requestMain += "    </Execute>";
        requestMain += "  </s:Body>";
        requestMain += "</s:Envelope>";
        var req = new XMLHttpRequest();
        req.open("POST", _getServerUrl(), true)
        req.setRequestHeader("Accept", "application/xml, text/xml, */*");
        req.setRequestHeader("Content-Type", "text/xml; charset=utf-8");
        req.setRequestHeader("SOAPAction", "http://schemas.microsoft.com/xrm/2011/Contracts/Services/IOrganizationService/Execute");
        var successCallback = null;
        var errorCallback = null;
        req.onreadystatechange = function () { MPFUNCResponse(gridControl,req, successCallback, errorCallback); };
        req.send(requestMain);
    };
    
    MPFUNCResponse = function (gridControl,req, successCallback, errorCallback) {
        ///<summary>
        /// Recieves the assign response
        ///</summary>
        ///<param name="req" Type="XMLHttpRequest">
        /// The XMLHttpRequest response
        ///</param>
        ///<param name="successCallback" Type="Function">
        /// The function to perform when an successfult response is returned.
        /// For this message no data is returned so a success callback is not really necessary.
        ///</param>
        ///<param name="errorCallback" Type="Function">
        /// The function to perform when an error is returned.
        /// This function accepts a JScript error returned by the _getError function
        ///</param>
        if (req.readyState == 4) {
            if (req.status == 200) {
                if (successCallback != null)
                { successCallback(); }
                gridControl.refresh();
                //alert('finished processing.....');
                
            }
            else {
                errorCallback(_MPgetError(req.responseXML));
            }
        }
    };
    
    
    _MPgetError = function (faultXml) {
        ///<summary>
        /// Parses the WCF fault returned in the event of an error.
        ///</summary>
        ///<param name="faultXml" Type="XML">
        /// The responseXML property of the XMLHttpRequest response.
        ///</param>
        var errorMessage = "Unknown Error (Unable to parse the fault)";
        if (typeof faultXml == "object") {
            try {
                var bodyNode = faultXml.firstChild.firstChild;
                //Retrieve the fault node
                for (var i = 0; i < bodyNode.childNodes.length; i++) {
                    var node = bodyNode.childNodes[i];
                    //NOTE: This comparison does not handle the case where the XML namespace changes
                    if ("s:Fault" == node.nodeName) {
                        for (var j = 0; j < node.childNodes.length; j++) {
                            var faultStringNode = node.childNodes[j];
                            if ("faultstring" == faultStringNode.nodeName) {
                                errorMessage = faultStringNode.text;
                                break;
                            }
                        }
                        break;
                    }
                }
            }
            catch (e) { };
        }
        return new Error(errorMessage);
    };
    
    
    
    
    
    function SetStateResponse(gridControl,req, successCallback, errorCallback) {
        ///<summary>
        /// Recieves the assign response
        ///</summary>
        ///<param name="req" Type="XMLHttpRequest">
        /// The XMLHttpRequest response
        ///</param>
        ///<param name="successCallback" Type="Function">
        /// The function to perform when an successfult response is returned.
        /// For this message no data is returned so a success callback is not really necessary.
        ///</param>
        ///<param name="errorCallback" Type="Function">
        /// The function to perform when an error is returned.
        /// This function accepts a JScript error returned by the _getError function
        ///</param>
        if (req.readyState == 4) {
            if (req.status == 200) {            
                alert('finished processing, please refresh the grid');
                gridControl.refresh();
    //            if (successCallback != null)
    //            { successCallback(); }
            }
            else {           
                _getError(req.responseXML);
            }
        }
    }
    function _getError(faultXml) {    
        ///<summary>
        /// Parses the WCF fault returned in the event of an error.
        ///</summary>
        ///<param name="faultXml" Type="XML">
        /// The responseXML property of the XMLHttpRequest response.
        ///</param>
        var errorMessage = "Unknown Error (Unable to parse the fault)";
        if (typeof faultXml == "object") {
            try {
                var bodyNode = faultXml.firstChild.firstChild;
                //Retrieve the fault node
                for (var i = 0; i < bodyNode.childNodes.length; i++) {
                    var node = bodyNode.childNodes[i];
                    //NOTE: This comparison does not handle the case where the XML namespace changes
                    if ("s:Fault" == node.nodeName) {
                        for (var j = 0; j < node.childNodes.length; j++) {
                            var faultStringNode = node.childNodes[j];
                            if ("faultstring" == faultStringNode.nodeName) {
                                errorMessage = faultStringNode.text;
                                break;
                            }
                        }
                        break;
                    }
                }
            }
            catch (e) { };
        }
        alert(errorMessage);
    }
    



    MayankP
    My Blog
    Follow Me on Twitter

    Tuesday, May 6, 2014 8:37 PM
    Answerer