コード例 #1
0
        public IActionResult Message(AddMessageViewModel addMessageViewModel)
        {
            if (ModelState.IsValid)
            {
            }

            return(View());
        }
コード例 #2
0
        public ActionResult Message(AddMessageViewModel model)
        {
            if (this.ModelState.IsValid)
            {
                this.messageService.Add(model.Email, model.Content);
                return this.RedirectToAction("Index");
            }

            return this.View("Index", model);
        }
コード例 #3
0
        public IActionResult AddMessage(string recepientId)
        {
            var message = new AddMessageViewModel()
            {
                RecepientId = recepientId,
                PhotographyAddictedUserId = this.User.FindFirstValue(ClaimTypes.NameIdentifier),
            };

            return(View(message));
        }
コード例 #4
0
        public IActionResult AddMessage(AddMessageViewModel model)
        {
            if (model.Text.Length > 300)
            {
                model.Text = model.Text.Substring(0, 300);
            }

            repository.AddMessage(model.Text, repository.GetUserByUserName(this.User.Identity.Name));
            return(Json(""));
        }
コード例 #5
0
        public AddMessageView()
        {
            InitializeComponent();

            IDataProvider      dataProvider      = new DataProvider();
            IStatisticsService statisticsService = new StatisticsService(dataProvider);
            IMessageService    messageService    = new MessageService(dataProvider, statisticsService);

            DataContext = new AddMessageViewModel(messageService);
        }
コード例 #6
0
        public IHttpActionResult Add(AddMessageViewModel model)
        {
            //TODO send ids to client and handle there
            if (model.JobSeekerProfileId == 0 && model.SenderProfileType == ProfileType.JobSeeker )
            {
                model.JobSeekerProfileId =
                    this.data.JobSeekerProfiles.All().Where(x => !x.IsDeleted)
                        .FirstOrDefault(x => x.UserId == this.CurrentUserId)
                        .JobSeekerProfileId;

                model.SenderId = model.JobSeekerProfileId;
            }

            if (model.RecruiterProfileId == 0 && model.SenderProfileType == ProfileType.Recruiter)
            {
                model.RecruiterProfileId =
                    this.data.RecruiterProfiles.All().Where(x => !x.IsDeleted)
                        .FirstOrDefault(x => x.UserId == this.CurrentUserId)
                        .RecruiterProfileId;

                model.SenderId = model.RecruiterProfileId;
            }

            if (model != null && ModelState.IsValid)
            {
                var message = AutoMapper.Mapper.Map<Message>(model);

                this.data.Messages.Add(message);
                this.data.SaveChanges();

                var jobSeeker =
                    this.data.JobSeekerProfiles.All().Where(x => !x.IsDeleted)
                        .FirstOrDefault(x => x.JobSeekerProfileId == model.JobSeekerProfileId);

                var recruiter =
                    this.data.RecruiterProfiles.All().Where(x => !x.IsDeleted)
                        .FirstOrDefault(x => x.RecruiterProfileId == model.RecruiterProfileId);

                if (jobSeeker == null || recruiter == null)
                {
                    return this.BadRequest("A message can only be sent between job seekers and recruiters.");
                }

                jobSeeker.Messages.Add(message);
                recruiter.Messages.Add(message);

                model.Id = message.Id;

                this.data.SaveChanges();

                return this.Ok(model);
            }

            return this.BadRequest();
        }
コード例 #7
0
        //[CheckReferrer]
        public virtual async Task <ActionResult> Reply(AddMessageViewModel viewModel)
        {
            if (!await _messageService.CheckAccess(viewModel.ConversationId))
            {
                return(HttpNotFound());
            }
            _messageService.Create(viewModel);
            await _unitOfWork.SaveChangesAsync();

            return(RedirectToAction(MVC.PrivateMessage.Messages(viewModel.ConversationId)));
        }
コード例 #8
0
ファイル: MessageService.cs プロジェクト: vbadvanced/Decision
        public void Create(AddMessageViewModel viewModel)
        {
            var newMessageToConversation = new Message
            {
                ConversationId = viewModel.ConversationId,
                Body           = viewModel.Body.ToSafeHtml(),
                ParentId       = viewModel.ParentId,
                SentOn         = DateTime.Now,
                SenderId       = _userManager.GetCurrentUserId()
            };

            _messages.Add(newMessageToConversation);
        }
コード例 #9
0
        public async Task <IActionResult> AddMessage(AddMessageViewModel input)
        {
            if (!this.ModelState.IsValid)
            {
                return(View(input));
            }
            if (input.RecepientId == input.PhotographyAddictedUserId)
            {
                return(this.RedirectToAction("Index", "Home"));
            }

            var conversationId = await messageService.AddMessageAsync(input);

            return(this.RedirectToAction("PreviewConversation", "Conversations", new { conversationId }));
        }
コード例 #10
0
        public async Task <IActionResult> AddAsync(AddMessageViewModel model)
        {
            if (ModelState.IsValid)
            {
                Message message = new Message
                {
                    MessageTitle   = model.MessageTitle,
                    MessageContent = model.MessageContent,
                    DateModified   = DateTime.Now
                };

                await _messageRepository.AddMessageAsync(message);

                return(RedirectToAction("Complete", new { message = "The Message is added Successfully and is now available for viewing" }));
            }
            return(View(model));
        }
コード例 #11
0
        public async Task AddMessage(int id, [FromBody] AddMessageViewModel model)
        {
            var userId = int.Parse(User.GetName());
            var chat   = await _chatRepository.GetChat(userId, id);

            var message = _mapper.Map <Message>(model);

            if (chat == null)
            {
                chat = new Chat
                {
                    IdSource = userId,
                    IdTarget = id
                };
                await _chatRepository.AddChat(chat);
            }

            message.IdSender = userId;
            message.IdChat   = chat.Id;
            message.Time     = DateTime.Now;
            await _messageRepository.AddMessage(message);
        }
コード例 #12
0
        public async Task <int> AddMessageAsync(AddMessageViewModel input)
        {
            var message = new Message()
            {
                CreationDate = DateTime.UtcNow,
                Text         = input.Text,
                RecepientId  = input.RecepientId,
                PhotographyAddictedUserId = input.PhotographyAddictedUserId,
            };

            var isConversation = conversationDbSet.All()
                                 .Where(i => (i.SenderPhotographyAddictedUser.Id == input.PhotographyAddictedUserId && i.RecepientPhotographyAddictedUser.Id == input.RecepientId) ||
                                        (i.SenderPhotographyAddictedUser.Id == input.RecepientId && i.RecepientPhotographyAddictedUser.Id == input.PhotographyAddictedUserId)).FirstOrDefault();

            if (isConversation == null)
            {
                var conversation = new Conversation()
                {
                    CreationDate = DateTime.UtcNow,
                    RecepientPhotographyAddictedUser = userDbset.All().Where(u => u.Id == input.RecepientId).First(),
                    SenderPhotographyAddictedUser    = userDbset.All().Where(u => u.Id == input.PhotographyAddictedUserId).First(),
                };

                conversation.Messages.Add(message);
                await conversationDbSet.AddAsync(conversation);

                await conversationDbSet.SaveChangesAsync();

                return(conversation.Id);
            }
            else
            {
                isConversation.Messages.Add(message);
                // await conversationDbSet.AddAsync(isConversation);
                await conversationDbSet.SaveChangesAsync();

                return((int)message.ConversationId);
            }
        }
コード例 #13
0
        public async Task <IActionResult> Send(AddMessageViewModel addMessageViewModel, string message, int id)
        {
            var user = await userManager.FindByNameAsync(User.Identity.Name);

            var name = user.FullName;

            if (ModelState.IsValid)
            {
                BookClub.Models.AddMessage newMessage = new BookClub.Models.AddMessage
                {
                    Message    = message,
                    ReceiverId = id,
                    Date       = DateTime.Now,
                    UserName   = name,
                    UserId     = int.Parse(userManager.GetUserId(HttpContext.User))
                };
                context.AddMessages.Add(newMessage);
                context.SaveChanges();

                return(Redirect("/Home"));
            }
            return(View(addMessageViewModel));
        }
コード例 #14
0
        public async Task <ActionResult> AddMessagePost(AddMessageViewModel model, int threadId, int groupId)
        {
            // Checking if the model is valled
            if (ModelState.IsValid)
            {
                ViewBag.ThreadId = threadId;
                ViewBag.GroupId  = groupId;

                // Creating the message
                Message message = new Message
                {
                    Body = model.Body
                };

                await MessageManager.CreateAsync(message, await ThreadManager.FindByIdAsync(threadId));
            }
            else
            {
                return(Content("There was a error with your message please check before you post again"));
            }

            return(RedirectToAction("Thread", new { threadId, groupId }));
        }
コード例 #15
0
        public async Task <IActionResult> AddMessage([FromBody] AddMessageViewModel message, [FromServices] IHubContext <ChatHub> chat)
        {
            if (ModelState.IsValid)
            {
                var messageDto = _mapper.Map <AddMessageDto>(message);
                var getMessage = await _chatService.SendMessage(messageDto);

                var participants = await _chatService.GetParticipants(message.ChatId);

                var user = chat.Clients.Users(participants);
                await chat.Clients.Users(participants).SendAsync("ReceiveMessage", new
                {
                    Text            = message.Text,
                    PosterFirstName = getMessage.FirstName,
                    PosterLastName  = getMessage.LastName,
                    PosterLastPhoto = getMessage.ImagePath,
                    Timestamp       = getMessage.CreatedDateUtc,
                    PosterId        = getMessage.CreatedById
                });

                return(Ok(getMessage));
            }
            return(BadRequest());
        }
コード例 #16
0
        public IActionResult AddMessage(AddMessageViewModel model)
        {
            if (ModelState.IsValid)
            {
                var error = _messageService.AddMessage(model.Description);

                switch (error)
                {
                case null:
                    return(RedirectToAction("Index", new { tab = AdminTabEnum.MESSAGES }));

                default:
                    return(this.InternalServerError());
                }
            }

            var indexModel = new AdminViewModel();

            FillAdminViewModel(indexModel);
            indexModel.AddMessageViewModel = model;
            indexModel.OpenAddMessageModal = true;
            indexModel.Tab = AdminTabEnum.MESSAGES;
            return(View("Index", indexModel));
        }
コード例 #17
0
 public AddMessage()
 {
     InitializeComponent();
     BindingContext = new AddMessageViewModel(Navigation);
 }
コード例 #18
0
        public IActionResult Messenger()
        {
            AddMessageViewModel addMessageViewModel = new AddMessageViewModel();

            return(View(addMessageViewModel));
        }
コード例 #19
0
 public AddMessageControl()
 {
     InitializeComponent();
     this.AddMessageViewModel = new AddMessageViewModel();
     this.DataContext         = AddMessageViewModel;
 }
コード例 #20
0
 public IActionResult Send(AddMessageViewModel addMessageViewModel)
 {
     return(View(addMessageViewModel));
 }
コード例 #21
0
        public async Task <IActionResult> Post([FromBody] AddMessageViewModel model)
        {
            await _messageController.AddAsync(model);

            return(NoContent());
        }