/// <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);
}
}
// Initialize variables for each state
void ChangeStage(Stage to)
{
switch (to)
{
case Stage.FALLOUT:
lastTick = tick;
break;
case Stage.LYNCH:
victim = SelectByVote();
break;
case Stage.KILL:
cycle++;
victim = SelectRandom(killer);
break;
case Stage.END:
break;
}
mafiaRenderer.Mark(Time.time);
mafiaRenderer.ResetStep();
stage = to;
}
public static void LogBiometrics(Crewmember source, string data)
{
LogEntry(
GetTimestamp() + ENDL
+ "BIOMETRICS AI -- " + source.name.ToUpper()
+ ", " + source.firstName.ToUpper()
+ data + ENDL
);
}
/// <summary>
/// Maps the crews.
/// </summary>
/// <param name="crewmember">The crew member.</param>
/// <param name="alerts">The alerts.</param>
/// <param name="personAlerts">The person alerts.</param>
/// <param name="alertTypeList">The alert Type Master List.</param>
internal static void MapCrews(Crewmember crewmember, ListResult<DataAccess.Entities.Alert> alerts, ListResult<DataAccess.Entities.PersonAlert> personAlerts, ListResult<DataAccess.Entities.AlertType> alertTypeList)
{
var alertCollection = AlertMapper.MapCollection(alerts.Items, personAlerts.Items, crewmember.CrewmemberId, alertTypeList);
if (alertCollection != null && alertCollection.Count > 0)
{
crewmember.HasAlert = true;
crewmember.AssignAlerts(alertCollection);
}
}
/// <summary>
/// Maps the crews.
/// </summary>
/// <param name="crewmember">The crew member.</param>
/// <param name="personMessages">The messages.</param>
/// <param name="messageTypeList">The message Type Master List.</param>
internal static void MapCrews(Crewmember crewmember, ListResult<DataAccess.Entities.PersonMessage> personMessages, ListResult<DataAccess.Entities.MessageType> messageTypeList)
{
var messageCollection = MessageMapper.MapCollection(personMessages.Items, crewmember.CrewmemberId, messageTypeList);
if (messageCollection != null && messageCollection.Count > 0)
{
crewmember.HasMessage = true;
crewmember.AssignMessages(messageCollection);
}
}
/// <summary>
/// Maps the crew.
/// </summary>
/// <param name="staterooms">The staterooms.</param>
/// <param name="shipDateTime">The ship date time.</param>
/// <param name="safetyRoleList">The safety role list.</param>
/// <param name="collection">The collection.</param>
/// <param name="crew">The crew.</param>
private static void MapCrew(IEnumerable<DataAccess.Entities.Stateroom> staterooms, DateTime? shipDateTime, IEnumerable<DataAccess.Entities.SafetyRole> safetyRoleList, Collection<Crewmember> collection, DataAccess.Entities.Crewmember crew)
{
var crewmember = new Crewmember
{
CrewmemberId = crew.CrewmemberId,
CrewmemberTypeId = crew.CrewmemberTypeId,
PersonalDetail = crew.PersonalDetail,
Department = crew.DepartmentId,
SecurityPhotoAddress = crew.SecurityPhotoAddress,
EmployeeNo = crew.EmployeeNo,
BoardingInfo = new BoardingInfo { OnboardDate = crew.EmbarkDetail.OnboardDate, AshoreDate = crew.EmbarkDetail.AshoreDate }
};
if (crew.CrewmemberRoles.Any())
{
var position = crew.CrewmemberRoles.FirstOrDefault();
crewmember.Position = position != null ? position.RoleId : null;
}
var stateroom = staterooms != null ? staterooms.FirstOrDefault(a => a.StateroomId.Equals(crew.StateroomId, StringComparison.OrdinalIgnoreCase)) : null;
if (stateroom != null)
{
crewmember.Stateroom = stateroom.StateroomNumber;
crewmember.StateroomOccupancy = stateroom.Capacity.ToString(CultureInfo.CurrentCulture);
}
var safetyDuty = shipDateTime != null ? crew.SafetyDuties.FirstOrDefault(a => shipDateTime >= a.StartDate && shipDateTime <= a.EndDate) : null;
var safetyRoleId = safetyDuty != null ? safetyDuty.SafetyRoleId : null;
var safetyRole = safetyRoleId != null ? safetyRoleList.FirstOrDefault(a => a.SafetyRoleId.Equals(safetyRoleId, StringComparison.OrdinalIgnoreCase)) : null;
crewmember.SafetyNumber = safetyRole != null ? safetyRole.SafetyNumber : null;
crewmember.PersonalDetail = crewmember.PersonalDetail ?? new PersonalDetail();
var passportDetail = crew.Identifications.FirstOrDefault(a => a.DocumentTypeId.Equals(ApplicationSetting.DocumentTypeId, StringComparison.OrdinalIgnoreCase));
if (passportDetail != null)
{
crewmember.PersonalDetail.DocumentNumber = passportDetail.Number;
crewmember.PersonalDetail.DocumentTypeId = passportDetail.DocumentTypeId;
}
else
{
var identificationDetail = crew.Identifications.FirstOrDefault();
if (identificationDetail != null)
{
crewmember.PersonalDetail.DocumentNumber = identificationDetail.Number;
crewmember.PersonalDetail.DocumentTypeId = identificationDetail.DocumentTypeId;
}
}
if (crew.CrewmemberAccessCards.Count > 0)
{
crewmember.AssignCrewmemberAccessCard(crew.CrewmemberAccessCards);
}
collection.Add(crewmember);
}
public string Render(Crewmember host, Crewmember target)
{
if (message == "?" || message == "...")
{
return(message);
}
return(host.name + FormatString(message, host, target)
+ (target == null ? "" : target.name)
+ FormatString(finisher, host, target));
}
protected override void Start()
{
base.Start();
cycleOffset = Random.Range(999, 9999);
ReplaceEntities();
killer = SelectRandom();
ChangeStage(stage);
// Render
mafiaRenderer.Load();
mafiaRenderer.RenderStart(reference.entities);
}
// Lynch
public bool RenderLynch(
Crewmember victim, Crewmember killer,
Dictionary <Crewmember, Crewmember> accusations
)
{
Step(0,
"The group appears to be arguing and gesturing wildly",
"They are arguing over the likely killer"
);
string a = "";
foreach (Crewmember member in accusations.Keys)
{
a += "\n" + member.name + " points at " + accusations[member].name;
}
Step(1, a);
if (Sleep(1))
{
return(false);
}
Step(2,
"<color=red>" + victim.Title + " is iced.</color>"
);
Step(3,
"The group investigates " + victim.name + "'s body",
"They are looking for evidence."
);
if (Sleep(3))
{
return(false);
}
bool match = victim == killer;
string color = match ? "cyan" : "#fc4e4e";
Step(4,
match ?
RandomMessage("evidence")
: "No evidence to incriminate " + victim.name + " is found.",
"<color=" + color + ">" + victim.name + " "
+ (match ? "is" : "is NOT") + " the killer.</color>"
);
return(step == 5);
}
// End
public void RenderEnd(
Crewmember killer, Crewmember last, ICollection <IEntity> entities
)
{
Step(0, last.name + " reaches for the camera and breaks the connection");
if ((killer as IDestroyable).Destroy)
{
bool single = entities.Count == 1;
string s = "The killer, " + killer.name + ", is dead--only ";
int i = 0;
foreach (IEntity e in entities)
{
if (!single && i == entities.Count - 1)
{
s += " and ";
}
s += (e as Crewmember).Title;
if (!single && i < entities.Count - 2)
{
s += ", ";
}
i++;
}
s += " " + (single ? "remains" : "remain") + ".";
Step(1, s);
}
else
{
Step(1,
"Everyone is dead--only " + last.name
+ ", the killer, remains."
);
}
Step(2, "[ END TRANSCRIPT ]", log: false);
if (step == 3)
{
Render.WriteToFile(Mafia.DATAPATH, "log");
step++;
}
}
// Fill in pronouns
string FormatString(string s, Crewmember host, Crewmember target)
{
if (s.Length < 4)
{
return(s == "%ns" ? "" : s);
}
string first = s.Substring(0, 3), last = s.Substring(s.Length - 3, 3);
s = (first == "%ns" ? s.Substring(3, s.Length - 3) : " " + s)
.Replace("%p", host.pronoun)
.Replace("%tp", target == null ? "?" : target.pronoun);
return(last == "%ns" ? s.Substring(0, s.Length - 3)
: target == null ? s : s + " ");
}
/// <summary>
/// Maps the user by crew.
/// </summary>
/// <param name="crewmember">The crewmember.</param>
/// <returns>User object</returns>
public static User MapUserByCrew(Crewmember crewmember)
{
User user = null;
if (crewmember != null && crewmember.PersonalDetail != null)
{
user = new User();
user.FirstName = crewmember.PersonalDetail.FirstName;
user.LastName = crewmember.PersonalDetail.LastName;
user.MiddleName = crewmember.PersonalDetail.MiddleName;
user.PersonId = crewmember.CrewmemberId;
user.ImageAddress = crewmember.SecurityPhotoAddress;
user.DepartmentId = crewmember.DepartmentId;
}
return user;
}
/// <summary>
/// Maps the crew.
/// </summary>
/// <param name="crewmembers">The crew members.</param>
/// <returns>crew member collection.</returns>
internal static ListResult<Crewmember> MapCrew(ListResult<Entities.Crewmember> crewmembers)
{
var list = new ListResult<Crewmember>();
foreach (var crew in crewmembers.Items)
{
var crewmember = new Crewmember
{
CrewmemberId = crew.CrewmemberId,
PersonalDetail = crew.PersonalDetail
};
list.Items.Add(crewmember);
}
list.TotalResults = crewmembers.TotalResults;
return list;
}
public virtual void Perform(CharacterActionInfo info)
{
int i = Random.Range(0, observations.Length);
int j = Random.Range(0, analyses.Length);
Crewmember self = info.character as Crewmember, target = null;
foreach (IEntity e in info.targets)
{
target = e as Crewmember;
break;
}
Render.Log(
observations[i].Render(self, target),
analyses[j].Render(self, target)
);
}
Crewmember SelectByVote()
{
Dictionary <Crewmember, int> votes = new Dictionary <Crewmember, int>();
accusations = new Dictionary <Crewmember, Crewmember>();
foreach (IEntity e in reference.entities)
{
// Skip dead Entities
if ((e as IDestroyable).Destroy)
{
continue;
}
var member = e as Crewmember;
Crewmember target = member.ChooseVote();
accusations[member] = target;
if (!votes.ContainsKey(target))
{
votes[target] = 1;
}
else
{
votes[target]++;
}
}
Crewmember selected = null;
int best = -1;
foreach (var entry in votes)
{
if (entry.Value > best)
{
selected = entry.Key;
best = entry.Value;
}
}
return(selected);
}
static void Main(string[] args)
{
string keypress = null;
keypress = Console.ReadLine();
while (keypress != null)
{
var newActor = new Crewmember("Dave", "Male", "Human", 0, 100, 0, 2.ToString(), "Cooking");
newActor.Age = newActor.GenerateAge();
newActor.Name = newActor.GenerateName("Male");
newActor.Gender = newActor.GenerateGender();
Console.WriteLine("The age is " + newActor.Age);
Console.WriteLine("The name is " + newActor.Name);
Console.WriteLine("The Gender is " + newActor.Gender);
Console.WriteLine("The Rank is " + newActor.rank);
Console.WriteLine("The Position is " + newActor.position);
Console.WriteLine("The Specialty is " + newActor.speciality);
Console.ReadLine();
}
}
public bool RenderKill(
Crewmember victim, int cycle, int offset, Crewmember lastKiller
)
{
Step(0,
"[ SHIP CYCLE " + (cycle + offset) + " ]", log: false
);
if (Sleep(0))
{
return(false);
}
if (step == 1)
{
Render.IncrementCycle();
}
Step(1,
(lastKiller != null ? lastKiller.name : "The crew")
+ " " + RandomMessage("enter")
);
if (Sleep(1))
{
return(false);
}
Step(2,
"<color=red>" + victim.Title + " "
+ RandomMessage("missing") + "</color>",
cycle == 1 ? "?" : victim.name + " has been murdered."
);
return(step == 3);
}
public void RenderStart(ICollection <IEntity> entities)
{
ConsoleReader.Node root;
ConsoleReader.LoadFile(Mafia.DATAPATH + "foreword.txt", out root);
foreach (ConsoleReader.Node line in root)
{
if (line.data != "")
{
Render.Print(line.data);
}
}
string register = "CREW REGISTER";
foreach (IEntity entity in entities)
{
Crewmember c = entity as Crewmember;
register += "\n" + c.name + ", " + c.firstName + " ... {" + c.role + "}";
}
Render.Print(register);
Render.Print("[ BEGIN TRANSCRIPT ]");
}
/// <summary>
/// Setups the manager.
/// </summary>
private void SetupData()
{
var alert = new Collection<Alert> { new Alert { AlertId = "12", AlertType = "2", Message = new Message { Description = "Test", ImageAddress = "http://172.26.248.122/ImagingMediaService/MediaItems/23", Subject = "Test" } } };
this.crewmember = new Crewmember { CrewmemberId = "212", PersonalDetail = new PersonalDetail { AnniversaryDate = null, BirthCountryId = "123", Birthdate = null, CitizenshipCountryId = "212", FirstName = "AA", Gender = Gender.Male, LastName = "sa", MaritalStatus = "Married", MiddleName = string.Empty, Nickname = string.Empty, Occupation = "Doctor", PreferredName = "Nic", Suffix = "S", Title = "Mr." }, CrewmemberTypeId = "12", EmployeeNo = "221", HasAlert = true, SecurityPhotoAddress = "http://172.26.248.122/ImagingMediaService/MediaItems/23" };
this.crewmember.AssignAlerts(alert);
this.manager.Setup(data => data.GetByIdAsync("212")).Returns(Task.FromResult(this.crewmember));
}
/// <summary>
/// Maps the crew details.
/// </summary>
/// <param name="personStatus">The person status.</param>
/// <param name="departments">The departments.</param>
/// <param name="roles">The roles.</param>
/// <param name="crewmember">The crew member.</param>
private static void MapCrewDetails(ListResult<PersonStatus> personStatus, ListResult<DataAccess.Entities.Department> departments, ListResult<DataAccess.Entities.Role> roles, Crewmember crewmember)
{
var crewmemberStatus = personStatus.Items.Where(a => a.PersonId.Equals(crewmember.CrewmemberId) && a.StatusTypeId.Equals(OnboardConstant)).OrderByDescending(a => a.StatusChangedDate).FirstOrDefault();
if (crewmemberStatus != null)
{
crewmember.LastEvent = crewmemberStatus.Status;
crewmember.LastDateTime = crewmemberStatus.StatusChangedDate;
}
var department = departments.Items.FirstOrDefault(a => a.DepartmentId.Equals(crewmember.Department, StringComparison.OrdinalIgnoreCase));
crewmember.Department = department != null ? department.Name : null;
var role = roles.Items.FirstOrDefault(a => a.RoleId.Equals(crewmember.Position, StringComparison.OrdinalIgnoreCase));
crewmember.Position = role != null ? role.Name : null;
}
/// <summary>
/// Function to select crew member.
/// </summary>
/// <param name="crewmember">Instance of CrewMember</param>
private void SelectCrewmember(Crewmember crewmember)
{
if (crewmember != null && !this.IsStopSelection)
{
PersonBase personBase = crewmember.MapToPersonBase();
PersonSelectionService.SelectPerson(personBase);
if (!this.IsShowPersonInfoIconClicked)
{
this.ShowAgeVerificationPopupView();
}
}
this.IsShowPersonInfoIconClicked = false;
this.IsStopSelection = false;
}
/// <summary>
/// Views the crewmember stateroom details.
/// </summary>
/// <param name="crewmember">The crewmember.</param>
private void ViewCrewmemberStateroomDetails(Crewmember crewmember)
{
this.IsShowPersonInfoIconClicked = true;
this.SelectCrewmember(crewmember);
PersonBase personBase = crewmember.MapToPersonBase();
Messenger.Instance.Notify(MessengerMessage.ShowPersonInfo, new Tuple<PersonBase, bool>(personBase, false));
}
/// <summary>
/// Function to manipulate alert for crew member.
/// </summary>
/// <param name="crewmember">Instance of Crewmember</param>
private static void ManipulateAlertsForCrewmember(Crewmember crewmember)
{
var allowOnboardAlerts = crewmember.Alerts.FirstOrDefault(a => a.AlertType.Equals(CommonConstants.AllowOnboard, StringComparison.OrdinalIgnoreCase));
if (allowOnboardAlerts != null)
{
crewmember.AllowOnboardAlert = allowOnboardAlerts;
crewmember.Alerts.Remove(allowOnboardAlerts);
}
if (IsPortManningAlert(crewmember.PortAssignedDate))
{
crewmember.Alerts.Add(AlertService.CreateAlerts(PortManning));
}
crewmember.HasAlert = crewmember.Alerts.Count > 0;
}
/// <summary>
/// Fills the user details.
/// </summary>
/// <param name="crewmember">The crew member.</param>
private void FillUserDetails(Crewmember crewmember)
{
this.workstation.User.UserName = this.LogOn.UserName;
this.workstation.User.UserFullName = this.workstation.User.UserName.IsNumeric() ? string.Format(CultureInfo.CurrentCulture, "{0}, {1}", crewmember.PersonalDetail.LastName, crewmember.PersonalDetail.FirstName) : this.LogOn.UserName;
this.workstation.User.Age = crewmember.PersonalDetail != null ? crewmember.PersonalDetail.Age : null;
this.workstation.User.Gender = crewmember.PersonalDetail != null ? crewmember.PersonalDetail.Gender : string.Empty;
if (string.IsNullOrEmpty(crewmember.SecurityPhotoAddress))
{
this.workstation.User.UserImage = null;
}
else
{
Observable.ToAsync(async () =>
{
byte[] bytes = await crewmember.SecurityPhotoAddress.PersonImageAddressToByteArray();
this.workstation.User.UserImage = bytes.ToBitmapSource();
})().Subscribe(r => { }, ex => { });
}
Messenger.Instance.Notify(MessengerMessage.NotifySystemInfoWorkstation);
}
/// <summary>
/// Maps the crew personal detail.
/// </summary>
/// <param name="dataReader">The data reader.</param>
/// <returns>The crew member</returns>
private static async Task<CrewmemberCollection> RetrieveCrewmemberPersonalDetail(SqlDataReader dataReader)
{
var crewmembers = new CrewmemberCollection();
if (dataReader != null)
{
while (await dataReader.ReadAsync())
{
var crewmember = new Crewmember();
crewmember.CrewmemberId = dataReader.Int32Field(CrewMemberId).ToString();
crewmember.PersonalDetail = new PersonalDetail();
crewmember.PersonalDetail.Age = dataReader.Int16NullableField(Age);
crewmember.PersonalDetail.AnniversaryDate = dataReader.DateTimeNullableField(AnniversaryDate);
crewmember.PersonalDetail.BirthCountryId = dataReader.Int32NullableField(BirthCountryId).ToString();
crewmember.PersonalDetail.Birthdate = dataReader.DateTimeNullableField(BirthDate);
crewmember.PersonalDetail.CitizenshipCountryId = dataReader.Int32NullableField(CitizenshipCountryId).ToString();
crewmember.PersonalDetail.FirstName = dataReader.StringField(FirstName);
crewmember.PersonalDetail.Gender = dataReader.StringField(Gender);
crewmember.PersonalDetail.LastName = dataReader.StringField(LastName);
crewmember.PersonalDetail.MaritalStatus = dataReader.StringField(MaritalStatus);
crewmember.PersonalDetail.MiddleName = dataReader.StringField(MiddleName);
crewmember.PersonalDetail.Nickname = dataReader.StringField(NickName);
crewmember.PersonalDetail.Occupation = dataReader.StringField(Occupation);
crewmember.PersonalDetail.DocumentNumber = dataReader.StringField(DocumentNumber);
crewmember.PersonalDetail.Suffix = dataReader.StringField(Suffix);
crewmember.PersonalDetail.Title = dataReader.StringField(Title);
crewmember.PersonalDetail.PreferredName = dataReader.StringField(PreferredName);
crewmember.BoardingInfo.OnboardDate = dataReader.DateTimeNullableField(OnboardDate);
crewmember.BoardingInfo.AshoreDate = dataReader.DateTimeNullableField(AshoreDate);
crewmembers.Add(crewmember);
}
}
return crewmembers;
}
/// <summary>
/// Function to retrieve photo of Crewmember.
/// </summary>
/// <param name="crewmember">Instance of Crewmember</param>
private static void RetrieveCrewmemberPhoto(Crewmember crewmember)
{
Observable.ToAsync(() =>
{
var person = new Person();
var crewmemberCollection = new CrewmemberCollection();
crewmemberCollection.Add(crewmember);
person.AssignCrewmembers(crewmemberCollection);
DIContainer.Instance.Resolve<PhotoService>().RetrievePhotos(person);
})().Subscribe(r => { }, ex => { });
}
public async Task RetrieveUserByUserAccountIdTest()
{
var crewmember = new Crewmember
{
CrewmemberId = "1",
CrewmemberStatusId = "2",
AddedDate = DateTime.Now,
CrewmemberTypeId = "1",
DepartmentId = "2",
EmployeeNo = "3",
IsActive = true,
LastModifiedDate = DateTime.Now,
RoleId = "2",
SecurityPhotoAddress = "dd",
ShipId = "4",
SourceId = "4",
StateroomId = "d",
UserAccountId = "4",
};
crewmember.PersonalDetail = new PersonalDetail
{
Birthdate = DateTime.Now,
CitizenshipCountryId = "1",
DepartmentId = "3",
DepartmentPOC = "f",
Email = "*****@*****.**",
FirstName = "gyze",
Gender = "M",
LastName = "ddefff",
MaritalStatus = "single",
MiddleName = "fffsd",
Note = "dfe",
Occupation = "faer",
PassportNo = "344345456",
Title = "Mr",
VisitorCardId = "3"
};
this.crewRepository.Setup(mockItem => mockItem.RetrieveCrewmemberByUserAccountId(It.IsAny<string>())).Returns(Task.FromResult(crewmember));
var alert = await this.crewData.RetrieveUserByUserAccountId("1");
Assert.IsNotNull(alert);
Assert.AreEqual(alert.PersonId, crewmember.CrewmemberId);
}
/// <summary>
/// Function to place crew member onboard.
/// </summary>
/// <param name="crewmember">Instance of Crewmember</param>
private void PlaceCrewmemberOnboard(Crewmember crewmember)
{
if (!crewmember.IsOnboard)
{
ChangeCrewmemberBoardingStatus(crewmember);
}
}
private void ResetSanity(Crewmember crewmember)
{
crewmember.sanity = crewmember.maxSanity;
crewmember.potentialFearIntensity = 0;
sanityPostProcessing.weight = 0;
}
/// <summary>
///
/// </summary>
/// <param name="dataReader"></param>
/// <returns></returns>
public static async Task<Crewmember> MapUserDetails(SqlDataReader dataReader)
{
var crew = new Crewmember();
if (dataReader != null)
{
while (await dataReader.ReadAsync())
{
crew.CrewmemberId = dataReader.Int32Field(CrewMemberId).ToString();
crew.PersonalDetail = new PersonalDetail();
crew.PersonalDetail.Title = dataReader.StringField(Title);
crew.PersonalDetail.FirstName = dataReader.StringField(FirstName);
crew.PersonalDetail.MiddleName = dataReader.StringField(MiddleName);
crew.PersonalDetail.LastName = dataReader.StringField(LastName);
crew.PersonalDetail.Nickname = dataReader.StringField(NickName);
crew.PersonalDetail.PreferredName = dataReader.StringField(PreferredName);
crew.PersonalDetail.Suffix = dataReader.StringField(Suffix);
crew.PersonalDetail.Gender = dataReader.StringField(Gender);
crew.PersonalDetail.Age = dataReader.Int32Field(Age);
crew.SecurityPhotoAddress = dataReader.StringField(SecurityPhotoAddress);
byte[] bytes = await crew.SecurityPhotoAddress.ImageAddressToByteArray();
crew.Photo = bytes.ToBitmapSource();
crew.AssignPhotoByteArray(new Collection<byte>(bytes));
}
}
return crew;
}
/// <summary>
/// Maps the crew.
/// </summary>
/// <param name="dataReader">The data reader.</param>
/// <returns>Crew member collection</returns>
private static async Task<CrewmemberCollection> MapCrew(SqlDataReader dataReader)
{
var crewmemberCollection = new CrewmemberCollection();
if (dataReader != null)
{
while (await dataReader.ReadAsync())
{
var crew = new Crewmember();
crew.CrewmemberId = dataReader.Int32Field(CrewMemberId).ToString();
crew.CrewmemberTypeId = dataReader.ByteField(CrewMemberTypeId).ToString();
crew.EmployeeNo = dataReader.StringField(EmployeeNo);
var hasAlert = dataReader.BooleanNullableField(HasAlert);
var hasMessage = dataReader.BooleanNullableField(HasMessage);
crew.HasAlert = hasAlert.HasValue ? hasAlert.Value : false;
crew.HasMessage = hasMessage.HasValue ? hasMessage.Value : false;
crew.Position = dataReader.StringField(Position);
crew.LastDateTime = dataReader.DateTimeNullableField(LastDateTime);
crew.LastEvent = dataReader.StringField(LastEvent);
crew.SafetyNumber = dataReader.StringField(SafetyNumber);
crew.SecurityPhotoAddress = dataReader.StringField(SecurityPhotoAddress);
crew.Stateroom = dataReader.StringField(Stateroom);
crew.StateroomOccupancy = dataReader.ByteField(StateroomOccupancy).ToString();
crew.Department = dataReader.StringField(Department);
crew.PortAssignedDate = dataReader.DateTimeNullableField(PortAssignedDate);
byte[] bytes = await crew.SecurityPhotoAddress.ImageAddressToByteArray();
crew.Photo = bytes.ToBitmapSource();
crew.AssignPhotoByteArray(new Collection<byte>(bytes));
crewmemberCollection.Add(crew);
}
}
return crewmemberCollection;
}
/// <summary>
/// Changes the selected crew member.
/// </summary>
/// <param name="crewmember">The crew member.</param>
private static void ChangeCrewmemberBoardingStatus(Crewmember crewmember)
{
if (crewmember != null)
{
PersonBase personBase = crewmember.MapToPersonBase();
PersonSelectionService.SelectPerson(personBase);
Messenger.Instance.Notify(MessengerMessage.ChangePersonBoardingStatus, personBase);
}
}
/// <summary>
/// Updates the image.
/// </summary>
/// <param name="crewmemberId">The crew member identifier.</param>
/// <param name="crew">The crew.</param>
/// <returns>Task instance.</returns>
public async Task UpdateImage(string crewmemberId, Crewmember crew)
{
await this.crewServiceClient.UpdateCrewmemberAsync(crewmemberId: crewmemberId, crewmember: JsonConvert.SerializeObject(crew));
}
/// <summary>
/// Shows the crew message.
/// </summary>
/// <param name="crew">The crew.</param>
private void ShowCrewMessage(Crewmember crew)
{
PersonBase personBase = crew.MapToPersonBase();
PersonSelectionService.SelectPerson(personBase);
this.ShowMessagePopUp(personBase);
}
/// <summary>
/// Maps the crew member data.
/// </summary>
/// <param name="crewMember">The crew member.</param>
/// <param name="persons">The persons.</param>
/// <param name="eventType">Type of the event.</param>
private static void MapCrewMemberData(Crewmember crewMember, Person persons, NotificationEventType eventType)
{
var selectedPerson = RetrieveSelectedPerson();
Crewmember retrievedcrewMember = persons.Crewmembers.FirstOrDefault();
if (crewMember != null)
{
if (eventType == NotificationEventType.PersonData)
{
crewMember.PersonalDetail.FirstName = retrievedcrewMember.PersonalDetail.FirstName;
crewMember.PersonalDetail.LastName = retrievedcrewMember.PersonalDetail.LastName;
crewMember.PersonalDetail.Gender = retrievedcrewMember.PersonalDetail.Gender;
crewMember.PersonalDetail.Age = retrievedcrewMember.PersonalDetail.Age;
crewMember.PersonalDetail.Birthdate = retrievedcrewMember.PersonalDetail.Birthdate;
crewMember.SecurityPhotoAddress = retrievedcrewMember.SecurityPhotoAddress;
crewMember.Stateroom = retrievedcrewMember.Stateroom;
crewMember.PersonalDetail.Country = RetriveCountry(retrievedcrewMember.PersonalDetail);
if (crewMember.PersonalDetail.Country != null)
{
crewMember.PersonalDetail.Country.Name = retrievedcrewMember.PersonalDetail.Country.Name;
}
crewMember.Department = retrievedcrewMember.Department;
crewMember.Position = retrievedcrewMember.Position;
crewMember.PersonalDetail.DocumentNumber = retrievedcrewMember.PersonalDetail.DocumentNumber;
crewMember.BoardingInfo.OnboardDate = retrievedcrewMember.BoardingInfo.OnboardDate;
crewMember.BoardingInfo.AshoreDate = retrievedcrewMember.BoardingInfo.AshoreDate;
}
else if (eventType == NotificationEventType.BoardingStatus)
{
crewMember.IsOnboard = retrievedcrewMember.IsOnboard;
crewMember.LastEvent = retrievedcrewMember.LastEvent;
crewMember.LastDateTime = retrievedcrewMember.LastDateTime;
if (crewMember.CrewmemberId.Equals(selectedPerson.PersonId, StringComparison.OrdinalIgnoreCase))
{
selectedPerson.IsOnboard = retrievedcrewMember.IsOnboard;
selectedPerson.LastEvent = retrievedcrewMember.LastEvent;
selectedPerson.LastDateTime = retrievedcrewMember.LastDateTime;
}
}
else if (eventType == NotificationEventType.Alert)
{
crewMember.HasAlert = retrievedcrewMember.HasAlert;
crewMember.AssignAlerts(retrievedcrewMember.Alerts);
selectedPerson.HasAlert = retrievedcrewMember.HasAlert;
selectedPerson.AssignAlerts(retrievedcrewMember.Alerts);
Messenger.Instance.Notify(MessengerMessage.NotifyPersonAlert, selectedPerson);
Messenger.Instance.Notify(MessengerMessage.NotifyAlertDetails, selectedPerson);
}
else if (eventType == NotificationEventType.Message)
{
var messageAcknowledge = retrievedcrewMember.Messages.All(m => m.StatusId.Equals(CommonConstants.MessageAcknowledgeStatusId));
crewMember.AreAllMessagesGotAcknowledged = messageAcknowledge;
crewMember.AssignMessages(retrievedcrewMember.Messages);
selectedPerson.AreAllMessagesGotAcknowledged = messageAcknowledge;
selectedPerson.AssignPersonMessages(retrievedcrewMember.Messages);
Messenger.Instance.Notify(MessengerMessage.NotifyPersonMessage, selectedPerson);
Messenger.Instance.Notify(MessengerMessage.NotifyMessageDetails, selectedPerson);
}
}
}
/// <summary>
/// Setups the data.
/// </summary>
private void SetupData()
{
var alert = new Collection<Alert> { new Alert { AlertId = "12", AlertType = "2", Message = new Message { Description = "Test", ImageAddress = "http://172.26.248.122/ImagingMediaService/MediaItems/23", Subject = "Test" } } };
var department = new DataAccess.Entities.Department { Name = "Development", DepartmentId = "1" };
this.crewmember = new Crewmember { CrewmemberId = "1", Position = "1", Department = "1", PersonalDetail = new PersonalDetail { AnniversaryDate = null, BirthCountryId = "123", Birthdate = null, CitizenshipCountryId = "212", FirstName = "AA", Gender = Gender.Male, LastName = "sa", MaritalStatus = "Married", MiddleName = string.Empty, Nickname = string.Empty, Occupation = "Doctor", PreferredName = "Nic", Suffix = "S", Title = "Mr." }, CrewmemberTypeId = "12", EmployeeNo = "221", HasAlert = true, SecurityPhotoAddress = "http://172.26.248.122/ImagingMediaService/MediaItems/23" };
var departmentList = new ListResult<DataAccess.Entities.Department>();
departmentList.Items.Add(department);
this.crewmember.AssignAlerts(alert);
var role = new DataAccess.Entities.Role { RoleId = "1", Name = "SE" };
var roleList = new ListResult<DataAccess.Entities.Role>();
roleList.Items.Add(role);
this.crewMemberRepository.Setup(data => data.GetDepartmentListAsync("1")).Returns(Task.FromResult(departmentList));
this.crewMemberRepository.Setup(data => data.GetRoleListAsync("1")).Returns(Task.FromResult(roleList));
this.crewMemberRepository.Setup(data => data.GetByIdAsync("1")).Returns(Task.FromResult(this.crewmember));
}
