Ejemplo n.º 1
0
        public void Get_new_card()
        {
            NewCard card = new NewCard()
            {
                UserId      = Guid.NewGuid(),
                Name        = "Test card 1",
                Description = "Test card",
                Flavor      = "",
                Type        = "Creature",
                SubType     = "Test"
            };

            Guid id = repository.AddCard(card);

            card = repository.GetCard(id);
            Assert.AreEqual(card.Id, id);
        }
Ejemplo n.º 2
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));
            };
        }
Ejemplo n.º 3
0
        public OpenDbModule()
        {
            this.RequiresAuthentication();

            Get["/cr/{status?}"] = parameters => {
                ChangeRequestModel model  = new ChangeRequestModel();
                string             status = (string)parameters.status;
                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;
                model.Title        = "M:tgDb.Info Admin";

                if (status == null)
                {
                    model.Changes    = repository.GetChangeRequests().ToList();
                    model.NewCards   = repository.GetNewCards().ToList();
                    model.NewSets    = repository.GetNewSets().ToList();
                    model.SetChanges = repository.GetSetChangeRequests().ToList();
                }
                else
                {
                    model.Changes    = repository.GetChangeRequests(status).ToList();
                    model.NewCards   = repository.GetNewCards(status).ToList();
                    model.NewSets    = repository.GetNewSets(status).ToList();
                    model.SetChanges = repository.GetSetChangeRequests(status).ToList();
                }

                return(View["Change/ChangeRequests", model]);
            };

            Get["/sets/new", true] = async(parameters, ct) => {
                NewSet model = new NewSet();
                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;

                return(View["Change/NewSet", model]);
            };

            Post["/sets/new", true] = async(parameters, ct) => {
                NewSet model = this.Bind <NewSet>();
                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;
                model.UserId       = model.Planeswalker.Id;

                var result = this.Validate(model);

                if (!result.IsValid)
                {
                    model.Errors = ErrorUtility.GetValidationErrors(result);
                    return(View["Change/NewSet", model]);
                }

                repository.AddSet(model);

                return(Response.AsRedirect(string.Format("/sets/new/{0}",
                                                         model.Id)));
            };

            Get["/sets/new/{id}", true] = async(parameters, ct) => {
                NewSet model = repository.GetSet((Guid)parameters.id);

                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;

                return(View["Change/NewSetRead", model]);
            };

            Post["/sets/new/{id}", true] = async(parameters, ct) => {
                NewSet model = repository.GetSet((Guid)parameters.id);
                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;
                Admin admin = new Admin(ConfigurationManager.AppSettings.Get("api"));

                if (!model.Planeswalker.InRole("admin"))
                {
                    return(HttpStatusCode.Unauthorized);
                }

                MtgDbAdminDriver.CardSet newSet =
                    new MtgDbAdminDriver.CardSet()
                {
                    Id          = model.SetId,
                    Name        = model.Name,
                    Description = model.Description,
                    ReleasedAt  = model.ReleasedAt,
                    Type        = model.Type,
                    Block       = model.Block,
                    Common      = model.Common,
                    Uncommon    = model.Uncommon,
                    Rare        = model.Rare,
                    MythicRare  = model.MythicRare,
                    BasicLand   = model.BasicLand
                };

                admin.AddSet(model.Planeswalker.AuthToken, newSet);
                model = repository.UpdateNewSetStatus(model.Id, "Accepted");

                model.Messages.Add("Set has been sucessfully added.");

                return(View["Change/NewSetRead", model]);
            };

            Get["/cards/new/{id}", true] = async(parameters, ct) => {
                NewCard model = repository.GetCard((Guid)parameters.id);
                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;

                return(View["Change/NewCardsRead", model]);
            };

            Post["/cards/new/{id}", true] = async(parameters, ct) => {
                NewCard model = repository.GetCard((Guid)parameters.id);
                Admin   admin = new Admin(ConfigurationManager.AppSettings.Get("api"));
                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;

                if (!model.Planeswalker.InRole("admin"))
                {
                    return(HttpStatusCode.Unauthorized);
                }


                string [] colors = null;

                if (model.Colors == null ||
                    model.Colors.Length == 0)
                {
                    colors    = new string[1];
                    colors[0] = "None";
                }
                else
                {
                    colors = model.Colors.Split(',');
                }

                MtgDbAdminDriver.Card newCard =
                    new MtgDbAdminDriver.Card()
                {
                    Id                = model.Mvid,
                    Name              = model.Name,
                    Description       = model.Description,
                    Flavor            = model.Flavor,
                    Power             = model.Power,
                    Toughness         = model.Toughness,
                    Loyalty           = model.Loyalty,
                    Artist            = model.Artist,
                    Type              = model.Type,
                    SubType           = model.SubType,
                    Token             = model.Token,
                    Colors            = colors,
                    CardSetId         = model.CardSetId,
                    ManaCost          = model.ManaCost,
                    ConvertedManaCost = model.ConvertedManaCost,
                    RelatedCardId     = model.RelatedCardId,
                    Rarity            = model.Rarity,
                    SetNumber         = model.SetNumber
                };

                try
                {
                    admin.AddCard(model.Planeswalker.AuthToken, newCard);
                    repository.UpdateNewCardStatus(model.Id, "Accepted");
                    model = repository.GetCard((Guid)parameters.id);
                    model.Messages.Add("Card has been sucessfully added.");
                }
                catch (Exception e)
                {
                    model.Errors.Add(e.Message);
                }

                return(View["Change/NewCardsRead", model]);
            };

            Get["/cards/new", true] = async(parameters, ct) => {
                NewCard model = new NewCard();

                if (Request.Query.SetId != null)
                {
                    model.CardSetId = (string)Request.Query.SetId;
                }

                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;
                model.Types        = magicdb.GetCardTypes();
                model.SubTypes     = magicdb.GetCardSubTypes();
                model.Rarities     = magicdb.GetCardRarityTypes();

                return(View["Change/NewCard", model]);
            };

            Post["/cards/new", true] = async(parameters, ct) => {
                NewCard model = this.Bind <NewCard>();
                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;
                model.UserId       = model.Planeswalker.Id;

                model.Types    = magicdb.GetCardTypes();
                model.SubTypes = magicdb.GetCardSubTypes();
                model.Rarities = magicdb.GetCardRarityTypes();

                var result = this.Validate(model);

                if (!result.IsValid)
                {
                    model.Errors = ErrorUtility.GetValidationErrors(result);
                    return(View["Change/NewCard", model]);
                }

                Guid id = repository.AddCard(model);
                model = repository.GetCard(id);

                return(Response.AsRedirect(string.Format("/cards/new/{0}",
                                                         model.Id)));
            };


            Get["/cards/{id}/logs"] = parameters => {
                CardLogsModel model = new CardLogsModel();
                model.ActiveMenu   = "sets";
                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;
                model.Mvid         = (int)parameters.id;

                if (Request.Query.v != null)
                {
                    int version = 0;
                    if (int.TryParse((string)Request.Query.v, out version))
                    {
                        model.NewVersion = version;
                    }
                }

                try
                {
                    model.Changes = repository.GetCardChangeRequests((int)parameters.id)
                                    .OrderByDescending(x => x.Version)
                                    .ToList();
                }
                catch (Exception e)
                {
                    model.Errors.Add(e.Message);
                }

                return(View["Change/CardLogs", model]);
            };

            Get["/cards/{id}/logs/{logid}"] = parameters => {
                CardChange model = new CardChange();
                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;

                try
                {
                    model = repository.GetCardChangeRequest((Guid)parameters.logid);
                }
                catch (Exception e)
                {
                    model.Errors.Add(e.Message);
                }

                model.ActiveMenu   = "sets";
                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;
                model.Mvid         = (int)parameters.id;


                return(View["Change/CardChange", model]);
            };

            Post["/change/{id}/field/{field}"] = parameters => {
                Admin        admin        = new Admin(ConfigurationManager.AppSettings.Get("api"));
                Planeswalker planeswalker = (Planeswalker)this.Context.CurrentUser;
                Guid         changeId     = Guid.Parse((string)parameters.id);
                string       field        = (string)parameters.field;
                CardChange   change       = null;

                if (!planeswalker.InRole("admin"))
                {
                    return(HttpStatusCode.Unauthorized);
                }

                try
                {
                    change = repository.GetCardChangeRequest(changeId);

                    if (field == "close")
                    {
                        repository.UpdateCardChangeStatus(change.Id, "Closed");

                        return(Response.AsRedirect(string.Format("/cards/{0}/logs/{1}",
                                                                 change.Mvid, change.Id)));
                    }

                    if (field == "open")
                    {
                        repository.UpdateCardChangeStatus(change.Id, "Pending");

                        return(Response.AsRedirect(string.Format("/cards/{0}/logs/{1}",
                                                                 change.Mvid, change.Id)));
                    }


                    if (field == "formats")
                    {
                        admin.UpdateCardFormats(planeswalker.AuthToken,
                                                change.Mvid, change.Formats);
                    }
                    else if (field == "rulings")
                    {
                        admin.UpdateCardRulings(planeswalker.AuthToken,
                                                change.Mvid, change.Rulings);
                    }
                    else
                    {
                        string value = change.GetFieldValue(field);
                        admin.UpdateCardField(planeswalker.AuthToken,
                                              change.Mvid, field, (string)value);
                    }

                    repository.UpdateCardChangeStatus(change.Id, "Accepted", field);
                }
                catch (Exception e)
                {
                    throw e;
                }

                return(Response.AsRedirect(string.Format("/cards/{0}/logs/{1}",
                                                         change.Mvid, change.Id)));
            };

            Post["/setchange/{id}/field/{field}"] = parameters => {
                Admin        admin        = new Admin(ConfigurationManager.AppSettings.Get("api"));
                Planeswalker planeswalker = (Planeswalker)this.Context.CurrentUser;
                Guid         changeId     = Guid.Parse((string)parameters.id);
                string       field        = (string)parameters.field;
                SetChange    change       = null;

                if (!planeswalker.InRole("admin"))
                {
                    return(HttpStatusCode.Unauthorized);
                }

                try
                {
                    change = repository.GetCardSetChangeRequest(changeId);

                    if (field == "close")
                    {
                        repository.UpdateCardSetChangeStatus(change.Id, "Closed");

                        return(Response.AsRedirect(string.Format("/sets/{0}/logs/{1}",
                                                                 change.SetId, change.Id)));
                    }

                    if (field == "open")
                    {
                        repository.UpdateCardSetChangeStatus(change.Id, "Pending");

                        return(Response.AsRedirect(string.Format("/sets/{0}/logs/{1}",
                                                                 change.SetId, change.Id)));
                    }

                    string value = change.GetFieldValue(field);
                    admin.UpdateCardSetField(planeswalker.AuthToken,
                                             change.SetId, field, (string)value);

                    repository.UpdateCardSetChangeStatus(change.Id, "Accepted", field);
                }
                catch (Exception e)
                {
                    throw e;
                }

                return(Response.AsRedirect(string.Format("/sets/{0}/logs/{1}",
                                                         change.SetId, change.Id)));
            };

            Get ["/cards/{id}/change"] = parameters => {
                CardChange model = new CardChange();
                Card       card;

                try
                {
                    card  = magicdb.GetCard((int)parameters.id);
                    model = CardChange.MapCard(card);
                    model.Planeswalker = (Planeswalker)this.Context.CurrentUser;
                }
                catch (Exception e)
                {
                    throw e;
                }

                return(View["Change/Card", model]);
            };

            Post ["/cards/{id}/change"] = parameters => {
                CardChange model   = this.Bind <CardChange>();
                Card       current = magicdb.GetCard((int)parameters.id);
                model.CardSetId    = current.CardSetId;
                model.CardSetName  = current.CardSetName;
                model.Name         = current.Name;
                model.Mvid         = (int)parameters.id;
                model.Rulings      = Bind.Rulings(Request);
                model.Formats      = Bind.Formats(Request);
                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;
                model.UserId       = model.Planeswalker.Id;
                CardChange card = null;

                var result = this.Validate(model);

                if (!result.IsValid)
                {
                    model.Errors = ErrorUtility.GetValidationErrors(result);
                    return(View["Change/Card", model]);
                }

                try
                {
                    card = repository.GetCardChangeRequest(
                        repository.AddCardChangeRequest(model)
                        );
                }
                catch (Exception e)
                {
                    model.Errors.Add(e.Message);
                    return(View["Change/Card", model]);
                }

                return(Response.AsRedirect(string.Format("/cards/{0}/logs?v={1}",
                                                         card.Mvid, card.Version)));

                //return model.Description;
                //return View["Change/Card", model];
            };

            Get ["/sets/{id}/change"] = parameters => {
                SetChange model = new SetChange();
                CardSet   set;

                try
                {
                    set   = magicdb.GetSet((string)parameters.id);
                    model = SetChange.MapSet(set);
                    model.Planeswalker = (Planeswalker)this.Context.CurrentUser;
                }
                catch (Exception e)
                {
                    throw e;
                }

                return(View["Change/CardSet", model]);
            };

            Post ["/sets/{id}/change"] = parameters => {
                SetChange model   = this.Bind <SetChange>();
                CardSet   current = magicdb.GetSet((string)parameters.id);
                model.SetId = current.Id;

                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;
                model.UserId       = model.Planeswalker.Id;
                SetChange set = null;

                var result = this.Validate(model);

                if (!result.IsValid)
                {
                    model.Errors = ErrorUtility.GetValidationErrors(result);
                    return(View["Change/CardSet", model]);
                }

                try
                {
                    set = repository.GetCardSetChangeRequest(
                        repository.AddCardSetChangeRequest(model)
                        );
                }
                catch (Exception e)
                {
                    model.Errors.Add(e.Message);
                    return(View["Change/CardSet", model]);
                }

                return(Response.AsRedirect(string.Format("/sets/{0}/logs?v={1}",
                                                         set.SetId, set.Version)));

                //return model.Description;
                //return View["Change/Card", model];
            };

            Get["/sets/{id}/logs"] = parameters => {
                SetLogsModel model = new SetLogsModel();
                model.ActiveMenu   = "sets";
                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;
                model.SetId        = (string)parameters.id;

                if (Request.Query.v != null)
                {
                    int version = 0;
                    if (int.TryParse((string)Request.Query.v, out version))
                    {
                        model.NewVersion = version;
                    }
                }

                try
                {
                    model.Changes = repository.GetCardSetChangeRequests((string)parameters.id)
                                    .OrderByDescending(x => x.Version)
                                    .ToList();
                }
                catch (Exception e)
                {
                    model.Errors.Add(e.Message);
                }

                return(View["Change/SetLogs", model]);
            };

            Get["/sets/{id}/logs/{logid}"] = parameters => {
                SetChange model = new SetChange();
                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;

                try
                {
                    model = repository.GetCardSetChangeRequest((Guid)parameters.logid);
                }
                catch (Exception e)
                {
                    model.Errors.Add(e.Message);
                }

                model.ActiveMenu   = "sets";
                model.Planeswalker = (Planeswalker)this.Context.CurrentUser;
                model.SetId        = (string)parameters.id;


                return(View["Change/SetChange", model]);
            };
        }
Ejemplo n.º 4
0
        public void Test_get_card()
        {
            Card card = repository.GetCard(1).Result;

            Assert.IsNotNull(card);
        }
Ejemplo n.º 5
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);
            };
        }
Ejemplo n.º 6
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);
            };
        }
Ejemplo n.º 7
0
 public Task <Card> GetCard(Guid playerId, Guid cardId)
 {
     return(repository.GetCard(playerId, cardId));
 }