public static void Delete(ProductInfoData productInfo, bool propogate = false)
{
lock (Lock)
{
context.productInfos.Remove(productInfo);
context.SaveChanges();
}
}
public static void update(ProductInfoData productInfo)
{
lock (Lock)
{
context.productInfos.Update(productInfo);
context.SaveChanges();
}
}
public static ICollection <FeedbackData> getAllFeedbacksOnProduct(int productID)
{
lock (Lock)
{
ProductInfoData product = getProductInfo(productID);
return(context.feedbacks.Where((FeedbackData x) => x.product.Equals(product)).ToList());
}
}
public static FeedbackData getFeedback(string userName, int productID)
{
lock (Lock)
{
MemberData member = getMember(userName);
ProductInfoData product = getProductInfo(productID);
return(context.feedbacks.Find(new object[] { product, member }));
}
}
public Product(ProductData productData)
{
ProductInfoData productInfoData = productData.productData;
this.info = ProductInfo.getProductInfo(productInfoData.productName, productInfoData.category, productInfoData.manufacturer);
this.amount = productData.amount;
this.price = productData.price;
this.discount_percent = 0;
}
public ProductInfoData toDataObject()
{
ProductInfoData ans = DataAccess.getProductInfo(this.id);
if (ans == null)
{
ans = new ProductInfoData(this.name, this.category, this.manufacturer, this.id);
}
return(ans);
}
public QuoteInfoDto CreateQuote(QuoteInfoDto dto)
{
ProductSystem productSystem = new ProductSystem(UnitOfWork);
ProductInfoData productData = productSystem.RetrieveProductInfo(dto.ProductId);
// TODO: fill some fields
dto.ProductName = productData.Name;
dto.Amount = productData.UnitPrice * 1;
return(dto);
}
public ProductInfo(ProductInfoData productInfoData)
{
this.name = productInfoData.productName;
this.category = productInfoData.category;
this.manufacturer = productInfoData.manufacturer;
this.id = productInfoData.productID;
currentId++;
// get feedbacks - TODO - DONE
foreach (FeedbackData item in DataLayer.ORM.DataAccess.getAllFeedbacksOnProduct(this.id))
{
feedbacks.Add(item.user.userName, item.comment);
}
}
public QuoteInfoDto CreateQuote(object productId)
{
ArgumentValidator.IsNotNull("productId", productId);
QuoteInfoDto dto = new QuoteInfoDto();
ProductSystem productSystem = new ProductSystem(UnitOfWork);
ProductInfoData productData = productSystem.RetrieveProductInfo(productId);
dto.ProductId = productId;
dto.ProductName = productData.Name;
dto.Amount = productData.UnitPrice * 1;
return(dto);
}
public ProductInfoData RetrieveProductInfo(object productId)
{
ProductInfoData result = null;
RepositoryExceptionWrapper.Wrap(GetType(), () =>
{
ICriteria query = CurrentSession.CreateCriteria <ProductInfoData>();
query.AddExpressionEq <ProductInfoData, object>(o => o.ProductId, productId);
result = query.UniqueResult <ProductInfoData>();
});
return(result);
}
public IServiceQueryResult <ProductInfoData> RetrieveProductInfo(object productId)
{
ProductInfoData result = Repository.RetrieveProductInfo(productId);
return(ServiceResultFactory.BuildServiceQueryResult <ProductInfoData>(result));
}
public static void AddProductInfo(ProductInfoData productInfoData)
{
productsInfo.Add(new ProductInfo(productInfoData));
}
int limit = 100;//拿几条数据
public async void GetDayDataFromDB()
{
DBProxyComponent dBProxyComponent = Game.Scene.GetComponent <DBProxyComponent>();
try
{
var acountscount = await dBProxyComponent.QueryCount <ProductInfoData>("{ }");
while (skip < acountscount)
{
string Json = "{ }"; //查找类型里面可以添加斜杠来做匹配查找，例如：{userNowArea:/^湖南省/}
string sort = "{ }"; //排序方式，必须要有参数和排序方式，例如：{userID:1}
string LSS = Json + "|" + skip + "|" + limit + "|" + sort;
var acounts = await dBProxyComponent.QueryLss <ProductInfoData>(LSS);
foreach (var dataDate in acounts)
{
ProductInfoData Infodata = dataDate as ProductInfoData;
if (ProductInfolist.TryAdd(Infodata._ProductInfoID, Infodata))
{
}
;
long ShopInfoID = Infodata._ShopInfoID;
lock (ShopProductlist)
{
List <ProductInfoData> datalist = new List <ProductInfoData>();
if (ShopProductlist.ContainsKey(ShopInfoID))
{
//有这个商铺直接往这个商铺的list里添加
ShopProductlist[ShopInfoID].Add(Infodata);
}
else
{
//没有这个商铺，添加这个商铺，在往商铺里面的list里添加
if (ShopProductlist.TryAdd(ShopInfoID, datalist) == true)
{
}
;
ShopProductlist[ShopInfoID].Add(Infodata);
}
}
}
skip += limit;
}
skip = 0;
var acounts1count = await dBProxyComponent.QueryCount <ProductInfoOrder>("{ }");
while (skip < acounts1count)
{
string Json = "{ }"; //查找类型里面可以添加斜杠来做匹配查找，例如：{userNowArea:/^湖南省/}
string sort = "{_CreationTime:-1 }"; //排序方式，必须要有参数和排序方式，例如：{userID:1}
string LSS = Json + "|" + skip + "|" + limit + "|" + sort;
var acounts1 = await dBProxyComponent.QueryLss <ProductInfoOrder>(LSS);
foreach (ProductInfoOrder item in acounts1)
{
ProductInfoOrder Orderdata = item as ProductInfoOrder;
long UserID = Orderdata._UserID;
lock (UserProductOrderlist)
{
List <ProductInfoOrder> datalist = new List <ProductInfoOrder>();
if (UserProductOrderlist.ContainsKey(UserID))
{
//有这个商铺直接往这个商铺的list里添加
UserProductOrderlist[UserID].Add(Orderdata);
}
else
{
//没有这个商铺，添加这个商铺，在往商铺里面的list里添加
if (UserProductOrderlist.TryAdd(UserID, datalist) == true)
{
}
;
UserProductOrderlist[UserID].Add(Orderdata);
}
}
}
skip += limit;
}
skip = 0;
var acounts2count = await dBProxyComponent.QueryCount <SimpleOrder>("{ }");
while (skip < acounts2count)
{
string Json = "{ }"; //查找类型里面可以添加斜杠来做匹配查找，例如：{userNowArea:/^湖南省/}
string sort = "{_id:-1 }"; //排序方式，必须要有参数和排序方式，例如：{userID:1}
string LSS = Json + "|" + skip + "|" + limit + "|" + sort;
var acounts1 = await dBProxyComponent.QueryLss <SimpleOrder>(LSS);
foreach (SimpleOrder item in acounts1)
{
SimpleOrder Orderdata = item as SimpleOrder;
if (Orderdata._State == 0)
{
long UserID = Orderdata._UserID;
lock (UserSimpleOrderlist)
{
List <SimpleOrder> datalist = new List <SimpleOrder>();
if (UserSimpleOrderlist.ContainsKey(UserID))
{
//有这个商铺直接往这个商铺的list里添加
UserSimpleOrderlist[UserID].Add(Orderdata);
}
else
{
//没有这个商铺，添加这个商铺，在往商铺里面的list里添加
if (UserSimpleOrderlist.TryAdd(UserID, datalist) == true)
{
}
;
UserSimpleOrderlist[UserID].Add(Orderdata);
}
}
}
}
skip += limit;
}
skip = 0;
var acount1s = await dBProxyComponent.Query <ServiceInfoData>("{ }");
foreach (ServiceInfoData item in acount1s)
{
if (!ServiceInfos.Contains(item._ServiceInfoID))
{
ServiceInfos.Add(item._ServiceInfoID);
}
}
var acounts3count = await dBProxyComponent.QueryCount <ShopActivityInfo>("{ }");
while (skip < acounts3count)
{
string Json = "{ }"; //查找类型里面可以添加斜杠来做匹配查找，例如：{userNowArea:/^湖南省/}
string sort = "{ }"; //排序方式，必须要有参数和排序方式，例如：{userID:1}
string LSS = Json + "|" + skip + "|" + limit + "|" + sort;
var acounts1 = await dBProxyComponent.QueryLss <ShopActivityInfo>(LSS);
foreach (ShopActivityInfo item in acounts1)
{
ShopActivityInfo Infodata = item as ShopActivityInfo;
long ShopInfoID = Infodata._ShopInfoID;
lock (UserSimpleOrderlist)
{
List <ShopActivityInfo> datalist = new List <ShopActivityInfo>();
if (ShopActivitylist.ContainsKey(ShopInfoID))
{
//有这个商铺直接往这个商铺的list里添加
ShopActivitylist[ShopInfoID].Add(Infodata);
}
else
{
//没有这个商铺，添加这个商铺，在往商铺里面的list里添加
if (ShopActivitylist.TryAdd(ShopInfoID, datalist) == true)
{
}
;
ShopActivitylist[ShopInfoID].Add(Infodata);
}
}
}
skip += limit;
}
skip = 0;
var acounts4count = await dBProxyComponent.QueryCount <ShopInfoData>("{ }");
while (skip < acounts4count)
{
string Json = "{ }"; //查找类型里面可以添加斜杠来做匹配查找，例如：{userNowArea:/^湖南省/}
string sort = "{ }"; //排序方式，必须要有参数和排序方式，例如：{userID:1}
string LSS = Json + "|" + skip + "|" + limit + "|" + sort;
var acounts = await dBProxyComponent.QueryLss <ShopInfoData>(LSS);
foreach (var dataDate in acounts)
{
ShopInfoData Infodata = dataDate as ShopInfoData;
if (ShopInfolist.TryAdd(Infodata._ShopInfoID, Infodata))
{
}
;
}
skip += limit;
}
skip = 0;
var acounts5count = await dBProxyComponent.QueryCount <CollectProduct>("{ }");
while (skip < acounts5count)
{
string Json = "{ }"; //查找类型里面可以添加斜杠来做匹配查找，例如：{userNowArea:/^湖南省/}
string sort = "{ }"; //排序方式，必须要有参数和排序方式，例如：{userID:1}
string LSS = Json + "|" + skip + "|" + limit + "|" + sort;
var acounts1 = await dBProxyComponent.QueryLss <CollectProduct>(LSS);
foreach (CollectProduct item in acounts1)
{
CollectProduct Orderdata = item as CollectProduct;
if (Orderdata._State == 0)
{
long UserID = Orderdata._UserID;
lock (UserCollectProductlist)
{
List <CollectProduct> datalist = new List <CollectProduct>();
if (UserCollectProductlist.ContainsKey(UserID))
{
//有这个商铺直接往这个商铺的list里添加
UserCollectProductlist[UserID].Add(Orderdata);
}
else
{
//没有这个商铺，添加这个商铺，在往商铺里面的list里添加
if (UserCollectProductlist.TryAdd(UserID, datalist) == true)
{
}
;
UserCollectProductlist[UserID].Add(Orderdata);
}
}
}
}
skip += limit;
}
skip = 0;
var acounts6count = await dBProxyComponent.QueryCount <CollectShopInfo>("{ }");
while (skip < acounts6count)
{
string Json = "{ }"; //查找类型里面可以添加斜杠来做匹配查找，例如：{userNowArea:/^湖南省/}
string sort = "{ }"; //排序方式，必须要有参数和排序方式，例如：{userID:1}
string LSS = Json + "|" + skip + "|" + limit + "|" + sort;
var acounts1 = await dBProxyComponent.QueryLss <CollectShopInfo>(LSS);
foreach (CollectShopInfo item in acounts1)
{
CollectShopInfo Orderdata = item as CollectShopInfo;
if (Orderdata._State == 0)
{
long UserID = Orderdata._UserID;
lock (UserCollecShoptlist)
{
List <CollectShopInfo> datalist = new List <CollectShopInfo>();
if (UserCollecShoptlist.ContainsKey(UserID))
{
//有这个商铺直接往这个商铺的list里添加
UserCollecShoptlist[UserID].Add(Orderdata);
}
else
{
//没有这个商铺，添加这个商铺，在往商铺里面的list里添加
if (UserCollecShoptlist.TryAdd(UserID, datalist) == true)
{
}
;
UserCollecShoptlist[UserID].Add(Orderdata);
}
}
}
}
skip += limit;
}
skip = 0;
var acounts7count = await dBProxyComponent.QueryCount <Discount>("{ }");
while (skip < acounts7count)
{
string Json = "{ }"; //查找类型里面可以添加斜杠来做匹配查找，例如：{userNowArea:/^湖南省/}
string sort = "{ }"; //排序方式，必须要有参数和排序方式，例如：{userID:1}
string LSS = Json + "|" + skip + "|" + limit + "|" + sort;
var acounts1 = await dBProxyComponent.QueryLss <Discount>(LSS);
foreach (Discount item in acounts1)
{
Discount Orderdata = item as Discount;
if (Orderdata._State == 0)
{
long UserID = Orderdata._UserID;
lock (UserDiscountlist)
{
List <Discount> datalist = new List <Discount>();
if (UserDiscountlist.ContainsKey(UserID))
{
//有这个商铺直接往这个商铺的list里添加
UserDiscountlist[UserID].Add(Orderdata);
}
else
{
//没有这个商铺，添加这个商铺，在往商铺里面的list里添加
if (UserDiscountlist.TryAdd(UserID, datalist) == true)
{
}
;
UserDiscountlist[UserID].Add(Orderdata);
}
}
}
}
skip += limit;
}
skip = 0;
var acounts8count = await dBProxyComponent.QueryCount <Footmark>("{ }");
while (skip < acounts8count)
{
string Json = "{ }"; //查找类型里面可以添加斜杠来做匹配查找，例如：{userNowArea:/^湖南省/}
string sort = "{ }"; //排序方式，必须要有参数和排序方式，例如：{userID:1}
string LSS = Json + "|" + skip + "|" + limit + "|" + sort;
var acounts1 = await dBProxyComponent.QueryLss <Footmark>(LSS);
foreach (Footmark item in acounts1)
{
Footmark Orderdata = item as Footmark;
if (Orderdata._State == 0)
{
long UserID = Orderdata._UserID;
lock (UserFootmarklist)
{
List <Footmark> datalist = new List <Footmark>();
if (UserFootmarklist.ContainsKey(UserID))
{
//有这个商铺直接往这个商铺的list里添加
UserFootmarklist[UserID].Add(Orderdata);
}
else
{
//没有这个商铺，添加这个商铺，在往商铺里面的list里添加
if (UserFootmarklist.TryAdd(UserID, datalist) == true)
{
}
;
UserFootmarklist[UserID].Add(Orderdata);
}
}
}
}
skip += limit;
}
skip = 0;
var acounts9count = await dBProxyComponent.QueryCount <ThumbProduct>("{ }");
while (skip < acounts9count)
{
string Json = "{ }"; //查找类型里面可以添加斜杠来做匹配查找，例如：{userNowArea:/^湖南省/}
string sort = "{ }"; //排序方式，必须要有参数和排序方式，例如：{userID:1}
string LSS = Json + "|" + skip + "|" + limit + "|" + sort;
var acounts1 = await dBProxyComponent.QueryLss <ThumbProduct>(LSS);
foreach (ThumbProduct item in acounts1)
{
ThumbProduct Orderdata = item as ThumbProduct;
if (Orderdata._State == 0)
{
long ThumbProductID = Orderdata._ThumbProductID;
lock (ThumbUserlist)
{
List <ThumbProduct> datalist = new List <ThumbProduct>();
if (ThumbUserlist.ContainsKey(ThumbProductID))
{
//有这个商铺直接往这个商铺的list里添加
ThumbUserlist[ThumbProductID].Add(Orderdata);
}
else
{
//没有这个商铺，添加这个商铺，在往商铺里面的list里添加
if (ThumbUserlist.TryAdd(ThumbProductID, datalist) == true)
{
}
;
ThumbUserlist[ThumbProductID].Add(Orderdata);
}
}
}
}
skip += limit;
}
skip = 0;
var acounts10count = await dBProxyComponent.QueryCount <EvaluateProduct>("{ }");
while (skip < acounts10count)
{
string Json = "{ }"; //查找类型里面可以添加斜杠来做匹配查找，例如：{userNowArea:/^湖南省/}
string sort = "{ }"; //排序方式，必须要有参数和排序方式，例如：{userID:1}
string LSS = Json + "|" + skip + "|" + limit + "|" + sort;
var acounts1 = await dBProxyComponent.QueryLss <EvaluateProduct>(LSS);
foreach (EvaluateProduct item in acounts1)
{
EvaluateProduct Orderdata = item as EvaluateProduct;
if (Orderdata._State == 0)
{
long EvaluateProductID = Orderdata._EvaluateProductID;
lock (ProductEvaluatelist)
{
List <EvaluateProduct> datalist = new List <EvaluateProduct>();
if (ProductEvaluatelist.ContainsKey(EvaluateProductID))
{
//有这个商铺直接往这个商铺的list里添加
ProductEvaluatelist[EvaluateProductID].Add(Orderdata);
}
else
{
//没有这个商铺，添加这个商铺，在往商铺里面的list里添加
if (ProductEvaluatelist.TryAdd(EvaluateProductID, datalist) == true)
{
}
;
ProductEvaluatelist[EvaluateProductID].Add(Orderdata);
}
}
}
}
skip += limit;
}
skip = 0;
}
catch (Exception e)
{
Log.Debug("ProductCenterComponent:GetDayDataFromDB:" + e);
}
}
