// GET: Events/Unjoin/5
public ActionResult Unjoin(int?id)
{
Account account = Session["account"] as Account;
if (account == null)
{
TempData["infoMsg"] = "You must be logged in.";
return(RedirectToAction("", "Login"));
}
if (id == null)
{
throw new HttpException(400, "Bad request");
}
PersonEvent personEvent = db.PersonEvents.Where(pe => pe.eventId == id && pe.personId == account.personId).SingleOrDefault();
if (personEvent == null)
{
TempData["infoMsg"] = "You must have already joined this event.";
return(RedirectToAction(""));
}
try
{
db.PersonEvents.Remove(personEvent);
db.SaveChanges();
}
catch (Exception)
{
TempData["errMsg"] = "An unexpected error has occurred. Please try again later.";
}
return(RedirectToAction(""));
}
public Task <Person> UpdateAsync(int id, PersonStatusEnum status)
{
Person person = null;
using (var context = new EFCore_GraphQLDbContext())
{
person = context.Persons.Include(p => p.PhoneNumbers)
.SingleOrDefault(p => p.Id == id);
person.Status = status;
context.SaveChanges();
}
//add event
var personEvent = new PersonEvent()
{
Id = 2,
Name = person.Name,
Status = person.Status,
Timestamp = DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss")
};
_eventsService.AddEvent(personEvent);
return(Task.FromResult(person));
}
public async Task <IActionResult> MarkAttendanceIn(MarkAttendanceDTO dto)
{
Person person = null;
var persons = _dbContext.Persons.ToList();
foreach (var p in persons)
{
if (p.FingerprintIds.Contains(dto.FingerprintId))
{
person = p;
break;
}
}
if (person is null)
{
return(BadRequest("Person not enrolled"));
}
var attendanceEvent = await _dbContext.Events.FindAsync(dto.EventId);
var personEvent = new PersonEvent
{
Event = attendanceEvent,
Person = person,
TimeIn = dto.AttendanceTimeStamp,
TimeOut = attendanceEvent.End
};
_dbContext.PersonEvents.Add(personEvent);
await _dbContext.SaveChangesAsync();
return(Ok());
}
public async Task <bool> Add(int personId, Event newEvent)
{
if (newEvent.Place != null)
{
newEvent.PlaceId = newEvent.Place.Id;
}
newEvent.Place = null;
if (newEvent.Id == 0)
{
_eventRepository.Add(newEvent);
}
var newPersonEvent = new PersonEvent
{
PersonId = personId,
Event = newEvent
};
var person = _personRepository
.GetAll()
.Include(e => e.PersonEvents)
.FirstOrDefault(p => p.Id == personId);
person.PersonEvents.Add(newPersonEvent);
return(await _eventRepository.SaveChangesAsync());
}
public override void IntegratedTest()
{
PersonEvent personEvent = new PersonEvent();
personEvent.EventId = new Guid("B7192C75-32F5-4184-BF1C-ED85680CDC67");
personEvent.PersonId = new Guid("7F21704C-4E76-4FC2-BDD2-98BD03D86115");
_personEventService.Insert(personEvent);
}
public override void IntegratedTest()
{
PersonEvent personEvent = new PersonEvent();
personEvent.EventId = new Guid("647E941F-A03D-4AA1-9F32-CE9A1A5B883E");
personEvent.PersonId = new Guid("B82230EA-6A0C-4971-ACDD-F805F6F3F07B");
_personEventService.Insert(personEvent);
}
private void CheckPersonalNumber(PersonEvent evt)
{
if (evt == null)
{
throw new ArgumentNullException(nameof(evt));
}
if (PersonalNumber != evt.PersonalNumber)
{
throw new BadEventInStreamException("There was an event in the stream belonging to another aggregate");
}
}
/// <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);
}
}
/// <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);
}
/// <summary>
/// Maps the asynchronous.
/// </summary>
/// <param name="personEvent">The gangway history list.</param>
/// <returns>
/// Return instance of Guest.
/// </returns>
private static GangwayHistory MapAsync(PersonEvent personEvent)
{
var eventDetail = personEvent.EventDetails != null ? personEvent.EventDetails.Deserialize<EventDetail>() : null;
return new GangwayHistory
{
EventDetails = eventDetail,
PersonId = personEvent.PersonId,
PersonTypeId = personEvent.PersonTypeId,
EventDateTime = personEvent.EventDate,
PortCode = personEvent.Port,
GangwayLocation = personEvent.Location,
GangwayEventTypeId = personEvent.EventTypeId,
UserName = personEvent.AddedBy
};
}
/// <summary>
/// Uploads photo asynchronous.
/// </summary>
/// <param name="personType">The person type.</param>
/// <param name="photo">The byte array of photo.</param>
/// <param name="personId">Person Id.</param>
/// <param name="personEvent">The person event.</param>
/// <returns>
/// Upload media Items.
/// </returns>
public async Task<string> UploadPhotosAsync(PersonType personType, byte[] photo, string personId, PersonEvent personEvent)
{
string fileName = string.Format("{0}{1}", personId, CommonConstants.ImageFormat);
var mediaAddress = await this.GetBaseAddress(personType);
var uploadedUrl = await this.imageMediaClient.UploadAsync(mediaAddress, photo, fileName);
string personTypeValue = personType.RetrievePersonTypeFilterValue();
if (uploadedUrl != null)
{
await this.personsClient.UpdateImageAsync(personId, personTypeValue, uploadedUrl, JsonConvert.SerializeObject(personEvent), true);
}
else
{
return await Task.FromResult(CommonConstants.Failed);
}
return await Task.FromResult(CommonConstants.Success);
}
static void Main(string[] args)
{
var factory = new ConnectionFactory()
{
HostName = "localhost", VirtualHost = "vhost", UserName = "******", Password = "******"
};
Console.Title = "SENDER";
using (var connection = factory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
while (true)
{
var myevent = new PersonEvent {
EventAction = PersonEventAction.PersonUpdated,
EventID = 4096,
EventSource = "NO.NMBU.IT.IDM.USERWEB",
EventUniqueID = Guid.NewGuid(),
NewPerson = new Person {
FamilyName = "Diffie",
GivenName = "Whitfield",
Mobile = "909 00 808",
PersonID = 101
}
};
string message = JsonConvert.SerializeObject(myevent, Formatting.Indented);
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "IDM",
routingKey: "Person.All",
basicProperties: null,
body: body);
Console.WriteLine(" [x] Sent {0}", message);
System.Threading.Thread.Sleep(5000);
}
}
}
}
public Task <Person> CreateAsync(Person person)
{
using (var context = new EFCore_GraphQLDbContext())
{
context.Persons.Add(person);
context.SaveChanges();
}
//add event
var personEvent = new PersonEvent()
{
Id = 1,
Name = person.Name,
Status = person.Status,
Timestamp = DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss")
};
_eventsService.AddEvent(personEvent);
return(Task.FromResult(person));
}
/// <summary>
/// Creates the asynchronous.
/// </summary>
/// <param name="personEvent">The person event.</param>
/// <returns>
/// Return string value.
/// </returns>
public async Task<string> CreateAsync(PersonEvent personEvent)
{
if (personEvent != null && string.IsNullOrWhiteSpace(personEvent.AlternateId))
{
personEvent.AlternateId = Guid.NewGuid().ToString();
}
return await this.personEventClient.CreatePersonEventAsync(JsonConvert.SerializeObject(personEvent));
}
public async Task<IHttpActionResult> UNAssignCard(string visitorId, string accessCardNumber, PersonEvent personEvent, bool? isOnlineMode = null)
{
return await this.CreateAsync(async operationResult => await this.personManager.UNAssignCard(visitorId, accessCardNumber, personEvent, isOnlineMode.HasValue ? isOnlineMode.Value : true));
}
/// <summary>
/// Function to update person boarding status.
/// </summary>
/// <param name="person">Instance of PersonBase</param>
/// <param name="personStatus">Instance of BoardingDetail</param>
/// <param name="personEvent">The person event.</param>
private static void UpdatePersonBoardingStatus(PersonBase person, BoardingDetail personStatus, PersonEvent personEvent)
{
var task = Task.Run(() => GangwayRepositoryFactory.Retrieve().UpdatePersonStatusAsync(person.PersonId, person.PersonTypeId, personStatus, personEvent));
task.Wait();
}
/// <summary>
/// Assigns the card.
/// </summary>
/// <param name="visitorId">The visitor identifier.</param>
/// <param name="accessCardNumber">The access card number.</param>
/// <param name="personEvent">The person event.</param>
/// <returns>
/// Task Return nothing
/// </returns>
public async Task<string> AssignCard(string visitorId, string accessCardNumber, PersonEvent personEvent)
{
string status;
var task = await this.personsClient.AssignCard(visitorId, accessCardNumber, JsonConvert.SerializeObject(personEvent), true);
status = task != string.Empty ? JsonConvert.DeserializeObject<string>(task) : default(string);
return await Task.FromResult(status);
}
/// <summary>
/// 解析报警数据
/// </summary>
/// <param name="deviceIp">设备ip</param>
/// <param name="msg">结构数据</param>
public static void AnalysisAlarmData(string deviceIp, HYAlarmData.MsgStrut msg)
{
try
{
if (msg.XmlData == "" || msg.XmlData == "null")
{
return;
}
switch (msg.AlarmType)
{
case HYAlarmData.XmlType.AlarmEventMsg:
AlarmEvent?.Invoke(deviceIp, SuperFramework.SuperConfig.Xml.XmlSerialization.XmlDeserialize <AlarmEventMsg>(msg.XmlData));
break;
case HYAlarmData.XmlType.XMLLayoutMessage:
TrackEvent?.Invoke(deviceIp, SuperFramework.SuperConfig.Xml.XmlSerialization.XmlDeserialize <XMLLayoutMessage>(msg.XmlData));
break;
case HYAlarmData.XmlType.CountingEventMsg:
PersonEvent?.Invoke(deviceIp, SuperFramework.SuperConfig.Xml.XmlSerialization.XmlDeserialize <CountingEventMsg>(msg.XmlData));
break;
}
}
catch (Exception) { }
//string str;
//int offset = 0;
//GetObjectData(buffer);
//if (GetSync())
//{
// offset = 0;
// if (GetMsgLength() > 0)
// {
// goto Label_00B7;
// }
//}
//return ;
//Label_0095:
////offset += Sock.Receive(buffer, offset, header.GetMsgLength() - 12 - offset, SocketFlags.None);
//if (offset >= GetMsgLength() - 12)
// goto Label_00C9;
//else
// goto Label_00B7;
//Label_00B7:
//if (offset < GetMsgLength())
// goto Label_0095;
//Label_00C9:
//str = Encoding.ASCII.GetString(buffer, 0, GetMsgLength() - 12);
////return .SuperConfig.Xml.XmlSerialization.XmlDeserialize<AlarmData>(str);
//XmlDocument document = new XmlDocument();
//document.LoadXml(str);
//string localName = document.DocumentElement.LocalName;
//object[] args = new object[2];
//args[0] = str;
//args[1] = localName;
//// base.Invoke(new dlgt_RefreshGui(this.RefreshGui), args);
////}
}
/// <summary>
/// Creates the event.
/// </summary>
/// <param name="personEvent">The person event.</param>
/// <param name="boardingDetail">The boarding detail.</param>
/// <param name="clearAlertMessage">The clear alert message.</param>
/// <returns>
/// Task Containing string.
/// </returns>
public async Task<string> CreateEventAsync(PersonEvent personEvent, BoardingDetail boardingDetail, ClearAlertMessage clearAlertMessage)
{
return await this.gangwayEventRepository.CreateEventAsync(personEvent);
}
/// <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>
/// Assigns the card.
/// </summary>
/// <param name="visitorId">The visitor identifier.</param>
/// <param name="accessCardNumber">The access card number.</param>
/// <param name="personEvent">The person event.</param>
/// <param name="isOnlineMode">if set to <c>true</c> [is on line mode].</param>
/// <returns>
/// Task Return nothing
/// </returns>
public async Task<string> AssignCard(string visitorId, string accessCardNumber, PersonEvent personEvent, bool isOnlineMode)
{
if (!isOnlineMode)
{
//// Code for handle BT Sync duplicate records
var response = await this.personEventClientRepository.CreateAsync(personEvent);
var result = response != null ? JsonConvert.DeserializeObject<bool>(response) : default(bool);
if (result)
{
await this.visitorClientRepository.AssignCard(visitorId, accessCardNumber);
}
}
else
{
await this.visitorClientRepository.AssignCard(visitorId, accessCardNumber);
if (personEvent != null)
{
await this.personEventClientRepository.CreateAsync(personEvent);
}
}
return SuccessStatus;
}
async Task ParseEventData_2(ILogEnd log, MyDbContext data, Event evt, string htmlText, long eventTawId)
{
// this page is so badly coded the HTML is invalid, chrome shows it correctly though, kudos to it
// but HtmlAgilityPack just fails on it
var eventInfoText = htmlText.TakeStringBetween("<table cellpadding=\"20\" cellspacing=\"5\">", "</table>");
var eventInfoDoc = new HtmlDocument();
eventInfoDoc.LoadHtml(eventInfoText);
var eventInfo = new HtmlTwoColsStringTable(eventInfoDoc.DocumentNode);
/*
* Name GRAW Practice -- Saber Squad Thursday Night (NA-SA)
* Description GRAW Practice -- Saber Squad Thursday Night (NA-SA)
* Type Practice
* Unit Ghost Recon
* When From: 6/3/2016 04:00:00 +02:00 to: 6/3/2016 05:00:00 +02:00
* Mandatory Yes
* Cancelled No
*/
evt.Name = eventInfo["Name"];
evt.Description = eventInfo["Description"];
evt.Type = eventInfo["Type"];
evt.Mandatory = eventInfo["Mandatory"] == "Yes";
evt.Cancelled = eventInfo["Cancelled"] == "Yes";
var when = eventInfo["When"];
var strFrom = when.TakeStringBetween("from:", "to:", StringComparison.InvariantCultureIgnoreCase).Trim();
if (strFrom != null)
{
evt.From = ParseUSDateTime(strFrom);
}
var strTo = when.TakeStringAfter("to:", StringComparison.InvariantCultureIgnoreCase).Trim();
if (strTo != null)
{
evt.To = ParseUSDateTime(strTo);
}
var attendeesText = htmlText.TakeStringBetween("<table width=100%>", "</table>");
var attendessDoc = new HtmlDocument();
attendessDoc.LoadHtml(attendeesText);
var attendeesTable = new HtmlTable(attendessDoc.DocumentNode);
var newPersonEvents = new List <PersonEvent>();
var personEvents = evt.Attended.ToList();
foreach (var row in attendeesTable)
{
var name = row[0]?.InnerText?.Trim();
var nameHref = row[0]?.SelectSingleNode("a")?.GetAttributeValue("href", ""); // http://taw.net/event/66327.aspx last row, unit name has no link
if (nameHref != null && nameHref.StartsWith("/member"))
{
if (name.IsNullOrWhiteSpace())
{
// a deleted member attended event, so there is a row of event attendee with empty name
}
else
{
var person = await GetPersonFromName(data, name);
var personToEvent = personEvents.FirstOrDefault(p => p.EventId == evt.EventId && p.PersonId == person.PersonId);
if (personToEvent == null)
{
personToEvent = new PersonEvent();
personToEvent.EventId = evt.EventId;
personToEvent.PersonId = person.PersonId;
personEvents.Add(personToEvent);
newPersonEvents.Add(personToEvent);
}
var attendanceStr = row[1]?.InnerText?.Trim();
AttendanceType attendanceType = AttendanceType.Unknown;
if (attendanceStr != null && Enum.TryParse(attendanceStr.ToLowerInvariant(), true, out attendanceType))
{
personToEvent.AttendanceType = attendanceType;
}
var timestampStr = row[2]?.InnerText?.Trim();
if (!timestampStr.Contains("--"))
{
personToEvent.TimeStamp = ParseUSDateTime(timestampStr);
}
}
}
else if (nameHref != null && nameHref.StartsWith("/unit"))
{
var unitTawIdStr = nameHref.Split('/', '\\').Last().RemoveFromEnd(".aspx".Length);
var unitTawId = int.Parse(unitTawIdStr);
var unit = await GetUnit(data, unitTawId, name);
evt.Units.Add(unit);
}
else if (nameHref == null)
{
// event with no unit
}
else
{
throw new Exception("something is wrong, found unexpected data, taw event id:" + eventTawId);
}
}
newPersonEvents.ForEach(pe => data.PersonEvents.Add(pe));
}
private void Publish(PersonEvent evt)
{
_newEvents.Add(evt);
CheckPersonalNumber(evt);
Apply((dynamic)evt);
}
/// <summary>
/// Creates the event.
/// </summary>
/// <param name="personEvent">The person event.</param>
/// <returns>
/// Task Containing string.
/// </returns>
public async Task<string> CreateEventAsync(PersonEvent personEvent)
{
string status;
var task = await this.personsClient.CreateEventAsync(JsonConvert.SerializeObject(personEvent));
status = task != string.Empty ? JsonConvert.DeserializeObject<string>(task) : default(string);
return await Task.FromResult(status);
}
public async Task EnsureSeedData()
{
_context.Database.Migrate();
if (await _userManager.FindByEmailAsync("*****@*****.**") == null)
{
var user = new IdentityUser
{
UserName = "******",
Email = "*****@*****.**"
};
await _userManager.CreateAsync(user, "P@ssw0rd!");
}
if (!_context.Persons.Any())
{
var adam = new Person()
{
Name = "Adam",
Meaning = "Earthling Man, Mankind",
Start = -4026,
End = -3970,
UnknownStart = 0,
UnknownEnd = 0,
ImageUrl = "http://i.imgur.com/00n9NWT.jpg",
};
var adamBirth = new Event()
{
Name = "Birth",
Year = -4026,
Text = "#Birth"
};
var adamBirthEvent = new PersonEvent()
{
Person = adam,
Event = adamBirth
};
adam.PersonEvents.Add(adamBirthEvent);
_context.Persons.Add(adam);
_context.Events.Add(adamBirth);
var eve = new Person()
{
Name = "Eve",
Meaning = "Living One",
Start = -4000,
End = -3970,
UnknownStart = -4026,
UnknownEnd = -3965,
ImageUrl = "http://i.imgur.com/00n9NWT.jpg",
};
var eveBirth = new Event()
{
Name = "Birth",
Year = -4026,
Text = "#Birth"
};
var eveBirthEvent = new PersonEvent()
{
Person = eve,
Event = eveBirth
};
eve.PersonEvents.Add(eveBirthEvent);
_context.Persons.Add(eve);
_context.Events.Add(eveBirth);
var relationshipAdamEve = new Relationship()
{
Person = adam,
RelatedPerson = eve,
RelationshipType = RelationshipType.Spouse
};
var relationshipEveAdam = new Relationship()
{
Person = eve,
RelatedPerson = adam,
RelationshipType = RelationshipType.Spouse
};
_context.Relationships.Add(relationshipAdamEve);
_context.Relationships.Add(relationshipEveAdam);
await _context.SaveChangesAsync();
}
}
/// <summary>
/// Function to change boarding status in party.
/// </summary>
/// <param name="person">Instance of PersonBase</param>
/// <param name="personEvent">The person event.</param>
/// <param name="isOnboard">Whether guest status will be onboard or ashore</param>
/// <returns>
/// Object of Boarding Detail
/// </returns>
private async Task<BoardingDetail> ChangeBoardingStatusInParty(PersonBase person, PersonEvent personEvent, bool isOnboard)
{
BoardingDetail personStatus = this.FillBoardingDetail(person, personEvent, isOnboard);
// Updates in web service.
ObservableManager.RunObservable(() => UpdatePersonBoardingStatus(person, personStatus, personEvent), () => this.OnUpdatePersonBoardingStatusComplete(person, isOnboard));
await Task.Run(() => { });
return personStatus;
}
/// <summary>
/// Function to fill BoardingDetail.
/// </summary>
/// <param name="person">Instance of PersonBase</param>
/// <param name="personEvent">The person event.</param>
/// <param name="isOnboard">Whether guest status will be onboard or ashore</param>
/// <returns>
/// Instance of BoardingDetail
/// </returns>
private BoardingDetail FillBoardingDetail(PersonBase person, PersonEvent personEvent, bool isOnboard)
{
BoardingDetail boardingDetail = new BoardingDetail();
boardingDetail.PersonId = person.PersonId;
boardingDetail.PersonTypeId = person.PersonTypeId;
boardingDetail.StatusTypeId = CommonConstants.BoardingStatusTypeId;
boardingDetail.ShipId = this.workstation.Ship.ShipId;
boardingDetail.Status = isOnboard ? CommonConstants.OnboardStatusParameter : CommonConstants.AshoreStatusParameter;
boardingDetail.StatusChangedDate = this.workstation.CurrentDateTime;
boardingDetail.StatusChangedDateGMT = DateTime.UtcNow;
boardingDetail.UserId = this.workstation.User.UserId;
boardingDetail.PortName = this.workstation.Port.Name;
boardingDetail.GangwayLocation = this.workstation.GangwayLocation.Name;
boardingDetail.MachineName = Environment.MachineName;
boardingDetail.VoyageId = person.CruiseDetail.VoyageId;
boardingDetail.LinkId = person.LinkId;
boardingDetail.StatusChangedBy = this.workstation.User.UserId;
boardingDetail.PersonEvent = personEvent;
return boardingDetail;
}
/// <summary>
/// Assigns the status.
/// </summary>
/// <param name="visitorId">The visitor identifier.</param>
/// <param name="accessCardNumber">The access card number.</param>
/// <param name="visitorCardAssignmentTypeId">The Visitor Card Assignment Type identifier.</param>
/// <param name="personEvent">The person event.</param>
/// <returns>The Status</returns>
private async Task<string> VisitorCardAssignment(string visitorId, string accessCardNumber, int visitorCardAssignmentTypeId, PersonEvent personEvent)
{
string status = string.Empty;
string linkId = personEvent.LinkId;
VisitorAccessCard visitor = new VisitorAccessCard
{
AccessCardId = null,
AccessCardNumber = accessCardNumber,
ExpiryDate = null
};
var command = Database.GetStoredProcCommand(RetrieveAccessCardStoredProcedure)
.AddParameter(VisitorId, DbType.Int32, visitorId)
.AddParameter(AccessCardNumber, DbType.String, accessCardNumber)
.AddParameter(EventTypeId, DbType.Byte, visitorCardAssignmentTypeId)
.AddParameter(LinkId, DbType.String, linkId)
.AddParameter(VisitorAccessCardDetail, DbType.Xml, visitor.RetrieveXml());
if (visitorCardAssignmentTypeId == VisitorCardAssignedTypeId)
{
status = AssignedStatus;
}
else if (visitorCardAssignmentTypeId == VisitorCardUnAssignedTypeId)
{
status = UnAssignedStatus;
}
await this.ExecuteNonQueryAsync(command);
return await Task.FromResult(status);
}
/// <summary>
/// insert person status
/// </summary>
/// <param name="personId">The person Id.</param>
/// <param name="personTypeId">Type of the person.</param>
/// <param name="boardingDetail">boarding details for person status changes</param>
/// <param name="personEvent">The person event.</param>
/// <returns>
/// result message
/// </returns>
public async Task<string> UpdatePersonStatusAsync(string personId, string personTypeId, BoardingDetail boardingDetail, PersonEvent personEvent)
{
return await this.personServiceRepository.UpdatePersonStatusAsync(personId, personTypeId, boardingDetail);
}
/// <summary>
/// Updates the image.
/// </summary>
/// <param name="personId">The person identifier.</param>
/// <param name="personType">Type of the person.</param>
/// <param name="mediaItemAddress">The media item address.</param>
/// <param name="personEvent">The person event.</param>
/// <param name="isOnlineMode">if set to <c>true</c> [is on line mode].</param>
/// <returns>
/// Task instance.
/// </returns>
public async Task UpdateImage(string personId, string personType, string mediaItemAddress, PersonEvent personEvent, bool isOnlineMode)
{
if (!isOnlineMode)
{
// TODO : BT Sync Event handling.
var response = await this.personEventRepository.CreateAsync(personEvent);
var result = response != null ? JsonConvert.DeserializeObject<bool>(response) : default(bool);
if (result)
{
await this.UpdateImage(personId, personType, mediaItemAddress);
}
}
else
{
await this.UpdateImage(personId, personType, mediaItemAddress);
if (personEvent != null)
{
await this.personEventRepository.CreateAsync(personEvent);
}
}
}
/// <summary>
/// Clears the person alert.
/// </summary>
/// <param name="clearAlertMessage">Instance of ClearAlertMessage</param>
/// <param name="alertMessageStatusType">The alert and message status type.</param>
/// <param name="personEvent">The person event.</param>
/// <returns>
/// Task Instance.
/// </returns>
public async Task ClearPersonAlertAndMessageAsync(ClearAlertMessage clearAlertMessage, AlertMessageStatusType alertMessageStatusType, PersonEvent personEvent)
{
await this.personServiceRepository.ClearPersonAlertAndMessageAsync(clearAlertMessage, alertMessageStatusType);
}
/// <summary>
/// Creates the event type asynchronous.
/// </summary>
/// <param name="personEvent">The person event.</param>
/// <returns>
/// Task containing string.
/// </returns>
public async Task<string> CreateEventAsync(PersonEvent personEvent)
{
return await this.personEventRepository.CreateAsync(personEvent);
}
/// <summary>
/// Unassign visitor card.
/// </summary>
/// <param name="visitorId">The visitor identifier.</param>
/// <param name="accessCardNumber">The access card number.</param>
/// <param name="personEvent">The person event.</param>
/// <returns>Task Return nothing</returns>
public async Task UNAssignCard(string visitorId, string accessCardNumber, PersonEvent personEvent)
{
await this.personServiceRepository.UNAssignCard(visitorId, accessCardNumber, personEvent);
}
/// <summary>
/// UN the assign card.
/// </summary>
/// <param name="visitorId">The visitor identifier.</param>
/// <param name="accessCardNumber">The access card number.</param>
/// <param name="personEvent">The person event.</param>
/// <param name="isOnlineMode">if set to <c>true</c> [is on line mode].</param>
/// <returns>
/// Task Return nothing
/// </returns>
public async Task<string> UNAssignCard(string visitorId, string accessCardNumber, PersonEvent personEvent, bool isOnlineMode)
{
return await this.personRepository.UNAssignCard(visitorId, accessCardNumber, personEvent, isOnlineMode);
}
/// <summary>
/// Creates the event.
/// </summary>
/// <param name="personEvent">The person event.</param>
/// <param name="boardingDetail">The boarding detail.</param>
/// <param name="clearAlertMessage">The clear alert message.</param>
/// <returns>
/// Task Containing string.
/// </returns>
public async Task<string> CreateEventAsync(PersonEvent personEvent, BoardingDetail boardingDetail, ClearAlertMessage clearAlertMessage)
{
var command = this.Database.GetStoredProcCommand(InsertPersonEventDetailStoredProcedure)
.AddParameter(MediaItemIdField, DbType.Int32, Convert.ToInt32(personEvent.MediaItemId))
.AddParameter(MediaItemTypeIdField, DbType.Int32, Convert.ToInt32(personEvent.MediaTypeId))
.AddParameter(PhotoURLField, DbType.String, personEvent.PhotoAddress)
.AddParameter(() => boardingDetail != null, PersonStatusJSONField, DbType.String, JsonConvert.SerializeObject(boardingDetail))
.AddParameter(PersonEventJSONField, DbType.String, JsonConvert.SerializeObject(personEvent))
.AddParameter(() => clearAlertMessage != null, PersonNotificationJSONField, DbType.String, JsonConvert.SerializeObject(clearAlertMessage))
.AddParameter(PersonEventDetailField, DbType.Xml, personEvent.RetrieveXml())
.AddParameter(EventDetailsField, DbType.Xml, personEvent.EventDetails)
.AddParameter(LinkIdField, DbType.String, string.IsNullOrEmpty(personEvent.LinkId) ? Guid.NewGuid().ToString() : personEvent.LinkId)
.AddParameter(AlternateIdField, DbType.String, personEvent.AlternateId);
return await this.ExecuteReaderAsync(command, GangwayEventDataMapper.MapGangwayEventStatusAsync);
}
public async Task<IHttpActionResult> Post(PersonEvent personEvent)
{
return await this.CreateAsync(async operationResult => await this.personManager.CreateEventAsync(personEvent));
}
/// <summary>
/// Unassign visitor card.
/// </summary>
/// <param name="visitorId">The visitor identifier.</param>
/// <param name="accessCardNumber">The access card number.</param>
/// <param name="personEvent">The person event.</param>
/// <returns>Task Return nothing</returns>
public async Task UNAssignCard(string visitorId, string accessCardNumber, PersonEvent personEvent)
{
await this.personsClient.UNAssignCard(visitorId, accessCardNumber, JsonConvert.SerializeObject(personEvent), true);
}
public PersonEvent AddEvent(PersonEvent personEvent)
{
AllEvents.Push(personEvent);
_eventStream.OnNext(personEvent);
return(personEvent);
}
/// <summary>
/// Setups the data.
/// </summary>
private void SetupData()
{
// Repository registration
Domain.Dependencies.Register();
DataAccess.Dependencies.Register();
Workstation ws = DIContainer.Instance.Resolve<Workstation>();
ws.Port = new Port { PortId = "1" };
ws.Ship = new Ship { ShipId = "1" };
ws.GangwayLocation = new GangwayLocation { LocationId = "1" };
ws.GangwayServiceBaseAddress = "http://Localhost/";
ws.ConfigurationServiceBaseAddress = "http://Localhost/";
ws.AuthenticationServiceBaseAddress = "http://Localhost/";
ws.AuthorizationServiceBaseAddress = "http://Localhost/";
ws.User.UserFullName = "DC-Dev60";
ws.ConnectionMode = ConnectionMode.Online;
this.intCollection = new Collection<int>();
intCollection.Add(0);
var brand = new Brand { BrandId = "3", Name = "Carnival Breeze", MediaItemAddress = "http://172.26.248.122/ImagingMediaService/MediaItems/23" };
brand.AssignPortIds(intCollection);
ws.Brand = brand;
this.workStation = ws;
this.repository = new Mock<GangwayEventRepository>();
this.embarkationStatisticsRepositoryMock = new Mock<EmbarkationStatisticsRepository>();
this.personServiceRepositoryMock = new Mock<PersonServiceRepository>();
this.photoCaptureRepositoryMock = new Mock<PhotoCaptureRepository>();
this.shipTimeRepositoryMock = new Mock<ShipTimeRepository>();
this.referenceDataRepositoryMock = new Mock<ReferenceDataRepository>();
this.gangwayEventRepositoryMock = new Mock<GangwayEventRepository>();
DIContainer.Instance.RegisterType<IPersonsClient, PersonsClientTest>();
DIContainer.Instance.RegisterType<IGuestClient, GuestClientTest>();
DIContainer.Instance.RegisterInstance<GangwayEventRepository>(this.repository.Object);
////DIContainer.Instance.RegisterInstance<ReferenceDataRepository>(this.referenceDataRepositoryMock.Object);
////DIContainer.Instance.RegisterInstance<EmbarkationStatisticsRepository>(this.embarkationStatisticsRepositoryMock.Object);
////DIContainer.Instance.RegisterInstance<GangwayEventRepository>(this.gangwayEventRepositoryMock.Object);
////DIContainer.Instance.RegisterInstance<PhotoCaptureRepository>(this.photoCaptureRepositoryMock.Object);
////DIContainer.Instance.RegisterInstance<PersonServiceRepository>(this.personServiceRepositoryMock.Object);
////DIContainer.Instance.RegisterInstance<ShipTimeRepository>(this.shipTimeRepositoryMock.Object);
var boardingDetail = new BoardingDetail
{
GangwayLocation = "location",
MachineName = "GWY terminal",
PortName = "port",
ShipId = "1",
Status = "onboard",
StatusTypeId = "1",
UserId = "1"
};
var personEvent = new PersonEvent { PersonId = "123", ApplicationId = "1" };
this.repository.Setup(a => a.CreateEventAsync(personEvent)).Returns(Task.FromResult("Successful"));
}
/// <summary>
/// Unassign visitor card.
/// </summary>
/// <param name="visitorId">The visitor identifier.</param>
/// <param name="accessCardNumber">The access card number.</param>
/// <param name="personEvent"></param>
/// <returns>Task Return nothing</returns>
public async Task UNAssignCard(string visitorId, string accessCardNumber, PersonEvent personEvent)
{
await VisitorCardAssignment(visitorId, accessCardNumber, VisitorCardUnAssignedTypeId, personEvent);
}
