Пример #1
0
        private void AddEntryAssociation(EntryMembers entryMembers, string associationName, object associatedData)
        {
            int contentId = _requestBuilder.GetContentId(associatedData);

            if (contentId == 0)
            {
                entryMembers.AddAssociationByValue(associationName, associatedData);
            }
            else
            {
                entryMembers.AddAssociationByContentId(associationName, contentId);
            }
        }
Пример #2
0
        private EntryMembers ParseEntryMembers(string tableName, IDictionary <string, object> entryData)
        {
            var entryMembers = new EntryMembers();

            var table = _schema.FindTable(tableName);

            foreach (var item in entryData)
            {
                ParseEntryMember(table, item, entryMembers);
            }

            return(entryMembers);
        }
        private int UpdateEntryPropertiesAndAssociations(
            string collection,
            IDictionary<string, object> entryKey,
            IDictionary<string, object> entryData,
            EntryMembers entryMembers)
        {
            bool hasPropertiesToUpdate = entryMembers.Properties.Count > 0;
            bool merge = !hasPropertiesToUpdate || CheckMergeConditions(collection, entryKey, entryData);
            var commandText = GetFluentClient()
                .For(_schema.FindBaseTable(collection).ActualName)
                .Key(entryKey)
                .CommandText;

            var feedWriter = new ODataFeedWriter();
            var table = _schema.FindConcreteTable(collection);
            var entryElement = feedWriter.CreateDataElement(_schema.TypesNamespace, table.EntityType.Name, entryMembers.Properties);
            var unlinkAssociationNames = new List<string>();
            foreach (var associatedData in entryMembers.AssociationsByValue)
            {
                var association = table.FindAssociation(associatedData.Key);
                if (associatedData.Value != null)
                {
                    CreateLinkElement(entryElement, collection, associatedData);
                }
                else
                {
                    unlinkAssociationNames.Add(association.ActualName);
                }
            }

            var command = new HttpCommand(merge ? RestVerbs.MERGE : RestVerbs.PUT, commandText, entryData, entryElement.ToString());
            _requestBuilder.AddCommandToRequest(command);
            var result = _requestRunner.UpdateEntry(command);

            foreach (var associatedData in entryMembers.AssociationsByContentId)
            {
                var linkCommand = CreateLinkCommand(collection, associatedData.Key,
                    feedWriter.CreateLinkPath(command.ContentId),
                    feedWriter.CreateLinkPath(associatedData.Value));
                _requestBuilder.AddCommandToRequest(linkCommand);
                _requestRunner.UpdateEntry(linkCommand);
            }

            foreach (var associationName in unlinkAssociationNames)
            {
                UnlinkEntry(collection, entryKey, associationName);
            }

            return result;
        }
        private async Task<IDictionary<string, object>> UpdateEntryPropertiesAndAssociationsAsync(
            string collection,
            IDictionary<string, object> entryKey,
            IDictionary<string, object> entryData,
            EntryMembers entryMembers,
            bool resultRequired)
        {
            bool hasPropertiesToUpdate = entryMembers.Properties.Count > 0;
            bool merge = !hasPropertiesToUpdate || CheckMergeConditions(collection, entryKey, entryData);
            var commandText = await GetFluentClient()
                .For(_schema.FindBaseTable(collection).ActualName)
                .Key(entryKey)
                .GetCommandTextAsync();

            var commandWriter = new CommandWriter(_schema);
            var table = _schema.FindConcreteTable(collection);
            var entryContent = commandWriter.CreateEntry(table.EntityType.Name, entryMembers.Properties);
            var unlinkAssociationNames = new List<string>();
            foreach (var associatedData in entryMembers.AssociationsByValue)
            {
                var association = table.FindAssociation(associatedData.Key);
                if (associatedData.Value != null)
                {
                    commandWriter.AddLink(entryContent, collection, associatedData);
                }
                else
                {
                    unlinkAssociationNames.Add(association.ActualName);
                }
            }

            var command = commandWriter.CreateUpdateCommand(commandText, entryData, entryContent, merge);
            var request = _requestBuilder.CreateRequest(command, resultRequired);
            var result = await _requestRunner.UpdateEntryAsync(request);

            foreach (var associatedData in entryMembers.AssociationsByContentId)
            {
                var linkCommand = commandWriter.CreateLinkCommand(collection, associatedData.Key, command.ContentId, associatedData.Value);
                request = _requestBuilder.CreateRequest(linkCommand);
                await _requestRunner.UpdateEntryAsync(request);
            }

            foreach (var associationName in unlinkAssociationNames)
            {
                await UnlinkEntryAsync(collection, entryKey, associationName);
            }

            return result;
        }
 private void AddEntryAssociation(EntryMembers entryMembers, string associationName, object associatedData)
 {
     int contentId = _requestBuilder.GetContentId(associatedData);
     if (contentId == 0)
     {
         entryMembers.AddAssociationByValue(associationName, associatedData);
     }
     else
     {
         entryMembers.AddAssociationByContentId(associationName, contentId);
     }
 }
 private void ParseEntryMember(Table table, KeyValuePair<string, object> item, EntryMembers entryMembers)
 {
     if (table.HasColumn(item.Key))
     {
         entryMembers.AddProperty(item.Key, item.Value);
     }
     else if (table.HasAssociation(item.Key))
     {
         var association = table.FindAssociation(item.Key);
         if (association.IsMultiple)
         {
             var collection = item.Value as IEnumerable<object>;
             if (collection != null)
             {
                 foreach (var element in collection)
                 {
                     AddEntryAssociation(entryMembers, item.Key, element);
                 }
             }
         }
         else
         {
             AddEntryAssociation(entryMembers, item.Key, item.Value);
         }
     }
     else
     {
         throw new UnresolvableObjectException(item.Key, string.Format("No property or association found for {0}.", item.Key));
     }
 }
        private EntryMembers ParseEntryMembers(Table table, IDictionary<string, object> entryData)
        {
            var entryMembers = new EntryMembers();

            foreach (var item in entryData)
            {
                ParseEntryMember(table, item, entryMembers);
            }

            return entryMembers;
        }
Пример #8
0
        private EntryMembers ParseEntryMembers(string tableName, IDictionary<string, object> entryData)
        {
            var entryMembers = new EntryMembers();

            var table = _schema.FindTable(tableName);
            foreach (var item in entryData)
            {
                ParseEntryMember(table, item, entryMembers);
            }

            return entryMembers;
        }
Пример #9
0
 private void ParseEntryMember(Table table, KeyValuePair <string, object> item, EntryMembers entryMembers)
 {
     if (table.HasColumn(item.Key))
     {
         entryMembers.AddProperty(item.Key, item.Value);
     }
     else if (table.HasAssociation(item.Key))
     {
         var association = table.FindAssociation(item.Key);
         if (association.IsMultiple)
         {
             var collection = item.Value as IEnumerable <object>;
             if (collection != null)
             {
                 foreach (var element in collection)
                 {
                     AddEntryAssociation(entryMembers, item.Key, element);
                 }
             }
         }
         else
         {
             AddEntryAssociation(entryMembers, item.Key, item.Value);
         }
     }
     else
     {
         throw new UnresolvableObjectException(item.Key, string.Format("No property or association found for {0}.", item.Key));
     }
 }
Пример #10
0
        private int UpdateEntryPropertiesAndAssociations(string tableName, IDictionary <string, object> entryKey, IDictionary <string, object> entryData, EntryMembers entryMembers)
        {
            bool merge       = CheckMergeConditions(tableName, entryKey, entryData);
            var  commandText = FormatGetKeyCommand(tableName, entryKey);

            var entryElement = ODataHelper.CreateDataElement(entryMembers.Properties);

            foreach (var associatedData in entryMembers.AssociationsByValue)
            {
                CreateLinkElement(entryElement, tableName, associatedData);
            }

            var command = new HttpCommand(merge ? RestVerbs.MERGE : RestVerbs.PUT, commandText, entryData, entryElement.ToString());

            _requestBuilder.AddCommandToRequest(command);
            var result = _requestRunner.UpdateEntry(command);

            foreach (var associatedData in entryMembers.AssociationsByContentId)
            {
                var linkCommand = CreateLinkCommand(tableName, associatedData.Key,
                                                    ODataHelper.CreateLinkPath(command.ContentId),
                                                    ODataHelper.CreateLinkPath(associatedData.Value));
                _requestBuilder.AddCommandToRequest(linkCommand);
                _requestRunner.UpdateEntry(linkCommand);
            }

            return(result);
        }
Пример #11
0
 private int UpdateEntryAssociations(string tableName, IDictionary <string, object> entryKey, IDictionary <string, object> entryData, EntryMembers entryMembers)
 {
     foreach (var associatedData in entryMembers.AssociationsByValue)
     {
         var association = _schema.FindTable(tableName).FindAssociation(associatedData.Key);
         if (associatedData.Value != null)
         {
             var associatedKeyValues = GetLinkedEntryKeyValues(association.ReferenceTableName, associatedData);
             if (associatedKeyValues != null)
             {
                 LinkEntry(tableName, entryKey, association.ActualName, GetLinkedEntryProperties(associatedData.Value));
             }
         }
         else
         {
             UnlinkEntry(tableName, entryKey, association.ActualName);
         }
     }
     return(0);
 }
Пример #12
0
        private int UpdateEntryPropertiesAndAssociations(string tableName, IDictionary<string, object> entryKey, IDictionary<string, object> entryData, EntryMembers entryMembers)
        {
            bool merge = CheckMergeConditions(tableName, entryKey, entryData);
            var commandText = FormatGetKeyCommand(tableName, entryKey);

            var entryElement = ODataHelper.CreateDataElement(entryMembers.Properties);
            foreach (var associatedData in entryMembers.AssociationsByValue)
            {
                CreateLinkElement(entryElement, tableName, associatedData);
            }

            var command = new HttpCommand(merge ? RestVerbs.MERGE : RestVerbs.PUT, commandText, entryData, entryElement.ToString());
            _requestBuilder.AddCommandToRequest(command);
            var result = _requestRunner.UpdateEntry(command);

            foreach (var associatedData in entryMembers.AssociationsByContentId)
            {
                var linkCommand = CreateLinkCommand(tableName, associatedData.Key, 
                    ODataHelper.CreateLinkPath(command.ContentId), 
                    ODataHelper.CreateLinkPath(associatedData.Value));
                _requestBuilder.AddCommandToRequest(linkCommand);
                _requestRunner.UpdateEntry(linkCommand);
            }

            return result;
        }
Пример #13
0
 private int UpdateEntryAssociations(string tableName, IDictionary<string, object> entryKey, IDictionary<string, object> entryData, EntryMembers entryMembers)
 {
     foreach (var associatedData in entryMembers.AssociationsByValue)
     {
         var association = _schema.FindTable(tableName).FindAssociation(associatedData.Key);
         if (associatedData.Value != null)
         {
             var associatedKeyValues = GetLinkedEntryKeyValues(association.ReferenceTableName, associatedData);
             if (associatedKeyValues != null)
             {
                 LinkEntry(tableName, entryKey, association.ActualName, GetLinkedEntryProperties(associatedData.Value));
             }
         }
         else
         {
             UnlinkEntry(tableName, entryKey, association.ActualName);
         }
     }
     return 0;
 }