private string InviteAttendees(IStepInput input)
{
var inviteAttendees = (InviteAttendeesInput)input;
if (!this.Data.ContainsKey("invite_unique_id"))
{
return("<response>The invite with id " + inviteAttendees.InviteId + " doesnt exists, please create the invite first</response>");
}
if (!IsCallRepeated(inviteAttendees))
{
EnsureCallIsNotRepeated(inviteAttendees);
}
else
{
return("<response>Contacts notified already</response>");
}
var invite = InviteInput.FromDict(this.Data);
foreach (var contact in inviteAttendees.Attendees)
{
InviteAttendee(invite, contact);
}
return("<response>Contacts notified succesfully</response>");
}
public string CreateInvite(InviteInput input)
{
if (input == null)
{
this.InternalServerError();
}
Trace.WriteLine("New invite is posted: " + input.InviteId);
var previous_invite = DataSerializer.DeserializeData(
WorkflowEngine.GetDataKey("multi_invite", input.InviteId)
);
if (previous_invite != null)
{
return("This invitation has been already sent");
}
var workflowContext = new WorkflowContext()
{
WorkflowStep = "create",
DataKey = input.InviteId,
WorkflowType = "multi_invite",
WorkflowId = input.InviteId,
Parameters = input,
};
return(WorkflowEngine.Process(workflowContext));
}
private string InviteCallReply(IStepInput input)
{
if (Data["invite_unique_id"] != null)
{
var invite = InviteInput.FromDict(this.Data);
var contact = Contact.FromDict(this.Data);
var message = "Hello {0}, You have been invited to {1} on {2}. Please press 1 if you want to come, 2 if not.";
message = string.Format(
message,
contact.Name,
invite.Title,
invite.Start.ToString()
);
XmlWriter.EnterNumber(
message,
new Dictionary <string, string>()
{
{ "step", "callreply" },
{ "type", "invite" }
}
);
}
else
{
XmlWriter.SayMessage("You have not been invited to this event, hang up");
}
return(XmlWriter.ToString());
}
private string CancelInvite(IStepInput input)
{
var CancelAttendees = (InviteAttendeesInput)input;
var invite = InviteInput.FromDict(this.Data);
if (!IsCallRepeated(invite))
{
EnsureCallIsNotRepeated(invite);
}
else
{
return("<response>Invite cancelled already</response>");
}
//This is how we ensure we dont contact the same people over the same message again
//Think duplicate calls to the API
if (DataSerializer.DeserializeData(WorkflowEngine.GetDataKey("multi_invite", CancelAttendees.UniqueCallId)) != null)
{
return("<response>Contacts have been notified already</response>");
}
else
{
DataSerializer.SerializeData(WorkflowEngine.GetDataKey("multi_invite", CancelAttendees.UniqueCallId), new DataStorage());
}
foreach (var contact in CancelAttendees.Attendees)
{
CancelAttendee(invite, contact);
}
return("<response>Event cancelled succesfully</response>");
}
private string InviteEmailReply(IStepInput input)
{
if (Data["invite_unique_id"] != null)
{
var invite = InviteInput.FromDict(this.Data);
var contact = Contact.FromDict(this.Data);
Bus.Send(new CreateEmailMessage()
{
Id = Guid.NewGuid().ToString(),
Address = contact.Email,
Sender = "*****@*****.**",
Subject = "Thanks for your Reply",
BodyTemplate = invite.ResponseEmailTemplate
});
Bus.Send(GetApiCall("email", "yes"));
if (invite.ResponseEmailTemplate != null && !string.IsNullOrEmpty(invite.ResponseEmailTemplate.RedirectUrl))
{
var templateManager = new MemoryTemplateManager();
return(templateManager.Fill(invite.ResponseEmailTemplate.RedirectUrl, this.Data));
}
else
{
return("<Response>Thank you for your response</Response>");
}
}
else
{
return("<Response>You havent been invited</Response>");
}
}
public Dictionary <string, string> GetTemplateContextData(InviteInput invite, Contact contact)
{
var template_data = invite.ToDict().Merge(contact.ToDict());
template_data["ACKNOWLEDGE_LINK"] = TwillioConfig.EmailCallbackUrl + "?email=" + contact.Email +
"&type=invite&step=emailin&contactId=" + contact.ContactId;
template_data["fullname"] = (string.IsNullOrEmpty(contact.Name)) ? " there" : contact.Name;
return(template_data);
}
private void CancelAttendeeSms(InviteInput invite, Contact contact)
{
if (string.IsNullOrEmpty(contact.Phone))
{
return;
}
Bus.Send(new CreateSmsMessage()
{
PhoneNumber = contact.Phone,
Message = string.Format("The event {0} on {1}, have been cancelled by the host", invite.Title, invite.Start.ToString()),
Id = Guid.NewGuid().ToString()
});
}
public async Task <ActionResult <ChatRoomViewModel> > Invite([FromBody] InviteInput input)
{
ChatRoomDto room = await this.chatService.InviteToRoomAsync(input.UserId, input.ChatRoomId);
if (room == null)
{
return(BadRequest());
}
ChatRoomViewModel model = mapper.Map <ChatRoomDto, ChatRoomViewModel>(room);
return(model);
}
public async Task <IActionResult> Post([FromBody] InviteInput inviteInput)
{
try
{
var invite = await _inviteAppService
.InsertAsync(inviteInput)
.ConfigureAwait(false);
return(Created("", invite));
}
catch (ArgumentException arg)
{
return(BadRequest(arg.Message));
}
}
private void CancelAttendee(InviteInput invite, Contact contact)
{
var workflowData = new DataStorage(invite.ToDict().Merge(contact.ToDict()));
CancelAttendeeEmail(invite, contact);
DataSerializer.SerializeData(WorkflowEngine.GetDataKey("invite", contact.Email), workflowData);
if (!string.IsNullOrEmpty(contact.Phone))
{
contact.Phone = contact.Phone.NormalizePhone();
CancelAttendeeSms(invite, contact);
CancelAttendeePhone(invite, contact);
DataSerializer.SerializeData(WorkflowEngine.GetDataKey("invite", contact.Phone), workflowData);
}
}
private void CancelAttendeePhone(InviteInput invite, Contact contact)
{
if (string.IsNullOrEmpty(contact.Phone))
{
return;
}
Bus.Send(new CreateCallMessage()
{
PhoneNumber = contact.Phone,
Id = Guid.NewGuid().ToString(),
Parameters = new Dictionary <string, string>()
{
{ "step", "cancel" },
{ "type", "invite" },
}
});
}
public void ShareToSocialNetworks(InviteInput invite)
{
if (invite.SharingOptions == null)
{
return;
}
var reducedInvite = Mapper.Map <InviteInput, ReducedInviteInput>(invite);
if (!string.IsNullOrEmpty(invite.SharingOptions.FacebookAccessToken))
{
Trace.WriteLine("Sharing to Facebook");
Bus.Send(new FacebookEventMessage()
{
Invite = reducedInvite,
AccessToken = invite.SharingOptions.FacebookAccessToken
});
}
}
private void CancelAttendeeEmail(InviteInput invite, Contact contact)
{
if (string.IsNullOrEmpty(contact.Email))
{
return;
}
var templateManager = new MemoryTemplateManager();
var bodyData = GetTemplateContextData(invite, contact);
Bus.Send(new CreateEmailMessage()
{
Id = Guid.NewGuid().ToString(),
Address = contact.Email,
Sender = "*****@*****.**",
Subject = templateManager.Fill(invite.CancelEmailTemplate.Subject, bodyData),
BodyTemplate = invite.CancelEmailTemplate,
BodyData = bodyData,
});
}
private void InviteAttendeeSms(InviteInput invite, Contact contact)
{
if (string.IsNullOrEmpty(contact.Phone))
{
return;
}
var date = invite.Start.ToString();
if (invite.End != null)
{
date += "to " + invite.End.ToString();
}
Bus.Send(new CreateSmsMessage()
{
PhoneNumber = contact.Phone,
Message = string.Format("You are hereby invited to {0} event on {1}, want to go? YES/NO", invite.Title, date),
Id = Guid.NewGuid().ToString()
});
}
public async Task <IActionResult> TeamUploadAsync([FromForm] TeamFile file)
{
// JSON file => string
var stringBuilder = new StringBuilder();
using (var reader = new StreamReader(file.File.OpenReadStream()))
{
while (reader.Peek() >= 0)
{
stringBuilder.AppendLine(await reader.ReadLineAsync());
}
}
string JSONString = stringBuilder.ToString();
// Set file content to Team Object
JObject jObjectTeam = JObject.Parse(JSONString);
Team team = jObjectTeam.ToObject <Team>();
long idTournamnet = file.IdTournament;
return(DbOperation(conn =>
{
CheckAuthLevel(UserLevel.OrgAdmin);
if (team == null)
{
throw new NoDataException();
}
long idTeam = team.Id;
// var existTeamQuery = conn.Query($"SELECT * FROM teams WHERE id = {team.Id} OR name = '{team.Name}' OR keyname = '{team.KeyName}';");
// 🔎 External Org team can overrrite team.id values so will make query more restrictive
var existTeamQuery = conn.Query($"SELECT * FROM teams WHERE id = {team.Id} AND name = '{team.Name}' AND keyname = '{team.KeyName}';");
bool teamExitst = existTeamQuery.Count() > 0;
if (!teamExitst)
{
// Add team and add Team to Tournament
Audit.Information(this, "{0}: Teams.CreateInTournament {idTournament} -> {Name}", GetUserId(), team.Name, idTournamnet);
var teamId = conn.Insert(team);
idTeam = teamId;
conn.Insert(new TournamentTeam {
IdTournament = idTournamnet, IdTeam = teamId
});
}
else
{
var existsTeamInTournamentQuery = conn.Query($"SELECT * FROM tournamentteams WHERE idtournament = {idTournamnet} AND idteam = '{idTeam}';");
bool existsTeamInTournament = existsTeamInTournamentQuery.Count() > 0;
if (!existsTeamInTournament)
{
// Add team just into tournamnet
Audit.Information(this, "{0}: Teams.AddToTournament {idTournament} -> {idTeam}", GetUserId(), idTournamnet, idTeam);
conn.Insert(new TournamentTeam {
IdTournament = idTournamnet, IdTeam = idTeam
});
// TODO: Notify team admin (if any) her team has been added to the competition.
}
if (existsTeamInTournament)
{
return new Exception("Error.Team_already_exitsts_in_tournament");
}
}
// 🚧🚧🚧 Add players to team
foreach (var player in team.Players)
{
if (player == null || player.UserData == null || player.TeamData == null)
{
throw new Exception("Malformed request");
}
Audit.Information(this, "{0}: Players.CreatePlayer {Name} {Surname}", GetUserId(), player.Name, player.Surname);
// User email should exists
bool userExists = PlayersController.CheckUserExistsInGlobalDirectory(Request, player.UserData.Id, player.UserData.Email);
if (!userExists)
{
throw new Exception($"{player.UserData.Email} does not exists in the global directory.");
}
var invite = new InviteInput {
IdPlayer = player.Id, IdTeam = idTeam, InviteText = "Hi, we want to invite you to join our team."
}; // 🚧 Lang
DbTransaction((c, t) =>
{
Audit.Information(this, "{0}: Players.Invite1: {IdTeam} {IdPlayer}", GetUserId(), invite.IdTeam, invite.IdPlayer);
if (!IsOrganizationAdmin() && !IsTeamAdmin(invite.IdTeam, c))
{
throw new UnauthorizedAccessException();
}
// Validate player is not already on the team.
var existingPlayer = c.ExecuteScalar <int>("SELECT COUNT(*) FROM teamplayers WHERE idteam = @idTeam AND idplayer = @idPlayer", invite, t);
if (existingPlayer > 0)
{
throw new Exception("Error.PlayerAlreadyInTeam");
}
invite.InviteText = mSanitizer.Sanitize(invite.InviteText);
var userOrg = c.QueryFirstOrDefault <User>($"SELECT * FROM users WHERE id = {player.IdUser}");
var notifData = new PlayerNotificationData {
};
if (userOrg == null)
{
// Insert player
var newPlayer = PlayersController.InsertPlayer(c, t, player, player.IdUser, GetUserId(), false, null, UserEventType.PlayerImported);
invite.IdPlayer = newPlayer.Id;
// Importing player that not exists in current org users
notifData = GetPlayerNotification(c, GetUserId(), invite.IdPlayer, invite.IdTeam, false, player.IdUser);
}
else
{
// Get current org player id becouse import Id can overlap
var playerOrg = c.QueryFirstOrDefault <Player>($"SELECT * FROM players WHERE iduser = {userOrg.Id}");
if (playerOrg == null)
{
throw new Exception("Error.PlayerNotFound"); // Player should exist
}
invite.IdPlayer = playerOrg.Id;
notifData = GetPlayerNotification(c, GetUserId(), invite.IdPlayer, invite.IdTeam);
}
// Create the teamplayers record
var tp = new TeamPlayer
{
IdPlayer = invite.IdPlayer,
IdTeam = invite.IdTeam,
IsTeamAdmin = false,
Status = 1
};
c.Insert(tp, t);
// UserEvent
c.Insert(new UserEvent
{
IdCreator = GetUserId(),
IdUser = notifData.To.Id,
Type = (int)UserEventType.PlayerInvitedToTeam,
TimeStamp = DateTime.Now,
Description = notifData.Team.Name
}, t);
notifData.InviteMessage = invite.InviteText;
Audit.Information(this, "{0}: Players.Invite2: {1} {2}", GetUserId(), notifData.Team.Name, notifData.To.Name);
mNotifications.NotifyEmail(Request, c, t, TemplateKeys.EmailPlayerInviteHtml, notifData);
return true;
});
}
return true;
}));
}
