public IHttpActionResult Patch([FromODataUri] string key, Delta <CODE_PROVANDCITYEntity> patch)
        {
            CODE_PROVANDCITYService service = new CODE_PROVANDCITYService();
            object id;

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            else if (patch.GetChangedPropertyNames().Contains("ITEM_CODE") && patch.TryGetPropertyValue("ITEM_CODE", out id) && (string)id != key)
            {
                return(BadRequest("The key from the url must match the key of the entity in the body"));
            }

            try
            {
                var query = service.GetEntity(key);
                patch.Patch(query);
                service.UpdateEntity(query);
                return(Updated(query));
            }
            catch (Exception)
            {
                return(NotFound());
            }
        }
Ejemplo n.º 2
0
        // PATCH tables/ExpenseItem/48D68C86-6EA6-4C25-AA33-223FC9A27959
        public Task <ExpenseItem> PatchExpenseItem(string id, Delta <ExpenseItem> patch)
        {
            var userSid      = this.GetCurrentUserSid();
            var userAccounts = _context.AccountUsers
                               .Where(accountUser => accountUser.UserId == userSid)
                               .Select(accountUser => accountUser.AccountId);

            var query = _context.ExpenseItems.Where(expenseItem => userAccounts.Contains(expenseItem.AccountId) && expenseItem.Id == id);

            if (!query.Any())
            {
                throw new HttpResponseException(HttpStatusCode.NotFound);
            }

            var changedProperties = patch.GetChangedPropertyNames().ToList();
            var filteredDelta     = new Delta <ExpenseItem>();

            if (changedProperties.Contains(nameof(ExpenseItem.Amount), StringComparer.OrdinalIgnoreCase))
            {
                filteredDelta.TrySetPropertyValue(nameof(ExpenseItem.Amount), patch.GetEntity().Amount);
            }
            if (changedProperties.Contains(nameof(ExpenseItem.Date), StringComparer.OrdinalIgnoreCase))
            {
                filteredDelta.TrySetPropertyValue(nameof(ExpenseItem.Date), patch.GetEntity().Date);
            }
            if (changedProperties.Contains(nameof(ExpenseItem.Description), StringComparer.OrdinalIgnoreCase))
            {
                filteredDelta.TrySetPropertyValue(nameof(ExpenseItem.Description), patch.GetEntity().Description);
            }

            return(UpdateAsync(id, filteredDelta));
        }
        public virtual async Task <IHttpActionResult> PatchAsync(string id, Delta <TUpdateModel> changes)
        {
            TModel original = await GetModelAsync(id, false);

            if (original == null)
            {
                return(NotFound());
            }

            // if there are no changes in the delta, then ignore the request
            if (changes == null || !changes.GetChangedPropertyNames().Any())
            {
                return(await OkModelAsync(original));
            }

            var permission = await CanUpdateAsync(original, changes);

            if (!permission.Allowed)
            {
                return(Permission(permission));
            }

            try {
                await UpdateModelAsync(original, changes);
                await AfterPatchAsync(original);
            } catch (ValidationException ex) {
                return(BadRequest(ex.Errors.ToErrorMessage()));
            }

            return(await OkModelAsync(original));
        }
        public virtual IHttpActionResult Patch(string id, Delta <TUpdateModel> changes)
        {
            // if there are no changes in the delta, then ignore the request
            if (changes == null || !changes.GetChangedPropertyNames().Any())
            {
                return(Ok());
            }

            TModel original = GetModel(id, false);

            if (original == null)
            {
                return(NotFound());
            }

            var permission = CanUpdate(original, changes);

            if (!permission.Allowed)
            {
                return(Permission(permission));
            }

            try {
                UpdateModel(original, changes);
            } catch (ValidationException ex) {
                return(BadRequest(ex.Errors.ToErrorMessage()));
            }

            return(Ok());
        }
Ejemplo n.º 5
0
        public void Read_PatchMode()
        {
            // Arrange
            string content     = Resources.SupplierPatch;
            var    readContext = new ODataDeserializerContext
            {
                Path         = new ODataPath(new EntitySetSegment(_edmModel.EntityContainer.FindEntitySet("Suppliers"))),
                Model        = _edmModel,
                ResourceType = typeof(Delta <Supplier>)
            };

            ODataResourceDeserializer deserializer =
                new ODataResourceDeserializer(_deserializerProvider);

            // Act
            Delta <Supplier> supplier = deserializer.Read(GetODataMessageReader(GetODataMessage(content), _edmModel),
                                                          typeof(Delta <Supplier>), readContext) as Delta <Supplier>;

            // Assert
            Assert.NotNull(supplier);
            Assert.Equal(supplier.GetChangedPropertyNames(), new string[] { "ID", "Name", "Address" });

            Assert.Equal((supplier as dynamic).Name, "Supplier Name");
            Assert.Equal("Supplier City", (supplier as dynamic).Address.City);
            Assert.Equal("123456", (supplier as dynamic).Address.ZipCode);
        }
Ejemplo n.º 6
0
        public override IHttpActionResult Patch(int key, Delta <ItSystem> delta)
        {
            var itSystem = Repository.GetByKey(key);

            if (itSystem == null)
            {
                return(NotFound());
            }

            var changedPropertyNames = delta.GetChangedPropertyNames().ToHashSet();

            if (AttemptToChangeUuid(delta, itSystem, changedPropertyNames))
            {
                return(BadRequest("Cannot change Uuid"));
            }

            var disabledBefore = itSystem.Disabled;
            var result         = base.Patch(key, delta);

            if (disabledBefore != itSystem.Disabled)
            {
                DomainEvents.Raise(new EnabledStatusChanged <ItSystem>(itSystem, disabledBefore, itSystem.Disabled));
            }

            return(result);
        }
Ejemplo n.º 7
0
        public override IHttpActionResult Patch(int key, Delta <Advice> delta)
        {
            try
            {
                var existingAdvice = Repository.GetByKey(key);
                var deltaAdvice    = delta.GetInstance();

                if (existingAdvice == null)
                {
                    return(NotFound());
                }

                if (existingAdvice.Type != deltaAdvice.Type)
                {
                    return(BadRequest("Cannot change advice type"));
                }

                if (!existingAdvice.IsActive)
                {
                    throw new ArgumentException(
                              "Cannot update inactive advice ");
                }
                if (existingAdvice.AdviceType == AdviceType.Immediate)
                {
                    throw new ArgumentException("Editing is not allowed for immediate advice");
                }
                if (existingAdvice.AdviceType == AdviceType.Repeat)
                {
                    var changedPropertyNames = delta.GetChangedPropertyNames().ToList();
                    if (changedPropertyNames.All(IsRecurringEditableProperty))
                    {
                        throw new ArgumentException("For recurring advices editing is only allowed for name, subject and stop date");
                    }

                    if (changedPropertyNames.Contains("StopDate") && deltaAdvice.StopDate != null)
                    {
                        if (deltaAdvice.StopDate.Value.Date < deltaAdvice.AlarmDate.GetValueOrDefault().Date || deltaAdvice.StopDate.Value.Date < _operationClock.Now.Date)
                        {
                            throw new ArgumentException("For recurring advices only future stop dates after the set alarm date is allowed");
                        }
                    }
                }

                var response = base.Patch(key, delta);

                if (response is UpdatedODataResult <Advice> )
                {
                    var updatedAdvice = Repository.GetByKey(key); //Re-load
                    _adviceService.UpdateSchedule(updatedAdvice);
                }

                return(response);
            }
            catch (Exception e)
            {
                Logger.ErrorException("Failed to update advice", e);
                return(StatusCode(HttpStatusCode.InternalServerError));
            }
        }
    public virtual async Task <IHttpActionResult> Patch([FromODataUri] TKey key, Delta <TEntity> patch, ODataQueryOptions <TEntity> options)
    {
        Validate(patch.GetInstance());
        if (!ModelState.IsValid)
        {
            return(BadRequest(ModelState));
        }
        if (!String.IsNullOrWhiteSpace(this.AllowedSelectProperties))
        {
            var updateableProperties = AllowedSelectProperties.Split(',').Select(x => x.Trim());

            /*****************************************************************
            * Example that prevents patch when invalid fields are presented *
            * Comment this block to passively allow the operation and skip  *
            * over the invalid fields                                       *
            * ***************************************************************/
            if (patch.GetChangedPropertyNames().Any(x => updateableProperties.Contains(x, StringComparer.OrdinalIgnoreCase)))
            {
                return(BadRequest("Can only Patch the following fields: " + this.AllowedSelectProperties));
            }

            /*****************************************************************
            * Passive example, re-create the delta and skip invalid fields  *
            * ***************************************************************/
            var delta = new Delta <TEntity>();
            foreach (var field in updateableProperties)
            {
                if (delta.TryGetPropertyValue(field, out object value))
                {
                    delta.TrySetPropertyValue(field, value);
                }
            }
            patch = delta;
        }
        var itemQuery = GetEntitySet().Where(FindByKey(key));
        var item      = itemQuery.FirstOrDefault();

        if (item == null)
        {
            return(NotFound());
        }
        patch.Patch(item);
        try
        {
            await db.SaveChangesAsync();
        }
        catch (DbUpdateConcurrencyException)
        {
            if (!ItemExists(key))
            {
                return(NotFound());
            }
            else
            {
                throw;
            }
        }
        return(Updated(item));
    }
Ejemplo n.º 9
0
        public IHttpActionResult Patch([FromODataUri] int key, Delta <Punch> patch)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var currentUser = CurrentUser();

            // Ensure that user is authorized.
            if (!currentUser.CanModifyPunches)
            {
                return(StatusCode(HttpStatusCode.Forbidden));
            }

            var punch = db.Punches
                        .Include("User")
                        .Where(p => p.User.OrganizationId == currentUser.OrganizationId)
                        .Where(p => p.Id == key)
                        .FirstOrDefault();

            // Record the object before any changes are made.
            var before = JsonConvert.SerializeObject(punch);

            if (punch == null)
            {
                return(NotFound());
            }

            // Cannot modify locked punches.
            if (punch.CommitId.HasValue)
            {
                return(BadRequest());
            }

            // Do not allow modifying some properties.
            if (patch.GetChangedPropertyNames().Contains("OrganizationId"))
            {
                return(BadRequest("Cannont modify OrganizationId"));
            }

            // Peform the update
            patch.Patch(punch);

            // Ensure InAt is at bottom of hour and OutAt is at top of the hour
            punch.InAt = new DateTime(punch.InAt.Year, punch.InAt.Month, punch.InAt.Day, punch.InAt.Hour, punch.InAt.Minute, 0, 0);
            if (punch.OutAt.HasValue)
            {
                punch.OutAt = new DateTime(punch.OutAt.Value.Year, punch.OutAt.Value.Month, punch.OutAt.Value.Day, punch.OutAt.Value.Hour, punch.OutAt.Value.Minute, 0, 0);
            }

            db.SaveChanges();

            // Record the activity.
            AuditPunch(punch.Id, before, JsonConvert.SerializeObject(punch), currentUser, "UPDATE");

            return(Updated(punch));
        }
Ejemplo n.º 10
0
        public void ReadFromStreamAsync_ForComplexType_WithNestedComplexType()
        {
            // Arrange
            const string content = "{\"value\":{" +
                                   "\"City\":\"UpdatedCity\"," +
                                   "\"Location\": {" +
                                   "\"Latitude\": 30.6," +
                                   "\"Longitude\": 101.313" +
                                   "}," +
                                   "\"SubLocation\": {" + // dynamic property
                                   "\"@odata.type\":\"#System.Web.OData.Formatter.Deserialization.Location\"," +
                                   "\"Latitude\": 15.5," +
                                   "\"Longitude\": 130.88" +
                                   "}" +
                                   "}}";

            ODataComplexTypeDeserializer deserializer = new ODataComplexTypeDeserializer(new DefaultODataDeserializerProvider());
            ODataConventionModelBuilder  builder      = new ODataConventionModelBuilder();

            builder.ComplexType <Region>();
            IEdmModel model = builder.GetEdmModel();

            ODataDeserializerContext readContext = new ODataDeserializerContext
            {
                Model        = model,
                ResourceType = typeof(Delta <Region>)
            };

            // Act
            object value = deserializer.Read(GetODataMessageReader(GetODataMessage(content), model),
                                             typeof(Delta <Region>), readContext);

            // Assert
            Delta <Region> region = Assert.IsType <Delta <Region> >(value);

            Assert.NotNull(region);
            Assert.Equal(new[] { "City", "Location" }, region.GetChangedPropertyNames());
            Assert.Empty(region.GetUnchangedPropertyNames());

            object propertyValue;

            Assert.True(region.TryGetPropertyValue("City", out propertyValue));
            string cityValue = Assert.IsType <string>(propertyValue);

            Assert.Equal("UpdatedCity", cityValue);

            Assert.True(region.TryGetPropertyValue("Location", out propertyValue));
            Location locationValue = Assert.IsType <Location>(propertyValue);

            Assert.Equal(30.6, locationValue.Latitude);
            Assert.Equal(101.313, locationValue.Longitude);

            // dynamic property
            Assert.True(region.TryGetPropertyValue("SubLocation", out propertyValue));
            locationValue = Assert.IsType <Location>(propertyValue);
            Assert.Equal(15.5, locationValue.Latitude);
            Assert.Equal(130.88, locationValue.Longitude);
        }
Ejemplo n.º 11
0
        // PATCH: odata/Tasks(5)
        public IActionResult Patch([FromODataUri] int key, Delta <Brizbee.Core.Models.Task> patch)
        {
            var currentUser = CurrentUser();

            var task = _context.Tasks
                       .Include(t => t.Job.Customer)
                       .Where(t => t.Id == key)
                       .FirstOrDefault();

            // Ensure that object was found.
            if (task == null)
            {
                return(NotFound());
            }

            // Ensure that user is authorized.
            if (!currentUser.CanModifyTasks ||
                task.Job.Customer.OrganizationId != currentUser.OrganizationId)
            {
                return(Forbid());
            }

            // Do not allow modifying some properties.
            if (patch.GetChangedPropertyNames().Contains("JobId") ||
                patch.GetChangedPropertyNames().Contains("CreatedAt") ||
                patch.GetChangedPropertyNames().Contains("Id"))
            {
                return(BadRequest("Cannot modify the JobId, CreatedAt, or Id."));
            }

            // Peform the update.
            patch.Patch(task);

            // Validate the model.
            ModelState.ClearValidationState(nameof(task));
            if (!TryValidateModel(task, nameof(task)))
            {
                return(BadRequest());
            }


            _context.SaveChanges();

            return(NoContent());
        }
Ejemplo n.º 12
0
        // PATCH: odata/Jobs(5)
        public IActionResult Patch([FromODataUri] int key, Delta <Job> patch)
        {
            var currentUser = CurrentUser();

            var job = _context.Jobs
                      .Include(j => j.Customer)
                      .Where(j => j.Customer.OrganizationId == currentUser.OrganizationId)
                      .Where(j => j.Id == key)
                      .FirstOrDefault();

            // Ensure that object was found.
            if (job == null)
            {
                return(NotFound());
            }

            // Ensure that user is authorized.
            if (!currentUser.CanModifyProjects ||
                currentUser.OrganizationId != job.Customer.OrganizationId)
            {
                return(Forbid());
            }

            // Do not allow modifying some properties.
            if (patch.GetChangedPropertyNames().Contains("CustomerId") ||
                patch.GetChangedPropertyNames().Contains("Id") ||
                patch.GetChangedPropertyNames().Contains("CreatedAt"))
            {
                return(BadRequest("Not authorized to modify the CustomerId, CreatedAt, or Id."));
            }

            // Peform the update
            patch.Patch(job);

            // Validate the model.
            ModelState.ClearValidationState(nameof(job));
            if (!TryValidateModel(job, nameof(job)))
            {
                return(BadRequest());
            }

            _context.SaveChanges();

            return(NoContent());
        }
    /// <summary>
    /// Get this list of non-editable changes in a <see cref="Delta{T}"/>.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="delta"></param>
    /// <returns></returns>
    public static IList <string> NonEditableChanges <T>(this Delta <T> delta)
        where T : class
    {
        var nec      = new List <string>();
        var excluded = typeof(T).NonEditableProperties();

        nec.AddRange(delta.GetChangedPropertyNames().Where(x => excluded.Contains(x)));
        return(nec);
    }
Ejemplo n.º 14
0
        public IActionResult PatchToQuery(int key, Delta <HuntingQueryResults> delta)
        {
            var changedPropertyNames = delta.GetChangedPropertyNames();

            HuntingQueryResults original = new HuntingQueryResults();

            delta.Patch(original);

            return(Ok(key));
        }
Ejemplo n.º 15
0
        // PATCH tables/TodoItem/48D68C86-6EA6-4C25-AA33-223FC9A27959
        public async Task <UserProfileDTO> PatchUserProfile(string id, Delta <UserProfileDTO> patch)
        {
            UserProfile currentUserProfile = this.context.UserProfiles.Include("InterestedIn")
                                             .First(j => (j.Id == id));


            UserProfileDTO updatedUserProfileEntity = patch.GetEntity();

            ICollection <TechnologyDTO> updatedTechnologies;

            bool reqeustContainsRelatedEntities = patch.GetChangedPropertyNames().Contains("InterestedIn");

            if (reqeustContainsRelatedEntities)
            {
                //If request contains Items get the updated list from the patch
                Mapper.Map <UserProfileDTO, UserProfile>(updatedUserProfileEntity, currentUserProfile);
                updatedTechnologies = updatedUserProfileEntity.InterestedIn;
            }
            else
            {
                //If request doest not have Items, then retain the original association
                UserProfileDTO userProfileDTOUpdated = Mapper.Map <UserProfile, UserProfileDTO>
                                                           (currentUserProfile);
                patch.Patch(userProfileDTOUpdated);
                Mapper.Map <UserProfileDTO, UserProfile>(userProfileDTOUpdated, currentUserProfile);
                updatedTechnologies = userProfileDTOUpdated.InterestedIn;
            }

            if (updatedTechnologies != null)
            {
                //Update related Items
                currentUserProfile.InterestedIn = new List <Technology>();
                foreach (var currentTechnologyDTO in updatedTechnologies)
                {
                    //Look up existing entry in database
                    Technology existingItem = this.context.Technologies
                                              .FirstOrDefault(j => (j.Id.ToString() == currentTechnologyDTO.Id.ToString()));

                    if (existingItem != null)
                    {
                        //Convert client type to database type
                        //            Mapper.Map<TechnologyDTO, Technology>(currentTechnologyDTO,
                        //              existingItem);
                        currentUserProfile.InterestedIn.Add(existingItem);
                    }
                }
            }

            await this.context.SaveChangesAsync();

            //Convert to client type before returning the result
            var result = Mapper.Map <UserProfile, UserProfileDTO>(currentUserProfile);

            return(result);
        }
Ejemplo n.º 16
0
        public void CanChangeDerivedClassProperties()
        {
            // Arrange
            dynamic delta = new Delta <Base>(typeof(Derived));

            // Act
            delta.DerivedInt = 10;

            // Assert
            Assert.Equal(delta.GetChangedPropertyNames(), new[] { "DerivedInt" });
        }
Ejemplo n.º 17
0
        // PUT: odata/LocationCollections(5)
        public IHttpActionResult Put([FromODataUri] int key, Delta <LocationCollection> patch)
        {
            string LogMsg = this.ControllerContext.RouteData.Values["controller"].ToString() + "Controller." +
                            this.ControllerContext.RouteData.Values["action"].ToString() + " :: ";

            LocationCollection locationcollection = null;

            try
            {
                Validate(patch.GetChangedPropertyNames());

                if (!ModelState.IsValid)
                {
                    NLogWriter.LogMessage(LogType.Error, LogMsg + "Invalid ModelState");
                    throw new Exception("Invalid modelstate");
                }

                locationcollection = data.LocationCollectionRepository.GetByID(key);
                if (locationcollection == null)
                {
                    NLogWriter.LogMessage(LogType.Error, LogMsg + "Unable to find Locationcollection by Key = '" + Convert.ToString(key) + "'");
                    throw new Exception("Unable to find locationcollection by key");
                }

                patch.Put(locationcollection);
                try
                {
                    data.Save();
                }
                catch (DbUpdateConcurrencyException ex)
                {
                    if (!LocationCollectionExists(key))
                    {
                        NLogWriter.LogMessage(LogType.Error, LogMsg + "DbUpdateConcurrencyException putting locationcollection by ID '" + Convert.ToString(key) + "' - Not Found :: " + ex.ToString());
                        throw new Exception("DbUpdateConcurrencyException putting locationcollection by ID = '" + Convert.ToString(key) + "' - Not Found :: " + ex.ToString());
                    }
                    else
                    {
                        throw;
                    }
                }
            }
            catch (Exception ex)
            {
                NLogWriter.LogMessage(LogType.Error, LogMsg + "Exception updating locationcollection :: " + ex.ToString());
                HttpResponseMessage resp = new HttpResponseMessage(HttpStatusCode.NotFound)
                {
                    Content      = new StringContent("Exception updating locationcollection :: " + ex.ToString()),
                    ReasonPhrase = "Unable to udpate locationcollection"
                };
                throw new HttpResponseException(resp);
            }
            return(Updated(locationcollection));
        }
Ejemplo n.º 18
0
 // PATCH tables/Domain/48D68C86-6EA6-4C25-AA33-223FC9A27959
 public Task <Domain> PatchDomain(string id, Delta <DomainRequest> patch)
 {
     try
     {
         // patch Mappers does not work for Patch.Itws a limitation.
         ValidationUtilities.ValidateEditDomainRequest(patch.GetEntity(), patch.GetChangedPropertyNames().ToList());
         string         currentUserEmail = HttpUtilities.GetUserNameFromToken(this.Request);
         Delta <Domain> deltaDest        = new Delta <Domain>();
         //Domain dbObject = context.Domains.FirstOrDefault(a => a.Id == id);
         //Mapper.Initialize(cfg => cfg.CreateMap<DomainRequest, Domain>()
         // .ForMember(i => i.ModifiedBy, j => j.UseValue(currentUserEmail))
         // .ForMember(i => i.UpdatedAt, j => j.UseValue(DateTimeOffset.UtcNow))
         //);
         //var domainMap = Mapper.Map<DomainRequest, Domain>(patch.GetEntity(), dbObject);
         //deltaDest.Put(domainMap);
         //patch.
         foreach (var item in patch.GetChangedPropertyNames())
         {
             object result;
             patch.TryGetPropertyValue(item, out result);
             bool bResult;
             if (bool.TryParse(result.ToString(), out bResult))
             {
                 deltaDest.TrySetPropertyValue(item, bResult);
             }
             else
             {
                 deltaDest.TrySetPropertyValue(item, result);
             }
         }
         deltaDest.TrySetPropertyValue("ModifiedBy", currentUserEmail);
         deltaDest.TrySetPropertyValue("UpdatedAt", DateTimeOffset.UtcNow);
         return(UpdateAsync(id, deltaDest));
     }
     catch (HttpResponseException ex)
     {
         LGSELogger.Error(ex);
         throw ex;
     }
 }
Ejemplo n.º 19
0
        // PATCH tables/SummaryItem/48D68C86-6EA6-4C25-AA33-223FC9A27959
        public Task <SummaryItem> PatchSummaryItem(string id, Delta <SummaryItem> patch)
        {
            SummaryItem oldSummaryItem = ValidateKey(id);

            // Only do the following if the summary value is being updated
            if (patch.GetChangedPropertyNames().Contains("Summary"))
            {
                string newSummaryCipher = patch.GetEntity().AddSummary(oldSummaryItem);
                patch.TrySetPropertyValue("Summary", newSummaryCipher);
            }

            return(UpdateAsync(id, patch));
        }
Ejemplo n.º 20
0
        public async Task <IHttpActionResult> Patch([FromODataUri] int elementFieldId, Delta <UserElementField> patch)
        {
            var userElementField = await MainUnitOfWork.AllLive.SingleOrDefaultAsync(item => item.ElementFieldId == elementFieldId);

            if (userElementField == null)
            {
                return(NotFound());
            }

            var patchEntity = patch.GetEntity();

            if (patchEntity.RowVersion == null)
            {
                throw new InvalidOperationException("RowVersion property of the entity cannot be null");
            }

            if (!userElementField.RowVersion.SequenceEqual(patchEntity.RowVersion))
            {
                return(Conflict());
            }

            patch.Patch(userElementField);

            try
            {
                await MainUnitOfWork.UpdateAsync(userElementField);
            }
            catch (DbUpdateException)
            {
                if (patch.GetChangedPropertyNames().Any(item => item == "ElementFieldId"))
                {
                    object elementFieldIdObject = null;
                    patch.TryGetPropertyValue("ElementFieldId", out elementFieldIdObject);

                    if (elementFieldIdObject != null && await MainUnitOfWork.All.AnyAsync(item => item.ElementFieldId == (int)elementFieldIdObject))
                    {
                        return(new UniqueKeyConflictResult(Request, "ElementFieldId", elementFieldIdObject.ToString()));
                    }
                    else
                    {
                        throw;
                    }
                }
                else
                {
                    throw;
                }
            }

            return(Ok(userElementField));
        }
Ejemplo n.º 21
0
        public virtual async Task <IHttpActionResult> Patch([FromODataUri] string providerKey, Delta <UserLogin> patch)
        {
            var userLogin = await MainUnitOfWork.AllLive.SingleOrDefaultAsync(item => item.ProviderKey == providerKey);

            if (userLogin == null)
            {
                return(NotFound());
            }

            var patchEntity = patch.GetEntity();

            if (patchEntity.RowVersion == null)
            {
                throw new InvalidOperationException("RowVersion property of the entity cannot be null");
            }

            if (!userLogin.RowVersion.SequenceEqual(patchEntity.RowVersion))
            {
                return(Conflict());
            }

            patch.Patch(userLogin);

            try
            {
                await MainUnitOfWork.UpdateAsync(userLogin);
            }
            catch (DbUpdateException)
            {
                if (patch.GetChangedPropertyNames().Any(item => item == "ProviderKey"))
                {
                    object providerKeyObject = null;
                    patch.TryGetPropertyValue("ProviderKey", out providerKeyObject);

                    if (providerKeyObject != null && await MainUnitOfWork.All.AnyAsync(item => item.ProviderKey == (string)providerKeyObject))
                    {
                        return(new UniqueKeyConflictResult(Request, "ProviderKey", providerKeyObject.ToString()));
                    }
                    else
                    {
                        throw;
                    }
                }
                else
                {
                    throw;
                }
            }

            return(Ok(userLogin));
        }
Ejemplo n.º 22
0
        public async Task <Result <TKey> > PatchAsync <TModel, TEntity, TKey>(Delta <TModel> delta, CancellationToken cancellationToken = default)
            where TModel : class, IObject <TKey>
            where TEntity : class, IObject <TKey>
        {
            var idName = nameof(IObject <TKey> .Id);

            if (delta.GetChangedPropertyNames().Contains(idName))
            {
                if (delta.TryGetPropertyValue(idName, out var value))
                {
                    if (value is TKey id)
                    {
                        var entity = await this.repository.FindOneAsync <TEntity, TKey>(id, cancellationToken);

                        if (entity != null)
                        {
                            var model = this.Mapper.Map <TEntity, TModel>(entity);
                            delta.Patch(model);
                            entity = this.Mapper.Map(model, entity);
                            await this.repository.CommitAsync(cancellationToken);

                            return(Result <TKey> .Success(id));
                        }
                        else
                        {
                            var error = $"The entity of type {typeof(TEntity).Name} with key {id} does not exits and can not be patched";
                            this.Logger.LogDebug(error);
                            return(Result <TKey> .Fail(error));
                        }
                    }
                    else
                    {
                        var error = $"The type of {value.GetType()} does not match the key type {typeof(TKey).Name} fot the entity type {typeof(TEntity).Name} and can not be patched";
                        this.Logger.LogDebug(error);
                        return(Result <TKey> .Fail(error));
                    }
                }
                else
                {
                    var error = $"The delta of entity of type {typeof(TEntity).Name} does not have a key ({idName}) and can not be patched";
                    this.Logger.LogDebug(error);
                    return(Result <TKey> .Fail(error));
                }
            }
            else
            {
                var error = $"The delta of entity of type {typeof(TEntity).Name} does not have a key property provided ({idName}) and can not be patched";
                this.Logger.LogDebug(error);
                return(Result <TKey> .Fail(error));
            }
        }
        public virtual async Task <IHttpActionResult> Patch([FromODataUri] int key, Delta <ResourcePool> patch)
        {
            var resourcePool = await MainUnitOfWork.AllLive.SingleOrDefaultAsync(item => item.Id == key);

            if (resourcePool == null)
            {
                return(NotFound());
            }

            var patchEntity = patch.GetEntity();

            if (patchEntity.RowVersion == null)
            {
                throw new InvalidOperationException("RowVersion property of the entity cannot be null");
            }

            if (!resourcePool.RowVersion.SequenceEqual(patchEntity.RowVersion))
            {
                return(Conflict());
            }

            patch.Patch(resourcePool);

            try
            {
                await MainUnitOfWork.UpdateAsync(resourcePool);
            }
            catch (DbUpdateException)
            {
                if (patch.GetChangedPropertyNames().Any(item => item == "Id"))
                {
                    object keyObject = null;
                    patch.TryGetPropertyValue("Id", out keyObject);

                    if (keyObject != null && await MainUnitOfWork.All.AnyAsync(item => item.Id == (int)keyObject))
                    {
                        return(new UniqueKeyConflictResult(Request, "Id", keyObject.ToString()));
                    }
                    else
                    {
                        throw;
                    }
                }
                else
                {
                    throw;
                }
            }

            return(Ok(resourcePool));
        }
        protected virtual async Task <PermissionResult> CanUpdateAsync(TModel original, Delta <TUpdateModel> changes)
        {
            if (original is IOwnedByOrganization orgModel && !CanAccessOrganization(orgModel.OrganizationId))
            {
                return(PermissionResult.DenyWithMessage("Invalid organization id specified."));
            }

            if (changes.GetChangedPropertyNames().Contains("OrganizationId"))
            {
                return(PermissionResult.DenyWithMessage("OrganizationId cannot be modified."));
            }

            return(PermissionResult.Allow);
        }
Ejemplo n.º 25
0
            public IHttpActionResult PatchToLocation(int key, Delta <Address> patch)
            {
                Assert.Equal(new[] { "Street", "City" }, patch.GetChangedPropertyNames());

                // Verify the origin address
                Address address = new Address();

                patch.Patch(address);

                Assert.Equal("UpdatedStreet", address.Street);
                Assert.Equal("UpdatedCity", address.City);

                return(Ok());
            }
Ejemplo n.º 26
0
        protected override Employee PatchEntity(int key, Delta <Employee> patch)
        {
            var employeeToPatch = GetEntityByKey(key);

            patch.Patch(employeeToPatch);
            db.Entry(employeeToPatch).State = EntityState.Modified;
            db.SaveChanges();
            var    changedProperty = patch.GetChangedPropertyNames().ToList()[0];
            object changedPropertyValue;

            patch.TryGetPropertyValue(changedProperty, out changedPropertyValue);
            Hub.Clients.All.updateEmployee(employeeToPatch.Id, changedProperty, changedPropertyValue);
            return(employeeToPatch);
        }
    /// <summary>
    /// Exclude changes from a <see cref="Delta{T}"/> based on a list of property names
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="delta"></param>
    /// <param name="excluded"></param>
    /// <returns></returns>
    public static Delta <T> Exclude <T>(this Delta <T> delta, IList <string> excluded)
        where T : class
    {
        var changed = new Delta <T>();

        foreach (var prop in delta.GetChangedPropertyNames().Where(x => !excluded.Contains(x)))
        {
            object value;
            if (delta.TryGetPropertyValue(prop, out value))
            {
                changed.TrySetPropertyValue(prop, value);
            }
        }
        return(changed);
    }
Ejemplo n.º 28
0
        protected virtual PermissionResult CanUpdate(TModel original, Delta <TUpdateModel> changes)
        {
            var orgModel = original as IOwnedByOrganization;

            if (orgModel != null && !IsInOrganization(orgModel.OrganizationId))
            {
                return(PermissionResult.DenyWithMessage("Invalid organization id specified."));
            }

            if (changes.GetChangedPropertyNames().Contains("OrganizationId"))
            {
                return(PermissionResult.DenyWithMessage("OrganizationId cannot be modified."));
            }

            return(PermissionResult.Allow);
        }
        protected override Product PatchEntity(int key, Delta <Product> patch)
        {
            Delta <V2VM.Product> v2Patch = new Delta <V2VM.Product>();

            foreach (string name in patch.GetChangedPropertyNames())
            {
                object value;
                if (patch.TryGetPropertyValue(name, out value))
                {
                    v2Patch.TrySetPropertyValue(name, value);
                }
            }
            var v2Product = _controller.PatchEntityImpl((long)key, v2Patch);

            return(Mapper.Map <Product>(v2Product));
        }
Ejemplo n.º 30
0
        public void Read_PatchMode()
        {
            IEdmEntityType supplierEntityType = EdmTestHelpers.GetModel().FindType("ODataDemo.Supplier") as IEdmEntityType;

            _readContext.IsPatchMode = true;

            ODataEntityDeserializer deserializer = new ODataEntityDeserializer(_supplierEdmType, _deserializerProvider);
            Delta <Supplier>        supplier     = deserializer.Read(GetODataMessageReader(GetODataMessage(BaselineResource.SuppliersPatchData), _edmModel), _readContext) as Delta <Supplier>;

            Assert.NotNull(supplier);
            Assert.Equal(supplier.GetChangedPropertyNames(), new string[] { "Name", "Address" });

            Assert.Equal((supplier as dynamic).Name, "Supplier Name");
            Assert.Equal("Supplier City", (supplier as dynamic).Address.City);
            Assert.Equal("123456", (supplier as dynamic).Address.ZipCode);
        }