public bool UserHasManResTicketPermission(Domain.Enums.MessageUserType UserType)
{
return(UserType == MessageUserType.Manager ||
UserType == MessageUserType.Resolver ||
UserType == MessageUserType.CategoryManager ||
UserType == MessageUserType.CategoryResolver);
}
//TODO: notification - V - test
public void ChangeStatus(Int64 TicketId, Domain.Enums.TicketStatus Status, Domain.Enums.MessageUserType UserType)
{
if (!CheckSessionAccess())
{
return;
}
Int64 messageId = 0;
Boolean Changed = service.TicketStatusModify(TicketId, Status, View.GetChangeStatusMessage(Status), true, UserType, ref messageId);
//Begin Action
if (Changed)
{
Int64 userId = service.UserGetIdfromPerson(UserContext.CurrentUserID);
List <KeyValuePair <int, String> > Objects = new List <KeyValuePair <int, string> >();
Objects.Add(ModuleTicket.KVPgetUser(userId));
Objects.Add(ModuleTicket.KVPgetTicket(TicketId));
View.SendUserActions(
service.ModuleID,
ModuleTicket.ActionType.TicketStatusChanged,
View.ViewCommunityId,
ModuleTicket.InteractionType.UserWithLearningObject,
Objects);
//End Action
//TODO: Notification - TEST
if (messageId > 0)
{
SendNotification(messageId, userId, ModuleTicket.NotificationActionType.StatusChanged);
}
}
}
//private bool MessageDraftUpdate(
// String HtmlMessage,
// String Preview,
// Int64 TicketId,
// Int64 MessageId,
// Int64 UserId)
//{
// Message msg = Manager.Get<Message>(MessageId);
// TicketUser usr = Manager.Get<TicketUser>(UserId);
// if (
// usr != null ||
// msg == null ||
// msg.Ticket == null ||
// msg.Ticket.Id != TicketId ||
// msg.Creator == null ||
// msg.Creator.Id != usr.Id ||
// !msg.IsDraft ||
// msg.Deleted != BaseStatusDeleted.None)
// return false;
// msg.UpdateMetaInfo(CurrentPerson, UC.IpAddress, UC.ProxyIpAddress);
// msg.Text = HtmlMessage;
// msg.Preview = Preview;
// Manager.SaveOrUpdate<Message>(msg);
// return true;
//}
/// <summary>
/// Dato un Ticket e l'utente recupera il relativo messaggio DRAFT.
/// Nel caso non esista, viene creato.
/// </summary>
/// <param name="TicketId"></param>
/// <param name="UserId"></param>
/// <returns></returns>
private Message MessageDraftGet(
Ticket Ticket, TicketUser User,
Domain.Enums.MessageUserType UserType = Domain.Enums.MessageUserType.Partecipant,
Domain.Enums.MessageType MessageType = Domain.Enums.MessageType.FeedBack
)
{
//if(!Manager.IsInTransaction())
//{
// Manager.BeginTransaction();
//}
Message msg = Manager.GetAll <Message>(m =>
m.IsDraft == true && m.Deleted == BaseStatusDeleted.None &&
m.Creator != null && m.Creator.Id == User.Id &&
m.Ticket != null && m.Ticket.Id == Ticket.Id).FirstOrDefault();
if (msg == null)
{
//if (!Manager.IsInTransaction())
// Manager.BeginTransaction();
msg = new Message();
msg.CreateMetaInfo(CurrentPerson, UC.IpAddress, UC.ProxyIpAddress);
msg.Creator = User;
msg.Action = Domain.Enums.MessageActionType.normal;
msg.Attachments = new List <TicketFile>();
msg.DisplayName = User.DisplayName;
msg.IsDraft = true;
msg.Preview = "";
msg.ShowRealName = true;
msg.Type = MessageType;
msg.UserType = UserType;
msg.Visibility = true;
msg.Ticket = Ticket;
msg.ToStatus = Ticket.Status;
msg.ToCondition = Ticket.Condition;
msg.ToCategory = (from Assignment ass in Ticket.Assignemts
where ass.AssignedCategory != null
orderby ass.CreatedOn
select ass.AssignedCategory).LastOrDefault()
?? Ticket.CreationCategory;
Manager.SaveOrUpdate <Message>(msg);
}
else
{
Manager.Refresh <Message>(msg);
}
//Manager.Flush();
return(msg);
}
/// <summary>
/// Modifica visibilità messaggio
/// </summary>
/// <param name="TicketId">Id Ticket</param>
/// <param name="MessageId">Id Messaggio</param>
/// <param name="Isvisibile">Visibilità</param>
/// <param name="UserType">Tipo utente</param>
/// <returns>TRUE se la modifica è avvenuta</returns>
public Boolean MessageChangeVisibility(
Int64 TicketId,
Int64 MessageId,
Boolean Isvisibile,
Domain.Enums.MessageUserType UserType)
{
if (UserType == Domain.Enums.MessageUserType.none || UserType == Domain.Enums.MessageUserType.Partecipant ||
CurrentPerson.TypeID == (int)UserTypeStandard.Guest ||
CurrentPerson.TypeID == (int)UserTypeStandard.ExternalUser)
{
return(false);
}
Message msg = Manager.Get <Message>(MessageId);
if (msg.UserType == Domain.Enums.MessageUserType.Partecipant)
{
return(false);
}
if (msg.Ticket == null || msg.Ticket.Id != TicketId || msg.Visibility == Isvisibile)
{
return(false);
}
msg.Visibility = Isvisibile;
msg.UpdateMetaInfo(CurrentPerson, UC.IpAddress, UC.ProxyIpAddress);
if (msg.Attachments != null && msg.Attachments.Any())
{
foreach (TicketFile file in msg.Attachments)
{
if (Isvisibile && file.Visibility == Domain.Enums.FileVisibility.hiddenMessage)
{
file.Visibility = Domain.Enums.FileVisibility.visible;
}
else if (!Isvisibile && file.Visibility == Domain.Enums.FileVisibility.visible)
{
file.Visibility = Domain.Enums.FileVisibility.hiddenMessage;
}
}
}
Manager.SaveOrUpdate <Message>(msg);
this.UserAccessUpdate(TicketId);
return(true);
}
/// <summary>
/// Restituisce le ActionType
/// </summary>
/// <param name="UserType">Tipo utente. Se diverso da creatore, controllo permessi per file comunità</param>
/// <param name="idCommunity">= 0 Se creatore o portale</param>
/// <param name="idPerson">= 0 se creatore o portale</param>
/// <param name="repositoryPermissions">Repository permission: if NULL = no community permission</param>
/// <returns></returns>
/// <remarks>
/// Eventuamente modificare i riferimenti per avere Id utente e comnità reali.
/// </remarks>
public List <lm.Comol.Core.DomainModel.Repository.RepositoryAttachmentUploadActions> UploadAvailableActionsGet(Domain.Enums.MessageUserType UserType, int idCommunity, int idPerson, lm.Comol.Core.FileRepository.Domain.ModuleRepository repositoryPermissions)
{
List <lm.Comol.Core.DomainModel.Repository.RepositoryAttachmentUploadActions> actions = new List <DomainModel.Repository.RepositoryAttachmentUploadActions>();
//UserType == TK.Enums.MessageUserType.Partecipant ||
if (idCommunity <= 0 || idPerson <= 0)
{
actions.Add(DomainModel.Repository.RepositoryAttachmentUploadActions.uploadtomoduleitem);
}
else
{
actions.Add(DomainModel.Repository.RepositoryAttachmentUploadActions.uploadtomoduleitem);
if (repositoryPermissions != null)
{
if (repositoryPermissions.Administration || repositoryPermissions.ManageItems || repositoryPermissions.ViewItemsList)
{
actions.Add(DomainModel.Repository.RepositoryAttachmentUploadActions.linkfromcommunity);
}
if (repositoryPermissions.UploadFile || repositoryPermissions.Administration || repositoryPermissions.ManageItems)
{
actions.Add(DomainModel.Repository.RepositoryAttachmentUploadActions.uploadtomoduleitemandcommunity);
}
}
}
return(actions);
}
/// <summary>
/// Aggiunge un messeggio dal Manager/Resolver al Ticket indicato
/// </summary>
/// <param name="TicketId">Id Ticket</param>
/// <param name="Text">Testo messaggio</param>
/// <param name="Preview">Eventuale anteprima</param>
/// <param name="HideToUser">Se nascondere il messaggio all'utente</param>
/// <param name="MessageType">Tipo di messaggio</param>
/// <param name="UpdateAccess">SE aggiornare l'accesso dell'utente al Ticket</param>
/// <param name="UserType">Tipo utente (per messaggio e controllo)</param>
/// <returns>Eventuali errori</returns>
public Domain.Enums.TicketMessageSendError MessageSendMan(
Int64 TicketId,
String Text,
String Preview,
Boolean HideToUser,
Domain.Enums.MessageType MessageType,
Domain.Enums.MessageUserType UserType,
Boolean UpdateAccess,
ref Int64 NewMessageId,
Int64 DraftId = -1,
Boolean IsDraft = false
)
{
bool isTicketClosed = false;
if (UserType == Domain.Enums.MessageUserType.none || UserType == Domain.Enums.MessageUserType.Partecipant ||
CurrentPerson.TypeID == (int)UserTypeStandard.Guest ||
CurrentPerson.TypeID == (int)UserTypeStandard.ExternalUser)
{
return(Domain.Enums.TicketMessageSendError.NoPermission);
}
if (String.IsNullOrEmpty(Text) || String.IsNullOrEmpty(Preview))
{
return(Domain.Enums.TicketMessageSendError.NoMessage);
}
Domain.TicketUser Usr = this.UserGetfromPerson(UC.CurrentUserID);
if (Usr == null || Usr.Id <= 0)
{
return(Domain.Enums.TicketMessageSendError.NoPermission);
}
Ticket tk = Manager.Get <Ticket>(TicketId);
if (tk == null)
{
return(Domain.Enums.TicketMessageSendError.TicketNotFound);
}
if (tk.IsDraft)
{
return(Domain.Enums.TicketMessageSendError.DraftTicket);
}
bool IsNew = false;
Message msg = (from Message m in tk.Messages where m.IsDraft == true && m.Creator != null && m.Creator.Id == Usr.Id select m).FirstOrDefault();
if (msg == null || msg.Id <= 0)
{
msg = new Message();
IsNew = true;
}
else
{
// TEORICAMENTE NON SERVE, MA FORSE MEGLIO METTERCELO!!!
if (DraftId != msg.Id)
{
//UPDATE FILE MESSAGE ID, FROM DraftId To msgId!!!
}
}
if (IsNew)
{
msg.CreateMetaInfo(CurrentPerson, UC.IpAddress, UC.ProxyIpAddress);
}
else
{
msg.UpdateMetaInfo(CurrentPerson, UC.IpAddress, UC.ProxyIpAddress);
}
msg.Text = Text;
msg.Preview = Preview;
msg.Creator = Usr;
msg.DisplayName = "";
msg.SendDate = DateTime.Now;
msg.ShowRealName = true;
msg.Ticket = tk;
msg.Type = MessageType;
msg.UserType = UserType;
msg.Visibility = !HideToUser;
if (tk.Status == TicketStatus.closeSolved || tk.Status == TicketStatus.closeUnsolved)
{
isTicketClosed = true;
msg.IsDraft = true;
}
else
{
msg.IsDraft = IsDraft;
}
msg.Action = Domain.Enums.MessageActionType.normal;
msg.ToStatus = tk.Status;
Domain.TicketUser usr = (from Assignment asg in tk.Assignemts where asg.AssignedTo != null orderby asg.CreatedOn select asg.AssignedTo).FirstOrDefault();
msg.ToUser = usr;
Domain.Category cat = (from Assignment asg in tk.Assignemts where asg.AssignedCategory != null orderby asg.CreatedOn select asg.AssignedCategory).FirstOrDefault();
if (cat == null)
{
cat = tk.CreationCategory;
}
msg.ToCategory = cat;
if (IsNew)
{
tk.Messages.Add(msg);
}
//else
// Manager.SaveOrUpdate<Message>(msg);
tk.UpdateMetaInfo(CurrentPerson, UC.IpAddress, UC.ProxyIpAddress);
Manager.SaveOrUpdate <Ticket>(tk);
if (UpdateAccess)
{
this.UserAccessUpdate(tk.Id);
}
NewMessageId = msg.Id;
if (isTicketClosed)
{
return(TicketMessageSendError.TicketClosed);
}
return(Domain.Enums.TicketMessageSendError.none);
}
