public void SendsFilter()
{
m_modelUpdater.Start();
m_modelUpdater.GetNewModel();
WaitAndGetNewModel();
Assert.Null(CoreLink.Filter);
var modelFilter = new ModelFilter
{
Boxes = { new FilterBox(new Vector3(1, 2, 3), new Vector3(4, 5, 6)) }
};
m_modelUpdater.Filter = modelFilter;
// This allows the updater to provide the already received modelResponse.
WaitAndGetNewModel();
// Now the updater is sending the filter, wait for the filtered model (we don't need it, but it guarantees the request to have been made).
WaitAndGetNewModel();
WaitAndGetNewModel();
// Only now can we check if it was sent (there is a race condition before the second wait).
Assert.NotNull(CoreLink.Filter);
m_modelUpdater.Stop();
}
public void WhenFilterContainSortDescriptionWithoutDirectionThenCreatesMatchingAscendingSortDescription()
{
const string Orderstring = "IntValue";
var descriptions = _factory.Create<FakeItem>(Orderstring);
var filter = new ModelFilter<FakeItem>(x => true, null, descriptions, 0, -1, false);
var sortedItems = filter.Filter(_items)
.ToArray();
Assert.AreEqual(
1,
sortedItems.OfType<FakeItem>()
.ElementAt(0)
.IntValue);
Assert.AreEqual(
2,
sortedItems.OfType<FakeItem>()
.ElementAt(1)
.IntValue);
Assert.AreEqual(
3,
sortedItems.OfType<FakeItem>()
.ElementAt(2)
.IntValue);
}
public void Filter_by_name_space_Test()
{
//Arrange
var ct = new List <ClassTemplate>
{
new ClassTemplate {
Name = "entity1", NameSpace = "NameSpace1"
},
new ClassTemplate {
Name = "entity2", NameSpace = "NameSpace1"
},
new ClassTemplate {
Name = "entityzz3", NameSpace = "NameSpace2"
},
};
//Act
var filter = new List <string> {
"NameSpace1.*"
};
var result = ModelFilter.FilterList(ct, filter).Select(x => x.Name);
//Assert
var expected = new[] { "entity1", "entity2" };
Assert.That(result, Is.EquivalentTo(expected));
}
public void WhenOrderingByChildPropertyThenUsesChildProperty()
{
const string Orderstring = "StringValue/Length desc";
var descriptions = _factory.Create <FakeItem>(Orderstring);
var filter = new ModelFilter <FakeItem>(x => true, null, descriptions, 0, -1, false);
var sortedItems = filter.Filter(_items)
.ToArray();
Assert.AreEqual(
"aaa",
sortedItems.OfType <FakeItem>()
.ElementAt(0)
.StringValue);
Assert.AreEqual(
"aa",
sortedItems.OfType <FakeItem>()
.ElementAt(1)
.StringValue);
Assert.AreEqual(
"a",
sortedItems.OfType <FakeItem>()
.ElementAt(2)
.StringValue);
}
public void WhenFilterContainsSortMultipleDescriptionsWithSpaceBetweenThenSortsByAll()
{
const string Orderstring = "DoubleValue, IntValue desc";
var descriptions = _factory.Create <FakeItem>(Orderstring);
var filter = new ModelFilter <FakeItem>(x => true, null, descriptions, 0, -1, false);
var sortedItems = filter.Filter(_items)
.ToArray();
Assert.AreEqual(
3,
sortedItems.OfType <FakeItem>()
.ElementAt(0)
.IntValue);
Assert.AreEqual(
1,
sortedItems.OfType <FakeItem>()
.ElementAt(1)
.IntValue);
Assert.AreEqual(
2,
sortedItems.OfType <FakeItem>()
.ElementAt(2)
.IntValue);
}
public PagedResultDto <ModelDto> GetModels(ModelFilter input)
{
var query = modelRepository.GetAll().Where(x => !x.IsDelete);
// filter by value
if (input.model != null)
{
query = query.Where(x => x.model.ToLower().Equals(input.model));
}
var totalCount = query.Count();
// sorting
if (!string.IsNullOrWhiteSpace(input.Sorting))
{
query = query.OrderBy(input.Sorting);
}
// paging
var items = query.PageBy(input).ToList();
// result
return(new PagedResultDto <ModelDto>(
totalCount,
items.Select(item => ObjectMapper.Map <ModelDto>(item)).ToList()));
}
public void WhenFilterContainSortDescriptionWithoutDirectionThenCreatesMatchingAscendingSortDescription()
{
const string Orderstring = "IntValue";
var descriptions = _factory.Create <FakeItem>(Orderstring);
var filter = new ModelFilter <FakeItem>(x => true, null, descriptions, 0, -1, false);
var sortedItems = filter.Filter(_items)
.ToArray();
Assert.AreEqual(
1,
sortedItems.OfType <FakeItem>()
.ElementAt(0)
.IntValue);
Assert.AreEqual(
2,
sortedItems.OfType <FakeItem>()
.ElementAt(1)
.IntValue);
Assert.AreEqual(
3,
sortedItems.OfType <FakeItem>()
.ElementAt(2)
.IntValue);
}
public async Task <IEnumerable <Model> > GetAsync(ModelFilter modelFilter)
{
try
{
int top = modelFilter.Top.HasValue ? modelFilter.Top.Value : 20;
int skip = modelFilter.Skip.HasValue ? modelFilter.Skip.Value : 0;
/*TODO: guardar el valor 20 y 0 en el appsettings.json*/
object param = new { End = top, Start = skip };
string query = @"SELECT * FROM
( SELECT *
from models
) SubQueryAlias
order by name desc
OFFSET @Start ROWS -- skip 10 rows
FETCH NEXT @End ROWS ONLY; -- take 10 rows";
if (!string.IsNullOrEmpty(modelFilter.Patt) && modelFilter.BrandId.HasValue)
{
param = new { End = top, Start = skip, Name = modelFilter.Patt, BrandId = modelFilter.BrandId.Value };
query = @"SELECT * FROM
( SELECT *
from models
where name like @Name
and brandId = @BrandId
) SubQueryAlias
order by name desc
OFFSET @Start ROWS
FETCH NEXT @End ROWS ONLY";
}
else if (!string.IsNullOrEmpty(modelFilter.Patt))
{
param = new { End = top, Start = skip, Name = modelFilter.Patt };
query = @"SELECT * FROM
( SELECT *
from models
where name like @Name
) SubQueryAlias
order by name desc
OFFSET @Start ROWS
FETCH NEXT @End ROWS ONLY";
}
else if (modelFilter.BrandId.HasValue)
{
param = new { End = top, Start = skip, BrandId = modelFilter.BrandId.Value };
query = @"SELECT * FROM
( SELECT *
from models
where brandId = @BrandId
) SubQueryAlias
order by name desc
OFFSET @Start ROWS
FETCH NEXT @End ROWS ONLY";
}
return(await _sqlDapper.GetAsync(query, param));
}
catch (Exception ex)
{
_logger.LogError(ex, "ModelRepository/GetAsync");
throw ex;
}
}
/// <summary>
/// Creates the configuration controls of this component.
/// </summary>
public static void AddControls(ModelFilter modelFilter, ClipControl owner)
{
// Model
var model = CommonControls.AssetSelector<Model>("Model", owner, modelFilter, "Model");
model.Top = 10;
owner.AdjustHeightFromChildren();
} // AddControls
public void WritesReadsGetModel()
{
var position = new Vector3(1, 2, 3);
var size = new Vector3(4, 5, 6);
var filter = new ModelFilter
{
Boxes = { new FilterBox(position, size) }
};
var observerDefinitions = new List <ObserverDefinition>
{
new ObserverDefinition(1, 2, "foofighter")
};
var message = GetModelRequestBuilder.Build(full: true, filter: filter, observerRequests: observerDefinitions);
Assert.Equal(Request.GetModelRequest, message.RequestType);
GetModelRequest getModelRequest = message.GetRequest(new GetModelRequest());
Assert.True(getModelRequest.Full);
Assert.Equal(position, getModelRequest.Filter.GetBoxes(0).Position());
Assert.Equal(size, getModelRequest.Filter.GetBoxes(0).Size());
var requestedObserver = getModelRequest.GetObservers(0);
Assert.Equal((uint)1, requestedObserver.NeuronId.Neuron);
Assert.Equal((uint)2, requestedObserver.NeuronId.Region);
Assert.Equal("foofighter", requestedObserver.Type);
}
public void Filter_by_name_Test()
{
// Arrange
var ct = new List <ClassTemplate>
{
new ClassTemplate {
Name = "entity1"
},
new ClassTemplate {
Name = "entity2"
},
new ClassTemplate {
Name = "entity3"
},
};
var filter = new List <string> {
"entity1"
};
//Act
var sut = ModelFilter.FilterList(ct, filter).Select(x => x.Name);
//Assert
var expected = new[] { "entity1" };
Assert.That(sut, Is.EquivalentTo(expected));
}
public GetModelListMessage(Request MyRequest)
{
try
{
_Environment = MyRequest._EnvironmentSelected;
GetService(MyRequest);
_ModelFilter = new ModelFilter();
_ModelFilter.CategoryCodeList = MyRequest._Parameters["Values"].Split(';');
var _ModelListMessage = _MarketplaceAPIService.GetModelListAsync(MyRequest._HeaderMessage, _ModelFilter);
if (_ModelListMessage != null)
{
if (_ModelListMessage.Result != null)
{
_ErrorMessage = _ModelListMessage.Result.ErrorMessage;
if (_ModelListMessage.Result.ErrorList != null)
{
_ErrorList = _ModelListMessage.Result.ErrorList;
}
}
}
_RequestXML = _RequestInterceptor.LastRequestXML;
_MessageXML = _RequestInterceptor.LastResponseXML;
}
catch (System.Exception ex)
{
_OperationSuccess = false;
_ErrorMessage = ex.Message;
_ErrorType = ex.HelpLink;
}
}
/// <summary>
/// Prepares query for execution by appending projection expression
/// </summary>
/// <param name="context">The context to execute against</param>
/// <returns>The prepared but unexecuted query</returns>
protected virtual UntypedQueryable <T> PrepareQuery(IDataContext context)
{
Context = context;
CheckContextAndQuery(ContextQuery);
IQueryable <T> query = ExtendQuery();
var preppedQuery = AppendExpressions(query);
return(ModelFilter.Project(preppedQuery));
}
public static RequestMessage Build(bool full, ModelFilter filter = null, IList <ObserverDefinition> observerRequests = null)
{
var builder = new FlatBufferBuilder(RequestMessageBuilder.BufferInitialSize);
Offset <Filter>?filterOffset = null;
if (filter != null)
{
var boxes = new Offset <Box3D> [filter.Boxes.Count];
filter.Boxes.EachWithIndex((i, box) =>
{
boxes[i] = Box3D.CreateBox3D(builder,
box.LowerBound.X,
box.LowerBound.Y,
box.LowerBound.Z,
box.Size.X,
box.Size.Y,
box.Size.Z);
});
VectorOffset boxesOffset = Filter.CreateBoxesVector(builder, boxes);
filterOffset = Filter.CreateFilter(builder, boxesOffset);
}
VectorOffset?observersVectorOffset = null;
if (observerRequests != null)
{
var observerOffsets = new Offset <Observer> [observerRequests.Count()];
observerRequests.EachWithIndex((i, definition) =>
{
Offset <NeuronId> neuronId = NeuronId.CreateNeuronId(builder, definition.NeuronIndex,
definition.RegionIndex);
StringOffset observerType = builder.CreateString(definition.Type);
observerOffsets[i] = Observer.CreateObserver(builder, neuronId, observerType);
});
observersVectorOffset = GetModelRequest.CreateObserversVector(builder, observerOffsets);
}
GetModelRequest.StartGetModelRequest(builder);
GetModelRequest.AddFull(builder, full);
if (filterOffset.HasValue)
{
GetModelRequest.AddFilter(builder, filterOffset.Value);
}
if (observersVectorOffset.HasValue)
{
GetModelRequest.AddObservers(builder, observersVectorOffset.Value);
}
Offset <GetModelRequest> requestOffset = GetModelRequest.EndGetModelRequest(builder);
return(RequestMessageBuilder.Build(builder, Request.GetModelRequest, requestOffset));
}
public void WhenFilterIsEmptyThenDoesNotSort()
{
var descriptions = _factory.Create <AliasItem>(string.Empty);
var filter = new ModelFilter <AliasItem>(x => true, null, descriptions, 0, -1, false);
var sortedItems = filter.Filter(_items)
.ToArray();
Assert.AreEqual(2, sortedItems.OfType <AliasItem>().ElementAt(0).AliasIntValue);
Assert.AreEqual(1, sortedItems.OfType <AliasItem>().ElementAt(1).AliasIntValue);
Assert.AreEqual(3, sortedItems.OfType <AliasItem>().ElementAt(2).AliasIntValue);
}
public GetModelListMessage(Request MyRequest)
{
_Environment = MyRequest._EnvironmentSelected;
GetService();
_ModelFilter = new ModelFilter();
_ModelFilter.CategoryCodeList = MyRequest._Parameters["Values"].Split(';');
var _ProductListMessage = _MarketplaceAPIService.GetModelListAsync(MyRequest._HeaderMessage, _ModelFilter);
XmlSerializer xmlSerializer = new XmlSerializer(_ProductListMessage.Result.GetType());
_RequestXML = _RequestInterceptor.LastRequestXML;
_MessageXML = _RequestInterceptor.LastResponseXML;
}
public async Task <IEnumerable <Model> > GetAsync(ModelFilter modelFilter)
{
try
{
return(await _modelRepository.GetAsync(modelFilter));
}
catch (Exception ex)
{
_logger.LogError(ex, $@"Error in Models params
Skip={modelFilter.Skip}
Top={modelFilter.Top}
Patt={modelFilter.Patt}
BrandId={modelFilter.BrandId}");
throw ex;
}
}
private ModelFilter Items_BuildFilter()
{
ModelFilter filter = new ModelFilter(delegate (object x) {
bool search, hideExpiring;
search = hideExpiring = true;
if (items_checkBox_hideExpiring.Checked)
hideExpiring = !((Item)x).Name.ToLower().Contains('(');
if (!string.IsNullOrEmpty(itemSearch)) search = ((Item)x).Name.ToLower().Contains(itemSearch);
return search && hideExpiring;
});
return filter;
}
public string GetQuery()
{
List <string> queries = new List <string>();
if (!string.IsNullOrEmpty(SerialNumberFilter))
{
queries.Add($"x.SerialNumber.ToLower().StartsWith(\"{ SerialNumberFilter.ToLower() }\")");
}
if (!string.IsNullOrEmpty(ModelFilter))
{
queries.Add($"x.Model.Name.ToLower().StartsWith(\"{ ModelFilter.ToLower() }\")");
}
if (!string.IsNullOrEmpty(ClassificationFilter))
{
queries.Add($"x.Classification.Model.ToLower().StartsWith(\"{ ClassificationFilter.ToLower() }\")");
}
if (!string.IsNullOrEmpty(LastUpdateFilter))
{
if (DateTime.TryParse(LastUpdateFilter, out var result))
{
queries.Add($"DateTime.Parse(x.LastUpdate) >= DateTime.Parse(\"{result.ToString("MM/dd/yyyy")}\")");
}
}
if (!string.IsNullOrEmpty(EventsCountFilter))
{
queries.Add($"x.DeviceEvents.Count() >= { EventsCountFilter }");
}
if (!string.IsNullOrEmpty(LastStatusFilter))
{
queries.Add($"x.LastStatus.ToLower().StartsWith(\"{LastStatusFilter.ToLower()}\")");
}
string query = InitializeQuery;
if (queries.Count > 0)
{
query += string.Join(" && ", queries);
}
return(queries.Count == 0 ? string.Empty : query);
}
/// <summary>
/// Parses the passes query parameters to a <see cref="ModelFilter{T}"/>.
/// </summary>
/// <param name="queryParameters"></param>
/// <returns></returns>
public IModelFilter <T> Parse(NameValueCollection queryParameters)
{
var orderbyField = queryParameters[StringConstants.OrderByParameter];
var selects = queryParameters[StringConstants.SelectParameter];
var filter = queryParameters[StringConstants.FilterParameter];
var skip = queryParameters[StringConstants.SkipParameter];
var top = queryParameters[StringConstants.TopParameter];
var filterExpression = m_filterExpressionFactory.Create <T>(filter);
var sortDescriptions = m_sortExpressionFactory.Create <T>(orderbyField);
var selectFunction = m_selectExpressionFactory.Create(selects);
var modelFilter = new ModelFilter <T>(
filterExpression,
selectFunction,
sortDescriptions,
skip.IsNullOrWhiteSpace() ? -1 : Convert.ToInt32(skip),
top.IsNullOrWhiteSpace() ? -1 : Convert.ToInt32(top));
return(modelFilter);
}
/// <summary>
/// Parses the passes query parameters to a <see cref="ModelFilter{T}"/>.
/// </summary>
/// <param name="queryParameters"></param>
/// <returns></returns>
public IModelFilter <T> Parse(IEnumerable <KeyValuePair <string, string> > queryParameters)
{
var orderbyField = queryParameters.GetValue(StringConstants.OrderByParameter).FirstOrDefault();
var selects = queryParameters.GetValue(StringConstants.SelectParameter).FirstOrDefault();
var filter = queryParameters.GetValue(StringConstants.FilterParameter).FirstOrDefault();
var skip = queryParameters.GetValue(StringConstants.SkipParameter).FirstOrDefault();
var top = queryParameters.GetValue(StringConstants.TopParameter).FirstOrDefault();
var filterExpression = _filterExpressionFactory.Create <T>(filter);
var sortDescriptions = _sortExpressionFactory.Create <T>(orderbyField);
var selectFunction = _selectExpressionFactory.Create(selects);
var modelFilter = new ModelFilter <T>(
_settings,
filterExpression,
selectFunction,
sortDescriptions,
string.IsNullOrWhiteSpace(skip) ? -1 : Convert.ToInt32(skip),
string.IsNullOrWhiteSpace(top) ? -1 : Convert.ToInt32(top));
return(modelFilter);
}
private void ShowIssues()
{
// Create a new filter based on the searchbox
var tmfilter = TextMatchFilter.Contains(objectListView1, TxtSearch.Text);
ModelFilter prfilter;
if (checkBoxShowPrs.Checked == true)
{
// Keep everything
prfilter = new ModelFilter(delegate(object x) { return(true); });
}
else
{
// Filter out pull requests
prfilter = new ModelFilter(delegate(object x) { return(!((TurtleIssue)x).IsPullRequest); });
}
var combfilter = new CompositeAllFilter(new List <IModelFilter> {
tmfilter, prfilter
});
objectListView1.ModelFilter = combfilter;
objectListView1.DefaultRenderer = new HighlightTextRenderer(tmfilter);
}
public void HistoryFilter()
{
if (chbFrom.Checked && chbTo.Checked)
{
filterHistory = new ModelFilter(delegate(object x) { return(((LogItem)x).Date > dtFrom.Value && ((LogItem)x).Date < dtTo.Value); });
}
else if (chbFrom.Checked)
{
filterHistory = new ModelFilter(delegate(object x) { return(((LogItem)x).Date > dtFrom.Value); });
}
else if (chbTo.Checked)
{
filterHistory = new ModelFilter(delegate(object x) { return(((LogItem)x).Date < dtTo.Value); });
}
else
{
filterHistory = new ModelFilter(delegate(object x) { return(true); });
}
olvLog.UseFiltering = true;
olvLog.ModelFilter = new CompositeAllFilter(new List <IModelFilter> {
filterDesc, filterLevel, filterDevice, filterHistory
});
}
public PagedResultDto <ModelDto> GetModelByFilter(ModelFilter modelFilter)
{
return(modelAppService.GetModels(modelFilter));
}
internal ModelFilterChangedEventArgs(ModelFilter filter)
{
this.filter = filter;
}
public GetModelListRequest()
{
_ModelFilter = new ModelFilter();
_Parameters.Add("Code Category", "");
}
public MemoryPart(Part part, VesselControl vesselControl)
{
kspPart = part;
byteCount = 0;
name = part.name;
uniqueID = part.gameObject.GetInstanceID();
try
{
parentID = part.parent.gameObject.GetInstanceID();
}
catch { Debug.Log(part.name + " does not have a parent"); }
var modelMeshes = part.FindModelComponents <MeshFilter>();
//var modelSkinnedMeshes = part.FindModelComponents<SkinnedMeshRenderer>();
// var combinedArray = new Mesh[modelMeshes.Count + modelSkinnedMeshes.Count];
// modelMeshes.CopyTo(combinedArray);
offset = vesselControl.adjustedVessel.InverseTransformPoint(part.transform.position);//vesselControl.adjustedVessel.InverseTransformPoint(filter.transform.position);
var tempParent = part.transform.parent;
part.transform.SetParent(vesselControl.adjustedVessel);//vesselControl.vesselCOM);
// var rotOffset = Quaternion.Inverse(part.vessel.vesselTransform.rotation) * filter.transform.rotation;
rotOffset = part.transform.localEulerAngles;
part.transform.SetParent(tempParent);
meshList = new List <ModelFilter>();
//for uniqueID
byteCount += 4;
//for parent uniqueID
byteCount += 4;
//for meshfilter count
byteCount += 4;
//for localPosition vector3
byteCount += 12;
//for localRot vector3
byteCount += 12;
//for part name string count
byteCount += 4;
//for part name
nameBytePackage = Encoding.ASCII.GetBytes(name);
byteCount += nameBytePackage.Length;
foreach (var filter in modelMeshes)
{
Debug.Log(filter.transform.name + " filter found on part " + part.name);
bool serialize = false;
if (!filter.name.ToLower().Contains("col"))
{
var gearModule = part.GetComponent <ModuleWheelBase>();
if (!gearModule)
{
serialize = true;
}
}
else
{
var engineModule = part.GetComponent <ModuleEngines>();
if (engineModule)
{
serialize = true;
}
}
if (serialize)
{
ModelFilter modelFilter = new ModelFilter();
byteCount += 12;
byteCount += 12;
byteCount += 12;
modelFilter.vesselPartOffset = part.transform.InverseTransformPoint(filter.transform.position); //vesselControl.adjustedVessel.InverseTransformPoint(filter.transform.position);
tempParent = filter.transform.parent;
filter.transform.SetParent(part.transform); //vesselControl.vesselCOM);
// var rotOffset = Quaternion.Inverse(part.vessel.vesselTransform.rotation) * filter.transform.rotation;
modelFilter.vesselPartLocalEuler = filter.transform.localEulerAngles;
filter.transform.SetParent(tempParent);
modelFilter.lossyScale = filter.transform.lossyScale;
//for mesh length
byteCount += 4;
var mesh = filter.mesh;
modelFilter.byteArrMesh = MeshSerializer.WriteMesh(mesh, true);
meshList.Add(modelFilter);
byteCount += modelFilter.byteArrMesh.Length;
}
}
//Texture2D texture = part.FindModelComponent<MeshRenderer>().material.GetTexture("_MainTex") as Texture2D;
////var tex = new Texture2D(texture.height, texture.width, TextureFormat.RGB24, false);
////Graphics.ConvertTexture(texture, tex);
//Color32[] pix = texture.GetPixels32();
//System.Array.Reverse(pix);
//Texture2D destTex = new Texture2D(texture.width, texture.height);
//destTex.SetPixels32(pix);
//destTex.Apply();
//byteArrTexture = destTex.GetRawTextureData();
// byteCount = byteArrMesh.Length;// + byteArrTexture.Length;
// Debug.Log(part.name + " mesh byte length " + byteArrMesh.Length);
//byteArrayList.Add(MeshSerializer.WriteMesh(mesh, true));
}
private void ParseModel(IDictionary <string, SwaggerModel> models, Type modelType, string route, string verb)
{
if (IsSwaggerScalarType(modelType) || modelType.ExcludesFeature(Feature.Metadata))
{
return;
}
var modelId = GetModelTypeName(modelType, route, verb);
if (models.ContainsKey(modelId))
{
return;
}
var modelTypeName = GetModelTypeName(modelType);
var model = new SwaggerModel
{
Id = modelId,
Description = modelType.GetDescription() ?? modelTypeName,
Properties = new OrderedDictionary <string, SwaggerProperty>()
};
models[model.Id] = model;
var properties = modelType.GetProperties();
// Order model properties by DataMember.Order if [DataContract] and [DataMember](s) defined
// Ordering defined by: http://msdn.microsoft.com/en-us/library/ms729813.aspx
var dataContractAttr = modelType.FirstAttribute <DataContractAttribute>();
if (dataContractAttr != null && properties.Any(prop => prop.IsDefined(typeof(DataMemberAttribute), true)))
{
var typeOrder = new List <Type> {
modelType
};
var baseType = modelType.BaseType;
while (baseType != null)
{
typeOrder.Add(baseType);
baseType = baseType.BaseType;
}
var propsWithDataMember = properties.Where(prop => prop.IsDefined(typeof(DataMemberAttribute), true));
var propDataMemberAttrs = properties.ToDictionary(prop => prop, prop => prop.FirstAttribute <DataMemberAttribute>());
properties = propsWithDataMember
.OrderBy(prop => propDataMemberAttrs[prop].Order) // Order by DataMember.Order
.ThenByDescending(prop => typeOrder.IndexOf(prop.DeclaringType)) // Then by BaseTypes First
.ThenBy(prop => // Then by [DataMember].Name / prop.Name
{
var name = propDataMemberAttrs[prop].Name;
return(name.IsNullOrEmpty() ? prop.Name : name);
}).ToArray();
}
var parseProperties = modelType.IsUserType();
if (parseProperties)
{
foreach (var prop in properties)
{
if (prop.HasAttribute <IgnoreDataMemberAttribute>())
{
continue;
}
var apiMembers = prop
.AllAttributes <ApiMemberAttribute>()
.OrderByDescending(attr => attr.Route)
.ToList();
var apiDoc = apiMembers
.Where(attr => string.IsNullOrEmpty(verb) || string.IsNullOrEmpty(attr.Verb) || (verb ?? "").Equals(attr.Verb))
.Where(attr => string.IsNullOrEmpty(route) || string.IsNullOrEmpty(attr.Route) || (route ?? "").StartsWith(attr.Route))
.FirstOrDefault(attr => attr.ParameterType == "body" || attr.ParameterType == "model");
if (apiMembers.Any(x => x.ExcludeInSchema))
{
continue;
}
var propertyType = prop.PropertyType;
var modelProp = new SwaggerProperty
{
Type = GetSwaggerTypeName(propertyType, route, verb),
Description = prop.GetDescription(),
};
if ((propertyType.IsValueType && !IsNullable(propertyType)) || apiMembers.Any(x => x.IsRequired))
{
if (model.Required == null)
{
model.Required = new List <string>();
}
model.Required.Add(prop.Name);
}
if (IsListType(propertyType))
{
modelProp.Type = SwaggerType.Array;
var listItemType = GetListElementType(propertyType);
modelProp.Items = new Dictionary <string, string> {
{ IsSwaggerScalarType(listItemType)
? "type"
: "$ref", GetSwaggerTypeName(listItemType, route, verb) }
};
ParseModel(models, listItemType, route, verb);
}
else if ((Nullable.GetUnderlyingType(propertyType) ?? propertyType).IsEnum)
{
var enumType = Nullable.GetUnderlyingType(propertyType) ?? propertyType;
if (enumType.IsNumericType())
{
var underlyingType = Enum.GetUnderlyingType(enumType);
modelProp.Type = GetSwaggerTypeName(underlyingType, route, verb);
modelProp.Enum = GetNumericValues(enumType, underlyingType).ToList();
}
else
{
modelProp.Type = SwaggerType.String;
modelProp.Enum = Enum.GetNames(enumType).ToList();
}
}
else
{
ParseModel(models, propertyType, route, verb);
var propAttr = prop.FirstAttribute <ApiMemberAttribute>();
if (propAttr != null)
{
if (propAttr.DataType != null)
{
modelProp.Type = propAttr.DataType;
}
if (propAttr.Format != null)
{
modelProp.Format = propAttr.Format;
}
}
}
if (apiDoc != null && modelProp.Description == null)
{
modelProp.Description = apiDoc.Description;
}
var allowableValues = prop.FirstAttribute <ApiAllowableValuesAttribute>();
if (allowableValues != null)
{
modelProp.Enum = GetEnumValues(allowableValues);
}
ModelPropertyFilter?.Invoke(modelProp);
model.Properties[GetModelPropertyName(prop)] = modelProp;
}
}
ModelFilter?.Invoke(model);
}
public GetModelConversation(bool full, ModelFilter filter = null, IList <ObserverDefinition> observerRequests = null)
{
RequestMessage = GetModelRequestBuilder.Build(full, filter, observerRequests);
}
public void WhenFilterContainsSortMultipleDescriptionsWithSpaceBetweenThenSortsByAll()
{
const string Orderstring = "DoubleValue, IntValue desc";
var descriptions = _factory.Create<AliasItem>(Orderstring);
var filter = new ModelFilter<AliasItem>(x => true, null, descriptions, 0, -1, false);
var sortedItems = filter.Filter(_items)
.ToArray();
Assert.AreEqual(3, sortedItems.OfType<AliasItem>().ElementAt(0).AliasIntValue);
Assert.AreEqual(1, sortedItems.OfType<AliasItem>().ElementAt(1).AliasIntValue);
Assert.AreEqual(2, sortedItems.OfType<AliasItem>().ElementAt(2).AliasIntValue);
}
public void WhenFilterIsEmptyThenDoesNotSort()
{
var descriptions = _factory.Create<AliasItem>(string.Empty);
var filter = new ModelFilter<AliasItem>(x => true, null, descriptions, 0, -1, false);
var sortedItems = filter.Filter(_items)
.ToArray();
Assert.AreEqual(2, sortedItems.OfType<AliasItem>().ElementAt(0).AliasIntValue);
Assert.AreEqual(1, sortedItems.OfType<AliasItem>().ElementAt(1).AliasIntValue);
Assert.AreEqual(3, sortedItems.OfType<AliasItem>().ElementAt(2).AliasIntValue);
}
public void WhenOrderingByChildPropertyThenUsesChildProperty()
{
const string Orderstring = "StringValue/Length desc";
var descriptions = _factory.Create<AliasItem>(Orderstring);
var filter = new ModelFilter<AliasItem>(x => true, null, descriptions, 0, -1, false);
var sortedItems = filter.Filter(_items)
.ToArray();
Assert.AreEqual("aaa", sortedItems.OfType<AliasItem>().ElementAt(0).StringValue);
Assert.AreEqual("aa", sortedItems.OfType<AliasItem>().ElementAt(1).StringValue);
Assert.AreEqual("a", sortedItems.OfType<AliasItem>().ElementAt(2).StringValue);
}
/// <summary>
/// 登录
/// </summary>
public HttpResult Login()
{
string name = HttpRequestData.FormString("user_name");
string pwd = HttpRequestData.Form <string>("user_pwd");
DBManipulator manipulator = DBConfigurator.OpenDBManipulator();
ModelFilter filter = new ModelFilter(typeof(C_ACCOUNT));
filter.PageQuery = new PagingQuery(5, 0);
//int count = manipulator.SelectCount(typeof(C_ACCOUNT));
//filter.AndParam("USER_NAME", name);
//filter.AndParam("USER_PWD", pwd);
//filter.PageQuery = new PagingQuery() { PageCount = 5, PageIndex = 0 };
//CModel cm = new CModel(typeof(C_ACCOUNT));
//C_ACCOUNT xincm = manipulator.GetModelByKey<C_ACCOUNT>(43);
//DateTime st = xincm.CREATE_DATE;
List <CModel> cs = manipulator.GetModels(filter);
//C_ACCOUNT model = manipulator.GetModel<C_ACCOUNT>(filter);
//string c_json1 = JsonConverter.JsonSerializer<C_ACCOUNT>(model);
//C_ACCOUNT c_json2 = JsonConverter.JsonDeserialize<C_ACCOUNT>(c_json1);
//CModel cmodel = manipulator.GetModel(filter);
//string c_json3 = JsonConverter.CModelToJson(cmodel);
//CModel c_json4 = JsonConverter.JsonToCModel(c_json3);
//C_ACCOUNT dsa = JsonConverter.CModelToModel<C_ACCOUNT>(c_json4);
//CModel cmode = manipulator.GetModelByKey("C_ACCOUNT", 43);
//CModel cmodel = manipulator.GetModel(filter);
//CModel col = new CModel();
//col["user"] = "******";
//col["pwd"] = "123";
//List<CModel> firends = new List<CModel>();
//firends.Add(cmodel);
//firends.Add(cmodel);
//col["firends"] = firends;
//List<string> familys = new List<string>();
//familys.Add("aa");
//familys.Add("bb");
//familys.Add("dd");
//col["familys"] = familys;
//CModel col1 = new CModel();
//col1["user"] = "******";
//col1["pwd"] = "123";
//col1["firends"] = firends;
//col1["familys"] = familys;
//col1["col"] = col;
//col1["col1"] = col;
//CModelList<C_ACCOUNT> models = new CModelList<C_ACCOUNT>();
//foreach (var item in models)
//{
//}
return(WebResponse.Result(""));
}
