Ejemplo n.º 1
0
 public static IEnumerable<Guid> GetGuidsAsEnumerable(ExecuteTransactionResponse executeTransactionResponse)
 {
     foreach (var responseItem in executeTransactionResponse.Responses)
     {
         yield return new Guid(responseItem.Results["id"].ToString());
     }
 }
Ejemplo n.º 2
0
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            ExecuteTransactionResponse response = new ExecuteTransactionResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("ConsumedCapacity", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller <ConsumedCapacity, ConsumedCapacityUnmarshaller>(ConsumedCapacityUnmarshaller.Instance);
                    response.ConsumedCapacity = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("Responses", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller <ItemResponse, ItemResponseUnmarshaller>(ItemResponseUnmarshaller.Instance);
                    response.Responses = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

            return(response);
        }
Ejemplo n.º 3
0
 public static IEnumerable <Guid> GetGuidsAsEnumerable(ExecuteTransactionResponse executeTransactionResponse)
 {
     foreach (var responseItem in executeTransactionResponse.Responses)
     {
         yield return(new Guid(responseItem.Results["id"].ToString()));
     }
 }
Ejemplo n.º 4
0
        private ExecuteTransactionResponse ExecuteInternal(ExecuteTransactionRequest request)
        {
            var response = new ExecuteTransactionResponse
            {
                Results =
                {
                    ["Responses"] = new OrganizationResponseCollection()
                }
            };

            for (int i = 0; i < request.Requests.Count; i++)
            {
                var childRequest = request.Requests[i];
                OrganizationResponse childResponse = null;
                try
                {
                    if (childRequest.RequestName == "ExecuteMultiple")
                    {
                        throw new Exception("ExecuteMultipleRequest cannot contain an ExecuteMultipleRequest");
                    }

                    childResponse = ExecuteInternal((dynamic)childRequest);
                    if (request.ReturnResponses != true)
                    {
                        childResponse = null;
                    }
                }
                catch (NotImplementedException)
                {
                    throw;
                }
                catch (Exception ex)
                {
                    throw new FaultException <OrganizationServiceFault>(new ExecuteTransactionFault
                    {
                        FaultedRequestIndex = i,
                        Message             = ex.Message,
                        Timestamp           = DateTime.UtcNow,
                        ErrorDetails        =
                        {
                            ["CallStack"] = ex.StackTrace
                        }
                    }, new FaultReason(ex.Message));
                }
                finally
                {
                    if (childResponse != null)
                    {
                        response.Responses.Add(childResponse);
                    }
                }
            }

            return(response);
        }
        public List <DtoMultipleReponse> Execute(List <ExecuteTransactionRequest> resultList, bool isOnlyErrRes = true)
        {
            List <DtoMultipleReponse> errorResponseList = new List <DtoMultipleReponse>();

            try
            {
                for (int i = 0; i < resultList.Count; i++)
                {
                    ExecuteTransactionRequest  request        = resultList[i] as ExecuteTransactionRequest;
                    ExecuteTransactionResponse responseResult = (ExecuteTransactionResponse)_orgProxy.Execute(request);

                    if (!isOnlyErrRes)
                    {
                        foreach (var responseItem in responseResult.Responses)
                        {
                            if (responseItem.Results.Count > 0)
                            {
                                DtoMultipleReponse dto = new DtoMultipleReponse()
                                {
                                    IsSuccess   = true,
                                    RequestName = responseItem.ResponseName
                                };

                                if ("Create".Equals(responseItem.ResponseName))                                 //Create만 Return Id가 존재하는 듯함
                                {
                                    //dto.RequestId = responseItem.Results["id"].ToString();
                                }
                                errorResponseList.Add(dto);
                            }
                        }
                    }
                }
                return(errorResponseList);
            }
            catch (FaultException <OrganizationServiceFault> ex)
            {
                DtoMultipleReponse dto = new DtoMultipleReponse()
                {
                    IsSuccess           = false,
                    RequestFaultMessage = ex.Detail.Message
                };
                errorResponseList.Add(dto);

                return(errorResponseList);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
Ejemplo n.º 6
0
        public static XrmUpdateResponse BulkUpdate(ExecuteTransactionRequest multipleRequest, IOrganizationService service)
        {
            if (multipleRequest == null && multipleRequest.Requests == null && multipleRequest.Requests.Count == 0)
            {
                return(null);
            }
            if (service == null)
            {
                return(null);
            }
            ExecuteTransactionResponse multipleResponses = (ExecuteTransactionResponse)service.Execute(multipleRequest);

            return(new XrmUpdateResponse {
                Updated = true, Existing = true
            });
        }
Ejemplo n.º 7
0
        public bool ExecuteTransaction(ExecuteTransaction transaction, string token, out string errorMessage, out string errorcode, out ExecuteTransactionResponse executeTransactionResponse)
        {
            errorcode    = "";
            errorMessage = "";

            string apikey = token;
            //func-ExecuteTransaction
            string url = ConfigurationManager.AppSettings["ExecuteTransactionUrl"];
            string xml = $@"<?xml version=""1.0"" encoding=""utf-8""?>
                <soap:Envelope xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:soap=""http://schemas.xmlsoap.org/soap/envelope/"">
                  <soap:Body>
                      <ExecuteTransaction xmlns=""http://tempuri.org/"" >
                      <Price>{transaction.PRICE}</Price>
                      <Amount>{transaction.AMOUNT}</Amount>
                      <Kod_makor>{transaction.KOD_MAKOR}</Kod_makor>
                      <Kod_station>{transaction.KOD_STATION}</Kod_station>
                      <Kod_hetken>{transaction.KOD_HETKEN}</Kod_hetken>
                      <Mispar_hetken>{transaction.MISPAR_HETKEN}</Mispar_hetken>
                      <Tidluk_date>{transaction.TIDLUK_DATE}</Tidluk_date>
                      <Tidluk_time>{transaction.TIDLUK_TIME}</Tidluk_time>
                      <Kod_tazkik>{transaction.KOD_TAZKIK}</Kod_tazkik>
                      <Station_order>{transaction.STATION_ORDER}</Station_order>
                    </ExecuteTransaction>
                  </soap:Body>
                </soap:Envelope>";
            string ans = POST(url, apikey, xml);

            if (ans.Contains("Error message"))
            {
                errorMessage = ans;
                executeTransactionResponse = null;
                return(false);
            }
            XmlDocument doc = new XmlDocument();

            doc.LoadXml(ans);
            executeTransactionResponse = new ExecuteTransactionResponse(doc.InnerText);

            if (executeTransactionResponse.ResponseCode == "2000")
            {
                return(true);
            }
            errorcode    = doc.InnerText;
            errorMessage = GetErrorMessage(errorcode);
            return(false);
        }
        public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
        {
            var executeTransactionRequest = (ExecuteTransactionRequest)request;
            var response = new ExecuteTransactionResponse { ["Responses"] = new OrganizationResponseCollection() };

            var service = ctx.GetFakedOrganizationService();

            foreach (var r in executeTransactionRequest.Requests)
            {
                var result = service.Execute(r);

                if (executeTransactionRequest.ReturnResponses.HasValue && executeTransactionRequest.ReturnResponses.Value)
                {
                    response.Responses.Add(result);        
                }
            }
            return response;
        }
        public List <DtoTransactionResponseGuid> Execute(List <ExecuteTransactionRequest> resultList)
        {
            List <DtoTransactionResponse>     errorResponseList  = new List <DtoTransactionResponse>();
            List <DtoTransactionResponseGuid> responseResultList = new List <DtoTransactionResponseGuid>();

            try
            {
                for (int i = 0; i < resultList.Count; i++)
                {
                    ExecuteTransactionRequest  request        = resultList[i] as ExecuteTransactionRequest;
                    ExecuteTransactionResponse responseResult = (ExecuteTransactionResponse)_orgProxy.Execute(request);

                    foreach (var resultResponse in responseResult.Responses)
                    {
                        if (resultResponse.ResponseName != "Delete")
                        {
                            responseResultList.Add(new DtoTransactionResponseGuid
                            {
                                Id = resultResponse.Results.Select(a => a.Value.ToString()).SingleOrDefault()
                            });
                        }
                    }
                }

                return(responseResultList);
            }
            catch (FaultException <OrganizationServiceFault> ex)
            {
                DtoTransactionResponse dto = new DtoTransactionResponse()
                {
                    ErrorDetails = ex.Detail.ErrorDetails,
                    Message      = ex.Detail.Message,
                    ErrorCode    = ex.Detail.ErrorCode
                };

                throw;
            }
            catch (Exception e)
            {
                throw e;
            }
        }
Ejemplo n.º 10
0
        public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
        {
            var executeTransactionRequest = (ExecuteTransactionRequest)request;
            var response = new ExecuteTransactionResponse {
                ["Responses"] = new OrganizationResponseCollection()
            };

            var service = ctx.GetFakedOrganizationService();

            foreach (var r in executeTransactionRequest.Requests)
            {
                var result = service.Execute(r);

                if (executeTransactionRequest.ReturnResponses.HasValue && executeTransactionRequest.ReturnResponses.Value)
                {
                    response.Responses.Add(result);
                }
            }
            return(response);
        }
        /// <summary>
        /// This sample demonstrates how to execute a collection of message requests in a single database transaction,
        /// by using a single web service call and optionally return the results.
        /// </summary>
        /// <seealso cref="https://msdn.microsoft.com/en-us/library/gg328075.aspx#bkmk_transaction"/>
        /// <param name="serverConfig">Contains server connection information.</param>
        /// <param name="promptforDelete">When True, the user will be prompted to delete all
        /// created entities.</param>
        public void Run(ServerConnection.Configuration serverConfig, bool promptforDelete)
        {
            ExecuteTransactionRequest requestToCreateRecords = null;

            try
            {
                // Get a reference to the organization service.
                using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri, serverConfig.Credentials, serverConfig.DeviceCredentials))
                {
                    // Enable early-bound type support to add/update entity records required for this sample.
                    _serviceProxy.EnableProxyTypes();

                    #region Execute Transaction to create records
                    // Create an ExecuteTransactionRequest object.
                    requestToCreateRecords = new ExecuteTransactionRequest()
                    {
                        // Create an empty organization request collection.
                        Requests        = new OrganizationRequestCollection(),
                        ReturnResponses = true
                    };

                    // Create several (local, in memory) entities in a collection.
                    EntityCollection input = GetCollectionOfEntitiesToCreate();

                    // Add a CreateRequest for each entity to the request collection.
                    foreach (var entity in input.Entities)
                    {
                        CreateRequest createRequest = new CreateRequest {
                            Target = entity
                        };
                        requestToCreateRecords.Requests.Add(createRequest);
                    }

                    // Execute all the requests in the request collection using a single web method call.
                    try
                    {
                        var responseForCreateRecords =
                            (ExecuteTransactionResponse)_serviceProxy.Execute(requestToCreateRecords);

                        int i = 0;
                        // Display the results returned in the responses.
                        foreach (var responseItem in responseForCreateRecords.Responses)
                        {
                            if (responseItem != null)
                            {
                                DisplayResponse(requestToCreateRecords.Requests[i], responseItem);
                            }
                            i++;
                        }
                    }
                    catch (FaultException <OrganizationServiceFault> ex)
                    {
                        Console.WriteLine("Create request failed for the account{0} and the reason being: {1}",
                                          ((ExecuteTransactionFault)(ex.Detail)).FaultedRequestIndex + 1, ex.Detail.Message);
                        throw;
                    }

                    #endregion Execute Transaction to create records

                    #region Execute Transaction to update records
                    ExecuteTransactionRequest requestForUpdates = new ExecuteTransactionRequest()
                    {
                        Requests = new OrganizationRequestCollection()
                    };

                    // Update the entities that were previously created.
                    EntityCollection update = GetCollectionOfEntitiesToUpdate();

                    foreach (var entity in update.Entities)
                    {
                        UpdateRequest updateRequest = new UpdateRequest {
                            Target = entity
                        };
                        requestForUpdates.Requests.Add(updateRequest);
                    }

                    try
                    {
                        ExecuteTransactionResponse responseForUpdates =
                            (ExecuteTransactionResponse)_serviceProxy.Execute(requestForUpdates);
                        Console.WriteLine("Entity records are updated.");
                    }
                    catch (FaultException <OrganizationServiceFault> ex)
                    {
                        Console.WriteLine("Update request failed for the account{0} and the reason being: {1}",
                                          ((ExecuteTransactionFault)(ex.Detail)).FaultedRequestIndex + 1, ex.Detail.Message);
                    }
                    #endregion Execute Transaction for update records

                    DeleteRequiredRecords(promptforDelete);
                }
            }
            catch (FaultException <OrganizationServiceFault> fault)
            {
                // Check if the maximum batch size has been exceeded. The maximum batch size is only included in the fault if it
                // the input request collection count exceeds the maximum batch size.
                if (fault.Detail.ErrorDetails.Contains("MaxBatchSize"))
                {
                    int maxBatchSize = Convert.ToInt32(fault.Detail.ErrorDetails["MaxBatchSize"]);
                    if (maxBatchSize < requestToCreateRecords.Requests.Count)
                    {
                        // Here you could reduce the size of your request collection and re-submit the ExecuteTransaction request.
                        // For this sample, that only issues a few requests per batch, we will just print out some info. However,
                        // this code will never be executed because the default max batch size is 1000.
                        Console.WriteLine("The input request collection contains %0 requests, which exceeds the maximum allowed (%1)",
                                          requestToCreateRecords.Requests.Count, maxBatchSize);
                    }
                }
                // Re-throw so Main() can process the fault.
                throw;
            }
        }
Ejemplo n.º 12
0
        public ExecuteTransactionResponse GetTransactionResponse(ExecuteTransactionRequest request)
        {
            var requestDictionary = new Dictionary <int, string>();

            var batchid          = "batch_" + Guid.NewGuid().ToString();
            var batchContent     = new MultipartContent("mixed", batchid);
            var changesetID      = "changeset_" + Guid.NewGuid().ToString();
            var changeSetContent = new MultipartContent("mixed", changesetID);

            for (int contentId = 1; contentId <= request.Requests.Count; contentId++)
            {
                HttpMessageContent content = new HttpMessageContent(GetRequestMessage((OrganizationRequest)request.Requests[contentId - 1]));
                content.Headers.Remove("Content-Type");
                content.Headers.TryAddWithoutValidation("Content-Type", "application/http");
                content.Headers.TryAddWithoutValidation("Content-Transfer-Encoding", "binary");
                content.Headers.TryAddWithoutValidation("Content-ID", contentId.ToString());
                changeSetContent.Add(content);
                requestDictionary.Add(contentId, ((OrganizationRequest)request.Requests[contentId - 1]).RequestName);
            }

            batchContent.Add(changeSetContent);

            var batchRequest = new HttpRequestMessage(HttpMethod.Post, _endpoint + "$batch")
            {
                Content = batchContent
            };

            var batchstring = batchRequest.Content.ReadAsStringAsync();

            var httpClient = new HttpClient(new HttpClientHandler {
                Credentials = _credential ?? CredentialCache.DefaultNetworkCredentials
            });
            var response = httpClient.SendAsync(batchRequest)?.Result;

            if (response == null)
            {
                throw new Exception("Сервер вернул пустой ответ");
            }

            if (!response.IsSuccessStatusCode)
            {
                var exception = JsonSerializer.Deserialize <CrmException>(response.Content.ReadAsStringAsync().Result);
                throw new CrmException(exception.Error.Message, exception);
            }

            var responseString = response.Content.ReadAsStringAsync();
            MultipartMemoryStreamProvider batchStream = response.Content.ReadAsMultipartAsync().Result;
            var batchStreamContent = batchStream.Contents.FirstOrDefault();

            MultipartMemoryStreamProvider changesetStream = batchStreamContent.ReadAsMultipartAsync().Result;

            var transactionResponse = new ExecuteTransactionResponse();

            foreach (var changesetContent in changesetStream.Contents)
            {
                changesetContent.Headers.Remove("Content-Type");
                changesetContent.Headers.Add("Content-Type", "application/http; msgtype=response");

                var indivdualResponse = changesetContent.ReadAsHttpResponseMessageAsync().Result;

                if (!indivdualResponse.IsSuccessStatusCode)
                {
                    var exception = JsonSerializer.Deserialize <CrmException>(response.Content.ReadAsStringAsync().Result);
                    throw new CrmException(exception.Error.Message, exception);
                }

                var operationName = requestDictionary.FirstOrDefault(dic => dic.Key == int.Parse(changesetContent.Headers.GetValues("Content-ID").FirstOrDefault())).Value;

                if (operationName == Constants.CREATE)
                {
                    var idString = indivdualResponse.Headers.GetValues("OData-EntityId").FirstOrDefault();
                    idString = idString.Replace(_endpoint, "").Replace("(", "").Replace(")", "");
                    idString = idString.Substring(idString.Length - 36);

                    var createResponse = new CreateResponse {
                        Id = Guid.Parse(idString), ResponseName = operationName
                    };
                    transactionResponse.Responses.Add(createResponse);
                }

                if (operationName == Constants.UPDATE)
                {
                    var updateResponse = new UpdateResponse {
                        ResponseName = operationName
                    };
                    transactionResponse.Responses.Add(updateResponse);
                }

                if (operationName == Constants.DELETE)
                {
                    var deleteResponse = new DeleteResponse {
                        ResponseName = operationName
                    };
                    transactionResponse.Responses.Add(deleteResponse);
                }

                if (operationName == Constants.DISASSOCIATE)
                {
                    var deleteResponse = new DissacociateResponse {
                        ResponseName = operationName
                    };
                    transactionResponse.Responses.Add(deleteResponse);
                }

                if (operationName == Constants.ASSOCIATE)
                {
                    var deleteResponse = new AssociateResponse {
                        ResponseName = operationName
                    };
                    transactionResponse.Responses.Add(deleteResponse);
                }
            }

            return(transactionResponse);
        }
Ejemplo n.º 13
0
        private void Run()
        {
            while (true)
            {
                try
                {
                    AppendText("Start transaction Goodi system");
                    Token token = DataBase.DBParser.Instance().GetToken();
                    if (token == null || token.Stemp_Tar < DateTime.Now || !RestApi.Instance().IsTokenValid(token.TokenNumber))
                    {
                        token = RestApi.Instance().GetNewToken();
                        if (token != null)
                        {
                            bool res = DataBase.DBParser.Instance().UpdateToken(token);
                        }
                        else
                        {
                            AppendText("Did not susseeded get token");
                            throw new Exception("Did not susseeded get token");
                        }
                    }

                    IEnumerable <ExecuteTransaction> transactions = DataBase.DBParser.Instance().GetAllTransactions();
                    List <ExecuteTransaction>        updateOk     = new List <ExecuteTransaction>();
                    List <ExecuteTransaction>        errorUpdate  = new List <ExecuteTransaction>();
                    foreach (ExecuteTransaction transaction in transactions)
                    {
                        string errorMessage = "";
                        string errorCode    = "";
                        bool   isUpdate     = false;
                        ExecuteTransactionResponse executeTransactionResponse = null;
                        bool result = RestApi.Instance().ExecuteTransaction(transaction, token.TokenNumber, out errorMessage, out errorCode, out executeTransactionResponse);
                        if (!result)
                        {
                            transaction.ERROR_MESSAGE = $"Station order  {transaction.STATION_ORDER} did not succeeded update in Goodi system";
                            AppendText(errorMessage);
                            isUpdate = DataBase.DBParser.Instance().UpdateTransaction(transaction.ID, errorMessage, errorCode);
                            errorUpdate.Add(transaction);
                        }
                        else
                        {
                            AppendText($"Successfully update Station order {transaction.STATION_ORDER}  in goodi system");
                            isUpdate = DataBase.DBParser.Instance().UpdateTransaction(transaction.ID, transactionResponse: executeTransactionResponse);
                            updateOk.Add(transaction);
                        }
                        if (isUpdate)
                        {
                            AppendText($"Successfully update Station order status {transaction.STATION_ORDER}  in data base");
                        }
                        else
                        {
                            transaction.ERROR_MESSAGE = $"Station order {transaction.STATION_ORDER} did not succeeded update order status in Data base";
                            AppendText(transaction.ERROR_MESSAGE);
                        }
                    }
                    if (updateOk.Count > 0 || errorUpdate.Count > 0)
                    {
                        AppendText($"{updateOk.Count} selers where update and {errorUpdate.Count} selers getting error");
                        //send mail
                        string title = $" ממשקי גודי דלקנים של צהל";
                        string body  = $"<div  style='direction:rtl' > שלום  <br /> מספר התדלוקים של צהל שעודכנו בגודי {updateOk.Count} <br /> מספר התדלוקים של צהל שלא עדכנו בגודי {errorUpdate.Count} </div>";
                        if (errorUpdate.Count > 0)
                        {
                            string errorSeler = "<div  style='direction:rtl' ><br />תדלוקים שלא עודכנו בגודי<br /></div>";
                            foreach (ExecuteTransaction transaction in errorUpdate)
                            {
                                errorSeler += $"<div  style='direction:rtl' ><br />{transaction.ToString()}<br /></div>";
                            }
                            body += errorSeler;
                        }
                        SendMail.Instance().Email(body, title);
                    }
                    AppendText("Finish Transaction to Goodi system");
                }
                catch (Exception ex)
                {
                    AppendText($"Error when try to update selers, error message: {ex.Message}");
                }
                if (m_stopThreadsEvent.WaitOne(_timeToWait))
                {
                    break;
                }
            }
        }
Ejemplo n.º 14
0
        [STAThread] // Required to support the interactive login experience
        static void Main(string[] args)
        {
            CrmServiceClient service = null;

            try
            {
                service = SampleHelpers.Connect("Connect");
                if (service.IsReady)
                {
                    // Create any entity records that the demonstration code requires
                    SetUpSample(service);
                    #region Demonstrate
                    // Create an ExecuteTransactionRequest object.
                    var requestToCreateRecords = new ExecuteTransactionRequest()
                    {
                        // Create an empty organization request collection.
                        Requests        = new OrganizationRequestCollection(),
                        ReturnResponses = true
                    };

                    // Create several (local, in memory) entities in a collection.
                    EntityCollection input = GetCollectionOfEntitiesToCreate();

                    // Add a CreateRequest for each entity to the request collection.
                    foreach (var entity in input.Entities)
                    {
                        CreateRequest createRequest = new CreateRequest {
                            Target = entity
                        };
                        requestToCreateRecords.Requests.Add(createRequest);
                    }


                    var responseForCreateRecords =
                        (ExecuteTransactionResponse)service.Execute(requestToCreateRecords);

                    int i = 0;
                    // Display the results returned in the responses.
                    foreach (var responseItem in responseForCreateRecords.Responses)
                    {
                        if (responseItem != null)
                        {
                            DisplayResponse(requestToCreateRecords.Requests[i], responseItem);
                        }
                        i++;
                    }


                    Console.WriteLine("Create request failed for the account{0} and the reason being: {1}");


                    var requestForUpdates = new ExecuteTransactionRequest()
                    {
                        Requests = new OrganizationRequestCollection()
                    };

                    // Update the entities that were previously created.
                    EntityCollection update = GetCollectionOfEntitiesToUpdate();

                    foreach (var entity in update.Entities)
                    {
                        UpdateRequest updateRequest = new UpdateRequest {
                            Target = entity
                        };
                        requestForUpdates.Requests.Add(updateRequest);
                    }


                    ExecuteTransactionResponse responseForUpdates =
                        (ExecuteTransactionResponse)service.Execute(requestForUpdates);
                    Console.WriteLine("Entity records are updated.");

                    Console.WriteLine("Update request failed for the account{0} and the reason being: {1}");
                    #endregion Demonstrate

                    #region Clean up
                    CleanUpSample(service);
                    #endregion Clean up
                }


                else
                {
                    const string UNABLE_TO_LOGIN_ERROR = "Unable to Login to Common Data Service";
                    if (service.LastCrmError.Equals(UNABLE_TO_LOGIN_ERROR))
                    {
                        Console.WriteLine("Check the connection string values in cds/App.config.");
                        throw new Exception(service.LastCrmError);
                    }
                    else
                    {
                        throw service.LastCrmException;
                    }
                }
            }
            catch (Exception ex)
            {
                SampleHelpers.HandleException(ex);
            }

            finally
            {
                if (service != null)
                {
                    service.Dispose();
                }

                Console.WriteLine("Press <Enter> to exit.");
                Console.ReadLine();
            }
        }
Ejemplo n.º 15
0
        public static void Main(string[] args)
        {
            try
            {
                ConnectToMSCRM("*****@*****.**", "Qwerty@123", "https://rbhyd123.crm8.dynamics.com/XRMServices/2011/Organization.svc");
                Guid userid = ((WhoAmIResponse)_service.Execute(new WhoAmIRequest())).UserId;
                if (userid != Guid.Empty)
                {
                    Console.WriteLine("Connection Established Successfully");
                }
                Console.ReadLine();
                Entity order = new Entity("salesorder");
                order["name"] = "Sales Order 2 Created";
                Console.WriteLine("name  is initialised in order");
                Console.ReadLine();
                Entity invoice = new Entity("invoice");
                invoice["name"] = "Invoice 2 Created";
                Console.WriteLine("name is initialised in Invoice");
                Console.ReadLine();
                Entity email = new Entity("email");
                email["subject"] = "Email 2 Created";
                Console.WriteLine("name is initialised in email");
                Console.ReadLine();
                //2. Pass the objects to the Target of each request
                CreateRequest createOrderRequest = new CreateRequest
                {
                    Target = order
                };
                CreateRequest createInvoiceRequest = new CreateRequest
                {
                    Target = invoice
                };
                CreateRequest createEmailRequest = new CreateRequest
                {
                    Target = email
                };
                //3. Instantiate the ExecuteTransactionRequest object and pass each request. Note that the transaction will execute the requests in the order that they are added. Also note that I have created a plugin which will force the Invoice to fail during creation, so we can see what happens with the entire transaction.
                ExecuteTransactionRequest transactionRequest = new ExecuteTransactionRequest
                {
                    // Pass independent operations
                    Requests = new OrganizationRequestCollection
                    {
                        createOrderRequest,
                        createInvoiceRequest, // we have forced this request to fail
                        createEmailRequest
                    },
                };
                //4.Pass the request to the Execute method.


                ExecuteTransactionResponse transactResponse =
                    (ExecuteTransactionResponse)_service.Execute(transactionRequest);
                Console.WriteLine("Service.Execute is called");
                Console.ReadLine();
            }

            catch (Exception ex)
            {
                Console.WriteLine("Exception:" + ex.Message);
                Console.ReadLine();
            }
        }
Ejemplo n.º 16
0
 public bool UpdateTransaction(int id, string errorMessage = null, string errorCode = null, ExecuteTransactionResponse transactionResponse = null)
 {
     using (OracleConnection connection = new OracleConnection(m_connectionString))
     {
         try
         {
             connection.Open();
             m_updateCmd.TblName = "TBL_GOODIES_ZAHAL_1272";
             m_updateCmd.AddIntKeyVal("ID", id);
             if (errorCode == null && errorMessage == null)
             {
                 m_updateCmd.AddIntVal("STATUS", 1);
                 m_updateCmd.AddTextVal("BALANCE", transactionResponse.Balance);
                 m_updateCmd.AddTextVal("ORDERID", transactionResponse.orderId);
             }
             else
             {
                 m_updateCmd.AddIntVal("STATUS", 2);
                 m_updateCmd.AddTextVal("ERROR_MESSAGE", errorMessage);
                 m_updateCmd.AddTextVal("ERROR_CODE", errorCode);
             }
             using (OracleCommand command = new OracleCommand(m_updateCmd.GetCmd(), connection))
             {
                 command.CommandTimeout = 5000;
                 int result = command.ExecuteNonQuery();
                 if (result > 0)
                 {
                     return(true);
                 }
             }
         }
         catch (Exception ex)
         {
             //log.Error($"Exception when try to update seler status, error message: {ex.Message}");
             return(false);
         }
         finally
         {
             connection.Close();
         }
     }
     return(false);
 }