public async Task <CreateEventViewModel> Handle(CreateEventCommand request, CancellationToken cancellationToken)
        {
            var      userId = HttpContextAccessor.HttpContext?.User.FindFirstValue(ClaimTypes.NameIdentifier);
            BaseUser user   = _context.BaseUsers.FirstOrDefault(u => u.Id == userId);

            if (user == null)
            {
                throw new CustomException(new Error
                {
                    ErrorType = ErrorType.Unauthorized,
                    Message   = Localizer["Unauthorized"]
                });
            }
            var eventObj = new Domain.Models.Event()
            {
                EventName        = request.EventName,
                EventDescription = request.EventDescription,
                EventTime        = request.EventTime,
                User             = user,
                UserId           = user.Id
            };
            await _context.Events.AddAsync(eventObj, cancellationToken);

            await _context.SaveChangesAsync(cancellationToken);

            return(new CreateEventViewModel
            {
                EventDto = _mapper.Map <EventShortDto>(eventObj)
            });
        }
        public async Task <ViewPersonalEventViewModel> Handle(ViewPersonalEventQuery request, CancellationToken cancellationToken)
        {
            var userId = HttpContextAccessor.HttpContext?.User.FindFirstValue(ClaimTypes.NameIdentifier);
            var user   = await UserManager.FindByIdAsync(userId);

            if (user == null)
            {
                throw new CustomException(new Error
                {
                    ErrorType = ErrorType.Unauthorized,
                    Message   = Localizer["Unauthorized"]
                });
            }
            Domain.Models.Event eventObj = _context.Events.FirstOrDefault(e => e.EventId == request.EventId);

            return(new ViewPersonalEventViewModel
            {
                Event = _mapper.Map <EventDto>(eventObj)
            });
        }
Пример #3
0
 public async Task <int> Insert(Domain.Models.Event events)
 {
     _eventRepository.Create(events);
     return(await Context.SaveChangesAsync());
 }
Пример #4
0
 public async Task <int> Update(Domain.Models.Event events)
 {
     return(await Context.SaveChangesAsync());
 }
Пример #5
0
        public async Task <ActionResultResponse <string> > Insert(string tenantId, string creatorId, string creatorFullName, string creatorAvatar, EventMeta eventMeta)
        {
            if (eventMeta.StartDate.HasValue && eventMeta.EndDate.HasValue)
            {
                if (DateTime.Compare(eventMeta.StartDate.Value, eventMeta.EndDate.Value) > 0)
                {
                    return(new ActionResultResponse <string>(-1, _websiteEventResourceService.GetString("Start time greater than end time.")));
                }
            }

            var eventId = Guid.NewGuid().ToString();
            var events  = new Domain.Models.Event
            {
                Id = eventId,
                ConcurrencyStamp            = eventId,
                IsActive                    = eventMeta.IsActive,
                StartDate                   = eventMeta.StartDate,
                EndDate                     = eventMeta.EndDate,
                LimitedUsers                = eventMeta.LimitedUsers,
                IsAllowRegisterWhenOverload = eventMeta.IsAllowRegisterWhenOverload,
                LimitedAccompanyPersons     = eventMeta.LimitedAccompanyPersons,
                StaffOnly                   = eventMeta.StaffOnly,
                IsAllowRegister             = eventMeta.IsAllowRegister,
                IsAllowAccompanyPerson      = eventMeta.IsAllowAccompanyPerson,
                Thumbnail                   = eventMeta.Thumbnail,
                Status          = ApproverStatus.Draft,
                TenantId        = tenantId,
                CreatorId       = creatorId,
                CreatorFullName = creatorFullName,
                CreatorAvatar   = creatorAvatar
            };

            var result = await _eventRepository.Insert(events);

            if (result <= 0)
            {
                return(new ActionResultResponse <string>(result,
                                                         _sharedResourceService.GetString(ErrorMessage.SomethingWentWrong)));
            }


            #region insert Translation.
            if (eventMeta.EventTranslations.Count > 0)
            {
                var resultInsertTranslation = await InsertEventTranslation();

                if (resultInsertTranslation.Code <= 0)
                {
                    return(resultInsertTranslation);
                }
            }
            #endregion

            await SendNotificationToApprover(tenantId, creatorId, creatorFullName, creatorAvatar, eventId);

            return(new ActionResultResponse <string>(1, _websiteEventResourceService.GetString("Add new event successful."),
                                                     string.Empty, eventId));

            #region Local functions
            async Task <ActionResultResponse <string> > InsertEventTranslation()
            {
                var apiUrls = _configuration.GetApiUrl();

                if (apiUrls == null)
                {
                    return(new ActionResultResponse <string>(-5,
                                                             _sharedResourceService.GetString(
                                                                 "Missing some configuration. Please contact with administrator.")));
                }

                var eventTags         = new List <TagSubjectViewModel>();
                var eventTranslations = new List <EventTranslation>();

                foreach (var eventTranslation in eventMeta.EventTranslations)
                {
                    // Check name exists.
                    //var isNameExists = await _eventTranslationRepository.CheckExists( eventId,
                    //    eventTranslation.LanguageId, eventTranslation.Name);
                    //if (isNameExists)
                    //{
                    //    await RollbackInsertEvent();
                    //    return new ActionResultResponse<string>(-1,
                    //        _websiteEventResourceService.GetString("Event name: \"{0}\" already exists.",
                    //            eventTranslation.Name));
                    //}

                    var eventTranslationInsert = new EventTranslation
                    {
                        EventId         = eventId,
                        LanguageId      = eventTranslation.LanguageId.Trim(),
                        Name            = eventTranslation.Name.Trim(),
                        MetaTitle       = eventTranslation.MetaTitle?.Trim(),
                        Description     = eventTranslation.Description?.Trim(),
                        MetaDescription = eventTranslation.MetaDescription?.Trim(),
                        Content         = eventTranslation.Content?.Trim(),
                        UnsignName      = eventTranslation.Name?.StripVietnameseChars().ToUpper(),
                        Address         = eventTranslation?.Address?.Trim()
                    };

                    eventTranslationInsert.SeoLink = !string.IsNullOrEmpty(eventTranslation.SeoLink)
                        ? eventTranslation.SeoLink.ToUrlString() : eventTranslation.Name.ToUrlString();

                    // Check Seolink exists.
                    var isSeolinkExists = await _eventTranslationRepository.CheckSeoLinkExists(eventId,
                                                                                               eventTranslation.LanguageId, eventTranslationInsert.SeoLink);

                    if (isSeolinkExists)
                    {
                        await RollbackInsertEvent();

                        return(new ActionResultResponse <string>(-2,
                                                                 _websiteEventResourceService.GetString("Seo link: \"{0}\" already exists.",
                                                                                                        eventTranslationInsert.SeoLink)));
                    }

                    eventTranslations.Add(eventTranslationInsert);

                    var eventTagInsert = new TagSubjectViewModel
                    {
                        TenantId        = tenantId,
                        CreatorId       = creatorId,
                        CreatorFullName = creatorFullName,
                        CreatorAvata    = creatorAvatar,
                        Type            = TagType.Event,
                        SubjectId       = eventId,
                        LanguageId      = eventTranslation.LanguageId.Trim(),
                        Tags            = eventTranslation.Tags
                    };
                    eventTags.Add(eventTagInsert);
                }

                var resultTag = await new HttpClientService()
                                .PostAsync <ActionResultResponse>($"{apiUrls.CoreApiUrl}/tags", eventTags);

                var resultTranslation = await _eventTranslationRepository.Inserts(eventTranslations);

                if (resultTranslation > 0)
                {
                    return(new ActionResultResponse <string>(resultTranslation,
                                                             _websiteEventResourceService.GetString("Add new event translation successful.")));
                }

                await RollbackInsertEventTranslation();
                await RollbackInsertEvent();

                return(new ActionResultResponse <string>(-3,
                                                         _websiteEventResourceService.GetString("Can not insert event translation. Please contact with administrator.")));
            }

            async Task RollbackInsertEvent()
            {
                await _eventRepository.ForceDelete(eventId);
            }

            async Task RollbackInsertEventTranslation()
            {
                await _eventTranslationRepository.Delete(eventId);
            }

            #endregion Local functions
        }