protected override void OnModelCreating(ModelBuilder modelBuilder)
{
OperationLogMap.SetConfig(modelBuilder.Entity <OperationLog>());
OrderAttachmentMap.SetConfig(modelBuilder.Entity <OrderAttachment>());
OrderItemMap.SetConfig(modelBuilder.Entity <OrderItem>());
OrderItemTouristMap.SetConfig(modelBuilder.Entity <OrderItemTourist>());
OrderMap.SetConfig(modelBuilder.Entity <Order>());
RefundItemMap.SetConfig(modelBuilder.Entity <RefundItem>());
RefundMap.SetConfig(modelBuilder.Entity <Refund>());
RefundTouristMap.SetConfig(modelBuilder.Entity <RefundTourist>());
RequirementItemMap.SetConfig(modelBuilder.Entity <RequirementItem>());
RequirementMap.SetConfig(modelBuilder.Entity <Requirement>());
TouristMap.SetConfig(modelBuilder.Entity <Tourist>());
// todo mappings
//modelBuilder.ComplexType<OrderMoney>().Property(m => m.BaseCurrencyCode).IsRequired();
//modelBuilder.ComplexType<OrderMoney>().Property(m => m.DealCurrencyCode).IsRequired();
//modelBuilder.ComplexType<OrderMoney>().Ignore(p => p.AmountForBaseCurrency);
//modelBuilder.ComplexType<Seller>().Property(s => s.SellerName);
//modelBuilder.ComplexType<User>();
//modelBuilder.ComplexType<SettlementItemComplexType>().Property(s => s.SerializedValue).HasColumnName("SettlementItems");
//modelBuilder.ComplexType<UseDatesComplexType>().Property(d => d.SerializedValue).HasColumnName("UseDates");
//Database.SetInitializer<OrderContext>(null);
base.OnModelCreating(modelBuilder);
}
public void Order_CaseInsensitive_Success()
{
var table = new SqlTable <Class1>();
var order = new[]
{
new NamedOrderItem {
PropertyName = "value1", Direction = OrderDirection.Desc
},
new NamedOrderItem {
PropertyName = "Id", Direction = OrderDirection.Asc
},
null
};
var orderMap = OrderMap.Build(table, order, true, false);
var sqlBuilder = SqlBuilder.Select.Order(orderMap);
var sqlOptions = new SqlOptions {
Dialect = SqlDialect.Postgres95
};
var actual = sqlBuilder.BuildSql(sqlOptions);
var expected = @"
ORDER BY
class1.value1 DESC,
class1.id ASC
";
Check(expected, actual);
}
public void Select_EqualsExpected()
{
var table = new SqlTable <Class1>();
var order = new
{
Id = new OrderItem {
Direction = OrderDirection.Asc, Index = 2
},
Value1 = new OrderItem {
Direction = OrderDirection.Desc, Index = 1
},
DoNotChange = (OrderItem)null
};
var orderMap = OrderMap.FromOrder(table, order);
var sqlFilter = SqlFilter.Construct(
new { Ids = new[] { 1, 2 }, Value1 = "foo", Auto = (int?)null }
);
var whereSql = new[]
{
Conditions.Or(sqlFilter[f => f.Ids].IsNull(), table[m => m.Id].EqualsAny(sqlFilter[f => f.Ids])),
Conditions.Or(sqlFilter[f => f.Value1].IsNull(),
table[m => m.Value1].EqualsOne(sqlFilter[f => f.Value1]))
};
var sqlOptions = new SqlOptions {
Dialect = SqlDialect.Postgres95
};
var sqlBuilder = SqlBuilder.Select
.Values(table)
.From(table)
.Where(whereSql)
.Order(orderMap)
.Offset(5)
.LimitBy(10);
var actual = sqlBuilder.BuildSql(sqlOptions);
var expected = @"
SELECT
class1.id AS Id,
class1.auto AS Auto,
class1.value1 AS Value1,
class1.value2 AS Value2,
class1.do_not_change AS DoNotChange
FROM foo.class1
WHERE
(@Ids IS NULL OR class1.id = ANY(@Ids))
AND (@Value1 IS NULL OR class1.value1 = @Value1)
ORDER BY
class1.value1 DESC,
class1.id ASC
OFFSET 5
LIMIT 10
";
Check(expected, actual);
Assert.AreEqual("Id", sqlBuilder.SplitOn);
}
private IEnumerable <OrderBlock> ParseOrderFilter(OrderMap orderMap)
{
if (orderMap == null)
{
return(Enumerable.Empty <OrderBlock>());
}
var setOrders = orderMap.Items.Select(t => new OrderBlock(t.Prop, t.Direction));
return(setOrders);
}
public Order Add(Order entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
var ret = _repository.Add(OrderMap.MapBack(entity));
return(OrderMap.Map(ret));
}
public Order CreateOrder(CreateOrderRequestDTO orderDto)
{
var order = OrderMap.Map(orderDto);
this.ValidateOrder(order);
order.OrderStatus = OrderStatus.Pending;
_context.Add(order);
_context.SaveChanges();
return(order);
}
public ResResultModel SaveLogisticsDistribution(PdaLogisticsDistributionModel model)
{
try
{
new CustomException("SaveLogisticsDistribution--" + JsonConvert.SerializeObject(model));
if (string.IsNullOrWhiteSpace(model.OrderCode) || string.IsNullOrWhiteSpace(model.Status))
{
throw new ArgumentException(MC.Request_Params_InvalidError);
}
var bll = new LogisticsDistribution();
var modelInfo = bll.GetModel(model.OrderCode);
if (modelInfo == null)
{
throw new ArgumentException(MC.Data_NotExist);
}
modelInfo.Status = model.Status;
if (bll.Update(modelInfo) < 1)
{
throw new ArgumentException(MC.M_Save_Error);
}
var ip = HttpClientHelper.GetClientIp(HttpContext.Current);
var om = new OrderMap();
var oldInfo = om.GetModel(model.OrderCode);
if (oldInfo != null)
{
var omInfo = new OrderMapInfo(oldInfo.UserId, oldInfo.OrderCode, model.Lnglat, ip, "", "", model.Platform, DateTime.Now);
om.Update(omInfo);
}
else
{
var omInfo = new OrderMapInfo(Guid.Empty, model.OrderCode, model.Lnglat, ip, "", "", model.Platform, DateTime.Now);
om.Insert(omInfo);
}
return(ResResult.Response(true, MC.M_Save_Ok, ""));
}
catch (Exception ex)
{
return(ResResult.Response(false, ex.Message, ""));
}
}
RelatedDocumentRow[] GetReferencesFromDb()
{
var map = new OrderMap().RelatedDocumentsMappings.First();
Func <IDataReader, RelatedDocumentRow> Callback()
=> reader
=> new RelatedDocumentRow
{
Id = (string)reader[map.IdColumnName],
Table = (string)reader[map.IdTableColumnName],
RelatedDocumentId = (string)reader[map.RelatedDocumentIdColumnName],
RelatedDocumentType = (string)reader[map.RelatedDocumentTableColumnName],
};
using (var trn = Store.BeginTransaction())
{
return(trn.ExecuteReaderWithProjection(
$"SELECT * FROM [{DocumentMap.DefaultRelatedDocumentTableName}]",
new CommandParameterValues(),
m => m.Read(Callback())
)
.ToArray());
}
}
public void OrderByEnumerable_EqualsExpected()
{
var table = new SqlTable <Class1>();
var order = new[]
{
new NamedOrderItem {
PropertyName = "Value1", Direction = OrderDirection.Desc
},
new NamedOrderItem {
PropertyName = "Id", Direction = OrderDirection.Asc
},
null
};
var orderMap = OrderMap.Build(table, order, true);
var sqlOptions = new SqlOptions {
Dialect = SqlDialect.Postgres95
};
var sqlBuilder = SqlBuilder.Select
.Star()
.From(table)
.Order(orderMap);
var actual = sqlBuilder.BuildSql(sqlOptions);
var expected = @"
SELECT
*
FROM foo.class1
ORDER BY
class1.value1 DESC,
class1.id ASC
";
Check(expected, actual);
}
public void AddRange(OrderMap orderMap)
{
AddRange(ParseOrderFilter(orderMap));
}
protected SqlSelectBuilderBase Order(OrderMap orderMap)
{
OrdersBlock.AddRange(orderMap);
CurrentPosition = SqlSelectPosition.Order;
return(this);
}
public IEnumerable <Order> GetAll()
{
return(_repository.GetAll().Select(x => OrderMap.Map(x)).ToArray());
}
public Order Get(long id)
{
var obj = _repository.Get(id);
return(OrderMap.Map(obj));
}
private void GetOrderMapList(HttpContext context)
{
var bll = new OrderMap();
context.Response.Write(ResResult.ResJsonString(true, "", bll.GetList()));
}
public new TBuilder Order(OrderMap orderMap) => (TBuilder)base.Order(orderMap);
