private static Dictionary<string, PositionModel> CalculateResults(Dictionary<string, PositionModel> traderPositions)
{
Dictionary<string, PositionModel> result = new Dictionary<string, PositionModel>();
foreach (var traderInfo in traderPositions)
{
foreach (var distinctSymbolData in traderInfo.Value.Symbol.GroupBy(r => r.Symbol))
{
foreach (var symbolData in distinctSymbolData)
{
if (symbolData.Quantity < 0 && distinctSymbolData.Count()>1 &&
distinctSymbolData.Select(r => r.Broker).Distinct().Count() > 0)
{
var longValuesSum = distinctSymbolData.Where(r => r.Quantity > 0);
decimal sumLong = longValuesSum.Sum(r => r.Quantity);
var shortValuesSum = distinctSymbolData.Where(r => r.Quantity < 0);
decimal sumShort = shortValuesSum.Sum(r => Math.Abs(r.Quantity));
SymbolData resultData = new SymbolData();
resultData.IsBoxed = true;
resultData.Quantity = Math.Min(sumLong, sumShort);
resultData.Symbol = symbolData.Symbol;
PositionModel positionResult = new PositionModel();
List<SymbolData> lstSymbolData = new List<SymbolData>();
lstSymbolData.Add(resultData);
positionResult.Symbol = lstSymbolData;
result.Add(traderInfo.Key, positionResult);
}
}
}
}
return result;
}
public async Task DeletePositionAsync(PositionModel model)
{
await Task.CompletedTask;
using (var tableAdapter = new PositionTableAdapter())
{
tableAdapter.Delete(model.Id);
}
}
public static PositionsEntity ToDto(PositionModel model)
{
return(new PositionsEntity
{
PosID = model.PosID,
DepID = model.DepID,
PosName = model.PosName,
// Temp = model.Temp
});
}
private IPositionModel PopulateModelFromInterface()
{
IPositionModel positionModel = new PositionModel();
positionModel.CreatedBy = createdBy.Text;
positionModel.CreatedDate = createdDate.Value;
positionModel.Id = 0;
positionModel.PositionName = positionName.Text;
return(positionModel);
}
public ActionResult Edit([Bind(Include = "PositionId,PositionName")] PositionModel positionModel)
{
if (ModelState.IsValid)
{
repository.Update(positionModel);
repository.Save();
return(RedirectToAction("Index"));
}
return(View(positionModel));
}
private bool CanBeACastle(List <CastleModel> curlist, PositionModel item, PositionModel center)
{
if (curlist.Any(e => e.Position == item && e.IsAdded))
{
return(false);
}
double num = Helpers.DistanceBetween(item.Lat, item.Lng, center.Lat, center.Lng);
return(num <= 500.0 && num >= 50.0 && !curlist.Any(p => Helpers.DistanceBetween(p.Position.Lat, p.Position.Lng, item.Lat, item.Lng) < 50.0));
}
public ActionResult Edit(Guid id)
{
PositionModel position = new PositionModel(id);
if (position == null)
{
return(HttpNotFound());
}
return(View(position));
}
public async Task <PositionModel> UpdatePositionAsync(PositionModel position)
{
var positionForUpdate = await positionRepository.GetAsync(position.Id);
positionForUpdate.ModifiedDate = DateTime.Now;
positionForUpdate.Description = position.Description;
await positionRepository.SaveChangesAsync();
return(mapper.Map <PositionModel>(positionForUpdate));
}
public void ShowPosition(PositionModel position)
{
Console.WriteLine("Id:\t\t{0}\nName:\t\t{1}\nSymbolId:\t{2}\nOpenDate:\t{3}\nOpenPrice:\t{4}\nOpenWeight:\t{5}\n" +
"TradeType:\t{6}\nTradeStatus:\t{7}\nCloseDate:\t{8}\nClosePrice:\t{9}\nCurrentPrice:\t{10}\n" +
"LastUpdateDate:\t{11}\nLastUpdatePrice:{12}\nGain:\t\t{13}\nAbsoluteGain:\t{14}\nMaxGain:\t{15}\n" +
"Dividends:\t{16}\nCurrencySymbol:\t{17}\n",
position.Id, position.Name, position.SymbolId, position.OpenDate, position.OpenPrice, position.OpenWeight, position.TradeType,
position.TradeStatus, position.CloseDate, position.ClosePrice, position.CurrentPrice, position.LastUpdateDate, position.LastUpdatePrice,
position.Gain, position.AbsoluteGain, position.MaxGain, position.Dividends, position.CurrencySymbol);
}
public static PositionViewModel MapPositionModelToPositionViewModel(PositionModel positionModel)
{
PositionViewModel positionViewModel = new PositionViewModel();
positionViewModel.Name = positionModel.Name;
positionViewModel.MinSalary = positionModel.MinSalary;
positionViewModel.MaxSalary = positionModel.MaxSalary;
return(positionViewModel);
}
public async Task <RouteModel> GetFirstRoute(PositionModel @from, PositionModel to, GameSpeed gameSpeed)
{
var direction = await GetDirection(@from, to);
if (direction.Status == DirectionsStatusCodes.OK && direction.Routes != null && direction.Routes.Any() && direction.Routes.ElementAt(0).Legs != null && direction.Routes.ElementAt(0).Legs.Any())
{
var selectedRouteLeg = direction.Routes.ElementAt(0).Legs.ElementAt(0);
return(FormatRoute(selectedRouteLeg, gameSpeed));
}
return(null);
}
public async Task DeletePositionAsync(PositionModel model)
{
using (var context = new StudentElectionContext())
{
var position = await context.Positions.SingleOrDefaultAsync(p => p.Id == model.Id);
context.Positions.Remove(position);
await context.SaveChangesAsync();
}
}
public async Task UpdatePositionAsync(PositionModel model)
{
using (var context = new StudentElectionContext())
{
var position = await context.Positions.SingleOrDefaultAsync(p => p.Id == model.Id);
_mapper.Map(model, position);
await context.SaveChangesAsync();
}
}
public ActionResult DetailPosition(string Position_ID)
{
PositionModel Model = new PositionModel();
Position r = db.Positions.Where(w => w.Position_ID.ToString() == Position_ID).FirstOrDefault();
Model.Position_ID = r.Position_ID;
Model.Name = r.Name;
Model.Initial = r.Initial;
Model.Detail = r.Detail;
return(Json(new { Position_ID = r.Position_ID, Name = r.Name, Initial = r.Initial, Detail = r.Detail }, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Recommend(string positionId, string personId, string personAppointmentId,
string seatId, string id)
{
//getting required data from session
var json = HttpContext.Session.GetString(SessionNominationModel);
var model = JsonConvert.DeserializeObject <NominationDetailModel>(json);
var institutionId = model.Institution.Id;
var cycleId = HttpContext.Session.GetString(SelectedCycle);
PositionModel position = model.Positions.Where(p => p.Id == positionId).FirstOrDefault();
//NominationModel nominationModel = position.Nominations.Where(n => n.Person.Id == personId).FirstOrDefault();
var positionModel =
await new RestfulClient(_logger,
HttpContext.Session.Get <AuthenticationResponse>("AuthenticationResponse")?.Token).Recommend(personAppointmentId, position, cycleId, institutionId);
//update data in session
model.Positions.Where(p => p.Id == positionId).Select(Positions => { Positions = positionModel; return(Positions); }).ToList();
var updatedJson = JsonConvert.SerializeObject(model);
HttpContext.Session.SetString(SessionNominationModel, updatedJson);
if (positionModel.IsError)
{
return(Json("Error - " + positionModel.ErrorMessage));
}
else
{
return(PartialView("_NominationsTablePartial", positionModel));
}
/*return PartialView("_NominationsTablePartial", new PositionModel
* {
* PositionName = "President",
* CurrentCycle = "2018 - 2020",
* CycleStatus = "On going",
* PreviousCycle = "2015 - 2018",
* Required = 3,
* Id = "123",
* Incubment = PersonDummyData(string.Empty),
* Nominations = new List<NominationModel>
* {
* new NominationModel
* {
* IsAppointed = false,
* IsRecommended = false,
* Priority = 1,
* Person = PersonDummyData(string.Empty),
* Id = "1111"
* }
* }
* });*/
}
public ActionResult AddPosition(PositionModel model)
{
if (ModelState.IsValid)
{
int record = CreatePosition(model.PositionName,
model.PositionSalary);
return(RedirectToAction("ViewPositions"));
}
return(View());
}
public async Task <HttpResponseMessage> PositionPut(long id, PositionModel model)
{
if (model != null)
{
await containerService.UpdatePositionAsync(id, model);
return(Success());
}
return(Failure("Невозможно добавить пустой элемент"));
}
//保存职位信息
public ActionResult SavePostion(PositionModel pModel)
{
if (pModel.PositionId == null || pModel.PositionId.ToString().Length == 0)
{
pModel.PositionId = Guid.Empty;
}
PositionLogic logic = new PositionLogic();
var result = logic.SavePosition(pModel);
return(Json(result));
}
private static void AddNewTraderInfo(Dictionary<string, PositionModel> traderPositions, DataRow dr)
{
PositionModel pmData = new PositionModel();
SymbolData symbolData = new SymbolData();
symbolData.Symbol = dr["symbol"].ToString();
symbolData.Quantity = Convert.ToDecimal(dr["quantity"].ToString());
symbolData.Broker = dr["broker"].ToString();
pmData.Symbol.Add(symbolData);
traderPositions.Add(dr["trader"].ToString(), pmData);
}
private void BtnEditProfile_Click(object sender, EventArgs e)
{
var document = new DocumentModel();
var position = new PositionModel();
Form currentForm = Application.OpenForms.OfType <Form>().Where(f => f.Name == "FrmEmployeeDetails").SingleOrDefault <Form>();
if (currentForm != null)
{
cmbPosition.Enabled = UserCache.PositionId == (int)PositionEnum.Administrator;
txtFirstName.Enabled = true;
txtLastName.Enabled = true;
mskTxtBirthday.Enabled = true;
cmbTypeDocument.Enabled = true;
txtDocumentNumber.Enabled = true;
txtAddress.Enabled = true;
txtPhone.Enabled = true;
txtEmail.Enabled = true;
txtUser.Enabled = true;
//stateYes.Enabled = true;
//stateNo.Enabled = true;
passYes.Enabled = true;
passNo.Enabled = true;
cmbPosition.DataSource = position.GetPositionList();
cmbPosition.ValueMember = "PositionId";
cmbPosition.DisplayMember = "PositionName";
cmbPosition.DisplayMember = UserCache.PositionName;
txtFirstName.Text = UserCache.FirstName;
txtLastName.Text = UserCache.LastName;
mskTxtBirthday.Text = UserCache.BirthDate.ToString();
cmbTypeDocument.DataSource = document.GetDocumentList();
cmbTypeDocument.ValueMember = "TypeDocumentId";
cmbTypeDocument.DisplayMember = "DocumentName";
txtDocumentNumber.Text = UserCache.DocumentNumber;
txtAddress.Text = UserCache.Address;
txtPhone.Text = UserCache.PhoneNumber;
txtEmail.Text = UserCache.Email;
txtUser.Text = UserCache.UserName;
if (UserCache.StateB == true)
{
stateYes.Checked = true;
stateNo.Checked = false;
}
else
{
stateYes.Checked = false;
stateNo.Checked = true;
}
}
}
public void Update(Position position)
{
PositionModel model = NHibernateHelper.CurrentSession.Get <PositionModel>(position.ID);
model.Name = position.Name;
model.Remark = position.Remark;
model.ParentId = position.Parent == null ? "" : position.Parent.ID;
model.UserIds = string.Join(",", position.Users.Select(u => u.ID));
NHibernateHelper.CurrentSession.Update(model);
NHibernateHelper.CurrentSession.Flush();
}
public void ShouldNotChangeCardinalPoint_SetCardinalPoint()
{
PositionModel position = new PositionModel
{
X = 0,
Y = 0,
CardinalPoint = "NORTE"
};
MainClass.SetCardinalPoint('A', position);
Assert.AreEqual("NORTE", position.CardinalPoint);
}
public async Task <ActionResult> Edit(int id, PositionModel model)
{
if (ModelState.IsValid && model != null)
{
var data = Mapper.Map <PositionModel, Position>(model);
await _positionService.UpdateAsync(data, id);
return(RedirectToAction("Index"));
}
return(View());
}
public bool Equals(PositionModel other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(Equals(other.Id, Id));
}
/// <summary>
/// 获取当前用户的职位信息
/// </summary>
/// <returns></returns>
public async Task <PositionModel> GetCurrentUserPositionAsync()
{
if (position != null)
{
return(position);
}
PositionModel positionModel = await GetPositionAsync(PositionId.Value);
position = positionModel;
return(position);
}
public ActionResult ModalWindow(string personid, string parentpositionid)
{
try {
PositionModel model = new PositionModel {
position = client.getPositionById(getToken(), Int32.Parse(personid)),
parentPosition = client.getPositionById(getToken(), Int32.Parse(parentpositionid))
};
return(PartialView("Modal", model));
} catch (Exception ex) {
return(PartialView("Error"));
}
}
public static int CreatePosition(string positionName, double positionSalary)
{
PositionModel data = new PositionModel
{
PositionName = positionName,
PositionSalary = positionSalary
};
string sql = @"insert into dbo.Position (PositionName,PositionSalary) values(
@PositionName,@PositionSalary)";
return(SQLDataAccess.SaveData(sql, data));
}
private static void AddNewTraderInfo(Dictionary <string, PositionModel> traderPositions, DataRow dr)
{
PositionModel pmData = new PositionModel();
SymbolData symbolData = new SymbolData();
symbolData.Symbol = dr["symbol"].ToString();
symbolData.Quantity = Convert.ToDecimal(dr["quantity"].ToString());
symbolData.Broker = dr["broker"].ToString();
pmData.Symbol.Add(symbolData);
traderPositions.Add(dr["trader"].ToString(), pmData);
}
// 呼叫position service利用所選取之職位查詢該職位底薪
public String SearchBasicSalaryByPositionID()
{
String positionID = this._employeeModel.GetPositionID();
this._positionModel.SetId(positionID);
this._positionService = new PositionService(this._positionModel);
this._positionModel = _positionService.SearchBsicSalaryByPositionID();
return(this._positionModel.GetBasicSalary().ToString());
}
private static void AttachPositions(Event viewEvent, EventBindingModel model)
{
foreach (var position in viewEvent.Sport.Positions)
{
PositionModel newPosition = new PositionModel();
newPosition.EventId = viewEvent.Id;
newPosition.Id = position.Id;
newPosition.Name = position.Name;
newPosition.Team = position.Team;
model.Positions.Add(newPosition);
}
}
private List <PlayerInSessionModel> InitializePlayers(List <PlayerModel> players, MapTileModel[,] map)
{
var rnd = new Random();
var playersInSession = new List <PlayerInSessionModel>();
foreach (var player in players)
{
PositionModel pos = GetRandomPlayerPosition(map, rnd);
playersInSession.Add(new PlayerInSessionModel(pos, player, map));
}
return(playersInSession);
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
positionList = PositionModel.Init();
otherPositionList = OtherPositionModel.Init();
dpDate.SelectedDate = DateTime.Now;
workerFilterList = WorkerFilterModel.Create(section.SectionId);
if (bwLoadData.IsBusy == false)
{
this.Cursor = Cursors.Wait;
bwLoadData.RunWorkerAsync();
}
}
public static Dictionary<string, PositionModel> Calculate(DataSet dsData)
{
Dictionary<string, PositionModel> traderPositions = new Dictionary<string, PositionModel>();
foreach (DataRow dr in dsData.Tables[0].Rows)
{
if (traderPositions.ContainsKey(dr["trader"].ToString()))
{
var postions = traderPositions[dr["trader"].ToString()];
SymbolData symbolData = new SymbolData();
var symbol = postions.Symbol.Where(r => r.Symbol == dr["symbol"].ToString()).ToList();
if (symbol.Count() > 0)
{
symbol.First().Quantity += Convert.ToDecimal(dr["quantity"].ToString());
}
else
{
symbolData.Symbol = dr["symbol"].ToString();
symbolData.Quantity = Convert.ToDecimal(dr["quantity"].ToString());
postions.Symbol.Add(symbolData);
}
}
else
{
PositionModel pmData=new PositionModel();
SymbolData symbolData = new SymbolData();
symbolData.Symbol = dr["symbol"].ToString();
symbolData.Quantity = Convert.ToDecimal(dr["quantity"].ToString());
pmData.Symbol.Add(symbolData);
traderPositions.Add(dr["trader"].ToString(), pmData);
}
}
return traderPositions;
}
private bool ValidateMove(Figure figure, int toRow, int toCol)
{
PositionModel toPosition = new PositionModel() { Row = toRow, Col = toCol };
PositionModel fromPosition = new PositionModel() { Row = figure.PositionRow, Col = figure.PositionCol };
if (toRow > 8 || toCol > 8)
{
return false;
}
if (toRow < 0 || toCol < 0)
{
return false;
}
var currentFigure = FigureFactory.GetFigure(figure);
List<PositionModel> possibleMoves = currentFigure.GetPossibleMoves();
List<PositionModel> possibleHits = currentFigure.GetPossibleHits();
var checkedPosMoves = possibleMoves.Find(x => x.Col == toPosition.Col && x.Row == toPosition.Row);
var checkedPosHits = possibleHits.Find(x => x.Col == toPosition.Col && x.Row == toPosition.Row);
if (checkedPosMoves == null && checkedPosHits == null)
{
return false;
}
if (!currentFigure.CanJump())
{
FigureRepository figureRepository = data.GetFigureRepository();
HashSet<PositionModel> movePath = GetMovePath(fromPosition, toPosition);
IQueryable<Figure> allGameFigures = figureRepository.GetGameFigures(figure.GameId);
HashSet<PositionModel> gameFiguresPositions = new HashSet<PositionModel>();
foreach (Figure gameFig in allGameFigures)
{
gameFiguresPositions.Add(new PositionModel()
{
Row = gameFig.PositionRow,
Col = gameFig.PositionCol
});
}
var positionIntersection = movePath.Intersect<PositionModel>(gameFiguresPositions);
if (positionIntersection.Count() > 0)
{
return false;
}
}
return true;
}
/// <summary>
/// constructor
/// </summary>
/// <param name="positionModel"></param>
public JobHistoryViewModel(PositionModel positionModel)
{
JobHistoryForm = new JobHistoryForm();
PositionModel = positionModel;
}
private IPositionModel PopulateModelFromInterface()
{
IPositionModel positionModel = new PositionModel();
positionModel.CreatedBy = createdBy.Text;
positionModel.CreatedDate = createdDate.Value;
positionModel.Id = 0;
positionModel.PositionName = positionName.Text;
return positionModel;
}
public bool Equals(PositionModel other)
{
if (ReferenceEquals(null, other)) return false;
if (ReferenceEquals(this, other)) return true;
return Equals(other.Id, Id);
}
private HashSet<PositionModel> GetMovePath(PositionModel fromPosition, PositionModel toPosition)
{
HashSet<PositionModel> movePath = new HashSet<PositionModel>();
if ((fromPosition.Col > toPosition.Col && fromPosition.Row < toPosition.Row) ||
(fromPosition.Col < toPosition.Col && fromPosition.Row > toPosition.Row))
{
int startCol = Math.Min(fromPosition.Col, toPosition.Col);
int endCol = Math.Max(fromPosition.Col, toPosition.Col);
int startRow = Math.Max(fromPosition.Row, toPosition.Row);
int endRow = Math.Min(fromPosition.Row, toPosition.Row);
int colDirection = 1;
int rowDirection = -1;
int numberOfSteps = Math.Abs(endCol - startCol);
for (int i = 1; i < numberOfSteps; i++)
{
startCol += colDirection;
startRow += rowDirection;
PositionModel newPosition = new PositionModel()
{
Col = startCol,
Row = startRow
};
movePath.Add(newPosition);
}
}
else
{
int startCol = Math.Min(fromPosition.Col, toPosition.Col);
int endCol = Math.Max(fromPosition.Col, toPosition.Col);
int startRow = Math.Min(fromPosition.Row, toPosition.Row);
int endRow = Math.Max(fromPosition.Row, toPosition.Row);
int colDirection = 0;
if (startCol != endCol)
{
colDirection = 1;
}
int rowDirection = 0;
if (startRow != endRow)
{
rowDirection = 1;
}
int numberOfSteps = Math.Max(endCol - startCol, endRow - startRow);
for (int i = 1; i < numberOfSteps; i++)
{
startCol += colDirection;
startRow += rowDirection;
PositionModel newPosition = new PositionModel()
{
Col = startCol,
Row = startRow
};
movePath.Add(newPosition);
}
}
return movePath;
}
