public ActionItem GetById(int Id)
{
ActionItem who = null;
_prov.ExecuteCmd("dbo.ActionItem_SelectById",
inputParamMapper : delegate(SqlParameterCollection parameter)
{
parameter.AddWithValue("@Id", Id);
},
singleRecordMapper : delegate(IDataReader rdr, short set)
{
switch (set)
{
case 0:
who = MapActionItem(rdr);
break;
case 1:
int actionItemId = rdr.GetSafeInt32(0);
PersonBase per = MapPersonBase(rdr, 1);
ActionItem parent = who;
if (parent.Assignees == null)
{
parent.Assignees = new List <PersonBase>();
}
parent.Assignees.Add(per);
break;
}
}
);
return(who);
}
public override void CheckTransition(PersonBase targetPerson)
{
if (targetPerson == null)
{
Fsm.PerformTransition(Transition.SeekTarget);
return;
}
if (!targetPerson.personData.Alive)
{
Fsm.PerformTransition(Transition.SeekTarget);
return;
}
Vector3 targetPos = targetPerson.transform.position;
targetPos.y = myPerson.transform.position.y;
float distance = Vector3.Distance(targetPos, myPerson.transform.position);
if (myPerson.personData.AttackDistance < distance)
{
//转到攻击状态
Fsm.PerformTransition(Transition.MoveToTarget);
}
Debug.Log("处于攻击状态");
}
public MoveToTarget(PersonBase mySelf, FsmSystem fsmSystem, Animator _anim)
{
myPerson = mySelf;
stateID = StateID.MoveToTarget;
Fsm = fsmSystem;
anim = _anim;
}
private void SetUpData()
{
this.personBase = new PersonBase();
this.personBase = this.FilledPerson();
this.personsPartyManager = DIContainer.Instance.Resolve<PersonsPartyManager>();
this.SetUpPartyManagerData();
}
/// <summary>
/// Crews the member mapper.
/// </summary>
/// <param name="crewmemberCollection">The crew member collection.</param>
/// <param name="crew">The object of personBase.</param>
public static void CrewmemberMapper(CrewmemberCollection crewmemberCollection, PersonBase crew)
{
var crewmember = new Crewmember();
if (crew != null && crewmemberCollection != null)
{
crewmember.CrewmemberId = crew.PersonId;
crewmember.PersonalDetail = crew.PersonalDetail;
crewmember.Photo = crew.Photo;
crewmember.SecurityPhotoAddress = crew.SecurityPhotoAddress;
crewmember.EmployeeNo = crew.EmployeeNo;
crewmember.IsOnboard = crew.IsOnboard;
crewmember.AreAllMessagesGotAcknowledged = crew.AreAllMessagesGotAcknowledged;
crewmember.LastDateTime = crew.LastDateTime;
crewmember.LastEvent = crew.LastEvent;
crewmember.Stateroom = crew.Stateroom;
crewmember.HasAlert = crew.HasAlert;
crewmember.HasMessage = crew.HasMessage;
crewmember.Department = crew.Department;
crewmember.StateroomOccupancy = crew.StateroomOccupancy;
crewmember.Position = crew.Position;
crewmember.AssignAlerts(crew.Alerts);
crewmember.AssignMessages(crew.Messages);
crewmember.BoardingInfo.OnboardDate = crew.BoardingInfo.OnboardDate;
crewmember.BoardingInfo.AshoreDate = crew.BoardingInfo.AshoreDate;
crewmember.AllowOnboardAlert = crew.AllowOnboardAlert;
crewmember.PortAssignedDate = crew.PortAssignedDate;
crewmemberCollection.Add(crewmember);
}
}
public static PersonBase SelectByEmail(string email)
{
PersonBase person = null;
DataProvider.ExecuteCmd(GetConnection, "dbo.Person_SelectByAspNetUsersEmail",
inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@email", email);
}
, map : delegate(IDataReader reader, short set)
{
switch (set)
{
case 0:
person = new PersonBase();
int startingIndex = 0; //startingOrdinal
person.Id = reader.GetSafeInt32(startingIndex++);
person.FirstName = reader.GetSafeString(startingIndex++);
person.MiddleName = reader.GetSafeString(startingIndex++);
person.LastName = reader.GetSafeString(startingIndex++);
person.PhoneNumber = reader.GetSafeString(startingIndex++);
person.Email = reader.GetSafeString(startingIndex++);
person.JobTitle = reader.GetSafeString(startingIndex++);
break;
}
}
);
return(person);
}
public static PersonSuggestion CreateSuggestion(this PersonBase person)
{
var id = person.Id != 0 ? person.Id : (int?)null;
var displayName = person.DisplayName;
return(new PersonSuggestion(id, displayName));
}
/// <summary>
/// Function to retrieve audible alert to play.
/// </summary>
/// <param name="person">Person information</param>
/// <param name="boardingStatusChangeState">Boarding status change information</param>
/// <returns>Audible alert information</returns>
private static AudibleAlert RetrieveAudibleAlert(PersonBase person, BoardingStatusChangeState boardingStatusChangeState)
{
switch (boardingStatusChangeState)
{
case BoardingStatusChangeState.AlreadyAshore:
return AudibleAlert.Rejected;
case BoardingStatusChangeState.AlreadyOnboard:
return AudibleAlert.Rejected;
case BoardingStatusChangeState.DeniedAshore:
return AudibleAlert.DeniedAshore;
case BoardingStatusChangeState.DeniedAshoreWithoutAuthorizedPerson:
return AudibleAlert.DeniedAshore;
case BoardingStatusChangeState.DeniedBoard:
return AudibleAlert.DeniedBoarding;
case BoardingStatusChangeState.NotCheckedIn:
return AudibleAlert.DeniedBoarding;
case BoardingStatusChangeState.PersonIsOnHold:
return AudibleAlert.PersonOnHold;
case BoardingStatusChangeState.Rejected:
return AudibleAlert.Rejected;
default:
if (person.IsOnboard)
{
return AudibleAlert.OnboardPerson;
}
return AudibleAlert.OffboardPerson;
}
}
private void dgvDealerList_CellContentClick(object sender, DataGridViewCellEventArgs e)
{
if (e.RowIndex == -1 || e.ColumnIndex == -1)
{
return;
}
if (GetSelectedCellText(dgvPersonList, e) == "Details")
{
PersonForm dealerForm = new PersonForm(_personType, ((PersonBase)dgvPersonList.Rows[e.RowIndex].DataBoundItem).Id);
ShowFormAsFixedDialog(this, dealerForm);
}
else if (GetSelectedCellText(dgvPersonList, e) == "Bills")
{
BillListForm billListForm = new BillListForm(_personType, ((PersonBase)dgvPersonList.Rows[e.RowIndex].DataBoundItem).Id);
ShowFormResizableAsDialog(this, billListForm);
}
else if (GetSelectedCellText(dgvPersonList, e) == "Select")
{
if (CallerForm != null && CallerForm.Name != null && CallerForm.Name == "CustomerCartDetailForm")
{
CustomerCartDetailForm customerBillBreakListForm = (CustomerCartDetailForm)CallerForm;
PersonBase person = (PersonBase)dgvPersonList.Rows[e.RowIndex].DataBoundItem;
customerBillBreakListForm.OnCustomerNameSelected(person.Id, person.Name);
Close();
}
}
}
private static SquadMember MapSquadMember(IDataReader reader, out int sm_SquadId)
{
SquadMember sm = new SquadMember();
int ord = 0;
PersonBase pb = new PersonBase();
SquadMemberStatus sms = new SquadMemberStatus();
sm.Id = reader.GetSafeInt32(ord++);
sm.SquadId = reader.GetSafeInt32(ord++);
sm_SquadId = sm.SquadId;
pb.Id = reader.GetSafeInt32(ord++);
sm.LeaderComment = reader.GetSafeString(ord++);
sm.DateCreated = reader.GetSafeDateTime(ord++);
sm.DateModified = reader.GetSafeDateTime(ord++);
sms.Id = reader.GetSafeInt32(ord++);
sms.Name = reader.GetSafeString(ord++);
pb.FirstName = reader.GetSafeString(ord++);
pb.MiddleName = reader.GetSafeString(ord++);
pb.LastName = reader.GetSafeString(ord++);
pb.PhoneNumber = reader.GetSafeString(ord++);
pb.Email = reader.GetSafeString(ord++);
pb.PhotoKey = reader.GetSafeString(ord++);
pb.ProfilePicture = SiteConfig.GetUrlFromFileKey(pb.PhotoKey);//this replaces the url
sm.IsLeader = reader.GetSafeBool(ord++);
sm.Person = pb;
sm.Status = sms;
return(sm);
}
private Response Root(PersonModel dto)
{
//PersonModel dto = this.Bind<PersonModel>();
if (dto == null)
{
return(HttpStatusCode.BadRequest);
}
else
{
Guid g = Guid.NewGuid();
CreateBase creat = new PersonCreater(g, dto.Name, dto.BirthDay);
PersonBase pers = creat.Create();
if (pers == null)
{
return(HttpStatusCode.UnprocessableEntity);
}
else
{
AddPerson((Person)pers);
var values = new Dictionary <string, string>
{
{ "Location", "http://localhost:1234/api/v1/persons/" },
{ "id", g.ToString() }
};
var response = new Response {
StatusCode = HttpStatusCode.Created, Headers = values
};
return(response);
}
}
}
/// <summary>
/// Function to map the Visitor entity to PersonBase.
/// </summary>
/// <param name="visitor">Instance of Visitor</param>
/// <returns>Instance of PersonBase</returns>
public static PersonBase MapToPersonBase(this Visitor visitor)
{
if (visitor == null)
{
throw new ArgumentNullException("visitor");
}
var personBase = new PersonBase();
personBase.PersonId = visitor.VisitorId;
personBase.PersonType = PersonType.Visitor;
personBase.PersonalDetail = visitor.PersonalDetail;
personBase.Photo = visitor.Photo;
personBase.IsPhotoAddedInCartForSwap = SwapPhotoManager.Instance.PhotoExistsInCart(personBase.PersonId);
personBase.AssignPhotoByteArray(visitor.PhotoByteArray);
personBase.IsOnboard = visitor.IsOnboard;
personBase.VisitorInfo = visitor.VisitorInfo;
personBase.PersonTypeId = CommonConstants.VisitorTypeId;
personBase.AreAllMessagesGotAcknowledged = visitor.AreAllMessagesGotAcknowledged;
personBase.LastDateTime = visitor.LastDateTime;
personBase.VisitorType = visitor.VisitorType;
personBase.LastEvent = visitor.LastEvent;
personBase.SecurityPhotoAddress = visitor.SecurityPhotoAddress;
personBase.HasAlert = visitor.HasAlert;
personBase.HasMessage = visitor.HasMessage;
personBase.CardNumber = visitor.CardNumber;
personBase.AssignAlerts(visitor.Alerts);
personBase.AssignPersonMessages(visitor.Messages);
personBase.AllowOnboardAlert = visitor.AllowOnboardAlert;
return personBase;
}
public AttackTarget(PersonBase myself, FsmSystem fsmSystem, Animator _anim)
{
myPerson = myself;
stateID = StateID.Attack;
Fsm = fsmSystem;
anim = _anim;
}
public override void AddNewPerson(PersonBase ObjPersonBase)
{
if (ObjPersonBase.FirstName != "" && ObjPersonBase.LastName != "")
{
_iRepoPersonBase.Add(ObjPersonBase);
}
}
private static Testimonial MapTestimonial(IDataReader reader)
{
Testimonial p = new Testimonial();
PersonBase pb = new PersonBase();
p.Person = pb;
int ord = 0; //startingOrdinal
p.Id = reader.GetSafeInt32(ord++);
p.Content = reader.GetSafeString(ord++);
p.DateCreated = reader.GetSafeDateTime(ord++);
p.DateModified = reader.GetSafeDateTime(ord++);
pb.Id = reader.GetSafeInt32(ord++);
pb.FirstName = reader.GetSafeString(ord++);
pb.MiddleName = reader.GetSafeString(ord++);
pb.LastName = reader.GetSafeString(ord++);
pb.PhoneNumber = reader.GetSafeString(ord++);
pb.Email = reader.GetSafeString(ord++);
pb.JobTitle = reader.GetSafeString(ord++);
string photo = reader.GetSafeString(ord++);
pb.ProfilePicture = "https://sabio-training.s3-us-west-2.amazonaws.com/C31/" + photo;
p.Inactive = reader.GetSafeBool(ord++);
return(p);
}
private async Task <ItemResponse <Guid> > SendResetPasswordEmail(PersonBase pb, ConfirmationEmailRequest model)
{
SecurityTokenAddRequest securityToken = new SecurityTokenAddRequest();
securityToken.FirstName = pb.FirstName;
securityToken.LastName = pb.LastName;
securityToken.Email = model.Email;
securityToken.TokenTypeId = 2;
securityToken.AspNetUserId = "";
Guid emailSecurityToken = SecurityTokenService.Insert(securityToken);
ConfirmationEmailRequest emailRequest = new ConfirmationEmailRequest();
emailRequest.FirstName = pb.FirstName;
emailRequest.LastName = pb.LastName;
emailRequest.Email = model.Email;
emailRequest.SecurityToken = emailSecurityToken;
await _emailService.ForgotPassword(emailRequest);
ItemResponse <Guid> response = new ItemResponse <Guid>();
response.Item = emailSecurityToken;
return(response);
}
public void PostPerson([FromBody] PersonBase ObjPersonToAdd)
{
if (ObjPersonToAdd.FirstName != "" && ObjPersonToAdd.LastName != "")
{
_ObjectOfPersonBusinessLogic.AddNewPerson(ObjPersonToAdd);
_ObjectUnitOfWork.Committ();
}
}
/// <summary>
/// Function to change boarding status.
/// </summary>
/// <param name="person">Instance of Person</param>
/// <returns>Boarding Status Change State</returns>
public async Task<BoardingStatusChangeState> ChangeBoardingStatus(PersonBase person)
{
if (person == null)
{
throw new ArgumentNullException("person");
}
return await this.ChangePersonBoardingStatus(person);
}
public async Task <Person> Add(PersonBase newPerson)
{
var entity = _recordMapper.Map(newPerson);
await _dbContext.Persons.AddAsync(entity);
await _dbContext.SaveChangesAsync();
return(entity);
}
private void UpdateContactInformation(PersonBase e)
{
NfcId = e.NfcId;
Lastname = e.Lastname;
Firstname = e.Firstname;
DisplayName = e.DisplayName;
Phone = e.ContactInformation.Phone;
Email = e.ContactInformation.Email;
Twitter = e.ContactInformation.Twitter;
}
private static PersonBase MapPersonBase(IDataReader rdr, int ord = 0)
{
PersonBase per = new PersonBase();
per.Id = rdr.GetSafeInt32(ord++);
per.FirstName = rdr.GetSafeString(ord++);
per.LastName = rdr.GetSafeString(ord++);
per.Email = rdr.GetSafeString(ord++);
per.Photo = rdr.GetSafeString(ord++);
return(per);
}
/// <summary>
/// Function to create messages for ashore.
/// </summary>
/// <param name="person">Instance of person.</param>
public void CreateAshoreMessages(PersonBase person)
{
if (person == null)
{
throw new ArgumentNullException("person");
}
if (person.PersonType == PersonType.Guest)
{
}
}
public void RemovePerson(PersonBase personBase)
{
if (personBase.personData.characterTypeEnum == CharacterTypeEnum.Player)
{
PlayerPersonList.Remove(personBase);
}
else if (personBase.personData.characterTypeEnum == CharacterTypeEnum.Enemy)
{
EnemyPersonList.Remove(personBase);
}
}
// smpt settings in web.config
public static void SendEmailBasePerson(PersonBase person)
{
MailMessage mailMessage = new MailMessage(fromMailAddres, toMailAddres);
mailMessage.Subject = "Post Report";
mailMessage.Body = person.ToString();
SmtpClient smtpClient = new SmtpClient();
smtpClient.Send(mailMessage);
}
/// <summary>
/// Initializes a new instance of the <see cref="PersonInfoUserControl" /> class.
/// </summary>
/// <param name="person">The person.</param>
/// <param name="isViewGangwayHistory">if set to <c>true</c> [is view gangway history].</param>
public PersonInfoUserControl(PersonBase person, bool isViewGangwayHistory)
{
if (person == null)
{
throw new ArgumentNullException("person");
}
this.InitializeComponent();
this.DataContext = this.personInfoViewModel;
this.personInfoViewModel.SelectedPerson = person;
this.personInfoViewModel.OnGangwayHistory = isViewGangwayHistory;
}
public static PersonBase InitPerson(PersonBase person)
{
person.FirstName = "John";
person.LastName = "Doe";
person.Baseball = true;
person.Football = false;
person.Basketball = true;
person.Father = "William Doe";
person.Mother = "Jennifer Doe";
person.HasChildren = false;
return(person);
}
public HttpResponseMessage LoadHome()
{
string aspNetUserId = UserService.GetCurrentUserId();
PersonBase pb = _personService.GetByAspNetUserId(aspNetUserId);
Person p = _personService.PublicSelect(pb.Id);
ItemResponse <Person> response = new ItemResponse <Person>();
response.Item = p;
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
public static PersonBase InitPerson( PersonBase person )
{
person.FirstName = "John";
person.LastName = "Doe";
person.Baseball = true;
person.Football = false;
person.Basketball = true;
person.Father = "William Doe";
person.Mother = "Jennifer Doe";
person.HasChildren = false;
return person;
}
/// <summary>
/// Creates the event.
/// </summary>
/// <param name="person">The person.</param>
/// <param name="gangwayEventType">Type of the gangway event.</param>
/// <param name="personEvent">The person event.</param>
/// <param name="boardingDetail">The boarding detail.</param>
/// <param name="clearAlertMessage">The clear alert message.</param>
public static async void CreateEvent(PersonBase person, GangwayEventType gangwayEventType, PersonEvent personEvent, BoardingDetail boardingDetail, ClearAlertMessage clearAlertMessage)
{
if (personEvent != null)
{
await GangwayRepositoryFactory.Retrieve().CreateEventAsync(personEvent, boardingDetail, clearAlertMessage);
}
else
{
var eventDetail = new EventDetail();
eventDetail.GangwayEventProcessType = person.GangwayEventProcessType.HasValue ? person.GangwayEventProcessType.Value : GangwayEventProcessType.Manual;
await GangwayRepositoryFactory.Retrieve().CreateEventAsync(MapPersonEvent(person, gangwayEventType, null, null, null, null, eventDetail), null, null);
}
}
public void InitChessPos(PersonData personData)
{
if (personData == null || personBase)
{
return;
}
GameObject model = Resources.Load <GameObject>("Prefab/" + GameConfig.HeroModelPath[personData.Id]);
GameObject personModel = Instantiate(model);
personModel.transform.position = transform.position;
personBase = personModel.GetComponent <PersonBase>();
personBase.Init(personData);
}
/// <summary>
/// Uploads photo asynchronous.
/// </summary>
/// <param name="swapPhoto">The swap photo.</param>
/// <param name="personBase">The person base.</param>
/// <param name="photo">The byte array of photo.</param>
/// <param name="gangwayEventType">Type of the gangway event.</param>
/// <returns>
/// Upload media Items.
/// </returns>
public async Task UploadPhotosAsync(SwapPhoto swapPhoto, PersonBase personBase, byte[] photo, GangwayEventType gangwayEventType)
{
var person = personBase != null ? personBase : new PersonBase
{
PersonId = swapPhoto.PersonId,
PersonType = swapPhoto.PersonType,
PersonTypeId = swapPhoto.PersonTypeId,
CruiseDetail = new GuestCruiseDetail { VoyageId = swapPhoto.VoyageId },
LinkId = swapPhoto.LinkId
};
var personEvent = CreateEventService.MapPersonEvent(person, null, gangwayEventType, null, null, null, null);
await GangwayRepositoryFactory.Retrieve().UploadPhotosAsync(person, photo, personEvent);
}
/// <summary>
/// Function to retrieve photo of person.
/// </summary>
/// <param name="person">Instance of PersonBase</param>
/// <returns>Instance of Task</returns>
public async Task RetrievePersonPhoto(PersonBase person)
{
if (person == null)
{
throw new ArgumentNullException("person");
}
if (!string.IsNullOrEmpty(person.SecurityPhotoAddress))
{
byte[] bytes = await person.SecurityPhotoAddress.PersonImageAddressToByteArray();
person.Photo = bytes.ToBitmapSource();
person.AssignPhotoByteArray(new Collection<byte>(bytes));
}
}
public override PersonBase Act(PersonBase targetPerson)
{
if (!anim.GetCurrentAnimatorStateInfo(0).IsName("Idle"))
{
anim.Play("Idle");
}
//查找目标
// targetPerson = FightMgr.instance.GetEnemyAtMinDistance(myPerson, out distance);
GameObject targetModel = GameObject.FindWithTag("Enemy");
targetPerson = targetModel?.GetComponent <PersonBase>();
return(targetPerson);
}
public void UpdateData(PersonBase personBase)
{
personData = personBase.personData;
if (personData == null)
{
return;
}
headImg.sprite = TextureMgr.instance.GetHeroHeadImgAtId(personData.Id);
drayImg.sprite = headImg.sprite;
levelText.text = personData.Level.ToString();
energySlider.value = personData.CurrEnergy * 1.0f / personData.MaxEnergy;
lifeSlider.value = personData.CurrLife * 1.0f / personData.MaxLife;
}
/// <summary>
/// Creates the event.
/// </summary>
/// <param name="person">The person.</param>
/// <param name="alertId">The alert identifier.</param>
/// <param name="gangwayEventType">Type of the gangway event.</param>
public static async void CreateEvent(PersonBase person, string alertId, GangwayEventType gangwayEventType)
{
var workstation = DIContainer.Instance.Resolve<Workstation>();
// Fills event detail.
var eventDetail = new EventDetail();
string eventTypeId = gangwayEventType.RetrieveEventTypeId();
eventDetail.GangwayEventProcessType = person.GangwayEventProcessType.HasValue ? person.GangwayEventProcessType.Value : GangwayEventProcessType.Manual;
eventDetail.AlertCode = alertId;
if (string.IsNullOrEmpty(alertId) && person.Alerts.Any(alert => alert.IsParentalAuthorizationAlert || alert.IsFolioAlert))
{
var alertData = person.Alerts.FirstOrDefault(alert => alert.IsParentalAuthorizationAlert || alert.IsFolioAlert);
if (alertData != null && alertData.Message != null)
{
eventDetail.AlertDescription = alertData.Message.Description;
}
}
else if (gangwayEventType == GangwayEventType.AlertRemoved && !string.IsNullOrEmpty(alertId))
{
eventDetail.AlertDescription = person.Alerts.Where(alert => alert.AlertId.Equals(alertId)).Select(a => a.Message.Description).FirstOrDefault();
}
else if (gangwayEventType == GangwayEventType.MessageRemoved && !string.IsNullOrEmpty(alertId))
{
eventDetail.AlertDescription = person.Messages.Where(alert => alert.AlertId.Equals(alertId)).Select(a => a.Message.Description).FirstOrDefault();
}
if (person.CruiseDetail != null)
{
eventDetail.ReservationNumber = person.CruiseDetail.ReservationNumber;
}
var personEvent = new PersonEvent()
{
EventTypeId = eventTypeId,
PersonId = person.PersonId,
PersonTypeId = person.PersonTypeId,
ShipId = workstation.Ship != null ? workstation.Ship.ShipId : null,
MachineName = workstation.MachineName,
Location = workstation.GangwayLocation != null ? workstation.GangwayLocation.Name : null,
Port = workstation.Port != null ? workstation.Port.Name : null,
AddedBy = workstation.User != null ? workstation.User.UserFullName : null,
EventDetails = eventDetail.RetrieveXml(),
EventDate = workstation.CurrentDateTime,
ApplicationId = CommonConstants.ApplicationId,
VoyageId = person.CruiseDetail != null ? person.CruiseDetail.VoyageId : null
};
await GangwayRepositoryFactory.Retrieve().CreateEventAsync(personEvent);
}
public static void SaveBasePerson(PersonBase person)
{
if (person != null)
{
SqlCommand command = new SqlCommand();
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "sproc_InsertBasePerson";
command.Parameters.AddWithValue("@FirstName", person.FirstName);
command.Parameters.AddWithValue("@LastName", person.LastName);
command.Parameters.AddWithValue("@Email", person.Email);
SaveToDb(command);
}
}
public static PersonBase MapBuyer(IDataReader reader)
{
PersonBase p = new PersonBase();
int startingIndex = 0;
p.Id = reader.GetSafeInt32(startingIndex++);
p.FirstName = reader.GetSafeString(startingIndex++);
p.LastName = reader.GetSafeString(startingIndex++);
p.PhoneCell = reader.GetSafeString(startingIndex++);
p.PhoneHome = reader.GetSafeString(startingIndex++);
p.PhoneWork = reader.GetSafeString(startingIndex++);
p.EmailPublic = reader.GetSafeString(startingIndex++);
p.KeyName = reader.GetSafeString(startingIndex++);
return(p);
}
/// <summary>
/// Вывод структуры в консоль
/// </summary>
public static void ShowStructure(PersonBase person)
{
if (person.GetType() == typeof(Adult))
{
Console.WriteLine("{0,-14} | {1,-14} | {2,-10} | {3,-10} " +
"| {4,-16} | {5, -13} | {6, -13}", "Имя", "Фамилия",
"Возраст", "Пол", "Состояние брака", "Работа", "Супруг");
}
else if (person.GetType() == typeof(Child))
{
Console.WriteLine("{0,-14} | {1,-14} | {2,-10} | {3,-10} " +
"| {4,-16} | {5, -13} | {6, -13}", "Имя", "Фамилия",
"Возраст", "Пол", "Состав семьи", "Детский сад", "Родители");
}
}
public bool DoesCustomerNameExists(Customer customer)
{
PersonBase existingCustomer = context.Customers
.Where(x => (x.Id != customer.Id && (x.Name.Trim().ToLower() == customer.Name.Trim().ToLower())) &&
(x.Address.Trim().ToLower() == customer.Address.Trim().ToLower()))
.FirstOrDefault();
if (existingCustomer == null)
{
return(false);
}
else
{
return(true);
}
}
/// <summary>
/// The save.
/// </summary>
/// <param name="personDetails">
/// The person details.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public void Save(PersonDetails personDetails)
{
var personBase = Mapper.Instance.Map <PersonDetails, PersonBase>(personDetails);
using (var dbContext = new StaplesDatabaseContext())
{
if (dbContext.Persons.Any(PersonBase.Comparer(personBase)))
{
// TODO some message ?
return;
}
dbContext.Persons.Add(personBase);
dbContext.SaveChanges();
}
}
public PersonBase[] FakePerson(int numPeople=1)
{
var fakePerson = A.Fake<PersonBase>();
fakePerson.Age = 33;
fakePerson.AthleteTypeValue = AthleteType.Triathlete;
fakePerson.FirstName = "John";
fakePerson.LastName = "Doe";
fakePerson.Username = "******";
fakePerson.PersonId = 12345;
var ret = new PersonBase[numPeople];
for (int i=0; i<numPeople;i++)
{
ret[i] = fakePerson;
}
return ret;
}
/// <summary>
/// 获取最短距离的敌人
/// </summary>
/// <param name="self"></param>
/// <param name="distance"></param>
/// <returns></returns>
public PersonBase GetEnemyAtMinDistance(PersonBase self, [CanBeNull] out float distance)
{
float minDistance = 99999;
distance = minDistance;
int index = 0;
if (self.personData.characterTypeEnum == CharacterTypeEnum.Player)
{
if (EnemyPersonList.Count <= 0)
{
return(null);
}
for (int i = 0; i < EnemyPersonList.Count; i++)
{
distance = Vector3.Distance(self.transform.position, EnemyPersonList[i].transform.position);
if (distance < minDistance)
{
distance = minDistance;
index = i;
}
}
return(EnemyPersonList[index]);
}
else if (self.personData.characterTypeEnum == CharacterTypeEnum.Enemy)
{
if (PlayerPersonList.Count <= 0)
{
return(null);
}
for (int i = 0; i < PlayerPersonList.Count; i++)
{
distance = Vector3.Distance(self.transform.position,
PlayerPersonList[i].transform.position);
if (distance < minDistance)
{
distance = minDistance;
index = i;
}
}
return(PlayerPersonList[index]);
}
return(null);
}
public async Task Send(UsersEmailSendRequest model)
{
List <PersonBase> personList = null;
DataProvider.ExecuteCmd(GetConnection, "dbo.PersonNotificationPreference_GetContactUsersPeople",
inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@AspNetUserRoleId", model.AspNetUserRoleId ?? String.Empty);
}
, map : delegate(IDataReader reader, short set)
{
switch (set)
{
case 0:
PersonBase prsn = new PersonBase();
int ord = 0;
prsn.Id = reader.GetSafeInt32(ord++);
prsn.FirstName = reader.GetSafeString(ord++);
prsn.MiddleName = reader.GetSafeString(ord++);
prsn.LastName = reader.GetSafeString(ord++);
prsn.PhoneNumber = reader.GetSafeString(ord++);
prsn.Email = reader.GetSafeString(ord++);
if (personList == null)
{
personList = new List <PersonBase>();
}
personList.Add(prsn);
break;
}
}
);
if (personList != null)
{
foreach (PersonBase prsn in personList)
{
string path = HttpContext.Current.Server.MapPath("~/HTML_Templates/ContactUsersEmail.html");
string emailBody = System.IO.File.ReadAllText(path);
string finalEmailHtml = emailBody.Replace("{{title}}", model.Title)
.Replace("{{body}}", model.Body);
await _emailService.Send(SiteConfig.SiteAdminEmailAddress, "Operation Code", prsn.FullName, prsn.Email, model.Subject, model.PlainText, finalEmailHtml);
}
}
}
private PersonBase FilledPerson()
{
var cruiseDetails = new GuestCruiseDetail { BeaconId = string.Empty, BerthNumber = string.Empty, IdentificationId = string.Empty, LoyaltyLevelTypeId = string.Empty, ReservationId = string.Empty, Stateroom = stateroom };
var personDetail = new PersonalDetail { CitizenshipCountryId = string.Empty, FirstName = string.Empty, LastName = string.Empty, MiddleName = string.Empty, Title = string.Empty, PreferredName = string.Empty, MaritalStatus = string.Empty, Nickname = string.Empty, Occupation = string.Empty, DocumentNumber = string.Empty, Suffix = string.Empty };
var person = new PersonBase
{
IsOnHold = true,
ChargeId = ChargeId,
CruiseDetail = cruiseDetails,
PersonalDetail = personDetail,
LastEvent = string.Empty,
PersonId = PersonId,
SecurityPhotoAddress = string.Empty,
Stateroom = stateroom,
PersonType = PersonType.Guest
};
return person;
}
/// <summary>
/// Function to process after update of boarding status.
/// </summary>
/// <param name="person">Instance of PersonBase</param>
/// <param name="isOnboard">Whether guest is onboard</param>
private void OnUpdatePersonBoardingStatusComplete(PersonBase person, bool isOnboard)
{
PersonsParty personsParty = DIContainer.Instance.Resolve<PersonsPartyManager>().CurrentParty;
if (personsParty != null)
{
if (!isOnboard && person.IsAdult)
{
if (personsParty.IsPartyCreated)
{
personsParty.IsAnyAdultAshore = true;
}
}
if (personsParty.Guests != null)
{
// Updates the boarding status of the authorized persons of all party.
personsParty.Guests.Iterate(g => g.PortAuthorizations.Iterate(p => p.DebarkAuthorizedPersons.Iterate(d =>
{
if (d.PersonId.Equals(person.PersonId, StringComparison.OrdinalIgnoreCase))
{
d.Person.IsOnboard = isOnboard;
}
})));
}
// Updates boarding status of the authorized persons of selected person.
personsParty.SelectedPerson.PortAuthorizations.Iterate(p => p.DebarkAuthorizedPersons.Iterate(d =>
{
if (d.PersonId.Equals(person.PersonId, StringComparison.OrdinalIgnoreCase))
{
d.Person.IsOnboard = isOnboard;
}
}));
// Updates boarding status in UI component to show in UI.
this.UpdateInUIComponent(person, isOnboard);
// Stops spin wheel.
Messenger.Instance.Notify(MessengerMessage.ShowSpinWheel, false);
}
}
/// <summary>
/// Visitors the mapper.
/// </summary>
/// <param name="visitorCollection">The visitor.</param>
/// <param name="visitor">The p.</param>
public static void VisitorMapper(VisitorCollection visitorCollection, PersonBase visitor)
{
var visitorMember = new Visitor();
if (visitor != null && visitorCollection != null)
{
visitorMember.VisitorId = visitor.PersonId;
visitorMember.PersonalDetail = visitor.PersonalDetail;
visitorMember.Photo = visitor.Photo;
visitorMember.SecurityPhotoAddress = visitor.SecurityPhotoAddress;
visitorMember.IsOnboard = visitor.IsOnboard;
visitorMember.AreAllMessagesGotAcknowledged = visitor.AreAllMessagesGotAcknowledged;
visitorMember.LastDateTime = visitor.LastDateTime;
visitorMember.LastEvent = visitor.LastEvent;
visitorMember.HasAlert = visitor.HasAlert;
visitorMember.HasMessage = visitor.HasMessage;
visitorMember.CardNumber = visitor.CardNumber;
visitorMember.AssignAlerts(visitor.Alerts);
visitorMember.AssignMessages(visitor.Messages);
visitorMember.AllowOnboardAlert = visitor.AllowOnboardAlert;
visitorCollection.Add(visitorMember);
}
}
/// <summary>
/// Creates the event.
/// </summary>
/// <param name="person">The person.</param>
/// <param name="alertId">The alert identifier.</param>
/// <param name="gangwayEventType">Type of the gangway event.</param>
/// <param name="boardingDetail">The boarding detail.</param>
/// <param name="clearAlertMessage">The clear alert message.</param>
/// <param name="photoAddress">The photo address.</param>
/// <param name="mediaItemId">The media item identifier.</param>
/// <returns>Return instance of Person Event.</returns>
public static PersonEvent MapPersonEvent(PersonBase person, string alertId, GangwayEventType gangwayEventType, BoardingDetail boardingDetail, ClearAlertMessage clearAlertMessage, string photoAddress, string mediaItemId)
{
// Fills event detail.
var eventDetail = new EventDetail();
if (person != null)
{
eventDetail.GangwayEventProcessType = person.GangwayEventProcessType.HasValue ? person.GangwayEventProcessType.Value : GangwayEventProcessType.Manual;
eventDetail.AlertCode = alertId;
var alertData = person.Alerts.FirstOrDefault(alert => alert.IsParentalAuthorizationAlert || alert.IsFolioAlert || alert.IsNotCheckedIn || alert.IsPortManningAlert);
if (string.IsNullOrEmpty(alertId) && alertData != null)
{
if (alertData != null && alertData.Message != null)
{
eventDetail.AlertDescription = alertData.Message.Description;
}
}
else if (gangwayEventType == GangwayEventType.AlertRemoved && !string.IsNullOrEmpty(alertId))
{
eventDetail.AlertDescription = person.Alerts.Where(alert => alert.AlertId.Equals(alertId)).Select(a => a.Message.Description).FirstOrDefault();
}
else if (gangwayEventType == GangwayEventType.MessageRemoved && !string.IsNullOrEmpty(alertId))
{
eventDetail.AlertDescription = person.Messages.Where(alert => alert.AlertId.Equals(alertId)).Select(a => a.Message.Description).FirstOrDefault();
}
if (person.CruiseDetail != null)
{
eventDetail.ReservationNumber = person.CruiseDetail.ReservationNumber;
}
return MapPersonEvent(person, gangwayEventType, boardingDetail, clearAlertMessage, photoAddress, mediaItemId, eventDetail);
}
return null;
}
/// <summary>
/// Function to map the Guest entity to PersonBase.
/// </summary>
/// <param name="guest">Instance of Guest</param>
/// <returns>Instance of PersonBase</returns>
public static PersonBase MapToPersonBase(this Guest guest)
{
if (guest == null)
{
throw new ArgumentNullException("guest");
}
var personBase = new PersonBase();
personBase.PersonId = guest.GuestId;
personBase.PersonType = PersonType.Guest;
personBase.SecurityPhotoAddress = guest.SecurityPhotoAddress;
personBase.Stateroom = guest.CruiseDetail != null ? guest.CruiseDetail.Stateroom : string.Empty;
personBase.PersonalDetail = guest.PersonalDetail;
personBase.CruiseDetail = guest.CruiseDetail;
personBase.Photo = guest.Photo;
personBase.IsPhotoAddedInCartForSwap = SwapPhotoManager.Instance.PhotoExistsInCart(personBase.PersonId);
personBase.AssignPhotoByteArray(guest.PhotoByteArray);
personBase.AssignPortAuthorizations(guest.PortAuthorizations);
personBase.AssignAlerts(guest.Alerts);
personBase.AssignFolios(guest.Folios);
personBase.HasAlert = guest.HasAlert;
personBase.HasMessage = guest.HasMessage;
personBase.AreAllMessagesGotAcknowledged = guest.AreAllMessagesGotAcknowledged;
personBase.IsOnboard = guest.IsOnboard;
personBase.PersonTypeId = CommonConstants.GuestTypeId;
personBase.LastDateTime = guest.LastDateTime;
personBase.LastEvent = guest.LastEvent;
personBase.IsParentalAuthorizationAlertOverridden = guest.IsParentalAuthorizationAlertOverridden;
personBase.IsBirthdayToday = guest.IsBirthdayToday;
personBase.IsAnniversaryDayToday = guest.IsAnniversaryDayToday;
personBase.IsOnboardWithoutCheckIn = guest.IsOnboardWithoutCheckIn;
personBase.IsDisabledCard = guest.IsDisabledCard;
personBase.AllowOnboardAlert = guest.AllowOnboardAlert;
personBase.AssignPersonMessages(guest.Messages);
return personBase;
}
/// <summary>
/// Function to map the Crew member entity to PersonBase.
/// </summary>
/// <param name="crewmember">Instance of Crew member</param>
/// <returns>Instance of PersonBase</returns>
public static PersonBase MapToPersonBase(this Crewmember crewmember)
{
if (crewmember == null)
{
throw new ArgumentNullException("crewmember");
}
var personBase = new PersonBase();
personBase.PersonId = crewmember.CrewmemberId;
personBase.PersonType = PersonType.Crewmember;
personBase.PersonalDetail = crewmember.PersonalDetail;
personBase.EmployeeNo = crewmember.EmployeeNo;
personBase.IsOnboard = crewmember.IsOnboard;
personBase.PersonTypeId = CommonConstants.CrewmemberTypeId;
personBase.LastDateTime = crewmember.LastDateTime;
personBase.LastEvent = crewmember.LastEvent;
personBase.IsPhotoAddedInCartForSwap = SwapPhotoManager.Instance.PhotoExistsInCart(personBase.PersonId);
personBase.SecurityPhotoAddress = crewmember.SecurityPhotoAddress;
personBase.AreAllMessagesGotAcknowledged = crewmember.AreAllMessagesGotAcknowledged;
personBase.Photo = crewmember.Photo;
personBase.AssignPhotoByteArray(crewmember.PhotoByteArray);
personBase.Stateroom = crewmember.Stateroom;
personBase.Department = crewmember.Department;
personBase.Position = crewmember.Position;
personBase.SafetyNumber = crewmember.SafetyNumber;
personBase.StateroomOccupancy = crewmember.StateroomOccupancy;
personBase.HasAlert = crewmember.HasAlert;
personBase.HasMessage = crewmember.HasMessage;
personBase.AssignAlerts(crewmember.Alerts);
personBase.AssignPersonMessages(crewmember.Messages);
personBase.BoardingInfo.OnboardDate = crewmember.BoardingInfo.OnboardDate;
personBase.BoardingInfo.AshoreDate = crewmember.BoardingInfo.AshoreDate;
personBase.AllowOnboardAlert = crewmember.AllowOnboardAlert;
personBase.PortAssignedDate = crewmember.PortAssignedDate;
return personBase;
}
private PersonBase FilledPerson()
{
var cruiseDetails = new GuestCruiseDetail { BeaconId = string.Empty, BerthNumber = string.Empty, IdentificationId = string.Empty, LoyaltyLevelTypeId = string.Empty, ReservationId = string.Empty, Stateroom = "00088" };
var personDetail = new PersonalDetail { CitizenshipCountryId = string.Empty, FirstName = string.Empty, LastName = string.Empty, MiddleName = string.Empty, Title = string.Empty, PreferredName = string.Empty, MaritalStatus = string.Empty, Nickname = string.Empty, Occupation = string.Empty, PassportNo = string.Empty, Suffix = string.Empty };
var alers = new AlertCollection();
alers.Add(new Alert { IsDenyAshore = true, IsParentalAuthorizationAlert = false, IsOverride = true, AlertType = "custom", AlertId = "1" });
alers.Add(new Alert { IsDenyAshore = true, IsParentalAuthorizationAlert = true, IsOverride = false, AlertType = "custom", AlertId = "1", Message = new Message() { Description = "demo", Subject = "abc" } });
alers.Add(new Alert { IsDenyAshore = false, IsParentalAuthorizationAlert = true, IsOverride = false, AlertType = "custom", AlertId = "2", Message = new Message() { Description = "demo", Subject = "abc" } });
var person = new PersonBase
{
IsOnboard = true,
IsOnHold = true,
ChargeId = "003",
CruiseDetail = cruiseDetails,
PersonalDetail = personDetail,
LastEvent = string.Empty,
PersonId = "001",
PersonTypeId = "3",
SecurityPhotoAddress = string.Empty,
Stateroom = "00088"
};
person.AssignAlerts(alers);
return person;
}
/// <summary>
/// Creates the person event.
/// </summary>
/// <param name="person">The person.</param>
/// <param name="gangwayEventType">Type of the gangway event.</param>
/// <param name="boardingDetail">The boarding detail.</param>
/// <param name="clearAlertMessage">The clear alert message.</param>
/// <param name="photoAddress">The photo address.</param>
/// <param name="mediaItemId">The media item identifier.</param>
/// <param name="eventDetail">The event detail.</param>
/// <returns>Return instance of Person Event.</returns>
private static PersonEvent MapPersonEvent(PersonBase person, GangwayEventType gangwayEventType, BoardingDetail boardingDetail, ClearAlertMessage clearAlertMessage, string photoAddress, string mediaItemId, EventDetail eventDetail)
{
var workstation = DIContainer.Instance.Resolve<Workstation>();
string eventTypeId = gangwayEventType.RetrieveEventTypeId();
return new PersonEvent()
{
EventTypeId = eventTypeId,
AlternateId = Guid.NewGuid().ToString(),
PersonId = person.PersonId,
PersonTypeId = person.PersonTypeId,
ShipId = workstation.Ship != null ? workstation.Ship.ShipId : null,
MachineName = workstation.MachineName,
Location = workstation.GangwayLocation != null ? workstation.GangwayLocation.Name : null,
Port = workstation.Port != null ? workstation.Port.Name : null,
AddedBy = workstation.User != null ? workstation.User.UserFullName : null,
EventDetails = eventDetail != null ? eventDetail.RetrieveXml() : null,
EventDate = workstation.CurrentDateTime,
EventDateGMT = DateTime.UtcNow,
ApplicationId = CommonConstants.ApplicationId,
VoyageId = person.CruiseDetail != null ? person.CruiseDetail.VoyageId : null,
LinkId = person.LinkId,
PersonStatusDetail = workstation.ConnectionMode == ConnectionMode.Offline ? boardingDetail : null,
PersonNotificationDetail = workstation.ConnectionMode == ConnectionMode.Offline ? clearAlertMessage : null,
PhotoAddress = photoAddress,
MediaItemId = mediaItemId,
MediaTypeId = CommonConstants.MediaItemTypeId
};
}
/// <summary>
/// Gets the stateroom category type.
/// </summary>
/// <param name="person">The p.</param>
/// <returns>stateroom category Id.</returns>
private string GetStateroomCategoryType(PersonBase person)
{
if (person.CruiseDetail != null && string.IsNullOrEmpty(person.CruiseDetail.StateroomCategoryId))
{
return person.CruiseDetail.StateroomCategoryType;
}
var stateroomCategory = this.tempStateroomCategories.FirstOrDefault(category => !string.IsNullOrEmpty(category.StateroomCategoryId) && category.StateroomCategoryId.Equals(person.CruiseDetail.StateroomCategoryId));
if (stateroomCategory != null)
{
return stateroomCategory.Category;
}
return null;
}
/// <summary>
/// Assigns the person to person base.
/// </summary>
/// <param name="person">The person.</param>
/// <param name="personType">Type of the person.</param>
private void AssignPersonToPersonBase(Person person, PersonType personType)
{
this.personBase = null;
if (personType == PersonType.Guest)
{
var guest = person.Guests.FirstOrDefault();
if (guest != null)
{
this.personBase = guest.MapToPersonBase();
}
}
else if (personType == PersonType.Crewmember)
{
var crewmember = person.Crewmembers.FirstOrDefault();
if (crewmember != null)
{
this.personBase = crewmember.MapToPersonBase();
}
}
else if (personType == PersonType.Visitor)
{
var visitor = person.Visitors.FirstOrDefault();
if (visitor != null)
{
this.personBase = visitor.MapToPersonBase();
}
}
Messenger.Instance.Notify(MessengerMessage.ShowSpinWheel, false);
if (this.personBase != null)
{
this.personBase.PersonalDetail.Country = this.allCountries.FirstOrDefault(a => a.CountryId.Equals(this.personBase.PersonalDetail.CitizenshipCountryId));
this.personBase.LoyaltyLevel = CommonMethods.RetrieveLoyaltyLevelNameById(this.tempLoyaltyLevelTypes, this.personBase.CruiseDetail);
Messenger.Instance.Notify(MessengerMessage.ShowPersonInfo, new Tuple<PersonBase, bool>(this.personBase, true));
}
}
/// <summary>
/// Uploads photo asynchronous.
/// </summary>
/// <param name="person">The person.</param>
/// <param name="photo">The byte array of photo.</param>
/// <param name="personEvent">The person event.</param>
/// <returns>
/// Upload media Items.
/// </returns>
public async Task UploadPhotosAsync(PersonBase person, byte[] photo, PersonEvent personEvent)
{
await this.photoCaptureRepository.UploadPhotosAsync(person.PersonType, photo, person.PersonId, personEvent);
}
/// <summary>
/// Initializes a new instance of the <see cref="PersonAlert" /> class.
/// </summary>
/// <param name="person">Instance of PersonBase</param>
/// <param name="isOnboardAlerts">Whether to show onboard alerts</param>
/// <param name="isSoundEnable">if set to <c>true</c> [is sound enable].</param>
/// <param name="isAlertIconClicked">if set to <c>true</c> [is alert icon clicked].</param>
public PersonAlert(PersonBase person, bool? isOnboardAlerts, bool isSoundEnable, bool isAlertIconClicked)
{
this.InitializeComponent();
this.DataContext = new PersonAlertViewModel(person, isOnboardAlerts, isSoundEnable, isAlertIconClicked);
this.RegisterEvents();
}
/// <summary>
/// Function to retrieve guests by search text.
/// </summary>
/// <param name="selectedPerson">Instance of PersonBase</param>
/// <param name="pageNumber">The page number.</param>
/// <param name="maxResults">The maximum results.</param>
/// <returns>Returns instance of Task</returns>
private async Task RetrieveGuestsBySearchText(PersonBase selectedPerson, int? pageNumber = null, int? maxResults = null)
{
await DIContainer.Instance.Resolve<SearchManager>().RetrievePersonsBySearchText(this.workstation.Ship.ShipId, selectedPerson.CruiseDetail == null ? null : selectedPerson.CruiseDetail.ReservationNumber, new List<PersonType>() { PersonType.Guest }, SearchType.Reservation, VisitorSearchType.None, selectedPerson.PersonId, this.OnSearchCompleted, false, pageNumber, maxResults, true, folioNumber: null);
}
/// <summary>
/// Function to show party detail using recent person.
/// </summary>
/// <param name="person">Instance of PersonBase</param>
private void ShowPartyDetailUsingRecentPerson(PersonBase person)
{
this.ShowPartyDetail(person);
}
/// <summary>
/// Function to assign selected person.
/// </summary>
/// <param name="personsParty">Instance of PersonsParty</param>
/// <param name="person">Instance of Person</param>
/// <param name="gangwayEventProcessType">Gangway event process type</param>
internal static void AssignSelectedPerson(PersonsParty personsParty, PersonBase person, GangwayEventProcessType? gangwayEventProcessType)
{
if (person == null)
{
return;
}
if (personsParty.SelectedPerson != null)
{
personsParty.Guests.Iterate(g => { g.IsSelected = false; g.NotifyPropertyChange("IsSelected"); });
personsParty.Crew.Iterate(c => { c.IsSelected = false; c.NotifyPropertyChange("IsSelected"); });
personsParty.Visitors.Iterate(v => { v.IsSelected = false; v.NotifyPropertyChange("IsSelected"); });
personsParty.SelectedPerson.IsSelected = false;
}
if (person.PersonType == PersonType.Guest)
{
personsParty.Guests.Where(guest => guest.GuestId.Equals(person.PersonId)).Iterate(guest => guest.IsSelected = true);
}
else if (person.PersonType == PersonType.Crewmember)
{
personsParty.Crew.Where(crew => crew.CrewmemberId.Equals(person.PersonId)).Iterate(crew => crew.IsSelected = true);
}
else if (person.PersonType == PersonType.Visitor)
{
personsParty.Visitors.Where(visitor => visitor.VisitorId.Equals(person.PersonId)).Iterate(visitor => visitor.IsSelected = true);
}
person.GangwayEventProcessType = gangwayEventProcessType.HasValue ? gangwayEventProcessType.Value : person.GangwayEventProcessType;
var selectedPerson = RetriveSelectedPersonFromParty(person, personsParty);
if (selectedPerson != null)
{
personsParty.SelectedPerson = selectedPerson;
personsParty.NotifyPropertyChange("SelectedPerson");
}
}
/// <summary>
/// Function to select person in current party.
/// </summary>
/// <param name="person">Instance of Person</param>
public static void SelectPerson(PersonBase person)
{
AssignSelectedPerson(DIContainer.Instance.Resolve<PersonsPartyManager>().CurrentParty, person, null);
}
/// <summary>
/// Function to retrieve selected person from party.
/// </summary>
/// <param name="person">Instance of PersonBase</param>
/// <param name="personsParty">Instance of PersonsParty</param>
/// <returns>Selected Person</returns>
private static PersonBase RetriveSelectedPersonFromParty(PersonBase person, PersonsParty personsParty)
{
PersonBase selectedPerson = null;
if (person.PersonType == PersonType.Guest)
{
if (personsParty.Guests != null && personsParty.Guests.Count > 0)
{
var guest = personsParty.Guests.FirstOrDefault(g => g.GuestId.Equals(person.PersonId, StringComparison.OrdinalIgnoreCase));
if (guest != null)
{
selectedPerson = guest.MapToPersonBase();
}
}
}
else if (person.PersonType == PersonType.Crewmember)
{
if (personsParty.Crew != null && personsParty.Crew.Count > 0)
{
var crewmember = personsParty.Crew.FirstOrDefault(c => c.CrewmemberId.Equals(person.PersonId, StringComparison.OrdinalIgnoreCase));
if (crewmember != null)
{
selectedPerson = crewmember.MapToPersonBase();
}
}
}
else if (person.PersonType == PersonType.Visitor)
{
if (personsParty.Visitors != null && personsParty.Visitors.Count > 0)
{
var visitor = personsParty.Visitors.FirstOrDefault(v => v.VisitorId.Equals(person.PersonId, StringComparison.OrdinalIgnoreCase));
if (visitor != null)
{
selectedPerson = visitor.MapToPersonBase();
}
}
}
return selectedPerson;
}
