예제 #1
0
        //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);
        }
예제 #2
0
        //TODO: notification - V - test
        public void SendMessage(
            String Text, String Preview, Boolean HideToUser,
            Domain.Enums.TicketStatus NewStatus,
            Domain.Enums.MessageType MsgType,
            Int64 DraftId)
        {
            if (!CheckSessionAccess())
            {
                return;
            }

            if (!service.UserHasManResTicketPermission(View.TicketId))
            {
                View.SendUserActions(service.ModuleID, ModuleTicket.ActionType.NoPermission, this.CurrentCommunityId, ModuleTicket.InteractionType.None);
                View.ShowNoPermission();
            }
            if (DraftId <= 0)
            {
                this.InitView();
                return;
            }

            if (this.service.MessageCheckDraft(DraftId))
            {
                this.InitView();
                return;
            }



            Domain.Enums.TicketMessageSendError error = Domain.Enums.TicketMessageSendError.none;



            Int64 messageId = 0;
            Int64 userId    = this.service.UserGetIdfromPerson(UserContext.CurrentUserID);

            if (NewStatus == Domain.Enums.TicketStatus.closeSolved || NewStatus == Domain.Enums.TicketStatus.closeUnsolved)
            {
                error = service.MessageSendMan(View.TicketId, Text, Preview, HideToUser, MsgType, View.UserType, false, ref messageId);
                service.TicketStatusModify(View.TicketId, NewStatus, View.GetChangeStatusMessage(NewStatus), true, View.UserType, ref messageId);

                //Begin Action
                List <KeyValuePair <int, String> > Objects = new List <KeyValuePair <int, string> >();
                Objects.Add(ModuleTicket.KVPgetUser(userId));
                Objects.Add(ModuleTicket.KVPgetTicket(View.TicketId));

                View.SendUserActions(service.ModuleID, ModuleTicket.ActionType.TicketStatusChanged, this.CurrentCommunityId, ModuleTicket.InteractionType.UserWithLearningObject, Objects);
                //End Action
            }
            else
            {
                service.TicketStatusModify(View.TicketId, NewStatus, View.GetChangeStatusMessage(NewStatus), false, View.UserType, ref messageId);
                error = service.MessageSendMan(View.TicketId, Text, Preview, HideToUser, MsgType, View.UserType, true, ref messageId);
            }

            if (error == Domain.Enums.TicketMessageSendError.none)
            {
                //Int64 userId = this.service.UserGetIdfromPerson(UserContext.CurrentUserID);
                //Begin Action
                List <KeyValuePair <int, String> > Objects = new List <KeyValuePair <int, string> >();
                Objects.Add(ModuleTicket.KVPgetUser(userId));
                Objects.Add(ModuleTicket.KVPgetMessage(messageId));

                View.SendUserActions(service.ModuleID, ModuleTicket.ActionType.MessageSend, this.CurrentCommunityId, ModuleTicket.InteractionType.UserWithLearningObject, Objects);
                //End Action

                //ToDo: Send Notification
                if (messageId > 0)
                {
                    SendNotification(messageId, userId, ModuleTicket.NotificationActionType.MassageSend);
                }

                this.InitView();
            }
            //else
            View.ShowSendError(error);
        }
예제 #3
0
        /// <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);
        }