Esempio n. 1
0
        public void Search_Success()
        {
            List <EquipmentOrder> itemsToDelete = new List <EquipmentOrder>();

            for (int i = 0; i < 5; i++)
            {
                EquipmentOrder item = new EquipmentOrder()
                {
                    EquipmentId = _equipmentToDelete.Id,
                    GameId      = _gameToDelete.Id,
                    Count       = i + 1
                };
                itemsToDelete.Add(_equipmentOrdersRepository.CreateOrUpdate(item));
            }

            var items = _equipmentOrdersRepository.Search("Count = @Count", new { PageSize = 10, PageNumber = 1, Count = 1 });

            foreach (var item in itemsToDelete)
            {
                _equipmentOrdersRepository.Delete(item.Id);
            }

            Assert.AreNotEqual(0, items.Count());
            Assert.AreEqual(1, items.FirstOrDefault().Count);
        }
        public void Search_Success()
        {
            List <Equipment> itemsToDelete = new List <Equipment>();

            for (int i = 0; i < 5; i++)
            {
                Equipment item = new Equipment()
                {
                    Name      = "EquipmentTestName",
                    Price     = i + 1,
                    Count     = i + 1,
                    CompanyId = _companyToDelete.Id
                };
                itemsToDelete.Add(_equipmentsRepository.CreateOrUpdate(item));
            }

            var items = _equipmentsRepository.Search("Price = @Price", new { PageSize = 10, PageNumber = 1, Price = 1 });

            foreach (var item in itemsToDelete)
            {
                _equipmentsRepository.Delete(item.Id);
            }

            Assert.AreNotEqual(0, items.Count());
            Assert.AreEqual(1, items.FirstOrDefault().Price);
        }
Esempio n. 3
0
        public void Search_Success()
        {
            List <Task> itemsToDelete = new List <Task>();

            for (int i = 0; i < 5; i++)
            {
                Task item = new Task()
                {
                    StaffId     = _firstUser.Id,
                    Text        = "TaskTestText" + i,
                    IsCompleted = false,
                    CompanyId   = _companyToDelete.Id
                };
                itemsToDelete.Add(_tasksRepository.CreateOrUpdate(item));
            }

            var items = _tasksRepository.Search("Text = @Text", new { PageSize = 10, PageNumber = 1, Text = "TaskTestText1" });

            foreach (var item in itemsToDelete)
            {
                _tasksRepository.Delete(item.Id);
            }

            Assert.AreEqual(1, items.Count());
            Assert.AreEqual("TaskTestText1", items.FirstOrDefault().Text);
        }
Esempio n. 4
0
        public void Search_Success()
        {
            List <Event> itemsToDelete = new List <Event>();

            for (int i = 0; i < 5; i++)
            {
                Event item = new Event()
                {
                    GameId      = _gameToDelete.Id,
                    CompanyId   = _companyToDelete.Id,
                    Description = "EventTestDescription" + i,
                    Title       = "NewTitle"
                };
                itemsToDelete.Add(_eventsRepository.CreateOrUpdate(item));
            }

            var items = _eventsRepository.Search("Description = @Description", new { PageSize = 10, PageNumber = 1, Description = "EventTestDescription1" });

            foreach (var item in itemsToDelete)
            {
                _eventsRepository.Delete(item.Id);
            }

            Assert.AreEqual(1, items.Count());
            Assert.AreEqual("EventTestDescription1", items.FirstOrDefault().Description);
        }
Esempio n. 5
0
        public void Search_Success()
        {
            List <Company> itemsToDelete = new List <Company>();

            for (int i = 0; i < 5; i++)
            {
                Company item = new Company()
                {
                    Name        = "CompanyTestName" + i,
                    Adress      = "CompanyTestAdress",
                    Description = "CompanyTestDescription",
                    OwnerId     = Guid.Parse("c76e0147-5532-4dac-85b9-828961dfb4b4")
                };

                itemsToDelete.Add(_companiesRepository.CreateOrUpdate(item));
            }

            var items = _companiesRepository.Search("Name = @Name", new { PageSize = 10, PageNumber = 1, Name = "CompanyTestName1" });

            foreach (var item in itemsToDelete)
            {
                _companiesRepository.Delete(item.Id);
            }

            Assert.AreNotEqual(0, items.Count());
            Assert.AreEqual("CompanyTestName1", items.FirstOrDefault().Name);
        }
Esempio n. 6
0
        public IEnumerable <Category> List()
        {
            var searchCriteria = DetachedCriteria.For(typeof(Category))
                                 .SetResultTransformer(new DistinctRootEntityResultTransformer());

            return(repository.Search(searchCriteria).ToList());
        }
Esempio n. 7
0
        public void Search_Success()
        {
            List <Game> itemsToDelete = new List <Game>();

            for (int i = 0; i < 5; i++)
            {
                Game item = new Game()
                {
                    CreatorId   = _firstUser.Id,
                    BeginDate   = DateTime.Now,
                    GameType    = _gameTypeToDelete.Id,
                    Playground  = _playgroundToDelete.Id,
                    PlayerCount = 10,
                    GamePrice   = i + 1,
                    CompanyId   = _companyToDelete.Id
                };
                itemsToDelete.Add(_gamesRepository.CreateOrUpdate(item));
            }

            var items = _gamesRepository.Search("GamePrice = @GamePrice", new { PageSize = 10, PageNumber = 1, GamePrice = 1 });

            foreach (var item in itemsToDelete)
            {
                _gamesRepository.Delete(item.Id);
            }

            Assert.AreNotEqual(0, items.Count());
            Assert.AreEqual(1, items.FirstOrDefault().GamePrice);
        }
    public async Task <IActionResult> GetAll(string groupId, string username)
    {
        try
        {
            //if group is is not null
            //search by group id with repo
            if (groupId != null)
            {
                var searchedByGroupIdResults = await _userRepository.Search(groupId);

                return(Ok(searchedByGroupIdResults));
            }
            if (username != null)
            {
                var searchedByUsernameResults = await _userRepository.Search(username);

                if (searchedByUsernameResults.Any())
                {
                    return(Ok(searchedByUsernameResults));
                }
                return(NotFound($"Sorry, there is no user with the username of {username}"));
            }
            var allUsers = await _userRepository.GetAll();

            return(Ok(allUsers));
        }
        catch (Exception)
        {
            return(NotFound("Sorry, there are no users."));
        }
    }
Esempio n. 9
0
        public void Search_Success()
        {
            List <News> itemsToDelete = new List <News>();

            for (int i = 0; i < 5; i++)
            {
                News item = new News()
                {
                    Title       = "NewsTestName" + i,
                    PublishDate = DateTime.Now,
                    Text        = "NewsTestText",
                    CompanyId   = _companyToDelete.Id
                };
                itemsToDelete.Add(_newsRepository.CreateOrUpdate(item));
            }

            var items = _newsRepository.Search("Title = @Title", new { PageSize = 10, PageNumber = 1, Title = "NewsTestName1" });

            foreach (var item in itemsToDelete)
            {
                _newsRepository.Delete(item.Id);
            }

            Assert.AreEqual(1, items.Count());
            Assert.AreEqual("NewsTestName1", items.FirstOrDefault().Title);
        }
        public void Search_Success()
        {
            List <GameType> itemsToDelete = new List <GameType>();

            for (int i = 0; i < 5; i++)
            {
                GameType item = new GameType()
                {
                    CompanyId = _companyToDelete.Id,
                    Name      = "GameTypesTestName" + i,
                    Price     = 100
                };
                itemsToDelete.Add(_gameTypesRepository.CreateOrUpdate(item));
            }

            var items = _gameTypesRepository.Search("Name = @Name", new { PageSize = 10, PageNumber = 1, Name = "GameTypesTestName1" });

            foreach (var item in itemsToDelete)
            {
                _gameTypesRepository.Delete(item.Id);
            }

            Assert.AreEqual(1, items.Count());
            Assert.AreEqual("GameTypesTestName1", items.FirstOrDefault().Name);
        }
        public void Search_Success()
        {
            List <Operation> itemsToDelete = new List <Operation>();

            for (int i = 0; i < 5; i++)
            {
                Operation item = new Operation()
                {
                    Price     = i + 1,
                    Date      = DateTime.Now,
                    CompanyId = _companyToDelete.Id
                };
                itemsToDelete.Add(_operationsRepository.CreateOrUpdate(item));
            }

            var items = _operationsRepository.Search("Price = @Price", new { PageSize = 10, PageNumber = 1, Price = 1 });

            foreach (var item in itemsToDelete)
            {
                _operationsRepository.Delete(item.Id);
            }

            Assert.AreNotEqual(0, items.Count());
            Assert.AreEqual(1, items.FirstOrDefault().Price);
        }
Esempio n. 12
0
        public void Search_Success()
        {
            List <Certificate> itemsToDelete = new List <Certificate>();

            for (int i = 0; i < 5; i++)
            {
                Certificate item = new Certificate()
                {
                    FirstName  = "TestFirstName",
                    LastName   = "TestLastName",
                    MiddleName = "TestMiddleName",
                    CompanyId  = _companyToDelete.Id,
                    StartDate  = DateTime.Now,
                    EndDate    = DateTime.Now.AddYears(1),
                    OwnerId    = Guid.Parse("c76e0147-5532-4dac-85b9-828961dfb4b4"),
                    Price      = i + 1
                };
                itemsToDelete.Add(_certificateRepository.CreateOrUpdate(item));
            }

            var items = _certificateRepository.Search("Price = @Price", new { PageSize = 10, PageNumber = 1, Price = 5 });

            foreach (var item in itemsToDelete)
            {
                _certificateRepository.Delete(item.Id);
            }

            Assert.AreEqual(1, items.Count());
            Assert.AreEqual(5, items.FirstOrDefault().Price);
        }
Esempio n. 13
0
        public void Search_Success()
        {
            List <Playground> itemsToDelete = new List <Playground>();

            for (int i = 0; i < 5; i++)
            {
                Playground item = new Playground()
                {
                    Name      = "PlaygroundTestName" + i,
                    CompanyId = _companyToDelete.Id,
                    Price     = 100
                };

                itemsToDelete.Add(_playgroundRepository.CreateOrUpdate(item));
            }

            var items = _playgroundRepository.Search("Name = @Name", new { PageSize = 10, PageNumber = 1, Name = "PlaygroundTestName1" });

            foreach (var item in itemsToDelete)
            {
                _playgroundRepository.Delete(item.Id);
            }

            Assert.AreEqual(1, items.Count());
            Assert.AreEqual("PlaygroundTestName1", items.FirstOrDefault().Name);
        }
Esempio n. 14
0
        public IEnumerable <Product> List()
        {
            var searchCriteria = DetachedCriteria.For(typeof(Product))
                                 .SetFetchMode("Categories", FetchMode.Join)
                                 .SetFetchMode("Prices", FetchMode.Join)
                                 .SetResultTransformer(new DistinctRootEntityResultTransformer());

            return(repository.Search(searchCriteria).ToList());
        }
Esempio n. 15
0
        public IHttpActionResult GetContactByName(string name)
        {
            var searchcriteria = new ContactSearchCriteria();

            searchcriteria.ContactName = name;

            var searchSpecification = new ContactSpecificationForSearch(searchcriteria);

            return(Ok(_contactRepo.Search(searchSpecification)));
        }
Esempio n. 16
0
        public bool IsMorningRollUp(long empId)
        {
            var atd = _attendanceRepository
                      .Search(t => t.EmployeeId == empId &&
                              DateTime.Now.Date == t.Day.Value.Date &&
                              DateTime.Now.Month == t.Day.Value.Month &&
                              DateTime.Now.Year == t.Day.Value.Year &&
                              t.Morning == true
                              ).FirstOrDefault();

            return(atd == null ? false : true);
        }
        public ActionResult CurrentSwimmerEvents()
        {
            string          userId = User.Identity.GetUserId();
            SearchViewModel model  = new SearchViewModel
            {
                SwimmerId = userId
            };

            var events = eventRP.Search(model);

            return(View("SearchEventResults", events));
        }
        public ActionResult CurrentSwimmerLanes()
        {
            string          userId = User.Identity.GetUserId();
            SearchViewModel model  = new SearchViewModel
            {
                SwimmerId = userId
            };

            var lanes = laneRP.Search(model);

            return(View("SearchLaneResults", lanes));
        }
        public List <Event> GetMyEvents()
        {
            string userId = RequestContext.Principal.Identity.GetUserId();

            SearchEventViewModel model = new SearchEventViewModel
            {
                SwimmerId = userId
            };

            var events = eveRP.Search(model);

            return(events.ToList());
        }
        public List <Lane> GetMyResults()
        {
            string userId = RequestContext.Principal.Identity.GetUserId();

            SearchLanesViewModel model = new SearchLanesViewModel
            {
                SwimmerId = userId
            };

            var lanes = laneRP.Search(model);

            return(lanes.ToList());
        }
        public List <Meet> GetMyMeets()
        {
            string userId = RequestContext.Principal.Identity.GetUserId();

            SearchMeetViewModel model = new SearchMeetViewModel
            {
                SwimmerId = userId
            };

            var meets = meetRP.Search(model);

            return(meets.ToList());
        }
Esempio n. 22
0
        public IEnumerable <Album> SearchAlbums(string?mbid, string title, string artist)
        {
            List <Album>?results = null;

            if (!string.IsNullOrEmpty(mbid))
            {
                results = _repository.Search <Album>(album => album.MusicBrainzId == mbid);
            }

            return(results?.Count > 0
                                ? results
                                : _repository.Search <Album>(album =>
                                                             album.Title.ToLower().Contains(title.ToLower()) &&
                                                             album.AlbumArtist.Name.ToLower().Contains(artist.ToLower())));
        }
Esempio n. 23
0
        public bool AddUser(int userId, int groupId)
        {
            try
            {
                using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required))
                {
                    Member member = _memberRepository.Get(_ => _.Id == userId);
                    Group  group  = _repository.Get(_ => _.Id == groupId, _ => _.Members);

                    var temp = _groupInvitationRepository.Search(_ => _.GroupId == groupId && _.UserId == userId);

                    foreach (var item in temp)
                    {
                        item.Status = RequestStatus.Approved;
                        _groupInvitationRepository.Update(item);
                    }

                    group.Members.Add(member);

                    _repository.Update(group);
                    _unitOfWork.SaveChanges();

                    scope.Complete();
                    return(true);
                }//end scope
            }
            catch (Exception ex)
            {
                _loggingService.Write(GetType().Name, nameof(UserRemoved), ex);
                return(false);
            }
        }
    public async Task <IActionResult> GetAll(string search = null)
    {
        if (search != null)
        {
            try
            {
                var searchResult = await _announcementRepository.Search(search);

                return(Ok(searchResult));
            }
            catch (Exception)
            {
                return(BadRequest("The text you've entered is invalid."));
            }
        }

        try
        {
            var allAnnouncements = await _announcementRepository.GetAll();

            return(Ok(allAnnouncements));
        }
        catch (Exception)
        {
            return(NotFound("There are no announcements."));
        }
    }
Esempio n. 25
0
        public Task <DataResult <IPagedListResult <DTOPaySlipBill> > > GetPayslipsWithPagingAsync(string searchTerm, string sortName, string sortDirection, int pageIndex, int pageSize,
                                                                                                  CancellationToken cancellationToken = default(CancellationToken))
        {
            return(Task.Run(() => {
                var searchQuery = new SearchQuery <PaySlipBill>();

                searchQuery.CurrentPage = pageIndex;
                searchQuery.Skip = pageSize * (pageIndex - 1);
                searchQuery.Take = pageSize;
                searchQuery.IncludeProperties = "Quotation";

                var sort = new FieldSortCriteria <PaySlipBill>(sortName, (SortDirection)Enum.Parse(typeof(SortDirection), sortDirection));
                searchQuery.AddSortCriteria(sort);

                if (!string.IsNullOrEmpty(searchTerm))
                {
                    searchQuery.AddFilter(x => x.Id == int.Parse(searchTerm) || x.QuotationId == searchTerm);
                }

                var pagedPayslips = paySlipBillRepository.Search(searchQuery);

                return new DataResult <IPagedListResult <DTOPaySlipBill> >
                {
                    Errors = new List <ErrorDescriber>(),
                    Target = GetDefaultPagingDtoResult <DTOPaySlipBill, PaySlipBill>(_mapper, pagedPayslips)
                };
            }, cancellationToken));
        }
        public Task <DataResult <IPagedListResult <DTOCustomerExchange> > > GetCustomersLookupWithPagingAsync(List <Expression <Func <CustomerExchange, bool> > > searchTerm,
                                                                                                              string sortName, string sortDirection, int pageIndex, int pageSize,
                                                                                                              CancellationToken cancellationToken = default(CancellationToken))
        {
            return(Task.Run(() =>
            {
                var searchQuery = new SearchQuery <CustomerExchange>();

                searchQuery.CurrentPage = pageIndex;
                searchQuery.Skip = pageSize * (pageIndex - 1);
                searchQuery.Take = pageSize;
                searchQuery.IncludeProperties = "Car,Customer";

                var sort = new FieldSortCriteria <CustomerExchange>(sortName, (SortDirection)Enum.Parse(typeof(SortDirection), sortDirection));
                searchQuery.AddSortCriteria(sort);

                foreach (var searchCondition in searchTerm)
                {
                    searchQuery.AddFilter(searchCondition);
                }

                var pagedCustomerWithCar = customerExchangeRepository.Search(searchQuery);
                var pagedCustomerWithCarDTOs = GetDefaultPagingDtoResult <DTOCustomerExchange, CustomerExchange>(_mapper, pagedCustomerWithCar);

                // Mapping customer, car and quotations to DTO
                pagedCustomerWithCarDTOs.DTOs = MappingCustomerAndCarDTO(pagedCustomerWithCar.DTOs.ToList(), pagedCustomerWithCarDTOs.DTOs.ToList());

                return new DataResult <IPagedListResult <DTOCustomerExchange> >
                {
                    Errors = new List <ErrorDescriber>(),
                    Target = pagedCustomerWithCarDTOs
                };
            }, cancellationToken));
        }
        public Task <DataResult <IPagedListResult <DTOCustomer> > > GetCustomersWithPagingAsync(string searchTerm, string sortName, string sortDirection, int pageIndex, int pageSize,
                                                                                                CancellationToken cancellationToken = default(CancellationToken))
        {
            return(Task.Run(() => {
                var searchQuery = new SearchQuery <Customer>();

                searchQuery.CurrentPage = pageIndex;
                searchQuery.Skip = pageSize * (pageIndex - 1);
                searchQuery.Take = pageSize;
                searchQuery.IncludeProperties = "Branch,CustomerType";

                var sort = new FieldSortCriteria <Customer>(sortName, (SortDirection)Enum.Parse(typeof(SortDirection), sortDirection));
                searchQuery.AddSortCriteria(sort);

                if (!string.IsNullOrEmpty(searchTerm))
                {
                    searchQuery.AddFilter(x => x.Name.Contains(searchTerm) ||
                                          x.Phone.Contains(searchTerm) ||
                                          x.Id.Contains(searchTerm));
                }

                var pagedCustomers = customerRepository.Search(searchQuery);

                return new DataResult <IPagedListResult <DTOCustomer> >
                {
                    Errors = new List <ErrorDescriber>(),
                    Target = GetDefaultPagingDtoResult <DTOCustomer, Customer>(_mapper, pagedCustomers)
                };
            }, cancellationToken));
        }
Esempio n. 28
0
        public async Task <IActionResult> Search(string s)
        {
            IActionResult res = null;

            var b = new BaseEntityDTO <IEnumerable <SegmentacaoModel> >()
            {
                Start = DateTime.Now
            };

            try
            {
                b.Result = await repository.Search(new SegmentacaoModel()
                {
                    Cliente = new ClienteModel()
                    {
                        ClienteID = ClienteID
                    }
                }, s, UsuarioID);

                b.Itens = b.Result.Count();
                b.End   = DateTime.Now;
                res     = Ok(b);
            }
            catch (Exception err)
            {
                b.End   = DateTime.Now;
                b.Error = (err.InnerException ?? err).Message;
                res     = BadRequest(b);
            }
            return(res);
        }
Esempio n. 29
0
        public void Bid(string name, string bidderId, string itemId, string amount)
        {
            long    bId;
            long    itmId;
            decimal amt;
            decimal?maxAmt = null;
            var     msg    = string.Empty;

            if (long.TryParse(bidderId, out bId) && long.TryParse(itemId, out itmId) && decimal.TryParse(amount, out amt))
            {
                var i   = Task.Run(async() => await _biddingManager.Search(x => x.ItemId == itmId));
                var itm = i.Result.OrderByDescending(x => x.Amount).FirstOrDefault();
                maxAmt = itm?.Amount.GetValueOrDefault();

                msg    = amt > maxAmt ? $"Current Max bid GH₵{amt:#,##0.00}" : $"Your bid of GH₵{amt:#,##0.00} below current max bid GH₵{maxAmt:#,##0.00}";
                maxAmt = amt > maxAmt ? amt : maxAmt;
                //var b = await _
                var b = Task.Run(async() => await _biddingManager.Save(new Bidding {
                    BidderId = bId, Amount = amt, ItemId = itmId, DateCreated = DateTime.Now, DateModified = DateTime.Now
                }));
                var r = b.Result;
            }
            else
            {
                msg = "Your Bidding session may have expired. Please logout and log back in to continue";
            }

            Clients.All.addNewMessageToPage(name, msg, string.Format(Extensions.CustomCultureInfo, "GH₵{0:#,##0.00}", maxAmt.GetValueOrDefault()));
        }
        private void LoadGrid()
        {
            dtgGridCustomer.DataSource = null;
            IEnumerable <CustomerBase> custs = Idal.Search(); // physically

            dtgGridCustomer.DataSource = custs;
        }
Esempio n. 31
0
        public DocumentModule(IRepository documents, IImageRepository images, IRatingRepository ratings, IReviewRepository reviews, IFavoritesRepository favorites, IEnvironmentPathProvider pathProvider)
            : base("/documents")
        {
            Get["/{id}/thumbnail"] = args =>
            {
                var doc = documents.GetDocument(args.id, true);
                string img = images.GetDocumentImage(args.id);

                if (String.IsNullOrEmpty(img))
                {
                    return ResolvePlaceHolderImageForDocumentType(pathProvider, doc);
                }

                return Response.AsFile(Path.Combine(pathProvider.GetImageCachePath(), img));
            };

            Get["/{id}"] = args =>
            {
                Document document = documents.GetDocument(args.id, false);
                return Response.AsJson(DtoMaps.Map(document, favorites, Context.GetUserInfo()));
            };
            
            Get["/{id}/rating"] = args =>
            {
                try
                {
                    DocumentRating rating = ratings.GetDocumentRating(args.id);

                    return Response.AsJson(new DocumentRatingDto
                    {
                        MaxScore = rating.MaxScore,
                        Score = rating.Score,
                        Source = rating.Source,
                        SourceUrl = rating.SourceUrl,
                        HasRating = true
                    }).AsCacheable(DateTime.Now.AddDays(1));
                }
                catch
                {
                    return new DocumentRatingDto {Success = true, HasRating = false};
                }
            };

            Get["/{id}/review"] = args =>
            {
                string review = reviews.GetDocumentReview(args.id);
                return Response.AsJson(new DocumentReviewDto{ Review = review, Url = "" }).AsCacheable(DateTime.Now.AddDays(1));
            };

            Get["/search"] = _ =>
            {
                string query = Request.Query.query.HasValue ? Request.Query.query : null;

                if (null == query) throw new InvalidOperationException("Ingenting å søke etter.");

                return Response.AsJson(documents.Search(query).Select(doc => DtoMaps.Map(doc, favorites, Context.GetUserInfo())).ToArray()).AsCacheable(DateTime.Now.AddHours(12));
            };
        }
Esempio n. 32
0
        public IndexModule (IRepository repository, Cache cache)
        {
            repo = repository;

            Get ["/"] = parameters => 
            {
                return View ["index"];
            };

            Get ["/search/", true] = async (parameters, ct) => 
            {
                string query = (string)Request.Query.q;
                int limit = 0; 
                int start = 0; 
                string total = "";

                if(Request.Query.limit != null)
                {
                    limit = (int)Request.Query.limit;
                }

                if(Request.Query.start != null)
                {
                    start = (int)Request.Query.start;
                }

                if(Request.Query.total != null)
                {
                    total = (string)Request.Query.total;
                    if(total.ToLower() == "true")
                    {
                        long count = await repo.SearchTotal(query,true);
                        return Response.AsJson (count);
                    }
                }
                    
                Card [] cards = await repo.Search (query,start,limit,true);

                return Response.AsJson (cards);
            };


            Get ["/search/{text}", true] = async (parameters, ct) => 
            {
                int limit = 0; 
                int start = 0; 
               

                if(Request.Query.limit != null)
                {
                    limit = (int)Request.Query.limit;
                }

                if(Request.Query.start != null)
                {
                    start = (int)Request.Query.start;
                }
                    
                Card [] cards = await repo.Search ((string)parameters.text,
                    start, limit, false);

                return Response.AsJson (cards);
            };

            Get ["/cards/types", true] = async (parameters, ct) => 
            {
                string [] types  = await repo.GetCardTypes();
                return Response.AsJson (types.OrderBy(x => x));
            };

            Get ["/cards/subtypes", true] = async (parameters, ct) => 
            {
                string [] types  = await repo.GetCardSubTypes();
                return Response.AsJson (types.OrderBy(x => x));
            };
                
            Get ["/cards/rarity", true] = async (parameters, ct) => 
            {
                string [] rarity  = await repo.GetCardRarity();
                return Response.AsJson (rarity.OrderBy(x => x));
            };

            Get ["/cards/random", true] = async (parameters, ct) => 
            {
                JsonSettings.MaxJsonLength =    100000000;
                Card card =                    null;
            
                card = await repo.GetRandomCard();

                return Response.AsJson (card);
            };

            Get ["/cards", true] = async (parameters, ct) => 
            {
                JsonSettings.MaxJsonLength =    100000000;
                Card[] cards =                  null;
               
                if(Request.Query.Fields != null)
                {
                    string[] fields = ((string)Request.Query.Fields).Split(',');

                    foreach(string field in fields)
                    {
                        if(typeof(Card).GetProperty(field,BindingFlags.IgnoreCase |  
                            BindingFlags.Public | BindingFlags.Instance) == null)
                        {
                            return Response.AsJson(string.Format("Field: {0} is invalid.", field),
                                HttpStatusCode.NotAcceptable);
                        }
                    }

                    cards = await repo.GetCards (Request.Query);

                    var c = cards
                            .AsQueryable()
                            .Select(string.Format("new ({0})",
                            (string)Request.Query.Fields));

                    return Response.AsJson(c);
                }
               
                cards = await repo.GetCards (Request.Query);
                return Response.AsJson (cards);
            };

            Get ["/cards/{id}", true] = async (parameters, ct) => 
            {
                try
                {
                    int[] multiverseIds = 
                        Array.ConvertAll(((string)parameters.id).Split(','), int.Parse);

                    if(multiverseIds.Length > 1)
                    {
                        Card [] cards = await repo.GetCards(multiverseIds);

                        return Response.AsJson(cards);
                    }
                }
                catch(Exception e)
                {
                    //swallo it, cannot convert parameter to int array 
                }


                int id = 0; 
                if(int.TryParse((string)parameters.id, out id))
                {
                    Card card = await repo.GetCard ((int)parameters.id);
                    return Response.AsJson (card);
                }
                else
                {
                    Card [] cards = await repo.GetCards ((string)parameters.id);
                    return Response.AsJson (cards);
                }
            };

            Get ["/sets/{id}", true] = async (parameters, ct) =>  
            {
                string [] ids = ((string)parameters.id).Split(',');

                if(ids.Length > 1)
                {
                    CardSet[] cardSets = await repo.GetSets (ids);
                    return Response.AsJson (cardSets);
                }

                CardSet cardSet = await repo.GetSet ((string)parameters.id);
                return Response.AsJson (cardSet);
            };

            Get ["/sets/", true] = async (parameters, ct) => 
            {
                CardSet[] cardset =             await repo.GetSets ();
                JsonSettings.MaxJsonLength =    1000000;

                return Response.AsJson (cardset);
            };

            Get ["/sets/{id}/cards/random", true] = async (parameters, ct) => 
            {
                JsonSettings.MaxJsonLength =    100000000;
                Card card =                     null;

                card = await repo.GetRandomCardInSet((string)parameters.id);

                return Response.AsJson (card);
            };


            Get ["/sets/{id}/cards/{setNumber}", true] = async (parameters, ct) => 
            {
                Card cards = await repo.GetCardBySetNumber((string)parameters.id,
                    (int)parameters.setNumber);

                return Response.AsJson(cards);
            };

            Get ["/sets/{id}/cards/", true] = async (parameters, ct) => 
            {
                JsonSettings.MaxJsonLength =    100000000;
                int start =                     0; 
                int end =                       0; 

                if(Request.Query.start != null )
                {
                    int.TryParse((string)Request.Query.start, out start);
                }

                if(Request.Query.end != null )
                {
                    int.TryParse((string)Request.Query.end, out end);
                }

                Card[] cards = null;
                if(start > 0 || end > 0)
                {
                    cards = await repo.GetCardsBySet ((string)parameters.id, start, end);
                }
                else
                {
                    cards = await repo.GetCardsBySet ((string)parameters.id);
                }

                if(Request.Query.Fields != null)
                {
                    var c = cards.AsQueryable()
                        .Select(string.Format("new ({0})",(string)Request.Query.Fields));

                    return Response.AsJson(c);
                }

                return Response.AsJson (cards);
            };
        }
Esempio n. 33
0
        public IndexModule (IRepository repository)
        {
            repo = repository;

            Get ["/"] = parameters => 
            {
                return View ["index"];
            };

            Get ["/search/{text}", true] = async (parameters, ct) => 
            {
                Card [] cards = await repo.Search ((string)parameters.text);

                return Response.AsJson (cards);
            };

            Get ["/cards", true] = async (parameters, ct) => 
            {
                JsonSettings.MaxJsonLength =    100000000;
                Card[] cards =                  null;
                cards =                         await repo.GetCards (Request.Query);
                  
                if(Request.Query.Fields != null)
                {
                    var c = cards.AsQueryable()
                        .Select(string.Format("new ({0})",
                            (string)Request.Query.Fields));

                    return Response.AsJson(c);
                }
                    
                return Response.AsJson (cards);
            };

            Get ["/cards/{id}", true] = async (parameters, ct) => 
            {
                try
                {
                    int[] multiverseIds = 
                        Array.ConvertAll(((string)parameters.id).Split(','), int.Parse);

                    if(multiverseIds.Length > 1)
                    {
                        Card [] cards = await repo.GetCards(multiverseIds);

                        return Response.AsJson(cards);
                    }
                }
                catch(Exception e)
                {
                    //swallo it, cannot convert parameter to int array 
                }


                int id = 0; 
                if(int.TryParse((string)parameters.id, out id))
                {
                    Card card = await repo.GetCard ((int)parameters.id);
                    return Response.AsJson (card);
                }
                else
                {
                    Card [] cards = await repo.GetCards ((string)parameters.id);
                    return Response.AsJson (cards);
                }
            };

            Get ["/sets/{id}", true] = async (parameters, ct) =>  
            {
                string [] ids = ((string)parameters.id).Split(',');

                if(ids.Length > 1)
                {
                    CardSet[] cardSets = await repo.GetSets (ids);
                    return Response.AsJson (cardSets);
                }

                CardSet cardSet = await repo.GetSet ((string)parameters.id);
                return Response.AsJson (cardSet);
            };

            Get ["/sets/", true] = async (parameters, ct) => 
            {
                CardSet[] cardset =             await repo.GetSets ();
                JsonSettings.MaxJsonLength =    1000000;

                return Response.AsJson (cardset);
            };

            Get ["/sets/{id}/cards/", true] = async (parameters, ct) => 
            {
                JsonSettings.MaxJsonLength =    100000000;
                int start =                     0; 
                int end =                       0; 

                if(Request.Query.start != null )
                {
                    int.TryParse((string)Request.Query.start, out start);
                }

                if(Request.Query.end != null )
                {
                    int.TryParse((string)Request.Query.end, out end);
                }

                Card[] cards = null;
                if(start > 0 || end > 0)
                {
                    cards = await repo.GetCardsBySet ((string)parameters.id, start, end);
                }
                else
                {
                    cards = await repo.GetCardsBySet ((string)parameters.id);
                }

                if(Request.Query.Fields != null)
                {
                    var c = cards.AsQueryable()
                        .Select(string.Format("new ({0})",(string)Request.Query.Fields));

                    return Response.AsJson(c);
                }

                return Response.AsJson (cards);
            };
        }