public Task <Result <string> > Send(UserInvitationData prefilledData, int inviterUserId)
{
return(Result.Success()
.Ensure(AllProvidedRolesExist, "All admin roles should exist")
.Bind(CreateInvitation)
.Check(SendInvitationMail));
async Task <bool> AllProvidedRolesExist()
{
var allRoles = await _context.AdministratorRoles.Select(x => x.Id).ToListAsync();
return(prefilledData.RoleIds.All(allRoles.Contains));
}
Task <Result <string> > CreateInvitation()
=> Create(prefilledData, inviterUserId);
async Task <Result> SendInvitationMail(string invitationCode)
{
var registrationInfo = prefilledData.UserRegistrationInfo;
var messagePayload = new InvitationData
{
InvitationCode = invitationCode,
UserEmailAddress = registrationInfo.Email,
UserName = $"{registrationInfo.FirstName} {registrationInfo.LastName}",
FrontendBaseUrl = _options.FrontendBaseUrl
};
return(await _notificationService.Send(messageData : messagePayload,
notificationType : NotificationTypes.AdministratorInvitation,
emails : new() { registrationInfo.Email }));
}
}
public bool AddAgentToGroupInvite(string RequestingAgentID, UUID inviteID, UUID groupID, UUID roleID, string agentID)
{
// Check whether the invitee is already a member of the group
MembershipData m = m_Database.RetrieveMember(groupID, agentID);
if (m != null)
{
return(false);
}
// Check permission to invite
if (!HasPower(RequestingAgentID, groupID, GroupPowers.Invite))
{
m_log.DebugFormat("[Groups]: ({0}) Attempt at inviting to group {1} denied because of lack of permission", RequestingAgentID, groupID);
return(false);
}
// Check whether there are pending invitations and delete them
InvitationData invite = m_Database.RetrieveInvitation(groupID, agentID);
if (invite != null)
{
m_Database.DeleteInvite(invite.InviteID);
}
invite = new InvitationData();
invite.InviteID = inviteID;
invite.PrincipalID = agentID;
invite.GroupID = groupID;
invite.RoleID = roleID;
invite.Data = new Dictionary <string, string>();
return(m_Database.StoreInvitation(invite));
}
private bool AddAgentToGroupInvite(UUID inviteID, UUID groupID, string agentID)
{
// Check whether the invitee is already a member of the group
MembershipData m = m_Database.RetrieveMember(groupID, agentID);
if (m != null)
{
return(false);
}
// Check whether there are pending invitations and delete them
InvitationData invite = m_Database.RetrieveInvitation(groupID, agentID);
if (invite != null)
{
m_Database.DeleteInvite(invite.InviteID);
}
invite = new InvitationData();
invite.InviteID = inviteID;
invite.PrincipalID = agentID;
invite.GroupID = groupID;
invite.RoleID = UUID.Zero;
invite.Data = new Dictionary <string, string>();
return(m_Database.StoreInvitation(invite));
}
public Invitation(InvitationData invitationData,
IInvitationDataSaver invitationDataSaver,
IInvitationResponseFactory responseFactory)
{
m_invitationData = invitationData;
m_invitationDataSaver = invitationDataSaver;
m_responseFactory = responseFactory;
}
public IInvitation Get(ISettings settings, Guid id)
{
using (ILifetimeScope scope = m_dependencyContainer.GetContainer().BeginLifetimeScope())
{
IInvitationDataFactory dataFactory = scope.Resolve <IInvitationDataFactory>();
InvitationData data = dataFactory.Get(new Settings(settings), id);
if (data != null)
{
IInvitationDataSaver dataSaver = scope.Resolve <IInvitationDataSaver>();
return(new Invitation(data, dataSaver, m_responseFactory));
}
else
{
return(null);
}
}
}
public GroupInviteInfo GetAgentToGroupInvite(string RequestingAgentID, UUID inviteID)
{
InvitationData data = m_Database.RetrieveInvitation(inviteID);
if (data == null)
{
return(null);
}
GroupInviteInfo inviteInfo = new GroupInviteInfo();
inviteInfo.AgentID = data.PrincipalID;
inviteInfo.GroupID = data.GroupID;
inviteInfo.InviteID = data.InviteID;
inviteInfo.RoleID = data.RoleID;
return(inviteInfo);
}
/// <summary>
///Prepara el reporte de invitación para ser visualizado
/// </summary>
/// <history>
/// [jorcanche] 16/04/2016 created
/// [jorcanche] 12/05/2016 Se cambio de frmInvitaciona RptinvitationHelper
/// </history>
public static async void RptInvitation(int guest = 0, string peID = "USER", Window window = null)
{
//Traemos la informacion del store y la almacenamos en un procedimiento
InvitationData invitationData = await BRInvitation.RptInvitationData(guest);
//Le damos memoria al reporte de Invitacion
var rptInvi = new rptInvitation();
/************************************************************************************************************
* Información Adiocional sobre el DataSource del Crystal
*************************************************************************************************************
* Para que el DataSource acepte una entidad primero se debe de converir a lista
* 1.- ObjectHelper.ObjectToList(invitationData.Invitation)
* Pero sí al convertirlo hay propiedades nulas, el DataSource no lo aceptara y marcara error; para evitar esto
* se debera convertir a DateTable para que no tenga nulos.
* 2.- TableHelper.GetDataTableFromList(ObjectHelper.ObjectToList(invitationData.Invitation))
*************************************************************************************************************/
//Le agregamos la informacion
rptInvi.SetDataSource(TableHelper.GetDataTableFromList(ObjectHelper.ObjectToList(new IM.Base.Classes.RptInvitationIM(invitationData.Invitation))));
//Cargamos los subreportes
rptInvi.Subreports["rptInvitationGuests.rpt"].SetDataSource(TableHelper.GetDataTableFromList(invitationData.InvitationGuest?.Select(c => new IM.Base.Classes.RptInvitationGuestsIM(c)).ToList() ?? new List <Classes.RptInvitationGuestsIM>()));
rptInvi.Subreports["rptInvitationDeposits.rpt"].SetDataSource(invitationData.InvitationDeposit?.Select(c => new IM.Base.Classes.RptInvitationDepositsIM(c)).ToList() ?? new List <Classes.RptInvitationDepositsIM>());
rptInvi.Subreports["rptInvitationGifts.rpt"].SetDataSource(TableHelper.GetDataTableFromList(invitationData.InvitationGift?.Select(c => new IM.Base.Classes.RptInvitationGiftsIM(c)).ToList() ?? new List <Classes.RptInvitationGiftsIM>()));
//Cambiamos el lenguaje de las etiquetas.
CrystalReportHelper.SetLanguage(rptInvi, invitationData.Invitation.gula);
//Fecha y hora
rptInvi.SetParameterValue("lblDateTime", BRHelpers.GetServerDateTime());
//Cambiado por
rptInvi.SetParameterValue("lblChangedBy", peID);
//Cargamos el Viewer
var frmViewer = new frmViewer(rptInvi)
{
Owner = window
};
frmViewer.ShowDialog();
}
public async Task <IViewComponentResult> InvokeAsync()
{
var user = await GetCurrentUser();
var userId = user.UserId;
var amountEvent = await _context.EventInvitation.Where(u => u.FkUser == userId).Where(u => u.IsAccepted == false).Include(e => e.FkEventNavigation).Include(e => e.FkEventNavigation.FkGameTypeNavigation).ToListAsync();
var amountTeam = await _context.TeamInvitation.Where(u => u.FkUser == userId).Where(u => u.IsAccepted == false).Include(t => t.FkTeamNavigation).ToListAsync();
var eventList = new List <EventDataInvitation>();
var teamList = new List <TeamDataInvitation>();
foreach (var item in amountEvent)
{
var url = "";
if (item.FkEventNavigation.FkGameTypeNavigation.IsOnline)
{
if (item.FkEventNavigation.IsTeamEvent)
{
url = "/Esports/TeamEvent?id=" + item.FkEvent.ToString();
}
else
{
url = "/Esports/ViewEvent?id=" + item.FkEvent.ToString();
}
}
else
{
url = "/Sports/ViewEvent?id=" + item.FkEvent.ToString();
}
eventList.Add(new EventDataInvitation(item.EventInvitationId, item.IsAccepted, item.FkUser, item.FkEvent, item.FkEventNavigation.Title, url));
}
foreach (var item in amountTeam)
{
teamList.Add(new TeamDataInvitation(item.TeamInvitationId, item.IsAccepted, item.FkUser, item.FkTeam, item.FkTeamNavigation.Name, "/Teams/Details?id=" + item.FkTeam.ToString()));
}
var data = new InvitationData(eventList, teamList);
//var items = await GetItemsAsync(maxPriority, isDone);
return(View(data));
}
private async Task <Result> SendInvitationMail(string invitationCode, UserInvitationData prefilledData,
UserInvitationTypes invitationType, int?inviterAgencyId)
{
string agencyName = null;
if (inviterAgencyId.HasValue)
{
var getAgencyResult = await _agencyManagementService.Get(inviterAgencyId.Value);
if (getAgencyResult.IsFailure)
{
return(Result.Failure("Could not find inviter agency"));
}
agencyName = getAgencyResult.Value.Name;
}
var messagePayload = new InvitationData
{
AgencyName = agencyName,
InvitationCode = invitationCode,
UserEmailAddress = prefilledData.UserRegistrationInfo.Email,
UserName = $"{prefilledData.UserRegistrationInfo.FirstName} {prefilledData.UserRegistrationInfo.LastName}"
};
var notificationType = invitationType switch
{
UserInvitationTypes.Agent => NotificationTypes.AgentInvitation,
UserInvitationTypes.ChildAgency => NotificationTypes.ChildAgencyInvitation,
_ => NotificationTypes.None
};
return(await _notificationService.Send(messageData : messagePayload,
notificationType : notificationType,
email : prefilledData.UserRegistrationInfo.Email));
}
/// <summary>
/// Trae la informacion de una invitación
/// </summary>
/// <param name="guestId"> Id del Huesped</param>
/// <history>
/// [jorcanche ] created 01/mayo/2016
/// </history>
public static async Task <InvitationData> RptInvitationData(int guestId)
{
var invitationData = new InvitationData();
return(await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
var resInvitation = dbContext.USP_OR_RptInvitation(guestId);
invitationData.Invitation = resInvitation.FirstOrDefault();
var resInviationGuest = resInvitation.GetNextResult <RptInvitation_Guest>();
invitationData.InvitationGuest = resInviationGuest.ToList();
var resInvitationDeposit = resInviationGuest.GetNextResult <RptInvitation_Deposit>();
invitationData.InvitationDeposit = resInvitationDeposit.ToList();
var resInvitationGift = resInvitationDeposit.GetNextResult <RptInvitation_Gift>();
invitationData.InvitationGift = resInvitationGift.ToList();
return invitationData;
}
}));
}
public bool StoreInvitation(InvitationData data)
{
return(m_Invites.Store(data));
}
public void Create(ITransactionHandler transactionHandler, InvitationData invitationData)
{
Create(transactionHandler, new DbProviderFactory(), invitationData);
}
public void Update(ITransactionHandler transactionHandler, IDbProviderFactory providerFactory, InvitationData invitationData)
{
if (invitationData.DataStateManager.GetState(invitationData) == DataStateManagerState.Updated)
{
providerFactory.EstablishTransaction(transactionHandler, invitationData);
using (IDbCommand command = transactionHandler.Connection.CreateCommand())
{
command.CommandText = "vte.USP_Invitation";
command.CommandType = CommandType.StoredProcedure;
command.Transaction = transactionHandler.Transaction.InnerTransaction;
IDataParameter timestamp = Util.CreateParameter(providerFactory, "timestamp", DbType.DateTime);
timestamp.Direction = ParameterDirection.Output;
command.Parameters.Add(timestamp);
Util.AddParameter(providerFactory, command.Parameters, "id", DbType.Guid, Util.GetParameterValue(invitationData.InvitationId));
Util.AddParameter(providerFactory, command.Parameters, "invitee", DbType.String, Util.GetParameterValue(invitationData.Invitee));
Util.AddParameter(providerFactory, command.Parameters, "title", DbType.String, Util.GetParameterValue(invitationData.Title));
Util.AddParameter(providerFactory, command.Parameters, "note", DbType.String, Util.GetParameterValue(invitationData.Note));
Util.AddParameter(providerFactory, command.Parameters, "eventDate", DbType.Date, Util.GetParameterValue(invitationData.EventDate));
Util.AddParameter(providerFactory, command.Parameters, "rsvpDue", DbType.Date, Util.GetParameterValue(invitationData.RSVPDueDate));
command.ExecuteNonQuery();
invitationData.UpdateTimestamp = (DateTime)timestamp.Value;
}
}
}
public bool StoreInvitation(InvitationData data)
{
return(false);
}
