Exemple #1
0
        public async Task <IActionResult> Play(string siteId, string id, string filename)
        {
            // This can prevent some unnecessary accesses.
            // These kind of file names won't be existing at all.
            if (string.IsNullOrWhiteSpace(filename) || AnyInvalidFileNameChars(filename))
            {
                return(NotFound());
            }

            var getFileInput = new GetFileInput
            {
                SiteId       = siteId,
                Id           = id,
                Key          = string.Empty,
                PropertyName = null,
                Module       = "VideoData"
            };
            var result = await
                         Business.InvokeAsync <GetFileCommand, GetFileInput, CommandResult <GetFileResult> >(_getFileCommand,
                                                                                                             getFileInput);

            if (result.IsSuccess)
            {
                if (!string.IsNullOrEmpty(result.Data.RedirectUrl))
                {
                    return(Redirect(result.Data.RedirectUrl));
                }
            }
            return(null);
        }
Exemple #2
0
 public Task <WorkspaceFile> GetFileAsync(
     GetFileInput input,
     [Service] IWorkspaceService workspaceService,
     CancellationToken cancellationToken)
 {
     return(workspaceService.GetFileAsync(new GetFileRequest(input.FileName)
     {
         Converter = input.Converter
     }, cancellationToken));
 }
Exemple #3
0
        private async Task <IActionResult> GetImageAsync(GetFileCommand _getFileCommand, string siteId, string id, string key,
                                                         string propertyName = null)
        {
            var fileInfo = new GetFileInput
            {
                SiteId       = siteId,
                Id           = id,
                Key          = key,
                PropertyName = propertyName,
                UserId       = StatController.GetUserId(User)
            };
            var result = await
                         Business.InvokeAsync <GetFileCommand, GetFileInput, CommandResult <GetFileResult> >(
                _getFileCommand, fileInfo).ConfigureAwait(false);

            if (result.IsSuccess)
            {
                return(File(result.Data.Stream, result.Data.ContentType));
            }

            return(NotFound());
            //return new HttpResponseMessage(HttpStatusCode.NotFound);
        }
        public Dtos.GetSubscribersOutput GetSubscribers(Dtos.GetSubscribersInput input)
        {
            try
            {
                if (input.CompanyId.HasValue)
                {
                    var subscribers = _subscribersRepository.GetSubscribersByCompany(input.CompanyId.Value);

                    List<SubscribersDto> subscriberList = new List<SubscribersDto>();

                    foreach (var item in subscribers)
                    {
                        SubscribersDto subscriber = new SubscribersDto();
                        subscriber.Email = item.Email;
                        subscriber.FullName = item.FullName;
                        subscriber.SmsNumber = item.SmsNumber;
                        subscriber.SubscriberId = item.SubscriberId;
                        subscriber.TotalCredits = item.TotalCredits;
                        subscriber.TotalSpend = item.TotalSpend;
                        subscriberList.Add(subscriber);
                    }

                    return new Dtos.GetSubscribersOutput
                    {
                        Subscribers = subscriberList
                    };
                }
                else {
                    //Called specific GetAllWithPeople method of task repository.
                    var subscribers = _subscribersRepository.GetAll();

                    if (input.SubscribersId != null)
                    {
                        subscribers.Where(s => s.Id == input.SubscribersId);

                        List<Dtos.SubscribersDto> results = new List<SubscribersDto>();
                        Dtos.SubscribersDto subscriberDto = Mapper.Map<Dtos.SubscribersDto>(subscribers);
                        results.Add(subscriberDto);

                        //Get subscriber images from DocumentHero
                        #region Get Subscriber Image
                        var inputFileExt = new List<FileExtDto>();
                        var inputFileExtValue = new FileExtDto()
                        {
                            Key = "SubscriberId",
                            Value = input.SubscribersId.ToString(),
                            FileRefId = input.CompanyId.Value
                        };
                        inputFileExt.Add(inputFileExtValue);
                        GetFileInput fileInput = new GetFileInput();
                        fileInput.ApiKey = input.CompanyId;
                        fileInput.FileMetadata = inputFileExt;
                        //var _fileExtRepository = _iocResolver.Resolve<IFileExtRepository>();
                        //var fileService = IocManager.Instance.Resolve<FileAppService>();
                        //var imageUri = fileService.GetFiles(fileInput);

                        //DocumentHero.Files.FileAppService fileAppService = new FileAppService();
                        var resultsImage = _documentHeroService.GetAllByKeyValue(fileInput);
                        if (resultsImage.Files != null)
                        {
                            subscriberDto.ImageUri = resultsImage.Files[0].Uri;
                        }
                        #endregion

                        return new Dtos.GetSubscribersOutput
                        {
                            Subscribers = results
                        };
                    }
                    //Used AutoMapper to automatically convert List<Task> to List<TaskDto>.
                    //We must declare mappings to be able to use AutoMapper
                    return new Dtos.GetSubscribersOutput
                    {
                        Subscribers = Mapper.Map<List<Dtos.SubscribersDto>>(subscribers)
                    };
                }
            }
            catch (System.Exception exc)
            {
                Logger.Error("Error getting subscriber list", exc);
                return new Dtos.GetSubscribersOutput();
            }
        }
        public Dtos.SubscribersDto GetSubscriber(Dtos.GetSubscribersInput input)
        {
            //Get the Subscriber(s)  
            //NOTE:  If multiple subscribers come back than we need to filter based on subscribers associated to criteria for a company
            //NOTE:  May need to refactor by adding CompanyRefId to Subscriber
            List<Subscriber> subscribers = new List<Subscriber>();
            Subscriber subscriber = new Subscriber();
            SubscribersDto subscriberDto = new SubscribersDto();
            try
            {
                if (input.SubscribersEmail != string.Empty)
                {
                    subscribers = _subscribersRepository.GetSubscriberByEmail(input.SubscribersEmail);
                    if (subscribers.Count > 1)
                    {
                        int subscriberId = 0;
                        foreach (var item in subscribers)
                        {
                            List<SubscriberCriteria> scList =
                                _subscribersValuesRepository.GetSubscribersCriteriaValues(item.Id, input.CompanyId.Value);
                            if (scList != null)
                            {
                                if (scList.Count > 0)
                                {
                                    subscriberId = item.Id;
                                }
                            }
                        }
                        subscriber = subscribers.Where(s => s.Id == subscriberId).FirstOrDefault();
                        subscriberDto = subscriber.MapTo<SubscribersDto>();
                    }
                    else
                    {
                        subscriber = subscribers.FirstOrDefault();
                        subscriberDto = subscriber.MapTo<SubscribersDto>();
                        if (subscriber != null)
                        {
                            //Get subscriber images from DocumentHero
                            #region Get Subscriber Image
                            var inputFileExt = new List<FileExtDto>();
                            var inputFileExtValue = new FileExtDto()
                            {
                                Key = "SubscriberId",
                                Value = subscriber.Id.ToString(),
                                FileRefId = input.CompanyId.Value
                            };
                            inputFileExt.Add(inputFileExtValue);
                            GetFileInput fileInput = new GetFileInput();
                            fileInput.ApiKey = input.CompanyId;
                            fileInput.FileMetadata = inputFileExt;
                            //var _fileExtRepository = _iocResolver.Resolve<IFileExtRepository>();
                            //var fileService = IocManager.Instance.Resolve<FileAppService>();
                            //var imageUri = fileService.GetFiles(fileInput);

                            //DocumentHero.Files.FileAppService fileAppService = new FileAppService();
                            var resultsImage = _documentHeroService.GetAllByKeyValue(fileInput);
                            if (resultsImage.Files != null)
                            {
                                subscriberDto.ImageUri = resultsImage.Files[0].Uri;
                            }
                        }
                        #endregion

                    }
                }

                return subscriberDto;
            }
            catch(System.Exception exc)
            {
                Logger.ErrorFormat("CH_SAS_000", exc.StackTrace);
                throw exc;
            }
        }
        public async Task<Dtos.GetSubscribersOutput> FindSubscribers(Dtos.GetSubscribersInput input)
        {
            Dtos.GetSubscribersOutput results = new Dtos.GetSubscribersOutput();
            List<Filter> filter = new List<Filter>();
            

            if (input.CompanyId.HasValue) filter.Add(
                new Filter { PropertyName = "ApiKey", Operation = Op.Equals, Value = input.CompanyId.Value });
            //if (input.TenantId.HasValue) filter.Add(
            //    new Filter { PropertyName = "TenantId", Operation = Op.Equals, Value = input.TenantId.Value });
            if (input.SubscribersEmail != null) filter.Add(
                new Filter { PropertyName = "Email", Operation = Op.Equals, Value = input.SubscribersEmail.ToLower() });
            if (input.SubscribersName != null) filter.Add(
                new Filter { PropertyName = "FullName", Operation = Op.Equals, Value = input.SubscribersName.ToLower() });
            if (input.SubscribersSms != null) filter.Add(
                new Filter { PropertyName = "SmsNumber", Operation = Op.Equals, Value = input.SubscribersSms.ToLower() });
            //if (input.TenantId.HasValue) filter.Add(
            //    new Filter { PropertyName = "TenantId", Operation = Op.Equals, Value = input.TenantId.Value });

            if (input.BeginSearchDate != null) filter.Add(
                 new Filter { PropertyName = "CreationTime", Operation = Op.GreaterThan, Value = input.BeginSearchDate.Value });
            if (input.EndSearchDate != null) filter.Add(
                 new Filter { PropertyName = "CreationTime", Operation = Op.LessThan, Value = input.EndSearchDate.Value });

            var deleg = ExpressionBuilder.GetExpression<Subscriber>(filter).Compile();

            if (input.TenantId.HasValue)
            {
                //using (CurrentUnitOfWork.SetFilterParameter(AbpDataFilters.MayHaveTenant, AbpDataFilters.Parameters.TenantId, input.TenantId))
                //{
                //CurrentUnitOfWork.SetFilterParameter(AbpDataFilters.MayHaveTenant, AbpDataFilters.Parameters.TenantId, input.TenantId);
                try
                {
                    var subscribers = _subscribersRepository.GetAll().Where(deleg).OrderByDescending(o => o.CreationTime).ToList();
                    var preSubscriberList = subscribers.MapTo<List<SubscribersDto>>();

                    //Get subscriber images from DocumentHero
                    foreach (var subscriber in preSubscriberList)
                    {
                        #region Get Subscriber Image
                        var inputFileExt = new List<FileExtDto>();
                        var inputFileExtValue = new FileExtDto() { Key = "SubscriberId", Value = subscriber.Id.ToString(), FileRefId = input.CompanyId.Value };
                        inputFileExt.Add(inputFileExtValue);
                        GetFileInput fileInput = new GetFileInput();
                        fileInput.ApiKey = input.CompanyId;
                        fileInput.FileMetadata = inputFileExt;
                        //var _fileExtRepository = _iocResolver.Resolve<IFileExtRepository>();
                        //var fileService = IocManager.Instance.Resolve<FileAppService>();
                        //var imageUri = fileService.GetFiles(fileInput);

                        //DocumentHero.Files.FileAppService fileAppService = new FileAppService();
                        var resultsImage = _documentHeroService.GetAllByKeyValue(fileInput);
                        if (resultsImage.Files != null)
                        {
                            subscriber.ImageUri = resultsImage.Files[0].Uri;
                        }
                        #endregion
                    }

                    return results = new Dtos.GetSubscribersOutput()
                    {
                        //Subscribers = subscribers.MapTo<List<SubscribersDto>>()
                        Subscribers = preSubscriberList
                    };
                }
                catch (System.Exception exc)
                {
                    throw exc;
                }
                //}
            }
            else
            {
                return results = new Dtos.GetSubscribersOutput()
                {
                    Subscribers = (await _subscribersRepository.GetAllListAsync()).MapTo<List<SubscribersDto>>()
                };
            }
        }