public void Create(ref DtoOrder order)
{
var model = order.ToRepository();
var insertedId = Insert(model, "Orderform");
order.Id = insertedId;
}
public void Update(DtoOrder order)
{
try
{
using (SqlConnection connection = this.connection.CreateConnection())
{
string Querry = "UPDATE Orders SET Betaald = @betaald, date = @date WHERE Id = @orderId";
if (order.KlantId.HasValue)
{
Querry = "UPDATE Orders SET Betaald = @betaald, KlantId = @klantId, date = @date WHERE Id = @orderId";
}
using (SqlCommand command = new SqlCommand(Querry, connection))
{
connection.Open();
command.Parameters.AddWithValue("@orderId", order.Id);
command.Parameters.AddWithValue("@betaald", order.Betaald);
if (order.KlantId.HasValue)
{
command.Parameters.AddWithValue("@klantId", order.KlantId);
}
command.Parameters.AddWithValue("@date", order.Date);
command.CommandType = CommandType.Text;
command.ExecuteNonQuery();
}
}
}
catch (SqlException se)
{
Console.Write(se.Message);
}
}
public ServiceResult <DtoOrder> Remove(DtoOrder item)
{
try
{
Repository.Delete(new Order()
{
OrderId = item.OrderId,
WhenCreated = item.WhenCreated,
Table = item.Table,
Comments = item.Comments,
StatusId = (byte)item.StatusId,
//ListOrderItems = item.ListOrderItems
});
return(new ServiceResult <DtoOrder>()
{
Success = true
});
}
catch (Exception ex)
{
//Log exception
return(new ServiceResult <DtoOrder>()
{
Success = false,
Exception = ex,
ErrorMessage = ex.Message
});
}
}
public DtoOrder GenerateNewOrder(DtoClient dtoClient, int?lastAddress = null)
{
try
{
EnsureArg.IsNotNull(dtoClient, nameof(dtoClient));
}
catch (Exception ex)
{
throw new BadRequest(ex);
}
var client = ClientQueries.GetClient(dtoClient.Token);
var order = new DtoOrder()
{
Client = client
};
DtoAddress selectedAddress = null;
if (lastAddress != null)
{
selectedAddress = client.Addresses?.Where(i => i.Id == lastAddress)?.FirstOrDefault() ?? dtoClient.Addresses?.FirstOrDefault();
}
else
{
order.AddressToShip = client.Addresses?.FirstOrDefault();
}
return(CheckOrder(order));
}
public DtoOrder AddSku(int orderId, DtoSku skuRequest)
{
try
{
EnsureArg.IsNotNull(skuRequest, nameof(skuRequest));
EnsureArg.IsGt(orderId, 0, nameof(orderId));
}
catch (Exception ex)
{
throw new BadRequest(ex);
}
var skus = OrderQueries.GetRequestedSkus(orderId);
var dbsku = skus.Where(i => i.Id == skuRequest.Id).FirstOrDefault();
DtoOrder dtoOrder = null;
if (dbsku == null)
{
dtoOrder = OrderQueries.AddSku(orderId, skuRequest.Id, skuRequest.Quantity.Value);
}
else
{
dtoOrder = OrderQueries.UpdateSku(orderId, dbsku.OrderSkuId.Value, skuRequest.Quantity.Value);
}
return(CheckOrder(dtoOrder));
}
public List <DtoOrder> GetOrders(int klantId)
{
List <DtoOrder> orders = new List <DtoOrder>();
try
{
using (SqlConnection connection = this.connection.CreateConnection())
{
string Querry = string.Format("select * from Orders where KlantId={0}", klantId);
using (SqlCommand command = new SqlCommand(Querry, connection))
{
connection.Open();
var reader = command.ExecuteReader();
while (reader.Read())
{
DtoOrder newOrder = new DtoOrder
{
Id = reader.GetInt32(0),
Betaald = reader.GetBool(1),
KlantId = reader.GetInt32(2),
Date = reader.GetDateTime(3)
};
orders.Add(newOrder);
}
}
}
}
catch (SqlException se)
{
Console.Write(se.Message);
}
return(orders);
}
public Order(DtoOrder DTO)
{
id = DTO.Id;
betaald = DTO.Betaald;
if (DTO.KlantId.HasValue)
{
klantId = DTO.KlantId.Value;
}
date = DTO.Date;
}
public BindingList<DtoOrder> SearchOrders(string number, string billingNumber)
{
DtoOrder dtoOrder = new DtoOrder()
{
Number = number,
Visit = new DtoVisit()
{
BillingNumber = billingNumber
}
};
return new BindingList<DtoOrder>(new OrderServiceClient().FindOrders(dtoOrder));
}
public ServiceResult <DtoOrder> Edit(DtoOrder item) //only for StatusId, Comments and Table
{
using (var transaction = Context.Database.BeginTransaction())
{
try
{
if (item == null) //maybe also if(!modelState.IsValid)
{
return(new ServiceResult <DtoOrder>
{
Success = false,
Exception = new ArgumentNullException("Order not valid.")
});
}
var dbOrder = Repository.DbContext.Orders.FirstOrDefault(o => o.OrderId == item.OrderId);
if (dbOrder == null)
{
return(new ServiceResult <DtoOrder>
{
Success = false,
ErrorMessage = "Order not found."
});
}
//dbOrder.StatusId = (byte)item.StatusId; //to be changed in separte method, becuase of privilege to change it
dbOrder.Table = item.Table;
dbOrder.Comments = item.Comments;
Repository.Update(dbOrder); //?
Context.SaveChanges(); //?
transaction.Commit();
return(new ServiceResult <DtoOrder>()
{
Success = true
});
}
catch (Exception ex)
{
//Log exception
transaction.Rollback();
return(new ServiceResult <DtoOrder>()
{
Success = false,
Exception = ex,
ErrorMessage = ex.Message
});
}
}
}
public BindingList <DtoOrder> SearchOrders(string number, string billingNumber)
{
DtoOrder dtoOrder = new DtoOrder()
{
Number = number,
Visit = new DtoVisit()
{
BillingNumber = billingNumber
}
};
return(new BindingList <DtoOrder>(new OrderServiceClient().FindOrders(dtoOrder)));
}
public NewOrderEditPresenter(INewOrderEditView newOrderEditView, DtoOrder editOrder )
{
this.newOrderEditView = newOrderEditView;
newOrderEditModel = new NewOrderModel();
newOrderEdit = editOrder;
newOrderEditView.LoadEditForm += LoadGridControls;
newOrderEditView.TestChoose += LoadDefaultEntities;
newOrderEditView.IndicationChoose += LoadIndications;
newOrderEditView.AddTestsToCheckBox += LoadTestsToCheckBox;
newOrderEditView.AddTubesToCheckBox += LoadTubesToCheckBox;
newOrderEditView.OrderEditClick += EditOrder;
newOrderEditView.DeleteFocusedTest += UpdateTestsForCheckBox;
newOrderEditView.DeleteFocuseTube += UpdateTubesForCheckBox;
}
public Order GetByID(int id)
{
IDalOrder orderDAL = DalFactory.CreateOrderDal();
DtoOrder DTO = orderDAL.GetById(id);
Order order = new Order(DTO);
//When order does not excist Create a new order
if (DTO.Id == 0)
{
order = GetByID(CreateNew());
}
return(order);
}
public NewOrderEditPresenter(INewOrderEditView newOrderEditView, DtoOrder editOrder)
{
this.newOrderEditView = newOrderEditView;
newOrderEditModel = new NewOrderModel();
newOrderEdit = editOrder;
newOrderEditView.LoadEditForm += LoadGridControls;
newOrderEditView.TestChoose += LoadDefaultEntities;
newOrderEditView.IndicationChoose += LoadIndications;
newOrderEditView.AddTestsToCheckBox += LoadTestsToCheckBox;
newOrderEditView.AddTubesToCheckBox += LoadTubesToCheckBox;
newOrderEditView.OrderEditClick += EditOrder;
newOrderEditView.DeleteFocusedTest += UpdateTestsForCheckBox;
newOrderEditView.DeleteFocuseTube += UpdateTubesForCheckBox;
}
public ServiceResult <DtoOrder> Add(DtoOrder order)
{
using (var transaction = Context.Database.BeginTransaction())
{
try
{
//TODO: Implement validation
var newOrder = new Order
{
OrderId = 0,
StatusId = (byte)OrderStatus.Created,
Table = order.Table,
WhenCreated = DateTime.UtcNow
};
Context.Orders.Add(newOrder);
Context.SaveChanges();
Context.OrderItems.AddRange(order.ListOrderItems.Select(o => new OrderItem
{
OrderItemId = 0,
ItemId = o.ItemId,
OrderId = newOrder.OrderId,
ItemQuantity = o.ItemQuantity
}));
transaction.Commit(); // SaveChanges() not necessary after the last change to the database and/or before transaction.Commit()
return(new ServiceResult <DtoOrder>
{
Success = true,
Item = new DtoOrder(newOrder)
});
}
catch (Exception ex)
{
transaction.Rollback();
return(new ServiceResult <DtoOrder>
{
Success = false,
Exception = ex,
ErrorMessage = "An exception occurred."
});
}
}
}
public IActionResult Save([FromBody] DtoOrder dto)
{
using (var trans = _dbContext.Database.BeginTransaction(_capBus, autoCommit: false))
{
//业务代码
var model = new Orders()
{
Amount = dto.Amount,
ProductID = dto.ProductID,
UserID = dto.UserID
};
_dbContext.Orders.Add(model);
_capBus.Publish("Commit.Order", model);
trans.Commit();
}
return(Ok());
}
public ServiceResult <DtoOrder> CreateOrder(DtoOrder order)
{
using (var transaction = Repository.DbContext.Database.BeginTransaction())
{
try
{
var newOrder = new Order
{
Id = 0,
StatusOfOrder = (byte)Status.Created,
Table = order.Table,
DateCreated = DateTime.UtcNow
};
DbContext.Orders.Add(newOrder);
DbContext.SaveChanges();
DbContext.OrderItems.AddRange(order.OrderItems.Select(o => new OrderItem
{
OrderItemId = 0,
ItemId = o.ItemId,
Orderid = newOrder.Id,
Quantity = (short)o.Quantity
}));
transaction.Commit();
transaction.Commit();
return(new ServiceResult <DtoOrder>
{
Success = true,
Item = new DtoOrder(newOrder)
});
}
catch (Exception ex)
{
transaction.Rollback();
return(new ServiceResult <DtoOrder>
{
Success = false,
Exception = ex,
ErrorMessage = "an exception occurred"
});
}
}
}
public ServiceResult <DtoOrder> Edit(DtoOrder order)
{
try
{
//TODO: Implement validation
if (order == null)
{
return new ServiceResult <DtoOrder>
{
Success = false,
Exception = new ArgumentNullException("order")
}
}
;
var dbOrder = DbContext.Orders.FirstOrDefault(x => x.Id == order.Id);
if (dbOrder == null)
{
return new ServiceResult <DtoOrder>
{
Success = false,
ErrorMessage = "order not found"
}
}
;
dbOrder.Table = order.Table;
DbContext.SaveChanges();
return(new ServiceResult <DtoOrder>
{
Success = true,
Item = new DtoOrder(dbOrder)
});
}
catch (Exception ex)
{
return(new ServiceResult <DtoOrder>
{
Success = false,
Exception = ex,
ErrorMessage = "an exception occurred"
});
}
}
public static DtoOrder ToDTO(this Repository.Pharma.Model.Orders.Order model)
{
if (model == null)
{
return(null);
}
var dto = new DtoOrder()
{
Id = model.Id,
AgreesReference = model.AgreesReference,
AgreesSimilar = model.AgreesSimilar,
AgressGeneric = model.AgressGeneric,
DeliveredOn = model.DeliveredOn,
RequestedOn = model.RequestedOn,
ScheduledTo = model.ScheduledTo,
};
return(dto);
}
public ServiceResult <DtoOrder> EditOrder(DtoOrder order)
{
try
{
if (order == null)
{
return(new ServiceResult <DtoOrder>
{
Success = false,
Exception = new ArgumentNullException("order")
});
}
var dbOrder = Repository.DbContext.Orders.FirstOrDefault(x => x.Id == order.OrderId);
if (dbOrder == null)
{
return(new ServiceResult <DtoOrder>
{
Success = false,
ErrorMessage = "3404"
});
}
dbOrder.Table = order.Table;
DbContext.SaveChanges();
return(new ServiceResult <DtoOrder>
{
Success = true,
Item = new DtoOrder(dbOrder)
});
}
catch (Exception ex)
{
return(new ServiceResult <DtoOrder>
{
Success = false,
Exception = ex,
ErrorMessage = ""
});
}
}
public static Repository.Pharma.Model.Orders.Order ToRepository(this DtoOrder dto)
{
if (dto == null)
{
return(null);
}
var model = new Repository.Pharma.Model.Orders.Order()
{
Id = dto.Id,
AgreesReference = dto.AgreesReference,
AgreesSimilar = dto.AgreesSimilar,
AgressGeneric = dto.AgressGeneric,
DeliveredOn = dto.DeliveredOn,
RequestedOn = dto.RequestedOn,
ScheduledTo = dto.ScheduledTo,
Client_Id = dto.Client?.Id,
AddressToShip_Id = dto.AddressToShip?.Id
};
return(model);
}
public ServiceResult <DtoOrder> Load(DtoOrder item)
{
try
{
var result = Repository.GetById(item.OrderId);
return(new ServiceResult <DtoOrder>()
{
Item = new DtoOrder(result),
Success = true
});
}
catch (Exception ex)
{
//Log exception
return(new ServiceResult <DtoOrder>()
{
Success = false,
Exception = ex,
ErrorMessage = ex.Message
});
}
}
public DtoOrder GetById(int id)
{
DtoOrder order = new DtoOrder();
try
{
using (SqlConnection connection = this.connection.CreateConnection())
{
string Querry = "select * from Orders where Id=@id";
using (SqlCommand command = new SqlCommand(Querry, connection))
{
connection.Open();
command.Parameters.AddWithValue("@id", id);
var reader = command.ExecuteReader();
while (reader.Read())
{
DtoOrder newOrder = new DtoOrder
{
Id = reader.GetInt32(0),
Betaald = reader.GetBool(1),
Date = reader.GetDateTime(3)
};
if (!reader.IsDBNull(2))
{
newOrder.KlantId = reader.GetInt32(2);
}
order = newOrder;
}
}
}
}
catch (SqlException se)
{
Console.Write(se.Message);
}
return(order);
}
public List <DtoOrder> GetAll()
{
DeleteAllEmpty();
List <DtoOrder> orders = new List <DtoOrder>();
try
{
using (SqlConnection connection = this.connection.CreateConnection())
{
string Querry = string.Format("select * from Orders ORDER BY Id DESC");
using (SqlCommand command = new SqlCommand(Querry, connection))
{
connection.Open();
var reader = command.ExecuteReader();
while (reader.Read())
{
DtoOrder newOrder = new DtoOrder
{
Id = reader.GetInt32(0),
Betaald = reader.GetBool(1),
Date = reader.GetDateTime(3)
};
if (!reader.IsDBNull(2))
{
newOrder.KlantId = reader.GetInt32(2);
}
orders.Add(newOrder);
}
}
}
}
catch (SqlException se)
{
Console.Write(se.Message);
}
return(orders);
}
// POST: api/DtoOrder
public IHttpActionResult Post([FromBody] DtoOrder order)
{
if (order == null)
{
return(NotFound());
}
var newOrder = new Orders();
List <int> productId_for_OrderToProduct = new List <int>();
var test = db.Shipping.SingleOrDefault(x => x.adress == order.Shipping.adress && x.city == order.Shipping.city && x.country == order.Shipping.country);
if (test == null)
{
var ship = new Shipping {
adress = order.Shipping.adress, city = order.Shipping.city, country = order.Shipping.country
};
db.Shipping.Add(ship);
db.SaveChanges();
newOrder.ShippingId = db.Shipping.SingleOrDefault(x => x.adress == ship.adress && x.city == ship.city && x.country == ship.country).ShippingId;
}
else
{
newOrder.ShippingId = test.ShippingId;
}
//Mapper DTO over til orders og skaffer productid til orderToProduct
newOrder.ItemsPrice = order.ItemsPrice;
for (int i = 0; i < order.orderItems.Length; i++)
{
productId_for_OrderToProduct.Add(order.orderItems[i].product);
}
;
newOrder.Taxprice = order.Taxprice;
newOrder.UserId = order.UserInfo.UserId;
newOrder.TotalPrice = order.TotalPrice;
newOrder.ShippingPrice = order.ShippingPrice;
newOrder.CreatedAt = DateTime.Now;
newOrder.PaymentId = 1;
if (newOrder == null)
{
return(Content(HttpStatusCode.NotFound, "Denne orderen ble ikke lagret"));
}
db.Orders.Add(newOrder);
db.SaveChanges();
//Finner id for den nye orderen
var newOrderId = db.Orders.Max(x => x.OrderId);
//Legger inn ordreId og productId inn i ordreToProduct
foreach (int id in productId_for_OrderToProduct)
{
db.OrderToProduct.Add(new OrderToProduct {
OrderId = newOrderId, productId = id
});
db.SaveChanges();
}
//Lager product liste for response på createProduct
var tempList = db.OrderToProduct.Where(x => x.OrderId == newOrderId).ToList();
var productResponseList = new List <DtoProducts>();
foreach (OrderToProduct prod in tempList)
{
productResponseList.Add(DtoHelper.Product_To_DtoProd(db.Products.SingleOrDefault(x => x.productId == prod.productId)));
}
//lager et object for å sende tilbake som bekreftelse
var DtoResponseOrder = new DtoOrder
{
_Id = newOrderId,
UserInfo = new DtoUserInfo {
UserId = order.UserInfo.UserId, name = order.UserInfo.name, email = order.UserInfo.email
},
orderItems = productResponseList.ToArray(),
Shipping = new DtoShipping {
adress = order.Shipping.adress, city = order.Shipping.city
},
ItemsPrice = order.ItemsPrice,
ShippingPrice = order.ShippingPrice,
Taxprice = order.Taxprice,
TotalPrice = order.TotalPrice,
CreatedAt = DateTime.Now.ToString(),
};
if (DtoResponseOrder == null)
{
return(Content(HttpStatusCode.NotFound, "Denne orderen ble ikke lagret"));
}
return(Ok(DtoResponseOrder));
}
public DtoOrder CheckOrder(DtoOrder order)
{
try
{
EnsureArg.IsNotNull(order, nameof(order));
}
catch (Exception ex)
{
throw new BadRequest(ex);
}
if (order.Id == 0)
{
OrderQueries.Create(ref order);
}
if (order.AddressToShip == null)
{
order.AddressToShip = order.Client?.Addresses?.FirstOrDefault();
OrderQueries.Update(ref order);
}
if (order.RequestedStores == null)
{
order.RequestedStores = StoreDomain.GetNearStore(order.AddressToShip);
}
if (order.SkusRequesteds?.Count() > 0)
{
foreach (var sku in order.SkusRequesteds)
{
sku.ProductReference = ProductDomain.GetProductBySku(sku.Id);
}
}
return(order);
// TODO Delivery
//if (order.AddressToShip != null && order.RequestedStores?.Count() > 0)
//{
// foreach (var store in order.RequestedStores)
// {
// var clientLocation = new GeoCoordinate(order.AddressToShip.Latitude.Value, order.AddressToShip.Longitude.Value);
// var storeLocation = new GeoCoordinate(store.Address.Latitude.Value, store.Address.Longitude.Value);
// store.Proximity = clientLocation.GetDistanceTo(storeLocation);
// if (store.AvaibleDeliveries?.Count > 0)
// {
// var maxdistance = store.AvaibleDeliveries.Max(i => i.MaxDistance);
// var safeDelivery = store.AvaibleDeliveries.Where(i => i.MaxDistance == maxdistance).FirstOrDefault();
// var removeDeliverys = new List<DtoDelivery>();
// foreach (var delivery in store.AvaibleDeliveries)
// {
// if (store.Proximity > delivery.MaxDistance)
// removeDeliverys.Add(delivery);
// }
// var deliveryMethod = store.AvaibleDeliveries
// .Where(i => !removeDeliverys.Contains(i))
// .OrderBy(i => i.MaxDistance).FirstOrDefault();
// if (deliveryMethod == null)
// store.Delivery = safeDelivery;
// else
// store.Delivery = deliveryMethod;
// }
// }
//}
}
public ServiceResult <DtoOrder> Load(DtoOrder item)
{
throw new NotImplementedException();
}
public void Update(ref DtoOrder order)
{
var model = order.ToRepository();
Update(model, "Orderform");
}
private static Dictionary <Type, object> GetDummiesDictionary()
{
#region Funds
DtoFunds dtoFunds = new DtoFunds {
Btc = 1.0m, Eur = 1.0m, Ftc = 1.0m, Ltc = 1.0m, Nmc = 1.0m, Nvc = 1.0m, Ppc = 1.0m, Rur = 1.0m, Trc = 1.0m, Usd = 1.0m
};
#endregion
#region DtoRights
DtoRights dtoRights = new DtoRights {
Info = true, Trade = true, Withdraw = true
};
#endregion
#region DtoUserInfo
DtoUserInfo dtoUserInfo = new DtoUserInfo
{
Funds = dtoFunds,
Rights = dtoRights,
OpenOrders = 2,
ServerTime = 123456798
};
#endregion
#region DtoTicker
DtoTicker dtoTicker = new DtoTicker
{
Average = 10m,
Buy = 9m,
High = 11m,
Last = 10.50m,
Low = 8m,
Sell = 7m,
ServerTime = 123456
};
#endregion
#region DtoCancelOrderAnswer
DtoCancelOrderAnswer dtoCancelOrderAnswer = new DtoCancelOrderAnswer
{
Funds = dtoFunds,
OrderId = 100
};
#endregion
#region DtoOrderInfo
DtoOrderInfo dtoOrderInfo = new DtoOrderInfo
{
Amount = 5,
Price = 2
};
#endregion
#region DtoDepth
DtoDepth dtoDepth = new DtoDepth
{
Asks = new List <DtoOrderInfo> {
dtoOrderInfo, dtoOrderInfo
},
Bids = new List <DtoOrderInfo> {
dtoOrderInfo
}
};
#endregion
#region DtoOrder
DtoOrder dtoOrder = new DtoOrder
{
Amount = 5,
Pair = Pair.btc_eur,
Rate = 100,
Status = 1,
TimestampCreated = 123456,
Type = TradeType.buy
};
#endregion
#region DtoActiveOrders
DtoActiveOrders dtoActiveOrders = new DtoActiveOrders
{
List = new Dictionary <int, DtoOrder> {
{ 123456789, dtoOrder }
}
};
DummyDtoActiveOrders dummyDtoActiveOrders = new DummyDtoActiveOrders
{
List = null
};
#endregion
#region DtoTrade
DtoTrade dtoTrade = new DtoTrade
{
Amount = 10,
IsYourOrder = true,
OrderId = 123456,
Pair = Pair.eur_usd,
Rate = 50,
Timestamp = 11545,
Type = TradeType.sell
};
#endregion
#region DtoTradeAnswer
DtoTradeAnswer dtoTradeAnswer = new DtoTradeAnswer
{
Funds = dtoFunds,
OrderId = 123456,
Received = 10,
Remains = 10
};
#endregion
#region DtoTradeHistory
DtoTradeHistory dtoTradeHistory = new DtoTradeHistory
{
List = new Dictionary <int, DtoTrade> {
{ 123456, dtoTrade }
}
};
#endregion
#region DtoTradeInfo
DtoTradeInfo dtoTradeInfo = new DtoTradeInfo
{
Amount = 15,
Date = DateTime.Now,
Item = Currency.eur,
Price = 100,
PriceCurrency = Currency.ltc,
Tid = 150
};
#endregion
#region DtoTransaction
DtoTransaction dtoTransaction = new DtoTransaction
{
Amount = 10,
Currency = Currency.eur,
Description = "description",
Status = 1,
Timestamp = 4587,
Type = 1
};
#endregion
#region DtoTransHistory
DtoTransHistory dtoTransHistory = new DtoTransHistory
{
List = new Dictionary <int, DtoTransaction> {
{ 132456, dtoTransaction }
}
};
#endregion
Dictionary <Type, Object> dummiesDictionary = new Dictionary <Type, object>
{
{ typeof(DtoFunds), dtoFunds },
{ typeof(DtoRights), dtoRights },
{ typeof(DtoUserInfo), dtoUserInfo },
{ typeof(DtoTicker), dtoTicker },
{ typeof(DtoCancelOrderAnswer), dtoCancelOrderAnswer },
{ typeof(DtoOrderInfo), dtoOrderInfo },
{ typeof(DtoDepth), dtoDepth },
{ typeof(DtoOrder), dtoOrder },
{ typeof(DtoActiveOrders), dtoActiveOrders },
{ typeof(DummyDtoActiveOrders), dummyDtoActiveOrders },
{ typeof(DtoTrade), dtoTrade },
{ typeof(DtoTradeAnswer), dtoTradeAnswer },
{ typeof(DtoTradeHistory), dtoTradeHistory },
{ typeof(DtoTradeInfo), dtoTradeInfo },
{ typeof(DtoTransaction), dtoTransaction },
{ typeof(DtoTransHistory), dtoTransHistory }
};
return(dummiesDictionary);
}
public DtoOrder[] FindOrders(DtoOrder dtoOrder)
{
Order[] orders = OrderMethods.Instance.GetOrders(dtoOrder.Number, dtoOrder.Visit.BillingNumber);
DtoOrder[] dtoOrders = orders.Select(order => new DtoOrder()
{
Id = order.Id,
Number = order.Number,
Visit = new DtoVisit()
{
Id = order.Visit.Id,
BillingNumber = order.Visit.BillingNumber,
Patient = new DtoPatient()
{
Id = order.Visit.Patient.Id,
FirstName = order.Visit.Patient.FirstName,
LastName = order.Visit.Patient.LastName
}
},
ClinicalInfo = order.ClinicalInfo,
}).ToArray();
return dtoOrders;
}
public string EditOrder(DtoOrder dtoOrder)
{
var visit = VisitMethods.Instance.GetVisitByBillingNumber(dtoOrder.Visit.BillingNumber);
var uniqueOrder = OrderMethods.Instance.GetOrderByNumber(dtoOrder.Number);
if (PatientMethods.Instance.GetPatientById(visit.Patient.Id).Dod == null)
{
if (uniqueOrder == null)
{
var order = new Order()
{
Number = dtoOrder.Number,
Visit = new Visit()
{
Id = visit.Id
},
ClinicalInfo = dtoOrder.ClinicalInfo
};
return OrderMethods.Instance.InsertOrder(order);
}
else
{
Order order = new Order()
{
Number = dtoOrder.Number,
Id = uniqueOrder.Id,
ClinicalInfo = dtoOrder.ClinicalInfo,
Visit = new Visit()
{
Id = visit.Id
}
};
return OrderMethods.Instance.UpdateOrder(order);
}
}
else
{
return "d";
}
}
public void TestCreateOrder()
{
DtoOrder order = new DtoOrder();
}
