public bool DeleteCommodityType(CommodityType commodityType)
{
if (commodityType == null) return false;
_unitOfWork.CommodityTypeRepository.Delete(commodityType);
_unitOfWork.Save();
return true;
}
private void SelectSymbol(string symbol, CommodityType type = CommodityType.Stocks, WnFCandles ch = null)
{
if (symbol == symbolOnDisplay)
{
return;
}
splitContainer2.Panel2.Controls.RemoveAt(0); splitContainer2.Panel1Collapsed = true;
if (!toolStripCBSymbol.AutoCompleteCustomSource.Contains(symbol))
{
chartsDic[symbol] = new Dictionary <CandlePeriod, CChartPanel>();
if (!toolStripCBSymbol.Items.Contains(symbol))
{
toolStripCBSymbol.Items.Add(symbol);
}
toolStripCBSymbol.AutoCompleteCustomSource.Add(symbol);
}
if (!symbolsOn.ContainsKey(symbol))
{
symbolsOn[symbol] = new Dictionary <CandlePeriod, WnFCandles>();
if (ch != null)
{
symbolsOn[symbol][(CandlePeriod)ch.Period] = ch;
}
}
toolStripCBSymbol.Text = symbol;
this.Text = Properties.Settings.Default.tm + " - " + symbolsDic[symbol];
}
public override int GetHashCode()
{
int hash = 1;
if (CommodityId != 0)
{
hash ^= CommodityId.GetHashCode();
}
if (CommodityType != 0)
{
hash ^= CommodityType.GetHashCode();
}
if (ProductId.Length != 0)
{
hash ^= ProductId.GetHashCode();
}
if (Price != 0D)
{
hash ^= Price.GetHashCode();
}
if (AmountRmb != 0D)
{
hash ^= AmountRmb.GetHashCode();
}
if (Currency.Length != 0)
{
hash ^= Currency.GetHashCode();
}
return(hash);
}
public List <CommodityType> LoadCommodityTypes(string whereClause)
{
List <CommodityType> commodityTypeList = new List <CommodityType>();
string sqlQuery = "SELECT * FROM " + CommodityType._tableName;
sqlQuery += ((whereClause != null && whereClause.Length > 0) ? " WHERE " + whereClause : "");
try
{
OleDbCommand sqlCommand = new OleDbCommand(sqlQuery, _accessConnection);
OleDbDataReader reader = sqlCommand.ExecuteReader();
while (reader.Read())
{
CommodityType newComm = new CommodityType();
newComm.Load(reader);
commodityTypeList.Add(newComm);
}
}
catch (Exception e)
{
}
return(commodityTypeList);
}
// Examines a list to see if a type of reward exists, and adds one if none exists
private void UpdateOrAdd(ref List <RewardRange> ranges, CommodityType type, string id, int low, int high, bool addZeroToRange = false)
{
int index = string.IsNullOrEmpty(id)
? ranges.FindIndex(r => r.Type == type && string.IsNullOrEmpty(r.ID))
: ranges.FindIndex(r => r.Type == type && r.ID == id);
if (index < 0)
{
if (0 < low)
{
low = 0;
}
else if (0 > high)
{
high = 0;
}
ranges.Add(new RewardRange(type, id, low, high));
}
else
{
RewardRange range = ranges[index];
if (low < range.Low)
{
range.Low = low;
}
if (high > range.High)
{
range.High = high;
}
ranges[index] = range;
}
}
public List <Model.CommodityType> GetCommodityType()
{
List <Model.CommodityType> books = new List <Model.CommodityType>();
CommodityType book = null;
if (DBHerpel.OpenConnection())
{
SqlDataReader dr = DBHerpel.ExecReader("select * from CommodityType where State=0");
if (dr != null)
{
while (dr.Read())
{
book = new CommodityType();
book.CommodityTypeID = (int)dr["CommodityTypeID"];
book.CommodityTypeName = dr["CommodityTypeName"] as string;
book.State = (int)dr["State"];
books.Add(book);
}
}
DBHerpel.CloseConnection();
}
return(books);
}
static public Occupation CommodityTypeToOccupation(CommodityType type)
{
if (type == CommodityType.Wheat)
{
return(Occupation.Farmer);
}
else if (type == CommodityType.Fish)
{
return(Occupation.Fisher);
}
else if (type == CommodityType.Timber)
{
return(Occupation.Woodworker);
}
else if (type == CommodityType.Grapes)
{
return(Occupation.GrapeFarmer);
}
else if (type == CommodityType.Cattle)
{
return(Occupation.CattleRancher);
}
else if (type == CommodityType.Pig)
{
return(Occupation.PigRancher);
}
else if (type == CommodityType.FruitVegetables)
{
return(Occupation.FruitVegFarmer);
}
else
{
return(Occupation.NutFarmer);
}
}
public JsonResult EditCommodityType(FormCollection form)
{
var apiResult = new APIResult();
try
{
var opt = form["opt"];
CommodityType model = new CommodityType();
model.Name = form["name"];
if (opt == "0")
{
model.Pid = Convert.ToInt64(form["id"]);
}
else
{
model.Id = Convert.ToInt64(form["id"]);
}
CommodityTypeBll.AddOrUpdate(model, UserContext.CurrentUser.Name, UserContext.CurrentUser.HotelId);
}
catch (Exception ex)
{
apiResult.Ret = -1;
apiResult.Msg = ex.Message;
if (!(ex is OperationExceptionFacade))
{
LogFactory.GetLogger().Log(LogLevel.Error, ex);
}
}
return(Json(apiResult));
}
public RewardRange(CommodityType type, string id, int low, int high)
{
Type = type;
ID = id;
Low = low;
High = high;
}
public static void UpdateCommodityData(CommodityType comType, CommodityData data)
{
List <CommodityData> list = null;
if (!sVipCommodityDicts.TryGetValue(comType, out list))
{
list = new List <CommodityData>();
}
bool tFind = false;
for (int i = 0; i < list.Count; i++)
{
if (list[i].IsEquals(data))
{
list[i] = data;
tFind = true;
break;
}
}
if (!tFind)
{
list.Add(data);
}
sVipCommodityDicts[comType] = list;
}
public int getMinimumTradeValue(int demandedInt)
{
if (demandedInt < 0 || demandedInt > 7)
{
return(4);
}
else
{
int minimum = 4;
if (demandedInt < 5)
{
ResourceType typeDemanded = (ResourceType)demandedInt;
int settlementsMin = findMinTradeValue(ownedUnits [typeof(Settlement)].Cast <IntersectionUnit>().ToList(), typeDemanded);
int citiesMin = findMinTradeValue(ownedUnits [typeof(City)].Cast <IntersectionUnit>().ToList(), typeDemanded);
minimum = Math.Min(settlementsMin, citiesMin);
}
else
{
CommodityType typeDemanded = (CommodityType)(demandedInt - 5);
int settlementsMin = findMinTradeValue(ownedUnits [typeof(Settlement)].Cast <IntersectionUnit>().ToList(), typeDemanded);
int citiesMin = findMinTradeValue(ownedUnits [typeof(City)].Cast <IntersectionUnit>().ToList(), typeDemanded);
minimum = Math.Min(settlementsMin, citiesMin);
}
return(minimum);
}
}
public RewardRange(ref RewardRange arg)
{
Type = arg.Type;
ID = arg.ID;
Low = arg.Low;
High = arg.High;
}
public RewardRange(ref CommodityVO arg)
{
Type = arg.Type;
ID = arg.ID;
Low = arg.Value;
High = arg.Value;
}
public static CommodityTypeViewModel BindCommodityTypeViewModel(CommodityType commodityType)
{
return(new CommodityTypeViewModel()
{
Name = commodityType.Name,
CommodityTypeId = commodityType.CommodityTypeID
});
}
public static AssetTuple getAsset(CommodityType commodityType, int number)
{
AssetTuple returnTuple = new AssetTuple();
returnTuple.commodities.commodityTuple [commodityType] = number;
return(returnTuple);
}
private CommodityType GetCommodityType(long commodityTypeId)
{
CommodityType commodityType =
conn.Query <CommodityType>(string.Format("SELECT id, name FROM commoditytype WHERE id = {0}", commodityTypeId))
.FirstOrDefault();
return(commodityType);
}
private void BindLookUps()
{
var movingAverageGroup = new MovingAverageGroup();
movingAverageGroup.LoadByUser(CurrentContext.UserId);
lkAccount.Properties.DataSource = movingAverageGroup.DefaultView;
lkCategory.Properties.DataSource = CommodityType.GetAllTypes();
}
//------------------------------------------------------------------------------------
public static void ClearCommodityDatas(CommodityType comType)
{
List <CommodityData> list = null;
if (sVipCommodityDicts.TryGetValue(comType, out list))
{
list.Clear();
}
}
public bool DeleteCommodityType(CommodityType commodityType)
{
if (commodityType == null)
{
return(false);
}
_unitOfWork.CommodityTypeRepository.Delete(commodityType);
_unitOfWork.Save();
return(true);
}
public ActionResult Create(CommodityType commoditytype)
{
if (ModelState.IsValid)
{
_commodityTypeService.AddCommodityType(commoditytype);
return(Json(new { success = true }));
}
return(PartialView(commoditytype));
}
public ActionResult Edit(CommodityType commoditytype)
{
if (ModelState.IsValid)
{
_commodityTypeService.EditCommodityType(commoditytype);
return(Json(new { success = true }));
}
// ViewBag.CommodityTypeID = new SelectList(db.Warehouses, "CommodityTypeID", "Name", store.WarehouseID);
return(PartialView(commoditytype));
}
public void GetCandles(string s, int p, CommodityType type, ref Dictionary <CandlePeriod, WnFCandles> dic, WnFDbConnectionWrapper wrpper = null)
{
WnFCandles ch = new QuandlChart(p, s, "WIKI", wrpper);
if (((QuandlChart)ch).GetCandles() > 0)
{
ch.FillCandles(_MAX_JSON);
}
dic[(CandlePeriod)p] = ch;
}
public void Find_Commodity_Type_By_Id_Test()
{
IUnitOfWork target = new UnitOfWork();
// Try finding a product by id
CommodityType testProduct = this.MockCommodityTypeRepository.CommodityType.FindById(2);
Assert.IsNotNull(testProduct);
Assert.IsInstanceOfType(testProduct, typeof(CommodityType)); // Test type
Assert.AreEqual("Non Food", testProduct.Name); // Verify it is the right product
}
public int UpdateCommodityType(CommodityType comm)
{
int result = 0;
/* TODO:THIS
* string sqlQuery = "UPDATE Commodities SET ";
* StringBuilder sbColValues = new StringBuilder();
* StringBuilder sbWhereClause = new StringBuilder();
* foreach (KeyValuePair<int, object> columnValue in comm.GetColumnValues())
* {
* ColumnDefinition columnDef = null;
* foreach (ColumnDefinition colDef in comm.ColumnDefs())
* {
* if (colDef.ColumnIndex == columnValue.Key)
* {
* columnDef = colDef;
* break;
* }
* }
* if (columnDef == null)
* {
* //TODO: LOG THIS!
* return result;
* }
*
* if (!columnDef.ColumnName.Equals("InventoryID"))
* {
* if (sbColValues.Length > 0)
* {
* sbColValues.Append(", ");
* }
* sbColValues.Append(columnDef.ColumnName + " = " + comm.GetInsertableValue(columnDef));
* }
* else
* {
* sbWhereClause.Append(" WHERE " + columnDef.ColumnName + " = " + comm.GetInsertableValue(columnDef));
* }
* }
*
* if (sbColValues.Length > 0 && sbWhereClause.Length > 0)
* {
* try
* {
* sqlQuery += sbColValues.ToString() + sbWhereClause.ToString();
* OleDbCommand sqlCommand = new OleDbCommand(sqlQuery, _accessConnection);
* result = sqlCommand.ExecuteNonQuery();
* }
* catch (Exception e)
* {
* //TODO: how to handle this?
* }
* }
*/
return(result);
}
public void receiveCommodity(CommodityType commodity, int amount)
{
if (amount < 0)
{
//Error
}
else
{
assets.commodities.commodityTuple [commodity] += amount;
}
}
public void CommodityTypeTest()
{
Commodity target = new Commodity(); // TODO: Initialize to an appropriate value
CommodityType expected = null; // TODO: Initialize to an appropriate value
CommodityType actual;
target.CommodityType = expected;
actual = target.CommodityType;
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public ActionResult Market(int id, FormCollection frm)
{
using (var session = DB.Instance.GetSession())
{
var guid = frm["guid"];
var system = session.Load <SolarSystem>(id);
var station = system.Stations.First(x => x.Guid == guid);
station.Commodities.Clear();
foreach (var post in frm.AllKeys)
{
if (post.StartsWith("c__"))
{
var parts = post.Substring(3).Split('_');
CommodityType type = (CommodityType)Enum.Parse(typeof(CommodityType), parts[0]);
CommodityAvailability supply = CommodityAvailability.None;
CommodityAvailability demand = CommodityAvailability.None;
double price = 0;
if (parts[1] == "supply")
{
supply = (CommodityAvailability)Enum.Parse(typeof(CommodityAvailability), frm[post]);
}
if (parts[1] == "demand")
{
demand = (CommodityAvailability)Enum.Parse(typeof(CommodityAvailability), frm[post]);
}
if (parts[1] == "price")
{
price = !String.IsNullOrEmpty(frm[post]) ? int.Parse(frm[post]) : 0;
}
if (supply != CommodityAvailability.None || demand != CommodityAvailability.None || price != 0)
{
var commodity = station.Commodities.FirstOrDefault(x => x.Type == type);
if (commodity == null)
{
commodity = new Commodity
{
Type = type
};
station.Commodities.Add(commodity);
}
commodity.Supply = supply != CommodityAvailability.None ? supply : commodity.Supply;
commodity.Demand = demand != CommodityAvailability.None ? demand : commodity.Demand;
commodity.Price = price != 0 ? price : commodity.Price;
commodity.Updated = DateTime.UtcNow;
}
}
}
session.SaveChanges();
return(RedirectToAction("Market", new { id = system.Id, guid = guid }));
}
}
public static List <CommodityData> GetCommodityList(CommodityType comType)
{
List <CommodityData> list = null;
if (sVipCommodityDicts.TryGetValue(comType, out list))
{
return(list);
}
return(list);
}
public void RegisterReward <T>(CommodityType type) where T : ICommand <CommodityVO>, new()
{
#if DEBUG
if (IsRegistered(type))
{
UnityEngine.Debug.LogError(">> Attempting to register previously registered reward type: \"" + type + "\"");
}
else
#endif
_rewardHandlers[type] = c => new T().Execute(c);
}
public void addCommodityWithType(CommodityType key, int value)
{
if (commodityTuple.ContainsKey(key))
{
commodityTuple[key] = value;
}
else
{
commodityTuple.Add(key, value);
}
}
protected override AbstractCommodity CreateCommodity(CommodityType commodityType)
{
AbstractCommodity commodity = null;
ICommodityIngredientFactory commodityIngredient = new ChaoshiCommodityIngredientFactory();
if ((commodityType & CommodityType.Gongyinglian) == CommodityType.Gongyinglian)
{
commodity = new GongyinglianCommodity(commodityIngredient);
}
return(commodity);
}
public ErrorCode Create(CommodityTypeEditVM ct)
{
try
{
if (CommodityTypeDal.GetExisted(o => o.CommodityId == ct.CommodityId && o.Name == ct.Name))
{
return ErrorCode.CommodityTypeExisted;
}
var commType = new CommodityType
{
Name = ct.Name,
Description = ct.Description,
CommodityId = ct.CommodityId
};
CommodityTypeDal.Create(commType);
return ErrorCode.NoError;
}
catch (Exception)
{
return ErrorCode.ServerError;
}
}
public ErrorCode Update(CommodityTypeEditVM vm)
{
try
{
if (
CommodityTypeDal.GetExisted(
o => o.Id != vm.Id && o.CommodityId == vm.CommodityId && o.Name == vm.Name))
{
return ErrorCode.CommodityTypeExisted;
}
var commType = new CommodityType
{
Id = vm.Id,
Name = vm.Name,
Description = vm.Description,
CommodityId = vm.CommodityId
};
CommodityTypeDal.Update(commType);
return ErrorCode.NoError;
}
catch (Exception)
{
return ErrorCode.ServerError;
}
}
public bool EditCommodityType(CommodityType commodityType)
{
_unitOfWork.CommodityTypeRepository.Edit(commodityType);
_unitOfWork.Save();
return true;
}
