private static Task ExecuteBatchRequest() { return(Task.Run(() => { CustomersContext context = new CustomersContext(new Uri(serviceUrl)); context.Format.UseJson(); IList <Customer> customers = context.Customers.ToList(); Customer customerToAdd = new Customer { Id = 5, Name = "New Customer" }; Customer customerToUpdate = customers.Skip(1).First(); Customer customerToDelete = customers.Skip(2).First(); context.AddToCustomers(customerToAdd); customerToUpdate.Name = "Peter"; context.UpdateObject(customerToUpdate); context.DeleteObject(customerToDelete); DataServiceResponse response = context.SaveChanges(SaveChangesOptions.BatchWithSingleChangeset | SaveChangesOptions.ReplaceOnUpdate); if (!response.IsBatchResponse) { Console.WriteLine("There was an error with the batch request"); } int i = 0; foreach (OperationResponse individualResponse in response) { Console.WriteLine("Operation {0} status code = {1}", i++, individualResponse.StatusCode); } })); }
public async Task TestRandomEntityTypesAsync <T>(string entitySetName) { // clear respository await this.ClearRepositoryAsync(entitySetName); // TODO: Get ride of random generator in test codes. It's bad idea to introduce random factors in functional test var rand = new Random(RandomSeedGenerator.GetRandomSeed()); T entityBaseline = await PostNewEntityAsync <T>(entitySetName, rand); T entityBeforeUpdate = await ReadFirstEntityAsync <T>(entitySetName); AssertExtension.PrimitiveEqual(entityBaseline, entityBeforeUpdate); DataServiceResponse responseUpdate = await UpdateEntityAsync <T>(entitySetName, entityBeforeUpdate, rand); T entityAfterUpdate = await ReadFirstEntityAsync <T>(entitySetName); AssertExtension.PrimitiveEqual(entityBeforeUpdate, entityAfterUpdate); DataServiceResponse responseDelete = await DeleteEntityAsync <T>(entitySetName, entityAfterUpdate); T[] entities = await ReadAllEntitiesAsync <T>(entitySetName); Assert.Empty(entities); }
private void SaveCallback(IAsyncResult asyncResult) { DataServiceResponse response = null; try { response = context.EndSaveChanges(asyncResult); } catch (Exception ex) { gridControl1.BeginInvoke((MethodInvoker) delegate { context.CancelRequest(asyncResult); }); HandleException(ex); gridControl1.BeginInvoke((MethodInvoker) delegate { DetachFailedEntities(); }); } gridControl1.BeginInvoke((MethodInvoker) delegate { wSMS.Reload(); }); gridControl1.BeginInvoke((MethodInvoker) delegate { if (SelectedRow > 0) { gridView1.FocusedRowHandle = SelectedRow; } if (!String.IsNullOrEmpty(newCustomerKey) && gridView1.DataRowCount > OldRowCount) { for (int i = 0; i < gridView1.DataRowCount; i++) { if (newCustomerKey == gridView1.GetRowCellValue(i, gridView1.Columns["CustomerID"]).ToString()) { gridView1.FocusedRowHandle = i; OldRowCount = gridView1.DataRowCount; newCustomerKey = String.Empty; break; } } } }); }
public void SendsIndividualErrorWhenOneOfTheRequestsFails() { Uri serviceUrl = new Uri(BaseAddress + "/DefaultBatch"); DefaultBatchProxy.Container client = new DefaultBatchProxy.Container(serviceUrl); client.Format.UseJson(); DefaultBatchProxy.DefaultBatchCustomer validCustomer = new DefaultBatchProxy.DefaultBatchCustomer() { Id = 10, Name = "Customer 10" }; DefaultBatchProxy.DefaultBatchCustomer invalidCustomer = new DefaultBatchProxy.DefaultBatchCustomer() { Id = -1, Name = "Customer -1" }; client.AddToDefaultBatchCustomer(validCustomer); client.AddToDefaultBatchCustomer(invalidCustomer); var aggregate = Assert.Throws <AggregateException>(() => { DataServiceResponse response = client.SaveChangesAsync(SaveChangesOptions.BatchWithSingleChangeset).Result; }); var exception = aggregate.InnerExceptions.Single() as DataServiceRequestException; Assert.NotNull(exception); Assert.Equal(200, exception.Response.BatchStatusCode); Assert.Equal(1, exception.Response.Count()); }
private static void QueryEntityInstance(DataServiceContextWrapper <DefaultContainer> contextWrapper) { // contextWrapper.Context.UndeclaredPropertyBehavior = UndeclaredPropertyBehavior.Support; contextWrapper.Configurations.ResponsePipeline .OnEntryEnded(PipelineEventsTestsHelper.AddRemovePropertySpecialEmployeeEntry_Reading) .OnEntityMaterialized(PipelineEventsTestsHelper.AddEnumPropertySpecialEmployeeEntity_Materialized) .OnEntityMaterialized(PipelineEventsTestsHelper.ModifyPropertyValueCustomerEntity_Materialized); var specialEmployee = contextWrapper.CreateQuery <Person>("Person").Where(p => p.PersonId == -10).Single() as SpecialEmployee; EntityDescriptor descriptor = contextWrapper.GetEntityDescriptor(specialEmployee); Assert.AreEqual("AddRemovePropertySpecialEmployeeEntry_Reading", specialEmployee.CarsLicensePlate, "Unexpected CarsLicensePlate"); Assert.AreEqual(1, specialEmployee.BonusLevel, "Unexpected BonusLevel"); specialEmployee = contextWrapper.Execute <SpecialEmployee>(new Uri("Person(-10)", UriKind.Relative)).Single(); Assert.AreEqual("AddRemovePropertySpecialEmployeeEntry_Reading", specialEmployee.CarsLicensePlate, "Unexpected CarsLicensePlate"); Assert.AreEqual(1, specialEmployee.BonusLevel, "Unexpected BonusLevel"); DataServiceRequest[] requests = new DataServiceRequest[] { contextWrapper.CreateQuery <Person>("Person"), contextWrapper.CreateQuery <Customer>("Customer"), }; DataServiceResponse responses = contextWrapper.ExecuteBatch(requests); bool personVerified = false; bool customerVerified = false; foreach (QueryOperationResponse response in responses) { foreach (object p in response) { var specialEmployee1 = p as SpecialEmployee; Customer c = p as Customer; if (specialEmployee1 != null) { Assert.AreEqual("AddRemovePropertySpecialEmployeeEntry_Reading", specialEmployee1.CarsLicensePlate, "Unexpected CarsLicensePlate"); Assert.AreEqual(1, specialEmployee1.BonusLevel, "Unexpected BonusLevel"); personVerified = true; } if (c != null) { Assert.IsTrue(c.Name.EndsWith("ModifyPropertyValueCustomerEntity_Materialized"), "Unexpected primitive property"); Assert.IsTrue(c.Auditing.ModifiedBy.Equals("ModifyPropertyValueCustomerEntity_Materialized"), "Unexpected complex property"); Assert.IsTrue(c.PrimaryContactInfo.EmailBag.Contains("ModifyPropertyValueCustomerEntity_Materialized"), "Unexpected collection property"); customerVerified = true; } } } Assert.IsTrue(personVerified && customerVerified, "Some inner request does not completed correctly"); }
public async Task SingletonQueryInBatchTest() { var serviceRoot = this.BaseAddress + "/clientTest/"; var ClientContext = new Client.Container(new Uri(serviceRoot)); // Reset data source await ClientContext.ExecuteAsync(new Uri(serviceRoot + "Umbrella/Microsoft.Test.E2E.AspNet.OData.Singleton.ResetDataSource"), "POST"); await ClientContext.ExecuteAsync(new Uri(serviceRoot + "Partners/Microsoft.Test.E2E.AspNet.OData.Singleton.ResetDataSource"), "POST"); DataServiceRequest[] requests = new DataServiceRequest[] { ClientContext.CreateSingletonQuery <Client.Company>("Umbrella"), ClientContext.CreateQuery <Client.Partner>("Partners") }; DataServiceResponse responses = await ClientContext.ExecuteBatchAsync(requests); foreach (var response in responses) { var companyResponse = response as QueryOperationResponse <Client.Company>; var partnerResponse = response as QueryOperationResponse <Client.Partner>; if (companyResponse != null) { Assert.Equal("Umbrella", companyResponse.Single().Name); } if (partnerResponse != null) { Assert.Equal(10, partnerResponse.ToArray().Count()); } } }
public bool SaveBizRuleCertMetadata(BizRuleCertMetadata bizRuleCertMetadata) { this.tableClient = account.CreateCloudTableClient(); this.tableClient.CreateTableIfNotExist(BizRuleCertTableName); this.tableContext = tableClient.GetDataServiceContext(); bizRuleCertMetadata.PartitionKey = bizRuleCertMetadata.TradingPartnerName; bizRuleCertMetadata.RowKey = bizRuleCertMetadata.RuleCertFileName; bizRuleCertMetadata.Timestamp = DateTime.UtcNow; if (BizRuleCerts.FirstOrDefault(t => t.PartitionKey == bizRuleCertMetadata.PartitionKey && t.RowKey == bizRuleCertMetadata.RowKey) == null) { BizRuleCerts.Add(bizRuleCertMetadata); } // We need upsert functionality here, hence removing AddObject call and adding UpdateObject // this.tableContext.AddObject(TradingPartnerSpecCertTableName, tradingPartnerSpecCert); // http://social.msdn.microsoft.com/Forums/windowsazure/en-US/892340f1-bfe1-4433-9246-b617abe6078c/upsert-operation-in-the-table // http://msdn.microsoft.com/en-us/library/windowsazure/hh452242.aspx // http://www.windowsazure.com/en-us/develop/net/how-to-guides/table-services/#replace-entity tableContext.AttachTo(BizRuleCertTableName, bizRuleCertMetadata); tableContext.UpdateObject(bizRuleCertMetadata); DataServiceResponse response = this.tableContext.SaveChangesWithRetries(SaveChangesOptions.Batch | SaveChangesOptions.ReplaceOnUpdate); return(response.BatchStatusCode == Http200 || response.BatchStatusCode == Http201 || response.BatchStatusCode == Http202); }
public void QueryEntityInstanceBatchAsync() { this.RunOnAtomAndJsonFormats( this.CreateContext, (contextWrapper) => { contextWrapper.Context.IgnoreMissingProperties = true; contextWrapper.Configurations.ResponsePipeline .OnEntryEnded(PipelineEventsTestsHelper.AddRemovePropertySpecialEmployeeEntry_Reading) .OnEntityMaterialized(PipelineEventsTestsHelper.AddEnumPropertySpecialEmployeeEntity_Materialized) .OnEntityMaterialized(PipelineEventsTestsHelper.ModifyPropertyValueCustomerEntity_Materialized); DataServiceRequest[] requests = new DataServiceRequest[] { contextWrapper.CreateQuery <Person>("Person(-10)"), contextWrapper.CreateQuery <Customer>("Customer"), }; DataServiceResponse responses = null; IAsyncResult r = contextWrapper.BeginExecuteBatch( result => { responses = contextWrapper.EndExecuteBatch(result); }, null, requests); while (!r.IsCompleted) { Thread.Sleep(1000); } bool personVerified = false; bool customerVerified = false; foreach (QueryOperationResponse response in responses) { foreach (object p in response) { SpecialEmployee se1 = p as SpecialEmployee; Customer c = p as Customer; if (se1 != null) { Assert.AreEqual("AddRemovePropertySpecialEmployeeEntry_Reading", se1.CarsLicensePlate, "Unexpected CarsLicensePlate"); Assert.AreEqual(1, se1.BonusLevel, "Unexpected BonusLevel"); personVerified = true; } if (c != null) { Assert.IsTrue(c.Name.EndsWith("ModifyPropertyValueCustomerEntity_Materialized"), "Unexpected primitive property"); Assert.IsTrue(c.Auditing.ModifiedBy.Equals("ModifyPropertyValueCustomerEntity_Materialized"), "Unexpected complex property"); Assert.IsTrue(c.PrimaryContactInfo.EmailBag.Contains("ModifyPropertyValueCustomerEntity_Materialized"), "Unexpected collection property"); customerVerified = true; } } } Assert.IsTrue(personVerified && customerVerified, "Some inner request does not completed correctly"); }); }
public async Task <IActionResult> CreateEstablishment([FromBody] ViewModels.AdoxioEstablishment item) { // create a new establishment. var adoxioEstablishment = new Adoxio_establishment(); // create a DataServiceCollection to add the record var EstablishmentCollection = new DataServiceCollection <Adoxio_establishment>(_system); EstablishmentCollection.Add(adoxioEstablishment); adoxioEstablishment.CopyValues(item); // PostOnlySetProperties is used so that settings such as owner will get set properly by the dynamics server. DataServiceResponse dsr = await _system.SaveChangesAsync(SaveChangesOptions.PostOnlySetProperties | SaveChangesOptions.BatchWithIndependentOperations); foreach (OperationResponse operationResult in dsr) { if (operationResult.StatusCode == 500) // error { return(StatusCode(500, operationResult.Error.Message)); } } ViewModels.AdoxioEstablishment result = adoxioEstablishment.ToViewModel(); result.id = ((Guid)dsr.GetAssignedId()).ToString(); return(Json(result)); }
/// <summary> /// Return the ID assigned by dynamics, or NULL if none. /// </summary> /// <param name="dsr"></param> /// <returns></returns> public static Guid?GetAssignedId(this DataServiceResponse dsr) { Guid?result = null; if (dsr != null) { var ienum = dsr.GetEnumerator(); while (ienum.MoveNext()) { ChangeOperationResponse cor = (ChangeOperationResponse)ienum.Current; if (cor.Descriptor is EntityDescriptor) { EntityDescriptor ed = (EntityDescriptor)cor.Descriptor; string identity = ed.Identity.ToString(); // convert the identity to a guid. int endpos = identity.LastIndexOf(")"); int startpos = identity.LastIndexOf("(") + 1; string guid = identity.Substring(startpos, endpos - startpos); result = Guid.ParseExact(guid, "D"); return(result); } } } return(result); }
public static void AddCustomAddress(String[] wkLine, Resources context) { string str1 = wkLine[0]; //Order No string str2 = wkLine[1]; //Advanced Payment ID string str3 = wkLine[2]; //Submit Date string str4 = wkLine[3]; //Payment Date string str5 = wkLine[4]; //Payment Time string str6 = wkLine[5]; //Total Amount string str7 = wkLine[6]; //Redac Division string str8 = wkLine[7]; //Parent Redac Division string str9 = wkLine[8]; //Tenant Name string str10 = wkLine[9]; //Company Name string str11 = wkLine[10]; //Street string str12 = wkLine[11]; //Street2 string str13 = wkLine[12]; //Street3 string str14 = wkLine[13]; //City string str15 = wkLine[14]; //US State string str16 = wkLine[15]; //ZIP/Postal code string str17 = wkLine[16]; //Country string str18 = wkLine[17]; //Main Phone string str19 = wkLine[18]; //Fax string str20 = wkLine[19]; //Email string str21 = wkLine[20]; //Purpose string str22 = wkLine[21]; //Amount string str23 = wkLine[22]; //Advance/Expense string str24 = wkLine[23]; //Payable to string str25 = wkLine[24]; //Payment Method string str26 = wkLine[25]; //Company ID string str27 = wkLine[26]; //Type string str28 = wkLine[27]; //CustomerGroup Console.WriteLine("account id : {0}", str26); DataServiceCollection <CustomerPostalAddress> customersCollection = new DataServiceCollection <CustomerPostalAddress>(context); CustomerPostalAddress myCustomer = new CustomerPostalAddress(); customersCollection.Add(myCustomer); myCustomer.CustomerAccountNumber = str26.Replace(",", ""); myCustomer.CustomerLegalEntityId = ConfigurationManager.AppSettings["RedacCompany"]; myCustomer.AddressLocationRoles = "Business"; myCustomer.AddressDescription = str2; myCustomer.AddressStreet = str11 + " " + str12 + " " + str13; myCustomer.AddressCity = str14; myCustomer.AddressState = ConfigurationManager.AppSettings[str15]; myCustomer.AddressZipCode = str16; myCustomer.AddressCountryRegionId = str17.Length > 0 ? ConfigurationManager.AppSettings[str17] : "USA"; myCustomer.IsPrimary = NoYes.No; DataServiceResponse response = null; try { response = context.SaveChanges(SaveChangesOptions.PostOnlySetProperties | SaveChangesOptions.BatchWithSingleChangeset); Console.WriteLine("added ok"); } catch (Exception ex) { Console.WriteLine(ex.Message + ex.InnerException); } }
public async Task <IActionResult> DeleteEstablishment(string id) { // get the establishment. Guid adoxio_establishmetid = new Guid(id); try { Adoxio_establishment adoxioLegalEntity = await _system.Adoxio_establishments.ByKey(adoxio_establishmetid).GetValueAsync(); _system.DeleteObject(adoxioLegalEntity); DataServiceResponse dsr = await _system.SaveChangesAsync(); foreach (OperationResponse result in dsr) { if (result.StatusCode == 500) // error { return(StatusCode(500, result.Error.Message)); } } } catch (Microsoft.OData.Client.DataServiceQueryException dsqe) { return(new NotFoundResult()); } return(NoContent()); // 204 }
private void StartConfirmation() { CancelButton.Enabled = false; ConfirmButton.Enabled = false; //open a progress alert ProgressAlert = UIAlertController.Create("Confirm Appointment", "Confirming appointment please wait...", UIAlertControllerStyle.Alert); PresentViewController(ProgressAlert, true, null); Task.Run(async() => { DataServiceResponse <ConfirmationResponse> response = await ConfirmAppointmentAsync(); if (response == null) { ShowError(response); } else { if (response.Success) { //refresh appointment data ApplicationData.Current.GetClientAppointments(); //success ShowSuccess(response); } else { //error ShowError(response); } } }); }
/// <summary> /// Verifies the data service response. /// </summary> /// <param name="responseData">The expected data for the response.</param> /// <param name="response">The response to verify.</param> /// <param name="cachedOperationsFromResponse">The individual operation responses, pre-enumerated and cached</param> /// <exception cref="TaupoNotSupportedException"> /// When exception is expected in the response data /// </exception> public void VerifyDataServiceResponse(DataServiceResponseData responseData, DataServiceResponse response, IList<OperationResponse> cachedOperationsFromResponse) { ExceptionUtilities.CheckArgumentNotNull(responseData, "responseData"); ExceptionUtilities.CheckArgumentNotNull(response, "response"); ExceptionUtilities.CheckArgumentNotNull(cachedOperationsFromResponse, "cachedOperationsFromResponse"); ExceptionUtilities.CheckAllRequiredDependencies(this); this.Assert.AreEqual(responseData.IsBatchResponse, response.IsBatchResponse, "Verifying if it's a batch response."); this.Assert.AreEqual(responseData.BatchStatusCode, response.BatchStatusCode, "Verifying batch status code."); //// No batch headers verification //// Note: verifying order of operation responses as well as the content. this.Assert.AreEqual(responseData.Count, cachedOperationsFromResponse.Count, "Unexpected number of operation responses in data service response"); for (int responseOrder = 0; responseOrder < responseData.Count; responseOrder++) { var operationResponseData = responseData[responseOrder]; var currentResponse = cachedOperationsFromResponse[responseOrder]; ChangeOperationResponseData changeResponseData = operationResponseData as ChangeOperationResponseData; if (changeResponseData != null) { ChangeOperationResponse changeResponse = currentResponse as ChangeOperationResponse; this.Assert.IsNotNull(changeResponse, GetVerificationFailureMessage(responseOrder, "Unexpected type of the operation response.\r\nExpected: {0}\r\nActual: {1}", typeof(ChangeOperationResponse).FullName, currentResponse)); this.VerifyChangeOperationResponse(changeResponseData, changeResponse, responseOrder); } else { throw new TaupoNotSupportedException( GetVerificationFailureMessage(responseOrder, "Verification for the operation response data of type '{0}' is not supported by this verifier.", operationResponseData.GetType().FullName)); } } }
async static Task CreateCustomer(string name, Guid?label = null) { Console.WriteLine($"Create a new Customer: name={name}"); Container context = GetContext(); Customer newCustomer = new Customer { Name = name, Label = label ?? Guid.Empty }; context.AddToCustomers(newCustomer); DataServiceResponse responses = await context.SaveChangesAsync(); foreach (var response in responses) { Console.WriteLine($" StatusCode={response.StatusCode}"); } Console.WriteLine(); // List Customers await ListCustomers(); }
private async Task <DataServiceResponse <ConfirmationResponse> > ConfirmAppointmentAsync() { ScheduleDataSource ds = new ScheduleDataSource(); Appointment a = ApplicationData.Current.NewAppointment; ConfirmationRequest request = new ConfirmationRequest() { AppointmentType = a.AppointmentType.Value, AppointmentReason = a.AppointmentSubType.Value, AppointmentSource = Appointment.MOBILE_APP_SOURCE, AdvisorEmailAddress = a.AdvisorEmail, AppointmentLanguage = a.AppointmentLanguage, BranchNumber = a.BranchNumber, ClientNumber = ApplicationData.Current.Client.CustomerNumber, SendEmailConfirmation = true, StartTimeUtc = a.StartDate.ToUniversalTime().ToString("o"), EndTimeUtc = a.EndDate.ToUniversalTime().ToString("o"), IncludeIcsFile = true, UiLanguageCode = 1033, PreferredDateUtc = a.StartDate.Date, AdvisorComments = string.Empty, ClientComments = string.Empty }; DataServiceResponse <ConfirmationResponse> response = await ds.ConfirmAppointmentAsync(request); return(response); }
public bool SaveSuspendedMessage(IFatpipeMessage message) { string location = "FpmDal->SaveSuspendedMessage"; bool result = true; SuspendedMessageEntity suspendedMessage = null; //TODO remove the return statement // don't want any message to be suspended return(true); try { Stopwatch watch = Stopwatch.StartNew(); suspendedMessage = new SuspendedMessageEntity(message.Header.TenantIdentifier, message.Header.Identifier); suspendedMessage.Timestamp = DateTime.UtcNow; suspendedMessage.SuspendedMessageBlobReference = message.Header.Identifier; if (message.Status != null) { suspendedMessage.ErrorMessage = string.Format(CultureInfo.InvariantCulture, "{0}. Message suspended after {1} retries. Error: {2}", message.Status.ProcessingResult, message.Status.NumberOfRetryAttempts, message.Status.ErrorDescription); } IOutboundFatpipeMessage outboundMessage = message as IOutboundFatpipeMessage; if (outboundMessage != null) { if (outboundMessage.RoutingInfo != null) { suspendedMessage.PartnerIdentifier = outboundMessage.RoutingInfo.PartnerId; } } this.suspendedTableServiceContext.AddObject(MaargConfiguration.Instance[MaargConfiguration.SuspendedMessageTableName], suspendedMessage); //save to suspended table and blob DataServiceResponse response = this.suspendedTableServiceContext.SaveChangesWithRetries(); // The entry in the Q is the message blob name using (Stream stream = BizpipeMesssageStreaming.WriteBizpipeMessageToStream(message)) { CloudBlob blob = this.suspendedContainer.GetBlobReference(suspendedMessage.SuspendedMessageBlobReference); blob.UploadFromStream(stream); } watch.Stop(); LoggerFactory.Logger.Debug(location, "Message {0} saved to suspended queue in {1} ms.", message.Header.Identifier, watch.ElapsedMilliseconds); } catch (Exception exception) { LoggerFactory.Logger.Error(location, EventId.BizpipeSaveSuspendMessage , "Exception encountered during suspended message operation: {0}." , exception.ToString()); result = false; } return(result); }
protected override void UpdateDataObject(object dataContext, object table, object oldDataObject, object newDataObject) { var dataServiceContext = (DataServiceContext)dataContext; var idataServiceContext = dataContext as IDataServiceContext; string etag = null; if (this._etagMap != null && this._etagMap.TryGetValue(DataServiceUtilities.BuildCompositeKey(oldDataObject), out etag)) { if (idataServiceContext != null) { idataServiceContext.AttachTo(TableName, newDataObject, etag); } else { dataServiceContext.AttachTo(TableName, newDataObject, etag); } } else { if (idataServiceContext != null) { idataServiceContext.AttachTo(TableName, newDataObject); } else { dataServiceContext.AttachTo(TableName, newDataObject); } } ProcessForeignKeys(dataServiceContext, newDataObject, _values); dataServiceContext.UpdateObject(newDataObject); DataServiceResponse dataServiceResponse = dataServiceContext.SaveChanges(); }
public static void saveSurvey(Output output) { var outputWcf = new DbServices.Output { }; try { db.AddToTableOutput(outputWcf); DataServiceResponse response = db.SaveChanges(); foreach (ChangeOperationResponse change in response) { EntityDescriptor descriptor = change.Descriptor as EntityDescriptor; if (descriptor != null) { DbServices.Output added = descriptor.Entity as DbServices.Output; if (added != null) { Console.WriteLine("Ankieta została zapisana"); } } } } catch (DataServiceRequestException ex) { throw new ApplicationException( "Wystąpił błąd podczas zapisu.", ex); } }
public virtual void SendsIndividualErrorWhenOneOfTheRequestsFails() { Uri serviceUrl = new Uri(BaseAddress + "/DefaultBatch"); Default.Container client = new Default.Container(serviceUrl); client.Format.UseJson(); Default.DefaultBatchCustomer validCustomer = new Default.DefaultBatchCustomer() { Id = 10, Name = "Customer 10" }; Default.DefaultBatchCustomer invalidCustomer = new Default.DefaultBatchCustomer() { Id = -1, Name = "Customer -1" }; client.AddToDefaultBatchCustomer(validCustomer); client.AddToDefaultBatchCustomer(invalidCustomer); DataServiceRequestException exception = Assert.Throws <DataServiceRequestException>(() => { DataServiceResponse response = client.SaveChanges(SaveChangesOptions.Batch); }); Assert.Equal(202, exception.Response.BatchStatusCode); Assert.Equal(1, exception.Response.Count()); }
public async Task <IActionResult> UpdateEstablishment([FromBody] ViewModels.AdoxioEstablishment item, string id) { if (id != item.id) { return(BadRequest()); } // get the establishment. Guid adoxio_establishmetid = new Guid(id); DataServiceCollection <Interfaces.Microsoft.Dynamics.CRM.Adoxio_establishment> AccountCollection = new DataServiceCollection <Interfaces.Microsoft.Dynamics.CRM.Adoxio_establishment>(_system); Adoxio_establishment adoxioEstablishment = await _system.Adoxio_establishments.ByKey(adoxio_establishmetid).GetValueAsync(); _system.UpdateObject(adoxioEstablishment); // copy values over from the data provided adoxioEstablishment.CopyValues(item); // PostOnlySetProperties is used so that settings such as owner will get set properly by the dynamics server. DataServiceResponse dsr = await _system.SaveChangesAsync(SaveChangesOptions.PostOnlySetProperties | SaveChangesOptions.BatchWithIndependentOperations); foreach (OperationResponse result in dsr) { if (result.StatusCode == 500) // error { return(StatusCode(500, result.Error.Message)); } } return(Json(adoxioEstablishment.ToViewModel())); }
public Item AddItem(string prefix = "TEST") { Item item = CreateItem(GetNextValueItemCode(prefix), prefix); try { serviceContainer.AddToItems(item); DataServiceResponse response = serviceContainer.SaveChanges(); if (response != null) { ChangeOperationResponse opRes = (ChangeOperationResponse)response.SingleOrDefault(); object retItem = ((System.Data.Services.Client.EntityDescriptor)(opRes.Descriptor)).Entity; if (retItem != null) { return((Item)retItem); } } } catch (Exception ex) { serviceContainer.Detach(item); throw ex; } return(null); }
public IList GetBatchObjects(string entityName, CriteriaOperator filter, Dictionary <string, string> properties) { DataServiceQuery query = CreateObjectQuery(entityName, filter, properties); DataServiceRequest[] batchRequests = new DataServiceRequest[] { query }; DataServiceResponse batchResponse = ServiceContext.ExecuteBatch(batchRequests); IList list = null; foreach (QueryOperationResponse response in batchResponse) { // Handle an error response. if (response.StatusCode > 299 || response.StatusCode < 200) { Console.WriteLine("An error occurred."); Console.WriteLine(response.Error.Message); } else { foreach (var item in response) { if (list == null) { var listType = typeof(List <>).MakeGenericType(item.GetType()); list = Activator.CreateInstance(listType) as IList; } list.Add(item); } } } return(list); }
/// <summary> /// Verifies the data service response. /// </summary> /// <param name="responseData">The expected data for the response.</param> /// <param name="response">The response to verify.</param> /// <param name="cachedOperationsFromResponse">The individual operation responses, pre-enumerated and cached</param> /// <exception cref="TaupoNotSupportedException"> /// When exception is expected in the response data /// </exception> public void VerifyDataServiceResponse(DataServiceResponseData responseData, DataServiceResponse response, IList <OperationResponse> cachedOperationsFromResponse) { ExceptionUtilities.CheckArgumentNotNull(responseData, "responseData"); ExceptionUtilities.CheckArgumentNotNull(response, "response"); ExceptionUtilities.CheckArgumentNotNull(cachedOperationsFromResponse, "cachedOperationsFromResponse"); ExceptionUtilities.CheckAllRequiredDependencies(this); this.Assert.AreEqual(responseData.IsBatchResponse, response.IsBatchResponse, "Verifying if it's a batch response."); this.Assert.AreEqual(responseData.BatchStatusCode, response.BatchStatusCode, "Verifying batch status code."); //// No batch headers verification //// Note: verifying order of operation responses as well as the content. this.Assert.AreEqual(responseData.Count, cachedOperationsFromResponse.Count, "Unexpected number of operation responses in data service response"); for (int responseOrder = 0; responseOrder < responseData.Count; responseOrder++) { var operationResponseData = responseData[responseOrder]; var currentResponse = cachedOperationsFromResponse[responseOrder]; ChangeOperationResponseData changeResponseData = operationResponseData as ChangeOperationResponseData; if (changeResponseData != null) { ChangeOperationResponse changeResponse = currentResponse as ChangeOperationResponse; this.Assert.IsNotNull(changeResponse, GetVerificationFailureMessage(responseOrder, "Unexpected type of the operation response.\r\nExpected: {0}\r\nActual: {1}", typeof(ChangeOperationResponse).FullName, currentResponse)); this.VerifyChangeOperationResponse(changeResponseData, changeResponse, responseOrder); } else { throw new TaupoNotSupportedException( GetVerificationFailureMessage(responseOrder, "Verification for the operation response data of type '{0}' is not supported by this verifier.", operationResponseData.GetType().FullName)); } } }
public void BatchInsertTask() { CloudTableClient tableClient = GenerateCloudTableClient(); TableServiceContext ctx = tableClient.GetTableServiceContext(); // Insert Entities SortedDictionary <string, ComplexEntity> entities = new SortedDictionary <string, ComplexEntity>(); for (int i = 0; i < 100; i++) { ComplexEntity insertEntity = new ComplexEntity("insert test", "foo" + i); entities.Add(insertEntity.RowKey, insertEntity); ctx.AddObject(currentTable.Name, insertEntity); } DataServiceResponse response = ctx.SaveChangesWithRetriesAsync(SaveChangesOptions.Batch).Result; Assert.AreEqual((int)HttpStatusCode.Accepted, response.BatchStatusCode); // Retrieve Entities List <ComplexEntity> retrievedEntities = (from ent in ctx.CreateQuery <ComplexEntity>(currentTable.Name) where ent.PartitionKey == entities.First().Value.PartitionKey select ent).AsTableServiceQuery(ctx).Execute().ToList(); Assert.AreEqual(entities.Count, retrievedEntities.Count); foreach (ComplexEntity retrievedEntity in retrievedEntities) { ComplexEntity.AssertEquality(entities[retrievedEntity.RowKey], retrievedEntity); entities.Remove(retrievedEntity.RowKey); } Assert.AreEqual(0, entities.Count); }
public async Task SendsIndividualErrorWhenOneOfTheRequestsFails() { Uri serviceUrl = new Uri(BaseAddress + "/DefaultBatch"); DefaultBatchProxy.Container client = new DefaultBatchProxy.Container(serviceUrl); client.Format.UseJson(); DefaultBatchProxy.DefaultBatchCustomer validCustomer = new DefaultBatchProxy.DefaultBatchCustomer() { Id = 10, Name = "Customer 10" }; DefaultBatchProxy.DefaultBatchCustomer invalidCustomer = new DefaultBatchProxy.DefaultBatchCustomer() { Id = -1, Name = "Customer -1" }; client.AddToDefaultBatchCustomer(validCustomer); client.AddToDefaultBatchCustomer(invalidCustomer); var exception = await Assert.ThrowsAsync <DataServiceRequestException>(async() => { DataServiceResponse response = await client.SaveChangesAsync(SaveChangesOptions.BatchWithSingleChangeset); }); Assert.NotNull(exception); Assert.Equal(200, exception.Response.BatchStatusCode); Assert.Single(exception.Response); }
private static void OnPositionEstimatesSaved(IAsyncResult result) { bool errorOccured = false; radiomapEntities context = result.AsyncState as radiomapEntities; try { // Complete the save changes operation and display the response. DataServiceResponse response = context.EndSaveChanges(result); foreach (ChangeOperationResponse changeResponse in response) { if (changeResponse.Error != null) { errorOccured = true; } } if (!errorOccured) { //Maybe raise success event? } } catch (Exception ex) { Exception exCopy = ex; } }
public async Task CanBatchQueriesWithDataServicesClient() { Uri serviceUrl = new Uri(BaseAddress + "/DefaultBatch"); DefaultBatchProxy.Container client = new DefaultBatchProxy.Container(serviceUrl); client.Format.UseJson(); Uri customersRequestUri = new Uri(BaseAddress + "/DefaultBatch/DefaultBatchCustomer"); DataServiceRequest <DefaultBatchProxy.DefaultBatchCustomer> customersRequest = new DataServiceRequest <DefaultBatchProxy.DefaultBatchCustomer>(customersRequestUri); Uri singleCustomerRequestUri = new Uri(BaseAddress + "/DefaultBatch/DefaultBatchCustomer(0)"); DataServiceRequest <DefaultBatchProxy.DefaultBatchCustomer> singleCustomerRequest = new DataServiceRequest <DefaultBatchProxy.DefaultBatchCustomer>(singleCustomerRequestUri); DataServiceResponse batchResponse = await client.ExecuteBatchAsync(customersRequest, singleCustomerRequest); if (batchResponse.IsBatchResponse) { Assert.Equal(200, batchResponse.BatchStatusCode); } foreach (QueryOperationResponse response in batchResponse) { Assert.Equal(200, response.StatusCode); if (response.Query.RequestUri == customersRequestUri) { // Previous test could modify the total count to be anywhere from, 10 to 14. Assert.InRange(response.Cast <DefaultBatchProxy.DefaultBatchCustomer>().Count(), 10, 14); continue; } if (response.Query.RequestUri == singleCustomerRequestUri) { Assert.Single(response.Cast <DefaultBatchProxy.DefaultBatchCustomer>()); continue; } } }
private void PostTestWorkRespose(IAsyncResult asyncResult) { try { DataServiceContext asynchConnector = asyncResult.AsyncState as DataServiceContext; DataServiceResponse response = asynchConnector.EndSaveChanges(asyncResult); foreach (ChangeOperationResponse changset in response) { if (changset.Error != null) { throw changset.Error; } } SignalUI("TestStatus", "Sent Response"); } catch (Exception exception) { string wrongError = "The context is already tracking a different entity with the same resource Uri."; if (!exception.InnerException.Message.Contains(wrongError)) { SignalUI("TestStatus", "Failed : " + exception.StackTrace.ToString()); SignalUI("TestStatus", "Failed : " + exception.InnerException.StackTrace.ToString()); DataServiceContext dsc = GetServiceContext(); Message response = new Message(); response.ReturnValue = exception.ToString(); response.WhoSentMe = "SL"; dsc.AddObject("Messages", response); dsc.BeginSaveChanges(PostTestWorkRespose, dsc); } } }
public void CanBatchQueriesWithDataServicesClient() { Uri serviceUrl = new Uri(BaseAddress + "/DefaultBatch"); Default.Container client = new Default.Container(serviceUrl); client.Format.UseJson(); Uri customersRequestUri = new Uri(BaseAddress + "/DefaultBatch/DefaultBatchCustomer"); DataServiceRequest <Default.DefaultBatchCustomer> customersRequest = new DataServiceRequest <Default.DefaultBatchCustomer>(customersRequestUri); Uri singleCustomerRequestUri = new Uri(BaseAddress + "/DefaultBatch/DefaultBatchCustomer(0)"); DataServiceRequest <Default.DefaultBatchCustomer> singleCustomerRequest = new DataServiceRequest <Default.DefaultBatchCustomer>(singleCustomerRequestUri); DataServiceResponse batchResponse = client.ExecuteBatch(customersRequest, singleCustomerRequest); if (batchResponse.IsBatchResponse) { Assert.Equal(202, batchResponse.BatchStatusCode); } foreach (QueryOperationResponse response in batchResponse) { Assert.Equal(200, response.StatusCode); if (response.Query.RequestUri == customersRequestUri) { Assert.Equal(10, response.Cast <Default.DefaultBatchCustomer>().Count()); continue; } if (response.Query.RequestUri == singleCustomerRequestUri) { Assert.Equal(1, response.Cast <Default.DefaultBatchCustomer>().Count()); continue; } } }
public void QueryFailureUsingExecuteBatch() { DataServiceRequest <northwindClient.Customers> request = new DataServiceRequest <northwindClient.Customers>(new Uri(ctx.BaseUri.OriginalString + "/Customers('QUICK')")); DataServiceRequest <northwindClient.Customers> request1 = new DataServiceRequest <northwindClient.Customers>(new Uri(ctx.BaseUri.OriginalString + "/Customers('NONEXIST')")); DataServiceResponse response = ctx.ExecuteBatch(request, request1); Utils.IsBatchResponse(response); List <QueryOperationResponse> responses = new List <QueryOperationResponse>(); foreach (QueryOperationResponse queryResponse in response) { responses.Add(queryResponse); } Assert.IsTrue(responses.Count == 2, "expecting 2 responses in batch query"); // first one to succeed Utils.IsSuccessResponse(responses[0], HttpStatusCode.OK); Assert.IsTrue(responses[0].Query == request, "expecting the same request object"); // expecting the second one to fail Utils.IsErrorResponse(responses[1], HttpStatusCode.NotFound, true); Assert.IsTrue(responses[1].Query == request1, "expecting the same request object1"); }
/// <summary> /// Get User details by User Id. /// </summary> /// <param name="userId"> User Id. </param> /// <returns> User details. </returns> public DataServiceResponse<UserDto> GetUserDetailsById(int userId) { var responseUserDto = new DataServiceResponse<UserDto>(); try { responseUserDto.Response = this.userRepository.GetUserById(userId); responseUserDto.Error = null; } catch (NullReferenceException nullReferenceException) { responseUserDto.Response = null; responseUserDto.Error = nullReferenceException; } return responseUserDto; }
/// <summary> /// The add user. /// </summary> /// <param name="user"> The user. </param> /// <returns> The data service response </returns> public DataServiceResponse<int> AddUser(UserDto user) { var responseUserDto = new DataServiceResponse<int>(); try { responseUserDto.Response = this.userRepository.AddUser(user); responseUserDto.Error = null; } catch (NullReferenceException nullReferenceException) { responseUserDto.Response = 0; responseUserDto.Error = nullReferenceException; } return responseUserDto; }
/// <summary> /// process the batch response /// </summary> /// <param name="batchReader">The batch reader to use for reading the batch response.</param> /// <returns>an instance of the DataServiceResponse, containing individual operation responses for this batch request.</returns> /// <remarks> /// The message reader for the entire batch response is stored in the this.batchMessageReader. /// The message reader is disposable, but this method should not dispose it itself. It will be either disposed by the caller (in case of exception) /// or the ownership will be passed to the returned response object (in case of success). /// In could also be diposed indirectly by this method when it enumerates through the responses. /// </remarks> private DataServiceResponse HandleBatchResponseInternal(ODataBatchReader batchReader) { Debug.Assert(this.batchMessageReader != null, "this.batchMessageReader != null"); Debug.Assert(batchReader != null, "batchReader != null"); DataServiceResponse response; HeaderCollection headers = new HeaderCollection(this.batchResponseMessage); IEnumerable<OperationResponse> responses = this.HandleBatchResponse(batchReader); if (this.Queries != null) { // ExecuteBatch, EndExecuteBatch response = new DataServiceResponse( headers, (int)this.batchResponseMessage.StatusCode, responses, true /*batchResponse*/); } else { List<OperationResponse> operationResponses = new List<OperationResponse>(); response = new DataServiceResponse(headers, (int)this.batchResponseMessage.StatusCode, operationResponses, true /*batchResponse*/); Exception exception = null; // SaveChanges, EndSaveChanges // enumerate the entire response foreach (ChangeOperationResponse changeOperationResponse in responses) { operationResponses.Add(changeOperationResponse); if (Util.IsBatchWithSingleChangeset(this.Options) && exception == null && changeOperationResponse.Error != null) { exception = changeOperationResponse.Error; } // Note that this will dispose the enumerator and this release the batch message reader which is owned // by the enumerable of responses by now. } // Note that if we encounter any error in a batch request with a single changeset, // we throw here since all change operations in the changeset are rolled back on the server. // If we encounter any error in a batch request with independent operations, we don't want to throw // since some of the operations might succeed. // Users need to inspect each OperationResponse to get the exception information from the failed operations. if (exception != null) { throw new DataServiceRequestException(Strings.DataServiceException_GeneralError, exception, response); } } return response; }
/// <summary> /// 本方法用以显示 ADO.NET Data Service 返回的详细信息。 /// </summary> /// <param name="response"></param> private void WriteOperationResponse(DataServiceResponse response) { messageTextBlock.Text = string.Empty; int i = 1; if (response.IsBatchResponse) { messageTextBlock.Text = string.Format("批处理返回状态码: {0}\n", response.BatchStatusCode); } foreach (ChangeOperationResponse change in response) { messageTextBlock.Text += string.Format("\t更改 {0} 状态码: {1}\n", i.ToString(), change.StatusCode.ToString()); if (change.Error != null) { string.Format("\t更改 {0} 错误: {1}\n", i.ToString(), change.Error.Message); } i++; } }
/// <summary> /// process the batch response /// </summary> /// <returns>an instance of the DataServiceResponse, containing individual operation responses for this batch request.</returns> private DataServiceResponse HandleBatchResponse() { bool batchMessageReaderOwned = true; try { if ((this.batchResponseMessage == null) || (this.batchResponseMessage.StatusCode == (int)HttpStatusCode.NoContent)) { // we always expect a response to our batch POST request throw Error.InvalidOperation(Strings.Batch_ExpectedResponse(1)); } Func<Stream> getResponseStream = () => this.ResponseStream; // We are not going to use the responseVersion returned from this call, as the $batch request itself doesn't apply versioning // of the responses on the root level. The responses are versioned on the part level. (Note that the version on the $batch level // is actually used to version the batch itself, but we for now we only recognize a single version so to keep it backward compatible // we don't check this here. Also note that the HandleResponse method will verify that we can support the version, that is it's // lower than the highest version we understand). Version responseVersion; BaseSaveResult.HandleResponse( this.RequestInfo, (HttpStatusCode)this.batchResponseMessage.StatusCode, // statusCode this.batchResponseMessage.GetHeader(XmlConstants.HttpODataVersion), // responseVersion getResponseStream, // getResponseStream true, // throwOnFailure out responseVersion); if (this.ResponseStream == null) { Error.ThrowBatchExpectedResponse(InternalError.NullResponseStream); } // Create the message and the message reader. this.batchResponseMessage = new HttpWebResponseMessage(new HeaderCollection(this.batchResponseMessage), this.batchResponseMessage.StatusCode, getResponseStream); ODataMessageReaderSettings messageReaderSettings = this.RequestInfo.GetDeserializationInfo(/*mergeOption*/ null).ReadHelper.CreateSettings(); // No need to pass in any model to the batch reader. this.batchMessageReader = new ODataMessageReader(this.batchResponseMessage, messageReaderSettings); ODataBatchReader batchReader; try { batchReader = this.batchMessageReader.CreateODataBatchReader(); } catch (ODataContentTypeException contentTypeException) { string mime; Encoding encoding; Exception inner = contentTypeException; ContentTypeUtil.ReadContentType(this.batchResponseMessage.GetHeader(XmlConstants.HttpContentType), out mime, out encoding); if (String.Equals(XmlConstants.MimeTextPlain, mime)) { inner = GetResponseText( this.batchResponseMessage.GetStream, (HttpStatusCode)this.batchResponseMessage.StatusCode); } throw Error.InvalidOperation(Strings.Batch_ExpectedContentType(this.batchResponseMessage.GetHeader(XmlConstants.HttpContentType)), inner); } DataServiceResponse response = this.HandleBatchResponseInternal(batchReader); // In case of successful processing of at least the beginning of the batch, the message reader is owned by the returned response // (or rather by the IEnumerable of operation responses inside it). // It will be disposed once the operation responses are enumerated (since the IEnumerator should be disposed once used). // In that case we must NOT dispose it here, since that enumeration can exist long after we return from this method. batchMessageReaderOwned = false; return response; } catch (DataServiceRequestException) { throw; } catch (InvalidOperationException ex) { HeaderCollection headers = new HeaderCollection(this.batchResponseMessage); int statusCode = this.batchResponseMessage == null ? (int)HttpStatusCode.InternalServerError : (int)this.batchResponseMessage.StatusCode; DataServiceResponse response = new DataServiceResponse(headers, statusCode, new OperationResponse[0], this.IsBatchRequest); throw new DataServiceRequestException(Strings.DataServiceException_GeneralError, ex, response); } finally { if (batchMessageReaderOwned) { Util.Dispose(ref this.batchMessageReader); } } }
protected override DataServiceResponse HandleResponse() { List<OperationResponse> list = new List<OperationResponse>((this.cachedResponses != null) ? this.cachedResponses.Count : 0); DataServiceResponse response = new DataServiceResponse(null, -1, list, false); Exception innerException = null; try { foreach (CachedResponse response2 in this.cachedResponses) { Descriptor descriptor = response2.Descriptor; base.SaveResultProcessed(descriptor); OperationResponse item = new ChangeOperationResponse(response2.Headers, descriptor) { StatusCode = (int) response2.StatusCode }; if (response2.Exception != null) { item.Error = response2.Exception; if (innerException == null) { innerException = response2.Exception; } } else { this.cachedResponse = response2; base.HandleOperationResponse(descriptor, response2.Headers); } list.Add(item); } } catch (InvalidOperationException exception2) { innerException = exception2; } if (innerException != null) { throw new DataServiceRequestException(System.Data.Services.Client.Strings.DataServiceException_GeneralError, innerException, response); } return response; }
public MediaDataServiceResponse(DataServiceResponse response) { _response = response; }
public SaveChangesEventArgs(DataServiceResponse response) { this.response = response; }
/// <summary> /// Creates a new instance of DataServiceRequestException. /// </summary> /// <param name="message">error message for this exception.</param> /// <param name="innerException">Exception that caused this exception to be thrown.</param> /// <param name="response">response object for this exception.</param> public DataServiceRequestException(string message, Exception innerException, DataServiceResponse response) : base(message, innerException) { this.response = response; }
private DataServiceResponse HandleBatchResponse() { Func<Stream> func2 = null; Func<Stream> getResponseStream = null; DataServiceResponse response3; bool flag = true; try { Version version; ODataBatchReader reader; if ((base.batchResponse == null) || (base.batchResponse.StatusCode == HttpStatusCode.NoContent)) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Batch_ExpectedResponse(1)); } if (func2 == null) { func2 = () => this.ResponseStream; } Func<Stream> func = func2; BaseSaveResult.HandleResponse(base.RequestInfo, base.batchResponse.StatusCode, base.batchResponse.Headers["DataServiceVersion"], func, true, out version); if (this.ResponseStream == null) { System.Data.Services.Client.Error.ThrowBatchExpectedResponse(InternalError.NullResponseStream); } HttpWebResponseMessage responseMessage = new HttpWebResponseMessage(base.batchResponse, func); ODataMessageReaderSettings settings = WebUtil.CreateODataMessageReaderSettings(base.RequestInfo.GetDeserializationInfo(null), null, false); this.batchMessageReader = new ODataMessageReader(responseMessage, settings); try { reader = this.batchMessageReader.CreateODataBatchReader(); } catch (Exception responseText) { string str; Encoding encoding; HttpProcessUtility.ReadContentType(base.batchResponse.ContentType, out str, out encoding); if (string.Equals("text/plain", str)) { if (getResponseStream == null) { getResponseStream = () => WebUtil.GetResponseStream(base.batchResponse, (DataServiceContext) base.Source); } responseText = BaseSaveResult.GetResponseText(getResponseStream, base.batchResponse.StatusCode); } throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Batch_ExpectedContentType(base.batchResponse.ContentType), responseText); } DataServiceResponse response = this.HandleBatchResponseInternal(reader); flag = false; response3 = response; } catch (DataServiceRequestException) { throw; } catch (InvalidOperationException exception3) { Dictionary<string, string> headers = WebUtil.WrapResponseHeaders(base.batchResponse); int statusCode = (base.batchResponse == null) ? 500 : ((int) base.batchResponse.StatusCode); DataServiceResponse response2 = new DataServiceResponse(headers, statusCode, null, this.IsBatch); throw new DataServiceRequestException(System.Data.Services.Client.Strings.DataServiceException_GeneralError, exception3, response2); } finally { if (flag) { Util.Dispose<ODataMessageReader>(ref this.batchMessageReader); } } return response3; }
private DataServiceResponse HandleBatchResponseInternal(ODataBatchReader batchReader) { Dictionary<string, string> headers = WebUtil.WrapResponseHeaders(base.batchResponse); IEnumerable<OperationResponse> enumerable = this.HandleBatchResponse(batchReader); if (this.Queries != null) { return new DataServiceResponse(headers, (int) base.batchResponse.StatusCode, enumerable, true); } List<OperationResponse> list = new List<OperationResponse>(); DataServiceResponse response = new DataServiceResponse(headers, (int) base.batchResponse.StatusCode, list, true); Exception innerException = null; foreach (ChangeOperationResponse response2 in enumerable) { list.Add(response2); if ((innerException == null) && (response2.Error != null)) { innerException = response2.Error; } } if (innerException != null) { throw new DataServiceRequestException(System.Data.Services.Client.Strings.DataServiceException_GeneralError, innerException, response); } return response; }
/// <summary> /// Handle the response. /// </summary> /// <returns>an instance of the DataServiceResponse, containing individual responses for all the requests made during this SaveChanges call.</returns> protected override DataServiceResponse HandleResponse() { List<OperationResponse> responses = new List<OperationResponse>(this.cachedResponses != null ? this.cachedResponses.Count : 0); DataServiceResponse service = new DataServiceResponse(null, -1, responses, false /*isBatch*/); Exception ex = null; try { foreach (CachedResponse response in this.cachedResponses) { Descriptor descriptor = response.Descriptor; this.SaveResultProcessed(descriptor); OperationResponse operationResponse = new ChangeOperationResponse(response.Headers, descriptor); operationResponse.StatusCode = (int)response.StatusCode; if (response.Exception != null) { operationResponse.Error = response.Exception; if (ex == null) { ex = response.Exception; } } else { this.cachedResponse = response; #if DEBUG this.HandleOperationResponse(descriptor, response.Headers, response.StatusCode); #else this.HandleOperationResponse(descriptor, response.Headers); #endif } responses.Add(operationResponse); } } catch (InvalidOperationException e) { ex = e; } if (ex != null) { throw new DataServiceRequestException(Strings.DataServiceException_GeneralError, ex, service); } return service; }
private DataServiceResponse ParseDataServiceResponse(DataServiceResponse resp, RequestResult reqResult, TableCommand<DataServiceResponse, DataServiceResponse> cmd) { if (reqResult.Exception != null) { throw reqResult.Exception; } return resp; }
/// <summary> /// Extracts the replica session key header from the serviceResponse. /// </summary> /// <param name="response">Data service serviceResponse (query or changeResponse).</param> public void ProcessResponseHeader(DataServiceResponse response) { foreach (ChangeOperationResponse change in response) { ProcessResponseHeader(change); } }