public ManagementToken(ODataRoute route, DataObjectEdmModel model)
{
Contract.Requires <ArgumentNullException>(route != null);
Contract.Requires <ArgumentNullException>(model != null);
Route = route;
_model = model;
Functions = new FunctionContainer(this);
}
public void TestGetDerivedTypes()
{
var model = new DataObjectEdmModel(new DataObjectEdmMetadata());
IList <Type> derivedTypes = model.GetDerivedTypes(typeof(Лес)).ToList();
Assert.NotNull(derivedTypes);
Assert.Equal(1, derivedTypes.Count);
Assert.Equal(typeof(Лес), derivedTypes.First());
}
public void TestRegisteringHierarchy()
{
var builder = new DefaultDataObjectEdmModelBuilder(new[] { GetType().Assembly });
DataObjectEdmModel model = builder.Build();
Assert.True(model.IsDataObjectRegistered(typeof(DataObject)));
Assert.True(model.IsDataObjectRegistered(typeof(H1)));
Assert.True(model.IsDataObjectRegistered(typeof(H2)));
}
public void TestWebApi()
{
var pathHandler = new DefaultODataPathHandler();
var model = new DataObjectEdmModel(new DataObjectEdmMetadata());
var conventions = new IODataRoutingConvention[0];
var constraint = new ODataPathRouteConstraint(pathHandler, model, "name", conventions);
var route = new ODataRoute("prefix", constraint);
var assemblies = new Assembly[0];
var modelBuilder = new DefaultDataObjectEdmModelBuilder(assemblies);
new PerRequestUpdateEdmModelHandler(new ManagementToken(route, model), modelBuilder);
}
private DataObject CreateDataObject(DataObjectEdmModel model, IEdmEntityTypeReference entityTypeReference, ODataEntryWithNavigationLinks entry, out Type objType)
{
IEdmEntityType entityType = entityTypeReference.EntityDefinition();
objType = model.GetDataObjectType(model.GetEdmEntitySet(entityType).Name);
var obj = (DataObject)Activator.CreateInstance(objType);
foreach (ODataProperty odataProp in entry.Entry.Properties)
{
string clrPropName = model.GetDataObjectPropertyName(objType, odataProp.Name);
Information.SetPropValueByName(obj, clrPropName, odataProp.Value);
}
return(obj);
}
public static Task <HttpResponseMessage> PatchAsJsonStringAsync(this HttpClient httpClient, DataObjectEdmModel model, DataObject dataObject, View view, string unlockUserName = null)
{
var pk = ((ICSSoft.STORMNET.KeyGen.KeyGuid)dataObject.__PrimaryKey).Guid.ToString();
var url = $"{model.GetEdmEntitySet(typeof(Лес)).Name}({pk})";
var jsonData = dataObject.ToJson(Лес.Views.ЛесE, model);
IPrincipal currentPrincipal = null;
try
{
if (unlockUserName != null)
{
currentPrincipal = Thread.CurrentPrincipal;
Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity(unlockUserName), null);
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Flexberry-Sync", "Unlock");
}
return(SendRequestAsJsonString(httpClient, url, jsonData, "PATCH"));
}
finally
{
if (unlockUserName != null)
{
Thread.CurrentPrincipal = currentPrincipal;
httpClient.DefaultRequestHeaders.Remove("Flexberry-Sync");
}
}
}
public void TestDataObjectIsNotRegisteredInEmptyModel()
{
var model = new DataObjectEdmModel(new DataObjectEdmMetadata());
Assert.False(model.IsDataObjectRegistered(typeof(DataObject)));
}
/// <summary>
/// Десериализует navigation property.
/// Также выполняет необходимые действия, чтобы обработка @odata.bind выполнялась по стандарту OData.
/// </summary>
/// <param name="entityResource">Объект, в который navigation property будет прочитано.</param>
/// <param name="navigationLinkWrapper">navigation линк.</param>
/// <param name="entityType">Тип сущности.</param>
/// <param name="readContext">Состояние и установки, используемые при чтении.</param>
public override void ApplyNavigationProperty(
object entityResource,
ODataNavigationLinkWithItems navigationLinkWrapper,
IEdmEntityTypeReference entityType,
ODataDeserializerContext readContext)
{
base.ApplyNavigationProperty(entityResource, navigationLinkWrapper, entityType, readContext);
EdmEntityObject edmEntity = (EdmEntityObject)entityResource;
DataObjectEdmModel model = readContext.Model as DataObjectEdmModel;
foreach (var childItem in navigationLinkWrapper.NestedItems)
{
if (!readContext.Request.Properties.ContainsKey(Dictionary))
{
readContext.Request.Properties.Add(Dictionary, new Dictionary <string, object>());
}
var dictionary = (Dictionary <string, object>)readContext.Request.Properties[Dictionary];
var navigationPropertyName = navigationLinkWrapper.NavigationLink.Name;
var entityReferenceLink = childItem as ODataEntityReferenceLinkBase;
if (entityReferenceLink != null)
{
Uri referencedEntityUrl = entityReferenceLink.EntityReferenceLink.Url;
if (referencedEntityUrl.IsAbsoluteUri)
{
referencedEntityUrl = referencedEntityUrl.MakeRelativeUri(readContext.Request.RequestUri);
}
var segments = referencedEntityUrl.OriginalString.Split(new[] { '(', ')' }, StringSplitOptions.RemoveEmptyEntries);
if (segments.Length != 2)
{
throw new ApplicationException($"Invalid @odata.bind: {referencedEntityUrl.OriginalString}");
}
var type = model.GetDataObjectType(segments[0]);
if (type == null)
{
throw new ApplicationException($"Invalid entity set: {segments[0]}");
}
Guid guid;
try
{
guid = new Guid(segments[1]);
}
catch (Exception)
{
throw new ApplicationException($"Invalid guid: {segments[1]}");
}
var linkedEdmEntity = new EdmEntityObject(model.GetEdmEntityType(type));
linkedEdmEntity.TrySetPropertyValue("__PrimaryKey", guid);
edmEntity.TrySetPropertyValue(navigationPropertyName, linkedEdmEntity);
if (!dictionary.ContainsKey(navigationPropertyName))
{
dictionary.Add(navigationPropertyName, navigationPropertyName);
}
}
var feed = childItem as ODataFeedWithEntries;
if (childItem == null || (feed != null && feed.Entries.Count == 0))
{
edmEntity.TrySetPropertyValue(navigationPropertyName, null);
if (!dictionary.ContainsKey(navigationPropertyName))
{
dictionary.Add(navigationPropertyName, null);
}
}
}
}
/// <summary>
/// Инициализирует словарь, представляющий объект данных <see cref="DataObject"/> в виде словаря <see cref="Dictionary{String,Object}"/>.
/// </summary>
/// <param name="dataObject">Объект данных, который нужно представить в виде словаря.</param>
/// <param name="dataObjectView">Представление, по которому определены свойства для конвертации объекта в словаря.</param>
/// <param name="model">Edm-модель, указанная в <see cref="ManagementToken"/>.</param>
/// <param name="serializeValues">Флаг: Нужно ли сериализовывать значения свойств объекта данных.</param>
public DataObjectDictionary(DataObject dataObject, View dataObjectView, DataObjectEdmModel model, bool serializeValues = false)
: base()
{
if (dataObject == null || dataObjectView == null)
{
return;
}
Type dataObjectType = dataObject.GetType();
Type viewDefinedType = dataObjectView.DefineClassType;
if (dataObjectType != viewDefinedType)
{
throw new ArgumentException(string.Format(
"Given view is defined for \"{0}\" type, but \"{1}\" is expected.",
viewDefinedType.Name,
dataObjectType.Name));
}
foreach (string propertyName in dataObjectView.GetSelfPrimitivePropertiesNames())
{
object propertyValue = Information.GetPropValueByName(dataObject, propertyName);
if (propertyValue != null && serializeValues)
{
if (propertyValue is KeyGuid)
{
propertyValue = ((KeyGuid)propertyValue).Guid;
}
else if (propertyValue is NullableDateTime)
{
propertyValue = ((NullableDateTime)propertyValue).Value.ToString("yyyy-MM-ddTHH:mm:ss.fffzzz");
}
else if (propertyValue is DateTime)
{
propertyValue = ((DateTime)propertyValue).ToString("yyyy-MM-ddTHH:mm:ss.fffzzz");
}
else if (propertyValue is NullableInt)
{
propertyValue = ((NullableInt)propertyValue).Value;
}
else if (propertyValue is NullableDecimal)
{
propertyValue = ((NullableDecimal)propertyValue).Value;
}
if (propertyValue is Geography)
{
GeoJsonObjectFormatter formatter = GeoJsonObjectFormatter.Create();
propertyValue = formatter.Write(propertyValue as Geography);
}
else
{
propertyValue = propertyValue.ToString();
}
}
var aliasPropertyName = model.GetEdmTypePropertyName(dataObjectType, propertyName);
Add(aliasPropertyName, propertyValue);
}
foreach (string masterName in dataObjectView.GetSelfMasterPropertiesNames())
{
DataObject master = (DataObject)Information.GetPropValueByName(dataObject, masterName);
View masterView = dataObjectView.GetSelfMasterView(masterName);
object masterValue = master != null
? new DataObjectDictionary(master, masterView, model, serializeValues)
: null;
var aliasMasterName = model.GetEdmTypePropertyName(dataObjectType, masterName);
Add(aliasMasterName, masterValue);
}
foreach (DetailInView detailInView in dataObjectView.Details)
{
List <DataObject> details = ((DetailArray)Information.GetPropValueByName(dataObject, detailInView.Name)).GetAllObjects().ToList();
var aliasDetailInViewName = model.GetEdmTypePropertyName(dataObjectType, detailInView.Name);
Add(aliasDetailInViewName, new DataObjectDictionaryCollection(details, detailInView.View, model, serializeValues));
}
}
/// <summary>
/// Осуществляет преобразование объекта данных <see cref="DataObject"/> в JSON-строку.
/// </summary>
/// <param name="dataObject">Преобразуемый объект данных.</param>
/// <param name="dataObjectView">Представление, по которому будет преобразован объект данных.</param>
/// <returns>JSON-строка, представляющая объект данных.</returns>
public static string ToJson(this DataObject dataObject, View dataObjectView, DataObjectEdmModel model)
{
return(new JavaScriptSerializer().Serialize(new DataObjectDictionary(dataObject, dataObjectView, model, true)));
}
/// <summary>
/// Инициализирует словарь, представляющий объект данных <see cref="DataObject"/> в виде словаря <see cref="Dictionary{String,Object}"/>.
/// </summary>
/// <remarks>
/// Используется для преобразования типов значений из словаря, полученного через стандартный десериализатор.
/// </remarks>
/// <param name="dataObjectAliases">Объект данных, в виде словаря псевдонимов.</param>
/// <param name="dataObjectView">Представление, по которому определены свойства для конвертации объекта в словарь.</param>
/// <param name="model">Edm-модель, указанная в ManagementToken.</param>
/// <param name="serializeValues">Флаг: Нужно ли сериализовывать значения свойств объекта.</param>
private DataObjectDictionary(Dictionary <string, object> dataObjectAliases, View dataObjectView, DataObjectEdmModel model, bool serializeValues = false)
: base()
{
if (dataObjectAliases == null || dataObjectView == null)
{
return;
}
Type dataObjectType = dataObjectView.DefineClassType;
List <string> viewAllPropertiesNames = dataObjectView.GetSelfAllPropertiesNames();
if (dataObjectAliases.Keys.Count != viewAllPropertiesNames.Count)
{
throw new Exception(string.Format(
"Received dataObject properties count is different from expected count. Received {0}, but {1} is expected.",
dataObjectAliases.Keys.Count,
viewAllPropertiesNames.Count));
}
for (int i = 0; i < dataObjectAliases.Keys.Count; i++)
{
string aliasPropertyName = dataObjectAliases.Keys.ElementAt(i);
string dataObjectPropertyName = model.GetDataObjectPropertyName(dataObjectType, aliasPropertyName);
if (!viewAllPropertiesNames.Contains(dataObjectPropertyName))
{
throw new Exception(string.Format(
"Received dataObject contains unexpected property. Property name is \"{0}\", but expected properties are: {1}.",
dataObjectPropertyName,
string.Concat("\"", string.Join("\", \"", viewAllPropertiesNames), "\"")));
}
object dataObjectPropertyValue = dataObjectAliases[aliasPropertyName];
Type dataObjectPropertyType = Information.GetPropertyType(dataObjectView.DefineClassType, dataObjectPropertyName);
if (dataObjectPropertyType.IsSubclassOf(typeof(DataObject)))
{
Dictionary <string, object> master = dataObjectPropertyValue as Dictionary <string, object>;
Add(aliasPropertyName, master != null ? new DataObjectDictionary(master, dataObjectView.GetSelfMasterView(dataObjectPropertyName), model, serializeValues) : null);
continue;
}
if (dataObjectPropertyType.IsSubclassOf(typeof(DetailArray)))
{
Dictionary <string, object>[] details = (dataObjectPropertyValue as ArrayList)?.Cast <Dictionary <string, object> >().ToArray()
?? new Dictionary <string, object>[] { };
DataObjectDictionary[] detailsDictionaries = details
.Select(x => new DataObjectDictionary(x, dataObjectView.GetDetail(dataObjectPropertyName).View, model, serializeValues))
.ToArray();
DataObjectDictionaryCollection detailsCollection = new DataObjectDictionaryCollection();
detailsCollection.AddRange(detailsDictionaries);
Add(aliasPropertyName, detailsCollection);
continue;
}
if (serializeValues)
{
Add(aliasPropertyName, dataObjectPropertyValue?.ToString());
continue;
}
if (dataObjectPropertyValue == null)
{
Add(aliasPropertyName, null);
continue;
}
Type actualPropertyType = dataObjectPropertyValue.GetType();
if (actualPropertyType == dataObjectPropertyType)
{
Add(aliasPropertyName, dataObjectPropertyValue);
continue;
}
if (dataObjectPropertyType.IsEnum && actualPropertyType == typeof(string))
{
Add(aliasPropertyName, Enum.Parse(dataObjectPropertyType, (string)dataObjectPropertyValue));
continue;
}
MethodInfo dataObjectPropertyParseMethod = dataObjectPropertyType.GetMethod("Parse", new[] { typeof(string) });
if (dataObjectPropertyParseMethod != null && actualPropertyType == typeof(string))
{
Add(aliasPropertyName, dataObjectPropertyParseMethod.Invoke(null, new[] { dataObjectPropertyValue }));
continue;
}
ConstructorInfo dataObjectPropertyConstructor = dataObjectPropertyType.GetConstructor(new[] { actualPropertyType });
if (dataObjectPropertyConstructor != null)
{
Add(aliasPropertyName, dataObjectPropertyConstructor.Invoke(new[] { dataObjectPropertyValue }));
continue;
}
}
}
/// <summary>
/// Создает новый словарь, представляющий объект данных <see cref="DataObject"/>.
/// </summary>
/// <remarks>
/// Типы значений в словаре, будут совпадают с типами значений в объекте данных.
/// </remarks>
/// <param name="jsonDataObject">Строка, содержащая объект данных в формате JSON.</param>
/// <param name="dataObjectView">Представление, по которому определены свойства для конвертации объекта в словарь.</param>
/// <param name="model">Edm-модель, указанная в ManagementToken.</param>
/// <param name="castValues">Флаг: нужно ли приводить типы значений к типам объекта данных.</param>
/// <returns>Новый словарь, представляющий объект данных <see cref="DataObject"/>.</returns>
public static DataObjectDictionary Parse(string jsonDataObject, View dataObjectView, DataObjectEdmModel model, bool castValues = true)
{
if (jsonDataObject == null || dataObjectView == null)
{
return(new DataObjectDictionary());
}
Dictionary <string, object> result = new JavaScriptSerializer().Deserialize <Dictionary <string, object> >(jsonDataObject);
result.Keys.Where(x => x.StartsWith(MetaDataPrefix)).ToList().ForEach(x => result.Remove(x));
return(new DataObjectDictionary(result, dataObjectView, model, !castValues));
}
/// <summary>
/// Инициализирует коллекцию объектов данных, представленных в виде словарей.
/// </summary>
/// <param name="dataObjects">Коллекция объектов данных.</param>
/// <param name="dataObjectsView">Представление, по которому определены свойства для конвертации объектов в коллекцию словарей.</param>
/// <param name="model">Edm-модель, указанная в <see cref="ManagementToken"/>.</param>
/// <param name="serializeValues">Флаг: Нужно ли сериализовывать значения свойств объекта данных.</param>
public DataObjectDictionaryCollection(List <DataObject> dataObjects, View dataObjectsView, DataObjectEdmModel model, bool serializeValues = false)
: base()
{
if (dataObjects == null || dataObjectsView == null)
{
return;
}
dataObjects.ForEach(x => Add(new DataObjectDictionary(x, dataObjectsView, model, serializeValues)));
}
public static Task <HttpResponseMessage> GetAsync(this HttpClient httpClient, DataObjectEdmModel model, Type dataObjectType, string lockUserName = null)
{
IPrincipal currentPrincipal = null;
try
{
if (lockUserName != null)
{
currentPrincipal = Thread.CurrentPrincipal;
Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity(lockUserName), null);
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Flexberry-Sync", "Lock");
}
return(httpClient.GetAsync(model.GetEdmEntitySet(dataObjectType).Name));
}
finally
{
if (lockUserName != null)
{
Thread.CurrentPrincipal = currentPrincipal;
httpClient.DefaultRequestHeaders.Remove("Flexberry-Sync");
}
}
}
/// <summary>
/// Создает новую коллекцию словарей, представляющую объекты данных <see cref="DataObject"/>.
/// </summary>
/// <remarks>
/// Типы значений в словарях коллекции, будут совпадать с типами значений в объектах данных.
/// </remarks>
/// <param name="jsonDataObjects">Строка, содержащая массив объектов данных в формате JSON (массив должен быть доступен по ключу "value").</param>
/// <param name="dataObjectsView">Представление, по которому определены свойства для конвертации объектов в коллекцию словарей.</param>
/// <param name="model">Edm-модель, указанная в ManagementToken.</param>
/// <param name="castValues">Флаг: нужно ли приводить типы значений к типам объекта данных.</param>
/// <returns>Новая коллекция словарей, представляющая объекты данных <see cref="DataObject"/>.</returns>
public static DataObjectDictionaryCollection Parse(string jsonDataObjects, View dataObjectsView, DataObjectEdmModel model, bool castValues = true)
{
DataObjectDictionaryCollection result = new DataObjectDictionaryCollection();
if (jsonDataObjects == null || dataObjectsView == null)
{
return(result);
}
JavaScriptSerializer serializer = new JavaScriptSerializer();
Dictionary <string, object> dictionary = serializer.Deserialize <Dictionary <string, object> >(jsonDataObjects);
object value;
if (dictionary.TryGetValue("value", out value) && value is ArrayList)
{
Dictionary <string, object>[] dataObjects = ((ArrayList)value).Cast <Dictionary <string, object> >().ToArray();
DataObjectDictionary[] dataObjectsDictionaries = dataObjects
.Select(x => DataObjectDictionary.Parse(serializer.Serialize(x), dataObjectsView, model, castValues))
.ToArray();
result.AddRange(dataObjectsDictionaries);
}
else
{
result.Add(DataObjectDictionary.Parse(jsonDataObjects, dataObjectsView, model, castValues));
}
return(result);
}
/// <summary>
/// Осуществляет получение типа объекта данных, соответствующего заданному имени набора сущностей в EDM-модели.
/// </summary>
/// <param name="edmEntitySetName">Имя набора сущностей в EDM-модели, для которого требуется получить представление по умолчанию.</param>
/// <returns>Типа объекта данных, соответствующий заданному имени набора сущностей в EDM-модели.</returns>
public Type GetDataObjectType(string edmEntitySetName)
{
DataObjectEdmModel model = (DataObjectEdmModel)_controller.QueryOptions.Context.Model;
return(model.GetDataObjectType(edmEntitySetName));
}
public static void PrepareHttpResponseMessage(ref HttpResponseMessage msg, string mediaType, DataObjectEdmModel model, byte[] buffer)
{
List <IEdmEntityObject> edmObjList = new List <IEdmEntityObject>();
var edmObj = new EdmEntityObject(model.GetEdmEntityType(typeof(DataObject)));
edmObj.TrySetPropertyValue("__PrimaryKey", buffer);
edmObjList.Add(edmObj);
IEdmCollectionTypeReference entityCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(edmObj.GetEdmType()));
EdmEntityObjectCollection collection = new EdmEntityObjectCollection(entityCollectionType, edmObjList);
msg.Content = new ObjectContent(typeof(EdmEntityObjectCollection), collection, new RawOutputFormatter(), mediaType);
}
